Snap for 7478028 from 313f77a7c9ef6b6f5e4c83e6ebbadb13699f6cb1 to mainline-adbd-release
Change-Id: Ia38bbd38424f7ca7e6810117cb5e3201f9af507e
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..328d4b1
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,214 @@
+name: CI
+
+on:
+ push:
+ branches:
+ - master
+ pull_request:
+
+jobs:
+ bazel-test:
+ name: 'Bazel tests'
+ runs-on: ubuntu-latest
+ steps:
+ - name: 'Check out repository'
+ uses: actions/checkout@v2
+ - name: 'Cache local Maven repository'
+ uses: actions/cache@v2
+ with:
+ path: |
+ ~/.m2/repository
+ !~/.m2/repository/com/google/dagger
+ key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
+ restore-keys: |
+ ${{ runner.os }}-maven-
+ - name: 'Cache Bazel files'
+ uses: actions/cache@v2
+ with:
+ path: ~/.cache/bazel
+ key: ${{ runner.os }}-bazel-${{ github.sha }}
+ restore-keys: |
+ ${{ runner.os }}-bazel-
+ - name: 'Cache Gradle files'
+ uses: actions/cache@v2
+ with:
+ path: |
+ ~/.gradle/caches
+ ~/.gradle/wrapper
+ key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+ restore-keys: |
+ ${{ runner.os }}-gradle-
+ - name: 'Run Bazel tests'
+ run: bazel test --test_output=errors //...
+ shell: bash
+ - name: 'Install local snapshot'
+ run: ./util/install-local-snapshot.sh
+ shell: bash
+ - name: 'Upload local snapshot for tests'
+ uses: actions/upload-artifact@v2
+ with:
+ name: local-snapshot
+ path: ~/.m2/repository/com/google/dagger
+ artifact-java-local-tests:
+ name: 'Artifact Java local tests'
+ needs: bazel-test
+ runs-on: ubuntu-latest
+ steps:
+ - name: 'Check out repository'
+ uses: actions/checkout@v2
+ - name: 'Cache Gradle files'
+ uses: actions/cache@v2
+ with:
+ path: |
+ ~/.gradle/caches
+ ~/.gradle/wrapper
+ key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+ restore-keys: |
+ ${{ runner.os }}-gradle-
+ - name: 'Download local snapshot for tests'
+ uses: actions/download-artifact@v2
+ with:
+ name: local-snapshot
+ path: ~/.m2/repository/com/google/dagger
+ - name: 'Gradle Java local tests'
+ run: ./util/run-local-gradle-tests.sh
+ shell: bash
+ artifact-android-local-tests:
+ name: 'Artifact Android local tests (AGP ${{ matrix.agp }})'
+ needs: bazel-test
+ runs-on: ubuntu-latest
+ strategy:
+ matrix:
+ agp: ['4.1.0', '4.2.0-beta04']
+ steps:
+ - name: 'Check out repository'
+ uses: actions/checkout@v2
+ - name: 'Cache Gradle files'
+ uses: actions/cache@v2
+ with:
+ path: |
+ ~/.gradle/caches
+ ~/.gradle/wrapper
+ key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+ restore-keys: |
+ ${{ runner.os }}-gradle-
+ - name: 'Download local snapshot for tests'
+ uses: actions/download-artifact@v2
+ with:
+ name: local-snapshot
+ path: ~/.m2/repository/com/google/dagger
+ - name: 'Gradle Android local tests (AGP ${{ matrix.agp }})'
+ run: ./util/run-local-gradle-android-tests.sh "${{ matrix.agp }}"
+ shell: bash
+ artifact-android-emulator-tests:
+ name: 'Artifact Android emulator tests (API 30)'
+ needs: bazel-test
+ # It's recommended to run emulator tests on macOS
+ # See https://github.com/marketplace/actions/android-emulator-runner
+ runs-on: macos-latest
+ steps:
+ - name: 'Check out repository'
+ uses: actions/checkout@v2
+ - name: 'Cache Gradle files'
+ uses: actions/cache@v2
+ with:
+ path: |
+ ~/.gradle/caches
+ ~/.gradle/wrapper
+ key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+ restore-keys: |
+ ${{ runner.os }}-gradle-
+ - name: 'Download local snapshot for tests'
+ uses: actions/download-artifact@v2
+ with:
+ name: local-snapshot
+ path: ~/.m2/repository/com/google/dagger
+ - name: 'Gradle Android emulator tests (API 30)'
+ uses: reactivecircus/android-emulator-runner@v2
+ timeout-minutes: 25
+ with:
+ api-level: 30
+ target: google_apis
+ script: ./util/run-local-emulator-tests.sh
+ publish-snapshot:
+ name: 'Publish snapshot'
+ # TODO(bcorso): Consider also waiting on artifact-android-emulator-tests
+ # and artifact-android-emulator-legacy-api-tests after checking flakiness.
+ needs: [bazel-test, artifact-java-local-tests, artifact-android-local-tests]
+ if: github.event_name == 'push' && github.repository == 'google/dagger' && github.ref == 'refs/heads/master'
+ runs-on: ubuntu-latest
+ steps:
+ - name: 'Check out repository'
+ uses: actions/checkout@v2
+ - name: 'Cache local Maven repository'
+ uses: actions/cache@v2
+ with:
+ path: |
+ ~/.m2/repository
+ !~/.m2/repository/com/google/dagger
+ key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
+ restore-keys: |
+ ${{ runner.os }}-maven-
+ - name: 'Cache Bazel files'
+ uses: actions/cache@v2
+ with:
+ path: ~/.cache/bazel
+ key: ${{ runner.os }}-bazel-${{ github.sha }}
+ restore-keys: |
+ ${{ runner.os }}-bazel-
+ - name: 'Cache Gradle files'
+ uses: actions/cache@v2
+ with:
+ path: |
+ ~/.gradle/caches
+ ~/.gradle/wrapper
+ key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+ restore-keys: |
+ ${{ runner.os }}-gradle-
+ - name: 'Publish latest docs'
+ run: ./util/generate-latest-docs.sh
+ shell: bash
+ env:
+ GH_TOKEN: ${{ github.token }}
+ - name: 'Publish latest snapshot'
+ run: ./util/publish-snapshot-on-commit.sh
+ shell: bash
+ env:
+ CI_DEPLOY_USERNAME: ${{ secrets.CI_DEPLOY_USERNAME }}
+ CI_DEPLOY_PASSWORD: ${{ secrets.CI_DEPLOY_PASSWORD }}
+ artifact-android-emulator-legacy-api-tests:
+ name: 'Artifact Android emulator tests (API ${{ matrix.api-level }})'
+ # We only run this on master push (essentially a postsubmit) since these
+ # can take a while to run
+ if: github.event_name == 'push' && github.repository == 'google/dagger' && github.ref == 'refs/heads/master'
+ needs: bazel-test
+ # It's recommended to run emulator tests on macOS
+ # See https://github.com/marketplace/actions/android-emulator-runner
+ runs-on: macos-latest
+ strategy:
+ matrix:
+ api-level: [16, 17, 18, 19, 21, 22, 23, 24, 25, 26, 27, 29]
+ steps:
+ - name: 'Check out repository'
+ uses: actions/checkout@v2
+ - name: 'Cache Gradle files'
+ uses: actions/cache@v2
+ with:
+ path: |
+ ~/.gradle/caches
+ ~/.gradle/wrapper
+ key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+ restore-keys: |
+ ${{ runner.os }}-gradle-
+ - name: 'Download local snapshot for tests'
+ uses: actions/download-artifact@v2
+ with:
+ name: local-snapshot
+ path: ~/.m2/repository/com/google/dagger
+ - name: 'Gradle Android emulator tests (API ${{ matrix.api-level }})'
+ uses: reactivecircus/android-emulator-runner@v2
+ timeout-minutes: 25
+ with:
+ api-level: ${{ matrix.api-level }}
+ target: google_apis
+ script: ./util/run-local-emulator-tests.sh
diff --git a/.gitignore b/.gitignore
index fabb38f..1f7ead8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -30,6 +30,8 @@
gen-external-apklibs
-/bazel-*
+bazel-*
*.pyc
+
+.gradle
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index 9015f2e..0000000
--- a/.travis.yml
+++ /dev/null
@@ -1,65 +0,0 @@
-language: android
-
-os: linux
-dist: trusty
-sudo: required
-addons:
- apt:
- sources:
- - ubuntu-toolchain-r-test
- packages:
- - libstdc++-4.9-dev # https://github.com/nodegit/nodegit/issues/853
- - gcc-4.8
- - g++-4.8
-
-jdk:
- - &jdk_for_publishing oraclejdk8
-
-android:
- components:
- - tools
- - tools # Duplicated as per https://github.com/travis-ci/travis-ci/issues/6040#issuecomment-219367943
- - build-tools-26.0.2
- - android-26
- - platform-tools
- - extra-android-m2repository
-
-before_install:
- - wget https://github.com/bazelbuild/bazel/releases/download/"${BAZEL_VERSION}"/bazel_"${BAZEL_VERSION}"-linux-x86_64.deb
- - sudo dpkg -i bazel_"${BAZEL_VERSION}"-linux-x86_64.deb
- - sudo rm -f /etc/mavenrc
- - wget http://www.us.apache.org/dist/maven/maven-3/3.1.1/binaries/apache-maven-3.1.1-bin.tar.gz
- - tar -zxf apache-maven-3.1.1-bin.tar.gz
- - export PATH="$PWD/apache-maven-3.1.1/bin:$PATH"
- - mkdir travis_bin
- - ln -s $(which gcc-4.8) travis_bin/gcc
- - ln -s $(which g++-4.8) travis_bin/g++
- - export PATH="${PWD}/travis_bin:${PATH}"
-
-script:
- - bazel test --test_output errors //...
- - pushd examples && mvn compile && popd
-
-env:
- global:
- # Encrypted credentials for deploying snapshots.
- - secure: eGc3LHBRIPmTnXLM1YoIqG1do9BkpFI2pJm3fz5Cd8UaXtf7Oefa+Ts3rcn4ipee5A+lf8kEouPshSoaQs81KZ2/qf8rSTCIqeFjHR8hzmOVYo/0zRfS/VSUT0yqN+jeRhuNk3+A49RTPlcfJqPv3tyddtrM1vF7axhCJPQIRJM=
- - secure: LTzrlqcSNeZTOV52D3ibY9RBdxY4Yu8dUOYhAonrWLE+eDTzuoyCzcPw8pEcYVNUi1rG6Q7v3QBDTnBztsPoCbcN5tEGjw5cQEbfEzSTkWaNCFjncWn36cLwx9lgbF+5Db/L0mYJ36unDKUpKVC8AgOtxQibfv/ffugfxxj8ohY=
-
- # Encrypted GitHub access token to allow util/generate-latest-docs.sh to
- # push Javadoc to gh-pages.
- # This uses an access token created by cgdecker and will need to be updated
- # (see util/generate-latest-docs.sh for a link) if he no longer has
- # permission to push to the repo.
- - secure: "UpTUhCQzAGbr5JetRg2GZxp/dPDep/7Il3yGeyDECopciWdx41OPk/QNqAXBhNtKuEaMVsmASyoteuhgaTryQdV4qUIGVOMhES6kbOlYy3nwK44VdsNeeepwVospyDyZbxMtXq5LuHWuTADmAl1mdjNPNoziXc523zjnUzUx/EQ="
- - JDK_FOR_PUBLISHING: *jdk_for_publishing
- - BAZEL_VERSION="0.24.1"
-
-after_success:
- - util/generate-latest-docs.sh
- - util/publish-snapshot-on-commit.sh
-
-branches:
- only:
- - master
- - /^release.*$/
diff --git a/Android.bp b/Android.bp
index 27a05c5..1bdbd1b 100644
--- a/Android.bp
+++ b/Android.bp
@@ -12,87 +12,46 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-java_import_host {
- name: "dagger2-auto-common",
- jars: ["lib/auto-common-0.10.jar"],
+package {
+ default_visibility: [":__subpackages__"],
+ default_applicable_licenses: ["external_dagger2_license"],
}
-java_import_host {
- name: "dagger2-auto-factory-jar",
- jars: ["lib/auto-factory-1.0-beta6.jar"],
-}
-
-java_plugin {
- name: "dagger2-auto-factory",
- processor_class: "com.google.auto.factory.processor.AutoFactoryProcessor",
- static_libs: [
- "dagger2-auto-factory-jar",
- "dagger2-auto-common",
- "guava",
- "javapoet",
- "dagger2-google-java-format",
+// Added automatically by a large-scale-change that took the approach of
+// 'apply every license found to every target'. While this makes sure we respect
+// every license restriction, it may not be entirely correct.
+//
+// e.g. GPL in an MIT project might only apply to the contrib/ directory.
+//
+// Please consider splitting the single license below into multiple licenses,
+// taking care not to lose any license_kind information, and overriding the
+// default license using the 'licenses: [...]' property on targets as needed.
+//
+// For unused files, consider creating a 'fileGroup' with "//visibility:private"
+// to attach the license to, and including a comment whether the files may be
+// used in the current project.
+//
+// large-scale-change included anything that looked like it might be a license
+// text as a license_text. e.g. LICENSE, NOTICE, COPYING etc.
+//
+// Please consider removing redundant or irrelevant files from 'license_text:'.
+// See: http://go/android-license-faq
+license {
+ name: "external_dagger2_license",
+ visibility: [":__subpackages__"],
+ license_kinds: [
+ "SPDX-license-identifier-Apache-2.0",
+ "legacy_not_a_contribution",
],
-}
-
-java_import_host {
- name: "dagger2-auto-service-jar",
- jars: ["lib/auto-service-1.0-rc5.jar"],
-}
-
-java_import_host {
- name: "dagger2-auto-service-annotations",
- jars: ["lib/auto-service-annotations-1.0-rc5.jar"],
-}
-
-java_plugin {
- name: "dagger2-auto-service",
- processor_class: "com.google.auto.service.processor.AutoServiceProcessor",
- static_libs: [
- "dagger2-auto-common",
- "dagger2-auto-service-jar",
- "dagger2-auto-service-annotations",
- "guava",
+ license_text: [
+ "LICENSE.txt",
+ "NOTICE",
],
}
java_import_host {
- name: "dagger2-auto-value-jar",
- jars: ["lib/auto-value-1.6.5.jar"],
-}
-
-java_import_host {
- name: "dagger2-auto-value-annotations",
- jars: ["lib/auto-value-annotations-1.6.5.jar"],
-}
-
-java_plugin {
- name: "dagger2-auto-value",
- processor_class: "com.google.auto.value.processor.AutoValueProcessor",
- static_libs: [
- "dagger2-auto-value-jar",
- "dagger2-auto-value-annotations",
- ],
-}
-
-java_plugin {
- name: "dagger2-auto-annotation",
- processor_class: "com.google.auto.value.processor.AutoAnnotationProcessor",
- static_libs: ["dagger2-auto-value-jar"],
-}
-
-java_import_host {
- name: "dagger2-google-java-format",
- jars: ["lib/google-java-format-1.7-all-deps.jar"],
-}
-
-java_import_host {
- name: "dagger2-inject",
- jars: ["lib/javax.inject-1.jar"],
-}
-
-java_import_host {
name: "dagger2-bootstrap-compiler-jar",
- jars: ["java/dagger/internal/codegen/bootstrap_compiler_deploy.jar"],
+ jars: ["java/dagger/internal/codegen/bootstrap/bootstrap_compiler_deploy.jar"],
}
java_plugin {
@@ -100,36 +59,42 @@
processor_class: "dagger.internal.codegen.ComponentProcessor",
generates_api: true,
static_libs: ["dagger2-bootstrap-compiler-jar"],
+ jarjar_rules: "jarjar-rules.txt",
}
-java_library_host {
+java_library {
name: "dagger2",
+ visibility: ["//visibility:public"],
+ host_supported: true,
srcs: [
"java/dagger/*.java",
+ "java/dagger/assisted/*.java",
"java/dagger/internal/*.java",
"java/dagger/multibindings/*.java",
"java/dagger/releasablereferences/*.java",
],
exclude_srcs: ["java/dagger/android/**/*.java"],
- static_libs: ["dagger2-inject"],
-
- libs: ["guava"],
+ libs: [
+ "guava",
+ "jsr330",
+ ],
java_version: "1.8",
+ sdk_version: "core_current",
}
// build dagger2 producers library
// ============================================================
-java_library_host {
+java_library {
name: "dagger2-producers",
+ host_supported: true,
srcs: ["java/dagger/producers/**/*.java"],
static_libs: [
- "dagger2-inject",
"error_prone_annotations",
],
@@ -137,9 +102,11 @@
"dagger2",
"dagger2-android-annotation-stubs",
"guava",
+ "jsr330",
],
java_version: "1.8",
+ sdk_version: "core_current",
}
// build dagger2 compiler plugin
@@ -147,8 +114,16 @@
java_plugin {
name: "dagger2-compiler",
+ visibility: ["//visibility:public"],
processor_class: "dagger.internal.codegen.ComponentProcessor",
generates_api: true,
+ static_libs: ["dagger2-compiler-lib"],
+ // shade guava to avoid conflicts with guava embedded in Error Prone.
+ jarjar_rules: "jarjar-rules.txt",
+}
+
+java_library_host {
+ name: "dagger2-compiler-lib",
use_tools_jar: true,
srcs: [
@@ -161,7 +136,7 @@
exclude_srcs: [
"java/dagger/internal/codegen/BindingGraphStatisticsCollector.java",
- "java/dagger/internal/codegen/DaggerKythePlugin.java",
+ "java/dagger/internal/codegen/kythe/DaggerKythePlugin.java",
],
// Manually include META-INF/services/javax.annotation.processing.Processor
@@ -169,30 +144,32 @@
java_resource_dirs: ["resources"],
static_libs: [
+ "auto_common",
"dagger2",
- "dagger2-auto-common",
- "dagger2-auto-factory",
- "dagger2-auto-service",
- "dagger2-auto-value",
- "dagger2-google-java-format",
- "dagger2-inject",
"dagger2-producers",
+ "google_java_format",
"guava",
"javapoet",
+ "jsr330",
+ "kotlin-stdlib",
+ "kotlinx_metadata_jvm",
],
- // shade guava to avoid conflicts with guava embedded in Error Prone.
- jarjar_rules: "jarjar-rules.txt",
libs: [
+ "auto_factory_annotations",
+ "auto_service_annotations",
+ "auto_value_annotations",
+ "auto_value_memoized_extension_annotations",
"dagger2-android-annotation-stubs",
],
plugins: [
- "dagger2-auto-factory",
- "dagger2-auto-service",
- "dagger2-auto-value",
- "dagger2-auto-annotation",
+ "auto_factory_plugin",
+ "auto_service_plugin",
+ "auto_value_plugin",
+ "auto_value_memoized_extension_plugin",
+ "auto_annotation_plugin",
"dagger2-bootstrap-compiler",
],
@@ -212,3 +189,233 @@
sdk_version: "core_current",
srcs: ["android-annotation-stubs/src/**/*.java"],
}
+
+// build core hilt library
+
+java_library {
+ name: "hilt_core",
+ srcs: [
+ "java/dagger/hilt/*.java",
+ "java/dagger/hilt/codegen/*.java",
+ "java/dagger/hilt/components/*.java",
+ "java/dagger/hilt/internal/*.java",
+ "java/dagger/hilt/internal/aliasof/*.java",
+ "java/dagger/hilt/internal/definecomponent/*.java",
+ "java/dagger/hilt/internal/generatesrootinput/*.java",
+ "java/dagger/hilt/migration/*.java",
+ "java/dagger/hilt/processor/internal/aggregateddeps/AggregatedDeps.java",
+ ],
+ static_libs: [
+ "jsr305",
+ "jsr330",
+ "dagger2",
+ ],
+ sdk_version: "core_current",
+ plugins: [
+ "hilt_define_component_processor",
+ "hilt_generates_root_input_processor",
+ ],
+}
+
+// Build the android hilt library. Depending on this will enable the Hilt annotation processors.
+
+android_library {
+ name: "hilt_android",
+ visibility: ["//visibility:public"],
+
+ srcs: [
+ "java/dagger/hilt/android/*.java",
+ "java/dagger/hilt/android/components/*.java",
+ "java/dagger/hilt/android/migration/*.java",
+ "java/dagger/hilt/android/qualifiers/*.java",
+ "java/dagger/hilt/android/scopes/*.java",
+ "java/dagger/hilt/android/internal/*.java",
+ "java/dagger/hilt/android/internal/builders/*.java",
+ "java/dagger/hilt/android/internal/lifecycle/*.java",
+ "java/dagger/hilt/android/internal/managers/*.java",
+ "java/dagger/hilt/android/internal/migration/*.java",
+ "java/dagger/hilt/android/internal/modules/*.java",
+ "java/dagger/hilt/android/lifecycle/*.java",
+ ],
+ manifest: "java/dagger/hilt/android/AndroidManifest.xml",
+ static_libs: [
+ "androidx.annotation_annotation",
+ "androidx.fragment_fragment",
+ "jsr305",
+ "jsr330",
+ "dagger2",
+ "hilt_core",
+ ],
+ sdk_version: "current",
+ min_sdk_version: "14",
+ plugins: [
+ "dagger2-compiler",
+ "hilt_android_entry_point_processor",
+ "hilt_aggregated_deps_processor",
+ "hilt_define_component_processor",
+ "hilt_generates_root_input_processor",
+ "hilt_originating_element_processor",
+ "hilt_root_processor",
+ ],
+ exported_plugins: [
+ "dagger2-compiler",
+ "hilt_android_entry_point_processor",
+ "hilt_aggregated_deps_processor",
+ "hilt_alias_of_processor",
+ "hilt_define_component_processor",
+ "hilt_generates_root_input_processor",
+ "hilt_originating_element_processor",
+ "hilt_root_processor",
+ "hilt_viewmodel_processor",
+ ],
+}
+
+android_library {
+ name: "hilt_android_testing",
+ visibility: ["//visibility:public"],
+
+ srcs: [
+ "java/dagger/hilt/android/internal/testing/*.java",
+ "java/dagger/hilt/android/testing/*.java",
+ ],
+ manifest: "java/dagger/hilt/android/testing/AndroidManifest.xml",
+ static_libs: [
+ "auto_value_annotations",
+ "androidx.annotation_annotation",
+ "androidx.fragment_fragment",
+ "androidx.annotation_annotation",
+ "androidx.fragment_fragment",
+ "androidx.test.core",
+ "android-support-multidex",
+ "jsr305",
+ "dagger2",
+ "hilt_core",
+ "junit",
+ ],
+ sdk_version: "current",
+ min_sdk_version: "14",
+ plugins: [
+ "auto_value_plugin",
+ "dagger2-compiler",
+ "hilt_generates_root_input_processor",
+ ],
+ exported_plugins: [
+ "dagger2-compiler",
+ "hilt_android_entry_point_processor",
+ "hilt_aggregated_deps_processor",
+ "hilt_define_component_processor",
+ "hilt_generates_root_input_processor",
+ "hilt_originating_element_processor",
+ "hilt_root_processor",
+ "hilt_viewmodel_processor",
+ "hilt_custom_test_application_processor",
+ "hilt_bindvalue_processor",
+ "hilt_uninstall_modules_processor",
+ ],
+}
+
+// Hilt has many annotation processors. To reduce compilation and runtime cost, they are all compiled
+// into hilt_android_processors. A java_plugin can only expose a single processor class, so each has
+// to be defined separately. Since they are not visible outside this package and will always be
+// exported together, only the first actually contains the annotation processor classes.
+java_plugin {
+ name: "hilt_generates_root_input_processor",
+ generates_api: true,
+ processor_class: "dagger.hilt.processor.internal.generatesrootinput.GeneratesRootInputProcessor",
+ static_libs: ["hilt_android_processors"],
+}
+
+java_plugin {
+ name: "hilt_android_entry_point_processor",
+ generates_api: true,
+ processor_class: "dagger.hilt.android.processor.internal.androidentrypoint.AndroidEntryPointProcessor",
+}
+
+java_plugin {
+ name: "hilt_aggregated_deps_processor",
+ generates_api: true,
+ processor_class: "dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsProcessor",
+}
+
+java_plugin {
+ name: "hilt_alias_of_processor",
+ generates_api: true,
+ processor_class: "dagger.hilt.processor.internal.aliasof.AliasOfProcessor",
+}
+
+java_plugin {
+ name: "hilt_define_component_processor",
+ generates_api: true,
+ processor_class: "dagger.hilt.processor.internal.definecomponent.DefineComponentProcessor",
+}
+
+java_plugin {
+ name: "hilt_originating_element_processor",
+ generates_api: true,
+ processor_class: "dagger.hilt.processor.internal.originatingelement.OriginatingElementProcessor",
+}
+
+java_plugin {
+ name: "hilt_root_processor",
+ generates_api: true,
+ processor_class: "dagger.hilt.processor.internal.root.RootProcessor",
+}
+
+java_plugin {
+ name: "hilt_viewmodel_processor",
+ generates_api: true,
+ processor_class: "dagger.hilt.android.processor.internal.viewmodel.ViewModelProcessor",
+}
+
+// Hilt testing processors
+java_plugin {
+ name: "hilt_custom_test_application_processor",
+ generates_api: true,
+ processor_class: "dagger.hilt.android.processor.internal.customtestapplication.CustomTestApplicationProcessor",
+}
+
+java_plugin {
+ name: "hilt_bindvalue_processor",
+ generates_api: true,
+ processor_class: "dagger.hilt.android.processor.internal.bindvalue.BindValueProcessor",
+}
+
+java_plugin {
+ name: "hilt_uninstall_modules_processor",
+ generates_api: true,
+ processor_class: "dagger.hilt.android.processor.internal.uninstallmodules.UninstallModulesProcessor",
+}
+
+java_library_host {
+ name: "hilt_android_processors",
+ use_tools_jar: true,
+ srcs: [
+ "java/dagger/hilt/android/processor/**/*.java",
+ "java/dagger/hilt/android/processor/**/*.kt",
+ "java/dagger/hilt/codegen/*.java",
+ "java/dagger/hilt/processor/internal/**/*.java",
+ ],
+ plugins: [
+ "auto_service_plugin",
+ "auto_value_plugin",
+ "auto_value_memoized_extension_plugin",
+ "dagger2-compiler",
+ ],
+ static_libs: [
+ "auto_common",
+ "auto_service_annotations",
+ "auto_value_annotations",
+ "auto_value_memoized_extension_annotations",
+ "guava",
+ "jsr305",
+ "dagger2-compiler-lib",
+ "dagger2",
+ "javapoet",
+ "jsr330",
+ "kotlin-stdlib",
+ "kotlinx_metadata_jvm",
+ "dagger2-android-annotation-stubs",
+ ],
+ // shade guava to avoid conflicts with guava embedded in Error Prone.
+ jarjar_rules: "jarjar-rules.txt",
+}
diff --git a/BUILD b/BUILD
index 8becb3e..015e849 100644
--- a/BUILD
+++ b/BUILD
@@ -12,15 +12,25 @@
# See the License for the specific language governing permissions and
# limitations under the License.
+load("@rules_java//java:defs.bzl", "java_library")
+load("@google_bazel_common//tools/javadoc:javadoc.bzl", "javadoc_library")
+load("@google_bazel_common//tools/jarjar:jarjar.bzl", "jarjar_library")
+load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "define_kt_toolchain")
+
package(default_visibility = ["//visibility:public"])
+define_kt_toolchain(
+ name = "kotlin_toolchain",
+ api_version = "1.4",
+ jvm_target = "1.8",
+ language_version = "1.4",
+)
+
package_group(
name = "src",
packages = ["//..."],
)
-load("@google_bazel_common//tools/javadoc:javadoc.bzl", "javadoc_library")
-
java_library(
name = "dagger_with_compiler",
exported_plugins = ["//java/dagger/internal/codegen:component-codegen"],
@@ -35,6 +45,22 @@
],
)
+java_library(
+ name = "spi",
+ exports = ["//java/dagger/spi"],
+)
+
+java_library(
+ name = "compiler_internals",
+ exports = [
+ "//java/dagger/internal/codegen:processor",
+ "//java/dagger/internal/codegen/base",
+ "//java/dagger/internal/codegen/binding",
+ "//java/dagger/internal/codegen/validation",
+ "//java/dagger/internal/codegen/writing",
+ ],
+)
+
android_library(
name = "android",
exported_plugins = ["//java/dagger/android/processor:plugin"],
@@ -49,118 +75,48 @@
],
)
-load("@google_bazel_common//tools/jarjar:jarjar.bzl", "jarjar_library")
-
-SHADE_RULES = ["rule com.google.auto.common.** dagger.shaded.auto.common.@1"]
-
-jarjar_library(
- name = "shaded_compiler",
- jars = [
- "//java/dagger/internal/codegen:base",
- "//java/dagger/internal/codegen:binding",
- "//java/dagger/internal/codegen:binding_graph_validation",
- "//java/dagger/internal/codegen:jdk-and-guava-extras",
- "//java/dagger/internal/codegen:processor",
- "//java/dagger/internal/codegen:validation",
- "//java/dagger/internal/codegen:writing",
- "//java/dagger/internal/codegen/javapoet",
- "//java/dagger/internal/codegen/langmodel",
- "//java/dagger/internal/codegen/serialization",
- "//java/dagger/model:internal-proxies",
- "//java/dagger/errorprone",
- "@com_google_auto_auto_common//jar",
- ],
- rules = SHADE_RULES,
-)
-
-jarjar_library(
- name = "shaded_compiler_src",
- jars = [
- "//java/dagger/internal/codegen:libbase-src.jar",
- "//java/dagger/internal/codegen:libbinding-src.jar",
- "//java/dagger/internal/codegen:libbinding_graph_validation-src.jar",
- "//java/dagger/internal/codegen:libjdk-and-guava-extras-src.jar",
- "//java/dagger/internal/codegen:libprocessor-src.jar",
- "//java/dagger/internal/codegen:libvalidation-src.jar",
- "//java/dagger/internal/codegen:libwriting-src.jar",
- "//java/dagger/internal/codegen/javapoet:libjavapoet-src.jar",
- "//java/dagger/internal/codegen/langmodel:liblangmodel-src.jar",
- # TODO(ronshapiro): is there a generated src.jar for protos in Bazel?
- "//java/dagger/errorprone:liberrorprone-src.jar",
- ],
-)
-
-jarjar_library(
- name = "shaded_spi",
- jars = [
- "//java/dagger/internal/codegen:jdk-and-guava-extras",
- "//java/dagger/model",
- "//java/dagger/spi",
- "@com_google_auto_auto_common//jar",
- ],
- rules = SHADE_RULES,
-)
-
-jarjar_library(
- name = "shaded_spi_src",
- jars = [
- "//java/dagger/internal/codegen:libjdk-and-guava-extras-src.jar",
- "//java/dagger/model:libmodel-src.jar",
- "//java/dagger/spi:libspi-src.jar",
- ],
-)
-
-javadoc_library(
- name = "spi-javadoc",
- srcs = [
- "//java/dagger/model:model-srcs",
- "//java/dagger/spi:spi-srcs",
- ],
- root_packages = [
- "dagger.model",
- "dagger.spi",
- ],
- deps = [
- "//java/dagger/model",
- "//java/dagger/spi",
- ],
-)
-
jarjar_library(
name = "shaded_android_processor",
jars = [
"//java/dagger/android/processor",
- "@com_google_auto_auto_common//jar",
+ "@maven//:com_google_auto_auto_common",
],
- rules = SHADE_RULES,
+ rules = [
+ "rule com.google.auto.common.** dagger.android.shaded.auto.common.@1",
+ ],
)
jarjar_library(
name = "shaded_grpc_server_processor",
jars = [
"//java/dagger/grpc/server/processor",
- "@com_google_auto_auto_common//jar",
+ "@maven//:com_google_auto_auto_common",
],
- rules = SHADE_RULES,
+ rules = [
+ "rule com.google.auto.common.** dagger.grpc.shaded.auto.common.@1",
+ ],
)
# coalesced javadocs used for the gh-pages site
javadoc_library(
name = "user-docs",
+ testonly = 1,
srcs = [
"//java/dagger:javadoc-srcs",
"//java/dagger/android:android-srcs",
"//java/dagger/android/support:support-srcs",
"//java/dagger/grpc/server:javadoc-srcs",
"//java/dagger/grpc/server/processor:javadoc-srcs",
- "//java/dagger/model:model-srcs",
+ "//java/dagger/hilt:javadoc-srcs",
"//java/dagger/producers:producers-srcs",
"//java/dagger/spi:spi-srcs",
],
- android_api_level = 26,
+ android_api_level = 30,
# TODO(ronshapiro): figure out how to specify the version number for release builds
doctitle = "Dagger Dependency Injection API",
exclude_packages = [
+ "dagger.hilt.android.internal",
+ "dagger.hilt.internal",
"dagger.internal",
"dagger.producers.internal",
"dagger.producers.monitoring.internal",
@@ -172,7 +128,8 @@
"//java/dagger/android/support",
"//java/dagger/grpc/server",
"//java/dagger/grpc/server/processor",
- "//java/dagger/model",
+ "//java/dagger/hilt/android:artifact-lib",
+ "//java/dagger/hilt/android/testing:artifact-lib",
"//java/dagger/producers",
"//java/dagger/spi",
],
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 45f15c4..54fb50a 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -33,11 +33,19 @@
* [Install Bazel](https://docs.bazel.build/versions/master/install.html)
* Build the Dagger project with `bazel build <target>`
* Learn more about Bazel targets [here][bazel targets].
- * If you see an error similar to `ERROR: missing input file
- '@androidsdk//:build-tools/26.0.2/aapt'`, install the missing build
- tools version with the android `sdkmanager` tool.
+ * Building Dagger's Android targets requires additional setup:
+ * Set the `ANDROID_HOME` environment variable to point to a directory
+ containing the Android SDK. If you do not have the Android SDK
+ installed, you'll have to
+ [download](https://developer.android.com/studio#command-tools)
+ and unzip it first.
+ * Install the necessary components. For example, under Linux, run:
+ `$ANDROID_HOME/tools/bin/sdkmanager "platforms;android-30" "build-tools;30.0.2"`
+ * If you skip this step, you will see an error similar to
+ `ERROR: missing input file '@androidsdk//:build-tools/30.0.2/aapt'`.
+ * You may also need to run `bazel sync`.
* Run tests with `bazel test <target>`, or `bazel test //...` to run all
- tests
+ tests.
* You can install the Dagger libraries in your **local maven repository** by
running the `./util/install-local-snapshot.sh` script.
* It will build the libraries and install them with a `LOCAL-SNAPSHOT`
diff --git a/METADATA b/METADATA
index 59b9e25..5eef5c3 100644
--- a/METADATA
+++ b/METADATA
@@ -11,7 +11,7 @@
type: GIT
value: "https://github.com/google/dagger"
}
- version: "dagger-2.23.1"
- last_upgrade_date { year: 2019 month: 6 day: 14 }
- license_type: PERMISSIVE
+ version: "dagger-2.19.1"
+ last_upgrade_date { year: 2020 month: 11 day: 18 }
+ license_type: NOTICE
}
diff --git a/README.md b/README.md
index a9ebc26..393e2e7 100644
--- a/README.md
+++ b/README.md
@@ -1,34 +1,23 @@
-# Dagger 2
+# Dagger
[![Maven Central][mavenbadge-svg]][mavencentral]
-A fast dependency injector for Android and Java.
+A fast dependency injector for Java and Android.
-## About Google's Fork
+Dagger is a compile-time framework for dependency injection. It uses no
+reflection or runtime bytecode generation, does all its analysis at
+compile-time, and generates plain Java source code.
-Dagger 2 is a compile-time evolution approach to dependency injection.
-Taking the approach started in Dagger 1.x to its ultimate conclusion,
-Dagger 2.x eliminates all reflection, and improves code clarity by
-removing the traditional ObjectGraph/Injector in favor of user-specified
-`@Component` interfaces.
-
-This github project represents the Dagger 2 development stream. The earlier
-[project page][square] (Square, Inc's repository) represents the earlier 1.0
-development stream. Both versions have benefited from strong involvement from
-Square, Google, and other contributors.
-
-Dagger is currently in active development, primarily internally at Google,
-with regular pushes to the open-source community. Snapshot releases are
-auto-deployed to sonatype's central maven repository on every clean build with
-the version `HEAD-SNAPSHOT`.
-
-> [Dagger 2's main documentation website can be found here.][website]
+Dagger is actively maintained by the same team that works on [Guava]. Snapshot
+releases are auto-deployed to Sonatype's central Maven repository on every clean
+build with the version `HEAD-SNAPSHOT`. The current version builds upon previous
+work done at [Square][square].
## Documentation
You can [find the dagger documentation here][website] which has extended usage
-instructions and other useful information. Substantial usage information can be
-found in the [API documentation][20api].
+instructions and other useful information. More detailed information can be
+found in the [API documentation][latestapi].
You can also learn more from [the original proposal][proposal],
[this talk by Greg Kick][gaktalk], and on the dagger-discuss@googlegroups.com
@@ -38,19 +27,154 @@
### Bazel
-If you build with `bazel`, follow the [`bazel` documentation for referencing
-external projects][bazel-external-deps] to include Dagger in your build.
+First, import the Dagger repository into your `WORKSPACE` file using
+[`http_archive`][bazel-external-deps].
-Given the following `WORKSPACE` definition, you can reference dagger via
-`@com_google_dagger//:dagger_with_compiler` in your deps.
+Note: The `http_archive` must point to a tagged release of Dagger, not just any
+commit. The version of the Dagger artifacts will match the version of the tagged
+release.
```python
+# Top-level WORKSPACE file
+
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+
+DAGGER_TAG = "2.28.1"
+DAGGER_SHA = "9e69ab2f9a47e0f74e71fe49098bea908c528aa02fa0c5995334447b310d0cdd"
http_archive(
- name = "com_google_dagger",
- urls = ["https://github.com/google/dagger/archive/dagger-<version>.zip"],
+ name = "dagger",
+ strip_prefix = "dagger-dagger-%s" % DAGGER_TAG,
+ sha256 = DAGGER_SHA,
+ urls = ["https://github.com/google/dagger/archive/dagger-%s.zip" % DAGGER_TAG],
)
```
+Next you will need to setup targets that export the proper dependencies
+and plugins. Follow the sections below to setup the dependencies you need.
+
+#### Dagger Setup
+
+First, load the Dagger artifacts and repositories, and add them to your list of
+[`maven_install`] artifacts.
+
+```python
+# Top-level WORKSPACE file
+
+load("@dagger//:workspace_defs.bzl", "DAGGER_ARTIFACTS", "DAGGER_REPOSITORIES")
+
+maven_install(
+ artifacts = DAGGER_ARTIFACTS + [...],
+ repositories = DAGGER_REPOSITORIES + [...],
+)
+```
+
+Next, load and call [`dagger_rules`](https://github.com/google/dagger/blob/master/workspace_defs.bzl)
+in your top-level `BUILD` file:
+
+```python
+# Top-level BUILD file
+
+load("@dagger//:workspace_defs.bzl", "dagger_rules")
+
+dagger_rules()
+```
+
+This will add the following Dagger build targets:
+(Note that these targets already export all of the dependencies and processors
+they need).
+
+```python
+deps = [
+ ":dagger", # For Dagger
+ ":dagger-spi", # For Dagger SPI
+ ":dagger-producers", # For Dagger Producers
+]
+```
+
+#### Dagger Android Setup
+
+First, load the Dagger Android artifacts and repositories, and add them to your
+list of [`maven_install`] artifacts.
+
+```python
+# Top-level WORKSPACE file
+
+load(
+ "@dagger//:workspace_defs.bzl",
+ "DAGGER_ANDROID_ARTIFACTS",
+ "DAGGER_ANDROID_REPOSITORIES"
+)
+
+maven_install(
+ artifacts = DAGGER_ANDROID_ARTIFACTS + [...],
+ repositories = DAGGER_ANDROID_REPOSITORIES + [...],
+)
+```
+
+Next, load and call [`dagger_android_rules`](https://github.com/google/dagger/blob/master/workspace_defs.bzl)
+in your top-level `BUILD` file:
+
+```python
+# Top-level BUILD file
+
+load("@dagger//:workspace_defs.bzl", "dagger_android_rules")
+
+dagger_android_rules()
+```
+
+This will add the following Dagger Android build targets:
+(Note that these targets already export all of the dependencies and processors
+they need).
+
+```python
+deps = [
+ ":dagger-android", # For Dagger Android
+ ":dagger-android-support", # For Dagger Android (Support)
+]
+```
+
+#### Hilt Android Setup
+
+First, load the Hilt Android artifacts and repositories, and add them to your
+list of [`maven_install`] artifacts.
+
+```python
+# Top-level WORKSPACE file
+
+load(
+ "@dagger//:workspace_defs.bzl",
+ "HILT_ANDROID_ARTIFACTS",
+ "HILT_ANDROID_REPOSITORIES"
+)
+
+maven_install(
+ artifacts = HILT_ANDROID_ARTIFACTS + [...],
+ repositories = HILT_ANDROID_REPOSITORIES + [...],
+)
+```
+
+Next, load and call [`hilt_android_rules`](https://github.com/google/dagger/blob/master/workspace_defs.bzl)
+in your top-level `BUILD` file:
+
+```python
+# Top-level BUILD file
+
+load("@dagger//:workspace_defs.bzl", "hilt_android_rules")
+
+hilt_android_rules()
+```
+
+This will add the following Hilt Android build targets:
+(Note that these targets already export all of the dependencies and processors
+they need).
+
+```python
+deps = [
+ ":hilt-android", # For Hilt Android
+ ":hilt-android-testing", # For Hilt Android Testing
+]
+```
+
### Other build systems
You will need to include the `dagger-2.x.jar` in your application's runtime.
@@ -124,25 +248,11 @@
</dependencies>
```
-#### Java Gradle
-```groovy
-// Add plugin https://plugins.gradle.org/plugin/net.ltgt.apt
-plugins {
- id "net.ltgt.apt" version "0.10"
-}
-
-// Add Dagger dependencies
-dependencies {
- compile 'com.google.dagger:dagger:2.x'
- apt 'com.google.dagger:dagger-compiler:2.x'
-}
-```
-
-#### Android Gradle
+#### Gradle
```groovy
// Add Dagger dependencies
dependencies {
- compile 'com.google.dagger:dagger:2.x'
+ implementation 'com.google.dagger:dagger:2.x'
annotationProcessor 'com.google.dagger:dagger-compiler:2.x'
}
```
@@ -150,13 +260,19 @@
If you're using classes in `dagger.android` you'll also want to include:
```groovy
-compile 'com.google.dagger:dagger-android:2.x'
-compile 'com.google.dagger:dagger-android-support:2.x' // if you use the support libraries
+implementation 'com.google.dagger:dagger-android:2.x'
+implementation 'com.google.dagger:dagger-android-support:2.x' // if you use the support libraries
annotationProcessor 'com.google.dagger:dagger-android-processor:2.x'
```
-If you're using a version of the Android gradle plugin below `2.2`, see
-https://bitbucket.org/hvisser/android-apt.
+Notes:
+
+- We use `implementation` instead of `api` for better compilation performance.
+ - See the [Gradle documentation][gradle-api-implementation] for more
+ information on how to select appropriately, and the [Android Gradle
+ plugin documentation][gradle-api-implementation-android] for Android
+ projects.
+- For Kotlin projects, use [`kapt`] in place of `annotationProcessor`.
If you're using the [Android Databinding library][databinding], you may want to
increase the number of errors that `javac` will print. When Dagger prints an
@@ -172,16 +288,11 @@
}
```
-### Download
+### Resources
- * 2.x (google/dagger)
- * [Dagger 2.0 Documentation][website]
- * [Dagger 2.0 Javadocs][20api]
- * [Dagger development Javadocs][latestapi] (from the `master` branch
- on GitHub)
- * [Google's Dagger project site on GitHub][project]
- * 1.x (square/dagger)
- * [Square's original Dagger project site on GitHub][square]
+* [Documentation][website]
+* [Javadocs][latestapi]
+* [GitHub Issues]
If you do not use maven, gradle, ivy, or other build systems that consume
@@ -212,13 +323,18 @@
See the License for the specific language governing permissions and
limitations under the License.
-[20api]: https://dagger.dev/api/2.0/
[`bazel`]: https://bazel.build
[bazel-external-deps]: https://docs.bazel.build/versions/master/external.html#depending-on-other-bazel-projects
+[`maven_install`]: https://github.com/bazelbuild/rules_jvm_external#exporting-and-consuming-artifacts-from-external-repositories
[Building Dagger]: CONTRIBUTING.md#building-dagger
[dagger-snap]: https://oss.sonatype.org/content/repositories/snapshots/com/google/dagger/
[databinding]: https://developer.android.com/topic/libraries/data-binding/
[gaktalk]: https://www.youtube.com/watch?v=oK_XtfXPkqw
+[GitHub Issues]: https://github.com/google/dagger/issues
+[gradle-api-implementation]: https://docs.gradle.org/current/userguide/java_library_plugin.html#sec:java_library_separation
+[gradle-api-implementation-android]: https://developer.android.com/studio/build/dependencies#dependency_configurations
+[Guava]: https://github.com/google/guava
+[`kapt`]: https://kotlinlang.org/docs/reference/kapt.html
[latestapi]: https://dagger.dev/api/latest/
[mavenbadge-svg]: https://maven-badges.herokuapp.com/maven-central/com.google.dagger/dagger/badge.svg
[mavencentral]: https://search.maven.org/artifact/com.google.dagger/dagger
diff --git a/WORKSPACE b/WORKSPACE
index 8758b38..6c2b6b0 100644
--- a/WORKSPACE
+++ b/WORKSPACE
@@ -12,23 +12,143 @@
# See the License for the specific language governing permissions and
# limitations under the License.
+# Declare the nested workspace so that the top-level workspace doesn't try to
+# traverse it when calling `bazel build //...`
+local_repository(
+ name = "examples_bazel",
+ path = "examples/bazel",
+)
+
load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
http_archive(
name = "google_bazel_common",
- strip_prefix = "bazel-common-26011657fee96a949c66500b1662c4c7288a4968",
- urls = ["https://github.com/google/bazel-common/archive/26011657fee96a949c66500b1662c4c7288a4968.zip"],
+ sha256 = "d8aa0ef609248c2a494d5dbdd4c89ef2a527a97c5a87687e5a218eb0b77ff640",
+ strip_prefix = "bazel-common-4a8d451e57fb7e1efecbf9495587a10684a19eb2",
+ urls = ["https://github.com/google/bazel-common/archive/4a8d451e57fb7e1efecbf9495587a10684a19eb2.zip"],
)
load("@google_bazel_common//:workspace_defs.bzl", "google_common_workspace_rules")
google_common_workspace_rules()
-# This fixes an issue with protobuf starting to use zlib by default in 3.7.0.
-# TODO(ronshapiro): Figure out if this is in fact necessary, or if proto can depend on the
+RULES_JVM_EXTERNAL_TAG = "2.7"
+
+RULES_JVM_EXTERNAL_SHA = "f04b1466a00a2845106801e0c5cec96841f49ea4e7d1df88dc8e4bf31523df74"
+
+http_archive(
+ name = "rules_jvm_external",
+ sha256 = RULES_JVM_EXTERNAL_SHA,
+ strip_prefix = "rules_jvm_external-%s" % RULES_JVM_EXTERNAL_TAG,
+ url = "https://github.com/bazelbuild/rules_jvm_external/archive/%s.zip" % RULES_JVM_EXTERNAL_TAG,
+)
+
+# rules_python and zlib are required by protobuf.
+# TODO(ronshapiro): Figure out if zlib is in fact necessary, or if proto can depend on the
# @bazel_tools library directly. See discussion in
# https://github.com/protocolbuffers/protobuf/pull/5389#issuecomment-481785716
-bind(
- name = "zlib",
- actual = "@bazel_tools//third_party/zlib",
+# TODO(cpovirk): Should we eventually get rules_python from "Bazel Federation?"
+# https://github.com/bazelbuild/rules_python#getting-started
+
+http_archive(
+ name = "rules_python",
+ sha256 = "e5470e92a18aa51830db99a4d9c492cc613761d5bdb7131c04bd92b9834380f6",
+ strip_prefix = "rules_python-4b84ad270387a7c439ebdccfd530e2339601ef27",
+ urls = ["https://github.com/bazelbuild/rules_python/archive/4b84ad270387a7c439ebdccfd530e2339601ef27.tar.gz"],
)
+
+http_archive(
+ name = "zlib",
+ build_file = "@com_google_protobuf//:third_party/zlib.BUILD",
+ sha256 = "629380c90a77b964d896ed37163f5c3a34f6e6d897311f1df2a7016355c45eff",
+ strip_prefix = "zlib-1.2.11",
+ urls = ["https://github.com/madler/zlib/archive/v1.2.11.tar.gz"],
+)
+
+RULES_KOTLIN_COMMIT = "2c283821911439e244285b5bfec39148e7d90e21"
+
+RULES_KOTLIN_SHA = "b04cd539e7e3571745179da95069586b6fa76a64306b24bb286154e652010608"
+
+http_archive(
+ name = "io_bazel_rules_kotlin",
+ sha256 = RULES_KOTLIN_SHA,
+ strip_prefix = "rules_kotlin-%s" % RULES_KOTLIN_COMMIT,
+ type = "zip",
+ urls = ["https://github.com/bazelbuild/rules_kotlin/archive/%s.zip" % RULES_KOTLIN_COMMIT],
+)
+
+load("@io_bazel_rules_kotlin//kotlin:dependencies.bzl", "kt_download_local_dev_dependencies")
+
+kt_download_local_dev_dependencies()
+
+load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "kotlin_repositories")
+
+KOTLIN_VERSION = "1.4.20"
+
+KOTLINC_RELEASE_SHA = "11db93a4d6789e3406c7f60b9f267eba26d6483dcd771eff9f85bb7e9837011f"
+
+KOTLINC_RELEASE = {
+ "sha256": KOTLINC_RELEASE_SHA,
+ "urls": ["https://github.com/JetBrains/kotlin/releases/download/v{v}/kotlin-compiler-{v}.zip".format(v = KOTLIN_VERSION)],
+}
+
+kotlin_repositories(compiler_release = KOTLINC_RELEASE)
+
+register_toolchains("//:kotlin_toolchain")
+
+load("@rules_jvm_external//:defs.bzl", "maven_install")
+
+ANDROID_LINT_VERSION = "26.6.2"
+
+maven_install(
+ artifacts = [
+ "androidx.annotation:annotation:1.1.0",
+ "androidx.appcompat:appcompat:1.2.0",
+ "androidx.activity:activity:1.1.0",
+ "androidx.fragment:fragment:1.2.5",
+ "androidx.lifecycle:lifecycle-viewmodel:2.2.0",
+ "androidx.lifecycle:lifecycle-viewmodel-savedstate:2.2.0",
+ "androidx.multidex:multidex:2.0.1",
+ "androidx.savedstate:savedstate:1.0.0",
+ "androidx.test:monitor:1.1.1",
+ "androidx.test:core:1.1.0",
+ "com.google.auto:auto-common:0.11",
+ "com.android.support:appcompat-v7:25.0.0",
+ "com.android.support:support-annotations:25.0.0",
+ "com.android.support:support-fragment:25.0.0",
+ "com.android.tools.external.org-jetbrains:uast:%s" % ANDROID_LINT_VERSION,
+ "com.android.tools.external.com-intellij:intellij-core:%s" % ANDROID_LINT_VERSION,
+ "com.android.tools.external.com-intellij:kotlin-compiler:%s" % ANDROID_LINT_VERSION,
+ "com.android.tools.lint:lint:%s" % ANDROID_LINT_VERSION,
+ "com.android.tools.lint:lint-api:%s" % ANDROID_LINT_VERSION,
+ "com.android.tools.lint:lint-checks:%s" % ANDROID_LINT_VERSION,
+ "com.android.tools.lint:lint-tests:%s" % ANDROID_LINT_VERSION,
+ "com.android.tools:testutils:%s" % ANDROID_LINT_VERSION,
+ "com.github.tschuchortdev:kotlin-compile-testing:1.2.8",
+ "com.google.guava:guava:27.1-android",
+ "org.jetbrains.kotlin:kotlin-stdlib:%s" % KOTLIN_VERSION,
+ "org.jetbrains.kotlinx:kotlinx-metadata-jvm:0.1.0",
+ "org.robolectric:robolectric:4.3.1",
+ ],
+ repositories = [
+ "https://repo1.maven.org/maven2",
+ "https://maven.google.com",
+ "https://jcenter.bintray.com/", # Lint has one trove4j dependency in jCenter
+ ],
+)
+
+BAZEL_SKYLIB_VERSION = "1.0.2"
+
+BAZEL_SKYLIB_SHA = "97e70364e9249702246c0e9444bccdc4b847bed1eb03c5a3ece4f83dfe6abc44"
+
+http_archive(
+ name = "bazel_skylib",
+ sha256 = BAZEL_SKYLIB_SHA,
+ urls = [
+ "https://github.com/bazelbuild/bazel-skylib/releases/download/{version}/bazel-skylib-{version}.tar.gz".format(version = BAZEL_SKYLIB_VERSION),
+ ],
+)
+
+load("@bazel_skylib//:workspace.bzl", "bazel_skylib_workspace")
+
+bazel_skylib_workspace()
diff --git a/android-annotation-stubs/gen_annotations.sh b/android-annotation-stubs/gen_annotations.sh
index 21aeb46..d4a0290 100755
--- a/android-annotation-stubs/gen_annotations.sh
+++ b/android-annotation-stubs/gen_annotations.sh
@@ -59,6 +59,8 @@
package net.ltgt.gradle.incap;
public enum IncrementalAnnotationProcessorType {
- DYNAMIC
+ AGGREGATING,
+ DYNAMIC,
+ ISOLATING
}
EOF
diff --git a/android-annotation-stubs/src/net/ltgt/gradle/incap/IncrementalAnnotationProcessorType.java b/android-annotation-stubs/src/net/ltgt/gradle/incap/IncrementalAnnotationProcessorType.java
index 83e3590..ef86328 100644
--- a/android-annotation-stubs/src/net/ltgt/gradle/incap/IncrementalAnnotationProcessorType.java
+++ b/android-annotation-stubs/src/net/ltgt/gradle/incap/IncrementalAnnotationProcessorType.java
@@ -16,5 +16,7 @@
package net.ltgt.gradle.incap;
public enum IncrementalAnnotationProcessorType {
- DYNAMIC
+ AGGREGATING,
+ DYNAMIC,
+ ISOLATING
}
diff --git a/build_defs.bzl b/build_defs.bzl
index 0bd7402..932ca08 100644
--- a/build_defs.bzl
+++ b/build_defs.bzl
@@ -24,3 +24,8 @@
"-target",
"1.7",
]
+
+POM_VERSION = "2.29.1"
+
+# DO NOT remove the comment on the next line. It's used in deploy-to-maven-central.sh
+POM_VERSION_ALPHA = POM_VERSION + "-alpha"
diff --git a/examples/BUILD b/examples/BUILD
new file mode 100644
index 0000000..5cd2290
--- /dev/null
+++ b/examples/BUILD
@@ -0,0 +1,18 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Description:
+# Dagger examples
+
+package(default_visibility = ["//:src"])
diff --git a/examples/bazel/BUILD b/examples/bazel/BUILD
new file mode 100644
index 0000000..0f9a621
--- /dev/null
+++ b/examples/bazel/BUILD
@@ -0,0 +1,22 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Description:
+# Dagger Bazel examples
+
+load("@dagger//:workspace_defs.bzl", "dagger_rules", "hilt_android_rules")
+
+dagger_rules()
+
+hilt_android_rules()
diff --git a/examples/bazel/WORKSPACE b/examples/bazel/WORKSPACE
new file mode 100644
index 0000000..23f93b1
--- /dev/null
+++ b/examples/bazel/WORKSPACE
@@ -0,0 +1,89 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Description:
+# Defines the Bazel workspace rules for the Dagger examples.
+
+########################
+# Load Dagger repository
+########################
+
+# TODO(bcorso): Replace with `http_archive` pointing to tagged released.
+local_repository(
+ name = "dagger",
+ path = "../../",
+)
+
+load(
+ "@dagger//:workspace_defs.bzl",
+ "DAGGER_ARTIFACTS",
+ "DAGGER_REPOSITORIES",
+ "HILT_ANDROID_ARTIFACTS",
+ "HILT_ANDROID_REPOSITORIES",
+)
+
+#########################
+# Load Android repository
+#########################
+
+android_sdk_repository(
+ name = "androidsdk",
+ api_level = 30,
+ build_tools_version = "30.0.2",
+)
+
+#############################
+# Load Robolectric repository
+#############################
+
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+
+http_archive(
+ name = "robolectric",
+ strip_prefix = "robolectric-bazel-4.1",
+ urls = ["https://github.com/robolectric/robolectric-bazel/archive/4.1.tar.gz"],
+)
+
+load("@robolectric//bazel:robolectric.bzl", "robolectric_repositories")
+
+robolectric_repositories()
+
+#########################
+# Load Maven repositories
+#########################
+
+RULES_JVM_EXTERNAL_TAG = "2.7"
+
+RULES_JVM_EXTERNAL_SHA = "f04b1466a00a2845106801e0c5cec96841f49ea4e7d1df88dc8e4bf31523df74"
+
+http_archive(
+ name = "rules_jvm_external",
+ sha256 = RULES_JVM_EXTERNAL_SHA,
+ strip_prefix = "rules_jvm_external-%s" % RULES_JVM_EXTERNAL_TAG,
+ url = "https://github.com/bazelbuild/rules_jvm_external/archive/%s.zip" % RULES_JVM_EXTERNAL_TAG,
+)
+
+load("@rules_jvm_external//:defs.bzl", "maven_install")
+
+maven_install(
+ artifacts = DAGGER_ARTIFACTS + HILT_ANDROID_ARTIFACTS + [
+ "androidx.test.ext:junit:1.1.1",
+ "androidx.test:runner:1.1.1",
+ "com.google.truth:truth:1.0.1",
+ "junit:junit:4.13",
+ "org.robolectric:robolectric:4.1",
+ "org.robolectric:annotations:4.1",
+ ],
+ repositories = DAGGER_REPOSITORIES + HILT_ANDROID_REPOSITORIES,
+)
diff --git a/examples/bazel/java/example/common/BUILD b/examples/bazel/java/example/common/BUILD
new file mode 100644
index 0000000..4de78ae
--- /dev/null
+++ b/examples/bazel/java/example/common/BUILD
@@ -0,0 +1,25 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+java_library(
+ name = "common",
+ srcs = glob(["*.java"]),
+ visibility = [
+ "//java/example:__subpackages__",
+ "//javatests/example:__subpackages__",
+ ],
+ deps = [
+ "//:dagger",
+ ],
+)
diff --git a/examples/bazel/java/example/common/CoffeeLogger.java b/examples/bazel/java/example/common/CoffeeLogger.java
new file mode 100644
index 0000000..10c1849
--- /dev/null
+++ b/examples/bazel/java/example/common/CoffeeLogger.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package example.common;
+
+import java.util.ArrayList;
+import java.util.List;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+/** A logger to logs steps while brewing coffee. */
+@Singleton
+public final class CoffeeLogger {
+ private final List<String> logs = new ArrayList<>();
+
+ @Inject
+ CoffeeLogger() {}
+
+ public void log(String msg) {
+ logs.add(msg);
+ }
+
+ public List<String> logs() {
+ return new ArrayList<>(logs);
+ }
+}
diff --git a/examples/bazel/java/example/common/CoffeeMaker.java b/examples/bazel/java/example/common/CoffeeMaker.java
new file mode 100644
index 0000000..796638d
--- /dev/null
+++ b/examples/bazel/java/example/common/CoffeeMaker.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package example.common;
+
+import dagger.Lazy;
+import javax.inject.Inject;
+
+/** A coffee maker to brew the coffee. */
+public class CoffeeMaker {
+ private final CoffeeLogger logger;
+ private final Lazy<Heater> heater; // Create a possibly costly heater only when we use it.
+ private final Pump pump;
+
+ @Inject
+ CoffeeMaker(CoffeeLogger logger, Lazy<Heater> heater, Pump pump) {
+ this.logger = logger;
+ this.heater = heater;
+ this.pump = pump;
+ }
+
+ public void brew() {
+ heater.get().on();
+ pump.pump();
+ logger.log(" [_]P coffee! [_]P ");
+ heater.get().off();
+ }
+}
diff --git a/examples/bazel/java/example/common/ElectricHeater.java b/examples/bazel/java/example/common/ElectricHeater.java
new file mode 100644
index 0000000..981a41a
--- /dev/null
+++ b/examples/bazel/java/example/common/ElectricHeater.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package example.common;
+
+import javax.inject.Inject;
+
+/** An electric heater to heat the coffee. */
+public class ElectricHeater implements Heater {
+
+ private final CoffeeLogger logger;
+ private boolean heating;
+
+ @Inject
+ ElectricHeater(CoffeeLogger logger) {
+ this.logger = logger;
+ }
+
+ @Override
+ public void on() {
+ this.heating = true;
+ logger.log("~ ~ ~ heating ~ ~ ~");
+ }
+
+ @Override
+ public void off() {
+ this.heating = false;
+ }
+
+ @Override
+ public boolean isHot() {
+ return heating;
+ }
+}
diff --git a/examples/bazel/java/example/common/Heater.java b/examples/bazel/java/example/common/Heater.java
new file mode 100644
index 0000000..9f9df50
--- /dev/null
+++ b/examples/bazel/java/example/common/Heater.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package example.common;
+
+/** A heater to heat the coffee. */
+public interface Heater {
+ void on();
+ void off();
+ boolean isHot();
+}
diff --git a/examples/bazel/java/example/common/Pump.java b/examples/bazel/java/example/common/Pump.java
new file mode 100644
index 0000000..4a627cf
--- /dev/null
+++ b/examples/bazel/java/example/common/Pump.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package example.common;
+
+/** A pump to pump the coffee. */
+public interface Pump {
+ void pump();
+}
diff --git a/examples/bazel/java/example/common/Thermosiphon.java b/examples/bazel/java/example/common/Thermosiphon.java
new file mode 100644
index 0000000..6509c80
--- /dev/null
+++ b/examples/bazel/java/example/common/Thermosiphon.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package example.common;
+
+import javax.inject.Inject;
+
+/** A thermosiphon to pump the coffee. */
+public class Thermosiphon implements Pump {
+ private final CoffeeLogger logger;
+ private final Heater heater;
+
+ @Inject
+ Thermosiphon(CoffeeLogger logger, Heater heater) {
+ this.logger = logger;
+ this.heater = heater;
+ }
+
+ @Override
+ public void pump() {
+ if (heater.isHot()) {
+ logger.log("=> => pumping => =>");
+ }
+ }
+}
diff --git a/examples/bazel/java/example/dagger/BUILD b/examples/bazel/java/example/dagger/BUILD
new file mode 100644
index 0000000..7af63b9
--- /dev/null
+++ b/examples/bazel/java/example/dagger/BUILD
@@ -0,0 +1,23 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+java_binary(
+ name = "dagger",
+ srcs = glob(["*.java"]),
+ main_class = "dagger.coffee.CoffeeApp",
+ deps = [
+ "//:dagger",
+ "//java/example/common",
+ ],
+)
diff --git a/examples/bazel/java/example/dagger/CoffeeApp.java b/examples/bazel/java/example/dagger/CoffeeApp.java
new file mode 100644
index 0000000..624fdf7
--- /dev/null
+++ b/examples/bazel/java/example/dagger/CoffeeApp.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package example.dagger;
+
+import dagger.Component;
+import example.common.CoffeeLogger;
+import example.common.CoffeeMaker;
+import javax.inject.Singleton;
+
+/** The main app responsible for brewing the coffee and printing the logs. */
+public class CoffeeApp {
+ @Singleton
+ @Component(
+ modules = {
+ HeaterModule.class,
+ PumpModule.class
+ }
+ )
+ public interface CoffeeShop {
+ CoffeeMaker maker();
+ CoffeeLogger logger();
+ }
+
+ public static void main(String[] args) {
+ CoffeeShop coffeeShop = DaggerCoffeeApp_CoffeeShop.builder().build();
+ coffeeShop.maker().brew();
+ coffeeShop.logger().logs().forEach(log -> System.out.println(log));
+ }
+}
diff --git a/examples/bazel/java/example/dagger/HeaterModule.java b/examples/bazel/java/example/dagger/HeaterModule.java
new file mode 100644
index 0000000..0709222
--- /dev/null
+++ b/examples/bazel/java/example/dagger/HeaterModule.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package example.dagger;
+
+import dagger.Binds;
+import dagger.Module;
+import example.common.ElectricHeater;
+import example.common.Heater;
+import javax.inject.Singleton;
+
+@Module
+interface HeaterModule {
+ @Binds
+ @Singleton
+ Heater bindHeater(ElectricHeater impl);
+}
diff --git a/examples/bazel/java/example/dagger/PumpModule.java b/examples/bazel/java/example/dagger/PumpModule.java
new file mode 100644
index 0000000..3af7052
--- /dev/null
+++ b/examples/bazel/java/example/dagger/PumpModule.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package example.dagger;
+
+import dagger.Binds;
+import dagger.Module;
+import example.common.Pump;
+import example.common.Thermosiphon;
+
+@Module
+abstract class PumpModule {
+ @Binds
+ abstract Pump providePump(Thermosiphon pump);
+}
diff --git a/examples/bazel/java/example/hilt/AndroidManifest.xml b/examples/bazel/java/example/hilt/AndroidManifest.xml
new file mode 100644
index 0000000..a786737
--- /dev/null
+++ b/examples/bazel/java/example/hilt/AndroidManifest.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="example.hilt">
+
+ <uses-sdk android:minSdkVersion="15" android:targetSdkVersion="28"/>
+
+ <application android:name=".CoffeeApp">
+ </application>
+</manifest>
diff --git a/examples/bazel/java/example/hilt/BUILD b/examples/bazel/java/example/hilt/BUILD
new file mode 100644
index 0000000..e890401
--- /dev/null
+++ b/examples/bazel/java/example/hilt/BUILD
@@ -0,0 +1,48 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+android_binary(
+ name = "hilt",
+ srcs = ["CoffeeApp.java"],
+ manifest = "AndroidManifest.xml",
+ resource_files = glob(["res/**"]),
+ deps = [
+ ":heater_module",
+ ":pump_module",
+ "//:hilt-android",
+ "//java/example/common",
+ ],
+)
+
+android_library(
+ name = "heater_module",
+ srcs = ["HeaterModule.java"],
+ manifest = "AndroidManifest.xml",
+ visibility = ["//javatests/example/hilt:__pkg__"],
+ deps = [
+ "//:hilt-android",
+ "//java/example/common",
+ ],
+)
+
+android_library(
+ name = "pump_module",
+ srcs = ["PumpModule.java"],
+ manifest = "AndroidManifest.xml",
+ visibility = ["//javatests/example/hilt:__pkg__"],
+ deps = [
+ "//:hilt-android",
+ "//java/example/common",
+ ],
+)
diff --git a/examples/bazel/java/example/hilt/CoffeeApp.java b/examples/bazel/java/example/hilt/CoffeeApp.java
new file mode 100644
index 0000000..0ff7212
--- /dev/null
+++ b/examples/bazel/java/example/hilt/CoffeeApp.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package example.hilt;
+
+import android.app.Application;
+import dagger.hilt.android.HiltAndroidApp;
+import example.common.CoffeeLogger;
+import example.common.CoffeeMaker;
+import javax.inject.Inject;
+
+/** The main app responsible for brewing the coffee and printing the logs. */
+@HiltAndroidApp(Application.class)
+public class CoffeeApp extends Hilt_CoffeeApp {
+
+ @Inject CoffeeMaker maker;
+ @Inject CoffeeLogger logger;
+
+ @Override
+ public void onCreate() {
+ super.onCreate();
+ maker.brew();
+ logger.logs().forEach(log -> System.out.println(log));
+ }
+}
diff --git a/examples/bazel/java/example/hilt/HeaterModule.java b/examples/bazel/java/example/hilt/HeaterModule.java
new file mode 100644
index 0000000..122bec0
--- /dev/null
+++ b/examples/bazel/java/example/hilt/HeaterModule.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package example.hilt;
+
+import dagger.Binds;
+import dagger.Module;
+import dagger.hilt.InstallIn;
+import dagger.hilt.components.SingletonComponent;
+import example.common.ElectricHeater;
+import example.common.Heater;
+import javax.inject.Singleton;
+
+@Module
+@InstallIn(SingletonComponent.class)
+interface HeaterModule {
+ @Binds
+ @Singleton
+ Heater bindHeater(ElectricHeater impl);
+}
diff --git a/examples/bazel/java/example/hilt/PumpModule.java b/examples/bazel/java/example/hilt/PumpModule.java
new file mode 100644
index 0000000..0ad3903
--- /dev/null
+++ b/examples/bazel/java/example/hilt/PumpModule.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package example.hilt;
+
+import dagger.Binds;
+import dagger.Module;
+import dagger.hilt.InstallIn;
+import dagger.hilt.components.SingletonComponent;
+import example.common.Pump;
+import example.common.Thermosiphon;
+
+@Module
+@InstallIn(SingletonComponent.class)
+abstract class PumpModule {
+ @Binds
+ abstract Pump providePump(Thermosiphon pump);
+}
diff --git a/examples/bazel/javatests/example/hilt/BUILD b/examples/bazel/javatests/example/hilt/BUILD
new file mode 100644
index 0000000..9982fbd
--- /dev/null
+++ b/examples/bazel/javatests/example/hilt/BUILD
@@ -0,0 +1,55 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+android_local_test(
+ name = "CoffeeAppFakePumpTest",
+ srcs = [
+ "CoffeeAppFakePumpTest.java",
+ ],
+ manifest_values = {
+ "minSdkVersion": "15",
+ },
+ deps = [
+ "//:hilt-android-testing",
+ "//java/example/common",
+ "//java/example/hilt:heater_module",
+ "@maven//:androidx_test_ext_junit",
+ "@maven//:androidx_test_runner",
+ "@maven//:com_google_truth_truth",
+ "@maven//:org_robolectric_annotations",
+ "@maven//:org_robolectric_robolectric",
+ "@robolectric//bazel:android-all",
+ ],
+)
+
+android_local_test(
+ name = "CoffeeAppFakeHeaterTest",
+ srcs = [
+ "CoffeeAppFakeHeaterTest.java",
+ ],
+ manifest_values = {
+ "minSdkVersion": "15",
+ },
+ deps = [
+ "//:hilt-android-testing",
+ "//java/example/common",
+ "//java/example/hilt:pump_module",
+ "@maven//:androidx_test_ext_junit",
+ "@maven//:androidx_test_runner",
+ "@maven//:com_google_truth_truth",
+ "@maven//:org_robolectric_annotations",
+ "@maven//:org_robolectric_robolectric",
+ "@robolectric//bazel:android-all",
+ ],
+)
diff --git a/examples/bazel/javatests/example/hilt/CoffeeAppFakeHeaterTest.java b/examples/bazel/javatests/example/hilt/CoffeeAppFakeHeaterTest.java
new file mode 100644
index 0000000..5f4e162
--- /dev/null
+++ b/examples/bazel/javatests/example/hilt/CoffeeAppFakeHeaterTest.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package example.hilt;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.content.Context;
+import android.os.Build;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import dagger.hilt.android.testing.BindValue;
+import dagger.hilt.android.testing.HiltAndroidRule;
+import dagger.hilt.android.testing.HiltAndroidTest;
+import dagger.hilt.android.testing.HiltTestApplication;
+import example.common.CoffeeLogger;
+import example.common.CoffeeMaker;
+import example.common.Heater;
+import javax.inject.Inject;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.annotation.Config;
+
+/** Tests using a fake heater. */
+@HiltAndroidTest
+@Config(sdk = {Build.VERSION_CODES.P}, application = HiltTestApplication.class)
+@RunWith(AndroidJUnit4.class)
+public final class CoffeeAppFakeHeaterTest {
+ public @Rule HiltAndroidRule rule = new HiltAndroidRule(this);
+
+ final class FakeHeater implements Heater {
+ private boolean heating;
+
+ @Override
+ public void on() {
+ this.heating = true;
+ logger.log("~ ~ ~ fake heating ~ ~ ~");
+ }
+
+ @Override
+ public void off() {
+ this.heating = false;
+ }
+
+ @Override
+ public boolean isHot() {
+ return heating;
+ }
+ }
+
+ @Inject CoffeeMaker maker;
+ @Inject CoffeeLogger logger;
+
+ @BindValue Heater fakeHeater = new FakeHeater();
+
+ @Test
+ public void testApplicationClass() throws Exception {
+ assertThat((Context) ApplicationProvider.getApplicationContext())
+ .isInstanceOf(HiltTestApplication.class);
+ }
+
+ @Test
+ public void testLogs() throws Exception {
+ rule.inject();
+ assertThat(logger.logs()).isEmpty();
+ maker.brew();
+ assertThat(logger.logs())
+ .containsExactly(
+ "~ ~ ~ fake heating ~ ~ ~",
+ "=> => pumping => =>",
+ " [_]P coffee! [_]P ")
+ .inOrder();
+ }
+}
diff --git a/examples/bazel/javatests/example/hilt/CoffeeAppFakePumpTest.java b/examples/bazel/javatests/example/hilt/CoffeeAppFakePumpTest.java
new file mode 100644
index 0000000..6d89270
--- /dev/null
+++ b/examples/bazel/javatests/example/hilt/CoffeeAppFakePumpTest.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package example.hilt;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.content.Context;
+import android.os.Build;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import dagger.hilt.android.testing.BindValue;
+import dagger.hilt.android.testing.HiltAndroidRule;
+import dagger.hilt.android.testing.HiltAndroidTest;
+import dagger.hilt.android.testing.HiltTestApplication;
+import example.common.CoffeeLogger;
+import example.common.CoffeeMaker;
+import example.common.Pump;
+import javax.inject.Inject;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.annotation.Config;
+
+/** Tests using a fake pump. */
+@HiltAndroidTest
+@Config(sdk = {Build.VERSION_CODES.P}, application = HiltTestApplication.class)
+@RunWith(AndroidJUnit4.class)
+public final class CoffeeAppFakePumpTest {
+ public @Rule HiltAndroidRule rule = new HiltAndroidRule(this);
+
+ @Inject CoffeeMaker maker;
+ @Inject CoffeeLogger logger;
+
+ @BindValue Pump fakePump = () -> logger.log("=> => fake pumping => =>");
+
+ @Test
+ public void testApplicationClass() throws Exception {
+ assertThat((Context) ApplicationProvider.getApplicationContext())
+ .isInstanceOf(HiltTestApplication.class);
+ }
+
+ @Test
+ public void testLogs() throws Exception {
+ rule.inject();
+ assertThat(logger.logs()).isEmpty();
+ maker.brew();
+ assertThat(logger.logs())
+ .containsExactly(
+ "~ ~ ~ heating ~ ~ ~",
+ "=> => fake pumping => =>",
+ " [_]P coffee! [_]P ")
+ .inOrder();
+ }
+}
diff --git a/examples/maven/coffee/pom.xml b/examples/maven/coffee/pom.xml
new file mode 100644
index 0000000..a196d99
--- /dev/null
+++ b/examples/maven/coffee/pom.xml
@@ -0,0 +1,59 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright (C) 2012 The Dagger Authors.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>com.google.dagger.examples</groupId>
+ <artifactId>parent</artifactId>
+ <version>LOCAL-SNAPSHOT</version>
+ </parent>
+
+ <artifactId>coffee</artifactId>
+ <name>Examples: Coffee</name>
+
+ <dependencies>
+ <dependency>
+ <!-- Force the correct version of Guava to be on the classpath. -->
+ <groupId>com.google.guava</groupId>
+ <artifactId>guava</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>com.google.dagger</groupId>
+ <artifactId>dagger</artifactId>
+ </dependency>
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-compiler-plugin</artifactId>
+ <version>3.6.1</version>
+ <configuration>
+ <annotationProcessorPaths>
+ <path>
+ <groupId>com.google.dagger</groupId>
+ <artifactId>dagger-compiler</artifactId>
+ <version>${project.version}</version>
+ </path>
+ </annotationProcessorPaths>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+</project>
diff --git a/examples/maven/coffee/src/main/java/example/dagger/CoffeeApp.java b/examples/maven/coffee/src/main/java/example/dagger/CoffeeApp.java
new file mode 100644
index 0000000..723ab91
--- /dev/null
+++ b/examples/maven/coffee/src/main/java/example/dagger/CoffeeApp.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package example.dagger;
+
+import dagger.Component;
+import javax.inject.Singleton;
+
+/** The main app responsible for brewing the coffee and printing the logs. */
+public class CoffeeApp {
+ @Singleton
+ @Component(
+ modules = {
+ HeaterModule.class,
+ PumpModule.class
+ }
+ )
+ public interface CoffeeShop {
+ CoffeeMaker maker();
+ CoffeeLogger logger();
+ }
+
+ public static void main(String[] args) {
+ CoffeeShop coffeeShop = DaggerCoffeeApp_CoffeeShop.builder().build();
+ coffeeShop.maker().brew();
+ coffeeShop.logger().logs().forEach(log -> System.out.println(log));
+ }
+}
diff --git a/examples/maven/coffee/src/main/java/example/dagger/CoffeeLogger.java b/examples/maven/coffee/src/main/java/example/dagger/CoffeeLogger.java
new file mode 100644
index 0000000..16d2bdb
--- /dev/null
+++ b/examples/maven/coffee/src/main/java/example/dagger/CoffeeLogger.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package example.dagger;
+
+import java.util.ArrayList;
+import java.util.List;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+/** A logger to logs steps while brewing coffee. */
+@Singleton
+public final class CoffeeLogger {
+ private final List<String> logs = new ArrayList<>();
+
+ @Inject
+ CoffeeLogger() {}
+
+ public void log(String msg) {
+ logs.add(msg);
+ }
+
+ public List<String> logs() {
+ return new ArrayList<>(logs);
+ }
+}
diff --git a/examples/maven/coffee/src/main/java/example/dagger/CoffeeMaker.java b/examples/maven/coffee/src/main/java/example/dagger/CoffeeMaker.java
new file mode 100644
index 0000000..20c1f27
--- /dev/null
+++ b/examples/maven/coffee/src/main/java/example/dagger/CoffeeMaker.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package example.dagger;
+
+import dagger.Lazy;
+import javax.inject.Inject;
+
+/** A coffee maker to brew the coffee. */
+public class CoffeeMaker {
+ private final CoffeeLogger logger;
+ private final Lazy<Heater> heater; // Create a possibly costly heater only when we use it.
+ private final Pump pump;
+
+ @Inject
+ CoffeeMaker(CoffeeLogger logger, Lazy<Heater> heater, Pump pump) {
+ this.logger = logger;
+ this.heater = heater;
+ this.pump = pump;
+ }
+
+ public void brew() {
+ heater.get().on();
+ pump.pump();
+ logger.log(" [_]P coffee! [_]P ");
+ heater.get().off();
+ }
+}
diff --git a/examples/maven/coffee/src/main/java/example/dagger/ElectricHeater.java b/examples/maven/coffee/src/main/java/example/dagger/ElectricHeater.java
new file mode 100644
index 0000000..567c7aa
--- /dev/null
+++ b/examples/maven/coffee/src/main/java/example/dagger/ElectricHeater.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package example.dagger;
+
+import javax.inject.Inject;
+
+/** An electric heater to heat the coffee. */
+public class ElectricHeater implements Heater {
+
+ private final CoffeeLogger logger;
+ private boolean heating;
+
+ @Inject
+ ElectricHeater(CoffeeLogger logger) {
+ this.logger = logger;
+ }
+
+ @Override
+ public void on() {
+ this.heating = true;
+ logger.log("~ ~ ~ heating ~ ~ ~");
+ }
+
+ @Override
+ public void off() {
+ this.heating = false;
+ }
+
+ @Override
+ public boolean isHot() {
+ return heating;
+ }
+}
diff --git a/examples/maven/coffee/src/main/java/example/dagger/Heater.java b/examples/maven/coffee/src/main/java/example/dagger/Heater.java
new file mode 100644
index 0000000..3d6d1f2
--- /dev/null
+++ b/examples/maven/coffee/src/main/java/example/dagger/Heater.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package example.dagger;
+
+/** A heater to heat the coffee. */
+public interface Heater {
+ void on();
+ void off();
+ boolean isHot();
+}
diff --git a/examples/maven/coffee/src/main/java/example/dagger/HeaterModule.java b/examples/maven/coffee/src/main/java/example/dagger/HeaterModule.java
new file mode 100644
index 0000000..fb8c969
--- /dev/null
+++ b/examples/maven/coffee/src/main/java/example/dagger/HeaterModule.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package example.dagger;
+
+import dagger.Binds;
+import dagger.Module;
+import javax.inject.Singleton;
+
+@Module
+interface HeaterModule {
+ @Binds
+ @Singleton
+ Heater bindHeater(ElectricHeater impl);
+}
diff --git a/examples/maven/coffee/src/main/java/example/dagger/Pump.java b/examples/maven/coffee/src/main/java/example/dagger/Pump.java
new file mode 100644
index 0000000..712b21c
--- /dev/null
+++ b/examples/maven/coffee/src/main/java/example/dagger/Pump.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package example.dagger;
+
+/** A pump to pump the coffee. */
+public interface Pump {
+ void pump();
+}
diff --git a/examples/maven/coffee/src/main/java/example/dagger/PumpModule.java b/examples/maven/coffee/src/main/java/example/dagger/PumpModule.java
new file mode 100644
index 0000000..202fed3
--- /dev/null
+++ b/examples/maven/coffee/src/main/java/example/dagger/PumpModule.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package example.dagger;
+
+import dagger.Binds;
+import dagger.Module;
+
+@Module
+abstract class PumpModule {
+ @Binds
+ abstract Pump providePump(Thermosiphon pump);
+}
diff --git a/examples/maven/coffee/src/main/java/example/dagger/Thermosiphon.java b/examples/maven/coffee/src/main/java/example/dagger/Thermosiphon.java
new file mode 100644
index 0000000..d94c33f
--- /dev/null
+++ b/examples/maven/coffee/src/main/java/example/dagger/Thermosiphon.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package example.dagger;
+
+import javax.inject.Inject;
+
+/** A thermosiphon to pump the coffee. */
+public class Thermosiphon implements Pump {
+ private final CoffeeLogger logger;
+ private final Heater heater;
+
+ @Inject
+ Thermosiphon(CoffeeLogger logger, Heater heater) {
+ this.logger = logger;
+ this.heater = heater;
+ }
+
+ @Override
+ public void pump() {
+ if (heater.isHot()) {
+ logger.log("=> => pumping => =>");
+ }
+ }
+}
diff --git a/examples/maven/pom.xml b/examples/maven/pom.xml
new file mode 100644
index 0000000..be21b96
--- /dev/null
+++ b/examples/maven/pom.xml
@@ -0,0 +1,70 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright (C) 2013 The Dagger Authors.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.sonatype.oss</groupId>
+ <artifactId>oss-parent</artifactId>
+ <version>9</version>
+ </parent>
+
+ <groupId>com.google.dagger.examples</groupId>
+ <artifactId>parent</artifactId>
+ <packaging>pom</packaging>
+ <name>Examples</name>
+ <version>LOCAL-SNAPSHOT</version>
+
+ <modules>
+ <module>coffee</module>
+ </modules>
+
+ <!-- Example-only dependencies. -->
+ <dependencyManagement>
+ <dependencies>
+ <dependency>
+ <groupId>com.google.dagger</groupId>
+ <artifactId>dagger</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>com.google.dagger</groupId>
+ <artifactId>dagger-compiler</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>com.google.guava</groupId>
+ <artifactId>guava</artifactId>
+ <version>26.0-jre</version>
+ </dependency>
+ </dependencies>
+ </dependencyManagement>
+
+ <build>
+ <pluginManagement>
+ <plugins>
+ <plugin>
+ <artifactId>maven-compiler-plugin</artifactId>
+ <configuration>
+ <source>1.8</source>
+ <target>1.8</target>
+ </configuration>
+ </plugin>
+ </plugins>
+ </pluginManagement>
+ </build>
+</project>
diff --git a/examples/pom.xml b/examples/pom.xml
deleted file mode 100644
index c12050d..0000000
--- a/examples/pom.xml
+++ /dev/null
@@ -1,70 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
- Copyright (C) 2013 The Dagger Authors.
-
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
--->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
- <modelVersion>4.0.0</modelVersion>
-
- <parent>
- <groupId>org.sonatype.oss</groupId>
- <artifactId>oss-parent</artifactId>
- <version>9</version>
- </parent>
-
- <groupId>com.google.dagger.example</groupId>
- <artifactId>dagger-example-parent</artifactId>
- <packaging>pom</packaging>
- <name>Examples</name>
- <version>2.17</version>
-
- <modules>
- <module>simple</module>
- </modules>
-
- <!-- Example-only dependencies. -->
- <dependencyManagement>
- <dependencies>
- <dependency>
- <groupId>com.google.dagger</groupId>
- <artifactId>dagger</artifactId>
- <version>${project.version}</version>
- </dependency>
- <dependency>
- <groupId>com.google.dagger</groupId>
- <artifactId>dagger-compiler</artifactId>
- <version>${project.version}</version>
- </dependency>
- <dependency>
- <groupId>com.google.guava</groupId>
- <artifactId>guava</artifactId>
- <version>26.0-jre</version>
- </dependency>
- </dependencies>
- </dependencyManagement>
-
- <build>
- <pluginManagement>
- <plugins>
- <plugin>
- <artifactId>maven-compiler-plugin</artifactId>
- <configuration>
- <source>1.6</source>
- <target>1.6</target>
- </configuration>
- </plugin>
- </plugins>
- </pluginManagement>
- </build>
-</project>
diff --git a/examples/simple/pom.xml b/examples/simple/pom.xml
deleted file mode 100644
index ffc99dc..0000000
--- a/examples/simple/pom.xml
+++ /dev/null
@@ -1,59 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
- Copyright (C) 2012 The Dagger Authors.
-
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
--->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
- <modelVersion>4.0.0</modelVersion>
-
- <parent>
- <groupId>com.google.dagger.example</groupId>
- <artifactId>dagger-example-parent</artifactId>
- <version>2.17</version>
- </parent>
-
- <artifactId>simple</artifactId>
- <name>Examples: Simple</name>
-
- <dependencies>
- <dependency>
- <!-- Force the correct version of Guava to be on the classpath. -->
- <groupId>com.google.guava</groupId>
- <artifactId>guava</artifactId>
- </dependency>
- <dependency>
- <groupId>com.google.dagger</groupId>
- <artifactId>dagger</artifactId>
- </dependency>
- </dependencies>
-
- <build>
- <plugins>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-compiler-plugin</artifactId>
- <version>3.6.1</version>
- <configuration>
- <annotationProcessorPaths>
- <path>
- <groupId>com.google.dagger</groupId>
- <artifactId>dagger-compiler</artifactId>
- <version>${project.version}</version>
- </path>
- </annotationProcessorPaths>
- </configuration>
- </plugin>
- </plugins>
- </build>
-</project>
diff --git a/examples/simple/src/main/java/coffee/CoffeeApp.java b/examples/simple/src/main/java/coffee/CoffeeApp.java
deleted file mode 100644
index 7a2b9a6..0000000
--- a/examples/simple/src/main/java/coffee/CoffeeApp.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package coffee;
-
-import dagger.Component;
-import javax.inject.Singleton;
-
-public class CoffeeApp {
- @Singleton
- @Component(modules = { DripCoffeeModule.class })
- public interface CoffeeShop {
- CoffeeMaker maker();
- }
-
- public static void main(String[] args) {
- CoffeeShop coffeeShop = DaggerCoffeeApp_CoffeeShop.builder().build();
- coffeeShop.maker().brew();
- }
-}
diff --git a/examples/simple/src/main/java/coffee/CoffeeMaker.java b/examples/simple/src/main/java/coffee/CoffeeMaker.java
deleted file mode 100644
index 6410336..0000000
--- a/examples/simple/src/main/java/coffee/CoffeeMaker.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package coffee;
-
-import dagger.Lazy;
-import javax.inject.Inject;
-
-class CoffeeMaker {
- private final Lazy<Heater> heater; // Create a possibly costly heater only when we use it.
- private final Pump pump;
-
- @Inject CoffeeMaker(Lazy<Heater> heater, Pump pump) {
- this.heater = heater;
- this.pump = pump;
- }
-
- public void brew() {
- heater.get().on();
- pump.pump();
- System.out.println(" [_]P coffee! [_]P ");
- heater.get().off();
- }
-}
diff --git a/examples/simple/src/main/java/coffee/DripCoffeeModule.java b/examples/simple/src/main/java/coffee/DripCoffeeModule.java
deleted file mode 100644
index e50d249..0000000
--- a/examples/simple/src/main/java/coffee/DripCoffeeModule.java
+++ /dev/null
@@ -1,12 +0,0 @@
-package coffee;
-
-import dagger.Module;
-import dagger.Provides;
-import javax.inject.Singleton;
-
-@Module(includes = PumpModule.class)
-class DripCoffeeModule {
- @Provides @Singleton Heater provideHeater() {
- return new ElectricHeater();
- }
-}
diff --git a/examples/simple/src/main/java/coffee/ElectricHeater.java b/examples/simple/src/main/java/coffee/ElectricHeater.java
deleted file mode 100644
index fbab399..0000000
--- a/examples/simple/src/main/java/coffee/ElectricHeater.java
+++ /dev/null
@@ -1,18 +0,0 @@
-package coffee;
-
-class ElectricHeater implements Heater {
- boolean heating;
-
- @Override public void on() {
- System.out.println("~ ~ ~ heating ~ ~ ~");
- this.heating = true;
- }
-
- @Override public void off() {
- this.heating = false;
- }
-
- @Override public boolean isHot() {
- return heating;
- }
-}
diff --git a/examples/simple/src/main/java/coffee/Heater.java b/examples/simple/src/main/java/coffee/Heater.java
deleted file mode 100644
index b5ddb6b..0000000
--- a/examples/simple/src/main/java/coffee/Heater.java
+++ /dev/null
@@ -1,7 +0,0 @@
-package coffee;
-
-interface Heater {
- void on();
- void off();
- boolean isHot();
-}
diff --git a/examples/simple/src/main/java/coffee/Pump.java b/examples/simple/src/main/java/coffee/Pump.java
deleted file mode 100644
index e394349..0000000
--- a/examples/simple/src/main/java/coffee/Pump.java
+++ /dev/null
@@ -1,5 +0,0 @@
-package coffee;
-
-interface Pump {
- void pump();
-}
diff --git a/examples/simple/src/main/java/coffee/PumpModule.java b/examples/simple/src/main/java/coffee/PumpModule.java
deleted file mode 100644
index df00b86..0000000
--- a/examples/simple/src/main/java/coffee/PumpModule.java
+++ /dev/null
@@ -1,10 +0,0 @@
-package coffee;
-
-import dagger.Binds;
-import dagger.Module;
-
-@Module
-abstract class PumpModule {
- @Binds
- abstract Pump providePump(Thermosiphon pump);
-}
diff --git a/examples/simple/src/main/java/coffee/Thermosiphon.java b/examples/simple/src/main/java/coffee/Thermosiphon.java
deleted file mode 100644
index c9f9828..0000000
--- a/examples/simple/src/main/java/coffee/Thermosiphon.java
+++ /dev/null
@@ -1,18 +0,0 @@
-package coffee;
-
-import javax.inject.Inject;
-
-class Thermosiphon implements Pump {
- private final Heater heater;
-
- @Inject
- Thermosiphon(Heater heater) {
- this.heater = heater;
- }
-
- @Override public void pump() {
- if (heater.isHot()) {
- System.out.println("=> => pumping => =>");
- }
- }
-}
diff --git a/gwt/BUILD b/gwt/BUILD
index da73013..5aa9110 100644
--- a/gwt/BUILD
+++ b/gwt/BUILD
@@ -15,9 +15,11 @@
# Description:
# GWT-specific files for Dagger
-package(default_visibility = ["//:src"])
+load("@rules_java//java:defs.bzl", "java_library")
+load("//tools:maven.bzl", "pom_file")
+load("//:build_defs.bzl", "POM_VERSION")
-load("//tools:maven.bzl", "pom_file", "POM_VERSION")
+package(default_visibility = ["//:src"])
java_library(
name = "gwt",
diff --git a/java/dagger/BUILD b/java/dagger/BUILD
index 3485431..aaebade 100644
--- a/java/dagger/BUILD
+++ b/java/dagger/BUILD
@@ -15,14 +15,17 @@
# Description:
# A JSR-330 compliant dependency injection system for android and java
-package(default_visibility = ["//:src"])
-
+load("@rules_java//java:defs.bzl", "java_library")
load(
"//:build_defs.bzl",
"DOCLINT_HTML_AND_SYNTAX",
+ "POM_VERSION",
"SOURCE_7_TARGET_7",
)
-load("//tools:maven.bzl", "POM_VERSION", "pom_file")
+load("//tools:maven.bzl", "pom_file")
+load("@google_bazel_common//tools/javadoc:javadoc.bzl", "javadoc_library")
+
+package(default_visibility = ["//:src"])
java_library(
name = "core",
@@ -47,8 +50,6 @@
srcs = glob(["**/*"]),
)
-load("@google_bazel_common//tools/javadoc:javadoc.bzl", "javadoc_library")
-
javadoc_library(
name = "core-javadoc",
srcs = [":javadoc-srcs"],
diff --git a/java/dagger/Provides.java b/java/dagger/Provides.java
index a60be3b..5d7827b 100644
--- a/java/dagger/Provides.java
+++ b/java/dagger/Provides.java
@@ -30,11 +30,11 @@
*
* <h3>Nullability</h3>
*
- * <p>Dagger forbids injecting {@code null} by default. Component implemenations that invoke
+ * <p>Dagger forbids injecting {@code null} by default. Component implementations that invoke
* {@code @Provides} methods that return {@code null} will throw a {@link NullPointerException}
* immediately thereafter. {@code @Provides} methods may opt into allowing {@code null} by
* annotating the method with any {@code @Nullable} annotation like
- * {@code javax.annotation.Nullable} or {@code android.support.annotation.Nullable}.
+ * {@code javax.annotation.Nullable} or {@code androidx.annotation.Nullable}.
*
* <p>If a {@code @Provides} method is marked {@code @Nullable}, Dagger will <em>only</em>
* allow injection into sites that are marked {@code @Nullable} as well. A component that
diff --git a/java/dagger/android/AndroidInjection.java b/java/dagger/android/AndroidInjection.java
index 2f4fb4c..f3296c6 100644
--- a/java/dagger/android/AndroidInjection.java
+++ b/java/dagger/android/AndroidInjection.java
@@ -1,4 +1,4 @@
- /*
+/*
* Copyright (C) 2017 The Dagger Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
@@ -39,99 +39,71 @@
* otherwise throws an {@link IllegalArgumentException}.
*
* @throws RuntimeException if the {@link Application} doesn't implement {@link
- * HasAndroidInjector} or {@link HasActivityInjector}.
+ * HasAndroidInjector}.
*/
public static void inject(Activity activity) {
checkNotNull(activity, "activity");
Application application = activity.getApplication();
- AndroidInjector<? super Activity> injector;
- if (application instanceof HasAndroidInjector) {
- injector = ((HasAndroidInjector) application).androidInjector();
- checkNotNull(injector, "%s.androidInjector() returned null", application.getClass());
- } else if (application instanceof HasActivityInjector) {
- injector = ((HasActivityInjector) application).activityInjector();
- checkNotNull(injector, "%s.activityInjector() returned null", application.getClass());
- } else {
+ if (!(application instanceof HasAndroidInjector)) {
throw new RuntimeException(
String.format(
- "%s does not implement %s or %s",
+ "%s does not implement %s",
application.getClass().getCanonicalName(),
- HasAndroidInjector.class.getCanonicalName(),
- HasActivityInjector.class.getCanonicalName()));
+ HasAndroidInjector.class.getCanonicalName()));
}
- injector.inject(activity);
+ inject(activity, (HasAndroidInjector) application);
}
/**
* Injects {@code fragment} if an associated {@link AndroidInjector} implementation can be found,
* otherwise throws an {@link IllegalArgumentException}.
*
- * <p>Uses the following algorithm to find the appropriate {@link AndroidInjector} to use to
- * inject {@code fragment}:
+ * <p>Uses the following algorithm to find the appropriate {@code AndroidInjector<Fragment>} to
+ * use to inject {@code fragment}:
*
* <ol>
- * <li>Walks the parent-fragment hierarchy to find a fragment that implements {@link
- * HasAndroidInjector} or {@link HasFragmentInjector}, and if none do
+ * <li>Walks the parent-fragment hierarchy to find the a fragment that implements {@link
+ * HasAndroidInjector}, and if none do
* <li>Uses the {@code fragment}'s {@link Fragment#getActivity() activity} if it implements
- * {@link HasAndroidInjector} or {@link HasFragmentInjector}, and if not
- * <li>Uses the {@link android.app.Application} if it implements {@link HasAndroidInjector}
- * {@link HasFragmentInjector}.
+ * {@link HasAndroidInjector}, and if not
+ * <li>Uses the {@link android.app.Application} if it implements {@link HasAndroidInjector}.
* </ol>
*
- * If none of them implement {@link HasAndroidInjector} or {@link HasFragmentInjector}, a {@link
- * IllegalArgumentException} is thrown.
+ * If none of them implement {@link HasAndroidInjector}, a {@link IllegalArgumentException} is
+ * thrown.
*
* @throws IllegalArgumentException if no parent fragment, activity, or application implements
- * {@link HasAndroidInjector} or {@link HasFragmentInjector}.
+ * {@link HasAndroidInjector}.
*/
public static void inject(Fragment fragment) {
checkNotNull(fragment, "fragment");
-
- Object hasInjector = findHasFragmentInjector(fragment);
- AndroidInjector<? super Fragment> injector;
- if (hasInjector instanceof HasAndroidInjector) {
- injector = ((HasAndroidInjector) hasInjector).androidInjector();
- checkNotNull(injector, "%s.androidInjector() returned null", hasInjector.getClass());
- } else if (hasInjector instanceof HasFragmentInjector) {
- injector = ((HasFragmentInjector) hasInjector).fragmentInjector();
- checkNotNull(injector, "%s.fragmentInjector() returned null", hasInjector.getClass());
- } else {
- throw new RuntimeException(
- String.format(
- "%s does not implement %s or %s",
- hasInjector.getClass().getCanonicalName(),
- HasAndroidInjector.class.getCanonicalName(),
- HasFragmentInjector.class.getCanonicalName()));
- }
-
+ HasAndroidInjector hasAndroidInjector = findHasAndroidInjectorForFragment(fragment);
if (Log.isLoggable(TAG, DEBUG)) {
Log.d(
TAG,
String.format(
"An injector for %s was found in %s",
fragment.getClass().getCanonicalName(),
- hasInjector.getClass().getCanonicalName()));
+ hasAndroidInjector.getClass().getCanonicalName()));
}
- injector.inject(fragment);
+ inject(fragment, hasAndroidInjector);
}
- private static Object findHasFragmentInjector(Fragment fragment) {
+ private static HasAndroidInjector findHasAndroidInjectorForFragment(Fragment fragment) {
Fragment parentFragment = fragment;
while ((parentFragment = parentFragment.getParentFragment()) != null) {
- if (parentFragment instanceof HasAndroidInjector
- || parentFragment instanceof HasFragmentInjector) {
- return parentFragment;
+ if (parentFragment instanceof HasAndroidInjector) {
+ return (HasAndroidInjector) parentFragment;
}
}
Activity activity = fragment.getActivity();
- if (activity instanceof HasAndroidInjector || activity instanceof HasFragmentInjector) {
- return activity;
+ if (activity instanceof HasAndroidInjector) {
+ return (HasAndroidInjector) activity;
}
- Application application = activity.getApplication();
- if (application instanceof HasAndroidInjector || application instanceof HasFragmentInjector) {
- return application;
+ if (activity.getApplication() instanceof HasAndroidInjector) {
+ return (HasAndroidInjector) activity.getApplication();
}
throw new IllegalArgumentException(
String.format("No injector was found for %s", fragment.getClass().getCanonicalName()));
@@ -142,28 +114,20 @@
* otherwise throws an {@link IllegalArgumentException}.
*
* @throws RuntimeException if the {@link Application} doesn't implement {@link
- * HasAndroidInjector} or {@link HasServiceInjector}.
+ * HasAndroidInjector}.
*/
public static void inject(Service service) {
checkNotNull(service, "service");
Application application = service.getApplication();
- AndroidInjector<? super Service> injector;
- if (application instanceof HasAndroidInjector) {
- injector = ((HasAndroidInjector) application).androidInjector();
- checkNotNull(injector, "%s.androidInjector() returned null", application.getClass());
- } else if (application instanceof HasServiceInjector) {
- injector = ((HasServiceInjector) application).serviceInjector();
- checkNotNull(injector, "%s.serviceInjector() returned null", application.getClass());
- } else {
+ if (!(application instanceof HasAndroidInjector)) {
throw new RuntimeException(
String.format(
- "%s does not implement %s or %s",
+ "%s does not implement %s",
application.getClass().getCanonicalName(),
- HasAndroidInjector.class.getCanonicalName(),
- HasServiceInjector.class.getCanonicalName()));
+ HasAndroidInjector.class.getCanonicalName()));
}
- injector.inject(service);
+ inject(service, (HasAndroidInjector) application);
}
/**
@@ -171,32 +135,21 @@
* be found, otherwise throws an {@link IllegalArgumentException}.
*
* @throws RuntimeException if the {@link Application} from {@link
- * Context#getApplicationContext()} doesn't implement {@link HasAndroidInjector} or {@link
- * HasBroadcastReceiverInjector}.
+ * Context#getApplicationContext()} doesn't implement {@link HasAndroidInjector}.
*/
public static void inject(BroadcastReceiver broadcastReceiver, Context context) {
checkNotNull(broadcastReceiver, "broadcastReceiver");
checkNotNull(context, "context");
-
Application application = (Application) context.getApplicationContext();
- AndroidInjector<? super BroadcastReceiver> injector;
- if (application instanceof HasAndroidInjector) {
- injector = ((HasAndroidInjector) application).androidInjector();
- checkNotNull(injector, "%s.androidInjector() returned null", application.getClass());
- } else if (application instanceof HasBroadcastReceiverInjector) {
- injector = ((HasBroadcastReceiverInjector) application).broadcastReceiverInjector();
- checkNotNull(
- injector, "%s.broadcastReceiverInjector() returned null", application.getClass());
- } else {
+ if (!(application instanceof HasAndroidInjector)) {
throw new RuntimeException(
String.format(
- "%s does not implement %s or %s",
+ "%s does not implement %s",
application.getClass().getCanonicalName(),
- HasAndroidInjector.class.getCanonicalName(),
- HasBroadcastReceiverInjector.class.getCanonicalName()));
+ HasAndroidInjector.class.getCanonicalName()));
}
- injector.inject(broadcastReceiver);
+ inject(broadcastReceiver, (HasAndroidInjector) application);
}
/**
@@ -204,29 +157,28 @@
* found, otherwise throws an {@link IllegalArgumentException}.
*
* @throws RuntimeException if the {@link Application} doesn't implement {@link
- * HasAndroidInjector} or {@link HasContentProviderInjector}.
+ * HasAndroidInjector}.
*/
public static void inject(ContentProvider contentProvider) {
checkNotNull(contentProvider, "contentProvider");
Application application = (Application) contentProvider.getContext().getApplicationContext();
-
- AndroidInjector<? super ContentProvider> injector;
- if (application instanceof HasAndroidInjector) {
- injector = ((HasAndroidInjector) application).androidInjector();
- checkNotNull(injector, "%s.androidInjector() returned null", application.getClass());
- } else if (application instanceof HasContentProviderInjector) {
- injector = ((HasContentProviderInjector) application).contentProviderInjector();
- checkNotNull(injector, "%s.contentProviderInjector() returned null", application.getClass());
- } else {
+ if (!(application instanceof HasAndroidInjector)) {
throw new RuntimeException(
String.format(
- "%s does not implement %s or %s",
+ "%s does not implement %s",
application.getClass().getCanonicalName(),
- HasAndroidInjector.class.getCanonicalName(),
- HasBroadcastReceiverInjector.class.getCanonicalName()));
+ HasAndroidInjector.class.getCanonicalName()));
}
- injector.inject(contentProvider);
+ inject(contentProvider, (HasAndroidInjector) application);
+ }
+
+ private static void inject(Object target, HasAndroidInjector hasAndroidInjector) {
+ AndroidInjector<Object> androidInjector = hasAndroidInjector.androidInjector();
+ checkNotNull(
+ androidInjector, "%s.androidInjector() returned null", hasAndroidInjector.getClass());
+
+ androidInjector.inject(target);
}
private AndroidInjection() {}
diff --git a/java/dagger/android/AndroidInjectionKey.java b/java/dagger/android/AndroidInjectionKey.java
index d4a5d72..ff4a1f6 100644
--- a/java/dagger/android/AndroidInjectionKey.java
+++ b/java/dagger/android/AndroidInjectionKey.java
@@ -28,11 +28,7 @@
* #value() value} of the annotation is the canonical name of the class that will be passed to
* {@link AndroidInjector#inject(Object)}.
*
- * <p>All key strings will be obfuscated by ProGuard/R8/AppReduce if the named class is obfuscated.
- *
- * <p>
- * You should only use this annotation if you are using a version of ProGuard/R8/AppReduce that
- * supports the {@code -identifiernamestring} flag.
+ * <p>All key strings will be obfuscated by ProGuard/R8 if the named class is obfuscated.
*/
@Beta
@MapKey
diff --git a/java/dagger/android/BUILD b/java/dagger/android/BUILD
index a88d16e..f0cea41 100644
--- a/java/dagger/android/BUILD
+++ b/java/dagger/android/BUILD
@@ -15,15 +15,18 @@
# Description:
# Public Dagger API for Android
-package(default_visibility = ["//:src"])
-
load(
"//:build_defs.bzl",
"DOCLINT_HTML_AND_SYNTAX",
"DOCLINT_REFERENCES",
+ "POM_VERSION",
"SOURCE_7_TARGET_7",
)
-load("//tools:maven.bzl", "POM_VERSION", "pom_file")
+load("//tools:dejetify.bzl", "dejetified_library")
+load("//tools:maven.bzl", "pom_file")
+load("@google_bazel_common//tools/javadoc:javadoc.bzl", "javadoc_library")
+
+package(default_visibility = ["//:src"])
# Work around b/70476182 which prevents Kythe from connecting :producers to the .java files it
# contains.
@@ -42,24 +45,18 @@
srcs = SRCS,
javacopts = SOURCE_7_TARGET_7 + DOCLINT_HTML_AND_SYNTAX + DOCLINT_REFERENCES,
manifest = "AndroidManifest.xml",
- proguard_specs = ["proguard.cfg"],
+ plugins = [
+ "//java/dagger/android/internal/proguard:plugin",
+ ],
tags = ["maven_coordinates=com.google.dagger:dagger-android:" + POM_VERSION],
+ exports = [
+ "//java/dagger/lint:lint-android-artifact-lib",
+ ],
deps = [
- ":manual-maven-deps",
"//:dagger_with_compiler",
"@google_bazel_common//third_party/java/auto:value",
"@google_bazel_common//third_party/java/error_prone:annotations",
- ],
-)
-
-# Our pom.xml generator does not have a way to add manual maven deps. This target exports the
-# targets that don't have the necessary maven_coordinates tags.
-android_library(
- name = "manual-maven-deps",
- tags = ["maven_coordinates=com.android.support:support-annotations:25.0.0"],
- visibility = ["//visibility:private"],
- exports = [
- "@androidsdk//com.android.support:support-annotations-25.0.0",
+ "@maven//:androidx_annotation_annotation",
],
)
@@ -79,12 +76,35 @@
targets = [":android"],
)
-load("@google_bazel_common//tools/javadoc:javadoc.bzl", "javadoc_library")
+dejetified_library(
+ name = "dejetified-android",
+ input = ":android.aar",
+ output = "android-legacy.aar",
+)
+
+android_library(
+ name = "legacy-deps",
+ tags = ["maven_coordinates=com.google.dagger:dagger-android-legacy:" + POM_VERSION],
+ exports = [
+ "//:dagger_with_compiler",
+ "@google_bazel_common//third_party/java/auto:value",
+ "@google_bazel_common//third_party/java/error_prone:annotations",
+ "@maven//:com_android_support_support_annotations",
+ ],
+)
+
+pom_file(
+ name = "legacy-pom",
+ artifact_id = "dagger-android-legacy",
+ artifact_name = "Dagger Android Legacy",
+ packaging = "aar",
+ targets = [":legacy-deps"],
+)
javadoc_library(
name = "android-javadoc",
srcs = [":android-srcs"],
- android_api_level = 26,
+ android_api_level = 30,
exclude_packages = ["dagger.android.internal"],
root_packages = ["dagger.android"],
deps = [":android"],
diff --git a/java/dagger/android/DaggerActivity.java b/java/dagger/android/DaggerActivity.java
index 43708f3..9f37223 100644
--- a/java/dagger/android/DaggerActivity.java
+++ b/java/dagger/android/DaggerActivity.java
@@ -19,7 +19,7 @@
import android.app.Activity;
import android.app.Fragment;
import android.os.Bundle;
-import android.support.annotation.Nullable;
+import androidx.annotation.Nullable;
import dagger.internal.Beta;
import javax.inject.Inject;
diff --git a/java/dagger/android/DaggerBroadcastReceiver.java b/java/dagger/android/DaggerBroadcastReceiver.java
index d39aa86..2efd724 100644
--- a/java/dagger/android/DaggerBroadcastReceiver.java
+++ b/java/dagger/android/DaggerBroadcastReceiver.java
@@ -19,7 +19,7 @@
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
-import android.support.annotation.CallSuper;
+import androidx.annotation.CallSuper;
import dagger.internal.Beta;
/**
diff --git a/java/dagger/android/DaggerContentProvider.java b/java/dagger/android/DaggerContentProvider.java
index 4aad485..e1d3f54 100644
--- a/java/dagger/android/DaggerContentProvider.java
+++ b/java/dagger/android/DaggerContentProvider.java
@@ -17,7 +17,7 @@
package dagger.android;
import android.content.ContentProvider;
-import android.support.annotation.CallSuper;
+import androidx.annotation.CallSuper;
import dagger.internal.Beta;
/** A {@link ContentProvider} that injects its members in {@link #onCreate()}. */
diff --git a/java/dagger/android/HasActivityInjector.java b/java/dagger/android/HasActivityInjector.java
deleted file mode 100644
index 136bbad..0000000
--- a/java/dagger/android/HasActivityInjector.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.android;
-
-import android.app.Activity;
-import dagger.internal.Beta;
-
-/** Provides an {@link AndroidInjector} of {@link Activity}s. */
-@Beta
-public interface HasActivityInjector {
-
- /** Returns an {@link AndroidInjector} of {@link Activity}s. */
- AndroidInjector<Activity> activityInjector();
-}
diff --git a/java/dagger/android/HasBroadcastReceiverInjector.java b/java/dagger/android/HasBroadcastReceiverInjector.java
deleted file mode 100644
index b2aa992..0000000
--- a/java/dagger/android/HasBroadcastReceiverInjector.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.android;
-
-import android.content.BroadcastReceiver;
-import dagger.internal.Beta;
-
-/** Provides an {@link AndroidInjector} of {@link BroadcastReceiver}s. */
-@Beta
-public interface HasBroadcastReceiverInjector {
-
- /** Returns an {@link AndroidInjector} of {@link BroadcastReceiver}s. */
- AndroidInjector<BroadcastReceiver> broadcastReceiverInjector();
-}
diff --git a/java/dagger/android/HasContentProviderInjector.java b/java/dagger/android/HasContentProviderInjector.java
deleted file mode 100644
index 997ddb8..0000000
--- a/java/dagger/android/HasContentProviderInjector.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.android;
-
-import android.content.ContentProvider;
-import dagger.internal.Beta;
-
-/** Provides an {@link AndroidInjector} of {@link ContentProvider}s. */
-@Beta
-public interface HasContentProviderInjector {
-
- /** Returns an {@link AndroidInjector} of {@link ContentProvider}s. */
- AndroidInjector<ContentProvider> contentProviderInjector();
-}
diff --git a/java/dagger/android/HasFragmentInjector.java b/java/dagger/android/HasFragmentInjector.java
deleted file mode 100644
index 564f32d..0000000
--- a/java/dagger/android/HasFragmentInjector.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.android;
-
-import android.app.Fragment;
-import dagger.internal.Beta;
-
-/** Provides an {@link AndroidInjector} of {@link Fragment}s. */
-@Beta
-public interface HasFragmentInjector {
-
- /** Returns an {@link AndroidInjector} of {@link Fragment}s. */
- AndroidInjector<Fragment> fragmentInjector();
-}
diff --git a/java/dagger/android/HasServiceInjector.java b/java/dagger/android/HasServiceInjector.java
deleted file mode 100644
index d1c6a6c..0000000
--- a/java/dagger/android/HasServiceInjector.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.android;
-
-import android.app.Service;
-import dagger.internal.Beta;
-
-/** Provides an {@link AndroidInjector} of {@link Service}s. */
-@Beta
-public interface HasServiceInjector {
-
- /** Returns an {@link AndroidInjector} of {@link Service}s. */
- AndroidInjector<Service> serviceInjector();
-}
diff --git a/java/dagger/android/internal/AndroidInjectionKeys.java b/java/dagger/android/internal/AndroidInjectionKeys.java
index f30b92c..1425350 100644
--- a/java/dagger/android/internal/AndroidInjectionKeys.java
+++ b/java/dagger/android/internal/AndroidInjectionKeys.java
@@ -20,6 +20,7 @@
* An internal implementation detail of Dagger's generated code. This is not guaranteed to remain
* consistent from version to version.
*/
+@GenerateAndroidInjectionProguardRules
public final class AndroidInjectionKeys {
/**
* Accepts the fully qualified name of a class that is injected with {@code dagger.android}.
diff --git a/java/dagger/android/internal/GenerateAndroidInjectionProguardRules.java b/java/dagger/android/internal/GenerateAndroidInjectionProguardRules.java
new file mode 100644
index 0000000..46bbb66
--- /dev/null
+++ b/java/dagger/android/internal/GenerateAndroidInjectionProguardRules.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.android.internal;
+
+import static java.lang.annotation.ElementType.TYPE;
+import static java.lang.annotation.RetentionPolicy.SOURCE;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+/**
+ * Our proguard rules generator needs one annotation to hook into for it to run, so we use this
+ * internally on {@link dagger.android.internal.AndroidInjectionKeys} as a throwaway for it to run.
+ * It has no other purpose.
+ */
+@Target(TYPE)
+@Retention(SOURCE)
+@interface GenerateAndroidInjectionProguardRules {}
diff --git a/java/dagger/android/internal/proguard/BUILD b/java/dagger/android/internal/proguard/BUILD
new file mode 100644
index 0000000..a11d0c0
--- /dev/null
+++ b/java/dagger/android/internal/proguard/BUILD
@@ -0,0 +1,37 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Internal Proguard Processor
+
+load("@rules_java//java:defs.bzl", "java_library", "java_plugin")
+load("//:build_defs.bzl", "DOCLINT_HTML_AND_SYNTAX", "DOCLINT_REFERENCES")
+
+package(default_visibility = ["//:src"])
+
+java_library(
+ name = "proguard-processor",
+ srcs = ["ProguardProcessor.java"],
+ javacopts = DOCLINT_HTML_AND_SYNTAX + DOCLINT_REFERENCES,
+ deps = [
+ "@google_bazel_common//third_party/java/auto:service",
+ ],
+)
+
+java_plugin(
+ name = "plugin",
+ generates_api = 1,
+ processor_class = "dagger.android.internal.proguard.ProguardProcessor",
+ deps = [":proguard-processor"],
+)
diff --git a/java/dagger/android/internal/proguard/ProguardProcessor.java b/java/dagger/android/internal/proguard/ProguardProcessor.java
new file mode 100644
index 0000000..49274e9
--- /dev/null
+++ b/java/dagger/android/internal/proguard/ProguardProcessor.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.android.internal.proguard;
+
+import static javax.tools.StandardLocation.CLASS_OUTPUT;
+
+import com.google.auto.service.AutoService;
+import java.io.IOException;
+import java.io.Writer;
+import java.util.Set;
+import javax.annotation.processing.AbstractProcessor;
+import javax.annotation.processing.Filer;
+import javax.annotation.processing.Processor;
+import javax.annotation.processing.RoundEnvironment;
+import javax.annotation.processing.SupportedAnnotationTypes;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.TypeElement;
+
+/**
+ * An {@linkplain Processor annotation processor} to generate dagger-android's specific proguard
+ * needs. This is only intended to run over the dagger-android project itself, as the alternative is
+ * to create an intermediary java_library for proguard rules to be consumed by the project.
+ *
+ * <p>Basic structure looks like this:
+ *
+ * <pre><code>
+ * resources/META-INF/com.android.tools/proguard/dagger-android.pro
+ * resources/META-INF/com.android.tools/r8/dagger-android.pro
+ * resources/META-INF/proguard/dagger-android.pro
+ * </code></pre>
+ */
+@AutoService(Processor.class)
+@SupportedAnnotationTypes(ProguardProcessor.GENERATE_RULES_ANNOTATION_NAME)
+public final class ProguardProcessor extends AbstractProcessor {
+
+ static final String GENERATE_RULES_ANNOTATION_NAME =
+ "dagger.android.internal.GenerateAndroidInjectionProguardRules";
+
+ @Override
+ public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+ roundEnv
+ .getElementsAnnotatedWith(
+ processingEnv.getElementUtils().getTypeElement(GENERATE_RULES_ANNOTATION_NAME))
+ .forEach(element -> generate());
+
+ return false;
+ }
+
+ private void generate() {
+ Filer filer = processingEnv.getFiler();
+
+ String errorProneRule = "-dontwarn com.google.errorprone.annotations.**\n";
+ String androidInjectionKeysRule =
+ "-identifiernamestring class dagger.android.internal.AndroidInjectionKeys {\n"
+ + " java.lang.String of(java.lang.String);\n"
+ + "}\n";
+
+ writeFile(filer, "com.android.tools/proguard", errorProneRule);
+ writeFile(filer, "com.android.tools/r8", errorProneRule + androidInjectionKeysRule);
+ writeFile(filer, "proguard", errorProneRule);
+ }
+
+ private static void writeFile(Filer filer, String intermediatePath, String contents) {
+ try (Writer writer =
+ filer
+ .createResource(
+ CLASS_OUTPUT, "", "META-INF/" + intermediatePath + "/dagger-android.pro")
+ .openWriter()) {
+ writer.write(contents);
+ } catch (IOException e) {
+ throw new IllegalStateException(e);
+ }
+ }
+
+ @Override
+ public SourceVersion getSupportedSourceVersion() {
+ return SourceVersion.latestSupported();
+ }
+}
diff --git a/java/dagger/android/processor/AndroidProcessor.java b/java/dagger/android/processor/AndroidProcessor.java
index 5c17341..ad7f08e 100644
--- a/java/dagger/android/processor/AndroidProcessor.java
+++ b/java/dagger/android/processor/AndroidProcessor.java
@@ -17,23 +17,18 @@
package dagger.android.processor;
import static javax.tools.Diagnostic.Kind.ERROR;
-import static javax.tools.StandardLocation.CLASS_OUTPUT;
import static net.ltgt.gradle.incap.IncrementalAnnotationProcessorType.ISOLATING;
import com.google.auto.common.BasicAnnotationProcessor;
import com.google.auto.service.AutoService;
import com.google.common.base.Ascii;
-import com.google.common.base.Joiner;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.googlejavaformat.java.filer.FormattingFiler;
-import java.io.IOException;
-import java.io.Writer;
import java.util.Set;
import javax.annotation.processing.Filer;
import javax.annotation.processing.Messager;
import javax.annotation.processing.Processor;
-import javax.annotation.processing.RoundEnvironment;
import javax.lang.model.SourceVersion;
import javax.lang.model.util.Elements;
import javax.lang.model.util.Types;
@@ -98,29 +93,6 @@
}
@Override
- protected void postRound(RoundEnvironment roundEnv) {
- if (roundEnv.processingOver() && useStringKeys()) {
- try (Writer writer = createProguardFile()){
- writer.write(
- Joiner.on("\n")
- .join(
- "-identifiernamestring class dagger.android.internal.AndroidInjectionKeys {",
- " java.lang.String of(java.lang.String);",
- "}"));
- } catch (IOException e) {
- e.printStackTrace();
- }
- }
- }
-
- private Writer createProguardFile() throws IOException {
- return processingEnv
- .getFiler()
- .createResource(CLASS_OUTPUT, "", "META-INF/proguard/dagger.android.AndroidInjectionKeys")
- .openWriter();
- }
-
- @Override
public Set<String> getSupportedOptions() {
return ImmutableSet.of(FLAG_EXPERIMENTAL_USE_STRING_KEYS);
}
diff --git a/java/dagger/android/processor/BUILD b/java/dagger/android/processor/BUILD
index 5754143..7e63c76 100644
--- a/java/dagger/android/processor/BUILD
+++ b/java/dagger/android/processor/BUILD
@@ -15,14 +15,17 @@
# Description:
# Public Dagger API for Android
-package(default_visibility = ["//:src"])
-
+load("@rules_java//java:defs.bzl", "java_import", "java_library", "java_plugin")
load(
"//:build_defs.bzl",
"DOCLINT_HTML_AND_SYNTAX",
"DOCLINT_REFERENCES",
+ "POM_VERSION",
)
-load("//tools:maven.bzl", "POM_VERSION", "pom_file")
+load("//tools:maven.bzl", "pom_file")
+load("@google_bazel_common//tools/javadoc:javadoc.bzl", "javadoc_library")
+
+package(default_visibility = ["//:src"])
filegroup(
name = "srcs",
@@ -35,15 +38,15 @@
javacopts = DOCLINT_HTML_AND_SYNTAX + DOCLINT_REFERENCES,
tags = ["maven_coordinates=com.google.dagger:dagger-android-processor:" + POM_VERSION],
deps = [
- "@google_bazel_common//third_party/java/guava",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
"@google_bazel_common//third_party/java/auto:service",
"@google_bazel_common//third_party/java/auto:value",
- "@google_bazel_common//third_party/java/auto:common",
+ "@maven//:com_google_auto_auto_common",
"@google_bazel_common//third_party/java/incap",
"@google_bazel_common//third_party/java/javapoet",
"@google_bazel_common//third_party/java/google_java_format",
"//java/dagger:core",
- "//java/dagger/model",
"//java/dagger/spi",
# https://github.com/bazelbuild/bazel/issues/2517
":dagger-android-jar",
@@ -78,8 +81,6 @@
deps = [":processor"],
)
-load("@google_bazel_common//tools/javadoc:javadoc.bzl", "javadoc_library")
-
javadoc_library(
name = "processor-javadoc",
srcs = [":srcs"],
diff --git a/java/dagger/android/proguard.cfg b/java/dagger/android/proguard.cfg
deleted file mode 100644
index bd8ffbf..0000000
--- a/java/dagger/android/proguard.cfg
+++ /dev/null
@@ -1 +0,0 @@
--dontwarn com.google.errorprone.annotations.**
diff --git a/java/dagger/android/support/AndroidSupportInjection.java b/java/dagger/android/support/AndroidSupportInjection.java
index 1624345..c77e297 100644
--- a/java/dagger/android/support/AndroidSupportInjection.java
+++ b/java/dagger/android/support/AndroidSupportInjection.java
@@ -20,8 +20,7 @@
import static dagger.internal.Preconditions.checkNotNull;
import android.app.Activity;
-import android.app.Application;
-import android.support.v4.app.Fragment;
+import androidx.fragment.app.Fragment;
import android.util.Log;
import dagger.android.AndroidInjector;
import dagger.android.HasAndroidInjector;
@@ -36,72 +35,59 @@
* Injects {@code fragment} if an associated {@link AndroidInjector} implementation can be found,
* otherwise throws an {@link IllegalArgumentException}.
*
- * <p>Uses the following algorithm to find the appropriate {@link AndroidInjector} to use to
- * inject {@code fragment}:
+ * <p>Uses the following algorithm to find the appropriate {@code AndroidInjector<Fragment>} to
+ * use to inject {@code fragment}:
*
* <ol>
- * <li>Walks the parent-fragment hierarchy to find a fragment that implements {@link
- * HasAndroidInjector} or {@link HasSupportFragmentInjector}, and if none do
+ * <li>Walks the parent-fragment hierarchy to find the a fragment that implements {@link
+ * HasAndroidInjector}, and if none do
* <li>Uses the {@code fragment}'s {@link Fragment#getActivity() activity} if it implements
- * {@link HasAndroidInjector} or {@link HasSupportFragmentInjector}, and if not
- * <li>Uses the {@link android.app.Application} if it implements {@link HasAndroidInjector}
- * {@link HasSupportFragmentInjector}.
+ * {@link HasAndroidInjector}, and if not
+ * <li>Uses the {@link android.app.Application} if it implements {@link HasAndroidInjector}.
* </ol>
*
- * If none of them implement {@link HasAndroidInjector} or {@link HasSupportFragmentInjector}, a
- * {@link IllegalArgumentException} is thrown.
+ * If none of them implement {@link HasAndroidInjector}, a {@link IllegalArgumentException} is
+ * thrown.
*
* @throws IllegalArgumentException if no parent fragment, activity, or application implements
- * {@link HasAndroidInjector} or {@link HasSupportFragmentInjector}.
+ * {@link HasAndroidInjector}.
*/
public static void inject(Fragment fragment) {
checkNotNull(fragment, "fragment");
-
- Object hasInjector = findHasSupportFragmentInjector(fragment);
- AndroidInjector<? super Fragment> injector;
- if (hasInjector instanceof HasAndroidInjector) {
- injector = ((HasAndroidInjector) hasInjector).androidInjector();
- checkNotNull(injector, "%s.androidInjector() returned null", hasInjector.getClass());
- } else if (hasInjector instanceof HasSupportFragmentInjector) {
- injector = ((HasSupportFragmentInjector) hasInjector).supportFragmentInjector();
- checkNotNull(injector, "%s.supportFragmentInjector() returned null", hasInjector.getClass());
- } else {
- throw new RuntimeException(
- String.format(
- "%s does not implement %s or %s",
- hasInjector.getClass().getCanonicalName(),
- HasAndroidInjector.class.getCanonicalName(),
- HasSupportFragmentInjector.class.getCanonicalName()));
- }
-
+ HasAndroidInjector hasAndroidInjector = findHasAndroidInjectorForFragment(fragment);
if (Log.isLoggable(TAG, DEBUG)) {
Log.d(
TAG,
String.format(
"An injector for %s was found in %s",
fragment.getClass().getCanonicalName(),
- hasInjector.getClass().getCanonicalName()));
+ hasAndroidInjector.getClass().getCanonicalName()));
}
- injector.inject(fragment);
+ inject(fragment, hasAndroidInjector);
}
- private static Object findHasSupportFragmentInjector(Fragment fragment) {
+ private static void inject(Object target, HasAndroidInjector hasAndroidInjector) {
+ AndroidInjector<Object> androidInjector = hasAndroidInjector.androidInjector();
+ checkNotNull(
+ androidInjector, "%s.androidInjector() returned null", hasAndroidInjector.getClass());
+
+ androidInjector.inject(target);
+ }
+
+ private static HasAndroidInjector findHasAndroidInjectorForFragment(Fragment fragment) {
Fragment parentFragment = fragment;
while ((parentFragment = parentFragment.getParentFragment()) != null) {
- if (parentFragment instanceof HasAndroidInjector
- || parentFragment instanceof HasSupportFragmentInjector) {
- return parentFragment;
+ if (parentFragment instanceof HasAndroidInjector) {
+ return (HasAndroidInjector) parentFragment;
}
}
Activity activity = fragment.getActivity();
- if (activity instanceof HasAndroidInjector || activity instanceof HasSupportFragmentInjector) {
- return activity;
+ if (activity instanceof HasAndroidInjector) {
+ return (HasAndroidInjector) activity;
}
- Application application = activity.getApplication();
- if (application instanceof HasAndroidInjector
- || application instanceof HasSupportFragmentInjector) {
- return application;
+ if (activity.getApplication() instanceof HasAndroidInjector) {
+ return (HasAndroidInjector) activity.getApplication();
}
throw new IllegalArgumentException(
String.format("No injector was found for %s", fragment.getClass().getCanonicalName()));
diff --git a/java/dagger/android/support/BUILD b/java/dagger/android/support/BUILD
index 749d541..03846b5 100644
--- a/java/dagger/android/support/BUILD
+++ b/java/dagger/android/support/BUILD
@@ -15,10 +15,16 @@
# Description:
# Public Dagger API for Android that interacts with the Android support libraries
-package(default_visibility = ["//:src"])
+load(
+ "//:build_defs.bzl",
+ "POM_VERSION",
+ "SOURCE_7_TARGET_7",
+)
+load("//tools:dejetify.bzl", "dejetified_library")
+load("//tools:maven.bzl", "pom_file")
+load("@google_bazel_common//tools/javadoc:javadoc.bzl", "javadoc_library")
-load("//:build_defs.bzl", "SOURCE_7_TARGET_7")
-load("//tools:maven.bzl", "pom_file", "POM_VERSION")
+package(default_visibility = ["//:src"])
filegroup(
name = "support-srcs",
@@ -32,27 +38,12 @@
manifest = "AndroidManifest.xml",
tags = ["maven_coordinates=com.google.dagger:dagger-android-support:" + POM_VERSION],
deps = [
- ":manual-maven-deps",
"//:dagger_with_compiler",
"//java/dagger/android",
"@google_bazel_common//third_party/java/error_prone:annotations",
- ],
-)
-
-# Our pom.xml generator does not have a way to add manual maven deps. This target exports the
-# targets that don't have the necessary maven_coordinates tags.
-android_library(
- name = "manual-maven-deps",
- tags = [
- "maven_coordinates=com.android.support:appcompat-v7:25.0.0",
- "maven_coordinates=com.android.support:support-annotations:25.0.0",
- "maven_coordinates=com.android.support:support-fragment:25.0.0",
- ],
- visibility = ["//visibility:private"],
- exports = [
- "@androidsdk//com.android.support:appcompat-v7-25.0.0",
- "@androidsdk//com.android.support:support-annotations-25.0.0",
- "@androidsdk//com.android.support:support-fragment-25.0.0",
+ "@maven//:androidx_annotation_annotation",
+ "@maven//:androidx_appcompat_appcompat",
+ "@maven//:androidx_fragment_fragment",
],
)
@@ -64,12 +55,37 @@
targets = [":support"],
)
-load("@google_bazel_common//tools/javadoc:javadoc.bzl", "javadoc_library")
+dejetified_library(
+ name = "dejetified-support",
+ input = ":support.aar",
+ output = "support-legacy.aar",
+)
+
+android_library(
+ name = "legacy-deps",
+ tags = ["maven_coordinates=com.google.dagger:dagger-android-support-legacy:" + POM_VERSION],
+ exports = [
+ "//:dagger_with_compiler",
+ "//java/dagger/android:legacy-deps",
+ "@google_bazel_common//third_party/java/error_prone:annotations",
+ "@maven//:com_android_support_appcompat_v7",
+ "@maven//:com_android_support_support_annotations",
+ "@maven//:com_android_support_support_fragment",
+ ],
+)
+
+pom_file(
+ name = "legacy-pom",
+ artifact_id = "dagger-android-support-legacy",
+ artifact_name = "Dagger Android Legacy Support",
+ packaging = "aar",
+ targets = [":legacy-deps"],
+)
javadoc_library(
name = "support-javadoc",
srcs = [":support-srcs"],
- android_api_level = 26,
+ android_api_level = 30,
root_packages = ["dagger.android.support"],
deps = [":support"],
)
diff --git a/java/dagger/android/support/DaggerAppCompatActivity.java b/java/dagger/android/support/DaggerAppCompatActivity.java
index ccc4faa..da5b173 100644
--- a/java/dagger/android/support/DaggerAppCompatActivity.java
+++ b/java/dagger/android/support/DaggerAppCompatActivity.java
@@ -17,8 +17,10 @@
package dagger.android.support;
import android.os.Bundle;
-import android.support.annotation.Nullable;
-import android.support.v7.app.AppCompatActivity;
+import androidx.annotation.ContentView;
+import androidx.annotation.LayoutRes;
+import androidx.annotation.Nullable;
+import androidx.appcompat.app.AppCompatActivity;
import dagger.android.AndroidInjection;
import dagger.android.AndroidInjector;
import dagger.android.DispatchingAndroidInjector;
@@ -36,6 +38,15 @@
@Inject DispatchingAndroidInjector<Object> androidInjector;
+ public DaggerAppCompatActivity() {
+ super();
+ }
+
+ @ContentView
+ public DaggerAppCompatActivity(@LayoutRes int contentLayoutId) {
+ super(contentLayoutId);
+ }
+
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
AndroidInjection.inject(this);
diff --git a/java/dagger/android/support/DaggerAppCompatDialogFragment.java b/java/dagger/android/support/DaggerAppCompatDialogFragment.java
index 1efaeec..7a5a76d 100644
--- a/java/dagger/android/support/DaggerAppCompatDialogFragment.java
+++ b/java/dagger/android/support/DaggerAppCompatDialogFragment.java
@@ -17,8 +17,8 @@
package dagger.android.support;
import android.content.Context;
-import android.support.v4.app.Fragment;
-import android.support.v7.app.AppCompatDialogFragment;
+import androidx.fragment.app.Fragment;
+import androidx.appcompat.app.AppCompatDialogFragment;
import dagger.android.AndroidInjector;
import dagger.android.DispatchingAndroidInjector;
import dagger.android.HasAndroidInjector;
diff --git a/java/dagger/android/support/DaggerDialogFragment.java b/java/dagger/android/support/DaggerDialogFragment.java
index 69b90bc..8b0bf23 100644
--- a/java/dagger/android/support/DaggerDialogFragment.java
+++ b/java/dagger/android/support/DaggerDialogFragment.java
@@ -17,8 +17,8 @@
package dagger.android.support;
import android.content.Context;
-import android.support.v4.app.DialogFragment;
-import android.support.v4.app.Fragment;
+import androidx.fragment.app.DialogFragment;
+import androidx.fragment.app.Fragment;
import dagger.android.AndroidInjector;
import dagger.android.DispatchingAndroidInjector;
import dagger.android.HasAndroidInjector;
diff --git a/java/dagger/android/support/DaggerFragment.java b/java/dagger/android/support/DaggerFragment.java
index 332cdaa..8874511 100644
--- a/java/dagger/android/support/DaggerFragment.java
+++ b/java/dagger/android/support/DaggerFragment.java
@@ -17,7 +17,9 @@
package dagger.android.support;
import android.content.Context;
-import android.support.v4.app.Fragment;
+import androidx.annotation.ContentView;
+import androidx.annotation.LayoutRes;
+import androidx.fragment.app.Fragment;
import dagger.android.AndroidInjector;
import dagger.android.DispatchingAndroidInjector;
import dagger.android.HasAndroidInjector;
@@ -34,6 +36,15 @@
@Inject DispatchingAndroidInjector<Object> androidInjector;
+ public DaggerFragment() {
+ super();
+ }
+
+ @ContentView
+ public DaggerFragment(@LayoutRes int contentLayoutId) {
+ super(contentLayoutId);
+ }
+
@Override
public void onAttach(Context context) {
AndroidSupportInjection.inject(this);
diff --git a/java/dagger/android/support/HasSupportFragmentInjector.java b/java/dagger/android/support/HasSupportFragmentInjector.java
deleted file mode 100644
index e80609e..0000000
--- a/java/dagger/android/support/HasSupportFragmentInjector.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.android.support;
-
-import android.support.v4.app.Fragment;
-import dagger.android.AndroidInjector;
-import dagger.internal.Beta;
-
-/** Provides an {@link AndroidInjector} of {@link Fragment}s. */
-@Beta
-public interface HasSupportFragmentInjector {
-
- /** Returns an {@link AndroidInjector} of {@link Fragment}s. */
- AndroidInjector<Fragment> supportFragmentInjector();
-}
diff --git a/java/dagger/assisted/Assisted.java b/java/dagger/assisted/Assisted.java
new file mode 100644
index 0000000..59d8eec
--- /dev/null
+++ b/java/dagger/assisted/Assisted.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.assisted;
+
+import static java.lang.annotation.ElementType.PARAMETER;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+/**
+ * Annotates a parameter within an {@link AssistedInject}-annotated constructor.
+ *
+ * <p>See {@link AssistedInject}.
+ */
+@Documented
+@Retention(RUNTIME)
+@Target(PARAMETER)
+public @interface Assisted {
+
+ /**
+ * Returns an identifier for an {@link Assisted} parameter.
+ *
+ * <p>Within an {@link AssistedInject} constructor, each {@link Assisted} parameter must be
+ * uniquely defined by the combination of its identifier and type. If no identifier is specified,
+ * the default identifier is an empty string. Thus, the following parameters are equivalent within
+ * an {@link AssistedInject} constructor:
+ *
+ * <ul>
+ * <li> {@code @Assisted Foo foo}
+ * <li> {@code @Assisted("") Foo foo}
+ * </ul>
+ *
+ * <p>Within an {@link AssistedFactory} method, each parameter must match an {@link Assisted}
+ * parameter in the associated {@link AssistedInject} constructor (i.e. identifier + type).
+ * A parameter with no {@code @Assisted} annotation will be assigned the default identifier. Thus,
+ * the following parameters are equivalent within an {@link AssistedFactory} method:
+ *
+ * <ul>
+ * <li> {@code Foo foo}
+ * <li> {@code @Assisted Foo foo}
+ * <li> {@code @Assisted("") Foo foo}
+ * </ul>
+ *
+ * <p>Example:
+ *
+ * <pre><code>
+ * final class DataService {
+ * {@literal @}AssistedInject
+ * DataService(
+ * BindingFromDagger bindingFromDagger,
+ * {@literal @}Assisted String name,
+ * {@literal @}Assisted("id") String id,
+ * {@literal @}Assisted("repo") String repo) {}
+ * }
+ *
+ * {@literal @}AssistedFactory
+ * interface DataServiceFactory {
+ * DataService create(
+ * String name,
+ * {@literal @}Assisted("id") String id,
+ * {@literal @}Assisted("repo") String repo);
+ * }
+ * </code></pre>
+ */
+ String value() default "";
+}
diff --git a/java/dagger/assisted/AssistedFactory.java b/java/dagger/assisted/AssistedFactory.java
new file mode 100644
index 0000000..4eba9a7
--- /dev/null
+++ b/java/dagger/assisted/AssistedFactory.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.assisted;
+
+import static java.lang.annotation.ElementType.TYPE;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+/**
+ * Annotates an abstract class or interface used to create an instance of a type via an {@link
+ * AssistedInject} constructor.
+ *
+ * <p>An {@link AssistedFactory}-annotated type must obey the following constraints:
+ *
+ * <ul>
+ * <li>The type must be an abstract class or interface,
+ * <li>The type must contain exactly one abstract, non-default method whose
+ * <ul>
+ * <li>return type must exactly match the type of an assisted injection type, and
+ * <li>parameters must match the exact list of {@link Assisted} parameters in the assisted
+ * injection type's constructor (and in the same order).
+ * </ul>
+ * </ul>
+ *
+ * See {@link AssistedInject}
+ */
+@Documented
+@Retention(RUNTIME)
+@Target(TYPE)
+public @interface AssistedFactory {}
diff --git a/java/dagger/assisted/AssistedInject.java b/java/dagger/assisted/AssistedInject.java
new file mode 100644
index 0000000..fadd46d
--- /dev/null
+++ b/java/dagger/assisted/AssistedInject.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.assisted;
+
+import static java.lang.annotation.ElementType.CONSTRUCTOR;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+/**
+ * Annotates the constuctor of a type that will be created via assisted injection.
+ *
+ * <p>Note that an assisted injection type cannot be scoped. In addition, assisted injection
+ * requires the use of a factory annotated with {@link AssistedFactory} (see the example below).
+ *
+ * <p>Example usage:
+ *
+ * <p>Suppose we have a type, {@code DataService}, that has two dependencies: {@code DataFetcher}
+ * and {@code Config}. When creating {@code DataService}, we would like to pass in an instance of
+ * {@code Config} manually rather than having Dagger create it for us. This can be done using
+ * assisted injection.
+ *
+ * <p>To start, we annotate the {@code DataService} constructor with {@link AssistedInject} and we
+ * annotate the {@code Config} parameter with {@link Assisted}, as shown below:
+ *
+ * <pre><code>
+ * final class DataService {
+ * private final DataFetcher dataFetcher;
+ * private final Config config;
+ *
+ * {@literal @}AssistedInject
+ * DataService(DataFetcher dataFetcher, {@literal @}Assisted Config config) {
+ * this.dataFetcher = dataFetcher;
+ * this.config = config;
+ * }
+ * }
+ * </code></pre>
+ *
+ * <p>Next, we define a factory for the assisted type, {@code DataService}, and annotate it with
+ * {@link AssistedFactory}. The factory must contain a single abstract, non-default method which
+ * takes in all of the assisted parameters (in order) and returns the assisted type.
+ *
+ * <pre><code>
+ * {@literal @}AssistedFactory
+ * interface DataServiceFactory {
+ * DataService create(Config config);
+ * }
+ * </code></pre>
+ *
+ * <p>Dagger will generate an implementation of the factory and bind it to the factory type. The
+ * factory can then be used to create an instance of the assisted type:
+ *
+ * <pre><code>
+ * class MyApplication {
+ * {@literal @}Inject DataServiceFactory dataServiceFactory;
+ *
+ * dataService = dataServiceFactory.create(new Config(...));
+ * }
+ * </code></pre>
+ */
+@Documented
+@Retention(RUNTIME)
+@Target(CONSTRUCTOR)
+public @interface AssistedInject {}
diff --git a/java/dagger/assisted/package-info.java b/java/dagger/assisted/package-info.java
new file mode 100644
index 0000000..9b8b7f0
--- /dev/null
+++ b/java/dagger/assisted/package-info.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * This package contains the API for Dagger's assisted injection.
+ *
+ * TODO(bcorso): Link to dagger.dev documentation.
+ */
+package dagger.assisted;
diff --git a/java/dagger/errorprone/AndroidSupportInjectionModuleMigrator.java b/java/dagger/errorprone/AndroidSupportInjectionModuleMigrator.java
index e98fe9b..bc0be48 100644
--- a/java/dagger/errorprone/AndroidSupportInjectionModuleMigrator.java
+++ b/java/dagger/errorprone/AndroidSupportInjectionModuleMigrator.java
@@ -19,7 +19,6 @@
import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
import com.google.errorprone.BugPattern;
-import com.google.errorprone.BugPattern.ProvidesFix;
import com.google.errorprone.VisitorState;
import com.google.errorprone.bugpatterns.BugChecker;
import com.google.errorprone.bugpatterns.BugChecker.MemberSelectTreeMatcher;
@@ -35,7 +34,6 @@
/** A refactoring to update AndroidInjector bindings to their new form. */
@BugPattern(
name = "AndroidSupportInjectionModuleMigrator",
- providesFix = ProvidesFix.REQUIRES_HUMAN_ATTENTION,
summary = "Inlines usages of AndroidSupportInjectionModule to AndroidInjectionModule",
explanation =
"AndroidSupportInjectionModule is now an empty module and acts as an alias for "
diff --git a/java/dagger/errorprone/BUILD b/java/dagger/errorprone/BUILD
index 408925a..9c3707f 100644
--- a/java/dagger/errorprone/BUILD
+++ b/java/dagger/errorprone/BUILD
@@ -1,6 +1,8 @@
# Description:
# ErrorProne refactorings and static analysis for Dagger
+load("@rules_java//java:defs.bzl", "java_library")
+
package(default_visibility = ["//:src"])
java_library(
@@ -8,8 +10,8 @@
srcs = glob(["*.java"]),
deps = [
"//java/dagger:core",
+ "//java/dagger/internal/guava:collect",
"@bazel_tools//tools/jdk:langtools-neverlink",
"@google_bazel_common//third_party/java/error_prone:check_api",
- "@google_bazel_common//third_party/java/guava",
],
)
diff --git a/java/dagger/example/BUILD b/java/dagger/example/BUILD
new file mode 100644
index 0000000..1973229
--- /dev/null
+++ b/java/dagger/example/BUILD
@@ -0,0 +1,18 @@
+# Copyright (C) 2017 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Description:
+# Dagger examples.
+
+package(default_visibility = ["//:src"])
diff --git a/java/dagger/example/android/simple/AndroidManifest.xml b/java/dagger/example/android/simple/AndroidManifest.xml
deleted file mode 100644
index 711fb1e..0000000
--- a/java/dagger/example/android/simple/AndroidManifest.xml
+++ /dev/null
@@ -1,31 +0,0 @@
-<!--
- ~ Copyright (C) 2017 The Dagger Authors.
- ~
- ~ Licensed under the Apache License, Version 2.0 (the "License");
- ~ you may not use this file except in compliance with the License.
- ~ You may obtain a copy of the License at
- ~
- ~ http://www.apache.org/licenses/LICENSE-2.0
- ~
- ~ Unless required by applicable law or agreed to in writing, software
- ~ distributed under the License is distributed on an "AS IS" BASIS,
- ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- ~ See the License for the specific language governing permissions and
- ~ limitations under the License.
- -->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
- package="dagger.example.android.simple">
-
- <uses-sdk
- android:minSdkVersion="14"
- android:targetSdkVersion="24"/>
-
- <application android:name=".SimpleApplication" android:label="@string/appName">
- <activity android:name=".MainActivity" android:theme="@style/Theme.AppCompat.Light.NoActionBar">
- <intent-filter>
- <action android:name="android.intent.action.MAIN" />
- <category android:name="android.intent.category.LAUNCHER" />
- </intent-filter>
- </activity>
- </application>
-</manifest>
diff --git a/java/dagger/example/android/simple/BUILD b/java/dagger/example/android/simple/BUILD
deleted file mode 100644
index 7396744..0000000
--- a/java/dagger/example/android/simple/BUILD
+++ /dev/null
@@ -1,42 +0,0 @@
-# Copyright (C) 2017 The Dagger Authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-# Description:
-# A skeletal application that demonstates wiring for an injected Application and Actiity.
-
-package(default_visibility = ["//:src"])
-
-android_library(
- name = "simple_lib",
- srcs = glob(["*.java"]),
- manifest = "AndroidManifest.xml",
- resource_files = glob(["res/**"]),
- deps = [
- "//:android",
- "//:android-support",
- "//:dagger_with_compiler",
- "@androidsdk//com.android.support:appcompat-v7-25.0.0",
- "@androidsdk//com.android.support:support-annotations-25.0.0",
- "@androidsdk//com.android.support:support-fragment-25.0.0",
- ],
-)
-
-android_binary(
- name = "simple",
- aapt_version = "aapt",
- manifest = "AndroidManifest.xml",
- deps = [
- ":simple_lib",
- ],
-)
diff --git a/java/dagger/example/android/simple/BuildModule.java b/java/dagger/example/android/simple/BuildModule.java
deleted file mode 100644
index 40ac8ee..0000000
--- a/java/dagger/example/android/simple/BuildModule.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.example.android.simple;
-
-import static android.os.Build.MODEL;
-
-import dagger.Module;
-import dagger.Provides;
-
-@Module
-final class BuildModule {
- @Provides
- @Model
- static String provideModel() {
- return MODEL;
- }
-}
diff --git a/java/dagger/example/android/simple/MainActivity.java b/java/dagger/example/android/simple/MainActivity.java
deleted file mode 100644
index f2aab2d..0000000
--- a/java/dagger/example/android/simple/MainActivity.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.example.android.simple;
-
-import android.os.Bundle;
-import android.util.Log;
-import android.widget.TextView;
-import dagger.Binds;
-import dagger.android.AndroidInjector;
-import dagger.android.support.DaggerAppCompatActivity;
-import dagger.multibindings.ClassKey;
-import dagger.multibindings.IntoMap;
-import javax.inject.Inject;
-
-/**
- * The main activity application. It can be injected with any binding from both {@link Component}
- * and {@link dagger.example.android.simple.SimpleApplication.Component}.
- */
-public class MainActivity extends DaggerAppCompatActivity {
- @dagger.Subcomponent
- interface Component extends AndroidInjector<MainActivity> {
-
- @dagger.Subcomponent.Builder
- abstract class Builder extends AndroidInjector.Builder<MainActivity> {}
- }
-
- @dagger.Module(subcomponents = Component.class)
- abstract class Module {
-
- @Binds
- @IntoMap
- @ClassKey(MainActivity.class)
- abstract AndroidInjector.Factory<?> bind(Component.Builder builder);
- }
-
- private static final String TAG = MainActivity.class.getSimpleName();
-
- @Inject @Model String model;
-
- @Inject
- void logInjection() {
- Log.i(TAG, "Injecting " + MainActivity.class.getSimpleName());
- }
-
- @Override
- protected void onCreate(Bundle savedInstanceState) {
- super.onCreate(savedInstanceState);
-
- setContentView(R.layout.activity_main);
-
- TextView greeting = (TextView) findViewById(R.id.greeting);
- String text = getResources().getString(R.string.welcome, model);
- greeting.setText(text);
- }
-}
diff --git a/java/dagger/example/android/simple/Model.java b/java/dagger/example/android/simple/Model.java
deleted file mode 100644
index c52bb98..0000000
--- a/java/dagger/example/android/simple/Model.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.example.android.simple;
-
-import static java.lang.annotation.RetentionPolicy.RUNTIME;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.Retention;
-import javax.inject.Qualifier;
-
-/** Qualifies bindings relating to {@link android.os.Build#MODEL}. */
-@Qualifier
-@Retention(RUNTIME)
-@Documented
-@interface Model {}
diff --git a/java/dagger/example/android/simple/SimpleApplication.java b/java/dagger/example/android/simple/SimpleApplication.java
deleted file mode 100644
index ae3d42d..0000000
--- a/java/dagger/example/android/simple/SimpleApplication.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.example.android.simple;
-
-import android.util.Log;
-import dagger.android.AndroidInjectionModule;
-import dagger.android.AndroidInjector;
-import dagger.android.DaggerApplication;
-import javax.inject.Inject;
-
-/**
- * A simple, skeletal application that demonstrates a dependency-injected application using the
- * utilities in {@code dagger.android}.
- */
-public class SimpleApplication extends DaggerApplication {
- private static final String TAG = SimpleApplication.class.getSimpleName();
-
- @dagger.Component(
- modules = {AndroidInjectionModule.class, MainActivity.Module.class, BuildModule.class})
- /* @ApplicationScoped and/or @Singleton */
- interface Component extends AndroidInjector<SimpleApplication> {
- @dagger.Component.Builder
- abstract class Builder extends AndroidInjector.Builder<SimpleApplication> {}
- }
-
- @Inject
- void logInjection() {
- Log.i(TAG, "Injecting " + SimpleApplication.class.getSimpleName());
- }
-
- @Override
- public void onCreate() {
- super.onCreate();
- }
-
- @Override
- protected AndroidInjector<SimpleApplication> applicationInjector() {
- return DaggerSimpleApplication_Component.builder().create(this);
- }
-}
diff --git a/java/dagger/example/android/simple/res/layout/activity_main.xml b/java/dagger/example/android/simple/res/layout/activity_main.xml
deleted file mode 100644
index 37add1f..0000000
--- a/java/dagger/example/android/simple/res/layout/activity_main.xml
+++ /dev/null
@@ -1,31 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
- ~ Copyright (C) 2017 The Dagger Authors.
- ~
- ~ Licensed under the Apache License, Version 2.0 (the "License");
- ~ you may not use this file except in compliance with the License.
- ~ You may obtain a copy of the License at
- ~
- ~ http://www.apache.org/licenses/LICENSE-2.0
- ~
- ~ Unless required by applicable law or agreed to in writing, software
- ~ distributed under the License is distributed on an "AS IS" BASIS,
- ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- ~ See the License for the specific language governing permissions and
- ~ limitations under the License.
- -->
-
-<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
- android:layout_width="match_parent"
- android:layout_height="match_parent"
- android:background="@android:color/background_light">
-
- <TextView
- android:id="@+id/greeting"
- android:layout_width="match_parent"
- android:layout_height="match_parent"
- android:layout_alignParentTop="true"
- android:textColor="@android:color/primary_text_light"
- style="@style/TextAppearance.AppCompat.Display4"
- />
-</RelativeLayout>
diff --git a/java/dagger/example/android/simple/res/values/strings.xml b/java/dagger/example/android/simple/res/values/strings.xml
deleted file mode 100644
index c4ba1fd..0000000
--- a/java/dagger/example/android/simple/res/values/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
- <string name="appName">Simple Dagger</string>
- <string name="welcome">Hello, %s!</string>
-</resources>
\ No newline at end of file
diff --git a/java/dagger/example/atm/AccountModule.java b/java/dagger/example/atm/AccountModule.java
new file mode 100644
index 0000000..3ff5a75
--- /dev/null
+++ b/java/dagger/example/atm/AccountModule.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.atm;
+
+import dagger.Module;
+import dagger.Provides;
+import dagger.example.atm.Database.Account;
+
+/** Bindings for the {@link Account} of the currently signed-in user. */
+@Module
+interface AccountModule {
+ @Provides
+ static Account account(Database database, @Username String username) {
+ return database.getAccount(username);
+ }
+}
diff --git a/java/dagger/example/atm/AmountsModule.java b/java/dagger/example/atm/AmountsModule.java
new file mode 100644
index 0000000..87e5e01
--- /dev/null
+++ b/java/dagger/example/atm/AmountsModule.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.atm;
+
+import dagger.Module;
+import dagger.Provides;
+import java.math.BigDecimal;
+
+/** Configures various amounts of money the application uses to control transactions. */
+@Module
+abstract class AmountsModule {
+
+ @Provides
+ @MinimumBalance
+ static BigDecimal minimumBalance() {
+ return BigDecimal.ZERO;
+ }
+
+ @Provides
+ @MaximumWithdrawal
+ static BigDecimal maximumWithdrawal() {
+ return new BigDecimal(1000);
+ }
+}
diff --git a/java/dagger/example/atm/BUILD b/java/dagger/example/atm/BUILD
new file mode 100644
index 0000000..d1ff505
--- /dev/null
+++ b/java/dagger/example/atm/BUILD
@@ -0,0 +1,33 @@
+# Copyright (C) 2019 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# An example of using dagger in a computerized fake ATM. The User's Guide (https://dagger.dev/users-guide)
+# is a walkthrough that ultimately builds this example.
+
+load("@rules_java//java:defs.bzl", "java_binary", "java_library")
+
+package(default_visibility = ["//:src"])
+
+java_library(
+ name = "atm",
+ srcs = glob(["*.java"]),
+ deps = ["//:dagger_with_compiler"],
+)
+
+java_binary(
+ name = "CommandLineAtm",
+ main_class = "dagger.example.atm.CommandLineAtm",
+ runtime_deps = [":atm"],
+)
diff --git a/java/dagger/example/atm/BigDecimalCommand.java b/java/dagger/example/atm/BigDecimalCommand.java
new file mode 100644
index 0000000..29bd6f5
--- /dev/null
+++ b/java/dagger/example/atm/BigDecimalCommand.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.atm;
+
+import java.math.BigDecimal;
+
+/**
+ * Abstract {@link Command} that expects a single argument that can be converted to {@link
+ * BigDecimal}.
+ */
+abstract class BigDecimalCommand extends SingleArgCommand {
+
+ private final Outputter outputter;
+
+ protected BigDecimalCommand(Outputter outputter) {
+ this.outputter = outputter;
+ }
+
+ @Override
+ protected final Result handleArg(String arg) {
+ BigDecimal amount = tryParse(arg);
+ if (amount == null) {
+ outputter.output(arg + " is not a valid number");
+ } else if (amount.signum() <= 0) {
+ outputter.output("amount must be positive");
+ } else {
+ handleAmount(amount);
+ }
+ return Result.handled();
+ }
+
+ private static BigDecimal tryParse(String arg) {
+ try {
+ return new BigDecimal(arg);
+ } catch (NumberFormatException e) {
+ return null;
+ }
+ }
+
+ /** Handles the given (positive) {@code amount} of money. */
+ protected abstract void handleAmount(BigDecimal amount);
+}
diff --git a/java/dagger/example/atm/Command.java b/java/dagger/example/atm/Command.java
new file mode 100644
index 0000000..a3ff0d0
--- /dev/null
+++ b/java/dagger/example/atm/Command.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.atm;
+
+import java.util.List;
+import java.util.Optional;
+
+/** A text-based command handler. */
+interface Command {
+ /**
+ * Processes and optionally acts upon the given {@code input}.
+ *
+ * @return a {@link Result} indicating how the input was handled
+ */
+ Result handleInput(List<String> input);
+
+ /**
+ * A command result, which has a {@link Status} and optionally a new {@link CommandRouter} that
+ * will handle subsequent commands.
+ */
+ final class Result {
+ private final Status status;
+ private final Optional<CommandRouter> nestedCommandRouter;
+
+ private Result(Status status, Optional<CommandRouter> nestedCommandRouter) {
+ this.status = status;
+ this.nestedCommandRouter = nestedCommandRouter;
+ }
+
+ static Result invalid() {
+ return new Result(Status.INVALID, Optional.empty());
+ }
+
+ static Result handled() {
+ return new Result(Status.HANDLED, Optional.empty());
+ }
+
+ static Result inputCompleted() {
+ return new Result(Status.INPUT_COMPLETED, Optional.empty());
+ }
+
+ static Result enterNestedCommandSet(CommandRouter nestedCommandRouter) {
+ return new Result(Status.HANDLED, Optional.of(nestedCommandRouter));
+ }
+
+ Status status() {
+ return status;
+ }
+
+ Optional<CommandRouter> nestedCommandRouter() {
+ return nestedCommandRouter;
+ }
+ }
+
+ enum Status {
+ /** The command or its arguments were invalid. */
+ INVALID,
+
+ /** The command handled the input and no other commands should attempt to handle it. */
+ HANDLED,
+
+ // TODO(ronshapiro): maybe call this TERMINATED? If so, maybe this should be called
+ // ContinueStatus?
+ /** The command handled the input and no further inputs should be submitted. */
+ INPUT_COMPLETED,
+ ;
+ }
+}
diff --git a/java/dagger/example/atm/CommandLineAtm.java b/java/dagger/example/atm/CommandLineAtm.java
new file mode 100644
index 0000000..be5cbe6
--- /dev/null
+++ b/java/dagger/example/atm/CommandLineAtm.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.atm;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+
+import java.util.Scanner;
+
+/** Main class for the command-line ATM. */
+class CommandLineAtm {
+ public static void main(String[] args) {
+ Scanner scanner = new Scanner(System.in, UTF_8.name());
+ CommandProcessor commandProcessor = CommandProcessorFactory.create().commandProcessor();
+
+ while (scanner.hasNextLine()) {
+ Command.Status commandStatus = commandProcessor.process(scanner.nextLine());
+ if (commandStatus.equals(Command.Status.INPUT_COMPLETED)) {
+ break;
+ }
+ }
+ }
+}
diff --git a/java/dagger/example/atm/CommandProcessor.java b/java/dagger/example/atm/CommandProcessor.java
new file mode 100644
index 0000000..3b52d73
--- /dev/null
+++ b/java/dagger/example/atm/CommandProcessor.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.atm;
+
+import dagger.example.atm.Command.Result;
+import dagger.example.atm.Command.Status;
+import java.util.ArrayDeque;
+import java.util.Deque;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+/**
+ * Processes successive commands by delegating to a {@link CommandRouter}.
+ *
+ * <p>Whereas {@link CommandRouter} routes an input string to a particular {@link Command}, this
+ * class maintains inter-command state to determine which {@link CommandRouter} should route
+ * successive commands.
+ *
+ * <p>This class is {@link Singleton} scoped because it has mutable state ({@code
+ * commandRouterStack}), and all users of {@link CommandProcessor} must use the same instance.
+ */
+@Singleton
+final class CommandProcessor {
+ private final Deque<CommandRouter> commandRouterStack = new ArrayDeque<>();
+
+ @Inject
+ CommandProcessor(CommandRouter firstCommandRouter) {
+ commandRouterStack.push(firstCommandRouter);
+ }
+
+ Status process(String input) {
+ if (commandRouterStack.isEmpty()) {
+ throw new IllegalStateException("No command router is available!");
+ }
+
+ Result result = commandRouterStack.peek().route(input);
+ switch (result.status()) {
+ case INPUT_COMPLETED:
+ commandRouterStack.pop();
+ return commandRouterStack.isEmpty() ? Status.INPUT_COMPLETED : Status.HANDLED;
+ case HANDLED:
+ // TODO(ronshapiro): We currently have a case of using a subcomponent for nested commands,
+ // which requires maintaining a binding indicating whether we are in the subcomponent are
+ // not. We can include another example where there's a CommandRouter that is created from an
+ // entirely different component, that way there are no inherited commands.
+ result.nestedCommandRouter().ifPresent(commandRouterStack::push);
+ // fall through
+ case INVALID:
+ return result.status();
+ }
+ throw new AssertionError(result.status());
+ }
+}
diff --git a/java/dagger/example/atm/CommandProcessorFactory.java b/java/dagger/example/atm/CommandProcessorFactory.java
new file mode 100644
index 0000000..a449703
--- /dev/null
+++ b/java/dagger/example/atm/CommandProcessorFactory.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.atm;
+
+import dagger.Component;
+import javax.inject.Singleton;
+
+/**
+ * Hand-written API for interfacing with Dagger. The command-line ATM needs a single class to
+ * execute: {@link CommandProcessor}.
+ *
+ * <p>The list of {@code modules} declares where Dagger should look, besides {@link
+ * javax.inject.Inject}-annotated constructors, to help instantiate {@link CommandProcessor} and its
+ * dependencies.
+ */
+@Singleton
+@Component(
+ modules = {
+ CommandsModule.class,
+ InMemoryDatabaseModule.class,
+ UserCommandsRouter.InstallationModule.class,
+ SystemOutModule.class,
+ })
+interface CommandProcessorFactory {
+ CommandProcessor commandProcessor();
+
+ static CommandProcessorFactory create() {
+ return DaggerCommandProcessorFactory.create();
+ }
+}
diff --git a/java/dagger/example/atm/CommandRouter.java b/java/dagger/example/atm/CommandRouter.java
new file mode 100644
index 0000000..ef75220
--- /dev/null
+++ b/java/dagger/example/atm/CommandRouter.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.atm;
+
+import dagger.example.atm.Command.Result;
+import dagger.example.atm.Command.Status;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import javax.inject.Inject;
+
+/** Routes individual text commands to the appropriate {@link Command}(s). */
+final class CommandRouter {
+ private final Map<String, Command> commands;
+ private final Outputter outputter;
+
+ @Inject
+ CommandRouter(Map<String, Command> commands, Outputter outputter) {
+ this.commands = commands;
+ this.outputter = outputter;
+ }
+
+ /**
+ * Calls {@link Command#handleInput(String) command.handleInput(input)} on this router's
+ * {@linkplain #commands commands}.
+ */
+ Result route(String input) {
+ List<String> splitInput = split(input);
+ if (splitInput.isEmpty()) {
+ return invalidCommand(input);
+ }
+
+ String commandKey = splitInput.get(0);
+ Command command = commands.get(commandKey);
+ if (command == null) {
+ return invalidCommand(input);
+ }
+
+ List<String> args = splitInput.subList(1, splitInput.size());
+ Result result = command.handleInput(args);
+ return result.status().equals(Status.INVALID) ? invalidCommand(input) : result;
+ }
+
+ private Result invalidCommand(String input) {
+ outputter.output(String.format("couldn't understand \"%s\". please try again.", input));
+ return Result.invalid();
+ }
+
+ private static List<String> split(String input) {
+ return Arrays.asList(input.trim().split("\\s+"));
+ }
+}
diff --git a/java/dagger/example/atm/CommandsModule.java b/java/dagger/example/atm/CommandsModule.java
new file mode 100644
index 0000000..266af12
--- /dev/null
+++ b/java/dagger/example/atm/CommandsModule.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.atm;
+
+import dagger.Binds;
+import dagger.BindsOptionalOf;
+import dagger.Module;
+import dagger.example.atm.Database.Account;
+import dagger.multibindings.IntoMap;
+import dagger.multibindings.StringKey;
+
+/** Installs basic commands. */
+@Module
+interface CommandsModule {
+ @Binds
+ @IntoMap
+ @StringKey("hello")
+ Command helloWorld(HelloWorldCommand command);
+
+ @Binds
+ @IntoMap
+ @StringKey("login")
+ Command login(LoginCommand command);
+
+ /**
+ * Declare an optional binding for {@link Account}. This allows other bindings to change their
+ * behavior depending on whether an {@link Account} is bound in the current (sub)component.
+ */
+ @BindsOptionalOf
+ Account loggedInAccount();
+}
diff --git a/java/dagger/example/atm/Database.java b/java/dagger/example/atm/Database.java
new file mode 100644
index 0000000..f6c0eda
--- /dev/null
+++ b/java/dagger/example/atm/Database.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.atm;
+
+import java.math.BigDecimal;
+
+/** An ATM database. */
+interface Database {
+ Account getAccount(String username);
+
+ /** An individual user's account. */
+ interface Account {
+ String username();
+
+ void deposit(BigDecimal amount);
+
+ void withdraw(BigDecimal amount);
+
+ BigDecimal balance();
+ }
+}
diff --git a/java/dagger/example/atm/DepositCommand.java b/java/dagger/example/atm/DepositCommand.java
new file mode 100644
index 0000000..9a5e2e2
--- /dev/null
+++ b/java/dagger/example/atm/DepositCommand.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.atm;
+
+import dagger.example.atm.Database.Account;
+import java.math.BigDecimal;
+import javax.inject.Inject;
+
+/** Deposits money to the ATM. */
+final class DepositCommand extends BigDecimalCommand {
+ private final Outputter outputter;
+ private final Account account;
+ private final WithdrawalLimiter withdrawalLimiter;
+
+ @Inject
+ DepositCommand(Outputter outputter, Account account, WithdrawalLimiter withdrawalLimiter) {
+ super(outputter);
+ this.outputter = outputter;
+ this.account = account;
+ this.withdrawalLimiter = withdrawalLimiter;
+ }
+
+ @Override
+ protected void handleAmount(BigDecimal amount) {
+ account.deposit(amount);
+ withdrawalLimiter.recordDeposit(amount);
+ outputter.output("your new balance is: " + account.balance());
+ }
+}
diff --git a/java/dagger/example/atm/HelloWorldCommand.java b/java/dagger/example/atm/HelloWorldCommand.java
new file mode 100644
index 0000000..f39d585
--- /dev/null
+++ b/java/dagger/example/atm/HelloWorldCommand.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.atm;
+
+import java.util.List;
+import javax.inject.Inject;
+
+final class HelloWorldCommand implements Command {
+ private final Outputter outputter;
+
+ @Inject
+ HelloWorldCommand(Outputter outputter) {
+ this.outputter = outputter;
+ }
+
+ @Override
+ public Result handleInput(List<String> args) {
+ if (!args.isEmpty()) {
+ return Result.invalid();
+ }
+ outputter.output("howdy!");
+ return Result.handled();
+ }
+}
diff --git a/java/dagger/example/atm/InMemoryDatabase.java b/java/dagger/example/atm/InMemoryDatabase.java
new file mode 100644
index 0000000..801d827
--- /dev/null
+++ b/java/dagger/example/atm/InMemoryDatabase.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.atm;
+
+import java.math.BigDecimal;
+import java.util.HashMap;
+import java.util.Map;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+/** A database that stores all of its data in memory. */
+@Singleton
+final class InMemoryDatabase implements Database {
+ private final Map<String, Account> accounts = new HashMap<>();
+
+ @Inject
+ InMemoryDatabase() {}
+
+ @Override
+ public Account getAccount(String username) {
+ return accounts.computeIfAbsent(username, InMemoryAccount::new);
+ }
+
+ private static final class InMemoryAccount implements Account {
+ private final String username;
+ private BigDecimal balance = BigDecimal.ZERO;
+
+ InMemoryAccount(String username) {
+ this.username = username;
+ }
+
+ @Override
+ public String username() {
+ return username;
+ }
+
+ @Override
+ public void deposit(BigDecimal amount) {
+ checkNonNegative(amount, "deposit");
+ balance = balance.add(amount);
+ }
+
+ @Override
+ public void withdraw(BigDecimal amount) {
+ checkNonNegative(amount, "withdraw");
+ balance = balance.subtract(amount);
+ }
+
+ private void checkNonNegative(BigDecimal amount, String action) {
+ if (amount.signum() == -1) {
+ throw new IllegalArgumentException(
+ String.format("Cannot %s negative amounts: %s", action, amount));
+ }
+ }
+
+ @Override
+ public BigDecimal balance() {
+ return balance;
+ }
+ }
+}
diff --git a/java/dagger/example/atm/InMemoryDatabaseModule.java b/java/dagger/example/atm/InMemoryDatabaseModule.java
new file mode 100644
index 0000000..bf4be67
--- /dev/null
+++ b/java/dagger/example/atm/InMemoryDatabaseModule.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.atm;
+
+import dagger.Binds;
+import dagger.Module;
+
+@Module
+interface InMemoryDatabaseModule {
+ @Binds
+ Database inMemory(InMemoryDatabase database);
+}
diff --git a/java/dagger/example/atm/LoginCommand.java b/java/dagger/example/atm/LoginCommand.java
new file mode 100644
index 0000000..4978cb5
--- /dev/null
+++ b/java/dagger/example/atm/LoginCommand.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.atm;
+
+import dagger.example.atm.Database.Account;
+import java.util.Optional;
+import javax.inject.Inject;
+
+/** Logs in a user, allowing them to interact with the ATM. */
+final class LoginCommand extends SingleArgCommand {
+ private final Outputter outputter;
+ private final Optional<Account> account;
+ private final UserCommandsRouter.Factory userCommandsFactory;
+
+ @Inject
+ LoginCommand(
+ Outputter outputter,
+ Optional<Account> account,
+ UserCommandsRouter.Factory userCommandsFactory) {
+ this.outputter = outputter;
+ this.account = account;
+ this.userCommandsFactory = userCommandsFactory;
+ }
+
+ @Override
+ public Result handleArg(String username) {
+ // If an Account binding exists, that means there is a user logged in. Don't allow a login
+ // command if we already have someone logged in!
+ if (account.isPresent()) {
+ String loggedInUser = account.get().username();
+ outputter.output(loggedInUser + " is already logged in");
+ if (!loggedInUser.equals(username)) {
+ outputter.output("run `logout` first before trying to log in another user");
+ }
+ return Result.handled();
+ } else {
+ UserCommandsRouter userCommands = userCommandsFactory.create(username);
+ return Result.enterNestedCommandSet(userCommands.router());
+ }
+ }
+}
diff --git a/java/dagger/example/atm/LogoutCommand.java b/java/dagger/example/atm/LogoutCommand.java
new file mode 100644
index 0000000..811d4b3
--- /dev/null
+++ b/java/dagger/example/atm/LogoutCommand.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.atm;
+
+import dagger.example.atm.Database.Account;
+import java.util.List;
+import javax.inject.Inject;
+
+/** Logs out the current user. */
+final class LogoutCommand implements Command {
+
+ private final Outputter outputter;
+ private final Account account;
+
+ @Inject
+ LogoutCommand(Outputter outputter, Account account) {
+ this.outputter = outputter;
+ this.account = account;
+ }
+
+ @Override
+ public Result handleInput(List<String> input) {
+ if (!input.isEmpty()) {
+ return Result.invalid();
+ }
+ outputter.output("logged out " + account.username());
+ return Result.inputCompleted();
+ }
+}
diff --git a/java/dagger/example/atm/MaximumWithdrawal.java b/java/dagger/example/atm/MaximumWithdrawal.java
new file mode 100644
index 0000000..d41c559
--- /dev/null
+++ b/java/dagger/example/atm/MaximumWithdrawal.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.atm;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import javax.inject.Qualifier;
+
+/**
+ * Qualifier for the maximum amount that can be withdrawn from an account in a single transaction.
+ */
+@Qualifier
+@Documented
+@Retention(RUNTIME)
+@interface MaximumWithdrawal {}
diff --git a/java/dagger/example/atm/MinimumBalance.java b/java/dagger/example/atm/MinimumBalance.java
new file mode 100644
index 0000000..bbb0ed1
--- /dev/null
+++ b/java/dagger/example/atm/MinimumBalance.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.atm;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import javax.inject.Qualifier;
+
+/** Qualifier for the minimum balance an account may have. */
+@Qualifier
+@Documented
+@Retention(RUNTIME)
+@interface MinimumBalance {}
diff --git a/java/dagger/example/atm/Outputter.java b/java/dagger/example/atm/Outputter.java
new file mode 100644
index 0000000..3d8de8a
--- /dev/null
+++ b/java/dagger/example/atm/Outputter.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.atm;
+
+/** Writes to a user interface. */
+interface Outputter {
+ void output(String output);
+}
diff --git a/java/dagger/example/atm/PerSession.java b/java/dagger/example/atm/PerSession.java
new file mode 100644
index 0000000..22faba5
--- /dev/null
+++ b/java/dagger/example/atm/PerSession.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.atm;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import javax.inject.Scope;
+
+/** A scope for instances that should be retained within a user session. */
+@Retention(RUNTIME)
+@Scope
+@Documented
+@interface PerSession {}
diff --git a/java/dagger/example/atm/SingleArgCommand.java b/java/dagger/example/atm/SingleArgCommand.java
new file mode 100644
index 0000000..81e5f65
--- /dev/null
+++ b/java/dagger/example/atm/SingleArgCommand.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.atm;
+
+import java.util.List;
+
+/** Abstract command that accepts a single argument. */
+abstract class SingleArgCommand implements Command {
+
+ @Override
+ public final Result handleInput(List<String> input) {
+ return input.size() == 1 ? handleArg(input.get(0)) : Result.invalid();
+ }
+
+ /** Handles the single argument to the command. */
+ protected abstract Result handleArg(String arg);
+}
diff --git a/java/dagger/example/atm/SystemOutModule.java b/java/dagger/example/atm/SystemOutModule.java
new file mode 100644
index 0000000..3c22941
--- /dev/null
+++ b/java/dagger/example/atm/SystemOutModule.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.atm;
+
+import dagger.Module;
+import dagger.Provides;
+
+@Module
+final class SystemOutModule {
+ @Provides
+ static Outputter textOutputter() {
+ return System.out::println;
+ }
+}
diff --git a/java/dagger/example/atm/UserCommandsModule.java b/java/dagger/example/atm/UserCommandsModule.java
new file mode 100644
index 0000000..bee4450
--- /dev/null
+++ b/java/dagger/example/atm/UserCommandsModule.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.atm;
+
+import dagger.Binds;
+import dagger.Module;
+import dagger.multibindings.IntoMap;
+import dagger.multibindings.StringKey;
+
+/** Commands that are only applicable when a user is logged in. */
+@Module
+interface UserCommandsModule {
+ @Binds
+ @IntoMap
+ @StringKey("deposit")
+ Command deposit(DepositCommand command);
+
+ @Binds
+ @IntoMap
+ @StringKey("withdraw")
+ Command withdraw(WithdrawCommand command);
+
+ @Binds
+ @IntoMap
+ @StringKey("logout")
+ Command logout(LogoutCommand command);
+}
diff --git a/java/dagger/example/atm/UserCommandsRouter.java b/java/dagger/example/atm/UserCommandsRouter.java
new file mode 100644
index 0000000..7d65989
--- /dev/null
+++ b/java/dagger/example/atm/UserCommandsRouter.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.atm;
+
+import dagger.BindsInstance;
+import dagger.Module;
+import dagger.Subcomponent;
+
+@PerSession
+@Subcomponent(modules = {AccountModule.class, AmountsModule.class, UserCommandsModule.class})
+interface UserCommandsRouter {
+ CommandRouter router();
+
+ @Subcomponent.Factory
+ interface Factory {
+ UserCommandsRouter create(@BindsInstance @Username String username);
+ }
+
+ @Module(subcomponents = UserCommandsRouter.class)
+ interface InstallationModule {}
+}
diff --git a/java/dagger/example/atm/Username.java b/java/dagger/example/atm/Username.java
new file mode 100644
index 0000000..7972844
--- /dev/null
+++ b/java/dagger/example/atm/Username.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.atm;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import javax.inject.Qualifier;
+
+/** Qualifier for the currently logged-in user. */
+@Retention(RUNTIME)
+@Qualifier
+@Documented
+@interface Username {}
diff --git a/java/dagger/example/atm/WithdrawCommand.java b/java/dagger/example/atm/WithdrawCommand.java
new file mode 100644
index 0000000..7e0cf04
--- /dev/null
+++ b/java/dagger/example/atm/WithdrawCommand.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.atm;
+
+import dagger.example.atm.Database.Account;
+import java.math.BigDecimal;
+import javax.inject.Inject;
+
+/** Withdraws money from the ATM. */
+final class WithdrawCommand extends BigDecimalCommand {
+ private final Outputter outputter;
+ private final Account account;
+ private final BigDecimal minimumBalance;
+ private final WithdrawalLimiter withdrawalLimiter;
+
+ @Inject
+ WithdrawCommand(
+ Outputter outputter,
+ Account account,
+ @MinimumBalance BigDecimal minimumBalance,
+ WithdrawalLimiter withdrawalLimiter) {
+ super(outputter);
+ this.outputter = outputter;
+ this.account = account;
+ this.minimumBalance = minimumBalance;
+ this.withdrawalLimiter = withdrawalLimiter;
+ }
+
+ @Override
+ protected void handleAmount(BigDecimal amount) {
+ BigDecimal remainingWithdrawalLimit = withdrawalLimiter.remainingWithdrawalLimit();
+ if (amount.compareTo(remainingWithdrawalLimit) > 0) {
+ outputter.output(
+ String.format(
+ "you may not withdraw %s; you may withdraw %s more in this session",
+ amount, remainingWithdrawalLimit));
+ return;
+ }
+
+ BigDecimal newBalance = account.balance().subtract(amount);
+ if (newBalance.compareTo(minimumBalance) < 0) {
+ outputter.output(
+ String.format(
+ "you don't have sufficient funds to withdraw %s. "
+ + "your balance is %s and the minimum balance is %s",
+ amount, account.balance(), minimumBalance));
+ } else {
+ account.withdraw(amount);
+ withdrawalLimiter.recordWithdrawal(amount);
+ outputter.output("your new balance is: " + account.balance());
+ }
+ }
+}
diff --git a/java/dagger/example/atm/WithdrawalLimiter.java b/java/dagger/example/atm/WithdrawalLimiter.java
new file mode 100644
index 0000000..c473b68
--- /dev/null
+++ b/java/dagger/example/atm/WithdrawalLimiter.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.atm;
+
+import java.math.BigDecimal;
+import javax.inject.Inject;
+
+/** Maintains the withdrawal amount available within a user session. */
+@PerSession
+final class WithdrawalLimiter {
+ private BigDecimal remainingWithdrawalLimit;
+
+ @Inject
+ WithdrawalLimiter(@MaximumWithdrawal BigDecimal maximumWithdrawal) {
+ this.remainingWithdrawalLimit = maximumWithdrawal;
+ }
+
+ void recordDeposit(BigDecimal amount) {
+ remainingWithdrawalLimit = remainingWithdrawalLimit.add(amount);
+ }
+
+ void recordWithdrawal(BigDecimal amount) {
+ remainingWithdrawalLimit = remainingWithdrawalLimit.subtract(amount);
+ }
+
+ BigDecimal remainingWithdrawalLimit() {
+ return remainingWithdrawalLimit;
+ }
+}
diff --git a/java/dagger/example/atm/build.gradle b/java/dagger/example/atm/build.gradle
new file mode 100644
index 0000000..2e6d3f4
--- /dev/null
+++ b/java/dagger/example/atm/build.gradle
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+plugins {
+ id 'java'
+ id 'application'
+}
+
+repositories {
+ mavenCentral()
+}
+
+sourceSets {
+ main {
+ java {
+ srcDir '.'
+ }
+ }
+}
+
+dependencies {
+ implementation 'com.google.dagger:dagger:2.23.2'
+ annotationProcessor 'com.google.dagger:dagger-compiler:2.23.2'
+}
+
+mainClassName = 'dagger.example.atm.CommandLineAtm'
+
+// Run with: `gradle run -q --console=plain`
+run {
+ standardInput = System.in
+}
diff --git a/java/dagger/example/atm/gradlew b/java/dagger/example/atm/gradlew
new file mode 100755
index 0000000..b0d6d0a
--- /dev/null
+++ b/java/dagger/example/atm/gradlew
@@ -0,0 +1,188 @@
+#!/usr/bin/env sh
+
+#
+# Copyright 2015 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+##
+## Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+ ls=`ls -ld "$PRG"`
+ link=`expr "$ls" : '.*-> \(.*\)$'`
+ if expr "$link" : '/.*' > /dev/null; then
+ PRG="$link"
+ else
+ PRG=`dirname "$PRG"`"/$link"
+ fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+ echo "$*"
+}
+
+die () {
+ echo
+ echo "$*"
+ echo
+ exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+ CYGWIN* )
+ cygwin=true
+ ;;
+ Darwin* )
+ darwin=true
+ ;;
+ MINGW* )
+ msys=true
+ ;;
+ NONSTOP* )
+ nonstop=true
+ ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+ if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+ # IBM's JDK on AIX uses strange locations for the executables
+ JAVACMD="$JAVA_HOME/jre/sh/java"
+ else
+ JAVACMD="$JAVA_HOME/bin/java"
+ fi
+ if [ ! -x "$JAVACMD" ] ; then
+ die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+ fi
+else
+ JAVACMD="java"
+ which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+ MAX_FD_LIMIT=`ulimit -H -n`
+ if [ $? -eq 0 ] ; then
+ if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+ MAX_FD="$MAX_FD_LIMIT"
+ fi
+ ulimit -n $MAX_FD
+ if [ $? -ne 0 ] ; then
+ warn "Could not set maximum file descriptor limit: $MAX_FD"
+ fi
+ else
+ warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+ fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+ GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+ APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+ CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+ JAVACMD=`cygpath --unix "$JAVACMD"`
+
+ # We build the pattern for arguments to be converted via cygpath
+ ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+ SEP=""
+ for dir in $ROOTDIRSRAW ; do
+ ROOTDIRS="$ROOTDIRS$SEP$dir"
+ SEP="|"
+ done
+ OURCYGPATTERN="(^($ROOTDIRS))"
+ # Add a user-defined pattern to the cygpath arguments
+ if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+ OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+ fi
+ # Now convert the arguments - kludge to limit ourselves to /bin/sh
+ i=0
+ for arg in "$@" ; do
+ CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+ CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
+
+ if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
+ eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+ else
+ eval `echo args$i`="\"$arg\""
+ fi
+ i=$((i+1))
+ done
+ case $i in
+ (0) set -- ;;
+ (1) set -- "$args0" ;;
+ (2) set -- "$args0" "$args1" ;;
+ (3) set -- "$args0" "$args1" "$args2" ;;
+ (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+ (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+ (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+ (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+ (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+ (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+ esac
+fi
+
+# Escape application args
+save () {
+ for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+ echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+ cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"
diff --git a/java/dagger/example/atm/gradlew.bat b/java/dagger/example/atm/gradlew.bat
new file mode 100644
index 0000000..9991c50
--- /dev/null
+++ b/java/dagger/example/atm/gradlew.bat
@@ -0,0 +1,100 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem http://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/java/dagger/example/atm/settings.gradle b/java/dagger/example/atm/settings.gradle
new file mode 100644
index 0000000..a6f2e01
--- /dev/null
+++ b/java/dagger/example/atm/settings.gradle
@@ -0,0 +1,17 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+rootProject.name = 'dagger-tutorial-atm'
diff --git a/java/dagger/example/gradle/android/simple/app/build.gradle b/java/dagger/example/gradle/android/simple/app/build.gradle
new file mode 100644
index 0000000..d8f6346
--- /dev/null
+++ b/java/dagger/example/gradle/android/simple/app/build.gradle
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+apply plugin: 'com.android.application'
+
+android {
+ compileSdkVersion 30
+ buildToolsVersion "30.0.2"
+
+ defaultConfig {
+ applicationId "dagger.example.gradle.android.simple"
+ minSdkVersion 15
+ targetSdkVersion 30
+ versionCode 1
+ versionName "1.0"
+ }
+}
+
+dependencies {
+ implementation 'androidx.appcompat:appcompat:1.2.0'
+ implementation 'com.google.dagger:dagger:LOCAL-SNAPSHOT'
+ implementation 'com.google.dagger:dagger-android-support:LOCAL-SNAPSHOT'
+ annotationProcessor 'com.google.dagger:dagger-compiler:LOCAL-SNAPSHOT'
+ annotationProcessor 'com.google.dagger:dagger-android-processor:LOCAL-SNAPSHOT'
+
+ // To help us catch usages of Guava APIs for Java 8 in the '-jre' variant.
+ annotationProcessor'com.google.guava:guava:28.1-android'
+}
diff --git a/java/dagger/example/gradle/android/simple/app/src/main/AndroidManifest.xml b/java/dagger/example/gradle/android/simple/app/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..cc666d2
--- /dev/null
+++ b/java/dagger/example/gradle/android/simple/app/src/main/AndroidManifest.xml
@@ -0,0 +1,30 @@
+<!--
+ ~ Copyright (C) 2017 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="dagger.example.gradle.android.simple">
+
+ <application
+ android:name=".SimpleApplication"
+ android:label="@string/appName"
+ android:theme="@style/Theme.AppCompat.Light">
+ <activity android:name=".SimpleActivity" android:exported="true">
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN" />
+ <category android:name="android.intent.category.LAUNCHER" />
+ </intent-filter>
+ </activity>
+ </application>
+</manifest>
diff --git a/java/dagger/example/gradle/android/simple/app/src/main/java/dagger/example/gradle/android/simple/BuildModule.java b/java/dagger/example/gradle/android/simple/app/src/main/java/dagger/example/gradle/android/simple/BuildModule.java
new file mode 100644
index 0000000..f6317c2
--- /dev/null
+++ b/java/dagger/example/gradle/android/simple/app/src/main/java/dagger/example/gradle/android/simple/BuildModule.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.gradle.android.simple;
+
+import static android.os.Build.MODEL;
+
+import dagger.Module;
+import dagger.Provides;
+
+@Module
+final class BuildModule {
+ @Provides
+ @Model
+ static String provideModel() {
+ return MODEL;
+ }
+}
diff --git a/java/dagger/example/gradle/android/simple/app/src/main/java/dagger/example/gradle/android/simple/Model.java b/java/dagger/example/gradle/android/simple/app/src/main/java/dagger/example/gradle/android/simple/Model.java
new file mode 100644
index 0000000..30a973e
--- /dev/null
+++ b/java/dagger/example/gradle/android/simple/app/src/main/java/dagger/example/gradle/android/simple/Model.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.gradle.android.simple;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import javax.inject.Qualifier;
+
+/** Qualifies bindings relating to {@link android.os.Build#MODEL}. */
+@Qualifier
+@Retention(RUNTIME)
+@Documented
+@interface Model {}
diff --git a/java/dagger/example/gradle/android/simple/app/src/main/java/dagger/example/gradle/android/simple/SimpleActivity.java b/java/dagger/example/gradle/android/simple/app/src/main/java/dagger/example/gradle/android/simple/SimpleActivity.java
new file mode 100644
index 0000000..734590a
--- /dev/null
+++ b/java/dagger/example/gradle/android/simple/app/src/main/java/dagger/example/gradle/android/simple/SimpleActivity.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.gradle.android.simple;
+
+import android.os.Bundle;
+import android.util.Log;
+import android.widget.TextView;
+import dagger.Binds;
+import dagger.Module;
+import dagger.Subcomponent;
+import dagger.android.AndroidInjector;
+import dagger.android.support.DaggerAppCompatActivity;
+import dagger.multibindings.ClassKey;
+import dagger.multibindings.IntoMap;
+import javax.inject.Inject;
+
+/**
+ * The main activity of the application.
+ *
+ * <p>It can be injected with any binding from both {@link SimpleActivityComponent} and {@link
+ * SimpleApplication.SimpleComponent}.
+ */
+public class SimpleActivity extends DaggerAppCompatActivity {
+ @Subcomponent
+ interface SimpleActivityComponent extends AndroidInjector<SimpleActivity> {
+
+ @Subcomponent.Factory
+ interface Factory extends AndroidInjector.Factory<SimpleActivity> {}
+ }
+
+ @Module(subcomponents = SimpleActivityComponent.class)
+ abstract static class InjectorModule {
+
+ @Binds
+ @IntoMap
+ @ClassKey(SimpleActivity.class)
+ abstract AndroidInjector.Factory<?> bind(SimpleActivityComponent.Factory factory);
+ }
+
+ private static final String TAG = SimpleActivity.class.getSimpleName();
+
+ @Inject @Model String model;
+
+ @Inject
+ void logInjection() {
+ Log.i(TAG, "Injecting");
+ }
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+
+ setContentView(R.layout.activity_main);
+
+ TextView greeting = (TextView) findViewById(R.id.greeting);
+ String text = getResources().getString(R.string.welcome, model);
+ greeting.setText(text);
+ }
+}
diff --git a/java/dagger/example/gradle/android/simple/app/src/main/java/dagger/example/gradle/android/simple/SimpleApplication.java b/java/dagger/example/gradle/android/simple/app/src/main/java/dagger/example/gradle/android/simple/SimpleApplication.java
new file mode 100644
index 0000000..e2e34ea
--- /dev/null
+++ b/java/dagger/example/gradle/android/simple/app/src/main/java/dagger/example/gradle/android/simple/SimpleApplication.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.gradle.android.simple;
+
+import android.util.Log;
+import dagger.Component;
+import dagger.android.AndroidInjectionModule;
+import dagger.android.AndroidInjector;
+import dagger.android.DaggerApplication;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+/**
+ * A simple, skeletal application that demonstrates a dependency-injected application using the
+ * utilities in {@code dagger.android}.
+ */
+public class SimpleApplication extends DaggerApplication {
+ private static final String TAG = SimpleApplication.class.getSimpleName();
+
+ @Singleton
+ @Component(
+ modules = {
+ AndroidInjectionModule.class,
+ SimpleActivity.InjectorModule.class,
+ BuildModule.class
+ }
+ )
+ interface SimpleComponent extends AndroidInjector<SimpleApplication> {
+ @Component.Factory
+ interface Factory extends AndroidInjector.Factory<SimpleApplication> {}
+ }
+
+ @Inject
+ void logInjection() {
+ Log.i(TAG, "Injecting " + SimpleApplication.class.getSimpleName());
+ }
+
+ @Override
+ public void onCreate() {
+ super.onCreate();
+ }
+
+ @Override
+ protected AndroidInjector<SimpleApplication> applicationInjector() {
+ return DaggerSimpleApplication_SimpleComponent.factory().create(this);
+ }
+}
diff --git a/java/dagger/example/gradle/android/simple/app/src/main/res/layout/activity_main.xml b/java/dagger/example/gradle/android/simple/app/src/main/res/layout/activity_main.xml
new file mode 100644
index 0000000..18a547b
--- /dev/null
+++ b/java/dagger/example/gradle/android/simple/app/src/main/res/layout/activity_main.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ Copyright (C) 2017 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+ android:layout_width="match_parent"
+ android:layout_height="match_parent"
+ android:background="@android:color/background_light">
+
+ <TextView
+ android:id="@+id/greeting"
+ android:layout_width="match_parent"
+ android:layout_height="match_parent"
+ android:layout_alignParentTop="true"
+ android:textColor="@android:color/primary_text_light"
+ />
+</RelativeLayout>
diff --git a/java/dagger/example/gradle/android/simple/app/src/main/res/values/strings.xml b/java/dagger/example/gradle/android/simple/app/src/main/res/values/strings.xml
new file mode 100644
index 0000000..f45fd41
--- /dev/null
+++ b/java/dagger/example/gradle/android/simple/app/src/main/res/values/strings.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+ <string name="appName">Simple Dagger Android</string>
+ <string name="welcome">Hello, %s!</string>
+</resources>
diff --git a/java/dagger/example/gradle/android/simple/build.gradle b/java/dagger/example/gradle/android/simple/build.gradle
new file mode 100644
index 0000000..50f8f0b
--- /dev/null
+++ b/java/dagger/example/gradle/android/simple/build.gradle
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+buildscript {
+ repositories {
+ google()
+ jcenter()
+ }
+ dependencies {
+ classpath 'com.android.tools.build:gradle:4.1.1'
+ }
+}
+
+allprojects {
+ repositories {
+ google()
+ jcenter()
+ mavenCentral()
+ mavenLocal()
+ }
+}
+
diff --git a/java/dagger/example/gradle/android/simple/gradle.properties b/java/dagger/example/gradle/android/simple/gradle.properties
new file mode 100644
index 0000000..2d8d1e4
--- /dev/null
+++ b/java/dagger/example/gradle/android/simple/gradle.properties
@@ -0,0 +1 @@
+android.useAndroidX=true
\ No newline at end of file
diff --git a/java/dagger/example/gradle/android/simple/gradle/wrapper/gradle-wrapper.jar b/java/dagger/example/gradle/android/simple/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000..5c2d1cf
--- /dev/null
+++ b/java/dagger/example/gradle/android/simple/gradle/wrapper/gradle-wrapper.jar
Binary files differ
diff --git a/java/dagger/example/gradle/android/simple/gradle/wrapper/gradle-wrapper.properties b/java/dagger/example/gradle/android/simple/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000..4d9ca16
--- /dev/null
+++ b/java/dagger/example/gradle/android/simple/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.7.1-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/java/dagger/example/gradle/android/simple/gradlew b/java/dagger/example/gradle/android/simple/gradlew
new file mode 100755
index 0000000..b0d6d0a
--- /dev/null
+++ b/java/dagger/example/gradle/android/simple/gradlew
@@ -0,0 +1,188 @@
+#!/usr/bin/env sh
+
+#
+# Copyright 2015 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+##
+## Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+ ls=`ls -ld "$PRG"`
+ link=`expr "$ls" : '.*-> \(.*\)$'`
+ if expr "$link" : '/.*' > /dev/null; then
+ PRG="$link"
+ else
+ PRG=`dirname "$PRG"`"/$link"
+ fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+ echo "$*"
+}
+
+die () {
+ echo
+ echo "$*"
+ echo
+ exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+ CYGWIN* )
+ cygwin=true
+ ;;
+ Darwin* )
+ darwin=true
+ ;;
+ MINGW* )
+ msys=true
+ ;;
+ NONSTOP* )
+ nonstop=true
+ ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+ if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+ # IBM's JDK on AIX uses strange locations for the executables
+ JAVACMD="$JAVA_HOME/jre/sh/java"
+ else
+ JAVACMD="$JAVA_HOME/bin/java"
+ fi
+ if [ ! -x "$JAVACMD" ] ; then
+ die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+ fi
+else
+ JAVACMD="java"
+ which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+ MAX_FD_LIMIT=`ulimit -H -n`
+ if [ $? -eq 0 ] ; then
+ if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+ MAX_FD="$MAX_FD_LIMIT"
+ fi
+ ulimit -n $MAX_FD
+ if [ $? -ne 0 ] ; then
+ warn "Could not set maximum file descriptor limit: $MAX_FD"
+ fi
+ else
+ warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+ fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+ GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+ APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+ CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+ JAVACMD=`cygpath --unix "$JAVACMD"`
+
+ # We build the pattern for arguments to be converted via cygpath
+ ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+ SEP=""
+ for dir in $ROOTDIRSRAW ; do
+ ROOTDIRS="$ROOTDIRS$SEP$dir"
+ SEP="|"
+ done
+ OURCYGPATTERN="(^($ROOTDIRS))"
+ # Add a user-defined pattern to the cygpath arguments
+ if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+ OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+ fi
+ # Now convert the arguments - kludge to limit ourselves to /bin/sh
+ i=0
+ for arg in "$@" ; do
+ CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+ CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
+
+ if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
+ eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+ else
+ eval `echo args$i`="\"$arg\""
+ fi
+ i=$((i+1))
+ done
+ case $i in
+ (0) set -- ;;
+ (1) set -- "$args0" ;;
+ (2) set -- "$args0" "$args1" ;;
+ (3) set -- "$args0" "$args1" "$args2" ;;
+ (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+ (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+ (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+ (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+ (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+ (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+ esac
+fi
+
+# Escape application args
+save () {
+ for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+ echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+ cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"
diff --git a/java/dagger/example/gradle/android/simple/settings.gradle b/java/dagger/example/gradle/android/simple/settings.gradle
new file mode 100644
index 0000000..c5a07bc
--- /dev/null
+++ b/java/dagger/example/gradle/android/simple/settings.gradle
@@ -0,0 +1,2 @@
+include ':app'
+rootProject.name='Simple Dagger Android'
\ No newline at end of file
diff --git a/java/dagger/example/gradle/simple/SimpleApplication.java b/java/dagger/example/gradle/simple/SimpleApplication.java
new file mode 100644
index 0000000..11552f8
--- /dev/null
+++ b/java/dagger/example/gradle/simple/SimpleApplication.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.example.gradle.simple;
+
+import dagger.Component;
+import dagger.Module;
+import dagger.Provides;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+/** A simple, skeletal application that defines a simple component. */
+public class SimpleApplication {
+ static final class Foo {
+ @Inject Foo() {}
+ }
+
+ @Module
+ static final class SimpleModule {
+ @Provides
+ static Foo provideFoo() {
+ return new Foo();
+ }
+ }
+
+ @Singleton
+ @Component(modules = { SimpleModule.class })
+ interface SimpleComponent {
+ Foo foo();
+ }
+
+ public static void main(String[] args) {
+ Foo foo = DaggerSimpleApplication_SimpleComponent.create().foo();
+ }
+}
diff --git a/java/dagger/example/gradle/simple/build.gradle b/java/dagger/example/gradle/simple/build.gradle
new file mode 100644
index 0000000..c9e59ef
--- /dev/null
+++ b/java/dagger/example/gradle/simple/build.gradle
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+plugins {
+ id 'java'
+ id 'application'
+}
+
+repositories {
+ mavenCentral()
+ mavenLocal()
+}
+
+sourceSets {
+ main {
+ java {
+ srcDir '.'
+ }
+ }
+}
+
+dependencies {
+ implementation 'com.google.dagger:dagger:LOCAL-SNAPSHOT'
+ annotationProcessor 'com.google.dagger:dagger-compiler:LOCAL-SNAPSHOT'
+}
+
+mainClassName = 'dagger.example.gradle.simple.SimpleApplication'
\ No newline at end of file
diff --git a/java/dagger/example/gradle/simple/gradle/wrapper/gradle-wrapper.jar b/java/dagger/example/gradle/simple/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000..5c2d1cf
--- /dev/null
+++ b/java/dagger/example/gradle/simple/gradle/wrapper/gradle-wrapper.jar
Binary files differ
diff --git a/java/dagger/example/gradle/simple/gradle/wrapper/gradle-wrapper.properties b/java/dagger/example/gradle/simple/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000..4d9ca16
--- /dev/null
+++ b/java/dagger/example/gradle/simple/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.7.1-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/java/dagger/example/gradle/simple/gradlew b/java/dagger/example/gradle/simple/gradlew
new file mode 100755
index 0000000..b0d6d0a
--- /dev/null
+++ b/java/dagger/example/gradle/simple/gradlew
@@ -0,0 +1,188 @@
+#!/usr/bin/env sh
+
+#
+# Copyright 2015 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+##
+## Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+ ls=`ls -ld "$PRG"`
+ link=`expr "$ls" : '.*-> \(.*\)$'`
+ if expr "$link" : '/.*' > /dev/null; then
+ PRG="$link"
+ else
+ PRG=`dirname "$PRG"`"/$link"
+ fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+ echo "$*"
+}
+
+die () {
+ echo
+ echo "$*"
+ echo
+ exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+ CYGWIN* )
+ cygwin=true
+ ;;
+ Darwin* )
+ darwin=true
+ ;;
+ MINGW* )
+ msys=true
+ ;;
+ NONSTOP* )
+ nonstop=true
+ ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+ if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+ # IBM's JDK on AIX uses strange locations for the executables
+ JAVACMD="$JAVA_HOME/jre/sh/java"
+ else
+ JAVACMD="$JAVA_HOME/bin/java"
+ fi
+ if [ ! -x "$JAVACMD" ] ; then
+ die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+ fi
+else
+ JAVACMD="java"
+ which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+ MAX_FD_LIMIT=`ulimit -H -n`
+ if [ $? -eq 0 ] ; then
+ if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+ MAX_FD="$MAX_FD_LIMIT"
+ fi
+ ulimit -n $MAX_FD
+ if [ $? -ne 0 ] ; then
+ warn "Could not set maximum file descriptor limit: $MAX_FD"
+ fi
+ else
+ warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+ fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+ GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+ APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+ CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+ JAVACMD=`cygpath --unix "$JAVACMD"`
+
+ # We build the pattern for arguments to be converted via cygpath
+ ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+ SEP=""
+ for dir in $ROOTDIRSRAW ; do
+ ROOTDIRS="$ROOTDIRS$SEP$dir"
+ SEP="|"
+ done
+ OURCYGPATTERN="(^($ROOTDIRS))"
+ # Add a user-defined pattern to the cygpath arguments
+ if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+ OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+ fi
+ # Now convert the arguments - kludge to limit ourselves to /bin/sh
+ i=0
+ for arg in "$@" ; do
+ CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+ CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
+
+ if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
+ eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+ else
+ eval `echo args$i`="\"$arg\""
+ fi
+ i=$((i+1))
+ done
+ case $i in
+ (0) set -- ;;
+ (1) set -- "$args0" ;;
+ (2) set -- "$args0" "$args1" ;;
+ (3) set -- "$args0" "$args1" "$args2" ;;
+ (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+ (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+ (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+ (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+ (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+ (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+ esac
+fi
+
+# Escape application args
+save () {
+ for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+ echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+ cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"
diff --git a/java/dagger/example/spi/BUILD b/java/dagger/example/spi/BUILD
index 84b4a87..bd889c3 100644
--- a/java/dagger/example/spi/BUILD
+++ b/java/dagger/example/spi/BUILD
@@ -15,17 +15,20 @@
# Description:
# An example of the dagger.spi.BindingGraphPlugin usage
+load("@rules_java//java:defs.bzl", "java_plugin")
+
package(default_visibility = ["//:src"])
java_plugin(
name = "binding-graph-visualizer",
srcs = glob(["*.java"]),
deps = [
- "//java/dagger/model",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/internal/guava:graph",
"//java/dagger/spi",
"@google_bazel_common//third_party/java/auto:service",
"@google_bazel_common//third_party/java/error_prone:annotations",
- "@google_bazel_common//third_party/java/guava",
"@google_bazel_common//third_party/java/javapoet",
],
)
diff --git a/java/dagger/grpc/server/BUILD b/java/dagger/grpc/server/BUILD
index 1c57807..d9a2f97 100644
--- a/java/dagger/grpc/server/BUILD
+++ b/java/dagger/grpc/server/BUILD
@@ -1,9 +1,16 @@
# A framework supporting Dagger-injected gRPC servers.
-package(default_visibility = ["//:src"])
+load("@rules_java//java:defs.bzl", "java_library")
+load(
+ "//:build_defs.bzl",
+ "DOCLINT_HTML_AND_SYNTAX",
+ "DOCLINT_REFERENCES",
+ "POM_VERSION",
+)
+load("//tools:maven.bzl", "pom_file")
+load("@google_bazel_common//tools/javadoc:javadoc.bzl", "javadoc_library")
-load("//:build_defs.bzl", "DOCLINT_HTML_AND_SYNTAX", "DOCLINT_REFERENCES")
-load("//tools:maven.bzl", "pom_file", "POM_VERSION")
+package(default_visibility = ["//:src"])
ANNOTATIONS_SRCS = [
"CallScoped.java",
@@ -34,12 +41,13 @@
exports = [":annotations"],
deps = [
"//:dagger_with_compiler",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
"@google_bazel_common//third_party/java/auto:value",
"@google_bazel_common//third_party/java/grpc:context",
"@google_bazel_common//third_party/java/grpc:core",
"@google_bazel_common//third_party/java/grpc:netty",
"@google_bazel_common//third_party/java/grpc:protobuf",
- "@google_bazel_common//third_party/java/guava",
"@google_bazel_common//third_party/java/jsr330_inject",
"@google_bazel_common//third_party/java/protobuf",
],
@@ -64,8 +72,6 @@
srcs = glob(["*.java"]),
)
-load("@google_bazel_common//tools/javadoc:javadoc.bzl", "javadoc_library")
-
javadoc_library(
name = "javadoc",
srcs = [":javadoc-srcs"],
diff --git a/java/dagger/grpc/server/README.md b/java/dagger/grpc/server/README.md
index 5fe8d5c..a864f36 100644
--- a/java/dagger/grpc/server/README.md
+++ b/java/dagger/grpc/server/README.md
@@ -7,4 +7,4 @@
It is in development, and is planned for open-source release as part of Dagger.
-See user documentation at https://dagger.dev/grpc.
+See user documentation at https://dagger.dev/dev-guide/grpc.
diff --git a/java/dagger/grpc/server/processor/BUILD b/java/dagger/grpc/server/processor/BUILD
index ce02b06..dd33651 100644
--- a/java/dagger/grpc/server/processor/BUILD
+++ b/java/dagger/grpc/server/processor/BUILD
@@ -1,7 +1,13 @@
-package(default_visibility = ["//:src"])
+load("@rules_java//java:defs.bzl", "java_library", "java_plugin")
+load(
+ "//:build_defs.bzl",
+ "DOCLINT_HTML_AND_SYNTAX",
+ "POM_VERSION",
+)
+load("//tools:maven.bzl", "pom_file")
+load("@google_bazel_common//tools/javadoc:javadoc.bzl", "javadoc_library")
-load("//:build_defs.bzl", "DOCLINT_HTML_AND_SYNTAX")
-load("//tools:maven.bzl", "pom_file", "POM_VERSION")
+package(default_visibility = ["//:src"])
java_library(
name = "processor",
@@ -11,12 +17,14 @@
deps = [
"//:dagger_with_compiler",
"//java/dagger/grpc/server:annotations",
- "@google_bazel_common//third_party/java/auto:common",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/internal/guava:io",
"@google_bazel_common//third_party/java/auto:service",
"@google_bazel_common//third_party/java/google_java_format",
- "@google_bazel_common//third_party/java/guava",
"@google_bazel_common//third_party/java/javapoet",
"@google_bazel_common//third_party/java/jsr250_annotations",
+ "@maven//:com_google_auto_auto_common",
],
)
@@ -39,8 +47,6 @@
srcs = glob(["*.java"]),
)
-load("@google_bazel_common//tools/javadoc:javadoc.bzl", "javadoc_library")
-
javadoc_library(
name = "javadoc",
srcs = [":javadoc-srcs"],
diff --git a/java/dagger/grpc/server/processor/GrpcServiceProcessor.java b/java/dagger/grpc/server/processor/GrpcServiceProcessor.java
index e361fdb..9b74454 100644
--- a/java/dagger/grpc/server/processor/GrpcServiceProcessor.java
+++ b/java/dagger/grpc/server/processor/GrpcServiceProcessor.java
@@ -40,7 +40,7 @@
/**
* Generates code from types annotated with {@link GrpcService @GrpcService}.
*
- * @see <a href="https://dagger.dev/grpc">https://dagger.dev/grpc</a>
+ * @see <a href="https://dagger.dev/dev-guide/grpc">https://dagger.dev/dev-guide/grpc</a>
*/
@AutoService(Processor.class)
public class GrpcServiceProcessor extends BasicAnnotationProcessor implements ProcessingStep {
diff --git a/java/dagger/hilt/BUILD b/java/dagger/hilt/BUILD
new file mode 100644
index 0000000..94af18a
--- /dev/null
+++ b/java/dagger/hilt/BUILD
@@ -0,0 +1,240 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+load("//tools:maven.bzl", "gen_maven_artifact")
+load("//:build_defs.bzl", "POM_VERSION_ALPHA")
+
+# Description:
+# A library that wraps the Dagger API to make DI usage and testing easier.
+
+package(default_visibility = ["//:src"])
+
+java_library(
+ name = "install_in",
+ srcs = ["InstallIn.java"],
+ exported_plugins = [
+ "//java/dagger/hilt/processor/internal/aggregateddeps:plugin",
+ ],
+ exports = [
+ "//java/dagger/hilt/processor/internal/aggregateddeps:annotation",
+ ],
+ deps = [
+ ":generates_root_input",
+ ":package_info",
+ ],
+)
+
+java_library(
+ name = "entry_point",
+ srcs = [
+ "EntryPoint.java",
+ "EntryPoints.java",
+ ],
+ exported_plugins = [
+ # This is required so that we can fail if @InstallIn is missing.
+ # TODO(bcorso): Consider using a separate processor to validate @EntryPoint.
+ "//java/dagger/hilt/processor/internal/aggregateddeps:plugin",
+ ],
+ deps = [
+ ":generates_root_input",
+ ":package_info",
+ "//java/dagger/hilt/internal:component_manager",
+ "//java/dagger/hilt/internal:generated_component",
+ "@google_bazel_common//third_party/java/jsr305_annotations",
+ ],
+)
+
+java_library(
+ name = "generates_root_input",
+ srcs = [
+ "GeneratesRootInput.java",
+ ],
+ exported_plugins = [
+ "//java/dagger/hilt/processor/internal/generatesrootinput:processor",
+ ],
+ exports = [
+ "//java/dagger/hilt/internal/generatesrootinput",
+ ],
+ deps = [
+ ":package_info",
+ ],
+)
+
+java_library(
+ name = "define_component",
+ srcs = [
+ "DefineComponent.java",
+ ],
+ exported_plugins = [
+ "//java/dagger/hilt/processor/internal/definecomponent:processor",
+ ],
+ exports = [
+ "//java/dagger/hilt/internal/definecomponent",
+ ],
+ deps = [
+ ":generates_root_input",
+ ":package_info",
+ "//java/dagger/hilt/internal/definecomponent",
+ ],
+)
+
+java_library(
+ name = "package_info",
+ srcs = ["package-info.java"],
+ deps = [
+ "@google_bazel_common//third_party/java/jsr305_annotations",
+ ],
+)
+
+filegroup(
+ name = "javadoc-srcs",
+ srcs = [
+ ":hilt_android_filegroup",
+ ":hilt_android_testing_filegroup",
+ ":hilt_filegroup",
+ ":hilt_testing_filegroup",
+ ],
+)
+
+filegroup(
+ name = "hilt_filegroup",
+ srcs = glob(["*"]) + [
+ "//java/dagger/hilt/codegen:srcs_filegroup",
+ "//java/dagger/hilt/components:srcs_filegroup",
+ "//java/dagger/hilt/migration:srcs_filegroup",
+ "//java/dagger/hilt/internal:srcs_filegroup",
+ "//java/dagger/hilt/internal/aliasof:srcs_filegroup",
+ "//java/dagger/hilt/internal/definecomponent:srcs_filegroup",
+ "//java/dagger/hilt/internal/generatesrootinput:srcs_filegroup",
+ ],
+)
+
+filegroup(
+ name = "hilt_testing_filegroup",
+ srcs = [
+ "//java/dagger/hilt/testing:srcs_filegroup",
+ ],
+)
+
+filegroup(
+ name = "hilt_android_filegroup",
+ srcs = [
+ "//java/dagger/hilt/android:srcs_filegroup",
+ "//java/dagger/hilt/android/components:srcs_filegroup",
+ "//java/dagger/hilt/android/internal:srcs_filegroup",
+ "//java/dagger/hilt/android/internal/builders:srcs_filegroup",
+ "//java/dagger/hilt/android/internal/lifecycle:srcs_filegroup",
+ "//java/dagger/hilt/android/internal/managers:srcs_filegroup",
+ "//java/dagger/hilt/android/internal/migration:srcs_filegroup",
+ "//java/dagger/hilt/android/internal/modules:srcs_filegroup",
+ "//java/dagger/hilt/android/lifecycle:srcs_filegroup",
+ "//java/dagger/hilt/android/migration:srcs_filegroup",
+ "//java/dagger/hilt/android/plugin:srcs_filegroup",
+ "//java/dagger/hilt/android/qualifiers:srcs_filegroup",
+ "//java/dagger/hilt/android/scopes:srcs_filegroup",
+ ],
+)
+
+filegroup(
+ name = "hilt_android_testing_filegroup",
+ srcs = [
+ "//java/dagger/hilt/android/internal/testing:srcs_filegroup",
+ "//java/dagger/hilt/android/testing:srcs_filegroup",
+ ],
+)
+
+filegroup(
+ name = "hilt_processing_filegroup",
+ srcs = [
+ "//java/dagger/hilt/android/processor:srcs_filegroup",
+ "//java/dagger/hilt/android/processor/internal:srcs_filegroup",
+ "//java/dagger/hilt/android/processor/internal/androidentrypoint:srcs_filegroup",
+ "//java/dagger/hilt/android/processor/internal/bindvalue:srcs_filegroup",
+ "//java/dagger/hilt/android/processor/internal/customtestapplication:srcs_filegroup",
+ "//java/dagger/hilt/android/processor/internal/uninstallmodules:srcs_filegroup",
+ "//java/dagger/hilt/android/processor/internal/viewmodel:srcs_filegroup",
+ "//java/dagger/hilt/processor:srcs_filegroup",
+ "//java/dagger/hilt/processor/internal:srcs_filegroup",
+ "//java/dagger/hilt/processor/internal/aggregateddeps:srcs_filegroup",
+ "//java/dagger/hilt/processor/internal/aliasof:srcs_filegroup",
+ "//java/dagger/hilt/processor/internal/definecomponent:srcs_filegroup",
+ "//java/dagger/hilt/processor/internal/disableinstallincheck:srcs_filegroup",
+ "//java/dagger/hilt/processor/internal/generatesrootinput:srcs_filegroup",
+ "//java/dagger/hilt/processor/internal/originatingelement:srcs_filegroup",
+ "//java/dagger/hilt/processor/internal/root:srcs_filegroup",
+ ],
+)
+
+java_library(
+ name = "artifact-core-lib",
+ tags = ["maven_coordinates=com.google.dagger:hilt-core:" + POM_VERSION_ALPHA],
+ exports = [
+ ":define_component",
+ ":entry_point",
+ ":generates_root_input",
+ ":install_in",
+ ":package_info",
+ "//java/dagger:core",
+ "//java/dagger/hilt/components",
+ "//java/dagger/hilt/migration:alias_of",
+ "//java/dagger/hilt/migration:disable_install_in_check",
+ ],
+)
+
+gen_maven_artifact(
+ name = "artifact-core",
+ artifact_coordinates = "com.google.dagger:hilt-core:" + POM_VERSION_ALPHA,
+ artifact_name = "Hilt Core",
+ artifact_target = ":artifact-core-lib",
+ artifact_target_libs = [
+ "//java/dagger/hilt:define_component",
+ "//java/dagger/hilt:entry_point",
+ "//java/dagger/hilt:generates_root_input",
+ "//java/dagger/hilt:install_in",
+ "//java/dagger/hilt:package_info",
+ "//java/dagger/hilt/codegen:originating_element",
+ "//java/dagger/hilt/codegen:package_info",
+ "//java/dagger/hilt/components",
+ "//java/dagger/hilt/components:package_info",
+ "//java/dagger/hilt/internal:component_manager",
+ "//java/dagger/hilt/internal:generated_component",
+ "//java/dagger/hilt/internal:preconditions",
+ "//java/dagger/hilt/internal:unsafe_casts",
+ "//java/dagger/hilt/internal/aliasof",
+ "//java/dagger/hilt/internal/definecomponent",
+ "//java/dagger/hilt/internal/generatesrootinput",
+ "//java/dagger/hilt/migration:alias_of",
+ "//java/dagger/hilt/migration:disable_install_in_check",
+ "//java/dagger/hilt/migration:package_info",
+ "//java/dagger/hilt/processor/internal/aggregateddeps:annotation",
+ ],
+ artifact_target_maven_deps = [
+ "com.google.code.findbugs:jsr305",
+ "com.google.dagger:dagger",
+ "javax.inject:javax.inject",
+ ],
+ artifact_target_maven_deps_banned = [
+ "com.google.guava:guava",
+ "javax.annotation:jsr250-api",
+ ],
+ javadoc_exclude_packages = [
+ "dagger.hilt.internal",
+ ],
+ javadoc_root_packages = [
+ "dagger.hilt",
+ ],
+ javadoc_srcs = [
+ "//java/dagger/hilt:hilt_filegroup",
+ ],
+)
diff --git a/java/dagger/hilt/DefineComponent.java b/java/dagger/hilt/DefineComponent.java
new file mode 100644
index 0000000..fcd572c
--- /dev/null
+++ b/java/dagger/hilt/DefineComponent.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt;
+
+import static java.lang.annotation.ElementType.TYPE;
+import static java.lang.annotation.RetentionPolicy.CLASS;
+
+import dagger.hilt.internal.definecomponent.DefineComponentNoParent;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+/**
+ * Defines a Hilt component.
+ *
+ * <p>Example defining a root component, {@code ParentComponent}:
+ *
+ * <pre><code>
+ * {@literal @}ParentScoped
+ * {@literal @}DefineComponent
+ * interface ParentComponent {}
+ * </code></pre>
+ *
+ * <p>Example defining a child component, {@code ChildComponent}:
+ *
+ * <pre><code>
+ * {@literal @}ChildScoped
+ * {@literal @}DefineComponent(parent = ParentComponent.class)
+ * interface ChildComponent {}
+ * </code></pre>
+ */
+@Retention(CLASS)
+@Target(TYPE)
+@GeneratesRootInput
+public @interface DefineComponent {
+ /** Returns the parent of this component, if it exists. */
+ Class<?> parent() default DefineComponentNoParent.class;
+
+ /**
+ * Defines a builder for a Hilt component.
+ *
+ * <pre><code>
+ * {@literal @}DefineComponent.Builder
+ * interface ParentComponentBuilder {
+ * ParentComponentBuilder seedData(SeedData seed);
+ * ParentComponent build();
+ * }
+ * </code></pre>
+ */
+ // TODO(bcorso): Consider making this a top-level class to hint that it doesn't need to be nested.
+ @Retention(CLASS)
+ @Target(TYPE)
+ @GeneratesRootInput
+ public @interface Builder {}
+}
diff --git a/java/dagger/hilt/EntryPoint.java b/java/dagger/hilt/EntryPoint.java
new file mode 100644
index 0000000..e216e77
--- /dev/null
+++ b/java/dagger/hilt/EntryPoint.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt;
+
+import static java.lang.annotation.RetentionPolicy.CLASS;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation for marking an interface as an entry point into a generated component. This annotation
+ * must be used with {@link dagger.hilt.InstallIn} to indicate which component(s) should have this
+ * entry point. When assembling components, Hilt will make the indicated components extend the
+ * interface marked with this annotation.
+ *
+ * <p>To use the annotated interface to access Dagger objects, use {@link dagger.hilt.EntryPoints}.
+ *
+ * <p>Example usage:
+ *
+ * <pre><code>
+ * {@literal @}EntryPoint
+ * {@literal @}InstallIn(SingletonComponent.class)
+ * public interface FooEntryPoint {
+ * Foo getFoo();
+ * }
+ *
+ * Foo foo = EntryPoints.get(component, FooEntryPoint.class).getFoo();
+ * </code></pre>
+ *
+ * @see <a href="https://dagger.dev/hilt/entry-points">Entry points</a>
+ */
+@Retention(CLASS)
+@Target(ElementType.TYPE)
+@GeneratesRootInput
+public @interface EntryPoint {}
diff --git a/java/dagger/hilt/EntryPoints.java b/java/dagger/hilt/EntryPoints.java
new file mode 100644
index 0000000..32e2312
--- /dev/null
+++ b/java/dagger/hilt/EntryPoints.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt;
+
+import dagger.hilt.internal.GeneratedComponent;
+import dagger.hilt.internal.GeneratedComponentManager;
+import javax.annotation.Nonnull;
+
+/** Static utility methods for accessing objects through entry points. */
+public final class EntryPoints {
+
+ /**
+ * Returns the entry point interface given a component or component manager. Note that this
+ * performs an unsafe cast and so callers should be sure that the given component/component
+ * manager matches the entry point interface that is given.
+ *
+ * @param component The Hilt-generated component instance. For convenience, also takes component
+ * manager instances as well.
+ * @param entryPoint The interface marked with {@link dagger.hilt.EntryPoint}. The {@link
+ * dagger.hilt.InstallIn} annotation on this entry point should match the component argument
+ * above.
+ */
+ // Note that the input is not statically declared to be a Component or ComponentManager to make
+ // this method easier to use, since most code will use this with an Application or Activity type.
+ @Nonnull
+ public static <T> T get(Object component, Class<T> entryPoint) {
+ if (component instanceof GeneratedComponent) {
+ // Unsafe cast. There is no way for this method to know that the correct component was used.
+ return entryPoint.cast(component);
+ } else if (component instanceof GeneratedComponentManager) {
+ // Unsafe cast. There is no way for this method to know that the correct component was used.
+ return entryPoint.cast(((GeneratedComponentManager<?>) component).generatedComponent());
+ } else {
+ throw new IllegalStateException(
+ String.format(
+ "Given component holder %s does not implement %s or %s",
+ component.getClass(), GeneratedComponent.class, GeneratedComponentManager.class));
+ }
+ }
+
+ private EntryPoints() {}
+}
diff --git a/java/dagger/hilt/GeneratesRootInput.java b/java/dagger/hilt/GeneratesRootInput.java
new file mode 100644
index 0000000..ffd786f
--- /dev/null
+++ b/java/dagger/hilt/GeneratesRootInput.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/** For annotating annotations that generate input for the {@link GenerateComponents}. */
+// TODO(danysantiago): Rename to GenerateComponentsInput
+@Target(ElementType.ANNOTATION_TYPE)
+@Retention(RetentionPolicy.CLASS)
+public @interface GeneratesRootInput {}
diff --git a/java/dagger/hilt/InstallIn.java b/java/dagger/hilt/InstallIn.java
new file mode 100644
index 0000000..9148c82
--- /dev/null
+++ b/java/dagger/hilt/InstallIn.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package dagger.hilt;
+
+import static java.lang.annotation.RetentionPolicy.CLASS;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+/**
+ * An annotation that declares which component(s) the annotated class should be included in when
+ * Hilt generates the components. This may only be used with classes annotated with
+ * {@literal @}{@link dagger.Module} or {@literal @}{@link dagger.hilt.EntryPoint}.
+ *
+ * <p>Example usage for installing a module in the generated {@code ApplicationComponent}:
+ *
+ * <pre><code>
+ * {@literal @}Module
+ * {@literal @}InstallIn(SingletonComponent.class)
+ * public final class FooModule {
+ * {@literal @}Provides
+ * static Foo provideFoo() {
+ * return new Foo();
+ * }
+ * }
+ * </code></pre>
+ *
+ * @see <a href="https://dagger.dev/hilt/modules">Hilt Modules</a>
+ */
+@Retention(CLASS)
+@Target({ElementType.TYPE})
+@GeneratesRootInput
+public @interface InstallIn {
+ Class<?>[] value();
+}
diff --git a/java/dagger/hilt/README.md b/java/dagger/hilt/README.md
new file mode 100644
index 0000000..911e466
--- /dev/null
+++ b/java/dagger/hilt/README.md
@@ -0,0 +1,4 @@
+# Hilt
+
+Hilt provides a standard way to incorporate Dagger dependency injection into an
+Android application. For more information, see https://dagger.dev/hilt.
diff --git a/java/dagger/hilt/android/ActivityRetainedLifecycle.java b/java/dagger/hilt/android/ActivityRetainedLifecycle.java
new file mode 100644
index 0000000..5e2d7cd
--- /dev/null
+++ b/java/dagger/hilt/android/ActivityRetainedLifecycle.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android;
+
+import android.app.Activity;
+import androidx.annotation.MainThread;
+import androidx.annotation.NonNull;
+
+/**
+ * A <code>ActivityRetainedLifecycle</code> class is associated with the lifecycle of the {@link
+ * dagger.hilt.android.components.ActivityRetainedComponent}.
+ */
+public interface ActivityRetainedLifecycle {
+
+ /**
+ * Adds a new {@link OnClearedListener} for receiving a callback when the activity retained
+ * instances will no longer be needed and destroyed.
+ *
+ * @param listener The listener that should be added.
+ */
+ @MainThread
+ void addOnClearedListener(@NonNull OnClearedListener listener);
+
+ /**
+ * Removes a {@link OnClearedListener} previously added via {@link
+ * #addOnClearedListener(OnClearedListener)}.
+ *
+ * @param listener The listener that should be removed.
+ */
+ @MainThread
+ void removeOnClearedListener(@NonNull OnClearedListener listener);
+
+ /**
+ * Listener for receiving a callback for when the {@link
+ * dagger.hilt.android.components.ActivityRetainedComponent} will no longer be used and destroyed.
+ */
+ interface OnClearedListener {
+
+ /**
+ * Called when the activity retained instances will no longer be used and destroyed.
+ *
+ * <p>Specifically this will be invoked during {@link Activity#onDestroy()} when {@link
+ * Activity#isChangingConfigurations} is false.
+ */
+ void onCleared();
+ }
+}
diff --git a/java/dagger/hilt/android/AndroidEntryPoint.java b/java/dagger/hilt/android/AndroidEntryPoint.java
new file mode 100644
index 0000000..8c56116
--- /dev/null
+++ b/java/dagger/hilt/android/AndroidEntryPoint.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android;
+
+import dagger.hilt.GeneratesRootInput;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+/**
+ * Marks an Android component class to be setup for injection with the standard Hilt Dagger Android
+ * components. Currently, this supports activities, fragments, views, services, and broadcast
+ * receivers.
+ *
+ * <p>This annotation will generate a base class that the annotated class should extend, either
+ * directly or via the Hilt Gradle Plugin. This base class will take care of injecting members into
+ * the Android class as well as handling instantiating the proper Hilt components at the right point
+ * in the lifecycle. The name of the base class will be "Hilt_<annotated class name>".
+ *
+ * <p>Example usage (with the Hilt Gradle Plugin):
+ *
+ * <pre><code>
+ * {@literal @}AndroidEntryPoint
+ * public final class FooActivity extends FragmentActivity {
+ * {@literal @}Inject Foo foo;
+ *
+ * {@literal @}Override
+ * public void onCreate(Bundle savedInstanceState) {
+ * super.onCreate(savedInstanceState); // The foo field is injected in super.onCreate()
+ * }
+ * }
+ * </code></pre>
+ *
+ * <p>Example usage (without the Hilt Gradle Plugin):
+ *
+ * <pre><code>
+ * {@literal @}AndroidEntryPoint(FragmentActivity.class)
+ * public final class FooActivity extends Hilt_FooActivity {
+ * {@literal @}Inject Foo foo;
+ *
+ * {@literal @}Override
+ * public void onCreate(Bundle savedInstanceState) {
+ * super.onCreate(savedInstanceState); // The foo field is injected in super.onCreate()
+ * }
+ * }
+ * </code></pre>
+ *
+ * @see HiltAndroidApp
+ */
+@Target({ElementType.TYPE})
+@GeneratesRootInput
+public @interface AndroidEntryPoint {
+
+ /**
+ * The base class for the generated Hilt class. When applying the Hilt Gradle Plugin this value
+ * is not necessary and will be inferred from the current superclass.
+ */
+ Class<?> value() default Void.class;
+}
diff --git a/java/dagger/hilt/android/AndroidManifest.xml b/java/dagger/hilt/android/AndroidManifest.xml
new file mode 100644
index 0000000..3a7b087
--- /dev/null
+++ b/java/dagger/hilt/android/AndroidManifest.xml
@@ -0,0 +1,19 @@
+<!--
+ Copyright (C) 2020 The Dagger Authors.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="dagger.hilt.android">
+ <uses-sdk android:minSdkVersion="14" />
+</manifest>
diff --git a/java/dagger/hilt/android/BUILD b/java/dagger/hilt/android/BUILD
new file mode 100644
index 0000000..47d7e67
--- /dev/null
+++ b/java/dagger/hilt/android/BUILD
@@ -0,0 +1,193 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# A library based on Hilt that provides standard components and automated injection for Android.
+load("//:build_defs.bzl", "POM_VERSION_ALPHA")
+load("//tools:maven.bzl", "gen_maven_artifact")
+
+package(default_visibility = ["//:src"])
+
+android_library(
+ name = "android_entry_point",
+ srcs = [
+ "AndroidEntryPoint.java",
+ "WithFragmentBindings.java",
+ ],
+ exported_plugins = [
+ "//java/dagger/hilt/android/processor/internal/androidentrypoint:plugin",
+ ],
+ exports = [
+ "//java/dagger/hilt:install_in",
+ "//java/dagger/hilt/android/components",
+ "//java/dagger/hilt/android/internal/builders",
+ "//java/dagger/hilt/android/internal/managers",
+ "//java/dagger/hilt/android/internal/managers:component_supplier",
+ "//java/dagger/hilt/android/internal/modules",
+ "//java/dagger/hilt/android/lifecycle",
+ "//java/dagger/hilt/codegen:originating_element",
+ "//java/dagger/hilt/internal:component_entry_point",
+ "//java/dagger/hilt/internal:component_manager",
+ "//java/dagger/hilt/internal:generated_entry_point",
+ "//java/dagger/hilt/internal:preconditions",
+ "@maven//:androidx_annotation_annotation",
+ "@maven//:androidx_fragment_fragment",
+ ],
+ deps = [
+ ":package_info",
+ "//java/dagger/hilt:generates_root_input",
+ ],
+)
+
+android_library(
+ name = "hilt_android_app",
+ srcs = ["HiltAndroidApp.java"],
+ exported_plugins = [
+ "//java/dagger/hilt/android/processor/internal/androidentrypoint:plugin",
+ "//java/dagger/hilt/android/processor/internal/viewmodel:validation_plugin",
+ "//java/dagger/hilt/processor/internal/root:plugin",
+ ],
+ exports = [
+ "//:dagger_with_compiler",
+ "//java/dagger/hilt:install_in",
+ "//java/dagger/hilt/android/components",
+ "//java/dagger/hilt/android/internal/managers",
+ "//java/dagger/hilt/android/internal/managers:component_supplier",
+ "//java/dagger/hilt/android/internal/modules",
+ "//java/dagger/hilt/codegen:originating_element",
+ "//java/dagger/hilt/internal:component_manager",
+ "//java/dagger/hilt/internal:generated_component",
+ "//java/dagger/hilt/internal:generated_entry_point",
+ "//java/dagger/hilt/migration:disable_install_in_check",
+ "@maven//:androidx_annotation_annotation",
+ ],
+ deps = [
+ ":package_info",
+ "//java/dagger/hilt:generates_root_input",
+ ],
+)
+
+android_library(
+ name = "entry_point_accessors",
+ srcs = ["EntryPointAccessors.java"],
+ deps = [
+ ":package_info",
+ "//java/dagger/hilt:entry_point",
+ "@google_bazel_common//third_party/java/jsr305_annotations",
+ "@maven//:androidx_fragment_fragment",
+ ],
+)
+
+android_library(
+ name = "activity_retained_lifecycle",
+ srcs = ["ActivityRetainedLifecycle.java"],
+ deps = [
+ ":package_info",
+ "@maven//:androidx_annotation_annotation",
+ ],
+)
+
+android_library(
+ name = "artifact-lib",
+ tags = ["maven_coordinates=com.google.dagger:hilt-android:" + POM_VERSION_ALPHA],
+ exports = [
+ ":android_entry_point",
+ ":entry_point_accessors",
+ ":hilt_android_app",
+ ":package_info",
+ "//java/dagger/hilt:artifact-core-lib",
+ "//java/dagger/hilt/android/migration:optional_inject",
+ "//java/dagger/lint:lint-android-artifact-lib",
+ ],
+)
+
+java_library(
+ name = "package_info",
+ srcs = ["package-info.java"],
+ deps = [
+ "@google_bazel_common//third_party/java/jsr305_annotations",
+ ],
+)
+
+gen_maven_artifact(
+ name = "artifact",
+ artifact_coordinates = "com.google.dagger:hilt-android:" + POM_VERSION_ALPHA,
+ artifact_name = "Hilt Android",
+ artifact_target = ":artifact-lib",
+ artifact_target_libs = [
+ ":entry_point_accessors",
+ "//java/dagger/hilt/android:activity_retained_lifecycle",
+ "//java/dagger/hilt/android:android_entry_point",
+ "//java/dagger/hilt/android:hilt_android_app",
+ "//java/dagger/hilt/android:package_info",
+ "//java/dagger/hilt/android/components",
+ "//java/dagger/hilt/android/components:view_model_component",
+ "//java/dagger/hilt/android/components:package_info",
+ "//java/dagger/hilt/android/internal",
+ "//java/dagger/hilt/android/internal/builders",
+ "//java/dagger/hilt/android/internal/lifecycle",
+ "//java/dagger/hilt/android/internal/managers",
+ "//java/dagger/hilt/android/internal/managers:component_supplier",
+ "//java/dagger/hilt/android/internal/migration:injected_by_hilt",
+ "//java/dagger/hilt/android/internal/modules",
+ "//java/dagger/hilt/android/lifecycle",
+ "//java/dagger/hilt/android/migration:optional_inject",
+ "//java/dagger/hilt/android/migration:package_info",
+ "//java/dagger/hilt/android/qualifiers",
+ "//java/dagger/hilt/android/qualifiers:package_info",
+ "//java/dagger/hilt/android/scopes",
+ "//java/dagger/hilt/android/scopes:activity_retained_scoped",
+ "//java/dagger/hilt/android/scopes:view_model_scoped",
+ "//java/dagger/hilt/android/scopes:package_info",
+ "//java/dagger/hilt/internal:component_entry_point",
+ "//java/dagger/hilt/internal:generated_entry_point",
+ ],
+ artifact_target_maven_deps = [
+ "androidx.activity:activity",
+ "androidx.annotation:annotation",
+ "androidx.fragment:fragment",
+ "androidx.lifecycle:lifecycle-viewmodel",
+ "androidx.lifecycle:lifecycle-viewmodel-savedstate",
+ "androidx.savedstate:savedstate",
+ "com.google.code.findbugs:jsr305",
+ "com.google.dagger:dagger-lint-aar",
+ "com.google.dagger:dagger",
+ "com.google.dagger:hilt-core",
+ "javax.inject:javax.inject",
+ ],
+ artifact_target_maven_deps_banned = [
+ "com.google.guava:guava",
+ "javax.annotation:jsr250-api",
+ ],
+ javadoc_android_api_level = 30,
+ javadoc_exclude_packages = [
+ "dagger.hilt.android.internal",
+ ],
+ javadoc_root_packages = [
+ "dagger.hilt.android",
+ ],
+ javadoc_srcs = [
+ "//java/dagger/hilt:hilt_android_filegroup",
+ ],
+ manifest = "AndroidManifest.xml",
+ packaging = "aar",
+ proguard_specs = [
+ "//java/dagger/hilt/android/lifecycle:proguard-rules.pro",
+ ],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/android/EntryPointAccessors.java b/java/dagger/hilt/android/EntryPointAccessors.java
new file mode 100644
index 0000000..6145af1
--- /dev/null
+++ b/java/dagger/hilt/android/EntryPointAccessors.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android;
+
+import android.app.Activity;
+import android.content.Context;
+import androidx.fragment.app.Fragment;
+import android.view.View;
+import dagger.hilt.EntryPoints;
+import javax.annotation.Nonnull;
+
+/** Static utility methods for dealing with entry points for standard Android components. */
+public final class EntryPointAccessors {
+
+ /**
+ * Returns the entry point interface from an application. The context can be any context derived
+ * from the application context. May only be used with entry point interfaces installed in the
+ * ApplicationComponent.
+ */
+ @Nonnull
+ public static <T> T fromApplication(Context context, Class<T> entryPoint) {
+ return EntryPoints.get(context.getApplicationContext(), entryPoint);
+ }
+
+ /**
+ * Returns the entry point interface from an activity. May only be used with entry point
+ * interfaces installed in the ActivityComponent.
+ */
+ @Nonnull
+ public static <T> T fromActivity(Activity activity, Class<T> entryPoint) {
+ return EntryPoints.get(activity, entryPoint);
+ }
+
+ /**
+ * Returns the entry point interface from a fragment. May only be used with entry point interfaces
+ * installed in the FragmentComponent.
+ */
+ @Nonnull
+ public static <T> T fromFragment(Fragment fragment, Class<T> entryPoint) {
+ return EntryPoints.get(fragment, entryPoint);
+ }
+
+ /**
+ * Returns the entry point interface from a view. May only be used with entry point interfaces
+ * installed in the ViewComponent or ViewNoFragmentComponent.
+ */
+ @Nonnull
+ public static <T> T fromView(View view, Class<T> entryPoint) {
+ return EntryPoints.get(view, entryPoint);
+ }
+
+ private EntryPointAccessors() {}
+}
diff --git a/java/dagger/hilt/android/HiltAndroidApp.java b/java/dagger/hilt/android/HiltAndroidApp.java
new file mode 100644
index 0000000..0c2ca0f
--- /dev/null
+++ b/java/dagger/hilt/android/HiltAndroidApp.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android;
+
+import dagger.hilt.GeneratesRootInput;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation for marking the {@link android.app.Application} class where the Dagger components
+ * should be generated. Since all components will be built in the same compilation as the annotated
+ * application, all modules and entry points that should be installed in the component need to be
+ * transitive compilation dependencies of the annotated application.
+ *
+ * <p>Usage of this annotation is similar to {@link dagger.hilt.android.AndroidEntryPoint} with the
+ * only difference being that it only works on application classes and additionally triggers Dagger
+ * component generation.
+ *
+ * <p>This annotation will generate a base class that the annotated class should extend, either
+ * directly or via the Hilt Gradle Plugin. This base class will take care of injecting members into
+ * the Android class as well as handling instantiating the proper Hilt components at the right point
+ * in the lifecycle. The name of the base class will be "Hilt_<annotated class name>".
+ *
+ * <p>Example usage (with the Hilt Gradle Plugin):
+ *
+ * <pre><code>
+ * {@literal @}HiltAndroidApp
+ * public final class FooApplication extends Application {
+ * {@literal @}Inject Foo foo;
+ *
+ * {@literal @}Override
+ * public void onCreate() {
+ * super.onCreate(); // The foo field is injected in super.onCreate()
+ * }
+ * }
+ * </code></pre>
+ *
+ * <p>Example usage (without the Hilt Gradle Plugin):
+ *
+ * <pre><code>
+ * {@literal @}HiltAndroidApp(Application.class)
+ * public final class FooApplication extends Hilt_FooApplication {
+ * {@literal @}Inject Foo foo;
+ *
+ * {@literal @}Override
+ * public void onCreate() {
+ * super.onCreate(); // The foo field is injected in super.onCreate()
+ * }
+ * }
+ * </code></pre>
+ *
+ * @see AndroidEntryPoint
+ */
+// Set the retention to RUNTIME because we check it via reflection in the HiltAndroidRule.
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE})
+@GeneratesRootInput
+public @interface HiltAndroidApp {
+ /**
+ * The base class for the generated Hilt application. When applying the Hilt Gradle Plugin this
+ * value is not necessary and will be inferred from the current superclass.
+ */
+ // TODO(erichang): It would be nice to make this Class<? extends Application> but then the default
+ // would have to be Application which would make the default actually valid even without the
+ // plugin. Maybe that is a good thing...but might be better to have users be explicit about the
+ // base class they want.
+ Class<?> value() default Void.class;
+}
diff --git a/java/dagger/hilt/android/WithFragmentBindings.java b/java/dagger/hilt/android/WithFragmentBindings.java
new file mode 100644
index 0000000..2b02498
--- /dev/null
+++ b/java/dagger/hilt/android/WithFragmentBindings.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+/**
+ * Makes a View annotated with {@link AndroidEntryPoint} have access to fragment bindings.
+ *
+ * <p>By default, views annotated with {@literal @}AndroidEntryPoint do not have access to fragment
+ * bindings and must use this annotation if fragment bindings are required. When this annotation is
+ * used, this view must always be attached through a fragment.
+ */
+@Target({ElementType.TYPE})
+public @interface WithFragmentBindings {}
diff --git a/java/dagger/hilt/android/components/ActivityComponent.java b/java/dagger/hilt/android/components/ActivityComponent.java
new file mode 100644
index 0000000..78f48cc
--- /dev/null
+++ b/java/dagger/hilt/android/components/ActivityComponent.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.components;
+
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.scopes.ActivityScoped;
+
+/** A Hilt component that has the lifetime of the activity. */
+@ActivityScoped
+@DefineComponent(parent = ActivityRetainedComponent.class)
+public interface ActivityComponent {}
diff --git a/java/dagger/hilt/android/components/ActivityRetainedComponent.java b/java/dagger/hilt/android/components/ActivityRetainedComponent.java
new file mode 100644
index 0000000..b3c340e
--- /dev/null
+++ b/java/dagger/hilt/android/components/ActivityRetainedComponent.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.components;
+
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.scopes.ActivityRetainedScoped;
+import dagger.hilt.components.SingletonComponent;
+
+/** A Hilt component that has the lifetime of a configuration surviving activity. */
+@ActivityRetainedScoped
+@DefineComponent(parent = SingletonComponent.class)
+public interface ActivityRetainedComponent {}
diff --git a/java/dagger/hilt/android/components/BUILD b/java/dagger/hilt/android/components/BUILD
new file mode 100644
index 0000000..3a307d1
--- /dev/null
+++ b/java/dagger/hilt/android/components/BUILD
@@ -0,0 +1,62 @@
+# Copyright (C) 2019 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Hilt Android components
+
+package(default_visibility = ["//:src"])
+
+android_library(
+ name = "components",
+ srcs = [
+ "ActivityComponent.java",
+ "ActivityRetainedComponent.java",
+ "FragmentComponent.java",
+ "ServiceComponent.java",
+ "ViewComponent.java",
+ "ViewWithFragmentComponent.java",
+ ],
+ exports = [
+ "//java/dagger/hilt/components",
+ ],
+ deps = [
+ ":package_info",
+ "//java/dagger/hilt:define_component",
+ "//java/dagger/hilt/android/scopes",
+ "//java/dagger/hilt/android/scopes:activity_retained_scoped",
+ "//java/dagger/hilt/components",
+ "@google_bazel_common//third_party/java/jsr330_inject",
+ ],
+)
+
+android_library(
+ name = "view_model_component",
+ srcs = ["ViewModelComponent.java"],
+ deps = [
+ ":components",
+ ":package_info",
+ "//java/dagger/hilt:define_component",
+ "//java/dagger/hilt/android/scopes:view_model_scoped",
+ ],
+)
+
+java_library(
+ name = "package_info",
+ srcs = ["package-info.java"],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/android/components/FragmentComponent.java b/java/dagger/hilt/android/components/FragmentComponent.java
new file mode 100644
index 0000000..6b088e6
--- /dev/null
+++ b/java/dagger/hilt/android/components/FragmentComponent.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.components;
+
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.scopes.FragmentScoped;
+
+/** A Hilt component that has the lifetime of the fragment. */
+@FragmentScoped
+@DefineComponent(parent = ActivityComponent.class)
+public interface FragmentComponent {}
diff --git a/java/dagger/hilt/android/components/ServiceComponent.java b/java/dagger/hilt/android/components/ServiceComponent.java
new file mode 100644
index 0000000..0a3f6ea
--- /dev/null
+++ b/java/dagger/hilt/android/components/ServiceComponent.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.components;
+
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.scopes.ServiceScoped;
+import dagger.hilt.components.SingletonComponent;
+
+/** A Hilt component that has the lifetime of the service. */
+@ServiceScoped
+@DefineComponent(parent = SingletonComponent.class)
+public interface ServiceComponent {}
diff --git a/java/dagger/hilt/android/components/ViewComponent.java b/java/dagger/hilt/android/components/ViewComponent.java
new file mode 100644
index 0000000..1f5b420
--- /dev/null
+++ b/java/dagger/hilt/android/components/ViewComponent.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.components;
+
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.scopes.ViewScoped;
+
+/** A Hilt component that has the lifetime of the view. */
+@ViewScoped
+@DefineComponent(parent = ActivityComponent.class)
+public interface ViewComponent {}
diff --git a/java/dagger/hilt/android/components/ViewModelComponent.java b/java/dagger/hilt/android/components/ViewModelComponent.java
new file mode 100644
index 0000000..2ba2133
--- /dev/null
+++ b/java/dagger/hilt/android/components/ViewModelComponent.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.components;
+
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.scopes.ViewModelScoped;
+
+/**
+ * A Hilt component that has the lifetime of a single {@link androidx.lifecycle.ViewModel}.
+ *
+ * <p>This Hilt component is the source of {@link
+ * dagger.hilt.android.lifecycle.HiltViewModel}-annotated {@link androidx.lifecycle.ViewModel}s
+ * used by the {@link dagger.hilt.android.lifecycle.HiltViewModelFactory}. It contains a default
+ * binding for the {@link androidx.lifecycle.SavedStateHandle} associated with the {@code
+ * ViewModel} that can be used by other dependencies provided by the component.
+ *
+ * <p>Dependencies available in the {@link dagger.hilt.components.SingletonComponent} and {@link
+ * ActivityRetainedComponent} are also available in this component since it is a child of {@code
+ * ActivityRetainedComponent}.
+ *
+ * <p>Example usage:
+ *
+ * <pre>
+ * @Module
+ * @InstallIn(ViewModelComponent.class)
+ * public final class ViewModelMovieModule {
+ * @Provides
+ * public static MovieRepository provideRepo(SavedStateHandle handle) {
+ * return new MovieRepository(handle.getString("movie-id"));
+ * }
+ * }
+ * </pre>
+ *
+ * <p>Dependencies in the {@code ViewModelComponent} can be scoped using the {@link ViewModelScoped}
+ * annotation. This allows for a single instance of a dependency to be provided across the
+ * dependencies of a single {@link dagger.hilt.android.lifecycle.HiltViewModel}-annotated {@code
+ * ViewModel}.
+ *
+ * @see dagger.hilt.android.lifecycle.HiltViewModel
+ * @see dagger.hilt.android.scopes.ViewModelScoped
+ */
+@ViewModelScoped
+@DefineComponent(parent = ActivityRetainedComponent.class)
+public interface ViewModelComponent {}
diff --git a/java/dagger/hilt/android/components/ViewWithFragmentComponent.java b/java/dagger/hilt/android/components/ViewWithFragmentComponent.java
new file mode 100644
index 0000000..be5f2e8
--- /dev/null
+++ b/java/dagger/hilt/android/components/ViewWithFragmentComponent.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.components;
+
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.scopes.ViewScoped;
+
+/** A Hilt component that has the lifetime of the view. */
+@ViewScoped
+@DefineComponent(parent = FragmentComponent.class)
+public interface ViewWithFragmentComponent {}
diff --git a/java/dagger/hilt/android/components/package-info.java b/java/dagger/hilt/android/components/package-info.java
new file mode 100644
index 0000000..9ac3686
--- /dev/null
+++ b/java/dagger/hilt/android/components/package-info.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * This package contains Hilt's built-in {@link dagger.Component}s for Android.
+ *
+ * @see <a href="https://dagger.dev/hilt/components.md">Hilt Components</a>
+ */
+package dagger.hilt.android.components;
diff --git a/java/dagger/hilt/android/example/BUILD b/java/dagger/hilt/android/example/BUILD
new file mode 100644
index 0000000..2a4c194
--- /dev/null
+++ b/java/dagger/hilt/android/example/BUILD
@@ -0,0 +1,27 @@
+# Copyright (C) 2017 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Description:
+# A skeletal application that demonstrates wiring for an injected Application and Activity.
+
+package(default_visibility = ["//:src"])
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(
+ ["**/*"],
+ # Exclude Gradle build folder to enable working along side Bazel
+ exclude = ["**/build/**"],
+ ),
+)
diff --git a/java/dagger/hilt/android/example/gradle/simple/app/build.gradle b/java/dagger/hilt/android/example/gradle/simple/app/build.gradle
new file mode 100644
index 0000000..b3687ee
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/app/build.gradle
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+apply plugin: 'com.android.application'
+apply plugin: 'dagger.hilt.android.plugin'
+
+android {
+ compileSdkVersion 30
+ buildToolsVersion "30.0.2"
+
+ defaultConfig {
+ applicationId "dagger.hilt.android.example.gradle.simple"
+ minSdkVersion 15
+ targetSdkVersion 30
+ versionCode 1
+ versionName "1.0"
+ testInstrumentationRunner "dagger.hilt.android.example.gradle.simple.SimpleEmulatorTestRunner"
+ }
+ compileOptions {
+ sourceCompatibility 1.8
+ targetCompatibility 1.8
+ }
+ testOptions {
+ unitTests.includeAndroidResources = true
+ }
+ sourceSets {
+ String sharedTestDir = 'src/sharedTest/java'
+ test {
+ java.srcDirs += sharedTestDir
+ }
+ androidTest {
+ java.srcDirs += sharedTestDir
+ }
+ }
+}
+
+dependencies {
+ implementation project(':feature')
+ implementation 'androidx.appcompat:appcompat:1.2.0'
+ implementation 'com.google.dagger:hilt-android:LOCAL-SNAPSHOT'
+ annotationProcessor 'com.google.dagger:hilt-android-compiler:LOCAL-SNAPSHOT'
+
+ testImplementation 'com.google.truth:truth:1.0.1'
+ testImplementation 'junit:junit:4.13'
+ testImplementation 'org.robolectric:robolectric:4.5-alpha-3'
+ testImplementation 'androidx.core:core:1.3.2'
+ testImplementation 'androidx.test.ext:junit:1.1.2'
+ testImplementation 'androidx.test:runner:1.3.0'
+ testImplementation 'com.google.dagger:hilt-android-testing:LOCAL-SNAPSHOT'
+ testAnnotationProcessor 'com.google.dagger:hilt-android-compiler:LOCAL-SNAPSHOT'
+
+ androidTestImplementation 'com.google.truth:truth:1.0.1'
+ androidTestImplementation 'junit:junit:4.13'
+ androidTestImplementation 'androidx.test.ext:junit:1.1.2'
+ androidTestImplementation 'androidx.test:runner:1.3.0'
+ androidTestImplementation 'com.google.dagger:hilt-android-testing:LOCAL-SNAPSHOT'
+ androidTestAnnotationProcessor 'com.google.dagger:hilt-android-compiler:LOCAL-SNAPSHOT'
+
+ // To help us catch usages of Guava APIs for Java 8 in the '-jre' variant.
+ annotationProcessor'com.google.guava:guava:28.1-android'
+ testAnnotationProcessor'com.google.guava:guava:28.1-android'
+ androidTestAnnotationProcessor'com.google.guava:guava:28.1-android'
+}
diff --git a/java/dagger/hilt/android/example/gradle/simple/app/src/androidTest/java/dagger/hilt/android/example/gradle/simple/SettingsActivityEmulatorTest.java b/java/dagger/hilt/android/example/gradle/simple/app/src/androidTest/java/dagger/hilt/android/example/gradle/simple/SettingsActivityEmulatorTest.java
new file mode 100644
index 0000000..28a7223
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/app/src/androidTest/java/dagger/hilt/android/example/gradle/simple/SettingsActivityEmulatorTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simple;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import androidx.test.core.app.ActivityScenario;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import dagger.hilt.android.testing.BindValue;
+import dagger.hilt.android.testing.HiltAndroidRule;
+import dagger.hilt.android.testing.HiltAndroidTest;
+import dagger.hilt.android.testing.UninstallModules;
+import javax.inject.Inject;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/** A simple test using Hilt. */
+@UninstallModules(ModelModule.class)
+@HiltAndroidTest
+@RunWith(AndroidJUnit4.class)
+public final class SettingsActivityEmulatorTest {
+ @Rule public HiltAndroidRule rule = new HiltAndroidRule(this);
+
+ @BindValue @Model String fakeModel = "FakeModel";
+
+ @Inject @Model String injectedModel;
+
+ @Test
+ public void testInjectedModel() throws Exception {
+ assertThat(injectedModel).isNull();
+ rule.inject();
+ assertThat(injectedModel).isEqualTo("FakeModel");
+ }
+
+ @Test
+ public void testActivityInject() throws Exception {
+ try (ActivityScenario<SettingsActivity> scenario =
+ ActivityScenario.launch(SettingsActivity.class)) {
+ scenario.onActivity(
+ activity ->
+ assertThat(activity.greeter.greet())
+ .isEqualTo("ProdUser, you are on build FakeModel."));
+ }
+ }
+}
diff --git a/java/dagger/hilt/android/example/gradle/simple/app/src/androidTest/java/dagger/hilt/android/example/gradle/simple/SimpleActivityEmulatorTest.java b/java/dagger/hilt/android/example/gradle/simple/app/src/androidTest/java/dagger/hilt/android/example/gradle/simple/SimpleActivityEmulatorTest.java
new file mode 100644
index 0000000..cbf8f7f
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/app/src/androidTest/java/dagger/hilt/android/example/gradle/simple/SimpleActivityEmulatorTest.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simple;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import androidx.test.core.app.ActivityScenario;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import dagger.hilt.android.testing.BindValue;
+import dagger.hilt.android.testing.HiltAndroidRule;
+import dagger.hilt.android.testing.HiltAndroidTest;
+import dagger.hilt.android.testing.UninstallModules;
+import javax.inject.Inject;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/** A simple test using Hilt. */
+@UninstallModules(UserNameModule.class)
+@HiltAndroidTest
+@RunWith(AndroidJUnit4.class)
+public final class SimpleActivityEmulatorTest {
+
+ @Rule public HiltAndroidRule rule = new HiltAndroidRule(this);
+
+ @BindValue @UserName String fakeUserName = "FakeUser";
+
+ @Inject @UserName String injectedUserName;
+
+ @Test
+ public void testInjectedUserName() throws Exception {
+ assertThat(injectedUserName).isNull();
+ rule.inject();
+ assertThat(injectedUserName).isEqualTo("FakeUser");
+ }
+
+ @Test
+ public void testActivityInject() throws Exception {
+ try (ActivityScenario<SimpleActivity> scenario =
+ ActivityScenario.launch(SimpleActivity.class)) {
+ scenario.onActivity(
+ activity -> assertThat(activity.greeter.greet()).isEqualTo("Hello, FakeUser!"));
+ }
+ }
+}
diff --git a/java/dagger/hilt/android/example/gradle/simple/app/src/androidTest/java/dagger/hilt/android/example/gradle/simple/SimpleEmulatorTestRunner.java b/java/dagger/hilt/android/example/gradle/simple/app/src/androidTest/java/dagger/hilt/android/example/gradle/simple/SimpleEmulatorTestRunner.java
new file mode 100644
index 0000000..daf046b
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/app/src/androidTest/java/dagger/hilt/android/example/gradle/simple/SimpleEmulatorTestRunner.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simple;
+
+import android.app.Application;
+import android.content.Context;
+import androidx.test.runner.AndroidJUnitRunner;
+import dagger.hilt.android.testing.HiltTestApplication;
+
+/** A custom runner to setup the emulator application class for tests. */
+public final class SimpleEmulatorTestRunner extends AndroidJUnitRunner {
+
+ @Override
+ public Application newApplication(ClassLoader cl, String className, Context context)
+ throws ClassNotFoundException, IllegalAccessException, InstantiationException {
+ return super.newApplication(cl, HiltTestApplication.class.getName(), context);
+ }
+}
diff --git a/java/dagger/hilt/android/example/gradle/simple/app/src/debug/AndroidManifest.xml b/java/dagger/hilt/android/example/gradle/simple/app/src/debug/AndroidManifest.xml
new file mode 100644
index 0000000..86460d8
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/app/src/debug/AndroidManifest.xml
@@ -0,0 +1,33 @@
+<!--
+ ~ Copyright (C) 2017 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="dagger.hilt.android.example.gradle.simple">
+
+ <application>
+ <activity
+ android:name=".Injection1Test$TestActivity"
+ android:theme="@style/Theme.AppCompat.Light"
+ android:exported="false" />
+ <activity
+ android:name=".Injection2Test$TestActivity"
+ android:theme="@style/Theme.AppCompat.Light"
+ android:exported="false"/>
+ <activity
+ android:name=".ActivityScenarioRuleTest$TestActivity"
+ android:theme="@style/Theme.AppCompat.Light"
+ android:exported="false"/>
+ </application>
+</manifest>
diff --git a/java/dagger/hilt/android/example/gradle/simple/app/src/main/AndroidManifest.xml b/java/dagger/hilt/android/example/gradle/simple/app/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..662c5b4
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/app/src/main/AndroidManifest.xml
@@ -0,0 +1,35 @@
+<!--
+ ~ Copyright (C) 2017 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="dagger.hilt.android.example.gradle.simple">
+
+ <application android:name=".SimpleApplication" android:label="@string/appName">
+ <activity
+ android:name=".SimpleActivity"
+ android:theme="@style/Theme.AppCompat.Light"
+ android:exported="true">
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN" />
+ <category android:name="android.intent.category.LAUNCHER" />
+ </intent-filter>
+ </activity>
+ <activity
+ android:name=".SettingsActivity"
+ android:theme="@style/Theme.AppCompat.Light"
+ android:exported="false">
+ </activity>
+ </application>
+</manifest>
diff --git a/java/dagger/hilt/android/example/gradle/simple/app/src/main/java/dagger/hilt/android/example/gradle/simple/Model.java b/java/dagger/hilt/android/example/gradle/simple/app/src/main/java/dagger/hilt/android/example/gradle/simple/Model.java
new file mode 100644
index 0000000..b4aec95
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/app/src/main/java/dagger/hilt/android/example/gradle/simple/Model.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simple;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import javax.inject.Qualifier;
+
+/** Qualifies bindings relating to {@link android.os.Build#MODEL}. */
+@Qualifier
+@Retention(RUNTIME)
+@Documented
+@interface Model {}
diff --git a/java/dagger/hilt/android/example/gradle/simple/app/src/main/java/dagger/hilt/android/example/gradle/simple/ModelModule.java b/java/dagger/hilt/android/example/gradle/simple/app/src/main/java/dagger/hilt/android/example/gradle/simple/ModelModule.java
new file mode 100644
index 0000000..d933c81
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/app/src/main/java/dagger/hilt/android/example/gradle/simple/ModelModule.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simple;
+
+import static android.os.Build.MODEL;
+
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.components.SingletonComponent;
+
+@Module
+@InstallIn(SingletonComponent.class)
+final class ModelModule {
+ @Provides
+ @Model
+ static String provideModel() {
+ return MODEL;
+ }
+
+ private ModelModule() {}
+}
diff --git a/java/dagger/hilt/android/example/gradle/simple/app/src/main/java/dagger/hilt/android/example/gradle/simple/SettingsActivity.java b/java/dagger/hilt/android/example/gradle/simple/app/src/main/java/dagger/hilt/android/example/gradle/simple/SettingsActivity.java
new file mode 100644
index 0000000..f508e48
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/app/src/main/java/dagger/hilt/android/example/gradle/simple/SettingsActivity.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simple;
+
+import android.os.Bundle;
+import android.widget.TextView;
+import androidx.appcompat.app.AppCompatActivity;
+import dagger.hilt.android.AndroidEntryPoint;
+import javax.inject.Inject;
+
+/** The settings activity of the application. */
+@AndroidEntryPoint
+public class SettingsActivity extends AppCompatActivity {
+ private static final String TAG = SettingsActivity.class.getSimpleName();
+
+ @Inject SettingsGreeter greeter;
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+
+ setContentView(R.layout.activity_settings);
+
+ ((TextView) findViewById(R.id.settings_greeting)).setText(greeter.greet());
+ }
+}
diff --git a/java/dagger/hilt/android/example/gradle/simple/app/src/main/java/dagger/hilt/android/example/gradle/simple/SettingsGreeter.java b/java/dagger/hilt/android/example/gradle/simple/app/src/main/java/dagger/hilt/android/example/gradle/simple/SettingsGreeter.java
new file mode 100644
index 0000000..4f8ab14
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/app/src/main/java/dagger/hilt/android/example/gradle/simple/SettingsGreeter.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simple;
+
+import android.app.Activity;
+import javax.inject.Inject;
+
+/** A class that returns a greeting for {@link SettingsActivity}. */
+final class SettingsGreeter {
+ private final Activity activity;
+ private final String userName;
+ private final String model;
+
+ @Inject
+ SettingsGreeter(Activity activity, @UserName String userName, @Model String model) {
+ this.activity = activity;
+ this.userName = userName;
+ this.model = model;
+ }
+
+ public String greet() {
+ return activity.getResources().getString(R.string.settings_welcome, userName, model);
+ }
+}
diff --git a/java/dagger/hilt/android/example/gradle/simple/app/src/main/java/dagger/hilt/android/example/gradle/simple/SimpleActivity.java b/java/dagger/hilt/android/example/gradle/simple/app/src/main/java/dagger/hilt/android/example/gradle/simple/SimpleActivity.java
new file mode 100644
index 0000000..70e2e57
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/app/src/main/java/dagger/hilt/android/example/gradle/simple/SimpleActivity.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simple;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.widget.Button;
+import android.widget.TextView;
+import androidx.appcompat.app.AppCompatActivity;
+import dagger.hilt.android.AndroidEntryPoint;
+import dagger.hilt.android.example.gradle.simple.feature.FeatureActivity;
+import javax.inject.Inject;
+
+/** The main activity of the application. */
+@AndroidEntryPoint
+public class SimpleActivity extends AppCompatActivity {
+ private static final String TAG = SimpleActivity.class.getSimpleName();
+
+ @Inject SimpleGreeter greeter;
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+
+ setContentView(R.layout.activity_main);
+
+ ((TextView) findViewById(R.id.greeting)).setText(greeter.greet());
+
+ Button featureButton = (Button) findViewById(R.id.goto_feature);
+ featureButton.setOnClickListener(
+ view -> startActivity(new Intent(this, FeatureActivity.class)));
+
+ Button settingsButton = (Button) findViewById(R.id.goto_settings);
+ settingsButton.setOnClickListener(
+ view -> startActivity(new Intent(this, SettingsActivity.class)));
+ }
+}
diff --git a/java/dagger/hilt/android/example/gradle/simple/app/src/main/java/dagger/hilt/android/example/gradle/simple/SimpleApplication.java b/java/dagger/hilt/android/example/gradle/simple/app/src/main/java/dagger/hilt/android/example/gradle/simple/SimpleApplication.java
new file mode 100644
index 0000000..a163d8c
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/app/src/main/java/dagger/hilt/android/example/gradle/simple/SimpleApplication.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simple;
+
+import android.app.Application;
+import dagger.hilt.android.HiltAndroidApp;
+import javax.inject.Inject;
+
+/**
+ * A simple, skeletal application that demonstrates a dependency-injected application using the
+ * utilities in {@code Hilt} in Android.
+ */
+@HiltAndroidApp
+public class SimpleApplication extends Application {
+
+ // Shows that we can inject SingletonComponent bindings into an application.
+ @Inject @Model String model;
+}
diff --git a/java/dagger/hilt/android/example/gradle/simple/app/src/main/java/dagger/hilt/android/example/gradle/simple/SimpleGreeter.java b/java/dagger/hilt/android/example/gradle/simple/app/src/main/java/dagger/hilt/android/example/gradle/simple/SimpleGreeter.java
new file mode 100644
index 0000000..6c35600
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/app/src/main/java/dagger/hilt/android/example/gradle/simple/SimpleGreeter.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simple;
+
+import android.app.Activity;
+import javax.inject.Inject;
+
+/** A class that returns a greeting for {@link SimpleActivity}. */
+final class SimpleGreeter {
+ private final Activity activity;
+ private final String userName;
+
+ @Inject
+ SimpleGreeter(Activity activity, @UserName String userName) {
+ this.activity = activity;
+ this.userName = userName;
+ }
+
+ public String greet() {
+ return activity.getResources().getString(R.string.welcome, userName);
+ }
+}
diff --git a/java/dagger/hilt/android/example/gradle/simple/app/src/main/java/dagger/hilt/android/example/gradle/simple/UserName.java b/java/dagger/hilt/android/example/gradle/simple/app/src/main/java/dagger/hilt/android/example/gradle/simple/UserName.java
new file mode 100644
index 0000000..173b163
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/app/src/main/java/dagger/hilt/android/example/gradle/simple/UserName.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simple;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import javax.inject.Qualifier;
+
+/** Qualifies bindings relating to the user name. */
+@Qualifier
+@Retention(RUNTIME)
+@Documented
+@interface UserName {}
diff --git a/java/dagger/hilt/android/example/gradle/simple/app/src/main/java/dagger/hilt/android/example/gradle/simple/UserNameModule.java b/java/dagger/hilt/android/example/gradle/simple/app/src/main/java/dagger/hilt/android/example/gradle/simple/UserNameModule.java
new file mode 100644
index 0000000..3969b73
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/app/src/main/java/dagger/hilt/android/example/gradle/simple/UserNameModule.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simple;
+
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityComponent;
+
+@Module
+@InstallIn(ActivityComponent.class)
+final class UserNameModule {
+ @UserName
+ @Provides
+ static String provideUserName() {
+ return "ProdUser";
+ }
+
+ private UserNameModule() {}
+}
diff --git a/java/dagger/hilt/android/example/gradle/simple/app/src/main/res/layout/activity_main.xml b/java/dagger/hilt/android/example/gradle/simple/app/src/main/res/layout/activity_main.xml
new file mode 100644
index 0000000..8a23af5
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/app/src/main/res/layout/activity_main.xml
@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ Copyright (C) 2017 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+ android:layout_width="match_parent"
+ android:layout_height="match_parent"
+ android:background="@android:color/background_light">
+
+ <TextView
+ android:id="@+id/greeting"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:layout_alignParentTop="true"
+ android:textColor="@android:color/primary_text_light"
+ />
+
+ <Button
+ android:id="@+id/goto_settings"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:layout_below="@id/greeting"
+ android:text="@string/navigateToSettings"
+ />
+
+ <Button
+ android:id="@+id/goto_feature"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:layout_below="@id/goto_settings"
+ android:text="@string/navigateToFeature"
+ />
+</RelativeLayout>
diff --git a/java/dagger/hilt/android/example/gradle/simple/app/src/main/res/layout/activity_settings.xml b/java/dagger/hilt/android/example/gradle/simple/app/src/main/res/layout/activity_settings.xml
new file mode 100644
index 0000000..466856c
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/app/src/main/res/layout/activity_settings.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<FrameLayout
+ xmlns:android="http://schemas.android.com/apk/res/android"
+ android:layout_width="match_parent"
+ android:layout_height="match_parent">
+
+ <TextView
+ android:id="@+id/settings_greeting"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:text="@string/settings_welcome" />
+</FrameLayout>
diff --git a/java/dagger/hilt/android/example/gradle/simple/app/src/main/res/values/strings.xml b/java/dagger/hilt/android/example/gradle/simple/app/src/main/res/values/strings.xml
new file mode 100644
index 0000000..f1b550c
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/app/src/main/res/values/strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+ <!--The app name [CHAR_LIMIT=20]-->
+ <string name="appName">Simple Hilt Android</string>
+
+ <!--The greeting message [CHAR_LIMIT=100]-->
+ <string name="welcome">Hello, %1$s!</string>
+
+ <!--The feature button message [CHAR_LIMIT=100]-->
+ <string name="navigateToFeature">Navigate to a feature!</string>
+
+ <!--The settings button message [CHAR_LIMIT=100]-->
+ <string name="navigateToSettings">Navigate to settings!</string>
+
+ <!--The feature button message [CHAR_LIMIT=100]-->
+ <string name="settings_welcome">%1$s, you are on build %2$s.</string>
+</resources>
diff --git a/java/dagger/hilt/android/example/gradle/simple/app/src/sharedTest/java/dagger/hilt/android/example/gradle/simple/ActivityScenarioRuleTest.java b/java/dagger/hilt/android/example/gradle/simple/app/src/sharedTest/java/dagger/hilt/android/example/gradle/simple/ActivityScenarioRuleTest.java
new file mode 100644
index 0000000..7f1fcfc
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/app/src/sharedTest/java/dagger/hilt/android/example/gradle/simple/ActivityScenarioRuleTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simple;
+
+import static androidx.lifecycle.Lifecycle.State.RESUMED;
+import static com.google.common.truth.Truth.assertThat;
+
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.test.ext.junit.rules.ActivityScenarioRule;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import dagger.hilt.android.AndroidEntryPoint;
+import dagger.hilt.android.testing.BindValue;
+import dagger.hilt.android.testing.HiltAndroidRule;
+import dagger.hilt.android.testing.HiltAndroidTest;
+import javax.inject.Inject;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/** Tests that {@link ActivityScenarioRule} works with Hilt tests. */
+@HiltAndroidTest
+@RunWith(AndroidJUnit4.class)
+public final class ActivityScenarioRuleTest {
+ private static final String STR_VALUE = "STR_VALUE";
+
+ /** An activity to test injection. */
+ @AndroidEntryPoint
+ public static final class TestActivity extends AppCompatActivity {
+ @Inject String str;
+ }
+
+ @Rule(order = 0) public HiltAndroidRule hiltRule = new HiltAndroidRule(this);
+
+ @Rule(order = 1)
+ public ActivityScenarioRule<TestActivity> scenarioRule =
+ new ActivityScenarioRule<>(TestActivity.class);
+
+ @BindValue String str = STR_VALUE;
+
+ @Test
+ public void testState() {
+ assertThat(scenarioRule.getScenario().getState()).isEqualTo(RESUMED);
+ }
+
+ @Test
+ public void testInjection() {
+ scenarioRule
+ .getScenario()
+ .onActivity(activity -> assertThat(activity.str).isEqualTo(STR_VALUE));
+ }
+}
diff --git a/java/dagger/hilt/android/example/gradle/simple/app/src/sharedTest/java/dagger/hilt/android/example/gradle/simple/BindValueTest.java b/java/dagger/hilt/android/example/gradle/simple/app/src/sharedTest/java/dagger/hilt/android/example/gradle/simple/BindValueTest.java
new file mode 100644
index 0000000..7abe3c2
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/app/src/sharedTest/java/dagger/hilt/android/example/gradle/simple/BindValueTest.java
@@ -0,0 +1,155 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simple;
+
+import static androidx.test.core.app.ApplicationProvider.getApplicationContext;
+import static com.google.common.truth.Truth.assertThat;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import com.google.common.collect.ImmutableSet;
+import dagger.MapKey;
+import dagger.hilt.EntryPoint;
+import dagger.hilt.EntryPoints;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.testing.BindElementsIntoSet;
+import dagger.hilt.android.testing.BindValue;
+import dagger.hilt.android.testing.BindValueIntoMap;
+import dagger.hilt.android.testing.BindValueIntoSet;
+import dagger.hilt.android.testing.HiltAndroidRule;
+import dagger.hilt.android.testing.HiltAndroidTest;
+import dagger.hilt.components.SingletonComponent;
+import java.util.Map;
+import java.util.Set;
+import javax.inject.Inject;
+import javax.inject.Named;
+import javax.inject.Provider;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/** A simple test using Hilt. */
+@HiltAndroidTest
+@RunWith(AndroidJUnit4.class)
+public final class BindValueTest {
+ private static final String BIND_VALUE_STRING = "BIND_VALUE_STRING";
+ private static final String TEST_QUALIFIER = "TEST_QUALIFIER";
+
+ private static final String SET_STRING_1 = "SetString1";
+ private static final String SET_STRING_2 = "SetString2";
+ private static final String SET_STRING_3 = "SetString3";
+
+ private static final String KEY_1 = "Key1";
+ private static final String KEY_2 = "Key2";
+ private static final String VALUE_1 = "Value1";
+ private static final String VALUE_2 = "Value2";
+ private static final String VALUE_3 = "Value3";
+
+ private static final Integer SET_INT_1 = 1;
+ private static final Integer SET_INT_2 = 2;
+ private static final Integer SET_INT_3 = 3;
+
+ @EntryPoint
+ @InstallIn(SingletonComponent.class)
+ interface BindValueEntryPoint {
+ @Named(TEST_QUALIFIER)
+ String bindValueString();
+
+ Set<String> getStringSet();
+ }
+
+ @Rule public HiltAndroidRule rule = new HiltAndroidRule(this);
+
+ @BindValue
+ @Named(TEST_QUALIFIER)
+ String bindValueString = BIND_VALUE_STRING;
+
+ @BindElementsIntoSet Set<String> bindElementsSet1 = ImmutableSet.of(SET_STRING_1);
+ @BindElementsIntoSet Set<String> bindElementsSet2 = ImmutableSet.of(SET_STRING_2);
+
+ @BindValueIntoMap
+ @MyMapKey(KEY_1)
+ String boundValue1 = VALUE_1;
+
+ @BindValueIntoMap
+ @MyMapKey(KEY_2)
+ String boundValue2 = VALUE_2;
+
+ @BindValueIntoSet Integer bindValueSetInt1 = SET_INT_1;
+ @BindValueIntoSet Integer bindValueSetInt2 = SET_INT_2;
+
+ @Inject Set<String> stringSet;
+ @Inject Provider<Set<String>> providedStringSet;
+ @Inject Provider<Map<String, String>> mapProvider;
+ @Inject Set<Integer> intSet;
+ @Inject Provider<Set<Integer>> providedIntSet;
+
+ @Test
+ public void testBindValueFieldIsProvided() throws Exception {
+ assertThat(bindValueString).isEqualTo(BIND_VALUE_STRING);
+ assertThat(getBinding()).isEqualTo(BIND_VALUE_STRING);
+ }
+
+ @Test
+ public void testBindValueIsMutable() throws Exception {
+ bindValueString = "newValue";
+ assertThat(getBinding()).isEqualTo("newValue");
+ }
+
+ @Test
+ public void testElementsIntoSet() throws Exception {
+ rule.inject();
+ // basic check that initial/default values are properly injected
+ assertThat(providedStringSet.get()).containsExactly(SET_STRING_1, SET_STRING_2);
+ // Test empty sets (something that cannot be done with @BindValueIntoSet)
+ bindElementsSet1 = ImmutableSet.of();
+ bindElementsSet2 = ImmutableSet.of();
+ assertThat(providedStringSet.get()).isEmpty();
+ // Test multiple elements in set.
+ bindElementsSet1 = ImmutableSet.of(SET_STRING_1, SET_STRING_2, SET_STRING_3);
+ assertThat(providedStringSet.get()).containsExactly(SET_STRING_1, SET_STRING_2, SET_STRING_3);
+ }
+
+ @Test
+ public void testBindValueIntoMap() throws Exception {
+ rule.inject();
+ Map<String, String> oldMap = mapProvider.get();
+ assertThat(oldMap).containsExactly(KEY_1, VALUE_1, KEY_2, VALUE_2);
+ boundValue1 = VALUE_3;
+ Map<String, String> newMap = mapProvider.get();
+ assertThat(oldMap).containsExactly(KEY_1, VALUE_1, KEY_2, VALUE_2);
+ assertThat(newMap).containsExactly(KEY_1, VALUE_3, KEY_2, VALUE_2);
+ }
+
+ @Test
+ public void testBindValueIntoSet() throws Exception {
+ rule.inject();
+ // basic check that initial/default values are properly injected
+ assertThat(providedIntSet.get()).containsExactly(SET_INT_1, SET_INT_2);
+ bindValueSetInt1 = SET_INT_3;
+ // change the value for bindValueSetString from 1 to 3
+ assertThat(providedIntSet.get()).containsExactly(SET_INT_2, SET_INT_3);
+ }
+
+ @MapKey
+ @interface MyMapKey {
+ String value();
+ }
+
+ private static String getBinding() {
+ return EntryPoints.get(getApplicationContext(), BindValueEntryPoint.class).bindValueString();
+ }
+}
diff --git a/java/dagger/hilt/android/example/gradle/simple/app/src/sharedTest/java/dagger/hilt/android/example/gradle/simple/BroadcastReceiverTest.java b/java/dagger/hilt/android/example/gradle/simple/app/src/sharedTest/java/dagger/hilt/android/example/gradle/simple/BroadcastReceiverTest.java
new file mode 100644
index 0000000..7585bbb
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/app/src/sharedTest/java/dagger/hilt/android/example/gradle/simple/BroadcastReceiverTest.java
@@ -0,0 +1,202 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simple;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.platform.app.InstrumentationRegistry;
+import dagger.hilt.android.AndroidEntryPoint;
+import dagger.hilt.android.testing.BindValue;
+import dagger.hilt.android.testing.HiltAndroidRule;
+import dagger.hilt.android.testing.HiltAndroidTest;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import javax.inject.Inject;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/** A injection test of Broadcast receivers */
+@HiltAndroidTest
+@RunWith(AndroidJUnit4.class)
+public class BroadcastReceiverTest {
+
+ @Rule public HiltAndroidRule rule = new HiltAndroidRule(this);
+
+ @BindValue final String valueToInject = "test value";
+
+ @Test
+ public void verifyReceiverInjectedValue() throws InterruptedException {
+ Context context = InstrumentationRegistry.getInstrumentation().getTargetContext();
+
+ TestReceiverOne receiver = new TestReceiverOne();
+ IntentFilter intentFilter = new IntentFilter("test-action");
+ context.registerReceiver(receiver, intentFilter);
+
+ Intent intent = new Intent();
+ intent.setAction("test-action");
+ context.sendBroadcast(intent);
+
+ receiver.latch.await(2, TimeUnit.SECONDS);
+ assertThat(receiver.injectedValue).isNotEmpty();
+ }
+
+ @Test
+ public void verifyBaseReceiverInjectedValue() throws InterruptedException {
+ Context context = InstrumentationRegistry.getInstrumentation().getTargetContext();
+
+ TestReceiverTwo receiver = new TestReceiverTwo();
+ IntentFilter intentFilter = new IntentFilter("test-action");
+ context.registerReceiver(receiver, intentFilter);
+
+ Intent intent = new Intent();
+ intent.setAction("test-action");
+ context.sendBroadcast(intent);
+
+ receiver.latch.await(2, TimeUnit.SECONDS);
+ assertThat(receiver.injectedValue).isNotEmpty();
+ }
+
+ @Test
+ public void verifyBaseReceiverIsNotDoubleInjected() throws InterruptedException {
+ Context context = InstrumentationRegistry.getInstrumentation().getTargetContext();
+
+ TestReceiverThree receiver = new TestReceiverThree();
+ IntentFilter intentFilter = new IntentFilter("test-action");
+ context.registerReceiver(receiver, intentFilter);
+
+ Intent intent = new Intent();
+ intent.setAction("test-action");
+ context.sendBroadcast(intent);
+
+ receiver.latch.await(2, TimeUnit.SECONDS);
+ assertThat(receiver.injectedValue).isNotEmpty();
+ assertThat(receiver.onReceiveCalled).isEqualTo(1);
+ }
+
+ @Test
+ public void verifyComplexReceiverInjectedValue() throws InterruptedException {
+ Context context = InstrumentationRegistry.getInstrumentation().getTargetContext();
+
+ TestReceiverFour receiver = new TestReceiverFour();
+ IntentFilter intentFilter = new IntentFilter("test-action");
+ context.registerReceiver(receiver, intentFilter);
+
+ Intent intent = new Intent();
+ intent.setAction("test-action");
+ context.sendBroadcast(intent);
+
+ receiver.latch.await(2, TimeUnit.SECONDS);
+ assertThat(receiver.injectedValue).isNotEmpty();
+ }
+
+ /** Test receiver */
+ @AndroidEntryPoint
+ static class TestReceiverOne extends BroadcastReceiver {
+
+ final CountDownLatch latch = new CountDownLatch(1);
+
+ @Inject
+ String injectedValue;
+
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ latch.countDown();
+ }
+ }
+
+ /** Test receiver */
+ @AndroidEntryPoint
+ static class TestReceiverTwo extends BaseReceiverAbstractMethod {
+
+ final CountDownLatch latch = new CountDownLatch(1);
+
+ @Inject
+ String injectedValue;
+
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ latch.countDown();
+ }
+ }
+
+ /** Test receiver */
+ @AndroidEntryPoint
+ static class TestReceiverThree extends BaseReceiverConcreteMethod {
+
+ final CountDownLatch latch = new CountDownLatch(1);
+
+ @Inject
+ String injectedValue;
+
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ super.onReceive(context, intent);
+ latch.countDown();
+ }
+ }
+
+ /** Complex-ish test receiver */
+ @AndroidEntryPoint
+ static class TestReceiverFour extends BroadcastReceiver {
+
+ final CountDownLatch latch = new CountDownLatch(1);
+
+ @Inject String injectedValue;
+
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ // Weird code, but it tests that the exception table and stack table frames are correctly
+ // updated in a transformation.
+ boolean var0;
+ if (context != null) {
+ var0 = false;
+ Object var1 = context.getClass();
+ try {
+ throw new IllegalStateException();
+ } catch (IllegalStateException ex) {
+ var0 = true;
+ }
+ } else {
+ BroadcastReceiver myself = this;
+ var0 = false;
+ }
+ latch.countDown();
+ }
+ }
+
+ /** Base test receiver */
+ abstract static class BaseReceiverAbstractMethod extends BroadcastReceiver {
+
+ }
+
+ /** Base test receiver */
+ abstract static class BaseReceiverConcreteMethod extends BroadcastReceiver {
+
+ int onReceiveCalled = 0;
+
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ onReceiveCalled++;
+ }
+ }
+}
diff --git a/java/dagger/hilt/android/example/gradle/simple/app/src/sharedTest/java/dagger/hilt/android/example/gradle/simple/Injection1Test.java b/java/dagger/hilt/android/example/gradle/simple/app/src/sharedTest/java/dagger/hilt/android/example/gradle/simple/Injection1Test.java
new file mode 100644
index 0000000..0ebd150
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/app/src/sharedTest/java/dagger/hilt/android/example/gradle/simple/Injection1Test.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simple;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.test.core.app.ActivityScenario;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.AndroidEntryPoint;
+import dagger.hilt.android.components.ActivityComponent;
+import dagger.hilt.android.testing.HiltAndroidRule;
+import dagger.hilt.android.testing.HiltAndroidTest;
+import dagger.hilt.components.SingletonComponent;
+import javax.inject.Inject;
+import javax.inject.Named;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/** Tests basic injection APIs, and that bindings don't conflict with {@link Injection2Test}. */
+@HiltAndroidTest
+@RunWith(AndroidJUnit4.class)
+public final class Injection1Test {
+ private static final String APPLICATION_QUALIFIER = "APPLICATION_QUALIFIER";
+ private static final String ACTIVITY_QUALIFIER = "ACTIVITY_QUALIFIER";
+ private static final String APPLICATION_VALUE = "Injection1Test_ApplicationValue";
+ private static final String ACTIVITY_VALUE = "Injection1Test_ActivityValue";
+
+ @Module
+ @InstallIn(SingletonComponent.class)
+ interface TestApplicationModule {
+ @Provides
+ @Named(APPLICATION_QUALIFIER)
+ static String provideString() {
+ return APPLICATION_VALUE;
+ }
+ }
+
+ @Module
+ @InstallIn(ActivityComponent.class)
+ interface TestActivityModule {
+ @Provides
+ @Named(ACTIVITY_QUALIFIER)
+ static String provideString() {
+ return ACTIVITY_VALUE;
+ }
+ }
+
+ /** Test activity used to test activity injection */
+ @AndroidEntryPoint
+ public static final class TestActivity extends AppCompatActivity {
+ @Inject @Named(ACTIVITY_QUALIFIER) String activityValue;
+ }
+
+ @Rule public HiltAndroidRule rule = new HiltAndroidRule(this);
+
+ @Inject @Named(APPLICATION_QUALIFIER) String applicationValue;
+
+ @Test
+ public void testApplicationInjection() throws Exception {
+ assertThat(applicationValue).isNull();
+ rule.inject();
+ assertThat(applicationValue).isEqualTo(APPLICATION_VALUE);
+ }
+
+ @Test
+ public void testActivityInjection() throws Exception {
+ try (ActivityScenario<TestActivity> scenario = ActivityScenario.launch(TestActivity.class)) {
+ scenario.onActivity(activity -> assertThat(activity.activityValue).isEqualTo(ACTIVITY_VALUE));
+ }
+ }
+
+ @Test
+ public void testSuperClassTransformation() {
+ try (ActivityScenario<TestActivity> scenario = ActivityScenario.launch(TestActivity.class)) {
+ scenario.onActivity(
+ activity ->
+ assertThat(activity.getClass().getSuperclass().getSimpleName())
+ .isEqualTo("Hilt_Injection1Test_TestActivity"));
+ }
+ }
+}
diff --git a/java/dagger/hilt/android/example/gradle/simple/app/src/sharedTest/java/dagger/hilt/android/example/gradle/simple/Injection2Test.java b/java/dagger/hilt/android/example/gradle/simple/app/src/sharedTest/java/dagger/hilt/android/example/gradle/simple/Injection2Test.java
new file mode 100644
index 0000000..51d60b2
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/app/src/sharedTest/java/dagger/hilt/android/example/gradle/simple/Injection2Test.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simple;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.test.core.app.ActivityScenario;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.AndroidEntryPoint;
+import dagger.hilt.android.components.ActivityComponent;
+import dagger.hilt.android.testing.HiltAndroidRule;
+import dagger.hilt.android.testing.HiltAndroidTest;
+import dagger.hilt.components.SingletonComponent;
+import javax.inject.Inject;
+import javax.inject.Named;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/** Tests basic injection APIs, and that bindings don't conflict with {@link Injection1Test}. */
+@HiltAndroidTest
+@RunWith(AndroidJUnit4.class)
+public final class Injection2Test {
+ private static final String APPLICATION_QUALIFIER = "APPLICATION_QUALIFIER";
+ private static final String ACTIVITY_QUALIFIER = "ACTIVITY_QUALIFIER";
+ private static final String APPLICATION_VALUE = "Injection2Test_ApplicationValue";
+ private static final String ACTIVITY_VALUE = "Injection2Test_ActivityValue";
+
+ @Module
+ @InstallIn(SingletonComponent.class)
+ interface TestApplicationModule {
+ @Provides
+ @Named(APPLICATION_QUALIFIER)
+ static String provideString() {
+ return APPLICATION_VALUE;
+ }
+ }
+
+ @Module
+ @InstallIn(ActivityComponent.class)
+ interface TestActivityModule {
+ @Provides
+ @Named(ACTIVITY_QUALIFIER)
+ static String provideString() {
+ return ACTIVITY_VALUE;
+ }
+ }
+
+ /** Test activity used to test activity injection */
+ @AndroidEntryPoint
+ public static final class TestActivity extends AppCompatActivity {
+ @Inject @Named(ACTIVITY_QUALIFIER) String activityValue;
+ }
+
+ @Rule public HiltAndroidRule rule = new HiltAndroidRule(this);
+
+ @Inject @Named(APPLICATION_QUALIFIER) String applicationValue;
+
+ @Test
+ public void testApplicationInjection() throws Exception {
+ assertThat(applicationValue).isNull();
+ rule.inject();
+ assertThat(applicationValue).isEqualTo(APPLICATION_VALUE);
+ }
+
+ @Test
+ public void testActivityInjection() throws Exception {
+ try (ActivityScenario<TestActivity> scenario = ActivityScenario.launch(TestActivity.class)) {
+ scenario.onActivity(activity -> assertThat(activity.activityValue).isEqualTo(ACTIVITY_VALUE));
+ }
+ }
+}
diff --git a/java/dagger/hilt/android/example/gradle/simple/app/src/sharedTest/java/dagger/hilt/android/example/gradle/simple/ModuleTest.java b/java/dagger/hilt/android/example/gradle/simple/app/src/sharedTest/java/dagger/hilt/android/example/gradle/simple/ModuleTest.java
new file mode 100644
index 0000000..73daf8f
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/app/src/sharedTest/java/dagger/hilt/android/example/gradle/simple/ModuleTest.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simple;
+
+import static org.junit.Assert.assertEquals;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import dagger.Binds;
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.testing.HiltAndroidRule;
+import dagger.hilt.android.testing.HiltAndroidTest;
+import dagger.hilt.components.SingletonComponent;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+import javax.inject.Inject;
+import javax.inject.Qualifier;
+import javax.inject.Singleton;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/** Tests basic functionality of using modules in test. */
+@HiltAndroidTest
+@RunWith(AndroidJUnit4.class)
+public final class ModuleTest {
+ @Rule public final HiltAndroidRule rules = new HiltAndroidRule(this);
+
+ /** Qualifier for distinguishing test Strings, */
+ @Qualifier
+ @Target({ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD})
+ public @interface TestQualifier {
+ int value();
+ }
+
+ @Inject
+ @TestQualifier(1)
+ String testString1;
+
+ @Inject
+ @TestQualifier(2)
+ String testString2;
+
+ @Inject
+ @TestQualifier(3)
+ String testString3;
+
+ @Inject
+ @TestQualifier(4)
+ String testString4;
+
+ @Inject FooImpl fooImpl;
+ @Inject Foo foo;
+
+ /**
+ * Module which is used to test if non-static test modules get registered in the component
+ * correctly.
+ */
+ @Module
+ @InstallIn(SingletonComponent.class)
+ public final class NonStaticModuleNonStaticProvides {
+ @Provides
+ @TestQualifier(1)
+ String provideString() {
+ return "1";
+ }
+ }
+
+ /**
+ * Module which is used to test if static test modules get registered in the component correctly.
+ */
+ @Module
+ @InstallIn(SingletonComponent.class)
+ public static final class StaticModuleStaticProvides {
+ @Provides
+ @TestQualifier(2)
+ static String provideString() {
+ return "2";
+ }
+
+ private StaticModuleStaticProvides() {}
+ }
+
+ /**
+ * Module which is used to test if static test modules with a non-static methods get registered in
+ * the component correctly.
+ */
+ @Module
+ @InstallIn(SingletonComponent.class)
+ public static final class StaticModuleNonStaticProvidesDefaultConstructor {
+ @Provides
+ @TestQualifier(3)
+ String provideString() {
+ return "3";
+ }
+ }
+
+ /**
+ * Module which is used to test if abstract test modules get registered in the component
+ * correctly.
+ */
+ @Module
+ @InstallIn(SingletonComponent.class)
+ public abstract static class AbstractModuleStaticProvides {
+ @Provides
+ @TestQualifier(4)
+ static String provideString() {
+ return "4";
+ }
+
+ private AbstractModuleStaticProvides() {}
+ }
+
+ /**
+ * Module which is used to test if abstract test modules with a binds method get registered in the
+ * component correctly.
+ */
+ @Module
+ @InstallIn(SingletonComponent.class)
+ public abstract static class AbstractModuleBindsMethod {
+ @Binds
+ abstract Foo foo(FooImpl fooImpl);
+ }
+
+ interface Foo {}
+
+ @Singleton
+ static final class FooImpl implements Foo {
+ @Inject
+ FooImpl() {}
+ }
+
+ @Test
+ public void testInjection() throws Exception {
+ rules.inject();
+ assertEquals("1", testString1);
+ assertEquals("2", testString2);
+ assertEquals("3", testString3);
+ assertEquals("4", testString4);
+ assertEquals(fooImpl, foo);
+ }
+}
diff --git a/java/dagger/hilt/android/example/gradle/simple/app/src/test/java/dagger/hilt/android/example/gradle/simple/SettingsActivityTest.java b/java/dagger/hilt/android/example/gradle/simple/app/src/test/java/dagger/hilt/android/example/gradle/simple/SettingsActivityTest.java
new file mode 100644
index 0000000..f1e5f27
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/app/src/test/java/dagger/hilt/android/example/gradle/simple/SettingsActivityTest.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simple;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.os.Build;
+import androidx.test.core.app.ActivityScenario;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import dagger.hilt.android.testing.BindValue;
+import dagger.hilt.android.testing.HiltAndroidRule;
+import dagger.hilt.android.testing.HiltAndroidTest;
+import dagger.hilt.android.testing.HiltTestApplication;
+import dagger.hilt.android.testing.UninstallModules;
+import javax.inject.Inject;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.annotation.Config;
+
+/** A simple test using Hilt. */
+@UninstallModules(ModelModule.class)
+@HiltAndroidTest
+@RunWith(AndroidJUnit4.class)
+// Robolectric requires Java9 to run API 29 and above, so use API 28 instead
+@Config(sdk = Build.VERSION_CODES.P, application = HiltTestApplication.class)
+public final class SettingsActivityTest {
+ @Rule public HiltAndroidRule rule = new HiltAndroidRule(this);
+
+ @BindValue @Model String fakeModel = "FakeModel";
+
+ @Inject @Model String injectedModel;
+
+ @Test
+ public void testInjectedModel() throws Exception {
+ assertThat(injectedModel).isNull();
+ rule.inject();
+ assertThat(injectedModel).isEqualTo("FakeModel");
+ }
+
+ @Test
+ public void testActivityInject() throws Exception {
+ try (ActivityScenario<SettingsActivity> scenario =
+ ActivityScenario.launch(SettingsActivity.class)) {
+ scenario.onActivity(
+ activity ->
+ assertThat(activity.greeter.greet())
+ .isEqualTo("ProdUser, you are on build FakeModel."));
+ }
+ }
+
+ @Test
+ public void testSuperClassTransformation() {
+ try (ActivityScenario<SettingsActivity> scenario =
+ ActivityScenario.launch(SettingsActivity.class)) {
+ scenario.onActivity(
+ activity ->
+ assertThat(activity.getClass().getSuperclass().getSimpleName())
+ .isEqualTo("Hilt_SettingsActivity"));
+ }
+ }
+}
diff --git a/java/dagger/hilt/android/example/gradle/simple/app/src/test/java/dagger/hilt/android/example/gradle/simple/SimpleActivityTest.java b/java/dagger/hilt/android/example/gradle/simple/app/src/test/java/dagger/hilt/android/example/gradle/simple/SimpleActivityTest.java
new file mode 100644
index 0000000..29b5f70
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/app/src/test/java/dagger/hilt/android/example/gradle/simple/SimpleActivityTest.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simple;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.os.Build;
+import androidx.test.core.app.ActivityScenario;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import dagger.hilt.android.testing.BindValue;
+import dagger.hilt.android.testing.HiltAndroidRule;
+import dagger.hilt.android.testing.HiltAndroidTest;
+import dagger.hilt.android.testing.HiltTestApplication;
+import dagger.hilt.android.testing.UninstallModules;
+import javax.inject.Inject;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.annotation.Config;
+
+/** A simple test using Hilt. */
+@UninstallModules(UserNameModule.class)
+@HiltAndroidTest
+@RunWith(AndroidJUnit4.class)
+// Robolectric requires Java9 to run API 29 and above, so use API 28 instead
+@Config(sdk = Build.VERSION_CODES.P, application = HiltTestApplication.class)
+public final class SimpleActivityTest {
+ @Rule public HiltAndroidRule rule = new HiltAndroidRule(this);
+
+ @BindValue @UserName String fakeUserName = "FakeUser";
+
+ @Inject @UserName String injectedUserName;
+
+ @Test
+ public void testInjectedUserName() throws Exception {
+ assertThat(injectedUserName).isNull();
+ rule.inject();
+ assertThat(injectedUserName).isEqualTo("FakeUser");
+ }
+
+ @Test
+ public void testActivityInject() throws Exception {
+ try (ActivityScenario<SimpleActivity> scenario =
+ ActivityScenario.launch(SimpleActivity.class)) {
+ scenario.onActivity(
+ activity -> assertThat(activity.greeter.greet()).isEqualTo("Hello, FakeUser!"));
+ }
+ }
+}
diff --git a/java/dagger/hilt/android/example/gradle/simple/app/src/test/resources/dagger/hilt/android/example/gradle/simple/robolectric.properties b/java/dagger/hilt/android/example/gradle/simple/app/src/test/resources/dagger/hilt/android/example/gradle/simple/robolectric.properties
new file mode 100644
index 0000000..0234ffe
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/app/src/test/resources/dagger/hilt/android/example/gradle/simple/robolectric.properties
@@ -0,0 +1,2 @@
+sdk=28
+application=dagger.hilt.android.testing.HiltTestApplication
\ No newline at end of file
diff --git a/java/dagger/hilt/android/example/gradle/simple/build.gradle b/java/dagger/hilt/android/example/gradle/simple/build.gradle
new file mode 100644
index 0000000..c0916a4
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/build.gradle
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+buildscript {
+ ext {
+ kotlin_version = '1.3.61'
+ agp_version = "4.2.0-beta04"
+ }
+ repositories {
+ google()
+ jcenter()
+ mavenLocal()
+ }
+ dependencies {
+ classpath "com.android.tools.build:gradle:$agp_version"
+ classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+ classpath 'com.google.dagger:hilt-android-gradle-plugin:LOCAL-SNAPSHOT'
+ }
+}
+
+allprojects {
+ repositories {
+ google()
+ jcenter()
+ mavenCentral()
+ mavenLocal()
+ }
+}
diff --git a/java/dagger/hilt/android/example/gradle/simple/feature/build.gradle b/java/dagger/hilt/android/example/gradle/simple/feature/build.gradle
new file mode 100644
index 0000000..462aefc
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/feature/build.gradle
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+apply plugin: 'kotlin-kapt'
+apply plugin: 'dagger.hilt.android.plugin'
+
+android {
+ compileSdkVersion 30
+ buildToolsVersion "30.0.2"
+
+ defaultConfig {
+ minSdkVersion 15
+ targetSdkVersion 30
+ versionCode 1
+ versionName "1.0"
+ }
+ compileOptions {
+ sourceCompatibility 1.8
+ targetCompatibility 1.8
+ }
+}
+
+kapt {
+ correctErrorTypes true
+}
+
+dependencies {
+ // This is api instead of implementation since Kotlin modules here consumed
+ // by the app need to expose @kotlin.Metadata
+ api "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
+
+ implementation 'androidx.appcompat:appcompat:1.2.0'
+ implementation 'com.google.dagger:hilt-android:LOCAL-SNAPSHOT'
+ kapt 'com.google.dagger:hilt-android-compiler:LOCAL-SNAPSHOT'
+}
diff --git a/java/dagger/hilt/android/example/gradle/simple/feature/src/main/AndroidManifest.xml b/java/dagger/hilt/android/example/gradle/simple/feature/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..f7919a9
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/feature/src/main/AndroidManifest.xml
@@ -0,0 +1,9 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="dagger.hilt.android.example.gradle.simple.feature">
+ <application>
+ <activity
+ android:name=".FeatureActivity"
+ android:theme="@style/Theme.AppCompat.Light"
+ android:exported="true"/>
+ </application>
+</manifest>
diff --git a/java/dagger/hilt/android/example/gradle/simple/feature/src/main/java/dagger/hilt/android/example/gradle/simple/feature/FeatureActivity.kt b/java/dagger/hilt/android/example/gradle/simple/feature/src/main/java/dagger/hilt/android/example/gradle/simple/feature/FeatureActivity.kt
new file mode 100644
index 0000000..03b9ae9
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/feature/src/main/java/dagger/hilt/android/example/gradle/simple/feature/FeatureActivity.kt
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simple.feature
+
+import android.os.Bundle
+import android.widget.Button
+import android.widget.TextView
+import androidx.appcompat.app.AppCompatActivity
+import dagger.hilt.android.AndroidEntryPoint
+import javax.inject.Inject
+
+@AndroidEntryPoint
+class FeatureActivity : AppCompatActivity() {
+ @Inject lateinit var counter: FeatureCounter
+
+ override fun onCreate(savedInstanceState: Bundle?) {
+ super.onCreate(savedInstanceState)
+
+ setContentView(R.layout.activity_feature)
+
+ findViewById<Button>(R.id.feature_button).setOnClickListener {
+ counter.count++
+ updateCountText()
+ }
+
+ updateCountText()
+ }
+
+ private fun updateCountText() {
+ findViewById<TextView>(R.id.feature_count).text = "The count: ${counter.count}"
+ }
+}
diff --git a/java/dagger/hilt/android/example/gradle/simple/feature/src/main/java/dagger/hilt/android/example/gradle/simple/feature/FeatureCounter.kt b/java/dagger/hilt/android/example/gradle/simple/feature/src/main/java/dagger/hilt/android/example/gradle/simple/feature/FeatureCounter.kt
new file mode 100644
index 0000000..0fd3db3
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/feature/src/main/java/dagger/hilt/android/example/gradle/simple/feature/FeatureCounter.kt
@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simple.feature
+
+class FeatureCounter(var count: Int)
diff --git a/java/dagger/hilt/android/example/gradle/simple/feature/src/main/java/dagger/hilt/android/example/gradle/simple/feature/FeatureModule.kt b/java/dagger/hilt/android/example/gradle/simple/feature/src/main/java/dagger/hilt/android/example/gradle/simple/feature/FeatureModule.kt
new file mode 100644
index 0000000..84ca99a
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/feature/src/main/java/dagger/hilt/android/example/gradle/simple/feature/FeatureModule.kt
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simple.feature
+
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.android.components.ActivityRetainedComponent
+import dagger.hilt.android.scopes.ActivityRetainedScoped
+
+@Module
+@InstallIn(ActivityRetainedComponent::class)
+object FeatureModule {
+ @Provides
+ @ActivityRetainedScoped
+ fun provideData() = FeatureCounter(0)
+}
diff --git a/java/dagger/hilt/android/example/gradle/simple/feature/src/main/res/layout/activity_feature.xml b/java/dagger/hilt/android/example/gradle/simple/feature/src/main/res/layout/activity_feature.xml
new file mode 100644
index 0000000..bf52431
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/feature/src/main/res/layout/activity_feature.xml
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ Copyright (C) 2017 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+ android:layout_width="match_parent"
+ android:layout_height="match_parent"
+ android:background="@android:color/background_light">
+
+ <TextView
+ android:id="@+id/feature_count"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:layout_alignParentTop="true"
+ android:textColor="@android:color/primary_text_light"
+ />
+
+ <Button
+ android:id="@+id/feature_button"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:layout_below="@id/feature_count"
+ android:text="Count++"
+ />
+</RelativeLayout>
diff --git a/java/dagger/hilt/android/example/gradle/simple/gradle.properties b/java/dagger/hilt/android/example/gradle/simple/gradle.properties
new file mode 100644
index 0000000..646c51b
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/gradle.properties
@@ -0,0 +1,2 @@
+android.useAndroidX=true
+android.enableJetifier=true
diff --git a/java/dagger/hilt/android/example/gradle/simple/gradle/wrapper/gradle-wrapper.jar b/java/dagger/hilt/android/example/gradle/simple/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000..5c2d1cf
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/gradle/wrapper/gradle-wrapper.jar
Binary files differ
diff --git a/java/dagger/hilt/android/example/gradle/simple/gradle/wrapper/gradle-wrapper.properties b/java/dagger/hilt/android/example/gradle/simple/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000..4d9ca16
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.7.1-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/java/dagger/hilt/android/example/gradle/simple/gradlew b/java/dagger/hilt/android/example/gradle/simple/gradlew
new file mode 100755
index 0000000..b0d6d0a
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/gradlew
@@ -0,0 +1,188 @@
+#!/usr/bin/env sh
+
+#
+# Copyright 2015 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+##
+## Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+ ls=`ls -ld "$PRG"`
+ link=`expr "$ls" : '.*-> \(.*\)$'`
+ if expr "$link" : '/.*' > /dev/null; then
+ PRG="$link"
+ else
+ PRG=`dirname "$PRG"`"/$link"
+ fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+ echo "$*"
+}
+
+die () {
+ echo
+ echo "$*"
+ echo
+ exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+ CYGWIN* )
+ cygwin=true
+ ;;
+ Darwin* )
+ darwin=true
+ ;;
+ MINGW* )
+ msys=true
+ ;;
+ NONSTOP* )
+ nonstop=true
+ ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+ if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+ # IBM's JDK on AIX uses strange locations for the executables
+ JAVACMD="$JAVA_HOME/jre/sh/java"
+ else
+ JAVACMD="$JAVA_HOME/bin/java"
+ fi
+ if [ ! -x "$JAVACMD" ] ; then
+ die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+ fi
+else
+ JAVACMD="java"
+ which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+ MAX_FD_LIMIT=`ulimit -H -n`
+ if [ $? -eq 0 ] ; then
+ if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+ MAX_FD="$MAX_FD_LIMIT"
+ fi
+ ulimit -n $MAX_FD
+ if [ $? -ne 0 ] ; then
+ warn "Could not set maximum file descriptor limit: $MAX_FD"
+ fi
+ else
+ warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+ fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+ GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+ APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+ CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+ JAVACMD=`cygpath --unix "$JAVACMD"`
+
+ # We build the pattern for arguments to be converted via cygpath
+ ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+ SEP=""
+ for dir in $ROOTDIRSRAW ; do
+ ROOTDIRS="$ROOTDIRS$SEP$dir"
+ SEP="|"
+ done
+ OURCYGPATTERN="(^($ROOTDIRS))"
+ # Add a user-defined pattern to the cygpath arguments
+ if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+ OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+ fi
+ # Now convert the arguments - kludge to limit ourselves to /bin/sh
+ i=0
+ for arg in "$@" ; do
+ CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+ CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
+
+ if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
+ eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+ else
+ eval `echo args$i`="\"$arg\""
+ fi
+ i=$((i+1))
+ done
+ case $i in
+ (0) set -- ;;
+ (1) set -- "$args0" ;;
+ (2) set -- "$args0" "$args1" ;;
+ (3) set -- "$args0" "$args1" "$args2" ;;
+ (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+ (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+ (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+ (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+ (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+ (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+ esac
+fi
+
+# Escape application args
+save () {
+ for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+ echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+ cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"
diff --git a/java/dagger/hilt/android/example/gradle/simple/settings.gradle b/java/dagger/hilt/android/example/gradle/simple/settings.gradle
new file mode 100644
index 0000000..2ae0b0a
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simple/settings.gradle
@@ -0,0 +1,3 @@
+rootProject.name='Simple Hilt Android'
+include ':app'
+include ':feature'
diff --git a/java/dagger/hilt/android/example/gradle/simpleKotlin/app/build.gradle b/java/dagger/hilt/android/example/gradle/simpleKotlin/app/build.gradle
new file mode 100644
index 0000000..bff4797
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simpleKotlin/app/build.gradle
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+apply plugin: 'com.android.application'
+apply plugin: 'kotlin-android'
+apply plugin: 'dagger.hilt.android.plugin'
+apply plugin: 'kotlin-kapt'
+
+android {
+ compileSdkVersion 30
+ buildToolsVersion "30.0.2"
+
+ defaultConfig {
+ applicationId "dagger.hilt.android.example.gradle.simpleKotlin"
+ minSdkVersion 15
+ targetSdkVersion 30
+ versionCode 1
+ versionName "1.0"
+ }
+ compileOptions {
+ sourceCompatibility 1.8
+ targetCompatibility 1.8
+ }
+ testOptions {
+ unitTests.includeAndroidResources = true
+ }
+}
+
+dependencies {
+ implementation fileTree(dir: "libs", include: ["*.jar"])
+ implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+ implementation 'androidx.appcompat:appcompat:1.2.0'
+
+ implementation 'com.google.dagger:hilt-android:LOCAL-SNAPSHOT'
+ kapt 'com.google.dagger:hilt-android-compiler:LOCAL-SNAPSHOT'
+
+ testImplementation 'com.google.truth:truth:1.0.1'
+ testImplementation 'junit:junit:4.13'
+ testImplementation 'org.robolectric:robolectric:4.5-alpha-3'
+ testImplementation 'androidx.core:core:1.3.2'
+ // TODO(bcorso): This multidex dep shouldn't be required -- it's a dep for the generated code.
+ testImplementation 'androidx.multidex:multidex:2.0.0'
+ testImplementation 'com.google.dagger:hilt-android-testing:LOCAL-SNAPSHOT'
+ kaptTest 'com.google.dagger:hilt-android-compiler:LOCAL-SNAPSHOT'
+}
diff --git a/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/debug/AndroidManifest.xml b/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/debug/AndroidManifest.xml
new file mode 100644
index 0000000..081c7ad
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/debug/AndroidManifest.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ Copyright (C) 2020 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="dagger.hilt.android.example.gradle.simpleKotlin">
+
+ <application>
+ <activity android:name=".SimpleTest$TestActivity" android:exported="false"/>
+ </application>
+</manifest>
diff --git a/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/main/AndroidManifest.xml b/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..2e274ab
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/main/AndroidManifest.xml
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ Copyright (C) 2020 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="dagger.hilt.android.example.gradle.simpleKotlin">
+
+ <application
+ android:name=".KotlinApplication"
+ android:allowBackup="true"
+ android:label="@string/app_name"
+ android:supportsRtl="true"
+ android:theme="@style/Theme.AppCompat.Light">
+ <activity android:name=".MainActivity" android:exported="true">
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN" />
+
+ <category android:name="android.intent.category.LAUNCHER" />
+ </intent-filter>
+ </activity>
+ </application>
+</manifest>
diff --git a/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/main/java/dagger/hilt/android/example/gradle/simpleKotlin/ActivityModule.kt b/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/main/java/dagger/hilt/android/example/gradle/simpleKotlin/ActivityModule.kt
new file mode 100644
index 0000000..8a85040
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/main/java/dagger/hilt/android/example/gradle/simpleKotlin/ActivityModule.kt
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package dagger.hilt.android.example.gradle.simpleKotlin
+
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.android.components.ActivityComponent
+
+@Module
+@InstallIn(ActivityComponent::class)
+object ActivityModule {
+ @UserName
+ @Provides
+ fun provideUserName(): String {
+ return "Android User"
+ }
+}
diff --git a/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/main/java/dagger/hilt/android/example/gradle/simpleKotlin/ApplicationModule.kt b/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/main/java/dagger/hilt/android/example/gradle/simpleKotlin/ApplicationModule.kt
new file mode 100644
index 0000000..9ee904d
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/main/java/dagger/hilt/android/example/gradle/simpleKotlin/ApplicationModule.kt
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simpleKotlin
+
+import android.os.Build
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+
+@Module
+@InstallIn(SingletonComponent::class)
+object ApplicationModule {
+ @Provides
+ @Model
+ fun provideModel(): String {
+ return Build.MODEL
+ }
+}
diff --git a/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/main/java/dagger/hilt/android/example/gradle/simpleKotlin/KotlinApplication.kt b/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/main/java/dagger/hilt/android/example/gradle/simpleKotlin/KotlinApplication.kt
new file mode 100644
index 0000000..765fb36
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/main/java/dagger/hilt/android/example/gradle/simpleKotlin/KotlinApplication.kt
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simpleKotlin
+
+import android.app.Application
+import dagger.hilt.android.HiltAndroidApp
+import javax.inject.Inject
+
+@HiltAndroidApp
+class KotlinApplication : Application() {
+ // Shows that we can inject SingletonComponent bindings into an application.
+ @Inject
+ @Model
+ @JvmField
+ var model: String? = null
+}
diff --git a/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/main/java/dagger/hilt/android/example/gradle/simpleKotlin/MainActivity.kt b/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/main/java/dagger/hilt/android/example/gradle/simpleKotlin/MainActivity.kt
new file mode 100644
index 0000000..564f05a
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/main/java/dagger/hilt/android/example/gradle/simpleKotlin/MainActivity.kt
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simpleKotlin
+
+import android.os.Bundle
+import android.view.View
+import android.widget.TextView
+import androidx.appcompat.app.AppCompatActivity
+import dagger.hilt.android.AndroidEntryPoint
+import javax.inject.Inject
+
+@AndroidEntryPoint
+class MainActivity : AppCompatActivity() {
+ // Shows that we can inject Application/Activity bindings into an activity.
+ @JvmField
+ @Model
+ @Inject
+ var model: String? = null
+
+ @JvmField
+ @UserName
+ @Inject
+ var name: String? = null
+
+ override fun onCreate(savedInstanceState: Bundle?) {
+ super.onCreate(savedInstanceState)
+ setContentView(R.layout.activity_main)
+ val greeting = findViewById<View>(R.id.greeting) as TextView
+ val text = resources.getString(R.string.welcome, name, model)
+ greeting.text = text
+ }
+}
diff --git a/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/main/java/dagger/hilt/android/example/gradle/simpleKotlin/Model.kt b/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/main/java/dagger/hilt/android/example/gradle/simpleKotlin/Model.kt
new file mode 100644
index 0000000..4fe168d
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/main/java/dagger/hilt/android/example/gradle/simpleKotlin/Model.kt
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simpleKotlin
+
+import javax.inject.Qualifier
+
+/** Qualifies bindings relating to [android.os.Build.MODEL]. */
+@Qualifier
+@Retention(AnnotationRetention.RUNTIME)
+internal annotation class Model
diff --git a/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/main/java/dagger/hilt/android/example/gradle/simpleKotlin/UserName.kt b/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/main/java/dagger/hilt/android/example/gradle/simpleKotlin/UserName.kt
new file mode 100644
index 0000000..a061ab5
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/main/java/dagger/hilt/android/example/gradle/simpleKotlin/UserName.kt
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simpleKotlin
+
+import javax.inject.Qualifier
+
+/** Qualifies bindings relating to the user name. */
+@Qualifier
+@Retention(AnnotationRetention.RUNTIME)
+internal annotation class UserName
diff --git a/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/main/res/layout/activity_main.xml b/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/main/res/layout/activity_main.xml
new file mode 100644
index 0000000..0d7637d
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/main/res/layout/activity_main.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ Copyright (C) 2020 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+ android:layout_width="match_parent"
+ android:layout_height="match_parent"
+ android:background="@android:color/background_light">
+
+ <TextView
+ android:id="@+id/greeting"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:layout_alignParentTop="true"
+ android:textColor="@android:color/primary_text_light"
+ />
+</RelativeLayout>
diff --git a/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/main/res/values/strings.xml b/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/main/res/values/strings.xml
new file mode 100644
index 0000000..c1e4f27
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/main/res/values/strings.xml
@@ -0,0 +1,23 @@
+<!--
+ ~ Copyright (C) 2020 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+
+<resources>
+ <!--The app name [CHAR_LIMIT=40]-->
+ <string name="app_name">Simple Hilt Kotlin Android App</string>
+
+ <!--The greeting message [CHAR_LIMIT=100]-->
+ <string name="welcome">Hello, %1$s! You are on build %2$s.</string>
+</resources>
diff --git a/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/test/java/dagger/hilt/android/example/gradle/simpleKotlin/SimpleTest.kt b/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/test/java/dagger/hilt/android/example/gradle/simpleKotlin/SimpleTest.kt
new file mode 100644
index 0000000..d52ff71
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simpleKotlin/app/src/test/java/dagger/hilt/android/example/gradle/simpleKotlin/SimpleTest.kt
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simpleKotlin
+
+import android.os.Build
+import androidx.appcompat.app.AppCompatActivity
+import androidx.test.core.app.ActivityScenario
+import com.google.common.truth.Truth.assertThat
+import dagger.hilt.android.AndroidEntryPoint
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import dagger.hilt.android.testing.HiltTestApplication
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+/**
+ * Example local unit test, which will execute on the development machine (host).
+ *
+ * See [testing documentation](http://d.android.com/tools/testing).
+ */
+@HiltAndroidTest
+@RunWith(RobolectricTestRunner::class)
+// Robolectric requires Java9 to run API 29 and above, so use API 28 instead
+@Config(sdk = [Build.VERSION_CODES.P], application = HiltTestApplication::class)
+class SimpleTest {
+ @Rule
+ @JvmField
+ var rule = HiltAndroidRule(this)
+
+ @AndroidEntryPoint
+ class TestActivity : AppCompatActivity()
+
+ @Test
+ fun verifyMainActivity() {
+ ActivityScenario.launch(MainActivity::class.java).use { scenario ->
+ scenario.onActivity { activity ->
+ assertThat(activity::class.java.getSuperclass()?.getSimpleName())
+ .isEqualTo("Hilt_MainActivity")
+ assertThat(activity.model).isNotNull()
+ assertThat(activity.name).isNotNull()
+ }
+ }
+ }
+
+ @Test
+ fun verifyTestActivity() {
+ ActivityScenario.launch(TestActivity::class.java).use { scenario ->
+ scenario.onActivity { activity ->
+ assertThat(activity::class.java.getSuperclass()?.getSimpleName())
+ .isEqualTo("Hilt_SimpleTest_TestActivity")
+ }
+ }
+ }
+}
diff --git a/java/dagger/hilt/android/example/gradle/simpleKotlin/build.gradle b/java/dagger/hilt/android/example/gradle/simpleKotlin/build.gradle
new file mode 100644
index 0000000..7a02482
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simpleKotlin/build.gradle
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+buildscript {
+ ext {
+ kotlin_version = '1.3.61'
+ agp_version = "4.2.0-beta04"
+ }
+ repositories {
+ google()
+ jcenter()
+ mavenLocal()
+ }
+ dependencies {
+ classpath "com.android.tools.build:gradle:$agp_version"
+ classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+ classpath 'com.google.dagger:hilt-android-gradle-plugin:LOCAL-SNAPSHOT'
+ }
+}
+
+allprojects {
+ repositories {
+ google()
+ jcenter()
+ mavenCentral()
+ mavenLocal()
+ }
+}
diff --git a/java/dagger/hilt/android/example/gradle/simpleKotlin/gradle.properties b/java/dagger/hilt/android/example/gradle/simpleKotlin/gradle.properties
new file mode 100644
index 0000000..646c51b
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simpleKotlin/gradle.properties
@@ -0,0 +1,2 @@
+android.useAndroidX=true
+android.enableJetifier=true
diff --git a/java/dagger/hilt/android/example/gradle/simpleKotlin/gradle/wrapper/gradle-wrapper.jar b/java/dagger/hilt/android/example/gradle/simpleKotlin/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000..5c2d1cf
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simpleKotlin/gradle/wrapper/gradle-wrapper.jar
Binary files differ
diff --git a/java/dagger/hilt/android/example/gradle/simpleKotlin/gradle/wrapper/gradle-wrapper.properties b/java/dagger/hilt/android/example/gradle/simpleKotlin/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000..4d9ca16
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simpleKotlin/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.7.1-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/java/dagger/hilt/android/example/gradle/simpleKotlin/gradlew b/java/dagger/hilt/android/example/gradle/simpleKotlin/gradlew
new file mode 100755
index 0000000..b0d6d0a
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simpleKotlin/gradlew
@@ -0,0 +1,188 @@
+#!/usr/bin/env sh
+
+#
+# Copyright 2015 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+##
+## Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+ ls=`ls -ld "$PRG"`
+ link=`expr "$ls" : '.*-> \(.*\)$'`
+ if expr "$link" : '/.*' > /dev/null; then
+ PRG="$link"
+ else
+ PRG=`dirname "$PRG"`"/$link"
+ fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+ echo "$*"
+}
+
+die () {
+ echo
+ echo "$*"
+ echo
+ exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+ CYGWIN* )
+ cygwin=true
+ ;;
+ Darwin* )
+ darwin=true
+ ;;
+ MINGW* )
+ msys=true
+ ;;
+ NONSTOP* )
+ nonstop=true
+ ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+ if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+ # IBM's JDK on AIX uses strange locations for the executables
+ JAVACMD="$JAVA_HOME/jre/sh/java"
+ else
+ JAVACMD="$JAVA_HOME/bin/java"
+ fi
+ if [ ! -x "$JAVACMD" ] ; then
+ die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+ fi
+else
+ JAVACMD="java"
+ which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+ MAX_FD_LIMIT=`ulimit -H -n`
+ if [ $? -eq 0 ] ; then
+ if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+ MAX_FD="$MAX_FD_LIMIT"
+ fi
+ ulimit -n $MAX_FD
+ if [ $? -ne 0 ] ; then
+ warn "Could not set maximum file descriptor limit: $MAX_FD"
+ fi
+ else
+ warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+ fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+ GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+ APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+ CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+ JAVACMD=`cygpath --unix "$JAVACMD"`
+
+ # We build the pattern for arguments to be converted via cygpath
+ ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+ SEP=""
+ for dir in $ROOTDIRSRAW ; do
+ ROOTDIRS="$ROOTDIRS$SEP$dir"
+ SEP="|"
+ done
+ OURCYGPATTERN="(^($ROOTDIRS))"
+ # Add a user-defined pattern to the cygpath arguments
+ if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+ OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+ fi
+ # Now convert the arguments - kludge to limit ourselves to /bin/sh
+ i=0
+ for arg in "$@" ; do
+ CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+ CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
+
+ if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
+ eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+ else
+ eval `echo args$i`="\"$arg\""
+ fi
+ i=$((i+1))
+ done
+ case $i in
+ (0) set -- ;;
+ (1) set -- "$args0" ;;
+ (2) set -- "$args0" "$args1" ;;
+ (3) set -- "$args0" "$args1" "$args2" ;;
+ (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+ (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+ (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+ (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+ (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+ (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+ esac
+fi
+
+# Escape application args
+save () {
+ for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+ echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+ cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"
diff --git a/java/dagger/hilt/android/example/gradle/simpleKotlin/settings.gradle b/java/dagger/hilt/android/example/gradle/simpleKotlin/settings.gradle
new file mode 100644
index 0000000..e42f9d1
--- /dev/null
+++ b/java/dagger/hilt/android/example/gradle/simpleKotlin/settings.gradle
@@ -0,0 +1,2 @@
+rootProject.name='Simple Kotlin Hilt Android'
+include ':app'
diff --git a/java/dagger/hilt/android/internal/BUILD b/java/dagger/hilt/android/internal/BUILD
new file mode 100644
index 0000000..57c84e3
--- /dev/null
+++ b/java/dagger/hilt/android/internal/BUILD
@@ -0,0 +1,28 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Internal Hilt Android utitlies
+
+package(default_visibility = ["//:src"])
+
+android_library(
+ name = "internal",
+ srcs = ["ThreadUtil.java"],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/android/internal/ThreadUtil.java b/java/dagger/hilt/android/internal/ThreadUtil.java
new file mode 100644
index 0000000..d5b11f5
--- /dev/null
+++ b/java/dagger/hilt/android/internal/ThreadUtil.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal;
+
+import android.os.Looper;
+
+/** Thread utility methods. */
+public final class ThreadUtil {
+
+ private static Thread mainThread;
+
+ private ThreadUtil() {}
+
+ /** Returns true if the current thread is the Main thread. */
+ public static boolean isMainThread() {
+ if (mainThread == null) {
+ mainThread = Looper.getMainLooper().getThread();
+ }
+ return Thread.currentThread() == mainThread;
+ }
+
+ /** Checks that the current thread is the Main thread. Otherwise throws an exception. */
+ public static void ensureMainThread() {
+ if (!isMainThread()) {
+ throw new IllegalStateException("Must be called on the Main thread.");
+ }
+ }
+}
diff --git a/java/dagger/hilt/android/internal/builders/ActivityComponentBuilder.java b/java/dagger/hilt/android/internal/builders/ActivityComponentBuilder.java
new file mode 100644
index 0000000..5ea09db
--- /dev/null
+++ b/java/dagger/hilt/android/internal/builders/ActivityComponentBuilder.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.builders;
+
+import android.app.Activity;
+import dagger.BindsInstance;
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.components.ActivityComponent;
+
+/** Interface for creating an {@link ActivityComponent}. */
+@DefineComponent.Builder
+public interface ActivityComponentBuilder {
+ ActivityComponentBuilder activity(
+ @BindsInstance
+ Activity activity);
+
+ ActivityComponent build();
+}
diff --git a/java/dagger/hilt/android/internal/builders/ActivityRetainedComponentBuilder.java b/java/dagger/hilt/android/internal/builders/ActivityRetainedComponentBuilder.java
new file mode 100644
index 0000000..110b3fe
--- /dev/null
+++ b/java/dagger/hilt/android/internal/builders/ActivityRetainedComponentBuilder.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.builders;
+
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.components.ActivityRetainedComponent;
+
+/** Interface for creating a {@link ActivityRetainedComponent}. */
+@DefineComponent.Builder
+public interface ActivityRetainedComponentBuilder {
+ ActivityRetainedComponent build();
+}
diff --git a/java/dagger/hilt/android/internal/builders/BUILD b/java/dagger/hilt/android/internal/builders/BUILD
new file mode 100644
index 0000000..0e282be
--- /dev/null
+++ b/java/dagger/hilt/android/internal/builders/BUILD
@@ -0,0 +1,37 @@
+# Copyright (C) 2019 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Hilt Android component builders
+
+package(default_visibility = ["//:src"])
+
+android_library(
+ name = "builders",
+ srcs = glob(["*.java"]),
+ deps = [
+ "//:dagger_with_compiler",
+ "//java/dagger/hilt:define_component",
+ "//java/dagger/hilt/android/components",
+ "//java/dagger/hilt/android/components:view_model_component",
+ "@maven//:androidx_activity_activity",
+ "@maven//:androidx_fragment_fragment",
+ "@maven//:androidx_lifecycle_lifecycle_viewmodel_savedstate",
+ ],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/android/internal/builders/FragmentComponentBuilder.java b/java/dagger/hilt/android/internal/builders/FragmentComponentBuilder.java
new file mode 100644
index 0000000..11cc89f
--- /dev/null
+++ b/java/dagger/hilt/android/internal/builders/FragmentComponentBuilder.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.builders;
+
+import androidx.fragment.app.Fragment;
+import dagger.BindsInstance;
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.components.FragmentComponent;
+
+/** Interface for creating a {@link FragmentComponent}. */
+@DefineComponent.Builder
+public interface FragmentComponentBuilder {
+ FragmentComponentBuilder fragment(@BindsInstance Fragment fragment);
+ FragmentComponent build();
+}
diff --git a/java/dagger/hilt/android/internal/builders/ServiceComponentBuilder.java b/java/dagger/hilt/android/internal/builders/ServiceComponentBuilder.java
new file mode 100644
index 0000000..9b95d12
--- /dev/null
+++ b/java/dagger/hilt/android/internal/builders/ServiceComponentBuilder.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.builders;
+
+import android.app.Service;
+import dagger.BindsInstance;
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.components.ServiceComponent;
+
+/** Interface for creating a {@link ServiceComponent}. */
+@DefineComponent.Builder
+public interface ServiceComponentBuilder {
+ ServiceComponentBuilder service(@BindsInstance Service service);
+ ServiceComponent build();
+}
diff --git a/java/dagger/hilt/android/internal/builders/ViewComponentBuilder.java b/java/dagger/hilt/android/internal/builders/ViewComponentBuilder.java
new file mode 100644
index 0000000..f2e37b6
--- /dev/null
+++ b/java/dagger/hilt/android/internal/builders/ViewComponentBuilder.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.builders;
+
+import android.view.View;
+import dagger.BindsInstance;
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.components.ViewComponent;
+
+/** Interface for creating a {@link ViewComponent}. */
+@DefineComponent.Builder
+public interface ViewComponentBuilder {
+ ViewComponentBuilder view(@BindsInstance View view);
+
+ ViewComponent build();
+}
diff --git a/java/dagger/hilt/android/internal/builders/ViewModelComponentBuilder.java b/java/dagger/hilt/android/internal/builders/ViewModelComponentBuilder.java
new file mode 100644
index 0000000..e9acbb9
--- /dev/null
+++ b/java/dagger/hilt/android/internal/builders/ViewModelComponentBuilder.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.builders;
+
+import androidx.lifecycle.SavedStateHandle;
+import dagger.BindsInstance;
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.components.ViewModelComponent;
+
+/** Interface for creating a {@link ViewModelComponent}. */
+@DefineComponent.Builder
+public interface ViewModelComponentBuilder {
+ ViewModelComponentBuilder savedStateHandle(@BindsInstance SavedStateHandle handle);
+
+ ViewModelComponent build();
+}
diff --git a/java/dagger/hilt/android/internal/builders/ViewWithFragmentComponentBuilder.java b/java/dagger/hilt/android/internal/builders/ViewWithFragmentComponentBuilder.java
new file mode 100644
index 0000000..b15a8cc
--- /dev/null
+++ b/java/dagger/hilt/android/internal/builders/ViewWithFragmentComponentBuilder.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.builders;
+
+import android.view.View;
+import dagger.BindsInstance;
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.components.ViewWithFragmentComponent;
+
+/** Interface for creating a {@link ViewWithFragmentComponent}. */
+@DefineComponent.Builder
+public interface ViewWithFragmentComponentBuilder {
+ ViewWithFragmentComponentBuilder view(@BindsInstance View view);
+
+ ViewWithFragmentComponent build();
+}
diff --git a/java/dagger/hilt/android/internal/lifecycle/BUILD b/java/dagger/hilt/android/internal/lifecycle/BUILD
new file mode 100644
index 0000000..b3ecfc2
--- /dev/null
+++ b/java/dagger/hilt/android/internal/lifecycle/BUILD
@@ -0,0 +1,43 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Hilt lifecycle ViewModel hooks.
+
+package(default_visibility = ["//:src"])
+
+android_library(
+ name = "lifecycle",
+ srcs = glob(["*.java"]),
+ deps = [
+ "//:dagger_with_compiler",
+ "//java/dagger/hilt:entry_point",
+ "//java/dagger/hilt:install_in",
+ "//java/dagger/hilt/android/components",
+ "//java/dagger/hilt/android/components:view_model_component",
+ "//java/dagger/hilt/android/internal/builders",
+ "//java/dagger/hilt/android/qualifiers",
+ "@maven//:androidx_activity_activity",
+ "@maven//:androidx_annotation_annotation",
+ "@maven//:androidx_fragment_fragment",
+ "@maven//:androidx_lifecycle_lifecycle_viewmodel",
+ "@maven//:androidx_lifecycle_lifecycle_viewmodel_savedstate",
+ "@maven//:androidx_savedstate_savedstate",
+ ],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/android/internal/lifecycle/DefaultActivityViewModelFactory.java b/java/dagger/hilt/android/internal/lifecycle/DefaultActivityViewModelFactory.java
new file mode 100644
index 0000000..becce8c
--- /dev/null
+++ b/java/dagger/hilt/android/internal/lifecycle/DefaultActivityViewModelFactory.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.lifecycle;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import javax.inject.Qualifier;
+
+/** Qualifier for the default view model factory used by @AndroidEntryPoint annotated activities. */
+@Qualifier
+@Retention(RetentionPolicy.CLASS)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.PARAMETER})
+public @interface DefaultActivityViewModelFactory {}
diff --git a/java/dagger/hilt/android/internal/lifecycle/DefaultFragmentViewModelFactory.java b/java/dagger/hilt/android/internal/lifecycle/DefaultFragmentViewModelFactory.java
new file mode 100644
index 0000000..9967053
--- /dev/null
+++ b/java/dagger/hilt/android/internal/lifecycle/DefaultFragmentViewModelFactory.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.lifecycle;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import javax.inject.Qualifier;
+
+/** Qualifier for the default view model factory used by @AndroidEntryPoint annotated fragments. */
+@Qualifier
+@Retention(RetentionPolicy.CLASS)
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.PARAMETER})
+public @interface DefaultFragmentViewModelFactory {}
diff --git a/java/dagger/hilt/android/internal/lifecycle/DefaultViewModelFactories.java b/java/dagger/hilt/android/internal/lifecycle/DefaultViewModelFactories.java
new file mode 100644
index 0000000..427822d
--- /dev/null
+++ b/java/dagger/hilt/android/internal/lifecycle/DefaultViewModelFactories.java
@@ -0,0 +1,167 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.lifecycle;
+
+import android.app.Application;
+import androidx.lifecycle.SavedStateViewModelFactory;
+import androidx.lifecycle.ViewModelProvider;
+import android.os.Bundle;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+import androidx.activity.ComponentActivity;
+import androidx.savedstate.SavedStateRegistryOwner;
+import dagger.Module;
+import dagger.hilt.EntryPoint;
+import dagger.hilt.EntryPoints;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityComponent;
+import dagger.hilt.android.components.FragmentComponent;
+import dagger.hilt.android.internal.builders.ViewModelComponentBuilder;
+import dagger.multibindings.Multibinds;
+import java.util.Set;
+import javax.inject.Inject;
+
+/**
+ * Modules and entry points for the default view model factory used by activities and fragments
+ * annotated with @AndroidEntryPoint.
+ *
+ * <p>Entry points are used to acquire the factory because injected fields in the generated
+ * activities and fragments are ignored by Dagger when using the transform due to the generated
+ * class not being part of the hierarchy during compile time.
+ */
+public final class DefaultViewModelFactories {
+
+ /**
+ * Retrieves the default view model factory for the activity.
+ *
+ * <p>Do not use except in Hilt generated code!
+ */
+ public static ViewModelProvider.Factory getActivityFactory(ComponentActivity activity) {
+ return EntryPoints.get(activity, ActivityEntryPoint.class)
+ .getHiltInternalFactoryFactory()
+ .fromActivity(activity);
+ }
+
+ /**
+ * Retrieves the default view model factory for the activity.
+ *
+ * <p>Do not use except in Hilt generated code!
+ */
+ public static ViewModelProvider.Factory getFragmentFactory(Fragment fragment) {
+ return EntryPoints.get(fragment, FragmentEntryPoint.class)
+ .getHiltInternalFactoryFactory()
+ .fromFragment(fragment);
+ }
+
+ /** Internal factory for the Hilt ViewModel Factory. */
+ public static final class InternalFactoryFactory {
+
+ private final Application application;
+ private final Set<String> keySet;
+ private final ViewModelComponentBuilder viewModelComponentBuilder;
+ @Nullable private final ViewModelProvider.Factory defaultActivityFactory;
+ @Nullable private final ViewModelProvider.Factory defaultFragmentFactory;
+
+ @Inject
+ InternalFactoryFactory(
+ Application application,
+ @HiltViewModelMap.KeySet Set<String> keySet,
+ ViewModelComponentBuilder viewModelComponentBuilder,
+ // These default factory bindings are temporary for the transition of deprecating
+ // the Hilt ViewModel extension for the built-in support
+ @DefaultActivityViewModelFactory Set<ViewModelProvider.Factory> defaultActivityFactorySet,
+ @DefaultFragmentViewModelFactory Set<ViewModelProvider.Factory> defaultFragmentFactorySet) {
+ this.application = application;
+ this.keySet = keySet;
+ this.viewModelComponentBuilder = viewModelComponentBuilder;
+ this.defaultActivityFactory = getFactoryFromSet(defaultActivityFactorySet);
+ this.defaultFragmentFactory = getFactoryFromSet(defaultFragmentFactorySet);
+ }
+
+ ViewModelProvider.Factory fromActivity(ComponentActivity activity) {
+ return getHiltViewModelFactory(activity,
+ activity.getIntent() != null ? activity.getIntent().getExtras() : null,
+ defaultActivityFactory);
+ }
+
+ ViewModelProvider.Factory fromFragment(Fragment fragment) {
+ return getHiltViewModelFactory(fragment, fragment.getArguments(), defaultFragmentFactory);
+ }
+
+ private ViewModelProvider.Factory getHiltViewModelFactory(
+ SavedStateRegistryOwner owner,
+ @Nullable Bundle defaultArgs,
+ @Nullable ViewModelProvider.Factory extensionDelegate) {
+ ViewModelProvider.Factory delegate = extensionDelegate == null
+ ? new SavedStateViewModelFactory(application, owner, defaultArgs)
+ : extensionDelegate;
+ return new HiltViewModelFactory(
+ owner, defaultArgs, keySet, delegate, viewModelComponentBuilder);
+ }
+
+ @Nullable
+ private static ViewModelProvider.Factory getFactoryFromSet(Set<ViewModelProvider.Factory> set) {
+ // A multibinding set is used instead of BindsOptionalOf because Optional is not available in
+ // Android until API 24 and we don't want to have Guava as a transitive dependency.
+ if (set.isEmpty()) {
+ return null;
+ }
+ if (set.size() > 1) {
+ throw new IllegalStateException(
+ "At most one default view model factory is expected. Found " + set);
+ }
+ ViewModelProvider.Factory factory = set.iterator().next();
+ if (factory == null) {
+ throw new IllegalStateException("Default view model factory must not be null.");
+ }
+ return factory;
+ }
+ }
+
+ /** The activity module to declare the optional factories. */
+ @Module
+ @InstallIn(ActivityComponent.class)
+ interface ActivityModule {
+ @Multibinds
+ @HiltViewModelMap.KeySet
+ abstract Set<String> viewModelKeys();
+
+ @Multibinds
+ @DefaultActivityViewModelFactory
+ Set<ViewModelProvider.Factory> defaultActivityViewModelFactory();
+
+ @Multibinds
+ @DefaultFragmentViewModelFactory
+ Set<ViewModelProvider.Factory> defaultFragmentViewModelFactory();
+ }
+
+ /** The activity entry point to retrieve the factory. */
+ @EntryPoint
+ @InstallIn(ActivityComponent.class)
+ public interface ActivityEntryPoint {
+ InternalFactoryFactory getHiltInternalFactoryFactory();
+ }
+
+ /** The fragment entry point to retrieve the factory. */
+ @EntryPoint
+ @InstallIn(FragmentComponent.class)
+ public interface FragmentEntryPoint {
+ InternalFactoryFactory getHiltInternalFactoryFactory();
+ }
+
+ private DefaultViewModelFactories() {}
+}
diff --git a/java/dagger/hilt/android/internal/lifecycle/HiltViewModelFactory.java b/java/dagger/hilt/android/internal/lifecycle/HiltViewModelFactory.java
new file mode 100644
index 0000000..3b0d3bc
--- /dev/null
+++ b/java/dagger/hilt/android/internal/lifecycle/HiltViewModelFactory.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.lifecycle;
+
+import androidx.lifecycle.AbstractSavedStateViewModelFactory;
+import androidx.lifecycle.SavedStateHandle;
+import androidx.lifecycle.ViewModel;
+import androidx.lifecycle.ViewModelProvider;
+import android.os.Bundle;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.savedstate.SavedStateRegistryOwner;
+import dagger.Module;
+import dagger.hilt.EntryPoint;
+import dagger.hilt.EntryPoints;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ViewModelComponent;
+import dagger.hilt.android.internal.builders.ViewModelComponentBuilder;
+import dagger.multibindings.Multibinds;
+import java.util.Map;
+import java.util.Set;
+import javax.inject.Provider;
+
+/**
+ * View Model Provider Factory for the Hilt Extension.
+ *
+ * <p>A provider for this factory will be installed in the {@link
+ * dagger.hilt.android.components.ActivityComponent} and {@link
+ * dagger.hilt.android.components.FragmentComponent}. An instance of this factory will also be the
+ * default factory by activities and fragments annotated with {@link
+ * dagger.hilt.android.AndroidEntryPoint}.
+ */
+public final class HiltViewModelFactory implements ViewModelProvider.Factory {
+
+ /** Hilt entry point for getting the multi-binding map of ViewModels. */
+ @EntryPoint
+ @InstallIn(ViewModelComponent.class)
+ public interface ViewModelFactoriesEntryPoint {
+ @HiltViewModelMap
+ Map<String, Provider<ViewModel>> getHiltViewModelMap();
+ }
+
+ /** Hilt module for providing the empty multi-binding map of ViewModels. */
+ @Module
+ @InstallIn(ViewModelComponent.class)
+ interface ViewModelModule {
+ @Multibinds
+ @HiltViewModelMap
+ Map<String, ViewModel> hiltViewModelMap();
+ }
+
+ private final Set<String> hiltViewModelKeys;
+ private final ViewModelProvider.Factory delegateFactory;
+ private final AbstractSavedStateViewModelFactory hiltViewModelFactory;
+
+ public HiltViewModelFactory(
+ @NonNull SavedStateRegistryOwner owner,
+ @Nullable Bundle defaultArgs,
+ @NonNull Set<String> hiltViewModelKeys,
+ @NonNull ViewModelProvider.Factory delegateFactory,
+ @NonNull ViewModelComponentBuilder viewModelComponentBuilder) {
+ this.hiltViewModelKeys = hiltViewModelKeys;
+ this.delegateFactory = delegateFactory;
+ this.hiltViewModelFactory =
+ new AbstractSavedStateViewModelFactory(owner, defaultArgs) {
+ @NonNull
+ @Override
+ @SuppressWarnings("unchecked")
+ protected <T extends ViewModel> T create(
+ @NonNull String key, @NonNull Class<T> modelClass, @NonNull SavedStateHandle handle) {
+ ViewModelComponent component =
+ viewModelComponentBuilder.savedStateHandle(handle).build();
+ Provider<? extends ViewModel> provider =
+ EntryPoints.get(component, ViewModelFactoriesEntryPoint.class)
+ .getHiltViewModelMap()
+ .get(modelClass.getName());
+ if (provider == null) {
+ throw new IllegalStateException(
+ "Expected the @HiltViewModel-annotated class '"
+ + modelClass.getName()
+ + "' to be available in the multi-binding of "
+ + "@HiltViewModelMap but none was found.");
+ }
+ return (T) provider.get();
+ }
+ };
+ }
+
+ @NonNull
+ @Override
+ public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {
+ if (hiltViewModelKeys.contains(modelClass.getName())) {
+ return hiltViewModelFactory.create(modelClass);
+ } else {
+ return delegateFactory.create(modelClass);
+ }
+ }
+}
diff --git a/java/dagger/hilt/android/internal/lifecycle/HiltViewModelMap.java b/java/dagger/hilt/android/internal/lifecycle/HiltViewModelMap.java
new file mode 100644
index 0000000..5d54e9c
--- /dev/null
+++ b/java/dagger/hilt/android/internal/lifecycle/HiltViewModelMap.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.lifecycle;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import javax.inject.Qualifier;
+
+/**
+ * Internal qualifier for the multibinding map of ViewModels used by the {@link
+ * dagger.hilt.android.lifecycle.HiltViewModelFactory}.
+ */
+@Qualifier
+@Retention(RetentionPolicy.CLASS)
+@Target({ElementType.METHOD, ElementType.PARAMETER})
+public @interface HiltViewModelMap {
+
+ /** Internal qualifier for the multibinding set of class names annotated with @ViewModelInject. */
+ @Qualifier
+ @Retention(RetentionPolicy.CLASS)
+ @Target({ElementType.METHOD, ElementType.PARAMETER})
+ @interface KeySet {}
+}
diff --git a/java/dagger/hilt/android/internal/managers/ActivityComponentManager.java b/java/dagger/hilt/android/internal/managers/ActivityComponentManager.java
new file mode 100644
index 0000000..ef7aa3b
--- /dev/null
+++ b/java/dagger/hilt/android/internal/managers/ActivityComponentManager.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.managers;
+
+import android.app.Activity;
+import android.app.Application;
+import androidx.activity.ComponentActivity;
+import dagger.hilt.EntryPoint;
+import dagger.hilt.EntryPoints;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityRetainedComponent;
+import dagger.hilt.android.internal.builders.ActivityComponentBuilder;
+import dagger.hilt.internal.GeneratedComponentManager;
+
+/**
+ * Do not use except in Hilt generated code!
+ *
+ * <p>A manager for the creation of components that live in the Activity.
+ *
+ * <p>Note: This class is not typed since its type in generated code is always <?> or <Object>. This
+ * is mainly due to the fact that we don't know the components at the time of generation, and
+ * because even the injector interface type is not a valid type if we have a hilt base class.
+ *
+ */
+public class ActivityComponentManager implements GeneratedComponentManager<Object> {
+ /** Entrypoint for {@link ActivityComponentBuilder}. */
+ @EntryPoint
+ @InstallIn(ActivityRetainedComponent.class)
+ public interface ActivityComponentBuilderEntryPoint {
+ ActivityComponentBuilder activityComponentBuilder();
+ }
+
+ private volatile Object component;
+ private final Object componentLock = new Object();
+
+ protected final Activity activity;
+
+ private final GeneratedComponentManager<ActivityRetainedComponent>
+ activityRetainedComponentManager;
+
+ public ActivityComponentManager(Activity activity) {
+ this.activity = activity;
+ this.activityRetainedComponentManager =
+ new ActivityRetainedComponentManager((ComponentActivity) activity);
+ }
+
+ @Override
+ public Object generatedComponent() {
+ if (component == null) {
+ synchronized (componentLock) {
+ if (component == null) {
+ component = createComponent();
+ }
+ }
+ }
+ return component;
+ }
+
+ protected Object createComponent() {
+ if (!(activity.getApplication() instanceof GeneratedComponentManager)) {
+ if (Application.class.equals(activity.getApplication().getClass())) {
+ throw new IllegalStateException(
+ "Hilt Activity must be attached to an @HiltAndroidApp Application. "
+ + "Did you forget to specify your Application's class name in your manifest's "
+ + "<application />'s android:name attribute?");
+ }
+ throw new IllegalStateException(
+ "Hilt Activity must be attached to an @AndroidEntryPoint Application. Found: "
+ + activity.getApplication().getClass());
+ }
+
+ return EntryPoints.get(
+ activityRetainedComponentManager, ActivityComponentBuilderEntryPoint.class)
+ .activityComponentBuilder()
+ .activity(activity)
+ .build();
+ }
+}
diff --git a/java/dagger/hilt/android/internal/managers/ActivityRetainedComponentManager.java b/java/dagger/hilt/android/internal/managers/ActivityRetainedComponentManager.java
new file mode 100644
index 0000000..2d4a72b
--- /dev/null
+++ b/java/dagger/hilt/android/internal/managers/ActivityRetainedComponentManager.java
@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.managers;
+
+import androidx.lifecycle.ViewModel;
+import androidx.lifecycle.ViewModelProvider;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.activity.ComponentActivity;
+import dagger.Binds;
+import dagger.Module;
+import dagger.hilt.EntryPoint;
+import dagger.hilt.EntryPoints;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.ActivityRetainedLifecycle;
+import dagger.hilt.android.components.ActivityRetainedComponent;
+import dagger.hilt.android.internal.ThreadUtil;
+import dagger.hilt.android.internal.builders.ActivityRetainedComponentBuilder;
+import dagger.hilt.android.scopes.ActivityRetainedScoped;
+import dagger.hilt.components.SingletonComponent;
+import dagger.hilt.internal.GeneratedComponentManager;
+import java.util.HashSet;
+import java.util.Set;
+import javax.inject.Inject;
+
+/** A manager for the creation of components that survives activity configuration changes. */
+final class ActivityRetainedComponentManager
+ implements GeneratedComponentManager<ActivityRetainedComponent> {
+
+ /** Entry point for {@link ActivityRetainedComponentBuilder}. */
+ @EntryPoint
+ @InstallIn(SingletonComponent.class)
+ public interface ActivityRetainedComponentBuilderEntryPoint {
+ ActivityRetainedComponentBuilder retainedComponentBuilder();
+ }
+
+ /** Entry point for {@link Lifecycle}. */
+ @EntryPoint
+ @InstallIn(ActivityRetainedComponent.class)
+ public interface ActivityRetainedLifecycleEntryPoint {
+ ActivityRetainedLifecycle getActivityRetainedLifecycle();
+ }
+
+ static final class ActivityRetainedComponentViewModel extends ViewModel {
+ private final ActivityRetainedComponent component;
+
+ ActivityRetainedComponentViewModel(ActivityRetainedComponent component) {
+ this.component = component;
+ }
+
+ ActivityRetainedComponent getComponent() {
+ return component;
+ }
+
+ @Override
+ protected void onCleared() {
+ super.onCleared();
+ ActivityRetainedLifecycle lifecycle =
+ EntryPoints.get(component, ActivityRetainedLifecycleEntryPoint.class)
+ .getActivityRetainedLifecycle();
+ ((ActivityRetainedComponentManager.Lifecycle) lifecycle).dispatchOnCleared();
+ }
+ }
+
+ private final ViewModelProvider viewModelProvider;
+
+ @Nullable private volatile ActivityRetainedComponent component;
+ private final Object componentLock = new Object();
+
+ ActivityRetainedComponentManager(ComponentActivity activity) {
+ this.viewModelProvider =
+ new ViewModelProvider(
+ activity,
+ new ViewModelProvider.Factory() {
+ @NonNull
+ @Override
+ @SuppressWarnings("unchecked")
+ public <T extends ViewModel> T create(@NonNull Class<T> aClass) {
+ ActivityRetainedComponent component =
+ EntryPoints.get(
+ activity.getApplication(),
+ ActivityRetainedComponentBuilderEntryPoint.class)
+ .retainedComponentBuilder()
+ .build();
+ return (T) new ActivityRetainedComponentViewModel(component);
+ }
+ });
+ }
+
+ @Override
+ public ActivityRetainedComponent generatedComponent() {
+ if (component == null) {
+ synchronized (componentLock) {
+ if (component == null) {
+ component = createComponent();
+ }
+ }
+ }
+ return component;
+ }
+
+ private ActivityRetainedComponent createComponent() {
+ return viewModelProvider.get(ActivityRetainedComponentViewModel.class).getComponent();
+ }
+
+ /** The default implementation of {@link ActivityRetainedLifecycle}. */
+ @ActivityRetainedScoped
+ static final class Lifecycle implements ActivityRetainedLifecycle {
+
+ private final Set<OnClearedListener> listeners = new HashSet<>();
+ private boolean onClearedDispatched = false;
+
+ @Inject
+ Lifecycle() {}
+
+ @Override
+ public void addOnClearedListener(@NonNull OnClearedListener listener) {
+ ThreadUtil.ensureMainThread();
+ throwIfOnClearedDispatched();
+ listeners.add(listener);
+ }
+
+ @Override
+ public void removeOnClearedListener(@NonNull OnClearedListener listener) {
+ ThreadUtil.ensureMainThread();
+ throwIfOnClearedDispatched();
+ listeners.remove(listener);
+ }
+
+ void dispatchOnCleared() {
+ ThreadUtil.ensureMainThread();
+ onClearedDispatched = true;
+ for (OnClearedListener listener : listeners) {
+ listener.onCleared();
+ }
+ }
+
+ private void throwIfOnClearedDispatched() {
+ if (onClearedDispatched) {
+ throw new IllegalStateException(
+ "There was a race between the call to add/remove an OnClearedListener and onCleared(). "
+ + "This can happen when posting to the Main thread from a background thread, "
+ + "which is not supported.");
+ }
+ }
+ }
+
+ @Module
+ @InstallIn(ActivityRetainedComponent.class)
+ abstract static class LifecycleModule {
+ @Binds
+ abstract ActivityRetainedLifecycle bind(Lifecycle impl);
+ }
+}
diff --git a/java/dagger/hilt/android/internal/managers/ApplicationComponentManager.java b/java/dagger/hilt/android/internal/managers/ApplicationComponentManager.java
new file mode 100644
index 0000000..bb645db
--- /dev/null
+++ b/java/dagger/hilt/android/internal/managers/ApplicationComponentManager.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.managers;
+
+import dagger.hilt.internal.GeneratedComponentManager;
+
+/**
+ * Do not use except in Hilt generated code!
+ *
+ * <p>A manager for the creation of components that live in the Application.
+ */
+public final class ApplicationComponentManager implements GeneratedComponentManager<Object> {
+ private volatile Object component;
+ private final Object componentLock = new Object();
+ private final ComponentSupplier componentCreator;
+
+ public ApplicationComponentManager(ComponentSupplier componentCreator) {
+ this.componentCreator = componentCreator;
+ }
+
+ @Override
+ public Object generatedComponent() {
+ if (component == null) {
+ synchronized (componentLock) {
+ if (component == null) {
+ component = componentCreator.get();
+ }
+ }
+ }
+ return component;
+ }
+}
diff --git a/java/dagger/hilt/android/internal/managers/BUILD b/java/dagger/hilt/android/internal/managers/BUILD
new file mode 100644
index 0000000..3bc8df1
--- /dev/null
+++ b/java/dagger/hilt/android/internal/managers/BUILD
@@ -0,0 +1,60 @@
+# Copyright (C) 2019 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Internal Hilt Android managers
+
+package(default_visibility = ["//:src"])
+
+android_library(
+ name = "component_supplier",
+ srcs = ["ComponentSupplier.java"],
+)
+
+android_library(
+ name = "managers",
+ srcs = [
+ "ActivityComponentManager.java",
+ "ActivityRetainedComponentManager.java",
+ "ApplicationComponentManager.java",
+ "BroadcastReceiverComponentManager.java",
+ "FragmentComponentManager.java",
+ "ServiceComponentManager.java",
+ "ViewComponentManager.java",
+ ],
+ deps = [
+ ":component_supplier",
+ "//:dagger_with_compiler",
+ "//java/dagger/hilt:entry_point",
+ "//java/dagger/hilt:install_in",
+ "//java/dagger/hilt/android:activity_retained_lifecycle",
+ "//java/dagger/hilt/android/components",
+ "//java/dagger/hilt/android/components:view_model_component",
+ "//java/dagger/hilt/android/internal",
+ "//java/dagger/hilt/android/internal/builders",
+ "//java/dagger/hilt/android/scopes:activity_retained_scoped",
+ "//java/dagger/hilt/android/scopes:view_model_scoped",
+ "//java/dagger/hilt/internal:component_manager",
+ "//java/dagger/hilt/internal:preconditions",
+ "@maven//:androidx_activity_activity",
+ "@maven//:androidx_annotation_annotation",
+ "@maven//:androidx_fragment_fragment",
+ "@maven//:androidx_lifecycle_lifecycle_viewmodel",
+ ],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/android/internal/managers/BroadcastReceiverComponentManager.java b/java/dagger/hilt/android/internal/managers/BroadcastReceiverComponentManager.java
new file mode 100644
index 0000000..471c31c
--- /dev/null
+++ b/java/dagger/hilt/android/internal/managers/BroadcastReceiverComponentManager.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.managers;
+
+import android.app.Application;
+import android.content.Context;
+import dagger.hilt.internal.GeneratedComponentManager;
+import dagger.hilt.internal.Preconditions;
+
+/**
+ * Do not use except in Hilt generated code!
+ *
+ * <p>A manager for the creation of components that live in the BroadcastReceiver.
+ */
+public final class BroadcastReceiverComponentManager {
+ @SuppressWarnings("unchecked")
+ public static Object generatedComponent(Context context) {
+ Application application = (Application) context.getApplicationContext();
+
+ Preconditions.checkArgument(
+ application instanceof GeneratedComponentManager,
+ "Hilt BroadcastReceiver must be attached to an @AndroidEntryPoint Application. "
+ + "Found: %s",
+ application.getClass());
+
+ return ((GeneratedComponentManager<?>) application).generatedComponent();
+ }
+
+ private BroadcastReceiverComponentManager() {}
+}
diff --git a/java/dagger/hilt/android/internal/managers/ComponentSupplier.java b/java/dagger/hilt/android/internal/managers/ComponentSupplier.java
new file mode 100644
index 0000000..de702a9
--- /dev/null
+++ b/java/dagger/hilt/android/internal/managers/ComponentSupplier.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.managers;
+
+/**
+ * Interface for supplying a component. This is separate from the Supplier interface so that
+ * optimizers can strip this method (and therefore all the Dagger code) from the main dex even if a
+ * Supplier is referenced in code kept in the main dex.
+ */
+public interface ComponentSupplier {
+ Object get();
+}
diff --git a/java/dagger/hilt/android/internal/managers/FragmentComponentManager.java b/java/dagger/hilt/android/internal/managers/FragmentComponentManager.java
new file mode 100644
index 0000000..40dd60a
--- /dev/null
+++ b/java/dagger/hilt/android/internal/managers/FragmentComponentManager.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.managers;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.os.Bundle;
+import androidx.fragment.app.Fragment;
+import android.view.LayoutInflater;
+import dagger.hilt.EntryPoint;
+import dagger.hilt.EntryPoints;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityComponent;
+import dagger.hilt.android.internal.builders.FragmentComponentBuilder;
+import dagger.hilt.internal.GeneratedComponentManager;
+import dagger.hilt.internal.Preconditions;
+
+/**
+ * Do not use except in Hilt generated code!
+ *
+ * <p>A manager for the creation of components that live in the Fragment.
+ *
+ * <p>Note: This class is not typed since its type in generated code is always <?> or <Object>. This
+ * is mainly due to the fact that we don't know the components at the time of generation, and
+ * because even the injector interface type is not a valid type if we have a hilt base class.
+ *
+ */
+public class FragmentComponentManager implements GeneratedComponentManager<Object> {
+ /** Entrypoint for {@link FragmentComponentBuilder}. */
+ @EntryPoint
+ @InstallIn(ActivityComponent.class)
+ public interface FragmentComponentBuilderEntryPoint {
+ FragmentComponentBuilder fragmentComponentBuilder();
+ }
+
+ private volatile Object component;
+ private final Object componentLock = new Object();
+ private final Fragment fragment;
+
+ public FragmentComponentManager(Fragment fragment) {
+ this.fragment = fragment;
+ }
+
+ @Override
+ public Object generatedComponent() {
+ if (component == null) {
+ synchronized (componentLock) {
+ if (component == null) {
+ component = createComponent();
+ }
+ }
+ }
+ return component;
+ }
+
+ private Object createComponent() {
+ Preconditions.checkNotNull(
+ fragment.getHost(),
+ "Hilt Fragments must be attached before creating the component.");
+ Preconditions.checkState(
+ fragment.getHost() instanceof GeneratedComponentManager,
+ "Hilt Fragments must be attached to an @AndroidEntryPoint Activity. Found: %s",
+ fragment.getHost().getClass());
+
+ validate(fragment);
+
+ return EntryPoints.get(fragment.getHost(), FragmentComponentBuilderEntryPoint.class)
+ .fragmentComponentBuilder()
+ .fragment(fragment)
+ .build();
+ }
+
+ /** Returns the fragments bundle, creating a new one if none exists. */
+ public static final void initializeArguments(Fragment fragment) {
+ Preconditions.checkNotNull(fragment);
+ if (fragment.getArguments() == null) {
+ fragment.setArguments(new Bundle());
+ }
+ }
+
+ public static final Context findActivity(Context context) {
+ while (context instanceof ContextWrapper
+ && !(context instanceof Activity)) {
+ context = ((ContextWrapper) context).getBaseContext();
+ }
+ return context;
+ }
+
+ public static ContextWrapper createContextWrapper(Context base, Fragment fragment) {
+ return new ViewComponentManager.FragmentContextWrapper(base, fragment);
+ }
+
+ public static ContextWrapper createContextWrapper(
+ LayoutInflater baseInflater, Fragment fragment) {
+ return new ViewComponentManager.FragmentContextWrapper(baseInflater, fragment);
+ }
+
+ /** Called immediately before component creation to allow validation on the Fragment. */
+ protected void validate(Fragment fragment) {
+ }
+}
diff --git a/java/dagger/hilt/android/internal/managers/ServiceComponentManager.java b/java/dagger/hilt/android/internal/managers/ServiceComponentManager.java
new file mode 100644
index 0000000..d5e7f15
--- /dev/null
+++ b/java/dagger/hilt/android/internal/managers/ServiceComponentManager.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.managers;
+
+import android.app.Application;
+import android.app.Service;
+import dagger.hilt.EntryPoint;
+import dagger.hilt.EntryPoints;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.internal.builders.ServiceComponentBuilder;
+import dagger.hilt.components.SingletonComponent;
+import dagger.hilt.internal.GeneratedComponentManager;
+import dagger.hilt.internal.Preconditions;
+
+/**
+ * Do not use except in Hilt generated code!
+ *
+ * <p>A manager for the creation of components that live in the Service.
+ *
+ * <p>Note: This class is not typed since its type in generated code is always <?> or <Object>. This
+ * is mainly due to the fact that we don't know the components at the time of generation, and
+ * because even the injector interface type is not a valid type if we have a hilt base class.
+ */
+public final class ServiceComponentManager implements GeneratedComponentManager<Object> {
+ /** Entrypoint for {@link ServiceComponentBuilder}. */
+ @EntryPoint
+ @InstallIn(SingletonComponent.class)
+ public interface ServiceComponentBuilderEntryPoint {
+ ServiceComponentBuilder serviceComponentBuilder();
+ }
+
+ private final Service service;
+ private Object component;
+
+ public ServiceComponentManager(Service service) {
+ this.service = service;
+ }
+
+ // This isn't ever really publicly exposed on a service so it should be fine without
+ // synchronization.
+ @Override
+ public Object generatedComponent() {
+ if (component == null) {
+ component = createComponent();
+ }
+ return component;
+ }
+
+ private Object createComponent() {
+ Application application = service.getApplication();
+ Preconditions.checkState(
+ application instanceof GeneratedComponentManager,
+ "Hilt service must be attached to an @AndroidEntryPoint Application. Found: %s",
+ application.getClass());
+
+ return EntryPoints.get(application, ServiceComponentBuilderEntryPoint.class)
+ .serviceComponentBuilder()
+ .service(service)
+ .build();
+ }
+}
diff --git a/java/dagger/hilt/android/internal/managers/ViewComponentManager.java b/java/dagger/hilt/android/internal/managers/ViewComponentManager.java
new file mode 100644
index 0000000..cb2ece0
--- /dev/null
+++ b/java/dagger/hilt/android/internal/managers/ViewComponentManager.java
@@ -0,0 +1,201 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.managers;
+
+import android.content.Context;
+import android.content.ContextWrapper;
+import androidx.fragment.app.Fragment;
+import android.view.LayoutInflater;
+import android.view.View;
+import dagger.hilt.EntryPoint;
+import dagger.hilt.EntryPoints;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityComponent;
+import dagger.hilt.android.components.FragmentComponent;
+import dagger.hilt.android.internal.builders.ViewComponentBuilder;
+import dagger.hilt.android.internal.builders.ViewWithFragmentComponentBuilder;
+import dagger.hilt.internal.GeneratedComponentManager;
+import dagger.hilt.internal.Preconditions;
+
+/**
+ * Do not use except in Hilt generated code!
+ *
+ * <p>A manager for the creation of components that live in the View.
+ *
+ * <p>Note: This class is not typed since its type in generated code is always <?> or <Object>. This
+ * is mainly due to the fact that we don't know the components at the time of generation, and
+ * because even the injector interface type is not a valid type if we have a hilt base class.
+ */
+public final class ViewComponentManager implements GeneratedComponentManager<Object> {
+ /** Entrypoint for {@link ViewWithFragmentComponentBuilder}. */
+ @EntryPoint
+ @InstallIn(FragmentComponent.class)
+ public interface ViewWithFragmentComponentBuilderEntryPoint {
+ ViewWithFragmentComponentBuilder viewWithFragmentComponentBuilder();
+ }
+
+ /** Entrypoint for {@link ViewComponentBuilder}. */
+ @EntryPoint
+ @InstallIn(ActivityComponent.class)
+ public interface ViewComponentBuilderEntryPoint {
+ ViewComponentBuilder viewComponentBuilder();
+ }
+
+ private volatile Object component;
+ private final Object componentLock = new Object();
+ private final boolean hasFragmentBindings;
+ private final View view;
+
+ public ViewComponentManager(View view, boolean hasFragmentBindings) {
+ this.view = view;
+ this.hasFragmentBindings = hasFragmentBindings;
+ }
+
+ @Override
+ public Object generatedComponent() {
+ if (component == null) {
+ synchronized (componentLock) {
+ if (component == null) {
+ component = createComponent();
+ }
+ }
+ }
+ return component;
+ }
+
+ private Object createComponent() {
+ GeneratedComponentManager<?> componentManager =
+ getParentComponentManager(/*allowMissing=*/ false);
+ if (hasFragmentBindings) {
+ return EntryPoints.get(componentManager, ViewWithFragmentComponentBuilderEntryPoint.class)
+ .viewWithFragmentComponentBuilder()
+ .view(view)
+ .build();
+ } else {
+ return EntryPoints.get(componentManager, ViewComponentBuilderEntryPoint.class)
+ .viewComponentBuilder()
+ .view(view)
+ .build();
+ }
+ }
+
+ /* Returns the component manager of the parent or null if not found. */
+ public GeneratedComponentManager<?> maybeGetParentComponentManager() {
+ return getParentComponentManager(/*allowMissing=*/ true);
+ }
+
+ private GeneratedComponentManager<?> getParentComponentManager(boolean allowMissing) {
+ if (hasFragmentBindings) {
+ Context context = getParentContext(FragmentContextWrapper.class, allowMissing);
+ if (context instanceof FragmentContextWrapper) {
+
+ FragmentContextWrapper fragmentContextWrapper = (FragmentContextWrapper) context;
+ return (GeneratedComponentManager<?>) fragmentContextWrapper.fragment;
+ } else if (allowMissing) {
+ // We didn't find anything, so return null if we're not supposed to fail.
+ // The rest of the logic is just about getting a good error message.
+ return null;
+ }
+
+ // Check if there was a valid parent component, just not a Fragment, to give a more
+ // specific error.
+ Context parent = getParentContext(GeneratedComponentManager.class, allowMissing);
+ Preconditions.checkState(
+ !(parent instanceof GeneratedComponentManager),
+ "%s, @WithFragmentBindings Hilt view must be attached to an "
+ + "@AndroidEntryPoint Fragment. "
+ + "Was attached to context %s",
+ view.getClass(),
+ parent.getClass().getName());
+ } else {
+ Context context = getParentContext(GeneratedComponentManager.class, allowMissing);
+ if (context instanceof GeneratedComponentManager) {
+ return (GeneratedComponentManager<?>) context;
+ } else if (allowMissing) {
+ return null;
+ }
+ }
+
+ // Couldn't find any parent components to descend from.
+ throw new IllegalStateException(
+ String.format(
+ "%s, Hilt view must be attached to an @AndroidEntryPoint Fragment or Activity.",
+ view.getClass()));
+
+ }
+
+ private Context getParentContext(Class<?> parentType, boolean allowMissing) {
+ Context context = unwrap(view.getContext(), parentType);
+ if (context == unwrap(context.getApplicationContext(), GeneratedComponentManager.class)) {
+ // If we searched for a type but ended up on the application context, just return null
+ // as this is never what we are looking for
+ Preconditions.checkState(
+ allowMissing,
+ "%s, Hilt view cannot be created using the application context. "
+ + "Use a Hilt Fragment or Activity context.",
+ view.getClass());
+ return null;
+ }
+ return context;
+ }
+
+ private static Context unwrap(Context context, Class<?> target) {
+ while (context instanceof ContextWrapper && !target.isInstance(context)) {
+ context = ((ContextWrapper) context).getBaseContext();
+ }
+ return context;
+ }
+
+ /**
+ * Do not use except in Hilt generated code!
+ *
+ * <p>A wrapper class to expose the {@link Fragment} to the views they're inflating.
+ */
+ // This is only non-final for the account override
+ public static final class FragmentContextWrapper extends ContextWrapper {
+ private LayoutInflater baseInflater;
+ private LayoutInflater inflater;
+ public final Fragment fragment;
+
+ public FragmentContextWrapper(Context base, Fragment fragment) {
+ super(Preconditions.checkNotNull(base));
+ this.baseInflater = null;
+ this.fragment = Preconditions.checkNotNull(fragment);
+ }
+
+ public FragmentContextWrapper(LayoutInflater baseInflater, Fragment fragment) {
+ super(Preconditions.checkNotNull(Preconditions.checkNotNull(baseInflater).getContext()));
+ this.baseInflater = baseInflater;
+ this.fragment = Preconditions.checkNotNull(fragment);
+ }
+
+ @Override
+ public Object getSystemService(String name) {
+ if (!LAYOUT_INFLATER_SERVICE.equals(name)) {
+ return getBaseContext().getSystemService(name);
+ }
+ if (inflater == null) {
+ if (baseInflater == null) {
+ baseInflater =
+ (LayoutInflater) getBaseContext().getSystemService(LAYOUT_INFLATER_SERVICE);
+ }
+ inflater = baseInflater.cloneInContext(this);
+ }
+ return inflater;
+ }
+ }
+}
diff --git a/java/dagger/hilt/android/internal/migration/BUILD b/java/dagger/hilt/android/internal/migration/BUILD
new file mode 100644
index 0000000..b877f6f
--- /dev/null
+++ b/java/dagger/hilt/android/internal/migration/BUILD
@@ -0,0 +1,28 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Internal classes for migration
+
+package(default_visibility = ["//:src"])
+
+android_library(
+ name = "injected_by_hilt",
+ srcs = ["InjectedByHilt.java"],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/android/internal/migration/InjectedByHilt.java b/java/dagger/hilt/android/internal/migration/InjectedByHilt.java
new file mode 100644
index 0000000..087a7ee
--- /dev/null
+++ b/java/dagger/hilt/android/internal/migration/InjectedByHilt.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.migration;
+
+/**
+ * Do not use except in Hilt generated code!
+ */
+public interface InjectedByHilt {
+ /** Returns true if this class was injected by Hilt. */
+ boolean wasInjectedByHilt();
+}
diff --git a/java/dagger/hilt/android/internal/modules/ActivityModule.java b/java/dagger/hilt/android/internal/modules/ActivityModule.java
new file mode 100644
index 0000000..080e203
--- /dev/null
+++ b/java/dagger/hilt/android/internal/modules/ActivityModule.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.modules;
+
+import android.app.Activity;
+import android.content.Context;
+import androidx.fragment.app.FragmentActivity;
+import dagger.Binds;
+import dagger.Module;
+import dagger.Provides;
+import dagger.Reusable;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityComponent;
+import dagger.hilt.android.qualifiers.ActivityContext;
+
+/** Provides convenience bindings for activities. */
+@Module
+@InstallIn(ActivityComponent.class)
+abstract class ActivityModule {
+ @Binds
+ @ActivityContext
+ abstract Context provideContext(Activity activity);
+
+ @Provides
+ @Reusable
+ static FragmentActivity provideFragmentActivity(Activity activity) {
+ try {
+ return (FragmentActivity) activity;
+ } catch (ClassCastException e) {
+ throw new IllegalStateException("Expected activity to be a FragmentActivity: " + activity, e);
+ }
+ }
+
+ private ActivityModule() {}
+}
diff --git a/java/dagger/hilt/android/internal/modules/ApplicationContextModule.java b/java/dagger/hilt/android/internal/modules/ApplicationContextModule.java
new file mode 100644
index 0000000..af4ebc2
--- /dev/null
+++ b/java/dagger/hilt/android/internal/modules/ApplicationContextModule.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.modules;
+
+import android.app.Application;
+import android.content.Context;
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.qualifiers.ApplicationContext;
+import dagger.hilt.components.SingletonComponent;
+
+/** Provides a binding for an Android BinderFragment Context. */
+@Module
+@InstallIn(SingletonComponent.class)
+public final class ApplicationContextModule {
+ private final Context applicationContext;
+
+ public ApplicationContextModule(Context applicationContext) {
+ this.applicationContext = applicationContext;
+ }
+
+ @Provides
+ @ApplicationContext
+ Context provideContext() {
+ return applicationContext;
+ }
+
+ @Provides
+ Application provideApplication() {
+ return (Application) applicationContext.getApplicationContext();
+ }
+}
diff --git a/java/dagger/hilt/android/internal/modules/BUILD b/java/dagger/hilt/android/internal/modules/BUILD
new file mode 100644
index 0000000..a36e237
--- /dev/null
+++ b/java/dagger/hilt/android/internal/modules/BUILD
@@ -0,0 +1,37 @@
+# Copyright (C) 2019 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Hilt android modules for standard components.
+
+package(default_visibility = ["//:src"])
+
+android_library(
+ name = "modules",
+ srcs = glob(["*.java"]),
+ deps = [
+ "//:dagger_with_compiler",
+ "//java/dagger/hilt:install_in",
+ "//java/dagger/hilt/android/components",
+ "//java/dagger/hilt/android/qualifiers",
+ "@maven//:androidx_activity_activity",
+ "@maven//:androidx_annotation_annotation",
+ "@maven//:androidx_fragment_fragment",
+ ],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/android/internal/testing/BUILD b/java/dagger/hilt/android/internal/testing/BUILD
new file mode 100644
index 0000000..b0bc361
--- /dev/null
+++ b/java/dagger/hilt/android/internal/testing/BUILD
@@ -0,0 +1,89 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Internal Hilt android testing libraries
+
+package(default_visibility = ["//:src"])
+
+java_library(
+ name = "test_injector",
+ testonly = 1,
+ srcs = [
+ "TestApplicationInjector.java",
+ "TestInjector.java",
+ ],
+)
+
+android_library(
+ name = "internal_test_root",
+ srcs = [
+ "InternalTestRoot.java",
+ ],
+ deps = [
+ "//java/dagger/hilt:generates_root_input",
+ ],
+)
+
+android_library(
+ name = "test_application_component_manager",
+ testonly = 1,
+ srcs = ["TestApplicationComponentManager.java"],
+ deps = [
+ ":test_component_data",
+ ":test_injector",
+ "//java/dagger/hilt/android/testing:on_component_ready_runner",
+ "//java/dagger/hilt/internal:component_manager",
+ "//java/dagger/hilt/internal:preconditions",
+ "@maven//:junit_junit",
+ ],
+)
+
+android_library(
+ name = "test_component_data",
+ testonly = 1,
+ srcs = [
+ "TestComponentData.java",
+ "TestComponentDataSupplier.java",
+ ],
+ deps = [
+ ":test_injector",
+ "//java/dagger/hilt/internal:component_manager",
+ ],
+)
+
+android_library(
+ name = "test_application_component_manager_holder",
+ testonly = 1,
+ srcs = ["TestApplicationComponentManagerHolder.java"],
+)
+
+android_library(
+ name = "mark_that_rules_ran_rule",
+ testonly = 1,
+ srcs = ["MarkThatRulesRanRule.java"],
+ deps = [
+ ":test_application_component_manager",
+ ":test_application_component_manager_holder",
+ "//java/dagger/hilt/internal:component_manager",
+ "//java/dagger/hilt/internal:preconditions",
+ "@maven//:androidx_test_core",
+ "@maven//:junit_junit",
+ ],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["**/*"]),
+)
diff --git a/java/dagger/hilt/android/internal/testing/InternalTestRoot.java b/java/dagger/hilt/android/internal/testing/InternalTestRoot.java
new file mode 100644
index 0000000..c3bbf0c
--- /dev/null
+++ b/java/dagger/hilt/android/internal/testing/InternalTestRoot.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.testing;
+
+import static java.lang.annotation.RetentionPolicy.CLASS;
+
+import android.app.Application;
+import dagger.hilt.GeneratesRootInput;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+/** Annotation that generates a Hilt test application. */
+@Retention(CLASS)
+@Target({ElementType.TYPE})
+@GeneratesRootInput
+public @interface InternalTestRoot {
+
+ /** Returns the test class. */
+ Class<?> testClass();
+
+ /** Returns the base {@link Application} class. */
+ Class<? extends Application> applicationBaseClass();
+}
diff --git a/java/dagger/hilt/android/internal/testing/MarkThatRulesRanRule.java b/java/dagger/hilt/android/internal/testing/MarkThatRulesRanRule.java
new file mode 100644
index 0000000..17c40b3
--- /dev/null
+++ b/java/dagger/hilt/android/internal/testing/MarkThatRulesRanRule.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.testing;
+
+import static dagger.hilt.internal.Preconditions.checkNotNull;
+import static dagger.hilt.internal.Preconditions.checkState;
+
+import android.content.Context;
+import androidx.test.core.app.ApplicationProvider;
+import dagger.hilt.internal.GeneratedComponentManager;
+import java.lang.annotation.Annotation;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+
+/**
+ * A Junit {@code TestRule} that's installed in all Hilt tests.
+ *
+ * <p>This rule enforces that a Hilt TestRule has run. The Dagger component will not be created
+ * without this test rule.
+ */
+public final class MarkThatRulesRanRule implements TestRule {
+ private static final String HILT_ANDROID_APP = "dagger.hilt.android.HiltAndroidApp";
+ private static final String HILT_ANDROID_TEST = "dagger.hilt.android.testing.HiltAndroidTest";
+
+ private final Context context = ApplicationProvider.getApplicationContext();
+ private final Object testInstance;
+ private final boolean autoAddModule;
+
+ private final AtomicBoolean started = new AtomicBoolean(false);
+
+ public MarkThatRulesRanRule(Object testInstance) {
+ this.autoAddModule = true;
+ this.testInstance = checkNotNull(testInstance);
+ checkState(
+ hasAnnotation(testInstance, HILT_ANDROID_TEST),
+ "Expected %s to be annotated with @HiltAndroidTest.",
+ testInstance.getClass().getName());
+ checkState(
+ context instanceof GeneratedComponentManager,
+ "Hilt test, %s, must use a Hilt test application but found %s. To fix, configure the test "
+ + "to use HiltTestApplication or a custom Hilt test application generated with "
+ + "@CustomTestApplication.",
+ testInstance.getClass().getName(),
+ context.getClass().getName());
+ checkState(
+ !hasAnnotation(context, HILT_ANDROID_APP),
+ "Hilt test, %s, cannot use a @HiltAndroidApp application but found %s. To fix, configure "
+ + "the test to use HiltTestApplication or a custom Hilt test application generated "
+ + "with @CustomTestApplication.",
+ testInstance.getClass().getName(),
+ context.getClass().getName());
+ }
+
+ public void delayComponentReady() {
+ checkState(!started.get(), "Called delayComponentReady after test execution started");
+ getTestApplicationComponentManager().delayComponentReady();
+ }
+
+ public void componentReady() {
+ checkState(started.get(), "Called componentReady before test execution started");
+ getTestApplicationComponentManager().componentReady();
+ }
+
+ public void inject() {
+ getTestApplicationComponentManager().inject();
+ }
+
+ @Override
+ public Statement apply(final Statement base, Description description) {
+ started.set(true);
+ checkState(
+ description.getTestClass().isInstance(testInstance),
+ "HiltAndroidRule was constructed with an argument that was not an instance of the test"
+ + " class");
+ return new Statement() {
+ @Override
+ public void evaluate() throws Throwable {
+
+ TestApplicationComponentManager componentManager = getTestApplicationComponentManager();
+ try {
+ // This check is required to check that state hasn't been set before this rule runs. This
+ // prevents cases like setting state in Application.onCreate for Gradle emulator tests
+ // that will get cleared after running the first test case.
+ componentManager.checkStateIsCleared();
+ componentManager.setAutoAddModule(autoAddModule);
+ if (testInstance != null) {
+ componentManager.setTestInstance(testInstance);
+ }
+ componentManager.setHasHiltTestRule(description);
+ base.evaluate();
+ componentManager.verifyDelayedComponentWasMadeReady();
+ } finally {
+ componentManager.clearState();
+ }
+ }
+ };
+ }
+
+ private TestApplicationComponentManager getTestApplicationComponentManager() {
+ checkState(
+ context instanceof TestApplicationComponentManagerHolder,
+ "The context is not an instance of TestApplicationComponentManagerHolder: %s",
+ context);
+ Object componentManager = ((TestApplicationComponentManagerHolder) context).componentManager();
+ checkState(
+ componentManager instanceof TestApplicationComponentManager,
+ "Expected TestApplicationComponentManagerHolder to return an instance of"
+ + "TestApplicationComponentManager");
+ return (TestApplicationComponentManager) componentManager;
+ }
+
+ private static boolean hasAnnotation(Object obj, String annotationName) {
+ for (Annotation annotation : obj.getClass().getAnnotations()) {
+ if (annotation.annotationType().getName().contentEquals(annotationName)) {
+ return true;
+ }
+ }
+ return false;
+ }
+}
diff --git a/java/dagger/hilt/android/internal/testing/TestApplicationComponentManager.java b/java/dagger/hilt/android/internal/testing/TestApplicationComponentManager.java
new file mode 100644
index 0000000..1878870
--- /dev/null
+++ b/java/dagger/hilt/android/internal/testing/TestApplicationComponentManager.java
@@ -0,0 +1,332 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.testing;
+
+import android.app.Application;
+import dagger.hilt.android.testing.OnComponentReadyRunner;
+import dagger.hilt.android.testing.OnComponentReadyRunner.OnComponentReadyRunnerHolder;
+import dagger.hilt.internal.GeneratedComponentManager;
+import dagger.hilt.internal.Preconditions;
+import java.lang.reflect.InvocationTargetException;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.runner.Description;
+
+/**
+ * Do not use except in Hilt generated code!
+ *
+ * <p>A manager for the creation of components that live in the test Application.
+ */
+public final class TestApplicationComponentManager
+ implements GeneratedComponentManager<Object>, OnComponentReadyRunnerHolder {
+
+ // This is a generated class that we always generate in a known location.
+ private static final String TEST_COMPONENT_DATA_SUPPLIER_IMPL =
+ "dagger.hilt.android.internal.testing.TestComponentDataSupplierImpl";
+
+ private final Application application;
+ private final Map<Class<?>, TestComponentData> testComponentDataSupplier;
+
+ private final AtomicReference<Object> component = new AtomicReference<>();
+ private final AtomicReference<Description> hasHiltTestRule = new AtomicReference<>();
+ private final Map<Class<?>, Object> registeredModules = new ConcurrentHashMap<>();
+ private final AtomicReference<Boolean> autoAddModuleEnabled = new AtomicReference<>();
+ private final AtomicReference<DelayedComponentState> delayedComponentState =
+ new AtomicReference<>(DelayedComponentState.NOT_DELAYED);
+ private volatile Object testInstance;
+ private volatile OnComponentReadyRunner onComponentReadyRunner = new OnComponentReadyRunner();
+
+ /**
+ * Represents the state of Component readiness. There are two valid transition sequences.
+ *
+ * <ul>
+ * <li>Typical test (no HiltAndroidRule#delayComponentReady): {@code NOT_DELAYED -> INJECTED}
+ * <li>Using HiltAndroidRule#delayComponentReady: {@code NOT_DELAYED -> COMPONENT_DELAYED ->
+ * COMPONENT_READY -> INJECTED}
+ * </ul>
+ */
+ private enum DelayedComponentState {
+ // Valid transitions: COMPONENT_DELAYED, INJECTED
+ NOT_DELAYED,
+ // Valid transitions: COMPONENT_READY
+ COMPONENT_DELAYED,
+ // Valid transitions: INJECTED
+ COMPONENT_READY,
+ // Terminal state
+ INJECTED
+ }
+
+ public TestApplicationComponentManager(Application application) {
+ this.application = application;
+ try {
+ this.testComponentDataSupplier =
+ Class.forName(TEST_COMPONENT_DATA_SUPPLIER_IMPL)
+ .asSubclass(TestComponentDataSupplier.class)
+ .getDeclaredConstructor()
+ .newInstance()
+ .get();
+ } catch (ClassNotFoundException
+ | NoSuchMethodException
+ | IllegalAccessException
+ | InstantiationException
+ | InvocationTargetException e) {
+ throw new RuntimeException(
+ "Hilt classes generated from @HiltAndroidTest are missing. Check that you have annotated "
+ + "your test class with @HiltAndroidTest and that the processor is running over your "
+ + "test",
+ e);
+ }
+ }
+
+ @Override
+ public Object generatedComponent() {
+ if (component.get() == null) {
+ Preconditions.checkState(
+ hasHiltTestRule(),
+ "The component was not created. Check that you have added the HiltAndroidRule.");
+ if (!registeredModules.keySet().containsAll(requiredModules())) {
+ Set<Class<?>> difference = new HashSet<>(requiredModules());
+ difference.removeAll(registeredModules.keySet());
+ throw new IllegalStateException(
+ "The component was not created. Check that you have "
+ + "registered all test modules:\n\tUnregistered: "
+ + difference);
+ }
+ Preconditions.checkState(
+ bindValueReady(), "The test instance has not been set. Did you forget to call #bind()?");
+ throw new IllegalStateException(
+ "The component has not been created. "
+ + "Check that you have called #inject()? Otherwise, "
+ + "there is a race between injection and component creation. Make sure there is a "
+ + "happens-before edge between the HiltAndroidRule/registering"
+ + " all test modules and the first injection.");
+ }
+ return component.get();
+ }
+
+ @Override
+ public OnComponentReadyRunner getOnComponentReadyRunner() {
+ return onComponentReadyRunner;
+ }
+
+ /** For framework use only! This flag must be set before component creation. */
+ void setHasHiltTestRule(Description description) {
+ Preconditions.checkState(
+ // Some exempted tests set the test rule multiple times. Use CAS to avoid setting twice.
+ hasHiltTestRule.compareAndSet(null, description),
+ "The hasHiltTestRule flag has already been set!");
+ tryToCreateComponent();
+ }
+
+ void checkStateIsCleared() {
+ Preconditions.checkState(
+ component.get() == null,
+ "The Hilt component cannot be set before Hilt's test rule has run.");
+ Preconditions.checkState(
+ hasHiltTestRule.get() == null,
+ "The Hilt test rule cannot be set before Hilt's test rule has run.");
+ Preconditions.checkState(
+ autoAddModuleEnabled.get() == null,
+ "The Hilt autoAddModuleEnabled cannot be set before Hilt's test rule has run.");
+ Preconditions.checkState(
+ testInstance == null,
+ "The Hilt BindValue instance cannot be set before Hilt's test rule has run.");
+ Preconditions.checkState(
+ registeredModules.isEmpty(),
+ "The Hilt registered modules cannot be set before Hilt's test rule has run.");
+ Preconditions.checkState(
+ onComponentReadyRunner.isEmpty(),
+ "The Hilt onComponentReadyRunner cannot add listeners before Hilt's test rule has run.");
+ DelayedComponentState state = delayedComponentState.get();
+ switch (state) {
+ case NOT_DELAYED:
+ case COMPONENT_DELAYED:
+ // Expected
+ break;
+ case COMPONENT_READY:
+ throw new IllegalStateException("Called componentReady before test execution started");
+ case INJECTED:
+ throw new IllegalStateException("Called inject before test execution started");
+ }
+ }
+
+ void clearState() {
+ component.set(null);
+ hasHiltTestRule.set(null);
+ testInstance = null;
+ registeredModules.clear();
+ autoAddModuleEnabled.set(null);
+ delayedComponentState.set(DelayedComponentState.NOT_DELAYED);
+ onComponentReadyRunner = new OnComponentReadyRunner();
+ }
+
+ public Description getDescription() {
+ return hasHiltTestRule.get();
+ }
+
+ public Object getTestInstance() {
+ Preconditions.checkState(
+ testInstance != null,
+ "The test instance has not been set.");
+ return testInstance;
+ }
+
+ /** For framework use only! This method should be called when a required module is installed. */
+ public <T> void registerModule(Class<T> moduleClass, T module) {
+ Preconditions.checkNotNull(moduleClass);
+ Preconditions.checkState(
+ testComponentData().daggerRequiredModules().contains(moduleClass),
+ "Found unknown module class: %s",
+ moduleClass.getName());
+ if (requiredModules().contains(moduleClass)) {
+ Preconditions.checkState(
+ // Some exempted tests register modules multiple times.
+ !registeredModules.containsKey(moduleClass),
+ "Module is already registered: %s",
+ moduleClass.getName());
+
+ registeredModules.put(moduleClass, module);
+ tryToCreateComponent();
+ }
+ }
+
+ void delayComponentReady() {
+ switch (delayedComponentState.getAndSet(DelayedComponentState.COMPONENT_DELAYED)) {
+ case NOT_DELAYED:
+ // Expected
+ break;
+ case COMPONENT_DELAYED:
+ throw new IllegalStateException("Called delayComponentReady() twice");
+ case COMPONENT_READY:
+ throw new IllegalStateException("Called delayComponentReady() after componentReady()");
+ case INJECTED:
+ throw new IllegalStateException("Called delayComponentReady() after inject()");
+ }
+ }
+
+ void componentReady() {
+ switch (delayedComponentState.getAndSet(DelayedComponentState.COMPONENT_READY)) {
+ case NOT_DELAYED:
+ throw new IllegalStateException(
+ "Called componentReady(), even though delayComponentReady() was not used.");
+ case COMPONENT_DELAYED:
+ // Expected
+ break;
+ case COMPONENT_READY:
+ throw new IllegalStateException("Called componentReady() multiple times");
+ case INJECTED:
+ throw new IllegalStateException("Called componentReady() after inject()");
+ }
+ tryToCreateComponent();
+ }
+
+ void inject() {
+ switch (delayedComponentState.getAndSet(DelayedComponentState.INJECTED)) {
+ case NOT_DELAYED:
+ case COMPONENT_READY:
+ // Expected
+ break;
+ case COMPONENT_DELAYED:
+ throw new IllegalStateException("Called inject() before calling componentReady()");
+ case INJECTED:
+ throw new IllegalStateException("Called inject() multiple times");
+ }
+ Preconditions.checkNotNull(testInstance);
+ testInjector().injectTest(testInstance);
+ }
+
+ void verifyDelayedComponentWasMadeReady() {
+ Preconditions.checkState(
+ delayedComponentState.get() != DelayedComponentState.COMPONENT_DELAYED,
+ "Used delayComponentReady(), but never called componentReady()");
+ }
+
+ private void tryToCreateComponent() {
+ if (hasHiltTestRule()
+ && registeredModules.keySet().containsAll(requiredModules())
+ && bindValueReady()
+ && delayedComponentReady()) {
+ Preconditions.checkState(
+ autoAddModuleEnabled.get() != null,
+ "Component cannot be created before autoAddModuleEnabled is set.");
+ Preconditions.checkState(
+ component.compareAndSet(
+ null,
+ componentSupplier().get(registeredModules, testInstance, autoAddModuleEnabled.get())),
+ "Tried to create the component more than once! "
+ + "There is a race between registering the HiltAndroidRule and registering"
+ + " all test modules. Make sure there is a happens-before edge between the two.");
+ onComponentReadyRunner.setComponentManager((GeneratedComponentManager) application);
+ }
+ }
+
+ void setTestInstance(Object testInstance) {
+ Preconditions.checkNotNull(testInstance);
+ Preconditions.checkState(this.testInstance == null, "The test instance was already set!");
+ this.testInstance = testInstance;
+ }
+
+ void setAutoAddModule(boolean autoAddModule) {
+ Preconditions.checkState(
+ autoAddModuleEnabled.get() == null, "autoAddModuleEnabled is already set!");
+ autoAddModuleEnabled.set(autoAddModule);
+ }
+
+ private Set<Class<?>> requiredModules() {
+ return autoAddModuleEnabled.get()
+ ? testComponentData().hiltRequiredModules()
+ : testComponentData().daggerRequiredModules();
+ }
+
+ private boolean waitForBindValue() {
+ return testComponentData().waitForBindValue();
+ }
+
+ private TestInjector<Object> testInjector() {
+ return testComponentData().testInjector();
+ }
+
+ private TestComponentData.ComponentSupplier componentSupplier() {
+ return testComponentData().componentSupplier();
+ }
+
+ private TestComponentData testComponentData() {
+ return testComponentDataSupplier.get(testClass());
+ }
+
+ private Class<?> testClass() {
+ Preconditions.checkState(
+ hasHiltTestRule(),
+ "Test must have an HiltAndroidRule.");
+ return hasHiltTestRule.get().getTestClass();
+ }
+
+ private boolean bindValueReady() {
+ return !waitForBindValue() || testInstance != null;
+ }
+
+ private boolean delayedComponentReady() {
+ return delayedComponentState.get() != DelayedComponentState.COMPONENT_DELAYED;
+ }
+
+ private boolean hasHiltTestRule() {
+ return hasHiltTestRule.get() != null;
+ }
+}
diff --git a/java/dagger/hilt/android/internal/testing/TestApplicationComponentManagerHolder.java b/java/dagger/hilt/android/internal/testing/TestApplicationComponentManagerHolder.java
new file mode 100644
index 0000000..a8695c4
--- /dev/null
+++ b/java/dagger/hilt/android/internal/testing/TestApplicationComponentManagerHolder.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.testing;
+
+/** For use by Hilt internally only! Returns the component manager. */
+public interface TestApplicationComponentManagerHolder {
+ // Returns {@link Object} so that we do not expose {@code TestApplicationComponentManager} to
+ // clients. Framework code should explicitly cast to {@code TestApplicationComponentManager}.
+ Object componentManager();
+}
diff --git a/java/dagger/hilt/android/internal/testing/TestApplicationInjector.java b/java/dagger/hilt/android/internal/testing/TestApplicationInjector.java
new file mode 100644
index 0000000..c7ff5c9
--- /dev/null
+++ b/java/dagger/hilt/android/internal/testing/TestApplicationInjector.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.testing;
+
+/**
+ * Interface to expose a method for members injection for use in tests.
+ */
+public interface TestApplicationInjector<T> {
+ void injectApp(T t);
+}
diff --git a/java/dagger/hilt/android/internal/testing/TestComponentData.java b/java/dagger/hilt/android/internal/testing/TestComponentData.java
new file mode 100644
index 0000000..4eed6fb
--- /dev/null
+++ b/java/dagger/hilt/android/internal/testing/TestComponentData.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.testing;
+
+import dagger.hilt.internal.Preconditions;
+import java.util.Map;
+import java.util.Set;
+
+/** Contains the data needed to create a test's component. */
+public final class TestComponentData {
+ private final ComponentSupplier componentSupplier;
+ private final TestInjector<Object> testInjector;
+ private final Set<Class<?>> daggerRequiredModules;
+ private final Set<Class<?>> hiltRequiredModules;
+ private final boolean waitForBindValue;
+
+ public TestComponentData(
+ boolean waitForBindValue,
+ TestInjector<Object> testInjector,
+ Set<Class<?>> daggerRequiredModules,
+ Set<Class<?>> hiltRequiredModules,
+ ComponentSupplier componentSupplier) {
+ Preconditions.checkState(
+ daggerRequiredModules.containsAll(hiltRequiredModules),
+ "Hilt required modules should be subset of Dagger required modules.");
+ this.componentSupplier = componentSupplier;
+ this.testInjector = testInjector;
+ this.daggerRequiredModules = daggerRequiredModules;
+ this.waitForBindValue = waitForBindValue;
+ this.hiltRequiredModules = hiltRequiredModules;
+ }
+
+ /** Returns the {@link ComponentSupplier}. */
+ public ComponentSupplier componentSupplier() {
+ return componentSupplier;
+ }
+
+ /** Returns the {@link TestInjector}. */
+ public TestInjector<Object> testInjector() {
+ return testInjector;
+ }
+
+ /** Returns the set of modules that Dagger cannot create instances of itself */
+ public Set<Class<?>> daggerRequiredModules() {
+ return daggerRequiredModules;
+ }
+
+ /**
+ * Returns a subset of {@link #daggerRequiredModules} that filters out the modules Hilt can
+ * instantiate itself.
+ */
+ public Set<Class<?>> hiltRequiredModules() {
+ return hiltRequiredModules;
+ }
+
+ /** Returns true if creation of the component needs to wait for bind() to be called. */
+ public boolean waitForBindValue() {
+ return waitForBindValue;
+ }
+
+ /** Returns the component using the given registered modules. */
+ public interface ComponentSupplier {
+ Object get(Map<Class<?>, ?> registeredModules, Object testInstance, Boolean autoAddModule);
+ }
+}
diff --git a/java/dagger/hilt/android/internal/testing/TestComponentDataSupplier.java b/java/dagger/hilt/android/internal/testing/TestComponentDataSupplier.java
new file mode 100644
index 0000000..e39073f
--- /dev/null
+++ b/java/dagger/hilt/android/internal/testing/TestComponentDataSupplier.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.testing;
+
+import java.util.Map;
+
+/** Stores the {@link TestComponentData} for all Hilt test classes. */
+public abstract class TestComponentDataSupplier {
+
+ /** Returns a map of {@link TestComponentData} keyed by test class. */
+ protected abstract Map<Class<?>, TestComponentData> get();
+}
diff --git a/java/dagger/hilt/android/internal/testing/TestInjector.java b/java/dagger/hilt/android/internal/testing/TestInjector.java
new file mode 100644
index 0000000..7055f91
--- /dev/null
+++ b/java/dagger/hilt/android/internal/testing/TestInjector.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.internal.testing;
+
+/**
+ * Interface to expose a method for members injection for use in tests.
+ */
+public interface TestInjector<T> {
+ void injectTest(T t);
+}
diff --git a/java/dagger/hilt/android/lifecycle/BUILD b/java/dagger/hilt/android/lifecycle/BUILD
new file mode 100644
index 0000000..fd80510
--- /dev/null
+++ b/java/dagger/hilt/android/lifecycle/BUILD
@@ -0,0 +1,39 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Hilt ViewModel integration.
+
+package(default_visibility = ["//:src"])
+
+android_library(
+ name = "lifecycle",
+ srcs = glob(["*.java"]),
+ exported_plugins = [
+ "//java/dagger/hilt/android/processor/internal/viewmodel:processor",
+ ],
+ proguard_specs = ["proguard-rules.pro"],
+ exports = [
+ "//java/dagger/hilt/android/components:view_model_component",
+ "//java/dagger/hilt/android/internal/lifecycle",
+ ],
+ deps = [
+ "//java/dagger/hilt:generates_root_input",
+ ],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/android/lifecycle/HiltViewModel.java b/java/dagger/hilt/android/lifecycle/HiltViewModel.java
new file mode 100644
index 0000000..198ec8a
--- /dev/null
+++ b/java/dagger/hilt/android/lifecycle/HiltViewModel.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.lifecycle;
+
+import dagger.hilt.GeneratesRootInput;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Identifies a {@link androidx.lifecycle.ViewModel} for construction injection.
+ *
+ * <p>The {@code ViewModel} annotated with {@link HiltViewModel} will be available for creation by
+ * the {@link dagger.hilt.android.lifecycle.HiltViewModelFactory} and can be retrieved by default in
+ * an {@code Activity} or {@code Fragment} annotated with {@link
+ * dagger.hilt.android.AndroidEntryPoint}. The {@code HiltViewModel} containing a constructor
+ * annotated with {@link javax.inject.Inject} will have its dependencies defined in the constructor
+ * parameters injected by Dagger's Hilt.
+ *
+ * <p>Example:
+ *
+ * <pre>
+ * @HiltViewModel
+ * public class DonutViewModel extends ViewModel {
+ * @Inject
+ * public DonutViewModel(SavedStateHandle handle, RecipeRepository repository) {
+ * // ...
+ * }
+ * }
+ * </pre>
+ *
+ * <pre>
+ * @AndroidEntryPoint
+ * public class CookingActivity extends AppCompatActivity {
+ * public void onCreate(Bundle savedInstanceState) {
+ * DonutViewModel vm = new ViewModelProvider(this).get(DonutViewModel.class);
+ * }
+ * }
+ * </pre>
+ *
+ * <p>Exactly one constructor in the {@code ViewModel} must be annotated with {@code Inject}.
+ *
+ * <p>Only dependencies available in the {@link dagger.hilt.android.components.ViewModelComponent}
+ * can be injected into the {@code ViewModel}.
+ *
+ * <p>
+ *
+ * @see dagger.hilt.android.components.ViewModelComponent
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.CLASS)
+@GeneratesRootInput
+public @interface HiltViewModel {}
diff --git a/java/dagger/hilt/android/lifecycle/proguard-rules.pro b/java/dagger/hilt/android/lifecycle/proguard-rules.pro
new file mode 100644
index 0000000..edd3d3d
--- /dev/null
+++ b/java/dagger/hilt/android/lifecycle/proguard-rules.pro
@@ -0,0 +1,2 @@
+# Keep class names of Hilt injected ViewModels since their name are used as a multibinding map key.
+-keepnames @dagger.hilt.android.lifecycle.HiltViewModel class * extends androidx.lifecycle.ViewModel
diff --git a/java/dagger/hilt/android/migration/BUILD b/java/dagger/hilt/android/migration/BUILD
new file mode 100644
index 0000000..ade47c3
--- /dev/null
+++ b/java/dagger/hilt/android/migration/BUILD
@@ -0,0 +1,50 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Helpers for migrating to Hilt.
+
+package(default_visibility = ["//:src"])
+
+android_library(
+ name = "optional_inject",
+ srcs = [
+ "OptionalInject.java",
+ "OptionalInjectCheck.java",
+ ],
+ exports = [
+ "//java/dagger/hilt/android/internal/migration:injected_by_hilt",
+ ],
+ deps = [
+ ":package_info",
+ "//java/dagger/hilt/android/internal/migration:injected_by_hilt",
+ "//java/dagger/hilt/internal:preconditions",
+ "@maven//:androidx_activity_activity",
+ "@maven//:androidx_annotation_annotation",
+ "@maven//:androidx_fragment_fragment",
+ ],
+)
+
+java_library(
+ name = "package_info",
+ srcs = ["package-info.java"],
+ deps = [
+ "@google_bazel_common//third_party/java/jsr305_annotations",
+ ],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["**/*"]),
+)
diff --git a/java/dagger/hilt/android/migration/OptionalInject.java b/java/dagger/hilt/android/migration/OptionalInject.java
new file mode 100644
index 0000000..14c1387
--- /dev/null
+++ b/java/dagger/hilt/android/migration/OptionalInject.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.migration;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+/**
+ * When placed on an {@link dagger.hilt.android.AndroidEntryPoint}-annotated activity / fragment /
+ * view / etc, allows injection to occur optionally based on whether or not the application is using
+ * Hilt.
+ *
+ * <p>When using this annotation, you can use {@link OptionalInjectCheck#wasInjectedByHilt} to check
+ * at runtime if the annotated class was injected by Hilt. Additionally, this annotation will also
+ * cause a method, {@code wasInjectedByHilt} to be generated in the Hilt base class as well, that
+ * behaves the same as {@link OptionalInjectCheck#wasInjectedByHilt}. The method is available to
+ * users that extend the Hilt base class directly and don't use the Gradle plugin.
+ *
+ * <p>Example usage:
+ *
+ * <pre><code>
+ * {@literal @}OptionalInject
+ * {@literal @}AndroidEntryPoint
+ * public final class MyFragment extends Fragment {
+ *
+ * {@literal @}Inject Foo foo;
+ *
+ * {@literal @}Override
+ * public void onAttach(Activity activity) {
+ * // Injection will happen here, but only if the Activity and the Application are also
+ * // AndroidEntryPoints and were injected by Hilt.
+ * super.onAttach(activity);
+ * if (!OptionalInjectCheck.wasInjectedByHilt(this)) {
+ * // Get Dagger components the previous way and inject.
+ * }
+ * }
+ * }
+ * </code></pre>
+ *
+ * <p>This is useful for libraries that have to support Hilt users as well as non-Hilt users.
+ * Injection will happen if the parent type (e.g. the activity of a fragment) is an {@link
+ * dagger.hilt.android.AndroidEntryPoint} annotated class and if that parent was also injected via
+ * Hilt.
+ *
+ * @see OptionalInjectCheck
+ * @see <a href="https://dagger.dev/hilt/optional-inject">Optional injection</a>
+ */
+@Target(ElementType.TYPE)
+public @interface OptionalInject {}
diff --git a/java/dagger/hilt/android/migration/OptionalInjectCheck.java b/java/dagger/hilt/android/migration/OptionalInjectCheck.java
new file mode 100644
index 0000000..f9d0ad8
--- /dev/null
+++ b/java/dagger/hilt/android/migration/OptionalInjectCheck.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.migration;
+
+import android.app.Service;
+import android.content.BroadcastReceiver;
+import androidx.annotation.NonNull;
+import androidx.fragment.app.Fragment;
+import android.view.View;
+import androidx.activity.ComponentActivity;
+import dagger.hilt.android.internal.migration.InjectedByHilt;
+import dagger.hilt.internal.Preconditions;
+
+/**
+ * Utility methods for validating if an {@link dagger.hilt.android.AndroidEntryPoint}-annotated
+ * class that is also annotated with {@link OptionalInject} was injected by Hilt.
+ *
+ * @see OptionalInject
+ */
+public final class OptionalInjectCheck {
+
+ /**
+ * Returns true if the Activity was injected by Hilt.
+ *
+ * @throws IllegalArgumentException if the given instance is not an AndroidEntryPoint nor is
+ * annotated with {@link OptionalInject}.
+ */
+ public static boolean wasInjectedByHilt(@NonNull ComponentActivity activity) {
+ return check(activity);
+ }
+
+ /**
+ * Returns true if the BroadcastReceiver was injected by Hilt.
+ *
+ * @throws IllegalArgumentException if the given instance is not an AndroidEntryPoint nor is
+ * annotated with {@link OptionalInject}.
+ */
+ public static boolean wasInjectedByHilt(@NonNull BroadcastReceiver broadcastReceiver) {
+ return check(broadcastReceiver);
+ }
+
+ /**
+ * Returns true if the Fragment was injected by Hilt.
+ *
+ * @throws IllegalArgumentException if the given instance is not an AndroidEntryPoint nor is
+ * annotated with {@link OptionalInject}.
+ */
+ public static boolean wasInjectedByHilt(@NonNull Fragment fragment) {
+ return check(fragment);
+ }
+
+ /**
+ * Returns true if the Service was injected by Hilt.
+ *
+ * @throws IllegalArgumentException if the given instance is not an AndroidEntryPoint nor is
+ * annotated with {@link OptionalInject}.
+ */
+ public static boolean wasInjectedByHilt(@NonNull Service service) {
+ return check(service);
+ }
+
+ /**
+ * Returns true if the View was injected by Hilt.
+ *
+ * @throws IllegalArgumentException if the given instance is not an AndroidEntryPoint nor is
+ * annotated with {@link OptionalInject}.
+ */
+ public static boolean wasInjectedByHilt(@NonNull View view) {
+ return check(view);
+ }
+
+ private static boolean check(@NonNull Object obj) {
+ Preconditions.checkNotNull(obj);
+ Preconditions.checkArgument(
+ obj instanceof InjectedByHilt,
+ "'%s' is not an optionally injected android entry point. Check that you have annotated"
+ + " the class with both @AndroidEntryPoint and @OptionalInject.",
+ obj.getClass());
+ return ((InjectedByHilt) obj).wasInjectedByHilt();
+ }
+
+ private OptionalInjectCheck() {}
+}
diff --git a/java/dagger/hilt/android/migration/package-info.java b/java/dagger/hilt/android/migration/package-info.java
new file mode 100644
index 0000000..e37225a
--- /dev/null
+++ b/java/dagger/hilt/android/migration/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * This package contains Android APIs to help migrating a codebase to Hilt.
+ *
+ * @see <a href="https://dagger.dev/hilt/migration">Migration to Hilt</a>
+ */
+@ParametersAreNonnullByDefault
+package dagger.hilt.android.migration;
+
+import javax.annotation.ParametersAreNonnullByDefault;
diff --git a/java/dagger/hilt/android/package-info.java b/java/dagger/hilt/android/package-info.java
new file mode 100644
index 0000000..894f7ab
--- /dev/null
+++ b/java/dagger/hilt/android/package-info.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * This package contains Hilt APIs for Android applications.
+ *
+ * <p>Hilt provides a standard way to incorporate Dagger dependency injection into an Android
+ * application.
+ *
+ * @see <a href="https://dagger.dev/hilt">Hilt Developer Docs</a>
+ */
+@ParametersAreNonnullByDefault
+package dagger.hilt.android;
+
+import javax.annotation.ParametersAreNonnullByDefault;
diff --git a/java/dagger/hilt/android/plugin/BUILD b/java/dagger/hilt/android/plugin/BUILD
new file mode 100644
index 0000000..7fd2c83
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/BUILD
@@ -0,0 +1,27 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Description:
+# A Gradle plugin that performs a transform.
+
+package(default_visibility = ["//:src"])
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(
+ ["**/*"],
+ # Exclude Gradle build folder to enable working along side Bazel
+ exclude = ["**/build/**"],
+ ),
+)
diff --git a/java/dagger/hilt/android/plugin/build.gradle b/java/dagger/hilt/android/plugin/build.gradle
new file mode 100644
index 0000000..274ecbe
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/build.gradle
@@ -0,0 +1,156 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+buildscript {
+ repositories {
+ google()
+ jcenter()
+ }
+}
+
+plugins {
+ id 'org.jetbrains.kotlin.jvm' version '1.4.20'
+ id 'java-gradle-plugin'
+ id 'maven-publish'
+}
+
+repositories {
+ google()
+ jcenter()
+}
+
+configurations {
+ additionalTestPlugin {
+ canBeConsumed = false
+ canBeResolved = true
+ extendsFrom implementation
+ }
+}
+
+dependencies {
+ implementation gradleApi()
+ compileOnly 'com.android.tools.build:gradle:4.2.0-beta04'
+ // TODO(danysantiago): Make compileOnly to avoid dep for non-Kotlin projects.
+ implementation 'org.jetbrains.kotlin:kotlin-gradle-plugin:1.4.20'
+ implementation 'org.javassist:javassist:3.26.0-GA'
+ implementation 'org.ow2.asm:asm:9.0'
+
+ testImplementation gradleTestKit()
+ testImplementation 'junit:junit:4.12'
+ testImplementation 'com.google.truth:truth:1.0.1'
+ additionalTestPlugin 'com.android.tools.build:gradle:4.2.0-beta04'
+}
+
+// Configure the generating task of plugin-under-test-metadata.properties to
+// include additional dependencies for the injected plugin classpath that
+// are not present in the main runtime dependencies. This allows us to test
+// the desired AGP version while keeping a compileOnly dep on the main source.
+tasks.withType(PluginUnderTestMetadata.class).named("pluginUnderTestMetadata").configure {
+ it.pluginClasspath.from(configurations.additionalTestPlugin)
+}
+
+compileKotlin {
+ kotlinOptions {
+ jvmTarget = "1.8"
+ }
+}
+
+// Create sources Jar from main kotlin sources
+tasks.register("sourcesJar", Jar).configure {
+ group = JavaBasePlugin.DOCUMENTATION_GROUP
+ description = "Assembles sources JAR"
+ classifier = "sources"
+ from(sourceSets["main"].allSource)
+}
+
+// Create javadoc Jar. The jar is empty since we don't really have docs
+// for this plugin but this is required to upload to Sonatype.
+// https://central.sonatype.org/pages/requirements.html#supply-javadoc-and-sources
+tasks.register("javadocJar", Jar).configure {
+ group = JavaBasePlugin.DOCUMENTATION_GROUP
+ description = "Assembles javadoc JAR"
+ classifier = "javadoc"
+}
+
+// Disable Gradle metadata publication.
+tasks.withType(GenerateModuleMetadata) {
+ enabled = false
+}
+
+// TODO(danysantiago): Use POM template in tools/ to avoid duplicating lines.
+publishing {
+ publications {
+ plugin(MavenPublication) {
+ artifactId = 'hilt-android-gradle-plugin'
+ def publishVersion = findProperty("PublishVersion")
+ version = (publishVersion != null) ? publishVersion : "LOCAL-SNAPSHOT"
+ from components.kotlin
+ artifact(sourcesJar)
+ artifact(javadocJar)
+ pom {
+ name = 'Hilt Android Gradle Plugin'
+ description = 'A fast dependency injector for Android and Java.'
+ url = 'https://github.com/google/dagger'
+ scm {
+ url = 'https://github.com/google/dagger/'
+ connection = 'scm:git:git://github.com/google/dagger.git'
+ developerConnection = 'scm:git:ssh://git@github.com/google/dagger.git'
+ tag = 'HEAD'
+ }
+ issueManagement {
+ system = 'GitHub Issues'
+ url = 'https://github.com/google/dagger/issues'
+ }
+ licenses {
+ license {
+ name = 'Apache 2.0'
+ url = 'https://www.apache.org/licenses/LICENSE-2.0.txt'
+ }
+ }
+ organization {
+ name = 'Google, Inc.'
+ url = 'https://www.google.com'
+ }
+ withXml {
+ def projectNode = asNode()
+ // Adds:
+ // <parent>
+ // <groupId>org.sonatype.oss</groupId>
+ // <artifactId>oss-parent</artifactId>
+ // <version>7</version>
+ // </parent>
+ def parentNode = projectNode.appendNode('parent')
+ parentNode.appendNode('groupId', 'org.sonatype.oss')
+ parentNode.appendNode('artifactId', 'oss-parent')
+ parentNode.appendNode('version', '7')
+ // Adds scm->tag because for some reason the DSL API does not.
+ // <scm>
+ // <tag>HEAD</tag>
+ // </scm>
+ projectNode.get('scm').first().appendNode('tag', 'HEAD')
+ }
+ }
+ }
+ }
+ // Publish to build output repository.
+ repositories {
+ maven {
+ url = uri("$buildDir/repo")
+ }
+ }
+}
+
+group='com.google.dagger'
diff --git a/java/dagger/hilt/android/plugin/gradle/wrapper/gradle-wrapper.jar b/java/dagger/hilt/android/plugin/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000..5c2d1cf
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/gradle/wrapper/gradle-wrapper.jar
Binary files differ
diff --git a/java/dagger/hilt/android/plugin/gradle/wrapper/gradle-wrapper.properties b/java/dagger/hilt/android/plugin/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000..4d9ca16
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.7.1-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/java/dagger/hilt/android/plugin/gradlew b/java/dagger/hilt/android/plugin/gradlew
new file mode 100755
index 0000000..b0d6d0a
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/gradlew
@@ -0,0 +1,188 @@
+#!/usr/bin/env sh
+
+#
+# Copyright 2015 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+##
+## Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+ ls=`ls -ld "$PRG"`
+ link=`expr "$ls" : '.*-> \(.*\)$'`
+ if expr "$link" : '/.*' > /dev/null; then
+ PRG="$link"
+ else
+ PRG=`dirname "$PRG"`"/$link"
+ fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+ echo "$*"
+}
+
+die () {
+ echo
+ echo "$*"
+ echo
+ exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+ CYGWIN* )
+ cygwin=true
+ ;;
+ Darwin* )
+ darwin=true
+ ;;
+ MINGW* )
+ msys=true
+ ;;
+ NONSTOP* )
+ nonstop=true
+ ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+ if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+ # IBM's JDK on AIX uses strange locations for the executables
+ JAVACMD="$JAVA_HOME/jre/sh/java"
+ else
+ JAVACMD="$JAVA_HOME/bin/java"
+ fi
+ if [ ! -x "$JAVACMD" ] ; then
+ die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+ fi
+else
+ JAVACMD="java"
+ which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+ MAX_FD_LIMIT=`ulimit -H -n`
+ if [ $? -eq 0 ] ; then
+ if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+ MAX_FD="$MAX_FD_LIMIT"
+ fi
+ ulimit -n $MAX_FD
+ if [ $? -ne 0 ] ; then
+ warn "Could not set maximum file descriptor limit: $MAX_FD"
+ fi
+ else
+ warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+ fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+ GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+ APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+ CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+ JAVACMD=`cygpath --unix "$JAVACMD"`
+
+ # We build the pattern for arguments to be converted via cygpath
+ ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+ SEP=""
+ for dir in $ROOTDIRSRAW ; do
+ ROOTDIRS="$ROOTDIRS$SEP$dir"
+ SEP="|"
+ done
+ OURCYGPATTERN="(^($ROOTDIRS))"
+ # Add a user-defined pattern to the cygpath arguments
+ if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+ OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+ fi
+ # Now convert the arguments - kludge to limit ourselves to /bin/sh
+ i=0
+ for arg in "$@" ; do
+ CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+ CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
+
+ if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
+ eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+ else
+ eval `echo args$i`="\"$arg\""
+ fi
+ i=$((i+1))
+ done
+ case $i in
+ (0) set -- ;;
+ (1) set -- "$args0" ;;
+ (2) set -- "$args0" "$args1" ;;
+ (3) set -- "$args0" "$args1" "$args2" ;;
+ (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+ (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+ (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+ (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+ (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+ (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+ esac
+fi
+
+# Escape application args
+save () {
+ for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+ echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+ cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"
diff --git a/java/dagger/hilt/android/plugin/src/main/kotlin/dagger/hilt/android/plugin/AndroidEntryPointClassTransformer.kt b/java/dagger/hilt/android/plugin/src/main/kotlin/dagger/hilt/android/plugin/AndroidEntryPointClassTransformer.kt
new file mode 100644
index 0000000..e066f48
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/main/kotlin/dagger/hilt/android/plugin/AndroidEntryPointClassTransformer.kt
@@ -0,0 +1,249 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package dagger.hilt.android.plugin
+
+import dagger.hilt.android.plugin.util.isClassFile
+import dagger.hilt.android.plugin.util.isJarFile
+import java.io.File
+import java.io.FileInputStream
+import java.util.zip.ZipInputStream
+import javassist.ClassPool
+import javassist.CtClass
+import javassist.Modifier
+import javassist.bytecode.Bytecode
+import javassist.bytecode.CodeIterator
+import javassist.bytecode.Opcode
+import org.slf4j.LoggerFactory
+
+typealias CodeArray = javassist.bytecode.ByteArray // Avoids conflict with Kotlin's stdlib ByteArray
+
+/**
+ * A helper class for performing the transform.
+ *
+ * Create it with the list of all available source directories along with the root output directory
+ * and use [AndroidEntryPointClassTransformer.transformFile] or
+ * [AndroidEntryPointClassTransformer.transformJarContents] to perform the actual transformation.
+ */
+internal class AndroidEntryPointClassTransformer(
+ val taskName: String,
+ allInputs: List<File>,
+ private val sourceRootOutputDir: File,
+ private val copyNonTransformed: Boolean
+) {
+ private val logger = LoggerFactory.getLogger(AndroidEntryPointClassTransformer::class.java)
+
+ // A ClassPool created from the given input files, this allows us to use the higher
+ // level Javaassit APIs, but requires class parsing/loading.
+ private val classPool: ClassPool = ClassPool(true).also { pool ->
+ allInputs.forEach {
+ pool.appendClassPath(it.path)
+ }
+ }
+
+ init {
+ sourceRootOutputDir.mkdirs()
+ }
+
+ /**
+ * Transforms the classes inside the jar and copies re-written class files if and only if they are
+ * transformed.
+ *
+ * @param inputFile The jar file to transform, must be a jar.
+ * @return true if at least one class within the jar was transformed.
+ */
+ fun transformJarContents(inputFile: File): Boolean {
+ require(inputFile.isJarFile()) {
+ "Invalid file, '$inputFile' is not a jar."
+ }
+ // Validate transform is not applied to a jar when copying is enabled, meaning the transformer
+ // is being used in the Android transform API pipeline which does not need to transform jars
+ // and handles copying them.
+ check(!copyNonTransformed) {
+ "Transforming a jar is not supported with 'copyNonTransformed'."
+ }
+ var transformed = false
+ ZipInputStream(FileInputStream(inputFile)).use { input ->
+ var entry = input.nextEntry
+ while (entry != null) {
+ if (entry.isClassFile()) {
+ val clazz = classPool.makeClass(input, false)
+ transformed = transformClassToOutput(clazz) || transformed
+ }
+ entry = input.nextEntry
+ }
+ }
+ return transformed
+ }
+
+ /**
+ * Transform a single class file.
+ *
+ * @param inputFile The file to transform, must be a class file.
+ * @return true if the class file was transformed.
+ */
+ fun transformFile(inputFile: File): Boolean {
+ check(inputFile.isClassFile()) {
+ "Invalid file, '$inputFile' is not a class."
+ }
+ val clazz = inputFile.inputStream().use { classPool.makeClass(it, false) }
+ return transformClassToOutput(clazz)
+ }
+
+ private fun transformClassToOutput(clazz: CtClass): Boolean {
+ val transformed = transformClass(clazz)
+ if (transformed || copyNonTransformed) {
+ clazz.writeFile(sourceRootOutputDir.path)
+ }
+ return transformed
+ }
+
+ private fun transformClass(clazz: CtClass): Boolean {
+ if (ANDROID_ENTRY_POINT_ANNOTATIONS.none { clazz.hasAnnotation(it) }) {
+ // Not a Android entry point annotated class, don't do anything.
+ return false
+ }
+
+ // TODO(danysantiago): Handle classes with '$' in their name if they do become an issue.
+ val superclassName = clazz.classFile.superclass
+ val entryPointSuperclassName =
+ clazz.packageName + ".Hilt_" + clazz.simpleName.replace("$", "_")
+ logger.info(
+ "[$taskName] Transforming ${clazz.name} to extend $entryPointSuperclassName instead of " +
+ "$superclassName."
+ )
+ val entryPointSuperclass = classPool.get(entryPointSuperclassName)
+ clazz.superclass = entryPointSuperclass
+ transformSuperMethodCalls(clazz, superclassName, entryPointSuperclassName)
+
+ // Check if Hilt generated class is a BroadcastReceiver with the marker field which means
+ // a super.onReceive invocation has to be inserted in the implementation.
+ if (entryPointSuperclass.declaredFields.any { it.name == "onReceiveBytecodeInjectionMarker" }) {
+ transformOnReceive(clazz, entryPointSuperclassName)
+ }
+
+ return true
+ }
+
+ /**
+ * Iterates over each declared method, finding in its bodies super calls. (e.g. super.onCreate())
+ * and rewrites the method reference of the invokespecial instruction to one that uses the new
+ * superclass.
+ *
+ * The invokespecial instruction is emitted for code that between other things also invokes a
+ * method of a superclass of the current class. The opcode invokespecial takes two operands, each
+ * of 8 bit, that together represent an address in the constant pool to a method reference. The
+ * method reference is computed at compile-time by looking the direct superclass declaration, but
+ * at runtime the code behaves like invokevirtual, where as the actual method invoked is looked up
+ * based on the class hierarchy.
+ *
+ * However, it has been observed that on APIs 19 to 22 the Android Runtime (ART) jumps over the
+ * direct superclass and into the method reference class, causing unexpected behaviours.
+ * Therefore, this method performs the additional transformation to rewrite direct super call
+ * invocations to use a method reference whose class in the pool is the new superclass. Note that
+ * this is not necessary for constructor calls since the Javassist library takes care of those.
+ *
+ * @see: https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-6.html#jvms-6.5.invokespecial
+ * @see: https://source.android.com/devices/tech/dalvik/dalvik-bytecode
+ */
+ private fun transformSuperMethodCalls(
+ clazz: CtClass,
+ oldSuperclassName: String,
+ newSuperclassName: String
+ ) {
+ val constantPool = clazz.classFile.constPool
+ clazz.declaredMethods
+ .filter {
+ it.methodInfo.isMethod &&
+ !Modifier.isStatic(it.modifiers) &&
+ !Modifier.isAbstract(it.modifiers) &&
+ !Modifier.isNative(it.modifiers)
+ }
+ .forEach { method ->
+ val codeAttr = method.methodInfo.codeAttribute
+ val code = codeAttr.code
+ codeAttr.iterator().forEachInstruction { index, opcode ->
+ // We are only interested in 'invokespecial' instructions.
+ if (opcode != Opcode.INVOKESPECIAL) {
+ return@forEachInstruction
+ }
+ // If the method reference of the instruction is not using the old superclass then we
+ // should not rewrite it.
+ val methodRef = CodeArray.readU16bit(code, index + 1)
+ val currentClassRef = constantPool.getMethodrefClassName(methodRef)
+ if (currentClassRef != oldSuperclassName) {
+ return@forEachInstruction
+ }
+ val nameAndTypeRef = constantPool.getMethodrefNameAndType(methodRef)
+ val newSuperclassRef = constantPool.addClassInfo(newSuperclassName)
+ val newMethodRef = constantPool.addMethodrefInfo(newSuperclassRef, nameAndTypeRef)
+ logger.info(
+ "[$taskName] Redirecting an invokespecial in " +
+ "${clazz.name}.${method.name}:${method.signature} at code index $index from " +
+ "method ref #$methodRef to #$newMethodRef."
+ )
+ CodeArray.write16bit(newMethodRef, code, index + 1)
+ }
+ }
+ }
+
+ // Iterate over each instruction in a CodeIterator.
+ private fun CodeIterator.forEachInstruction(body: CodeIterator.(Int, Int) -> Unit) {
+ while (hasNext()) {
+ val index = next()
+ this.body(index, byteAt(index))
+ }
+ }
+
+ /**
+ * For a BroadcastReceiver insert a super call in the onReceive method implementation since
+ * after the class is transformed onReceive will no longer be abstract (it is implemented by
+ * Hilt generated receiver).
+ */
+ private fun transformOnReceive(clazz: CtClass, entryPointSuperclassName: String) {
+ val method = clazz.declaredMethods.first {
+ it.name + it.signature == ON_RECEIVE_METHOD_NAME + ON_RECEIVE_METHOD_SIGNATURE
+ }
+ val constantPool = clazz.classFile.constPool
+ val newCode = Bytecode(constantPool).apply {
+ addAload(0) // Loads 'this'
+ addAload(1) // Loads method param 1 (Context)
+ addAload(2) // Loads method param 2 (Intent)
+ addInvokespecial(
+ entryPointSuperclassName, ON_RECEIVE_METHOD_NAME, ON_RECEIVE_METHOD_SIGNATURE
+ )
+ }
+ val newCodeAttribute = newCode.toCodeAttribute()
+ val currentCodeAttribute = method.methodInfo.codeAttribute
+ currentCodeAttribute.maxStack =
+ maxOf(newCodeAttribute.maxStack, currentCodeAttribute.maxStack)
+ currentCodeAttribute.maxLocals =
+ maxOf(newCodeAttribute.maxLocals, currentCodeAttribute.maxLocals)
+ val codeIterator = currentCodeAttribute.iterator()
+ val pos = codeIterator.insertEx(newCode.get()) // insert new code
+ codeIterator.insert(newCodeAttribute.exceptionTable, pos) // offset exception table
+ method.methodInfo.rebuildStackMap(clazz.classPool) // update stack table
+ }
+
+ companion object {
+ val ANDROID_ENTRY_POINT_ANNOTATIONS = setOf(
+ "dagger.hilt.android.AndroidEntryPoint",
+ "dagger.hilt.android.HiltAndroidApp"
+ )
+ val ON_RECEIVE_METHOD_NAME = "onReceive"
+ val ON_RECEIVE_METHOD_SIGNATURE =
+ "(Landroid/content/Context;Landroid/content/Intent;)V"
+ }
+}
diff --git a/java/dagger/hilt/android/plugin/src/main/kotlin/dagger/hilt/android/plugin/AndroidEntryPointClassVisitor.kt b/java/dagger/hilt/android/plugin/src/main/kotlin/dagger/hilt/android/plugin/AndroidEntryPointClassVisitor.kt
new file mode 100644
index 0000000..015bb76
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/main/kotlin/dagger/hilt/android/plugin/AndroidEntryPointClassVisitor.kt
@@ -0,0 +1,197 @@
+package dagger.hilt.android.plugin
+
+import com.android.build.api.instrumentation.AsmClassVisitorFactory
+import com.android.build.api.instrumentation.ClassContext
+import com.android.build.api.instrumentation.ClassData
+import com.android.build.api.instrumentation.InstrumentationParameters
+import java.io.File
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.Input
+import org.objectweb.asm.ClassReader
+import org.objectweb.asm.ClassVisitor
+import org.objectweb.asm.FieldVisitor
+import org.objectweb.asm.MethodVisitor
+import org.objectweb.asm.Opcodes
+
+/**
+ * ASM Adapter that transforms @AndroidEntryPoint-annotated classes to extend the Hilt
+ * generated android class, including the @HiltAndroidApp application class.
+ */
+@Suppress("UnstableApiUsage")
+class AndroidEntryPointClassVisitor(
+ private val apiVersion: Int,
+ nextClassVisitor: ClassVisitor,
+ private val additionalClasses: File
+) : ClassVisitor(apiVersion, nextClassVisitor) {
+
+ interface AndroidEntryPointParams : InstrumentationParameters {
+ @get:Input
+ val additionalClassesDir: Property<File>
+ }
+
+ abstract class Factory : AsmClassVisitorFactory<AndroidEntryPointParams> {
+ override fun createClassVisitor(
+ classContext: ClassContext,
+ nextClassVisitor: ClassVisitor
+ ): ClassVisitor {
+ return AndroidEntryPointClassVisitor(
+ apiVersion = instrumentationContext.apiVersion.get(),
+ nextClassVisitor = nextClassVisitor,
+ additionalClasses = parameters.get().additionalClassesDir.get()
+ )
+ }
+
+ /**
+ * Check if a class should be transformed.
+ *
+ * Only classes that are an Android entry point should be transformed.
+ */
+ override fun isInstrumentable(classData: ClassData) =
+ classData.classAnnotations.any { ANDROID_ENTRY_POINT_ANNOTATIONS.contains(it) }
+ }
+
+ // The name of the Hilt generated superclass in it internal form.
+ // e.g. "my/package/Hilt_MyActivity"
+ lateinit var newSuperclassName: String
+
+ lateinit var oldSuperclassName: String
+
+ override fun visit(
+ version: Int,
+ access: Int,
+ name: String,
+ signature: String?,
+ superName: String?,
+ interfaces: Array<out String>?
+ ) {
+ val packageName = name.substringBeforeLast('/')
+ val className = name.substringAfterLast('/')
+ newSuperclassName =
+ packageName + "/Hilt_" + className.replace("$", "_")
+ oldSuperclassName = superName ?: error { "Superclass of $name is null!" }
+ super.visit(version, access, name, signature, newSuperclassName, interfaces)
+ }
+
+ override fun visitMethod(
+ access: Int,
+ name: String,
+ descriptor: String,
+ signature: String?,
+ exceptions: Array<out String>?
+ ): MethodVisitor {
+ val nextMethodVisitor = super.visitMethod(access, name, descriptor, signature, exceptions)
+ val invokeSpecialVisitor = InvokeSpecialAdapter(apiVersion, nextMethodVisitor)
+ if (name == ON_RECEIVE_METHOD_NAME &&
+ descriptor == ON_RECEIVE_METHOD_DESCRIPTOR &&
+ hasOnReceiveBytecodeInjectionMarker()
+ ) {
+ return OnReceiveAdapter(apiVersion, invokeSpecialVisitor)
+ }
+ return invokeSpecialVisitor
+ }
+
+ /**
+ * Adapter for super calls (e.g. super.onCreate()) that rewrites the owner reference of the
+ * invokespecial instruction to use the new superclass.
+ *
+ * The invokespecial instruction is emitted for code that between other things also invokes a
+ * method of a superclass of the current class. The opcode invokespecial takes two operands, each
+ * of 8 bit, that together represent an address in the constant pool to a method reference. The
+ * method reference is computed at compile-time by looking the direct superclass declaration, but
+ * at runtime the code behaves like invokevirtual, where as the actual method invoked is looked up
+ * based on the class hierarchy.
+ *
+ * However, it has been observed that on APIs 19 to 22 the Android Runtime (ART) jumps over the
+ * direct superclass and into the method reference class, causing unexpected behaviours.
+ * Therefore, this method performs the additional transformation to rewrite direct super call
+ * invocations to use a method reference whose class in the pool is the new superclass. Note that
+ * this is not necessary for constructor calls since the Javassist library takes care of those.
+ *
+ * @see: https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-6.html#jvms-6.5.invokespecial
+ * @see: https://source.android.com/devices/tech/dalvik/dalvik-bytecode
+ */
+ inner class InvokeSpecialAdapter(
+ apiVersion: Int,
+ nextClassVisitor: MethodVisitor
+ ) : MethodVisitor(apiVersion, nextClassVisitor) {
+ override fun visitMethodInsn(
+ opcode: Int,
+ owner: String,
+ name: String,
+ descriptor: String,
+ isInterface: Boolean
+ ) {
+ if (opcode == Opcodes.INVOKESPECIAL && owner == oldSuperclassName) {
+ // Update the owner of all INVOKESPECIAL instructions, including those found in
+ // constructors.
+ super.visitMethodInsn(opcode, newSuperclassName, name, descriptor, isInterface)
+ } else {
+ super.visitMethodInsn(opcode, owner, name, descriptor, isInterface)
+ }
+ }
+ }
+
+ /**
+ * Method adapter for a BroadcastReceiver's onReceive method to insert a super call since with
+ * its new superclass, onReceive will no longer be abstract (it is implemented by Hilt generated
+ * receiver).
+ */
+ inner class OnReceiveAdapter(
+ apiVersion: Int,
+ nextClassVisitor: MethodVisitor
+ ) : MethodVisitor(apiVersion, nextClassVisitor) {
+ override fun visitCode() {
+ super.visitCode()
+ super.visitIntInsn(Opcodes.ALOAD, 0) // Load 'this'
+ super.visitIntInsn(Opcodes.ALOAD, 1) // Load method param 1 (Context)
+ super.visitIntInsn(Opcodes.ALOAD, 2) // Load method param 2 (Intent)
+ super.visitMethodInsn(
+ Opcodes.INVOKESPECIAL,
+ newSuperclassName,
+ ON_RECEIVE_METHOD_NAME,
+ ON_RECEIVE_METHOD_DESCRIPTOR,
+ false
+ )
+ }
+ }
+
+ /**
+ * Check if Hilt generated class is a BroadcastReceiver with the marker field which means
+ * a super.onReceive invocation has to be inserted in the implementation.
+ */
+ private fun hasOnReceiveBytecodeInjectionMarker() =
+ findAdditionalClassFile(newSuperclassName).inputStream().use {
+ var hasMarker = false
+ ClassReader(it).accept(
+ object : ClassVisitor(apiVersion) {
+ override fun visitField(
+ access: Int,
+ name: String,
+ descriptor: String,
+ signature: String?,
+ value: Any?
+ ): FieldVisitor? {
+ if (name == "onReceiveBytecodeInjectionMarker") {
+ hasMarker = true
+ }
+ return null
+ }
+ },
+ ClassReader.SKIP_CODE or ClassReader.SKIP_DEBUG or ClassReader.SKIP_FRAMES
+ )
+ return@use hasMarker
+ }
+
+ private fun findAdditionalClassFile(className: String) =
+ File(additionalClasses, "$className.class")
+
+ companion object {
+ val ANDROID_ENTRY_POINT_ANNOTATIONS = setOf(
+ "dagger.hilt.android.AndroidEntryPoint",
+ "dagger.hilt.android.HiltAndroidApp"
+ )
+ const val ON_RECEIVE_METHOD_NAME = "onReceive"
+ const val ON_RECEIVE_METHOD_DESCRIPTOR =
+ "(Landroid/content/Context;Landroid/content/Intent;)V"
+ }
+}
diff --git a/java/dagger/hilt/android/plugin/src/main/kotlin/dagger/hilt/android/plugin/AndroidEntryPointTransform.kt b/java/dagger/hilt/android/plugin/src/main/kotlin/dagger/hilt/android/plugin/AndroidEntryPointTransform.kt
new file mode 100644
index 0000000..9bb5160
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/main/kotlin/dagger/hilt/android/plugin/AndroidEntryPointTransform.kt
@@ -0,0 +1,174 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.plugin
+
+import com.android.build.api.transform.DirectoryInput
+import com.android.build.api.transform.Format
+import com.android.build.api.transform.JarInput
+import com.android.build.api.transform.QualifiedContent
+import com.android.build.api.transform.Status
+import com.android.build.api.transform.Transform
+import com.android.build.api.transform.TransformInput
+import com.android.build.api.transform.TransformInvocation
+import dagger.hilt.android.plugin.util.isClassFile
+import java.io.File
+
+/**
+ * Bytecode transformation to make @AndroidEntryPoint annotated classes extend the Hilt
+ * generated android classes, including the @HiltAndroidApp application class.
+ *
+ * A transform receives input as a collection [TransformInput], which is composed of [JarInput]s and
+ * [DirectoryInput]s. The resulting files must be placed in the
+ * [TransformInvocation.getOutputProvider]. The bytecode transformation can be done with any library
+ * (in our case Javaassit). The [QualifiedContent.Scope] defined in a transform defines the input
+ * the transform will receive and if it can be applied to only the Android application projects or
+ * Android libraries too.
+ *
+ * See: [TransformPublic Docs](https://google.github.io/android-gradle-dsl/javadoc/current/com/android/build/api/transform/Transform.html)
+ */
+class AndroidEntryPointTransform : Transform() {
+ // The name of the transform. This name appears as a gradle task.
+ override fun getName() = "AndroidEntryPointTransform"
+
+ // The type of input this transform will handle.
+ override fun getInputTypes() = setOf(QualifiedContent.DefaultContentType.CLASSES)
+
+ override fun isIncremental() = true
+
+ // The project scope this transform is applied to.
+ override fun getScopes() = mutableSetOf(QualifiedContent.Scope.PROJECT)
+
+ /**
+ * Performs the transformation of the bytecode.
+ *
+ * The inputs will be available in the [TransformInvocation] along with referenced inputs that
+ * should not be transformed. The inputs received along with the referenced inputs depend on the
+ * scope of the transform.
+ *
+ * The invocation will also indicate if an incremental transform has to be applied or not. Even
+ * though a transform might return true in its [isIncremental] function, the invocation might
+ * return false in [TransformInvocation.isIncremental], therefore both cases must be handled.
+ */
+ override fun transform(invocation: TransformInvocation) {
+ if (!invocation.isIncremental) {
+ // Remove any lingering files on a non-incremental invocation since everything has to be
+ // transformed.
+ invocation.outputProvider.deleteAll()
+ }
+
+ invocation.inputs.forEach { transformInput ->
+ transformInput.jarInputs.forEach { jarInput ->
+ val outputJar =
+ invocation.outputProvider.getContentLocation(
+ jarInput.name,
+ jarInput.contentTypes,
+ jarInput.scopes,
+ Format.JAR
+ )
+ if (invocation.isIncremental) {
+ when (jarInput.status) {
+ Status.ADDED, Status.CHANGED -> copyJar(jarInput.file, outputJar)
+ Status.REMOVED -> outputJar.delete()
+ Status.NOTCHANGED -> {
+ // No need to transform.
+ }
+ else -> {
+ error("Unknown status: ${jarInput.status}")
+ }
+ }
+ } else {
+ copyJar(jarInput.file, outputJar)
+ }
+ }
+ transformInput.directoryInputs.forEach { directoryInput ->
+ val outputDir = invocation.outputProvider.getContentLocation(
+ directoryInput.name,
+ directoryInput.contentTypes,
+ directoryInput.scopes,
+ Format.DIRECTORY
+ )
+ val classTransformer =
+ createHiltClassTransformer(invocation.inputs, invocation.referencedInputs, outputDir)
+ if (invocation.isIncremental) {
+ directoryInput.changedFiles.forEach { (file, status) ->
+ val outputFile = toOutputFile(outputDir, directoryInput.file, file)
+ when (status) {
+ Status.ADDED, Status.CHANGED ->
+ transformFile(file, outputFile.parentFile, classTransformer)
+ Status.REMOVED -> outputFile.delete()
+ Status.NOTCHANGED -> {
+ // No need to transform.
+ }
+ else -> {
+ error("Unknown status: $status")
+ }
+ }
+ }
+ } else {
+ directoryInput.file.walkTopDown().forEach { file ->
+ val outputFile = toOutputFile(outputDir, directoryInput.file, file)
+ transformFile(file, outputFile.parentFile, classTransformer)
+ }
+ }
+ }
+ }
+ }
+
+ // Create a transformer given an invocation inputs. Note that since this is a PROJECT scoped
+ // transform the actual transformation is only done on project files and not its dependencies.
+ private fun createHiltClassTransformer(
+ inputs: Collection<TransformInput>,
+ referencedInputs: Collection<TransformInput>,
+ outputDir: File
+ ): AndroidEntryPointClassTransformer {
+ val classFiles = (inputs + referencedInputs).flatMap { input ->
+ (input.directoryInputs + input.jarInputs).map { it.file }
+ }
+ return AndroidEntryPointClassTransformer(
+ taskName = name,
+ allInputs = classFiles,
+ sourceRootOutputDir = outputDir,
+ copyNonTransformed = true
+ )
+ }
+
+ // Transform a single file. If the file is not a class file it is just copied to the output dir.
+ private fun transformFile(
+ inputFile: File,
+ outputDir: File,
+ transformer: AndroidEntryPointClassTransformer
+ ) {
+ if (inputFile.isClassFile()) {
+ transformer.transformFile(inputFile)
+ } else if (inputFile.isFile) {
+ // Copy all non .class files to the output.
+ outputDir.mkdirs()
+ val outputFile = File(outputDir, inputFile.name)
+ inputFile.copyTo(target = outputFile, overwrite = true)
+ }
+ }
+
+ // We are only interested in project compiled classes but we have to copy received jars to the
+ // output.
+ private fun copyJar(inputJar: File, outputJar: File) {
+ outputJar.parentFile?.mkdirs()
+ inputJar.copyTo(target = outputJar, overwrite = true)
+ }
+
+ private fun toOutputFile(outputDir: File, inputDir: File, inputFile: File) =
+ File(outputDir, inputFile.relativeTo(inputDir).path)
+}
diff --git a/java/dagger/hilt/android/plugin/src/main/kotlin/dagger/hilt/android/plugin/HiltExtension.kt b/java/dagger/hilt/android/plugin/src/main/kotlin/dagger/hilt/android/plugin/HiltExtension.kt
new file mode 100644
index 0000000..7a33836
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/main/kotlin/dagger/hilt/android/plugin/HiltExtension.kt
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package dagger.hilt.android.plugin
+
+/**
+ * Configuration options for the Hilt Gradle Plugin
+ */
+interface HiltExtension {
+
+ /**
+ * If set to `true`, Hilt will adjust the compile classpath such that it includes transitive
+ * dependencies, ignoring `api` or `implementation` boundaries during compilation. You should
+ * enable this option if your project has multiple level of transitive dependencies that contain
+ * injected classes or entry points.
+ *
+ * Enabling this option also requires android.lintOptions.checkReleaseBuilds to be set to 'false'
+ * if the Android Gradle Plugin version being used is less than 7.0.
+ *
+ * See https://github.com/google/dagger/issues/1991 for more context.
+ */
+ var enableExperimentalClasspathAggregation: Boolean
+
+ /**
+ * If set to `true`, Hilt will register a transform task that will rewrite `@AndroidEntryPoint`
+ * annotated classes before the host-side JVM tests run. You should enable this option if you are
+ * running Robolectric UI tests as part of your JUnit tests.
+ *
+ * This flag is not necessary if when com.android.tools.build:gradle:4.2.0+ is used and will be
+ * deprecated in a future version.
+ */
+ var enableTransformForLocalTests: Boolean
+}
+
+internal open class HiltExtensionImpl : HiltExtension {
+ override var enableExperimentalClasspathAggregation: Boolean = false
+ override var enableTransformForLocalTests: Boolean = false
+}
diff --git a/java/dagger/hilt/android/plugin/src/main/kotlin/dagger/hilt/android/plugin/HiltGradlePlugin.kt b/java/dagger/hilt/android/plugin/src/main/kotlin/dagger/hilt/android/plugin/HiltGradlePlugin.kt
new file mode 100644
index 0000000..e26edb5
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/main/kotlin/dagger/hilt/android/plugin/HiltGradlePlugin.kt
@@ -0,0 +1,298 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.plugin
+
+import com.android.build.api.component.Component
+import com.android.build.api.extension.AndroidComponentsExtension
+import com.android.build.api.instrumentation.FramesComputationMode
+import com.android.build.api.instrumentation.InstrumentationScope
+import com.android.build.gradle.AppExtension
+import com.android.build.gradle.BaseExtension
+import com.android.build.gradle.LibraryExtension
+import com.android.build.gradle.TestExtension
+import com.android.build.gradle.TestedExtension
+import com.android.build.gradle.api.AndroidBasePlugin
+import com.android.build.gradle.api.BaseVariant
+import com.android.build.gradle.api.TestVariant
+import com.android.build.gradle.api.UnitTestVariant
+import dagger.hilt.android.plugin.util.CopyTransform
+import dagger.hilt.android.plugin.util.SimpleAGPVersion
+import java.io.File
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.artifacts.component.ProjectComponentIdentifier
+import org.gradle.api.attributes.Attribute
+
+/**
+ * A Gradle plugin that checks if the project is an Android project and if so, registers a
+ * bytecode transformation.
+ *
+ * The plugin also passes an annotation processor option to disable superclass validation for
+ * classes annotated with `@AndroidEntryPoint` since the registered transform by this plugin will
+ * update the superclass.
+ */
+class HiltGradlePlugin : Plugin<Project> {
+ override fun apply(project: Project) {
+ var configured = false
+ project.plugins.withType(AndroidBasePlugin::class.java) {
+ configured = true
+ configureHilt(project)
+ }
+ project.afterEvaluate {
+ check(configured) {
+ // Check if configuration was applied, if not inform the developer they have applied the
+ // plugin to a non-android project.
+ "The Hilt Android Gradle plugin can only be applied to an Android project."
+ }
+ verifyDependencies(it)
+ }
+ }
+
+ private fun configureHilt(project: Project) {
+ val hiltExtension = project.extensions.create(
+ HiltExtension::class.java, "hilt", HiltExtensionImpl::class.java
+ )
+ configureCompileClasspath(project, hiltExtension)
+ if (SimpleAGPVersion.ANDROID_GRADLE_PLUGIN_VERSION < SimpleAGPVersion(4, 2)) {
+ // Configures bytecode transform using older APIs pre AGP 4.2
+ configureTransform(project, hiltExtension)
+ } else {
+ // Configures bytecode transform using AGP 4.2 ASM pipeline.
+ configureTransformASM(project, hiltExtension)
+ }
+ configureProcessorFlags(project)
+ }
+
+ private fun configureCompileClasspath(project: Project, hiltExtension: HiltExtension) {
+ val androidExtension = project.extensions.findByType(BaseExtension::class.java)
+ ?: throw error("Android BaseExtension not found.")
+ when (androidExtension) {
+ is AppExtension -> {
+ // For an app project we configure the app variant and both androidTest and test variants,
+ // Hilt components are generated in all of them.
+ androidExtension.applicationVariants.all {
+ configureVariantCompileClasspath(project, hiltExtension, androidExtension, it)
+ }
+ androidExtension.testVariants.all {
+ configureVariantCompileClasspath(project, hiltExtension, androidExtension, it)
+ }
+ androidExtension.unitTestVariants.all {
+ configureVariantCompileClasspath(project, hiltExtension, androidExtension, it)
+ }
+ }
+ is LibraryExtension -> {
+ // For a library project, only the androidTest and test variant are configured since
+ // Hilt components are not generated in a library.
+ androidExtension.testVariants.all {
+ configureVariantCompileClasspath(project, hiltExtension, androidExtension, it)
+ }
+ androidExtension.unitTestVariants.all {
+ configureVariantCompileClasspath(project, hiltExtension, androidExtension, it)
+ }
+ }
+ is TestExtension -> {
+ androidExtension.applicationVariants.all {
+ configureVariantCompileClasspath(project, hiltExtension, androidExtension, it)
+ }
+ }
+ else -> error(
+ "Hilt plugin is unable to configure the compile classpath for project with extension " +
+ "'$androidExtension'"
+ )
+ }
+
+ project.dependencies.apply {
+ registerTransform(CopyTransform::class.java) { spec ->
+ // Java/Kotlin library projects offer an artifact of type 'jar'.
+ spec.from.attribute(ARTIFACT_TYPE_ATTRIBUTE, "jar")
+ // Android library projects (with or without Kotlin) offer an artifact of type
+ // 'processed-jar', which AGP can offer as a jar.
+ spec.from.attribute(ARTIFACT_TYPE_ATTRIBUTE, "processed-jar")
+ spec.to.attribute(ARTIFACT_TYPE_ATTRIBUTE, DAGGER_ARTIFACT_TYPE_VALUE)
+ }
+ }
+ }
+
+ private fun configureVariantCompileClasspath(
+ project: Project,
+ hiltExtension: HiltExtension,
+ androidExtension: BaseExtension,
+ variant: BaseVariant
+ ) {
+ if (!hiltExtension.enableExperimentalClasspathAggregation) {
+ // Option is not enabled, don't configure compile classpath. Note that the option can't be
+ // checked earlier (before iterating over the variants) since it would have been too early for
+ // the value to be populated from the build file.
+ return
+ }
+
+ if (androidExtension.lintOptions.isCheckReleaseBuilds &&
+ SimpleAGPVersion.ANDROID_GRADLE_PLUGIN_VERSION < SimpleAGPVersion(7, 0)
+ ) {
+ // Sadly we have to ask users to disable lint when enableExperimentalClasspathAggregation is
+ // set to true and they are not in AGP 7.0+ since Lint will cause issues during the
+ // configuration phase. See b/158753935 and b/160392650
+ error(
+ "Invalid Hilt plugin configuration: When 'enableExperimentalClasspathAggregation' is " +
+ "enabled 'android.lintOptions.checkReleaseBuilds' has to be set to false unless " +
+ "com.android.tools.build:gradle:7.0.0+ is used."
+ )
+ }
+
+ if (
+ listOf(
+ "android.injected.build.model.only", // Sent by AS 1.0 only
+ "android.injected.build.model.only.advanced", // Sent by AS 1.1+
+ "android.injected.build.model.only.versioned", // Sent by AS 2.4+
+ "android.injected.build.model.feature.full.dependencies", // Sent by AS 2.4+
+ "android.injected.build.model.v2", // Sent by AS 4.2+
+ ).any { project.properties.containsKey(it) }
+ ) {
+ // Do not configure compile classpath when AndroidStudio is building the model (syncing)
+ // otherwise it will cause a freeze.
+ return
+ }
+
+ val runtimeConfiguration = if (variant is TestVariant) {
+ // For Android test variants, the tested runtime classpath is used since the test app has
+ // tested dependencies removed.
+ variant.testedVariant.runtimeConfiguration
+ } else {
+ variant.runtimeConfiguration
+ }
+ val artifactView = runtimeConfiguration.incoming.artifactView { view ->
+ view.attributes.attribute(ARTIFACT_TYPE_ATTRIBUTE, DAGGER_ARTIFACT_TYPE_VALUE)
+ view.componentFilter { identifier ->
+ // Filter out the project's classes from the aggregated view since this can cause
+ // issues with Kotlin internal members visibility. b/178230629
+ if (identifier is ProjectComponentIdentifier) {
+ identifier.projectName != project.name
+ } else {
+ true
+ }
+ }
+ }
+
+ // CompileOnly config names don't follow the usual convention:
+ // <Variant Name> -> <Config Name>
+ // debug -> debugCompileOnly
+ // debugAndroidTest -> androidTestDebugCompileOnly
+ // debugUnitTest -> testDebugCompileOnly
+ // release -> releaseCompileOnly
+ // releaseUnitTest -> testReleaseCompileOnly
+ val compileOnlyConfigName = when (variant) {
+ is TestVariant ->
+ "androidTest${variant.name.substringBeforeLast("AndroidTest").capitalize()}CompileOnly"
+ is UnitTestVariant ->
+ "test${variant.name.substringBeforeLast("UnitTest").capitalize()}CompileOnly"
+ else ->
+ "${variant.name}CompileOnly"
+ }
+ project.dependencies.add(compileOnlyConfigName, artifactView.files)
+ }
+
+ @Suppress("UnstableApiUsage")
+ private fun configureTransformASM(project: Project, hiltExtension: HiltExtension) {
+ var warnAboutLocalTestsFlag = false
+ fun registerTransform(androidComponent: Component) {
+ if (hiltExtension.enableTransformForLocalTests && !warnAboutLocalTestsFlag) {
+ project.logger.warn(
+ "The Hilt configuration option 'enableTransformForLocalTests' is no longer necessary " +
+ "when com.android.tools.build:gradle:4.2.0+ is used."
+ )
+ warnAboutLocalTestsFlag = true
+ }
+ androidComponent.transformClassesWith(
+ classVisitorFactoryImplClass = AndroidEntryPointClassVisitor.Factory::class.java,
+ scope = InstrumentationScope.PROJECT
+ ) { params ->
+ val classesDir =
+ File(project.buildDir, "intermediates/javac/${androidComponent.name}/classes")
+ params.additionalClassesDir.set(classesDir)
+ }
+ androidComponent.setAsmFramesComputationMode(
+ FramesComputationMode.COMPUTE_FRAMES_FOR_INSTRUMENTED_METHODS
+ )
+ }
+
+ val androidComponents = project.extensions.getByType(AndroidComponentsExtension::class.java)
+ androidComponents.onVariants { registerTransform(it) }
+ androidComponents.androidTests { registerTransform(it) }
+ androidComponents.unitTests { registerTransform(it) }
+ }
+
+ private fun configureTransform(project: Project, hiltExtension: HiltExtension) {
+ val androidExtension = project.extensions.findByType(BaseExtension::class.java)
+ ?: throw error("Android BaseExtension not found.")
+ androidExtension.registerTransform(AndroidEntryPointTransform())
+
+ // Create and configure a task for applying the transform for host-side unit tests. b/37076369
+ val testedExtensions = project.extensions.findByType(TestedExtension::class.java)
+ testedExtensions?.unitTestVariants?.all { unitTestVariant ->
+ HiltTransformTestClassesTask.create(
+ project = project,
+ unitTestVariant = unitTestVariant,
+ extension = hiltExtension
+ )
+ }
+ }
+
+ private fun configureProcessorFlags(project: Project) {
+ val androidExtension = project.extensions.findByType(BaseExtension::class.java)
+ ?: throw error("Android BaseExtension not found.")
+ // Pass annotation processor flag to disable @AndroidEntryPoint superclass validation.
+ androidExtension.defaultConfig.apply {
+ javaCompileOptions.apply {
+ annotationProcessorOptions.apply {
+ PROCESSOR_OPTIONS.forEach { (key, value) -> argument(key, value) }
+ }
+ }
+ }
+ }
+
+ private fun verifyDependencies(project: Project) {
+ // If project is already failing, skip verification since dependencies might not be resolved.
+ if (project.state.failure != null) {
+ return
+ }
+ val dependencies = project.configurations.flatMap { configuration ->
+ configuration.dependencies.map { dependency -> dependency.group to dependency.name }
+ }
+ if (!dependencies.contains(LIBRARY_GROUP to "hilt-android")) {
+ error(missingDepError("$LIBRARY_GROUP:hilt-android"))
+ }
+ if (!dependencies.contains(LIBRARY_GROUP to "hilt-android-compiler") &&
+ !dependencies.contains(LIBRARY_GROUP to "hilt-compiler")
+ ) {
+ error(missingDepError("$LIBRARY_GROUP:hilt-compiler"))
+ }
+ }
+
+ companion object {
+ val ARTIFACT_TYPE_ATTRIBUTE = Attribute.of("artifactType", String::class.java)
+ const val DAGGER_ARTIFACT_TYPE_VALUE = "jar-for-dagger"
+
+ const val LIBRARY_GROUP = "com.google.dagger"
+ val PROCESSOR_OPTIONS = listOf(
+ "dagger.fastInit" to "enabled",
+ "dagger.hilt.android.internal.disableAndroidSuperclassValidation" to "true"
+ )
+ val missingDepError: (String) -> String = { depCoordinate ->
+ "The Hilt Android Gradle plugin is applied but no $depCoordinate dependency was found."
+ }
+ }
+}
diff --git a/java/dagger/hilt/android/plugin/src/main/kotlin/dagger/hilt/android/plugin/HiltTransformTestClassesTask.kt b/java/dagger/hilt/android/plugin/src/main/kotlin/dagger/hilt/android/plugin/HiltTransformTestClassesTask.kt
new file mode 100644
index 0000000..84b35b1
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/main/kotlin/dagger/hilt/android/plugin/HiltTransformTestClassesTask.kt
@@ -0,0 +1,174 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package dagger.hilt.android.plugin
+
+import com.android.build.gradle.api.UnitTestVariant
+import dagger.hilt.android.plugin.util.isClassFile
+import dagger.hilt.android.plugin.util.isJarFile
+import java.io.File
+import javax.inject.Inject
+import org.gradle.api.Action
+import org.gradle.api.DefaultTask
+import org.gradle.api.Project
+import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.FileCollection
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.Classpath
+import org.gradle.api.tasks.OutputDirectory
+import org.gradle.api.tasks.TaskAction
+import org.gradle.api.tasks.TaskProvider
+import org.gradle.api.tasks.compile.JavaCompile
+import org.gradle.api.tasks.testing.Test
+import org.gradle.workers.WorkAction
+import org.gradle.workers.WorkParameters
+import org.gradle.workers.WorkerExecutor
+import org.jetbrains.kotlin.gradle.plugin.KotlinBasePluginWrapper
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+/**
+ * Task that transform classes used by host-side unit tests. See b/37076369
+ */
+@Suppress("UnstableApiUsage")
+abstract class HiltTransformTestClassesTask @Inject constructor(
+ private val workerExecutor: WorkerExecutor
+) : DefaultTask() {
+
+ @get:Classpath
+ abstract val compiledClasses: ConfigurableFileCollection
+
+ @get:OutputDirectory
+ abstract val outputDir: DirectoryProperty
+
+ internal interface Parameters : WorkParameters {
+ val name: Property<String>
+ val compiledClasses: ConfigurableFileCollection
+ val outputDir: DirectoryProperty
+ }
+
+ abstract class WorkerAction : WorkAction<Parameters> {
+ override fun execute() {
+ val outputDir = parameters.outputDir.asFile.get()
+ outputDir.deleteRecursively()
+ outputDir.mkdirs()
+
+ val allInputs = parameters.compiledClasses.files.toList()
+ val classTransformer = AndroidEntryPointClassTransformer(
+ taskName = parameters.name.get(),
+ allInputs = allInputs,
+ sourceRootOutputDir = outputDir,
+ copyNonTransformed = false
+ )
+ // Parse the classpath in reverse so that we respect overwrites, if it ever happens.
+ allInputs.reversed().forEach {
+ if (it.isDirectory) {
+ it.walkTopDown().forEach { file ->
+ if (file.isClassFile()) {
+ classTransformer.transformFile(file)
+ }
+ }
+ } else if (it.isJarFile()) {
+ classTransformer.transformJarContents(it)
+ }
+ }
+ }
+ }
+
+ @TaskAction
+ fun transformClasses() {
+ workerExecutor.noIsolation().submit(WorkerAction::class.java) {
+ it.compiledClasses.from(compiledClasses)
+ it.outputDir.set(outputDir)
+ it.name.set(name)
+ }
+ }
+
+ internal class ConfigAction(
+ private val outputDir: File,
+ private val inputClasspath: FileCollection
+ ) : Action<HiltTransformTestClassesTask> {
+ override fun execute(transformTask: HiltTransformTestClassesTask) {
+ transformTask.description = "Transforms AndroidEntryPoint annotated classes for JUnit tests."
+ transformTask.outputDir.set(outputDir)
+ transformTask.compiledClasses.from(inputClasspath)
+ }
+ }
+
+ companion object {
+
+ private const val TASK_PREFIX = "hiltTransformFor"
+
+ fun create(
+ project: Project,
+ unitTestVariant: UnitTestVariant,
+ extension: HiltExtension
+ ) {
+ if (!extension.enableTransformForLocalTests) {
+ // Not enabled, nothing to do here.
+ return
+ }
+
+ // TODO(danysantiago): Only use project compiled sources as input, and not all dependency jars
+ // Using 'null' key to obtain the full compile classpath since we are not using the
+ // registerPreJavacGeneratedBytecode() API that would have otherwise given us a key to get
+ // a classpath up to the generated bytecode associated with the key.
+ val inputClasspath =
+ project.objects.fileCollection().from(unitTestVariant.getCompileClasspath(null))
+
+ // Find the test sources Java compile task and add its output directory into our input
+ // classpath file collection. This also makes the transform task depend on the test compile
+ // task.
+ @Suppress("UNCHECKED_CAST")
+ val testCompileTaskProvider = project.tasks.named(
+ "compile${unitTestVariant.name.capitalize()}JavaWithJavac"
+ ) as TaskProvider<JavaCompile>
+ inputClasspath.from(testCompileTaskProvider.map { it.destinationDirectory })
+
+ // Similarly, if the Kotlin plugin is configured, find the test sources Kotlin compile task
+ // and add its output directory to our input classpath file collection.
+ project.plugins.withType(KotlinBasePluginWrapper::class.java) {
+ @Suppress("UNCHECKED_CAST")
+ val kotlinCompileTaskProvider = project.tasks.named(
+ "compile${unitTestVariant.name.capitalize()}Kotlin"
+ ) as TaskProvider<KotlinCompile>
+ inputClasspath.from(kotlinCompileTaskProvider.map { it.destinationDirectory })
+ }
+
+ // Create and configure the transform task.
+ val outputDir =
+ project.buildDir.resolve("intermediates/hilt/${unitTestVariant.dirName}Output")
+ val hiltTransformProvider = project.tasks.register(
+ "$TASK_PREFIX${unitTestVariant.name.capitalize()}",
+ HiltTransformTestClassesTask::class.java,
+ ConfigAction(outputDir, inputClasspath)
+ )
+ // Map the transform task's output to a file collection.
+ val outputFileCollection =
+ project.objects.fileCollection().from(hiltTransformProvider.map { it.outputDir })
+
+ // Configure test classpath by appending the transform output file collection to the start of
+ // the test classpath so they override the original ones. This also makes test task (the one
+ // that runs the tests) depend on the transform task.
+ @Suppress("UNCHECKED_CAST")
+ val testTaskProvider = project.tasks.named(
+ "test${unitTestVariant.name.capitalize()}"
+ ) as TaskProvider<Test>
+ testTaskProvider.configure {
+ it.classpath = outputFileCollection + it.classpath
+ }
+ }
+ }
+}
diff --git a/java/dagger/hilt/android/plugin/src/main/kotlin/dagger/hilt/android/plugin/util/CopyTransform.kt b/java/dagger/hilt/android/plugin/src/main/kotlin/dagger/hilt/android/plugin/util/CopyTransform.kt
new file mode 100644
index 0000000..39a2d3a
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/main/kotlin/dagger/hilt/android/plugin/util/CopyTransform.kt
@@ -0,0 +1,29 @@
+package dagger.hilt.android.plugin.util
+
+import org.gradle.api.artifacts.transform.CacheableTransform
+import org.gradle.api.artifacts.transform.InputArtifact
+import org.gradle.api.artifacts.transform.TransformAction
+import org.gradle.api.artifacts.transform.TransformOutputs
+import org.gradle.api.artifacts.transform.TransformParameters
+import org.gradle.api.file.FileSystemLocation
+import org.gradle.api.provider.Provider
+import org.gradle.api.tasks.Classpath
+
+// A transform that registers the input jar file as an output and thus changing from one artifact
+// type to another.
+// TODO: Improve to only copy classes that need to be visible by Hilt & Dagger.
+@CacheableTransform
+abstract class CopyTransform : TransformAction<TransformParameters.None> {
+ @get:Classpath
+ @get:InputArtifact
+ abstract val inputArtifactProvider: Provider<FileSystemLocation>
+
+ override fun transform(outputs: TransformOutputs) {
+ val input = inputArtifactProvider.get().asFile
+ when {
+ input.isDirectory -> outputs.dir(input)
+ input.isFile -> outputs.file(input)
+ else -> error("File/directory does not exist: ${input.absolutePath}")
+ }
+ }
+}
diff --git a/java/dagger/hilt/android/plugin/src/main/kotlin/dagger/hilt/android/plugin/util/Files.kt b/java/dagger/hilt/android/plugin/src/main/kotlin/dagger/hilt/android/plugin/util/Files.kt
new file mode 100644
index 0000000..e5a101e
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/main/kotlin/dagger/hilt/android/plugin/util/Files.kt
@@ -0,0 +1,14 @@
+package dagger.hilt.android.plugin.util
+
+import com.android.SdkConstants
+import java.io.File
+import java.util.zip.ZipEntry
+
+/* Checks if a file is a .class file. */
+fun File.isClassFile() = this.isFile && this.extension == SdkConstants.EXT_CLASS
+
+/* Checks if a Zip entry is a .class file. */
+fun ZipEntry.isClassFile() = !this.isDirectory && this.name.endsWith(SdkConstants.DOT_CLASS)
+
+/* CHecks if a file is a .jar file. */
+fun File.isJarFile() = this.isFile && this.extension == SdkConstants.EXT_JAR
diff --git a/java/dagger/hilt/android/plugin/src/main/kotlin/dagger/hilt/android/plugin/util/SimpleAGPVersion.kt b/java/dagger/hilt/android/plugin/src/main/kotlin/dagger/hilt/android/plugin/util/SimpleAGPVersion.kt
new file mode 100644
index 0000000..1580431
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/main/kotlin/dagger/hilt/android/plugin/util/SimpleAGPVersion.kt
@@ -0,0 +1,41 @@
+package dagger.hilt.android.plugin.util
+
+import com.android.Version
+
+/**
+ * Simple Android Gradle Plugin version class since there is no public API one. b/175816217
+ */
+internal data class SimpleAGPVersion(
+ val major: Int,
+ val minor: Int,
+) : Comparable<SimpleAGPVersion> {
+
+ override fun compareTo(other: SimpleAGPVersion): Int {
+ return compareValuesBy(
+ this,
+ other,
+ compareBy(SimpleAGPVersion::major).thenBy(SimpleAGPVersion::minor)
+ ) { it }
+ }
+
+ companion object {
+
+ val ANDROID_GRADLE_PLUGIN_VERSION by lazy { parse(Version.ANDROID_GRADLE_PLUGIN_VERSION) }
+
+ fun parse(version: String?) =
+ tryParse(version) ?: error("Unable to parse AGP version: $version")
+
+ private fun tryParse(version: String?): SimpleAGPVersion? {
+ if (version == null) {
+ return null
+ }
+
+ val parts = version.split('.')
+ if (parts.size == 1) {
+ return SimpleAGPVersion(parts[0].toInt(), 0)
+ }
+
+ return SimpleAGPVersion(parts[0].toInt(), parts[1].toInt())
+ }
+ }
+}
diff --git a/java/dagger/hilt/android/plugin/src/main/resources/META-INF/gradle-plugins/dagger.hilt.android.plugin.properties b/java/dagger/hilt/android/plugin/src/main/resources/META-INF/gradle-plugins/dagger.hilt.android.plugin.properties
new file mode 100644
index 0000000..5d2b9df
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/main/resources/META-INF/gradle-plugins/dagger.hilt.android.plugin.properties
@@ -0,0 +1 @@
+implementation-class=dagger.hilt.android.plugin.HiltGradlePlugin
\ No newline at end of file
diff --git a/java/dagger/hilt/android/plugin/src/test/data/android-libraryA/build.gradle b/java/dagger/hilt/android/plugin/src/test/data/android-libraryA/build.gradle
new file mode 100644
index 0000000..e2d2a7b
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/test/data/android-libraryA/build.gradle
@@ -0,0 +1,28 @@
+plugins {
+ id 'com.android.library'
+ id 'dagger.hilt.android.plugin'
+}
+
+android {
+ compileSdkVersion 30
+ buildToolsVersion "30.0.2"
+
+ defaultConfig {
+ minSdkVersion 21
+ targetSdkVersion 30
+ versionCode 1
+ versionName "1.0"
+ }
+ compileOptions {
+ sourceCompatibility 1.8
+ targetCompatibility 1.8
+ }
+}
+
+dependencies {
+ implementation 'com.google.dagger:hilt-android:LOCAL-SNAPSHOT'
+ annotationProcessor 'com.google.dagger:hilt-compiler:LOCAL-SNAPSHOT'
+
+ implementation project(':libraryB')
+ implementation project(':libraryC')
+}
\ No newline at end of file
diff --git a/java/dagger/hilt/android/plugin/src/test/data/android-libraryA/src/main/AndroidManifest.xml b/java/dagger/hilt/android/plugin/src/test/data/android-libraryA/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..e704d4a
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/test/data/android-libraryA/src/main/AndroidManifest.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="liba">
+</manifest>
\ No newline at end of file
diff --git a/java/dagger/hilt/android/plugin/src/test/data/android-libraryA/src/main/java/liba/LibraryA.java b/java/dagger/hilt/android/plugin/src/test/data/android-libraryA/src/main/java/liba/LibraryA.java
new file mode 100644
index 0000000..95e9356
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/test/data/android-libraryA/src/main/java/liba/LibraryA.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package liba;
+
+import javax.inject.Inject;
+import libb.LibraryB;
+import libc.LibraryC;
+
+/** Test LibA */
+public class LibraryA {
+ @Inject
+ public LibraryA(LibraryB b, LibraryC c) {}
+}
diff --git a/java/dagger/hilt/android/plugin/src/test/data/android-libraryC/build.gradle b/java/dagger/hilt/android/plugin/src/test/data/android-libraryC/build.gradle
new file mode 100644
index 0000000..3031528
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/test/data/android-libraryC/build.gradle
@@ -0,0 +1,25 @@
+plugins {
+ id 'com.android.library'
+ id 'dagger.hilt.android.plugin'
+}
+
+android {
+ compileSdkVersion 30
+ buildToolsVersion "30.0.2"
+
+ defaultConfig {
+ minSdkVersion 21
+ targetSdkVersion 30
+ versionCode 1
+ versionName "1.0"
+ }
+ compileOptions {
+ sourceCompatibility 1.8
+ targetCompatibility 1.8
+ }
+}
+
+dependencies {
+ implementation 'com.google.dagger:hilt-android:LOCAL-SNAPSHOT'
+ annotationProcessor 'com.google.dagger:hilt-compiler:LOCAL-SNAPSHOT'
+}
\ No newline at end of file
diff --git a/java/dagger/hilt/android/plugin/src/test/data/android-libraryC/src/main/AndroidManifest.xml b/java/dagger/hilt/android/plugin/src/test/data/android-libraryC/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..a4967e3
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/test/data/android-libraryC/src/main/AndroidManifest.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="libc">
+</manifest>
\ No newline at end of file
diff --git a/java/dagger/hilt/android/plugin/src/test/data/android-libraryC/src/main/java/libc/LibraryC.java b/java/dagger/hilt/android/plugin/src/test/data/android-libraryC/src/main/java/libc/LibraryC.java
new file mode 100644
index 0000000..f7397fc
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/test/data/android-libraryC/src/main/java/libc/LibraryC.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package libc;
+
+import javax.inject.Inject;
+
+/** Test LibC */
+public class LibraryC {
+ @Inject
+ public LibraryC() {}
+}
diff --git a/java/dagger/hilt/android/plugin/src/test/data/java-libraryA/build.gradle b/java/dagger/hilt/android/plugin/src/test/data/java-libraryA/build.gradle
new file mode 100644
index 0000000..dde8858
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/test/data/java-libraryA/build.gradle
@@ -0,0 +1,15 @@
+plugins {
+ id 'java-library'
+}
+
+java {
+ sourceCompatibility = JavaVersion.VERSION_1_8
+ targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+dependencies {
+ implementation 'com.google.dagger:hilt-core:LOCAL-SNAPSHOT'
+ annotationProcessor 'com.google.dagger:hilt-compiler:LOCAL-SNAPSHOT'
+
+ implementation project(':libraryB')
+}
\ No newline at end of file
diff --git a/java/dagger/hilt/android/plugin/src/test/data/java-libraryA/src/main/java/liba/LibraryA.java b/java/dagger/hilt/android/plugin/src/test/data/java-libraryA/src/main/java/liba/LibraryA.java
new file mode 100644
index 0000000..afc0da2
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/test/data/java-libraryA/src/main/java/liba/LibraryA.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package liba;
+
+import javax.inject.Inject;
+import libb.LibraryBProvided;
+
+/** Test LibA */
+public class LibraryA {
+ @Inject
+ public LibraryA(LibraryBProvided b) {}
+}
diff --git a/java/dagger/hilt/android/plugin/src/test/data/java-libraryB/build.gradle b/java/dagger/hilt/android/plugin/src/test/data/java-libraryB/build.gradle
new file mode 100644
index 0000000..55780cc
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/test/data/java-libraryB/build.gradle
@@ -0,0 +1,13 @@
+plugins {
+ id 'java-library'
+}
+
+java {
+ sourceCompatibility = JavaVersion.VERSION_1_8
+ targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+dependencies {
+ implementation 'com.google.dagger:hilt-core:LOCAL-SNAPSHOT'
+ annotationProcessor 'com.google.dagger:hilt-compiler:LOCAL-SNAPSHOT'
+}
\ No newline at end of file
diff --git a/java/dagger/hilt/android/plugin/src/test/data/java-libraryB/src/main/java/libb/LibraryB.java b/java/dagger/hilt/android/plugin/src/test/data/java-libraryB/src/main/java/libb/LibraryB.java
new file mode 100644
index 0000000..285d5ba
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/test/data/java-libraryB/src/main/java/libb/LibraryB.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package libb;
+
+import javax.inject.Inject;
+
+/** Test LibB */
+public class LibraryB {
+ @Inject
+ public LibraryB() {}
+}
diff --git a/java/dagger/hilt/android/plugin/src/test/data/java-libraryB/src/main/java/libb/LibraryBModule.java b/java/dagger/hilt/android/plugin/src/test/data/java-libraryB/src/main/java/libb/LibraryBModule.java
new file mode 100644
index 0000000..d1c08f0
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/test/data/java-libraryB/src/main/java/libb/LibraryBModule.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package libb;
+
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.components.SingletonComponent;
+
+/** Test LibB Module */
+@Module
+@InstallIn(SingletonComponent.class)
+public final class LibraryBModule {
+ @Provides
+ public static LibraryBProvided provideB() {
+ return new LibraryBProvided();
+ }
+}
diff --git a/java/dagger/hilt/android/plugin/src/test/data/java-libraryB/src/main/java/libb/LibraryBProvided.java b/java/dagger/hilt/android/plugin/src/test/data/java-libraryB/src/main/java/libb/LibraryBProvided.java
new file mode 100644
index 0000000..b472bfb
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/test/data/java-libraryB/src/main/java/libb/LibraryBProvided.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package libb;
+
+/** Test LibB Provided */
+public class LibraryBProvided {}
diff --git a/java/dagger/hilt/android/plugin/src/test/data/simple-project/gradle.properties b/java/dagger/hilt/android/plugin/src/test/data/simple-project/gradle.properties
new file mode 100644
index 0000000..5bac8ac
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/test/data/simple-project/gradle.properties
@@ -0,0 +1 @@
+android.useAndroidX=true
diff --git a/java/dagger/hilt/android/plugin/src/test/data/simple-project/src/main/AndroidManifest.xml b/java/dagger/hilt/android/plugin/src/test/data/simple-project/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..29060e0
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/test/data/simple-project/src/main/AndroidManifest.xml
@@ -0,0 +1,18 @@
+<!--
+ ~ Copyright (C) 2020 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="simple">
+</manifest>
\ No newline at end of file
diff --git a/java/dagger/hilt/android/plugin/src/test/data/simple-project/src/main/java/simple/Activity1.java b/java/dagger/hilt/android/plugin/src/test/data/simple-project/src/main/java/simple/Activity1.java
new file mode 100644
index 0000000..a6e5d93
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/test/data/simple-project/src/main/java/simple/Activity1.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package simple;
+
+import androidx.appcompat.app.AppCompatActivity;
+import dagger.hilt.android.AndroidEntryPoint;
+import javax.inject.Inject;
+
+/** Just an activity. */
+@AndroidEntryPoint(AppCompatActivity.class)
+public class Activity1 extends Hilt_Activity1 {
+ @Inject String data;
+
+ // Insert-change
+}
diff --git a/java/dagger/hilt/android/plugin/src/test/data/simple-project/src/main/java/simple/Activity2.java b/java/dagger/hilt/android/plugin/src/test/data/simple-project/src/main/java/simple/Activity2.java
new file mode 100644
index 0000000..f7793be
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/test/data/simple-project/src/main/java/simple/Activity2.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package simple;
+
+import androidx.appcompat.app.AppCompatActivity;
+import dagger.hilt.android.AndroidEntryPoint;
+import javax.inject.Inject;
+
+/** Just an activity. */
+@AndroidEntryPoint(AppCompatActivity.class)
+public class Activity2 extends Hilt_Activity2 {
+ @Inject String data;
+
+ // Insert-change
+}
diff --git a/java/dagger/hilt/android/plugin/src/test/data/simple-project/src/main/java/simple/Module1.java b/java/dagger/hilt/android/plugin/src/test/data/simple-project/src/main/java/simple/Module1.java
new file mode 100644
index 0000000..d3297c3
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/test/data/simple-project/src/main/java/simple/Module1.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package simple;
+
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityComponent;
+
+/** Just a module. */
+@Module
+@InstallIn(ActivityComponent.class)
+public class Module1 {
+
+ @Provides
+ static String provideData() {
+ return "010101";
+ }
+
+ // Insert-change
+
+}
diff --git a/java/dagger/hilt/android/plugin/src/test/data/simple-project/src/main/java/simple/Module2.java b/java/dagger/hilt/android/plugin/src/test/data/simple-project/src/main/java/simple/Module2.java
new file mode 100644
index 0000000..dd23236
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/test/data/simple-project/src/main/java/simple/Module2.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package simple;
+
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityComponent;
+
+/** Just a module. */
+@Module
+@InstallIn(ActivityComponent.class)
+public class Module2 {
+
+ @Provides
+ static int provideData() {
+ return 0x010101;
+ }
+
+ // Insert-change
+
+}
diff --git a/java/dagger/hilt/android/plugin/src/test/data/simple-project/src/main/java/simple/SimpleApp.java b/java/dagger/hilt/android/plugin/src/test/data/simple-project/src/main/java/simple/SimpleApp.java
new file mode 100644
index 0000000..5a92241
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/test/data/simple-project/src/main/java/simple/SimpleApp.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package simple;
+
+import android.app.Application;
+import dagger.hilt.android.HiltAndroidApp;
+
+/** Just an application. */
+@HiltAndroidApp(Application.class)
+public class SimpleApp extends Hilt_SimpleApp {
+ // Insert-change
+}
diff --git a/java/dagger/hilt/android/plugin/src/test/kotlin/CompileClasspathTest.kt b/java/dagger/hilt/android/plugin/src/test/kotlin/CompileClasspathTest.kt
new file mode 100644
index 0000000..6141250
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/test/kotlin/CompileClasspathTest.kt
@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.io.File
+import org.gradle.testkit.runner.TaskOutcome
+import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+
+class CompileClasspathTest {
+ @get:Rule
+ val testProjectDir = TemporaryFolder()
+
+ lateinit var gradleRunner: GradleTestRunner
+
+ @Before
+ fun setup() {
+ gradleRunner = GradleTestRunner(testProjectDir)
+ gradleRunner.addAndroidOption(
+ "lintOptions.checkReleaseBuilds = false"
+ )
+ gradleRunner.addHiltOption(
+ "enableExperimentalClasspathAggregation = true"
+ )
+ gradleRunner.addDependencies(
+ "implementation 'androidx.appcompat:appcompat:1.1.0'",
+ "implementation 'com.google.dagger:hilt-android:LOCAL-SNAPSHOT'",
+ "annotationProcessor 'com.google.dagger:hilt-compiler:LOCAL-SNAPSHOT'",
+ "implementation project(':libraryA')",
+ )
+ gradleRunner.addSrc(
+ srcPath = "minimal/MyApp.java",
+ srcContent =
+ """
+ package minimal;
+
+ import android.app.Application;
+ import liba.LibraryA;
+
+ @dagger.hilt.android.HiltAndroidApp
+ public class MyApp extends Application {
+ @javax.inject.Inject
+ LibraryA libraryA;
+ }
+ """.trimIndent()
+ )
+ gradleRunner.setAppClassName(".MyApp")
+ }
+
+ // Verifies that library B and library C injected classes are available in the root classpath.
+ @Test
+ fun test_injectClasses() {
+ File("src/test/data/android-libraryA")
+ .copyRecursively(File(testProjectDir.root, "libraryA"))
+ File("src/test/data/java-libraryB")
+ .copyRecursively(File(testProjectDir.root, "libraryB"))
+ File("src/test/data/android-libraryC")
+ .copyRecursively(File(testProjectDir.root, "libraryC"))
+
+ testProjectDir.newFile("settings.gradle").apply {
+ writeText(
+ """
+ include ':libraryA'
+ include ':libraryB'
+ include ':libraryC'
+ """.trimIndent()
+ )
+ }
+
+ val result = gradleRunner.build()
+ val assembleTask = result.getTask(":assembleDebug")
+ assertEquals(TaskOutcome.SUCCESS, assembleTask.outcome)
+ }
+
+ // Verifies that library B Hilt module is available in the root classpath.
+ @Test
+ fun test_injectClassesFromModules() {
+ File("src/test/data/java-libraryA")
+ .copyRecursively(File(testProjectDir.root, "libraryA"))
+ File("src/test/data/java-libraryB")
+ .copyRecursively(File(testProjectDir.root, "libraryB"))
+
+ testProjectDir.newFile("settings.gradle").apply {
+ writeText(
+ """
+ include ':libraryA'
+ include ':libraryB'
+ """.trimIndent()
+ )
+ }
+
+ val result = gradleRunner.build()
+ val assembleTask = result.getTask(":assembleDebug")
+ assertEquals(TaskOutcome.SUCCESS, assembleTask.outcome)
+ }
+}
diff --git a/java/dagger/hilt/android/plugin/src/test/kotlin/GradleTestRunner.kt b/java/dagger/hilt/android/plugin/src/test/kotlin/GradleTestRunner.kt
new file mode 100644
index 0000000..2d58766
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/test/kotlin/GradleTestRunner.kt
@@ -0,0 +1,214 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.io.File
+import org.gradle.testkit.runner.BuildResult
+import org.gradle.testkit.runner.GradleRunner
+import org.junit.rules.TemporaryFolder
+
+/**
+ * Testing utility class that sets up a simple Android project that applies the Hilt plugin.
+ */
+class GradleTestRunner(val tempFolder: TemporaryFolder) {
+ private val dependencies = mutableListOf<String>()
+ private val activities = mutableListOf<String>()
+ private val additionalAndroidOptions = mutableListOf<String>()
+ private val hiltOptions = mutableListOf<String>()
+ private var appClassName: String? = null
+ private var buildFile: File? = null
+ private var gradlePropertiesFile: File? = null
+ private var manifestFile: File? = null
+
+ init {
+ tempFolder.newFolder("src", "main", "java", "minimal")
+ tempFolder.newFolder("src", "main", "res")
+ }
+
+ // Adds project dependencies, e.g. "implementation <group>:<id>:<version>"
+ fun addDependencies(vararg deps: String) {
+ dependencies.addAll(deps)
+ }
+
+ // Adds an <activity> tag in the project's Android Manifest, e.g. "<activity name=".Foo"/>
+ fun addActivities(vararg activityElements: String) {
+ activities.addAll(activityElements)
+ }
+
+ // Adds 'android' options to the project's build.gradle, e.g. "lintOptions.checkReleaseBuilds = false"
+ fun addAndroidOption(vararg options: String) {
+ additionalAndroidOptions.addAll(options)
+ }
+
+ // Adds 'hilt' options to the project's build.gradle, e.g. "enableExperimentalClasspathAggregation = true"
+ fun addHiltOption(vararg options: String) {
+ hiltOptions.addAll(options)
+ }
+
+ // Adds a source package to the project. The package path is relative to 'src/main/java'.
+ fun addSrcPackage(packagePath: String) {
+ File(tempFolder.root, "src/main/java/$packagePath").mkdirs()
+ }
+
+ // Adds a source file to the project. The source path is relative to 'src/main/java'.
+ fun addSrc(srcPath: String, srcContent: String): File {
+ File(tempFolder.root, "src/main/java/${srcPath.substringBeforeLast(File.separator)}").mkdirs()
+ return tempFolder.newFile("/src/main/java/$srcPath").apply { writeText(srcContent) }
+ }
+
+ // Adds a resource file to the project. The source path is relative to 'src/main/res'.
+ fun addRes(resPath: String, resContent: String): File {
+ File(tempFolder.root, "src/main/res/${resPath.substringBeforeLast(File.separator)}").mkdirs()
+ return tempFolder.newFile("/src/main/res/$resPath").apply { writeText(resContent) }
+ }
+
+ fun setAppClassName(name: String) {
+ appClassName = name
+ }
+
+ // Executes a Gradle builds and expects it to succeed.
+ fun build(): Result {
+ setupFiles()
+ return Result(tempFolder.root, createRunner().build())
+ }
+
+ // Executes a Gradle build and expects it to fail.
+ fun buildAndFail(): Result {
+ setupFiles()
+ return Result(tempFolder.root, createRunner().buildAndFail())
+ }
+
+ private fun setupFiles() {
+ writeBuildFile()
+ writeGradleProperties()
+ writeAndroidManifest()
+ }
+
+ private fun writeBuildFile() {
+ buildFile?.delete()
+ buildFile = tempFolder.newFile("build.gradle").apply {
+ writeText(
+ """
+ buildscript {
+ repositories {
+ google()
+ jcenter()
+ }
+ dependencies {
+ classpath 'com.android.tools.build:gradle:4.2.0-beta04'
+ }
+ }
+
+ plugins {
+ id 'com.android.application'
+ id 'dagger.hilt.android.plugin'
+ }
+
+ android {
+ compileSdkVersion 30
+ buildToolsVersion "30.0.2"
+
+ defaultConfig {
+ applicationId "plugin.test"
+ minSdkVersion 21
+ targetSdkVersion 30
+ }
+
+ compileOptions {
+ sourceCompatibility 1.8
+ targetCompatibility 1.8
+ }
+ ${additionalAndroidOptions.joinToString(separator = "\n")}
+ }
+
+ allprojects {
+ repositories {
+ mavenLocal()
+ google()
+ jcenter()
+ }
+ }
+
+ dependencies {
+ ${dependencies.joinToString(separator = "\n")}
+ }
+
+ hilt {
+ ${hiltOptions.joinToString(separator = "\n")}
+ }
+ """.trimIndent()
+ )
+ }
+ }
+
+ private fun writeGradleProperties() {
+ gradlePropertiesFile?.delete()
+ gradlePropertiesFile = tempFolder.newFile("gradle.properties").apply {
+ writeText(
+ """
+ android.useAndroidX=true
+ """.trimIndent()
+ )
+ }
+ }
+
+ private fun writeAndroidManifest() {
+ manifestFile?.delete()
+ manifestFile = tempFolder.newFile("/src/main/AndroidManifest.xml").apply {
+ writeText(
+ """
+ <?xml version="1.0" encoding="utf-8"?>
+ <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="minimal">
+ <application
+ android:name="${appClassName ?: "android.app.Application"}"
+ android:theme="@style/Theme.AppCompat.Light.DarkActionBar">
+ ${activities.joinToString(separator = "\n")}
+ </application>
+ </manifest>
+ """.trimIndent()
+ )
+ }
+ }
+
+ private fun createRunner() = GradleRunner.create()
+ .withProjectDir(tempFolder.root)
+ .withArguments("assembleDebug", "--stacktrace")
+ .withPluginClasspath()
+// .withDebug(true) // Add this line to enable attaching a debugger to the gradle test invocation
+ .forwardOutput()
+
+ // Data class representing a Gradle Test run result.
+ data class Result(
+ private val projectRoot: File,
+ private val buildResult: BuildResult
+ ) {
+ // Finds a task by name.
+ fun getTask(name: String) = buildResult.task(name) ?: error("Task '$name' not found.")
+
+ // Gets the full build output.
+ fun getOutput() = buildResult.output
+
+ // Finds a transformed file. The srcFilePath is relative to the app's package.
+ fun getTransformedFile(srcFilePath: String): File {
+ val parentDir =
+ File(projectRoot, "build/intermediates/asm_instrumented_project_classes/debug")
+ return File(parentDir, srcFilePath).also {
+ if (!it.exists()) {
+ error("Unable to find transformed class ${it.path}")
+ }
+ }
+ }
+ }
+}
diff --git a/java/dagger/hilt/android/plugin/src/test/kotlin/HiltGradlePluginTest.kt b/java/dagger/hilt/android/plugin/src/test/kotlin/HiltGradlePluginTest.kt
new file mode 100644
index 0000000..f256985
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/test/kotlin/HiltGradlePluginTest.kt
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+
+/**
+ * Functional test of the plugin
+ *
+ * To run these tests first deploy artifacts to local maven via util/install-local-snapshot.sh.
+ */
+class HiltGradlePluginTest {
+
+ @get:Rule
+ val testProjectDir = TemporaryFolder()
+
+ lateinit var gradleRunner: GradleTestRunner
+
+ @Before
+ fun setup() {
+ gradleRunner = GradleTestRunner(testProjectDir)
+ }
+
+ // Verify plugin configuration fails when runtime dependency is missing but plugin is applied.
+ @Test
+ fun test_missingLibraryDep() {
+ gradleRunner.addDependencies(
+ "implementation 'androidx.appcompat:appcompat:1.1.0'"
+ )
+
+ val result = gradleRunner.buildAndFail()
+ assertThat(result.getOutput()).contains(
+ "The Hilt Android Gradle plugin is applied but no " +
+ "com.google.dagger:hilt-android dependency was found."
+ )
+ }
+
+ // Verify plugin configuration fails when compiler dependency is missing but plugin is applied.
+ @Test
+ fun test_missingCompilerDep() {
+ gradleRunner.addDependencies(
+ "implementation 'androidx.appcompat:appcompat:1.1.0'",
+ "implementation 'com.google.dagger:hilt-android:LOCAL-SNAPSHOT'"
+ )
+
+ val result = gradleRunner.buildAndFail()
+ assertThat(result.getOutput()).contains(
+ "The Hilt Android Gradle plugin is applied but no " +
+ "com.google.dagger:hilt-compiler dependency was found."
+ )
+ }
+}
diff --git a/java/dagger/hilt/android/plugin/src/test/kotlin/IncrementalProcessorTest.kt b/java/dagger/hilt/android/plugin/src/test/kotlin/IncrementalProcessorTest.kt
new file mode 100644
index 0000000..a003ab5
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/test/kotlin/IncrementalProcessorTest.kt
@@ -0,0 +1,615 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import com.google.common.truth.Expect
+import java.io.File
+import org.gradle.testkit.runner.BuildResult
+import org.gradle.testkit.runner.GradleRunner
+import org.gradle.testkit.runner.TaskOutcome
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+
+/**
+ * Tests to verify Gradle annotation processor incremental compilation.
+ *
+ * To run these tests first deploy artifacts to local maven via util/install-local-snapshot.sh.
+ */
+class IncrementalProcessorTest {
+
+ @get:Rule
+ val testProjectDir = TemporaryFolder()
+
+ @get:Rule
+ val expect: Expect = Expect.create()
+
+ // Original source files
+ private lateinit var srcApp: File
+ private lateinit var srcActivity1: File
+ private lateinit var srcActivity2: File
+ private lateinit var srcModule1: File
+ private lateinit var srcModule2: File
+
+ // Generated source files
+ private lateinit var genHiltApp: File
+ private lateinit var genHiltActivity1: File
+ private lateinit var genHiltActivity2: File
+ private lateinit var genAppInjector: File
+ private lateinit var genActivityInjector1: File
+ private lateinit var genActivityInjector2: File
+ private lateinit var genAppInjectorDeps: File
+ private lateinit var genActivityInjectorDeps1: File
+ private lateinit var genActivityInjectorDeps2: File
+ private lateinit var genModuleDeps1: File
+ private lateinit var genModuleDeps2: File
+ private lateinit var genHiltComponents: File
+ private lateinit var genDaggerHiltApplicationComponent: File
+
+ // Compiled classes
+ private lateinit var classSrcApp: File
+ private lateinit var classSrcActivity1: File
+ private lateinit var classSrcActivity2: File
+ private lateinit var classSrcModule1: File
+ private lateinit var classSrcModule2: File
+ private lateinit var classGenHiltApp: File
+ private lateinit var classGenHiltActivity1: File
+ private lateinit var classGenHiltActivity2: File
+ private lateinit var classGenAppInjector: File
+ private lateinit var classGenActivityInjector1: File
+ private lateinit var classGenActivityInjector2: File
+ private lateinit var classGenAppInjectorDeps: File
+ private lateinit var classGenActivityInjectorDeps1: File
+ private lateinit var classGenActivityInjectorDeps2: File
+ private lateinit var classGenModuleDeps1: File
+ private lateinit var classGenModuleDeps2: File
+ private lateinit var classGenHiltComponents: File
+ private lateinit var classGenDaggerHiltApplicationComponent: File
+
+ // Timestamps of files
+ private lateinit var fileToTimestampMap: Map<File, Long>
+
+ // Sets of files that have changed/not changed/deleted
+ private lateinit var changedFiles: Set<File>
+ private lateinit var unchangedFiles: Set<File>
+ private lateinit var deletedFiles: Set<File>
+
+ @Before
+ fun setup() {
+ val projectRoot = testProjectDir.root
+ // copy test project
+ File("src/test/data/simple-project").copyRecursively(projectRoot)
+
+ // set up build file
+ File(projectRoot, "build.gradle").writeText(
+ """
+ buildscript {
+ repositories {
+ google()
+ jcenter()
+ }
+ dependencies {
+ classpath 'com.android.tools.build:gradle:3.5.3'
+ }
+ }
+
+ plugins {
+ id 'com.android.application'
+ }
+
+ android {
+ compileSdkVersion 30
+ buildToolsVersion "30.0.2"
+
+ defaultConfig {
+ applicationId "hilt.simple"
+ minSdkVersion 21
+ targetSdkVersion 30
+ }
+
+ compileOptions {
+ sourceCompatibility 1.8
+ targetCompatibility 1.8
+ }
+ }
+
+ repositories {
+ mavenLocal()
+ google()
+ jcenter()
+ }
+
+ dependencies {
+ implementation 'androidx.appcompat:appcompat:1.1.0'
+ implementation 'com.google.dagger:dagger:LOCAL-SNAPSHOT'
+ annotationProcessor 'com.google.dagger:dagger-compiler:LOCAL-SNAPSHOT'
+ implementation 'com.google.dagger:hilt-android:LOCAL-SNAPSHOT'
+ annotationProcessor 'com.google.dagger:hilt-compiler:LOCAL-SNAPSHOT'
+ }
+ """.trimIndent()
+ )
+
+ // Compute file paths
+ srcApp = File(projectRoot, "$SRC_DIR/simple/SimpleApp.java")
+ srcActivity1 = File(projectRoot, "$SRC_DIR/simple/Activity1.java")
+ srcActivity2 = File(projectRoot, "$SRC_DIR/simple/Activity2.java")
+ srcModule1 = File(projectRoot, "$SRC_DIR/simple/Module1.java")
+ srcModule2 = File(projectRoot, "$SRC_DIR/simple/Module2.java")
+
+ genHiltApp = File(projectRoot, "$GEN_SRC_DIR/simple/Hilt_SimpleApp.java")
+ genHiltActivity1 = File(projectRoot, "$GEN_SRC_DIR/simple/Hilt_Activity1.java")
+ genHiltActivity2 = File(projectRoot, "$GEN_SRC_DIR/simple/Hilt_Activity2.java")
+ genAppInjector = File(projectRoot, "$GEN_SRC_DIR/simple/SimpleApp_GeneratedInjector.java")
+ genActivityInjector1 = File(projectRoot, "$GEN_SRC_DIR/simple/Activity1_GeneratedInjector.java")
+ genActivityInjector2 = File(projectRoot, "$GEN_SRC_DIR/simple/Activity2_GeneratedInjector.java")
+ genAppInjectorDeps = File(
+ projectRoot,
+ "$GEN_SRC_DIR/hilt_aggregated_deps/simple_SimpleApp_GeneratedInjectorModuleDeps.java"
+ )
+ genActivityInjectorDeps1 = File(
+ projectRoot,
+ "$GEN_SRC_DIR/hilt_aggregated_deps/simple_Activity1_GeneratedInjectorModuleDeps.java"
+ )
+ genActivityInjectorDeps2 = File(
+ projectRoot,
+ "$GEN_SRC_DIR/hilt_aggregated_deps/simple_Activity2_GeneratedInjectorModuleDeps.java"
+ )
+ genModuleDeps1 = File(
+ projectRoot,
+ "$GEN_SRC_DIR/hilt_aggregated_deps/simple_Module1ModuleDeps.java"
+ )
+ genModuleDeps2 = File(
+ projectRoot,
+ "$GEN_SRC_DIR/hilt_aggregated_deps/simple_Module2ModuleDeps.java"
+ )
+ genHiltComponents = File(
+ projectRoot,
+ "$GEN_SRC_DIR/simple/SimpleApp_HiltComponents.java"
+ )
+ genDaggerHiltApplicationComponent = File(
+ projectRoot,
+ "$GEN_SRC_DIR/simple/DaggerSimpleApp_HiltComponents_SingletonC.java"
+ )
+
+ classSrcApp = File(projectRoot, "$CLASS_DIR/simple/SimpleApp.class")
+ classSrcActivity1 = File(projectRoot, "$CLASS_DIR/simple/Activity1.class")
+ classSrcActivity2 = File(projectRoot, "$CLASS_DIR/simple/Activity2.class")
+ classSrcModule1 = File(projectRoot, "$CLASS_DIR/simple/Module1.class")
+ classSrcModule2 = File(projectRoot, "$CLASS_DIR/simple/Module2.class")
+ classGenHiltApp = File(projectRoot, "$CLASS_DIR/simple/Hilt_SimpleApp.class")
+ classGenHiltActivity1 = File(projectRoot, "$CLASS_DIR/simple/Hilt_Activity1.class")
+ classGenHiltActivity2 = File(projectRoot, "$CLASS_DIR/simple/Hilt_Activity2.class")
+ classGenAppInjector = File(projectRoot, "$CLASS_DIR/simple/SimpleApp_GeneratedInjector.class")
+ classGenActivityInjector1 = File(
+ projectRoot,
+ "$CLASS_DIR/simple/Activity1_GeneratedInjector.class"
+ )
+ classGenActivityInjector2 = File(
+ projectRoot,
+ "$CLASS_DIR/simple/Activity2_GeneratedInjector.class"
+ )
+ classGenAppInjectorDeps = File(
+ projectRoot,
+ "$CLASS_DIR/hilt_aggregated_deps/simple_SimpleApp_GeneratedInjectorModuleDeps.class"
+ )
+ classGenActivityInjectorDeps1 = File(
+ projectRoot,
+ "$CLASS_DIR/hilt_aggregated_deps/simple_Activity1_GeneratedInjectorModuleDeps.class"
+ )
+ classGenActivityInjectorDeps2 = File(
+ projectRoot,
+ "$CLASS_DIR/hilt_aggregated_deps/simple_Activity2_GeneratedInjectorModuleDeps.class"
+ )
+ classGenModuleDeps1 = File(
+ projectRoot,
+ "$CLASS_DIR/hilt_aggregated_deps/simple_Module1ModuleDeps.class"
+ )
+ classGenModuleDeps2 = File(
+ projectRoot,
+ "$CLASS_DIR/hilt_aggregated_deps/simple_Module2ModuleDeps.class"
+ )
+ classGenHiltComponents = File(
+ projectRoot,
+ "$CLASS_DIR/simple/SimpleApp_HiltComponents.class"
+ )
+ classGenDaggerHiltApplicationComponent = File(
+ projectRoot,
+ "$CLASS_DIR/simple/DaggerSimpleApp_HiltComponents_SingletonC.class"
+ )
+ }
+
+ @Test
+ fun firstFullBuild() {
+ // This test verifies the results of the first full (non-incremental) build. The other tests
+ // verify the results of the second incremental build based on different change scenarios.
+ val result = runFullBuild()
+ expect.that(result.task(COMPILE_TASK)!!.outcome).isEqualTo(TaskOutcome.SUCCESS)
+
+ // Check annotation processing outputs
+ assertFilesExist(
+ genHiltApp,
+ genHiltActivity1,
+ genHiltActivity2,
+ genAppInjector,
+ genActivityInjector1,
+ genActivityInjector2,
+ genAppInjectorDeps,
+ genActivityInjectorDeps1,
+ genActivityInjectorDeps2,
+ genModuleDeps1,
+ genModuleDeps2,
+ genHiltComponents,
+ genDaggerHiltApplicationComponent
+ )
+
+ // Check compilation outputs
+ assertFilesExist(
+ classSrcApp,
+ classSrcActivity1,
+ classSrcActivity2,
+ classSrcModule1,
+ classSrcModule2,
+ classGenHiltApp,
+ classGenHiltActivity1,
+ classGenHiltActivity2,
+ classGenAppInjector,
+ classGenActivityInjector1,
+ classGenActivityInjector2,
+ classGenAppInjectorDeps,
+ classGenActivityInjectorDeps1,
+ classGenActivityInjectorDeps2,
+ classGenModuleDeps1,
+ classGenModuleDeps2,
+ classGenHiltComponents,
+ classGenDaggerHiltApplicationComponent
+ )
+ }
+
+ @Test
+ fun changeActivitySource() {
+ runFullBuild()
+
+ // Change Activity 1 source
+ searchAndReplace(
+ srcActivity1, "// Insert-change",
+ """
+ @Override
+ public void onResume() {
+ super.onResume();
+ }
+ """.trimIndent()
+ )
+
+ val result = runIncrementalBuild()
+ expect.that(result.task(COMPILE_TASK)!!.outcome).isEqualTo(TaskOutcome.SUCCESS)
+
+ // Check annotation processing outputs
+ // * Only activity 1 sources are re-generated, isolation in modules and from other activities
+ // * Root classes along with components are always re-generated (aggregated processor)
+ assertChangedFiles(
+ FileType.JAVA,
+ genHiltApp,
+ genHiltActivity1,
+ genAppInjector,
+ genActivityInjector1,
+ genAppInjectorDeps,
+ genActivityInjectorDeps1,
+ genHiltComponents,
+ genDaggerHiltApplicationComponent
+ )
+
+ // Check compilation outputs
+ // * Gen sources from activity 1 are re-compiled
+ // * All aggregating processor gen sources are re-compiled
+ assertChangedFiles(
+ FileType.CLASS,
+ classSrcActivity1,
+ classGenHiltApp,
+ classGenHiltActivity1,
+ classGenAppInjector,
+ classGenActivityInjector1,
+ classGenAppInjectorDeps,
+ classGenActivityInjectorDeps1,
+ classGenHiltComponents,
+ classGenDaggerHiltApplicationComponent
+ )
+ }
+
+ @Test
+ fun changeModuleSource() {
+ runFullBuild()
+
+ // Change Module 1 source
+ searchAndReplace(
+ srcModule1, "// Insert-change",
+ """
+ @Provides
+ static double provideDouble() {
+ return 10.10;
+ }
+ """.trimIndent()
+ )
+
+ val result = runIncrementalBuild()
+ expect.that(result.task(COMPILE_TASK)!!.outcome).isEqualTo(TaskOutcome.SUCCESS)
+
+ // Check annotation processing outputs
+ // * Only module 1 sources are re-generated, isolation from other modules
+ // * Root classes along with components are always re-generated (aggregated processor)
+ assertChangedFiles(
+ FileType.JAVA,
+ genHiltApp,
+ genAppInjector,
+ genAppInjectorDeps,
+ genModuleDeps1,
+ genHiltComponents,
+ genDaggerHiltApplicationComponent
+ )
+
+ // Check compilation outputs
+ // * Gen sources from module 1 are re-compiled
+ // * All aggregating processor gen sources are re-compiled
+ assertChangedFiles(
+ FileType.CLASS,
+ classSrcModule1,
+ classGenHiltApp,
+ classGenAppInjector,
+ classGenAppInjectorDeps,
+ classGenModuleDeps1,
+ classGenHiltComponents,
+ classGenDaggerHiltApplicationComponent
+ )
+ }
+
+ @Test
+ fun changeAppSource() {
+ runFullBuild()
+
+ // Change Application source
+ searchAndReplace(
+ srcApp, "// Insert-change",
+ """
+ @Override
+ public void onCreate() {
+ super.onCreate();
+ }
+ """.trimIndent()
+ )
+
+ val result = runIncrementalBuild()
+ expect.that(result.task(COMPILE_TASK)!!.outcome).isEqualTo(TaskOutcome.SUCCESS)
+
+ // Check annotation processing outputs
+ // * No modules or activities (or any other non-root) classes should be generated
+ // * Root classes along with components are always re-generated (aggregated processor)
+ assertChangedFiles(
+ FileType.JAVA,
+ genHiltApp,
+ genAppInjector,
+ genAppInjectorDeps,
+ genHiltComponents,
+ genDaggerHiltApplicationComponent
+ )
+
+ // Check compilation outputs
+ // * All aggregating processor gen sources are re-compiled
+ assertChangedFiles(
+ FileType.CLASS,
+ classSrcApp, // re-compiles because superclass re-compiled
+ classGenHiltApp,
+ classGenAppInjector,
+ classGenAppInjectorDeps,
+ classGenHiltComponents,
+ classGenDaggerHiltApplicationComponent
+ )
+ }
+
+ @Test
+ fun deleteActivitySource() {
+ runFullBuild()
+
+ srcActivity2.delete()
+
+ val result = runIncrementalBuild()
+ expect.that(result.task(COMPILE_TASK)!!.outcome).isEqualTo(TaskOutcome.SUCCESS)
+
+ // Check annotation processing outputs
+ // * All related gen classes from activity 2 should be deleted
+ // * Unrelated activities and modules are in isolation and should be unchanged
+ // * Root classes along with components are always re-generated (aggregated processor)
+ assertDeletedFiles(
+ genHiltActivity2,
+ genActivityInjector2,
+ genActivityInjectorDeps2
+ )
+ assertChangedFiles(
+ FileType.JAVA,
+ genHiltApp,
+ genAppInjector,
+ genAppInjectorDeps,
+ genHiltComponents,
+ genDaggerHiltApplicationComponent
+ )
+
+ // Check compilation outputs
+ // * All compiled classes from activity 2 should be deleted
+ // * Unrelated activities and modules are in isolation and should be unchanged
+ assertDeletedFiles(
+ classSrcActivity2,
+ classGenHiltActivity2,
+ classGenActivityInjector2,
+ classGenActivityInjectorDeps2
+ )
+ assertChangedFiles(
+ FileType.CLASS,
+ classGenHiltApp,
+ classGenAppInjector,
+ classGenAppInjectorDeps,
+ classGenHiltComponents,
+ classGenDaggerHiltApplicationComponent
+ )
+ }
+
+ @Test
+ fun deleteModuleSource() {
+ runFullBuild()
+
+ srcModule2.delete()
+
+ val result = runIncrementalBuild()
+ expect.that(result.task(COMPILE_TASK)!!.outcome).isEqualTo(TaskOutcome.SUCCESS)
+
+ // Check annotation processing outputs
+ // * All related gen classes from module 2 should be deleted
+ // * Unrelated activities and modules are in isolation and should be unchanged
+ // * Root classes along with components are always re-generated (aggregated processor)
+ assertDeletedFiles(
+ genModuleDeps2
+ )
+ assertChangedFiles(
+ FileType.JAVA,
+ genHiltApp,
+ genAppInjector,
+ genAppInjectorDeps,
+ genHiltComponents,
+ genDaggerHiltApplicationComponent
+ )
+
+ // Check compilation outputs
+ // * All compiled classes from module 2 should be deleted
+ // * Unrelated activities and modules are in isolation and should be unchanged
+ assertDeletedFiles(
+ classSrcModule2,
+ classGenModuleDeps2
+ )
+ assertChangedFiles(
+ FileType.CLASS,
+ classGenHiltApp,
+ classGenAppInjector,
+ classGenAppInjectorDeps,
+ classGenHiltComponents,
+ classGenDaggerHiltApplicationComponent
+ )
+ }
+
+ private fun runGradleTasks(vararg args: String): BuildResult {
+ return GradleRunner.create()
+ .withProjectDir(testProjectDir.root)
+ .withArguments(*args)
+ .withPluginClasspath()
+ .forwardOutput()
+ .build()
+ }
+
+ private fun runFullBuild(): BuildResult {
+ val result = runGradleTasks(CLEAN_TASK, COMPILE_TASK)
+ recordTimestamps()
+ return result
+ }
+
+ private fun runIncrementalBuild(): BuildResult {
+ val result = runGradleTasks(COMPILE_TASK)
+ recordFileChanges()
+ return result
+ }
+ private fun recordTimestamps() {
+ val files = listOf(
+ genHiltApp,
+ genHiltActivity1,
+ genHiltActivity2,
+ genAppInjector,
+ genActivityInjector1,
+ genActivityInjector2,
+ genAppInjectorDeps,
+ genActivityInjectorDeps1,
+ genActivityInjectorDeps2,
+ genModuleDeps1,
+ genModuleDeps2,
+ genHiltComponents,
+ genDaggerHiltApplicationComponent,
+ classSrcApp,
+ classSrcActivity1,
+ classSrcActivity2,
+ classSrcModule1,
+ classSrcModule2,
+ classGenHiltApp,
+ classGenHiltActivity1,
+ classGenHiltActivity2,
+ classGenAppInjector,
+ classGenActivityInjector1,
+ classGenActivityInjector2,
+ classGenAppInjectorDeps,
+ classGenActivityInjectorDeps1,
+ classGenActivityInjectorDeps2,
+ classGenModuleDeps1,
+ classGenModuleDeps2,
+ classGenHiltComponents,
+ classGenDaggerHiltApplicationComponent
+ )
+
+ fileToTimestampMap = mutableMapOf<File, Long>().apply {
+ for (file in files) {
+ this[file] = file.lastModified()
+ }
+ }
+ }
+
+ private fun recordFileChanges() {
+ changedFiles = fileToTimestampMap.filter { (file, previousTimestamp) ->
+ file.exists() && file.lastModified() != previousTimestamp
+ }.keys
+
+ unchangedFiles = fileToTimestampMap.filter { (file, previousTimestamp) ->
+ file.exists() && file.lastModified() == previousTimestamp
+ }.keys
+
+ deletedFiles = fileToTimestampMap.filter { (file, _) -> !file.exists() }.keys
+ }
+
+ private fun assertFilesExist(vararg files: File) {
+ expect.withMessage("Existing files")
+ .that(files.filter { it.exists() })
+ .containsExactlyElementsIn(files)
+ }
+
+ private fun assertChangedFiles(type: FileType, vararg files: File) {
+ expect.withMessage("Changed files")
+ .that(changedFiles.filter { it.name.endsWith(type.extension) })
+ .containsExactlyElementsIn(files)
+ }
+
+ private fun assertDeletedFiles(vararg files: File) {
+ expect.withMessage("Deleted files").that(deletedFiles).containsAtLeastElementsIn(files)
+ }
+
+ private fun searchAndReplace(file: File, search: String, replace: String) {
+ file.writeText(file.readText().replace(search, replace))
+ }
+
+ enum class FileType(val extension: String) {
+ JAVA(".java"),
+ CLASS(".class"),
+ }
+
+ companion object {
+ private const val SRC_DIR = "src/main/java"
+ private const val GEN_SRC_DIR = "build/generated/ap_generated_sources/debug/out/"
+ private const val CLASS_DIR = "build/intermediates/javac/debug/classes"
+
+ private const val CLEAN_TASK = ":clean"
+ private const val COMPILE_TASK = ":compileDebugJavaWithJavac"
+ }
+}
diff --git a/java/dagger/hilt/android/plugin/src/test/kotlin/TransformTest.kt b/java/dagger/hilt/android/plugin/src/test/kotlin/TransformTest.kt
new file mode 100644
index 0000000..0b84002
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/test/kotlin/TransformTest.kt
@@ -0,0 +1,313 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.io.DataInputStream
+import java.io.FileInputStream
+import javassist.bytecode.ByteArray
+import javassist.bytecode.ClassFile
+import junit.framework.Assert.assertEquals
+import org.gradle.testkit.runner.TaskOutcome
+import org.junit.Assert
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+
+class TransformTest {
+
+ @get:Rule
+ val testProjectDir = TemporaryFolder()
+
+ lateinit var gradleRunner: GradleTestRunner
+
+ @Before
+ fun setup() {
+ gradleRunner = GradleTestRunner(testProjectDir)
+ gradleRunner.addSrc(
+ srcPath = "minimal/MainActivity.java",
+ srcContent =
+ """
+ package minimal;
+
+ import android.os.Bundle;
+ import androidx.appcompat.app.AppCompatActivity;
+
+ @dagger.hilt.android.AndroidEntryPoint
+ public class MainActivity extends AppCompatActivity {
+ @Override
+ public void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ }
+ }
+ """.trimIndent()
+ )
+ }
+
+ // Simple functional test to verify transformation.
+ @Test
+ fun testAssemble() {
+ gradleRunner.addDependencies(
+ "implementation 'androidx.appcompat:appcompat:1.1.0'",
+ "implementation 'com.google.dagger:hilt-android:LOCAL-SNAPSHOT'",
+ "annotationProcessor 'com.google.dagger:hilt-compiler:LOCAL-SNAPSHOT'"
+ )
+ gradleRunner.addActivities(
+ "<activity android:name=\".MainActivity\"/>"
+ )
+
+ val result = gradleRunner.build()
+ val assembleTask = result.getTask(":assembleDebug")
+ Assert.assertEquals(TaskOutcome.SUCCESS, assembleTask.outcome)
+
+ val transformedClass = result.getTransformedFile("minimal/MainActivity.class")
+ FileInputStream(transformedClass).use { fileInput ->
+ ClassFile(DataInputStream(fileInput)).let { classFile ->
+ // Verify superclass is updated
+ Assert.assertEquals("minimal.Hilt_MainActivity", classFile.superclass)
+ // Verify super call is also updated
+ val constPool = classFile.constPool
+ classFile.methods.first { it.name == "onCreate" }.let { methodInfo ->
+ // bytecode of MainActivity.onCreate() is:
+ // 0 - aload_0
+ // 1 - aload_1
+ // 2 - invokespecial
+ // 5 - return
+ val invokeIndex = 2
+ val methodRef = ByteArray.readU16bit(methodInfo.codeAttribute.code, invokeIndex + 1)
+ val classRef = constPool.getMethodrefClassName(methodRef)
+ Assert.assertEquals("minimal.Hilt_MainActivity", classRef)
+ }
+ }
+ }
+ }
+
+ // Verify correct transformation is done on nested classes.
+ @Test
+ fun testAssemble_nestedClass() {
+ gradleRunner.addDependencies(
+ "implementation 'androidx.appcompat:appcompat:1.1.0'",
+ "implementation 'com.google.dagger:hilt-android:LOCAL-SNAPSHOT'",
+ "annotationProcessor 'com.google.dagger:hilt-compiler:LOCAL-SNAPSHOT'"
+ )
+
+ gradleRunner.addSrc(
+ srcPath = "minimal/TopClass.java",
+ srcContent =
+ """
+ package minimal;
+
+ import androidx.appcompat.app.AppCompatActivity;
+
+ public class TopClass {
+ @dagger.hilt.android.AndroidEntryPoint
+ public static class NestedActivity extends AppCompatActivity { }
+ }
+ """.trimIndent()
+ )
+
+ val result = gradleRunner.build()
+ val assembleTask = result.getTask(":assembleDebug")
+ Assert.assertEquals(TaskOutcome.SUCCESS, assembleTask.outcome)
+
+ val transformedClass = result.getTransformedFile("minimal/TopClass\$NestedActivity.class")
+ FileInputStream(transformedClass).use { fileInput ->
+ ClassFile(DataInputStream(fileInput)).let { classFile ->
+ Assert.assertEquals("minimal.Hilt_TopClass_NestedActivity", classFile.superclass)
+ }
+ }
+ }
+
+ // Verify transformation ignores abstract methods.
+ @Test
+ fun testAssemble_abstractMethod() {
+ gradleRunner.addDependencies(
+ "implementation 'androidx.appcompat:appcompat:1.1.0'",
+ "implementation 'com.google.dagger:hilt-android:LOCAL-SNAPSHOT'",
+ "annotationProcessor 'com.google.dagger:hilt-compiler:LOCAL-SNAPSHOT'"
+ )
+
+ gradleRunner.addSrc(
+ srcPath = "minimal/AbstractActivity.java",
+ srcContent =
+ """
+ package minimal;
+
+ import androidx.appcompat.app.AppCompatActivity;
+
+ @dagger.hilt.android.AndroidEntryPoint
+ public abstract class AbstractActivity extends AppCompatActivity {
+ public abstract void method();
+ }
+ """.trimIndent()
+ )
+
+ val result = gradleRunner.build()
+ val assembleTask = result.getTask(":assembleDebug")
+ Assert.assertEquals(TaskOutcome.SUCCESS, assembleTask.outcome)
+
+ val transformedClass = result.getTransformedFile("minimal/AbstractActivity.class")
+ FileInputStream(transformedClass).use { fileInput ->
+ ClassFile(DataInputStream(fileInput)).let { classFile ->
+ Assert.assertEquals("minimal.Hilt_AbstractActivity", classFile.superclass)
+ }
+ }
+ }
+
+ // Verify transformation ignores native methods.
+ @Test
+ fun testAssemble_nativeMethod() {
+ gradleRunner.addDependencies(
+ "implementation 'androidx.appcompat:appcompat:1.1.0'",
+ "implementation 'com.google.dagger:hilt-android:LOCAL-SNAPSHOT'",
+ "annotationProcessor 'com.google.dagger:hilt-compiler:LOCAL-SNAPSHOT'"
+ )
+
+ gradleRunner.addSrc(
+ srcPath = "minimal/SimpleActivity.java",
+ srcContent =
+ """
+ package minimal;
+
+ import androidx.appcompat.app.AppCompatActivity;
+
+ @dagger.hilt.android.AndroidEntryPoint
+ public class SimpleActivity extends AppCompatActivity {
+ public native void method();
+ }
+ """.trimIndent()
+ )
+
+ val result = gradleRunner.build()
+ val assembleTask = result.getTask(":assembleDebug")
+ Assert.assertEquals(TaskOutcome.SUCCESS, assembleTask.outcome)
+
+ val transformedClass = result.getTransformedFile("minimal/SimpleActivity.class")
+ FileInputStream(transformedClass).use { fileInput ->
+ ClassFile(DataInputStream(fileInput)).let { classFile ->
+ Assert.assertEquals("minimal.Hilt_SimpleActivity", classFile.superclass)
+ }
+ }
+ }
+
+ // Verifies the transformation is applied incrementally when a class to be transformed is updated.
+ @Test
+ fun testTransform_incrementalClass() {
+ gradleRunner.addDependencies(
+ "implementation 'androidx.appcompat:appcompat:1.1.0'",
+ "implementation 'com.google.dagger:hilt-android:LOCAL-SNAPSHOT'",
+ "annotationProcessor 'com.google.dagger:hilt-compiler:LOCAL-SNAPSHOT'"
+ )
+
+ val srcFile = gradleRunner.addSrc(
+ srcPath = "minimal/OtherActivity.java",
+ srcContent =
+ """
+ package minimal;
+
+ import androidx.appcompat.app.AppCompatActivity;
+
+ @dagger.hilt.android.AndroidEntryPoint
+ public class OtherActivity extends AppCompatActivity {
+
+ }
+ """.trimIndent()
+ )
+
+ gradleRunner.build().let {
+ val assembleTask = it.getTask(TRANSFORM_TASK_NAME)
+ Assert.assertEquals(TaskOutcome.SUCCESS, assembleTask.outcome)
+ }
+
+ gradleRunner.build().let {
+ val assembleTask = it.getTask(TRANSFORM_TASK_NAME)
+ Assert.assertEquals(TaskOutcome.UP_TO_DATE, assembleTask.outcome)
+ }
+
+ srcFile.delete()
+ gradleRunner.addSrc(
+ srcPath = "minimal/OtherActivity.java",
+ srcContent =
+ """
+ package minimal;
+
+ import androidx.fragment.app.FragmentActivity;
+
+ @dagger.hilt.android.AndroidEntryPoint
+ public class OtherActivity extends FragmentActivity {
+
+ }
+ """.trimIndent()
+ )
+
+ val result = gradleRunner.build()
+ val assembleTask = result.getTask(TRANSFORM_TASK_NAME)
+ Assert.assertEquals(TaskOutcome.SUCCESS, assembleTask.outcome)
+
+ val transformedClass = result.getTransformedFile("minimal/OtherActivity.class")
+ FileInputStream(transformedClass).use { fileInput ->
+ ClassFile(DataInputStream(fileInput)).let { classFile ->
+ Assert.assertEquals("minimal.Hilt_OtherActivity", classFile.superclass)
+ }
+ }
+ }
+
+ // Verifies the transformation is applied incrementally when a new class is added to an existing
+ // directory.
+ @Test
+ fun testTransform_incrementalDir() {
+ gradleRunner.addDependencies(
+ "implementation 'androidx.appcompat:appcompat:1.1.0'",
+ "implementation 'com.google.dagger:hilt-android:LOCAL-SNAPSHOT'",
+ "annotationProcessor 'com.google.dagger:hilt-compiler:LOCAL-SNAPSHOT'"
+ )
+
+ gradleRunner.addSrcPackage("ui/")
+
+ gradleRunner.build().let {
+ val assembleTask = it.getTask(TRANSFORM_TASK_NAME)
+ assertEquals(TaskOutcome.SUCCESS, assembleTask.outcome)
+ }
+
+ gradleRunner.build().let {
+ val assembleTask = it.getTask(TRANSFORM_TASK_NAME)
+ assertEquals(TaskOutcome.UP_TO_DATE, assembleTask.outcome)
+ }
+
+ gradleRunner.addSrc(
+ srcPath = "ui/OtherActivity.java",
+ srcContent =
+ """
+ package ui;
+
+ import androidx.appcompat.app.AppCompatActivity;
+
+ @dagger.hilt.android.AndroidEntryPoint
+ public class OtherActivity extends AppCompatActivity {
+
+ }
+ """.trimIndent()
+ )
+
+ val result = gradleRunner.build()
+ val assembleTask = result.getTask(TRANSFORM_TASK_NAME)
+ assertEquals(TaskOutcome.SUCCESS, assembleTask.outcome)
+ }
+
+ companion object {
+ const val TRANSFORM_TASK_NAME =
+ ":transformDebugClassesWithAsm"
+ }
+}
diff --git a/java/dagger/hilt/android/plugin/src/test/kotlin/util/SimpleAGPVersionTest.kt b/java/dagger/hilt/android/plugin/src/test/kotlin/util/SimpleAGPVersionTest.kt
new file mode 100644
index 0000000..75292b8
--- /dev/null
+++ b/java/dagger/hilt/android/plugin/src/test/kotlin/util/SimpleAGPVersionTest.kt
@@ -0,0 +1,40 @@
+package util
+
+import com.google.common.truth.Truth.assertThat
+import dagger.hilt.android.plugin.util.SimpleAGPVersion
+import org.junit.Test
+
+class SimpleAGPVersionTest {
+
+ @Test
+ fun parsing() {
+ assertThat(SimpleAGPVersion.parse("4.2"))
+ .isEqualTo(SimpleAGPVersion(4, 2))
+ assertThat(SimpleAGPVersion.parse("4.2.1"))
+ .isEqualTo(SimpleAGPVersion(4, 2))
+ assertThat(SimpleAGPVersion.parse("7.0.0-alpha01"))
+ .isEqualTo(SimpleAGPVersion(7, 0))
+ }
+
+ @Test
+ fun comparing() {
+ assertThat(SimpleAGPVersion(4, 2))
+ .isEqualTo(SimpleAGPVersion(4, 2))
+ assertThat(SimpleAGPVersion(4, 2))
+ .isGreaterThan(SimpleAGPVersion(3, 4))
+ assertThat(SimpleAGPVersion(4, 2))
+ .isLessThan(SimpleAGPVersion(7, 0))
+
+ assertThat(SimpleAGPVersion.parse("4.2.1"))
+ .isEqualTo(SimpleAGPVersion.parse("4.2.2"))
+ assertThat(SimpleAGPVersion.parse("4.2.1"))
+ .isGreaterThan(SimpleAGPVersion.parse("3.4.1"))
+ assertThat(SimpleAGPVersion.parse("4.2.1"))
+ .isLessThan(SimpleAGPVersion.parse("7.0.1"))
+
+ assertThat(SimpleAGPVersion.parse("4.2.1"))
+ .isLessThan(SimpleAGPVersion.parse("7.0.0-alpha01"))
+ assertThat(SimpleAGPVersion.parse("7.0.0-alpha01"))
+ .isEqualTo(SimpleAGPVersion.parse("7.0.0-alpha02"))
+ }
+}
diff --git a/java/dagger/hilt/android/processor/BUILD b/java/dagger/hilt/android/processor/BUILD
new file mode 100644
index 0000000..e116c44
--- /dev/null
+++ b/java/dagger/hilt/android/processor/BUILD
@@ -0,0 +1,100 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Hilt android processors.
+
+load("//:build_defs.bzl", "POM_VERSION_ALPHA")
+load("//tools:maven.bzl", "gen_maven_artifact")
+
+package(default_visibility = ["//:src"])
+
+java_library(
+ name = "artifact-lib",
+ tags = ["maven_coordinates=com.google.dagger:hilt-android-compiler:" + POM_VERSION_ALPHA],
+ visibility = ["//visibility:private"],
+ exports = [
+ "//java/dagger/hilt/processor:artifact-lib-shared",
+ ],
+)
+
+gen_maven_artifact(
+ name = "artifact",
+ artifact_coordinates = "com.google.dagger:hilt-android-compiler:" + POM_VERSION_ALPHA,
+ artifact_name = "Hilt Android Processor",
+ artifact_target = ":artifact-lib",
+ artifact_target_libs = [
+ "//java/dagger/hilt/android/processor/internal:android_classnames",
+ "//java/dagger/hilt/android/processor/internal:utils",
+ "//java/dagger/hilt/android/processor/internal/androidentrypoint:android_generators",
+ "//java/dagger/hilt/android/processor/internal/androidentrypoint:compiler_options",
+ "//java/dagger/hilt/android/processor/internal/androidentrypoint:metadata",
+ "//java/dagger/hilt/android/processor/internal/androidentrypoint:processor_lib",
+ "//java/dagger/hilt/android/processor/internal/bindvalue:bind_value_processor_lib",
+ "//java/dagger/hilt/android/processor/internal/customtestapplication:processor_lib",
+ "//java/dagger/hilt/android/processor/internal/viewmodel:validation_plugin_lib",
+ "//java/dagger/hilt/android/processor/internal/uninstallmodules:processor_lib",
+ "//java/dagger/hilt/android/processor/internal/viewmodel:processor_lib",
+ "//java/dagger/hilt/processor/internal:base_processor",
+ "//java/dagger/hilt/processor/internal:classnames",
+ "//java/dagger/hilt/processor/internal:component_descriptor",
+ "//java/dagger/hilt/processor/internal:component_names",
+ "//java/dagger/hilt/processor/internal:components",
+ "//java/dagger/hilt/processor/internal:kotlin",
+ "//java/dagger/hilt/processor/internal:processor_errors",
+ "//java/dagger/hilt/processor/internal:processors",
+ "//java/dagger/hilt/processor/internal/aggregateddeps:component_dependencies",
+ "//java/dagger/hilt/processor/internal/aggregateddeps:processor_lib",
+ "//java/dagger/hilt/processor/internal/aliasof:alias_ofs",
+ "//java/dagger/hilt/processor/internal/aliasof:processor_lib",
+ "//java/dagger/hilt/processor/internal/definecomponent:define_components",
+ "//java/dagger/hilt/processor/internal/definecomponent:processor_lib",
+ "//java/dagger/hilt/processor/internal/generatesrootinput:generates_root_inputs",
+ "//java/dagger/hilt/processor/internal/generatesrootinput:processor_lib",
+ "//java/dagger/hilt/processor/internal/originatingelement:processor_lib",
+ "//java/dagger/hilt/processor/internal/root:processor_lib",
+ "//java/dagger/hilt/processor/internal/root:root_metadata",
+ "//java/dagger/hilt/processor/internal/root:root_type",
+ ],
+ artifact_target_maven_deps = [
+ "com.google.auto:auto-common",
+ "com.google.code.findbugs:jsr305",
+ "com.google.dagger:dagger-compiler",
+ "com.google.dagger:dagger",
+ "com.google.dagger:dagger-spi",
+ "com.google.guava:failureaccess",
+ "com.google.guava:guava",
+ "com.squareup:javapoet",
+ "javax.annotation:jsr250-api",
+ "javax.inject:javax.inject",
+ "net.ltgt.gradle.incap:incap",
+ "org.jetbrains.kotlin:kotlin-stdlib",
+ "org.jetbrains.kotlinx:kotlinx-metadata-jvm",
+ ],
+ javadoc_android_api_level = 30,
+ javadoc_root_packages = [
+ "dagger.hilt.processor",
+ "dagger.hilt.android.processor",
+ ],
+ javadoc_srcs = [
+ "//java/dagger/hilt:hilt_processing_filegroup",
+ ],
+ shaded_deps = ["@maven//:com_google_auto_auto_common"],
+ shaded_rules = ["rule com.google.auto.common.** dagger.hilt.android.shaded.auto.common.@1"],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/android/processor/internal/AndroidClassNames.java b/java/dagger/hilt/android/processor/internal/AndroidClassNames.java
new file mode 100644
index 0000000..915ae51
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/AndroidClassNames.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal;
+
+import static com.squareup.javapoet.ClassName.get;
+
+import com.squareup.javapoet.ClassName;
+
+/** Holder for commonly used class names. */
+public final class AndroidClassNames {
+
+ public static final ClassName APPLICATION_PROVIDER =
+ get("androidx.test.core.app", "ApplicationProvider");
+ public static final ClassName ACTIVITY = get("android.app", "Activity");
+ public static final ClassName COMPONENT_ACTIVITY = get("androidx.activity", "ComponentActivity");
+ public static final ClassName APPLICATION = get("android.app", "Application");
+ public static final ClassName BROADCAST_RECEIVER = get("android.content", "BroadcastReceiver");
+ public static final ClassName SERVICE = get("android.app", "Service");
+ public static final ClassName FRAGMENT =
+ get("androidx.fragment.app", "Fragment");
+ public static final ClassName VIEW = get("android.view", "View");
+
+ public static final ClassName NULLABLE_INTERNAL = get("android.annotation", "Nullable");
+ public static final ClassName TARGET_API = get("android.annotation", "TargetApi");
+
+ public static final ClassName CONTEXT = get("android.content", "Context");
+ public static final ClassName CONTEXT_WRAPPER = get("android.content", "ContextWrapper");
+ public static final ClassName INTENT = get("android.content", "Intent");
+
+ public static final ClassName BUNDLE = get("android.os", "Bundle");
+
+ public static final ClassName CALL_SUPER = get("androidx.annotation", "CallSuper");
+ public static final ClassName MAIN_THREAD = get("androidx.annotation", "MainThread");
+ public static final ClassName NULLABLE = get("androidx.annotation", "Nullable");
+ public static final ClassName MULTI_DEX_APPLICATION =
+ get("androidx.multidex", "MultiDexApplication");
+
+ public static final ClassName ATTRIBUTE_SET = get("android.util", "AttributeSet");
+ public static final ClassName LAYOUT_INFLATER = get("android.view", "LayoutInflater");
+
+ public static final ClassName ANDROID_ENTRY_POINT =
+ get("dagger.hilt.android", "AndroidEntryPoint");
+ public static final ClassName WITH_FRAGMENT_BINDINGS =
+ get("dagger.hilt.android", "WithFragmentBindings");
+ public static final ClassName HILT_ANDROID_APP =
+ get("dagger.hilt.android", "HiltAndroidApp");
+ public static final ClassName OPTIONAL_INJECT =
+ get("dagger.hilt.android.migration", "OptionalInject");
+
+ public static final ClassName SINGLETON_COMPONENT =
+ get("dagger.hilt.components", "SingletonComponent");
+ public static final ClassName ACTIVITY_COMPONENT =
+ get("dagger.hilt.android.components", "ActivityComponent");
+ public static final ClassName ACTIVITY_RETAINED_COMPONENT =
+ get("dagger.hilt.android.components", "ActivityRetainedComponent");
+ public static final ClassName FRAGMENT_COMPONENT =
+ get("dagger.hilt.android.components", "FragmentComponent");
+ public static final ClassName VIEW_WITH_FRAGMENT_COMPONENT =
+ get("dagger.hilt.android.components", "ViewWithFragmentComponent");
+ public static final ClassName VIEW_COMPONENT =
+ get("dagger.hilt.android.components", "ViewComponent");
+ public static final ClassName SERVICE_COMPONENT =
+ get("dagger.hilt.android.components", "ServiceComponent");
+ public static final ClassName VIEW_MODEL_COMPONENT =
+ get("dagger.hilt.android.components", "ViewModelComponent");
+
+ public static final ClassName ACTIVITY_COMPONENT_MANAGER =
+ get("dagger.hilt.android.internal.managers", "ActivityComponentManager");
+ public static final ClassName APPLICATION_COMPONENT_MANAGER =
+ get("dagger.hilt.android.internal.managers", "ApplicationComponentManager");
+ public static final ClassName BROADCAST_RECEIVER_COMPONENT_MANAGER =
+ get("dagger.hilt.android.internal.managers", "BroadcastReceiverComponentManager");
+ public static final ClassName COMPONENT_SUPPLIER =
+ get("dagger.hilt.android.internal.managers", "ComponentSupplier");
+ public static final ClassName FRAGMENT_COMPONENT_MANAGER =
+ get("dagger.hilt.android.internal.managers", "FragmentComponentManager");
+ public static final ClassName SERVICE_COMPONENT_MANAGER =
+ get("dagger.hilt.android.internal.managers", "ServiceComponentManager");
+ public static final ClassName VIEW_COMPONENT_MANAGER =
+ get("dagger.hilt.android.internal.managers", "ViewComponentManager");
+
+ public static final ClassName INJECTED_BY_HILT =
+ get("dagger.hilt.android.internal.migration", "InjectedByHilt");
+
+ public static final ClassName APPLICATION_CONTEXT_MODULE =
+ get("dagger.hilt.android.internal.modules", "ApplicationContextModule");
+
+ public static final ClassName DEFAULT_VIEW_MODEL_FACTORIES =
+ get("dagger.hilt.android.internal.lifecycle", "DefaultViewModelFactories");
+ public static final ClassName HILT_VIEW_MODEL =
+ get("dagger.hilt.android.lifecycle", "HiltViewModel");
+ public static final ClassName HILT_VIEW_MODEL_MAP_QUALIFIER =
+ get("dagger.hilt.android.internal.lifecycle", "HiltViewModelMap");
+ public static final ClassName HILT_VIEW_MODEL_KEYS_QUALIFIER =
+ get("dagger.hilt.android.internal.lifecycle", "HiltViewModelMap", "KeySet");
+ public static final ClassName VIEW_MODEL = get("androidx.lifecycle", "ViewModel");
+ public static final ClassName VIEW_MODEL_PROVIDER_FACTORY =
+ get("androidx.lifecycle", "ViewModelProvider", "Factory");
+ public static final ClassName SAVED_STATE_HANDLE =
+ get("androidx.lifecycle", "SavedStateHandle");
+
+ private AndroidClassNames() {}
+}
diff --git a/java/dagger/hilt/android/processor/internal/BUILD b/java/dagger/hilt/android/processor/internal/BUILD
new file mode 100644
index 0000000..aaf8b89
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/BUILD
@@ -0,0 +1,45 @@
+# Copyright (C) 2019 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Internal code for implementing Hilt android processors.
+
+package(default_visibility = ["//:src"])
+
+java_library(
+ name = "android_classnames",
+ srcs = [
+ "AndroidClassNames.java",
+ ],
+ deps = [
+ "@google_bazel_common//third_party/java/javapoet",
+ ],
+)
+
+# TODO(erichang): Merge this into other utils
+java_library(
+ name = "utils",
+ srcs = [
+ "MoreTypes.java",
+ ],
+ deps = [
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ ],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["**/*"]),
+)
diff --git a/java/dagger/hilt/android/processor/internal/MoreTypes.java b/java/dagger/hilt/android/processor/internal/MoreTypes.java
new file mode 100644
index 0000000..e5a2cdd
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/MoreTypes.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Iterables;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.ArrayType;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.ErrorType;
+import javax.lang.model.type.ExecutableType;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.ElementFilter;
+import javax.lang.model.util.SimpleTypeVisitor7;
+import javax.lang.model.util.Types;
+
+/** More utility methods for types. */
+public final class MoreTypes {
+ private MoreTypes() {}
+
+ /**
+ * If the received mirror represents a declared type or an array of declared types, this returns
+ * the represented declared type. Otherwise throws an IllegalStateException.
+ */
+ public static DeclaredType getDeclaredType(TypeMirror type) {
+ return type.accept(
+ new SimpleTypeVisitor7<DeclaredType, Void>() {
+ @Override public DeclaredType visitArray(ArrayType type, Void unused) {
+ return getDeclaredType(type.getComponentType());
+ }
+
+ @Override public DeclaredType visitDeclared(DeclaredType type, Void unused) {
+ return type;
+ }
+
+ @Override public DeclaredType visitError(ErrorType type, Void unused) {
+ return type;
+ }
+
+ @Override public DeclaredType defaultAction(TypeMirror type, Void unused) {
+ throw new IllegalStateException("Unhandled type: " + type);
+ }
+ }, null /* the Void accumulator */);
+ }
+
+ /** Returns the TypeElement corresponding to a TypeMirror. */
+ public static TypeElement asTypeElement(TypeMirror type) {
+ return asTypeElement(getDeclaredType(type));
+ }
+
+ /** Returns the TypeElement corresponding to a DeclaredType. */
+ public static TypeElement asTypeElement(DeclaredType type) {
+ return (TypeElement) type.asElement();
+ }
+
+ /**
+ * Returns a {@link ExecutableType} if the {@link TypeMirror} represents an executable type such
+ * as a method, constructor, or initializer or throws an {@link IllegalArgumentException}.
+ */
+ public static ExecutableType asExecutable(TypeMirror maybeExecutableType) {
+ return maybeExecutableType.accept(ExecutableTypeVisitor.INSTANCE, null);
+ }
+
+ private static final class ExecutableTypeVisitor extends CastingTypeVisitor<ExecutableType> {
+ private static final ExecutableTypeVisitor INSTANCE = new ExecutableTypeVisitor();
+
+ ExecutableTypeVisitor() {
+ super("executable type");
+ }
+
+ @Override
+ public ExecutableType visitExecutable(ExecutableType type, Void ignore) {
+ return type;
+ }
+ }
+
+ private abstract static class CastingTypeVisitor<T> extends SimpleTypeVisitor7<T, Void> {
+ private final String label;
+
+ CastingTypeVisitor(String label) {
+ this.label = label;
+ }
+
+ @Override
+ protected T defaultAction(TypeMirror e, Void v) {
+ throw new IllegalArgumentException(e + " does not represent a " + label);
+ }
+ }
+
+ /**
+ * Returns the first matching method, if one exists (starting with classElement, then searching
+ * each sub classes).
+ */
+ public static Optional<ExecutableElement> findInheritedMethod(
+ Types types, TypeElement classElement, ExecutableElement method) {
+ Optional<ExecutableElement> match = Optional.empty();
+ while (!match.isPresent() && !classElement.asType().getKind().equals(TypeKind.NONE)) {
+ match = findMethod(types, classElement, method);
+ classElement = MoreTypes.asTypeElement(classElement.getSuperclass());
+ }
+ return match;
+ }
+
+ /** Returns a method with a matching signature in classElement if one exists. */
+ public static Optional<ExecutableElement> findMethod(
+ Types types, TypeElement classElement, ExecutableElement method) {
+ ExecutableType methodType = asExecutable(method.asType());
+ Set<ExecutableElement> matchingMethods =
+ findMethods(classElement, method.getSimpleName().toString())
+ .stream()
+ .filter(clsMethod -> types.isSubsignature(asExecutable(clsMethod.asType()), methodType))
+ .collect(Collectors.toSet());
+
+ Preconditions.checkState(
+ matchingMethods.size() <= 1,
+ "Found multiple methods with matching signature in class %s: %s",
+ classElement,
+ matchingMethods);
+
+ return matchingMethods.size() == 1
+ ? Optional.of(Iterables.getOnlyElement(matchingMethods))
+ : Optional.empty();
+ }
+
+ /** Returns methods with a matching name in classElement. */
+ public static Set<ExecutableElement> findMethods(TypeElement classElement, String name) {
+ return ElementFilter.methodsIn(classElement.getEnclosedElements())
+ .stream()
+ .filter(clsMethod -> clsMethod.getSimpleName().contentEquals(name))
+ .collect(Collectors.toSet());
+ }
+}
diff --git a/java/dagger/hilt/android/processor/internal/androidentrypoint/ActivityGenerator.java b/java/dagger/hilt/android/processor/internal/androidentrypoint/ActivityGenerator.java
new file mode 100644
index 0000000..ce9ad14
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/androidentrypoint/ActivityGenerator.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.androidentrypoint;
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterSpec;
+import com.squareup.javapoet.TypeSpec;
+import com.squareup.javapoet.TypeVariableName;
+import dagger.hilt.android.processor.internal.AndroidClassNames;
+import dagger.hilt.processor.internal.Processors;
+import java.io.IOException;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.Modifier;
+
+/** Generates an Hilt Activity class for the @AndroidEntryPoint annotated class. */
+public final class ActivityGenerator {
+
+ private final ProcessingEnvironment env;
+ private final AndroidEntryPointMetadata metadata;
+ private final ClassName generatedClassName;
+
+ public ActivityGenerator(ProcessingEnvironment env, AndroidEntryPointMetadata metadata) {
+ this.env = env;
+ this.metadata = metadata;
+
+ generatedClassName = metadata.generatedClassName();
+ }
+
+ // @Generated("ActivityGenerator")
+ // abstract class Hilt_$CLASS extends $BASE implements ComponentManager<?> {
+ // ...
+ // }
+ public void generate() throws IOException {
+ TypeSpec.Builder builder =
+ TypeSpec.classBuilder(generatedClassName.simpleName())
+ .addOriginatingElement(metadata.element())
+ .superclass(metadata.baseClassName())
+ .addModifiers(metadata.generatedClassModifiers());
+
+ Generators.addGeneratedBaseClassJavadoc(builder, AndroidClassNames.ANDROID_ENTRY_POINT);
+ Processors.addGeneratedAnnotation(builder, env, getClass());
+
+ Generators.copyConstructors(metadata.baseElement(), builder);
+ builder.addMethod(onCreate());
+
+
+ metadata.baseElement().getTypeParameters().stream()
+ .map(TypeVariableName::get)
+ .forEachOrdered(builder::addTypeVariable);
+
+ Generators.addComponentOverride(metadata, builder);
+ Generators.copyLintAnnotations(metadata.element(), builder);
+
+ Generators.addInjectionMethods(metadata, builder);
+
+ if (Processors.isAssignableFrom(metadata.baseElement(), AndroidClassNames.COMPONENT_ACTIVITY)
+ && !metadata.overridesAndroidEntryPointClass()) {
+ builder.addMethod(getDefaultViewModelProviderFactory());
+ }
+
+ JavaFile.builder(generatedClassName.packageName(), builder.build())
+ .build()
+ .writeTo(env.getFiler());
+ }
+
+ // @CallSuper
+ // @Override
+ // protected void onCreate(@Nullable Bundle savedInstanceState) {
+ // inject();
+ // super.onCreate(savedInstanceState);
+ // }
+ private MethodSpec onCreate() {
+ return MethodSpec.methodBuilder("onCreate")
+ .addAnnotation(AndroidClassNames.CALL_SUPER)
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PROTECTED)
+ .addParameter(
+ ParameterSpec.builder(AndroidClassNames.BUNDLE, "savedInstanceState")
+ .addAnnotation(AndroidClassNames.NULLABLE)
+ .build())
+ .addStatement("inject()")
+ .addStatement("super.onCreate(savedInstanceState)")
+ .build();
+ }
+
+ // @Override
+ // public ViewModelProvider.Factory getDefaultViewModelProviderFactory() {
+ // return DefaultViewModelFactories.getActivityFactory(this);
+ // }
+ private MethodSpec getDefaultViewModelProviderFactory() {
+ return MethodSpec.methodBuilder("getDefaultViewModelProviderFactory")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC)
+ .returns(AndroidClassNames.VIEW_MODEL_PROVIDER_FACTORY)
+ .addStatement(
+ "return $T.getActivityFactory(this)",
+ AndroidClassNames.DEFAULT_VIEW_MODEL_FACTORIES)
+ .build();
+ }
+}
diff --git a/java/dagger/hilt/android/processor/internal/androidentrypoint/AndroidEntryPointMetadata.java b/java/dagger/hilt/android/processor/internal/androidentrypoint/AndroidEntryPointMetadata.java
new file mode 100644
index 0000000..e5868f8
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/androidentrypoint/AndroidEntryPointMetadata.java
@@ -0,0 +1,522 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.androidentrypoint;
+
+import static dagger.hilt.android.processor.internal.androidentrypoint.HiltCompilerOptions.BooleanOption.DISABLE_ANDROID_SUPERCLASS_VALIDATION;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.MoreTypes;
+import com.google.auto.value.AutoValue;
+import com.google.auto.value.extension.memoized.Memoized;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.squareup.javapoet.AnnotationSpec;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.ParameterSpec;
+import com.squareup.javapoet.TypeName;
+import dagger.hilt.android.processor.internal.AndroidClassNames;
+import dagger.hilt.processor.internal.BadInputException;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.Components;
+import dagger.hilt.processor.internal.KotlinMetadataUtils;
+import dagger.hilt.processor.internal.ProcessorErrors;
+import dagger.hilt.processor.internal.Processors;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import java.util.LinkedHashSet;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeMirror;
+
+/** Metadata class for @AndroidEntryPoint annotated classes. */
+@AutoValue
+public abstract class AndroidEntryPointMetadata {
+
+ /** The class {@link Element} annotated with @AndroidEntryPoint. */
+ public abstract TypeElement element();
+
+ /** The base class {@link Element} given to @AndroidEntryPoint. */
+ public abstract TypeElement baseElement();
+
+ /** The name of the generated base class, beginning with 'Hilt_'. */
+ public abstract ClassName generatedClassName();
+
+ /** Returns {@code true} if the class requires bytecode injection to replace the base class. */
+ public abstract boolean requiresBytecodeInjection();
+
+ /** Returns the {@link AndroidType} for the annotated element. */
+ public abstract AndroidType androidType();
+
+ /** Returns {@link Optional} of {@link AndroidEntryPointMetadata}. */
+ public abstract Optional<AndroidEntryPointMetadata> baseMetadata();
+
+ /** Returns set of scopes that the component interface should be installed in. */
+ public abstract ImmutableSet<ClassName> installInComponents();
+
+ /** Returns the component manager this generated Hilt class should use. */
+ public abstract TypeName componentManager();
+
+ /** Returns the initialization arguments for the component manager. */
+ public abstract Optional<CodeBlock> componentManagerInitArgs();
+
+ /**
+ * Returns the metadata for the root most class in the hierarchy.
+ *
+ * <p>If this is the only metadata in the class hierarchy, it returns this.
+ */
+ @Memoized
+ public AndroidEntryPointMetadata rootMetadata() {
+ return baseMetadata().map(AndroidEntryPointMetadata::rootMetadata).orElse(this);
+ }
+
+ boolean isRootMetadata() {
+ return this.equals(rootMetadata());
+ }
+
+ /** Returns true if this class allows optional injection. */
+ public boolean allowsOptionalInjection() {
+ return Processors.hasAnnotation(element(), AndroidClassNames.OPTIONAL_INJECT);
+ }
+
+ /** Returns true if any base class (transitively) allows optional injection. */
+ public boolean baseAllowsOptionalInjection() {
+ return baseMetadata().isPresent() && baseMetadata().get().allowsOptionalInjection();
+ }
+
+ /** Returns true if any base class (transitively) uses @AndroidEntryPoint. */
+ public boolean overridesAndroidEntryPointClass() {
+ return baseMetadata().isPresent();
+ }
+
+ /** The name of the class annotated with @AndroidEntryPoint */
+ public ClassName elementClassName() {
+ return ClassName.get(element());
+ }
+
+ /** The name of the base class given to @AndroidEntryPoint */
+ public TypeName baseClassName() {
+ return TypeName.get(baseElement().asType());
+ }
+
+ /** The name of the generated injector for the Hilt class. */
+ public ClassName injectorClassName() {
+ return Processors.append(
+ Processors.getEnclosedClassName(elementClassName()), "_GeneratedInjector");
+ }
+
+ /**
+ * The name of inject method for this class. The format is: inject$CLASS. If the class is nested,
+ * will return the full name deliminated with '_'. e.g. Foo.Bar.Baz -> injectFoo_Bar_Baz
+ */
+ public String injectMethodName() {
+ return "inject" + Processors.getEnclosedName(elementClassName());
+ }
+
+ /** Returns the @InstallIn annotation for the module providing this class. */
+ public final AnnotationSpec injectorInstallInAnnotation() {
+ return Components.getInstallInAnnotationSpec(installInComponents());
+ }
+
+ public ParameterSpec componentManagerParam() {
+ return ParameterSpec.builder(componentManager(), "componentManager").build();
+ }
+
+ /**
+ * Modifiers that should be applied to the generated class.
+ *
+ * <p>Note that the generated class must have public visibility if used by a
+ * public @AndroidEntryPoint-annotated kotlin class. See:
+ * https://discuss.kotlinlang.org/t/why-does-kotlin-prohibit-exposing-restricted-visibility-types/7047
+ */
+ public Modifier[] generatedClassModifiers() {
+ return isKotlinClass(element()) && element().getModifiers().contains(Modifier.PUBLIC)
+ ? new Modifier[] {Modifier.ABSTRACT, Modifier.PUBLIC}
+ : new Modifier[] {Modifier.ABSTRACT};
+ }
+
+ private static ClassName generatedClassName(TypeElement element) {
+ String prefix = "Hilt_";
+ return Processors.prepend(Processors.getEnclosedClassName(ClassName.get(element)), prefix);
+ }
+
+ private static final ImmutableSet<ClassName> HILT_ANNOTATION_NAMES =
+ ImmutableSet.of(
+ AndroidClassNames.HILT_ANDROID_APP,
+ AndroidClassNames.ANDROID_ENTRY_POINT);
+
+ private static ImmutableSet<? extends AnnotationMirror> hiltAnnotations(Element element) {
+ return element.getAnnotationMirrors().stream()
+ .filter(mirror -> HILT_ANNOTATION_NAMES.contains(ClassName.get(mirror.getAnnotationType())))
+ .collect(toImmutableSet());
+ }
+
+ /** Returns true if the given element has Android Entry Point metadata. */
+ public static boolean hasAndroidEntryPointMetadata(Element element) {
+ return !hiltAnnotations(element).isEmpty();
+ }
+
+ /** Returns the {@link AndroidEntryPointMetadata} for a @AndroidEntryPoint annotated element. */
+ public static AndroidEntryPointMetadata of(ProcessingEnvironment env, Element element) {
+ LinkedHashSet<Element> inheritanceTrace = new LinkedHashSet<>();
+ inheritanceTrace.add(element);
+ return of(env, element, inheritanceTrace);
+ }
+
+ public static AndroidEntryPointMetadata manuallyConstruct(
+ TypeElement element,
+ TypeElement baseElement,
+ ClassName generatedClassName,
+ boolean requiresBytecodeInjection,
+ AndroidType androidType,
+ Optional<AndroidEntryPointMetadata> baseMetadata,
+ ImmutableSet<ClassName> installInComponents,
+ TypeName componentManager,
+ Optional<CodeBlock> componentManagerInitArgs) {
+ return new AutoValue_AndroidEntryPointMetadata(
+ element,
+ baseElement,
+ generatedClassName,
+ requiresBytecodeInjection,
+ androidType,
+ baseMetadata,
+ installInComponents,
+ componentManager,
+ componentManagerInitArgs);
+ }
+
+ /**
+ * Internal implementation for "of" method, checking inheritance cycle utilizing inheritanceTrace
+ * along the way.
+ */
+ private static AndroidEntryPointMetadata of(
+ ProcessingEnvironment env, Element element, LinkedHashSet<Element> inheritanceTrace) {
+ ImmutableSet<? extends AnnotationMirror> hiltAnnotations = hiltAnnotations(element);
+ ProcessorErrors.checkState(
+ hiltAnnotations.size() == 1,
+ element,
+ "Expected exactly 1 of %s. Found: %s",
+ HILT_ANNOTATION_NAMES,
+ hiltAnnotations);
+ ClassName annotationClassName =
+ ClassName.get(
+ MoreTypes.asTypeElement(Iterables.getOnlyElement(hiltAnnotations).getAnnotationType()));
+
+ ProcessorErrors.checkState(
+ element.getKind() == ElementKind.CLASS,
+ element,
+ "Only classes can be annotated with @%s",
+ annotationClassName.simpleName());
+ TypeElement androidEntryPointElement = MoreElements.asType(element);
+
+ ProcessorErrors.checkState(
+ androidEntryPointElement.getTypeParameters().isEmpty(),
+ element,
+ "@%s-annotated classes cannot have type parameters.",
+ annotationClassName.simpleName());
+
+ final TypeElement androidEntryPointClassValue =
+ Processors.getAnnotationClassValue(
+ env.getElementUtils(),
+ Processors.getAnnotationMirror(androidEntryPointElement, annotationClassName),
+ "value");
+ final TypeElement baseElement;
+ final ClassName generatedClassName;
+ boolean requiresBytecodeInjection =
+ DISABLE_ANDROID_SUPERCLASS_VALIDATION.get(env)
+ && MoreTypes.isTypeOf(Void.class, androidEntryPointClassValue.asType());
+ if (requiresBytecodeInjection) {
+ baseElement = MoreElements.asType(env.getTypeUtils().asElement(androidEntryPointElement.getSuperclass()));
+ // If this AndroidEntryPoint is a Kotlin class and its base type is also Kotlin and has
+ // default values declared in its constructor then error out because for the short-form
+ // usage of @AndroidEntryPoint the bytecode transformation will be done incorrectly.
+ KotlinMetadataUtil metadataUtil = KotlinMetadataUtils.getMetadataUtil();
+ ProcessorErrors.checkState(
+ !metadataUtil.hasMetadata(androidEntryPointElement)
+ || !metadataUtil.containsConstructorWithDefaultParam(baseElement),
+ baseElement,
+ "The base class, '%s', of the @AndroidEntryPoint, '%s', contains a constructor with "
+ + "default parameters. This is currently not supported by the Gradle plugin. Either "
+ + "specify the base class as described at "
+ + "https://dagger.dev/hilt/gradle-setup#why-use-the-plugin or remove the default value "
+ + "declaration.",
+ baseElement.getQualifiedName(),
+ androidEntryPointElement.getQualifiedName());
+ generatedClassName = generatedClassName(androidEntryPointElement);
+ } else {
+ baseElement = androidEntryPointClassValue;
+ ProcessorErrors.checkState(
+ !MoreTypes.isTypeOf(Void.class, baseElement.asType()),
+ androidEntryPointElement,
+ "Expected @%s to have a value."
+ + " Did you forget to apply the Gradle Plugin? (dagger.hilt.android.plugin)\n"
+ + "See https://dagger.dev/hilt/gradle-setup.html" ,
+ annotationClassName.simpleName());
+
+ // Check that the root $CLASS extends Hilt_$CLASS
+ String extendsName =
+ env.getTypeUtils()
+ .asElement(androidEntryPointElement.getSuperclass())
+ .getSimpleName()
+ .toString();
+ generatedClassName = generatedClassName(androidEntryPointElement);
+ ProcessorErrors.checkState(
+ extendsName.contentEquals(generatedClassName.simpleName()),
+ androidEntryPointElement,
+ "@%s class expected to extend %s. Found: %s",
+ annotationClassName.simpleName(),
+ generatedClassName.simpleName(),
+ extendsName);
+ }
+
+ Optional<AndroidEntryPointMetadata> baseMetadata =
+ baseMetadata(env, androidEntryPointElement, baseElement, inheritanceTrace);
+
+ if (baseMetadata.isPresent()) {
+ return manuallyConstruct(
+ androidEntryPointElement,
+ baseElement,
+ generatedClassName,
+ requiresBytecodeInjection,
+ baseMetadata.get().androidType(),
+ baseMetadata,
+ baseMetadata.get().installInComponents(),
+ baseMetadata.get().componentManager(),
+ baseMetadata.get().componentManagerInitArgs());
+ } else {
+ Type type = Type.of(androidEntryPointElement, baseElement);
+ return manuallyConstruct(
+ androidEntryPointElement,
+ baseElement,
+ generatedClassName,
+ requiresBytecodeInjection,
+ type.androidType,
+ Optional.empty(),
+ ImmutableSet.of(type.component),
+ type.manager,
+ Optional.ofNullable(type.componentManagerInitArgs));
+ }
+ }
+
+ private static Optional<AndroidEntryPointMetadata> baseMetadata(
+ ProcessingEnvironment env,
+ TypeElement element,
+ TypeElement baseElement,
+ LinkedHashSet<Element> inheritanceTrace) {
+ ProcessorErrors.checkState(
+ inheritanceTrace.add(baseElement),
+ element,
+ cyclicInheritanceErrorMessage(inheritanceTrace, baseElement));
+ if (hasAndroidEntryPointMetadata(baseElement)) {
+ AndroidEntryPointMetadata baseMetadata =
+ AndroidEntryPointMetadata.of(env, baseElement, inheritanceTrace);
+ checkConsistentAnnotations(element, baseMetadata);
+ return Optional.of(baseMetadata);
+ }
+
+ TypeMirror superClass = baseElement.getSuperclass();
+ // None type is returned if this is an interface or Object
+ if (superClass.getKind() != TypeKind.NONE && superClass.getKind() != TypeKind.ERROR) {
+ Preconditions.checkState(superClass.getKind() == TypeKind.DECLARED);
+ return baseMetadata(env, element, MoreTypes.asTypeElement(superClass), inheritanceTrace);
+ }
+
+ return Optional.empty();
+ }
+
+ private static String cyclicInheritanceErrorMessage(
+ LinkedHashSet<Element> inheritanceTrace, TypeElement cycleEntryPoint) {
+ return String.format(
+ "Cyclic inheritance detected. Make sure the base class of @AndroidEntryPoint "
+ + "is not the annotated class itself or subclass of the annotated class.\n"
+ + "The cyclic inheritance structure: %s --> %s\n",
+ inheritanceTrace.stream()
+ .map(Element::asType)
+ .map(TypeMirror::toString)
+ .collect(Collectors.joining(" --> ")),
+ cycleEntryPoint.asType());
+ }
+
+ private static boolean isKotlinClass(TypeElement typeElement) {
+ return typeElement.getAnnotationMirrors().stream()
+ .map(mirror -> mirror.getAnnotationType())
+ .anyMatch(type -> ClassName.get(type).equals(ClassNames.KOTLIN_METADATA));
+ }
+
+ /**
+ * The Android type of the Android Entry Point element. Component splits (like with fragment
+ * bindings) are coalesced.
+ */
+ public enum AndroidType {
+ APPLICATION,
+ ACTIVITY,
+ BROADCAST_RECEIVER,
+ FRAGMENT,
+ SERVICE,
+ VIEW
+ }
+
+ /** The type of Android Entry Point element. This includes splits for different components. */
+ private static final class Type {
+ private static final Type APPLICATION =
+ new Type(
+ AndroidClassNames.SINGLETON_COMPONENT,
+ AndroidType.APPLICATION,
+ AndroidClassNames.APPLICATION_COMPONENT_MANAGER,
+ null);
+ private static final Type SERVICE =
+ new Type(
+ AndroidClassNames.SERVICE_COMPONENT,
+ AndroidType.SERVICE,
+ AndroidClassNames.SERVICE_COMPONENT_MANAGER,
+ CodeBlock.of("this"));
+ private static final Type BROADCAST_RECEIVER =
+ new Type(
+ AndroidClassNames.SINGLETON_COMPONENT,
+ AndroidType.BROADCAST_RECEIVER,
+ AndroidClassNames.BROADCAST_RECEIVER_COMPONENT_MANAGER,
+ null);
+ private static final Type ACTIVITY =
+ new Type(
+ AndroidClassNames.ACTIVITY_COMPONENT,
+ AndroidType.ACTIVITY,
+ AndroidClassNames.ACTIVITY_COMPONENT_MANAGER,
+ CodeBlock.of("this"));
+ private static final Type FRAGMENT =
+ new Type(
+ AndroidClassNames.FRAGMENT_COMPONENT,
+ AndroidType.FRAGMENT,
+ AndroidClassNames.FRAGMENT_COMPONENT_MANAGER,
+ CodeBlock.of("this"));
+ private static final Type VIEW =
+ new Type(
+ AndroidClassNames.VIEW_WITH_FRAGMENT_COMPONENT,
+ AndroidType.VIEW,
+ AndroidClassNames.VIEW_COMPONENT_MANAGER,
+ CodeBlock.of("this, true /* hasFragmentBindings */"));
+ private static final Type VIEW_NO_FRAGMENT =
+ new Type(
+ AndroidClassNames.VIEW_COMPONENT,
+ AndroidType.VIEW,
+ AndroidClassNames.VIEW_COMPONENT_MANAGER,
+ CodeBlock.of("this, false /* hasFragmentBindings */"));
+
+ final ClassName component;
+ final AndroidType androidType;
+ final ClassName manager;
+ final CodeBlock componentManagerInitArgs;
+
+ Type(
+ ClassName component,
+ AndroidType androidType,
+ ClassName manager,
+ CodeBlock componentManagerInitArgs) {
+ this.component = component;
+ this.androidType = androidType;
+ this.manager = manager;
+ this.componentManagerInitArgs = componentManagerInitArgs;
+ }
+
+ AndroidType androidType() {
+ return androidType;
+ }
+
+ private static Type of(TypeElement element, TypeElement baseElement) {
+ if (Processors.hasAnnotation(element, AndroidClassNames.HILT_ANDROID_APP)) {
+ return forHiltAndroidApp(element, baseElement);
+ }
+ return forAndroidEntryPoint(element, baseElement);
+ }
+
+ private static Type forHiltAndroidApp(TypeElement element, TypeElement baseElement) {
+ ProcessorErrors.checkState(
+ Processors.isAssignableFrom(baseElement, AndroidClassNames.APPLICATION),
+ element,
+ "@HiltAndroidApp base class must extend Application. Found: %s",
+ baseElement);
+ return Type.APPLICATION;
+ }
+
+ private static Type forAndroidEntryPoint(TypeElement element, TypeElement baseElement) {
+ if (Processors.isAssignableFrom(baseElement, AndroidClassNames.ACTIVITY)) {
+ ProcessorErrors.checkState(
+ Processors.isAssignableFrom(baseElement, AndroidClassNames.COMPONENT_ACTIVITY),
+ element,
+ "Activities annotated with @AndroidEntryPoint must be a subclass of "
+ + "androidx.activity.ComponentActivity. (e.g. FragmentActivity, "
+ + "AppCompatActivity, etc.)"
+ );
+ return Type.ACTIVITY;
+ } else if (Processors.isAssignableFrom(baseElement, AndroidClassNames.SERVICE)) {
+ return Type.SERVICE;
+ } else if (Processors.isAssignableFrom(baseElement, AndroidClassNames.BROADCAST_RECEIVER)) {
+ return Type.BROADCAST_RECEIVER;
+ } else if (Processors.isAssignableFrom(baseElement, AndroidClassNames.FRAGMENT)) {
+ return Type.FRAGMENT;
+ } else if (Processors.isAssignableFrom(baseElement, AndroidClassNames.VIEW)) {
+ boolean withFragmentBindings =
+ Processors.hasAnnotation(element, AndroidClassNames.WITH_FRAGMENT_BINDINGS);
+ return withFragmentBindings ? Type.VIEW : Type.VIEW_NO_FRAGMENT;
+ } else if (Processors.isAssignableFrom(baseElement, AndroidClassNames.APPLICATION)) {
+ throw new BadInputException(
+ "@AndroidEntryPoint cannot be used on an Application. Use @HiltAndroidApp instead.",
+ element);
+ }
+ throw new BadInputException(
+ "@AndroidEntryPoint base class must extend ComponentActivity, (support) Fragment, "
+ + "View, Service, or BroadcastReceiver.",
+ element);
+ }
+ }
+
+ private static void checkConsistentAnnotations(
+ TypeElement element, AndroidEntryPointMetadata baseMetadata) {
+ TypeElement baseElement = baseMetadata.element();
+ checkAnnotationsMatch(element, baseElement, AndroidClassNames.WITH_FRAGMENT_BINDINGS);
+
+ ProcessorErrors.checkState(
+ baseMetadata.allowsOptionalInjection()
+ || !Processors.hasAnnotation(element, AndroidClassNames.OPTIONAL_INJECT),
+ element,
+ "@OptionalInject Hilt class cannot extend from a non-optional @AndroidEntryPoint "
+ + "base: %s",
+ element);
+ }
+
+ private static void checkAnnotationsMatch(
+ TypeElement element, TypeElement baseElement, ClassName annotationName) {
+ boolean isAnnotated = Processors.hasAnnotation(element, annotationName);
+ boolean isBaseAnnotated = Processors.hasAnnotation(baseElement, annotationName);
+ ProcessorErrors.checkState(
+ isAnnotated == isBaseAnnotated,
+ element,
+ isBaseAnnotated
+ ? "Classes that extend an @%1$s base class must also be annotated @%1$s"
+ : "Classes that extend a @AndroidEntryPoint base class must not use @%1$s when the "
+ + "base class "
+ + "does not use @%1$s",
+ annotationName.simpleName());
+ }
+}
diff --git a/java/dagger/hilt/android/processor/internal/androidentrypoint/AndroidEntryPointProcessor.java b/java/dagger/hilt/android/processor/internal/androidentrypoint/AndroidEntryPointProcessor.java
new file mode 100644
index 0000000..7bb9b9a
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/androidentrypoint/AndroidEntryPointProcessor.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.androidentrypoint;
+
+import static net.ltgt.gradle.incap.IncrementalAnnotationProcessorType.ISOLATING;
+
+import com.google.auto.service.AutoService;
+import com.google.common.collect.ImmutableSet;
+import dagger.hilt.android.processor.internal.AndroidClassNames;
+import dagger.hilt.processor.internal.BaseProcessor;
+import java.util.Set;
+import javax.annotation.processing.Processor;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import net.ltgt.gradle.incap.IncrementalAnnotationProcessor;
+
+/**
+ * Processor that creates a module for classes marked with {@link
+ * dagger.hilt.android.AndroidEntryPoint}.
+ */
+@IncrementalAnnotationProcessor(ISOLATING)
+@AutoService(Processor.class)
+public final class AndroidEntryPointProcessor extends BaseProcessor {
+
+ @Override
+ public Set<String> getSupportedAnnotationTypes() {
+ return ImmutableSet.of(
+ AndroidClassNames.ANDROID_ENTRY_POINT.toString(),
+ AndroidClassNames.HILT_ANDROID_APP.toString());
+ }
+
+ @Override
+ public Set<String> getSupportedOptions() {
+ return HiltCompilerOptions.getProcessorOptions();
+ }
+
+ @Override
+ public boolean delayErrors() {
+ return true;
+ }
+
+ @Override
+ public void processEach(TypeElement annotation, Element element) throws Exception {
+ AndroidEntryPointMetadata metadata = AndroidEntryPointMetadata.of(getProcessingEnv(), element);
+ new InjectorEntryPointGenerator(getProcessingEnv(), metadata).generate();
+ switch (metadata.androidType()) {
+ case APPLICATION:
+ new ApplicationGenerator(getProcessingEnv(), metadata).generate();
+ break;
+ case ACTIVITY:
+ new ActivityGenerator(getProcessingEnv(), metadata).generate();
+ break;
+ case BROADCAST_RECEIVER:
+ new BroadcastReceiverGenerator(getProcessingEnv(), metadata).generate();
+ break;
+ case FRAGMENT:
+ new FragmentGenerator(
+ getProcessingEnv(), metadata )
+ .generate();
+ break;
+ case SERVICE:
+ new ServiceGenerator(getProcessingEnv(), metadata).generate();
+ break;
+ case VIEW:
+ new ViewGenerator(getProcessingEnv(), metadata).generate();
+ break;
+ default:
+ throw new IllegalStateException("Unknown Hilt type: " + metadata.androidType());
+ }
+ }
+}
diff --git a/java/dagger/hilt/android/processor/internal/androidentrypoint/ApplicationGenerator.java b/java/dagger/hilt/android/processor/internal/androidentrypoint/ApplicationGenerator.java
new file mode 100644
index 0000000..f16e06d
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/androidentrypoint/ApplicationGenerator.java
@@ -0,0 +1,162 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.androidentrypoint;
+
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterSpec;
+import com.squareup.javapoet.TypeName;
+import com.squareup.javapoet.TypeSpec;
+import com.squareup.javapoet.TypeVariableName;
+import dagger.hilt.android.processor.internal.AndroidClassNames;
+import dagger.hilt.processor.internal.ComponentNames;
+import dagger.hilt.processor.internal.Processors;
+import java.io.IOException;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.Modifier;
+
+/** Generates an Hilt Application for an @AndroidEntryPoint app class. */
+public final class ApplicationGenerator {
+ private final ProcessingEnvironment env;
+ private final AndroidEntryPointMetadata metadata;
+ private final ClassName wrapperClassName;
+
+ public ApplicationGenerator(ProcessingEnvironment env, AndroidEntryPointMetadata metadata) {
+ this.env = env;
+ this.metadata = metadata;
+ wrapperClassName = metadata.generatedClassName();
+ }
+
+ // @Generated("ApplicationGenerator")
+ // abstract class Hilt_$APP extends $BASE implements ComponentManager<ApplicationComponent> {
+ // ...
+ // }
+ public void generate() throws IOException {
+ TypeSpec.Builder typeSpecBuilder =
+ TypeSpec.classBuilder(wrapperClassName.simpleName())
+ .addOriginatingElement(metadata.element())
+ .superclass(metadata.baseClassName())
+ .addModifiers(metadata.generatedClassModifiers())
+ .addField(componentManagerField())
+ .addMethod(componentManagerMethod());
+
+ Generators.addGeneratedBaseClassJavadoc(typeSpecBuilder, AndroidClassNames.HILT_ANDROID_APP);
+ Processors.addGeneratedAnnotation(typeSpecBuilder, env, getClass());
+
+ metadata.baseElement().getTypeParameters().stream()
+ .map(TypeVariableName::get)
+ .forEachOrdered(typeSpecBuilder::addTypeVariable);
+
+ Generators.copyLintAnnotations(metadata.element(), typeSpecBuilder);
+ Generators.addComponentOverride(metadata, typeSpecBuilder);
+
+ typeSpecBuilder.addMethod(onCreateMethod());
+
+ JavaFile.builder(metadata.elementClassName().packageName(), typeSpecBuilder.build())
+ .build()
+ .writeTo(env.getFiler());
+ }
+
+ // private final ApplicationComponentManager<ApplicationComponent> componentManager =
+ // new ApplicationComponentManager(/* creatorType */);
+ private FieldSpec componentManagerField() {
+ ParameterSpec managerParam = metadata.componentManagerParam();
+ return FieldSpec.builder(managerParam.type, managerParam.name)
+ .addModifiers(Modifier.PRIVATE, Modifier.FINAL)
+ .initializer("new $T($L)", AndroidClassNames.APPLICATION_COMPONENT_MANAGER, creatorType())
+ .build();
+ }
+
+ // protected ApplicationComponentManager<ApplicationComponent> componentManager() {
+ // return componentManager();
+ // }
+ private MethodSpec componentManagerMethod() {
+ return MethodSpec.methodBuilder("componentManager")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
+ .returns(metadata.componentManagerParam().type)
+ .addStatement("return $N", metadata.componentManagerParam())
+ .build();
+ }
+
+ // new Supplier<ApplicationComponent>() {
+ // @Override
+ // public ApplicationComponent get() {
+ // return DaggerApplicationComponent.builder()
+ // .applicationContextModule(new ApplicationContextModule(Hilt_$APP.this))
+ // .build();
+ // }
+ // }
+ private TypeSpec creatorType() {
+ ClassName component =
+ ComponentNames.generatedComponent(
+ metadata.elementClassName(), AndroidClassNames.SINGLETON_COMPONENT);
+ return TypeSpec.anonymousClassBuilder("")
+ .addSuperinterface(AndroidClassNames.COMPONENT_SUPPLIER)
+ .addMethod(
+ MethodSpec.methodBuilder("get")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC)
+ .returns(TypeName.OBJECT)
+ .addStatement(
+ "return $T.builder()\n"
+ + ".applicationContextModule(new $T($T.this))\n"
+ + ".build()",
+ Processors.prepend(Processors.getEnclosedClassName(component), "Dagger"),
+ AndroidClassNames.APPLICATION_CONTEXT_MODULE,
+ wrapperClassName)
+ .build())
+ .build();
+ }
+
+ // @CallSuper
+ // @Override
+ // public void onCreate() {
+ // // This is a known unsafe cast but should be fine if the only use is
+ // // $APP extends Hilt_$APP
+ // generatedComponent().inject(($APP) this);
+ // super.onCreate();
+ // }
+ private MethodSpec onCreateMethod() {
+ return MethodSpec.methodBuilder("onCreate")
+ .addAnnotation(AndroidClassNames.CALL_SUPER)
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC)
+ .addCode(injectCodeBlock())
+ .addStatement("super.onCreate()")
+ .build();
+ }
+
+ // // This is a known unsafe cast but should be fine if the only use is
+ // // $APP extends Hilt_$APP
+ // generatedComponent().inject$APP(($APP) this);
+ private CodeBlock injectCodeBlock() {
+ return CodeBlock.builder()
+ .add("// This is a known unsafe cast, but is safe in the only correct use case:\n")
+ .add("// $T extends $T\n", metadata.elementClassName(), metadata.generatedClassName())
+ .addStatement(
+ "(($T) generatedComponent()).$L($L)",
+ metadata.injectorClassName(),
+ metadata.injectMethodName(),
+ Generators.unsafeCastThisTo(metadata.elementClassName()))
+ .build();
+ }
+}
diff --git a/java/dagger/hilt/android/processor/internal/androidentrypoint/BUILD b/java/dagger/hilt/android/processor/internal/androidentrypoint/BUILD
new file mode 100644
index 0000000..55e9ddc
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/androidentrypoint/BUILD
@@ -0,0 +1,109 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# Description:
+# Hilt android processors.
+
+package(default_visibility = ["//:src"])
+
+java_plugin(
+ name = "plugin",
+ generates_api = 1,
+ processor_class = "dagger.hilt.android.processor.internal.androidentrypoint.AndroidEntryPointProcessor",
+ tags = [
+ "annotation=dagger.hilt.android.AndroidEntryPoint;" +
+ "genclass=${package}.Hilt_${outerclasses}${classname};" +
+ "genclass=${package}.${outerclasses}${classname}_EntryPoint",
+ ],
+ deps = [
+ ":processor_lib",
+ ],
+)
+
+java_library(
+ name = "processor_lib",
+ srcs = ["AndroidEntryPointProcessor.java"],
+ deps = [
+ ":android_generators",
+ ":compiler_options",
+ ":metadata",
+ "//java/dagger/hilt/android/processor/internal:android_classnames",
+ "//java/dagger/hilt/processor/internal:base_processor",
+ "//java/dagger/hilt/processor/internal:processors",
+ "//java/dagger/internal/guava:collect",
+ "@google_bazel_common//third_party/java/auto:service",
+ "@google_bazel_common//third_party/java/incap",
+ ],
+)
+
+java_library(
+ name = "android_generators",
+ srcs = [
+ "ActivityGenerator.java",
+ "ApplicationGenerator.java",
+ "BroadcastReceiverGenerator.java",
+ "FragmentGenerator.java",
+ "Generators.java",
+ "InjectorEntryPointGenerator.java",
+ "ServiceGenerator.java",
+ "ViewGenerator.java",
+ ],
+ deps = [
+ ":metadata",
+ "//java/dagger/hilt/android/processor/internal:android_classnames",
+ "//java/dagger/hilt/android/processor/internal:utils",
+ "//java/dagger/hilt/processor/internal:classnames",
+ "//java/dagger/hilt/processor/internal:component_names",
+ "//java/dagger/hilt/processor/internal:processor_errors",
+ "//java/dagger/hilt/processor/internal:processors",
+ "//java/dagger/internal/codegen/extension",
+ "//java/dagger/internal/codegen/langmodel",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "@google_bazel_common//third_party/java/javapoet",
+ "@maven//:com_google_auto_auto_common",
+ ],
+)
+
+java_library(
+ name = "metadata",
+ srcs = [
+ "AndroidEntryPointMetadata.java",
+ ],
+ deps = [
+ ":compiler_options",
+ "//java/dagger/hilt/android/processor/internal:android_classnames",
+ "//java/dagger/hilt/processor/internal:classnames",
+ "//java/dagger/hilt/processor/internal:components",
+ "//java/dagger/hilt/processor/internal:kotlin",
+ "//java/dagger/hilt/processor/internal:processor_errors",
+ "//java/dagger/hilt/processor/internal:processors",
+ "//java/dagger/internal/codegen/extension",
+ "//java/dagger/internal/codegen/kotlin",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "@google_bazel_common//third_party/java/auto:value",
+ "@google_bazel_common//third_party/java/javapoet",
+ "@maven//:com_google_auto_auto_common",
+ ],
+)
+
+java_library(
+ name = "compiler_options",
+ srcs = ["HiltCompilerOptions.java"],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/android/processor/internal/androidentrypoint/BroadcastReceiverGenerator.java b/java/dagger/hilt/android/processor/internal/androidentrypoint/BroadcastReceiverGenerator.java
new file mode 100644
index 0000000..f8e9f60
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/androidentrypoint/BroadcastReceiverGenerator.java
@@ -0,0 +1,153 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.androidentrypoint;
+
+import static dagger.internal.codegen.langmodel.DaggerElements.getMethodDescriptor;
+
+import com.google.common.collect.Iterables;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterSpec;
+import com.squareup.javapoet.TypeName;
+import com.squareup.javapoet.TypeSpec;
+import com.squareup.javapoet.TypeVariableName;
+import dagger.hilt.android.processor.internal.AndroidClassNames;
+import dagger.hilt.android.processor.internal.MoreTypes;
+import dagger.hilt.processor.internal.Processors;
+import java.io.IOException;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.util.ElementFilter;
+
+/** Generates an Hilt BroadcastReceiver class for the @AndroidEntryPoint annotated class. */
+public final class BroadcastReceiverGenerator {
+
+ private static final String ON_RECEIVE_DESCRIPTOR =
+ "onReceive(Landroid/content/Context;Landroid/content/Intent;)V";
+
+ private final ProcessingEnvironment env;
+ private final AndroidEntryPointMetadata metadata;
+ private final ClassName generatedClassName;
+
+ public BroadcastReceiverGenerator(
+ ProcessingEnvironment env, AndroidEntryPointMetadata metadata) {
+ this.env = env;
+ this.metadata = metadata;
+
+ generatedClassName = metadata.generatedClassName();
+ }
+
+ // @Generated("BroadcastReceiverGenerator")
+ // abstract class Hilt_$CLASS extends $BASE {
+ // ...
+ // }
+ public void generate() throws IOException {
+ TypeSpec.Builder builder =
+ TypeSpec.classBuilder(generatedClassName.simpleName())
+ .addOriginatingElement(metadata.element())
+ .superclass(metadata.baseClassName())
+ .addModifiers(metadata.generatedClassModifiers())
+ .addMethod(onReceiveMethod());
+
+ Generators.addGeneratedBaseClassJavadoc(builder, AndroidClassNames.ANDROID_ENTRY_POINT);
+ Processors.addGeneratedAnnotation(builder, env, getClass());
+ Generators.copyConstructors(metadata.baseElement(), builder);
+
+ metadata.baseElement().getTypeParameters().stream()
+ .map(TypeVariableName::get)
+ .forEachOrdered(builder::addTypeVariable);
+
+ Generators.addInjectionMethods(metadata, builder);
+ Generators.copyLintAnnotations(metadata.element(), builder);
+
+ // Add an unused field used as a marker to let the bytecode injector know this receiver will
+ // need to be injected with a super.onReceive call. This is only necessary if no concrete
+ // onReceive call is implemented in any of the super classes.
+ if (metadata.requiresBytecodeInjection() && !isOnReceiveImplemented(metadata.baseElement())) {
+ builder.addField(
+ FieldSpec.builder(
+ TypeName.BOOLEAN,
+ "onReceiveBytecodeInjectionMarker",
+ Modifier.PRIVATE,
+ Modifier.FINAL)
+ .initializer("false")
+ .build());
+ }
+
+ JavaFile.builder(generatedClassName.packageName(),
+ builder.build()).build().writeTo(env.getFiler());
+ }
+
+ private static boolean isOnReceiveImplemented(TypeElement typeElement) {
+ boolean isImplemented =
+ ElementFilter.methodsIn(typeElement.getEnclosedElements()).stream()
+ .anyMatch(
+ methodElement ->
+ getMethodDescriptor(methodElement).equals(ON_RECEIVE_DESCRIPTOR)
+ && !methodElement.getModifiers().contains(Modifier.ABSTRACT));
+ if (isImplemented) {
+ return true;
+ } else if (typeElement.getSuperclass().getKind() != TypeKind.NONE) {
+ return isOnReceiveImplemented(MoreTypes.asTypeElement(typeElement.getSuperclass()));
+ } else {
+ return false;
+ }
+ }
+
+ // @Override
+ // public void onReceive(Context context, Intent intent) {
+ // inject(context);
+ // super.onReceive();
+ // }
+ private MethodSpec onReceiveMethod() throws IOException {
+ MethodSpec.Builder method =
+ MethodSpec.methodBuilder("onReceive")
+ .addAnnotation(Override.class)
+ .addAnnotation(AndroidClassNames.CALL_SUPER)
+ .addModifiers(Modifier.PUBLIC)
+ .addParameter(ParameterSpec.builder(AndroidClassNames.CONTEXT, "context").build())
+ .addParameter(ParameterSpec.builder(AndroidClassNames.INTENT, "intent").build())
+ .addStatement("inject(context)");
+
+ if (metadata.overridesAndroidEntryPointClass()) {
+ // We directly call super.onReceive here because we know Hilt base classes have a
+ // non-abstract onReceive method. However, because the Hilt base class may not be generated
+ // already we cannot fall down to the below logic to find it.
+ method.addStatement("super.onReceive(context, intent)");
+ } else {
+ // Get the onReceive method element from BroadcastReceiver.
+ ExecutableElement onReceiveElement =
+ Iterables.getOnlyElement(
+ MoreTypes.findMethods(
+ env.getElementUtils()
+ .getTypeElement(AndroidClassNames.BROADCAST_RECEIVER.toString()),
+ "onReceive"));
+
+ // If the base class or one of its super classes implements onReceive, call super.onReceive()
+ MoreTypes.findInheritedMethod(env.getTypeUtils(), metadata.baseElement(), onReceiveElement)
+ .filter(onReceive -> !onReceive.getModifiers().contains(Modifier.ABSTRACT))
+ .ifPresent(onReceive -> method.addStatement("super.onReceive(context, intent)"));
+ }
+
+ return method.build();
+ }
+}
diff --git a/java/dagger/hilt/android/processor/internal/androidentrypoint/FragmentGenerator.java b/java/dagger/hilt/android/processor/internal/androidentrypoint/FragmentGenerator.java
new file mode 100644
index 0000000..4ef479f
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/androidentrypoint/FragmentGenerator.java
@@ -0,0 +1,217 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.androidentrypoint;
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.TypeSpec;
+import com.squareup.javapoet.TypeVariableName;
+import dagger.hilt.android.processor.internal.AndroidClassNames;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.Processors;
+import java.io.IOException;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.Modifier;
+
+/** Generates an Hilt Fragment class for the @AndroidEntryPoint annotated class. */
+public final class FragmentGenerator {
+ private static final FieldSpec COMPONENT_CONTEXT_FIELD =
+ FieldSpec.builder(AndroidClassNames.CONTEXT_WRAPPER, "componentContext")
+ .addModifiers(Modifier.PRIVATE)
+ .build();
+
+ private final ProcessingEnvironment env;
+ private final AndroidEntryPointMetadata metadata;
+ private final ClassName generatedClassName;
+
+ public FragmentGenerator(
+ ProcessingEnvironment env,
+ AndroidEntryPointMetadata metadata ) {
+ this.env = env;
+ this.metadata = metadata;
+ generatedClassName = metadata.generatedClassName();
+ }
+
+ public void generate() throws IOException {
+ JavaFile.builder(generatedClassName.packageName(), createTypeSpec())
+ .build()
+ .writeTo(env.getFiler());
+ }
+
+ // @Generated("FragmentGenerator")
+ // abstract class Hilt_$CLASS extends $BASE implements ComponentManager<?> {
+ // ...
+ // }
+ TypeSpec createTypeSpec() {
+ TypeSpec.Builder builder =
+ TypeSpec.classBuilder(generatedClassName.simpleName())
+ .addOriginatingElement(metadata.element())
+ .superclass(metadata.baseClassName())
+ .addModifiers(metadata.generatedClassModifiers())
+ .addField(COMPONENT_CONTEXT_FIELD)
+ .addMethod(onAttachContextMethod())
+ .addMethod(onAttachActivityMethod())
+ .addMethod(initializeComponentContextMethod())
+ .addMethod(getContextMethod())
+ .addMethod(inflatorMethod());
+
+ Generators.addGeneratedBaseClassJavadoc(builder, AndroidClassNames.ANDROID_ENTRY_POINT);
+ Processors.addGeneratedAnnotation(builder, env, getClass());
+ Generators.copyLintAnnotations(metadata.element(), builder);
+ Generators.addSuppressAnnotation(builder, "deprecation");
+ Generators.copyConstructors(metadata.baseElement(), builder);
+
+ metadata.baseElement().getTypeParameters().stream()
+ .map(TypeVariableName::get)
+ .forEachOrdered(builder::addTypeVariable);
+
+ Generators.addComponentOverride(metadata, builder);
+
+ Generators.addInjectionMethods(metadata, builder);
+
+ if (!metadata.overridesAndroidEntryPointClass() ) {
+ builder.addMethod(getDefaultViewModelProviderFactory());
+ }
+
+ return builder.build();
+ }
+
+ // @CallSuper
+ // @Override
+ // public void onAttach(Activity activity) {
+ // super.onAttach(activity);
+ // initializeComponentContext();
+ // }
+ private static MethodSpec onAttachContextMethod() {
+ return MethodSpec.methodBuilder("onAttach")
+ .addAnnotation(Override.class)
+ .addAnnotation(AndroidClassNames.CALL_SUPER)
+ .addModifiers(Modifier.PUBLIC)
+ .addParameter(AndroidClassNames.CONTEXT, "context")
+ .addStatement("super.onAttach(context)")
+ .addStatement("initializeComponentContext()")
+ .build();
+ }
+
+ // @CallSuper
+ // @Override
+ // public void onAttach(Activity activity) {
+ // super.onAttach(activity);
+ // Preconditions.checkState(
+ // componentContext == null || FragmentComponentManager.findActivity(
+ // componentContext) == activity, "...");
+ // initializeComponentContext();
+ // }
+ private static MethodSpec onAttachActivityMethod() {
+ return MethodSpec.methodBuilder("onAttach")
+ .addAnnotation(Override.class)
+ .addAnnotation(AndroidClassNames.CALL_SUPER)
+ .addAnnotation(AndroidClassNames.MAIN_THREAD)
+ .addModifiers(Modifier.PUBLIC)
+ .addParameter(AndroidClassNames.ACTIVITY, "activity")
+ .addStatement("super.onAttach(activity)")
+ .addStatement(
+ "$T.checkState($N == null || $T.findActivity($N) == activity, $S)",
+ ClassNames.PRECONDITIONS,
+ COMPONENT_CONTEXT_FIELD,
+ AndroidClassNames.FRAGMENT_COMPONENT_MANAGER,
+ COMPONENT_CONTEXT_FIELD,
+ "onAttach called multiple times with different Context! "
+ + "Hilt Fragments should not be retained.")
+ .addStatement("initializeComponentContext()")
+ .build();
+ }
+
+ // private void initializeComponentContext() {
+ // // Only inject on the first call to onAttach.
+ // if (componentContext == null) {
+ // // Note: The LayoutInflater provided by this componentContext may be different from super
+ // // Fragment's because we are getting it from base context instead of cloning from super
+ // // Fragment's LayoutInflater.
+ // componentContext = FragmentComponentManager.createContextWrapper(super.getContext(), this);
+ // inject();
+ // }
+ // }
+ private MethodSpec initializeComponentContextMethod() {
+ return MethodSpec.methodBuilder("initializeComponentContext")
+ .addModifiers(Modifier.PRIVATE)
+ .addComment("Only inject on the first call to onAttach.")
+ .beginControlFlow("if ($N == null)", COMPONENT_CONTEXT_FIELD)
+ .addComment(
+ "Note: The LayoutInflater provided by this componentContext may be different from"
+ + " super Fragment's because we getting it from base context instead of cloning"
+ + " from the super Fragment's LayoutInflater.")
+ .addStatement(
+ "$N = $T.createContextWrapper(super.getContext(), this)",
+ COMPONENT_CONTEXT_FIELD,
+ metadata.componentManager())
+ .addStatement("inject()")
+ .endControlFlow()
+ .build();
+ }
+
+ // @Override
+ // public Context getContext() {
+ // return componentContext;
+ // }
+ private static MethodSpec getContextMethod() {
+ return MethodSpec.methodBuilder("getContext")
+ .returns(AndroidClassNames.CONTEXT)
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC)
+ .addStatement("return $N", COMPONENT_CONTEXT_FIELD)
+ .build();
+ }
+
+ // @Override
+ // public LayoutInflater onGetLayoutInflater(Bundle savedInstanceState) {
+ // LayoutInflater inflater = super.onGetLayoutInflater(savedInstanceState);
+ // return LayoutInflater.from(FragmentComponentManager.createContextWrapper(inflater, this));
+ // }
+ private MethodSpec inflatorMethod() {
+ return MethodSpec.methodBuilder("onGetLayoutInflater")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC)
+ .addParameter(AndroidClassNames.BUNDLE, "savedInstanceState")
+ .returns(AndroidClassNames.LAYOUT_INFLATER)
+ .addStatement(
+ "$T inflater = super.onGetLayoutInflater(savedInstanceState)",
+ AndroidClassNames.LAYOUT_INFLATER)
+ .addStatement(
+ "return $T.from($T.createContextWrapper(inflater, this))",
+ AndroidClassNames.LAYOUT_INFLATER,
+ metadata.componentManager())
+ .build();
+ }
+
+ // @Override
+ // public ViewModelProvider.Factory getDefaultViewModelProviderFactory() {
+ // return DefaultViewModelFactories.getFragmentFactory(this);
+ // }
+ private MethodSpec getDefaultViewModelProviderFactory() {
+ return MethodSpec.methodBuilder("getDefaultViewModelProviderFactory")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC)
+ .returns(AndroidClassNames.VIEW_MODEL_PROVIDER_FACTORY)
+ .addStatement(
+ "return $T.getFragmentFactory(this)",
+ AndroidClassNames.DEFAULT_VIEW_MODEL_FACTORIES)
+ .build();
+ }
+}
diff --git a/java/dagger/hilt/android/processor/internal/androidentrypoint/Generators.java b/java/dagger/hilt/android/processor/internal/androidentrypoint/Generators.java
new file mode 100644
index 0000000..daadd03
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/androidentrypoint/Generators.java
@@ -0,0 +1,493 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.androidentrypoint;
+
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static dagger.internal.codegen.extension.DaggerCollectors.toOptional;
+import static javax.lang.model.element.Modifier.PRIVATE;
+
+import com.google.common.base.Preconditions;
+import com.squareup.javapoet.AnnotationSpec;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterSpec;
+import com.squareup.javapoet.TypeName;
+import com.squareup.javapoet.TypeSpec;
+import dagger.hilt.android.processor.internal.AndroidClassNames;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.Processors;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.util.ElementFilter;
+
+/** Helper class for writing Hilt generators. */
+final class Generators {
+
+ static void addGeneratedBaseClassJavadoc(TypeSpec.Builder builder, ClassName annotation) {
+ builder.addJavadoc("A generated base class to be extended by the @$T annotated class. If using"
+ + " the Gradle plugin, this is swapped as the base class via bytecode transformation.",
+ annotation);
+ }
+
+ /**
+ * Copies all constructors with arguments to the builder.
+ */
+ static void copyConstructors(TypeElement baseClass, TypeSpec.Builder builder) {
+ copyConstructors(baseClass, CodeBlock.builder().build(), builder);
+ }
+
+ /**
+ * Copies all constructors with arguments along with an appended body to the builder.
+ */
+ static void copyConstructors(TypeElement baseClass, CodeBlock body, TypeSpec.Builder builder) {
+ List<ExecutableElement> constructors =
+ ElementFilter.constructorsIn(baseClass.getEnclosedElements())
+ .stream()
+ .filter(constructor -> !constructor.getModifiers().contains(PRIVATE))
+ .collect(Collectors.toList());
+
+ if (constructors.size() == 1
+ && getOnlyElement(constructors).getParameters().isEmpty()
+ && body.isEmpty()) {
+ // No need to copy the constructor if the default constructor will handle it.
+ return;
+ }
+
+ constructors.forEach(constructor -> builder.addMethod(copyConstructor(constructor, body)));
+ }
+
+ /** Returns Optional with AnnotationSpec for Nullable if found on element, empty otherwise. */
+ private static Optional<AnnotationSpec> getNullableAnnotationSpec(Element element) {
+ for (AnnotationMirror annotationMirror : element.getAnnotationMirrors()) {
+ if (annotationMirror
+ .getAnnotationType()
+ .asElement()
+ .getSimpleName()
+ .contentEquals("Nullable")) {
+ AnnotationSpec annotationSpec = AnnotationSpec.get(annotationMirror);
+ // If using the android internal Nullable, convert it to the externally-visible version.
+ return AndroidClassNames.NULLABLE_INTERNAL.equals(annotationSpec.type)
+ ? Optional.of(AnnotationSpec.builder(AndroidClassNames.NULLABLE).build())
+ : Optional.of(annotationSpec);
+ }
+ }
+ return Optional.empty();
+ }
+
+ /**
+ * Returns a ParameterSpec of the input parameter, @Nullable annotated if existing in original
+ * (this does not handle Nullable type annotations).
+ */
+ private static ParameterSpec getParameterSpecWithNullable(VariableElement parameter) {
+ ParameterSpec.Builder builder = ParameterSpec.get(parameter).toBuilder();
+ getNullableAnnotationSpec(parameter).ifPresent(builder::addAnnotation);
+ return builder.build();
+ }
+
+ /**
+ * Returns a {@link MethodSpec} for a constructor matching the given {@link ExecutableElement}
+ * constructor signature, and just calls super. If the constructor is
+ * {@link android.annotation.TargetApi} guarded, adds the TargetApi as well.
+ */
+ // Example:
+ // Foo(Param1 param1, Param2 param2) {
+ // super(param1, param2);
+ // }
+ static MethodSpec copyConstructor(ExecutableElement constructor) {
+ return copyConstructor(constructor, CodeBlock.builder().build());
+ }
+
+ private static MethodSpec copyConstructor(ExecutableElement constructor, CodeBlock body) {
+ List<ParameterSpec> params =
+ constructor.getParameters().stream()
+ .map(parameter -> getParameterSpecWithNullable(parameter))
+ .collect(Collectors.toList());
+
+ final MethodSpec.Builder builder =
+ MethodSpec.constructorBuilder()
+ .addParameters(params)
+ .addStatement(
+ "super($L)",
+ params.stream().map(param -> param.name).collect(Collectors.joining(", ")))
+ .addCode(body);
+
+ constructor.getAnnotationMirrors().stream()
+ .filter(a -> Processors.hasAnnotation(a, AndroidClassNames.TARGET_API))
+ .collect(toOptional())
+ .map(AnnotationSpec::get)
+ .ifPresent(builder::addAnnotation);
+
+ return builder.build();
+ }
+
+ /**
+ * Copies the Android lint annotations from the annotated element to the generated element.
+ *
+ * <p>Note: For now we only copy over {@link android.annotation.TargetApi}.
+ */
+ static void copyLintAnnotations(Element element, TypeSpec.Builder builder) {
+ if (Processors.hasAnnotation(element, AndroidClassNames.TARGET_API)) {
+ builder.addAnnotation(
+ AnnotationSpec.get(
+ Processors.getAnnotationMirror(element, AndroidClassNames.TARGET_API)));
+ }
+ }
+
+ // @Override
+ // public CompT generatedComponent() {
+ // return componentManager().generatedComponent();
+ // }
+ static void addComponentOverride(AndroidEntryPointMetadata metadata, TypeSpec.Builder builder) {
+ if (metadata.overridesAndroidEntryPointClass()) {
+ // We don't need to override this method if we are extending a Hilt type.
+ return;
+ }
+ builder
+ .addSuperinterface(ClassNames.GENERATED_COMPONENT_MANAGER_HOLDER)
+ .addMethod(
+ MethodSpec.methodBuilder("generatedComponent")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
+ .returns(TypeName.OBJECT)
+ .addStatement("return $L.generatedComponent()", componentManagerCallBlock(metadata))
+ .build());
+ }
+
+ /** Adds the inject() and optionally the componentManager() methods to allow for injection. */
+ static void addInjectionMethods(AndroidEntryPointMetadata metadata, TypeSpec.Builder builder) {
+ switch (metadata.androidType()) {
+ case ACTIVITY:
+ case FRAGMENT:
+ case VIEW:
+ case SERVICE:
+ addComponentManagerMethods(metadata, builder);
+ // fall through
+ case BROADCAST_RECEIVER:
+ addInjectMethod(metadata, builder);
+ break;
+ default:
+ throw new AssertionError();
+ }
+ }
+
+ // @Override
+ // public FragmentComponentManager componentManager() {
+ // if (componentManager == null) {
+ // synchronize (componentManagerLock) {
+ // if (componentManager == null) {
+ // componentManager = createComponentManager();
+ // }
+ // }
+ // }
+ // return componentManager;
+ // }
+ private static void addComponentManagerMethods(
+ AndroidEntryPointMetadata metadata, TypeSpec.Builder typeSpecBuilder) {
+ if (metadata.overridesAndroidEntryPointClass()) {
+ // We don't need to override this method if we are extending a Hilt type.
+ return;
+ }
+
+ ParameterSpec managerParam = metadata.componentManagerParam();
+ typeSpecBuilder.addField(componentManagerField(metadata));
+
+ typeSpecBuilder.addMethod(createComponentManagerMethod(metadata));
+
+ MethodSpec.Builder methodSpecBuilder =
+ MethodSpec.methodBuilder("componentManager")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
+ .returns(managerParam.type)
+ .beginControlFlow("if ($N == null)", managerParam);
+
+ // Views do not do double-checked locking because this is called from the constructor
+ if (metadata.androidType() != AndroidEntryPointMetadata.AndroidType.VIEW) {
+ typeSpecBuilder.addField(componentManagerLockField());
+
+ methodSpecBuilder
+ .beginControlFlow("synchronized (componentManagerLock)")
+ .beginControlFlow("if ($N == null)", managerParam);
+ }
+
+ methodSpecBuilder
+ .addStatement("$N = createComponentManager()", managerParam)
+ .endControlFlow();
+
+ if (metadata.androidType() != AndroidEntryPointMetadata.AndroidType.VIEW) {
+ methodSpecBuilder
+ .endControlFlow()
+ .endControlFlow();
+ }
+
+ methodSpecBuilder.addStatement("return $N", managerParam);
+
+ typeSpecBuilder.addMethod(methodSpecBuilder.build());
+ }
+
+ // protected FragmentComponentManager createComponentManager() {
+ // return new FragmentComponentManager(initArgs);
+ // }
+ private static MethodSpec createComponentManagerMethod(AndroidEntryPointMetadata metadata) {
+ Preconditions.checkState(
+ metadata.componentManagerInitArgs().isPresent(),
+ "This method should not have been called for metadata where the init args are not"
+ + " present.");
+ return MethodSpec.methodBuilder("createComponentManager")
+ .addModifiers(Modifier.PROTECTED)
+ .returns(metadata.componentManager())
+ .addStatement(
+ "return new $T($L)",
+ metadata.componentManager(),
+ metadata.componentManagerInitArgs().get())
+ .build();
+ }
+
+ // private volatile ComponentManager componentManager;
+ private static FieldSpec componentManagerField(AndroidEntryPointMetadata metadata) {
+ ParameterSpec managerParam = metadata.componentManagerParam();
+ FieldSpec.Builder builder = FieldSpec.builder(managerParam.type, managerParam.name)
+ .addModifiers(Modifier.PRIVATE);
+
+ // Views do not need volatile since these are set in the constructor if ever set.
+ if (metadata.androidType() != AndroidEntryPointMetadata.AndroidType.VIEW) {
+ builder.addModifiers(Modifier.VOLATILE);
+ }
+
+ return builder.build();
+ }
+
+ // private final Object componentManagerLock = new Object();
+ private static FieldSpec componentManagerLockField() {
+ return FieldSpec.builder(TypeName.get(Object.class), "componentManagerLock")
+ .addModifiers(Modifier.PRIVATE, Modifier.FINAL)
+ .initializer("new Object()")
+ .build();
+ }
+
+ // protected void inject() {
+ // if (!injected) {
+ // generatedComponent().inject$CLASS(($CLASS) this);
+ // injected = true;
+ // }
+ // }
+ private static void addInjectMethod(
+ AndroidEntryPointMetadata metadata, TypeSpec.Builder typeSpecBuilder) {
+ MethodSpec.Builder methodSpecBuilder = MethodSpec.methodBuilder("inject")
+ .addModifiers(Modifier.PROTECTED);
+
+ // Check if the parent is a Hilt type. If it isn't or if it is but it
+ // wasn't injected by hilt, then return.
+ // Object parent = ...depends on type...
+ // if (!(parent instanceof GeneratedComponentManager)
+ // || ((parent instanceof InjectedByHilt) &&
+ // !((InjectedByHilt) parent).wasInjectedByHilt())) {
+ // return;
+ //
+ if (metadata.allowsOptionalInjection()) {
+ methodSpecBuilder
+ .addStatement("$T parent = $L", ClassNames.OBJECT, getParentCodeBlock(metadata))
+ .beginControlFlow(
+ "if (!(parent instanceof $T) "
+ + "|| ((parent instanceof $T) && !(($T) parent).wasInjectedByHilt()))",
+ ClassNames.GENERATED_COMPONENT_MANAGER,
+ AndroidClassNames.INJECTED_BY_HILT,
+ AndroidClassNames.INJECTED_BY_HILT)
+ .addStatement("return")
+ .endControlFlow();
+ }
+
+ typeSpecBuilder.addField(injectedField(metadata));
+
+ switch (metadata.androidType()) {
+ case ACTIVITY:
+ case FRAGMENT:
+ case VIEW:
+ case SERVICE:
+ // Only add @Override if an ancestor extends a generated Hilt class.
+ // When using bytecode injection, this isn't always guaranteed.
+ if (metadata.overridesAndroidEntryPointClass()
+ && ancestorExtendsGeneratedHiltClass(metadata)) {
+ methodSpecBuilder.addAnnotation(Override.class);
+ }
+ methodSpecBuilder
+ .beginControlFlow("if (!injected)")
+ .addStatement("injected = true")
+ .addStatement(
+ "(($T) $L).$L($L)",
+ metadata.injectorClassName(),
+ generatedComponentCallBlock(metadata),
+ metadata.injectMethodName(),
+ unsafeCastThisTo(metadata.elementClassName()))
+ .endControlFlow();
+ break;
+ case BROADCAST_RECEIVER:
+ typeSpecBuilder.addField(injectedLockField());
+
+ methodSpecBuilder
+ .addParameter(ParameterSpec.builder(AndroidClassNames.CONTEXT, "context").build())
+ .beginControlFlow("if (!injected)")
+ .beginControlFlow("synchronized (injectedLock)")
+ .beginControlFlow("if (!injected)")
+ .addStatement(
+ "(($T) $T.generatedComponent(context)).$L($L)",
+ metadata.injectorClassName(),
+ metadata.componentManager(),
+ metadata.injectMethodName(),
+ unsafeCastThisTo(metadata.elementClassName()))
+ .addStatement("injected = true")
+ .endControlFlow()
+ .endControlFlow()
+ .endControlFlow();
+ break;
+ default:
+ throw new AssertionError();
+ }
+
+ // Also add a wasInjectedByHilt method if needed.
+ // Even if we aren't optionally injected, if we override an optionally injected Hilt class
+ // we also need to override the wasInjectedByHilt method.
+ if (metadata.allowsOptionalInjection() || metadata.baseAllowsOptionalInjection()) {
+ typeSpecBuilder.addMethod(
+ MethodSpec.methodBuilder("wasInjectedByHilt")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC)
+ .returns(boolean.class)
+ .addStatement("return injected")
+ .build());
+ // Only add the interface though if this class allows optional injection (not that it
+ // really matters since if the base allows optional injection the class implements the
+ // interface anyway). But it is probably better to be consistent about only optionally
+ // injected classes extend the interface.
+ if (metadata.allowsOptionalInjection()) {
+ typeSpecBuilder.addSuperinterface(AndroidClassNames.INJECTED_BY_HILT);
+ }
+ }
+
+ typeSpecBuilder.addMethod(methodSpecBuilder.build());
+ }
+
+ private static CodeBlock getParentCodeBlock(AndroidEntryPointMetadata metadata) {
+ switch (metadata.androidType()) {
+ case ACTIVITY:
+ case SERVICE:
+ return CodeBlock.of("getApplicationContext()");
+ case FRAGMENT:
+ return CodeBlock.of("getHost()");
+ case VIEW:
+ return CodeBlock.of(
+ "$L.maybeGetParentComponentManager()", componentManagerCallBlock(metadata));
+ case BROADCAST_RECEIVER:
+ // Broadcast receivers receive a "context" parameter
+ return CodeBlock.of("context.getApplicationContext()");
+ default:
+ throw new AssertionError();
+ }
+ }
+
+ /**
+ * Returns the call to {@code generatedComponent()} with casts if needed.
+ *
+ * <p>A cast is required when the root generated Hilt class uses bytecode injection because
+ * subclasses won't have access to the {@code generatedComponent()} method in that case.
+ */
+ private static CodeBlock generatedComponentCallBlock(AndroidEntryPointMetadata metadata) {
+ return CodeBlock.of(
+ "$L.generatedComponent()",
+ !metadata.isRootMetadata() && metadata.rootMetadata().requiresBytecodeInjection()
+ ? unsafeCastThisTo(ClassNames.GENERATED_COMPONENT_MANAGER_HOLDER)
+ : "this");
+ }
+
+ /**
+ * Returns the call to {@code componentManager()} with casts if needed.
+ *
+ * <p>A cast is required when the root generated Hilt class uses bytecode injection because
+ * subclasses won't have access to the {@code componentManager()} method in that case.
+ */
+ private static CodeBlock componentManagerCallBlock(AndroidEntryPointMetadata metadata) {
+ return CodeBlock.of(
+ "$L.componentManager()",
+ !metadata.isRootMetadata() && metadata.rootMetadata().requiresBytecodeInjection()
+ ? unsafeCastThisTo(ClassNames.GENERATED_COMPONENT_MANAGER_HOLDER)
+ : "this");
+ }
+
+ static CodeBlock unsafeCastThisTo(ClassName castType) {
+ return CodeBlock.of("$T.<$T>unsafeCast(this)", ClassNames.UNSAFE_CASTS, castType);
+ }
+
+ /** Returns {@code true} if the an ancestor annotated class extends the generated class */
+ private static boolean ancestorExtendsGeneratedHiltClass(AndroidEntryPointMetadata metadata) {
+ while (metadata.baseMetadata().isPresent()) {
+ metadata = metadata.baseMetadata().get();
+ if (!metadata.requiresBytecodeInjection()) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ // private boolean injected = false;
+ private static FieldSpec injectedField(AndroidEntryPointMetadata metadata) {
+ FieldSpec.Builder builder = FieldSpec.builder(TypeName.BOOLEAN, "injected")
+ .addModifiers(Modifier.PRIVATE);
+
+ // Broadcast receivers do double-checked locking so this needs to be volatile
+ if (metadata.androidType() == AndroidEntryPointMetadata.AndroidType.BROADCAST_RECEIVER) {
+ builder.addModifiers(Modifier.VOLATILE);
+ }
+
+ // Views should not add an initializer here as this runs after the super constructor
+ // and may reset state set during the super constructor call.
+ if (metadata.androidType() != AndroidEntryPointMetadata.AndroidType.VIEW) {
+ builder.initializer("false");
+ }
+ return builder.build();
+ }
+
+ // private final Object injectedLock = new Object();
+ private static FieldSpec injectedLockField() {
+ return FieldSpec.builder(TypeName.OBJECT, "injectedLock")
+ .addModifiers(Modifier.PRIVATE, Modifier.FINAL)
+ .initializer("new $T()", TypeName.OBJECT)
+ .build();
+ }
+
+ /**
+ * Adds the SupressWarnings to supress a warning in the generated code.
+ *
+ * @param keys the string keys of the warnings to suppress, e.g. 'deprecation', 'unchecked', etc.
+ */
+ public static void addSuppressAnnotation(TypeSpec.Builder builder, String... keys) {
+ AnnotationSpec.Builder annotationBuilder = AnnotationSpec.builder(SuppressWarnings.class);
+ for (String key : keys) {
+ annotationBuilder.addMember("value", "$S", key);
+ }
+ builder.addAnnotation(annotationBuilder.build());
+ }
+
+ private Generators() {}
+}
diff --git a/java/dagger/hilt/android/processor/internal/androidentrypoint/HiltCompilerOptions.java b/java/dagger/hilt/android/processor/internal/androidentrypoint/HiltCompilerOptions.java
new file mode 100644
index 0000000..577410d
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/androidentrypoint/HiltCompilerOptions.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.androidentrypoint;
+
+import java.util.Arrays;
+import java.util.Set;
+import java.util.stream.Collectors;
+import javax.annotation.processing.ProcessingEnvironment;
+
+/** Hilt annotation processor options. */
+// TODO(danysantiago): Consider consolidating with Dagger compiler options logic.
+// TODO(user): Move this class to dagger/hilt/processor/internal
+public final class HiltCompilerOptions {
+
+ /** Processor options which can have true or false values. */
+ public enum BooleanOption {
+ /**
+ * Flag that disables validating the superclass of @AndroidEntryPoint are Hilt_ generated,
+ * classes. This flag is to be used internally by the Gradle plugin, enabling the bytecode
+ * transformation to change the superclass.
+ */
+ DISABLE_ANDROID_SUPERCLASS_VALIDATION(
+ "android.internal.disableAndroidSuperclassValidation", false),
+
+ /** Flag that disables check on modules to be annotated with @InstallIn. */
+ DISABLE_MODULES_HAVE_INSTALL_IN_CHECK("disableModulesHaveInstallInCheck", false);
+
+ private final String name;
+ private final boolean defaultValue;
+
+ BooleanOption(String name, boolean defaultValue) {
+ this.name = name;
+ this.defaultValue = defaultValue;
+ }
+
+ public boolean get(ProcessingEnvironment env) {
+ String value = env.getOptions().get(getQualifiedName());
+ if (value == null) {
+ return defaultValue;
+ }
+ // TODO(danysantiago): Strictly verify input, either 'true' or 'false' and nothing else.
+ return Boolean.parseBoolean(value);
+ }
+
+ public String getQualifiedName() {
+ return "dagger.hilt." + name;
+ }
+ }
+
+ public static Set<String> getProcessorOptions() {
+ return Arrays.stream(BooleanOption.values())
+ .map(BooleanOption::getQualifiedName)
+ .collect(Collectors.toSet());
+ }
+
+ private HiltCompilerOptions() {}
+}
diff --git a/java/dagger/hilt/android/processor/internal/androidentrypoint/InjectorEntryPointGenerator.java b/java/dagger/hilt/android/processor/internal/androidentrypoint/InjectorEntryPointGenerator.java
new file mode 100644
index 0000000..e9e217d
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/androidentrypoint/InjectorEntryPointGenerator.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.androidentrypoint;
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.TypeSpec;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.Processors;
+import java.io.IOException;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.Modifier;
+
+/** Generates an entry point that allows for injection of the given activity */
+public final class InjectorEntryPointGenerator {
+ private final ProcessingEnvironment env;
+ private final AndroidEntryPointMetadata metadata;
+
+ public InjectorEntryPointGenerator(
+ ProcessingEnvironment env, AndroidEntryPointMetadata metadata) {
+ this.env = env;
+ this.metadata = metadata;
+ }
+
+ // @Generated("InjectorEntryPointGenerator")
+ // @InstallIn({$SCOPES})
+ // public interface FooActivity_GeneratedInjector {
+ // void injectFoo(FooActivity foo);
+ // }
+ public void generate() throws IOException {
+ ClassName name = metadata.injectorClassName();
+ TypeSpec.Builder builder =
+ TypeSpec.interfaceBuilder(name.simpleName())
+ .addOriginatingElement(metadata.element())
+ .addAnnotation(Processors.getOriginatingElementAnnotation(metadata.element()))
+ .addAnnotation(ClassNames.GENERATED_ENTRY_POINT)
+ .addAnnotation(metadata.injectorInstallInAnnotation())
+ .addModifiers(Modifier.PUBLIC)
+ .addMethod(
+ MethodSpec.methodBuilder(metadata.injectMethodName())
+ .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
+ .addParameter(
+ metadata.elementClassName(),
+ Processors.upperToLowerCamel(metadata.elementClassName().simpleName()))
+ .build());
+
+ Processors.addGeneratedAnnotation(builder, env, getClass());
+ Generators.copyLintAnnotations(metadata.element(), builder);
+
+ JavaFile.builder(name.packageName(), builder.build()).build().writeTo(env.getFiler());
+ }
+}
diff --git a/java/dagger/hilt/android/processor/internal/androidentrypoint/ServiceGenerator.java b/java/dagger/hilt/android/processor/internal/androidentrypoint/ServiceGenerator.java
new file mode 100644
index 0000000..a80a215
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/androidentrypoint/ServiceGenerator.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.androidentrypoint;
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterSpec;
+import com.squareup.javapoet.TypeName;
+import com.squareup.javapoet.TypeSpec;
+import com.squareup.javapoet.TypeVariableName;
+import dagger.hilt.android.processor.internal.AndroidClassNames;
+import dagger.hilt.processor.internal.Processors;
+import java.io.IOException;
+import java.util.List;
+import java.util.stream.Collectors;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.util.ElementFilter;
+
+/** Generates an Hilt Service class for the @AndroidEntryPoint annotated class. */
+public final class ServiceGenerator {
+ private final ProcessingEnvironment env;
+ private final AndroidEntryPointMetadata metadata;
+ private final ClassName generatedClassName;
+
+ public ServiceGenerator(ProcessingEnvironment env, AndroidEntryPointMetadata metadata) {
+ this.env = env;
+ this.metadata = metadata;
+
+ generatedClassName = metadata.generatedClassName();
+ }
+
+ // @Generated("ServiceGenerator")
+ // abstract class Hilt_$CLASS extends $BASE {
+ // ...
+ // }
+ public void generate() throws IOException {
+ TypeSpec.Builder builder =
+ TypeSpec.classBuilder(generatedClassName.simpleName())
+ .addOriginatingElement(metadata.element())
+ .superclass(metadata.baseClassName())
+ .addModifiers(metadata.generatedClassModifiers())
+ .addMethods(baseClassConstructors())
+ .addMethod(onCreateMethod());
+
+ Generators.addGeneratedBaseClassJavadoc(builder, AndroidClassNames.ANDROID_ENTRY_POINT);
+ Processors.addGeneratedAnnotation(builder, env, getClass());
+ Generators.copyLintAnnotations(metadata.element(), builder);
+
+ metadata.baseElement().getTypeParameters().stream()
+ .map(TypeVariableName::get)
+ .forEachOrdered(builder::addTypeVariable);
+
+ Generators.addInjectionMethods(metadata, builder);
+
+ Generators.addComponentOverride(metadata, builder);
+
+ JavaFile.builder(generatedClassName.packageName(), builder.build())
+ .build().writeTo(env.getFiler());
+ }
+
+ private List<MethodSpec> baseClassConstructors() {
+ return ElementFilter.constructorsIn(metadata.baseElement().getEnclosedElements())
+ .stream()
+ .map((constructor) -> {
+ List<ParameterSpec> params =
+ constructor.getParameters()
+ .stream()
+ .map(p -> ParameterSpec.builder(TypeName.get(p.asType()), p.toString()).build())
+ .collect(Collectors.toList());
+
+ return MethodSpec.constructorBuilder()
+ .addParameters(params)
+ .addStatement(
+ "super($L)",
+ params.stream().map(p -> p.name).collect(Collectors.joining(",")))
+ .build();
+ })
+ .collect(Collectors.toList());
+ }
+
+ // @CallSuper
+ // @Override
+ // protected void onCreate() {
+ // inject();
+ // super.onCreate();
+ // }
+ private MethodSpec onCreateMethod() throws IOException {
+ return MethodSpec.methodBuilder("onCreate")
+ .addAnnotation(AndroidClassNames.CALL_SUPER)
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC)
+ .addStatement("inject()")
+ .addStatement("super.onCreate()")
+ .build();
+ }
+}
diff --git a/java/dagger/hilt/android/processor/internal/androidentrypoint/ViewGenerator.java b/java/dagger/hilt/android/processor/internal/androidentrypoint/ViewGenerator.java
new file mode 100644
index 0000000..412b09a
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/androidentrypoint/ViewGenerator.java
@@ -0,0 +1,194 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.androidentrypoint;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.Visibility;
+import com.squareup.javapoet.AnnotationSpec;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.TypeSpec;
+import com.squareup.javapoet.TypeVariableName;
+import dagger.hilt.android.processor.internal.AndroidClassNames;
+import dagger.hilt.processor.internal.Processors;
+import java.io.IOException;
+import java.util.List;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.ElementFilter;
+
+/** Generates an Hilt View class for the @AndroidEntryPoint annotated class. */
+public final class ViewGenerator {
+ private final ProcessingEnvironment env;
+ private final AndroidEntryPointMetadata metadata;
+ private final ClassName generatedClassName;
+
+ public ViewGenerator(ProcessingEnvironment env, AndroidEntryPointMetadata metadata) {
+ this.env = env;
+ this.metadata = metadata;
+
+ generatedClassName = metadata.generatedClassName();
+ }
+
+ // @Generated("ViewGenerator")
+ // abstract class Hilt_$CLASS extends $BASE implements
+ // ComponentManagerHolder<ViewComponentManager<$CLASS_EntryPoint>> {
+ // ...
+ // }
+ public void generate() throws IOException {
+ // Note: we do not use the Generators helper methods here because injection is called
+ // from the constructor where the double-check pattern doesn't work (due to the super
+ // constructor being called before fields are initialized) and because it isn't necessary
+ // since the object isn't done constructing yet.
+
+ TypeSpec.Builder builder =
+ TypeSpec.classBuilder(generatedClassName.simpleName())
+ .addOriginatingElement(metadata.element())
+ .superclass(metadata.baseClassName())
+ .addModifiers(metadata.generatedClassModifiers());
+
+ Generators.addGeneratedBaseClassJavadoc(builder, AndroidClassNames.ANDROID_ENTRY_POINT);
+ Processors.addGeneratedAnnotation(builder, env, getClass());
+ Generators.copyLintAnnotations(metadata.element(), builder);
+
+ metadata.baseElement().getTypeParameters().stream()
+ .map(TypeVariableName::get)
+ .forEachOrdered(builder::addTypeVariable);
+
+ Generators.addComponentOverride(metadata, builder);
+
+ Generators.addInjectionMethods(metadata, builder);
+
+ ElementFilter.constructorsIn(metadata.baseElement().getEnclosedElements()).stream()
+ .filter(this::isConstructorVisibleToGeneratedClass)
+ .forEach(constructor -> builder.addMethod(constructorMethod(constructor)));
+
+ JavaFile.builder(generatedClassName.packageName(), builder.build())
+ .build()
+ .writeTo(env.getFiler());
+ }
+
+ private boolean isConstructorVisibleToGeneratedClass(ExecutableElement constructorElement) {
+ if (Visibility.ofElement(constructorElement) == Visibility.DEFAULT
+ && !isInOurPackage(constructorElement)) {
+ return false;
+ } else if (Visibility.ofElement(constructorElement) == Visibility.PRIVATE) {
+ return false;
+ }
+
+ // We extend the base class, so both protected and public methods are always accessible.
+ return true;
+ }
+
+ /**
+ * Returns a pass-through constructor matching the base class's provided constructorElement. The
+ * generated constructor simply calls super(), then inject().
+ *
+ * <p>Eg
+ *
+ * <pre>
+ * Hilt_$CLASS(Context context, ...) {
+ * super(context, ...);
+ * inject();
+ * }
+ * </pre>
+ */
+ private MethodSpec constructorMethod(ExecutableElement constructorElement) {
+ MethodSpec.Builder constructor =
+ Generators.copyConstructor(constructorElement).toBuilder();
+
+ if (isRestrictedApiConstructor(constructorElement)) {
+ // 4 parameter constructors are only available on @TargetApi(21).
+ constructor.addAnnotation(
+ AnnotationSpec.builder(AndroidClassNames.TARGET_API).addMember("value", "21").build());
+ }
+
+ constructor.addStatement("inject()");
+
+ return constructor.build();
+ }
+
+ private boolean isRestrictedApiConstructor(ExecutableElement constructor) {
+ if (constructor.getParameters().size() != 4) {
+ return false;
+ }
+
+ List<? extends VariableElement> constructorParams = constructor.getParameters();
+ for (int i = 0; i < constructorParams.size(); i++) {
+ TypeMirror type = constructorParams.get(i).asType();
+ Element element = env.getTypeUtils().asElement(type);
+ switch (i) {
+ case 0:
+ if (!isFirstRestrictedParameter(element)) {
+ return false;
+ }
+ break;
+ case 1:
+ if (!isSecondRestrictedParameter(element)) {
+ return false;
+ }
+ break;
+ case 2:
+ if (!isThirdRestrictedParameter(type)) {
+ return false;
+ }
+ break;
+ case 3:
+ if (!isFourthRestrictedParameter(type)) {
+ return false;
+ }
+ break;
+ default:
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ private static boolean isFourthRestrictedParameter(TypeMirror type) {
+ return type.getKind().isPrimitive()
+ && Processors.getPrimitiveType(type).getKind() == TypeKind.INT;
+ }
+
+ private static boolean isThirdRestrictedParameter(TypeMirror type) {
+ return type.getKind().isPrimitive()
+ && Processors.getPrimitiveType(type).getKind() == TypeKind.INT;
+ }
+
+ private static boolean isSecondRestrictedParameter(Element element) {
+ return element instanceof TypeElement
+ && Processors.isAssignableFrom(
+ MoreElements.asType(element), AndroidClassNames.ATTRIBUTE_SET);
+ }
+
+ private static boolean isFirstRestrictedParameter(Element element) {
+ return element instanceof TypeElement
+ && Processors.isAssignableFrom(MoreElements.asType(element), AndroidClassNames.CONTEXT);
+ }
+
+ private boolean isInOurPackage(ExecutableElement constructorElement) {
+ return MoreElements.getPackage(constructorElement)
+ .equals(MoreElements.getPackage(metadata.element()));
+ }
+}
diff --git a/java/dagger/hilt/android/processor/internal/bindvalue/BUILD b/java/dagger/hilt/android/processor/internal/bindvalue/BUILD
new file mode 100644
index 0000000..cbc51b3
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/bindvalue/BUILD
@@ -0,0 +1,60 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# Description:
+# Hilt android library for binding values in test processors.
+
+package(default_visibility = ["//:src"])
+
+java_plugin(
+ name = "bind_value_processor",
+ generates_api = 1,
+ processor_class = "dagger.hilt.android.processor.internal.bindvalue.BindValueProcessor",
+ deps = [
+ ":bind_value_processor_lib",
+ ],
+)
+
+java_library(
+ name = "bind_value_processor_lib",
+ srcs = [
+ "BindValueGenerator.java",
+ "BindValueMetadata.java",
+ "BindValueProcessor.java",
+ ],
+ deps = [
+ "//:dagger_with_compiler",
+ "//java/dagger/hilt/processor/internal:base_processor",
+ "//java/dagger/hilt/processor/internal:classnames",
+ "//java/dagger/hilt/processor/internal:components",
+ "//java/dagger/hilt/processor/internal:kotlin",
+ "//java/dagger/hilt/processor/internal:processor_errors",
+ "//java/dagger/hilt/processor/internal:processors",
+ "//java/dagger/internal/codegen/extension",
+ "//java/dagger/internal/codegen/kotlin",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "@google_bazel_common//third_party/java/auto:service",
+ "@google_bazel_common//third_party/java/auto:value",
+ "@google_bazel_common//third_party/java/incap",
+ "@google_bazel_common//third_party/java/javapoet",
+ "@google_bazel_common//third_party/java/jsr250_annotations",
+ "@google_bazel_common//third_party/java/jsr330_inject",
+ "@maven//:com_google_auto_auto_common",
+ ],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/android/processor/internal/bindvalue/BindValueGenerator.java b/java/dagger/hilt/android/processor/internal/bindvalue/BindValueGenerator.java
new file mode 100644
index 0000000..108a15d
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/bindvalue/BindValueGenerator.java
@@ -0,0 +1,160 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.bindvalue;
+
+import static com.google.common.base.CaseFormat.LOWER_CAMEL;
+import static com.google.common.base.CaseFormat.UPPER_CAMEL;
+import static java.util.Comparator.comparing;
+
+import com.google.common.collect.ImmutableSet;
+import com.squareup.javapoet.AnnotationSpec;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterSpec;
+import com.squareup.javapoet.TypeSpec;
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.android.processor.internal.bindvalue.BindValueMetadata.BindValueElement;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.Components;
+import dagger.hilt.processor.internal.Processors;
+import dagger.multibindings.ElementsIntoSet;
+import dagger.multibindings.IntoMap;
+import dagger.multibindings.IntoSet;
+import java.io.IOException;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.Modifier;
+
+/**
+ * Generates a SINGLETON module for all {@code BindValue} annotated fields in a test class.
+ */
+final class BindValueGenerator {
+ private static final String SUFFIX = "_BindValueModule";
+
+ private final ProcessingEnvironment env;
+ private final BindValueMetadata metadata;
+ private final ClassName testClassName;
+ private final ClassName className;
+
+ BindValueGenerator(ProcessingEnvironment env, BindValueMetadata metadata) {
+ this.env = env;
+ this.metadata = metadata;
+ testClassName = ClassName.get(metadata.testElement());
+ className = Processors.append(testClassName, SUFFIX);
+ }
+
+ // @Module
+ // @InstallIn(SingletonComponent.class)
+ // public final class FooTest_BindValueModule {
+ // // providesMethods ...
+ // }
+ void generate() throws IOException {
+ TypeSpec.Builder builder =
+ TypeSpec.classBuilder(className)
+ .addOriginatingElement(metadata.testElement())
+ .addAnnotation(Processors.getOriginatingElementAnnotation(metadata.testElement()))
+ .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
+ .addAnnotation(Module.class)
+ .addAnnotation(
+ Components.getInstallInAnnotationSpec(
+ ImmutableSet.of(ClassNames.SINGLETON_COMPONENT)))
+ .addMethod(providesTestMethod());
+
+ Processors.addGeneratedAnnotation(builder, env, getClass());
+
+ metadata.bindValueElements().stream()
+ .map(this::providesMethod)
+ .sorted(comparing(MethodSpec::toString))
+ .forEachOrdered(builder::addMethod);
+
+ JavaFile.builder(className.packageName(), builder.build())
+ .build()
+ .writeTo(env.getFiler());
+ }
+
+ // @Provides
+ // static FooTest providesFooTest(@ApplicationContext Context context) {
+ // return (FooTest)
+ // ((TestApplicationComponentManager)
+ // ((TestApplicationComponentManagerHolder) context).componentManager())
+ // .getTestInstance();
+ // }
+ private MethodSpec providesTestMethod() {
+ String methodName = "provides" + testClassName.simpleName();
+ MethodSpec.Builder builder =
+ MethodSpec.methodBuilder(methodName)
+ .addAnnotation(Provides.class)
+ .addModifiers(Modifier.STATIC)
+ .addParameter(
+ ParameterSpec.builder(ClassNames.CONTEXT, "context")
+ .addAnnotation(ClassNames.APPLICATION_CONTEXT)
+ .build())
+ .returns(testClassName)
+ .addStatement(
+ "return ($T) (($T) (($T) context).componentManager()).getTestInstance()",
+ testClassName,
+ ClassNames.TEST_APPLICATION_COMPONENT_MANAGER,
+ ClassNames.TEST_APPLICATION_COMPONENT_MANAGER_HOLDER);
+ return builder.build();
+ }
+
+ // @Provides
+ // @BarQualifier
+ // static Bar providesBarQualifierBar(FooTest test) {
+ // return test.bar;
+ // }
+ private MethodSpec providesMethod(BindValueElement bindValue) {
+ // We only allow fields in the Test class, which should have unique variable names.
+ String methodName = "provides"
+ + LOWER_CAMEL.to(UPPER_CAMEL, bindValue.variableElement().getSimpleName().toString());
+ MethodSpec.Builder builder =
+ MethodSpec.methodBuilder(methodName)
+ .addAnnotation(Provides.class)
+ .addModifiers(Modifier.STATIC)
+ .returns(ClassName.get(bindValue.variableElement().asType()));
+
+ if (bindValue.variableElement().getModifiers().contains(Modifier.STATIC)) {
+ builder.addStatement(
+ "return $T.$L", testClassName, bindValue.variableElement().getSimpleName());
+ } else {
+ builder
+ .addParameter(testClassName, "test")
+ .addStatement(
+ "return $L",
+ bindValue.getterElement().isPresent()
+ ? CodeBlock.of("test.$L()", bindValue.getterElement().get().getSimpleName())
+ : CodeBlock.of("test.$L", bindValue.variableElement().getSimpleName()));
+ }
+
+ ClassName annotationClassName = bindValue.annotationName();
+ if (BindValueMetadata.BIND_VALUE_INTO_MAP_ANNOTATIONS.contains(annotationClassName)) {
+ builder.addAnnotation(IntoMap.class);
+ // It is safe to call get() on the Optional<AnnotationMirror> returned by mapKey()
+ // because a @BindValueIntoMap is required to have one and is checked in
+ // BindValueMetadata.BindValueElement.create().
+ builder.addAnnotation(AnnotationSpec.get(bindValue.mapKey().get()));
+ } else if (BindValueMetadata.BIND_VALUE_INTO_SET_ANNOTATIONS.contains(annotationClassName)) {
+ builder.addAnnotation(IntoSet.class);
+ } else if (BindValueMetadata.BIND_ELEMENTS_INTO_SET_ANNOTATIONS.contains(annotationClassName)) {
+ builder.addAnnotation(ElementsIntoSet.class);
+ }
+ bindValue.qualifier().ifPresent(q -> builder.addAnnotation(AnnotationSpec.get(q)));
+ return builder.build();
+ }
+}
diff --git a/java/dagger/hilt/android/processor/internal/bindvalue/BindValueMetadata.java b/java/dagger/hilt/android/processor/internal/bindvalue/BindValueMetadata.java
new file mode 100644
index 0000000..bf50288
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/bindvalue/BindValueMetadata.java
@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.bindvalue;
+
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.value.AutoValue;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.squareup.javapoet.ClassName;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.KotlinMetadataUtils;
+import dagger.hilt.processor.internal.ProcessorErrors;
+import dagger.hilt.processor.internal.Processors;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import java.util.Collection;
+import java.util.Optional;
+import javax.inject.Inject;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+
+/**
+ * Represents metadata for a test class that has {@code BindValue} fields.
+ */
+@AutoValue
+abstract class BindValueMetadata {
+ static final ImmutableSet<ClassName> BIND_VALUE_ANNOTATIONS =
+ ImmutableSet.of(
+ ClassNames.ANDROID_BIND_VALUE);
+ static final ImmutableSet<ClassName> BIND_VALUE_INTO_SET_ANNOTATIONS =
+ ImmutableSet.of(
+ ClassNames.ANDROID_BIND_VALUE_INTO_SET);
+ static final ImmutableSet<ClassName> BIND_ELEMENTS_INTO_SET_ANNOTATIONS =
+ ImmutableSet.of(
+ ClassNames.ANDROID_BIND_ELEMENTS_INTO_SET);
+ static final ImmutableSet<ClassName> BIND_VALUE_INTO_MAP_ANNOTATIONS =
+ ImmutableSet.of(
+ ClassNames.ANDROID_BIND_VALUE_INTO_MAP);
+
+ /** @return the {@code TestRoot} annotated class's name. */
+ abstract TypeElement testElement();
+
+ /** @return a {@link ImmutableSet} of elements annotated with @BindValue. */
+ abstract ImmutableSet<BindValueElement> bindValueElements();
+
+ /** @return a new BindValueMetadata instance. */
+ static BindValueMetadata create(TypeElement testElement, Collection<Element> bindValueElements) {
+
+ ImmutableSet.Builder<BindValueElement> elements = ImmutableSet.builder();
+ for (Element element : bindValueElements) {
+ elements.add(BindValueElement.create(element));
+ }
+
+ return new AutoValue_BindValueMetadata(testElement, elements.build());
+ }
+
+ @AutoValue
+ abstract static class BindValueElement {
+ abstract VariableElement variableElement();
+
+ abstract ClassName annotationName();
+
+ abstract Optional<AnnotationMirror> qualifier();
+
+ abstract Optional<AnnotationMirror> mapKey();
+
+ abstract Optional<ExecutableElement> getterElement();
+
+ static BindValueElement create(Element element) {
+ ImmutableList<ClassName> bindValues = BindValueProcessor.getBindValueAnnotations(element);
+ ProcessorErrors.checkState(
+ bindValues.size() == 1,
+ element,
+ "Fields can be annotated with only one of @BindValue, @BindValueIntoMap,"
+ + " @BindElementsIntoSet, @BindValueIntoSet. Found: %s",
+ bindValues.stream().map(m -> "@" + m.simpleName()).collect(toImmutableList()));
+ ClassName annotationClassName = bindValues.get(0);
+
+ ProcessorErrors.checkState(
+ element.getKind() == ElementKind.FIELD,
+ element,
+ "@%s can only be used with fields. Found: %s",
+ annotationClassName.simpleName(),
+ element);
+
+ KotlinMetadataUtil metadataUtil = KotlinMetadataUtils.getMetadataUtil();
+ Optional<ExecutableElement> propertyGetter =
+ metadataUtil.hasMetadata(element)
+ ? metadataUtil.getPropertyGetter(MoreElements.asVariable(element))
+ : Optional.empty();
+ if (propertyGetter.isPresent()) {
+ ProcessorErrors.checkState(
+ !propertyGetter.get().getModifiers().contains(Modifier.PRIVATE),
+ element,
+ "@%s field getter cannot be private. Found: %s",
+ annotationClassName.simpleName(),
+ element);
+ } else {
+ ProcessorErrors.checkState(
+ !element.getModifiers().contains(Modifier.PRIVATE),
+ element,
+ "@%s fields cannot be private. Found: %s",
+ annotationClassName.simpleName(),
+ element);
+ }
+
+ ProcessorErrors.checkState(
+ !Processors.hasAnnotation(element, Inject.class),
+ element,
+ "@%s fields cannot be used with @Inject annotation. Found %s",
+ annotationClassName.simpleName(),
+ element);
+
+ ImmutableList<AnnotationMirror> qualifiers = Processors.getQualifierAnnotations(element);
+ ProcessorErrors.checkState(
+ qualifiers.size() <= 1,
+ element,
+ "@%s fields cannot have more than one qualifier. Found %s",
+ annotationClassName.simpleName(),
+ qualifiers);
+
+ ImmutableList<AnnotationMirror> mapKeys = Processors.getMapKeyAnnotations(element);
+ Optional<AnnotationMirror> optionalMapKeys;
+ if (BIND_VALUE_INTO_MAP_ANNOTATIONS.contains(annotationClassName)) {
+ ProcessorErrors.checkState(
+ mapKeys.size() == 1,
+ element,
+ "@BindValueIntoMap fields must have exactly one @MapKey. Found %s",
+ mapKeys);
+ optionalMapKeys = Optional.of(mapKeys.get(0));
+ } else {
+ ProcessorErrors.checkState(
+ mapKeys.isEmpty(),
+ element,
+ "@MapKey can only be used on @BindValueIntoMap fields, not @%s fields",
+ annotationClassName.simpleName());
+ optionalMapKeys = Optional.empty();
+ }
+
+ ImmutableList<AnnotationMirror> scopes = Processors.getScopeAnnotations(element);
+ ProcessorErrors.checkState(
+ scopes.isEmpty(),
+ element,
+ "@%s fields cannot be scoped. Found %s",
+ annotationClassName.simpleName(),
+ scopes);
+
+ return new AutoValue_BindValueMetadata_BindValueElement(
+ (VariableElement) element,
+ annotationClassName,
+ qualifiers.isEmpty()
+ ? Optional.<AnnotationMirror>empty()
+ : Optional.<AnnotationMirror>of(qualifiers.get(0)),
+ optionalMapKeys,
+ propertyGetter);
+ }
+ }
+}
diff --git a/java/dagger/hilt/android/processor/internal/bindvalue/BindValueProcessor.java b/java/dagger/hilt/android/processor/internal/bindvalue/BindValueProcessor.java
new file mode 100644
index 0000000..060b077
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/bindvalue/BindValueProcessor.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.bindvalue;
+
+import static net.ltgt.gradle.incap.IncrementalAnnotationProcessorType.ISOLATING;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.service.AutoService;
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Multimap;
+import com.squareup.javapoet.AnnotationSpec;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.TypeName;
+import dagger.hilt.processor.internal.BaseProcessor;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.ProcessorErrors;
+import dagger.hilt.processor.internal.Processors;
+import dagger.internal.codegen.extension.DaggerStreams;
+import java.util.Collection;
+import java.util.Map;
+import javax.annotation.processing.Processor;
+import javax.annotation.processing.RoundEnvironment;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.TypeElement;
+import net.ltgt.gradle.incap.IncrementalAnnotationProcessor;
+
+/** Provides a test's @BindValue fields to the SINGLETON component. */
+@IncrementalAnnotationProcessor(ISOLATING)
+@AutoService(Processor.class)
+public final class BindValueProcessor extends BaseProcessor {
+
+ private static final ImmutableSet<ClassName> SUPPORTED_ANNOTATIONS =
+ ImmutableSet.<ClassName>builder()
+ .addAll(BindValueMetadata.BIND_VALUE_ANNOTATIONS)
+ .addAll(BindValueMetadata.BIND_VALUE_INTO_SET_ANNOTATIONS)
+ .addAll(BindValueMetadata.BIND_ELEMENTS_INTO_SET_ANNOTATIONS)
+ .addAll(BindValueMetadata.BIND_VALUE_INTO_MAP_ANNOTATIONS)
+ .build();
+
+ private final Multimap<TypeElement, Element> testRootMap = ArrayListMultimap.create();
+
+ @Override
+ public ImmutableSet<String> getSupportedAnnotationTypes() {
+ return SUPPORTED_ANNOTATIONS.stream()
+ .map(TypeName::toString)
+ .collect(DaggerStreams.toImmutableSet());
+ }
+
+ @Override
+ protected void preRoundProcess(RoundEnvironment roundEnv) {
+ testRootMap.clear();
+ }
+
+ @Override
+ public void processEach(TypeElement annotation, Element element) throws Exception {
+ ClassName annotationClassName = ClassName.get(annotation);
+ Element enclosingElement = element.getEnclosingElement();
+ // Restrict BindValue to the direct test class (e.g. not allowed in a base test class) because
+ // otherwise generated BindValue modules from the base class will not associate with the
+ // correct test class. This would make the modules apply globally which would be a weird
+ // difference since just moving a declaration to the parent would change whether the module is
+ // limited to the test that declares it to global.
+ ProcessorErrors.checkState(
+ enclosingElement.getKind() == ElementKind.CLASS
+ && (Processors.hasAnnotation(enclosingElement, ClassNames.HILT_ANDROID_TEST)
+ ),
+ enclosingElement,
+ "@%s can only be used within a class annotated with "
+ + "@HiltAndroidTest. Found: %s",
+ annotationClassName.simpleName(),
+ enclosingElement);
+
+ testRootMap.put(MoreElements.asType(enclosingElement), element);
+ }
+
+ @Override
+ public void postRoundProcess(RoundEnvironment roundEnvironment) throws Exception {
+ // Generate a module for each testing class with a @BindValue field.
+ for (Map.Entry<TypeElement, Collection<Element>> e : testRootMap.asMap().entrySet()) {
+ BindValueMetadata metadata = BindValueMetadata.create(e.getKey(), e.getValue());
+ new BindValueGenerator(getProcessingEnv(), metadata).generate();
+ }
+ }
+
+ static ImmutableList<ClassName> getBindValueAnnotations(Element element) {
+ ImmutableList.Builder<ClassName> builder = ImmutableList.builder();
+ for (AnnotationMirror annotation : element.getAnnotationMirrors()) {
+ TypeName tn = AnnotationSpec.get(annotation).type;
+ if (SUPPORTED_ANNOTATIONS.contains(tn)) {
+ builder.add((ClassName) tn); // the cast is checked by .contains()
+ }
+ }
+ return builder.build();
+ }
+}
diff --git a/java/dagger/hilt/android/processor/internal/customtestapplication/BUILD b/java/dagger/hilt/android/processor/internal/customtestapplication/BUILD
new file mode 100644
index 0000000..e9721d5
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/customtestapplication/BUILD
@@ -0,0 +1,53 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# A processor for @dagger.hilt.android.testing.CustomTestApplication.
+
+package(default_visibility = ["//:src"])
+
+java_plugin(
+ name = "processor",
+ generates_api = 1,
+ processor_class = "dagger.hilt.android.processor.internal.customtestapplication.CustomTestApplicationProcessor",
+ deps = [":processor_lib"],
+)
+
+java_library(
+ name = "processor_lib",
+ srcs = [
+ "CustomTestApplicationGenerator.java",
+ "CustomTestApplicationMetadata.java",
+ "CustomTestApplicationProcessor.java",
+ ],
+ deps = [
+ "//java/dagger/hilt/processor/internal:base_processor",
+ "//java/dagger/hilt/processor/internal:classnames",
+ "//java/dagger/hilt/processor/internal:processor_errors",
+ "//java/dagger/hilt/processor/internal:processors",
+ "//java/dagger/internal/codegen/extension",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "@google_bazel_common//third_party/java/auto:service",
+ "@google_bazel_common//third_party/java/auto:value",
+ "@google_bazel_common//third_party/java/incap",
+ "@google_bazel_common//third_party/java/javapoet",
+ "@maven//:com_google_auto_auto_common",
+ ],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/android/processor/internal/customtestapplication/CustomTestApplicationGenerator.java b/java/dagger/hilt/android/processor/internal/customtestapplication/CustomTestApplicationGenerator.java
new file mode 100644
index 0000000..51b7ef4
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/customtestapplication/CustomTestApplicationGenerator.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.customtestapplication;
+
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterSpec;
+import com.squareup.javapoet.ParameterizedTypeName;
+import com.squareup.javapoet.TypeName;
+import com.squareup.javapoet.TypeSpec;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.Processors;
+import java.io.IOException;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.Modifier;
+
+/**
+ * Generates an Android Application that holds the Singleton component.
+ */
+final class CustomTestApplicationGenerator {
+ private static final ParameterSpec COMPONENT_MANAGER =
+ ParameterSpec.builder(ClassNames.TEST_APPLICATION_COMPONENT_MANAGER, "componentManager")
+ .build();
+
+ private final ProcessingEnvironment processingEnv;
+ private final CustomTestApplicationMetadata metadata;
+
+ public CustomTestApplicationGenerator(
+ ProcessingEnvironment processingEnv, CustomTestApplicationMetadata metadata) {
+ this.processingEnv = processingEnv;
+ this.metadata = metadata;
+ }
+
+ public void generate() throws IOException {
+ TypeSpec.Builder generator =
+ TypeSpec.classBuilder(metadata.appName())
+ .addOriginatingElement(metadata.element())
+ .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
+ .superclass(metadata.baseAppName())
+ .addSuperinterface(
+ ParameterizedTypeName.get(ClassNames.GENERATED_COMPONENT_MANAGER, TypeName.OBJECT))
+ .addSuperinterface(ClassNames.TEST_APPLICATION_COMPONENT_MANAGER_HOLDER)
+ .addField(getComponentManagerField())
+ .addMethod(getAttachBaseContextMethod())
+ .addMethod(getComponentManagerMethod())
+ .addMethod(getComponentMethod());
+
+ Processors.addGeneratedAnnotation(
+ generator, processingEnv, CustomTestApplicationProcessor.class);
+
+ JavaFile.builder(metadata.appName().packageName(), generator.build())
+ .build()
+ .writeTo(processingEnv.getFiler());
+ }
+
+ // Initialize this in attachBaseContext to not pull it into the main dex.
+ /** private TestApplicationComponentManager componentManager; */
+ private static FieldSpec getComponentManagerField() {
+ return FieldSpec.builder(COMPONENT_MANAGER.type, COMPONENT_MANAGER.name, Modifier.PRIVATE)
+ .build();
+ }
+
+ /**
+ * Initializes application fields. These fields are initialized in attachBaseContext to avoid
+ * potential multidexing issues.
+ *
+ * <pre><code>
+ * {@literal @Override} protected void attachBaseContext(Context base) {
+ * super.attachBaseContext(base);
+ * componentManager = new TestApplicationComponentManager(this);
+ * }
+ * </code></pre>
+ */
+ private static MethodSpec getAttachBaseContextMethod() {
+ return MethodSpec.methodBuilder("attachBaseContext")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PROTECTED, Modifier.FINAL)
+ .addParameter(ClassNames.CONTEXT, "base")
+ .addStatement("super.attachBaseContext(base)")
+ .addStatement("$N = new $T(this)", COMPONENT_MANAGER, COMPONENT_MANAGER.type)
+ .build();
+ }
+
+ private static MethodSpec getComponentMethod() {
+ return MethodSpec.methodBuilder("generatedComponent")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
+ .returns(TypeName.OBJECT)
+ .addStatement("return $N.generatedComponent()", COMPONENT_MANAGER)
+ .build();
+ }
+
+ private static MethodSpec getComponentManagerMethod() {
+ return MethodSpec.methodBuilder("componentManager")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
+ .returns(TypeName.OBJECT)
+ .addStatement("return $N", COMPONENT_MANAGER)
+ .build();
+ }
+}
diff --git a/java/dagger/hilt/android/processor/internal/customtestapplication/CustomTestApplicationMetadata.java b/java/dagger/hilt/android/processor/internal/customtestapplication/CustomTestApplicationMetadata.java
new file mode 100644
index 0000000..de8e3f7
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/customtestapplication/CustomTestApplicationMetadata.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.customtestapplication;
+
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.MoreTypes;
+import com.google.auto.value.AutoValue;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.squareup.javapoet.ClassName;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.ProcessorErrors;
+import dagger.hilt.processor.internal.Processors;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.util.ElementFilter;
+import javax.lang.model.util.Elements;
+
+/** Stores the metadata for a custom base test application. */
+@AutoValue
+abstract class CustomTestApplicationMetadata {
+ /** Returns the annotated element. */
+ abstract TypeElement element();
+
+ /** Returns the name of the base application. */
+ abstract ClassName baseAppName();
+
+ /** Returns the name of the generated application */
+ ClassName appName() {
+ return Processors.append(
+ Processors.getEnclosedClassName(ClassName.get(element())), "_Application");
+ }
+
+ static CustomTestApplicationMetadata of(Element element, Elements elements) {
+ Preconditions.checkState(
+ Processors.hasAnnotation(element, ClassNames.CUSTOM_TEST_APPLICATION),
+ "The given element, %s, is not annotated with @%s.",
+ element,
+ ClassNames.CUSTOM_TEST_APPLICATION.simpleName());
+
+ ProcessorErrors.checkState(
+ MoreElements.isType(element),
+ element,
+ "@%s should only be used on classes or interfaces but found: %s",
+ ClassNames.CUSTOM_TEST_APPLICATION.simpleName(),
+ element);
+
+ TypeElement baseAppElement = getBaseElement(element, elements);
+
+ return new AutoValue_CustomTestApplicationMetadata(
+ MoreElements.asType(element), ClassName.get(baseAppElement));
+ }
+
+ private static TypeElement getBaseElement(Element element, Elements elements) {
+ TypeElement baseElement =
+ Processors.getAnnotationClassValue(
+ elements,
+ Processors.getAnnotationMirror(element, ClassNames.CUSTOM_TEST_APPLICATION),
+ "value");
+
+ TypeElement baseSuperclassElement = baseElement;
+ while (!baseSuperclassElement.getSuperclass().getKind().equals(TypeKind.NONE)) {
+ ProcessorErrors.checkState(
+ !Processors.hasAnnotation(baseSuperclassElement, ClassNames.HILT_ANDROID_APP),
+ element,
+ "@%s value cannot be annotated with @%s. Found: %s",
+ ClassNames.CUSTOM_TEST_APPLICATION.simpleName(),
+ ClassNames.HILT_ANDROID_APP.simpleName(),
+ baseSuperclassElement);
+
+ ImmutableList<VariableElement> injectFields =
+ ElementFilter.fieldsIn(baseSuperclassElement.getEnclosedElements()).stream()
+ .filter(field -> Processors.hasAnnotation(field, ClassNames.INJECT))
+ .collect(toImmutableList());
+ ProcessorErrors.checkState(
+ injectFields.isEmpty(),
+ element,
+ "@%s does not support application classes (or super classes) with @Inject fields. Found "
+ + "%s with @Inject fields %s.",
+ ClassNames.CUSTOM_TEST_APPLICATION.simpleName(),
+ baseSuperclassElement,
+ injectFields);
+
+ ImmutableList<ExecutableElement> injectMethods =
+ ElementFilter.methodsIn(baseSuperclassElement.getEnclosedElements()).stream()
+ .filter(method -> Processors.hasAnnotation(method, ClassNames.INJECT))
+ .collect(toImmutableList());
+ ProcessorErrors.checkState(
+ injectMethods.isEmpty(),
+ element,
+ "@%s does not support application classes (or super classes) with @Inject methods. Found "
+ + "%s with @Inject methods %s.",
+ ClassNames.CUSTOM_TEST_APPLICATION.simpleName(),
+ baseSuperclassElement,
+ injectMethods);
+
+ ImmutableList<ExecutableElement> injectConstructors =
+ ElementFilter.constructorsIn(baseSuperclassElement.getEnclosedElements()).stream()
+ .filter(method -> Processors.hasAnnotation(method, ClassNames.INJECT))
+ .collect(toImmutableList());
+ ProcessorErrors.checkState(
+ injectConstructors.isEmpty(),
+ element,
+ "@%s does not support application classes (or super classes) with @Inject constructors. "
+ + "Found %s with @Inject constructors %s.",
+ ClassNames.CUSTOM_TEST_APPLICATION.simpleName(),
+ baseSuperclassElement,
+ injectConstructors);
+
+ baseSuperclassElement = MoreTypes.asTypeElement(baseSuperclassElement.getSuperclass());
+ }
+
+ // We check this last because if the base type is a @HiltAndroidApp we'd accidentally fail
+ // with this message instead of the one above when the superclass hasn't yet been generated.
+ ProcessorErrors.checkState(
+ Processors.isAssignableFrom(baseElement, ClassNames.APPLICATION),
+ element,
+ "@%s value should be an instance of %s. Found: %s",
+ ClassNames.CUSTOM_TEST_APPLICATION.simpleName(),
+ ClassNames.APPLICATION,
+ baseElement);
+
+ return baseElement;
+ }
+}
diff --git a/java/dagger/hilt/android/processor/internal/customtestapplication/CustomTestApplicationProcessor.java b/java/dagger/hilt/android/processor/internal/customtestapplication/CustomTestApplicationProcessor.java
new file mode 100644
index 0000000..fd1a6c8
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/customtestapplication/CustomTestApplicationProcessor.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.customtestapplication;
+
+import static net.ltgt.gradle.incap.IncrementalAnnotationProcessorType.ISOLATING;
+
+import com.google.auto.service.AutoService;
+import com.google.common.collect.ImmutableSet;
+import dagger.hilt.processor.internal.BaseProcessor;
+import dagger.hilt.processor.internal.ClassNames;
+import javax.annotation.processing.Processor;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import net.ltgt.gradle.incap.IncrementalAnnotationProcessor;
+
+/** Processes usages of {@link dagger.hilt.android.testing.CustomTestApplication}. */
+@IncrementalAnnotationProcessor(ISOLATING)
+@AutoService(Processor.class)
+public final class CustomTestApplicationProcessor extends BaseProcessor {
+
+ @Override
+ public ImmutableSet<String> getSupportedAnnotationTypes() {
+ return ImmutableSet.of(ClassNames.CUSTOM_TEST_APPLICATION.toString());
+ }
+
+ @Override
+ public void processEach(TypeElement annotation, Element element) throws Exception {
+ CustomTestApplicationMetadata metadata =
+ CustomTestApplicationMetadata.of(element, getElementUtils());
+ new CustomTestApplicationGenerator(getProcessingEnv(), metadata).generate();
+ }
+}
diff --git a/java/dagger/hilt/android/processor/internal/uninstallmodules/BUILD b/java/dagger/hilt/android/processor/internal/uninstallmodules/BUILD
new file mode 100644
index 0000000..73c4606
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/uninstallmodules/BUILD
@@ -0,0 +1,48 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# A processor for @dagger.hilt.android.testing.UninstallModules.
+
+package(default_visibility = ["//:src"])
+
+java_plugin(
+ name = "processor",
+ generates_api = 1,
+ processor_class = "dagger.hilt.android.processor.internal.uninstallmodules.UninstallModulesProcessor",
+ deps = [":processor_lib"],
+)
+
+java_library(
+ name = "processor_lib",
+ srcs = [
+ "UninstallModulesProcessor.java",
+ ],
+ deps = [
+ "//java/dagger/hilt/processor/internal:base_processor",
+ "//java/dagger/hilt/processor/internal:classnames",
+ "//java/dagger/hilt/processor/internal:processor_errors",
+ "//java/dagger/hilt/processor/internal:processors",
+ "//java/dagger/internal/codegen/extension",
+ "//java/dagger/internal/guava:collect",
+ "@google_bazel_common//third_party/java/auto:service",
+ "@google_bazel_common//third_party/java/incap",
+ "@maven//:com_google_auto_auto_common",
+ ],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/android/processor/internal/uninstallmodules/UninstallModulesProcessor.java b/java/dagger/hilt/android/processor/internal/uninstallmodules/UninstallModulesProcessor.java
new file mode 100644
index 0000000..e92f0f0
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/uninstallmodules/UninstallModulesProcessor.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.uninstallmodules;
+
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
+import static net.ltgt.gradle.incap.IncrementalAnnotationProcessorType.ISOLATING;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.service.AutoService;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import dagger.hilt.processor.internal.BaseProcessor;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.ProcessorErrors;
+import dagger.hilt.processor.internal.Processors;
+import java.util.Set;
+import javax.annotation.processing.Processor;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import net.ltgt.gradle.incap.IncrementalAnnotationProcessor;
+
+/** Validates {@link dagger.hilt.android.testing.UninstallModules} usages. */
+@IncrementalAnnotationProcessor(ISOLATING)
+@AutoService(Processor.class)
+public final class UninstallModulesProcessor extends BaseProcessor {
+
+ @Override
+ public Set<String> getSupportedAnnotationTypes() {
+ return ImmutableSet.of(ClassNames.IGNORE_MODULES.toString());
+ }
+
+ @Override
+ public void processEach(TypeElement annotation, Element element) throws Exception {
+ // TODO(bcorso): Consider using RootType to check this?
+ // TODO(bcorso): Loosen this restriction to allow defining sets of ignored modules in libraries.
+ ProcessorErrors.checkState(
+ MoreElements.isType(element)
+ && Processors.hasAnnotation(element, ClassNames.HILT_ANDROID_TEST),
+ element,
+ "@%s should only be used on test classes annotated with @%s, but found: %s",
+ annotation.getSimpleName(),
+ ClassNames.HILT_ANDROID_TEST.simpleName(),
+ element);
+
+ ImmutableList<TypeElement> invalidModules =
+ Processors.getAnnotationClassValues(
+ getElementUtils(),
+ Processors.getAnnotationMirror(element, ClassNames.IGNORE_MODULES),
+ "value")
+ .stream()
+ .filter(
+ module ->
+ !(Processors.hasAnnotation(module, ClassNames.MODULE)
+ && Processors.hasAnnotation(module, ClassNames.INSTALL_IN)))
+ .collect(toImmutableList());
+
+ ProcessorErrors.checkState(
+ invalidModules.isEmpty(),
+ // TODO(b/152801981): Point to the annotation value rather than the annotated element.
+ element,
+ "@%s should only include modules annotated with both @Module and @InstallIn, but found: "
+ + "%s.",
+ annotation.getSimpleName(),
+ invalidModules);
+ }
+}
diff --git a/java/dagger/hilt/android/processor/internal/viewmodel/BUILD b/java/dagger/hilt/android/processor/internal/viewmodel/BUILD
new file mode 100644
index 0000000..b45925f
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/viewmodel/BUILD
@@ -0,0 +1,84 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# ViewModelInject processor.
+load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "kt_jvm_library")
+
+package(default_visibility = ["//:src"])
+
+java_plugin(
+ name = "processor",
+ generates_api = 1,
+ processor_class = "dagger.hilt.android.processor.internal.viewmodel.ViewModelProcessor",
+ deps = [":processor_lib"],
+)
+
+kt_jvm_library(
+ name = "processor_lib",
+ srcs = [
+ "ViewModelMetadata.kt",
+ "ViewModelModuleGenerator.kt",
+ "ViewModelProcessor.kt",
+ ],
+ deps = [
+ "//java/dagger/hilt/android/processor/internal:android_classnames",
+ "//java/dagger/hilt/processor/internal:base_processor",
+ "//java/dagger/hilt/processor/internal:classnames",
+ "//java/dagger/hilt/processor/internal:processor_errors",
+ "//java/dagger/hilt/processor/internal:processors",
+ "//java/dagger/internal/guava:collect",
+ "@google_bazel_common//third_party/java/auto:service",
+ "@google_bazel_common//third_party/java/incap",
+ "@google_bazel_common//third_party/java/javapoet",
+ "@maven//:com_google_auto_auto_common",
+ ],
+)
+
+java_plugin(
+ name = "validation_plugin",
+ deps = [":validation_plugin_lib"],
+)
+
+kt_jvm_library(
+ name = "validation_plugin_lib",
+ srcs = [
+ "ViewModelValidationPlugin.kt",
+ ],
+ deps = [
+ "//:spi",
+ "//java/dagger/hilt/android/processor/internal:android_classnames",
+ "//java/dagger/hilt/processor/internal:processors",
+ "//java/dagger/internal/guava:graph",
+ "@google_bazel_common//third_party/java/auto:service",
+ "@google_bazel_common//third_party/java/javapoet",
+ "@maven//:com_google_auto_auto_common",
+ ],
+)
+
+# See: https://github.com/bazelbuild/rules_kotlin/issues/324
+alias(
+ name = "libprocessor_lib-src.jar",
+ actual = ":processor_lib-sources.jar",
+)
+
+alias(
+ name = "libvalidation_plugin_lib-src.jar",
+ actual = ":validation_plugin_lib-sources.jar",
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/android/processor/internal/viewmodel/ViewModelMetadata.kt b/java/dagger/hilt/android/processor/internal/viewmodel/ViewModelMetadata.kt
new file mode 100644
index 0000000..789fbfe
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/viewmodel/ViewModelMetadata.kt
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.viewmodel
+
+import com.google.auto.common.MoreElements
+import com.squareup.javapoet.ClassName
+import dagger.hilt.android.processor.internal.AndroidClassNames
+import dagger.hilt.processor.internal.ClassNames
+import dagger.hilt.processor.internal.ProcessorErrors
+import dagger.hilt.processor.internal.Processors
+import javax.annotation.processing.ProcessingEnvironment
+import javax.lang.model.element.Modifier
+import javax.lang.model.element.NestingKind
+import javax.lang.model.element.TypeElement
+import javax.lang.model.util.ElementFilter
+
+/**
+ * Data class that represents a Hilt injected ViewModel
+ */
+internal class ViewModelMetadata private constructor(
+ val typeElement: TypeElement
+) {
+ val className = ClassName.get(typeElement)
+
+ val modulesClassName = ClassName.get(
+ MoreElements.getPackage(typeElement).qualifiedName.toString(),
+ "${className.simpleNames().joinToString("_")}_HiltModules"
+ )
+
+ companion object {
+ internal fun create(
+ processingEnv: ProcessingEnvironment,
+ typeElement: TypeElement,
+ ): ViewModelMetadata? {
+ val types = processingEnv.typeUtils
+ val elements = processingEnv.elementUtils
+
+ ProcessorErrors.checkState(
+ types.isSubtype(
+ typeElement.asType(),
+ elements.getTypeElement(AndroidClassNames.VIEW_MODEL.toString()).asType()
+ ),
+ typeElement,
+ "@HiltViewModel is only supported on types that subclass %s.",
+ AndroidClassNames.VIEW_MODEL
+ )
+
+ ElementFilter.constructorsIn(typeElement.enclosedElements).filter { constructor ->
+ ProcessorErrors.checkState(
+ !Processors.hasAnnotation(constructor, ClassNames.ASSISTED_INJECT),
+ constructor,
+ "ViewModel constructor should be annotated with @Inject instead of @AssistedInject."
+ )
+ Processors.hasAnnotation(constructor, ClassNames.INJECT)
+ }.let { injectConstructors ->
+ ProcessorErrors.checkState(
+ injectConstructors.size == 1,
+ typeElement,
+ "@HiltViewModel annotated class should contain exactly one @Inject " +
+ "annotated constructor."
+ )
+
+ injectConstructors.forEach { constructor ->
+ ProcessorErrors.checkState(
+ !constructor.modifiers.contains(Modifier.PRIVATE),
+ constructor,
+ "@Inject annotated constructors must not be private."
+ )
+ }
+ }
+
+ ProcessorErrors.checkState(
+ typeElement.nestingKind != NestingKind.MEMBER ||
+ typeElement.modifiers.contains(Modifier.STATIC),
+ typeElement,
+ "@HiltViewModel may only be used on inner classes if they are static."
+ )
+
+ Processors.getScopeAnnotations(typeElement).let { scopeAnnotations ->
+ ProcessorErrors.checkState(
+ scopeAnnotations.isEmpty(),
+ typeElement,
+ "@HiltViewModel classes should not be scoped. Found: %s",
+ scopeAnnotations.joinToString()
+ )
+ }
+
+ return ViewModelMetadata(
+ typeElement
+ )
+ }
+ }
+}
diff --git a/java/dagger/hilt/android/processor/internal/viewmodel/ViewModelModuleGenerator.kt b/java/dagger/hilt/android/processor/internal/viewmodel/ViewModelModuleGenerator.kt
new file mode 100644
index 0000000..846f7d2
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/viewmodel/ViewModelModuleGenerator.kt
@@ -0,0 +1,169 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.viewmodel
+
+import com.google.auto.common.GeneratedAnnotationSpecs
+import com.squareup.javapoet.AnnotationSpec
+import com.squareup.javapoet.ClassName
+import com.squareup.javapoet.JavaFile
+import com.squareup.javapoet.MethodSpec
+import com.squareup.javapoet.TypeSpec
+import dagger.hilt.android.processor.internal.AndroidClassNames
+import dagger.hilt.processor.internal.ClassNames
+import javax.annotation.processing.ProcessingEnvironment
+import javax.lang.model.SourceVersion
+import javax.lang.model.element.Modifier
+import javax.lang.model.util.Elements
+
+/**
+ * Source generator to support Hilt injection of ViewModels.
+ *
+ * Should generate:
+ * ```
+ * public final class $_HiltModules {
+ * @Module
+ * @InstallIn(ViewModelComponent.class)
+ * public static abstract class BindsModule {
+ * @Binds
+ * @IntoMap
+ * @StringKey("pkg.$")
+ * @HiltViewModelMap
+ * public abstract ViewModel bind($ vm)
+ * }
+ * @Module
+ * @InstallIn(ActivityRetainedComponent.class)
+ * public static final class KeyModule {
+ * @Provides
+ * @IntoSet
+ * @HiltViewModelMap.KeySet
+ * public static String provide() {
+ * return "pkg.$";
+ * }
+ * }
+ * }
+ * ```
+ */
+internal class ViewModelModuleGenerator(
+ private val processingEnv: ProcessingEnvironment,
+ private val injectedViewModel: ViewModelMetadata
+) {
+ fun generate() {
+ val modulesTypeSpec = TypeSpec.classBuilder(injectedViewModel.modulesClassName)
+ .addOriginatingElement(injectedViewModel.typeElement)
+ .addGeneratedAnnotation(processingEnv.elementUtils, processingEnv.sourceVersion)
+ .addAnnotation(
+ AnnotationSpec.builder(ClassNames.ORIGINATING_ELEMENT)
+ .addMember(
+ "topLevelClass",
+ "$T.class",
+ injectedViewModel.className.topLevelClassName()
+ )
+ .build()
+ )
+ .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
+ .addType(getBindsModuleTypeSpec())
+ .addType(getKeyModuleTypeSpec())
+ .addMethod(
+ MethodSpec.constructorBuilder()
+ .addModifiers(Modifier.PRIVATE)
+ .build()
+ )
+ .build()
+ JavaFile.builder(injectedViewModel.modulesClassName.packageName(), modulesTypeSpec)
+ .build()
+ .writeTo(processingEnv.filer)
+ }
+
+ private fun getBindsModuleTypeSpec() = createModuleTypeSpec(
+ className = "BindsModule",
+ component = AndroidClassNames.VIEW_MODEL_COMPONENT
+ )
+ .addModifiers(Modifier.ABSTRACT)
+ .addMethod(getViewModelBindsMethod())
+ .build()
+
+ private fun getViewModelBindsMethod() =
+ MethodSpec.methodBuilder("binds")
+ .addAnnotation(ClassNames.BINDS)
+ .addAnnotation(ClassNames.INTO_MAP)
+ .addAnnotation(
+ AnnotationSpec.builder(ClassNames.STRING_KEY)
+ .addMember("value", S, injectedViewModel.className.reflectionName())
+ .build()
+ )
+ .addAnnotation(AndroidClassNames.HILT_VIEW_MODEL_MAP_QUALIFIER)
+ .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
+ .returns(AndroidClassNames.VIEW_MODEL)
+ .addParameter(injectedViewModel.className, "vm")
+ .build()
+
+ private fun getKeyModuleTypeSpec() = createModuleTypeSpec(
+ className = "KeyModule",
+ component = AndroidClassNames.ACTIVITY_RETAINED_COMPONENT
+ )
+ .addModifiers(Modifier.FINAL)
+ .addMethod(
+ MethodSpec.constructorBuilder()
+ .addModifiers(Modifier.PRIVATE)
+ .build()
+ )
+ .addMethod(getViewModelKeyProvidesMethod())
+ .build()
+
+ private fun getViewModelKeyProvidesMethod() =
+ MethodSpec.methodBuilder("provide")
+ .addAnnotation(ClassNames.PROVIDES)
+ .addAnnotation(ClassNames.INTO_SET)
+ .addAnnotation(AndroidClassNames.HILT_VIEW_MODEL_KEYS_QUALIFIER)
+ .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
+ .returns(String::class.java)
+ .addStatement("return $S", injectedViewModel.className.reflectionName())
+ .build()
+
+ private fun createModuleTypeSpec(className: String, component: ClassName) =
+ TypeSpec.classBuilder(className)
+ .addOriginatingElement(injectedViewModel.typeElement)
+ .addAnnotation(ClassNames.MODULE)
+ .addAnnotation(
+ AnnotationSpec.builder(ClassNames.INSTALL_IN)
+ .addMember("value", "$T.class", component)
+ .build()
+ )
+ .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
+
+ companion object {
+
+ const val L = "\$L"
+ const val T = "\$T"
+ const val N = "\$N"
+ const val S = "\$S"
+ const val W = "\$W"
+
+ private fun TypeSpec.Builder.addGeneratedAnnotation(
+ elements: Elements,
+ sourceVersion: SourceVersion
+ ) = apply {
+ GeneratedAnnotationSpecs.generatedAnnotationSpec(
+ elements,
+ sourceVersion,
+ ViewModelProcessor::class.java
+ ).ifPresent { generatedAnnotation ->
+ addAnnotation(generatedAnnotation)
+ }
+ }
+ }
+}
diff --git a/java/dagger/hilt/android/processor/internal/viewmodel/ViewModelProcessor.kt b/java/dagger/hilt/android/processor/internal/viewmodel/ViewModelProcessor.kt
new file mode 100644
index 0000000..97ebe52
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/viewmodel/ViewModelProcessor.kt
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.viewmodel
+
+import com.google.auto.common.MoreElements
+import com.google.auto.service.AutoService
+import dagger.hilt.android.processor.internal.AndroidClassNames
+import dagger.hilt.processor.internal.BaseProcessor
+import javax.annotation.processing.Processor
+import javax.annotation.processing.RoundEnvironment
+import javax.lang.model.SourceVersion
+import javax.lang.model.element.Element
+import javax.lang.model.element.TypeElement
+import net.ltgt.gradle.incap.IncrementalAnnotationProcessor
+import net.ltgt.gradle.incap.IncrementalAnnotationProcessorType
+
+/**
+ * Annotation processor for @ViewModelInject.
+ */
+@AutoService(Processor::class)
+@IncrementalAnnotationProcessor(IncrementalAnnotationProcessorType.ISOLATING)
+class ViewModelProcessor : BaseProcessor() {
+
+ private val parsedElements = mutableSetOf<TypeElement>()
+
+ override fun getSupportedAnnotationTypes() = setOf(
+ AndroidClassNames.HILT_VIEW_MODEL.toString()
+ )
+
+ override fun getSupportedSourceVersion() = SourceVersion.latest()
+
+ override fun processEach(annotation: TypeElement, element: Element) {
+ val typeElement = MoreElements.asType(element)
+ if (parsedElements.add(typeElement)) {
+ ViewModelMetadata.create(
+ processingEnv,
+ typeElement,
+ )?.let { viewModelMetadata ->
+ ViewModelModuleGenerator(
+ processingEnv,
+ viewModelMetadata
+ ).generate()
+ }
+ }
+ }
+
+ override fun postRoundProcess(roundEnv: RoundEnvironment?) {
+ parsedElements.clear()
+ }
+}
diff --git a/java/dagger/hilt/android/processor/internal/viewmodel/ViewModelValidationPlugin.kt b/java/dagger/hilt/android/processor/internal/viewmodel/ViewModelValidationPlugin.kt
new file mode 100644
index 0000000..a8e57dc
--- /dev/null
+++ b/java/dagger/hilt/android/processor/internal/viewmodel/ViewModelValidationPlugin.kt
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.viewmodel
+
+import com.google.auto.common.MoreTypes.asElement
+import com.google.auto.service.AutoService
+import com.google.common.graph.EndpointPair
+import com.google.common.graph.ImmutableNetwork
+import com.squareup.javapoet.ClassName
+import dagger.hilt.android.processor.internal.AndroidClassNames
+import dagger.hilt.processor.internal.Processors.hasAnnotation
+import dagger.model.Binding
+import dagger.model.BindingGraph
+import dagger.model.BindingGraph.Edge
+import dagger.model.BindingGraph.Node
+import dagger.model.BindingKind
+import dagger.spi.BindingGraphPlugin
+import dagger.spi.DiagnosticReporter
+import javax.tools.Diagnostic.Kind
+
+/**
+ * Plugin to validate users do not inject @HiltViewModel classes.
+ */
+@AutoService(BindingGraphPlugin::class)
+class ViewModelValidationPlugin : BindingGraphPlugin {
+
+ override fun visitGraph(bindingGraph: BindingGraph, diagnosticReporter: DiagnosticReporter) {
+ if (bindingGraph.rootComponentNode().isSubcomponent()) {
+ // This check does not work with partial graphs since it needs to take into account the source
+ // component.
+ return
+ }
+
+ val network: ImmutableNetwork<Node, Edge> = bindingGraph.network()
+ bindingGraph.dependencyEdges().forEach { edge ->
+ val pair: EndpointPair<Node> = network.incidentNodes(edge)
+ val target: Node = pair.target()
+ val source: Node = pair.source()
+ if (target is Binding &&
+ isHiltViewModelBinding(target) &&
+ !isInternalHiltViewModelUsage(source)
+ ) {
+ diagnosticReporter.reportDependency(
+ Kind.ERROR,
+ edge,
+ "\nInjection of an @HiltViewModel class is prohibited since it does not create a " +
+ "ViewModel instance correctly.\nAccess the ViewModel via the Android APIs " +
+ "(e.g. ViewModelProvider) instead." +
+ "\nInjected ViewModel: ${target.key().type()}\n"
+ )
+ }
+ }
+ }
+
+ private fun isHiltViewModelBinding(target: Binding): Boolean {
+ // Make sure this is from an @Inject constructor rather than an overridden binding like an
+ // @Provides and that the class is annotated with @HiltViewModel.
+ return target.kind() == BindingKind.INJECTION &&
+ hasAnnotation(asElement(target.key().type()), AndroidClassNames.HILT_VIEW_MODEL)
+ }
+
+ private fun isInternalHiltViewModelUsage(source: Node): Boolean {
+ // We expect @HiltViewModel classes to be bound into a map with an @Binds like
+ // @Binds
+ // @IntoMap
+ // @StringKey(...)
+ // @HiltViewModelMap
+ // abstract ViewModel bindViewModel(FooViewModel vm)
+ //
+ // So we check that it is a multibinding contribution with the internal qualifier.
+ // TODO(erichang): Should we check for even more things?
+ return source is Binding &&
+ source.key().qualifier().isPresent() &&
+ ClassName.get(source.key().qualifier().get().getAnnotationType()) ==
+ AndroidClassNames.HILT_VIEW_MODEL_MAP_QUALIFIER &&
+ source.key().multibindingContributionIdentifier().isPresent()
+ }
+}
diff --git a/java/dagger/hilt/android/qualifiers/ActivityContext.java b/java/dagger/hilt/android/qualifiers/ActivityContext.java
new file mode 100644
index 0000000..cfcc40e
--- /dev/null
+++ b/java/dagger/hilt/android/qualifiers/ActivityContext.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.qualifiers;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import javax.inject.Qualifier;
+
+/** Annotation for a {@code Context} that corresponds to the activity. */
+@Qualifier
+@Retention(RetentionPolicy.CLASS)
+@Target({ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD})
+public @interface ActivityContext {}
diff --git a/java/dagger/hilt/android/qualifiers/ApplicationContext.java b/java/dagger/hilt/android/qualifiers/ApplicationContext.java
new file mode 100644
index 0000000..226ef75
--- /dev/null
+++ b/java/dagger/hilt/android/qualifiers/ApplicationContext.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.qualifiers;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+import javax.inject.Qualifier;
+
+/** Annotation for an Application Context dependency. */
+@Qualifier
+@Target({ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD})
+public @interface ApplicationContext {}
diff --git a/java/dagger/hilt/android/qualifiers/BUILD b/java/dagger/hilt/android/qualifiers/BUILD
new file mode 100644
index 0000000..26b45ec
--- /dev/null
+++ b/java/dagger/hilt/android/qualifiers/BUILD
@@ -0,0 +1,40 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Hilt Android qualifiers
+
+package(default_visibility = ["//:src"])
+
+android_library(
+ name = "qualifiers",
+ srcs = [
+ "ActivityContext.java",
+ "ApplicationContext.java",
+ ],
+ deps = [
+ ":package_info",
+ "@google_bazel_common//third_party/java/jsr330_inject",
+ ],
+)
+
+java_library(
+ name = "package_info",
+ srcs = ["package-info.java"],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/android/qualifiers/package-info.java b/java/dagger/hilt/android/qualifiers/package-info.java
new file mode 100644
index 0000000..2cbd744
--- /dev/null
+++ b/java/dagger/hilt/android/qualifiers/package-info.java
@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/** This package contains Hilt's built-in Android {@link javax.inject.Qualifier} annotations. */
+package dagger.hilt.android.qualifiers;
diff --git a/java/dagger/hilt/android/scopes/ActivityRetainedScoped.java b/java/dagger/hilt/android/scopes/ActivityRetainedScoped.java
new file mode 100644
index 0000000..c61325d
--- /dev/null
+++ b/java/dagger/hilt/android/scopes/ActivityRetainedScoped.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.scopes;
+
+import static java.lang.annotation.RetentionPolicy.CLASS;
+
+import java.lang.annotation.Retention;
+import javax.inject.Scope;
+
+/**
+ * Scope annotation for bindings that should exist for the life of an activity, surviving
+ * configuration.
+ */
+@Scope
+@Retention(CLASS)
+public @interface ActivityRetainedScoped {}
diff --git a/java/dagger/hilt/android/scopes/ActivityScoped.java b/java/dagger/hilt/android/scopes/ActivityScoped.java
new file mode 100644
index 0000000..9f128f7
--- /dev/null
+++ b/java/dagger/hilt/android/scopes/ActivityScoped.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.scopes;
+
+import static java.lang.annotation.RetentionPolicy.CLASS;
+
+import java.lang.annotation.Retention;
+import javax.inject.Scope;
+
+/**
+ * Scope annotation for bindings that should exist for the life of an activity.
+ */
+@Scope
+@Retention(CLASS)
+public @interface ActivityScoped {}
diff --git a/java/dagger/hilt/android/scopes/BUILD b/java/dagger/hilt/android/scopes/BUILD
new file mode 100644
index 0000000..e74ac9e
--- /dev/null
+++ b/java/dagger/hilt/android/scopes/BUILD
@@ -0,0 +1,60 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+package(default_visibility = ["//:src"])
+
+# Description:
+# Hilt scopes.
+
+android_library(
+ name = "scopes",
+ srcs = [
+ "ActivityScoped.java",
+ "FragmentScoped.java",
+ "ServiceScoped.java",
+ "ViewScoped.java",
+ ],
+ deps = [
+ ":package_info",
+ "@google_bazel_common//third_party/java/jsr330_inject",
+ ],
+)
+
+android_library(
+ name = "activity_retained_scoped",
+ srcs = ["ActivityRetainedScoped.java"],
+ deps = [
+ ":package_info",
+ "@google_bazel_common//third_party/java/jsr330_inject",
+ ],
+)
+
+android_library(
+ name = "view_model_scoped",
+ srcs = ["ViewModelScoped.java"],
+ deps = [
+ ":package_info",
+ "@google_bazel_common//third_party/java/jsr330_inject",
+ ],
+)
+
+java_library(
+ name = "package_info",
+ srcs = ["package-info.java"],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/android/scopes/FragmentScoped.java b/java/dagger/hilt/android/scopes/FragmentScoped.java
new file mode 100644
index 0000000..bc6c75e
--- /dev/null
+++ b/java/dagger/hilt/android/scopes/FragmentScoped.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.scopes;
+
+import static java.lang.annotation.RetentionPolicy.CLASS;
+
+import java.lang.annotation.Retention;
+import javax.inject.Scope;
+
+/**
+ * Scope annotation for bindings that should exist for the life of a fragment.
+ */
+@Scope
+@Retention(CLASS)
+public @interface FragmentScoped {}
diff --git a/java/dagger/hilt/android/scopes/ServiceScoped.java b/java/dagger/hilt/android/scopes/ServiceScoped.java
new file mode 100644
index 0000000..84205f2
--- /dev/null
+++ b/java/dagger/hilt/android/scopes/ServiceScoped.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.scopes;
+
+import static java.lang.annotation.RetentionPolicy.CLASS;
+
+import java.lang.annotation.Retention;
+import javax.inject.Scope;
+
+/**
+ * Scope annotation for bindings that should exist for the life of a service.
+ */
+@Scope
+@Retention(CLASS)
+public @interface ServiceScoped {}
diff --git a/java/dagger/hilt/android/scopes/ViewModelScoped.java b/java/dagger/hilt/android/scopes/ViewModelScoped.java
new file mode 100644
index 0000000..8861125
--- /dev/null
+++ b/java/dagger/hilt/android/scopes/ViewModelScoped.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.scopes;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import javax.inject.Scope;
+
+/**
+ * Scope annotation for bindings that should exist for the life of a a single {@link
+ * androidx.lifecycle.ViewModel}.
+ *
+ * <p>Use this scope annotation when you want to define a dependency in the {@link
+ * dagger.hilt.android.components.ViewModelComponent} for which a single instance will be provided
+ * across all other dependencies for a single {@link
+ * dagger.hilt.android.lifecycle.HiltViewModel}-annotated {@code ViewModel}. Other {@code
+ * ViewModel}s that request the scoped dependency will receive a different instance. For sharing the
+ * same instance of a dependency across all {@code ViewModel}s use a scope from one of the parent
+ * components of {@code dagger.hilt.android.components.ViewModelComponent}, such as {@link
+ * javax.inject.Singleton} or {@link dagger.hilt.android.scopes.ActivityRetainedScoped}.
+ *
+ * <p>For example:
+ *
+ * <pre>
+ * @Module
+ * @InstallIn(ViewModelComponent.class)
+ * public final class ViewModelMovieModule {
+ * @Provides
+ * @ViewModelScoped
+ * public static MovieRepository provideRepo(SavedStateHandle handle) {
+ * return new MovieRepository(handle.getString("movie-id"));
+ * }
+ * }
+ *
+ * public final class MovieDetailFetcher {
+ * @Inject MovieDetailFetcher(MovieRepository movieRepo) {
+ * // ...
+ * }
+ * }
+ *
+ * public final class MoviePosterFetcher {
+ * @Inject MoviePosterFetcher(MovieRepository movieRepo) {
+ * // ...
+ * }
+ * }
+ *
+ * @HiltViewModel
+ * public class MovieViewModel extends ViewModel {
+ * @Inject
+ * public MovieViewModel(MovieDetailFetcher detailFetcher, MoviePosterFetcher posterFetcher) {
+ * // Both detailFetcher and posterFetcher will contain the same instance of
+ * // the MovieRepository.
+ * }
+ * }
+ * </pre>
+ *
+ * @see dagger.hilt.android.lifecycle.HiltViewModel
+ * @see dagger.hilt.android.components.ViewModelComponent
+ */
+@Scope
+@Retention(RetentionPolicy.CLASS)
+public @interface ViewModelScoped {}
diff --git a/java/dagger/hilt/android/scopes/ViewScoped.java b/java/dagger/hilt/android/scopes/ViewScoped.java
new file mode 100644
index 0000000..abf7c0a
--- /dev/null
+++ b/java/dagger/hilt/android/scopes/ViewScoped.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.scopes;
+
+import static java.lang.annotation.RetentionPolicy.CLASS;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+import javax.inject.Scope;
+
+/**
+ * Scope annotation for bindings that should exist for the life of a View.
+ */
+@Scope
+@Retention(CLASS)
+@Target({ElementType.METHOD, ElementType.TYPE})
+public @interface ViewScoped {}
diff --git a/java/dagger/hilt/android/scopes/package-info.java b/java/dagger/hilt/android/scopes/package-info.java
new file mode 100644
index 0000000..6f8f989
--- /dev/null
+++ b/java/dagger/hilt/android/scopes/package-info.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * This package contains Hilt's built-in Android {@link javax.inject.Scope} annotations.
+ *
+ * @see <a href="https://dagger.dev/hilt/components.md#component-lifetimes">Component Lifetimes</a>
+ */
+package dagger.hilt.android.scopes;
diff --git a/java/dagger/hilt/android/testing/AndroidManifest.xml b/java/dagger/hilt/android/testing/AndroidManifest.xml
new file mode 100644
index 0000000..26ec669
--- /dev/null
+++ b/java/dagger/hilt/android/testing/AndroidManifest.xml
@@ -0,0 +1,19 @@
+<!--
+ Copyright (C) 2020 The Dagger Authors.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="dagger.hilt.android.testing">
+ <uses-sdk android:minSdkVersion="14" />
+</manifest>
diff --git a/java/dagger/hilt/android/testing/BUILD b/java/dagger/hilt/android/testing/BUILD
new file mode 100644
index 0000000..47db287
--- /dev/null
+++ b/java/dagger/hilt/android/testing/BUILD
@@ -0,0 +1,238 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# Description:
+# Testing libraries for Hilt Android.
+
+load("//:build_defs.bzl", "POM_VERSION_ALPHA")
+load("//tools:maven.bzl", "gen_maven_artifact")
+
+package(default_visibility = ["//:src"])
+
+android_library(
+ name = "custom_test_application",
+ testonly = 1,
+ srcs = ["CustomTestApplication.java"],
+ exported_plugins = [
+ "//java/dagger/hilt/android/processor/internal/customtestapplication:processor",
+ ],
+ exports = [
+ "//java/dagger/hilt/android/internal/testing:test_application_component_manager",
+ "//java/dagger/hilt/android/internal/testing:test_application_component_manager_holder",
+ "//java/dagger/hilt/internal:component_manager",
+ ],
+ deps = [
+ ":package_info",
+ "//java/dagger/hilt:generates_root_input",
+ ],
+)
+
+android_library(
+ name = "hilt_android_test",
+ testonly = 1,
+ srcs = ["HiltAndroidTest.java"],
+ exported_plugins = [
+ "//java/dagger/hilt/processor/internal/root:plugin",
+ "//java/dagger/hilt/android/processor/internal/androidentrypoint:plugin",
+ "//java/dagger/hilt/android/processor/internal/viewmodel:validation_plugin",
+ ],
+ exports = [
+ ":hilt_android_rule",
+ ":hilt_test_application",
+ ":on_component_ready_runner",
+ ":package_info",
+ "//:dagger_with_compiler",
+ "//java/dagger/hilt:install_in",
+ "//java/dagger/hilt/android/components",
+ "//java/dagger/hilt/android/internal/builders",
+ "//java/dagger/hilt/android/internal/managers",
+ "//java/dagger/hilt/android/internal/modules",
+ "//java/dagger/hilt/android/internal/testing:test_application_component_manager",
+ "//java/dagger/hilt/android/internal/testing:test_application_component_manager_holder",
+ "//java/dagger/hilt/android/internal/testing:test_injector",
+ "//java/dagger/hilt/android/scopes",
+ "//java/dagger/hilt/internal:component_entry_point",
+ "//java/dagger/hilt/internal:component_manager",
+ "//java/dagger/hilt/internal:generated_entry_point",
+ "//java/dagger/hilt/internal:preconditions",
+ "//java/dagger/hilt/migration:disable_install_in_check",
+ "@maven//:androidx_annotation_annotation",
+ "@maven//:androidx_multidex_multidex",
+ "@maven//:androidx_test_core",
+ ],
+ deps = [
+ "//java/dagger/hilt:generates_root_input",
+ ],
+)
+
+android_library(
+ name = "hilt_android_rule",
+ testonly = 1,
+ srcs = ["HiltAndroidRule.java"],
+ deps = [
+ ":package_info",
+ "//java/dagger/hilt/android/internal/testing:mark_that_rules_ran_rule",
+ "//java/dagger/hilt/internal:preconditions",
+ "@maven//:junit_junit",
+ ],
+)
+
+android_library(
+ name = "hilt_test_application",
+ testonly = 1,
+ srcs = [
+ "HiltTestApplication.java",
+ ],
+ deps = [
+ ":on_component_ready_runner",
+ ":package_info",
+ "//java/dagger/hilt/android/internal/testing:test_application_component_manager",
+ "//java/dagger/hilt/android/internal/testing:test_application_component_manager_holder",
+ "//java/dagger/hilt/internal:component_manager",
+ "@maven//:androidx_multidex_multidex",
+ ],
+)
+
+android_library(
+ name = "on_component_ready_runner",
+ testonly = 1,
+ srcs = ["OnComponentReadyRunner.java"],
+ deps = [
+ ":package_info",
+ "//:dagger_with_compiler",
+ "//java/dagger/hilt:entry_point",
+ "//java/dagger/hilt/android/internal/testing:test_application_component_manager_holder",
+ "//java/dagger/hilt/internal:component_manager",
+ "//java/dagger/hilt/internal:preconditions",
+ "@google_bazel_common//third_party/java/auto:value",
+ ],
+)
+
+android_library(
+ name = "uninstall_modules",
+ testonly = 1,
+ srcs = ["UninstallModules.java"],
+ exported_plugins = [
+ "//java/dagger/hilt/android/processor/internal/uninstallmodules:processor",
+ ],
+ deps = [
+ ":package_info",
+ ],
+)
+
+java_library(
+ name = "bind_value",
+ testonly = 1,
+ srcs = [
+ "BindElementsIntoSet.java",
+ "BindValue.java",
+ "BindValueIntoMap.java",
+ "BindValueIntoSet.java",
+ ],
+ exported_plugins = [
+ "//java/dagger/hilt/android/processor/internal/bindvalue:bind_value_processor",
+ ],
+ exports = [
+ "//java/dagger/hilt:install_in",
+ "//java/dagger/hilt/android/qualifiers",
+ ],
+ deps = [
+ ":package_info",
+ "//java/dagger/hilt:generates_root_input",
+ ],
+)
+
+java_library(
+ name = "package_info",
+ srcs = ["package-info.java"],
+ deps = [
+ "@google_bazel_common//third_party/java/jsr305_annotations",
+ ],
+)
+
+android_library(
+ name = "artifact-lib",
+ testonly = 1,
+ tags = ["maven_coordinates=com.google.dagger:hilt-android-testing:" + POM_VERSION_ALPHA],
+ exports = [
+ ":bind_value",
+ ":custom_test_application",
+ ":hilt_android_test",
+ ":package_info",
+ ":uninstall_modules",
+ "//java/dagger/hilt/android:artifact-lib",
+ "//java/dagger/hilt/testing:test_install_in",
+ ],
+)
+
+gen_maven_artifact(
+ name = "artifact",
+ testonly = 1,
+ artifact_coordinates = "com.google.dagger:hilt-android-testing:" + POM_VERSION_ALPHA,
+ artifact_name = "Hilt Android Testing",
+ artifact_target = ":artifact-lib",
+ artifact_target_libs = [
+ "//java/dagger/hilt/android/internal/testing:mark_that_rules_ran_rule",
+ "//java/dagger/hilt/android/internal/testing:test_application_component_manager",
+ "//java/dagger/hilt/android/internal/testing:test_application_component_manager_holder",
+ "//java/dagger/hilt/android/internal/testing:test_component_data",
+ "//java/dagger/hilt/android/internal/testing:test_injector",
+ "//java/dagger/hilt/android/testing:bind_value",
+ "//java/dagger/hilt/android/testing:custom_test_application",
+ "//java/dagger/hilt/android/testing:hilt_android_rule",
+ "//java/dagger/hilt/android/testing:hilt_android_test",
+ "//java/dagger/hilt/android/testing:hilt_test_application",
+ "//java/dagger/hilt/android/testing:on_component_ready_runner",
+ "//java/dagger/hilt/android/testing:package_info",
+ "//java/dagger/hilt/testing:test_install_in",
+ "//java/dagger/hilt/testing:package_info",
+ "//java/dagger/hilt/android/testing:uninstall_modules",
+ ],
+ artifact_target_maven_deps = [
+ "androidx.activity:activity",
+ "androidx.annotation:annotation",
+ "androidx.fragment:fragment",
+ "androidx.lifecycle:lifecycle-viewmodel",
+ "androidx.lifecycle:lifecycle-viewmodel-savedstate",
+ "androidx.multidex:multidex",
+ "androidx.test:core",
+ "com.google.code.findbugs:jsr305",
+ "com.google.dagger:dagger",
+ "com.google.dagger:hilt-android",
+ "javax.inject:javax.inject",
+ "junit:junit",
+ ],
+ artifact_target_maven_deps_banned = [
+ "com.google.guava:guava",
+ "javax.annotation:jsr250-api",
+ ],
+ javadoc_android_api_level = 30,
+ javadoc_exclude_packages = [
+ "dagger.hilt.internal",
+ "dagger.hilt.android.internal",
+ ],
+ javadoc_root_packages = [
+ "dagger.hilt.android.testing",
+ ],
+ javadoc_srcs = [
+ "//java/dagger/hilt:hilt_android_testing_filegroup",
+ "//java/dagger/hilt:hilt_testing_filegroup",
+ ],
+ manifest = "AndroidManifest.xml",
+ packaging = "aar",
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/android/testing/BindElementsIntoSet.java b/java/dagger/hilt/android/testing/BindElementsIntoSet.java
new file mode 100644
index 0000000..620e0c5
--- /dev/null
+++ b/java/dagger/hilt/android/testing/BindElementsIntoSet.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.testing;
+
+import static java.lang.annotation.RetentionPolicy.CLASS;
+
+import dagger.hilt.GeneratesRootInput;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+/**
+ * An annotation that can be used on a test field to contribute the value into the {@link
+ * dagger.hilt.components.SingletonComponent} as an {@link
+ * dagger.multibindings.ElementsIntoSet} for the given type. Example usage:
+ *
+ * <pre><code>
+ * public class FooTest{
+ * ...
+ * {@literal @}BindElementsIntoSet Set<String> bindedSet = ImmutableSet.of("bar", "baz");
+ * ...
+ * }
+ * </code></pre>
+ *
+ * Here, bindedSet will be accessible to the entire application for your test. This is functionally
+ * equivalent to installing the following module in your test:
+ *
+ * <pre><code>
+ * {@literal @}Module
+ * {@literal @}InstallIn
+ * interface MyModule {
+ * {@literal @}Provides
+ * {@literal @}ElementsIntoSet
+ * Set<String> bindSet() {
+ * return ImmutableSet.of("bar", "baz");
+ * }
+ * }
+ * </code></pre>
+ *
+ * Also see {@link BindValueIntoSet}, where you can gather individual elements into one set and bind
+ * it to the application.
+ */
+@Retention(CLASS)
+@Target({ElementType.FIELD})
+@GeneratesRootInput
+public @interface BindElementsIntoSet {}
diff --git a/java/dagger/hilt/android/testing/BindValue.java b/java/dagger/hilt/android/testing/BindValue.java
new file mode 100644
index 0000000..c0164f8
--- /dev/null
+++ b/java/dagger/hilt/android/testing/BindValue.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.testing;
+
+import static java.lang.annotation.RetentionPolicy.CLASS;
+
+import dagger.hilt.GeneratesRootInput;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+/**
+ * An annotation that can be used on a test field to contribute the value into the {@link
+ * dagger.hilt.components.SingletonComponent}. Example usage:
+ *
+ * <pre><code>
+ * public class FooTest{
+ * ...
+ * {@literal @}BindValue Bar boundBar = new Bar();
+ * ...
+ * }
+ * </code></pre>
+ *
+ * Here {@code boundBar} will be accessible to the entire application for your test.
+ */
+@Retention(CLASS)
+@Target({ElementType.FIELD})
+@GeneratesRootInput
+public @interface BindValue {}
diff --git a/java/dagger/hilt/android/testing/BindValueIntoMap.java b/java/dagger/hilt/android/testing/BindValueIntoMap.java
new file mode 100644
index 0000000..b1dfcb3
--- /dev/null
+++ b/java/dagger/hilt/android/testing/BindValueIntoMap.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.testing;
+
+import static java.lang.annotation.RetentionPolicy.CLASS;
+
+import dagger.hilt.GeneratesRootInput;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+/**
+ * An annotation that can be used on a test field to contribute the value into the {@link
+ * dagger.hilt.components.SingletonComponent} as an {@link dagger.multibindings.IntoMap}
+ * for the given type. Example usage:
+ *
+ * <pre><code>
+ * public class FooTest{
+ * ...
+ * {@literal @}BindValueIntoMap
+ * {@literal @}MyMapKey(KEY1)
+ * String boundBar = "bar";
+ *
+ * {@literal @}BindValueIntoMap
+ * {@literal @}MyMapKey(KEY2)
+ * String boundBaz = "baz";
+ * ...
+ * }
+ * </code></pre>
+ *
+ * Here the map that contains all the bound elements (in this case "bar" and "baz") will be
+ * accessible to the entire application for your test.
+ */
+@Retention(CLASS)
+@Target({ElementType.FIELD})
+@GeneratesRootInput
+public @interface BindValueIntoMap {}
diff --git a/java/dagger/hilt/android/testing/BindValueIntoSet.java b/java/dagger/hilt/android/testing/BindValueIntoSet.java
new file mode 100644
index 0000000..690a55c
--- /dev/null
+++ b/java/dagger/hilt/android/testing/BindValueIntoSet.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.testing;
+
+import static java.lang.annotation.RetentionPolicy.CLASS;
+
+import dagger.hilt.GeneratesRootInput;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+/**
+ * An annotation that can be used on a test field to contribute the value into the {@link
+ * dagger.hilt.components.SingletonComponent} as an {@link dagger.multibindings.IntoSet}
+ * for the given type. Example usage:
+ *
+ * <pre><code>
+ * public class FooTest{
+ * ...
+ * {@literal @}BindValueIntoSet String boundBar = "bar";
+ * {@literal @}BindValueIntoSet String boundBaz = "baz";
+ * ...
+ * }
+ * </code></pre>
+ *
+ * Here the set that contains all the bound elements (in this case "bar" and "baz") will be
+ * accessible to the entire application for your test. Also see {@link BindElementsIntoSet}, where
+ * you can gather individual elements into one set and bind it to the application.
+ */
+@Retention(CLASS)
+@Target({ElementType.FIELD})
+@GeneratesRootInput
+public @interface BindValueIntoSet {}
diff --git a/java/dagger/hilt/android/testing/CustomTestApplication.java b/java/dagger/hilt/android/testing/CustomTestApplication.java
new file mode 100644
index 0000000..36a4410
--- /dev/null
+++ b/java/dagger/hilt/android/testing/CustomTestApplication.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.testing;
+
+import dagger.hilt.GeneratesRootInput;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+/**
+ * An annotation that creates an application with the given base type that can be used for any
+ * test in the given build.
+ *
+ * <p>This annotation is useful for creating an application that can be used with instrumentation
+ * tests in gradle, since every instrumentation test must share the same application type.
+ */
+@Target({ElementType.TYPE})
+@GeneratesRootInput
+public @interface CustomTestApplication {
+
+ /** Returns the base {@link android.app.Application} class. */
+ Class<?> value();
+}
diff --git a/java/dagger/hilt/android/testing/HiltAndroidRule.java b/java/dagger/hilt/android/testing/HiltAndroidRule.java
new file mode 100644
index 0000000..32a34f7
--- /dev/null
+++ b/java/dagger/hilt/android/testing/HiltAndroidRule.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.testing;
+
+import static dagger.hilt.internal.Preconditions.checkNotNull;
+
+import dagger.hilt.android.internal.testing.MarkThatRulesRanRule;
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+
+/**
+ * A {@link TestRule} for Hilt that can be used with JVM or Instrumentation tests.
+ *
+ * <p>This rule is required. The Dagger component will not be created without this test rule.
+ */
+public final class HiltAndroidRule implements TestRule {
+ private final MarkThatRulesRanRule rule;
+
+ /** Creates a new instance of the rules. Tests should pass {@code this}. */
+ public HiltAndroidRule(Object testInstance) {
+ this.rule = new MarkThatRulesRanRule(checkNotNull(testInstance));
+ }
+
+ @Override public Statement apply(Statement baseStatement, Description description) {
+ return rule.apply(baseStatement, description);
+ }
+
+ /**
+ * Completes Dagger injection. Must be called before accessing inject types. Must be called after
+ * any non-static test module have been added. If {@link #delayComponentReady} was used, this must
+ * be called after {@link #componentReady}.
+ */
+ public void inject() {
+ rule.inject();
+ }
+
+ /**
+ * Delays creating the component until {@link #componentReady} is called. This is only necessary
+ * in the case that a dynamically bound value (e.g. configuring an @BindValue field in @Before
+ * or @Test method) is requested before test case execution begins.
+ *
+ * <p>Examples of early binding requests include an Activity launched by a test rule, or an entry
+ * points in a {@link OnComponentReadyRunner}.
+ *
+ * <p>If this method is called, {@link #componentReady} must be called before the test case
+ * finishes.
+ */
+ public HiltAndroidRule delayComponentReady() {
+ rule.delayComponentReady();
+ return this;
+ }
+
+ /**
+ * Completes Dagger component creation if {@link delayComponentReady} was used. Binds the current
+ * value of {@link BindValue} fields. Normally this happens automatically. This method may only be
+ * called if {@link delayComponentReady} was used to delay value binding.
+ *
+ * @return an instance of the test rule for chaining
+ */
+ public HiltAndroidRule componentReady() {
+ rule.componentReady();
+ return this;
+ }
+}
diff --git a/java/dagger/hilt/android/testing/HiltAndroidTest.java b/java/dagger/hilt/android/testing/HiltAndroidTest.java
new file mode 100644
index 0000000..fa15f92
--- /dev/null
+++ b/java/dagger/hilt/android/testing/HiltAndroidTest.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.testing;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import dagger.hilt.GeneratesRootInput;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+/** Annotation used for marking an Android emulator tests that require injection. */
+// Set the retention to RUNTIME because we check it via reflection in the HiltAndroidRule.
+@Retention(RUNTIME)
+@Target({ElementType.TYPE})
+@GeneratesRootInput
+public @interface HiltAndroidTest {}
diff --git a/java/dagger/hilt/android/testing/HiltTestApplication.java b/java/dagger/hilt/android/testing/HiltTestApplication.java
new file mode 100644
index 0000000..97eb4cb
--- /dev/null
+++ b/java/dagger/hilt/android/testing/HiltTestApplication.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.testing;
+
+import android.content.Context;
+import androidx.multidex.MultiDexApplication;
+import dagger.hilt.android.internal.testing.TestApplicationComponentManager;
+import dagger.hilt.android.internal.testing.TestApplicationComponentManagerHolder;
+import dagger.hilt.internal.GeneratedComponentManager;
+
+/**
+ * An application that can be used for Android instrumentation or Robolectric tests using Hilt.
+ */
+public final class HiltTestApplication extends MultiDexApplication
+ implements GeneratedComponentManager<Object>, TestApplicationComponentManagerHolder {
+
+ // This field is initialized in attachBaseContext to avoid pulling the generated component into
+ // the main dex. We could possibly avoid this by class loading TestComponentDataSupplier lazily
+ // rather than in the TestApplicationComponentManager constructor.
+ private TestApplicationComponentManager componentManager;
+
+ @Override
+ protected final void attachBaseContext(Context base) {
+ super.attachBaseContext(base);
+ componentManager = new TestApplicationComponentManager(this);
+ }
+
+ @Override
+ public final Object componentManager() {
+ return componentManager;
+ }
+
+ @Override
+ public final Object generatedComponent() {
+ return componentManager.generatedComponent();
+ }
+}
diff --git a/java/dagger/hilt/android/testing/OnComponentReadyRunner.java b/java/dagger/hilt/android/testing/OnComponentReadyRunner.java
new file mode 100644
index 0000000..925a19f
--- /dev/null
+++ b/java/dagger/hilt/android/testing/OnComponentReadyRunner.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.testing;
+
+import android.app.Application;
+import android.content.Context;
+import com.google.auto.value.AutoValue;
+import dagger.hilt.EntryPoints;
+import dagger.hilt.android.internal.testing.TestApplicationComponentManagerHolder;
+import dagger.hilt.internal.GeneratedComponentManager;
+import dagger.hilt.internal.Preconditions;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Provides access to the Singleton component in tests, so that Rules can access it after custom
+ * test modules have been added.
+ */
+public final class OnComponentReadyRunner {
+ private final List<EntryPointListener<?>> listeners = new ArrayList<>();
+ private GeneratedComponentManager<?> componentManager;
+ private boolean componentHostSet = false;
+
+ /** Used by generated code, to notify listeners that the component has been created. */
+ public void setComponentManager(GeneratedComponentManager<?> componentManager) {
+ Preconditions.checkState(!componentHostSet, "Component host was already set.");
+ componentHostSet = true;
+ this.componentManager = componentManager;
+ for (EntryPointListener<?> listener : listeners) {
+ listener.deliverComponent(componentManager);
+ }
+ }
+
+ /** Must be called on the test thread, before the Statement is evaluated. */
+ public static <T> void addListener(
+ Context context, Class<T> entryPoint, OnComponentReadyListener<T> listener) {
+ Application application = (Application) context.getApplicationContext();
+ if (application instanceof TestApplicationComponentManagerHolder) {
+ TestApplicationComponentManagerHolder managerHolder =
+ (TestApplicationComponentManagerHolder) application;
+ OnComponentReadyRunnerHolder runnerHolder =
+ (OnComponentReadyRunnerHolder) managerHolder.componentManager();
+ runnerHolder.getOnComponentReadyRunner().addListenerInternal(entryPoint, listener);
+ }
+ }
+
+ private <T> void addListenerInternal(Class<T> entryPoint, OnComponentReadyListener<T> listener) {
+ if (componentHostSet) {
+ // If the componentHost was already set, just call through immediately
+ runListener(componentManager, entryPoint, listener);
+ } else {
+ listeners.add(EntryPointListener.create(entryPoint, listener));
+ }
+ }
+
+ public boolean isEmpty() {
+ return listeners.isEmpty();
+ }
+
+ @AutoValue
+ abstract static class EntryPointListener<T> {
+ static <T> EntryPointListener<T> create(
+ Class<T> entryPoint, OnComponentReadyListener<T> listener) {
+ return new AutoValue_OnComponentReadyRunner_EntryPointListener<T>(entryPoint, listener);
+ }
+
+ abstract Class<T> entryPoint();
+
+ abstract OnComponentReadyListener<T> listener();
+
+ private void deliverComponent(GeneratedComponentManager<?> object) {
+ runListener(object, entryPoint(), listener());
+ }
+ }
+
+ private static <T> void runListener(
+ GeneratedComponentManager<?> componentManager,
+ Class<T> entryPoint,
+ OnComponentReadyListener<T> listener) {
+ try {
+ listener.onComponentReady(EntryPoints.get(componentManager, entryPoint));
+ } catch (RuntimeException | Error t) {
+ throw t;
+ } catch (Throwable t) {
+ throw new RuntimeException(t);
+ }
+ }
+
+ /** Public for use by generated code and {@link TestApplicationComponentManager} */
+ public interface OnComponentReadyRunnerHolder {
+ OnComponentReadyRunner getOnComponentReadyRunner();
+ }
+
+ /** Rules should register an implementation of this to get access to the singleton component */
+ public interface OnComponentReadyListener<T> {
+ void onComponentReady(T entryPoint) throws Throwable;
+ }
+}
diff --git a/java/dagger/hilt/android/testing/UninstallModules.java b/java/dagger/hilt/android/testing/UninstallModules.java
new file mode 100644
index 0000000..6480c10
--- /dev/null
+++ b/java/dagger/hilt/android/testing/UninstallModules.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.testing;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+/**
+ * An annotation used to uninstall modules that have previously been installed with {@link
+ * dagger.hilt.InstallIn}.
+ *
+ * <p>This feature should only be used in tests. It is useful for replacing production bindings with
+ * fake bindings. The basic idea is to allow users to uninstall the module that provided the
+ * production binding so that a fake binding can be provided by the test.
+ *
+ * <p>Example:
+ *
+ * <pre><code>
+ * {@literal @}HiltAndroidTest
+ * {@literal @}UninstallModules({
+ * ProdFooModule.class,
+ * })
+ * public class MyTest {
+ * {@literal @}Module
+ * {@literal @}InstallIn(SingletonComponent.class)
+ * interface FakeFooModule {
+ * {@literal @}Binds Foo bindFoo(FakeFoo fakeFoo);
+ * }
+ * }
+ * </code></pre>
+ */
+@Target({ElementType.TYPE})
+public @interface UninstallModules {
+
+ /**
+ * Returns the list of classes to uninstall.
+ *
+ * <p>These classes must be annotated with both {@link dagger.Module} and {@link
+ * dagger.hilt.InstallIn}.
+ *
+ * <p>Note:A module that is included as part of another module's {@link dagger.Module#includes()}
+ * cannot be truly uninstalled until the including module is also uninstalled.
+ */
+ Class<?>[] value() default {};
+}
diff --git a/java/dagger/hilt/android/testing/package-info.java b/java/dagger/hilt/android/testing/package-info.java
new file mode 100644
index 0000000..fae8e7d
--- /dev/null
+++ b/java/dagger/hilt/android/testing/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * This package contains APIs for writing Android local or instrumentation tests with Hilt.
+ *
+ * @see <a href="https://dagger.dev/hilt/testing">Hilt Testing</a>
+ */
+@ParametersAreNonnullByDefault
+package dagger.hilt.android.testing;
+
+import javax.annotation.ParametersAreNonnullByDefault;
diff --git a/java/dagger/hilt/codegen/BUILD b/java/dagger/hilt/codegen/BUILD
new file mode 100644
index 0000000..c88182b
--- /dev/null
+++ b/java/dagger/hilt/codegen/BUILD
@@ -0,0 +1,39 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# This package contains sources used within code generated sources.
+
+package(default_visibility = ["//:src"])
+
+java_library(
+ name = "originating_element",
+ srcs = ["OriginatingElement.java"],
+ exported_plugins = [
+ "//java/dagger/hilt/processor/internal/originatingelement:processor",
+ ],
+ deps = [
+ ":package_info",
+ ],
+)
+
+java_library(
+ name = "package_info",
+ srcs = ["package-info.java"],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/codegen/OriginatingElement.java b/java/dagger/hilt/codegen/OriginatingElement.java
new file mode 100644
index 0000000..c53a430
--- /dev/null
+++ b/java/dagger/hilt/codegen/OriginatingElement.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.codegen;
+
+/**
+ * An annotation used to specify the originating element that triggered the code generation of a
+ * type. This annotation should only be used on generated code and is meant to be used by code
+ * generators that generate Hilt modules, entry points, etc. Failure to use this annotation may mean
+ * improper test isolation for generated classes.
+ *
+ * <p>This annotation should be used on any generated top-level class that either contains generated
+ * modules (or entry points) or contains annotations that will generate modules (or entry points).
+ *
+ * <p>Example: Suppose we have the following use of an annotation, {@code MyAnnotation}.
+ *
+ * <pre><code>
+ * class Outer {
+ * static class Inner {
+ * {@literal @}MyAnnotation Foo foo;
+ * }
+ * }
+ * </code></pre>
+ *
+ * <p>If {@code MyAnnotation} generates an entry point, it should be annotated as follows:
+ *
+ * <pre><code>
+ * {@literal @}OriginatingElement(topLevelClass = Outer.class)
+ * {@literal @}EntryPoint
+ * {@literal @}InstallIn(SingletonComponent.class) {
+ * ...
+ * }
+ * </code></pre>
+ */
+// TODO(bcorso): Consider just advising/enforcing that all top-level classes use this annotation.
+public @interface OriginatingElement {
+ /** Returns the top-level class enclosing the originating element. */
+ Class<?> topLevelClass();
+}
diff --git a/java/dagger/hilt/codegen/package-info.java b/java/dagger/hilt/codegen/package-info.java
new file mode 100644
index 0000000..b6bf709
--- /dev/null
+++ b/java/dagger/hilt/codegen/package-info.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * This package contains APIs for code generators that produce code that will be processed by Hilt.
+ */
+// TODO(danysantiago): Add documentation about other code generators that produce input for Hilt
+package dagger.hilt.codegen;
diff --git a/java/dagger/hilt/components/BUILD b/java/dagger/hilt/components/BUILD
new file mode 100644
index 0000000..48dc8cd
--- /dev/null
+++ b/java/dagger/hilt/components/BUILD
@@ -0,0 +1,40 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Hilt components
+
+package(default_visibility = ["//:src"])
+
+java_library(
+ name = "components",
+ srcs = [
+ "SingletonComponent.java",
+ ],
+ deps = [
+ ":package_info",
+ "//java/dagger/hilt:define_component",
+ "@google_bazel_common//third_party/java/jsr330_inject",
+ ],
+)
+
+java_library(
+ name = "package_info",
+ srcs = ["package-info.java"],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/components/SingletonComponent.java b/java/dagger/hilt/components/SingletonComponent.java
new file mode 100644
index 0000000..07e8fe7
--- /dev/null
+++ b/java/dagger/hilt/components/SingletonComponent.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.components;
+
+import dagger.hilt.DefineComponent;
+import javax.inject.Singleton;
+
+/** A Hilt component for singleton bindings. */
+@Singleton
+@DefineComponent
+public interface SingletonComponent {}
diff --git a/java/dagger/hilt/components/package-info.java b/java/dagger/hilt/components/package-info.java
new file mode 100644
index 0000000..3c8cb18
--- /dev/null
+++ b/java/dagger/hilt/components/package-info.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * This package contains Hilt's built-in {@link dagger.Component}s.
+ *
+ * @see <a href="https://dagger.dev/hilt/components.md">Hilt Components</a>
+ */
+package dagger.hilt.components;
diff --git a/java/dagger/hilt/internal/BUILD b/java/dagger/hilt/internal/BUILD
new file mode 100644
index 0000000..dc245d1
--- /dev/null
+++ b/java/dagger/hilt/internal/BUILD
@@ -0,0 +1,68 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Internal Hilt libraries
+
+package(default_visibility = ["//:src"])
+
+java_library(
+ name = "generated_component",
+ srcs = [
+ "GeneratedComponent.java",
+ ],
+)
+
+java_library(
+ name = "component_manager",
+ srcs = [
+ "GeneratedComponentManager.java",
+ "GeneratedComponentManagerHolder.java",
+ ],
+ exports = [
+ ":preconditions",
+ ":unsafe_casts",
+ ],
+)
+
+java_library(
+ name = "preconditions",
+ srcs = [
+ "Preconditions.java",
+ ],
+)
+
+java_library(
+ name = "unsafe_casts",
+ srcs = [
+ "UnsafeCasts.java",
+ ],
+)
+
+java_library(
+ name = "component_entry_point",
+ srcs = ["ComponentEntryPoint.java"],
+ deps = ["//java/dagger/hilt:generates_root_input"],
+)
+
+java_library(
+ name = "generated_entry_point",
+ srcs = ["GeneratedEntryPoint.java"],
+ deps = ["//java/dagger/hilt:generates_root_input"],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/internal/ComponentEntryPoint.java b/java/dagger/hilt/internal/ComponentEntryPoint.java
new file mode 100644
index 0000000..3967e1b
--- /dev/null
+++ b/java/dagger/hilt/internal/ComponentEntryPoint.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.internal;
+
+import static java.lang.annotation.RetentionPolicy.CLASS;
+
+import dagger.hilt.GeneratesRootInput;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation marking generated interfaces for entry points for which there is also a corresponding
+ * generated Component. Component entry points differ from normal entry points in that they may be
+ * filtered out in tests.
+ */
+@Target(ElementType.TYPE)
+@Retention(CLASS)
+@GeneratesRootInput
+// TODO(bcorso): Rename and publicly strip these references out of hilt.
+public @interface ComponentEntryPoint {}
diff --git a/java/dagger/hilt/internal/GeneratedComponent.java b/java/dagger/hilt/internal/GeneratedComponent.java
new file mode 100644
index 0000000..4d85d37
--- /dev/null
+++ b/java/dagger/hilt/internal/GeneratedComponent.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.internal;
+
+/** A marker interface indicating that this is a Hilt generated component. */
+public interface GeneratedComponent {}
diff --git a/java/dagger/hilt/internal/GeneratedComponentManager.java b/java/dagger/hilt/internal/GeneratedComponentManager.java
new file mode 100644
index 0000000..bd837a3
--- /dev/null
+++ b/java/dagger/hilt/internal/GeneratedComponentManager.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.internal;
+
+/** An interface that provides a managed generated component. */
+// TODO(bcorso): Consider either removing type parameter or using actual component type in usages.
+public interface GeneratedComponentManager<T> {
+ T generatedComponent();
+}
diff --git a/java/dagger/hilt/internal/GeneratedComponentManagerHolder.java b/java/dagger/hilt/internal/GeneratedComponentManagerHolder.java
new file mode 100644
index 0000000..f65e2df
--- /dev/null
+++ b/java/dagger/hilt/internal/GeneratedComponentManagerHolder.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.internal;
+
+/** An interface that provides a managed generated component holder. */
+public interface GeneratedComponentManagerHolder extends GeneratedComponentManager<Object> {
+
+ public GeneratedComponentManager<?> componentManager();
+}
diff --git a/java/dagger/hilt/internal/GeneratedEntryPoint.java b/java/dagger/hilt/internal/GeneratedEntryPoint.java
new file mode 100644
index 0000000..76319b9
--- /dev/null
+++ b/java/dagger/hilt/internal/GeneratedEntryPoint.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.internal;
+
+import dagger.hilt.GeneratesRootInput;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+/** Do not use. Only for use from Hilt generators. */
+@Target(ElementType.TYPE)
+@GeneratesRootInput
+public @interface GeneratedEntryPoint {}
diff --git a/java/dagger/hilt/internal/Preconditions.java b/java/dagger/hilt/internal/Preconditions.java
new file mode 100644
index 0000000..b2a84db
--- /dev/null
+++ b/java/dagger/hilt/internal/Preconditions.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.internal;
+
+/**
+ * A partial copy of Guava's {@code com.google.common.base.Preconditions} meant to be used by
+ * generated code. TODO(danysantiago): Consolidate with dagger.internal.Preconditions
+ */
+public final class Preconditions {
+
+ /**
+ * Ensures that an object reference passed as a parameter to the calling method is not null.
+ *
+ * @param reference an object reference
+ * @return the non-null reference that was validated
+ * @throws NullPointerException if {@code reference} is null
+ */
+ public static <T> T checkNotNull(T reference) {
+ if (reference == null) {
+ throw new NullPointerException();
+ }
+ return reference;
+ }
+
+ /**
+ * Ensures that an object reference passed as a parameter to the calling method is not null.
+ *
+ * @param reference an object reference
+ * @param errorMessage the exception message to use if the check fails
+ * @return the non-null reference that was validated
+ * @throws NullPointerException if {@code reference} is null
+ */
+ public static <T> T checkNotNull(T reference, String errorMessage) {
+ if (reference == null) {
+ throw new NullPointerException(errorMessage);
+ }
+ return reference;
+ }
+
+ /**
+ * Ensures the truth of an expression involving one or more parameters to the calling method.
+ *
+ * @param expression a boolean expression
+ * @param errorMessageTemplate a template for the exception message should the check fail. The
+ * message is formed by replacing each occurrence of {@code "%s"} with the corresponding
+ * argument value from {@code args}.
+ * @param args the arguments to be substituted into the message template.
+ * @throws IllegalArgumentException if {@code expression} is false
+ */
+ public static void checkArgument(
+ boolean expression, String errorMessageTemplate, Object... args) {
+ if (!expression) {
+ throw new IllegalArgumentException(String.format(errorMessageTemplate, args));
+ }
+ }
+
+ /**
+ * Ensures the truth of an expression involving one or more parameters to the calling method.
+ *
+ * @param expression a boolean expression
+ * @param errorMessageTemplate a template for the exception message should the check fail. The
+ * message is formed by replacing each occurrence of {@code "%s"} with the corresponding
+ * argument value from {@code args}.
+ * @param args the arguments to be substituted into the message template.
+ * @throws IllegalStateException if {@code expression} is false
+ */
+ public static void checkState(boolean expression, String errorMessageTemplate, Object... args) {
+ if (!expression) {
+ throw new IllegalStateException(String.format(errorMessageTemplate, args));
+ }
+ }
+
+ private Preconditions() {}
+}
diff --git a/java/dagger/hilt/internal/UnsafeCasts.java b/java/dagger/hilt/internal/UnsafeCasts.java
new file mode 100644
index 0000000..796dfce
--- /dev/null
+++ b/java/dagger/hilt/internal/UnsafeCasts.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.internal;
+
+/** Runtime utility method for performing a casting in generated code. */
+public final class UnsafeCasts {
+
+ // Only used where code generations makes it safe.
+ @SuppressWarnings({"TypeParameterUnusedInFormals", "unchecked"})
+ public static <T> T unsafeCast(Object obj) {
+ return (T) obj;
+ }
+
+ private UnsafeCasts() {}
+}
diff --git a/java/dagger/hilt/internal/aliasof/AliasOfPropagatedData.java b/java/dagger/hilt/internal/aliasof/AliasOfPropagatedData.java
new file mode 100644
index 0000000..25ea704
--- /dev/null
+++ b/java/dagger/hilt/internal/aliasof/AliasOfPropagatedData.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.internal.aliasof;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/** An annotation used to aggregate AliasOf values in a common location. */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.CLASS)
+public @interface AliasOfPropagatedData {
+ Class<? extends Annotation> defineComponentScope();
+
+ Class<? extends Annotation> alias();
+}
diff --git a/java/dagger/hilt/internal/aliasof/BUILD b/java/dagger/hilt/internal/aliasof/BUILD
new file mode 100644
index 0000000..3e96ed4
--- /dev/null
+++ b/java/dagger/hilt/internal/aliasof/BUILD
@@ -0,0 +1,28 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# The annotation for classes generated by @AliasOf.
+
+package(default_visibility = ["//:src"])
+
+android_library(
+ name = "aliasof",
+ srcs = ["AliasOfPropagatedData.java"],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/internal/definecomponent/BUILD b/java/dagger/hilt/internal/definecomponent/BUILD
new file mode 100644
index 0000000..b1d56c4
--- /dev/null
+++ b/java/dagger/hilt/internal/definecomponent/BUILD
@@ -0,0 +1,32 @@
+# Copyright (C) 2019 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# The annotations for classes generated by @DefineComponent and @DefineComponent.Factory.
+
+package(default_visibility = ["//:src"])
+
+java_library(
+ name = "definecomponent",
+ srcs = glob(["*.java"]),
+ visibility = [
+ "//java/dagger/hilt:__pkg__",
+ "//java/dagger/hilt/android:__pkg__",
+ ],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/internal/definecomponent/DefineComponentClasses.java b/java/dagger/hilt/internal/definecomponent/DefineComponentClasses.java
new file mode 100644
index 0000000..25555fb
--- /dev/null
+++ b/java/dagger/hilt/internal/definecomponent/DefineComponentClasses.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.internal.definecomponent;
+
+import static java.lang.annotation.ElementType.TYPE;
+import static java.lang.annotation.RetentionPolicy.CLASS;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+/**
+ * An annotation used to aggregate {@link dagger.hilt.DefineComponent} types in a common location.
+ *
+ * <p>Note: The types are given using {@link String} rather than {@link Class} since the {@link
+ * dagger.hilt.DefineComponent} type is not necessarily in the same package and not necessarily
+ * public.
+ */
+@Retention(CLASS)
+@Target(TYPE)
+public @interface DefineComponentClasses {
+ /**
+ * Returns the fully qualified name of the {@link dagger.hilt.DefineComponent} type, or an empty
+ * string if it wasn't given.
+ */
+ String component() default "";
+
+ /**
+ * Returns the fully qualified name of the {@link dagger.hilt.DefineComponent.Builder} type, or an
+ * empty string if it wasn't given.
+ */
+ String builder() default "";
+}
diff --git a/java/dagger/hilt/internal/definecomponent/DefineComponentNoParent.java b/java/dagger/hilt/internal/definecomponent/DefineComponentNoParent.java
new file mode 100644
index 0000000..d5da760
--- /dev/null
+++ b/java/dagger/hilt/internal/definecomponent/DefineComponentNoParent.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.internal.definecomponent;
+
+/** A class used by {@link DefineComponent#parent()} as the default type when no parent is given. */
+public final class DefineComponentNoParent {
+ private DefineComponentNoParent() {}
+}
diff --git a/java/dagger/hilt/internal/generatesrootinput/BUILD b/java/dagger/hilt/internal/generatesrootinput/BUILD
new file mode 100644
index 0000000..8e54ac4
--- /dev/null
+++ b/java/dagger/hilt/internal/generatesrootinput/BUILD
@@ -0,0 +1,28 @@
+# Copyright (C) 2019 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# The annotations for classes generated by @GeneratesRootInput.
+
+package(default_visibility = ["//:src"])
+
+java_library(
+ name = "generatesrootinput",
+ srcs = ["GeneratesRootInputPropagatedData.java"],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/internal/generatesrootinput/GeneratesRootInputPropagatedData.java b/java/dagger/hilt/internal/generatesrootinput/GeneratesRootInputPropagatedData.java
new file mode 100644
index 0000000..d4917f8
--- /dev/null
+++ b/java/dagger/hilt/internal/generatesrootinput/GeneratesRootInputPropagatedData.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.internal.generatesrootinput;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * An annotation used to aggregate {@link dagger.hilt.GeneratesRootInput} types in a common
+ * location.
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.CLASS)
+public @interface GeneratesRootInputPropagatedData {
+ Class<? extends Annotation> value();
+}
diff --git a/java/dagger/hilt/migration/AliasOf.java b/java/dagger/hilt/migration/AliasOf.java
new file mode 100644
index 0000000..b68d4f1
--- /dev/null
+++ b/java/dagger/hilt/migration/AliasOf.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.migration;
+
+import dagger.hilt.GeneratesRootInput;
+import java.lang.annotation.Annotation;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Defines an alias between an existing Hilt scope and the annotated scope. For example, the
+ * following code makes {@literal @}MyScope a functional replacement for {@literal @}ActivityScope.
+ *
+ * <p>
+ *
+ * <pre>
+ * {@literal @}Scope
+ * {@literal @}AliasOf(ActivityScope.class)
+ * public {@literal @}interface MyScope{}
+ * </pre>
+ *
+ * <p>
+ */
+@Target(ElementType.ANNOTATION_TYPE)
+@Retention(RetentionPolicy.CLASS)
+@GeneratesRootInput
+public @interface AliasOf {
+ /** Returns the existing Hilt scope that the annotated scope is aliasing. */
+ Class<? extends Annotation> value();
+}
diff --git a/java/dagger/hilt/migration/BUILD b/java/dagger/hilt/migration/BUILD
new file mode 100644
index 0000000..a14410d
--- /dev/null
+++ b/java/dagger/hilt/migration/BUILD
@@ -0,0 +1,57 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# Description:
+# Libraries for migration.
+
+package(default_visibility = ["//:src"])
+
+android_library(
+ name = "alias_of",
+ srcs = [
+ "AliasOf.java",
+ ],
+ exported_plugins = [
+ "//java/dagger/hilt/processor/internal/aliasof:processor",
+ ],
+ exports = [
+ "//java/dagger/hilt/internal/aliasof",
+ ],
+ deps = [
+ ":package_info",
+ "//java/dagger/hilt:generates_root_input",
+ ],
+)
+
+java_library(
+ name = "disable_install_in_check",
+ srcs = ["DisableInstallInCheck.java"],
+ exported_plugins = [
+ "//java/dagger/hilt/processor/internal/disableinstallincheck:processor",
+ ],
+ exports = [
+ ],
+ deps = [
+ ":package_info",
+ ],
+)
+
+java_library(
+ name = "package_info",
+ srcs = ["package-info.java"],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/migration/DisableInstallInCheck.java b/java/dagger/hilt/migration/DisableInstallInCheck.java
new file mode 100644
index 0000000..acb6252
--- /dev/null
+++ b/java/dagger/hilt/migration/DisableInstallInCheck.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.migration;
+
+/**
+ * Marks a {@link dagger.Module}-annotated class to allow it to have no {@link
+ * dagger.hilt.InstallIn} annotation.
+ *
+ * <p>Use this annotation on modules to suppress the error of a missing {@link
+ * dagger.hilt.InstallIn} annotation. This is useful in cases where non-Hilt Dagger code must be
+ * used long-term. If the issue is widespread, consider changing the error behavior with the
+ * compiler flag {@code dagger.hilt.disableModulesHaveInstallInCheck} instead.
+ */
+public @interface DisableInstallInCheck {}
diff --git a/java/dagger/hilt/migration/package-info.java b/java/dagger/hilt/migration/package-info.java
new file mode 100644
index 0000000..bc269e3
--- /dev/null
+++ b/java/dagger/hilt/migration/package-info.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * This package contains APIs to help migrating a codebase to Hilt.
+ *
+ * @see <a href="https://dagger.dev/hilt/migration">Migration to Hilt</a>
+ */
+package dagger.hilt.migration;
diff --git a/java/dagger/hilt/package-info.java b/java/dagger/hilt/package-info.java
new file mode 100644
index 0000000..568b060
--- /dev/null
+++ b/java/dagger/hilt/package-info.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * This package contains the core APIs for Hilt.
+ *
+ * <p>Hilt provides a standard way to incorporate Dagger dependency injection into an Android
+ * application.
+ *
+ * @see <a href="https://dagger.dev/hilt">Hilt Developer Docs</a>
+ */
+@ParametersAreNonnullByDefault
+package dagger.hilt;
+
+import javax.annotation.ParametersAreNonnullByDefault;
diff --git a/java/dagger/hilt/processor/BUILD b/java/dagger/hilt/processor/BUILD
new file mode 100644
index 0000000..87adcf3
--- /dev/null
+++ b/java/dagger/hilt/processor/BUILD
@@ -0,0 +1,120 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Hilt android processors.
+
+load("//:build_defs.bzl", "POM_VERSION_ALPHA")
+load("//tools:maven.bzl", "gen_maven_artifact")
+
+package(default_visibility = ["//:src"])
+
+# TODO(bcorso): merge this into :artifact-lib once we remove hilt-android-compiler artifact.
+java_library(
+ name = "artifact-lib-shared",
+ exports = [
+ "//java/dagger/hilt/android/processor/internal/androidentrypoint:processor_lib",
+ "//java/dagger/hilt/android/processor/internal/bindvalue:bind_value_processor_lib",
+ "//java/dagger/hilt/android/processor/internal/customtestapplication:processor_lib",
+ "//java/dagger/hilt/android/processor/internal/uninstallmodules:processor_lib",
+ "//java/dagger/hilt/android/processor/internal/viewmodel:processor_lib",
+ "//java/dagger/hilt/android/processor/internal/viewmodel:validation_plugin_lib",
+ "//java/dagger/hilt/processor/internal/aggregateddeps:processor_lib",
+ "//java/dagger/hilt/processor/internal/aliasof:processor_lib",
+ "//java/dagger/hilt/processor/internal/definecomponent:processor_lib",
+ "//java/dagger/hilt/processor/internal/generatesrootinput:processor_lib",
+ "//java/dagger/hilt/processor/internal/originatingelement:processor_lib",
+ "//java/dagger/hilt/processor/internal/root:processor_lib",
+ "//java/dagger/internal/codegen:processor",
+ ],
+)
+
+java_library(
+ name = "artifact-lib",
+ tags = ["maven_coordinates=com.google.dagger:hilt-compiler:" + POM_VERSION_ALPHA],
+ visibility = ["//visibility:private"],
+ exports = [
+ ":artifact-lib-shared",
+ ],
+)
+
+gen_maven_artifact(
+ name = "artifact",
+ artifact_coordinates = "com.google.dagger:hilt-compiler:" + POM_VERSION_ALPHA,
+ artifact_name = "Hilt Processor",
+ artifact_target = ":artifact-lib",
+ artifact_target_libs = [
+ "//java/dagger/hilt/android/processor/internal:android_classnames",
+ "//java/dagger/hilt/android/processor/internal:utils",
+ "//java/dagger/hilt/android/processor/internal/androidentrypoint:android_generators",
+ "//java/dagger/hilt/android/processor/internal/androidentrypoint:compiler_options",
+ "//java/dagger/hilt/android/processor/internal/androidentrypoint:metadata",
+ "//java/dagger/hilt/android/processor/internal/androidentrypoint:processor_lib",
+ "//java/dagger/hilt/android/processor/internal/bindvalue:bind_value_processor_lib",
+ "//java/dagger/hilt/android/processor/internal/customtestapplication:processor_lib",
+ "//java/dagger/hilt/android/processor/internal/viewmodel:validation_plugin_lib",
+ "//java/dagger/hilt/android/processor/internal/uninstallmodules:processor_lib",
+ "//java/dagger/hilt/android/processor/internal/viewmodel:processor_lib",
+ "//java/dagger/hilt/processor/internal:base_processor",
+ "//java/dagger/hilt/processor/internal:classnames",
+ "//java/dagger/hilt/processor/internal:component_descriptor",
+ "//java/dagger/hilt/processor/internal:component_names",
+ "//java/dagger/hilt/processor/internal:components",
+ "//java/dagger/hilt/processor/internal:kotlin",
+ "//java/dagger/hilt/processor/internal:processor_errors",
+ "//java/dagger/hilt/processor/internal:processors",
+ "//java/dagger/hilt/processor/internal/aggregateddeps:component_dependencies",
+ "//java/dagger/hilt/processor/internal/aggregateddeps:processor_lib",
+ "//java/dagger/hilt/processor/internal/aliasof:alias_ofs",
+ "//java/dagger/hilt/processor/internal/aliasof:processor_lib",
+ "//java/dagger/hilt/processor/internal/definecomponent:define_components",
+ "//java/dagger/hilt/processor/internal/definecomponent:processor_lib",
+ "//java/dagger/hilt/processor/internal/generatesrootinput:generates_root_inputs",
+ "//java/dagger/hilt/processor/internal/generatesrootinput:processor_lib",
+ "//java/dagger/hilt/processor/internal/originatingelement:processor_lib",
+ "//java/dagger/hilt/processor/internal/root:processor_lib",
+ "//java/dagger/hilt/processor/internal/root:root_metadata",
+ "//java/dagger/hilt/processor/internal/root:root_type",
+ ],
+ artifact_target_maven_deps = [
+ "com.google.auto:auto-common",
+ "com.google.code.findbugs:jsr305",
+ "com.google.dagger:dagger-compiler",
+ "com.google.dagger:dagger",
+ "com.google.dagger:dagger-spi",
+ "com.google.guava:failureaccess",
+ "com.google.guava:guava",
+ "com.squareup:javapoet",
+ "javax.annotation:jsr250-api",
+ "javax.inject:javax.inject",
+ "net.ltgt.gradle.incap:incap",
+ "org.jetbrains.kotlin:kotlin-stdlib",
+ "org.jetbrains.kotlinx:kotlinx-metadata-jvm",
+ ],
+ javadoc_android_api_level = 30,
+ javadoc_root_packages = [
+ "dagger.hilt.processor",
+ "dagger.hilt.android.processor",
+ ],
+ javadoc_srcs = [
+ "//java/dagger/hilt:hilt_processing_filegroup",
+ ],
+ shaded_deps = ["@maven//:com_google_auto_auto_common"],
+ shaded_rules = ["rule com.google.auto.common.** dagger.hilt.android.shaded.auto.common.@1"],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/processor/internal/AnnotationValues.java b/java/dagger/hilt/processor/internal/AnnotationValues.java
new file mode 100644
index 0000000..584d8f9
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/AnnotationValues.java
@@ -0,0 +1,186 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal;
+
+import static com.google.auto.common.AnnotationMirrors.getAnnotationValue;
+import static com.google.auto.common.AnnotationMirrors.getAnnotationValuesWithDefaults;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.auto.common.MoreTypes;
+import com.google.common.collect.ImmutableList;
+import java.util.List;
+import java.util.Optional;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
+import javax.lang.model.element.AnnotationValueVisitor;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.SimpleAnnotationValueVisitor8;
+
+/** A utility class for working with {@link AnnotationValue} instances. */
+// TODO(bcorso): Update auto-common maven import so we can use it rather than this copy.
+public final class AnnotationValues {
+
+ private AnnotationValues() {}
+
+ private static class DefaultVisitor<T> extends SimpleAnnotationValueVisitor8<T, Void> {
+ final Class<T> clazz;
+
+ DefaultVisitor(Class<T> clazz) {
+ this.clazz = checkNotNull(clazz);
+ }
+
+ @Override
+ public T defaultAction(Object o, Void unused) {
+ throw new IllegalArgumentException(
+ "Expected a " + clazz.getSimpleName() + ", got instead: " + o);
+ }
+ }
+
+ private static final class TypeMirrorVisitor extends DefaultVisitor<DeclaredType> {
+ static final TypeMirrorVisitor INSTANCE = new TypeMirrorVisitor();
+
+ TypeMirrorVisitor() {
+ super(DeclaredType.class);
+ }
+
+ @Override
+ public DeclaredType visitType(TypeMirror value, Void unused) {
+ return MoreTypes.asDeclared(value);
+ }
+ }
+
+ /**
+ * Returns the value as a class.
+ *
+ * @throws IllegalArgumentException if the value is not a class.
+ */
+ public static DeclaredType getTypeMirror(AnnotationValue value) {
+ return TypeMirrorVisitor.INSTANCE.visit(value);
+ }
+
+ private static final class EnumVisitor extends DefaultVisitor<VariableElement> {
+ static final EnumVisitor INSTANCE = new EnumVisitor();
+
+ EnumVisitor() {
+ super(VariableElement.class);
+ }
+
+ @Override
+ public VariableElement visitEnumConstant(VariableElement value, Void unused) {
+ return value;
+ }
+ }
+
+ /**
+ * Returns the value as a VariableElement.
+ *
+ * @throws IllegalArgumentException if the value is not an enum.
+ */
+ public static VariableElement getEnum(AnnotationValue value) {
+ return EnumVisitor.INSTANCE.visit(value);
+ }
+
+ /**
+ * Returns the value as a string.
+ *
+ * @throws IllegalArgumentException if the value is not a string.
+ */
+ public static String getString(AnnotationValue value) {
+ return valueOfType(value, String.class);
+ }
+
+ private static <T> T valueOfType(AnnotationValue annotationValue, Class<T> type) {
+ Object value = annotationValue.getValue();
+ if (!type.isInstance(value)) {
+ throw new IllegalArgumentException(
+ "Expected " + type.getSimpleName() + ", got instead: " + value);
+ }
+ return type.cast(value);
+ }
+
+ /** Returns the int value of an annotation */
+ public static int getIntValue(AnnotationMirror annotation, String valueName) {
+ return (int) getAnnotationValue(annotation, valueName).getValue();
+ }
+
+ /** Returns an optional int value of an annotation if the value name is present */
+ public static Optional<Integer> getOptionalIntValue(
+ AnnotationMirror annotation, String valueName) {
+ return isValuePresent(annotation, valueName)
+ ? Optional.of(getIntValue(annotation, valueName))
+ : Optional.empty();
+ }
+
+ /** Returns the String value of an annotation */
+ public static String getStringValue(AnnotationMirror annotation, String valueName) {
+ return (String) getAnnotationValue(annotation, valueName).getValue();
+ }
+
+ /** Returns an optional String value of an annotation if the value name is present */
+ public static Optional<String> getOptionalStringValue(
+ AnnotationMirror annotation, String valueName) {
+ return isValuePresent(annotation, valueName)
+ ? Optional.of(getStringValue(annotation, valueName))
+ : Optional.empty();
+ }
+
+ /** Returns the int array value of an annotation */
+ public static int[] getIntArrayValue(AnnotationMirror annotation, String valueName) {
+ return getAnnotationValues(getAnnotationValue(annotation, valueName)).stream()
+ .mapToInt(it -> (int) it.getValue())
+ .toArray();
+ }
+
+ /** Returns the String array value of an annotation */
+ public static String[] getStringArrayValue(AnnotationMirror annotation, String valueName) {
+ return getAnnotationValues(getAnnotationValue(annotation, valueName)).stream()
+ .map(it -> (String) it.getValue())
+ .toArray(String[]::new);
+ }
+
+ private static boolean isValuePresent(AnnotationMirror annotation, String valueName) {
+ return getAnnotationValuesWithDefaults(annotation).keySet().stream()
+ .anyMatch(member -> member.getSimpleName().contentEquals(valueName));
+ }
+
+ /**
+ * Returns the list of values represented by an array annotation value.
+ *
+ * @throws IllegalArgumentException unless {@code annotationValue} represents an array
+ */
+ public static ImmutableList<AnnotationValue> getAnnotationValues(
+ AnnotationValue annotationValue) {
+ return annotationValue.accept(AS_ANNOTATION_VALUES, null);
+ }
+
+ private static final AnnotationValueVisitor<ImmutableList<AnnotationValue>, String>
+ AS_ANNOTATION_VALUES =
+ new SimpleAnnotationValueVisitor8<ImmutableList<AnnotationValue>, String>() {
+ @Override
+ public ImmutableList<AnnotationValue> visitArray(
+ List<? extends AnnotationValue> vals, String elementName) {
+ return ImmutableList.copyOf(vals);
+ }
+
+ @Override
+ protected ImmutableList<AnnotationValue> defaultAction(Object o, String elementName) {
+ throw new IllegalArgumentException(elementName + " is not an array: " + o);
+ }
+ };
+}
diff --git a/java/dagger/hilt/processor/internal/BUILD b/java/dagger/hilt/processor/internal/BUILD
new file mode 100644
index 0000000..baff1d8
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/BUILD
@@ -0,0 +1,149 @@
+# Copyright (C) 2019 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Internal code for implementing Hilt processors.
+
+package(default_visibility = ["//:src"])
+
+java_library(
+ name = "base_processor",
+ srcs = [
+ "BaseProcessor.java",
+ "ProcessorErrorHandler.java",
+ ],
+ deps = [
+ ":processor_errors",
+ ":processors",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "@google_bazel_common//third_party/java/auto:value",
+ "@google_bazel_common//third_party/java/javapoet",
+ "@maven//:com_google_auto_auto_common",
+ ],
+)
+
+java_library(
+ name = "processor_errors",
+ srcs = [
+ "BadInputException.java",
+ "ErrorTypeException.java",
+ "ProcessorErrors.java",
+ ],
+ deps = [
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "@google_bazel_common//third_party/java/error_prone:annotations",
+ "@google_bazel_common//third_party/java/jsr305_annotations",
+ "@maven//:com_google_auto_auto_common",
+ ],
+)
+
+java_library(
+ name = "processors",
+ srcs = [
+ "AnnotationValues.java",
+ "Processors.java",
+ ],
+ deps = [
+ ":classnames",
+ ":kotlin",
+ ":processor_errors",
+ "//java/dagger/internal/codegen/extension",
+ "//java/dagger/internal/codegen/kotlin",
+ "//java/dagger/internal/codegen/langmodel",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "@google_bazel_common//third_party/java/javapoet",
+ "@google_bazel_common//third_party/java/jsr305_annotations",
+ "@google_bazel_common//third_party/java/jsr330_inject",
+ "@maven//:com_google_auto_auto_common",
+ "@maven//:org_jetbrains_kotlin_kotlin_stdlib",
+ "@maven//:org_jetbrains_kotlinx_kotlinx_metadata_jvm",
+ ],
+)
+
+java_library(
+ name = "classnames",
+ srcs = [
+ "ClassNames.java",
+ ],
+ deps = [
+ "@google_bazel_common//third_party/java/javapoet",
+ ],
+)
+
+java_library(
+ name = "component_names",
+ srcs = [
+ "ComponentNames.java",
+ ],
+ deps = [
+ ":processors",
+ "@google_bazel_common//third_party/java/javapoet",
+ ],
+)
+
+java_library(
+ name = "component_descriptor",
+ srcs = [
+ "ComponentDescriptor.java",
+ "ComponentGenerator.java",
+ "ComponentTree.java",
+ ],
+ deps = [
+ ":classnames",
+ ":processors",
+ "//java/dagger/internal/codegen/extension",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/internal/guava:graph",
+ "@google_bazel_common//third_party/java/auto:value",
+ "@google_bazel_common//third_party/java/javapoet",
+ ],
+)
+
+java_library(
+ name = "components",
+ srcs = [
+ "Components.java",
+ ],
+ deps = [
+ ":classnames",
+ ":component_descriptor",
+ ":kotlin",
+ ":processor_errors",
+ ":processors",
+ "//java/dagger/hilt/processor/internal/definecomponent:define_components",
+ "//java/dagger/internal/codegen/extension",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "@google_bazel_common//third_party/java/javapoet",
+ "@maven//:com_google_auto_auto_common",
+ ],
+)
+
+java_library(
+ name = "kotlin",
+ srcs = ["KotlinMetadataUtils.java"],
+ deps = [
+ "//:dagger_with_compiler",
+ "//java/dagger/internal/codegen/kotlin",
+ ],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/processor/internal/BadInputException.java b/java/dagger/hilt/processor/internal/BadInputException.java
new file mode 100644
index 0000000..d961768
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/BadInputException.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal;
+
+import com.google.common.collect.ImmutableList;
+import javax.lang.model.element.Element;
+
+/**
+ * Exception to throw when input code has caused an error.
+ * Includes elements to point to for the cause of the error
+ */
+public final class BadInputException extends RuntimeException {
+ private final ImmutableList<Element> badElements;
+
+ public BadInputException(String message, Element badElement) {
+ super(message);
+ this.badElements = ImmutableList.of(badElement);
+ }
+
+ public BadInputException(String message, Iterable<? extends Element> badElements) {
+ super(message);
+ this.badElements = ImmutableList.copyOf(badElements);
+ }
+
+ public ImmutableList<Element> getBadElements() {
+ return badElements;
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/BaseProcessor.java b/java/dagger/hilt/processor/internal/BaseProcessor.java
new file mode 100644
index 0000000..4961cd5
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/BaseProcessor.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal;
+
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.value.AutoValue;
+import com.google.common.collect.LinkedHashMultimap;
+import com.google.common.collect.SetMultimap;
+import com.squareup.javapoet.ClassName;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+import javax.annotation.processing.AbstractProcessor;
+import javax.annotation.processing.Messager;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.annotation.processing.RoundEnvironment;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.util.Elements;
+import javax.lang.model.util.Types;
+
+/**
+ * Implements default configurations for Processors, and provides structure for exception handling.
+ *
+ * <p>By default #process() will do the following:
+ *
+ * <ol>
+ * <li> #preRoundProcess()
+ * <li> foreach element:
+ * <ul><li> #processEach()</ul>
+ * </li>
+ * <li> #postRoundProcess()
+ * <li> #claimAnnotation()
+ * </ol>
+ *
+ * <p>#processEach() allows each element to be processed, even if exceptions are thrown. Due to the
+ * non-deterministic ordering of the processed elements, this is needed to ensure a consistent set
+ * of exceptions are thrown with each build.
+ */
+public abstract class BaseProcessor extends AbstractProcessor {
+ /** Stores the state of processing for a given annotation and element. */
+ @AutoValue
+ abstract static class ProcessingState {
+ private static ProcessingState of(TypeElement annotation, Element element) {
+ // We currently only support TypeElements directly annotated with the annotation.
+ // TODO(bcorso): Switch to using BasicAnnotationProcessor if we need more than this.
+ // Note: Switching to BasicAnnotationProcessor is currently not possible because of cyclic
+ // references to generated types in our API. For example, an @AndroidEntryPoint annotated
+ // element will indefinitely defer its own processing because it extends a generated type
+ // that it's responsible for generating.
+ checkState(MoreElements.isType(element));
+ checkState(Processors.hasAnnotation(element, ClassName.get(annotation)));
+ return new AutoValue_BaseProcessor_ProcessingState(
+ ClassName.get(annotation),
+ ClassName.get(MoreElements.asType(element)));
+ }
+
+ /** Returns the class name of the annotation. */
+ abstract ClassName annotationClassName();
+
+ /** Returns the type name of the annotated element. */
+ abstract ClassName elementClassName();
+
+ /** Returns the annotation that triggered the processing. */
+ TypeElement annotation(Elements elements) {
+ return elements.getTypeElement(elementClassName().toString());
+ }
+
+ /** Returns the annotated element to process. */
+ TypeElement element(Elements elements) {
+ return elements.getTypeElement(annotationClassName().toString());
+ }
+ }
+
+ private final Set<ProcessingState> stateToReprocess = new LinkedHashSet<>();
+ private Elements elements;
+ private Types types;
+ private Messager messager;
+ private ProcessorErrorHandler errorHandler;
+
+ /** Used to perform initialization before each round of processing. */
+ protected void preRoundProcess(RoundEnvironment roundEnv) {};
+
+ /**
+ * Called for each element in a round that uses a supported annotation.
+ *
+ * Note that an exception can be thrown for each element in the round. This is usually preferred
+ * over throwing only the first exception in a round. Only throwing the first exception in the
+ * round can lead to flaky errors that are dependent on the non-deterministic ordering that the
+ * elements are processed in.
+ */
+ protected void processEach(TypeElement annotation, Element element) throws Exception {};
+
+ /**
+ * Used to perform post processing at the end of a round. This is especially useful for handling
+ * additional processing that depends on aggregate data, that cannot be handled in #processEach().
+ *
+ * <p>Note: this will not be called if an exception is thrown during #processEach() -- if we have
+ * already detected errors on an annotated element, performing post processing on an aggregate
+ * will just produce more (perhaps non-deterministic) errors.
+ */
+ protected void postRoundProcess(RoundEnvironment roundEnv) throws Exception {};
+
+ /** @return true if you want to claim annotations after processing each round. Default false. */
+ protected boolean claimAnnotations() {
+ return false;
+ }
+
+ /**
+ * @return true if you want to delay errors to the last round. Useful if the processor
+ * generates code for symbols used a lot in the user code. Delaying allows as much code to
+ * compile as possible for correctly configured types and reduces error spam.
+ */
+ protected boolean delayErrors() {
+ return false;
+ }
+
+
+ @Override
+ public synchronized void init(ProcessingEnvironment processingEnvironment) {
+ super.init(processingEnvironment);
+ this.messager = processingEnv.getMessager();
+ this.elements = processingEnv.getElementUtils();
+ this.types = processingEnv.getTypeUtils();
+ this.errorHandler = new ProcessorErrorHandler(processingEnvironment);
+ }
+
+ @Override
+ public SourceVersion getSupportedSourceVersion() {
+ return SourceVersion.latestSupported();
+ }
+
+ /**
+ * This should not be overridden, as it defines the order of the processing.
+ */
+ @Override
+ public final boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+ preRoundProcess(roundEnv);
+
+ boolean roundError = false;
+
+ // Gather the set of new and deferred elements to process, grouped by annotation.
+ SetMultimap<TypeElement, Element> elementMultiMap = LinkedHashMultimap.create();
+ for (ProcessingState processingState : stateToReprocess) {
+ elementMultiMap.put(processingState.annotation(elements), processingState.element(elements));
+ }
+ for (TypeElement annotation : annotations) {
+ elementMultiMap.putAll(annotation, roundEnv.getElementsAnnotatedWith(annotation));
+ }
+
+ // Clear the processing state before reprocessing.
+ stateToReprocess.clear();
+
+ for (Map.Entry<TypeElement, Collection<Element>> entry : elementMultiMap.asMap().entrySet()) {
+ TypeElement annotation = entry.getKey();
+ for (Element element : entry.getValue()) {
+ try {
+ processEach(annotation, element);
+ } catch (Exception e) {
+ if (e instanceof ErrorTypeException && !roundEnv.processingOver()) {
+ // Allow an extra round to reprocess to try to resolve this type.
+ stateToReprocess.add(ProcessingState.of(annotation, element));
+ } else {
+ errorHandler.recordError(e);
+ roundError = true;
+ }
+ }
+ }
+ }
+
+ if (!roundError) {
+ try {
+ postRoundProcess(roundEnv);
+ } catch (Exception e) {
+ errorHandler.recordError(e);
+ }
+ }
+
+ if (!delayErrors() || roundEnv.processingOver()) {
+ errorHandler.checkErrors();
+ }
+
+ return claimAnnotations();
+ }
+
+ /** @return the error handle for the processor. */
+ protected final ProcessorErrorHandler getErrorHandler() {
+ return errorHandler;
+ }
+
+ public final ProcessingEnvironment getProcessingEnv() {
+ return processingEnv;
+ }
+
+ public final Elements getElementUtils() {
+ return elements;
+ }
+
+ public final Types getTypeUtils() {
+ return types;
+ }
+
+ public final Messager getMessager() {
+ return messager;
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/ClassNames.java b/java/dagger/hilt/processor/internal/ClassNames.java
new file mode 100644
index 0000000..234ea7b
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/ClassNames.java
@@ -0,0 +1,183 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal;
+
+import static com.squareup.javapoet.ClassName.get;
+
+import com.squareup.javapoet.ClassName;
+
+/** Holder for commonly used class names. */
+public final class ClassNames {
+ public static final ClassName ORIGINATING_ELEMENT =
+ get("dagger.hilt.codegen", "OriginatingElement");
+ public static final ClassName AGGREGATED_DEPS =
+ get("dagger.hilt.processor.internal.aggregateddeps", "AggregatedDeps");
+ public static final ClassName GENERATED_COMPONENT =
+ get("dagger.hilt.internal", "GeneratedComponent");
+ public static final ClassName GENERATED_COMPONENT_MANAGER =
+ get("dagger.hilt.internal", "GeneratedComponentManager");
+ public static final ClassName GENERATED_COMPONENT_MANAGER_HOLDER =
+ get("dagger.hilt.internal", "GeneratedComponentManagerHolder");
+ public static final ClassName IGNORE_MODULES =
+ get("dagger.hilt.android.testing", "UninstallModules");
+
+ public static final ClassName DEFINE_COMPONENT = get("dagger.hilt", "DefineComponent");
+ public static final ClassName DEFINE_COMPONENT_BUILDER =
+ get("dagger.hilt", "DefineComponent", "Builder");
+ public static final ClassName DEFINE_COMPONENT_NO_PARENT =
+ get("dagger.hilt.internal.definecomponent", "DefineComponentNoParent");
+ public static final ClassName DEFINE_COMPONENT_CLASSES =
+ get("dagger.hilt.internal.definecomponent", "DefineComponentClasses");
+
+ public static final ClassName ASSISTED_INJECT = get("dagger.assisted", "AssistedInject");
+ public static final ClassName BINDS =
+ get("dagger", "Binds");
+ public static final ClassName BINDS_OPTIONAL_OF =
+ get("dagger", "BindsOptionalOf");
+ public static final ClassName MODULE = get("dagger", "Module");
+ public static final ClassName MULTIBINDS =
+ get("dagger.multibindings", "Multibinds");
+ public static final ClassName INTO_MAP = get("dagger.multibindings", "IntoMap");
+ public static final ClassName INTO_SET = get("dagger.multibindings", "IntoSet");
+ public static final ClassName STRING_KEY = get("dagger.multibindings", "StringKey");
+ public static final ClassName PROVIDES =
+ get("dagger", "Provides");
+ public static final ClassName COMPONENT = get("dagger", "Component");
+ public static final ClassName COMPONENT_BUILDER = get("dagger", "Component", "Builder");
+ public static final ClassName SUBCOMPONENT = get("dagger", "Subcomponent");
+ public static final ClassName SUBCOMPONENT_BUILDER =
+ get("dagger", "Subcomponent", "Builder");
+ public static final ClassName PRODUCTION_COMPONENT =
+ get("dagger.producers", "ProductionComponent");
+
+ public static final ClassName CONTRIBUTES_ANDROID_INJECTOR =
+ get("dagger.android", "ContributesAndroidInjector");
+
+ public static final ClassName INJECT =
+ get("javax.inject", "Inject");
+ public static final ClassName QUALIFIER =
+ get("javax.inject", "Qualifier");
+ public static final ClassName SCOPE =
+ get("javax.inject", "Scope");
+ public static final ClassName PROVIDER = get("javax.inject", "Provider");
+ public static final ClassName DISABLE_INSTALL_IN_CHECK =
+ get("dagger.hilt.migration", "DisableInstallInCheck");
+ public static final ClassName ALIAS_OF = get("dagger.hilt.migration", "AliasOf");
+ public static final ClassName ALIAS_OF_PROPAGATED_DATA =
+ get("dagger.hilt.internal.aliasof", "AliasOfPropagatedData");
+
+ public static final ClassName GENERATES_ROOT_INPUT = get("dagger.hilt", "GeneratesRootInput");
+ public static final ClassName GENERATES_ROOT_INPUT_PROPAGATED_DATA =
+ get("dagger.hilt.internal.generatesrootinput", "GeneratesRootInputPropagatedData");
+
+ public static final ClassName ACTIVITY_SCOPED =
+ get("dagger.hilt.android.scopes", "ActivityScoped");
+ public static final ClassName FRAGMENT_SCOPED =
+ get("dagger.hilt.android.scopes", "FragmentScoped");
+ public static final ClassName SERVICE_SCOPED = get("dagger.hilt.android.scopes", "ServiceScoped");
+ public static final ClassName VIEW_SCOPED = get("dagger.hilt.android.scopes", "ViewScoped");
+
+ public static final ClassName INSTALL_IN =
+ get("dagger.hilt", "InstallIn");
+ public static final ClassName TEST_INSTALL_IN = get("dagger.hilt.testing", "TestInstallIn");
+ public static final ClassName ENTRY_POINT =
+ get("dagger.hilt", "EntryPoint");
+ public static final ClassName ENTRY_POINTS = get("dagger.hilt", "EntryPoints");
+ public static final ClassName COMPONENT_ENTRY_POINT =
+ get("dagger.hilt.internal", "ComponentEntryPoint");
+ public static final ClassName GENERATED_ENTRY_POINT =
+ get("dagger.hilt.internal", "GeneratedEntryPoint");
+ public static final ClassName UNSAFE_CASTS = get("dagger.hilt.internal", "UnsafeCasts");
+ public static final ClassName ROOT_PROCESSOR =
+ get("dagger.hilt.processor.internal.root", "RootProcessor");
+
+ public static final ClassName SINGLETON = get("javax.inject", "Singleton");
+
+ // TODO(erichang): Move these class names out when we factor out the android portion
+ public static final ClassName APPLICATION = get("android.app", "Application");
+ public static final ClassName MULTI_DEX_APPLICATION =
+ get("androidx.multidex", "MultiDexApplication");
+ public static final ClassName ANDROID_ENTRY_POINT =
+ get("dagger.hilt.android", "AndroidEntryPoint");
+ public static final ClassName HILT_ANDROID_APP =
+ get("dagger.hilt.android", "HiltAndroidApp");
+ public static final ClassName CONTEXT = get("android.content", "Context");
+ public static final ClassName APPLICATION_PROVIDER =
+ get("androidx.test.core.app", "ApplicationProvider");
+ public static final ClassName COMPONENT_SUPPLIER =
+ get("dagger.hilt.android.internal.managers", "ComponentSupplier");
+ public static final ClassName APPLICATION_CONTEXT_MODULE =
+ get("dagger.hilt.android.internal.modules", "ApplicationContextModule");
+ public static final ClassName INTERNAL_TEST_ROOT =
+ get("dagger.hilt.android.internal.testing", "InternalTestRoot");
+ public static final ClassName TEST_INJECTOR =
+ get("dagger.hilt.android.internal.testing", "TestInjector");
+ public static final ClassName TEST_APPLICATION_INJECTOR =
+ get("dagger.hilt.android.internal.testing", "TestApplicationInjector");
+ public static final ClassName TEST_APPLICATION_COMPONENT_MANAGER =
+ get("dagger.hilt.android.internal.testing", "TestApplicationComponentManager");
+ public static final ClassName TEST_APPLICATION_COMPONENT_MANAGER_HOLDER =
+ get("dagger.hilt.android.internal.testing", "TestApplicationComponentManagerHolder");
+ public static final ClassName TEST_INSTANCE_HOLDER =
+ get("dagger.hilt.android.internal.testing", "TestInstanceHolder");
+ public static final ClassName HILT_ANDROID_TEST =
+ get("dagger.hilt.android.testing", "HiltAndroidTest");
+ public static final ClassName CUSTOM_TEST_APPLICATION =
+ get("dagger.hilt.android.testing", "CustomTestApplication");
+ public static final ClassName ON_COMPONENT_READY_RUNNER =
+ get("dagger.hilt.android.testing", "OnComponentReadyRunner");
+ public static final ClassName ON_COMPONENT_READY_RUNNER_HOLDER =
+ get("dagger.hilt.android.testing", "OnComponentReadyRunner", "OnComponentReadyRunnerHolder");
+ public static final ClassName ANDROID_BIND_VALUE =
+ get("dagger.hilt.android.testing", "BindValue");
+ public static final ClassName ANDROID_BIND_ELEMENTS_INTO_SET =
+ get("dagger.hilt.android.testing", "BindElementsIntoSet");
+ public static final ClassName ANDROID_BIND_VALUE_INTO_MAP =
+ get("dagger.hilt.android.testing", "BindValueIntoMap");
+ public static final ClassName ANDROID_BIND_VALUE_INTO_SET =
+ get("dagger.hilt.android.testing", "BindValueIntoSet");
+ public static final ClassName APPLICATION_CONTEXT =
+ get("dagger.hilt.android.qualifiers", "ApplicationContext");
+ public static final ClassName TEST_COMPONENT_DATA =
+ get("dagger.hilt.android.internal.testing", "TestComponentData");
+ public static final ClassName TEST_COMPONENT_DATA_SUPPLIER =
+ get("dagger.hilt.android.internal.testing", "TestComponentDataSupplier");
+
+ public static final ClassName CLASS = get("java.lang", "Class");
+ public static final ClassName LIST = get("java.util", "List");
+ public static final ClassName SET = get("java.util", "Set");
+ public static final ClassName MAP = get("java.util", "Map");
+ public static final ClassName HASH_MAP = get("java.util", "HashMap");
+ public static final ClassName HASH_SET = get("java.util", "HashSet");
+ public static final ClassName COLLECTIONS = get("java.util", "Collections");
+ public static final ClassName ARRAYS = get("java.util", "Arrays");
+
+ // Standard components
+ public static final ClassName SINGLETON_COMPONENT =
+ get("dagger.hilt.components", "SingletonComponent");
+ public static final ClassName ACTIVITY_COMPONENT =
+ get("dagger.hilt.android.components", "ActivityComponent");
+
+ public static final ClassName PRECONDITIONS = get("dagger.hilt.internal", "Preconditions");
+
+ public static final ClassName OBJECT = get("java.lang", "Object");
+
+ // Kotlin-specific class names
+ public static final ClassName KOTLIN_METADATA = get("kotlin", "Metadata");
+
+ private ClassNames() {}
+}
diff --git a/java/dagger/hilt/processor/internal/ComponentDescriptor.java b/java/dagger/hilt/processor/internal/ComponentDescriptor.java
new file mode 100644
index 0000000..5d3cef9
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/ComponentDescriptor.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.collect.ImmutableSet;
+import com.squareup.javapoet.ClassName;
+import java.util.Optional;
+
+// TODO(bcorso): Reduce the visibility of this class and return ClassNames instead.
+// TODO(erichang): Rename this class so it doesn't conflict with
+// dagger.internal.codegen.ComponentDescriptor
+/** Represents a single component in the hierarchy. */
+@AutoValue
+public abstract class ComponentDescriptor {
+ public static Builder builder() {
+ return new AutoValue_ComponentDescriptor.Builder()
+ .scopes(ImmutableSet.of());
+ }
+
+ /** Returns the {@link ClassName} for this component descriptor. */
+ public abstract ClassName component();
+
+ /** Returns the {@link ClassName}s for the scopes of this component descriptor. */
+ public abstract ImmutableSet<ClassName> scopes();
+
+ /** Returns the {@link ClassName} for the creator interface. if it exists. */
+ public abstract Optional<ClassName> creator();
+
+ /** Returns the {@link ClassName} for the parent, if it exists. */
+ public abstract Optional<ComponentDescriptor> parent();
+
+ /** Returns {@code true} if the descriptor represents a root component. */
+ public boolean isRoot() {
+ return !parent().isPresent();
+ }
+
+ /**
+ * Returns {@code true} if the given {@link ComponentDescriptor} represents the same {@link
+ * #component()}.
+ */
+ // TODO(b/144939893): Remove equals and hashcode once we have unique ComponentDescriptor instances
+ @Override
+ public final boolean equals(Object obj) {
+ if (obj == this) {
+ return true;
+ }
+ if (!(obj instanceof ComponentDescriptor)) {
+ return false;
+ }
+ ComponentDescriptor that = (ComponentDescriptor) obj;
+
+ // Only check the component name, which should map 1:1 to each component descriptor created
+ // by DefineComponents#componentDescriptor(Element). However, if users are building their own
+ // ComponentDescriptors manually, then this might not be true. We should lock down the builder
+ // method to avoid that.
+ return component().equals(that.component());
+ }
+
+ @Override
+ public final int hashCode() {
+ return component().hashCode();
+ }
+
+ /** Builder for ComponentDescriptor. */
+ @AutoValue.Builder
+ public interface Builder {
+ Builder component(ClassName component);
+
+ Builder scopes(ImmutableSet<ClassName> scopes);
+
+ Builder scopes(ClassName... scopes);
+
+ Builder creator(ClassName creator);
+
+ Builder parent(ComponentDescriptor parent);
+
+
+ ComponentDescriptor build();
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/ComponentGenerator.java b/java/dagger/hilt/processor/internal/ComponentGenerator.java
new file mode 100644
index 0000000..3a4bf1e
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/ComponentGenerator.java
@@ -0,0 +1,172 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal;
+
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
+import static java.util.Comparator.comparing;
+
+import com.google.common.base.Joiner;
+import com.google.common.base.Utf8;
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableList;
+import com.squareup.javapoet.AnnotationSpec;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.TypeName;
+import com.squareup.javapoet.TypeSpec;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.TypeElement;
+
+/** Generates a Dagger component or subcomponent interface. */
+// TODO(bcorso): Make this non-public
+public final class ComponentGenerator {
+ private static final Joiner JOINER = Joiner.on(".");
+ private static final Comparator<ClassName> SIMPLE_NAME_SORTER =
+ Comparator.comparing((ClassName c) -> JOINER.join(c.simpleNames()))
+ .thenComparing(ClassName::compareTo);
+ private static final Comparator<TypeName> TYPE_NAME_SORTER = comparing(TypeName::toString);
+
+ private final ProcessingEnvironment processingEnv;
+ private final ClassName name;
+ private final TypeElement rootElement;
+ private final Optional<ClassName> superclass;
+ private final ImmutableList<ClassName> modules;
+ private final ImmutableList<TypeName> entryPoints;
+ private final ImmutableCollection<ClassName> scopes;
+ private final ImmutableList<AnnotationSpec> extraAnnotations;
+ private final ClassName componentAnnotation;
+ private final Optional<TypeSpec> componentBuilder;
+
+ public ComponentGenerator(
+ ProcessingEnvironment processingEnv,
+ ClassName name,
+ TypeElement rootElement,
+ Optional<ClassName> superclass,
+ Set<? extends ClassName> modules,
+ Set<? extends TypeName> entryPoints,
+ ImmutableCollection<ClassName> scopes,
+ ImmutableList<AnnotationSpec> extraAnnotations,
+ ClassName componentAnnotation,
+ Optional<TypeSpec> componentBuilder) {
+ this.processingEnv = processingEnv;
+ this.name = name;
+ this.rootElement = rootElement;
+ this.superclass = superclass;
+ this.modules = modules.stream().sorted(SIMPLE_NAME_SORTER).collect(toImmutableList());
+ this.entryPoints = entryPoints.stream().sorted(TYPE_NAME_SORTER).collect(toImmutableList());
+ this.scopes = scopes;
+ this.extraAnnotations = extraAnnotations;
+ this.componentAnnotation = componentAnnotation;
+ this.componentBuilder = componentBuilder;
+ }
+
+ public TypeSpec generate() throws IOException {
+ TypeSpec.Builder generator =
+ TypeSpec.classBuilder(name)
+ // Public because components from a scope below must reference to create
+ .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
+ .addOriginatingElement(rootElement)
+ .addAnnotation(getComponentAnnotation());
+
+ componentBuilder.ifPresent(generator::addType);
+
+ scopes.forEach(generator::addAnnotation);
+
+ addEntryPoints(generator);
+
+ superclass.ifPresent(generator::superclass);
+
+ generator.addAnnotations(extraAnnotations);
+
+ return generator.build();
+ }
+
+ /** Returns the component annotation with the list of modules to install for the component. */
+ private AnnotationSpec getComponentAnnotation() {
+ AnnotationSpec.Builder builder = AnnotationSpec.builder(componentAnnotation);
+ modules.forEach(module -> builder.addMember("modules", "$T.class", module));
+ return builder.build();
+ }
+
+ /**
+ * Adds entry points to the component.
+ *
+ * See b/140979968. If the entry points exceed 65763 bytes, we have to partition them to avoid the
+ * limit. To be safe, we split at 60000 bytes.
+ */
+ private void addEntryPoints(TypeSpec.Builder builder) throws IOException {
+ int currBytes = 0;
+ List<Integer> partitionIndexes = new ArrayList<>();
+
+ partitionIndexes.add(0);
+ for (int i = 0; i < entryPoints.size(); i++) {
+ // This over estimates the actual length because it includes the fully qualified name (FQN).
+ // TODO(bcorso): Have a better way to estimate the upper bound. For example, most types will
+ // not include the FQN, but we'll have to consider all of the different subtypes of TypeName,
+ // simple name collisions, etc...
+ int nextBytes = Utf8.encodedLength(entryPoints.get(i).toString());
+
+ // To be safe, we split at 60000 to account for the component name, spaces, commas, etc...
+ if (currBytes + nextBytes > 60000) {
+ partitionIndexes.add(i);
+ currBytes = 0;
+ }
+
+ currBytes += nextBytes;
+ }
+ partitionIndexes.add(entryPoints.size());
+
+ if (partitionIndexes.size() <= 2) {
+ // No extra partitions are needed, so just add all of the entrypoints as is.
+ builder.addSuperinterfaces(entryPoints);
+ } else {
+ // Create interfaces for each partition.
+ // The partitioned interfaces will be added to the component instead of the real entry points.
+ for (int i = 1; i < partitionIndexes.size(); i++) {
+ int startIndex = partitionIndexes.get(i - 1);
+ int endIndex = partitionIndexes.get(i);
+ builder.addSuperinterface(
+ createPartitionInterface(entryPoints.subList(startIndex, endIndex), i));
+ }
+ }
+ }
+
+ private ClassName createPartitionInterface(List<TypeName> partition, int partitionIndex)
+ throws IOException {
+ // TODO(bcorso): Nest the partion inside the HiltComponents wrapper rather than appending name
+ ClassName partitionName =
+ Processors.append(
+ Processors.getEnclosedClassName(name), "_EntryPointPartition" + partitionIndex);
+ TypeSpec.Builder builder =
+ TypeSpec.interfaceBuilder(partitionName)
+ .addOriginatingElement(rootElement)
+ .addModifiers(Modifier.ABSTRACT)
+ .addSuperinterfaces(partition);
+
+ Processors.addGeneratedAnnotation(builder, processingEnv, ClassNames.ROOT_PROCESSOR.toString());
+
+ JavaFile.builder(name.packageName(), builder.build()).build().writeTo(processingEnv.getFiler());
+ return partitionName;
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/ComponentNames.java b/java/dagger/hilt/processor/internal/ComponentNames.java
new file mode 100644
index 0000000..fab4d19
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/ComponentNames.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal;
+
+import com.squareup.javapoet.ClassName;
+
+/**
+ * Utility class for getting the generated component name.
+ *
+ * <p>This should not be used externally.
+ */
+public final class ComponentNames {
+ private ComponentNames() {}
+
+ /** Returns the name of the generated component wrapper. */
+ public static ClassName generatedComponentsWrapper(ClassName root) {
+ return Processors.append(Processors.getEnclosedClassName(root), "_HiltComponents");
+ }
+
+ /** Returns the name of the generated component. */
+ public static ClassName generatedComponent(ClassName root, ClassName component) {
+ return generatedComponentsWrapper(root).nestedClass(componentName(component));
+ }
+
+ /**
+ * Returns the shortened component name by replacing the ending "Component" with "C" if it exists.
+ *
+ * <p>This is a hack because nested subcomponents in Dagger generate extremely long class names
+ * that hit the 256 character limit.
+ */
+ // TODO(bcorso): See if this issue can be fixed in Dagger, e.g. by using static subcomponents.
+ private static String componentName(ClassName component) {
+ // TODO(bcorso): How do we want to handle collisions across packages? Currently, we only handle
+ // collisions across enclosing elements since namespacing by package would likely lead to too
+ // long of class names.
+ // Note: This uses regex matching so we only match if the name ends in "Component"
+ return Processors.getEnclosedName(component).replaceAll("Component$", "C");
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/ComponentTree.java b/java/dagger/hilt/processor/internal/ComponentTree.java
new file mode 100644
index 0000000..6d2137a
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/ComponentTree.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal;
+
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.common.graph.GraphBuilder;
+import com.google.common.graph.Graphs;
+import com.google.common.graph.ImmutableGraph;
+import com.google.common.graph.MutableGraph;
+import com.squareup.javapoet.ClassName;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+/** A representation of the full tree of scopes. */
+public final class ComponentTree {
+ private final ImmutableGraph<ComponentDescriptor> graph;
+ private final ComponentDescriptor root;
+
+ /** Creates a new tree from a set of descriptors. */
+ public static ComponentTree from(Set<ComponentDescriptor> descriptors) {
+ MutableGraph<ComponentDescriptor> graph =
+ GraphBuilder.directed().allowsSelfLoops(false).build();
+
+ descriptors.forEach(
+ descriptor -> {
+ graph.addNode(descriptor);
+ descriptor.parent().ifPresent(parent -> graph.putEdge(parent, descriptor));
+ });
+
+ return new ComponentTree(ImmutableGraph.copyOf(graph));
+ }
+
+ private ComponentTree(ImmutableGraph<ComponentDescriptor> graph) {
+ this.graph = Preconditions.checkNotNull(graph);
+ Preconditions.checkState(
+ !Graphs.hasCycle(graph),
+ "Component graph has cycles: %s",
+ graph.nodes());
+
+ // Check that each component has a unique descriptor
+ Map<ClassName, ComponentDescriptor> descriptors = new HashMap<>();
+ for (ComponentDescriptor descriptor : graph.nodes()) {
+ if (descriptors.containsKey(descriptor.component())) {
+ ComponentDescriptor prevDescriptor = descriptors.get(descriptor.component());
+ Preconditions.checkState(
+ // TODO(b/144939893): Use "==" instead of ".equals()"?
+ descriptor.equals(prevDescriptor),
+ "%s has mismatching descriptors:\n"
+ + " %s\n\n"
+ + " %s\n\n",
+ prevDescriptor.component(),
+ prevDescriptor,
+ descriptor);
+ }
+ descriptors.put(descriptor.component(), descriptor);
+ }
+
+ ImmutableList<ComponentDescriptor> roots =
+ graph.nodes().stream()
+ .filter(node -> graph.inDegree(node) == 0)
+ .collect(toImmutableList());
+
+ Preconditions.checkState(
+ roots.size() == 1,
+ "Component graph must have exactly 1 root. Found: %s",
+ roots.stream().map(ComponentDescriptor::component).collect(toImmutableList()));
+
+ root = Iterables.getOnlyElement(roots);
+ }
+
+ public ImmutableSet<ComponentDescriptor> getComponentDescriptors() {
+ return ImmutableSet.copyOf(graph.nodes());
+ }
+
+ public ImmutableSet<ComponentDescriptor> childrenOf(ComponentDescriptor componentDescriptor) {
+ return ImmutableSet.copyOf(graph.successors(componentDescriptor));
+ }
+
+ public ImmutableGraph<ComponentDescriptor> graph() {
+ return graph;
+ }
+
+ public ComponentDescriptor root() {
+ return root;
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/Components.java b/java/dagger/hilt/processor/internal/Components.java
new file mode 100644
index 0000000..661dd8a
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/Components.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal;
+
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+
+import com.google.auto.common.MoreElements;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableSet;
+import com.squareup.javapoet.AnnotationSpec;
+import com.squareup.javapoet.ClassName;
+import dagger.hilt.processor.internal.definecomponent.DefineComponents;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.util.Elements;
+
+/** Helper methods for defining components and the component hierarchy. */
+public final class Components {
+ // TODO(bcorso): Remove this once all usages are replaced with #getComponents().
+ /**
+ * Returns the {@link ComponentDescriptor}s for a given element annotated with {@link
+ * dagger.hilt.InstallIn}.
+ */
+ public static ImmutableSet<ComponentDescriptor> getComponentDescriptors(
+ Elements elements, Element element) {
+ DefineComponents defineComponents = DefineComponents.create();
+ return getComponents(elements, element).stream()
+ .map(component -> elements.getTypeElement(component.canonicalName()))
+ // TODO(b/144939893): Memoize ComponentDescriptors so we're not recalculating.
+ .map(defineComponents::componentDescriptor)
+ .collect(toImmutableSet());
+ }
+
+ /** Returns the {@link dagger.hilt.InstallIn} components for a given element. */
+ public static ImmutableSet<ClassName> getComponents(Elements elements, Element element) {
+ ImmutableSet<ClassName> components;
+ if (Processors.hasAnnotation(element, ClassNames.INSTALL_IN)
+ || Processors.hasAnnotation(element, ClassNames.TEST_INSTALL_IN)) {
+ components = getHiltInstallInComponents(elements, element);
+ } else {
+ // Check the enclosing element in case it passed in module is a companion object. This helps
+ // in cases where the element was arrived at by checking a binding method and moving outward.
+ Element enclosing = element.getEnclosingElement();
+ if (enclosing != null
+ && MoreElements.isType(enclosing)
+ && MoreElements.isType(element)
+ && Processors.hasAnnotation(enclosing, ClassNames.MODULE)
+ && KotlinMetadataUtils.getMetadataUtil().isCompanionObjectClass(
+ MoreElements.asType(element))) {
+ return getComponents(elements, enclosing);
+ }
+ if (Processors.hasErrorTypeAnnotation(element)) {
+ throw new BadInputException(
+ "Error annotation found on element " + element + ". Look above for compilation errors",
+ element);
+ } else {
+ throw new BadInputException(
+ String.format(
+ "An @InstallIn annotation is required for: %s." ,
+ element),
+ element);
+ }
+ }
+
+ return components;
+ }
+
+ public static AnnotationSpec getInstallInAnnotationSpec(ImmutableSet<ClassName> components) {
+ Preconditions.checkArgument(!components.isEmpty());
+ AnnotationSpec.Builder builder = AnnotationSpec.builder(ClassNames.INSTALL_IN);
+ components.forEach(component -> builder.addMember("value", "$T.class", component));
+ return builder.build();
+ }
+
+ private static ImmutableSet<ClassName> getHiltInstallInComponents(
+ Elements elements, Element element) {
+ Preconditions.checkArgument(
+ Processors.hasAnnotation(element, ClassNames.INSTALL_IN)
+ || Processors.hasAnnotation(element, ClassNames.TEST_INSTALL_IN));
+
+ ImmutableSet<TypeElement> components =
+ ImmutableSet.copyOf(
+ Processors.hasAnnotation(element, ClassNames.INSTALL_IN)
+ ? Processors.getAnnotationClassValues(
+ elements,
+ Processors.getAnnotationMirror(element, ClassNames.INSTALL_IN),
+ "value")
+ : Processors.getAnnotationClassValues(
+ elements,
+ Processors.getAnnotationMirror(element, ClassNames.TEST_INSTALL_IN),
+ "components"));
+
+ ImmutableSet<TypeElement> undefinedComponents =
+ components.stream()
+ .filter(component -> !Processors.hasAnnotation(component, ClassNames.DEFINE_COMPONENT))
+ .collect(toImmutableSet());
+
+ ProcessorErrors.checkState(
+ undefinedComponents.isEmpty(),
+ element,
+ "@InstallIn, can only be used with @DefineComponent-annotated classes, but found: %s",
+ undefinedComponents);
+
+ return components.stream().map(ClassName::get).collect(toImmutableSet());
+ }
+
+ private Components() {}
+}
diff --git a/java/dagger/hilt/processor/internal/ErrorTypeException.java b/java/dagger/hilt/processor/internal/ErrorTypeException.java
new file mode 100644
index 0000000..6f8f67e
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/ErrorTypeException.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal;
+
+import javax.lang.model.element.Element;
+
+/**
+ * Exception to throw when a required {@link Element} is or inherits from an error kind.
+ *
+ * <p>Includes element to point to for the cause of the error
+ */
+public final class ErrorTypeException extends RuntimeException {
+ private final Element badElement;
+
+ public ErrorTypeException(String message, Element badElement) {
+ super(message);
+ this.badElement = badElement;
+ }
+
+ public Element getBadElement() {
+ return badElement;
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/KotlinMetadataUtils.java b/java/dagger/hilt/processor/internal/KotlinMetadataUtils.java
new file mode 100644
index 0000000..ec5ddf8
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/KotlinMetadataUtils.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal;
+
+import dagger.Component;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import javax.inject.Singleton;
+
+/** A single-use provider of {@link KotlinMetadataUtil}. */
+// TODO(erichang): Revert this, should be wrapped with a Dagger module.
+public final class KotlinMetadataUtils {
+
+ @Singleton
+ @Component
+ interface MetadataComponent {
+ KotlinMetadataUtil get();
+ }
+
+ /** Gets the metadata util. */
+ public static KotlinMetadataUtil getMetadataUtil() {
+ return DaggerKotlinMetadataUtils_MetadataComponent.create().get();
+ }
+
+ private KotlinMetadataUtils() {}
+}
diff --git a/java/dagger/hilt/processor/internal/ProcessorErrorHandler.java b/java/dagger/hilt/processor/internal/ProcessorErrorHandler.java
new file mode 100644
index 0000000..460e8a9
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/ProcessorErrorHandler.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.value.AutoValue;
+import com.google.common.base.Throwables;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import javax.annotation.processing.Messager;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.Element;
+import javax.lang.model.util.Elements;
+import javax.tools.Diagnostic.Kind;
+
+/** Utility class to handle keeping track of errors during processing. */
+final class ProcessorErrorHandler {
+
+ private static final String FAILURE_PREFIX = "[Hilt]\n";
+
+ // Special characters to make the tag red and bold to draw attention since
+ // this error can get drowned out by other errors resulting from missing
+ // symbols when we can't generate code.
+ private static final String FAILURE_SUFFIX =
+ "\n\033[1;31m[Hilt] Processing did not complete. See error above for details.\033[0m";
+
+ private final Messager messager;
+ private final Elements elements;
+ private final List<HiltError> hiltErrors;
+
+ ProcessorErrorHandler(ProcessingEnvironment env) {
+ this.messager = env.getMessager();
+ this.elements = env.getElementUtils();
+ this.hiltErrors = new ArrayList<>();
+ }
+
+ /**
+ * Records an error message for some exception to the messager. This can be used to handle
+ * exceptions gracefully that would otherwise be propagated out of the {@code process} method. The
+ * message is stored in order to allow the build to continue as far as it can. The build will be
+ * failed with a {@link Kind#ERROR} in {@link #checkErrors} if an error was recorded with this
+ * method.
+ */
+ void recordError(Throwable t) {
+ // Store messages to allow the build to continue as far as it can. The build will
+ // be failed in checkErrors when processing is over.
+
+ if (t instanceof BadInputException) {
+ BadInputException badInput = (BadInputException) t;
+ for (Element element : badInput.getBadElements()) {
+ hiltErrors.add(HiltError.of(badInput.getMessage(), element));
+ }
+ } else if (t instanceof ErrorTypeException) {
+ ErrorTypeException badInput = (ErrorTypeException) t;
+ hiltErrors.add(HiltError.of(badInput.getMessage(), badInput.getBadElement()));
+ } else if (t.getMessage() != null) {
+ hiltErrors.add(HiltError.of(t.getMessage() + ": " + Throwables.getStackTraceAsString(t)));
+ } else {
+ hiltErrors.add(HiltError.of(t.getClass() + ": " + Throwables.getStackTraceAsString(t)));
+ }
+ }
+
+ /** Checks for any recorded errors. This should be called at the end of process every round. */
+ void checkErrors() {
+ if (!hiltErrors.isEmpty()) {
+ hiltErrors.forEach(
+ hiltError -> {
+ if (hiltError.element().isPresent()) {
+ Element element = hiltError.element().get();
+ if (MoreElements.isType(element)) {
+ // If the error type is a TypeElement, get a new one just in case it was thrown in a
+ // previous round we can report the correct instance. Otherwise, this leads to
+ // issues in AndroidStudio when linking an error to the proper element.
+ // TODO(bcorso): Consider only allowing TypeElement errors when delaying errors,
+ // or maybe even removing delayed errors altogether.
+ element =
+ elements.getTypeElement(
+ MoreElements.asType(element).getQualifiedName().toString());
+ }
+ messager.printMessage(Kind.ERROR, hiltError.message(), element);
+ } else {
+ messager.printMessage(Kind.ERROR, hiltError.message());
+ }
+ });
+ hiltErrors.clear();
+ }
+ }
+
+ @AutoValue
+ abstract static class HiltError {
+ static HiltError of(String message) {
+ return of(message, Optional.empty());
+ }
+
+ static HiltError of(String message, Element element) {
+ return of(message, Optional.of(element));
+ }
+
+ private static HiltError of(String message, Optional<Element> element) {
+ return new AutoValue_ProcessorErrorHandler_HiltError(
+ FAILURE_PREFIX + message + FAILURE_SUFFIX, element);
+ }
+
+ abstract String message();
+
+ abstract Optional<Element> element();
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/ProcessorErrors.java b/java/dagger/hilt/processor/internal/ProcessorErrors.java
new file mode 100644
index 0000000..b1578da
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/ProcessorErrors.java
@@ -0,0 +1,164 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal;
+
+import com.google.auto.common.MoreTypes;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.errorprone.annotations.FormatMethod;
+import com.google.errorprone.annotations.FormatString;
+import java.util.Collection;
+import java.util.stream.Collectors;
+import javax.annotation.Nullable;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeMirror;
+
+/** Static helper methods for throwing errors during code generation. */
+public final class ProcessorErrors {
+ /**
+ * Ensures the truth of an expression involving the state of the calling instance, but not
+ * involving any parameters to the calling method.
+ *
+ * @param expression a boolean expression
+ * @param badElement the element that was at fault
+ * @param errorMessage the exception message to use if the check fails; will be converted to a
+ * string using {@link String#valueOf(Object)}
+ * @throws BadInputException if {@code expression} is false
+ */
+ public static void checkState(
+ boolean expression,
+ Element badElement,
+ @Nullable Object errorMessage) {
+ Preconditions.checkNotNull(badElement);
+ if (!expression) {
+ throw new BadInputException(String.valueOf(errorMessage), badElement);
+ }
+ }
+
+ /**
+ * Ensures the truth of an expression involving the state of the calling instance, but not
+ * involving any parameters to the calling method.
+ *
+ * <p>e.g. checkState(foo.isABar(), "Failed because of %s is not a bar", foo);
+ *
+ * @param expression a boolean expression
+ * @param badElement the element that was at fault
+ * @param errorMessageTemplate a template for the exception message should the check fail. The
+ * message is formed by replacing each {@code %s} placeholder in the template with an
+ * argument. These are matched by position - the first {@code %s} gets {@code
+ * errorMessageArgs[0]}, etc. Unmatched arguments will be appended to the formatted message in
+ * square braces. Unmatched placeholders will be left as-is.
+ * @param errorMessageArgs the arguments to be substituted into the message template. Arguments
+ * are converted to strings using {@link String#valueOf(Object)}.
+ * @throws BadInputException if {@code expression} is false
+ * @throws NullPointerException if the check fails and either {@code errorMessageTemplate} or
+ * {@code errorMessageArgs} is null (don't let this happen)
+ */
+ @FormatMethod
+ public static void checkState(
+ boolean expression,
+ Element badElement,
+ @Nullable @FormatString String errorMessageTemplate,
+ @Nullable Object... errorMessageArgs) {
+ Preconditions.checkNotNull(badElement);
+ if (!expression) {
+ throw new BadInputException(
+ String.format(errorMessageTemplate, errorMessageArgs), badElement);
+ }
+ }
+
+ /**
+ * Ensures the truth of an expression involving the state of the calling instance, but not
+ * involving any parameters to the calling method.
+ *
+ * @param expression a boolean expression
+ * @param badElements the element that were at fault
+ * @param errorMessage the exception message to use if the check fails; will be converted to a
+ * string using {@link String#valueOf(Object)}
+ * @throws BadInputException if {@code expression} is false
+ */
+ public static void checkState(
+ boolean expression,
+ Collection<? extends Element> badElements,
+ @Nullable Object errorMessage) {
+ Preconditions.checkNotNull(badElements);
+ if (!expression) {
+ Preconditions.checkState(!badElements.isEmpty());
+ throw new BadInputException(String.valueOf(errorMessage), badElements);
+ }
+ }
+
+ /**
+ * Ensures the truth of an expression involving the state of the calling instance, but not
+ * involving any parameters to the calling method.
+ *
+ * @param expression a boolean expression
+ * @param badElements the elements that were at fault
+ * @param errorMessageTemplate a template for the exception message should the check fail. The
+ * message is formed by replacing each {@code %s} placeholder in the template with an
+ * argument. These are matched by position - the first {@code %s} gets {@code
+ * errorMessageArgs[0]}, etc. Unmatched arguments will be appended to the formatted message in
+ * square braces. Unmatched placeholders will be left as-is.
+ * @param errorMessageArgs the arguments to be substituted into the message template. Arguments
+ * are converted to strings using {@link String#valueOf(Object)}.
+ * @throws BadInputException if {@code expression} is false
+ * @throws NullPointerException if the check fails and either {@code errorMessageTemplate} or
+ * {@code errorMessageArgs} is null (don't let this happen)
+ */
+ @FormatMethod
+ public static void checkState(
+ boolean expression,
+ Collection<? extends Element> badElements,
+ @Nullable @FormatString String errorMessageTemplate,
+ @Nullable Object... errorMessageArgs) {
+ Preconditions.checkNotNull(badElements);
+ if (!expression) {
+ Preconditions.checkState(!badElements.isEmpty());
+ throw new BadInputException(
+ String.format(errorMessageTemplate, errorMessageArgs), badElements);
+ }
+ }
+
+ /**
+ * Ensures that the given element is not an error kind and does not inherit from an error kind.
+ *
+ * @param element the element to check
+ * @throws ErrorTypeException if {@code element} inherits from an error kind.
+ */
+ public static void checkNotErrorKind(TypeElement element) {
+ TypeMirror currType = element.asType();
+ ImmutableList.Builder<String> typeHierarchy = ImmutableList.builder();
+ while (currType.getKind() != TypeKind.NONE) {
+ typeHierarchy.add(currType.toString());
+ if (currType.getKind() == TypeKind.ERROR) {
+ throw new ErrorTypeException(
+ String.format(
+ "%s, type hierarchy contains error kind, %s."
+ + "\n\tThe partially resolved hierarchy is:\n\t\t%s",
+ element,
+ currType,
+ typeHierarchy.build().stream().collect(Collectors.joining(" -> "))),
+ element);
+ }
+ currType = MoreTypes.asTypeElement(currType).getSuperclass();
+ }
+ }
+
+ private ProcessorErrors() {}
+}
diff --git a/java/dagger/hilt/processor/internal/Processors.java b/java/dagger/hilt/processor/internal/Processors.java
new file mode 100644
index 0000000..b33c19d
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/Processors.java
@@ -0,0 +1,940 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal;
+
+import static com.google.auto.common.MoreElements.asPackage;
+import static com.google.auto.common.MoreElements.asVariable;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static dagger.internal.codegen.extension.DaggerCollectors.toOptional;
+import static javax.lang.model.element.Modifier.ABSTRACT;
+import static javax.lang.model.element.Modifier.STATIC;
+
+import com.google.auto.common.AnnotationMirrors;
+import com.google.auto.common.GeneratedAnnotations;
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.MoreTypes;
+import com.google.common.base.CaseFormat;
+import com.google.common.base.Equivalence.Wrapper;
+import com.google.common.base.Joiner;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.FluentIterable;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.LinkedHashMultimap;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.SetMultimap;
+import com.squareup.javapoet.AnnotationSpec;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterSpec;
+import com.squareup.javapoet.ParameterizedTypeName;
+import com.squareup.javapoet.TypeName;
+import com.squareup.javapoet.TypeSpec;
+import dagger.internal.codegen.extension.DaggerStreams;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import java.lang.annotation.Annotation;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.annotation.processing.RoundEnvironment;
+import javax.inject.Qualifier;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.PackageElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.ArrayType;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.ErrorType;
+import javax.lang.model.type.PrimitiveType;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.ElementFilter;
+import javax.lang.model.util.Elements;
+import javax.lang.model.util.SimpleAnnotationValueVisitor7;
+import javax.lang.model.util.SimpleTypeVisitor7;
+
+/** Static helper methods for writing a processor. */
+public final class Processors {
+
+ public static final String CONSTRUCTOR_NAME = "<init>";
+
+ public static final String STATIC_INITIALIZER_NAME = "<clinit>";
+
+ private static final String JAVA_CLASS = "java.lang.Class";
+
+ /** Returns a map from {@link AnnotationMirror} attribute name to {@link AnnotationValue}s */
+ public static ImmutableMap<String, AnnotationValue> getAnnotationValues(Elements elements,
+ AnnotationMirror annotation) {
+ ImmutableMap.Builder<String, AnnotationValue> annotationMembers = ImmutableMap.builder();
+ for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> e
+ : elements.getElementValuesWithDefaults(annotation).entrySet()) {
+ annotationMembers.put(e.getKey().getSimpleName().toString(), e.getValue());
+ }
+ return annotationMembers.build();
+ }
+
+ /**
+ * Returns a multimap from attribute name to the values that are an array of annotation mirrors.
+ * The returned map will not contain mappings for any attributes that are not Annotation Arrays.
+ *
+ * <p>e.g. if the input was the annotation mirror for
+ * <pre>
+ * {@literal @}Foo({{@literal @}Bar("hello"), {@literal @}Bar("world")})
+ * </pre>
+ * the map returned would have "value" map to a set containing the two @Bar annotation mirrors.
+ */
+ public static Multimap<String, AnnotationMirror> getAnnotationAnnotationArrayValues(
+ Elements elements, AnnotationMirror annotation) {
+ SetMultimap<String, AnnotationMirror> annotationMembers = LinkedHashMultimap.create();
+ for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> e
+ : elements.getElementValuesWithDefaults(annotation).entrySet()) {
+ String attribute = e.getKey().getSimpleName().toString();
+ Set<AnnotationMirror> annotationMirrors = new LinkedHashSet<>();
+ e.getValue().accept(new AnnotationMirrorAnnotationValueVisitor(), annotationMirrors);
+ annotationMembers.putAll(attribute, annotationMirrors);
+ }
+ return annotationMembers;
+ }
+
+ private static final class AnnotationMirrorAnnotationValueVisitor
+ extends SimpleAnnotationValueVisitor7<Void, Set<AnnotationMirror>> {
+
+ @Override
+ public Void visitArray(List<? extends AnnotationValue> vals, Set<AnnotationMirror> types) {
+ for (AnnotationValue val : vals) {
+ val.accept(this, types);
+ }
+ return null;
+ }
+
+ @Override
+ public Void visitAnnotation(AnnotationMirror a, Set<AnnotationMirror> annotationMirrors) {
+ annotationMirrors.add(a);
+ return null;
+ }
+ }
+
+ /** Returns the {@link TypeElement} for a class attribute on an annotation. */
+ public static TypeElement getAnnotationClassValue(
+ Elements elements, AnnotationMirror annotation, String key) {
+ return Iterables.getOnlyElement(getAnnotationClassValues(elements, annotation, key));
+ }
+
+ /** Returns a list of {@link TypeElement}s for a class attribute on an annotation. */
+ public static ImmutableList<TypeElement> getAnnotationClassValues(
+ Elements elements, AnnotationMirror annotation, String key) {
+ ImmutableList<TypeElement> values = getOptionalAnnotationClassValues(elements, annotation, key);
+
+ ProcessorErrors.checkState(
+ values.size() >= 1,
+ // TODO(b/152801981): Point to the annotation value rather than the annotated element.
+ annotation.getAnnotationType().asElement(),
+ "@%s, '%s' class is invalid or missing: %s",
+ annotation.getAnnotationType().asElement().getSimpleName(),
+ key,
+ annotation);
+
+ return values;
+ }
+
+ /** Returns a multimap from attribute name to elements for class valued attributes. */
+ private static Multimap<String, DeclaredType> getAnnotationClassValues(
+ Elements elements, AnnotationMirror annotation) {
+ Element javaClass = elements.getTypeElement(JAVA_CLASS);
+ SetMultimap<String, DeclaredType> annotationMembers = LinkedHashMultimap.create();
+ for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> e :
+ elements.getElementValuesWithDefaults(annotation).entrySet()) {
+ Optional<DeclaredType> returnType = getOptionalDeclaredType(e.getKey().getReturnType());
+ if (returnType.isPresent() && returnType.get().asElement().equals(javaClass)) {
+ String attribute = e.getKey().getSimpleName().toString();
+ Set<DeclaredType> declaredTypes = new LinkedHashSet<DeclaredType>();
+ e.getValue().accept(new DeclaredTypeAnnotationValueVisitor(), declaredTypes);
+ annotationMembers.putAll(attribute, declaredTypes);
+ }
+ }
+ return annotationMembers;
+ }
+
+ /** Returns an optional {@link TypeElement} for a class attribute on an annotation. */
+ public static Optional<TypeElement> getOptionalAnnotationClassValue(
+ Elements elements, AnnotationMirror annotation, String key) {
+ return getAnnotationClassValues(elements, annotation).get(key).stream()
+ .map(MoreTypes::asTypeElement)
+ .collect(toOptional());
+ }
+
+ /** Returns a list of {@link TypeElement}s for a class attribute on an annotation. */
+ public static ImmutableList<TypeElement> getOptionalAnnotationClassValues(
+ Elements elements, AnnotationMirror annotation, String key) {
+ return ImmutableList.copyOf(
+ getAnnotationClassValues(elements, annotation).get(key).stream()
+ .map(MoreTypes::asTypeElement)
+ .collect(Collectors.toList()));
+ }
+
+ private static final class DeclaredTypeAnnotationValueVisitor
+ extends SimpleAnnotationValueVisitor7<Void, Set<DeclaredType>> {
+
+ @Override public Void visitArray(
+ List<? extends AnnotationValue> vals, Set<DeclaredType> types) {
+ for (AnnotationValue val : vals) {
+ val.accept(this, types);
+ }
+ return null;
+ }
+
+ @Override public Void visitType(TypeMirror t, Set<DeclaredType> types) {
+ DeclaredType declared = MoreTypes.asDeclared(t);
+ checkNotNull(declared);
+ types.add(declared);
+ return null;
+ }
+ }
+
+ /**
+ * If the received mirror represents a primitive type or an array of primitive types, this returns
+ * the represented primitive type. Otherwise throws an IllegalStateException.
+ */
+ public static PrimitiveType getPrimitiveType(TypeMirror type) {
+ return type.accept(
+ new SimpleTypeVisitor7<PrimitiveType, Void> () {
+ @Override public PrimitiveType visitArray(ArrayType type, Void unused) {
+ return getPrimitiveType(type.getComponentType());
+ }
+
+ @Override public PrimitiveType visitPrimitive(PrimitiveType type, Void unused) {
+ return type;
+ }
+
+ @Override public PrimitiveType defaultAction(TypeMirror type, Void unused) {
+ throw new IllegalStateException("Unhandled type: " + type);
+ }
+ }, null /* the Void accumulator */);
+ }
+
+ /**
+ * Returns an {@link Optional#of} the declared type if the received mirror represents a declared
+ * type or an array of declared types, otherwise returns {@link Optional#empty}.
+ */
+ public static Optional<DeclaredType> getOptionalDeclaredType(TypeMirror type) {
+ return Optional.ofNullable(
+ type.accept(
+ new SimpleTypeVisitor7<DeclaredType, Void>(null /* defaultValue */) {
+ @Override
+ public DeclaredType visitArray(ArrayType type, Void unused) {
+ return MoreTypes.asDeclared(type.getComponentType());
+ }
+
+ @Override
+ public DeclaredType visitDeclared(DeclaredType type, Void unused) {
+ return type;
+ }
+
+ @Override
+ public DeclaredType visitError(ErrorType type, Void unused) {
+ return type;
+ }
+ },
+ null /* the Void accumulator */));
+ }
+
+ /**
+ * Returns the declared type if the received mirror represents a declared type or an array of
+ * declared types, otherwise throws an {@link IllegalStateException}.
+ */
+ public static DeclaredType getDeclaredType(TypeMirror type) {
+ return getOptionalDeclaredType(type)
+ .orElseThrow(() -> new IllegalStateException("Not a declared type: " + type));
+ }
+
+ /** Gets the values from an annotation value representing a string array. */
+ public static ImmutableList<String> getStringArrayAnnotationValue(AnnotationValue value) {
+ return value.accept(new SimpleAnnotationValueVisitor7<ImmutableList<String>, Void>() {
+ @Override
+ public ImmutableList<String> defaultAction(Object o, Void unused) {
+ throw new IllegalStateException("Expected an array, got instead: " + o);
+ }
+
+ @Override
+ public ImmutableList<String> visitArray(List<? extends AnnotationValue> values,
+ Void unused) {
+ ImmutableList.Builder<String> builder = ImmutableList.builder();
+ for (AnnotationValue value : values) {
+ builder.add(getStringAnnotationValue(value));
+ }
+ return builder.build();
+ }
+ }, /* unused accumulator */ null);
+ }
+
+ /** Gets the values from an annotation value representing an int. */
+ public static Boolean getBooleanAnnotationValue(AnnotationValue value) {
+ return value.accept(
+ new SimpleAnnotationValueVisitor7<Boolean, Void>() {
+ @Override
+ public Boolean defaultAction(Object o, Void unused) {
+ throw new IllegalStateException("Expected a boolean, got instead: " + o);
+ }
+
+ @Override
+ public Boolean visitBoolean(boolean value, Void unused) {
+ return value;
+ }
+ }, /* unused accumulator */
+ null);
+ }
+
+ /** Gets the values from an annotation value representing an int. */
+ public static Integer getIntAnnotationValue(AnnotationValue value) {
+ return value.accept(new SimpleAnnotationValueVisitor7<Integer, Void>() {
+ @Override
+ public Integer defaultAction(Object o, Void unused) {
+ throw new IllegalStateException("Expected an int, got instead: " + o);
+ }
+
+ @Override
+ public Integer visitInt(int value, Void unused) {
+ return value;
+ }
+ }, /* unused accumulator */ null);
+ }
+
+ /** Gets the values from an annotation value representing a long. */
+ public static Long getLongAnnotationValue(AnnotationValue value) {
+ return value.accept(
+ new SimpleAnnotationValueVisitor7<Long, Void>() {
+ @Override
+ public Long defaultAction(Object o, Void unused) {
+ throw new IllegalStateException("Expected an int, got instead: " + o);
+ }
+
+ @Override
+ public Long visitLong(long value, Void unused) {
+ return value;
+ }
+ },
+ null /* unused accumulator */);
+ }
+
+ /** Gets the values from an annotation value representing a string. */
+ public static String getStringAnnotationValue(AnnotationValue value) {
+ return value.accept(new SimpleAnnotationValueVisitor7<String, Void>() {
+ @Override
+ public String defaultAction(Object o, Void unused) {
+ throw new IllegalStateException("Expected a string, got instead: " + o);
+ }
+
+ @Override
+ public String visitString(String value, Void unused) {
+ return value;
+ }
+ }, /* unused accumulator */ null);
+ }
+
+ /** Gets the values from an annotation value representing a DeclaredType. */
+ public static DeclaredType getDeclaredTypeAnnotationValue(AnnotationValue value) {
+ return value.accept(
+ new SimpleAnnotationValueVisitor7<DeclaredType, Void>() {
+ @Override
+ public DeclaredType defaultAction(Object o, Void unused) {
+ throw new IllegalStateException("Expected a TypeMirror, got instead: " + o);
+ }
+
+ @Override
+ public DeclaredType visitType(TypeMirror typeMirror, Void unused) {
+ return MoreTypes.asDeclared(typeMirror);
+ }
+ }, /* unused accumulator */
+ null);
+ }
+
+ private static final SimpleAnnotationValueVisitor7<ImmutableSet<VariableElement>, Void>
+ ENUM_ANNOTATION_VALUE_VISITOR =
+ new SimpleAnnotationValueVisitor7<ImmutableSet<VariableElement>, Void>() {
+ @Override
+ public ImmutableSet<VariableElement> defaultAction(Object o, Void unused) {
+ throw new IllegalStateException(
+ "Expected an Enum or an Enum array, got instead: " + o);
+ }
+
+ @Override
+ public ImmutableSet<VariableElement> visitArray(
+ List<? extends AnnotationValue> values, Void unused) {
+ ImmutableSet.Builder<VariableElement> builder = ImmutableSet.builder();
+ for (AnnotationValue value : values) {
+ builder.addAll(value.accept(this, null));
+ }
+ return builder.build();
+ }
+
+ @Override
+ public ImmutableSet<VariableElement> visitEnumConstant(
+ VariableElement value, Void unused) {
+ return ImmutableSet.of(value);
+ }
+ };
+
+ /** Gets the values from an annotation value representing a Enum array. */
+ public static ImmutableSet<VariableElement> getEnumArrayAnnotationValue(AnnotationValue value) {
+ return value.accept(ENUM_ANNOTATION_VALUE_VISITOR, /* unused accumulator */ null);
+ }
+
+ /** Converts an annotation value map to be keyed by the attribute name. */
+ public static ImmutableMap<String, AnnotationValue> convertToAttributeNameMap(
+ Map<? extends ExecutableElement, ? extends AnnotationValue> annotationValues) {
+ ImmutableMap.Builder<String, AnnotationValue> builder = ImmutableMap.builder();
+ for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> e
+ : annotationValues.entrySet()) {
+ String attribute = e.getKey().getSimpleName().toString();
+ builder.put(attribute, e.getValue());
+ }
+ return builder.build();
+ }
+
+ /** Returns the given elements containing package element. */
+ public static PackageElement getPackageElement(Element originalElement) {
+ checkNotNull(originalElement);
+ for (Element e = originalElement; e != null; e = e.getEnclosingElement()) {
+ if (e instanceof PackageElement) {
+ return (PackageElement) e;
+ }
+ }
+ throw new IllegalStateException("Cannot find a package for " + originalElement);
+ }
+
+ public static TypeElement getTopLevelType(Element originalElement) {
+ checkNotNull(originalElement);
+ for (Element e = originalElement; e != null; e = e.getEnclosingElement()) {
+ if (isTopLevel(e)) {
+ return MoreElements.asType(e);
+ }
+ }
+ throw new IllegalStateException("Cannot find a top-level type for " + originalElement);
+ }
+
+ /** Returns true if the given element is a top-level element. */
+ public static boolean isTopLevel(Element element) {
+ return element.getEnclosingElement().getKind() == ElementKind.PACKAGE;
+ }
+
+ /** Returns true if the given element is annotated with the given annotation. */
+ public static boolean hasAnnotation(Element element, Class<? extends Annotation> annotation) {
+ return element.getAnnotation(annotation) != null;
+ }
+
+ /** Returns true if the given element has an annotation with the given class name. */
+ public static boolean hasAnnotation(Element element, ClassName className) {
+ return getAnnotationMirrorOptional(element, className).isPresent();
+ }
+
+ /** Returns true if the given element has an annotation with the given class name. */
+ public static boolean hasAnnotation(AnnotationMirror mirror, ClassName className) {
+ return hasAnnotation(mirror.getAnnotationType().asElement(), className);
+ }
+
+ /** Returns true if the given element is annotated with the given annotation. */
+ public static boolean hasAnnotation(
+ AnnotationMirror mirror, Class<? extends Annotation> annotation) {
+ return hasAnnotation(mirror.getAnnotationType().asElement(), annotation);
+ }
+
+ /** Returns true if the given element has an annotation that is an error kind. */
+ public static boolean hasErrorTypeAnnotation(Element element) {
+ for (AnnotationMirror annotationMirror : element.getAnnotationMirrors()) {
+ if (annotationMirror.getAnnotationType().getKind() == TypeKind.ERROR) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+
+ /**
+ * Returns all elements in the round that are annotated with at least 1 of the given
+ * annotations.
+ */
+ @SafeVarargs
+ public static ImmutableSet<Element> getElementsAnnotatedWith(RoundEnvironment roundEnv,
+ Class<? extends Annotation>... annotations) {
+ ImmutableSet.Builder<Element> builder = ImmutableSet.builder();
+ for (Class<? extends Annotation> annotation : annotations){
+ builder.addAll(roundEnv.getElementsAnnotatedWith(annotation));
+ }
+
+ return builder.build();
+ }
+
+ /**
+ * Returns the name of a class, including prefixing with enclosing class names. i.e. for inner
+ * class Foo enclosed by Bar, returns Bar_Foo instead of just Foo
+ */
+ public static String getEnclosedName(ClassName name) {
+ return Joiner.on('_').join(name.simpleNames());
+ }
+
+ /** Returns the name of a class. See {@link #getEnclosedName(ClassName)}. */
+ public static String getEnclosedName(TypeElement element) {
+ return getEnclosedName(ClassName.get(element));
+ }
+
+ /**
+ * Returns an equivalent class name with the {@code .} (dots) used for inner classes replaced with
+ * {@code _}.
+ */
+ public static ClassName getEnclosedClassName(ClassName className) {
+ return ClassName.get(className.packageName(), getEnclosedName(className));
+ }
+
+ /** Returns the fully qualified class name, with _ instead of . */
+ public static String getFullyQualifiedEnclosedClassName(ClassName className) {
+ return className.packageName().replace('.', '_') + getEnclosedName(className);
+ }
+
+ /**
+ * Returns the fully qualified class name, with _ instead of . For elements that are not type
+ * elements, this continues to append the simple name of elements. For example,
+ * foo_bar_Outer_Inner_fooMethod.
+ */
+ public static String getFullEnclosedName(Element element) {
+ Preconditions.checkNotNull(element);
+ String qualifiedName = "";
+ while (element != null) {
+ if (element.getKind().equals(ElementKind.PACKAGE)) {
+ qualifiedName = asPackage(element).getQualifiedName() + qualifiedName;
+ } else {
+ // This check is needed to keep the name stable when compiled with jdk8 vs jdk11. jdk11
+ // contains newly added "module" enclosing elements of packages, which adds an addtional "_"
+ // prefix to the name due to an empty module element compared with jdk8.
+ if (!element.getSimpleName().toString().isEmpty()) {
+ qualifiedName = "." + element.getSimpleName() + qualifiedName;
+ }
+ }
+ element = element.getEnclosingElement();
+ }
+ return qualifiedName.replace('.', '_');
+ }
+
+ /** Appends the given string to the end of the class name. */
+ public static ClassName append(ClassName name, String suffix) {
+ return name.peerClass(name.simpleName() + suffix);
+ }
+
+ /** Prepends the given string to the beginning of the class name. */
+ public static ClassName prepend(ClassName name, String prefix) {
+ return name.peerClass(prefix + name.simpleName());
+ }
+
+ /**
+ * Removes the string {@code suffix} from the simple name of {@code type} and returns it.
+ *
+ * @throws BadInputException if the simple name of {@code type} does not end with {@code suffix}
+ */
+ public static ClassName removeNameSuffix(TypeElement type, String suffix) {
+ ClassName originalName = ClassName.get(type);
+ String originalSimpleName = originalName.simpleName();
+ ProcessorErrors.checkState(originalSimpleName.endsWith(suffix),
+ type, "Name of type %s must end with '%s'", originalName, suffix);
+ String withoutSuffix =
+ originalSimpleName.substring(0, originalSimpleName.length() - suffix.length());
+ return originalName.peerClass(withoutSuffix);
+ }
+
+ /** @see #getAnnotationMirror(Element, ClassName) */
+ public static AnnotationMirror getAnnotationMirror(
+ Element element, Class<? extends Annotation> annotationClass) {
+ return getAnnotationMirror(element, ClassName.get(annotationClass));
+ }
+
+ /** @see #getAnnotationMirror(Element, ClassName) */
+ public static AnnotationMirror getAnnotationMirror(Element element, String annotationClassName) {
+ return getAnnotationMirror(element, ClassName.bestGuess(annotationClassName));
+ }
+
+ /**
+ * Returns the annotation mirror from the given element that corresponds to the given class.
+ *
+ * @throws IllegalStateException if the given element isn't annotated with that annotation.
+ */
+ public static AnnotationMirror getAnnotationMirror(Element element, ClassName className) {
+ Optional<AnnotationMirror> annotationMirror = getAnnotationMirrorOptional(element, className);
+ if (annotationMirror.isPresent()) {
+ return annotationMirror.get();
+ } else {
+ throw new IllegalStateException(
+ String.format(
+ "Couldn't find annotation %s on element %s. Found annotations: %s",
+ className, element.getSimpleName(), element.getAnnotationMirrors()));
+ }
+ }
+
+ /**
+ * Returns the annotation mirror from the given element that corresponds to the given class.
+ *
+ * @throws {@link IllegalArgumentException} if 2 or more annotations are found.
+ * @return {@link Optional#empty()} if no annotation is found on the element.
+ */
+ static Optional<AnnotationMirror> getAnnotationMirrorOptional(
+ Element element, ClassName className) {
+ return element.getAnnotationMirrors().stream()
+ .filter(mirror -> ClassName.get(mirror.getAnnotationType()).equals(className))
+ .collect(toOptional());
+ }
+
+ /** @return true if element inherits directly or indirectly from the className */
+ public static boolean isAssignableFrom(TypeElement element, ClassName className) {
+ return isAssignableFromAnyOf(element, ImmutableSet.of(className));
+ }
+
+ /** @return true if element inherits directly or indirectly from any of the classNames */
+ public static boolean isAssignableFromAnyOf(TypeElement element,
+ ImmutableSet<ClassName> classNames) {
+ for (ClassName className : classNames) {
+ if (ClassName.get(element).equals(className)) {
+ return true;
+ }
+ }
+
+ TypeMirror superClass = element.getSuperclass();
+ // None type is returned if this is an interface or Object
+ // Error type is returned for classes that are generated by this processor
+ if ((superClass.getKind() != TypeKind.NONE) && (superClass.getKind() != TypeKind.ERROR)) {
+ Preconditions.checkState(superClass.getKind() == TypeKind.DECLARED);
+ if (isAssignableFromAnyOf(MoreTypes.asTypeElement(superClass), classNames)) {
+ return true;
+ }
+ }
+
+ for (TypeMirror iface : element.getInterfaces()) {
+ // Skip errors and keep looking. This is especially needed for classes generated by this
+ // processor.
+ if (iface.getKind() == TypeKind.ERROR) {
+ continue;
+ }
+ Preconditions.checkState(iface.getKind() == TypeKind.DECLARED,
+ "Interface type is %s", iface.getKind());
+ if (isAssignableFromAnyOf(MoreTypes.asTypeElement(iface), classNames)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ /** Returns methods from a given TypeElement, not including constructors. */
+ public static ImmutableList<ExecutableElement> getMethods(TypeElement element) {
+ ImmutableList.Builder<ExecutableElement> builder = ImmutableList.builder();
+ for (Element e : element.getEnclosedElements()) {
+ // Only look for executable elements, not fields, etc
+ if (e instanceof ExecutableElement) {
+ ExecutableElement method = (ExecutableElement) e;
+ if (!method.getSimpleName().contentEquals(CONSTRUCTOR_NAME)
+ && !method.getSimpleName().contentEquals(STATIC_INITIALIZER_NAME)) {
+ builder.add(method);
+ }
+ }
+ }
+ return builder.build();
+ }
+
+ public static ImmutableList<ExecutableElement> getConstructors(TypeElement element) {
+ ImmutableList.Builder<ExecutableElement> builder = ImmutableList.builder();
+ for (Element enclosed : element.getEnclosedElements()) {
+ // Only look for executable elements, not fields, etc
+ if (enclosed instanceof ExecutableElement) {
+ ExecutableElement method = (ExecutableElement) enclosed;
+ if (method.getSimpleName().contentEquals(CONSTRUCTOR_NAME)) {
+ builder.add(method);
+ }
+ }
+ }
+ return builder.build();
+ }
+
+ /**
+ * Returns all transitive methods from a given TypeElement, not including constructors. Also does
+ * not include methods from Object or that override methods on Object.
+ */
+ public static ImmutableList<ExecutableElement> getAllMethods(TypeElement element) {
+ ImmutableList.Builder<ExecutableElement> builder = ImmutableList.builder();
+ builder.addAll(
+ Iterables.filter(
+ getMethods(element),
+ method -> {
+ return !isObjectMethod(method);
+ }));
+ TypeMirror superclass = element.getSuperclass();
+ if (superclass.getKind() != TypeKind.NONE) {
+ TypeElement superclassElement = MoreTypes.asTypeElement(superclass);
+ builder.addAll(getAllMethods(superclassElement));
+ }
+ for (TypeMirror iface : element.getInterfaces()) {
+ builder.addAll(getAllMethods(MoreTypes.asTypeElement(iface)));
+ }
+ return builder.build();
+ }
+
+ /** Checks that the given element is not the error type. */
+ public static void checkForCompilationError(TypeElement e) {
+ ProcessorErrors.checkState(e.asType().getKind() != TypeKind.ERROR, e,
+ "Unable to resolve the type %s. Look for compilation errors above related to this type.",
+ e);
+ }
+
+ private static void addInterfaceMethods(
+ TypeElement type, ImmutableList.Builder<ExecutableElement> interfaceMethods) {
+ for (TypeMirror interfaceMirror : type.getInterfaces()) {
+ TypeElement interfaceElement = MoreTypes.asTypeElement(interfaceMirror);
+ interfaceMethods.addAll(getMethods(interfaceElement));
+ addInterfaceMethods(interfaceElement, interfaceMethods);
+ }
+ }
+
+ /**
+ * Finds methods of interfaces implemented by {@code type}. This method also checks the
+ * superinterfaces of those interfaces. This method does not check the interfaces of any
+ * superclass of {@code type}.
+ */
+ public static ImmutableList<ExecutableElement> methodsOnInterfaces(TypeElement type) {
+ ImmutableList.Builder<ExecutableElement> interfaceMethods = new ImmutableList.Builder<>();
+ addInterfaceMethods(type, interfaceMethods);
+ return interfaceMethods.build();
+ }
+
+ /** Returns MapKey annotated annotations found on an element. */
+ public static ImmutableList<AnnotationMirror> getMapKeyAnnotations(Element element) {
+ return getAnnotationsAnnotatedWith(element, ClassName.get("dagger", "MapKey"));
+ }
+
+ /** Returns Qualifier annotated annotations found on an element. */
+ public static ImmutableList<AnnotationMirror> getQualifierAnnotations(Element element) {
+ // TODO(bcorso): Consolidate this logic with InjectionAnnotations in Dagger
+ ImmutableSet<? extends AnnotationMirror> qualifiers =
+ AnnotationMirrors.getAnnotatedAnnotations(element, Qualifier.class);
+ KotlinMetadataUtil metadataUtil = KotlinMetadataUtils.getMetadataUtil();
+ if (element.getKind() == ElementKind.FIELD
+ // static fields are generally not supported, no need to get qualifier from kotlin metadata
+ && !element.getModifiers().contains(STATIC)
+ && metadataUtil.hasMetadata(element)) {
+ VariableElement fieldElement = asVariable(element);
+ return Stream.concat(
+ qualifiers.stream(),
+ metadataUtil.isMissingSyntheticPropertyForAnnotations(fieldElement)
+ ? Stream.empty()
+ : metadataUtil
+ .getSyntheticPropertyAnnotations(fieldElement, Qualifier.class)
+ .stream())
+ .map(AnnotationMirrors.equivalence()::wrap)
+ .distinct()
+ .map(Wrapper::get)
+ .collect(DaggerStreams.toImmutableList());
+ } else {
+ return ImmutableList.copyOf(qualifiers);
+ }
+ }
+
+ /** Returns Scope annotated annotations found on an element. */
+ public static ImmutableList<AnnotationMirror> getScopeAnnotations(Element element) {
+ return getAnnotationsAnnotatedWith(element, ClassNames.SCOPE);
+ }
+
+ /** Returns annotations of element that are annotated with subAnnotation */
+ public static ImmutableList<AnnotationMirror> getAnnotationsAnnotatedWith(
+ Element element, ClassName subAnnotation) {
+ ImmutableList.Builder<AnnotationMirror> builder = ImmutableList.builder();
+ element.getAnnotationMirrors().stream()
+ .filter(annotation -> hasAnnotation(annotation, subAnnotation))
+ .forEach(builder::add);
+ return builder.build();
+ }
+
+ /** Returns true if there are any annotations of element that are annotated with subAnnotation */
+ public static boolean hasAnnotationsAnnotatedWith(Element element, ClassName subAnnotation) {
+ return !getAnnotationsAnnotatedWith(element, subAnnotation).isEmpty();
+ }
+
+ /**
+ * Returns true iff the given {@code method} is one of the public or protected methods on {@link
+ * Object}, or an overridden version thereof.
+ *
+ * <p>This method ignores the return type of the given method, but this is generally fine since
+ * two methods which only differ by their return type will cause a compiler error. (e.g. a
+ * non-static method with the signature {@code int equals(Object)})
+ */
+ public static boolean isObjectMethod(ExecutableElement method) {
+ // First check if this method is directly defined on Object
+ Element enclosingElement = method.getEnclosingElement();
+ if (enclosingElement.getKind() == ElementKind.CLASS
+ && TypeName.get(enclosingElement.asType()).equals(TypeName.OBJECT)) {
+ return true;
+ }
+
+ if (method.getModifiers().contains(Modifier.STATIC)) {
+ return false;
+ }
+ switch (method.getSimpleName().toString()) {
+ case "equals":
+ return (method.getParameters().size() == 1)
+ && (method.getParameters().get(0).asType().toString().equals("java.lang.Object"));
+ case "hashCode":
+ case "toString":
+ case "clone":
+ case "getClass":
+ case "notify":
+ case "notifyAll":
+ case "finalize":
+ return method.getParameters().isEmpty();
+ case "wait":
+ if (method.getParameters().isEmpty()) {
+ return true;
+ } else if ((method.getParameters().size() == 1)
+ && (method.getParameters().get(0).asType().toString().equals("long"))) {
+ return true;
+ } else if ((method.getParameters().size() == 2)
+ && (method.getParameters().get(0).asType().toString().equals("long"))
+ && (method.getParameters().get(1).asType().toString().equals("int"))) {
+ return true;
+ }
+ return false;
+ default:
+ return false;
+ }
+ }
+
+ public static ParameterSpec parameterSpecFromVariableElement(VariableElement element) {
+ return ParameterSpec.builder(
+ ClassName.get(element.asType()),
+ upperToLowerCamel(element.getSimpleName().toString()))
+ .build();
+ }
+
+ /**
+ * Shortcut for converting from upper camel to lower camel case
+ *
+ * <p>Example: "SomeString" => "someString"
+ */
+ public static String upperToLowerCamel(String upperCamel) {
+ return CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL, upperCamel);
+ }
+
+ /** @return copy of the given MethodSpec as {@link MethodSpec.Builder} with method body removed */
+ public static MethodSpec.Builder copyMethodSpecWithoutBody(MethodSpec methodSpec) {
+ MethodSpec.Builder builder;
+
+ if (methodSpec.isConstructor()) {
+ // Constructors cannot have return types
+ builder = MethodSpec.constructorBuilder();
+ } else {
+ builder = MethodSpec.methodBuilder(methodSpec.name)
+ .returns(methodSpec.returnType);
+ }
+
+ return builder
+ .addAnnotations(methodSpec.annotations)
+ .addModifiers(methodSpec.modifiers)
+ .addParameters(methodSpec.parameters)
+ .addExceptions(methodSpec.exceptions)
+ .addJavadoc(methodSpec.javadoc.toString())
+ .addTypeVariables(methodSpec.typeVariables);
+ }
+
+ /** @return A method spec for an empty constructor (useful for abstract Dagger modules). */
+ public static MethodSpec privateEmptyConstructor() {
+ return MethodSpec.constructorBuilder().addModifiers(Modifier.PRIVATE).build();
+ }
+
+ /**
+ * Returns true if the given method is annotated with one of the annotations Dagger recognizes
+ * for abstract methods (e.g. @Binds).
+ */
+ public static boolean hasDaggerAbstractMethodAnnotation(ExecutableElement method) {
+ return hasAnnotation(method, ClassNames.BINDS)
+ || hasAnnotation(method, ClassNames.BINDS_OPTIONAL_OF)
+ || hasAnnotation(method, ClassNames.MULTIBINDS)
+ || hasAnnotation(method, ClassNames.CONTRIBUTES_ANDROID_INJECTOR);
+ }
+
+ public static ImmutableSet<TypeElement> toTypeElements(Elements elements, String[] classes) {
+ return FluentIterable.from(classes).transform(elements::getTypeElement).toSet();
+ }
+
+ public static ImmutableSet<ClassName> toClassNames(Iterable<TypeElement> elements) {
+ return FluentIterable.from(elements).transform(ClassName::get).toSet();
+ }
+
+ public static boolean requiresModuleInstance(Elements elements, TypeElement module) {
+ // Binding methods that lack ABSTRACT or STATIC require module instantiation.
+ // Required by Dagger. See b/31489617.
+ return ElementFilter.methodsIn(elements.getAllMembers(module)).stream()
+ .filter(Processors::isBindingMethod)
+ .map(ExecutableElement::getModifiers)
+ .anyMatch(modifiers -> !modifiers.contains(ABSTRACT) && !modifiers.contains(STATIC));
+ }
+
+ private static boolean isBindingMethod(ExecutableElement method) {
+ return hasAnnotation(method, ClassNames.PROVIDES)
+ || hasAnnotation(method, ClassNames.BINDS)
+ || hasAnnotation(method, ClassNames.BINDS_OPTIONAL_OF)
+ || hasAnnotation(method, ClassNames.MULTIBINDS);
+ }
+
+ public static void addGeneratedAnnotation(
+ TypeSpec.Builder typeSpecBuilder, ProcessingEnvironment env, Class<?> generatorClass) {
+ addGeneratedAnnotation(typeSpecBuilder, env, generatorClass.getName());
+ }
+
+ public static void addGeneratedAnnotation(
+ TypeSpec.Builder typeSpecBuilder, ProcessingEnvironment env, String generatorClass) {
+ GeneratedAnnotations.generatedAnnotation(env.getElementUtils(), env.getSourceVersion())
+ .ifPresent(
+ annotation ->
+ typeSpecBuilder.addAnnotation(
+ AnnotationSpec.builder(ClassName.get(annotation))
+ .addMember("value", "$S", generatorClass)
+ .build()));
+ }
+
+ public static AnnotationSpec getOriginatingElementAnnotation(TypeElement element) {
+ TypeName rawType = rawTypeName(ClassName.get(getTopLevelType(element)));
+ return AnnotationSpec.builder(ClassNames.ORIGINATING_ELEMENT)
+ .addMember("topLevelClass", "$T.class", rawType)
+ .build();
+ }
+
+ /**
+ * Returns the {@link TypeName} for the raw type of the given type name. If the argument isn't a
+ * parameterized type, it returns the argument unchanged.
+ */
+ public static TypeName rawTypeName(TypeName typeName) {
+ return (typeName instanceof ParameterizedTypeName)
+ ? ((ParameterizedTypeName) typeName).rawType
+ : typeName;
+ }
+
+ private Processors() {}
+}
diff --git a/java/dagger/hilt/processor/internal/aggregateddeps/AggregatedDeps.java b/java/dagger/hilt/processor/internal/aggregateddeps/AggregatedDeps.java
new file mode 100644
index 0000000..cc955ef
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/aggregateddeps/AggregatedDeps.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.aggregateddeps;
+
+import static java.lang.annotation.RetentionPolicy.CLASS;
+
+import java.lang.annotation.Retention;
+
+// TODO(bcorso): Change this API to clearly represent that each AggeregatedDeps should only contain
+// a single module, entry point, or component entry point.
+/** Annotation for propagating dependency information through javac runs. */
+@Retention(CLASS)
+public @interface AggregatedDeps {
+ /** Returns the components that this dependency will be installed in. */
+ String[] components();
+
+ /** Returns the test this dependency is associated with, otherwise an empty string. */
+ String test() default "";
+
+ /** Returns the deps that this dep replaces. */
+ String[] replaces() default {};
+
+ String[] modules() default {};
+
+ String[] entryPoints() default {};
+
+ String[] componentEntryPoints() default {};
+}
diff --git a/java/dagger/hilt/processor/internal/aggregateddeps/AggregatedDepsGenerator.java b/java/dagger/hilt/processor/internal/aggregateddeps/AggregatedDepsGenerator.java
new file mode 100644
index 0000000..bcc2dfe
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/aggregateddeps/AggregatedDepsGenerator.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.aggregateddeps;
+
+import com.google.common.collect.ImmutableSet;
+import com.squareup.javapoet.AnnotationSpec;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.TypeSpec;
+import dagger.hilt.processor.internal.Processors;
+import java.io.IOException;
+import java.util.Optional;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.TypeElement;
+
+/**
+ * Generates the @AggregatedDeps annotated class used to pass information
+ * about modules and entry points through multiple javac runs.
+ */
+final class AggregatedDepsGenerator {
+ static final String AGGREGATING_PACKAGE = "hilt_aggregated_deps";
+ private static final ClassName AGGREGATED_DEPS =
+ ClassName.get("dagger.hilt.processor.internal.aggregateddeps", "AggregatedDeps");
+
+ private final String dependencyType;
+ private final TypeElement dependency;
+ private final Optional<ClassName> testName;
+ private final ImmutableSet<ClassName> components;
+ private final ImmutableSet<ClassName> replacedDependencies;
+ private final ProcessingEnvironment processingEnv;
+
+ AggregatedDepsGenerator(
+ String dependencyType,
+ TypeElement dependency,
+ Optional<ClassName> testName,
+ ImmutableSet<ClassName> components,
+ ImmutableSet<ClassName> replacedDependencies,
+ ProcessingEnvironment processingEnv) {
+ this.dependencyType = dependencyType;
+ this.dependency = dependency;
+ this.testName = testName;
+ this.components = components;
+ this.replacedDependencies = replacedDependencies;
+ this.processingEnv = processingEnv;
+ }
+
+ void generate() throws IOException {
+ ClassName name =
+ ClassName.get(
+ AGGREGATING_PACKAGE, Processors.getFullEnclosedName(dependency) + "ModuleDeps");
+ TypeSpec.Builder generator =
+ TypeSpec.classBuilder(name.simpleName())
+ .addOriginatingElement(dependency)
+ .addAnnotation(aggregatedDepsAnnotation())
+ .addJavadoc("Generated class to pass information through multiple javac runs.\n");
+
+ Processors.addGeneratedAnnotation(generator, processingEnv, getClass());
+
+ JavaFile.builder(name.packageName(), generator.build())
+ .build()
+ .writeTo(processingEnv.getFiler());
+ }
+
+ private AnnotationSpec aggregatedDepsAnnotation() {
+ AnnotationSpec.Builder annotationBuilder = AnnotationSpec.builder(AGGREGATED_DEPS);
+ components.forEach(component -> annotationBuilder.addMember("components", "$S", component));
+ replacedDependencies.forEach(dep -> annotationBuilder.addMember("replaces", "$S", dep));
+ testName.ifPresent(test -> annotationBuilder.addMember("test", "$S", test));
+ annotationBuilder.addMember(dependencyType, "$S", dependency.getQualifiedName());
+ return annotationBuilder.build();
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/aggregateddeps/AggregatedDepsProcessor.java b/java/dagger/hilt/processor/internal/aggregateddeps/AggregatedDepsProcessor.java
new file mode 100644
index 0000000..58c938f
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/aggregateddeps/AggregatedDepsProcessor.java
@@ -0,0 +1,469 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.aggregateddeps;
+
+import static com.google.auto.common.AnnotationMirrors.getAnnotationValue;
+import static com.google.auto.common.MoreElements.asType;
+import static com.google.auto.common.MoreElements.getPackage;
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static dagger.hilt.android.processor.internal.androidentrypoint.HiltCompilerOptions.BooleanOption.DISABLE_MODULES_HAVE_INSTALL_IN_CHECK;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static javax.lang.model.element.ElementKind.CLASS;
+import static javax.lang.model.element.ElementKind.INTERFACE;
+import static javax.lang.model.element.Modifier.ABSTRACT;
+import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.STATIC;
+import static net.ltgt.gradle.incap.IncrementalAnnotationProcessorType.ISOLATING;
+
+import com.google.auto.service.AutoService;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.squareup.javapoet.ClassName;
+import dagger.hilt.processor.internal.BaseProcessor;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.Components;
+import dagger.hilt.processor.internal.KotlinMetadataUtils;
+import dagger.hilt.processor.internal.ProcessorErrors;
+import dagger.hilt.processor.internal.Processors;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import javax.annotation.processing.Processor;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.Name;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.util.ElementFilter;
+import javax.lang.model.util.SimpleAnnotationValueVisitor8;
+import net.ltgt.gradle.incap.IncrementalAnnotationProcessor;
+
+/** Processor that outputs dummy files to propagate information through multiple javac runs. */
+@IncrementalAnnotationProcessor(ISOLATING)
+@AutoService(Processor.class)
+public final class AggregatedDepsProcessor extends BaseProcessor {
+
+ private static final ImmutableSet<ClassName> ENTRY_POINT_ANNOTATIONS =
+ ImmutableSet.of(
+ ClassNames.ENTRY_POINT,
+ ClassNames.GENERATED_ENTRY_POINT,
+ ClassNames.COMPONENT_ENTRY_POINT);
+
+ private static final ImmutableSet<ClassName> MODULE_ANNOTATIONS =
+ ImmutableSet.of(
+ ClassNames.MODULE);
+
+ private static final ImmutableSet<ClassName> INSTALL_IN_ANNOTATIONS =
+ ImmutableSet.of(ClassNames.INSTALL_IN, ClassNames.TEST_INSTALL_IN);
+
+ private final Set<Element> seen = new HashSet<>();
+
+ @Override
+ public Set<String> getSupportedAnnotationTypes() {
+ return ImmutableSet.builder()
+ .addAll(INSTALL_IN_ANNOTATIONS)
+ .addAll(MODULE_ANNOTATIONS)
+ .addAll(ENTRY_POINT_ANNOTATIONS)
+ .build()
+ .stream()
+ .map(Object::toString)
+ .collect(toImmutableSet());
+ }
+
+ @Override
+ public void processEach(TypeElement annotation, Element element) throws Exception {
+ if (!seen.add(element)) {
+ return;
+ }
+
+ Optional<ClassName> installInAnnotation = getAnnotation(element, INSTALL_IN_ANNOTATIONS);
+ Optional<ClassName> entryPointAnnotation = getAnnotation(element, ENTRY_POINT_ANNOTATIONS);
+ Optional<ClassName> moduleAnnotation = getAnnotation(element, MODULE_ANNOTATIONS);
+
+ boolean hasInstallIn = installInAnnotation.isPresent();
+ boolean isEntryPoint = entryPointAnnotation.isPresent();
+ boolean isModule = moduleAnnotation.isPresent();
+
+ ProcessorErrors.checkState(
+ !hasInstallIn || isEntryPoint || isModule,
+ element,
+ "@%s-annotated classes must also be annotated with @Module or @EntryPoint: %s",
+ installInAnnotation.map(ClassName::simpleName).orElse("@InstallIn"),
+ element);
+
+ ProcessorErrors.checkState(
+ !(isEntryPoint && isModule),
+ element,
+ "@%s and @%s cannot be used on the same interface: %s",
+ moduleAnnotation.map(ClassName::simpleName).orElse("@Module"),
+ entryPointAnnotation.map(ClassName::simpleName).orElse("@EntryPoint"),
+ element);
+
+ if (isModule) {
+ processModule(element, installInAnnotation, moduleAnnotation.get());
+ } else if (isEntryPoint) {
+ processEntryPoint(element, installInAnnotation, entryPointAnnotation.get());
+ } else {
+ throw new AssertionError();
+ }
+ }
+
+ private void processModule(
+ Element element, Optional<ClassName> installInAnnotation, ClassName moduleAnnotation)
+ throws Exception {
+ ProcessorErrors.checkState(
+ installInAnnotation.isPresent()
+ || isDaggerGeneratedModule(element)
+ || installInCheckDisabled(element),
+ element,
+ "%s is missing an @InstallIn annotation. If this was intentional, see"
+ + " https://dagger.dev/hilt/compiler-options#disable-install-in-check for how to disable this"
+ + " check.",
+ element);
+
+ if (!installInAnnotation.isPresent()) {
+ // Modules without @InstallIn or @TestInstallIn annotations don't need to be processed further
+ return;
+ }
+
+ ProcessorErrors.checkState(
+ element.getKind() == CLASS || element.getKind() == INTERFACE,
+ element,
+ "Only classes and interfaces can be annotated with @Module: %s",
+ element);
+ TypeElement module = asType(element);
+
+ ProcessorErrors.checkState(
+ Processors.isTopLevel(module)
+ || module.getModifiers().contains(STATIC)
+ || module.getModifiers().contains(ABSTRACT)
+ || Processors.hasAnnotation(module.getEnclosingElement(), ClassNames.HILT_ANDROID_TEST),
+ module,
+ "Nested @%s modules must be static unless they are directly nested within a test. "
+ + "Found: %s",
+ installInAnnotation.get().simpleName(),
+ module);
+
+ // Check that if Dagger needs an instance of the module, Hilt can provide it automatically by
+ // calling a visible empty constructor.
+ ProcessorErrors.checkState(
+ !daggerRequiresModuleInstance(module) || hasVisibleEmptyConstructor(module),
+ module,
+ "Modules that need to be instantiated by Hilt must have a visible, empty constructor.");
+
+ // TODO(b/28989613): This should really be fixed in Dagger. Remove once Dagger bug is fixed.
+ ImmutableList<ExecutableElement> abstractMethodsWithMissingBinds =
+ ElementFilter.methodsIn(module.getEnclosedElements()).stream()
+ .filter(method -> method.getModifiers().contains(ABSTRACT))
+ .filter(method -> !Processors.hasDaggerAbstractMethodAnnotation(method))
+ .collect(toImmutableList());
+ ProcessorErrors.checkState(
+ abstractMethodsWithMissingBinds.isEmpty(),
+ module,
+ "Found unimplemented abstract methods, %s, in an abstract module, %s. "
+ + "Did you forget to add a Dagger binding annotation (e.g. @Binds)?",
+ abstractMethodsWithMissingBinds,
+ module);
+
+ ImmutableList<TypeElement> replacedModules = ImmutableList.of();
+ if (Processors.hasAnnotation(module, ClassNames.TEST_INSTALL_IN)) {
+ Optional<TypeElement> originatingTestElement = getOriginatingTestElement(module);
+ ProcessorErrors.checkState(
+ !originatingTestElement.isPresent(),
+ // TODO(b/152801981): this should really error on the annotation value
+ module,
+ "@TestInstallIn modules cannot be nested in (or originate from) a "
+ + "@HiltAndroidTest-annotated class: %s",
+ originatingTestElement
+ .map(testElement -> testElement.getQualifiedName().toString())
+ .orElse(""));
+
+ AnnotationMirror testInstallIn =
+ Processors.getAnnotationMirror(module, ClassNames.TEST_INSTALL_IN);
+ replacedModules =
+ Processors.getAnnotationClassValues(getElementUtils(), testInstallIn, "replaces");
+
+ ProcessorErrors.checkState(
+ !replacedModules.isEmpty(),
+ // TODO(b/152801981): this should really error on the annotation value
+ module,
+ "@TestInstallIn#replaces() cannot be empty. Use @InstallIn instead.");
+
+ ImmutableList<TypeElement> nonInstallInModules =
+ replacedModules.stream()
+ .filter(
+ replacedModule ->
+ !Processors.hasAnnotation(replacedModule, ClassNames.INSTALL_IN))
+ .collect(toImmutableList());
+
+ ProcessorErrors.checkState(
+ nonInstallInModules.isEmpty(),
+ // TODO(b/152801981): this should really error on the annotation value
+ module,
+ "@TestInstallIn#replaces() can only contain @InstallIn modules, but found: %s",
+ nonInstallInModules);
+
+ ImmutableList<TypeElement> hiltWrapperModules =
+ replacedModules.stream()
+ .filter(
+ replacedModule ->
+ replacedModule.getSimpleName().toString().startsWith("HiltWrapper_"))
+ .collect(toImmutableList());
+
+ ProcessorErrors.checkState(
+ hiltWrapperModules.isEmpty(),
+ // TODO(b/152801981): this should really error on the annotation value
+ module,
+ "@TestInstallIn#replaces() cannot contain Hilt generated public wrapper modules, "
+ + "but found: %s. ",
+ hiltWrapperModules);
+
+ if (!getPackage(module).getQualifiedName().toString().startsWith("dagger.hilt")) {
+ // Prevent external users from overriding Hilt's internal modules. Techincally, except for
+ // ApplicationContextModule, making all modules pkg-private should be enough but this is an
+ // extra measure of precaution.
+ ImmutableList<TypeElement> hiltInternalModules =
+ replacedModules.stream()
+ .filter(
+ replacedModule ->
+ getPackage(replacedModule)
+ .getQualifiedName()
+ .toString()
+ .startsWith("dagger.hilt"))
+ .collect(toImmutableList());
+
+ ProcessorErrors.checkState(
+ hiltInternalModules.isEmpty(),
+ // TODO(b/152801981): this should really error on the annotation value
+ module,
+ "@TestInstallIn#replaces() cannot contain internal Hilt modules, but found: %s. ",
+ hiltInternalModules);
+ }
+
+ // Prevent users from uninstalling test-specific @InstallIn modules.
+ ImmutableList<TypeElement> replacedTestSpecificInstallIn =
+ replacedModules.stream()
+ .filter(replacedModule -> getOriginatingTestElement(replacedModule).isPresent())
+ .collect(toImmutableList());
+
+ ProcessorErrors.checkState(
+ replacedTestSpecificInstallIn.isEmpty(),
+ // TODO(b/152801981): this should really error on the annotation value
+ module,
+ "@TestInstallIn#replaces() cannot replace test specific @InstallIn modules, but found: "
+ + "%s. Please remove the @InstallIn module manually rather than replacing it.",
+ replacedTestSpecificInstallIn);
+ }
+
+ generateAggregatedDeps(
+ "modules",
+ module,
+ moduleAnnotation,
+ replacedModules.stream().map(ClassName::get).collect(toImmutableSet()));
+ }
+
+ private void processEntryPoint(
+ Element element, Optional<ClassName> installInAnnotation, ClassName entryPointAnnotation)
+ throws Exception {
+ ProcessorErrors.checkState(
+ installInAnnotation.isPresent() ,
+ element,
+ "@%s %s must also be annotated with @InstallIn",
+ entryPointAnnotation.simpleName(),
+ element);
+
+ ProcessorErrors.checkState(
+ !Processors.hasAnnotation(element, ClassNames.TEST_INSTALL_IN),
+ element,
+ "@TestInstallIn can only be used with modules");
+
+ ProcessorErrors.checkState(
+ element.getKind() == INTERFACE,
+ element,
+ "Only interfaces can be annotated with @%s: %s",
+ entryPointAnnotation.simpleName(),
+ element);
+ TypeElement entryPoint = asType(element);
+
+ generateAggregatedDeps(
+ entryPointAnnotation.equals(ClassNames.COMPONENT_ENTRY_POINT)
+ ? "componentEntryPoints"
+ : "entryPoints",
+ entryPoint,
+ entryPointAnnotation,
+ ImmutableSet.of());
+ }
+
+ private void generateAggregatedDeps(
+ String key,
+ TypeElement element,
+ ClassName annotation,
+ ImmutableSet<ClassName> replacedModules)
+ throws Exception {
+ // Get @InstallIn components here to catch errors before skipping user's pkg-private element.
+ ImmutableSet<ClassName> components = Components.getComponents(getElementUtils(), element);
+
+ if (isValidKind(element)) {
+ Optional<PkgPrivateMetadata> pkgPrivateMetadata =
+ PkgPrivateMetadata.of(getElementUtils(), element, annotation);
+ if (pkgPrivateMetadata.isPresent()) {
+ if (key.contentEquals("modules")) {
+ new PkgPrivateModuleGenerator(getProcessingEnv(), pkgPrivateMetadata.get()).generate();
+ } else {
+ new PkgPrivateEntryPointGenerator(getProcessingEnv(), pkgPrivateMetadata.get())
+ .generate();
+ }
+ } else {
+ Optional<ClassName> testName = getOriginatingTestElement(element).map(ClassName::get);
+ new AggregatedDepsGenerator(
+ key, element, testName, components, replacedModules, getProcessingEnv())
+ .generate();
+ }
+ }
+ }
+
+ private static Optional<ClassName> getAnnotation(
+ Element element, ImmutableSet<ClassName> annotations) {
+ ImmutableSet<ClassName> usedAnnotations =
+ annotations.stream()
+ .filter(annotation -> Processors.hasAnnotation(element, annotation))
+ .collect(toImmutableSet());
+
+ if (usedAnnotations.isEmpty()) {
+ return Optional.empty();
+ }
+
+ ProcessorErrors.checkState(
+ usedAnnotations.size() == 1,
+ element,
+ "Only one of the following annotations can be used on %s: %s",
+ element,
+ usedAnnotations);
+
+ return Optional.of(getOnlyElement(usedAnnotations));
+ }
+
+ private Optional<TypeElement> getOriginatingTestElement(Element element) {
+ TypeElement topLevelType = getOriginatingTopLevelType(element);
+ return Processors.hasAnnotation(topLevelType, ClassNames.HILT_ANDROID_TEST)
+ ? Optional.of(asType(topLevelType))
+ : Optional.empty();
+ }
+
+ private TypeElement getOriginatingTopLevelType(Element element) {
+ TypeElement topLevelType = Processors.getTopLevelType(element);
+ if (Processors.hasAnnotation(topLevelType, ClassNames.ORIGINATING_ELEMENT)) {
+ return getOriginatingTopLevelType(
+ Processors.getAnnotationClassValue(
+ getElementUtils(),
+ Processors.getAnnotationMirror(topLevelType, ClassNames.ORIGINATING_ELEMENT),
+ "topLevelClass"));
+ }
+ return topLevelType;
+ }
+
+ private static boolean isValidKind(Element element) {
+ // don't go down the rabbit hole of analyzing undefined types. N.B. we don't issue
+ // an error here because javac already has and we don't want to spam the user.
+ return element.asType().getKind() != TypeKind.ERROR;
+ }
+
+ private boolean installInCheckDisabled(Element element) {
+ return DISABLE_MODULES_HAVE_INSTALL_IN_CHECK.get(getProcessingEnv())
+ || Processors.hasAnnotation(element, ClassNames.DISABLE_INSTALL_IN_CHECK);
+ }
+
+ /**
+ * When using Dagger Producers, don't process generated modules. They will not have the expected
+ * annotations.
+ */
+ private static boolean isDaggerGeneratedModule(Element element) {
+ if (!Processors.hasAnnotation(element, ClassNames.MODULE)) {
+ return false;
+ }
+ return element.getAnnotationMirrors().stream()
+ .filter(mirror -> isGenerated(mirror))
+ .map(mirror -> asString(getOnlyElement(asList(getAnnotationValue(mirror, "value")))))
+ .anyMatch(value -> value.startsWith("dagger"));
+ }
+
+ private static List<? extends AnnotationValue> asList(AnnotationValue value) {
+ return value.accept(
+ new SimpleAnnotationValueVisitor8<List<? extends AnnotationValue>, Void>() {
+ @Override
+ public List<? extends AnnotationValue> visitArray(
+ List<? extends AnnotationValue> value, Void unused) {
+ return value;
+ }
+ },
+ null);
+ }
+
+ private static String asString(AnnotationValue value) {
+ return value.accept(
+ new SimpleAnnotationValueVisitor8<String, Void>() {
+ @Override
+ public String visitString(String value, Void unused) {
+ return value;
+ }
+ },
+ null);
+ }
+
+ private static boolean isGenerated(AnnotationMirror annotationMirror) {
+ Name name = asType(annotationMirror.getAnnotationType().asElement()).getQualifiedName();
+ return name.contentEquals("javax.annotation.Generated")
+ || name.contentEquals("javax.annotation.processing.Generated");
+ }
+
+ private static boolean daggerRequiresModuleInstance(TypeElement module) {
+ return !module.getModifiers().contains(ABSTRACT)
+ && !hasOnlyStaticProvides(module)
+ // Skip ApplicationContextModule, since Hilt manages this module internally.
+ && !ClassNames.APPLICATION_CONTEXT_MODULE.equals(ClassName.get(module))
+ // Skip Kotlin object modules since all their provision methods are static
+ && !isKotlinObject(module);
+ }
+
+ private static boolean isKotlinObject(TypeElement type) {
+ KotlinMetadataUtil metadataUtil = KotlinMetadataUtils.getMetadataUtil();
+ return metadataUtil.isObjectClass(type) || metadataUtil.isCompanionObjectClass(type);
+ }
+
+ private static boolean hasOnlyStaticProvides(TypeElement module) {
+ // TODO(erichang): Check for @Produces too when we have a producers story
+ return ElementFilter.methodsIn(module.getEnclosedElements()).stream()
+ .filter(method -> Processors.hasAnnotation(method, ClassNames.PROVIDES))
+ .allMatch(method -> method.getModifiers().contains(STATIC));
+ }
+
+ private static boolean hasVisibleEmptyConstructor(TypeElement type) {
+ List<ExecutableElement> constructors = ElementFilter.constructorsIn(type.getEnclosedElements());
+ return constructors.isEmpty()
+ || constructors.stream()
+ .filter(constructor -> constructor.getParameters().isEmpty())
+ .anyMatch(
+ constructor ->
+ !constructor.getModifiers().contains(PRIVATE)
+ );
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/aggregateddeps/BUILD b/java/dagger/hilt/processor/internal/aggregateddeps/BUILD
new file mode 100644
index 0000000..ebbc941
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/aggregateddeps/BUILD
@@ -0,0 +1,88 @@
+# Copyright (C) 2019 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# A processor that aggregates metadata about Hilt @InstallIn annotations
+
+package(default_visibility = ["//:src"])
+
+# TODO(bcorso): Remove all AggregatedDeps usage from the processor class path.
+java_library(
+ name = "annotation",
+ srcs = ["AggregatedDeps.java"],
+ exports = [
+ "//java/dagger/hilt/codegen:originating_element",
+ ],
+)
+
+java_plugin(
+ name = "plugin",
+ generates_api = 1,
+ processor_class = "dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsProcessor",
+ deps = [":processor_lib"],
+)
+
+java_library(
+ name = "processor_lib",
+ srcs = [
+ "AggregatedDepsGenerator.java",
+ "AggregatedDepsProcessor.java",
+ "PkgPrivateEntryPointGenerator.java",
+ "PkgPrivateMetadata.java",
+ "PkgPrivateModuleGenerator.java",
+ ],
+ deps = [
+ "//:dagger_with_compiler",
+ "//java/dagger/hilt/android/processor/internal/androidentrypoint:compiler_options",
+ "//java/dagger/hilt/processor/internal:base_processor",
+ "//java/dagger/hilt/processor/internal:classnames",
+ "//java/dagger/hilt/processor/internal:components",
+ "//java/dagger/hilt/processor/internal:kotlin",
+ "//java/dagger/hilt/processor/internal:processor_errors",
+ "//java/dagger/hilt/processor/internal:processors",
+ "//java/dagger/internal/codegen/extension",
+ "//java/dagger/internal/codegen/kotlin",
+ "//java/dagger/internal/guava:collect",
+ "@google_bazel_common//third_party/java/auto:service",
+ "@google_bazel_common//third_party/java/auto:value",
+ "@google_bazel_common//third_party/java/incap",
+ "@google_bazel_common//third_party/java/javapoet",
+ "@google_bazel_common//third_party/java/jsr250_annotations",
+ "@maven//:com_google_auto_auto_common",
+ ],
+)
+
+java_library(
+ name = "component_dependencies",
+ srcs = [
+ "ComponentDependencies.java",
+ ],
+ deps = [
+ ":processor_lib",
+ "//java/dagger/hilt/processor/internal:classnames",
+ "//java/dagger/hilt/processor/internal:component_descriptor",
+ "//java/dagger/hilt/processor/internal:processor_errors",
+ "//java/dagger/hilt/processor/internal:processors",
+ "//java/dagger/internal/codegen/extension",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "@google_bazel_common//third_party/java/auto:value",
+ "@google_bazel_common//third_party/java/javapoet",
+ ],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/processor/internal/aggregateddeps/ComponentDependencies.java b/java/dagger/hilt/processor/internal/aggregateddeps/ComponentDependencies.java
new file mode 100644
index 0000000..23ed148
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/aggregateddeps/ComponentDependencies.java
@@ -0,0 +1,459 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.aggregateddeps;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator.AGGREGATING_PACKAGE;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSetMultimap;
+import com.google.common.collect.SetMultimap;
+import com.squareup.javapoet.ClassName;
+import dagger.hilt.processor.internal.AnnotationValues;
+import dagger.hilt.processor.internal.BadInputException;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.ComponentDescriptor;
+import dagger.hilt.processor.internal.ProcessorErrors;
+import dagger.hilt.processor.internal.Processors;
+import dagger.hilt.processor.internal.aggregateddeps.ComponentDependencies.AggregatedDepMetadata.DependencyType;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.PackageElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.util.Elements;
+
+/** Represents information needed to create a component (i.e. modules, entry points, etc) */
+@AutoValue
+public abstract class ComponentDependencies {
+ private static Builder builder() {
+ return new AutoValue_ComponentDependencies.Builder();
+ }
+
+ /** Returns the modules for a component, without any filtering. */
+ public abstract Dependencies modules();
+
+ /** Returns the entry points associated with the given a component. */
+ public abstract Dependencies entryPoints();
+
+ /** Returns the component entry point associated with the given a component. */
+ public abstract Dependencies componentEntryPoints();
+
+ @AutoValue.Builder
+ abstract static class Builder {
+ abstract Dependencies.Builder modulesBuilder();
+
+ abstract Dependencies.Builder entryPointsBuilder();
+
+ abstract Dependencies.Builder componentEntryPointsBuilder();
+
+ abstract ComponentDependencies autoBuild();
+
+ ComponentDependencies build(Elements elements) {
+ validateModules(modulesBuilder().build(), elements);
+ return autoBuild();
+ }
+ }
+
+ /** A key used for grouping a test dependency by both its component and test name. */
+ @AutoValue
+ abstract static class TestDepKey {
+ static TestDepKey of(ClassName component, ClassName test) {
+ return new AutoValue_ComponentDependencies_TestDepKey(component, test);
+ }
+
+ /** Returns the name of the component this dependency should be installed in. */
+ abstract ClassName component();
+
+ /** Returns the name of the test that this dependency should be installed in. */
+ abstract ClassName test();
+ }
+
+ /**
+ * Holds a set of component dependencies, e.g. modules or entry points.
+ *
+ * <p>This class handles separating dependencies into global and test dependencies. Global
+ * dependencies are installed with every test, where test dependencies are only installed with the
+ * specified test. The total set of dependencies includes all global + test dependencies.
+ */
+ @AutoValue
+ public abstract static class Dependencies {
+ static Builder builder() {
+ return new AutoValue_ComponentDependencies_Dependencies.Builder();
+ }
+
+ /** Returns the global deps keyed by component. */
+ abstract ImmutableSetMultimap<ClassName, TypeElement> globalDeps();
+
+ /** Returns the global test deps keyed by component. */
+ abstract ImmutableSetMultimap<ClassName, TypeElement> globalTestDeps();
+
+ /** Returns the test deps keyed by component and test. */
+ abstract ImmutableSetMultimap<TestDepKey, TypeElement> testDeps();
+
+ /** Returns the uninstalled test deps keyed by test. */
+ abstract ImmutableSetMultimap<ClassName, TypeElement> uninstalledTestDeps();
+
+ /** Returns the global uninstalled test deps. */
+ abstract ImmutableSet<TypeElement> globalUninstalledTestDeps();
+
+ /** Returns the dependencies to be installed in the given component for the given root. */
+ public ImmutableSet<TypeElement> get(ClassName component, ClassName root, boolean isTestRoot) {
+ if (!isTestRoot) {
+ return globalDeps().get(component);
+ }
+
+ ImmutableSet<TypeElement> uninstalledTestDepsForRoot = uninstalledTestDeps().get(root);
+ return ImmutableSet.<TypeElement>builder()
+ .addAll(
+ globalDeps().get(component).stream()
+ .filter(dep -> !uninstalledTestDepsForRoot.contains(dep))
+ .filter(dep -> !globalUninstalledTestDeps().contains(dep))
+ .collect(toImmutableSet()))
+ .addAll(globalTestDeps().get(component))
+ .addAll(testDeps().get(TestDepKey.of(component, root)))
+ .build();
+ }
+
+ @AutoValue.Builder
+ abstract static class Builder {
+ abstract ImmutableSetMultimap.Builder<ClassName, TypeElement> globalDepsBuilder();
+
+ abstract ImmutableSetMultimap.Builder<ClassName, TypeElement> globalTestDepsBuilder();
+
+ abstract ImmutableSetMultimap.Builder<TestDepKey, TypeElement> testDepsBuilder();
+
+ abstract ImmutableSetMultimap.Builder<ClassName, TypeElement> uninstalledTestDepsBuilder();
+
+ abstract ImmutableSet.Builder<TypeElement> globalUninstalledTestDepsBuilder();
+
+ abstract Dependencies build();
+ }
+ }
+
+ /**
+ * Pulls the component dependencies from the {@code packageName}.
+ *
+ * <p>Dependency files are generated by the {@link AggregatedDepsProcessor}, and have the form:
+ *
+ * <pre>{@code
+ * {@literal @}AggregatedDeps(
+ * components = {
+ * "foo.FooComponent",
+ * "bar.BarComponent"
+ * },
+ * modules = "baz.BazModule"
+ * )
+ *
+ * }</pre>
+ */
+ public static ComponentDependencies from(
+ ImmutableSet<ComponentDescriptor> descriptors, Elements elements) {
+ Map<String, ComponentDescriptor> descriptorLookup = descriptorLookupMap(descriptors);
+ ImmutableList<AggregatedDepMetadata> metadatas =
+ getAggregatedDeps(elements).stream()
+ .map(deps -> AggregatedDepMetadata.create(deps, descriptorLookup, elements))
+ .collect(toImmutableList());
+
+ ComponentDependencies.Builder componentDependencies = ComponentDependencies.builder();
+ for (AggregatedDepMetadata metadata : metadatas) {
+ Dependencies.Builder builder = null;
+ switch (metadata.dependencyType()) {
+ case MODULE:
+ builder = componentDependencies.modulesBuilder();
+ break;
+ case ENTRY_POINT:
+ builder = componentDependencies.entryPointsBuilder();
+ break;
+ case COMPONENT_ENTRY_POINT:
+ builder = componentDependencies.componentEntryPointsBuilder();
+ break;
+ }
+
+ for (ComponentDescriptor componentDescriptor : metadata.componentDescriptors()) {
+ ClassName component = componentDescriptor.component();
+ if (metadata.testElement().isPresent()) {
+ // In this case the @InstallIn or @TestInstallIn applies to only the given test root.
+ ClassName test = ClassName.get(metadata.testElement().get());
+ builder.testDepsBuilder().put(TestDepKey.of(component, test), metadata.dependency());
+ builder.uninstalledTestDepsBuilder().putAll(test, metadata.replacedDependencies());
+ } else {
+ // In this case the @InstallIn or @TestInstallIn applies to all roots
+ if (!metadata.replacedDependencies().isEmpty()) {
+ // If there are replacedDependencies() it means this is a @TestInstallIn
+ builder.globalTestDepsBuilder().put(component, metadata.dependency());
+ builder.globalUninstalledTestDepsBuilder().addAll(metadata.replacedDependencies());
+ } else {
+ builder.globalDepsBuilder().put(component, metadata.dependency());
+ }
+ }
+ }
+ }
+
+ // Collect all @UninstallModules.
+ // TODO(b/176438516): Filter @UninstallModules at the root.
+ metadatas.stream()
+ .filter(metadata -> metadata.testElement().isPresent())
+ .map(metadata -> metadata.testElement().get())
+ .distinct()
+ .filter(testElement -> Processors.hasAnnotation(testElement, ClassNames.IGNORE_MODULES))
+ .forEach(
+ testElement ->
+ componentDependencies
+ .modulesBuilder()
+ .uninstalledTestDepsBuilder()
+ .putAll(
+ ClassName.get(testElement), getUninstalledModules(testElement, elements)));
+
+ return componentDependencies.build(elements);
+ }
+
+ private static ImmutableMap<String, ComponentDescriptor> descriptorLookupMap(
+ ImmutableSet<ComponentDescriptor> descriptors) {
+ ImmutableMap.Builder<String, ComponentDescriptor> builder = ImmutableMap.builder();
+ for (ComponentDescriptor descriptor : descriptors) {
+ // This is a temporary hack to map the old ApplicationComponent to the new SingletonComponent.
+ // Technically, this is only needed for backwards compatibility with libraries using the old
+ // processor since new processors should convert to the new SingletonComponent when generating
+ // the metadata class.
+ if (descriptor.component().equals(ClassNames.SINGLETON_COMPONENT)) {
+ builder.put("dagger.hilt.android.components.ApplicationComponent", descriptor);
+ }
+ builder.put(descriptor.component().toString(), descriptor);
+ }
+ return builder.build();
+ }
+
+ // Validate that the @UninstallModules doesn't contain any test modules.
+ private static Dependencies validateModules(Dependencies moduleDeps, Elements elements) {
+ SetMultimap<ClassName, TypeElement> invalidTestModules = HashMultimap.create();
+ moduleDeps.testDeps().entries().stream()
+ .filter(
+ e -> moduleDeps.uninstalledTestDeps().containsEntry(e.getKey().test(), e.getValue()))
+ .forEach(e -> invalidTestModules.put(e.getKey().test(), e.getValue()));
+
+ // Currently we don't have a good way to throw an error for all tests, so we sort (to keep the
+ // error reporting order stable) and then choose the first test.
+ // TODO(bcorso): Consider using ProcessorErrorHandler directly to report all errors at once?
+ Optional<ClassName> invalidTest =
+ invalidTestModules.keySet().stream()
+ .min((test1, test2) -> test1.toString().compareTo(test2.toString()));
+ if (invalidTest.isPresent()) {
+ throw new BadInputException(
+ String.format(
+ "@UninstallModules on test, %s, should not containing test modules, "
+ + "but found: %s",
+ invalidTest.get(),
+ invalidTestModules.get(invalidTest.get()).stream()
+ // Sort modules to keep stable error messages.
+ .sorted((test1, test2) -> test1.toString().compareTo(test2.toString()))
+ .collect(toImmutableList())),
+ elements.getTypeElement(invalidTest.get().toString()));
+ }
+ return moduleDeps;
+ }
+
+ private static ImmutableSet<TypeElement> getUninstalledModules(
+ TypeElement testElement, Elements elements) {
+ ImmutableList<TypeElement> userUninstallModules =
+ Processors.getAnnotationClassValues(
+ elements,
+ Processors.getAnnotationMirror(testElement, ClassNames.IGNORE_MODULES),
+ "value");
+
+ // For pkg-private modules, find the generated wrapper class and uninstall that instead.
+ return userUninstallModules.stream()
+ .map(uninstallModule -> getPublicDependency(uninstallModule, elements))
+ .collect(toImmutableSet());
+ }
+
+ /** Returns the public Hilt wrapper module, or the module itself if its already public. */
+ private static TypeElement getPublicDependency(TypeElement dependency, Elements elements) {
+ return PkgPrivateMetadata.of(elements, dependency, ClassNames.MODULE)
+ .map(metadata -> elements.getTypeElement(metadata.generatedClassName().toString()))
+ .orElse(dependency);
+ }
+
+ /** Returns the top-level elements of the aggregated deps package. */
+ private static ImmutableList<AnnotationMirror> getAggregatedDeps(Elements elements) {
+ PackageElement packageElement = elements.getPackageElement(AGGREGATING_PACKAGE);
+ checkState(
+ packageElement != null,
+ "Couldn't find package %s. Did you mark your @Module classes with @InstallIn annotations?",
+ AGGREGATING_PACKAGE);
+
+ List<? extends Element> aggregatedDepsElements = packageElement.getEnclosedElements();
+ checkState(
+ !aggregatedDepsElements.isEmpty(),
+ "No dependencies found. Did you mark your @Module classes with @InstallIn annotations?");
+
+ ImmutableList.Builder<AnnotationMirror> builder = ImmutableList.builder();
+ for (Element element : aggregatedDepsElements) {
+ ProcessorErrors.checkState(
+ element.getKind() == ElementKind.CLASS,
+ element,
+ "Only classes may be in package %s. Did you add custom code in the package?",
+ AGGREGATING_PACKAGE);
+
+ AnnotationMirror aggregatedDeps =
+ Processors.getAnnotationMirror(element, ClassNames.AGGREGATED_DEPS);
+ ProcessorErrors.checkState(
+ aggregatedDeps != null,
+ element,
+ "Classes in package %s must be annotated with @AggregatedDeps: %s. Found: %s.",
+ AGGREGATING_PACKAGE,
+ element.getSimpleName(),
+ element.getAnnotationMirrors());
+
+ builder.add(aggregatedDeps);
+ }
+ return builder.build();
+ }
+
+ @AutoValue
+ abstract static class AggregatedDepMetadata {
+ static AggregatedDepMetadata create(
+ AnnotationMirror aggregatedDeps,
+ Map<String, ComponentDescriptor> descriptorLookup,
+ Elements elements) {
+ ImmutableMap<String, AnnotationValue> aggregatedDepsValues =
+ Processors.getAnnotationValues(elements, aggregatedDeps);
+
+ return new AutoValue_ComponentDependencies_AggregatedDepMetadata(
+ getTestElement(aggregatedDepsValues.get("test"), elements),
+ getComponents(aggregatedDepsValues.get("components"), descriptorLookup),
+ getDependencyType(
+ aggregatedDepsValues.get("modules"),
+ aggregatedDepsValues.get("entryPoints"),
+ aggregatedDepsValues.get("componentEntryPoints")),
+ getDependency(
+ aggregatedDepsValues.get("modules"),
+ aggregatedDepsValues.get("entryPoints"),
+ aggregatedDepsValues.get("componentEntryPoints"),
+ elements),
+ getReplacedDependencies(aggregatedDepsValues.get("replaces"), elements));
+ }
+
+ enum DependencyType {
+ MODULE,
+ ENTRY_POINT,
+ COMPONENT_ENTRY_POINT
+ }
+
+ abstract Optional<TypeElement> testElement();
+
+ abstract ImmutableList<ComponentDescriptor> componentDescriptors();
+
+ abstract DependencyType dependencyType();
+
+ abstract TypeElement dependency();
+
+ abstract ImmutableSet<TypeElement> replacedDependencies();
+
+ private static Optional<TypeElement> getTestElement(
+ AnnotationValue testValue, Elements elements) {
+ checkNotNull(testValue);
+ String test = AnnotationValues.getString(testValue);
+ return test.isEmpty() ? Optional.empty() : Optional.of(elements.getTypeElement(test));
+ }
+
+ private static ImmutableList<ComponentDescriptor> getComponents(
+ AnnotationValue componentsValue, Map<String, ComponentDescriptor> descriptorLookup) {
+ checkNotNull(componentsValue);
+ ImmutableList<String> componentNames =
+ AnnotationValues.getAnnotationValues(componentsValue).stream()
+ .map(AnnotationValues::getString)
+ .collect(toImmutableList());
+
+ checkState(!componentNames.isEmpty());
+ ImmutableList.Builder<ComponentDescriptor> components = ImmutableList.builder();
+ for (String componentName : componentNames) {
+ checkState(
+ descriptorLookup.containsKey(componentName),
+ "%s is not a valid Component. Did you add or remove code in package %s?",
+ componentName,
+ AGGREGATING_PACKAGE);
+ components.add(descriptorLookup.get(componentName));
+ }
+ return components.build();
+ }
+
+ private static DependencyType getDependencyType(
+ AnnotationValue modulesValue,
+ AnnotationValue entryPointsValue,
+ AnnotationValue componentEntryPointsValue) {
+ checkNotNull(modulesValue);
+ checkNotNull(entryPointsValue);
+ checkNotNull(componentEntryPointsValue);
+
+ ImmutableSet.Builder<DependencyType> dependencyTypes = ImmutableSet.builder();
+ if (!AnnotationValues.getAnnotationValues(modulesValue).isEmpty()) {
+ dependencyTypes.add(DependencyType.MODULE);
+ }
+ if (!AnnotationValues.getAnnotationValues(entryPointsValue).isEmpty()) {
+ dependencyTypes.add(DependencyType.ENTRY_POINT);
+ }
+ if (!AnnotationValues.getAnnotationValues(componentEntryPointsValue).isEmpty()) {
+ dependencyTypes.add(DependencyType.COMPONENT_ENTRY_POINT);
+ }
+ return getOnlyElement(dependencyTypes.build());
+ }
+
+ private static TypeElement getDependency(
+ AnnotationValue modulesValue,
+ AnnotationValue entryPointsValue,
+ AnnotationValue componentEntryPointsValue,
+ Elements elements) {
+ checkNotNull(modulesValue);
+ checkNotNull(entryPointsValue);
+ checkNotNull(componentEntryPointsValue);
+
+ return elements.getTypeElement(
+ AnnotationValues.getString(
+ getOnlyElement(
+ ImmutableList.<AnnotationValue>builder()
+ .addAll(AnnotationValues.getAnnotationValues(modulesValue))
+ .addAll(AnnotationValues.getAnnotationValues(entryPointsValue))
+ .addAll(AnnotationValues.getAnnotationValues(componentEntryPointsValue))
+ .build())));
+ }
+
+ private static ImmutableSet<TypeElement> getReplacedDependencies(
+ AnnotationValue replacedDependenciesValue, Elements elements) {
+ // Allow null values to support libraries using a Hilt version before @TestInstallIn was added
+ return replacedDependenciesValue == null
+ ? ImmutableSet.of()
+ : AnnotationValues.getAnnotationValues(replacedDependenciesValue).stream()
+ .map(AnnotationValues::getString)
+ .map(elements::getTypeElement)
+ .map(replacedDep -> getPublicDependency(replacedDep, elements))
+ .collect(toImmutableSet());
+ }
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/aggregateddeps/PkgPrivateEntryPointGenerator.java b/java/dagger/hilt/processor/internal/aggregateddeps/PkgPrivateEntryPointGenerator.java
new file mode 100644
index 0000000..6dac59f
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/aggregateddeps/PkgPrivateEntryPointGenerator.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.aggregateddeps;
+
+import com.squareup.javapoet.AnnotationSpec;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.TypeSpec;
+import dagger.hilt.processor.internal.Processors;
+import java.io.IOException;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.Modifier;
+
+/**
+ * Generates a public Dagger entrypoint that includes a user's pkg-private entrypoint. This allows a
+ * user's entrypoint to use pkg-private visibility to hide from external packages.
+ */
+final class PkgPrivateEntryPointGenerator {
+ private final ProcessingEnvironment env;
+ private final PkgPrivateMetadata metadata;
+
+ PkgPrivateEntryPointGenerator(ProcessingEnvironment env, PkgPrivateMetadata metadata) {
+ this.env = env;
+ this.metadata = metadata;
+ }
+
+ // This method creates the following generated code for an EntryPoint in pkg.MyEntryPoint that is
+ // package
+ // private
+ //
+ // package pkg; //same package
+ //
+ // import dagger.hilt.InstallIn;
+ // import dagger.hilt.EntryPoint;;
+ // import javax.annotation.Generated;
+ //
+ // @Generated("dagger.hilt.processor.internal.aggregateddeps.PkgPrivateEntryPointGenerator")
+ // @InstallIn(InstallIn.Component.ACTIVITY)
+ // @EntryPoint
+ // public final class HiltWrapper_MyEntryPoint extends MyEntryPoint {
+ // }
+ void generate() throws IOException {
+
+ TypeSpec.Builder entryPointInterfaceBuilder =
+ TypeSpec.interfaceBuilder(metadata.generatedClassName().simpleName())
+ .addOriginatingElement(metadata.getTypeElement())
+ .addAnnotation(Processors.getOriginatingElementAnnotation(metadata.getTypeElement()))
+ .addModifiers(Modifier.PUBLIC)
+ .addSuperinterface(metadata.baseClassName())
+ .addAnnotation(metadata.getAnnotation());
+
+ Processors.addGeneratedAnnotation(entryPointInterfaceBuilder, env, getClass());
+
+ if (metadata.getOptionalInstallInAnnotationMirror().isPresent()) {
+ entryPointInterfaceBuilder.addAnnotation(
+ AnnotationSpec.get(metadata.getOptionalInstallInAnnotationMirror().get()));
+ }
+
+ JavaFile.builder(
+ metadata.generatedClassName().packageName(), entryPointInterfaceBuilder.build())
+ .build()
+ .writeTo(env.getFiler());
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/aggregateddeps/PkgPrivateMetadata.java b/java/dagger/hilt/processor/internal/aggregateddeps/PkgPrivateMetadata.java
new file mode 100644
index 0000000..66f1751
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/aggregateddeps/PkgPrivateMetadata.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.aggregateddeps;
+
+import static com.google.auto.common.Visibility.effectiveVisibilityOfElement;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.Visibility;
+import com.google.auto.value.AutoValue;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.TypeName;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.Processors;
+import java.util.Optional;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.util.Elements;
+
+/** PkgPrivateModuleMetadata contains a set of utilities for processing package private modules. */
+@AutoValue
+abstract class PkgPrivateMetadata {
+ private static final String PREFIX = "HiltWrapper_";
+
+ /** Returns the base class name of the elemenet. */
+ TypeName baseClassName() {
+ return TypeName.get(getTypeElement().asType());
+ }
+
+ /** Returns TypeElement for the module element the metadata object represents */
+ abstract TypeElement getTypeElement();
+
+ /**
+ * Returns an optional @InstallIn AnnotationMirror for the module element the metadata object
+ * represents
+ */
+ abstract Optional<AnnotationMirror> getOptionalInstallInAnnotationMirror();
+
+ /** Return the Type of this package private element. */
+ abstract ClassName getAnnotation();
+
+ /** Returns the expected genenerated classname for the element the metadata object represents */
+ final ClassName generatedClassName() {
+ return Processors.prepend(
+ Processors.getEnclosedClassName(ClassName.get(getTypeElement())), PREFIX);
+ }
+
+ /**
+ * Returns an Optional PkgPrivateMetadata requiring Hilt processing, otherwise returns an empty
+ * Optional.
+ */
+ static Optional<PkgPrivateMetadata> of(Elements elements, Element element, ClassName annotation) {
+ // If this is a public element no wrapping is needed
+ if (effectiveVisibilityOfElement(element) == Visibility.PUBLIC) {
+ return Optional.empty();
+ }
+
+ Optional<AnnotationMirror> installIn;
+ if (Processors.hasAnnotation(element, ClassNames.INSTALL_IN)) {
+ installIn = Optional.of(Processors.getAnnotationMirror(element, ClassNames.INSTALL_IN));
+ } else if (Processors.hasAnnotation(element, ClassNames.TEST_INSTALL_IN)) {
+ installIn = Optional.of(Processors.getAnnotationMirror(element, ClassNames.TEST_INSTALL_IN));
+ } else {
+ throw new IllegalStateException(
+ "Expected element to be annotated with @InstallIn: " + element);
+ }
+
+ if (annotation.equals(ClassNames.MODULE)
+ ) {
+ // Skip modules that require a module instance. Required by
+ // dagger (b/31489617)
+ if (Processors.requiresModuleInstance(elements, MoreElements.asType(element))) {
+ return Optional.empty();
+ }
+ }
+ return Optional.of(
+ new AutoValue_PkgPrivateMetadata(MoreElements.asType(element), installIn, annotation));
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/aggregateddeps/PkgPrivateModuleGenerator.java b/java/dagger/hilt/processor/internal/aggregateddeps/PkgPrivateModuleGenerator.java
new file mode 100644
index 0000000..18ff0bd
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/aggregateddeps/PkgPrivateModuleGenerator.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.aggregateddeps;
+
+import com.squareup.javapoet.AnnotationSpec;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.TypeSpec;
+import dagger.hilt.processor.internal.Processors;
+import java.io.IOException;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.Modifier;
+
+/**
+ * Generates a public Dagger module that includes a user's pkg-private module. This allows a user's
+ * module to use pkg-private visibility to hide from external packages, but still allows Hilt to
+ * install the module when the component is created in another package.
+ */
+final class PkgPrivateModuleGenerator {
+ private final ProcessingEnvironment env;
+ private final PkgPrivateMetadata metadata;
+
+ PkgPrivateModuleGenerator(ProcessingEnvironment env, PkgPrivateMetadata metadata) {
+ this.env = env;
+ this.metadata = metadata;
+ }
+
+ // This method creates the following generated code for a pkg-private module, pkg.MyModule:
+ //
+ // package pkg; //same as module
+ //
+ // import dagger.Module;
+ // import dagger.hilt.InstallIn;
+ // import javax.annotation.Generated;
+ //
+ // @Generated("dagger.hilt.processor.internal.aggregateddeps.PkgPrivateModuleGenerator")
+ // @InstallIn(ActivityComponent.class)
+ // @Module(includes = MyModule.class)
+ // public final class HiltModuleWrapper_MyModule {}
+ void generate() throws IOException {
+ TypeSpec.Builder builder =
+ TypeSpec.classBuilder(metadata.generatedClassName().simpleName())
+ .addOriginatingElement(metadata.getTypeElement())
+ .addAnnotation(Processors.getOriginatingElementAnnotation(metadata.getTypeElement()))
+ .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
+ // generated @InstallIn is exactly the same as the module being processed
+ .addAnnotation(
+ AnnotationSpec.get(metadata.getOptionalInstallInAnnotationMirror().get()))
+ .addAnnotation(
+ AnnotationSpec.builder(metadata.getAnnotation())
+ .addMember("includes", "$T.class", metadata.getTypeElement())
+ .build());
+
+ Processors.addGeneratedAnnotation(builder, env, getClass());
+
+ JavaFile.builder(metadata.generatedClassName().packageName(), builder.build())
+ .build()
+ .writeTo(env.getFiler());
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/aliasof/AliasOfProcessor.java b/java/dagger/hilt/processor/internal/aliasof/AliasOfProcessor.java
new file mode 100644
index 0000000..6efd643
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/aliasof/AliasOfProcessor.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.aliasof;
+
+import static net.ltgt.gradle.incap.IncrementalAnnotationProcessorType.ISOLATING;
+
+import com.google.auto.service.AutoService;
+import com.google.common.collect.ImmutableSet;
+import dagger.hilt.processor.internal.BaseProcessor;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.ProcessorErrors;
+import dagger.hilt.processor.internal.Processors;
+import java.util.Set;
+import javax.annotation.processing.Processor;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import net.ltgt.gradle.incap.IncrementalAnnotationProcessor;
+
+/** Processes the annotations annotated with {@link dagger.hilt.migration.AliasOf} */
+@IncrementalAnnotationProcessor(ISOLATING)
+@AutoService(Processor.class)
+public final class AliasOfProcessor extends BaseProcessor {
+ @Override
+ public Set<String> getSupportedAnnotationTypes() {
+ return ImmutableSet.of(ClassNames.ALIAS_OF.toString());
+ }
+
+ @Override
+ public void processEach(TypeElement annotation, Element element) throws Exception {
+ ProcessorErrors.checkState(
+ Processors.hasAnnotation(element, ClassNames.SCOPE),
+ element,
+ "%s should only be used on scopes." + " However, it was found annotating %s",
+ annotation,
+ element);
+ AnnotationMirror annotationMirror =
+ Processors.getAnnotationMirror(element, ClassNames.ALIAS_OF);
+
+ Element defineComponentScope =
+ Processors.getAnnotationClassValue(getElementUtils(), annotationMirror, "value");
+
+ new AliasOfPropagatedDataGenerator(getProcessingEnv(), element, defineComponentScope)
+ .generate();
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/aliasof/AliasOfPropagatedDataGenerator.java b/java/dagger/hilt/processor/internal/aliasof/AliasOfPropagatedDataGenerator.java
new file mode 100644
index 0000000..75c4c15
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/aliasof/AliasOfPropagatedDataGenerator.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.aliasof;
+
+import com.squareup.javapoet.AnnotationSpec;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.TypeSpec;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.Processors;
+import java.io.IOException;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.Element;
+
+/** Generates resource files for {@link dagger.hilt.migration.AliasOf}. */
+final class AliasOfPropagatedDataGenerator {
+
+ private final ProcessingEnvironment processingEnv;
+ private final Element aliasScope;
+ private final Element defineComponentScope;
+
+ AliasOfPropagatedDataGenerator(
+ ProcessingEnvironment processingEnv, Element aliasScope, Element defineComponentScope) {
+ this.processingEnv = processingEnv;
+ this.aliasScope = aliasScope;
+ this.defineComponentScope = defineComponentScope;
+ }
+
+ void generate() throws IOException {
+ TypeSpec.Builder generator =
+ TypeSpec.classBuilder(Processors.getFullEnclosedName(aliasScope))
+ .addOriginatingElement(aliasScope)
+ .addAnnotation(
+ AnnotationSpec.builder(ClassNames.ALIAS_OF_PROPAGATED_DATA)
+ .addMember("defineComponentScope", "$T.class", defineComponentScope)
+ .addMember("alias", "$T.class", aliasScope)
+ .build())
+ .addJavadoc("Generated class for aggregating scope aliases. \n");
+
+ Processors.addGeneratedAnnotation(generator, processingEnv, getClass());
+
+ JavaFile.builder(AliasOfs.AGGREGATING_PACKAGE, generator.build())
+ .build()
+ .writeTo(processingEnv.getFiler());
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/aliasof/AliasOfs.java b/java/dagger/hilt/processor/internal/aliasof/AliasOfs.java
new file mode 100644
index 0000000..930a72e
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/aliasof/AliasOfs.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.aliasof;
+
+import static com.google.common.base.Suppliers.memoize;
+
+import com.google.common.base.Preconditions;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableMultimap;
+import com.google.common.collect.ImmutableSet;
+import com.squareup.javapoet.ClassName;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.ProcessorErrors;
+import dagger.hilt.processor.internal.Processors;
+import java.util.List;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.PackageElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.util.Elements;
+
+/**
+ * Extracts a multimap of aliases annotated with {@link dagger.hilt.migration.AliasOf} mapping them
+ * to scopes they are alias of.
+ */
+public final class AliasOfs {
+ static final String AGGREGATING_PACKAGE = AliasOfs.class.getPackage().getName() + ".codegen";
+
+ private final ProcessingEnvironment processingEnvironment;
+ private final ImmutableSet<ClassName> defineComponentScopes;
+ private final Supplier<ImmutableMultimap<ClassName, ClassName>> aliases =
+ memoize(() -> getAliases());
+
+ public AliasOfs(
+ ProcessingEnvironment processingEnvironment, ImmutableSet<ClassName> defineComponentScopes) {
+ this.defineComponentScopes = defineComponentScopes;
+ this.processingEnvironment = processingEnvironment;
+ }
+
+ public ImmutableSet<ClassName> getAliasesFor(ClassName defineComponentScope) {
+ return ImmutableSet.copyOf(aliases.get().get(defineComponentScope));
+ }
+
+ private ImmutableMultimap<ClassName, ClassName> getAliases() {
+ Elements elements = processingEnvironment.getElementUtils();
+ PackageElement packageElement = elements.getPackageElement(AGGREGATING_PACKAGE);
+ if (packageElement == null) {
+ return ImmutableMultimap.of();
+ }
+ List<? extends Element> scopeAliasElements = packageElement.getEnclosedElements();
+ Preconditions.checkState(
+ !scopeAliasElements.isEmpty(), "No scope aliases Found in package %s.", packageElement);
+
+ ImmutableMultimap.Builder<ClassName, ClassName> builder = ImmutableMultimap.builder();
+ for (Element element : scopeAliasElements) {
+ ProcessorErrors.checkState(
+ element.getKind() == ElementKind.CLASS,
+ element,
+ "Only classes may be in package %s. Did you add custom code in the package?",
+ packageElement);
+
+ AnnotationMirror annotationMirror =
+ Processors.getAnnotationMirror(element, ClassNames.ALIAS_OF_PROPAGATED_DATA);
+
+ ProcessorErrors.checkState(
+ annotationMirror != null,
+ element,
+ "Classes in package %s must be annotated with @%s: %s."
+ + " Found: %s. Files in this package are generated, did you add custom code in the"
+ + " package? ",
+ packageElement,
+ ClassNames.ALIAS_OF_PROPAGATED_DATA,
+ element.getSimpleName(),
+ element.getAnnotationMirrors());
+
+ TypeElement defineComponentScope =
+ Processors.getAnnotationClassValue(elements, annotationMirror, "defineComponentScope");
+ TypeElement alias = Processors.getAnnotationClassValue(elements, annotationMirror, "alias");
+
+ Preconditions.checkState(
+ defineComponentScopes.contains(ClassName.get(defineComponentScope)),
+ "The scope %s cannot be an alias for %s. You can only have aliases of a scope defined"
+ + " directly on a @DefineComponent type.",
+ ClassName.get(alias),
+ ClassName.get(defineComponentScope));
+
+ builder.put(ClassName.get(defineComponentScope), ClassName.get(alias));
+ }
+
+ return builder.build();
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/aliasof/BUILD b/java/dagger/hilt/processor/internal/aliasof/BUILD
new file mode 100644
index 0000000..d3f90f2
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/aliasof/BUILD
@@ -0,0 +1,64 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# A processor for @dagger.hilt.AliasOfProcessor.
+
+package(default_visibility = ["//:src"])
+
+java_plugin(
+ name = "processor",
+ generates_api = 1,
+ processor_class = "dagger.hilt.processor.internal.aliasof.AliasOfProcessor",
+ deps = [":processor_lib"],
+)
+
+java_library(
+ name = "processor_lib",
+ srcs = [
+ "AliasOfProcessor.java",
+ "AliasOfPropagatedDataGenerator.java",
+ ],
+ deps = [
+ ":alias_ofs",
+ "//java/dagger/hilt/processor/internal:base_processor",
+ "//java/dagger/hilt/processor/internal:classnames",
+ "//java/dagger/hilt/processor/internal:processor_errors",
+ "//java/dagger/hilt/processor/internal:processors",
+ "//java/dagger/internal/guava:collect",
+ "@google_bazel_common//third_party/java/auto:service",
+ "@google_bazel_common//third_party/java/incap",
+ "@google_bazel_common//third_party/java/javapoet",
+ ],
+)
+
+java_library(
+ name = "alias_ofs",
+ srcs = [
+ "AliasOfs.java",
+ ],
+ deps = [
+ "//java/dagger/hilt/processor/internal:classnames",
+ "//java/dagger/hilt/processor/internal:processor_errors",
+ "//java/dagger/hilt/processor/internal:processors",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "@google_bazel_common//third_party/java/javapoet",
+ ],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/processor/internal/definecomponent/BUILD b/java/dagger/hilt/processor/internal/definecomponent/BUILD
new file mode 100644
index 0000000..7edec1c
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/definecomponent/BUILD
@@ -0,0 +1,69 @@
+# Copyright (C) 2019 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# A processor for @dagger.hilt.DefineComponent.
+
+package(default_visibility = ["//:src"])
+
+java_plugin(
+ name = "processor",
+ generates_api = 1,
+ processor_class = "dagger.hilt.processor.internal.definecomponent.DefineComponentProcessor",
+ deps = [":processor_lib"],
+)
+
+java_library(
+ name = "processor_lib",
+ srcs = [
+ "DefineComponentProcessor.java",
+ ],
+ deps = [
+ ":define_components",
+ "//java/dagger/hilt/processor/internal:base_processor",
+ "//java/dagger/hilt/processor/internal:classnames",
+ "//java/dagger/hilt/processor/internal:processors",
+ "//java/dagger/internal/guava:collect",
+ "@google_bazel_common//third_party/java/auto:service",
+ "@google_bazel_common//third_party/java/incap",
+ "@google_bazel_common//third_party/java/javapoet",
+ ],
+)
+
+java_library(
+ name = "define_components",
+ srcs = [
+ "DefineComponentBuilderMetadatas.java",
+ "DefineComponentMetadatas.java",
+ "DefineComponents.java",
+ ],
+ deps = [
+ "//java/dagger/hilt/processor/internal:classnames",
+ "//java/dagger/hilt/processor/internal:component_descriptor",
+ "//java/dagger/hilt/processor/internal:processor_errors",
+ "//java/dagger/hilt/processor/internal:processors",
+ "//java/dagger/internal/codegen/extension",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/internal/guava:graph",
+ "@google_bazel_common//third_party/java/auto:value",
+ "@google_bazel_common//third_party/java/javapoet",
+ "@maven//:com_google_auto_auto_common",
+ ],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/processor/internal/definecomponent/DefineComponentBuilderMetadatas.java b/java/dagger/hilt/processor/internal/definecomponent/DefineComponentBuilderMetadatas.java
new file mode 100644
index 0000000..0f10f39
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/definecomponent/DefineComponentBuilderMetadatas.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.definecomponent;
+
+import static javax.lang.model.element.Modifier.STATIC;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.MoreTypes;
+import com.google.auto.value.AutoValue;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.TypeName;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.ProcessorErrors;
+import dagger.hilt.processor.internal.Processors;
+import dagger.hilt.processor.internal.definecomponent.DefineComponentMetadatas.DefineComponentMetadata;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.ElementFilter;
+
+/** Metadata for types annotated with {@link dagger.hilt.DefineComponent.Builder}. */
+final class DefineComponentBuilderMetadatas {
+ static DefineComponentBuilderMetadatas create(DefineComponentMetadatas componentMetadatas) {
+ return new DefineComponentBuilderMetadatas(componentMetadatas);
+ }
+
+ private final Map<Element, DefineComponentBuilderMetadata> builderMetadatas = new HashMap<>();
+ private final DefineComponentMetadatas componentMetadatas;
+
+ private DefineComponentBuilderMetadatas(DefineComponentMetadatas componentMetadatas) {
+ this.componentMetadatas = componentMetadatas;
+ }
+
+ DefineComponentBuilderMetadata get(Element element) {
+ if (!builderMetadatas.containsKey(element)) {
+ builderMetadatas.put(element, getUncached(element));
+ }
+ return builderMetadatas.get(element);
+ }
+
+ private DefineComponentBuilderMetadata getUncached(Element element) {
+ ProcessorErrors.checkState(
+ Processors.hasAnnotation(element, ClassNames.DEFINE_COMPONENT_BUILDER),
+ element,
+ "%s, expected to be annotated with @DefineComponent.Builder. Found: %s",
+ element,
+ element.getAnnotationMirrors());
+
+ // TODO(bcorso): Allow abstract classes?
+ ProcessorErrors.checkState(
+ element.getKind().equals(ElementKind.INTERFACE),
+ element,
+ "@DefineComponent.Builder is only allowed on interfaces. Found: %s",
+ element);
+ TypeElement builder = MoreElements.asType(element);
+
+ // TODO(bcorso): Allow extending interfaces?
+ ProcessorErrors.checkState(
+ builder.getInterfaces().isEmpty(),
+ builder,
+ "@DefineComponent.Builder %s, cannot extend a super class or interface. Found: %s",
+ builder,
+ builder.getInterfaces());
+
+ // TODO(bcorso): Allow type parameters?
+ ProcessorErrors.checkState(
+ builder.getTypeParameters().isEmpty(),
+ builder,
+ "@DefineComponent.Builder %s, cannot have type parameters.",
+ builder.asType());
+
+ List<VariableElement> nonStaticFields =
+ ElementFilter.fieldsIn(builder.getEnclosedElements()).stream()
+ .filter(method -> !method.getModifiers().contains(STATIC))
+ .collect(Collectors.toList());
+ ProcessorErrors.checkState(
+ nonStaticFields.isEmpty(),
+ builder,
+ "@DefineComponent.Builder %s, cannot have non-static fields. Found: %s",
+ builder,
+ nonStaticFields);
+
+ List<ExecutableElement> buildMethods =
+ ElementFilter.methodsIn(builder.getEnclosedElements()).stream()
+ .filter(method -> !method.getModifiers().contains(STATIC))
+ .filter(method -> method.getParameters().isEmpty())
+ .collect(Collectors.toList());
+
+ ProcessorErrors.checkState(
+ buildMethods.size() == 1,
+ builder,
+ "@DefineComponent.Builder %s, must have exactly 1 build method that takes no parameters. "
+ + "Found: %s",
+ builder,
+ buildMethods);
+
+ ExecutableElement buildMethod = buildMethods.get(0);
+ TypeMirror component = buildMethod.getReturnType();
+ ProcessorErrors.checkState(
+ buildMethod.getReturnType().getKind().equals(TypeKind.DECLARED)
+ && Processors.hasAnnotation(
+ MoreTypes.asTypeElement(component), ClassNames.DEFINE_COMPONENT),
+ builder,
+ "@DefineComponent.Builder method, %s#%s, must return a @DefineComponent type. Found: %s",
+ builder,
+ buildMethod,
+ component);
+
+ List<ExecutableElement> nonStaticNonBuilderMethods =
+ ElementFilter.methodsIn(builder.getEnclosedElements()).stream()
+ .filter(method -> !method.getModifiers().contains(STATIC))
+ .filter(method -> !method.equals(buildMethod))
+ .filter(method -> !TypeName.get(method.getReturnType()).equals(ClassName.get(builder)))
+ .collect(Collectors.toList());
+
+ ProcessorErrors.checkState(
+ nonStaticNonBuilderMethods.isEmpty(),
+ nonStaticNonBuilderMethods,
+ "@DefineComponent.Builder %s, all non-static methods must return %s or %s. Found: %s",
+ builder,
+ builder,
+ component,
+ nonStaticNonBuilderMethods);
+
+ return new AutoValue_DefineComponentBuilderMetadatas_DefineComponentBuilderMetadata(
+ builder,
+ buildMethod,
+ componentMetadatas.get(MoreTypes.asTypeElement(component)));
+ }
+
+ @AutoValue
+ abstract static class DefineComponentBuilderMetadata {
+ abstract TypeElement builder();
+
+ abstract ExecutableElement buildMethod();
+
+ abstract DefineComponentMetadata componentMetadata();
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/definecomponent/DefineComponentMetadatas.java b/java/dagger/hilt/processor/internal/definecomponent/DefineComponentMetadatas.java
new file mode 100644
index 0000000..aa69e40
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/definecomponent/DefineComponentMetadatas.java
@@ -0,0 +1,195 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.definecomponent;
+
+import static com.google.auto.common.AnnotationMirrors.getAnnotationElementAndValue;
+import static com.google.auto.common.MoreElements.asType;
+import static com.google.auto.common.MoreTypes.asTypeElement;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
+import static java.util.stream.Collectors.joining;
+import static javax.lang.model.element.Modifier.STATIC;
+
+import com.google.auto.common.MoreTypes;
+import com.google.auto.value.AutoValue;
+import com.google.common.collect.ImmutableList;
+import com.squareup.javapoet.ClassName;
+import dagger.hilt.processor.internal.AnnotationValues;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.ProcessorErrors;
+import dagger.hilt.processor.internal.Processors;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.util.ElementFilter;
+
+/** Metadata for types annotated with {@link dagger.hilt.DefineComponent}. */
+final class DefineComponentMetadatas {
+ static DefineComponentMetadatas create() {
+ return new DefineComponentMetadatas();
+ }
+
+ private final Map<Element, DefineComponentMetadata> metadatas = new HashMap<>();
+
+ private DefineComponentMetadatas() {}
+
+ /** Returns the metadata for an element annotated with {@link dagger.hilt.DefineComponent}. */
+ DefineComponentMetadata get(Element element) {
+ return get(element, new LinkedHashSet<>());
+ }
+
+ private DefineComponentMetadata get(Element element, LinkedHashSet<Element> childPath) {
+ if (!metadatas.containsKey(element)) {
+ metadatas.put(element, getUncached(element, childPath));
+ }
+ return metadatas.get(element);
+ }
+
+ private DefineComponentMetadata getUncached(
+ Element element, LinkedHashSet<Element> childPath) {
+ ProcessorErrors.checkState(
+ childPath.add(element),
+ element,
+ "@DefineComponent cycle: %s -> %s",
+ childPath.stream().map(Object::toString).collect(joining(" -> ")),
+ element);
+
+ ProcessorErrors.checkState(
+ Processors.hasAnnotation(element, ClassNames.DEFINE_COMPONENT),
+ element,
+ "%s, expected to be annotated with @DefineComponent. Found: %s",
+ element,
+ element.getAnnotationMirrors());
+
+ // TODO(bcorso): Allow abstract classes?
+ ProcessorErrors.checkState(
+ element.getKind().equals(ElementKind.INTERFACE),
+ element,
+ "@DefineComponent is only allowed on interfaces. Found: %s",
+ element);
+ TypeElement component = asType(element);
+
+ // TODO(bcorso): Allow extending interfaces?
+ ProcessorErrors.checkState(
+ component.getInterfaces().isEmpty(),
+ component,
+ "@DefineComponent %s, cannot extend a super class or interface. Found: %s",
+ component,
+ component.getInterfaces());
+
+ // TODO(bcorso): Allow type parameters?
+ ProcessorErrors.checkState(
+ component.getTypeParameters().isEmpty(),
+ component,
+ "@DefineComponent %s, cannot have type parameters.",
+ component.asType());
+
+ // TODO(bcorso): Allow non-static abstract methods (aka EntryPoints)?
+ List<ExecutableElement> nonStaticMethods =
+ ElementFilter.methodsIn(component.getEnclosedElements()).stream()
+ .filter(method -> !method.getModifiers().contains(STATIC))
+ .collect(Collectors.toList());
+ ProcessorErrors.checkState(
+ nonStaticMethods.isEmpty(),
+ component,
+ "@DefineComponent %s, cannot have non-static methods. Found: %s",
+ component,
+ nonStaticMethods);
+
+ // No need to check non-static fields since interfaces can't have them.
+
+ ImmutableList<TypeElement> scopes =
+ Processors.getScopeAnnotations(component).stream()
+ .map(AnnotationMirror::getAnnotationType)
+ .map(MoreTypes::asTypeElement)
+ .collect(toImmutableList());
+
+ ImmutableList<AnnotationMirror> aliasScopes =
+ Processors.getAnnotationsAnnotatedWith(component, ClassNames.ALIAS_OF);
+ ProcessorErrors.checkState(
+ aliasScopes.isEmpty(),
+ component,
+ "@DefineComponent %s, references invalid scope(s) annotated with @AliasOf. "
+ + "@DefineComponent scopes cannot be aliases of other scopes: %s",
+ component,
+ aliasScopes);
+
+ AnnotationMirror mirror =
+ Processors.getAnnotationMirror(component, ClassNames.DEFINE_COMPONENT);
+ AnnotationValue parentValue = getAnnotationElementAndValue(mirror, "parent").getValue();
+
+ ProcessorErrors.checkState(
+ // TODO(bcorso): Contribute a check to auto/common AnnotationValues.
+ !"<error>".contentEquals(parentValue.getValue().toString()),
+ component,
+ "@DefineComponent %s, references an invalid parent type: %s",
+ component,
+ mirror);
+
+ TypeElement parent = asTypeElement(AnnotationValues.getTypeMirror(parentValue));
+
+ ProcessorErrors.checkState(
+ ClassName.get(parent).equals(ClassNames.DEFINE_COMPONENT_NO_PARENT)
+ || Processors.hasAnnotation(parent, ClassNames.DEFINE_COMPONENT),
+ component,
+ "@DefineComponent %s, references a type not annotated with @DefineComponent: %s",
+ component,
+ parent);
+
+ Optional<DefineComponentMetadata> parentComponent =
+ ClassName.get(parent).equals(ClassNames.DEFINE_COMPONENT_NO_PARENT)
+ ? Optional.empty()
+ : Optional.of(get(parent, childPath));
+
+ ProcessorErrors.checkState(
+ parentComponent.isPresent()
+ || ClassName.get(component).equals(ClassNames.SINGLETON_COMPONENT),
+ component,
+ "@DefineComponent %s is missing a parent declaration.\n"
+ + "Please declare the parent, for example: @DefineComponent(parent ="
+ + " SingletonComponent.class)",
+ component);
+
+ return new AutoValue_DefineComponentMetadatas_DefineComponentMetadata(
+ component, scopes, parentComponent);
+ }
+
+ @AutoValue
+ abstract static class DefineComponentMetadata {
+
+ /** Returns the component annotated with {@link dagger.hilt.DefineComponent}. */
+ abstract TypeElement component();
+
+ /** Returns the scopes of the component. */
+ abstract ImmutableList<TypeElement> scopes();
+
+ /** Returns the parent component, if one exists. */
+ abstract Optional<DefineComponentMetadata> parentMetadata();
+
+ boolean isRoot() {
+ return !parentMetadata().isPresent();
+ }
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/definecomponent/DefineComponentProcessor.java b/java/dagger/hilt/processor/internal/definecomponent/DefineComponentProcessor.java
new file mode 100644
index 0000000..e0bfca9
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/definecomponent/DefineComponentProcessor.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.definecomponent;
+
+import static net.ltgt.gradle.incap.IncrementalAnnotationProcessorType.ISOLATING;
+
+import com.google.auto.service.AutoService;
+import com.google.common.collect.ImmutableSet;
+import com.squareup.javapoet.AnnotationSpec;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.TypeSpec;
+import dagger.hilt.processor.internal.BaseProcessor;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.Processors;
+import dagger.hilt.processor.internal.definecomponent.DefineComponentBuilderMetadatas.DefineComponentBuilderMetadata;
+import dagger.hilt.processor.internal.definecomponent.DefineComponentMetadatas.DefineComponentMetadata;
+import java.io.IOException;
+import java.util.Set;
+import javax.annotation.processing.Processor;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import net.ltgt.gradle.incap.IncrementalAnnotationProcessor;
+
+/**
+ * A processor for {@link dagger.hilt.DefineComponent} and {@link
+ * dagger.hilt.DefineComponent.Builder}.
+ */
+@IncrementalAnnotationProcessor(ISOLATING)
+@AutoService(Processor.class)
+public final class DefineComponentProcessor extends BaseProcessor {
+ private final DefineComponentMetadatas componentMetadatas = DefineComponentMetadatas.create();
+ private final DefineComponentBuilderMetadatas componentBuilderMetadatas =
+ DefineComponentBuilderMetadatas.create(componentMetadatas);
+
+ @Override
+ public Set<String> getSupportedAnnotationTypes() {
+ return ImmutableSet.of(
+ ClassNames.DEFINE_COMPONENT.toString(), ClassNames.DEFINE_COMPONENT_BUILDER.toString());
+ }
+
+ @Override
+ protected void processEach(TypeElement annotation, Element element) throws Exception {
+ if (ClassName.get(annotation).equals(ClassNames.DEFINE_COMPONENT)) {
+ // TODO(bcorso): For cycles we currently process each element in the cycle. We should skip
+ // processing of subsequent elements in a cycle, but this requires ensuring that the first
+ // element processed is always the same so that our failure tests are stable.
+ DefineComponentMetadata metadata = componentMetadatas.get(element);
+ generateFile("component", metadata.component());
+ } else if (ClassName.get(annotation).equals(ClassNames.DEFINE_COMPONENT_BUILDER)) {
+ DefineComponentBuilderMetadata metadata = componentBuilderMetadatas.get(element);
+ generateFile("builder", metadata.builder());
+ } else {
+ throw new AssertionError("Unhandled annotation type: " + annotation);
+ }
+ }
+
+ private void generateFile(String member, TypeElement typeElement) throws IOException {
+ TypeSpec.Builder builder =
+ TypeSpec.interfaceBuilder(Processors.getFullEnclosedName(typeElement))
+ .addOriginatingElement(typeElement)
+ .addAnnotation(
+ AnnotationSpec.builder(ClassNames.DEFINE_COMPONENT_CLASSES)
+ .addMember(member, "$S", typeElement.getQualifiedName())
+ .build());
+
+ Processors.addGeneratedAnnotation(builder, processingEnv, getClass());
+
+ JavaFile.builder(DefineComponents.AGGREGATING_PACKAGE, builder.build())
+ .build()
+ .writeTo(processingEnv.getFiler());
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/definecomponent/DefineComponents.java b/java/dagger/hilt/processor/internal/definecomponent/DefineComponents.java
new file mode 100644
index 0000000..0b33011
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/definecomponent/DefineComponents.java
@@ -0,0 +1,225 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.definecomponent;
+
+import static com.google.auto.common.AnnotationMirrors.getAnnotationElementAndValue;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.value.AutoValue;
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ListMultimap;
+import com.squareup.javapoet.ClassName;
+import dagger.hilt.processor.internal.AnnotationValues;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.ComponentDescriptor;
+import dagger.hilt.processor.internal.ComponentTree;
+import dagger.hilt.processor.internal.ProcessorErrors;
+import dagger.hilt.processor.internal.Processors;
+import dagger.hilt.processor.internal.definecomponent.DefineComponentBuilderMetadatas.DefineComponentBuilderMetadata;
+import dagger.hilt.processor.internal.definecomponent.DefineComponentMetadatas.DefineComponentMetadata;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Optional;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.PackageElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.util.Elements;
+
+/**
+ * A utility class for getting {@link DefineComponentMetadata} and {@link
+ * DefineComponentBuilderMetadata}.
+ */
+public final class DefineComponents {
+ static final String AGGREGATING_PACKAGE =
+ DefineComponents.class.getPackage().getName() + ".codegen";
+
+ public static DefineComponents create() {
+ return new DefineComponents();
+ }
+
+ private final Map<Element, ComponentDescriptor> componentDescriptors = new HashMap<>();
+ private final DefineComponentMetadatas componentMetadatas = DefineComponentMetadatas.create();
+ private final DefineComponentBuilderMetadatas componentBuilderMetadatas =
+ DefineComponentBuilderMetadatas.create(componentMetadatas);
+
+ private DefineComponents() {}
+
+ /** Returns the {@link ComponentDescriptor} for the given component element. */
+ // TODO(b/144940889): This descriptor doesn't contain the "creator" or the "installInName".
+ public ComponentDescriptor componentDescriptor(Element element) {
+ if (!componentDescriptors.containsKey(element)) {
+ componentDescriptors.put(element, uncachedComponentDescriptor(element));
+ }
+ return componentDescriptors.get(element);
+ }
+
+ private ComponentDescriptor uncachedComponentDescriptor(Element element) {
+ DefineComponentMetadata metadata = componentMetadatas.get(element);
+ ComponentDescriptor.Builder builder =
+ ComponentDescriptor.builder()
+ .component(ClassName.get(metadata.component()))
+ .scopes(metadata.scopes().stream().map(ClassName::get).collect(toImmutableSet()));
+
+
+ metadata.parentMetadata()
+ .map(DefineComponentMetadata::component)
+ .map(this::componentDescriptor)
+ .ifPresent(builder::parent);
+
+ return builder.build();
+ }
+
+ /** Returns the {@link ComponentTree} from the aggregated {@link ComponentDescriptor}s. */
+ public ComponentTree getComponentTree(Elements elements) {
+ AggregatedMetadata aggregatedMetadata =
+ AggregatedMetadata.from(elements, componentMetadatas, componentBuilderMetadatas);
+ ListMultimap<DefineComponentMetadata, DefineComponentBuilderMetadata> builderMultimap =
+ ArrayListMultimap.create();
+ aggregatedMetadata.builders()
+ .forEach(builder -> builderMultimap.put(builder.componentMetadata(), builder));
+
+ // Check that there are not multiple builders per component
+ for (DefineComponentMetadata componentMetadata : builderMultimap.keySet()) {
+ TypeElement component = componentMetadata.component();
+ ProcessorErrors.checkState(
+ builderMultimap.get(componentMetadata).size() <= 1,
+ component,
+ "Multiple @%s declarations are not allowed for @%s type, %s. Found: %s",
+ ClassNames.DEFINE_COMPONENT_BUILDER,
+ ClassNames.DEFINE_COMPONENT,
+ component,
+ builderMultimap.get(componentMetadata).stream()
+ .map(DefineComponentBuilderMetadata::builder)
+ .map(TypeElement::toString)
+ .sorted()
+ .collect(toImmutableList()));
+ }
+
+ // Now that we know there is at most 1 builder per component, convert the Multimap to Map.
+ Map<DefineComponentMetadata, DefineComponentBuilderMetadata> builderMap = new LinkedHashMap<>();
+ builderMultimap.entries().forEach(e -> builderMap.put(e.getKey(), e.getValue()));
+
+
+ return ComponentTree.from(aggregatedMetadata.components().stream()
+ .map(componentMetadata -> toComponentDescriptor(componentMetadata, builderMap))
+ .collect(toImmutableSet()));
+ }
+
+ private static ComponentDescriptor toComponentDescriptor(
+ DefineComponentMetadata componentMetadata,
+ Map<DefineComponentMetadata, DefineComponentBuilderMetadata> builderMap) {
+ ComponentDescriptor.Builder builder =
+ ComponentDescriptor.builder()
+ .component(ClassName.get(componentMetadata.component()))
+ .scopes(
+ componentMetadata.scopes().stream().map(ClassName::get).collect(toImmutableSet()));
+
+
+ if (builderMap.containsKey(componentMetadata)) {
+ builder.creator(ClassName.get(builderMap.get(componentMetadata).builder()));
+ }
+
+ componentMetadata
+ .parentMetadata()
+ .map(parent -> toComponentDescriptor(parent, builderMap))
+ .ifPresent(builder::parent);
+
+ return builder.build();
+ }
+
+ @AutoValue
+ abstract static class AggregatedMetadata {
+ /** Returns the aggregated metadata for {@link DefineComponentClasses#component()}. */
+ abstract ImmutableList<DefineComponentMetadata> components();
+
+ /** Returns the aggregated metadata for {@link DefineComponentClasses#builder()}. */
+ abstract ImmutableList<DefineComponentBuilderMetadata> builders();
+
+ static AggregatedMetadata from(
+ Elements elements,
+ DefineComponentMetadatas componentMetadatas,
+ DefineComponentBuilderMetadatas componentBuilderMetadatas) {
+ PackageElement packageElement = elements.getPackageElement(AGGREGATING_PACKAGE);
+
+ if (packageElement == null) {
+ return new AutoValue_DefineComponents_AggregatedMetadata(
+ ImmutableList.of(), ImmutableList.of());
+ }
+
+ ImmutableList.Builder<DefineComponentMetadata> components = ImmutableList.builder();
+ ImmutableList.Builder<DefineComponentBuilderMetadata> builders = ImmutableList.builder();
+ for (Element element : packageElement.getEnclosedElements()) {
+ ProcessorErrors.checkState(
+ MoreElements.isType(element),
+ element,
+ "Only types may be in package %s. Did you add custom code in the package?",
+ packageElement);
+
+ TypeElement typeElement = MoreElements.asType(element);
+ ProcessorErrors.checkState(
+ Processors.hasAnnotation(typeElement, ClassNames.DEFINE_COMPONENT_CLASSES),
+ typeElement,
+ "Class, %s, must be annotated with @%s. Found: %s.",
+ typeElement,
+ ClassNames.DEFINE_COMPONENT_CLASSES.simpleName(),
+ typeElement.getAnnotationMirrors());
+
+ Optional<TypeElement> component = defineComponentClass(elements, typeElement, "component");
+ Optional<TypeElement> builder = defineComponentClass(elements, typeElement, "builder");
+ ProcessorErrors.checkState(
+ component.isPresent() || builder.isPresent(),
+ typeElement,
+ "@DefineComponentClasses missing both `component` and `builder` members.");
+
+ component.map(componentMetadatas::get).ifPresent(components::add);
+ builder.map(componentBuilderMetadatas::get).ifPresent(builders::add);
+ }
+
+ return new AutoValue_DefineComponents_AggregatedMetadata(
+ components.build(), builders.build());
+ }
+
+ private static Optional<TypeElement> defineComponentClass(
+ Elements elements, Element element, String annotationMember) {
+ AnnotationMirror mirror =
+ Processors.getAnnotationMirror(element, ClassNames.DEFINE_COMPONENT_CLASSES);
+ AnnotationValue value = getAnnotationElementAndValue(mirror, annotationMember).getValue();
+ String className = AnnotationValues.getString(value);
+
+ if (className.isEmpty()) { // The default value.
+ return Optional.empty();
+ }
+
+ TypeElement type = elements.getTypeElement(className);
+ ProcessorErrors.checkState(
+ type != null,
+ element,
+ "%s.%s(), has invalid value: `%s`.",
+ ClassNames.DEFINE_COMPONENT_CLASSES.simpleName(),
+ annotationMember,
+ className);
+
+ return Optional.of(type);
+ }
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/disableinstallincheck/BUILD b/java/dagger/hilt/processor/internal/disableinstallincheck/BUILD
new file mode 100644
index 0000000..e3865a6
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/disableinstallincheck/BUILD
@@ -0,0 +1,49 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# A processor for @dagger.hilt.AliasOfProcessor.
+
+package(default_visibility = ["//:src"])
+
+java_plugin(
+ name = "processor",
+ generates_api = 1,
+ processor_class = "dagger.hilt.processor.internal.disableinstallincheck.DisableInstallInCheckProcessor",
+ visibility = [
+ "//java/dagger/hilt/migration:__pkg__",
+ ],
+ deps = [":processor_lib"],
+)
+
+java_library(
+ name = "processor_lib",
+ srcs = [
+ "DisableInstallInCheckProcessor.java",
+ ],
+ deps = [
+ "//java/dagger/hilt/processor/internal:base_processor",
+ "//java/dagger/hilt/processor/internal:classnames",
+ "//java/dagger/hilt/processor/internal:processor_errors",
+ "//java/dagger/hilt/processor/internal:processors",
+ "//java/dagger/internal/guava:collect",
+ "@google_bazel_common//third_party/java/auto:service",
+ "@google_bazel_common//third_party/java/incap",
+ ],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/processor/internal/disableinstallincheck/DisableInstallInCheckProcessor.java b/java/dagger/hilt/processor/internal/disableinstallincheck/DisableInstallInCheckProcessor.java
new file mode 100644
index 0000000..c51f350
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/disableinstallincheck/DisableInstallInCheckProcessor.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.disableinstallincheck;
+
+import static net.ltgt.gradle.incap.IncrementalAnnotationProcessorType.ISOLATING;
+
+import com.google.auto.service.AutoService;
+import com.google.common.collect.ImmutableSet;
+import dagger.hilt.processor.internal.BaseProcessor;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.ProcessorErrors;
+import dagger.hilt.processor.internal.Processors;
+import javax.annotation.processing.Processor;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import net.ltgt.gradle.incap.IncrementalAnnotationProcessor;
+
+/** Processes the annotations annotated with {@link dagger.hilt.migration.DisableInstallInCheck} */
+@IncrementalAnnotationProcessor(ISOLATING)
+@AutoService(Processor.class)
+public final class DisableInstallInCheckProcessor extends BaseProcessor {
+ @Override
+ public ImmutableSet<String> getSupportedAnnotationTypes() {
+ return ImmutableSet.of(ClassNames.DISABLE_INSTALL_IN_CHECK.toString());
+ }
+
+ @Override
+ public void processEach(TypeElement annotation, Element element) {
+ ProcessorErrors.checkState(
+ Processors.hasAnnotation(element, ClassNames.MODULE),
+ element,
+ "@DisableInstallInCheck should only be used on modules. However, it was found annotating"
+ + " %s",
+ element);
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/generatesrootinput/BUILD b/java/dagger/hilt/processor/internal/generatesrootinput/BUILD
new file mode 100644
index 0000000..f24ffb7
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/generatesrootinput/BUILD
@@ -0,0 +1,65 @@
+# Copyright (C) 2019 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# A processor for @dagger.hilt.GeneratesRootInput.
+
+package(default_visibility = ["//:src"])
+
+java_plugin(
+ name = "processor",
+ generates_api = 1,
+ processor_class = "dagger.hilt.processor.internal.generatesrootinput.GeneratesRootInputProcessor",
+ deps = [":processor_lib"],
+)
+
+java_library(
+ name = "processor_lib",
+ srcs = [
+ "GeneratesRootInputProcessor.java",
+ "GeneratesRootInputPropagatedDataGenerator.java",
+ ],
+ deps = [
+ ":generates_root_inputs",
+ "//java/dagger/hilt/processor/internal:base_processor",
+ "//java/dagger/hilt/processor/internal:classnames",
+ "//java/dagger/hilt/processor/internal:processor_errors",
+ "//java/dagger/hilt/processor/internal:processors",
+ "//java/dagger/internal/guava:collect",
+ "@google_bazel_common//third_party/java/auto:service",
+ "@google_bazel_common//third_party/java/incap",
+ "@google_bazel_common//third_party/java/javapoet",
+ ],
+)
+
+java_library(
+ name = "generates_root_inputs",
+ srcs = [
+ "GeneratesRootInputs.java",
+ ],
+ deps = [
+ "//java/dagger/hilt/processor/internal:classnames",
+ "//java/dagger/hilt/processor/internal:processor_errors",
+ "//java/dagger/hilt/processor/internal:processors",
+ "//java/dagger/internal/codegen/extension",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "@google_bazel_common//third_party/java/javapoet",
+ ],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/processor/internal/generatesrootinput/GeneratesRootInputProcessor.java b/java/dagger/hilt/processor/internal/generatesrootinput/GeneratesRootInputProcessor.java
new file mode 100644
index 0000000..6588e09
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/generatesrootinput/GeneratesRootInputProcessor.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.generatesrootinput;
+
+import static net.ltgt.gradle.incap.IncrementalAnnotationProcessorType.ISOLATING;
+
+import com.google.auto.service.AutoService;
+import com.google.common.collect.ImmutableSet;
+import dagger.hilt.processor.internal.BaseProcessor;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.ProcessorErrors;
+import java.util.Set;
+import javax.annotation.processing.Processor;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.TypeElement;
+import net.ltgt.gradle.incap.IncrementalAnnotationProcessor;
+
+/**
+ * Processes the annotations annotated with {@link dagger.hilt.GeneratesRootInput} which generate
+ * input for components and should be processed before component creation.
+ */
+@IncrementalAnnotationProcessor(ISOLATING)
+@AutoService(Processor.class)
+public final class GeneratesRootInputProcessor extends BaseProcessor {
+
+ @Override
+ public Set<String> getSupportedAnnotationTypes() {
+ return ImmutableSet.of(ClassNames.GENERATES_ROOT_INPUT.toString());
+ }
+
+ @Override
+ public void processEach(TypeElement annotation, Element element) throws Exception {
+ ProcessorErrors.checkState(
+ element.getKind().equals(ElementKind.ANNOTATION_TYPE),
+ element,
+ "%s should only annotate other annotations. However, it was found annotating %s",
+ annotation,
+ element);
+
+ new GeneratesRootInputPropagatedDataGenerator(this.getProcessingEnv(), element).generate();
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/generatesrootinput/GeneratesRootInputPropagatedDataGenerator.java b/java/dagger/hilt/processor/internal/generatesrootinput/GeneratesRootInputPropagatedDataGenerator.java
new file mode 100644
index 0000000..5c53894
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/generatesrootinput/GeneratesRootInputPropagatedDataGenerator.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.generatesrootinput;
+
+import com.squareup.javapoet.AnnotationSpec;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.TypeSpec;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.Processors;
+import java.io.IOException;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.Element;
+
+/** Generates resource files for {@link GeneratesRootInputs}. */
+final class GeneratesRootInputPropagatedDataGenerator {
+ private final ProcessingEnvironment processingEnv;
+ private final Element element;
+
+ GeneratesRootInputPropagatedDataGenerator(ProcessingEnvironment processingEnv, Element element) {
+ this.processingEnv = processingEnv;
+ this.element = element;
+ }
+
+ void generate() throws IOException {
+ TypeSpec.Builder generator =
+ TypeSpec.classBuilder(Processors.getFullEnclosedName(element))
+ .addOriginatingElement(element)
+ .addAnnotation(
+ AnnotationSpec.builder(ClassNames.GENERATES_ROOT_INPUT_PROPAGATED_DATA)
+ .addMember("value", "$T.class", element)
+ .build())
+ .addJavadoc(
+ "Generated class to"
+ + "get the list of annotations that generate input for root.\n");
+
+ Processors.addGeneratedAnnotation(generator, processingEnv, getClass());
+
+ JavaFile.builder(GeneratesRootInputs.AGGREGATING_PACKAGE, generator.build())
+ .build()
+ .writeTo(processingEnv.getFiler());
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/generatesrootinput/GeneratesRootInputs.java b/java/dagger/hilt/processor/internal/generatesrootinput/GeneratesRootInputs.java
new file mode 100644
index 0000000..139592e
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/generatesrootinput/GeneratesRootInputs.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.generatesrootinput;
+
+import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.base.Suppliers.memoize;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.squareup.javapoet.ClassName;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.ProcessorErrors;
+import dagger.hilt.processor.internal.Processors;
+import java.util.List;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.annotation.processing.RoundEnvironment;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.PackageElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.util.Elements;
+
+/** Extracts the list of annotations annotated with {@link dagger.hilt.GeneratesRootInput}. */
+public final class GeneratesRootInputs {
+ static final String AGGREGATING_PACKAGE =
+ GeneratesRootInputs.class.getPackage().getName() + ".codegen";
+
+ private final Elements elements;
+ private final Supplier<ImmutableList<ClassName>> generatesRootInputAnnotations =
+ memoize(() -> getAnnotationList());
+
+ public GeneratesRootInputs(ProcessingEnvironment processingEnvironment) {
+ this.elements = processingEnvironment.getElementUtils();
+ }
+
+ public ImmutableSet<Element> getElementsToWaitFor(RoundEnvironment roundEnv) {
+ // Processing can only take place after all dependent annotations have been processed
+ // Note: We start with ClassName rather than TypeElement because jdk8 does not treat type
+ // elements as equal across rounds. Thus, in order for RoundEnvironment#getElementsAnnotatedWith
+ // to work properly, we get new elements to ensure it works across rounds (See b/148693284).
+ return generatesRootInputAnnotations.get().stream()
+ .map(className -> elements.getTypeElement(className.toString()))
+ .filter(element -> element != null)
+ .flatMap(annotation -> roundEnv.getElementsAnnotatedWith(annotation).stream())
+ .collect(toImmutableSet());
+ }
+
+ private ImmutableList<ClassName> getAnnotationList() {
+ PackageElement packageElement = elements.getPackageElement(AGGREGATING_PACKAGE);
+
+ if (packageElement == null) {
+ return ImmutableList.of();
+ }
+
+ List<? extends Element> annotationElements = packageElement.getEnclosedElements();
+ checkState(!annotationElements.isEmpty(), "No elements Found in package %s.", packageElement);
+
+ ImmutableList.Builder<ClassName> builder = ImmutableList.builder();
+ for (Element element : annotationElements) {
+ ProcessorErrors.checkState(
+ element.getKind() == ElementKind.CLASS,
+ element,
+ "Only classes may be in package %s. Did you add custom code in the package?",
+ packageElement);
+
+ AnnotationMirror annotationMirror =
+ Processors.getAnnotationMirror(element, ClassNames.GENERATES_ROOT_INPUT_PROPAGATED_DATA);
+ ProcessorErrors.checkState(
+ annotationMirror != null,
+ element,
+ "Classes in package %s must be annotated with @%s: %s."
+ + " Found: %s. Files in this package are generated, did you add custom code in the"
+ + " package? ",
+ packageElement,
+ ClassNames.GENERATES_ROOT_INPUT_PROPAGATED_DATA,
+ element.getSimpleName(),
+ element.getAnnotationMirrors());
+
+ TypeElement annotation =
+ Processors.getAnnotationClassValue(elements, annotationMirror, "value");
+
+ builder.add(ClassName.get(annotation));
+ }
+ // This annotation was on Dagger so it couldn't be annotated with @GeneratesRootInput to be
+ // cultivated later. We have to manually add it to the list.
+ builder.add(ClassNames.PRODUCTION_COMPONENT);
+ return builder.build();
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/originatingelement/BUILD b/java/dagger/hilt/processor/internal/originatingelement/BUILD
new file mode 100644
index 0000000..50dbcf6
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/originatingelement/BUILD
@@ -0,0 +1,47 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# A processor for @dagger.hilt.codegen.OriginatingElement.
+
+package(default_visibility = ["//:src"])
+
+java_plugin(
+ name = "processor",
+ generates_api = 1,
+ processor_class = "dagger.hilt.processor.internal.originatingelement.OriginatingElementProcessor",
+ deps = [":processor_lib"],
+)
+
+java_library(
+ name = "processor_lib",
+ srcs = [
+ "OriginatingElementProcessor.java",
+ ],
+ deps = [
+ "//java/dagger/hilt/processor/internal:base_processor",
+ "//java/dagger/hilt/processor/internal:classnames",
+ "//java/dagger/hilt/processor/internal:processor_errors",
+ "//java/dagger/hilt/processor/internal:processors",
+ "//java/dagger/internal/guava:collect",
+ "@google_bazel_common//third_party/java/auto:service",
+ "@google_bazel_common//third_party/java/incap",
+ "@maven//:com_google_auto_auto_common",
+ ],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/processor/internal/originatingelement/OriginatingElementProcessor.java b/java/dagger/hilt/processor/internal/originatingelement/OriginatingElementProcessor.java
new file mode 100644
index 0000000..723cf04
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/originatingelement/OriginatingElementProcessor.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.originatingelement;
+
+import static net.ltgt.gradle.incap.IncrementalAnnotationProcessorType.ISOLATING;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.service.AutoService;
+import com.google.common.collect.ImmutableSet;
+import dagger.hilt.processor.internal.BaseProcessor;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.ProcessorErrors;
+import dagger.hilt.processor.internal.Processors;
+import javax.annotation.processing.Processor;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import net.ltgt.gradle.incap.IncrementalAnnotationProcessor;
+
+/**
+ * Processes the annotations annotated with {@link dagger.hilt.codegen.OriginatingElement} to check
+ * that they're only used on top-level classes and the value passed is also a top-level class.
+ */
+@IncrementalAnnotationProcessor(ISOLATING)
+@AutoService(Processor.class)
+public final class OriginatingElementProcessor extends BaseProcessor {
+
+ @Override
+ public ImmutableSet<String> getSupportedAnnotationTypes() {
+ return ImmutableSet.of(ClassNames.ORIGINATING_ELEMENT.toString());
+ }
+
+ @Override
+ public void processEach(TypeElement annotation, Element element) throws Exception {
+ ProcessorErrors.checkState(
+ MoreElements.isType(element) && Processors.isTopLevel(element),
+ element,
+ "@%s should only be used to annotate top-level types, but found: %s",
+ annotation.getSimpleName(),
+ element);
+
+ TypeElement originatingElementValue =
+ Processors.getAnnotationClassValue(
+ getElementUtils(),
+ Processors.getAnnotationMirror(element, ClassNames.ORIGINATING_ELEMENT),
+ "topLevelClass");
+
+ // TODO(bcorso): ProcessorErrors should allow us to point to the annotation too.
+ ProcessorErrors.checkState(
+ Processors.isTopLevel(originatingElementValue),
+ element,
+ "@%s.topLevelClass value should be a top-level class, but found: %s",
+ annotation.getSimpleName(),
+ originatingElementValue);
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/root/BUILD b/java/dagger/hilt/processor/internal/root/BUILD
new file mode 100644
index 0000000..709eb7f
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/root/BUILD
@@ -0,0 +1,102 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Annotation processor for Hilt.
+
+package(default_visibility = ["//:src"])
+
+java_plugin(
+ name = "plugin",
+ generates_api = 1,
+ processor_class = "dagger.hilt.processor.internal.root.RootProcessor",
+ deps = [
+ ":processor_lib",
+ ],
+)
+
+java_library(
+ name = "processor_lib",
+ srcs = [
+ "RootFileFormatter.java",
+ "RootGenerator.java",
+ "RootProcessor.java",
+ "TestComponentDataGenerator.java",
+ "TestComponentDataSupplierGenerator.java",
+ "TestInjectorGenerator.java",
+ ],
+ deps = [
+ ":root_metadata",
+ ":root_type",
+ "//java/dagger/hilt/processor/internal:base_processor",
+ "//java/dagger/hilt/processor/internal:classnames",
+ "//java/dagger/hilt/processor/internal:component_descriptor",
+ "//java/dagger/hilt/processor/internal:component_names",
+ "//java/dagger/hilt/processor/internal:processor_errors",
+ "//java/dagger/hilt/processor/internal:processors",
+ "//java/dagger/hilt/processor/internal/aggregateddeps:component_dependencies",
+ "//java/dagger/hilt/processor/internal/definecomponent:define_components",
+ "//java/dagger/hilt/processor/internal/generatesrootinput:generates_root_inputs",
+ "//java/dagger/internal/codegen/extension",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/internal/guava:graph",
+ "@google_bazel_common//third_party/java/auto:service",
+ "@google_bazel_common//third_party/java/incap",
+ "@google_bazel_common//third_party/java/javapoet",
+ "@maven//:com_google_auto_auto_common",
+ ],
+)
+
+java_library(
+ name = "root_metadata",
+ srcs = [
+ "Root.java",
+ "RootMetadata.java",
+ "TestRootMetadata.java",
+ ],
+ deps = [
+ ":root_type",
+ "//java/dagger/hilt/processor/internal:classnames",
+ "//java/dagger/hilt/processor/internal:component_descriptor",
+ "//java/dagger/hilt/processor/internal:kotlin",
+ "//java/dagger/hilt/processor/internal:processor_errors",
+ "//java/dagger/hilt/processor/internal:processors",
+ "//java/dagger/hilt/processor/internal/aggregateddeps:component_dependencies",
+ "//java/dagger/hilt/processor/internal/aliasof:alias_ofs",
+ "//java/dagger/internal/codegen/extension",
+ "//java/dagger/internal/codegen/kotlin",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "@google_bazel_common//third_party/java/auto:value",
+ "@google_bazel_common//third_party/java/javapoet",
+ "@maven//:com_google_auto_auto_common",
+ ],
+)
+
+java_library(
+ name = "root_type",
+ srcs = ["RootType.java"],
+ deps = [
+ "//java/dagger/hilt/processor/internal:classnames",
+ "//java/dagger/hilt/processor/internal:processor_errors",
+ "//java/dagger/hilt/processor/internal:processors",
+ "@google_bazel_common//third_party/java/javapoet",
+ ],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/processor/internal/root/Root.java b/java/dagger/hilt/processor/internal/root/Root.java
new file mode 100644
index 0000000..981636d
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/root/Root.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.root;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.value.AutoValue;
+import com.squareup.javapoet.ClassName;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+
+/** Metadata for a root element that can trigger the {@link RootProcessor}. */
+@AutoValue
+abstract class Root {
+ /** Creates a {@plainlink Root root} for the given {@plainlink Element element}. */
+ static Root create(Element element, ProcessingEnvironment env) {
+ TypeElement rootElement = MoreElements.asType(element);
+ return new AutoValue_Root(RootType.of(env, rootElement), rootElement);
+ }
+
+ /** Returns the type of the root {@code element}. */
+ abstract RootType type();
+
+ /** Returns the root element that should be used with processing. */
+ abstract TypeElement element();
+
+ /** Returns the class name of the root element. */
+ ClassName classname() {
+ return ClassName.get(element());
+ }
+
+ @Override
+ public final String toString() {
+ return element().toString();
+ }
+
+ boolean isTestRoot() {
+ return type().isTestRoot();
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/root/RootFileFormatter.java b/java/dagger/hilt/processor/internal/root/RootFileFormatter.java
new file mode 100644
index 0000000..45cdd22
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/root/RootFileFormatter.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.root;
+
+import com.squareup.javapoet.JavaFile;
+import java.io.IOException;
+import java.io.Writer;
+import java.util.regex.MatchResult;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import javax.annotation.processing.Filer;
+import javax.lang.model.element.Element;
+import javax.tools.JavaFileObject;
+
+/**
+ * Typically we would just use {@code JavaFile#writeTo()} to write files. However, this formatter
+ * exists to add new lines inbetween interfaces. This can be important for classes with many
+ * interfaces (e.g. Dagger components) to avoid spamming the entire list of interfaces when
+ * reporting errors to the user.
+ *
+ * <p>See b/33108646.
+ */
+final class RootFileFormatter {
+ private static final Pattern CLASS_PATERN = Pattern.compile("(\\h*)(.*class.*implements)(.*\\{)");
+
+ /** Formats the {@link JavaFile} java source file. */
+ static void write(JavaFile javaFile, Filer filer) throws IOException {
+ String fileName =
+ javaFile.packageName.isEmpty()
+ ? javaFile.typeSpec.name
+ : javaFile.packageName + "." + javaFile.typeSpec.name;
+
+ Element[] originatingElements = javaFile.typeSpec.originatingElements.toArray(new Element[0]);
+
+ StringBuilder sb = new StringBuilder("");
+ javaFile.writeTo(sb);
+ String fileContent = formatInterfaces(sb.toString(), CLASS_PATERN);
+
+ JavaFileObject filerSourceFile = filer.createSourceFile(fileName, originatingElements);
+ try (Writer writer = filerSourceFile.openWriter()) {
+ writer.write(fileContent);
+ } catch (Exception e) {
+ try {
+ filerSourceFile.delete();
+ } catch (Exception ignored) {
+ // Nothing to do.
+ }
+ throw e;
+ }
+ }
+
+ private static String formatInterfaces(String content, Pattern pattern) {
+ Matcher matcher = pattern.matcher(content);
+ StringBuffer sb = new StringBuffer(content.length());
+ while (matcher.find()) {
+ MatchResult result = matcher.toMatchResult();
+ String spaces = result.group(1);
+ String prefix = result.group(2);
+ String interfaces = result.group(3);
+ String formattedInterfaces = formatInterfaces(spaces, interfaces);
+ matcher.appendReplacement(
+ sb, Matcher.quoteReplacement(spaces + prefix + formattedInterfaces));
+ }
+ matcher.appendTail(sb);
+ return sb.toString();
+ }
+
+ private static String formatInterfaces(String prefixSpaces, String interfaces) {
+ StringBuilder sb = new StringBuilder(interfaces);
+ String newLine = String.format("\n%s ", prefixSpaces);
+
+ // Add a line break after each interface so that there's only 1 interface per line.
+ int i = 0;
+ int bracketCount = 0;
+ while (i >= 0 && i < sb.length()) {
+ char c = sb.charAt(i++);
+ if (c == '<') {
+ bracketCount++;
+ } else if (c == '>') {
+ bracketCount--;
+ } else if (c == ',' && bracketCount == 0) {
+ sb.insert(i++, newLine);
+ }
+ }
+ return sb.toString();
+ }
+
+ private RootFileFormatter() {}
+}
diff --git a/java/dagger/hilt/processor/internal/root/RootGenerator.java b/java/dagger/hilt/processor/internal/root/RootGenerator.java
new file mode 100644
index 0000000..c2c55e6
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/root/RootGenerator.java
@@ -0,0 +1,219 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.root;
+
+import static dagger.hilt.processor.internal.Processors.toClassNames;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static javax.lang.model.element.Modifier.ABSTRACT;
+import static javax.lang.model.element.Modifier.PUBLIC;
+import static javax.lang.model.element.Modifier.STATIC;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.graph.GraphBuilder;
+import com.google.common.graph.Graphs;
+import com.google.common.graph.MutableGraph;
+import com.squareup.javapoet.AnnotationSpec;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.TypeSpec;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.ComponentDescriptor;
+import dagger.hilt.processor.internal.ComponentGenerator;
+import dagger.hilt.processor.internal.ComponentNames;
+import dagger.hilt.processor.internal.ComponentTree;
+import dagger.hilt.processor.internal.Processors;
+import java.io.IOException;
+import java.util.Optional;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.Modifier;
+
+/** Generates components and any other classes needed for a root. */
+final class RootGenerator {
+
+ static void generate(RootMetadata metadata, ProcessingEnvironment env) throws IOException {
+ new RootGenerator(
+ RootMetadata.copyWithNewTree(
+ metadata,
+ filterDescriptors(metadata.componentTree())),
+ env).generateComponents();
+ }
+
+ private final RootMetadata metadata;
+ private final ProcessingEnvironment env;
+ private final Root root;
+
+ private RootGenerator(RootMetadata metadata, ProcessingEnvironment env) {
+ this.metadata = metadata;
+ this.env = env;
+ this.root = metadata.root();
+ }
+
+ private void generateComponents() throws IOException {
+
+ // TODO(bcorso): Consider moving all of this logic into ComponentGenerator?
+ TypeSpec.Builder componentsWrapper =
+ TypeSpec.classBuilder(getComponentsWrapperClassName())
+ .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
+ .addMethod(MethodSpec.constructorBuilder().addModifiers(Modifier.PRIVATE).build());
+
+ Processors.addGeneratedAnnotation(componentsWrapper, env, ClassNames.ROOT_PROCESSOR.toString());
+
+ ImmutableMap<ComponentDescriptor, ClassName> subcomponentBuilderModules =
+ subcomponentBuilderModules(componentsWrapper);
+
+ ComponentTree componentTree = metadata.componentTree();
+ for (ComponentDescriptor componentDescriptor : componentTree.getComponentDescriptors()) {
+ ImmutableSet<ClassName> modules =
+ ImmutableSet.<ClassName>builder()
+ .addAll(toClassNames(metadata.modules(componentDescriptor.component())))
+ .addAll(
+ componentTree.childrenOf(componentDescriptor).stream()
+ .map(subcomponentBuilderModules::get)
+ .collect(toImmutableSet()))
+ .build();
+
+ componentsWrapper.addType(
+ new ComponentGenerator(
+ env,
+ getComponentClassName(componentDescriptor),
+ root.element(),
+ Optional.empty(),
+ modules,
+ metadata.entryPoints(componentDescriptor.component()),
+ metadata.scopes(componentDescriptor.component()),
+ ImmutableList.of(),
+ componentAnnotation(componentDescriptor),
+ componentBuilder(componentDescriptor))
+ .generate().toBuilder().addModifiers(Modifier.STATIC).build());
+ }
+
+ RootFileFormatter.write(
+ JavaFile.builder(root.classname().packageName(), componentsWrapper.build()).build(),
+ env.getFiler());
+ }
+
+ private static ComponentTree filterDescriptors(ComponentTree componentTree) {
+ MutableGraph<ComponentDescriptor> graph =
+ GraphBuilder.from(componentTree.graph()).build();
+
+ componentTree.graph().nodes().forEach(graph::addNode);
+ componentTree.graph().edges().forEach(graph::putEdge);
+
+ // Remove components that do not have builders (besides the root component) since if
+ // we didn't find any builder class, then we don't need to generate the component
+ // since it would be inaccessible.
+ componentTree.getComponentDescriptors().stream()
+ .filter(descriptor -> !descriptor.isRoot() && !descriptor.creator().isPresent())
+ .forEach(graph::removeNode);
+
+ // The graph may still have nodes that are children of components that don't have builders,
+ // so we need to find reachable nodes from the root and create a new graph to remove those.
+ // We reuse the root from the original tree since it should not have been removed.
+ return ComponentTree.from(Graphs.reachableNodes(graph, componentTree.root()));
+ }
+
+ private ImmutableMap<ComponentDescriptor, ClassName> subcomponentBuilderModules(
+ TypeSpec.Builder componentsWrapper) throws IOException {
+ ImmutableMap.Builder<ComponentDescriptor, ClassName> modules = ImmutableMap.builder();
+ for (ComponentDescriptor descriptor : metadata.componentTree().getComponentDescriptors()) {
+ // Root component builders don't have subcomponent builder modules
+ if (!descriptor.isRoot() && descriptor.creator().isPresent()) {
+ ClassName component = getComponentClassName(descriptor);
+ ClassName builder = descriptor.creator().get();
+ ClassName module = component.peerClass(component.simpleName() + "BuilderModule");
+ componentsWrapper.addType(subcomponentBuilderModule(component, builder, module));
+ modules.put(descriptor, module);
+ }
+ }
+ return modules.build();
+ }
+
+ // Generates:
+ // @Module(subcomponents = FooSubcomponent.class)
+ // interface FooSubcomponentBuilderModule {
+ // @Binds FooSubcomponentInterfaceBuilder bind(FooSubcomponent.Builder builder);
+ // }
+ private TypeSpec subcomponentBuilderModule(
+ ClassName componentName, ClassName builderName, ClassName moduleName) throws IOException {
+ TypeSpec.Builder subcomponentBuilderModule =
+ TypeSpec.interfaceBuilder(moduleName)
+ .addOriginatingElement(root.element())
+ .addModifiers(ABSTRACT)
+ .addAnnotation(
+ AnnotationSpec.builder(ClassNames.MODULE)
+ .addMember("subcomponents", "$T.class", componentName)
+ .build())
+ .addAnnotation(ClassNames.DISABLE_INSTALL_IN_CHECK)
+ .addMethod(
+ MethodSpec.methodBuilder("bind")
+ .addModifiers(ABSTRACT, PUBLIC)
+ .addAnnotation(ClassNames.BINDS)
+ .returns(builderName)
+ .addParameter(componentName.nestedClass("Builder"), "builder")
+ .build());
+
+ Processors.addGeneratedAnnotation(
+ subcomponentBuilderModule, env, ClassNames.ROOT_PROCESSOR.toString());
+
+ return subcomponentBuilderModule.build();
+ }
+
+ private Optional<TypeSpec> componentBuilder(ComponentDescriptor descriptor) {
+ return descriptor
+ .creator()
+ .map(
+ creator ->
+ TypeSpec.interfaceBuilder("Builder")
+ .addOriginatingElement(root.element())
+ .addModifiers(STATIC, ABSTRACT)
+ .addSuperinterface(creator)
+ .addAnnotation(componentBuilderAnnotation(descriptor))
+ .build());
+ }
+
+ private ClassName componentAnnotation(ComponentDescriptor componentDescriptor) {
+ if (!componentDescriptor.isRoot()
+ ) {
+ return ClassNames.SUBCOMPONENT;
+ } else {
+ return ClassNames.COMPONENT;
+ }
+ }
+
+ private ClassName componentBuilderAnnotation(ComponentDescriptor componentDescriptor) {
+ if (componentDescriptor.isRoot()) {
+ return ClassNames.COMPONENT_BUILDER;
+ } else {
+ return ClassNames.SUBCOMPONENT_BUILDER;
+ }
+ }
+
+ private ClassName getPartialRootModuleClassName() {
+ return getComponentsWrapperClassName().nestedClass("PartialRootModule");
+ }
+
+ private ClassName getComponentsWrapperClassName() {
+ return ComponentNames.generatedComponentsWrapper(root.classname());
+ }
+
+ private ClassName getComponentClassName(ComponentDescriptor componentDescriptor) {
+ return ComponentNames.generatedComponent(root.classname(), componentDescriptor.component());
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/root/RootMetadata.java b/java/dagger/hilt/processor/internal/root/RootMetadata.java
new file mode 100644
index 0000000..4c43f1d
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/root/RootMetadata.java
@@ -0,0 +1,243 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.root;
+
+import static com.google.common.base.Suppliers.memoize;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static javax.lang.model.element.Modifier.ABSTRACT;
+import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.STATIC;
+
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSetMultimap;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.TypeName;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.ComponentDescriptor;
+import dagger.hilt.processor.internal.ComponentTree;
+import dagger.hilt.processor.internal.KotlinMetadataUtils;
+import dagger.hilt.processor.internal.Processors;
+import dagger.hilt.processor.internal.aggregateddeps.ComponentDependencies;
+import dagger.hilt.processor.internal.aliasof.AliasOfs;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import java.util.List;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.util.ElementFilter;
+import javax.lang.model.util.Elements;
+import javax.tools.Diagnostic;
+
+/** Contains metadata about the given hilt root. */
+public final class RootMetadata {
+ private static final ClassName APPLICATION_CONTEXT_MODULE =
+ ClassName.get("dagger.hilt.android.internal.modules", "ApplicationContextModule");
+
+ static RootMetadata create(
+ Root root,
+ ComponentTree componentTree,
+ ComponentDependencies deps,
+ ProcessingEnvironment env) {
+ RootMetadata metadata = new RootMetadata(root, componentTree, deps, env);
+ metadata.validate();
+ return metadata;
+ }
+
+ static RootMetadata copyWithNewTree(
+ RootMetadata other,
+ ComponentTree componentTree) {
+ return create(other.root, componentTree, other.deps, other.env);
+ }
+
+ private final Root root;
+ private final ProcessingEnvironment env;
+ private final Elements elements;
+ private final ComponentTree componentTree;
+ private final ComponentDependencies deps;
+ private final Supplier<ImmutableSetMultimap<ClassName, ClassName>> scopesByComponent =
+ memoize(this::getScopesByComponentUncached);
+ private final Supplier<TestRootMetadata> testRootMetadata =
+ memoize(this::testRootMetadataUncached);
+
+ private RootMetadata(
+ Root root,
+ ComponentTree componentTree,
+ ComponentDependencies deps,
+ ProcessingEnvironment env) {
+ this.root = root;
+ this.env = env;
+ this.elements = env.getElementUtils();
+ this.componentTree = componentTree;
+ this.deps = deps;
+ }
+
+ public Root root() {
+ return root;
+ }
+
+ public ComponentTree componentTree() {
+ return componentTree;
+ }
+
+ public ComponentDependencies deps() {
+ return deps;
+ }
+
+ public ImmutableSet<TypeElement> modules(ClassName componentName) {
+ return deps.modules().get(componentName, root.classname(), root.isTestRoot());
+ }
+
+ public ImmutableSet<TypeName> entryPoints(ClassName componentName) {
+ return ImmutableSet.<TypeName>builder()
+ .addAll(getUserDefinedEntryPoints(componentName))
+ .add(componentName)
+ .build();
+ }
+
+ public ImmutableSet<ClassName> scopes(ClassName componentName) {
+ return scopesByComponent.get().get(componentName);
+ }
+
+ /**
+ * Returns all modules in the given component that do not have accessible default constructors.
+ * Note that a non-static module nested in an outer class is considered to have no default
+ * constructors, since an instance of the outer class is needed to construct the module. This also
+ * filters out framework modules directly referenced by the codegen, since those are already known
+ * about and are specifically handled in the codegen.
+ */
+ public ImmutableSet<TypeElement> modulesThatDaggerCannotConstruct(ClassName componentName) {
+ return modules(componentName).stream()
+ .filter(module -> !daggerCanConstruct(module))
+ .filter(module -> !APPLICATION_CONTEXT_MODULE.equals(ClassName.get(module)))
+ .collect(toImmutableSet());
+ }
+
+ public TestRootMetadata testRootMetadata() {
+ return testRootMetadata.get();
+ }
+
+ public boolean waitForBindValue() {
+ return false;
+ }
+
+ private TestRootMetadata testRootMetadataUncached() {
+ return TestRootMetadata.of(env, root().element());
+ }
+
+ /**
+ * Validates that the {@link RootType} annotation is compatible with its {@link TypeElement} and
+ * {@link ComponentDependencies}.
+ */
+ private void validate() {
+
+ // Only test modules in the application component can be missing default constructor
+ for (ComponentDescriptor componentDescriptor : componentTree.getComponentDescriptors()) {
+ ClassName componentName = componentDescriptor.component();
+ for (TypeElement extraModule : modulesThatDaggerCannotConstruct(componentName)) {
+ if (root.type().isTestRoot() && !componentName.equals(ClassNames.SINGLETON_COMPONENT)) {
+ env.getMessager()
+ .printMessage(
+ Diagnostic.Kind.ERROR,
+ "[Hilt] All test modules (unless installed in ApplicationComponent) must use "
+ + "static provision methods or have a visible, no-arg constructor. Found: "
+ + extraModule.getQualifiedName(),
+ root.element());
+ } else if (!root.type().isTestRoot()) {
+ env.getMessager()
+ .printMessage(
+ Diagnostic.Kind.ERROR,
+ "[Hilt] All modules must be static and use static provision methods or have a "
+ + "visible, no-arg constructor. Found: "
+ + extraModule.getQualifiedName(),
+ root.element());
+ }
+ }
+ }
+ }
+
+ private ImmutableSet<TypeName> getUserDefinedEntryPoints(ClassName componentName) {
+ ImmutableSet.Builder<TypeName> entryPointSet = ImmutableSet.builder();
+ entryPointSet.add(ClassNames.GENERATED_COMPONENT);
+ for (TypeElement element :
+ deps.entryPoints().get(componentName, root.classname(), root.isTestRoot())) {
+ entryPointSet.add(ClassName.get(element));
+ }
+ return entryPointSet.build();
+ }
+
+ private ImmutableSetMultimap<ClassName, ClassName> getScopesByComponentUncached() {
+ ImmutableSetMultimap.Builder<ClassName, ClassName> builder = ImmutableSetMultimap.builder();
+
+ ImmutableSet<ClassName> defineComponentScopes =
+ componentTree.getComponentDescriptors().stream()
+ .flatMap(descriptor -> descriptor.scopes().stream())
+ .collect(toImmutableSet());
+
+ AliasOfs aliasOfs = new AliasOfs(env, defineComponentScopes);
+
+ for (ComponentDescriptor componentDescriptor : componentTree.getComponentDescriptors()) {
+ for (ClassName scope : componentDescriptor.scopes()) {
+ builder.put(componentDescriptor.component(), scope);
+ builder.putAll(componentDescriptor.component(), aliasOfs.getAliasesFor(scope));
+ }
+ }
+
+ return builder.build();
+ }
+
+ private static boolean daggerCanConstruct(TypeElement type) {
+ KotlinMetadataUtil metadataUtil = KotlinMetadataUtils.getMetadataUtil();
+ boolean isKotlinObject =
+ metadataUtil.isObjectClass(type) || metadataUtil.isCompanionObjectClass(type);
+ if (isKotlinObject) {
+ // Treat Kotlin object modules as if Dagger can construct them (it technically can't, but it
+ // doesn't need to as it can use them since all their provision methods are static).
+ return true;
+ }
+
+ return !isInnerClass(type)
+ && !hasNonDaggerAbstractMethod(type)
+ && (hasOnlyStaticProvides(type) || hasVisibleEmptyConstructor(type));
+ }
+
+ private static boolean isInnerClass(TypeElement type) {
+ return type.getNestingKind().isNested() && !type.getModifiers().contains(STATIC);
+ }
+
+ private static boolean hasNonDaggerAbstractMethod(TypeElement type) {
+ // TODO(erichang): Actually this isn't really supported b/28989613
+ return ElementFilter.methodsIn(type.getEnclosedElements()).stream()
+ .filter(method -> method.getModifiers().contains(ABSTRACT))
+ .anyMatch(method -> !Processors.hasDaggerAbstractMethodAnnotation(method));
+ }
+
+ private static boolean hasOnlyStaticProvides(TypeElement type) {
+ // TODO(erichang): Check for @Produces too when we have a producers story
+ return ElementFilter.methodsIn(type.getEnclosedElements()).stream()
+ .filter(method -> Processors.hasAnnotation(method, ClassNames.PROVIDES))
+ .allMatch(method -> method.getModifiers().contains(STATIC));
+ }
+
+ private static boolean hasVisibleEmptyConstructor(TypeElement type) {
+ List<ExecutableElement> constructors = ElementFilter.constructorsIn(type.getEnclosedElements());
+ return constructors.isEmpty()
+ || constructors.stream()
+ .filter(constructor -> constructor.getParameters().isEmpty())
+ .anyMatch(constructor -> !constructor.getModifiers().contains(PRIVATE));
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/root/RootProcessor.java b/java/dagger/hilt/processor/internal/root/RootProcessor.java
new file mode 100644
index 0000000..8f8c948
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/root/RootProcessor.java
@@ -0,0 +1,181 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.root;
+
+import static com.google.common.base.Preconditions.checkState;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static javax.lang.model.element.Modifier.PUBLIC;
+import static net.ltgt.gradle.incap.IncrementalAnnotationProcessorType.AGGREGATING;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.service.AutoService;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.squareup.javapoet.ClassName;
+import dagger.hilt.processor.internal.BaseProcessor;
+import dagger.hilt.processor.internal.ComponentTree;
+import dagger.hilt.processor.internal.ProcessorErrors;
+import dagger.hilt.processor.internal.aggregateddeps.ComponentDependencies;
+import dagger.hilt.processor.internal.definecomponent.DefineComponents;
+import dagger.hilt.processor.internal.generatesrootinput.GeneratesRootInputs;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.annotation.processing.Processor;
+import javax.annotation.processing.RoundEnvironment;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import net.ltgt.gradle.incap.IncrementalAnnotationProcessor;
+
+/** Processor that outputs dagger components based on transitive build deps. */
+@IncrementalAnnotationProcessor(AGGREGATING)
+@AutoService(Processor.class)
+public final class RootProcessor extends BaseProcessor {
+ private final List<ClassName> rootNames = new ArrayList<>();
+ private final Set<ClassName> processed = new HashSet<>();
+ private boolean isTestEnv;
+ // TODO(bcorso): Consider using a Dagger component to create/scope these objects
+ private final DefineComponents defineComponents = DefineComponents.create();
+ private GeneratesRootInputs generatesRootInputs;
+
+ @Override
+ public synchronized void init(ProcessingEnvironment processingEnvironment) {
+ super.init(processingEnvironment);
+ generatesRootInputs = new GeneratesRootInputs(processingEnvironment);
+ }
+
+ @Override
+ public ImmutableSet<String> getSupportedAnnotationTypes() {
+ return ImmutableSet.<String>builder()
+ .addAll(
+ Arrays.stream(RootType.values())
+ .map(rootType -> rootType.className().toString())
+ .collect(toImmutableSet()))
+ .build();
+ }
+
+ @Override
+ public void processEach(TypeElement annotation, Element element) throws Exception {
+ TypeElement rootElement = MoreElements.asType(element);
+ boolean isTestRoot = RootType.of(getProcessingEnv(), rootElement).isTestRoot();
+ checkState(
+ rootNames.isEmpty() || isTestEnv == isTestRoot,
+ "Cannot mix test roots with non-test roots:"
+ + "\n\tNon-Test Roots: %s"
+ + "\n\tTest Roots: %s",
+ isTestRoot ? rootNames : rootElement,
+ isTestRoot ? rootElement : rootNames);
+ isTestEnv = isTestRoot;
+
+ rootNames.add(ClassName.get(rootElement));
+ if (isTestEnv) {
+ new TestInjectorGenerator(
+ getProcessingEnv(),
+ TestRootMetadata.of(getProcessingEnv(), rootElement)).generate();
+ } else {
+ ProcessorErrors.checkState(
+ rootNames.size() <= 1, element, "More than one root found: %s", rootNames);
+ }
+ }
+
+ @Override
+ public void postRoundProcess(RoundEnvironment roundEnv) throws Exception {
+ Set<Element> newElements = generatesRootInputs.getElementsToWaitFor(roundEnv);
+ if (!processed.isEmpty() ) {
+ checkState(
+ newElements.isEmpty(),
+ "Found extra modules after compilation: %s\n"
+ + "(If you are adding an annotation processor that generates root input for hilt, "
+ + "the annotation must be annotated with @dagger.hilt.GeneratesRootInput.\n)",
+ newElements);
+ }
+
+ if (!newElements.isEmpty()) {
+ // Skip further processing since there's new elements that generate root inputs in this round.
+ return;
+ }
+
+ ImmutableList<Root> rootsToProcess =
+ rootNames.stream()
+ .filter(rootName -> !processed.contains(rootName))
+ // We create a new root element each round to avoid the jdk8 bug where
+ // TypeElement.equals does not work for elements across processing rounds.
+ .map(rootName -> getElementUtils().getTypeElement(rootName.toString()))
+ .map(rootElement -> Root.create(rootElement, getProcessingEnv()))
+ .collect(toImmutableList());
+
+ if (rootsToProcess.isEmpty()) {
+ // Skip further processing since there's no roots that need processing.
+ return;
+ }
+
+ // TODO(bcorso): Currently, if there's an exception in any of the roots we stop processing
+ // all roots. We should consider if it's worth trying to continue processing for other
+ // roots. At the moment, I think it's rare that if one root failed the others would not.
+ try {
+ ComponentTree tree = defineComponents.getComponentTree(getElementUtils());
+ ComponentDependencies deps = ComponentDependencies.from(
+ tree.getComponentDescriptors(), getElementUtils());
+ ImmutableList<RootMetadata> rootMetadatas =
+ rootsToProcess.stream()
+ .map(root -> RootMetadata.create(root, tree, deps, getProcessingEnv()))
+ .collect(toImmutableList());
+
+ for (RootMetadata rootMetadata : rootMetadatas) {
+ setProcessingState(rootMetadata.root());
+ generateComponents(rootMetadata);
+ }
+
+ if (isTestEnv) {
+ generateTestComponentData(rootMetadatas);
+ }
+ } catch (Exception e) {
+ for (Root root : rootsToProcess) {
+ processed.add(root.classname());
+ }
+ throw e;
+ }
+ }
+
+ private void setProcessingState(Root root) {
+ processed.add(root.classname());
+ }
+
+ private void generateComponents(RootMetadata rootMetadata) throws IOException {
+ RootGenerator.generate(rootMetadata, getProcessingEnv());
+ }
+
+ private void generateTestComponentData(ImmutableList<RootMetadata> rootMetadatas)
+ throws IOException {
+ for (RootMetadata rootMetadata : rootMetadatas) {
+ // TODO(bcorso): Consider moving this check earlier into processEach.
+ TypeElement testElement = rootMetadata.testRootMetadata().testElement();
+ ProcessorErrors.checkState(
+ testElement.getModifiers().contains(PUBLIC),
+ testElement,
+ "Hilt tests must be public, but found: %s",
+ testElement);
+ new TestComponentDataGenerator(getProcessingEnv(), rootMetadata).generate();
+ }
+ new TestComponentDataSupplierGenerator(getProcessingEnv(), rootMetadatas).generate();
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/root/RootType.java b/java/dagger/hilt/processor/internal/root/RootType.java
new file mode 100644
index 0000000..3545231
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/root/RootType.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.root;
+
+import com.squareup.javapoet.ClassName;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.Processors;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.TypeElement;
+
+/** The valid root types for Hilt applications. */
+// TODO(erichang): Fix this class so we don't have to have placeholders
+ enum RootType {
+ ROOT(ClassNames.HILT_ANDROID_APP),
+
+ // Placeholder to make sure @HiltAndroidTest usages get processed
+ HILT_ANDROID_TEST_ROOT(ClassNames.HILT_ANDROID_TEST),
+
+ TEST_ROOT(ClassNames.INTERNAL_TEST_ROOT);
+
+ @SuppressWarnings("ImmutableEnumChecker")
+ private final ClassName annotation;
+
+ RootType(ClassName annotation) {
+ this.annotation = annotation;
+ }
+
+ public boolean isTestRoot() {
+ return this == TEST_ROOT;
+ }
+
+ public ClassName className() {
+ return annotation;
+ }
+
+ public static RootType of(ProcessingEnvironment env, TypeElement element) {
+ if (Processors.hasAnnotation(element, ClassNames.HILT_ANDROID_APP)) {
+ return ROOT;
+ } else if (Processors.hasAnnotation(element, ClassNames.HILT_ANDROID_TEST)) {
+ return TEST_ROOT;
+ } else if (Processors.hasAnnotation(element, ClassNames.INTERNAL_TEST_ROOT)) {
+ return TEST_ROOT;
+ }
+ throw new IllegalStateException("Unknown root type: " + element);
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/root/TestComponentDataGenerator.java b/java/dagger/hilt/processor/internal/root/TestComponentDataGenerator.java
new file mode 100644
index 0000000..284f8cd
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/root/TestComponentDataGenerator.java
@@ -0,0 +1,216 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.root;
+
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static java.util.stream.Collectors.joining;
+import static javax.lang.model.element.Modifier.FINAL;
+import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.PUBLIC;
+import static javax.lang.model.element.Modifier.STATIC;
+import static javax.lang.model.util.ElementFilter.constructorsIn;
+
+import com.google.common.collect.ImmutableSet;
+import com.squareup.javapoet.AnnotationSpec;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.TypeSpec;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.ComponentNames;
+import dagger.hilt.processor.internal.Processors;
+import java.io.IOException;
+import java.util.List;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+
+/** Generates an implementation of {@link dagger.hilt.android.internal.TestComponentData}. */
+public final class TestComponentDataGenerator {
+ private final ProcessingEnvironment processingEnv;
+ private final RootMetadata rootMetadata;
+ private final ClassName name;
+
+ public TestComponentDataGenerator(
+ ProcessingEnvironment processingEnv,
+ RootMetadata rootMetadata) {
+ this.processingEnv = processingEnv;
+ this.rootMetadata = rootMetadata;
+ this.name =
+ Processors.append(
+ Processors.getEnclosedClassName(rootMetadata.testRootMetadata().testName()),
+ "_ComponentDataHolder");
+ }
+
+ /**
+ *
+ *
+ * <pre><code>{@code
+ * public final class FooTest_ComponentDataHolder {
+ * public static TestComponentData get() {
+ * return new TestComponentData(
+ * false, // waitForBindValue
+ * testInstance -> injectInternal(($1T) testInstance),
+ * Arrays.asList(FooTest.TestModule.class, ...),
+ * modules ->
+ * DaggerFooTest_ApplicationComponent.builder()
+ * .applicationContextModule(
+ * new ApplicationContextModule(ApplicationProvider.getApplicationContext()))
+ * .testModule((FooTest.TestModule) modules.get(FooTest.TestModule.class))
+ * .testModule(modules.containsKey(FooTest.TestModule.class)
+ * ? (FooTest.TestModule) modules.get(FooTest.TestModule.class)
+ * : ((TestInstace) testInstance).new TestModule())
+ * .build());
+ * }
+ * }
+ * }</code></pre>
+ */
+ public void generate() throws IOException {
+ TypeSpec.Builder generator =
+ TypeSpec.classBuilder(name)
+ .addModifiers(PUBLIC, FINAL)
+ .addMethod(MethodSpec.constructorBuilder().addModifiers(PRIVATE).build())
+ .addMethod(getMethod())
+ .addMethod(getTestInjectInternalMethod());
+
+ Processors.addGeneratedAnnotation(
+ generator, processingEnv, ClassNames.ROOT_PROCESSOR.toString());
+
+ JavaFile.builder(rootMetadata.testRootMetadata().testName().packageName(), generator.build())
+ .build()
+ .writeTo(processingEnv.getFiler());
+ }
+
+ private MethodSpec getMethod() {
+ TypeElement testElement = rootMetadata.testRootMetadata().testElement();
+ ClassName component =
+ ComponentNames.generatedComponent(
+ ClassName.get(testElement), ClassNames.SINGLETON_COMPONENT);
+ ImmutableSet<TypeElement> daggerRequiredModules =
+ rootMetadata.modulesThatDaggerCannotConstruct(ClassNames.SINGLETON_COMPONENT);
+ ImmutableSet<TypeElement> hiltRequiredModules =
+ daggerRequiredModules.stream()
+ .filter(module -> !canBeConstructedByHilt(module, testElement))
+ .collect(toImmutableSet());
+
+ return MethodSpec.methodBuilder("get")
+ .addModifiers(PUBLIC, STATIC)
+ .returns(ClassNames.TEST_COMPONENT_DATA)
+ .addStatement(
+ "return new $T($L, $L, $L, $L, $L)",
+ ClassNames.TEST_COMPONENT_DATA,
+ rootMetadata.waitForBindValue(),
+ CodeBlock.of("testInstance -> injectInternal(($1T) testInstance)", testElement),
+ getElementsListed(daggerRequiredModules),
+ getElementsListed(hiltRequiredModules),
+ CodeBlock.of(
+ "(modules, testInstance, autoAddModuleEnabled) -> $T.builder()\n"
+ + ".applicationContextModule(new $T($T.getApplicationContext()))\n"
+ + "$L"
+ + ".build()",
+ Processors.prepend(Processors.getEnclosedClassName(component), "Dagger"),
+ ClassNames.APPLICATION_CONTEXT_MODULE,
+ ClassNames.APPLICATION_PROVIDER,
+ daggerRequiredModules.stream()
+ .map(module -> getAddModuleStatement(module, testElement))
+ .collect(joining("\n"))))
+ .build();
+ }
+
+ /**
+ *
+ *
+ * <pre><code>
+ * .testModule(modules.get(FooTest.TestModule.class))
+ * </code></pre>
+ *
+ * <pre><code>
+ * .testModule(autoAddModuleEnabled
+ * ? ((FooTest) testInstance).new TestModule()
+ * : (FooTest.TestModule) modules.get(FooTest.TestModule.class))
+ * </code></pre>
+ */
+ private static String getAddModuleStatement(TypeElement module, TypeElement testElement) {
+ ClassName className = ClassName.get(module);
+ return canBeConstructedByHilt(module, testElement)
+ ? CodeBlock.of(
+ ".$1L(autoAddModuleEnabled\n"
+ // testInstance can never be null if we reach here, because this flag can be
+ // turned on only when testInstance is not null
+ + " ? (($3T) testInstance).new $4L()\n"
+ + " : ($2T) modules.get($2T.class))",
+ Processors.upperToLowerCamel(className.simpleName()),
+ className,
+ className.enclosingClassName(),
+ className.simpleName())
+ .toString()
+ : CodeBlock.of(
+ ".$1L(($2T) modules.get($2T.class))",
+ Processors.upperToLowerCamel(className.simpleName()),
+ className)
+ .toString();
+ }
+
+ private static boolean canBeConstructedByHilt(TypeElement module, TypeElement testElement) {
+ return hasOnlyAccessibleNoArgConstructor(module)
+ && module.getEnclosingElement().equals(testElement);
+ }
+
+ private static boolean hasOnlyAccessibleNoArgConstructor(TypeElement module) {
+ List<ExecutableElement> declaredConstructors = constructorsIn(module.getEnclosedElements());
+ return declaredConstructors.isEmpty()
+ || (declaredConstructors.size() == 1
+ && !declaredConstructors.get(0).getModifiers().contains(PRIVATE)
+ && declaredConstructors.get(0).getParameters().isEmpty());
+ }
+
+ /* Arrays.asList(FooTest.TestModule.class, ...) */
+ private static CodeBlock getElementsListed(ImmutableSet<TypeElement> modules) {
+ return modules.isEmpty()
+ ? CodeBlock.of("$T.emptySet()", ClassNames.COLLECTIONS)
+ : CodeBlock.of(
+ "new $T<>($T.asList($L))",
+ ClassNames.HASH_SET,
+ ClassNames.ARRAYS,
+ modules.stream()
+ .map(module -> CodeBlock.of("$T.class", module).toString())
+ .collect(joining(",")));
+ }
+
+ private MethodSpec getTestInjectInternalMethod() {
+ TypeElement testElement = rootMetadata.testRootMetadata().testElement();
+ ClassName testName = ClassName.get(testElement);
+ return MethodSpec.methodBuilder("injectInternal")
+ .addModifiers(PRIVATE, STATIC)
+ .addParameter(testName, "testInstance")
+ .addAnnotation(
+ AnnotationSpec.builder(SuppressWarnings.class)
+ .addMember("value", "$S", "unchecked")
+ .build())
+ .addStatement("$L.injectTest(testInstance)", getInjector(testElement))
+ .build();
+ }
+
+ private static CodeBlock getInjector(TypeElement testElement) {
+ return CodeBlock.of(
+ "(($T) (($T) $T.getApplicationContext()).generatedComponent())",
+ ClassNames.TEST_INJECTOR,
+ ClassNames.GENERATED_COMPONENT_MANAGER,
+ ClassNames.APPLICATION_PROVIDER);
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/root/TestComponentDataSupplierGenerator.java b/java/dagger/hilt/processor/internal/root/TestComponentDataSupplierGenerator.java
new file mode 100644
index 0000000..e5a83b6
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/root/TestComponentDataSupplierGenerator.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.root;
+
+import static javax.lang.model.element.Modifier.FINAL;
+import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.PROTECTED;
+import static javax.lang.model.element.Modifier.PUBLIC;
+
+import com.google.common.collect.ImmutableList;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterizedTypeName;
+import com.squareup.javapoet.TypeName;
+import com.squareup.javapoet.TypeSpec;
+import com.squareup.javapoet.WildcardTypeName;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.Processors;
+import java.io.IOException;
+import javax.annotation.processing.ProcessingEnvironment;
+
+/** Generates an implementation of {@link dagger.hilt.android.internal.TestComponentDataSupplier} */
+public final class TestComponentDataSupplierGenerator {
+ private static final ClassName TEST_COMPONENT_DATA_SUPPLIER_IMPL =
+ ClassName.get("dagger.hilt.android.internal.testing", "TestComponentDataSupplierImpl");
+ private static final ParameterizedTypeName CLASS_TYPE =
+ ParameterizedTypeName.get(ClassNames.CLASS, WildcardTypeName.subtypeOf(TypeName.OBJECT));
+ private static final ParameterizedTypeName TEST_COMPONENT_DATA_MAP_TYPE =
+ ParameterizedTypeName.get(ClassNames.MAP, CLASS_TYPE, ClassNames.TEST_COMPONENT_DATA);
+
+ private final ProcessingEnvironment processingEnv;
+ private final ImmutableList<RootMetadata> rootMetadatas;
+
+ public TestComponentDataSupplierGenerator(
+ ProcessingEnvironment processingEnv,
+ ImmutableList<RootMetadata> rootMetadatas) {
+ this.processingEnv = processingEnv;
+ this.rootMetadatas = rootMetadatas;
+ }
+
+ /**
+ * <pre><code>{@code
+ * public final class TestComponentDataSupplierImpl extends TestComponentDataSupplier {
+ * private final Map<Class<?>, TestComponentData> testComponentDataMap = new HashMap<>();
+ *
+ * protected TestComponentDataSupplierImpl() {
+ * testComponentDataMap.put(FooTest.class, new FooTest_ComponentData());
+ * testComponentDataMap.put(BarTest.class, new BarTest_ComponentData());
+ * ...
+ * }
+ *
+ * @Override
+ * protected Map<Class<?>, TestComponentData> get() {
+ * return testComponentDataMap;
+ * }
+ * }
+ * }</code></pre>
+ */
+ public void generate() throws IOException {
+ TypeSpec.Builder generator =
+ TypeSpec.classBuilder(TEST_COMPONENT_DATA_SUPPLIER_IMPL)
+ .addModifiers(PUBLIC, FINAL)
+ .superclass(ClassNames.TEST_COMPONENT_DATA_SUPPLIER)
+ .addField(
+ FieldSpec.builder(
+ TEST_COMPONENT_DATA_MAP_TYPE, "testComponentDataMap", PRIVATE, FINAL)
+ .initializer("new $T<>($L)", ClassNames.HASH_MAP, rootMetadatas.size())
+ .build())
+ .addMethod(constructor())
+ .addMethod(getMethod());
+
+ Processors.addGeneratedAnnotation(
+ generator, processingEnv, ClassNames.ROOT_PROCESSOR.toString());
+
+ JavaFile.builder(TEST_COMPONENT_DATA_SUPPLIER_IMPL.packageName(), generator.build())
+ .build()
+ .writeTo(processingEnv.getFiler());
+ }
+
+
+ private MethodSpec constructor() {
+ MethodSpec.Builder constructor = MethodSpec.constructorBuilder();
+ for (RootMetadata rootMetadata : rootMetadatas) {
+ ClassName testName = rootMetadata.testRootMetadata().testName();
+ ClassName testComponentDataHolderName =
+ Processors.append(Processors.getEnclosedClassName(testName), "_ComponentDataHolder");
+ constructor.addStatement(
+ "testComponentDataMap.put($T.class, $T.get())",
+ testName,
+ testComponentDataHolderName);
+ }
+ return constructor.build();
+ }
+
+ private MethodSpec getMethod() {
+ return MethodSpec.methodBuilder("get")
+ .addAnnotation(Override.class)
+ .addModifiers(PROTECTED)
+ .returns(TEST_COMPONENT_DATA_MAP_TYPE)
+ .addStatement("return testComponentDataMap")
+ .build();
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/root/TestInjectorGenerator.java b/java/dagger/hilt/processor/internal/root/TestInjectorGenerator.java
new file mode 100644
index 0000000..fc97fed
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/root/TestInjectorGenerator.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.root;
+
+import com.squareup.javapoet.AnnotationSpec;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterizedTypeName;
+import com.squareup.javapoet.TypeSpec;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.Processors;
+import java.io.IOException;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.TypeElement;
+
+/** Generates an entry point for a test. */
+public final class TestInjectorGenerator {
+ private final ProcessingEnvironment env;
+ private final TestRootMetadata metadata;
+
+ TestInjectorGenerator(ProcessingEnvironment env, TestRootMetadata metadata) {
+ this.env = env;
+ this.metadata = metadata;
+ }
+
+ // @GeneratedEntryPoint
+ // @InstallIn(SingletonComponent.class)
+ // public interface FooTest_GeneratedInjector extends TestInjector<FooTest> {}
+ public void generate() throws IOException {
+ TypeSpec.Builder builder =
+ TypeSpec.interfaceBuilder(metadata.testInjectorName())
+ .addOriginatingElement(metadata.testElement())
+ .addAnnotation(Processors.getOriginatingElementAnnotation(metadata.testElement()))
+ .addAnnotation(ClassNames.GENERATED_ENTRY_POINT)
+ .addAnnotation(
+ AnnotationSpec.builder(ClassNames.INSTALL_IN)
+ .addMember("value", "$T.class", installInComponent(metadata.testElement()))
+ .build())
+ .addModifiers(Modifier.PUBLIC)
+ .addSuperinterface(
+ ParameterizedTypeName.get(ClassNames.TEST_INJECTOR, metadata.testName()))
+ .addMethod(
+ MethodSpec.methodBuilder("injectTest")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
+ .addParameter(
+ metadata.testName(),
+ Processors.upperToLowerCamel(metadata.testName().simpleName()))
+ .build());
+
+ Processors.addGeneratedAnnotation(builder, env, getClass());
+
+ JavaFile.builder(metadata.testInjectorName().packageName(), builder.build())
+ .build()
+ .writeTo(env.getFiler());
+ }
+
+ private static ClassName installInComponent(TypeElement testElement) {
+ return ClassNames.SINGLETON_COMPONENT;
+ }
+}
diff --git a/java/dagger/hilt/processor/internal/root/TestRootMetadata.java b/java/dagger/hilt/processor/internal/root/TestRootMetadata.java
new file mode 100644
index 0000000..561beb7
--- /dev/null
+++ b/java/dagger/hilt/processor/internal/root/TestRootMetadata.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.root;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.value.AutoValue;
+import com.squareup.javapoet.ClassName;
+import dagger.hilt.processor.internal.ClassNames;
+import dagger.hilt.processor.internal.ProcessorErrors;
+import dagger.hilt.processor.internal.Processors;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+
+/** Metadata class for {@code InternalTestRoot} annotated classes. */
+@AutoValue
+abstract class TestRootMetadata {
+
+ /** Returns the {@link TypeElement} for the test class. */
+ abstract TypeElement testElement();
+
+ /** Returns the {@link TypeElement} for the base application. */
+ abstract TypeElement baseElement();
+
+ /** Returns the {@link ClassName} for the test class. */
+ ClassName testName() {
+ return ClassName.get(testElement());
+ }
+
+ /** Returns the {@link ClassName} for the base application. */
+ ClassName baseAppName() {
+ return ClassName.get(baseElement());
+ }
+
+ /** The name of the generated Hilt test application class for the given test name. */
+ ClassName appName() {
+ return Processors.append(Processors.getEnclosedClassName(testName()), "_Application");
+ }
+
+ /** The name of the generated Hilt test application class for the given test name. */
+ ClassName testInjectorName() {
+ return Processors.append(Processors.getEnclosedClassName(testName()), "_GeneratedInjector");
+ }
+
+ static TestRootMetadata of(ProcessingEnvironment env, Element element) {
+
+ TypeElement testElement = MoreElements.asType(element);
+
+ TypeElement baseElement =
+ env.getElementUtils().getTypeElement(ClassNames.MULTI_DEX_APPLICATION.toString());
+ ProcessorErrors.checkState(
+ !Processors.hasAnnotation(element, ClassNames.ANDROID_ENTRY_POINT),
+ element,
+ "Tests cannot be annotated with @AndroidEntryPoint. Please use @HiltAndroidTest");
+
+ ProcessorErrors.checkState(
+ Processors.hasAnnotation(element, ClassNames.HILT_ANDROID_TEST),
+ element,
+ "Tests must be annotated with @HiltAndroidTest");
+
+ return new AutoValue_TestRootMetadata(testElement, baseElement);
+ }
+}
diff --git a/java/dagger/hilt/testing/BUILD b/java/dagger/hilt/testing/BUILD
new file mode 100644
index 0000000..3ea1c5f
--- /dev/null
+++ b/java/dagger/hilt/testing/BUILD
@@ -0,0 +1,47 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Description:
+# Testing libraries for Hilt.
+
+package(default_visibility = ["//:src"])
+
+java_library(
+ name = "package_info",
+ srcs = ["package-info.java"],
+ deps = [
+ "@google_bazel_common//third_party/java/jsr305_annotations",
+ ],
+)
+
+java_library(
+ name = "test_install_in",
+ testonly = 1,
+ srcs = ["TestInstallIn.java"],
+ exported_plugins = [
+ "//java/dagger/hilt/processor/internal/aggregateddeps:plugin",
+ ],
+ exports = [
+ "//java/dagger/hilt/processor/internal/aggregateddeps:annotation",
+ ],
+ deps = [
+ ":package_info",
+ "//java/dagger/hilt:generates_root_input",
+ ],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/java/dagger/hilt/testing/TestInstallIn.java b/java/dagger/hilt/testing/TestInstallIn.java
new file mode 100644
index 0000000..dfe1389
--- /dev/null
+++ b/java/dagger/hilt/testing/TestInstallIn.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.testing;
+
+import static java.lang.annotation.RetentionPolicy.CLASS;
+
+import dagger.hilt.GeneratesRootInput;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+/**
+ * An annotation that replaces one or more {@link dagger.hilt.InstallIn} modules with the annotated
+ * module in tests.
+ *
+ * <p>The annotated class must also be annotated with {@link dagger.Module}.
+ *
+ * <p>Example:
+ *
+ * <pre><code>
+ * // Replaces FooModule with FakeFooModule, and installs it into the same component as FooModule.
+ * {@literal @}Module
+ * {@literal @}TestInstallIn(components = SingletonComponent.class, replaces = FooModule.class)
+ * public final class FakeFooModule {
+ * {@literal @}Provides
+ * static Foo provideFoo() {
+ * return new FakeFoo();
+ * }
+ * }
+ * </code></pre>
+ *
+ * @see <a href="https://dagger.dev/hilt/modules">Hilt Modules</a>
+ */
+@Retention(CLASS)
+@Target({ElementType.TYPE})
+@GeneratesRootInput
+public @interface TestInstallIn {
+ /** Returns the component(s) into which the annotated module will be installed. */
+ Class<?>[] components();
+
+ /** Returns the {@link InstallIn} module(s) that the annotated class will replace in tests. */
+ Class<?>[] replaces();
+}
diff --git a/java/dagger/hilt/testing/package-info.java b/java/dagger/hilt/testing/package-info.java
new file mode 100644
index 0000000..5837343
--- /dev/null
+++ b/java/dagger/hilt/testing/package-info.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * This package contains APIs for writing tests with Hilt.
+ *
+ * @see <a href="https://dagger.dev/hilt/testing">Hilt Testing</a>
+ */
+@ParametersAreNonnullByDefault
+package dagger.hilt.testing;
+
+import javax.annotation.ParametersAreNonnullByDefault;
diff --git a/java/dagger/internal/ConfigureInitializationParameters.java b/java/dagger/internal/ConfigureInitializationParameters.java
deleted file mode 100644
index 1ca0fbb..0000000
--- a/java/dagger/internal/ConfigureInitializationParameters.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright (C) 2019 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal;
-
-import static java.lang.annotation.ElementType.METHOD;
-
-import java.lang.annotation.Target;
-
-/**
- * Annotates a {@code configureInitialization()} method with {@code ComponentRequirement}s that it
- * accepts as parameters.
- */
-@Target(METHOD)
-public @interface ConfigureInitializationParameters {
- /**
- * The list of parameters.
- *
- * Each value is a {@link dagger.internal.codegen.serialization.ComponentRequirementProto}
- * serialized in Base64.
- */
- String[] value() default {};
-}
diff --git a/java/dagger/internal/GenerationOptions.java b/java/dagger/internal/GenerationOptions.java
deleted file mode 100644
index 996cd1d..0000000
--- a/java/dagger/internal/GenerationOptions.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Target;
-
-/**
- * Metadata annotation for base subcomponent implementations in ahead-of-time compilations. This
- * propagates any compiler options related to code generation so that later compilations can
- * recreate the model of the generated code of superclass implementations.
- */
-@Target(ElementType.TYPE)
-public @interface GenerationOptions {
- boolean fastInit();
-}
diff --git a/java/dagger/internal/InjectedFieldSignature.java b/java/dagger/internal/InjectedFieldSignature.java
new file mode 100644
index 0000000..55d3285
--- /dev/null
+++ b/java/dagger/internal/InjectedFieldSignature.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Marks a {@link dagger.MembersInjector} method for injecting a field with the signature of the
+ * field intended to inject.
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target(ElementType.METHOD)
+public @interface InjectedFieldSignature {
+ String value();
+}
diff --git a/java/dagger/internal/MapBuilder.java b/java/dagger/internal/MapBuilder.java
index 25e2b5b..12824d1 100644
--- a/java/dagger/internal/MapBuilder.java
+++ b/java/dagger/internal/MapBuilder.java
@@ -50,11 +50,9 @@
}
public Map<K, V> build() {
- switch (contributions.size()) {
- case 0:
- return Collections.emptyMap();
- default:
- return Collections.unmodifiableMap(contributions);
+ if (contributions.isEmpty()) {
+ return Collections.emptyMap();
}
+ return Collections.unmodifiableMap(contributions);
}
}
diff --git a/java/dagger/internal/MapFactory.java b/java/dagger/internal/MapFactory.java
index 8eb0783..39748c9 100644
--- a/java/dagger/internal/MapFactory.java
+++ b/java/dagger/internal/MapFactory.java
@@ -66,11 +66,13 @@
super(size);
}
+ @Override
public Builder<K, V> put(K key, Provider<V> providerOfValue) {
super.put(key, providerOfValue);
return this;
}
+ @Override
public Builder<K, V> putAll(Provider<Map<K, V>> mapFactory) {
super.putAll(mapFactory);
return this;
diff --git a/java/dagger/internal/MissingBindingFactory.java b/java/dagger/internal/MissingBindingFactory.java
deleted file mode 100644
index 993d150..0000000
--- a/java/dagger/internal/MissingBindingFactory.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal;
-
-/**
- * A {@link Factory} that always throws on calls to {@link Factory#get()}. This is necessary in
- * ahead-of-time subcomponents mode, where modifiable binding methods need to return a {@code
- * Provider<T>} to a framework instance initialization that is pruned and no longer in the binding
- * graph, but was present in a superclass implementation. This class fulfills that requirement but
- * is still practically unusable.
- */
-public final class MissingBindingFactory<T> implements Factory<T> {
- private static final MissingBindingFactory<Object> INSTANCE = new MissingBindingFactory<>();
-
- private MissingBindingFactory() {}
-
- @SuppressWarnings({"unchecked", "rawtypes"}) // safe covariant cast
- public static <T> Factory<T> create() {
- return (Factory) INSTANCE;
- }
-
- @Override
- public T get() {
- throw new AssertionError(
- "This binding is not part of the final binding graph. The key was requested by a binding "
- + "that was believed to possibly be part of the graph, but is no longer requested. "
- + "If this exception is thrown, it is the result of a Dagger bug.");
- }
-}
diff --git a/java/dagger/internal/ModifiableBinding.java b/java/dagger/internal/ModifiableBinding.java
deleted file mode 100644
index 1e658e4..0000000
--- a/java/dagger/internal/ModifiableBinding.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (C) 2019 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal;
-
-import static java.lang.annotation.ElementType.METHOD;
-
-import java.lang.annotation.Target;
-
-/** Annotates methods that implement bindings that may be modified by subclass implementations. */
-@Target(METHOD)
-public @interface ModifiableBinding {
- /** {@code ModifiableBindingType} of the binding. */
- // TODO(ronshapiro): should this be a shared enum with dagger.internal.codegen?
- String modifiableBindingType();
-
- /** A {@link dagger.internal.codegen.serialization.BindingRequestProto} serialized in Base64. */
- String bindingRequest();
-
- /**
- * For a multibinding, the keys of all contributions it depends on in this implementation.
- */
- String[] multibindingContributions() default {};
-}
diff --git a/java/dagger/internal/ModifiableModule.java b/java/dagger/internal/ModifiableModule.java
deleted file mode 100644
index 983321e..0000000
--- a/java/dagger/internal/ModifiableModule.java
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- * Copyright (C) 2019 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal;
-
-/**
- * Annotates methods that return {@linkplain dagger.Module modules} that may be modified by subclass
- * implementations.
- */
-public @interface ModifiableModule {
- /** The serialized {@code ComponentRequirement} of this method's module. */
- String value();
-}
diff --git a/java/dagger/internal/Preconditions.java b/java/dagger/internal/Preconditions.java
index 714a353..5c2d740 100644
--- a/java/dagger/internal/Preconditions.java
+++ b/java/dagger/internal/Preconditions.java
@@ -51,6 +51,34 @@
}
/**
+ * Ensures that an object reference returned from a provides method is not null.
+ *
+ * @param reference an object reference
+ * @return the non-null reference that was validated
+ * @throws NullPointerException if {@code reference} is null
+ */
+ public static <T> T checkNotNullFromProvides(T reference) {
+ if (reference == null) {
+ throw new NullPointerException("Cannot return null from a non-@Nullable @Provides method");
+ }
+ return reference;
+ }
+
+ /**
+ * Ensures that an object reference returned from a component method is not null.
+ *
+ * @param reference an object reference
+ * @return the non-null reference that was validated
+ * @throws NullPointerException if {@code reference} is null
+ */
+ public static <T> T checkNotNullFromComponent(T reference) {
+ if (reference == null) {
+ throw new NullPointerException("Cannot return null from a non-@Nullable component method");
+ }
+ return reference;
+ }
+
+ /**
* Ensures that an object reference passed as a parameter to the calling method is not null.
*
* @param reference an object reference
diff --git a/java/dagger/internal/SetBuilder.java b/java/dagger/internal/SetBuilder.java
index 41a2fc7..d65e7cb 100644
--- a/java/dagger/internal/SetBuilder.java
+++ b/java/dagger/internal/SetBuilder.java
@@ -61,13 +61,12 @@
}
public Set<T> build() {
- switch (contributions.size()) {
- case 0:
- return Collections.emptySet();
- case 1:
- return Collections.singleton(contributions.get(0));
- default:
- return Collections.unmodifiableSet(new HashSet<>(contributions));
+ if (contributions.isEmpty()) {
+ return Collections.emptySet();
+ } else if (contributions.size() == 1) {
+ return Collections.singleton(contributions.get(0));
+ } else {
+ return Collections.unmodifiableSet(new HashSet<>(contributions));
}
}
}
diff --git a/java/dagger/internal/codegen/AnnotationCreatorGenerator.java b/java/dagger/internal/codegen/AnnotationCreatorGenerator.java
deleted file mode 100644
index 273f552..0000000
--- a/java/dagger/internal/codegen/AnnotationCreatorGenerator.java
+++ /dev/null
@@ -1,167 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.squareup.javapoet.MethodSpec.constructorBuilder;
-import static com.squareup.javapoet.MethodSpec.methodBuilder;
-import static com.squareup.javapoet.TypeSpec.classBuilder;
-import static dagger.internal.codegen.AnnotationExpression.createMethodName;
-import static dagger.internal.codegen.AnnotationExpression.getAnnotationCreatorClassName;
-import static dagger.internal.codegen.javapoet.CodeBlocks.makeParametersCodeBlock;
-import static javax.lang.model.element.Modifier.FINAL;
-import static javax.lang.model.element.Modifier.PRIVATE;
-import static javax.lang.model.element.Modifier.PUBLIC;
-import static javax.lang.model.element.Modifier.STATIC;
-import static javax.lang.model.util.ElementFilter.methodsIn;
-
-import com.google.auto.common.MoreTypes;
-import com.google.common.collect.ImmutableList;
-import com.google.errorprone.annotations.CanIgnoreReturnValue;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.MethodSpec;
-import com.squareup.javapoet.TypeName;
-import com.squareup.javapoet.TypeSpec;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import java.util.LinkedHashSet;
-import java.util.Optional;
-import java.util.Set;
-import javax.annotation.processing.Filer;
-import javax.inject.Inject;
-import javax.lang.model.SourceVersion;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ElementKind;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.util.SimpleTypeVisitor6;
-
-/**
- * Generates classes that create annotation instances for an annotation type. The generated class
- * will have a private empty constructor, a static method that creates the annotation type itself,
- * and a static method that creates each annotation type that is nested in the top-level annotation
- * type.
- *
- * <p>So for an example annotation:
- *
- * <pre>
- * {@literal @interface} Foo {
- * String s();
- * int i();
- * Bar bar(); // an annotation defined elsewhere
- * }
- * </pre>
- *
- * the generated class will look like:
- *
- * <pre>
- * public final class FooCreator {
- * private FooCreator() {}
- *
- * public static Foo createFoo(String s, int i, Bar bar) { … }
- * public static Bar createBar(…) { … }
- * }
- * </pre>
- */
-class AnnotationCreatorGenerator extends SourceFileGenerator<TypeElement> {
- private static final ClassName AUTO_ANNOTATION =
- ClassName.get("com.google.auto.value", "AutoAnnotation");
-
- @Inject
- AnnotationCreatorGenerator(Filer filer, DaggerElements elements, SourceVersion sourceVersion) {
- super(filer, elements, sourceVersion);
- }
-
- @Override
- ClassName nameGeneratedType(TypeElement annotationType) {
- return getAnnotationCreatorClassName(annotationType);
- }
-
- @Override
- Element originatingElement(TypeElement annotationType) {
- return annotationType;
- }
-
- @Override
- Optional<TypeSpec.Builder> write(ClassName generatedTypeName, TypeElement annotationType) {
- TypeSpec.Builder annotationCreatorBuilder =
- classBuilder(generatedTypeName)
- .addModifiers(PUBLIC, FINAL)
- .addMethod(constructorBuilder().addModifiers(PRIVATE).build());
-
- for (TypeElement annotationElement : annotationsToCreate(annotationType)) {
- annotationCreatorBuilder.addMethod(buildCreateMethod(generatedTypeName, annotationElement));
- }
-
- return Optional.of(annotationCreatorBuilder);
- }
-
- private MethodSpec buildCreateMethod(ClassName generatedTypeName, TypeElement annotationElement) {
- String createMethodName = createMethodName(annotationElement);
- MethodSpec.Builder createMethod =
- methodBuilder(createMethodName)
- .addAnnotation(AUTO_ANNOTATION)
- .addModifiers(PUBLIC, STATIC)
- .returns(TypeName.get(annotationElement.asType()));
-
- ImmutableList.Builder<CodeBlock> parameters = ImmutableList.builder();
- for (ExecutableElement annotationMember : methodsIn(annotationElement.getEnclosedElements())) {
- String parameterName = annotationMember.getSimpleName().toString();
- TypeName parameterType = TypeName.get(annotationMember.getReturnType());
- createMethod.addParameter(parameterType, parameterName);
- parameters.add(CodeBlock.of("$L", parameterName));
- }
-
- ClassName autoAnnotationClass =
- generatedTypeName.peerClass(
- "AutoAnnotation_" + generatedTypeName.simpleName() + "_" + createMethodName);
- createMethod.addStatement(
- "return new $T($L)", autoAnnotationClass, makeParametersCodeBlock(parameters.build()));
- return createMethod.build();
- }
-
- /**
- * Returns the annotation types for which {@code @AutoAnnotation static Foo createFoo(…)} methods
- * should be written.
- */
- protected Set<TypeElement> annotationsToCreate(TypeElement annotationElement) {
- return nestedAnnotationElements(annotationElement, new LinkedHashSet<>());
- }
-
- @CanIgnoreReturnValue
- private static Set<TypeElement> nestedAnnotationElements(
- TypeElement annotationElement, Set<TypeElement> annotationElements) {
- if (annotationElements.add(annotationElement)) {
- for (ExecutableElement method : methodsIn(annotationElement.getEnclosedElements())) {
- TRAVERSE_NESTED_ANNOTATIONS.visit(method.getReturnType(), annotationElements);
- }
- }
- return annotationElements;
- }
-
- private static final SimpleTypeVisitor6<Void, Set<TypeElement>> TRAVERSE_NESTED_ANNOTATIONS =
- new SimpleTypeVisitor6<Void, Set<TypeElement>>() {
- @Override
- public Void visitDeclared(DeclaredType t, Set<TypeElement> p) {
- TypeElement typeElement = MoreTypes.asTypeElement(t);
- if (typeElement.getKind() == ElementKind.ANNOTATION_TYPE) {
- nestedAnnotationElements(typeElement, p);
- }
- return null;
- }
- };
-}
diff --git a/java/dagger/internal/codegen/AnnotationExpression.java b/java/dagger/internal/codegen/AnnotationExpression.java
deleted file mode 100644
index 8d729e2..0000000
--- a/java/dagger/internal/codegen/AnnotationExpression.java
+++ /dev/null
@@ -1,207 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.AnnotationMirrors.getAnnotationValuesWithDefaults;
-import static dagger.internal.codegen.SourceFiles.classFileName;
-import static dagger.internal.codegen.javapoet.CodeBlocks.makeParametersCodeBlock;
-import static java.util.stream.Collectors.toList;
-
-import com.google.auto.common.MoreElements;
-import com.google.auto.common.MoreTypes;
-import com.google.common.collect.ImmutableList;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.TypeName;
-import java.util.List;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.AnnotationValue;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.element.VariableElement;
-import javax.lang.model.type.ArrayType;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.TypeMirror;
-import javax.lang.model.util.SimpleAnnotationValueVisitor6;
-import javax.lang.model.util.SimpleTypeVisitor6;
-
-/**
- * Returns an expression creating an instance of the visited annotation type. Its parameter must be
- * a class as generated by {@link AnnotationCreatorGenerator}.
- *
- * <p>Note that {@link AnnotationValue#toString()} is the source-code representation of the value
- * <em>when used in an annotation</em>, which is not always the same as the representation needed
- * when creating the value in a method body.
- *
- * <p>For example, inside an annotation, a nested array of {@code int}s is simply {@code {1, 2, 3}},
- * but in code it would have to be {@code new int[] {1, 2, 3}}.
- */
-class AnnotationExpression extends SimpleAnnotationValueVisitor6<CodeBlock, AnnotationValue> {
-
- private final AnnotationMirror annotation;
- private final ClassName creatorClass;
-
- AnnotationExpression(AnnotationMirror annotation) {
- this.annotation = annotation;
- this.creatorClass =
- getAnnotationCreatorClassName(
- MoreTypes.asTypeElement(annotation.getAnnotationType()));
- }
-
- /**
- * Returns an expression that calls static methods on the annotation's creator class to create an
- * annotation instance equivalent the annotation passed to the constructor.
- */
- CodeBlock getAnnotationInstanceExpression() {
- return getAnnotationInstanceExpression(annotation);
- }
-
- private CodeBlock getAnnotationInstanceExpression(AnnotationMirror annotation) {
- return CodeBlock.of(
- "$T.$L($L)",
- creatorClass,
- createMethodName(
- MoreElements.asType(annotation.getAnnotationType().asElement())),
- makeParametersCodeBlock(
- getAnnotationValuesWithDefaults(annotation)
- .entrySet()
- .stream()
- .map(entry -> getValueExpression(entry.getKey().getReturnType(), entry.getValue()))
- .collect(toList())));
- }
-
- /**
- * Returns the name of the generated class that contains the static {@code create} methods for an
- * annotation type.
- */
- static ClassName getAnnotationCreatorClassName(TypeElement annotationType) {
- ClassName annotationTypeName = ClassName.get(annotationType);
- return annotationTypeName
- .topLevelClassName()
- .peerClass(classFileName(annotationTypeName) + "Creator");
- }
-
- static String createMethodName(TypeElement annotationType) {
- return "create" + annotationType.getSimpleName();
- }
-
- /**
- * Returns an expression that evaluates to a {@code value} of a given type on an {@code
- * annotation}.
- */
- CodeBlock getValueExpression(TypeMirror valueType, AnnotationValue value) {
- return ARRAY_LITERAL_PREFIX.visit(valueType, this.visit(value, value));
- }
-
- @Override
- public CodeBlock visitEnumConstant(VariableElement c, AnnotationValue p) {
- return CodeBlock.of("$T.$L", c.getEnclosingElement(), c.getSimpleName());
- }
-
- @Override
- public CodeBlock visitAnnotation(AnnotationMirror a, AnnotationValue p) {
- return getAnnotationInstanceExpression(a);
- }
-
- @Override
- public CodeBlock visitType(TypeMirror t, AnnotationValue p) {
- return CodeBlock.of("$T.class", t);
- }
-
- @Override
- public CodeBlock visitString(String s, AnnotationValue p) {
- return CodeBlock.of("$S", s);
- }
-
- @Override
- public CodeBlock visitByte(byte b, AnnotationValue p) {
- return CodeBlock.of("(byte) $L", b);
- }
-
- @Override
- public CodeBlock visitChar(char c, AnnotationValue p) {
- return CodeBlock.of("$L", p);
- }
-
- @Override
- public CodeBlock visitDouble(double d, AnnotationValue p) {
- return CodeBlock.of("$LD", d);
- }
-
- @Override
- public CodeBlock visitFloat(float f, AnnotationValue p) {
- return CodeBlock.of("$LF", f);
- }
-
- @Override
- public CodeBlock visitLong(long i, AnnotationValue p) {
- return CodeBlock.of("$LL", i);
- }
-
- @Override
- public CodeBlock visitShort(short s, AnnotationValue p) {
- return CodeBlock.of("(short) $L", s);
- }
-
- @Override
- protected CodeBlock defaultAction(Object o, AnnotationValue p) {
- return CodeBlock.of("$L", o);
- }
-
- @Override
- public CodeBlock visitArray(List<? extends AnnotationValue> values, AnnotationValue p) {
- ImmutableList.Builder<CodeBlock> codeBlocks = ImmutableList.builder();
- for (AnnotationValue value : values) {
- codeBlocks.add(this.visit(value, p));
- }
- return CodeBlock.of("{$L}", makeParametersCodeBlock(codeBlocks.build()));
- }
-
- /**
- * If the visited type is an array, prefixes the parameter code block with {@code new T[]}, where
- * {@code T} is the raw array component type.
- */
- private static final SimpleTypeVisitor6<CodeBlock, CodeBlock> ARRAY_LITERAL_PREFIX =
- new SimpleTypeVisitor6<CodeBlock, CodeBlock>() {
-
- @Override
- public CodeBlock visitArray(ArrayType t, CodeBlock p) {
- return CodeBlock.of("new $T[] $L", RAW_TYPE_NAME.visit(t.getComponentType()), p);
- }
-
- @Override
- protected CodeBlock defaultAction(TypeMirror e, CodeBlock p) {
- return p;
- }
- };
-
- /**
- * If the visited type is an array, returns the name of its raw component type; otherwise returns
- * the name of the type itself.
- */
- private static final SimpleTypeVisitor6<TypeName, Void> RAW_TYPE_NAME =
- new SimpleTypeVisitor6<TypeName, Void>() {
- @Override
- public TypeName visitDeclared(DeclaredType t, Void p) {
- return ClassName.get(MoreTypes.asTypeElement(t));
- }
-
- @Override
- protected TypeName defaultAction(TypeMirror e, Void p) {
- return TypeName.get(e);
- }
- };
-}
diff --git a/java/dagger/internal/codegen/AnnotationProtoConverter.java b/java/dagger/internal/codegen/AnnotationProtoConverter.java
deleted file mode 100644
index 282d8ca..0000000
--- a/java/dagger/internal/codegen/AnnotationProtoConverter.java
+++ /dev/null
@@ -1,275 +0,0 @@
-/*
- * Copyright (C) 2019 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.AnnotationMirrors.getAnnotationValuesWithDefaults;
-import static com.google.common.base.Preconditions.checkState;
-import static com.google.common.collect.Maps.transformValues;
-import static dagger.internal.codegen.DaggerStreams.toImmutableList;
-import static javax.lang.model.util.ElementFilter.fieldsIn;
-
-import com.google.auto.common.MoreTypes;
-import com.google.common.collect.ImmutableList;
-import dagger.internal.codegen.serialization.AnnotationProto;
-import dagger.internal.codegen.serialization.AnnotationValueProto;
-import java.util.Collections;
-import java.util.List;
-import javax.inject.Inject;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.AnnotationValue;
-import javax.lang.model.element.AnnotationValueVisitor;
-import javax.lang.model.element.VariableElement;
-import javax.lang.model.type.TypeMirror;
-import javax.lang.model.util.SimpleAnnotationValueVisitor8;
-
-/** Converts {@link AnnotationMirror}s to {@link AnnotationProto}s and vice-versa. */
-final class AnnotationProtoConverter {
- private final TypeProtoConverter typeProtoConverter;
-
- @Inject
- AnnotationProtoConverter(TypeProtoConverter typeProtoConverter) {
- this.typeProtoConverter = typeProtoConverter;
- }
-
- /** Translates an {@link AnnotationMirror} to a proto representation. */
- static AnnotationProto toProto(AnnotationMirror annotationMirror) {
- AnnotationProto.Builder builder = AnnotationProto.newBuilder();
- builder.setAnnotationType(TypeProtoConverter.toProto(annotationMirror.getAnnotationType()));
- getAnnotationValuesWithDefaults(annotationMirror)
- .forEach(
- (attribute, value) ->
- builder.putAllValues(
- Collections.singletonMap(
- attribute.getSimpleName().toString(), annotationValueProto(value))));
- return builder.build();
- }
-
- /** Creates an {@link AnnotationMirror} from its proto representation. */
- AnnotationMirror fromProto(AnnotationProto annotation) {
- return SimpleAnnotationMirror.of(
- MoreTypes.asTypeElement(typeProtoConverter.fromProto(annotation.getAnnotationType())),
- transformValues(annotation.getValues(), AnnotationValueFromProto::new));
- }
-
- private static final AnnotationValueVisitor<
- AnnotationValueProto.Builder, AnnotationValueProto.Builder>
- ANNOTATION_VALUE_TO_PROTO =
- new SimpleAnnotationValueVisitor8<
- AnnotationValueProto.Builder, AnnotationValueProto.Builder>() {
- @Override
- public AnnotationValueProto.Builder visitAnnotation(
- AnnotationMirror nestedAnnotation, AnnotationValueProto.Builder builder) {
- return builder
- .setNestedAnnotation(toProto(nestedAnnotation))
- .setKind(AnnotationValueProto.Kind.ANNOTATION);
- }
-
- @Override
- public AnnotationValueProto.Builder visitBoolean(
- boolean b, AnnotationValueProto.Builder builder) {
- return builder.setBooleanValue(b).setKind(AnnotationValueProto.Kind.BOOLEAN);
- }
-
- @Override
- public AnnotationValueProto.Builder visitChar(
- char c, AnnotationValueProto.Builder builder) {
- return builder
- .setStringValue(String.valueOf(c))
- .setKind(AnnotationValueProto.Kind.CHAR);
- }
-
- @Override
- public AnnotationValueProto.Builder visitByte(
- byte b, AnnotationValueProto.Builder builder) {
- return builder.setIntValue(b).setKind(AnnotationValueProto.Kind.BYTE);
- }
-
- @Override
- public AnnotationValueProto.Builder visitShort(
- short s, AnnotationValueProto.Builder builder) {
- return builder.setIntValue(s).setKind(AnnotationValueProto.Kind.SHORT);
- }
-
- @Override
- public AnnotationValueProto.Builder visitInt(
- int i, AnnotationValueProto.Builder builder) {
- return builder.setIntValue(i).setKind(AnnotationValueProto.Kind.INT);
- }
-
- @Override
- public AnnotationValueProto.Builder visitFloat(
- float f, AnnotationValueProto.Builder builder) {
- return builder.setFloatValue(f).setKind(AnnotationValueProto.Kind.FLOAT);
- }
-
- @Override
- public AnnotationValueProto.Builder visitLong(
- long l, AnnotationValueProto.Builder builder) {
- return builder.setLongValue(l).setKind(AnnotationValueProto.Kind.LONG);
- }
-
- @Override
- public AnnotationValueProto.Builder visitDouble(
- double d, AnnotationValueProto.Builder builder) {
- return builder.setDoubleValue(d).setKind(AnnotationValueProto.Kind.DOUBLE);
- }
-
- @Override
- public AnnotationValueProto.Builder visitString(
- String s, AnnotationValueProto.Builder builder) {
- return builder.setStringValue(s).setKind(AnnotationValueProto.Kind.STRING);
- }
-
- @Override
- public AnnotationValueProto.Builder visitType(
- TypeMirror t, AnnotationValueProto.Builder builder) {
- return builder
- .setClassLiteral(TypeProtoConverter.toProto(t))
- .setKind(AnnotationValueProto.Kind.CLASS_LITERAL);
- }
-
- @Override
- public AnnotationValueProto.Builder visitEnumConstant(
- VariableElement c, AnnotationValueProto.Builder builder) {
- return builder
- .setEnumType(TypeProtoConverter.toProto(c.asType()))
- .setEnumName(c.getSimpleName().toString())
- .setKind(AnnotationValueProto.Kind.ENUM);
- }
-
- @Override
- public AnnotationValueProto.Builder visitArray(
- List<? extends AnnotationValue> values, AnnotationValueProto.Builder builder) {
- values.forEach(value -> builder.addArrayValues(annotationValueProto(value)));
- return builder.setKind(AnnotationValueProto.Kind.ARRAY);
- }
-
- @Override
- public AnnotationValueProto.Builder visitUnknown(
- AnnotationValue av, AnnotationValueProto.Builder builder) {
- throw new UnsupportedOperationException(av.toString());
- }
- };
-
- /** Translates an {@link AnnotationValue} to a proto representation. */
- private static AnnotationValueProto annotationValueProto(AnnotationValue annotationValue) {
- return annotationValue
- .accept(ANNOTATION_VALUE_TO_PROTO, AnnotationValueProto.newBuilder())
- .build();
- }
-
- private class AnnotationValueFromProto implements AnnotationValue {
- private final AnnotationValueProto proto;
-
- AnnotationValueFromProto(AnnotationValueProto proto) {
- this.proto = proto;
- }
-
- @Override
- public Object getValue() {
- switch (proto.getKind()) {
- case BOOLEAN:
- return proto.getBooleanValue();
- case BYTE:
- return (byte) proto.getIntValue();
- case SHORT:
- return (short) proto.getIntValue();
- case CHAR:
- return getCharValue();
- case INT:
- return proto.getIntValue();
- case FLOAT:
- return proto.getFloatValue();
- case LONG:
- return proto.getLongValue();
- case DOUBLE:
- return proto.getDoubleValue();
- case STRING:
- return proto.getStringValue();
- case CLASS_LITERAL:
- return typeProtoConverter.fromProto(proto.getClassLiteral());
- case ENUM:
- return getEnumConstant();
- case ANNOTATION:
- return fromProto(proto.getNestedAnnotation());
- case ARRAY:
- return getArrayValues();
- case UNKNOWN:
- case UNRECOGNIZED:
- // fall through
- }
- throw new AssertionError(proto);
- }
-
- @Override
- public <R, P> R accept(AnnotationValueVisitor<R, P> visitor, P passedValue) {
- switch (proto.getKind()) {
- case BOOLEAN:
- return visitor.visitBoolean(proto.getBooleanValue(), passedValue);
- case BYTE:
- return visitor.visitByte((byte) proto.getIntValue(), passedValue);
- case SHORT:
- return visitor.visitShort((short) proto.getIntValue(), passedValue);
- case CHAR:
- return visitor.visitChar(getCharValue(), passedValue);
- case INT:
- return visitor.visitInt(proto.getIntValue(), passedValue);
- case FLOAT:
- return visitor.visitFloat(proto.getFloatValue(), passedValue);
- case LONG:
- return visitor.visitLong(proto.getLongValue(), passedValue);
- case DOUBLE:
- return visitor.visitDouble(proto.getDoubleValue(), passedValue);
- case STRING:
- return visitor.visitString((String) getValue(), passedValue);
- case CLASS_LITERAL:
- return visitor.visitType((TypeMirror) getValue(), passedValue);
- case ENUM:
- return visitor.visitEnumConstant((VariableElement) getValue(), passedValue);
- case ANNOTATION:
- return visitor.visitAnnotation((AnnotationMirror) getValue(), passedValue);
- case ARRAY:
- return visitor.visitArray(getArrayValues(), passedValue);
- case UNKNOWN:
- case UNRECOGNIZED:
- // fall through
- }
- throw new AssertionError(proto);
- }
-
- private char getCharValue() {
- checkState(proto.getKind().equals(AnnotationValueProto.Kind.CHAR));
- return proto.getStringValue().charAt(0);
- }
-
- private VariableElement getEnumConstant() {
- checkState(proto.getKind().equals(AnnotationValueProto.Kind.ENUM));
- TypeMirror enumType = typeProtoConverter.fromProto(proto.getEnumType());
- return fieldsIn(MoreTypes.asTypeElement(enumType).getEnclosedElements()).stream()
- .filter(value -> value.getSimpleName().contentEquals(proto.getEnumName()))
- .findFirst()
- .get();
- }
-
- private ImmutableList<AnnotationValue> getArrayValues() {
- checkState(proto.getKind().equals(AnnotationValueProto.Kind.ARRAY));
- return proto.getArrayValuesList().stream()
- .map(AnnotationValueFromProto::new)
- .collect(toImmutableList());
- }
- }
-}
diff --git a/java/dagger/internal/codegen/AnonymousProviderCreationExpression.java b/java/dagger/internal/codegen/AnonymousProviderCreationExpression.java
deleted file mode 100644
index fc30eaa..0000000
--- a/java/dagger/internal/codegen/AnonymousProviderCreationExpression.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.BindingRequest.bindingRequest;
-import static dagger.internal.codegen.javapoet.CodeBlocks.anonymousProvider;
-import static dagger.model.RequestKind.INSTANCE;
-
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import dagger.internal.codegen.FrameworkFieldInitializer.FrameworkInstanceCreationExpression;
-import dagger.internal.codegen.javapoet.Expression;
-
-/**
- * A {@link javax.inject.Provider} creation expression for an anonymous inner class whose
- * {@code get()} method returns the expression for an instance binding request for its key.
- */
-final class AnonymousProviderCreationExpression
- implements FrameworkInstanceCreationExpression {
- private final ContributionBinding binding;
- private final ComponentBindingExpressions componentBindingExpressions;
- private final ClassName requestingClass;
-
- AnonymousProviderCreationExpression(
- ContributionBinding binding,
- ComponentBindingExpressions componentBindingExpressions,
- ClassName requestingClass) {
- this.binding = binding;
- this.componentBindingExpressions = componentBindingExpressions;
- this.requestingClass = requestingClass;
- }
-
- @Override
- public CodeBlock creationExpression() {
- BindingRequest instanceExpressionRequest = bindingRequest(binding.key(), INSTANCE);
- Expression instanceExpression =
- componentBindingExpressions.getDependencyExpression(
- instanceExpressionRequest,
- // Not a real class name, but the actual requestingClass is an inner class within the
- // given class, not that class itself.
- requestingClass.nestedClass("Anonymous"));
- return anonymousProvider(instanceExpression);
- }
-}
diff --git a/java/dagger/internal/codegen/AnyBindingMethodValidator.java b/java/dagger/internal/codegen/AnyBindingMethodValidator.java
deleted file mode 100644
index bad9636..0000000
--- a/java/dagger/internal/codegen/AnyBindingMethodValidator.java
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreElements.isAnnotationPresent;
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.internal.codegen.Util.reentrantComputeIfAbsent;
-import static dagger.internal.codegen.langmodel.DaggerElements.isAnyAnnotationPresent;
-import static java.util.stream.Collectors.joining;
-
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import java.lang.annotation.Annotation;
-import java.util.HashMap;
-import java.util.Map;
-import javax.inject.Inject;
-import javax.lang.model.element.ExecutableElement;
-
-/** Validates any binding method. */
-final class AnyBindingMethodValidator {
-
- private final ImmutableMap<Class<? extends Annotation>, BindingMethodValidator> validators;
- private final Map<ExecutableElement, ValidationReport<ExecutableElement>> reports =
- new HashMap<>();
-
- @Inject
- AnyBindingMethodValidator(
- ImmutableMap<Class<? extends Annotation>, BindingMethodValidator> validators) {
- this.validators = validators;
- }
-
- /** Returns the binding method annotations considered by this validator. */
- ImmutableSet<Class<? extends Annotation>> methodAnnotations() {
- return validators.keySet();
- }
-
- /**
- * Returns {@code true} if {@code method} is annotated with at least one of {@link
- * #methodAnnotations()}.
- */
- boolean isBindingMethod(ExecutableElement method) {
- return isAnyAnnotationPresent(method, methodAnnotations());
- }
-
- /**
- * Returns a validation report for a method.
- *
- * <ul>
- * <li>Reports an error if {@code method} is annotated with more than one {@linkplain
- * #methodAnnotations() binding method annotation}.
- * <li>Validates {@code method} with the {@link BindingMethodValidator} for the single
- * {@linkplain #methodAnnotations() binding method annotation}.
- * </ul>
- *
- * @throws IllegalArgumentException if {@code method} is not annotated by any {@linkplain
- * #methodAnnotations() binding method annotation}
- */
- ValidationReport<ExecutableElement> validate(ExecutableElement method) {
- return reentrantComputeIfAbsent(reports, method, this::validateUncached);
- }
-
- /**
- * Returns {@code true} if {@code method} was already {@linkplain #validate(ExecutableElement)
- * validated}.
- */
- boolean wasAlreadyValidated(ExecutableElement method) {
- return reports.containsKey(method);
- }
-
- private ValidationReport<ExecutableElement> validateUncached(ExecutableElement method) {
- ValidationReport.Builder<ExecutableElement> report = ValidationReport.about(method);
- ImmutableSet<? extends Class<? extends Annotation>> bindingMethodAnnotations =
- methodAnnotations()
- .stream()
- .filter(annotation -> isAnnotationPresent(method, annotation))
- .collect(toImmutableSet());
- switch (bindingMethodAnnotations.size()) {
- case 0:
- throw new IllegalArgumentException(
- String.format("%s has no binding method annotation", method));
-
- case 1:
- report.addSubreport(
- validators.get(getOnlyElement(bindingMethodAnnotations)).validate(method));
- break;
-
- default:
- report.addError(
- String.format(
- "%s is annotated with more than one of (%s)",
- method.getSimpleName(),
- methodAnnotations().stream().map(Class::getCanonicalName).collect(joining(", "))),
- method);
- break;
- }
- return report.build();
- }
-}
diff --git a/java/dagger/internal/codegen/AssistedFactoryProcessingStep.java b/java/dagger/internal/codegen/AssistedFactoryProcessingStep.java
new file mode 100644
index 0000000..abc0436
--- /dev/null
+++ b/java/dagger/internal/codegen/AssistedFactoryProcessingStep.java
@@ -0,0 +1,360 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen;
+
+import static com.google.auto.common.MoreElements.asType;
+import static com.google.auto.common.MoreTypes.asDeclared;
+import static com.google.auto.common.MoreTypes.asTypeElement;
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static dagger.internal.codegen.binding.AssistedInjectionAnnotations.assistedInjectedConstructors;
+import static dagger.internal.codegen.binding.SourceFiles.generatedClassNameForBinding;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
+import static dagger.internal.codegen.javapoet.CodeBlocks.toParametersCodeBlock;
+import static dagger.internal.codegen.javapoet.TypeNames.INSTANCE_FACTORY;
+import static dagger.internal.codegen.javapoet.TypeNames.providerOf;
+import static java.util.stream.Collectors.joining;
+import static javax.lang.model.element.Modifier.ABSTRACT;
+import static javax.lang.model.element.Modifier.FINAL;
+import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.PUBLIC;
+import static javax.lang.model.element.Modifier.STATIC;
+
+import com.google.auto.common.MoreElements;
+import com.google.common.collect.ImmutableSet;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterSpec;
+import com.squareup.javapoet.ParameterizedTypeName;
+import com.squareup.javapoet.TypeName;
+import com.squareup.javapoet.TypeSpec;
+import com.squareup.javapoet.TypeVariableName;
+import dagger.assisted.AssistedFactory;
+import dagger.internal.codegen.base.SourceFileGenerationException;
+import dagger.internal.codegen.base.SourceFileGenerator;
+import dagger.internal.codegen.binding.AssistedInjectionAnnotations;
+import dagger.internal.codegen.binding.AssistedInjectionAnnotations.AssistedFactoryMetadata;
+import dagger.internal.codegen.binding.AssistedInjectionAnnotations.AssistedParameter;
+import dagger.internal.codegen.binding.BindingFactory;
+import dagger.internal.codegen.binding.ProvisionBinding;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.internal.codegen.validation.TypeCheckingProcessingStep;
+import dagger.internal.codegen.validation.ValidationReport;
+import java.lang.annotation.Annotation;
+import java.util.HashSet;
+import java.util.Optional;
+import java.util.Set;
+import javax.annotation.processing.Filer;
+import javax.annotation.processing.Messager;
+import javax.inject.Inject;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.ExecutableType;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeMirror;
+
+/** An annotation processor for {@link dagger.assisted.AssistedFactory}-annotated types. */
+final class AssistedFactoryProcessingStep extends TypeCheckingProcessingStep<TypeElement> {
+ private final Messager messager;
+ private final Filer filer;
+ private final SourceVersion sourceVersion;
+ private final DaggerElements elements;
+ private final DaggerTypes types;
+ private final BindingFactory bindingFactory;
+
+ @Inject
+ AssistedFactoryProcessingStep(
+ Messager messager,
+ Filer filer,
+ SourceVersion sourceVersion,
+ DaggerElements elements,
+ DaggerTypes types,
+ BindingFactory bindingFactory) {
+ super(MoreElements::asType);
+ this.messager = messager;
+ this.filer = filer;
+ this.sourceVersion = sourceVersion;
+ this.elements = elements;
+ this.types = types;
+ this.bindingFactory = bindingFactory;
+ }
+
+ @Override
+ public ImmutableSet<Class<? extends Annotation>> annotations() {
+ return ImmutableSet.of(AssistedFactory.class);
+ }
+
+ @Override
+ protected void process(
+ TypeElement factory, ImmutableSet<Class<? extends Annotation>> annotations) {
+ ValidationReport<TypeElement> report = new AssistedFactoryValidator().validate(factory);
+ report.printMessagesTo(messager);
+ if (report.isClean()) {
+ try {
+ ProvisionBinding binding = bindingFactory.assistedFactoryBinding(factory, Optional.empty());
+ new AssistedFactoryImplGenerator().generate(binding);
+ } catch (SourceFileGenerationException e) {
+ e.printMessageTo(messager);
+ }
+ }
+ }
+
+ private final class AssistedFactoryValidator {
+ ValidationReport<TypeElement> validate(TypeElement factory) {
+ ValidationReport.Builder<TypeElement> report = ValidationReport.about(factory);
+
+ if (!factory.getModifiers().contains(ABSTRACT)) {
+ return report
+ .addError(
+ "The @AssistedFactory-annotated type must be either an abstract class or "
+ + "interface.",
+ factory)
+ .build();
+ }
+
+ if (factory.getNestingKind().isNested() && !factory.getModifiers().contains(STATIC)) {
+ report.addError("Nested @AssistedFactory-annotated types must be static. ", factory);
+ }
+
+ ImmutableSet<ExecutableElement> abstractFactoryMethods =
+ AssistedInjectionAnnotations.assistedFactoryMethods(factory, elements, types);
+
+ if (abstractFactoryMethods.isEmpty()) {
+ report.addError(
+ "The @AssistedFactory-annotated type is missing an abstract, non-default method "
+ + "whose return type matches the assisted injection type.",
+ factory);
+ }
+
+ for (ExecutableElement method : abstractFactoryMethods) {
+ ExecutableType methodType = types.resolveExecutableType(method, factory.asType());
+ if (!isAssistedInjectionType(methodType.getReturnType())) {
+ report.addError(
+ String.format(
+ "Invalid return type: %s. An assisted factory's abstract method must return a "
+ + "type with an @AssistedInject-annotated constructor.",
+ methodType.getReturnType()),
+ method);
+ }
+ if (!method.getTypeParameters().isEmpty()) {
+ report.addError(
+ "@AssistedFactory does not currently support type parameters in the creator "
+ + "method. See https://github.com/google/dagger/issues/2279",
+ method);
+ }
+ }
+
+ if (abstractFactoryMethods.size() > 1) {
+ report.addError(
+ "The @AssistedFactory-annotated type should contain a single abstract, non-default"
+ + " method but found multiple: "
+ + abstractFactoryMethods,
+ factory);
+ }
+
+ if (!report.build().isClean()) {
+ return report.build();
+ }
+
+ AssistedFactoryMetadata metadata =
+ AssistedFactoryMetadata.create(factory.asType(), elements, types);
+
+ // Note: We check uniqueness of the @AssistedInject constructor parameters in
+ // AssistedInjectProcessingStep. We need to check uniqueness for here too because we may
+ // have resolved some type parameters that were not resolved in the @AssistedInject type.
+ Set<AssistedParameter> uniqueAssistedParameters = new HashSet<>();
+ for (AssistedParameter assistedParameter : metadata.assistedFactoryAssistedParameters()) {
+ if (!uniqueAssistedParameters.add(assistedParameter)) {
+ report.addError(
+ "@AssistedFactory method has duplicate @Assisted types: " + assistedParameter,
+ assistedParameter.variableElement());
+ }
+ }
+
+ if (!ImmutableSet.copyOf(metadata.assistedInjectAssistedParameters())
+ .equals(ImmutableSet.copyOf(metadata.assistedFactoryAssistedParameters()))) {
+ report.addError(
+ String.format(
+ "The parameters in the factory method must match the @Assisted parameters in %s."
+ + "\n Actual: %s#%s"
+ + "\n Expected: %s#%s(%s)",
+ metadata.assistedInjectType(),
+ metadata.factory().getQualifiedName(),
+ metadata.factoryMethod(),
+ metadata.factory().getQualifiedName(),
+ metadata.factoryMethod().getSimpleName(),
+ metadata.assistedInjectAssistedParameters().stream()
+ .map(AssistedParameter::type)
+ .map(Object::toString)
+ .collect(joining(", "))),
+ metadata.factoryMethod());
+ }
+
+ return report.build();
+ }
+
+ private boolean isAssistedInjectionType(TypeMirror type) {
+ return type.getKind() == TypeKind.DECLARED
+ && AssistedInjectionAnnotations.isAssistedInjectionType(asTypeElement(type));
+ }
+ }
+
+ /** Generates an implementation of the {@link dagger.assisted.AssistedFactory}-annotated class. */
+ private final class AssistedFactoryImplGenerator extends SourceFileGenerator<ProvisionBinding> {
+ AssistedFactoryImplGenerator() {
+ super(filer, elements, sourceVersion);
+ }
+
+ @Override
+ public ClassName nameGeneratedType(ProvisionBinding binding) {
+ return generatedClassNameForBinding(binding);
+ }
+
+ @Override
+ public Element originatingElement(ProvisionBinding binding) {
+ return binding.bindingElement().get();
+ }
+
+ // For each @AssistedFactory-annotated type, we generates a class named "*_Impl" that implements
+ // that type.
+ //
+ // Note that this class internally delegates to the @AssistedInject generated class, which
+ // contains the actual implementation logic for creating the @AssistedInject type. The reason we
+ // need both of these generated classes is because while the @AssistedInject generated class
+ // knows how to create the @AssistedInject type, it doesn't know about all of the
+ // @AssistedFactory interfaces that it needs to extend when it's generated. Thus, the role of
+ // the @AssistedFactory generated class is purely to implement the @AssistedFactory type.
+ // Furthermore, while we could have put all of the logic into the @AssistedFactory generated
+ // class and not generate the @AssistedInject generated class, having the @AssistedInject
+ // generated class ensures we have proper accessibility to the @AssistedInject type, and reduces
+ // duplicate logic if there are multiple @AssistedFactory types for the same @AssistedInject
+ // type.
+ //
+ // Example:
+ // public class FooFactory_Impl implements FooFactory {
+ // private final Foo_Factory delegateFactory;
+ //
+ // FooFactory_Impl(Foo_Factory delegateFactory) {
+ // this.delegateFactory = delegateFactory;
+ // }
+ //
+ // @Override
+ // public Foo createFoo(AssistedDep assistedDep) {
+ // return delegateFactory.get(assistedDep);
+ // }
+ //
+ // public static Provider<FooFactory> create(Foo_Factory delegateFactory) {
+ // return InstanceFactory.create(new FooFactory_Impl(delegateFactory));
+ // }
+ // }
+ @Override
+ public Optional<TypeSpec.Builder> write(ProvisionBinding binding) {
+ TypeElement factory = asType(binding.bindingElement().get());
+
+ ClassName name = nameGeneratedType(binding);
+ TypeSpec.Builder builder =
+ TypeSpec.classBuilder(name)
+ .addModifiers(PUBLIC, FINAL)
+ .addTypeVariables(
+ factory.getTypeParameters().stream()
+ .map(TypeVariableName::get)
+ .collect(toImmutableList()));
+
+ if (factory.getKind() == ElementKind.INTERFACE) {
+ builder.addSuperinterface(factory.asType());
+ } else {
+ builder.superclass(factory.asType());
+ }
+
+ AssistedFactoryMetadata metadata =
+ AssistedFactoryMetadata.create(asDeclared(factory.asType()), elements, types);
+ ParameterSpec delegateFactoryParam =
+ ParameterSpec.builder(
+ delegateFactoryTypeName(metadata.assistedInjectType()), "delegateFactory")
+ .build();
+ builder
+ .addField(
+ FieldSpec.builder(delegateFactoryParam.type, delegateFactoryParam.name)
+ .addModifiers(PRIVATE, FINAL)
+ .build())
+ .addMethod(
+ MethodSpec.constructorBuilder()
+ .addParameter(delegateFactoryParam)
+ .addStatement("this.$1N = $1N", delegateFactoryParam)
+ .build())
+ .addMethod(
+ MethodSpec.overriding(metadata.factoryMethod(), metadata.factoryType(), types)
+ .addStatement(
+ "return $N.get($L)",
+ delegateFactoryParam,
+ // Use the order of the parameters from the @AssistedInject constructor but
+ // use the parameter names of the @AssistedFactory method.
+ metadata.assistedInjectAssistedParameters().stream()
+ .map(metadata.assistedFactoryAssistedParametersMap()::get)
+ .map(param -> CodeBlock.of("$L", param.getSimpleName()))
+ .collect(toParametersCodeBlock()))
+ .build())
+ .addMethod(
+ MethodSpec.methodBuilder("create")
+ .addModifiers(PUBLIC, STATIC)
+ .addParameter(delegateFactoryParam)
+ .addTypeVariables(
+ metadata.assistedInjectElement().getTypeParameters().stream()
+ .map(TypeVariableName::get)
+ .collect(toImmutableList()))
+ .returns(providerOf(TypeName.get(factory.asType())))
+ .addStatement(
+ "return $T.$Lcreate(new $T($N))",
+ INSTANCE_FACTORY,
+ // Java 7 type inference requires the method call provide the exact type here.
+ sourceVersion.compareTo(SourceVersion.RELEASE_7) <= 0
+ ? CodeBlock.of("<$T>", types.accessibleType(metadata.factoryType(), name))
+ : CodeBlock.of(""),
+ name,
+ delegateFactoryParam)
+ .build());
+ return Optional.of(builder);
+ }
+
+ /** Returns the generated factory {@link TypeName type} for an @AssistedInject constructor. */
+ private TypeName delegateFactoryTypeName(DeclaredType assistedInjectType) {
+ // The name of the generated factory for the assisted inject type,
+ // e.g. an @AssistedInject Foo(...) {...} constructor will generate a Foo_Factory class.
+ ClassName generatedFactoryClassName =
+ generatedClassNameForBinding(
+ bindingFactory.injectionBinding(
+ getOnlyElement(assistedInjectedConstructors(asTypeElement(assistedInjectType))),
+ Optional.empty()));
+
+ // Return the factory type resolved with the same type parameters as the assisted inject type.
+ return assistedInjectType.getTypeArguments().isEmpty()
+ ? generatedFactoryClassName
+ : ParameterizedTypeName.get(
+ generatedFactoryClassName,
+ assistedInjectType.getTypeArguments().stream()
+ .map(TypeName::get)
+ .collect(toImmutableList())
+ .toArray(new TypeName[0]));
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/AssistedInjectProcessingStep.java b/java/dagger/internal/codegen/AssistedInjectProcessingStep.java
new file mode 100644
index 0000000..4f2f5b7
--- /dev/null
+++ b/java/dagger/internal/codegen/AssistedInjectProcessingStep.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2021 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen;
+
+import static com.google.auto.common.MoreTypes.asDeclared;
+import static com.google.common.base.Preconditions.checkState;
+import static dagger.internal.codegen.langmodel.DaggerElements.closestEnclosingTypeElement;
+
+import com.google.auto.common.MoreElements;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import dagger.assisted.AssistedInject;
+import dagger.internal.codegen.binding.AssistedInjectionAnnotations;
+import dagger.internal.codegen.binding.AssistedInjectionAnnotations.AssistedParameter;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.internal.codegen.validation.TypeCheckingProcessingStep;
+import dagger.internal.codegen.validation.ValidationReport;
+import java.lang.annotation.Annotation;
+import java.util.HashSet;
+import java.util.Set;
+import javax.annotation.processing.Messager;
+import javax.inject.Inject;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.type.DeclaredType;
+
+/** An annotation processor for {@link dagger.assisted.AssistedInject}-annotated elements. */
+final class AssistedInjectProcessingStep extends TypeCheckingProcessingStep<ExecutableElement> {
+ private final DaggerTypes types;
+ private final Messager messager;
+
+ @Inject
+ AssistedInjectProcessingStep(DaggerTypes types, Messager messager) {
+ super(MoreElements::asExecutable);
+ this.types = types;
+ this.messager = messager;
+ }
+
+ @Override
+ public ImmutableSet<Class<? extends Annotation>> annotations() {
+ return ImmutableSet.of(AssistedInject.class);
+ }
+
+ @Override
+ protected void process(
+ ExecutableElement assistedInjectElement,
+ ImmutableSet<Class<? extends Annotation>> annotations) {
+ new AssistedInjectValidator().validate(assistedInjectElement).printMessagesTo(messager);
+ }
+
+ private final class AssistedInjectValidator {
+ ValidationReport<ExecutableElement> validate(ExecutableElement constructor) {
+ checkState(constructor.getKind() == ElementKind.CONSTRUCTOR);
+ ValidationReport.Builder<ExecutableElement> report = ValidationReport.about(constructor);
+
+ DeclaredType assistedInjectType =
+ asDeclared(closestEnclosingTypeElement(constructor).asType());
+ ImmutableList<AssistedParameter> assistedParameters =
+ AssistedInjectionAnnotations.assistedInjectAssistedParameters(assistedInjectType, types);
+
+ Set<AssistedParameter> uniqueAssistedParameters = new HashSet<>();
+ for (AssistedParameter assistedParameter : assistedParameters) {
+ if (!uniqueAssistedParameters.add(assistedParameter)) {
+ report.addError(
+ "@AssistedInject constructor has duplicate @Assisted type: " + assistedParameter,
+ assistedParameter.variableElement());
+ }
+ }
+
+ return report.build();
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/AssistedProcessingStep.java b/java/dagger/internal/codegen/AssistedProcessingStep.java
new file mode 100644
index 0000000..3173987
--- /dev/null
+++ b/java/dagger/internal/codegen/AssistedProcessingStep.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen;
+
+import static com.google.auto.common.MoreElements.isAnnotationPresent;
+import static dagger.internal.codegen.langmodel.DaggerElements.closestEnclosingTypeElement;
+
+import com.google.auto.common.MoreElements;
+import com.google.common.collect.ImmutableSet;
+import dagger.assisted.Assisted;
+import dagger.assisted.AssistedInject;
+import dagger.internal.codegen.binding.AssistedInjectionAnnotations;
+import dagger.internal.codegen.binding.InjectionAnnotations;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.internal.codegen.validation.TypeCheckingProcessingStep;
+import dagger.internal.codegen.validation.ValidationReport;
+import java.lang.annotation.Annotation;
+import javax.annotation.processing.Messager;
+import javax.inject.Inject;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+
+/**
+ * An annotation processor for {@link dagger.assisted.Assisted}-annotated types.
+ *
+ * <p>This processing step should run after {@link AssistedFactoryProcessingStep}.
+ */
+final class AssistedProcessingStep extends TypeCheckingProcessingStep<VariableElement> {
+ private final KotlinMetadataUtil kotlinMetadataUtil;
+ private final InjectionAnnotations injectionAnnotations;
+ private final DaggerElements elements;
+ private final DaggerTypes types;
+ private final Messager messager;
+
+ @Inject
+ AssistedProcessingStep(
+ KotlinMetadataUtil kotlinMetadataUtil,
+ InjectionAnnotations injectionAnnotations,
+ DaggerElements elements,
+ DaggerTypes types,
+ Messager messager) {
+ super(MoreElements::asVariable);
+ this.kotlinMetadataUtil = kotlinMetadataUtil;
+ this.injectionAnnotations = injectionAnnotations;
+ this.elements = elements;
+ this.types = types;
+ this.messager = messager;
+ }
+
+ @Override
+ public ImmutableSet<Class<? extends Annotation>> annotations() {
+ return ImmutableSet.of(Assisted.class);
+ }
+
+ @Override
+ protected void process(
+ VariableElement assisted, ImmutableSet<Class<? extends Annotation>> annotations) {
+ new AssistedValidator().validate(assisted).printMessagesTo(messager);
+ }
+
+ private final class AssistedValidator {
+ ValidationReport<VariableElement> validate(VariableElement assisted) {
+ ValidationReport.Builder<VariableElement> report = ValidationReport.about(assisted);
+
+ Element enclosingElement = assisted.getEnclosingElement();
+ if (!isAssistedInjectConstructor(enclosingElement)
+ && !isAssistedFactoryCreateMethod(enclosingElement)
+ // The generated java stubs for kotlin data classes contain a "copy" method that has
+ // the same parameters (and annotations) as the constructor, so just ignore it.
+ && !isKotlinDataClassCopyMethod(enclosingElement)) {
+ report.addError(
+ "@Assisted parameters can only be used within an @AssistedInject-annotated "
+ + "constructor.",
+ assisted);
+ }
+
+ injectionAnnotations
+ .getQualifiers(assisted)
+ .forEach(
+ qualifier ->
+ report.addError(
+ "Qualifiers cannot be used with @Assisted parameters.", assisted, qualifier));
+
+ return report.build();
+ }
+ }
+
+ private boolean isAssistedInjectConstructor(Element element) {
+ return element.getKind() == ElementKind.CONSTRUCTOR
+ && isAnnotationPresent(element, AssistedInject.class);
+ }
+
+ private boolean isAssistedFactoryCreateMethod(Element element) {
+ if (element.getKind() == ElementKind.METHOD) {
+ TypeElement enclosingElement = closestEnclosingTypeElement(element);
+ return AssistedInjectionAnnotations.isAssistedFactoryType(enclosingElement)
+ // This assumes we've already validated AssistedFactory and that a valid method exists.
+ && AssistedInjectionAnnotations.assistedFactoryMethod(enclosingElement, elements, types)
+ .equals(element);
+ }
+ return false;
+ }
+
+ private boolean isKotlinDataClassCopyMethod(Element element) {
+ // Note: This is a best effort. Technically, we could check the return type and parameters of
+ // the copy method to verify it's the one associated with the constructor, but I'd rather keep
+ // this simple to avoid encoding too many details of kapt's stubs. At worst, we'll be allowing
+ // an @Assisted annotation that has no affect, which is already true for many of Dagger's other
+ // annotations.
+ return element.getKind() == ElementKind.METHOD
+ && element.getSimpleName().contentEquals("copy")
+ && kotlinMetadataUtil.isDataClass(closestEnclosingTypeElement(element));
+ }
+}
diff --git a/java/dagger/internal/codegen/BUILD b/java/dagger/internal/codegen/BUILD
index 824a72e..be970be 100644
--- a/java/dagger/internal/codegen/BUILD
+++ b/java/dagger/internal/codegen/BUILD
@@ -15,485 +15,106 @@
# Description:
# A JSR-330 compliant dependency injection system for android and java
+load("@rules_java//java:defs.bzl", "java_library", "java_plugin")
+load(
+ "//:build_defs.bzl",
+ "POM_VERSION",
+)
+load("//tools:maven.bzl", "gen_maven_artifact")
+
package(default_visibility = ["//:src"])
-load("//:build_defs.bzl", "DOCLINT_HTML_AND_SYNTAX", "DOCLINT_REFERENCES")
-load("//tools:maven.bzl", "POM_VERSION", "pom_file")
-
-EXPERIMENTAL_VISUALIZER_SRCS = ["BindingNetworkVisualizer.java"]
-
-JAVAC_PLUGIN_MODULE_SRCS = ["JavacPluginModule.java"]
-
-KYTHE_SRCS = ["DaggerKythePlugin.java"]
-
-STATISTICS_COLLECTOR_SRCS = ["BindingGraphStatisticsCollector.java"]
-
-CODEGEN_SRCS = glob(
- ["*.java"],
- exclude = EXPERIMENTAL_VISUALIZER_SRCS + KYTHE_SRCS + STATISTICS_COLLECTOR_SRCS +
- JAVAC_PLUGIN_MODULE_SRCS,
-)
-
-CODEGEN_PLUGINS = [":bootstrap_compiler_plugin"]
-
-CODEGEN_SHARED_DEPS = [
- "@google_bazel_common//third_party/java/auto:service",
- "@google_bazel_common//third_party/java/auto:value",
- "@google_bazel_common//third_party/java/auto:common",
- "@google_bazel_common//third_party/java/checker_framework_annotations",
- "@google_bazel_common//third_party/java/error_prone:annotations",
- "@google_bazel_common//third_party/java/google_java_format",
- "@google_bazel_common//third_party/java/javapoet",
- "@bazel_tools//tools/jdk:langtools-neverlink",
- "@google_bazel_common//third_party/java/jsr250_annotations",
- "@google_bazel_common//third_party/java/jsr330_inject",
- "//java/dagger:core",
- "//java/dagger/internal/codegen/serialization",
- "//java/dagger/producers",
- "//java/dagger/model",
- "//java/dagger/spi",
- "//java/dagger/model:internal-proxies",
-]
-
-CODEGEN_DEPS = CODEGEN_SHARED_DEPS + [
- ":jdk-and-guava-extras",
- "@google_bazel_common//third_party/java/guava",
-]
-
-# Extra features for the JDK and Guava. This code is merged into both
-# the dagger-compiler and dagger-spi artifacts that are sent to Maven
-java_library(
- name = "jdk-and-guava-extras",
- srcs = [
- "DaggerGraphs.java",
- "DaggerStreams.java",
- "Optionals.java",
- ],
- plugins = CODEGEN_PLUGINS,
- tags = ["maven:merged"],
- deps = [
- "@google_bazel_common//third_party/java/guava",
- ],
-)
-
-# Common types needed across all of the codegen package
-java_library(
- name = "base",
- srcs = [
- "AnnotationProtoConverter.java",
- "ClearableCache.java",
- "CompilerOptions.java",
- "ComponentAnnotation.java",
- "ContributionType.java",
- "DaggerStatistics.java",
- "DaggerStatisticsCollectingProcessingStep.java",
- "DaggerStatisticsCollector.java",
- "DaggerStatisticsRecorder.java",
- "DiagnosticFormatting.java",
- "ElementFormatter.java",
- "FeatureStatus.java",
- "Formatter.java",
- "ForwardingCompilerOptions.java",
- "FrameworkTypes.java",
- "InjectionAnnotations.java",
- "Keys.java",
- "MapKeyAccessibility.java",
- "MapType.java",
- "ModuleAnnotation.java",
- "MoreAnnotationMirrors.java",
- "MoreAnnotationValues.java",
- "MultibindingAnnotations.java",
- "OptionalType.java",
- "ProcessingEnvironmentCompilerOptions.java",
- "ProcessingOptions.java",
- "RequestKinds.java",
- "Scopes.java",
- "SetType.java",
- "SimpleAnnotationMirror.java",
- "SimpleTypeAnnotationValue.java",
- "SourceFileGenerationException.java", # Used in :writing and :processor
- "SourceFileGenerator.java", # Needed by InjectBindingRegistry in :binding and also :writing
- "TypeCheckingProcessingStep.java",
- "TypeProtoConverter.java",
- "UniqueNameSet.java",
- "Util.java",
- "ValidationType.java",
- "package-info.java",
- ],
- plugins = CODEGEN_PLUGINS,
- tags = ["maven:merged"],
- deps = CODEGEN_DEPS + [
- "//java/dagger/internal/codegen/javapoet",
- "//java/dagger/internal/codegen/langmodel",
- ],
-)
-
-# Classes that help to build a model of the binding graph
-java_library(
- name = "binding",
- srcs = [
- "AnnotationExpression.java",
- "Binding.java",
- "BindingDeclaration.java",
- "BindingDeclarationFormatter.java",
- "BindingFactory.java",
- "BindingGraph.java",
- "BindingGraphConverter.java",
- "BindingGraphFactory.java",
- "BindingNode.java",
- "BindingRequest.java",
- "BindingType.java",
- "BindsTypeChecker.java",
- "ChildFactoryMethodEdgeImpl.java",
- "ComponentCreatorAnnotation.java",
- "ComponentCreatorDescriptor.java",
- "ComponentCreatorKind.java",
- "ComponentDescriptor.java",
- "ComponentDescriptorFactory.java",
- "ComponentKind.java",
- "ComponentNodeImpl.java",
- "ComponentRequirement.java",
- "ComponentTreeTraverser.java",
- "ConfigurationAnnotations.java", # Uses ModuleDescriptors
- "ContributionBinding.java",
- "DelegateDeclaration.java",
- "DependencyEdgeImpl.java",
- "DependencyRequestFactory.java",
- "DependencyRequestFormatter.java",
- "DependencyVariableNamer.java", # Used by SourceFiles
- "ErrorMessages.java", # Consider splitting this up as it pulls in too much
- "FrameworkDependency.java",
- "FrameworkField.java", # Used by SourceFiles
- "FrameworkType.java",
- "FrameworkTypeMapper.java",
- "InjectBindingRegistry.java",
- "InjectionSiteFactory.java",
- "KeyFactory.java",
- "KeyVariableNamer.java", # needs ConfigurationAnnotations, SourceFiles
- "MapKeys.java",
- "MembersInjectionBinding.java",
- "MethodSignature.java",
- "MethodSignatureFormatter.java",
- "ModuleDescriptor.java",
- "ModuleKind.java",
- "MultibindingDeclaration.java",
- "OptionalBindingDeclaration.java",
- "ProductionBinding.java",
- "ProvisionBinding.java",
- "ResolvedBindings.java",
- "SourceFiles.java", # Consider splitting this up?
- "SubcomponentCreatorBindingEdgeImpl.java",
- "SubcomponentDeclaration.java",
- ],
- plugins = CODEGEN_PLUGINS,
- tags = ["maven:merged"],
- deps = CODEGEN_DEPS + [
- ":base",
- "//java/dagger/internal/codegen/langmodel",
- "//java/dagger/internal/codegen/javapoet",
- ],
-)
-
-# Code related to validating the user-written Dagger code
-java_library(
- name = "validation",
- srcs = [
- "AnyBindingMethodValidator.java",
- "BindingElementValidator.java",
- "BindingGraphPlugins.java",
- "BindingGraphValidator.java",
- "BindingMethodProcessingStep.java",
- "BindingMethodValidator.java",
- "BindsInstanceElementValidator.java",
- "BindsInstanceMethodValidator.java",
- "BindsInstanceParameterValidator.java",
- "BindsInstanceProcessingStep.java",
- "BindsMethodValidator.java",
- "BindsOptionalOfMethodValidator.java",
- "ComponentCreatorValidator.java",
- "ComponentDescriptorValidator.java",
- "ComponentHierarchyValidator.java",
- "ComponentValidator.java",
- "DependencyRequestValidator.java",
- "DiagnosticReporterFactory.java",
- "InjectValidator.java",
- "MapKeyValidator.java",
- "MembersInjectionValidator.java",
- "ModuleValidator.java",
- "MultibindingAnnotationsProcessingStep.java",
- "MultibindsMethodValidator.java",
- "ProducesMethodValidator.java",
- "ProvidesMethodValidator.java",
- "Validation.java",
- "ValidationReport.java",
- ],
- plugins = CODEGEN_PLUGINS,
- tags = ["maven:merged"],
- deps = CODEGEN_DEPS + [
- ":base",
- ":binding",
- "//java/dagger/internal/codegen/langmodel",
- ],
-)
-
-java_library(
- name = "binding_graph_validation",
- srcs = [
- "DependencyCycleValidator.java",
- "DependsOnProductionExecutorValidator.java",
- "DuplicateBindingsValidator.java",
- "IncompatiblyScopedBindingsValidator.java",
- "InjectBindingValidator.java",
- "MapMultibindingValidator.java",
- "MissingBindingValidator.java",
- "NullableBindingValidator.java",
- "ProvisionDependencyOnProducerBindingValidator.java",
- "SubcomponentFactoryMethodValidator.java",
- ],
- plugins = CODEGEN_PLUGINS,
- tags = ["maven:merged"],
- deps = CODEGEN_DEPS + [
- ":base",
- ":binding",
- ":validation",
- "//java/dagger/internal/codegen/langmodel",
- ],
-)
-
-# Classes that assemble the model of the generated code and write to the Filer
-java_library(
- name = "writing",
- srcs = [
- "AnnotationCreatorGenerator.java",
- "AnonymousProviderCreationExpression.java",
- "BindingExpression.java",
- "ComponentBindingExpressions.java",
- "ComponentCreatorImplementation.java",
- "ComponentImplementation.java",
- "ComponentInstanceBindingExpression.java",
- "ComponentMethodBindingExpression.java",
- "ComponentProvisionBindingExpression.java",
- "ComponentRequirementBindingExpression.java",
- "ComponentRequirementExpression.java",
- "ComponentRequirementExpressions.java",
- "DeferredModifiableBindingExpression.java",
- "DelegateBindingExpression.java",
- "DelegatingFrameworkInstanceCreationExpression.java",
- "DependencyMethodProducerCreationExpression.java",
- "DependencyMethodProviderCreationExpression.java",
- "DerivedFromFrameworkInstanceBindingExpression.java",
- "FactoryGenerator.java",
- "FrameworkFieldInitializer.java",
- "FrameworkInstanceBindingExpression.java",
- "FrameworkInstanceSupplier.java",
- "GenerationCompilerOptions.java",
- "GwtCompatibility.java",
- "HjarSourceFileGenerator.java",
- "ImmediateFutureBindingExpression.java",
- "InaccessibleMapKeyProxyGenerator.java",
- "InjectionMethod.java",
- "InjectionMethods.java",
- "InjectionOrProvisionProviderCreationExpression.java",
- "InnerSwitchingProviders.java",
- "InstanceFactoryCreationExpression.java",
- "MapBindingExpression.java",
- "MapFactoryCreationExpression.java",
- "MemberSelect.java",
- "MembersInjectionBindingExpression.java",
- "MembersInjectionMethods.java",
- "MembersInjectorGenerator.java",
- "MembersInjectorProviderCreationExpression.java",
- "MethodBindingExpression.java",
- "MissingBindingExpression.java",
- "ModifiableAbstractMethodBindingExpression.java",
- "ModifiableBindingExpressions.java",
- "ModifiableBindingMethods.java",
- "ModifiableBindingType.java",
- "ModifiableConcreteMethodBindingExpression.java",
- "ModuleConstructorProxyGenerator.java",
- "ModuleGenerator.java",
- "ModuleProxies.java",
- "MonitoringModuleGenerator.java",
- "MonitoringModuleProcessingStep.java",
- "MultibindingExpression.java",
- "MultibindingFactoryCreationExpression.java",
- "OptionalBindingExpression.java",
- "OptionalFactories.java",
- "OptionalFactoryInstanceCreationExpression.java",
- "ParentComponent.java",
- "PerComponentImplementation.java",
- "PerGeneratedFile.java",
- "PrivateMethodBindingExpression.java",
- "ProducerCreationExpression.java",
- "ProducerEntryPointView.java",
- "ProducerFactoryGenerator.java",
- "ProducerFromProviderCreationExpression.java",
- "ProducerNodeInstanceBindingExpression.java",
- "ProviderInstanceBindingExpression.java",
- "PrunedConcreteMethodBindingExpression.java",
- "SetBindingExpression.java",
- "SetFactoryCreationExpression.java",
- "SimpleInvocationBindingExpression.java",
- "SimpleMethodBindingExpression.java",
- "SubcomponentCreatorBindingExpression.java",
- "SubcomponentNames.java",
- "SwitchingProviders.java",
- "TopLevel.java",
- "UnwrappedMapKeyGenerator.java",
- ],
- plugins = CODEGEN_PLUGINS,
- tags = ["maven:merged"],
- deps = CODEGEN_DEPS + [
- ":base",
- ":binding",
- "//java/dagger/internal/codegen/javapoet",
- "//java/dagger/internal/codegen/langmodel",
- ],
-)
-
-# The processor's "main", if you will
java_library(
name = "processor",
- srcs = [
- "BindingGraphValidationModule.java",
- "BindingMethodValidatorsModule.java",
- "ComponentCreatorImplementationFactory.java",
- "ComponentGenerator.java",
- "ComponentHjarProcessingStep.java",
- "ComponentImplementationBuilder.java",
- "ComponentImplementationFactory.java",
- "ComponentProcessingStep.java",
- "ComponentProcessor.java",
- "CurrentImplementationSubcomponent.java",
- "DeserializedComponentImplementationBuilder.java",
- "GenerationOptionsModule.java",
- "InjectBindingRegistryImpl.java",
- "InjectBindingRegistryModule.java",
- "InjectProcessingStep.java",
- "MapKeyProcessingStep.java",
- "ModuleProcessingStep.java",
- "ProcessingEnvironmentModule.java",
- "ProcessingRoundCacheModule.java",
- "SourceFileGeneratorsModule.java",
- "SpiModule.java",
- "SystemComponentsModule.java",
- "TopLevelImplementationComponent.java",
+ srcs = glob(
+ ["*.java"],
+ exclude = ["package-info.java"],
+ ),
+ plugins = [
+ "//java/dagger/internal/codegen/bootstrap",
],
- plugins = CODEGEN_PLUGINS,
tags = ["maven_coordinates=com.google.dagger:dagger-compiler:" + POM_VERSION],
- deps = CODEGEN_DEPS + [
- ":base",
- ":binding",
- ":binding_graph_validation",
- ":writing",
- ":validation",
- "//java/dagger/internal/codegen/javapoet",
- "//java/dagger/internal/codegen/langmodel",
- "@google_bazel_common//third_party/java/incap",
+ exports = [
+ "@google_bazel_common//third_party/java/jsr250_annotations", # Export for @Generated
],
-)
-
-pom_file(
- name = "pom",
- artifact_id = "dagger-compiler",
- artifact_name = "Dagger Compiler",
- targets = [
- ":processor",
- ":base",
- ":binding",
- ":binding_graph_validation",
- ":writing",
- ":validation",
- "//java/dagger/internal/codegen/serialization",
- "//java/dagger/internal/codegen/javapoet",
- ],
-)
-
-java_library(
- name = "javac-plugin-module",
- srcs = JAVAC_PLUGIN_MODULE_SRCS,
- plugins = [":component-codegen"],
- visibility = ["//visibility:private"],
deps = [
- ":base",
- ":binding",
- ":javac",
- ":processor",
+ ":package_info",
"//java/dagger:core",
+ "//java/dagger/internal/codegen/base",
+ "//java/dagger/internal/codegen/binding",
+ "//java/dagger/internal/codegen/bindinggraphvalidation",
+ "//java/dagger/internal/codegen/compileroption",
+ "//java/dagger/internal/codegen/componentgenerator",
+ "//java/dagger/internal/codegen/extension",
+ "//java/dagger/internal/codegen/javapoet",
+ "//java/dagger/internal/codegen/kotlin",
"//java/dagger/internal/codegen/langmodel",
- ],
-)
-
-java_library(
- name = "kythe",
- srcs = KYTHE_SRCS,
- plugins = [":component-codegen"],
- deps = [
- ":base",
- ":binding",
- ":javac",
- ":javac-plugin-module",
- ":kythe_plugin",
- ":processor",
- "//java/dagger:core",
- "//java/dagger/internal/codegen/langmodel",
- "//java/dagger/model",
+ "//java/dagger/internal/codegen/validation",
+ "//java/dagger/internal/codegen/writing",
+ "//java/dagger/internal/guava:collect",
"//java/dagger/producers",
- "@google_bazel_common//third_party/java/auto:common",
+ "//java/dagger/spi",
"@google_bazel_common//third_party/java/auto:service",
- "@google_bazel_common//third_party/java/guava",
+ "@google_bazel_common//third_party/java/auto:value",
+ "@google_bazel_common//third_party/java/error_prone:annotations",
+ "@google_bazel_common//third_party/java/google_java_format",
+ "@google_bazel_common//third_party/java/incap",
+ "@google_bazel_common//third_party/java/javapoet",
+ "@google_bazel_common//third_party/java/jsr330_inject",
+ "@maven//:com_google_auto_auto_common",
],
)
-# Replacement for @bazel_tools//third_party/java/jdk/langtools:javac, which seems to have gone away?
-java_import(
- name = "javac",
- jars = ["@bazel_tools//third_party/java/jdk/langtools:javac_jar"],
-)
-
-# A _deploy.jar consisting of the java_librarys in https://github.com/kythe/kythe needed to build a
-# Kythe plugin
-# TODO(ronshapiro): replace this with a http_archive of the next release in
-# https://github.com/kythe/kythe/releases
-java_import(
- name = "kythe_plugin",
- jars = ["kythe_plugin_deploy.jar"],
- neverlink = 1,
-)
-
-java_import(
- name = "bootstrap_compiler",
- jars = ["bootstrap_compiler_deploy.jar"],
- visibility = ["//visibility:private"],
-)
-
-java_plugin(
- name = "bootstrap_compiler_plugin",
- generates_api = 1,
- processor_class = "dagger.internal.codegen.ComponentProcessor",
- deps = [":bootstrap_compiler"],
-)
-
-load("@google_bazel_common//tools/javadoc:javadoc.bzl", "javadoc_library")
-
-javadoc_library(
- name = "codegen-javadoc",
- srcs = CODEGEN_SRCS,
- root_packages = ["dagger.internal.codegen"],
- deps = [":processor"],
-)
-
java_library(
- name = "check-package-javadoc",
- testonly = 1,
- srcs = CODEGEN_SRCS,
- javacopts = DOCLINT_HTML_AND_SYNTAX + DOCLINT_REFERENCES,
- plugins = CODEGEN_PLUGINS,
- deps = CODEGEN_DEPS + [
- "//java/dagger/internal/codegen/langmodel",
+ name = "package_info",
+ srcs = ["package-info.java"],
+ tags = ["maven:merged"],
+ deps = ["@google_bazel_common//third_party/java/error_prone:annotations"],
+)
+
+gen_maven_artifact(
+ name = "artifact",
+ artifact_coordinates = "com.google.dagger:dagger-compiler:" + POM_VERSION,
+ artifact_name = "Dagger Compiler",
+ artifact_target = ":processor",
+ artifact_target_libs = [
+ ":package_info",
+ "//java/dagger/internal/codegen/base",
+ "//java/dagger/internal/codegen/base:shared",
+ "//java/dagger/internal/codegen/binding",
+ "//java/dagger/internal/codegen/bindinggraphvalidation",
+ "//java/dagger/internal/codegen/compileroption",
+ "//java/dagger/internal/codegen/componentgenerator",
"//java/dagger/internal/codegen/javapoet",
- "@google_bazel_common//third_party/java/incap",
+ "//java/dagger/internal/codegen/kotlin",
+ "//java/dagger/internal/codegen/langmodel",
+ "//java/dagger/internal/codegen/validation",
+ "//java/dagger/internal/codegen/writing",
+ "//java/dagger/model:internal-proxies",
],
+ artifact_target_maven_deps = [
+ "com.google.auto:auto-common",
+ "com.google.code.findbugs:jsr305",
+ "com.google.dagger:dagger-producers",
+ "com.google.dagger:dagger-spi",
+ "com.google.dagger:dagger",
+ "com.google.googlejavaformat:google-java-format",
+ "com.google.guava:failureaccess",
+ "com.google.guava:guava",
+ "com.squareup:javapoet",
+ "javax.annotation:jsr250-api",
+ "javax.inject:javax.inject",
+ "net.ltgt.gradle.incap:incap",
+ "org.checkerframework:checker-compat-qual",
+ "org.jetbrains.kotlin:kotlin-stdlib",
+ "org.jetbrains.kotlinx:kotlinx-metadata-jvm",
+ ],
+ javadoc_root_packages = ["dagger.internal.codegen"],
+ # The javadocs should only include ComponentProcessor.java, since that is the only class used
+ # externally. Specifically, ComponentProcessor.forTesting() is required for testing SPI plugins.
+ javadoc_srcs = ["ComponentProcessor.java"],
+ shaded_deps = ["@maven//:com_google_auto_auto_common"],
+ shaded_rules = ["rule com.google.auto.common.** dagger.shaded.auto.common.@1"],
)
java_plugin(
@@ -509,19 +130,3 @@
],
deps = [":processor"],
)
-
-java_library(
- name = "statistics",
- srcs = STATISTICS_COLLECTOR_SRCS,
- plugins = [":component-codegen"],
- deps = [
- ":base",
- ":binding",
- ":javac",
- ":javac-plugin-module",
- ":processor",
- "//java/dagger:core",
- "//java/dagger/model",
- "@google_bazel_common//third_party/java/error_prone:check_api",
- ],
-)
diff --git a/java/dagger/internal/codegen/Binding.java b/java/dagger/internal/codegen/Binding.java
deleted file mode 100644
index c0f6b71..0000000
--- a/java/dagger/internal/codegen/Binding.java
+++ /dev/null
@@ -1,314 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Suppliers.memoize;
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static dagger.internal.codegen.DaggerStreams.toImmutableList;
-import static java.util.stream.Collectors.toSet;
-import static javax.lang.model.element.Modifier.ABSTRACT;
-import static javax.lang.model.element.Modifier.STATIC;
-
-import com.google.auto.value.AutoValue;
-import com.google.common.base.Supplier;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableSetMultimap;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Multimaps;
-import com.google.common.collect.Sets;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.BindingKind;
-import dagger.model.DependencyRequest;
-import dagger.model.Key;
-import dagger.model.Scope;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.Modifier;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.element.TypeParameterElement;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.TypeMirror;
-import javax.lang.model.util.SimpleTypeVisitor6;
-
-/**
- * An abstract type for classes representing a Dagger binding. Particularly, contains the {@link
- * Element} that generated the binding and the {@link DependencyRequest} instances that are required
- * to satisfy the binding, but leaves the specifics of the <i>mechanism</i> of the binding to the
- * subtypes.
- */
-abstract class Binding extends BindingDeclaration {
-
- /**
- * Returns {@code true} if using this binding requires an instance of the {@link
- * #contributingModule()}.
- */
- boolean requiresModuleInstance() {
- if (!bindingElement().isPresent() || !contributingModule().isPresent()) {
- return false;
- }
- Set<Modifier> modifiers = bindingElement().get().getModifiers();
- return !modifiers.contains(ABSTRACT) && !modifiers.contains(STATIC);
- }
-
- /**
- * Returns {@code true} if this binding may provide {@code null} instead of an instance of {@link
- * #key()}. Nullable bindings cannot be requested from {@linkplain DependencyRequest#isNullable()
- * non-nullable dependency requests}.
- */
- abstract boolean isNullable();
-
- /** The kind of binding this instance represents. */
- abstract BindingKind kind();
-
- /** The {@link BindingType} of this binding. */
- abstract BindingType bindingType();
-
- /** The {@link FrameworkType} of this binding. */
- final FrameworkType frameworkType() {
- return FrameworkType.forBindingType(bindingType());
- }
-
- /**
- * The explicit set of {@link DependencyRequest dependencies} required to satisfy this binding as
- * defined by the user-defined injection sites.
- */
- abstract ImmutableSet<DependencyRequest> explicitDependencies();
-
- /**
- * The set of {@link DependencyRequest dependencies} that are added by the framework rather than a
- * user-defined injection site. This returns an unmodifiable set.
- */
- // TODO(gak): this will eventually get changed to return a set of FrameworkDependency
- ImmutableSet<DependencyRequest> implicitDependencies() {
- return ImmutableSet.of();
- }
-
- private final Supplier<ImmutableSet<DependencyRequest>> dependencies =
- memoize(
- () -> {
- ImmutableSet<DependencyRequest> implicitDependencies = implicitDependencies();
- return ImmutableSet.copyOf(
- implicitDependencies.isEmpty()
- ? explicitDependencies()
- : Sets.union(implicitDependencies, explicitDependencies()));
- });
-
- /**
- * The set of {@link DependencyRequest dependencies} required to satisfy this binding. This is the
- * union of {@link #explicitDependencies()} and {@link #implicitDependencies()}. This returns an
- * unmodifiable set.
- */
- final ImmutableSet<DependencyRequest> dependencies() {
- return dependencies.get();
- }
-
- private final Supplier<ImmutableList<FrameworkDependency>> frameworkDependencies =
- memoize(
- () ->
- dependencyAssociations()
- .stream()
- .map(DependencyAssociation::frameworkDependency)
- .collect(toImmutableList()));
-
- /**
- * The framework dependencies of {@code binding}. There will be one element for each different
- * binding key in the <em>{@linkplain Binding#unresolved() unresolved}</em> version of {@code
- * binding}.
- *
- * <p>For example, given the following modules:
- *
- * <pre><code>
- * {@literal @Module} abstract class {@literal BaseModule<T>} {
- * {@literal @Provides} Foo provideFoo(T t, String string) {
- * return …;
- * }
- * }
- *
- * {@literal @Module} class StringModule extends {@literal BaseModule<String>} {}
- * </code></pre>
- *
- * Both dependencies of {@code StringModule.provideFoo} have the same binding key: {@code String}.
- * But there are still two dependencies, because in the unresolved binding they have different
- * binding keys:
- *
- * <dl>
- * <dt>{@code T}
- * <dd>{@code String t}
- * <dt>{@code String}
- * <dd>{@code String string}
- * </dl>
- *
- * <p>Note that the sets returned by this method when called on the same binding will be equal,
- * and their elements will be in the same order.
- */
- /* TODO(dpb): The stable-order postcondition is actually hard to verify in code for two equal
- * instances of Binding, because it really depends on the order of the binding's dependencies,
- * and two equal instances of Binding may have the same dependencies in a different order. */
- final ImmutableList<FrameworkDependency> frameworkDependencies() {
- return frameworkDependencies.get();
- }
-
- /**
- * Associates a {@link FrameworkDependency} with the set of {@link DependencyRequest} instances
- * that correlate for a binding.
- */
- @AutoValue
- abstract static class DependencyAssociation {
- abstract FrameworkDependency frameworkDependency();
-
- abstract ImmutableSet<DependencyRequest> dependencyRequests();
-
- static DependencyAssociation create(
- FrameworkDependency frameworkDependency, Iterable<DependencyRequest> dependencyRequests) {
- return new AutoValue_Binding_DependencyAssociation(
- frameworkDependency, ImmutableSet.copyOf(dependencyRequests));
- }
- }
-
- private final Supplier<ImmutableList<DependencyAssociation>> dependencyAssociations =
- memoize(
- () -> {
- FrameworkTypeMapper frameworkTypeMapper =
- FrameworkTypeMapper.forBindingType(bindingType());
- ImmutableList.Builder<DependencyAssociation> list = ImmutableList.builder();
- for (Set<DependencyRequest> requests : groupByUnresolvedKey()) {
- list.add(
- DependencyAssociation.create(
- FrameworkDependency.create(
- getOnlyElement(
- requests.stream().map(DependencyRequest::key).collect(toSet())),
- frameworkTypeMapper.getFrameworkType(requests)),
- requests));
- }
- return list.build();
- });
-
- /**
- * Returns the same {@link FrameworkDependency} instances from {@link #frameworkDependencies}, but
- * with the set of {@link DependencyRequest} instances with which each is associated.
- *
- * <p>Ths method returns a list of {@link Map.Entry entries} rather than a {@link Map} or {@link
- * com.google.common.collect.Multimap} because any given {@link FrameworkDependency} may appear
- * multiple times if the {@linkplain Binding#unresolved() unresolved} binding requires it. If that
- * distinction is not important, the entries can be merged into a single mapping.
- */
- final ImmutableList<DependencyAssociation> dependencyAssociations() {
- return dependencyAssociations.get();
- }
-
- private final Supplier<ImmutableMap<DependencyRequest, FrameworkDependency>>
- frameworkDependenciesMap =
- memoize(
- () -> {
- ImmutableMap.Builder<DependencyRequest, FrameworkDependency> frameworkDependencies =
- ImmutableMap.builder();
- for (DependencyAssociation dependencyAssociation : dependencyAssociations()) {
- for (DependencyRequest dependencyRequest :
- dependencyAssociation.dependencyRequests()) {
- frameworkDependencies.put(
- dependencyRequest, dependencyAssociation.frameworkDependency());
- }
- }
- return frameworkDependencies.build();
- });
-
- /**
- * Returns the mapping from each {@linkplain #dependencies dependency} to its associated {@link
- * FrameworkDependency}.
- */
- final ImmutableMap<DependencyRequest, FrameworkDependency>
- dependenciesToFrameworkDependenciesMap() {
- return frameworkDependenciesMap.get();
- }
-
- /**
- * Groups {@code binding}'s implicit dependencies by their binding key, using the dependency keys
- * from the {@link Binding#unresolved()} binding if it exists.
- */
- private ImmutableList<Set<DependencyRequest>> groupByUnresolvedKey() {
- ImmutableSetMultimap.Builder<Key, DependencyRequest> dependenciesByKeyBuilder =
- ImmutableSetMultimap.builder();
- Iterator<DependencyRequest> dependencies = dependencies().iterator();
- Binding unresolved = unresolved().isPresent() ? unresolved().get() : this;
- Iterator<DependencyRequest> unresolvedDependencies = unresolved.dependencies().iterator();
- while (dependencies.hasNext()) {
- dependenciesByKeyBuilder.put(unresolvedDependencies.next().key(), dependencies.next());
- }
- return ImmutableList.copyOf(
- Multimaps.asMap(
- dependenciesByKeyBuilder.orderValuesBy(SourceFiles.DEPENDENCY_ORDERING).build())
- .values());
- }
-
- /**
- * If this binding's key's type parameters are different from those of the
- * {@link #bindingTypeElement()}, this is the binding for the {@link #bindingTypeElement()}'s
- * unresolved type.
- */
- abstract Optional<? extends Binding> unresolved();
-
- Optional<Scope> scope() {
- return Optional.empty();
- }
-
- // TODO(sameb): Remove the TypeElement parameter and pull it from the TypeMirror.
- static boolean hasNonDefaultTypeParameters(
- TypeElement element, TypeMirror type, DaggerTypes types) {
- // If the element has no type parameters, nothing can be wrong.
- if (element.getTypeParameters().isEmpty()) {
- return false;
- }
-
- List<TypeMirror> defaultTypes = Lists.newArrayList();
- for (TypeParameterElement parameter : element.getTypeParameters()) {
- defaultTypes.add(parameter.asType());
- }
-
- List<TypeMirror> actualTypes =
- type.accept(
- new SimpleTypeVisitor6<List<TypeMirror>, Void>() {
- @Override
- protected List<TypeMirror> defaultAction(TypeMirror e, Void p) {
- return ImmutableList.of();
- }
-
- @Override
- public List<TypeMirror> visitDeclared(DeclaredType t, Void p) {
- return ImmutableList.<TypeMirror>copyOf(t.getTypeArguments());
- }
- },
- null);
-
- // The actual type parameter size can be different if the user is using a raw type.
- if (defaultTypes.size() != actualTypes.size()) {
- return true;
- }
-
- for (int i = 0; i < defaultTypes.size(); i++) {
- if (!types.isSameType(defaultTypes.get(i), actualTypes.get(i))) {
- return true;
- }
- }
- return false;
- }
-}
diff --git a/java/dagger/internal/codegen/BindingDeclaration.java b/java/dagger/internal/codegen/BindingDeclaration.java
deleted file mode 100644
index c9520cd..0000000
--- a/java/dagger/internal/codegen/BindingDeclaration.java
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.model.BindingKind;
-import dagger.model.Key;
-import java.util.Optional;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.TypeElement;
-
-/** An object that declares or specifies a binding. */
-abstract class BindingDeclaration {
-
- /** The {@link Key} of this declaration. */
- abstract Key key();
-
- /**
- * The {@link Element} that declares this binding. Absent for {@linkplain BindingKind binding
- * kinds} that are not always declared by exactly one element.
- *
- * <p>For example, consider {@link BindingKind#MULTIBOUND_SET}. A component with many
- * {@code @IntoSet} bindings for the same key will have a synthetic binding that depends on all
- * contributions, but with no identifiying binding element. A {@code @Multibinds} method will also
- * contribute a synthetic binding, but since multiple {@code @Multibinds} methods can coexist in
- * the same component (and contribute to one single binding), it has no binding element.
- */
- // TODO(ronshapiro): examine whether this wildcard+bound have any benefit.
- // We never actually refer to the overridden bindingElement methods directly in a way which needs
- // anything more than an Element. Removing the wildcard would allow for simpler user-written code
- // when the binding element is passed to a method.
- abstract Optional<Element> bindingElement();
-
- /**
- * The type enclosing the {@link #bindingElement()}, or {@link Optional#empty()} if {@link
- * #bindingElement()} is empty.
- */
- final Optional<TypeElement> bindingTypeElement() {
- return bindingElement().map(DaggerElements::closestEnclosingTypeElement);
- }
-
- /**
- * The installed module class that contributed the {@link #bindingElement()}. May be a subclass of
- * the class that contains {@link #bindingElement()}. Absent if {@link #bindingElement()} is
- * empty.
- */
- abstract Optional<TypeElement> contributingModule();
-}
diff --git a/java/dagger/internal/codegen/BindingDeclarationFormatter.java b/java/dagger/internal/codegen/BindingDeclarationFormatter.java
deleted file mode 100644
index d850165..0000000
--- a/java/dagger/internal/codegen/BindingDeclarationFormatter.java
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.collect.Sets.immutableEnumSet;
-import static dagger.internal.codegen.DiagnosticFormatting.stripCommonTypePrefixes;
-import static dagger.internal.codegen.ElementFormatter.elementToString;
-import static javax.lang.model.element.ElementKind.PARAMETER;
-import static javax.lang.model.type.TypeKind.DECLARED;
-import static javax.lang.model.type.TypeKind.EXECUTABLE;
-
-import com.google.auto.common.MoreElements;
-import com.google.auto.common.MoreTypes;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-import javax.inject.Inject;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.TypeKind;
-
-/**
- * Formats a {@link BindingDeclaration} into a {@link String} suitable for use in error messages.
- */
-final class BindingDeclarationFormatter extends Formatter<BindingDeclaration> {
- private static final ImmutableSet<TypeKind> FORMATTABLE_ELEMENT_TYPE_KINDS =
- immutableEnumSet(EXECUTABLE, DECLARED);
-
- private final MethodSignatureFormatter methodSignatureFormatter;
-
- @Inject
- BindingDeclarationFormatter(MethodSignatureFormatter methodSignatureFormatter) {
- this.methodSignatureFormatter = methodSignatureFormatter;
- }
-
- /**
- * Returns {@code true} for declarations that this formatter can format. Specifically bindings
- * from subcomponent declarations or those with {@linkplain BindingDeclaration#bindingElement()
- * binding elements} that are methods, constructors, or types.
- */
- boolean canFormat(BindingDeclaration bindingDeclaration) {
- if (bindingDeclaration instanceof SubcomponentDeclaration) {
- return true;
- }
- if (bindingDeclaration.bindingElement().isPresent()) {
- Element bindingElement = bindingDeclaration.bindingElement().get();
- return bindingElement.getKind().equals(PARAMETER)
- || FORMATTABLE_ELEMENT_TYPE_KINDS.contains(bindingElement.asType().getKind());
- }
- // TODO(dpb): validate whether what this is doing is correct
- return false;
- }
-
- @Override
- public String format(BindingDeclaration bindingDeclaration) {
- if (bindingDeclaration instanceof SubcomponentDeclaration) {
- return formatSubcomponentDeclaration((SubcomponentDeclaration) bindingDeclaration);
- }
-
- if (bindingDeclaration.bindingElement().isPresent()) {
- Element bindingElement = bindingDeclaration.bindingElement().get();
- if (bindingElement.getKind().equals(PARAMETER)) {
- return elementToString(bindingElement);
- }
-
- switch (bindingElement.asType().getKind()) {
- case EXECUTABLE:
- return methodSignatureFormatter.format(
- MoreElements.asExecutable(bindingElement),
- bindingDeclaration
- .contributingModule()
- .map(module -> MoreTypes.asDeclared(module.asType())));
-
- case DECLARED:
- return stripCommonTypePrefixes(bindingElement.asType().toString());
-
- default:
- throw new IllegalArgumentException(
- "Formatting unsupported for element: " + bindingElement);
- }
- }
-
- return String.format(
- "Dagger-generated binding for %s",
- stripCommonTypePrefixes(bindingDeclaration.key().toString()));
- }
-
- private String formatSubcomponentDeclaration(SubcomponentDeclaration subcomponentDeclaration) {
- ImmutableList<TypeElement> moduleSubcomponents =
- subcomponentDeclaration.moduleAnnotation().subcomponents();
- int index = moduleSubcomponents.indexOf(subcomponentDeclaration.subcomponentType());
- StringBuilder annotationValue = new StringBuilder();
- if (moduleSubcomponents.size() != 1) {
- annotationValue.append("{");
- }
- annotationValue.append(
- formatArgumentInList(
- index,
- moduleSubcomponents.size(),
- subcomponentDeclaration.subcomponentType().getQualifiedName() + ".class"));
- if (moduleSubcomponents.size() != 1) {
- annotationValue.append("}");
- }
-
- return String.format(
- "@%s(subcomponents = %s) for %s",
- subcomponentDeclaration.moduleAnnotation().annotationClass().getSimpleName(),
- annotationValue,
- subcomponentDeclaration.contributingModule().get());
- }
-}
diff --git a/java/dagger/internal/codegen/BindingElementValidator.java b/java/dagger/internal/codegen/BindingElementValidator.java
deleted file mode 100644
index 0051912..0000000
--- a/java/dagger/internal/codegen/BindingElementValidator.java
+++ /dev/null
@@ -1,383 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Verify.verifyNotNull;
-import static dagger.internal.codegen.InjectionAnnotations.getQualifiers;
-import static dagger.internal.codegen.MapKeys.getMapKeys;
-import static dagger.internal.codegen.Scopes.scopesOf;
-import static dagger.internal.codegen.Util.reentrantComputeIfAbsent;
-import static dagger.internal.codegen.langmodel.DaggerElements.getAnnotationMirror;
-import static javax.lang.model.type.TypeKind.ARRAY;
-import static javax.lang.model.type.TypeKind.DECLARED;
-import static javax.lang.model.type.TypeKind.TYPEVAR;
-import static javax.lang.model.type.TypeKind.VOID;
-
-import com.google.common.collect.ImmutableSet;
-import com.google.errorprone.annotations.FormatMethod;
-import dagger.MapKey;
-import dagger.Provides;
-import dagger.model.Key;
-import dagger.model.Scope;
-import dagger.multibindings.ElementsIntoSet;
-import dagger.multibindings.IntoMap;
-import dagger.producers.Produces;
-import java.lang.annotation.Annotation;
-import java.util.Formatter;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Optional;
-import javax.inject.Qualifier;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.type.TypeKind;
-import javax.lang.model.type.TypeMirror;
-
-/** A validator for elements that represent binding declarations. */
-abstract class BindingElementValidator<E extends Element> {
- private final Class<? extends Annotation> bindingAnnotation;
- private final AllowsMultibindings allowsMultibindings;
- private final AllowsScoping allowsScoping;
- private final Map<E, ValidationReport<E>> cache = new HashMap<>();
-
- /**
- * Creates a validator object.
- *
- * @param bindingAnnotation the annotation on an element that identifies it as a binding element
- */
- protected BindingElementValidator(
- Class<? extends Annotation> bindingAnnotation,
- AllowsMultibindings allowsMultibindings,
- AllowsScoping allowsScoping) {
- this.bindingAnnotation = bindingAnnotation;
- this.allowsMultibindings = allowsMultibindings;
- this.allowsScoping = allowsScoping;
- }
-
- /** Returns a {@link ValidationReport} for {@code element}. */
- final ValidationReport<E> validate(E element) {
- return reentrantComputeIfAbsent(cache, element, this::validateUncached);
- }
-
- private ValidationReport<E> validateUncached(E element) {
- return elementValidator(element).validate();
- }
-
- /**
- * Returns an error message of the form "<{@link #bindingElements()}> <i>rule</i>", where
- * <i>rule</i> comes from calling {@link String#format(String, Object...)} on {@code ruleFormat}
- * and the other arguments.
- */
- @FormatMethod
- protected final String bindingElements(String ruleFormat, Object... args) {
- return new Formatter().format("%s ", bindingElements()).format(ruleFormat, args).toString();
- }
-
- /**
- * The kind of elements that this validator validates. Should be plural. Used for error reporting.
- */
- protected abstract String bindingElements();
-
- /** The verb describing the {@link ElementValidator#bindingElementType()} in error messages. */
- // TODO(ronshapiro,dpb): improve the name of this method and it's documentation.
- protected abstract String bindingElementTypeVerb();
-
- /** The error message when a binding element has a bad type. */
- protected String badTypeMessage() {
- return bindingElements(
- "must %s a primitive, an array, a type variable, or a declared type",
- bindingElementTypeVerb());
- }
-
- /**
- * The error message when a the type for a binding element with {@link
- * ElementsIntoSet @ElementsIntoSet} or {@code SET_VALUES} is a not set type.
- */
- protected String elementsIntoSetNotASetMessage() {
- return bindingElements(
- "annotated with @ElementsIntoSet must %s a Set", bindingElementTypeVerb());
- }
-
- /**
- * The error message when a the type for a binding element with {@link
- * ElementsIntoSet @ElementsIntoSet} or {@code SET_VALUES} is a raw set.
- */
- protected String elementsIntoSetRawSetMessage() {
- return bindingElements(
- "annotated with @ElementsIntoSet cannot %s a raw Set", bindingElementTypeVerb());
- }
-
- /*** Returns an {@link ElementValidator} for validating the given {@code element}. */
- protected abstract ElementValidator elementValidator(E element);
-
- /** Validator for a single binding element. */
- protected abstract class ElementValidator {
- protected final E element;
- protected final ValidationReport.Builder<E> report;
-
- protected ElementValidator(E element) {
- this.element = element;
- this.report = ValidationReport.about(element);
- }
-
- /** Checks the element for validity. */
- private ValidationReport<E> validate() {
- checkType();
- checkQualifiers();
- checkMapKeys();
- checkMultibindings();
- checkScopes();
- checkAdditionalProperties();
- return report.build();
- }
-
- /** Check any additional properties of the element. Does nothing by default. */
- protected void checkAdditionalProperties() {}
-
- /**
- * The type declared by this binding element. This may differ from a binding's {@link
- * Key#type()}, for example in multibindings. An {@link Optional#empty()} return value indicates
- * that the contributed type is ambiguous or missing, i.e. a {@code @BindsInstance} method with
- * zero or many parameters.
- */
- // TODO(dpb): should this be an ImmutableList<TypeMirror>, with this class checking the size?
- protected abstract Optional<TypeMirror> bindingElementType();
-
- /**
- * Adds an error if the {@link #bindingElementType() binding element type} is not appropriate.
- *
- * <p>Adds an error if the type is not a primitive, array, declared type, or type variable.
- *
- * <p>If the binding is not a multibinding contribution, adds an error if the type is a
- * framework type.
- *
- * <p>If the element has {@link ElementsIntoSet @ElementsIntoSet} or {@code SET_VALUES}, adds an
- * error if the type is not a {@code Set<T>} for some {@code T}
- */
- protected void checkType() {
- switch (ContributionType.fromBindingElement(element)) {
- case UNIQUE:
- /* Validate that a unique binding is not attempting to bind a framework type. This
- * validation is only appropriate for unique bindings because multibindings may collect
- * framework types. E.g. Set<Provider<Foo>> is perfectly reasonable. */
- checkFrameworkType();
- // fall through
-
- case SET:
- case MAP:
- bindingElementType().ifPresent(type -> checkKeyType(type));
- break;
-
- case SET_VALUES:
- checkSetValuesType();
- }
- }
-
- /**
- * Adds an error if {@code keyType} is not a primitive, declared type, array, or type variable.
- */
- protected void checkKeyType(TypeMirror keyType) {
- TypeKind kind = keyType.getKind();
- if (kind.equals(VOID)) {
- report.addError(bindingElements("must %s a value (not void)", bindingElementTypeVerb()));
- } else if (!(kind.isPrimitive()
- || kind.equals(DECLARED)
- || kind.equals(ARRAY)
- || kind.equals(TYPEVAR))) {
- report.addError(badTypeMessage());
- }
- }
-
- /**
- * Adds an error if the type for an element with {@link ElementsIntoSet @ElementsIntoSet} or
- * {@code SET_VALUES} is not a a {@code Set<T>} for a reasonable {@code T}.
- */
- // TODO(gak): should we allow "covariant return" for set values?
- protected void checkSetValuesType() {
- bindingElementType().ifPresent(keyType -> checkSetValuesType(keyType));
- }
-
- /** Adds an error if {@code type} is not a {@code Set<T>} for a reasonable {@code T}. */
- protected final void checkSetValuesType(TypeMirror type) {
- if (!SetType.isSet(type)) {
- report.addError(elementsIntoSetNotASetMessage());
- } else {
- SetType setType = SetType.from(type);
- if (setType.isRawType()) {
- report.addError(elementsIntoSetRawSetMessage());
- } else {
- checkKeyType(setType.elementType());
- }
- }
- }
-
- /**
- * Adds an error if the element has more than one {@linkplain Qualifier qualifier} annotation.
- */
- private void checkQualifiers() {
- ImmutableSet<? extends AnnotationMirror> qualifiers = getQualifiers(element);
- if (qualifiers.size() > 1) {
- for (AnnotationMirror qualifier : qualifiers) {
- report.addError(
- bindingElements("may not use more than one @Qualifier"),
- element,
- qualifier);
- }
- }
- }
-
- /**
- * Adds an error if an {@link IntoMap @IntoMap} element doesn't have exactly one {@link
- * MapKey @MapKey} annotation, or if an element that is {@link IntoMap @IntoMap} has any.
- */
- private void checkMapKeys() {
- if (!allowsMultibindings.allowsMultibindings()) {
- return;
- }
- ImmutableSet<? extends AnnotationMirror> mapKeys = getMapKeys(element);
- if (ContributionType.fromBindingElement(element).equals(ContributionType.MAP)) {
- switch (mapKeys.size()) {
- case 0:
- report.addError(bindingElements("of type map must declare a map key"));
- break;
- case 1:
- break;
- default:
- report.addError(bindingElements("may not have more than one map key"));
- break;
- }
- } else if (!mapKeys.isEmpty()) {
- report.addError(bindingElements("of non map type cannot declare a map key"));
- }
- }
-
- /**
- * Adds errors if:
- *
- * <ul>
- * <li>the element doesn't allow {@linkplain MultibindingAnnotations multibinding annotations}
- * and has any
- * <li>the element does allow them but has more than one
- * <li>the element has a multibinding annotation and its {@link Provides} or {@link Produces}
- * annotation has a {@code type} parameter.
- * </ul>
- */
- private void checkMultibindings() {
- ImmutableSet<AnnotationMirror> multibindingAnnotations =
- MultibindingAnnotations.forElement(element);
-
- switch (allowsMultibindings) {
- case NO_MULTIBINDINGS:
- for (AnnotationMirror annotation : multibindingAnnotations) {
- report.addError(
- bindingElements("cannot have multibinding annotations"),
- element,
- annotation);
- }
- break;
-
- case ALLOWS_MULTIBINDINGS:
- if (multibindingAnnotations.size() > 1) {
- for (AnnotationMirror annotation : multibindingAnnotations) {
- report.addError(
- bindingElements("cannot have more than one multibinding annotation"),
- element,
- annotation);
- }
- }
- break;
- }
-
- // TODO(ronshapiro): move this into ProvidesMethodValidator
- if (bindingAnnotation.equals(Provides.class)) {
- AnnotationMirror bindingAnnotationMirror =
- getAnnotationMirror(element, bindingAnnotation).get();
- boolean usesProvidesType = false;
- for (ExecutableElement member : bindingAnnotationMirror.getElementValues().keySet()) {
- usesProvidesType |= member.getSimpleName().contentEquals("type");
- }
- if (usesProvidesType && !multibindingAnnotations.isEmpty()) {
- report.addError(
- "@Provides.type cannot be used with multibinding annotations", element);
- }
- }
- }
-
- /**
- * Adds an error if the element has a scope but doesn't allow scoping, or if it has more than
- * one {@linkplain Scope scope} annotation.
- */
- private void checkScopes() {
- ImmutableSet<Scope> scopes = scopesOf(element);
- String error = null;
- switch (allowsScoping) {
- case ALLOWS_SCOPING:
- if (scopes.size() <= 1) {
- return;
- }
- error = bindingElements("cannot use more than one @Scope");
- break;
- case NO_SCOPING:
- error = bindingElements("cannot be scoped");
- break;
- }
- verifyNotNull(error);
- for (Scope scope : scopes) {
- report.addError(error, element, scope.scopeAnnotation());
- }
- }
-
- /**
- * Adds an error if the {@link #bindingElementType() type} is a {@linkplain FrameworkTypes
- * framework type}.
- */
- private void checkFrameworkType() {
- if (bindingElementType().filter(FrameworkTypes::isFrameworkType).isPresent()) {
- report.addError(bindingElements("must not %s framework types", bindingElementTypeVerb()));
- }
- }
- }
-
- /** Whether to check multibinding annotations. */
- enum AllowsMultibindings {
- /**
- * This element disallows multibinding annotations, so don't bother checking for their validity.
- * {@link MultibindingAnnotationsProcessingStep} will add errors if the element has any
- * multibinding annotations.
- */
- NO_MULTIBINDINGS,
-
- /** This element allows multibinding annotations, so validate them. */
- ALLOWS_MULTIBINDINGS,
- ;
-
- private boolean allowsMultibindings() {
- return this == ALLOWS_MULTIBINDINGS;
- }
- }
-
- /** How to check scoping annotations. */
- enum AllowsScoping {
- /** This element disallows scoping, so check that no scope annotations are present. */
- NO_SCOPING,
-
- /** This element allows scoping, so validate that there's at most one scope annotation. */
- ALLOWS_SCOPING,
- ;
- }
-}
diff --git a/java/dagger/internal/codegen/BindingExpression.java b/java/dagger/internal/codegen/BindingExpression.java
deleted file mode 100644
index 65200f7..0000000
--- a/java/dagger/internal/codegen/BindingExpression.java
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
-
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import dagger.internal.codegen.ComponentDescriptor.ComponentMethodDescriptor;
-import dagger.internal.codegen.ModifiableBindingMethods.ModifiableBindingMethod;
-import dagger.internal.codegen.javapoet.Expression;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import javax.lang.model.type.TypeMirror;
-
-/** A factory of code expressions used to access a single request for a binding in a component. */
-// TODO(user): Rename this to RequestExpression?
-abstract class BindingExpression {
-
- /**
- * Returns an expression that evaluates to the value of a request based on the given requesting
- * class.
- *
- * @param requestingClass the class that will contain the expression
- */
- abstract Expression getDependencyExpression(ClassName requestingClass);
-
- /**
- * Equivalent to {@link #getDependencyExpression} that is used only when the request is for an
- * implementation of a component method. By default, just delegates to {@link
- * #getDependencyExpression}.
- */
- Expression getDependencyExpressionForComponentMethod(
- ComponentMethodDescriptor componentMethod, ComponentImplementation component) {
- return getDependencyExpression(component.name());
- }
-
- /** Returns {@code true} if this binding expression should be encapsulated in a method. */
- boolean requiresMethodEncapsulation() {
- return false;
- }
-
- /**
- * Returns an expression for the implementation of a component method with the given request.
- *
- * @param component the component that will contain the implemented method
- */
- CodeBlock getComponentMethodImplementation(
- ComponentMethodDescriptor componentMethod, ComponentImplementation component) {
- // By default, just delegate to #getDependencyExpression().
- return CodeBlock.of(
- "return $L;",
- getDependencyExpressionForComponentMethod(componentMethod, component).codeBlock());
- }
-
- /**
- * Returns an expression for the implementation of a modifiable binding method for the given
- * component.
- */
- CodeBlock getModifiableBindingMethodImplementation(
- ModifiableBindingMethod modifiableBindingMethod,
- ComponentImplementation component,
- DaggerTypes types) {
- Expression dependencyExpression = getDependencyExpression(component.name());
-
- // It's possible to have a case where a modifiable component method delegates to another
- // binding method from an enclosing class that is not itself a component method. In that case,
- // the enclosing class's method may return a publicly accessible type, but the nested class will
- // have a return type that is defined by the component method. In that case, a downcast is
- // necessary so that the return statement is valid.
- //
- // E.g.:
- //
- // public class DaggerAncestor implements Ancestor {
- // protected Object packagePrivateModifiable() { ... }
- //
- // protected class LeafImpl extends DaggerLeaf {
- // @Override
- // public final PackagePrivateModifiable componentMethod() {
- // return (PackagePrivateModifiable) DaggerAncestor.this.packagePrivateModifiable();
- // }
- // }
- // }
- //
- // DaggerAncestor.packagePrivateModifiable returns Object even though the actual instance's type
- // is PackagePrivateModifiable. So a cast is necessary.
- //
- // This isn't necessary for getComponentMethodImplementation() because that's only used for
- // non-modifiable bindings
- TypeMirror returnType = modifiableBindingMethod.returnType();
- if (!types.isAssignable(dependencyExpression.type(), returnType)
- && isTypeAccessibleFrom(returnType, component.name().packageName())) {
- dependencyExpression = dependencyExpression.castTo(returnType);
- }
-
- return CodeBlock.of("return $L;", dependencyExpression.codeBlock());
- }
-}
diff --git a/java/dagger/internal/codegen/BindingFactory.java b/java/dagger/internal/codegen/BindingFactory.java
deleted file mode 100644
index 564b412..0000000
--- a/java/dagger/internal/codegen/BindingFactory.java
+++ /dev/null
@@ -1,508 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreElements.isAnnotationPresent;
-import static com.google.auto.common.MoreTypes.asDeclared;
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.base.Preconditions.checkState;
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static dagger.internal.codegen.Binding.hasNonDefaultTypeParameters;
-import static dagger.internal.codegen.ComponentDescriptor.isComponentProductionMethod;
-import static dagger.internal.codegen.ConfigurationAnnotations.getNullableType;
-import static dagger.internal.codegen.ContributionBinding.bindingKindForMultibindingKey;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.internal.codegen.InjectionAnnotations.getQualifier;
-import static dagger.internal.codegen.MapKeys.getMapKey;
-import static dagger.internal.codegen.MoreAnnotationMirrors.wrapOptionalInEquivalence;
-import static dagger.internal.codegen.Scopes.uniqueScopeOf;
-import static dagger.model.BindingKind.BOUND_INSTANCE;
-import static dagger.model.BindingKind.COMPONENT;
-import static dagger.model.BindingKind.COMPONENT_DEPENDENCY;
-import static dagger.model.BindingKind.COMPONENT_PRODUCTION;
-import static dagger.model.BindingKind.COMPONENT_PROVISION;
-import static dagger.model.BindingKind.DELEGATE;
-import static dagger.model.BindingKind.INJECTION;
-import static dagger.model.BindingKind.MEMBERS_INJECTOR;
-import static dagger.model.BindingKind.OPTIONAL;
-import static dagger.model.BindingKind.PRODUCTION;
-import static dagger.model.BindingKind.PROVISION;
-import static dagger.model.BindingKind.SUBCOMPONENT_CREATOR;
-import static javax.lang.model.element.ElementKind.CONSTRUCTOR;
-import static javax.lang.model.element.ElementKind.METHOD;
-
-import com.google.auto.common.MoreElements;
-import com.google.auto.common.MoreTypes;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableSortedSet;
-import com.google.common.collect.Iterables;
-import dagger.Module;
-import dagger.internal.codegen.MembersInjectionBinding.InjectionSite;
-import dagger.internal.codegen.ProductionBinding.ProductionKind;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.DependencyRequest;
-import dagger.model.Key;
-import dagger.model.RequestKind;
-import dagger.producers.Produced;
-import dagger.producers.Producer;
-import java.util.Optional;
-import java.util.function.BiFunction;
-import javax.inject.Inject;
-import javax.inject.Provider;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.element.VariableElement;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.ExecutableType;
-import javax.lang.model.type.TypeMirror;
-
-/** A factory for {@link Binding} objects. */
-final class BindingFactory {
- private final DaggerTypes types;
- private final KeyFactory keyFactory;
- private final DependencyRequestFactory dependencyRequestFactory;
- private final InjectionSiteFactory injectionSiteFactory;
- private final DaggerElements elements;
-
- @Inject
- BindingFactory(
- DaggerTypes types,
- DaggerElements elements,
- KeyFactory keyFactory,
- DependencyRequestFactory dependencyRequestFactory,
- InjectionSiteFactory injectionSiteFactory) {
- this.types = types;
- this.elements = elements;
- this.keyFactory = keyFactory;
- this.dependencyRequestFactory = dependencyRequestFactory;
- this.injectionSiteFactory = injectionSiteFactory;
- }
-
- /**
- * Returns an {@link dagger.model.BindingKind#INJECTION} binding.
- *
- * @param constructorElement the {@code @Inject}-annotated constructor
- * @param resolvedType the parameterized type if the constructor is for a generic class and the
- * binding should be for the parameterized type
- */
- // TODO(dpb): See if we can just pass the parameterized type and not also the constructor.
- ProvisionBinding injectionBinding(
- ExecutableElement constructorElement, Optional<TypeMirror> resolvedType) {
- checkArgument(constructorElement.getKind().equals(CONSTRUCTOR));
- checkArgument(isAnnotationPresent(constructorElement, Inject.class));
- checkArgument(!getQualifier(constructorElement).isPresent());
-
- ExecutableType constructorType = MoreTypes.asExecutable(constructorElement.asType());
- DeclaredType constructedType =
- MoreTypes.asDeclared(constructorElement.getEnclosingElement().asType());
- // If the class this is constructing has some type arguments, resolve everything.
- if (!constructedType.getTypeArguments().isEmpty() && resolvedType.isPresent()) {
- DeclaredType resolved = MoreTypes.asDeclared(resolvedType.get());
- // Validate that we're resolving from the correct type.
- checkState(
- types.isSameType(types.erasure(resolved), types.erasure(constructedType)),
- "erased expected type: %s, erased actual type: %s",
- types.erasure(resolved),
- types.erasure(constructedType));
- constructorType = MoreTypes.asExecutable(types.asMemberOf(resolved, constructorElement));
- constructedType = resolved;
- }
-
- Key key = keyFactory.forInjectConstructorWithResolvedType(constructedType);
- ImmutableSet<DependencyRequest> provisionDependencies =
- dependencyRequestFactory.forRequiredResolvedVariables(
- constructorElement.getParameters(), constructorType.getParameterTypes());
-
- ProvisionBinding.Builder builder =
- ProvisionBinding.builder()
- .contributionType(ContributionType.UNIQUE)
- .bindingElement(constructorElement)
- .key(key)
- .provisionDependencies(provisionDependencies)
- .injectionSites(injectionSiteFactory.getInjectionSites(constructedType))
- .kind(INJECTION)
- .scope(uniqueScopeOf(constructorElement.getEnclosingElement()));
-
- TypeElement bindingTypeElement = MoreElements.asType(constructorElement.getEnclosingElement());
- if (hasNonDefaultTypeParameters(bindingTypeElement, key.type(), types)) {
- builder.unresolved(injectionBinding(constructorElement, Optional.empty()));
- }
- return builder.build();
- }
-
- /**
- * Returns a {@link dagger.model.BindingKind#PROVISION} binding for a {@code @Provides}-annotated
- * method.
- *
- * @param contributedBy the installed module that declares or inherits the method
- */
- ProvisionBinding providesMethodBinding(
- ExecutableElement providesMethod, TypeElement contributedBy) {
- return setMethodBindingProperties(
- ProvisionBinding.builder(),
- providesMethod,
- contributedBy,
- keyFactory.forProvidesMethod(providesMethod, contributedBy),
- this::providesMethodBinding)
- .kind(PROVISION)
- .scope(uniqueScopeOf(providesMethod))
- .nullableType(getNullableType(providesMethod))
- .build();
- }
-
- /**
- * Returns a {@link dagger.model.BindingKind#PRODUCTION} binding for a {@code @Produces}-annotated
- * method.
- *
- * @param contributedBy the installed module that declares or inherits the method
- */
- ProductionBinding producesMethodBinding(
- ExecutableElement producesMethod, TypeElement contributedBy) {
- // TODO(beder): Add nullability checking with Java 8.
- ProductionBinding.Builder builder =
- setMethodBindingProperties(
- ProductionBinding.builder(),
- producesMethod,
- contributedBy,
- keyFactory.forProducesMethod(producesMethod, contributedBy),
- this::producesMethodBinding)
- .kind(PRODUCTION)
- .productionKind(ProductionKind.fromProducesMethod(producesMethod))
- .thrownTypes(producesMethod.getThrownTypes())
- .executorRequest(dependencyRequestFactory.forProductionImplementationExecutor())
- .monitorRequest(dependencyRequestFactory.forProductionComponentMonitor());
- return builder.build();
- }
-
- private <C extends ContributionBinding, B extends ContributionBinding.Builder<C, B>>
- B setMethodBindingProperties(
- B builder,
- ExecutableElement method,
- TypeElement contributedBy,
- Key key,
- BiFunction<ExecutableElement, TypeElement, C> create) {
- checkArgument(method.getKind().equals(METHOD));
- ExecutableType methodType =
- MoreTypes.asExecutable(
- types.asMemberOf(MoreTypes.asDeclared(contributedBy.asType()), method));
- if (!types.isSameType(methodType, method.asType())) {
- builder.unresolved(create.apply(method, MoreElements.asType(method.getEnclosingElement())));
- }
- return builder
- .contributionType(ContributionType.fromBindingElement(method))
- .bindingElement(method)
- .contributingModule(contributedBy)
- .key(key)
- .dependencies(
- dependencyRequestFactory.forRequiredResolvedVariables(
- method.getParameters(), methodType.getParameterTypes()))
- .wrappedMapKeyAnnotation(wrapOptionalInEquivalence(getMapKey(method)));
- }
-
- /**
- * Returns a {@link dagger.model.BindingKind#MULTIBOUND_MAP} or {@link
- * dagger.model.BindingKind#MULTIBOUND_SET} binding given a set of multibinding contribution
- * bindings.
- *
- * @param key a key that may be satisfied by a multibinding
- */
- ContributionBinding syntheticMultibinding(
- Key key, Iterable<ContributionBinding> multibindingContributions) {
- ContributionBinding.Builder<?, ?> builder =
- multibindingRequiresProduction(key, multibindingContributions)
- ? ProductionBinding.builder()
- : ProvisionBinding.builder();
- return builder
- .contributionType(ContributionType.UNIQUE)
- .key(key)
- .dependencies(
- dependencyRequestFactory.forMultibindingContributions(key, multibindingContributions))
- .kind(bindingKindForMultibindingKey(key))
- .build();
- }
-
- private boolean multibindingRequiresProduction(
- Key key, Iterable<ContributionBinding> multibindingContributions) {
- if (MapType.isMap(key)) {
- MapType mapType = MapType.from(key);
- if (mapType.valuesAreTypeOf(Producer.class) || mapType.valuesAreTypeOf(Produced.class)) {
- return true;
- }
- } else if (SetType.isSet(key) && SetType.from(key).elementsAreTypeOf(Produced.class)) {
- return true;
- }
- return Iterables.any(
- multibindingContributions, binding -> binding.bindingType().equals(BindingType.PRODUCTION));
- }
-
- /** Returns a {@link dagger.model.BindingKind#COMPONENT} binding for the component. */
- ProvisionBinding componentBinding(TypeElement componentDefinitionType) {
- checkNotNull(componentDefinitionType);
- return ProvisionBinding.builder()
- .contributionType(ContributionType.UNIQUE)
- .bindingElement(componentDefinitionType)
- .key(keyFactory.forType(componentDefinitionType.asType()))
- .kind(COMPONENT)
- .build();
- }
-
- /**
- * Returns a {@link dagger.model.BindingKind#COMPONENT_DEPENDENCY} binding for a component's
- * dependency.
- */
- ProvisionBinding componentDependencyBinding(ComponentRequirement dependency) {
- checkNotNull(dependency);
- return ProvisionBinding.builder()
- .contributionType(ContributionType.UNIQUE)
- .bindingElement(dependency.typeElement())
- .key(keyFactory.forType(dependency.type()))
- .kind(COMPONENT_DEPENDENCY)
- .build();
- }
-
- /**
- * Returns a {@link dagger.model.BindingKind#COMPONENT_PROVISION} or {@link
- * dagger.model.BindingKind#COMPONENT_PRODUCTION} binding for a method on a component's
- * dependency.
- *
- * @param componentDescriptor the component with the dependency, not the dependency that has the
- * method
- */
- ContributionBinding componentDependencyMethodBinding(
- ComponentDescriptor componentDescriptor, ExecutableElement dependencyMethod) {
- checkArgument(dependencyMethod.getKind().equals(METHOD));
- checkArgument(dependencyMethod.getParameters().isEmpty());
- ContributionBinding.Builder<?, ?> builder;
- if (componentDescriptor.isProduction()
- && isComponentProductionMethod(elements, dependencyMethod)) {
- builder =
- ProductionBinding.builder()
- .key(keyFactory.forProductionComponentMethod(dependencyMethod))
- .kind(COMPONENT_PRODUCTION)
- .thrownTypes(dependencyMethod.getThrownTypes());
- } else {
- builder =
- ProvisionBinding.builder()
- .key(keyFactory.forComponentMethod(dependencyMethod))
- .nullableType(getNullableType(dependencyMethod))
- .kind(COMPONENT_PROVISION)
- .scope(uniqueScopeOf(dependencyMethod));
- }
- return builder
- .contributionType(ContributionType.UNIQUE)
- .bindingElement(dependencyMethod)
- .build();
- }
-
- /**
- * Returns a {@link dagger.model.BindingKind#BOUND_INSTANCE} binding for a
- * {@code @BindsInstance}-annotated builder setter method or factory method parameter.
- */
- ProvisionBinding boundInstanceBinding(ComponentRequirement requirement, Element element) {
- checkArgument(element instanceof VariableElement || element instanceof ExecutableElement);
- VariableElement parameterElement =
- element instanceof VariableElement
- ? MoreElements.asVariable(element)
- : getOnlyElement(MoreElements.asExecutable(element).getParameters());
- return ProvisionBinding.builder()
- .contributionType(ContributionType.UNIQUE)
- .bindingElement(element)
- .key(requirement.key().get())
- .nullableType(getNullableType(parameterElement))
- .kind(BOUND_INSTANCE)
- .build();
- }
-
- /**
- * Returns a {@link dagger.model.BindingKind#SUBCOMPONENT_CREATOR} binding declared by a component
- * method that returns a subcomponent builder. Use {{@link
- * #subcomponentCreatorBinding(ImmutableSet)}} for bindings declared using {@link
- * Module#subcomponents()}.
- *
- * @param component the component that declares or inherits the method
- */
- ProvisionBinding subcomponentCreatorBinding(
- ExecutableElement subcomponentCreatorMethod, TypeElement component) {
- checkArgument(subcomponentCreatorMethod.getKind().equals(METHOD));
- checkArgument(subcomponentCreatorMethod.getParameters().isEmpty());
- Key key =
- keyFactory.forSubcomponentCreatorMethod(
- subcomponentCreatorMethod, asDeclared(component.asType()));
- return ProvisionBinding.builder()
- .contributionType(ContributionType.UNIQUE)
- .bindingElement(subcomponentCreatorMethod)
- .key(key)
- .kind(SUBCOMPONENT_CREATOR)
- .build();
- }
-
- /**
- * Returns a {@link dagger.model.BindingKind#SUBCOMPONENT_CREATOR} binding declared using {@link
- * Module#subcomponents()}.
- */
- ProvisionBinding subcomponentCreatorBinding(
- ImmutableSet<SubcomponentDeclaration> subcomponentDeclarations) {
- SubcomponentDeclaration subcomponentDeclaration = subcomponentDeclarations.iterator().next();
- return ProvisionBinding.builder()
- .contributionType(ContributionType.UNIQUE)
- .key(subcomponentDeclaration.key())
- .kind(SUBCOMPONENT_CREATOR)
- .build();
- }
-
- /**
- * Returns a {@link dagger.model.BindingKind#DELEGATE} binding.
- *
- * @param delegateDeclaration the {@code @Binds}-annotated declaration
- * @param actualBinding the binding that satisfies the {@code @Binds} declaration
- */
- ContributionBinding delegateBinding(
- DelegateDeclaration delegateDeclaration, ContributionBinding actualBinding) {
- switch (actualBinding.bindingType()) {
- case PRODUCTION:
- return buildDelegateBinding(
- ProductionBinding.builder().nullableType(actualBinding.nullableType()),
- delegateDeclaration,
- Producer.class);
-
- case PROVISION:
- return buildDelegateBinding(
- ProvisionBinding.builder()
- .scope(uniqueScopeOf(delegateDeclaration.bindingElement().get()))
- .nullableType(actualBinding.nullableType()),
- delegateDeclaration,
- Provider.class);
-
- case MEMBERS_INJECTION: // fall-through to throw
- }
- throw new AssertionError("bindingType: " + actualBinding);
- }
-
- /**
- * Returns a {@link dagger.model.BindingKind#DELEGATE} binding used when there is no binding that
- * satisfies the {@code @Binds} declaration.
- */
- ContributionBinding unresolvedDelegateBinding(DelegateDeclaration delegateDeclaration) {
- return buildDelegateBinding(
- ProvisionBinding.builder().scope(uniqueScopeOf(delegateDeclaration.bindingElement().get())),
- delegateDeclaration,
- Provider.class);
- }
-
- private ContributionBinding buildDelegateBinding(
- ContributionBinding.Builder<?, ?> builder,
- DelegateDeclaration delegateDeclaration,
- Class<?> frameworkType) {
- return builder
- .contributionType(delegateDeclaration.contributionType())
- .bindingElement(delegateDeclaration.bindingElement().get())
- .contributingModule(delegateDeclaration.contributingModule().get())
- .key(keyFactory.forDelegateBinding(delegateDeclaration, frameworkType))
- .dependencies(delegateDeclaration.delegateRequest())
- .wrappedMapKeyAnnotation(delegateDeclaration.wrappedMapKey())
- .kind(DELEGATE)
- .build();
- }
-
- /**
- * Returns an {@link dagger.model.BindingKind#OPTIONAL} binding for {@code key}.
- *
- * @param requestKind the kind of request for the optional binding
- * @param underlyingKeyBindings the possibly empty set of bindings that exist in the component for
- * the underlying (non-optional) key
- */
- ContributionBinding syntheticOptionalBinding(
- Key key, RequestKind requestKind, ResolvedBindings underlyingKeyBindings) {
- ContributionBinding.Builder<?, ?> builder =
- syntheticOptionalBindingBuilder(requestKind, underlyingKeyBindings)
- .contributionType(ContributionType.UNIQUE)
- .key(key)
- .kind(OPTIONAL);
- if (!underlyingKeyBindings.isEmpty()) {
- builder.dependencies(
- dependencyRequestFactory.forSyntheticPresentOptionalBinding(key, requestKind));
- }
- return builder.build();
- }
-
- private ContributionBinding.Builder<?, ?> syntheticOptionalBindingBuilder(
- RequestKind requestKind, ResolvedBindings underlyingKeyBindings) {
- return !underlyingKeyBindings.isEmpty()
- && (underlyingKeyBindings.bindingTypes().contains(BindingType.PRODUCTION)
- || requestKind.equals(RequestKind.PRODUCER) // handles producerFromProvider cases
- || requestKind.equals(RequestKind.PRODUCED)) // handles producerFromProvider cases
- ? ProductionBinding.builder()
- : ProvisionBinding.builder();
- }
-
- /** Returns a {@link dagger.model.BindingKind#MEMBERS_INJECTOR} binding. */
- ProvisionBinding membersInjectorBinding(
- Key key, MembersInjectionBinding membersInjectionBinding) {
- return ProvisionBinding.builder()
- .key(key)
- .contributionType(ContributionType.UNIQUE)
- .kind(MEMBERS_INJECTOR)
- .bindingElement(MoreTypes.asTypeElement(membersInjectionBinding.key().type()))
- .provisionDependencies(membersInjectionBinding.dependencies())
- .injectionSites(membersInjectionBinding.injectionSites())
- .build();
- }
-
- /**
- * Returns a {@link dagger.model.BindingKind#MEMBERS_INJECTION} binding.
- *
- * @param resolvedType if {@code declaredType} is a generic class and {@code resolvedType} is a
- * parameterization of that type, the returned binding will be for the resolved type
- */
- // TODO(dpb): See if we can just pass one nongeneric/parameterized type.
- MembersInjectionBinding membersInjectionBinding(
- DeclaredType declaredType, Optional<TypeMirror> resolvedType) {
- // If the class this is injecting has some type arguments, resolve everything.
- if (!declaredType.getTypeArguments().isEmpty() && resolvedType.isPresent()) {
- DeclaredType resolved = asDeclared(resolvedType.get());
- // Validate that we're resolving from the correct type.
- checkState(
- types.isSameType(types.erasure(resolved), types.erasure(declaredType)),
- "erased expected type: %s, erased actual type: %s",
- types.erasure(resolved),
- types.erasure(declaredType));
- declaredType = resolved;
- }
- ImmutableSortedSet<InjectionSite> injectionSites =
- injectionSiteFactory.getInjectionSites(declaredType);
- ImmutableSet<DependencyRequest> dependencies =
- injectionSites
- .stream()
- .flatMap(injectionSite -> injectionSite.dependencies().stream())
- .collect(toImmutableSet());
-
- Key key = keyFactory.forMembersInjectedType(declaredType);
- TypeElement typeElement = MoreElements.asType(declaredType.asElement());
- return new AutoValue_MembersInjectionBinding(
- key,
- dependencies,
- typeElement,
- hasNonDefaultTypeParameters(typeElement, key.type(), types)
- ? Optional.of(
- membersInjectionBinding(asDeclared(typeElement.asType()), Optional.empty()))
- : Optional.empty(),
- injectionSites);
- }
-}
diff --git a/java/dagger/internal/codegen/BindingGraph.java b/java/dagger/internal/codegen/BindingGraph.java
deleted file mode 100644
index 2f548b2..0000000
--- a/java/dagger/internal/codegen/BindingGraph.java
+++ /dev/null
@@ -1,232 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkState;
-import static dagger.internal.codegen.DaggerStreams.presentValues;
-import static dagger.internal.codegen.DaggerStreams.stream;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-
-import com.google.auto.value.AutoValue;
-import com.google.auto.value.extension.memoized.Memoized;
-import com.google.common.collect.FluentIterable;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Multimaps;
-import com.google.common.graph.Traverser;
-import dagger.Subcomponent;
-import dagger.model.Key;
-import dagger.model.RequestKind;
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.element.VariableElement;
-
-/** The canonical representation of a full-resolved graph. */
-@AutoValue
-abstract class BindingGraph {
- abstract ComponentDescriptor componentDescriptor();
-
- /**
- * The resolved bindings for all {@link ContributionBinding}s in this graph, keyed by {@link Key}.
- */
- // TODO(ronshapiro): when MembersInjectionBinding no longer extends Binding, rename this to
- // bindings()
- abstract ImmutableMap<Key, ResolvedBindings> contributionBindings();
-
- /**
- * The resolved bindings for all {@link MembersInjectionBinding}s in this graph, keyed by {@link
- * Key}.
- */
- abstract ImmutableMap<Key, ResolvedBindings> membersInjectionBindings();
-
- /**
- * Returns the {@link ResolvedBindings resolved bindings} instance for {@code
- * bindingExpressionKey}. If the bindings will be used for members injection, a {@link
- * ResolvedBindings} with {@linkplain #membersInjectionBindings() members injection bindings} will
- * be returned, otherwise a {@link ResolvedBindings} with {@link #contributionBindings()} will be
- * returned.
- */
- final ResolvedBindings resolvedBindings(BindingRequest request) {
- return request.isRequestKind(RequestKind.MEMBERS_INJECTION)
- ? membersInjectionBindings().get(request.key())
- : contributionBindings().get(request.key());
- }
-
- final Iterable<ResolvedBindings> resolvedBindings() {
- // Don't return an immutable collection - this is only ever used for looping over all bindings
- // in the graph. Copying is wasteful, especially if is a hashing collection, since the values
- // should all, by definition, be distinct.
- // TODO(dpb): consider inlining this to callers and removing this.
- return Iterables.concat(membersInjectionBindings().values(), contributionBindings().values());
- }
-
- abstract ImmutableList<BindingGraph> subgraphs();
-
- /**
- * The type that defines the component for this graph.
- *
- * @see ComponentDescriptor#typeElement()
- */
- TypeElement componentTypeElement() {
- return componentDescriptor().typeElement();
- }
-
- /**
- * Returns the set of modules that are owned by this graph regardless of whether or not any of
- * their bindings are used in this graph. For graphs representing top-level {@link
- * dagger.Component components}, this set will be the same as {@linkplain
- * ComponentDescriptor#modules() the component's transitive modules}. For {@linkplain Subcomponent
- * subcomponents}, this set will be the transitive modules that are not owned by any of their
- * ancestors.
- */
- abstract ImmutableSet<ModuleDescriptor> ownedModules();
-
- @Memoized
- ImmutableSet<TypeElement> ownedModuleTypes() {
- return FluentIterable.from(ownedModules()).transform(ModuleDescriptor::moduleElement).toSet();
- }
-
- /**
- * Returns the factory method for this subcomponent, if it exists.
- *
- * <p>This factory method is the one defined in the parent component's interface.
- *
- * <p>In the example below, the {@link BindingGraph#factoryMethod} for {@code ChildComponent}
- * would return the {@link ExecutableElement}: {@code childComponent(ChildModule1)} .
- *
- * <pre><code>
- * {@literal @Component}
- * interface ParentComponent {
- * ChildComponent childComponent(ChildModule1 childModule);
- * }
- * </code></pre>
- */
- // TODO(b/73294201): Consider returning the resolved ExecutableType for the factory method.
- abstract Optional<ExecutableElement> factoryMethod();
-
- /**
- * Returns a map between the {@linkplain ComponentRequirement component requirement} and the
- * corresponding {@link VariableElement} for each module parameter in the {@linkplain
- * BindingGraph#factoryMethod factory method}.
- */
- // TODO(dpb): Consider disallowing modules if none of their bindings are used.
- ImmutableMap<ComponentRequirement, VariableElement> factoryMethodParameters() {
- checkState(factoryMethod().isPresent());
- ImmutableMap.Builder<ComponentRequirement, VariableElement> builder = ImmutableMap.builder();
- for (VariableElement parameter : factoryMethod().get().getParameters()) {
- builder.put(ComponentRequirement.forModule(parameter.asType()), parameter);
- }
- return builder.build();
- }
-
- private static final Traverser<BindingGraph> SUBGRAPH_TRAVERSER =
- Traverser.forTree(BindingGraph::subgraphs);
-
- /**
- * The types for which the component needs instances.
- *
- * <ul>
- * <li>component dependencies
- * <li>{@linkplain #ownedModules() owned modules} with concrete instance bindings that are used
- * in the graph
- * <li>bound instances
- * </ul>
- */
- @Memoized
- ImmutableSet<ComponentRequirement> componentRequirements() {
- ImmutableSet<TypeElement> requiredModules = requiredModuleElements();
- ImmutableSet.Builder<ComponentRequirement> requirements = ImmutableSet.builder();
- componentDescriptor().requirements().stream()
- .filter(
- requirement ->
- !requirement.kind().isModule()
- || requiredModules.contains(requirement.typeElement()))
- .forEach(requirements::add);
- if (factoryMethod().isPresent()) {
- requirements.addAll(factoryMethodParameters().keySet());
- }
- return requirements.build();
- }
-
- private ImmutableSet<TypeElement> requiredModuleElements() {
- return stream(SUBGRAPH_TRAVERSER.depthFirstPostOrder(this))
- .flatMap(graph -> graph.contributionBindings().values().stream())
- .flatMap(bindings -> bindings.contributionBindings().stream())
- .map(ContributionBinding::contributingModule)
- .distinct()
- .flatMap(presentValues())
- .filter(ownedModuleTypes()::contains)
- .collect(toImmutableSet());
- }
-
- /** Returns the {@link ComponentDescriptor}s for this component and its subcomponents. */
- ImmutableSet<ComponentDescriptor> componentDescriptors() {
- return FluentIterable.from(SUBGRAPH_TRAVERSER.depthFirstPreOrder(this))
- .transform(BindingGraph::componentDescriptor)
- .toSet();
- }
-
- /**
- * {@code true} if this graph contains all bindings installed in the component; {@code false} if
- * it contains only those bindings that are reachable from at least one entry point.
- */
- abstract boolean isFullBindingGraph();
-
- @Memoized
- @Override
- public abstract int hashCode();
-
- @Override // Suppresses ErrorProne warning that hashCode was overridden w/o equals
- public abstract boolean equals(Object other);
-
- static BindingGraph create(
- ComponentDescriptor componentDescriptor,
- Map<Key, ResolvedBindings> resolvedContributionBindingsMap,
- Map<Key, ResolvedBindings> resolvedMembersInjectionBindings,
- List<BindingGraph> subgraphs,
- Set<ModuleDescriptor> ownedModules,
- Optional<ExecutableElement> factoryMethod,
- boolean isFullBindingGraph) {
- checkForDuplicates(subgraphs);
- return new AutoValue_BindingGraph(
- componentDescriptor,
- ImmutableMap.copyOf(resolvedContributionBindingsMap),
- ImmutableMap.copyOf(resolvedMembersInjectionBindings),
- ImmutableList.copyOf(subgraphs),
- ImmutableSet.copyOf(ownedModules),
- factoryMethod,
- isFullBindingGraph);
- }
-
- private static final void checkForDuplicates(Iterable<BindingGraph> graphs) {
- Map<TypeElement, Collection<BindingGraph>> duplicateGraphs =
- Maps.filterValues(
- Multimaps.index(graphs, graph -> graph.componentDescriptor().typeElement()).asMap(),
- overlapping -> overlapping.size() > 1);
- if (!duplicateGraphs.isEmpty()) {
- throw new IllegalArgumentException("Expected no duplicates: " + duplicateGraphs);
- }
- }
-}
diff --git a/java/dagger/internal/codegen/BindingGraphConverter.java b/java/dagger/internal/codegen/BindingGraphConverter.java
deleted file mode 100644
index a2cc799..0000000
--- a/java/dagger/internal/codegen/BindingGraphConverter.java
+++ /dev/null
@@ -1,239 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreTypes.asTypeElement;
-import static dagger.internal.codegen.BindingRequest.bindingRequest;
-import static dagger.internal.codegen.DaggerGraphs.unreachableNodes;
-import static dagger.model.BindingKind.SUBCOMPONENT_CREATOR;
-
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterables;
-import com.google.common.graph.MutableNetwork;
-import com.google.common.graph.Network;
-import com.google.common.graph.NetworkBuilder;
-import dagger.model.BindingGraph.ComponentNode;
-import dagger.model.BindingGraph.DependencyEdge;
-import dagger.model.BindingGraph.Edge;
-import dagger.model.BindingGraph.MissingBinding;
-import dagger.model.BindingGraph.Node;
-import dagger.model.BindingGraphProxies;
-import dagger.model.ComponentPath;
-import dagger.model.DependencyRequest;
-import javax.inject.Inject;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.TypeMirror;
-
-/** Converts {@link dagger.internal.codegen.BindingGraph}s to {@link dagger.model.BindingGraph}s. */
-final class BindingGraphConverter {
- private final BindingDeclarationFormatter bindingDeclarationFormatter;
-
- @Inject
- BindingGraphConverter(BindingDeclarationFormatter bindingDeclarationFormatter) {
- this.bindingDeclarationFormatter = bindingDeclarationFormatter;
- }
-
- /**
- * Creates the external {@link dagger.model.BindingGraph} representing the given internal {@link
- * dagger.internal.codegen.BindingGraph}.
- */
- dagger.model.BindingGraph convert(BindingGraph bindingGraph) {
- Traverser traverser = new Traverser(bindingGraph);
- traverser.traverseComponents();
-
- // When bindings are copied down into child graphs because they transitively depend on local
- // multibindings or optional bindings, the parent-owned binding is still there. If that
- // parent-owned binding is not reachable from its component, it doesn't need to be in the graph
- // because it will never be used. So remove all nodes that are not reachable from the root
- // component—unless we're converting a full binding graph.
- if (!bindingGraph.isFullBindingGraph()) {
- unreachableNodes(traverser.network.asGraph(), rootComponentNode(traverser.network))
- .forEach(traverser.network::removeNode);
- }
-
- return BindingGraphProxies.bindingGraph(traverser.network, bindingGraph.isFullBindingGraph());
- }
-
- // TODO(dpb): Example of BindingGraph logic applied to derived networks.
- private ComponentNode rootComponentNode(Network<Node, Edge> network) {
- return (ComponentNode)
- Iterables.find(
- network.nodes(),
- node -> node instanceof ComponentNode && node.componentPath().atRoot());
- }
-
- private final class Traverser extends ComponentTreeTraverser {
- private final MutableNetwork<Node, Edge> network =
- NetworkBuilder.directed().allowsParallelEdges(true).allowsSelfLoops(true).build();
- private final boolean isRootSubcomponent;
- private final boolean isFullBindingGraph;
-
- private final ComponentPath rootComponentPath;
- private ComponentNode parentComponent;
- private ComponentNode currentComponent;
-
- Traverser(BindingGraph graph) {
- super(graph);
- rootComponentPath = ComponentPath.create(ImmutableList.of(graph.componentTypeElement()));
- isRootSubcomponent = graph.componentDescriptor().isSubcomponent();
- isFullBindingGraph = graph.isFullBindingGraph();
- }
-
- @Override
- protected void visitComponent(BindingGraph graph) {
- ComponentNode grandparentComponent = parentComponent;
- parentComponent = currentComponent;
- currentComponent = ComponentNodeImpl.create(componentPath(), graph.componentDescriptor());
-
- network.addNode(currentComponent);
-
- for (ResolvedBindings resolvedBindings : graph.resolvedBindings()) {
- for (BindingNode binding : bindingNodes(resolvedBindings)) {
- addBinding(binding);
- if (binding.kind().equals(SUBCOMPONENT_CREATOR)
- && binding.componentPath().equals(currentComponent.componentPath())) {
- network.addEdge(
- binding,
- subcomponentNode(binding.key().type(), graph),
- new SubcomponentCreatorBindingEdgeImpl(
- resolvedBindings.subcomponentDeclarations()));
- }
- }
- }
-
- super.visitComponent(graph);
-
- currentComponent = parentComponent;
- parentComponent = grandparentComponent;
- }
-
- @Override
- protected void visitEntryPoint(DependencyRequest entryPoint, BindingGraph graph) {
- addDependencyEdges(currentComponent, entryPoint);
- super.visitEntryPoint(entryPoint, graph);
- }
-
- @Override
- protected void visitSubcomponentFactoryMethod(
- BindingGraph graph, BindingGraph parent, ExecutableElement factoryMethod) {
- network.addEdge(
- parentComponent, currentComponent, new ChildFactoryMethodEdgeImpl(factoryMethod));
- super.visitSubcomponentFactoryMethod(graph, parent, factoryMethod);
- }
-
- /**
- * Adds a {@link dagger.model.BindingGraph.DependencyEdge} from a node to the binding(s) that
- * satisfy a dependency request.
- */
- private void addDependencyEdges(Node source, DependencyRequest dependencyRequest) {
- ResolvedBindings dependencies = resolvedDependencies(source, dependencyRequest);
- if (dependencies.isEmpty()) {
- addDependencyEdge(source, dependencyRequest, missingBindingNode(dependencies));
- } else {
- for (BindingNode dependency : bindingNodes(dependencies)) {
- addDependencyEdge(source, dependencyRequest, dependency);
- }
- }
- }
-
- private void addDependencyEdge(
- Node source, DependencyRequest dependencyRequest, Node dependency) {
- network.addNode(dependency);
- if (!hasDependencyEdge(source, dependency, dependencyRequest)) {
- network.addEdge(
- source,
- dependency,
- new DependencyEdgeImpl(dependencyRequest, source instanceof ComponentNode));
- }
- }
-
- private boolean hasDependencyEdge(
- Node source, Node dependency, DependencyRequest dependencyRequest) {
- // An iterative approach is used instead of a Stream because this method is called in a hot
- // loop, and the Stream calculates the size of network.edgesConnecting(), which is slow. This
- // seems to be because caculating the edges connecting two nodes in a Network that supports
- // parallel edges is must check the equality of many nodes, and BindingNode's equality
- // semantics drag in the equality of many other expensive objects
- for (Edge edge : network.edgesConnecting(source, dependency)) {
- if (edge instanceof DependencyEdge) {
- if (((DependencyEdge) edge).dependencyRequest().equals(dependencyRequest)) {
- return true;
- }
- }
- }
- return false;
- }
-
- private ResolvedBindings resolvedDependencies(
- Node source, DependencyRequest dependencyRequest) {
- return graphForAncestor(source.componentPath().currentComponent())
- .resolvedBindings(bindingRequest(dependencyRequest));
- }
-
- /** Adds a binding and all its dependencies. */
- private void addBinding(BindingNode binding) {
- network.addNode(binding);
- for (DependencyRequest dependencyRequest : binding.dependencies()) {
- addDependencyEdges(binding, dependencyRequest);
- }
- }
-
- private ImmutableSet<BindingNode> bindingNodes(ResolvedBindings resolvedBindings) {
- ImmutableSet.Builder<BindingNode> bindingNodes = ImmutableSet.builder();
- resolvedBindings
- .allBindings()
- .asMap()
- .forEach(
- (component, bindings) -> {
- for (Binding binding : bindings) {
- bindingNodes.add(bindingNode(resolvedBindings, binding, component));
- }
- });
- return bindingNodes.build();
- }
-
- private BindingNode bindingNode(
- ResolvedBindings resolvedBindings, Binding binding, TypeElement owningComponent) {
- return BindingNode.create(
- pathFromRootToAncestor(owningComponent),
- binding,
- resolvedBindings.multibindingDeclarations(),
- resolvedBindings.optionalBindingDeclarations(),
- resolvedBindings.subcomponentDeclarations(),
- bindingDeclarationFormatter);
- }
-
- private MissingBinding missingBindingNode(ResolvedBindings dependencies) {
- // TODO(b/117833324): Revisit whether limiting missing binding nodes to the root component is
- // necessary to limit the amount of missing binding nodes in the network, or if perhaps *all*
- // missing binding nodes should be structured this way.
- return BindingGraphProxies.missingBindingNode(
- isRootSubcomponent && !isFullBindingGraph ? rootComponentPath : componentPath(),
- dependencies.key());
- }
-
- private ComponentNode subcomponentNode(TypeMirror subcomponentBuilderType, BindingGraph graph) {
- TypeElement subcomponentBuilderElement = asTypeElement(subcomponentBuilderType);
- ComponentDescriptor subcomponent =
- graph.componentDescriptor().getChildComponentWithBuilderType(subcomponentBuilderElement);
- return ComponentNodeImpl.create(
- componentPath().childPath(subcomponent.typeElement()), subcomponent);
- }
- }
-}
diff --git a/java/dagger/internal/codegen/BindingGraphFactory.java b/java/dagger/internal/codegen/BindingGraphFactory.java
deleted file mode 100644
index d96da8a..0000000
--- a/java/dagger/internal/codegen/BindingGraphFactory.java
+++ /dev/null
@@ -1,1061 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreTypes.isType;
-import static com.google.auto.common.MoreTypes.isTypeOf;
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.collect.Iterables.isEmpty;
-import static dagger.internal.codegen.ComponentDescriptor.isComponentContributionMethod;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.internal.codegen.RequestKinds.getRequestKind;
-import static dagger.internal.codegen.SourceFiles.generatedMonitoringModuleName;
-import static dagger.internal.codegen.Util.reentrantComputeIfAbsent;
-import static dagger.model.BindingKind.DELEGATE;
-import static dagger.model.BindingKind.INJECTION;
-import static dagger.model.BindingKind.OPTIONAL;
-import static dagger.model.BindingKind.SUBCOMPONENT_CREATOR;
-import static dagger.model.RequestKind.MEMBERS_INJECTION;
-import static java.util.function.Predicate.isEqual;
-import static javax.lang.model.util.ElementFilter.methodsIn;
-
-import com.google.auto.common.MoreTypes;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableSetMultimap;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.Multimaps;
-import com.google.common.collect.Sets;
-import dagger.MembersInjector;
-import dagger.Reusable;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.model.DependencyRequest;
-import dagger.model.Key;
-import dagger.model.Scope;
-import dagger.producers.Produced;
-import dagger.producers.Producer;
-import dagger.producers.internal.ProductionExecutorModule;
-import java.util.ArrayDeque;
-import java.util.Collection;
-import java.util.Deque;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.LinkedHashMap;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Queue;
-import java.util.Set;
-import java.util.function.Function;
-import javax.inject.Inject;
-import javax.inject.Provider;
-import javax.inject.Singleton;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-
-/** A factory for {@link BindingGraph} objects. */
-@Singleton
-final class BindingGraphFactory implements ClearableCache {
- private final DaggerElements elements;
- private final InjectBindingRegistry injectBindingRegistry;
- private final KeyFactory keyFactory;
- private final BindingFactory bindingFactory;
- private final ModuleDescriptor.Factory moduleDescriptorFactory;
- private final Map<Key, ImmutableSet<Key>> keysMatchingRequestCache = new HashMap<>();
-
- @Inject
- BindingGraphFactory(
- DaggerElements elements,
- InjectBindingRegistry injectBindingRegistry,
- KeyFactory keyFactory,
- BindingFactory bindingFactory,
- ModuleDescriptor.Factory moduleDescriptorFactory) {
- this.elements = elements;
- this.injectBindingRegistry = injectBindingRegistry;
- this.keyFactory = keyFactory;
- this.bindingFactory = bindingFactory;
- this.moduleDescriptorFactory = moduleDescriptorFactory;
- }
-
- /**
- * Creates a binding graph for a component.
- *
- * @param createFullBindingGraph if {@code true}, the binding graph will include all bindings;
- * otherwise it will include only bindings reachable from at least one entry point
- */
- BindingGraph create(ComponentDescriptor componentDescriptor, boolean createFullBindingGraph) {
- return create(Optional.empty(), componentDescriptor, createFullBindingGraph);
- }
-
- private BindingGraph create(
- Optional<Resolver> parentResolver,
- ComponentDescriptor componentDescriptor,
- boolean createFullBindingGraph) {
- ImmutableSet.Builder<ContributionBinding> explicitBindingsBuilder = ImmutableSet.builder();
- ImmutableSet.Builder<DelegateDeclaration> delegatesBuilder = ImmutableSet.builder();
- ImmutableSet.Builder<OptionalBindingDeclaration> optionalsBuilder = ImmutableSet.builder();
-
- if (componentDescriptor.isRealComponent()) {
- // binding for the component itself
- explicitBindingsBuilder.add(
- bindingFactory.componentBinding(componentDescriptor.typeElement()));
- }
-
- // Collect Component dependencies.
- for (ComponentRequirement dependency : componentDescriptor.dependencies()) {
- explicitBindingsBuilder.add(bindingFactory.componentDependencyBinding(dependency));
- List<ExecutableElement> dependencyMethods =
- methodsIn(elements.getAllMembers(dependency.typeElement()));
- for (ExecutableElement method : dependencyMethods) {
- // MembersInjection methods aren't "provided" explicitly, so ignore them.
- if (isComponentContributionMethod(elements, method)) {
- explicitBindingsBuilder.add(
- bindingFactory.componentDependencyMethodBinding(componentDescriptor, method));
- }
- }
- }
-
- // Collect bindings on the creator.
- componentDescriptor
- .creatorDescriptor()
- .ifPresent(
- creatorDescriptor ->
- creatorDescriptor.boundInstanceRequirements().stream()
- .map(
- requirement ->
- bindingFactory.boundInstanceBinding(
- requirement, creatorDescriptor.elementForRequirement(requirement)))
- .forEach(explicitBindingsBuilder::add));
-
- componentDescriptor
- .childComponentsDeclaredByBuilderEntryPoints()
- .forEach(
- (builderEntryPoint, childComponent) -> {
- if (!componentDescriptor
- .childComponentsDeclaredByModules()
- .contains(childComponent)) {
- explicitBindingsBuilder.add(
- bindingFactory.subcomponentCreatorBinding(
- builderEntryPoint.methodElement(), componentDescriptor.typeElement()));
- }
- });
-
- ImmutableSet.Builder<MultibindingDeclaration> multibindingDeclarations = ImmutableSet.builder();
- ImmutableSet.Builder<SubcomponentDeclaration> subcomponentDeclarations = ImmutableSet.builder();
-
- // Collect transitive module bindings and multibinding declarations.
- for (ModuleDescriptor moduleDescriptor : modules(componentDescriptor, parentResolver)) {
- explicitBindingsBuilder.addAll(moduleDescriptor.bindings());
- multibindingDeclarations.addAll(moduleDescriptor.multibindingDeclarations());
- subcomponentDeclarations.addAll(moduleDescriptor.subcomponentDeclarations());
- delegatesBuilder.addAll(moduleDescriptor.delegateDeclarations());
- optionalsBuilder.addAll(moduleDescriptor.optionalDeclarations());
- }
-
- final Resolver requestResolver =
- new Resolver(
- parentResolver,
- componentDescriptor,
- indexBindingDeclarationsByKey(explicitBindingsBuilder.build()),
- indexBindingDeclarationsByKey(multibindingDeclarations.build()),
- indexBindingDeclarationsByKey(subcomponentDeclarations.build()),
- indexBindingDeclarationsByKey(delegatesBuilder.build()),
- indexBindingDeclarationsByKey(optionalsBuilder.build()));
-
- componentDescriptor.entryPointMethods().stream()
- .map(method -> method.dependencyRequest().get())
- .forEach(
- entryPoint -> {
- if (entryPoint.kind().equals(MEMBERS_INJECTION)) {
- requestResolver.resolveMembersInjection(entryPoint.key());
- } else {
- requestResolver.resolve(entryPoint.key());
- }
- });
-
- if (createFullBindingGraph) {
- // Resolve the keys for all bindings in all modules, stripping any multibinding contribution
- // identifier so that the multibinding itself is resolved.
- modules(componentDescriptor, parentResolver).stream()
- .flatMap(module -> module.allBindingKeys().stream())
- .map(key -> key.toBuilder().multibindingContributionIdentifier(Optional.empty()).build())
- .forEach(requestResolver::resolve);
- }
-
- // Resolve all bindings for subcomponents, creating subgraphs for all subcomponents that have
- // been detected during binding resolution. If a binding for a subcomponent is never resolved,
- // no BindingGraph will be created for it and no implementation will be generated. This is
- // done in a queue since resolving one subcomponent might resolve a key for a subcomponent
- // from a parent graph. This is done until no more new subcomponents are resolved.
- Set<ComponentDescriptor> resolvedSubcomponents = new HashSet<>();
- ImmutableList.Builder<BindingGraph> subgraphs = ImmutableList.builder();
- for (ComponentDescriptor subcomponent :
- Iterables.consumingIterable(requestResolver.subcomponentsToResolve)) {
- if (resolvedSubcomponents.add(subcomponent)) {
- subgraphs.add(create(Optional.of(requestResolver), subcomponent, createFullBindingGraph));
- }
- }
-
- return BindingGraph.create(
- componentDescriptor,
- requestResolver.getResolvedContributionBindings(),
- requestResolver.getResolvedMembersInjectionBindings(),
- subgraphs.build(),
- requestResolver.getOwnedModules(),
- requestResolver.getFactoryMethod(),
- createFullBindingGraph);
- }
-
- /**
- * Returns all the modules that should be installed in the component. For production components
- * and production subcomponents that have a parent that is not a production component or
- * subcomponent, also includes the production monitoring module for the component and the
- * production executor module.
- */
- private ImmutableSet<ModuleDescriptor> modules(
- ComponentDescriptor componentDescriptor, Optional<Resolver> parentResolver) {
- return shouldIncludeImplicitProductionModules(componentDescriptor, parentResolver)
- ? new ImmutableSet.Builder<ModuleDescriptor>()
- .addAll(componentDescriptor.modules())
- .add(descriptorForMonitoringModule(componentDescriptor.typeElement()))
- .add(descriptorForProductionExecutorModule())
- .build()
- : componentDescriptor.modules();
- }
-
- private boolean shouldIncludeImplicitProductionModules(
- ComponentDescriptor component, Optional<Resolver> parentResolver) {
- return component.isProduction()
- && ((!component.isSubcomponent() && component.isRealComponent())
- || (parentResolver.isPresent()
- && !parentResolver.get().componentDescriptor.isProduction()));
- }
-
- /**
- * Returns a descriptor for a generated module that handles monitoring for production components.
- * This module is generated in the {@link MonitoringModuleProcessingStep}.
- *
- * @throws TypeNotPresentException if the module has not been generated yet. This will cause the
- * processor to retry in a later processing round.
- */
- private ModuleDescriptor descriptorForMonitoringModule(TypeElement componentDefinitionType) {
- return moduleDescriptorFactory.create(
- elements.checkTypePresent(
- generatedMonitoringModuleName(componentDefinitionType).toString()));
- }
-
- /** Returns a descriptor {@link ProductionExecutorModule}. */
- private ModuleDescriptor descriptorForProductionExecutorModule() {
- return moduleDescriptorFactory.create(elements.getTypeElement(ProductionExecutorModule.class));
- }
-
- /** Indexes {@code bindingDeclarations} by {@link BindingDeclaration#key()}. */
- private static <T extends BindingDeclaration>
- ImmutableSetMultimap<Key, T> indexBindingDeclarationsByKey(Iterable<T> declarations) {
- return ImmutableSetMultimap.copyOf(Multimaps.index(declarations, BindingDeclaration::key));
- }
-
- @Override
- public void clearCache() {
- keysMatchingRequestCache.clear();
- }
-
- private final class Resolver {
- final Optional<Resolver> parentResolver;
- final ComponentDescriptor componentDescriptor;
- final ImmutableSetMultimap<Key, ContributionBinding> explicitBindings;
- final ImmutableSet<ContributionBinding> explicitBindingsSet;
- final ImmutableSetMultimap<Key, ContributionBinding> explicitMultibindings;
- final ImmutableSetMultimap<Key, MultibindingDeclaration> multibindingDeclarations;
- final ImmutableSetMultimap<Key, SubcomponentDeclaration> subcomponentDeclarations;
- final ImmutableSetMultimap<Key, DelegateDeclaration> delegateDeclarations;
- final ImmutableSetMultimap<Key, OptionalBindingDeclaration> optionalBindingDeclarations;
- final ImmutableSetMultimap<Key, DelegateDeclaration> delegateMultibindingDeclarations;
- final Map<Key, ResolvedBindings> resolvedContributionBindings = new LinkedHashMap<>();
- final Map<Key, ResolvedBindings> resolvedMembersInjectionBindings = new LinkedHashMap<>();
- final Deque<Key> cycleStack = new ArrayDeque<>();
- final Map<Key, Boolean> keyDependsOnLocalBindingsCache = new HashMap<>();
- final Map<Binding, Boolean> bindingDependsOnLocalBindingsCache = new HashMap<>();
- final Queue<ComponentDescriptor> subcomponentsToResolve = new ArrayDeque<>();
-
- Resolver(
- Optional<Resolver> parentResolver,
- ComponentDescriptor componentDescriptor,
- ImmutableSetMultimap<Key, ContributionBinding> explicitBindings,
- ImmutableSetMultimap<Key, MultibindingDeclaration> multibindingDeclarations,
- ImmutableSetMultimap<Key, SubcomponentDeclaration> subcomponentDeclarations,
- ImmutableSetMultimap<Key, DelegateDeclaration> delegateDeclarations,
- ImmutableSetMultimap<Key, OptionalBindingDeclaration> optionalBindingDeclarations) {
- this.parentResolver = parentResolver;
- this.componentDescriptor = checkNotNull(componentDescriptor);
- this.explicitBindings = checkNotNull(explicitBindings);
- this.explicitBindingsSet = ImmutableSet.copyOf(explicitBindings.values());
- this.multibindingDeclarations = checkNotNull(multibindingDeclarations);
- this.subcomponentDeclarations = checkNotNull(subcomponentDeclarations);
- this.delegateDeclarations = checkNotNull(delegateDeclarations);
- this.optionalBindingDeclarations = checkNotNull(optionalBindingDeclarations);
- this.explicitMultibindings = multibindingContributionsByMultibindingKey(explicitBindingsSet);
- this.delegateMultibindingDeclarations =
- multibindingContributionsByMultibindingKey(delegateDeclarations.values());
- subcomponentsToResolve.addAll(
- componentDescriptor.childComponentsDeclaredByFactoryMethods().values());
- subcomponentsToResolve.addAll(
- componentDescriptor.childComponentsDeclaredByBuilderEntryPoints().values());
- }
-
- /** Returns the optional factory method for this component. */
- Optional<ExecutableElement> getFactoryMethod() {
- return parentResolver
- .flatMap(
- parent ->
- parent.componentDescriptor.getFactoryMethodForChildComponent(componentDescriptor))
- .map(method -> method.methodElement());
- }
-
- /**
- * Returns the resolved contribution bindings for the given {@link Key}:
- *
- * <ul>
- * <li>All explicit bindings for:
- * <ul>
- * <li>the requested key
- * <li>{@code Set<T>} if the requested key's type is {@code Set<Produced<T>>}
- * <li>{@code Map<K, Provider<V>>} if the requested key's type is {@code Map<K,
- * Producer<V>>}.
- * </ul>
- * <li>A synthetic binding that depends on {@code Map<K, Producer<V>>} if the requested key's
- * type is {@code Map<K, V>} and there are some explicit bindings for {@code Map<K,
- * Producer<V>>}.
- * <li>A synthetic binding that depends on {@code Map<K, Provider<V>>} if the requested key's
- * type is {@code Map<K, V>} and there are some explicit bindings for {@code Map<K,
- * Provider<V>>} but no explicit bindings for {@code Map<K, Producer<V>>}.
- * <li>An implicit {@link Inject @Inject}-annotated constructor binding if there is one and
- * there are no explicit bindings or synthetic bindings.
- * </ul>
- */
- ResolvedBindings lookUpBindings(Key requestKey) {
- Set<ContributionBinding> bindings = new LinkedHashSet<>();
- bindings.addAll(getExplicitBindings(requestKey));
-
- ImmutableSet<ContributionBinding> multibindingContributions =
- getAllMatchingBindingDeclarations(requestKey, this::getExplicitMultibindings);
- ImmutableSet<MultibindingDeclaration> multibindingDeclarations =
- getAllMatchingBindingDeclarations(requestKey, this::getMultibindingDeclarations);
-
- syntheticMultibinding(requestKey, multibindingContributions, multibindingDeclarations)
- .ifPresent(bindings::add);
-
- ImmutableSet<OptionalBindingDeclaration> optionalBindingDeclarations =
- getAllMatchingBindingDeclarations(requestKey, this::getOptionalBindingDeclarations);
- syntheticOptionalBinding(requestKey, optionalBindingDeclarations).ifPresent(bindings::add);
-
- ImmutableSet<SubcomponentDeclaration> subcomponentDeclarations =
- getSubcomponentDeclarations(requestKey);
- syntheticSubcomponentBuilderBinding(subcomponentDeclarations)
- .ifPresent(
- binding -> {
- bindings.add(binding);
- addSubcomponentToOwningResolver(binding);
- });
-
- if (isType(requestKey.type()) && isTypeOf(MembersInjector.class, requestKey.type())) {
- injectBindingRegistry
- .getOrFindMembersInjectorProvisionBinding(requestKey)
- .ifPresent(bindings::add);
- }
-
- // If there are no bindings, add the implicit @Inject-constructed binding if there is one.
- if (bindings.isEmpty()) {
- injectBindingRegistry.getOrFindProvisionBinding(requestKey)
- .filter(binding -> !isIncorrectlyScopedInPartialGraph(binding))
- .ifPresent(bindings::add);
- }
-
- return ResolvedBindings.forContributionBindings(
- requestKey,
- indexBindingsByOwningComponent(requestKey, ImmutableSet.copyOf(bindings)),
- multibindingDeclarations,
- subcomponentDeclarations,
- optionalBindingDeclarations);
- }
-
- /**
- * Returns true if this binding graph resolution is for a partial graph and the {@code @Inject}
- * binding's scope doesn't match any of the components in the current component ancestry. If so,
- * the binding is not owned by any of the currently known components, and will be owned by a
- * future ancestor (or, if never owned, will result in an incompatibly scoped binding error at
- * the root component).
- */
- private boolean isIncorrectlyScopedInPartialGraph(ProvisionBinding binding) {
- checkArgument(binding.kind().equals(INJECTION));
- Resolver owningResolver = getOwningResolver(binding).orElse(this);
- ComponentDescriptor owningComponent = owningResolver.componentDescriptor;
- return rootComponent().isSubcomponent()
- && binding.scope().isPresent()
- && !binding.scope().get().isReusable()
- && !owningComponent.scopes().contains(binding.scope().get());
- }
-
- private ComponentDescriptor rootComponent() {
- return parentResolver.map(Resolver::rootComponent).orElse(componentDescriptor);
- }
-
- /** Returns the resolved members injection bindings for the given {@link Key}. */
- ResolvedBindings lookUpMembersInjectionBinding(Key requestKey) {
- // no explicit deps for members injection, so just look it up
- Optional<MembersInjectionBinding> binding =
- injectBindingRegistry.getOrFindMembersInjectionBinding(requestKey);
- return binding.isPresent()
- ? ResolvedBindings.forMembersInjectionBinding(
- requestKey, componentDescriptor, binding.get())
- : ResolvedBindings.noBindings(requestKey);
- }
-
- /**
- * When a binding is resolved for a {@link SubcomponentDeclaration}, adds corresponding {@link
- * ComponentDescriptor subcomponent} to a queue in the owning component's resolver. The queue
- * will be used to detect which subcomponents need to be resolved.
- */
- private void addSubcomponentToOwningResolver(ProvisionBinding subcomponentCreatorBinding) {
- checkArgument(subcomponentCreatorBinding.kind().equals(SUBCOMPONENT_CREATOR));
- Resolver owningResolver = getOwningResolver(subcomponentCreatorBinding).get();
-
- TypeElement builderType = MoreTypes.asTypeElement(subcomponentCreatorBinding.key().type());
- owningResolver.subcomponentsToResolve.add(
- owningResolver.componentDescriptor.getChildComponentWithBuilderType(builderType));
- }
-
- /**
- * Profiling has determined that computing the keys matching {@code requestKey} has measurable
- * performance impact. It is called repeatedly (at least 3 times per key resolved per {@link
- * BindingGraph}. {@code javac}'s name-checking performance seems suboptimal (converting byte
- * strings to Strings repeatedly), and the matching keys creations relies on that. This also
- * ensures that the resulting keys have their hash codes cached on successive calls to this
- * method.
- *
- * <p>This caching may become obsolete if:
- *
- * <ul>
- * <li>We decide to intern all {@link Key} instances
- * <li>We fix javac's name-checking peformance (though we may want to keep this for older
- * javac users)
- * </ul>
- */
- private ImmutableSet<Key> keysMatchingRequest(Key requestKey) {
- return keysMatchingRequestCache.computeIfAbsent(
- requestKey, this::keysMatchingRequestUncached);
- }
-
- private ImmutableSet<Key> keysMatchingRequestUncached(Key requestKey) {
- ImmutableSet.Builder<Key> keys = ImmutableSet.builder();
- keys.add(requestKey);
- keyFactory.unwrapSetKey(requestKey, Produced.class).ifPresent(keys::add);
- keyFactory.rewrapMapKey(requestKey, Producer.class, Provider.class).ifPresent(keys::add);
- keyFactory.rewrapMapKey(requestKey, Provider.class, Producer.class).ifPresent(keys::add);
- keys.addAll(keyFactory.implicitFrameworkMapKeys(requestKey));
- return keys.build();
- }
-
- /**
- * Returns a synthetic binding that depends on individual multibinding contributions.
- *
- * <p>If there are no {@code multibindingContributions} or {@code multibindingDeclarations},
- * returns {@link Optional#empty()}.
- *
- * <p>If there are production {@code multibindingContributions} or the request is for any of the
- * following types, returns a {@link ProductionBinding}.
- *
- * <ul>
- * <li>{@code Set<Produced<T>>}
- * <li>{@code Map<K, Producer<V>>}
- * <li>{@code Map<K, Produced<V>>}
- * </ul>
- *
- * Otherwise, returns a {@link ProvisionBinding}.
- */
- private Optional<ContributionBinding> syntheticMultibinding(
- Key key,
- Iterable<ContributionBinding> multibindingContributions,
- Iterable<MultibindingDeclaration> multibindingDeclarations) {
- return isEmpty(multibindingContributions) && isEmpty(multibindingDeclarations)
- ? Optional.empty()
- : Optional.of(bindingFactory.syntheticMultibinding(key, multibindingContributions));
- }
-
- private Optional<ProvisionBinding> syntheticSubcomponentBuilderBinding(
- ImmutableSet<SubcomponentDeclaration> subcomponentDeclarations) {
- return subcomponentDeclarations.isEmpty()
- ? Optional.empty()
- : Optional.of(bindingFactory.subcomponentCreatorBinding(subcomponentDeclarations));
- }
-
- /**
- * Returns a synthetic binding for {@code @Qualifier Optional<Type>} if there are any {@code
- * optionalBindingDeclarations}.
- *
- * <p>If there are no bindings for the underlying key (the key for dependency requests for
- * {@code Type}), returns a provision binding that always returns {@link Optional#empty()}.
- *
- * <p>If there are any production bindings for the underlying key, returns a production binding.
- * Otherwise returns a provision binding.
- */
- private Optional<ContributionBinding> syntheticOptionalBinding(
- Key key, ImmutableSet<OptionalBindingDeclaration> optionalBindingDeclarations) {
- return optionalBindingDeclarations.isEmpty()
- ? Optional.empty()
- : Optional.of(
- bindingFactory.syntheticOptionalBinding(
- key,
- getRequestKind(OptionalType.from(key).valueType()),
- lookUpBindings(keyFactory.unwrapOptional(key).get())));
- }
-
- private ImmutableSet<ContributionBinding> createDelegateBindings(
- ImmutableSet<DelegateDeclaration> delegateDeclarations) {
- ImmutableSet.Builder<ContributionBinding> builder = ImmutableSet.builder();
- for (DelegateDeclaration delegateDeclaration : delegateDeclarations) {
- builder.add(createDelegateBinding(delegateDeclaration));
- }
- return builder.build();
- }
-
- /**
- * Creates one (and only one) delegate binding for a delegate declaration, based on the resolved
- * bindings of the right-hand-side of a {@link dagger.Binds} method. If there are duplicate
- * bindings for the dependency key, there should still be only one binding for the delegate key.
- */
- private ContributionBinding createDelegateBinding(DelegateDeclaration delegateDeclaration) {
- Key delegateKey = delegateDeclaration.delegateRequest().key();
- if (cycleStack.contains(delegateKey)) {
- return bindingFactory.unresolvedDelegateBinding(delegateDeclaration);
- }
-
- ResolvedBindings resolvedDelegate;
- try {
- cycleStack.push(delegateKey);
- resolvedDelegate = lookUpBindings(delegateKey);
- } finally {
- cycleStack.pop();
- }
- if (resolvedDelegate.contributionBindings().isEmpty()) {
- // This is guaranteed to result in a missing binding error, so it doesn't matter if the
- // binding is a Provision or Production, except if it is a @IntoMap method, in which
- // case the key will be of type Map<K, Provider<V>>, which will be "upgraded" into a
- // Map<K, Producer<V>> if it's requested in a ProductionComponent. This may result in a
- // strange error, that the RHS needs to be provided with an @Inject or @Provides
- // annotated method, but a user should be able to figure out if a @Produces annotation
- // is needed.
- // TODO(gak): revisit how we model missing delegates if/when we clean up how we model
- // binding declarations
- return bindingFactory.unresolvedDelegateBinding(delegateDeclaration);
- }
- // It doesn't matter which of these is selected, since they will later on produce a
- // duplicate binding error.
- ContributionBinding explicitDelegate =
- resolvedDelegate.contributionBindings().iterator().next();
- return bindingFactory.delegateBinding(delegateDeclaration, explicitDelegate);
- }
-
- // TODO(dpb,ronshapiro): requestKey appears to be interchangeable with each binding's .key(),
- // but should it? We're currently conflating the two all over the place and it would be good
- // to unify, or if it's necessary, clarify why with docs+tests. Specifically, should we also
- // be checking these for keysMatchingRequest?
- private ImmutableSetMultimap<TypeElement, ContributionBinding> indexBindingsByOwningComponent(
- Key requestKey, Iterable<? extends ContributionBinding> bindings) {
- ImmutableSetMultimap.Builder<TypeElement, ContributionBinding> index =
- ImmutableSetMultimap.builder();
- for (ContributionBinding binding : bindings) {
- index.put(getOwningComponent(requestKey, binding), binding);
- }
- return index.build();
- }
-
- /**
- * Returns the component that should contain the framework field for {@code binding}.
- *
- * <p>If {@code binding} is either not bound in an ancestor component or depends transitively on
- * bindings in this component, returns this component.
- *
- * <p>Otherwise, resolves {@code request} in this component's parent in order to resolve any
- * multibinding contributions in the parent, and returns the parent-resolved {@link
- * ResolvedBindings#owningComponent(ContributionBinding)}.
- */
- private TypeElement getOwningComponent(Key requestKey, ContributionBinding binding) {
- if (isResolvedInParent(requestKey, binding)
- && !new LocalDependencyChecker().dependsOnLocalBindings(binding)) {
- ResolvedBindings parentResolvedBindings =
- parentResolver.get().resolvedContributionBindings.get(requestKey);
- return parentResolvedBindings.owningComponent(binding);
- } else {
- return componentDescriptor.typeElement();
- }
- }
-
- /**
- * Returns {@code true} if {@code binding} is owned by an ancestor. If so, {@linkplain #resolve
- * resolves} the {@link Key} in this component's parent. Don't resolve directly in the owning
- * component in case it depends on multibindings in any of its descendants.
- */
- private boolean isResolvedInParent(Key requestKey, ContributionBinding binding) {
- Optional<Resolver> owningResolver = getOwningResolver(binding);
- if (owningResolver.isPresent() && !owningResolver.get().equals(this)) {
- parentResolver.get().resolve(requestKey);
- return true;
- } else {
- return false;
- }
- }
-
- private Optional<Resolver> getOwningResolver(ContributionBinding binding) {
- // TODO(ronshapiro): extract the different pieces of this method into their own methods
- if ((binding.scope().isPresent() && binding.scope().get().isProductionScope())
- || binding.bindingType().equals(BindingType.PRODUCTION)) {
- for (Resolver requestResolver : getResolverLineage()) {
- // Resolve @Inject @ProductionScope bindings at the highest production component.
- if (binding.kind().equals(INJECTION)
- && requestResolver.componentDescriptor.isProduction()) {
- return Optional.of(requestResolver);
- }
-
- // Resolve explicit @Produces and @ProductionScope bindings at the highest component that
- // installs the binding.
- if (requestResolver.containsExplicitBinding(binding)) {
- return Optional.of(requestResolver);
- }
- }
- }
-
- if (binding.scope().isPresent() && binding.scope().get().isReusable()) {
- for (Resolver requestResolver : getResolverLineage().reverse()) {
- // If a @Reusable binding was resolved in an ancestor, use that component.
- ResolvedBindings resolvedBindings =
- requestResolver.resolvedContributionBindings.get(binding.key());
- if (resolvedBindings != null
- && resolvedBindings.contributionBindings().contains(binding)) {
- return Optional.of(requestResolver);
- }
- }
- // If a @Reusable binding was not resolved in any ancestor, resolve it here.
- return Optional.empty();
- }
-
- for (Resolver requestResolver : getResolverLineage().reverse()) {
- if (requestResolver.containsExplicitBinding(binding)) {
- return Optional.of(requestResolver);
- }
- }
-
- // look for scope separately. we do this for the case where @Singleton can appear twice
- // in the † compatibility mode
- Optional<Scope> bindingScope = binding.scope();
- if (bindingScope.isPresent()) {
- for (Resolver requestResolver : getResolverLineage().reverse()) {
- if (requestResolver.componentDescriptor.scopes().contains(bindingScope.get())) {
- return Optional.of(requestResolver);
- }
- }
- }
- return Optional.empty();
- }
-
- private boolean containsExplicitBinding(ContributionBinding binding) {
- return explicitBindingsSet.contains(binding)
- || resolverContainsDelegateDeclarationForBinding(binding)
- || subcomponentDeclarations.containsKey(binding.key());
- }
-
- /** Returns true if {@code binding} was installed in a module in this resolver's component. */
- private boolean resolverContainsDelegateDeclarationForBinding(ContributionBinding binding) {
- return binding.kind().equals(DELEGATE)
- && delegateDeclarations.get(binding.key()).stream()
- .anyMatch(
- declaration ->
- declaration.contributingModule().equals(binding.contributingModule())
- && declaration.bindingElement().equals(binding.bindingElement()));
- }
-
- /** Returns the resolver lineage from parent to child. */
- private ImmutableList<Resolver> getResolverLineage() {
- ImmutableList.Builder<Resolver> resolverList = ImmutableList.builder();
- for (Optional<Resolver> currentResolver = Optional.of(this);
- currentResolver.isPresent();
- currentResolver = currentResolver.get().parentResolver) {
- resolverList.add(currentResolver.get());
- }
- return resolverList.build().reverse();
- }
-
- /**
- * For all {@linkplain #keysMatchingRequest(Key) keys matching {@code requestKey}}, applies
- * {@code getDeclarationsPerKey} and collects the values into an {@link ImmutableSet}.
- */
- private <T extends BindingDeclaration> ImmutableSet<T> getAllMatchingBindingDeclarations(
- Key requestKey, Function<Key, Collection<T>> getDeclarationsPerKey) {
- return keysMatchingRequest(requestKey)
- .stream()
- .flatMap(key -> getDeclarationsPerKey.apply(key).stream())
- .collect(toImmutableSet());
- }
-
- /**
- * Returns the explicit {@link ContributionBinding}s that match the {@code key} from this and
- * all ancestor resolvers.
- */
- private ImmutableSet<ContributionBinding> getExplicitBindings(Key key) {
- ImmutableSet.Builder<ContributionBinding> bindings = ImmutableSet.builder();
- for (Resolver resolver : getResolverLineage()) {
- bindings.addAll(resolver.getLocalExplicitBindings(key));
- }
- return bindings.build();
- }
-
- /**
- * Returns the explicit {@link ContributionBinding}s that match the {@code key} from this
- * resolver.
- */
- private ImmutableSet<ContributionBinding> getLocalExplicitBindings(Key key) {
- return new ImmutableSet.Builder<ContributionBinding>()
- .addAll(explicitBindings.get(key))
- // @Binds @IntoMap declarations have key Map<K, V>, unlike @Provides @IntoMap or @Produces
- // @IntoMap, which have Map<K, Provider/Producer<V>> keys. So unwrap the key's type's
- // value type if it's a Map<K, Provider/Producer<V>> before looking in
- // delegateDeclarations. createDelegateBindings() will create bindings with the properly
- // wrapped key type.
- .addAll(
- createDelegateBindings(delegateDeclarations.get(keyFactory.unwrapMapValueType(key))))
- .build();
- }
-
- /**
- * Returns the explicit multibinding contributions that contribute to the map or set requested
- * by {@code key} from this and all ancestor resolvers.
- */
- private ImmutableSet<ContributionBinding> getExplicitMultibindings(Key key) {
- ImmutableSet.Builder<ContributionBinding> multibindings = ImmutableSet.builder();
- for (Resolver resolver : getResolverLineage()) {
- multibindings.addAll(resolver.getLocalExplicitMultibindings(key));
- }
- return multibindings.build();
- }
-
- /**
- * Returns the explicit multibinding contributions that contribute to the map or set requested
- * by {@code key} from this resolver.
- */
- private ImmutableSet<ContributionBinding> getLocalExplicitMultibindings(Key key) {
- ImmutableSet.Builder<ContributionBinding> multibindings = ImmutableSet.builder();
- multibindings.addAll(explicitMultibindings.get(key));
- if (!MapType.isMap(key)
- || MapType.from(key).isRawType()
- || MapType.from(key).valuesAreFrameworkType()) {
- // @Binds @IntoMap declarations have key Map<K, V>, unlike @Provides @IntoMap or @Produces
- // @IntoMap, which have Map<K, Provider/Producer<V>> keys. So unwrap the key's type's
- // value type if it's a Map<K, Provider/Producer<V>> before looking in
- // delegateMultibindingDeclarations. createDelegateBindings() will create bindings with the
- // properly wrapped key type.
- multibindings.addAll(
- createDelegateBindings(
- delegateMultibindingDeclarations.get(keyFactory.unwrapMapValueType(key))));
- }
- return multibindings.build();
- }
-
- /**
- * Returns the {@link MultibindingDeclaration}s that match the {@code key} from this and all
- * ancestor resolvers.
- */
- private ImmutableSet<MultibindingDeclaration> getMultibindingDeclarations(Key key) {
- ImmutableSet.Builder<MultibindingDeclaration> multibindingDeclarations =
- ImmutableSet.builder();
- for (Resolver resolver : getResolverLineage()) {
- multibindingDeclarations.addAll(resolver.multibindingDeclarations.get(key));
- }
- return multibindingDeclarations.build();
- }
-
- /**
- * Returns the {@link SubcomponentDeclaration}s that match the {@code key} from this and all
- * ancestor resolvers.
- */
- private ImmutableSet<SubcomponentDeclaration> getSubcomponentDeclarations(Key key) {
- ImmutableSet.Builder<SubcomponentDeclaration> subcomponentDeclarations =
- ImmutableSet.builder();
- for (Resolver resolver : getResolverLineage()) {
- subcomponentDeclarations.addAll(resolver.subcomponentDeclarations.get(key));
- }
- return subcomponentDeclarations.build();
- }
- /**
- * Returns the {@link OptionalBindingDeclaration}s that match the {@code key} from this and all
- * ancestor resolvers.
- */
- private ImmutableSet<OptionalBindingDeclaration> getOptionalBindingDeclarations(Key key) {
- Optional<Key> unwrapped = keyFactory.unwrapOptional(key);
- if (!unwrapped.isPresent()) {
- return ImmutableSet.of();
- }
- ImmutableSet.Builder<OptionalBindingDeclaration> declarations = ImmutableSet.builder();
- for (Resolver resolver : getResolverLineage()) {
- declarations.addAll(resolver.optionalBindingDeclarations.get(unwrapped.get()));
- }
- return declarations.build();
- }
-
- /**
- * Returns the {@link ResolvedBindings} for {@code key} that was resolved in this resolver or an
- * ancestor resolver. Only checks for {@link ContributionBinding}s as {@link
- * MembersInjectionBinding}s are not inherited.
- */
- private Optional<ResolvedBindings> getPreviouslyResolvedBindings(Key key) {
- Optional<ResolvedBindings> result =
- Optional.ofNullable(resolvedContributionBindings.get(key));
- if (result.isPresent()) {
- return result;
- } else if (parentResolver.isPresent()) {
- return parentResolver.get().getPreviouslyResolvedBindings(key);
- } else {
- return Optional.empty();
- }
- }
-
- private void resolveMembersInjection(Key key) {
- ResolvedBindings bindings = lookUpMembersInjectionBinding(key);
- resolveDependencies(bindings);
- resolvedMembersInjectionBindings.put(key, bindings);
- }
-
- void resolve(Key key) {
- // If we find a cycle, stop resolving. The original request will add it with all of the
- // other resolved deps.
- if (cycleStack.contains(key)) {
- return;
- }
-
- // If the binding was previously resolved in this (sub)component, don't resolve it again.
- if (resolvedContributionBindings.containsKey(key)) {
- return;
- }
-
- /*
- * If the binding was previously resolved in an ancestor component, then we may be able to
- * avoid resolving it here and just depend on the ancestor component resolution.
- *
- * 1. If it depends transitively on multibinding contributions or optional bindings with
- * bindings from this subcomponent, then we have to resolve it in this subcomponent so
- * that it sees the local bindings.
- *
- * 2. If there are any explicit bindings in this component, they may conflict with those in
- * the ancestor component, so resolve them here so that conflicts can be caught.
- */
- if (getPreviouslyResolvedBindings(key).isPresent()) {
- /* Resolve in the parent in case there are multibinding contributions or conflicts in some
- * component between this one and the previously-resolved one. */
- parentResolver.get().resolve(key);
- if (!new LocalDependencyChecker().dependsOnLocalBindings(key)
- && getLocalExplicitBindings(key).isEmpty()) {
- /* Cache the inherited parent component's bindings in case resolving at the parent found
- * bindings in some component between this one and the previously-resolved one. */
- resolvedContributionBindings.put(key, getPreviouslyResolvedBindings(key).get());
- return;
- }
- }
-
- cycleStack.push(key);
- try {
- ResolvedBindings bindings = lookUpBindings(key);
- resolvedContributionBindings.put(key, bindings);
- resolveDependencies(bindings);
- } finally {
- cycleStack.pop();
- }
- }
-
- /**
- * {@link #resolve(Key) Resolves} each of the dependencies of the bindings owned by this
- * component.
- */
- private void resolveDependencies(ResolvedBindings resolvedBindings) {
- for (Binding binding : resolvedBindings.bindingsOwnedBy(componentDescriptor)) {
- for (DependencyRequest dependency : binding.dependencies()) {
- resolve(dependency.key());
- }
- }
- }
-
- /**
- * Returns all of the {@link ResolvedBindings} for {@link ContributionBinding}s from this and
- * all ancestor resolvers, indexed by {@link ResolvedBindings#key()}.
- */
- Map<Key, ResolvedBindings> getResolvedContributionBindings() {
- Map<Key, ResolvedBindings> bindings = new LinkedHashMap<>();
- parentResolver.ifPresent(parent -> bindings.putAll(parent.getResolvedContributionBindings()));
- bindings.putAll(resolvedContributionBindings);
- return bindings;
- }
-
- /**
- * Returns all of the {@link ResolvedBindings} for {@link MembersInjectionBinding} from this
- * resolvers, indexed by {@link ResolvedBindings#key()}.
- */
- ImmutableMap<Key, ResolvedBindings> getResolvedMembersInjectionBindings() {
- return ImmutableMap.copyOf(resolvedMembersInjectionBindings);
- }
-
- ImmutableSet<ModuleDescriptor> getInheritedModules() {
- return parentResolver.isPresent()
- ? Sets.union(
- parentResolver.get().getInheritedModules(),
- parentResolver.get().componentDescriptor.modules())
- .immutableCopy()
- : ImmutableSet.<ModuleDescriptor>of();
- }
-
- ImmutableSet<ModuleDescriptor> getOwnedModules() {
- return Sets.difference(componentDescriptor.modules(), getInheritedModules()).immutableCopy();
- }
-
- private final class LocalDependencyChecker {
- private final Set<Object> cycleChecker = new HashSet<>();
-
- /**
- * Returns {@code true} if any of the bindings resolved for {@code key} are multibindings with
- * contributions declared within this component's modules or optional bindings with present
- * values declared within this component's modules, or if any of its unscoped dependencies
- * depend on such bindings.
- *
- * <p>We don't care about scoped dependencies because they will never depend on bindings from
- * subcomponents.
- *
- * @throws IllegalArgumentException if {@link #getPreviouslyResolvedBindings(Key)} is empty
- */
- boolean dependsOnLocalBindings(Key key) {
- // Don't recur infinitely if there are valid cycles in the dependency graph.
- // http://b/23032377
- if (!cycleChecker.add(key)) {
- return false;
- }
- return reentrantComputeIfAbsent(
- keyDependsOnLocalBindingsCache, key, this::dependsOnLocalBindingsUncached);
- }
-
- private boolean dependsOnLocalBindingsUncached(Key key) {
- checkArgument(
- getPreviouslyResolvedBindings(key).isPresent(),
- "no previously resolved bindings in %s for %s",
- Resolver.this,
- key);
- ResolvedBindings previouslyResolvedBindings = getPreviouslyResolvedBindings(key).get();
- if (hasLocalMultibindingContributions(key)
- || hasLocalOptionalBindingContribution(previouslyResolvedBindings)) {
- return true;
- }
-
- for (Binding binding : previouslyResolvedBindings.bindings()) {
- if (dependsOnLocalBindings(binding)) {
- return true;
- }
- }
- return false;
- }
-
- /**
- * Returns {@code true} if {@code binding} is unscoped (or has {@link Reusable @Reusable}
- * scope) and depends on multibindings with contributions declared within this component's
- * modules, or if any of its unscoped or {@link Reusable @Reusable} scoped dependencies depend
- * on such local multibindings.
- *
- * <p>We don't care about non-reusable scoped dependencies because they will never depend on
- * multibindings with contributions from subcomponents.
- */
- boolean dependsOnLocalBindings(Binding binding) {
- if (!cycleChecker.add(binding)) {
- return false;
- }
- return reentrantComputeIfAbsent(
- bindingDependsOnLocalBindingsCache, binding, this::dependsOnLocalBindingsUncached);
- }
-
- private boolean dependsOnLocalBindingsUncached(Binding binding) {
- if ((!binding.scope().isPresent() || binding.scope().get().isReusable())
- // TODO(beder): Figure out what happens with production subcomponents.
- && !binding.bindingType().equals(BindingType.PRODUCTION)) {
- for (DependencyRequest dependency : binding.dependencies()) {
- if (dependsOnLocalBindings(dependency.key())) {
- return true;
- }
- }
- }
- return false;
- }
-
- /**
- * Returns {@code true} if there is at least one multibinding contribution declared within
- * this component's modules that matches the key.
- */
- private boolean hasLocalMultibindingContributions(Key requestKey) {
- return keysMatchingRequest(requestKey)
- .stream()
- .anyMatch(key -> !getLocalExplicitMultibindings(key).isEmpty());
- }
-
- /**
- * Returns {@code true} if there is a contribution in this component for an {@code
- * Optional<Foo>} key that has not been contributed in a parent.
- */
- private boolean hasLocalOptionalBindingContribution(ResolvedBindings resolvedBindings) {
- if (resolvedBindings
- .contributionBindings()
- .stream()
- .map(ContributionBinding::kind)
- .anyMatch(isEqual(OPTIONAL))) {
- return !getLocalExplicitBindings(keyFactory.unwrapOptional(resolvedBindings.key()).get())
- .isEmpty();
- } else {
- // If a parent contributes a @Provides Optional<Foo> binding and a child has a
- // @BindsOptionalOf Foo method, the two should conflict, even if there is no binding for
- // Foo on its own
- return !getOptionalBindingDeclarations(resolvedBindings.key()).isEmpty();
- }
- }
- }
- }
-
- /**
- * A multimap of those {@code declarations} that are multibinding contribution declarations,
- * indexed by the key of the set or map to which they contribute.
- */
- static <T extends BindingDeclaration>
- ImmutableSetMultimap<Key, T> multibindingContributionsByMultibindingKey(
- Iterable<T> declarations) {
- ImmutableSetMultimap.Builder<Key, T> builder = ImmutableSetMultimap.builder();
- for (T declaration : declarations) {
- if (declaration.key().multibindingContributionIdentifier().isPresent()) {
- builder.put(
- declaration
- .key()
- .toBuilder()
- .multibindingContributionIdentifier(Optional.empty())
- .build(),
- declaration);
- }
- }
- return builder.build();
- }
-}
diff --git a/java/dagger/internal/codegen/BindingGraphPlugins.java b/java/dagger/internal/codegen/BindingGraphPlugins.java
deleted file mode 100644
index e2c3812..0000000
--- a/java/dagger/internal/codegen/BindingGraphPlugins.java
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.spi.BindingGraphPlugin;
-import java.util.Map;
-import java.util.Set;
-import javax.annotation.processing.Filer;
-import javax.inject.Inject;
-
-/** Initializes {@link BindingGraphPlugin}s. */
-final class BindingGraphPlugins {
- private final ImmutableSet<BindingGraphPlugin> plugins;
- private final Filer filer;
- private final DaggerTypes types;
- private final DaggerElements elements;
- private final Map<String, String> processingOptions;
-
- @Inject
- BindingGraphPlugins(
- @Validation Set<BindingGraphPlugin> validationPlugins,
- ImmutableSet<BindingGraphPlugin> externalPlugins,
- Filer filer,
- DaggerTypes types,
- DaggerElements elements,
- @ProcessingOptions Map<String, String> processingOptions) {
- this.plugins = Sets.union(validationPlugins, externalPlugins).immutableCopy();
- this.filer = filer;
- this.types = types;
- this.elements = elements;
- this.processingOptions = processingOptions;
- }
-
- /** Returns {@link BindingGraphPlugin#supportedOptions()} from all the plugins. */
- ImmutableSet<String> allSupportedOptions() {
- return plugins.stream()
- .flatMap(plugin -> plugin.supportedOptions().stream())
- .collect(toImmutableSet());
- }
-
- /** Initializes the plugins. */
- // TODO(ronshapiro): Should we validate the uniqueness of plugin names?
- void initializePlugins() {
- plugins.forEach(this::initializePlugin);
- }
-
- private void initializePlugin(BindingGraphPlugin plugin) {
- plugin.initFiler(filer);
- plugin.initTypes(types);
- plugin.initElements(elements);
- Set<String> supportedOptions = plugin.supportedOptions();
- if (!supportedOptions.isEmpty()) {
- plugin.initOptions(Maps.filterKeys(processingOptions, supportedOptions::contains));
- }
- }
-}
diff --git a/java/dagger/internal/codegen/BindingGraphStatisticsCollector.java b/java/dagger/internal/codegen/BindingGraphStatisticsCollector.java
deleted file mode 100644
index 129647f..0000000
--- a/java/dagger/internal/codegen/BindingGraphStatisticsCollector.java
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * Copyright (C) 2019 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.errorprone.util.ASTHelpers.getSymbol;
-import static dagger.internal.codegen.ComponentAnnotation.rootComponentAnnotation;
-
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.bugpatterns.BugChecker;
-import com.google.errorprone.bugpatterns.BugChecker.ClassTreeMatcher;
-import com.google.errorprone.matchers.Description;
-import com.sun.source.tree.ClassTree;
-import com.sun.tools.javac.code.Symbol.ClassSymbol;
-import com.sun.tools.javac.util.Context;
-import dagger.BindsInstance;
-import dagger.Component;
-import dagger.model.BindingGraph;
-import javax.inject.Inject;
-import javax.inject.Singleton;
-
-/** A {@link BugChecker} that collects statistics derived from a {@link BindingGraph}. */
-public abstract class BindingGraphStatisticsCollector extends BugChecker
- implements ClassTreeMatcher {
- private BindingGraphConverter bindingGraphConverter;
- private BindingGraphFactory bindingGraphFactory;
- private ComponentDescriptorFactory componentDescriptorFactory;
- private boolean isInjected;
-
- @Singleton
- @Component(modules = JavacPluginModule.class)
- interface Injector {
- void inject(BindingGraphStatisticsCollector collector);
-
- @Component.Factory
- interface Factory {
- Injector create(@BindsInstance Context context);
- }
- }
-
- // BugCheckers must have no-arg constructors, so we'll use method injection instead.
- @Inject
- void inject(
- BindingGraphConverter bindingGraphConverter,
- BindingGraphFactory bindingGraphFactory,
- ComponentDescriptorFactory componentDescriptorFactory) {
- this.bindingGraphConverter = bindingGraphConverter;
- this.bindingGraphFactory = bindingGraphFactory;
- this.componentDescriptorFactory = componentDescriptorFactory;
- }
-
- @Override
- public final Description matchClass(ClassTree tree, VisitorState state) {
- injectIfNecessary(state.context);
-
- ClassSymbol symbol = getSymbol(tree);
- rootComponentAnnotation(symbol)
- .map(annotation -> createBindingGraph(symbol))
- .ifPresent(graph -> visitBindingGraph(graph, state));
-
- return Description.NO_MATCH;
- }
-
- private BindingGraph createBindingGraph(ClassSymbol component) {
- return bindingGraphConverter.convert(
- bindingGraphFactory.create(
- componentDescriptorFactory.rootComponentDescriptor(component), false));
- }
-
- /** Visits a {@link BindingGraph} and emits stats to a {@link VisitorState}. */
- protected abstract void visitBindingGraph(BindingGraph graph, VisitorState state);
-
- private void injectIfNecessary(Context context) {
- if (isInjected) {
- return;
- }
- DaggerBindingGraphStatisticsCollector_Injector.factory().create(context).inject(this);
- isInjected = true;
- }
-}
diff --git a/java/dagger/internal/codegen/BindingGraphValidationModule.java b/java/dagger/internal/codegen/BindingGraphValidationModule.java
deleted file mode 100644
index 63e1fa2..0000000
--- a/java/dagger/internal/codegen/BindingGraphValidationModule.java
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import dagger.Binds;
-import dagger.Module;
-import dagger.multibindings.IntoSet;
-import dagger.spi.BindingGraphPlugin;
-
-/** Binds the set of {@link BindingGraphPlugin}s used to implement Dagger validation. */
-@Module
-interface BindingGraphValidationModule {
-
- @Binds
- @IntoSet
- @Validation
- BindingGraphPlugin dependencyCycle(DependencyCycleValidator validation);
-
- @Binds
- @IntoSet
- @Validation
- BindingGraphPlugin dependsOnProductionExecutor(DependsOnProductionExecutorValidator validation);
-
- @Binds
- @IntoSet
- @Validation
- BindingGraphPlugin duplicateBindings(DuplicateBindingsValidator validation);
-
- @Binds
- @IntoSet
- @Validation
- BindingGraphPlugin incompatiblyScopedBindings(IncompatiblyScopedBindingsValidator validation);
-
- @Binds
- @IntoSet
- @Validation
- BindingGraphPlugin injectBinding(InjectBindingValidator validation);
-
- @Binds
- @IntoSet
- @Validation
- BindingGraphPlugin mapMultibinding(MapMultibindingValidator validation);
-
- @Binds
- @IntoSet
- @Validation
- BindingGraphPlugin missingBinding(MissingBindingValidator validation);
-
- @Binds
- @IntoSet
- @Validation
- BindingGraphPlugin nullableBinding(NullableBindingValidator validation);
-
- @Binds
- @IntoSet
- @Validation
- BindingGraphPlugin provisionDependencyOnProducerBinding(
- ProvisionDependencyOnProducerBindingValidator validation);
-
- @Binds
- @IntoSet
- @Validation
- BindingGraphPlugin subcomponentFactoryMethod(SubcomponentFactoryMethodValidator validation);
-}
diff --git a/java/dagger/internal/codegen/BindingGraphValidator.java b/java/dagger/internal/codegen/BindingGraphValidator.java
deleted file mode 100644
index df17b15..0000000
--- a/java/dagger/internal/codegen/BindingGraphValidator.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static javax.tools.Diagnostic.Kind.ERROR;
-
-import com.google.common.collect.ImmutableSet;
-import dagger.internal.codegen.DiagnosticReporterFactory.DiagnosticReporterImpl;
-import dagger.model.BindingGraph;
-import dagger.spi.BindingGraphPlugin;
-import java.util.Set;
-import javax.inject.Inject;
-import javax.inject.Singleton;
-
-/** Validates a {@link BindingGraph}. */
-@Singleton
-final class BindingGraphValidator {
- private final ImmutableSet<BindingGraphPlugin> validationPlugins;
- private final ImmutableSet<BindingGraphPlugin> externalPlugins;
- private final DiagnosticReporterFactory diagnosticReporterFactory;
-
- @Inject
- BindingGraphValidator(
- @Validation Set<BindingGraphPlugin> validationPlugins,
- ImmutableSet<BindingGraphPlugin> externalPlugins,
- DiagnosticReporterFactory diagnosticReporterFactory) {
- this.validationPlugins = ImmutableSet.copyOf(validationPlugins);
- this.externalPlugins = ImmutableSet.copyOf(externalPlugins);
- this.diagnosticReporterFactory = checkNotNull(diagnosticReporterFactory);
- }
-
- /** Returns {@code true} if no errors are reported for {@code graph}. */
- boolean isValid(BindingGraph graph) {
- return isValid(validationPlugins, graph) && isValid(externalPlugins, graph);
- }
-
- private boolean isValid(ImmutableSet<BindingGraphPlugin> plugins, BindingGraph graph) {
- boolean isValid = true;
- for (BindingGraphPlugin plugin : plugins) {
- DiagnosticReporterImpl reporter = diagnosticReporterFactory.reporter(graph, plugin);
- plugin.visitGraph(graph, reporter);
- if (reporter.reportedDiagnosticKinds().contains(ERROR)) {
- isValid = false;
- }
- }
- return isValid;
- }
-}
diff --git a/java/dagger/internal/codegen/BindingMethodProcessingStep.java b/java/dagger/internal/codegen/BindingMethodProcessingStep.java
deleted file mode 100644
index e6c4f8e..0000000
--- a/java/dagger/internal/codegen/BindingMethodProcessingStep.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkArgument;
-
-import com.google.auto.common.MoreElements;
-import com.google.common.collect.ImmutableSet;
-import java.lang.annotation.Annotation;
-import java.util.Set;
-import javax.annotation.processing.Messager;
-import javax.inject.Inject;
-import javax.lang.model.element.ExecutableElement;
-
-/** A step that validates all binding methods that were not validated while processing modules. */
-final class BindingMethodProcessingStep extends TypeCheckingProcessingStep<ExecutableElement> {
-
- private final Messager messager;
- private final AnyBindingMethodValidator anyBindingMethodValidator;
-
- @Inject
- BindingMethodProcessingStep(
- Messager messager, AnyBindingMethodValidator anyBindingMethodValidator) {
- super(MoreElements::asExecutable);
- this.messager = messager;
- this.anyBindingMethodValidator = anyBindingMethodValidator;
- }
-
- @Override
- public Set<? extends Class<? extends Annotation>> annotations() {
- return anyBindingMethodValidator.methodAnnotations();
- }
-
- @Override
- protected void process(
- ExecutableElement method, ImmutableSet<Class<? extends Annotation>> annotations) {
- checkArgument(
- anyBindingMethodValidator.isBindingMethod(method),
- "%s is not annotated with any of %s",
- method,
- annotations());
- if (!anyBindingMethodValidator.wasAlreadyValidated(method)) {
- anyBindingMethodValidator.validate(method).printMessagesTo(messager);
- }
- }
-}
diff --git a/java/dagger/internal/codegen/BindingMethodValidator.java b/java/dagger/internal/codegen/BindingMethodValidator.java
deleted file mode 100644
index 21c05cc..0000000
--- a/java/dagger/internal/codegen/BindingMethodValidator.java
+++ /dev/null
@@ -1,303 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.langmodel.DaggerElements.isAnyAnnotationPresent;
-import static java.util.stream.Collectors.joining;
-import static javax.lang.model.element.Modifier.ABSTRACT;
-import static javax.lang.model.element.Modifier.PRIVATE;
-
-import com.google.common.collect.ImmutableSet;
-import com.google.errorprone.annotations.FormatMethod;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import java.lang.annotation.Annotation;
-import java.util.Optional;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.VariableElement;
-import javax.lang.model.type.TypeMirror;
-
-/** A validator for methods that represent binding declarations. */
-abstract class BindingMethodValidator extends BindingElementValidator<ExecutableElement> {
-
- private final DaggerElements elements;
- private final DaggerTypes types;
- private final DependencyRequestValidator dependencyRequestValidator;
- private final Class<? extends Annotation> methodAnnotation;
- private final ImmutableSet<? extends Class<? extends Annotation>> enclosingElementAnnotations;
- private final Abstractness abstractness;
- private final ExceptionSuperclass exceptionSuperclass;
-
- /**
- * Creates a validator object.
- *
- * @param methodAnnotation the annotation on a method that identifies it as a binding method
- * @param enclosingElementAnnotation the method must be declared in a class or interface annotated
- * with this annotation
- */
- protected BindingMethodValidator(
- DaggerElements elements,
- DaggerTypes types,
- DependencyRequestValidator dependencyRequestValidator,
- Class<? extends Annotation> methodAnnotation,
- Class<? extends Annotation> enclosingElementAnnotation,
- Abstractness abstractness,
- ExceptionSuperclass exceptionSuperclass,
- AllowsMultibindings allowsMultibindings,
- AllowsScoping allowsScoping) {
- this(
- elements,
- types,
- methodAnnotation,
- ImmutableSet.of(enclosingElementAnnotation),
- dependencyRequestValidator,
- abstractness,
- exceptionSuperclass,
- allowsMultibindings,
- allowsScoping);
- }
-
- /**
- * Creates a validator object.
- *
- * @param methodAnnotation the annotation on a method that identifies it as a binding method
- * @param enclosingElementAnnotations the method must be declared in a class or interface
- * annotated with one of these annotations
- */
- protected BindingMethodValidator(
- DaggerElements elements,
- DaggerTypes types,
- Class<? extends Annotation> methodAnnotation,
- Iterable<? extends Class<? extends Annotation>> enclosingElementAnnotations,
- DependencyRequestValidator dependencyRequestValidator,
- Abstractness abstractness,
- ExceptionSuperclass exceptionSuperclass,
- AllowsMultibindings allowsMultibindings,
- AllowsScoping allowsScoping) {
- super(methodAnnotation, allowsMultibindings, allowsScoping);
- this.elements = elements;
- this.types = types;
- this.methodAnnotation = methodAnnotation;
- this.enclosingElementAnnotations = ImmutableSet.copyOf(enclosingElementAnnotations);
- this.dependencyRequestValidator = dependencyRequestValidator;
- this.abstractness = abstractness;
- this.exceptionSuperclass = exceptionSuperclass;
- }
-
- /** The annotation that identifies binding methods validated by this object. */
- final Class<? extends Annotation> methodAnnotation() {
- return methodAnnotation;
- }
-
- /**
- * Returns an error message of the form "@<i>annotation</i> methods <i>rule</i>", where
- * <i>rule</i> comes from calling {@link String#format(String, Object...)} on {@code ruleFormat}
- * and the other arguments.
- */
- @FormatMethod
- protected final String bindingMethods(String ruleFormat, Object... args) {
- return bindingElements(ruleFormat, args);
- }
-
- @Override
- protected final String bindingElements() {
- return String.format("@%s methods", methodAnnotation.getSimpleName());
- }
-
- @Override
- protected final String bindingElementTypeVerb() {
- return "return";
- }
-
- /** Abstract validator for individual binding method elements. */
- protected abstract class MethodValidator extends ElementValidator {
- protected MethodValidator(ExecutableElement element) {
- super(element);
- }
-
- @Override
- protected final Optional<TypeMirror> bindingElementType() {
- return Optional.of(element.getReturnType());
- }
-
- @Override
- protected final void checkAdditionalProperties() {
- checkEnclosingElement();
- checkTypeParameters();
- checkNotPrivate();
- checkAbstractness();
- checkThrows();
- checkParameters();
- checkAdditionalMethodProperties();
- }
-
- /** Checks additional properties of the binding method. */
- protected void checkAdditionalMethodProperties() {}
-
- /**
- * Adds an error if the method is not declared in a class or interface annotated with one of the
- * {@link #enclosingElementAnnotations}.
- */
- private void checkEnclosingElement() {
- if (!isAnyAnnotationPresent(
- element.getEnclosingElement(), enclosingElementAnnotations)) {
- report.addError(
- bindingMethods(
- "can only be present within a @%s",
- enclosingElementAnnotations.stream()
- .map(Class::getSimpleName)
- .collect(joining(" or @"))));
- }
- }
-
- /** Adds an error if the method is generic. */
- private void checkTypeParameters() {
- if (!element.getTypeParameters().isEmpty()) {
- report.addError(bindingMethods("may not have type parameters"));
- }
- }
-
- /** Adds an error if the method is private. */
- private void checkNotPrivate() {
- if (element.getModifiers().contains(PRIVATE)) {
- report.addError(bindingMethods("cannot be private"));
- }
- }
-
- /** Adds an error if the method is abstract but must not be, or is not and must be. */
- private void checkAbstractness() {
- boolean isAbstract = element.getModifiers().contains(ABSTRACT);
- switch (abstractness) {
- case MUST_BE_ABSTRACT:
- if (!isAbstract) {
- report.addError(bindingMethods("must be abstract"));
- }
- break;
-
- case MUST_BE_CONCRETE:
- if (isAbstract) {
- report.addError(bindingMethods("cannot be abstract"));
- }
- }
- }
-
- /**
- * Adds an error if the method declares throws anything but an {@link Error} or an appropriate
- * subtype of {@link Exception}.
- */
- private void checkThrows() {
- exceptionSuperclass.checkThrows(BindingMethodValidator.this, element, report);
- }
-
- /** Adds errors for the method parameters. */
- protected void checkParameters() {
- for (VariableElement parameter : element.getParameters()) {
- checkParameter(parameter);
- }
- }
-
- /**
- * Adds errors for a method parameter. This implementation reports an error if the parameter has
- * more than one qualifier.
- */
- protected void checkParameter(VariableElement parameter) {
- dependencyRequestValidator.validateDependencyRequest(report, parameter, parameter.asType());
- }
- }
-
- /** An abstract/concrete restriction on methods. */
- protected enum Abstractness {
- MUST_BE_ABSTRACT,
- MUST_BE_CONCRETE
- }
-
- /**
- * The exception class that all {@code throws}-declared throwables must extend, other than {@link
- * Error}.
- */
- protected enum ExceptionSuperclass {
- /** Methods may not declare any throwable types. */
- NO_EXCEPTIONS {
- @Override
- protected String errorMessage(BindingMethodValidator validator) {
- return validator.bindingMethods("may not throw");
- }
-
- @Override
- protected void checkThrows(
- BindingMethodValidator validator,
- ExecutableElement element,
- ValidationReport.Builder<ExecutableElement> report) {
- if (!element.getThrownTypes().isEmpty()) {
- report.addError(validator.bindingMethods("may not throw"));
- return;
- }
- }
- },
-
- /** Methods may throw checked or unchecked exceptions or errors. */
- EXCEPTION(Exception.class) {
- @Override
- protected String errorMessage(BindingMethodValidator validator) {
- return validator.bindingMethods(
- "may only throw unchecked exceptions or exceptions subclassing Exception");
- }
- },
-
- /** Methods may throw unchecked exceptions or errors. */
- RUNTIME_EXCEPTION(RuntimeException.class) {
- @Override
- protected String errorMessage(BindingMethodValidator validator) {
- return validator.bindingMethods("may only throw unchecked exceptions");
- }
- },
- ;
-
- private final Class<? extends Exception> superclass;
-
- ExceptionSuperclass() {
- this(null);
- }
-
- ExceptionSuperclass(Class<? extends Exception> superclass) {
- this.superclass = superclass;
- }
-
- /**
- * Adds an error if the method declares throws anything but an {@link Error} or an appropriate
- * subtype of {@link Exception}.
- *
- * <p>This method is overridden in {@link #NO_EXCEPTIONS}.
- */
- protected void checkThrows(
- BindingMethodValidator validator,
- ExecutableElement element,
- ValidationReport.Builder<ExecutableElement> report) {
- TypeMirror exceptionSupertype = validator.elements.getTypeElement(superclass).asType();
- TypeMirror errorType = validator.elements.getTypeElement(Error.class).asType();
- for (TypeMirror thrownType : element.getThrownTypes()) {
- if (!validator.types.isSubtype(thrownType, exceptionSupertype)
- && !validator.types.isSubtype(thrownType, errorType)) {
- report.addError(errorMessage(validator));
- break;
- }
- }
- }
-
- protected abstract String errorMessage(BindingMethodValidator validator);
- }
-}
diff --git a/java/dagger/internal/codegen/BindingMethodValidatorsModule.java b/java/dagger/internal/codegen/BindingMethodValidatorsModule.java
deleted file mode 100644
index 28a272d..0000000
--- a/java/dagger/internal/codegen/BindingMethodValidatorsModule.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.collect.Maps.uniqueIndex;
-
-import com.google.common.collect.ImmutableMap;
-import dagger.Binds;
-import dagger.Module;
-import dagger.Provides;
-import dagger.multibindings.IntoSet;
-import java.lang.annotation.Annotation;
-import java.util.Set;
-
-/**
- * Binds each {@link BindingMethodValidator} into a map, keyed by {@link
- * BindingMethodValidator#methodAnnotation()}.
- */
-@Module
-interface BindingMethodValidatorsModule {
- @Provides
- static ImmutableMap<Class<? extends Annotation>, BindingMethodValidator> indexValidators(
- Set<BindingMethodValidator> validators) {
- return uniqueIndex(validators, BindingMethodValidator::methodAnnotation);
- }
-
- @Binds
- @IntoSet
- BindingMethodValidator provides(ProvidesMethodValidator validator);
-
- @Binds
- @IntoSet
- BindingMethodValidator produces(ProducesMethodValidator validator);
-
- @Binds
- @IntoSet
- BindingMethodValidator binds(BindsMethodValidator validator);
-
- @Binds
- @IntoSet
- BindingMethodValidator multibinds(MultibindsMethodValidator validator);
-
- @Binds
- @IntoSet
- BindingMethodValidator bindsOptionalOf(BindsOptionalOfMethodValidator validator);
-}
diff --git a/java/dagger/internal/codegen/BindingNode.java b/java/dagger/internal/codegen/BindingNode.java
deleted file mode 100644
index a7da092..0000000
--- a/java/dagger/internal/codegen/BindingNode.java
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static dagger.internal.codegen.BindingType.PRODUCTION;
-
-import com.google.auto.value.AutoValue;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterables;
-import dagger.BindsOptionalOf;
-import dagger.Module;
-import dagger.model.BindingKind;
-import dagger.model.ComponentPath;
-import dagger.model.DependencyRequest;
-import dagger.model.Key;
-import dagger.model.Scope;
-import dagger.multibindings.Multibinds;
-import java.util.Optional;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.TypeElement;
-
-/**
- * An implementation of {@link dagger.model.Binding} that also exposes {@link BindingDeclaration}s
- * associated with the binding.
- */
-// TODO(dpb): Consider a supertype of dagger.model.Binding that dagger.internal.codegen.Binding
-// could also implement.
-@AutoValue
-abstract class BindingNode implements dagger.model.Binding {
- static BindingNode create(
- ComponentPath component,
- Binding delegate,
- ImmutableSet<MultibindingDeclaration> multibindingDeclarations,
- ImmutableSet<OptionalBindingDeclaration> optionalBindingDeclarations,
- ImmutableSet<SubcomponentDeclaration> subcomponentDeclarations,
- BindingDeclarationFormatter bindingDeclarationFormatter) {
- BindingNode node =
- new AutoValue_BindingNode(
- component,
- delegate,
- multibindingDeclarations,
- optionalBindingDeclarations,
- subcomponentDeclarations);
- node.bindingDeclarationFormatter = checkNotNull(bindingDeclarationFormatter);
- return node;
- }
-
- private BindingDeclarationFormatter bindingDeclarationFormatter;
-
- abstract Binding delegate();
-
- abstract ImmutableSet<MultibindingDeclaration> multibindingDeclarations();
-
- abstract ImmutableSet<OptionalBindingDeclaration> optionalBindingDeclarations();
-
- abstract ImmutableSet<SubcomponentDeclaration> subcomponentDeclarations();
-
- /**
- * The {@link Element}s (other than the binding's {@link #bindingElement()}) that are associated
- * with the binding.
- *
- * <ul>
- * <li>{@linkplain BindsOptionalOf optional binding} declarations
- * <li>{@linkplain Module#subcomponents() module subcomponent} declarations
- * <li>{@linkplain Multibinds multibinding} declarations
- * </ul>
- */
- final Iterable<BindingDeclaration> associatedDeclarations() {
- return Iterables.concat(
- multibindingDeclarations(), optionalBindingDeclarations(), subcomponentDeclarations());
- }
-
- @Override
- public Key key() {
- return delegate().key();
- }
-
- @Override
- public ImmutableSet<DependencyRequest> dependencies() {
- return delegate().dependencies();
- }
-
- @Override
- public Optional<Element> bindingElement() {
- return delegate().bindingElement();
- }
-
- @Override
- public Optional<TypeElement> contributingModule() {
- return delegate().contributingModule();
- }
-
- @Override
- public boolean requiresModuleInstance() {
- return delegate().requiresModuleInstance();
- }
-
- @Override
- public Optional<Scope> scope() {
- return delegate().scope();
- }
-
- @Override
- public boolean isNullable() {
- return delegate().isNullable();
- }
-
- @Override
- public boolean isProduction() {
- return delegate().bindingType().equals(PRODUCTION);
- }
-
- @Override
- public BindingKind kind() {
- return delegate().kind();
- }
-
- @Override
- public final String toString() {
- return bindingDeclarationFormatter.format(delegate());
- }
-}
diff --git a/java/dagger/internal/codegen/BindingRequest.java b/java/dagger/internal/codegen/BindingRequest.java
deleted file mode 100644
index 27067aa..0000000
--- a/java/dagger/internal/codegen/BindingRequest.java
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.RequestKinds.requestType;
-
-import com.google.auto.value.AutoValue;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.internal.codegen.serialization.BindingRequestProto;
-import dagger.internal.codegen.serialization.FrameworkTypeWrapper;
-import dagger.internal.codegen.serialization.RequestKindWrapper;
-import dagger.model.DependencyRequest;
-import dagger.model.Key;
-import dagger.model.RequestKind;
-import java.util.Optional;
-import javax.lang.model.type.TypeMirror;
-
-/**
- * A request for a binding, which may be in the form of a request for a dependency to pass to a
- * constructor or module method ({@link RequestKind}) or an internal request for a framework
- * instance ({@link FrameworkType}).
- */
-@AutoValue
-abstract class BindingRequest {
- /** Creates a {@link BindingRequest} for the given {@link DependencyRequest}. */
- static BindingRequest bindingRequest(DependencyRequest dependencyRequest) {
- return bindingRequest(dependencyRequest.key(), dependencyRequest.kind());
- }
-
- /**
- * Creates a {@link BindingRequest} for a normal dependency request for the given {@link Key} and
- * {@link RequestKind}.
- */
- static BindingRequest bindingRequest(Key key, RequestKind requestKind) {
- // When there's a request that has a 1:1 mapping to a FrameworkType, the request should be
- // associated with that FrameworkType as well, because we want to ensure that if a request
- // comes in for that as a dependency first and as a framework instance later, they resolve to
- // the same binding expression.
- // TODO(cgdecker): Instead of doing this, make ComponentBindingExpressions create a
- // BindingExpression for the RequestKind that simply delegates to the BindingExpression for the
- // FrameworkType. Then there are separate BindingExpressions, but we don't end up doing weird
- // things like creating two fields when there should only be one.
- return new AutoValue_BindingRequest(
- key, Optional.of(requestKind), FrameworkType.forRequestKind(requestKind));
- }
-
- /**
- * Creates a {@link BindingRequest} for a request for a framework instance for the given {@link
- * Key} with the given {@link FrameworkType}.
- */
- static BindingRequest bindingRequest(Key key, FrameworkType frameworkType) {
- return new AutoValue_BindingRequest(
- key, frameworkType.requestKind(), Optional.of(frameworkType));
- }
-
- /** Creates a {@link BindingRequest} for the given {@link FrameworkDependency}. */
- static BindingRequest bindingRequest(FrameworkDependency frameworkDependency) {
- return bindingRequest(frameworkDependency.key(), frameworkDependency.frameworkType());
- }
-
- /** Returns the {@link Key} for the requested binding. */
- abstract Key key();
-
- /** Returns the request kind associated with this request, if any. */
- abstract Optional<RequestKind> requestKind();
-
- /** Returns the framework type associated with this request, if any. */
- abstract Optional<FrameworkType> frameworkType();
-
- /** Returns whether this request is of the given kind. */
- final boolean isRequestKind(RequestKind requestKind) {
- return requestKind.equals(requestKind().orElse(null));
- }
-
- final TypeMirror requestedType(TypeMirror contributedType, DaggerTypes types) {
- if (requestKind().isPresent()) {
- return requestType(requestKind().get(), contributedType, types);
- }
- return types.wrapType(contributedType, frameworkType().get().frameworkClass());
- }
-
- /** Returns a name that can be used for the kind of request this is. */
- final String kindName() {
- Object requestKindObject =
- requestKind().isPresent()
- ? requestKind().get()
- : frameworkType().get().frameworkClass().getSimpleName();
- return requestKindObject.toString();
- }
-
- /** Returns {@code true} if this request can be satisfied by a production binding. */
- final boolean canBeSatisfiedByProductionBinding() {
- if (requestKind().isPresent()) {
- return RequestKinds.canBeSatisfiedByProductionBinding(requestKind().get());
- }
- return frameworkType().get().equals(FrameworkType.PRODUCER_NODE);
- }
-
- /** Creates a proto representation of this binding request. */
- BindingRequestProto toProto() {
- BindingRequestProto.Builder builder =
- BindingRequestProto.newBuilder().setKey(KeyFactory.toProto(key()));
- if (frameworkType().isPresent()) {
- builder.setFrameworkType(
- FrameworkTypeWrapper.FrameworkType.valueOf(frameworkType().get().name()));
- } else {
- builder.setRequestKind(RequestKindWrapper.RequestKind.valueOf(requestKind().get().name()));
- }
- return builder.build();
- }
-}
diff --git a/java/dagger/internal/codegen/BindingType.java b/java/dagger/internal/codegen/BindingType.java
deleted file mode 100644
index 37109c7..0000000
--- a/java/dagger/internal/codegen/BindingType.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import dagger.MembersInjector;
-
-/** Whether a binding or declaration is for provision, production, or a {@link MembersInjector}. */
-enum BindingType {
- /** A binding with this type is a {@link ProvisionBinding}. */
- PROVISION,
-
- /** A binding with this type is a {@link MembersInjectionBinding}. */
- MEMBERS_INJECTION,
-
- /** A binding with this type is a {@link ProductionBinding}. */
- PRODUCTION,
-}
diff --git a/java/dagger/internal/codegen/BindsInstanceElementValidator.java b/java/dagger/internal/codegen/BindsInstanceElementValidator.java
deleted file mode 100644
index 9249c8e..0000000
--- a/java/dagger/internal/codegen/BindsInstanceElementValidator.java
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import dagger.BindsInstance;
-import javax.lang.model.element.Element;
-
-abstract class BindsInstanceElementValidator<E extends Element> extends BindingElementValidator<E> {
- BindsInstanceElementValidator() {
- super(BindsInstance.class, AllowsMultibindings.NO_MULTIBINDINGS, AllowsScoping.NO_SCOPING);
- }
-
- @Override
- protected final String bindingElements() {
- // Even though @BindsInstance may be placed on methods, the subject of errors is the
- // parameter
- return "@BindsInstance parameters";
- }
-
- @Override
- protected final String bindingElementTypeVerb() {
- return "be";
- }
-}
diff --git a/java/dagger/internal/codegen/BindsInstanceMethodValidator.java b/java/dagger/internal/codegen/BindsInstanceMethodValidator.java
deleted file mode 100644
index 1a491c7..0000000
--- a/java/dagger/internal/codegen/BindsInstanceMethodValidator.java
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static dagger.internal.codegen.ComponentAnnotation.anyComponentAnnotation;
-import static dagger.internal.codegen.ModuleAnnotation.moduleAnnotation;
-import static javax.lang.model.element.Modifier.ABSTRACT;
-
-import com.google.auto.common.MoreElements;
-import java.util.List;
-import java.util.Optional;
-import javax.inject.Inject;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.element.VariableElement;
-import javax.lang.model.type.TypeMirror;
-
-final class BindsInstanceMethodValidator extends BindsInstanceElementValidator<ExecutableElement> {
- @Inject
- BindsInstanceMethodValidator() {}
-
- @Override
- protected ElementValidator elementValidator(ExecutableElement element) {
- return new Validator(element);
- }
-
- private class Validator extends ElementValidator {
- Validator(ExecutableElement element) {
- super(element);
- }
-
- @Override
- protected void checkAdditionalProperties() {
- if (!element.getModifiers().contains(ABSTRACT)) {
- report.addError("@BindsInstance methods must be abstract");
- }
- if (element.getParameters().size() != 1) {
- report.addError(
- "@BindsInstance methods should have exactly one parameter for the bound type");
- }
- TypeElement enclosingType = MoreElements.asType(element.getEnclosingElement());
- moduleAnnotation(enclosingType)
- .ifPresent(moduleAnnotation -> report.addError(didYouMeanBinds(moduleAnnotation)));
- anyComponentAnnotation(enclosingType)
- .ifPresent(
- componentAnnotation ->
- report.addError(
- String.format(
- "@BindsInstance methods should not be included in @%1$ss. "
- + "Did you mean to put it in a @%1$s.Builder?",
- componentAnnotation.simpleName())));
- }
-
- @Override
- protected Optional<TypeMirror> bindingElementType() {
- List<? extends VariableElement> parameters =
- MoreElements.asExecutable(element).getParameters();
- return parameters.size() == 1
- ? Optional.of(getOnlyElement(parameters).asType())
- : Optional.empty();
- }
- }
-
- private static String didYouMeanBinds(ModuleAnnotation moduleAnnotation) {
- return String.format(
- "@BindsInstance methods should not be included in @%ss. Did you mean @Binds?",
- moduleAnnotation.annotationClass().getSimpleName());
- }
-}
diff --git a/java/dagger/internal/codegen/BindsInstanceParameterValidator.java b/java/dagger/internal/codegen/BindsInstanceParameterValidator.java
deleted file mode 100644
index b2dc8d8..0000000
--- a/java/dagger/internal/codegen/BindsInstanceParameterValidator.java
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static javax.lang.model.element.ElementKind.METHOD;
-import static javax.lang.model.element.Modifier.ABSTRACT;
-import static javax.lang.model.type.TypeKind.DECLARED;
-import static javax.lang.model.type.TypeKind.TYPEVAR;
-
-import com.google.auto.common.MoreElements;
-import java.util.Optional;
-import javax.inject.Inject;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.VariableElement;
-import javax.lang.model.type.TypeKind;
-import javax.lang.model.type.TypeMirror;
-
-final class BindsInstanceParameterValidator extends BindsInstanceElementValidator<VariableElement> {
- @Inject
- BindsInstanceParameterValidator() {}
-
- @Override
- protected ElementValidator elementValidator(VariableElement element) {
- return new Validator(element);
- }
-
- private class Validator extends ElementValidator {
- Validator(VariableElement element) {
- super(element);
- }
-
- @Override
- protected void checkAdditionalProperties() {
- Element enclosing = element.getEnclosingElement();
- if (!enclosing.getKind().equals(METHOD)) {
- report.addError(
- "@BindsInstance should only be applied to methods or parameters of methods");
- return;
- }
-
- ExecutableElement method = MoreElements.asExecutable(enclosing);
- if (!method.getModifiers().contains(ABSTRACT)) {
- report.addError("@BindsInstance parameters may only be used in abstract methods");
- }
-
- TypeKind returnKind = method.getReturnType().getKind();
- if (!(returnKind.equals(DECLARED) || returnKind.equals(TYPEVAR))) {
- report.addError(
- "@BindsInstance parameters may not be used in methods with a void, array or primitive "
- + "return type");
- }
- }
-
- @Override
- protected Optional<TypeMirror> bindingElementType() {
- return Optional.of(element.asType());
- }
- }
-}
diff --git a/java/dagger/internal/codegen/BindsInstanceProcessingStep.java b/java/dagger/internal/codegen/BindsInstanceProcessingStep.java
deleted file mode 100644
index 4c222a9..0000000
--- a/java/dagger/internal/codegen/BindsInstanceProcessingStep.java
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import com.google.auto.common.MoreElements;
-import com.google.common.collect.ImmutableSet;
-import dagger.BindsInstance;
-import java.lang.annotation.Annotation;
-import java.util.Set;
-import javax.annotation.processing.Messager;
-import javax.inject.Inject;
-import javax.lang.model.element.Element;
-
-/**
- * Processing step that validates that the {@code BindsInstance} annotation is applied to the
- * correct elements.
- */
-final class BindsInstanceProcessingStep extends TypeCheckingProcessingStep<Element> {
- private final BindsInstanceMethodValidator methodValidator;
- private final BindsInstanceParameterValidator parameterValidator;
- private final Messager messager;
-
- @Inject
- BindsInstanceProcessingStep(
- BindsInstanceMethodValidator methodValidator,
- BindsInstanceParameterValidator parameterValidator,
- Messager messager) {
- super(element -> element);
- this.methodValidator = methodValidator;
- this.parameterValidator = parameterValidator;
- this.messager = messager;
- }
-
- @Override
- public Set<? extends Class<? extends Annotation>> annotations() {
- return ImmutableSet.of(BindsInstance.class);
- }
-
- @Override
- protected void process(Element element, ImmutableSet<Class<? extends Annotation>> annotations) {
- switch (element.getKind()) {
- case PARAMETER:
- parameterValidator.validate(MoreElements.asVariable(element)).printMessagesTo(messager);
- break;
- case METHOD:
- methodValidator.validate(MoreElements.asExecutable(element)).printMessagesTo(messager);
- break;
- default:
- throw new AssertionError(element);
- }
- }
-}
diff --git a/java/dagger/internal/codegen/BindsMethodValidator.java b/java/dagger/internal/codegen/BindsMethodValidator.java
deleted file mode 100644
index e198c3a..0000000
--- a/java/dagger/internal/codegen/BindsMethodValidator.java
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.BindingElementValidator.AllowsMultibindings.ALLOWS_MULTIBINDINGS;
-import static dagger.internal.codegen.BindingElementValidator.AllowsScoping.ALLOWS_SCOPING;
-import static dagger.internal.codegen.BindingMethodValidator.Abstractness.MUST_BE_ABSTRACT;
-import static dagger.internal.codegen.BindingMethodValidator.ExceptionSuperclass.RUNTIME_EXCEPTION;
-
-import com.google.auto.common.MoreTypes;
-import com.google.common.collect.ImmutableSet;
-import dagger.Binds;
-import dagger.Module;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.producers.ProducerModule;
-import javax.inject.Inject;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.VariableElement;
-import javax.lang.model.type.TypeMirror;
-
-/** A validator for {@link Binds} methods. */
-final class BindsMethodValidator extends BindingMethodValidator {
- private final DaggerTypes types;
- private final BindsTypeChecker bindsTypeChecker;
-
- @Inject
- BindsMethodValidator(
- DaggerElements elements,
- DaggerTypes types,
- DependencyRequestValidator dependencyRequestValidator) {
- super(
- elements,
- types,
- Binds.class,
- ImmutableSet.of(Module.class, ProducerModule.class),
- dependencyRequestValidator,
- MUST_BE_ABSTRACT,
- RUNTIME_EXCEPTION,
- ALLOWS_MULTIBINDINGS,
- ALLOWS_SCOPING);
- this.types = types;
- this.bindsTypeChecker = new BindsTypeChecker(types, elements);
- }
-
- @Override
- protected ElementValidator elementValidator(ExecutableElement element) {
- return new Validator(element);
- }
-
- private class Validator extends MethodValidator {
- Validator(ExecutableElement element) {
- super(element);
- }
-
- @Override
- protected void checkParameters() {
- if (element.getParameters().size() != 1) {
- report.addError(
- bindingMethods(
- "must have exactly one parameter, whose type is assignable to the return type"));
- } else {
- super.checkParameters();
- }
- }
-
- @Override
- protected void checkParameter(VariableElement parameter) {
- super.checkParameter(parameter);
- TypeMirror leftHandSide = boxIfNecessary(element.getReturnType());
- TypeMirror rightHandSide = parameter.asType();
- ContributionType contributionType = ContributionType.fromBindingElement(element);
- if (contributionType.equals(ContributionType.SET_VALUES) && !SetType.isSet(leftHandSide)) {
- report.addError(
- "@Binds @ElementsIntoSet methods must return a Set and take a Set parameter");
- }
-
- if (!bindsTypeChecker.isAssignable(rightHandSide, leftHandSide, contributionType)) {
- // TODO(ronshapiro): clarify this error message for @ElementsIntoSet cases, where the
- // right-hand-side might not be assignable to the left-hand-side, but still compatible with
- // Set.addAll(Collection<? extends E>)
- report.addError("@Binds methods' parameter type must be assignable to the return type");
- }
- }
-
- private TypeMirror boxIfNecessary(TypeMirror maybePrimitive) {
- if (maybePrimitive.getKind().isPrimitive()) {
- return types.boxedClass(MoreTypes.asPrimitiveType(maybePrimitive)).asType();
- }
- return maybePrimitive;
- }
- }
-}
diff --git a/java/dagger/internal/codegen/BindsOptionalOfMethodValidator.java b/java/dagger/internal/codegen/BindsOptionalOfMethodValidator.java
deleted file mode 100644
index e1c9d73..0000000
--- a/java/dagger/internal/codegen/BindsOptionalOfMethodValidator.java
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.BindingElementValidator.AllowsMultibindings.NO_MULTIBINDINGS;
-import static dagger.internal.codegen.BindingElementValidator.AllowsScoping.NO_SCOPING;
-import static dagger.internal.codegen.BindingMethodValidator.Abstractness.MUST_BE_ABSTRACT;
-import static dagger.internal.codegen.BindingMethodValidator.ExceptionSuperclass.NO_EXCEPTIONS;
-import static dagger.internal.codegen.InjectionAnnotations.getQualifiers;
-import static dagger.internal.codegen.InjectionAnnotations.injectedConstructors;
-import static dagger.internal.codegen.Keys.isValidImplicitProvisionKey;
-
-import com.google.auto.common.MoreElements;
-import com.google.auto.common.MoreTypes;
-import com.google.common.collect.ImmutableSet;
-import dagger.BindsOptionalOf;
-import dagger.Module;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.producers.ProducerModule;
-import javax.inject.Inject;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.type.TypeMirror;
-
-/** A validator for {@link BindsOptionalOf} methods. */
-final class BindsOptionalOfMethodValidator extends BindingMethodValidator {
-
- private final DaggerTypes types;
-
- @Inject
- BindsOptionalOfMethodValidator(
- DaggerElements elements,
- DaggerTypes types,
- DependencyRequestValidator dependencyRequestValidator) {
- super(
- elements,
- types,
- BindsOptionalOf.class,
- ImmutableSet.of(Module.class, ProducerModule.class),
- dependencyRequestValidator,
- MUST_BE_ABSTRACT,
- NO_EXCEPTIONS,
- NO_MULTIBINDINGS,
- NO_SCOPING);
- this.types = types;
- }
-
- @Override
- protected ElementValidator elementValidator(ExecutableElement element) {
- return new Validator(element);
- }
-
- private class Validator extends MethodValidator {
- Validator(ExecutableElement element) {
- super(element);
- }
-
- @Override
- protected void checkKeyType(TypeMirror keyType) {
- super.checkKeyType(keyType);
- if (isValidImplicitProvisionKey(
- getQualifiers(element).stream().findFirst(), keyType, types)
- && !injectedConstructors(MoreElements.asType(MoreTypes.asDeclared(keyType).asElement()))
- .isEmpty()) {
- report.addError(
- "@BindsOptionalOf methods cannot return unqualified types that have an @Inject-"
- + "annotated constructor because those are always present");
- }
- }
-
- @Override
- protected void checkParameters() {
- if (!element.getParameters().isEmpty()) {
- report.addError("@BindsOptionalOf methods cannot have parameters");
- }
- }
- }
-}
diff --git a/java/dagger/internal/codegen/BindsTypeChecker.java b/java/dagger/internal/codegen/BindsTypeChecker.java
deleted file mode 100644
index acecc9e..0000000
--- a/java/dagger/internal/codegen/BindsTypeChecker.java
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.collect.Iterables.getOnlyElement;
-
-import com.google.auto.common.MoreElements;
-import com.google.auto.common.MoreTypes;
-import com.google.common.collect.ImmutableList;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import java.util.Map;
-import java.util.Set;
-import javax.inject.Inject;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.TypeMirror;
-
-/**
- * Checks the assignability of one type to another, given a {@link ContributionType} context. This
- * is used by {@link BindsMethodValidator} to validate that the right-hand-side of a {@link
- * dagger.Binds} method is valid, as well as in {@link DelegateBindingExpression} when the
- * right-hand-side in generated code might be an erased type due to accessibility.
- */
-final class BindsTypeChecker {
- private final DaggerTypes types;
- private final DaggerElements elements;
-
- @Inject
- BindsTypeChecker(DaggerTypes types, DaggerElements elements) {
- this.types = types;
- this.elements = elements;
- }
-
- /**
- * Checks the assignability of {@code rightHandSide} to {@code leftHandSide} given a {@link
- * ContributionType} context.
- */
- boolean isAssignable(
- TypeMirror rightHandSide, TypeMirror leftHandSide, ContributionType contributionType) {
- return types.isAssignable(rightHandSide, desiredAssignableType(leftHandSide, contributionType));
- }
-
- private TypeMirror desiredAssignableType(
- TypeMirror leftHandSide, ContributionType contributionType) {
- switch (contributionType) {
- case UNIQUE:
- return leftHandSide;
- case SET:
- DeclaredType parameterizedSetType = types.getDeclaredType(setElement(), leftHandSide);
- return methodParameterType(parameterizedSetType, "add");
- case SET_VALUES:
- return methodParameterType(MoreTypes.asDeclared(leftHandSide), "addAll");
- case MAP:
- DeclaredType parameterizedMapType =
- types.getDeclaredType(mapElement(), unboundedWildcard(), leftHandSide);
- return methodParameterTypes(parameterizedMapType, "put").get(1);
- }
- throw new AssertionError("Unknown contribution type: " + contributionType);
- }
-
- private ImmutableList<TypeMirror> methodParameterTypes(DeclaredType type, String methodName) {
- ImmutableList.Builder<ExecutableElement> methodsForName = ImmutableList.builder();
- for (ExecutableElement method :
- // type.asElement().getEnclosedElements() is not used because some non-standard JDKs (e.g.
- // J2CL) don't redefine Set.add() (whose only purpose of being redefined in the standard JDK
- // is documentation, and J2CL's implementation doesn't declare docs for JDK types).
- // MoreElements.getLocalAndInheritedMethods ensures that the method will always be present.
- MoreElements.getLocalAndInheritedMethods(MoreTypes.asTypeElement(type), types, elements)) {
- if (method.getSimpleName().contentEquals(methodName)) {
- methodsForName.add(method);
- }
- }
- ExecutableElement method = getOnlyElement(methodsForName.build());
- return ImmutableList.copyOf(
- MoreTypes.asExecutable(types.asMemberOf(type, method)).getParameterTypes());
- }
-
- private TypeMirror methodParameterType(DeclaredType type, String methodName) {
- return getOnlyElement(methodParameterTypes(type, methodName));
- }
-
- private TypeElement setElement() {
- return elements.getTypeElement(Set.class);
- }
-
- private TypeElement mapElement() {
- return elements.getTypeElement(Map.class);
- }
-
- private TypeMirror unboundedWildcard() {
- return types.getWildcardType(null, null);
- }
-}
diff --git a/java/dagger/internal/codegen/ChildFactoryMethodEdgeImpl.java b/java/dagger/internal/codegen/ChildFactoryMethodEdgeImpl.java
deleted file mode 100644
index a5e0219..0000000
--- a/java/dagger/internal/codegen/ChildFactoryMethodEdgeImpl.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.ElementFormatter.elementToString;
-
-import dagger.model.BindingGraph.ChildFactoryMethodEdge;
-import javax.lang.model.element.ExecutableElement;
-
-/** An implementation of {@link ChildFactoryMethodEdge}. */
-final class ChildFactoryMethodEdgeImpl implements ChildFactoryMethodEdge {
-
- private final ExecutableElement factoryMethod;
-
- ChildFactoryMethodEdgeImpl(ExecutableElement factoryMethod) {
- this.factoryMethod = factoryMethod;
- }
-
- @Override
- public ExecutableElement factoryMethod() {
- return factoryMethod;
- }
-
- @Override
- public String toString() {
- return elementToString(factoryMethod);
- }
-}
diff --git a/java/dagger/internal/codegen/ClearableCache.java b/java/dagger/internal/codegen/ClearableCache.java
deleted file mode 100644
index 66ce3ef..0000000
--- a/java/dagger/internal/codegen/ClearableCache.java
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * Copyright (C) 2019 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-/** A cache of objects that can be cleared. */
-interface ClearableCache {
- /** Releases cached references. */
- void clearCache();
-}
diff --git a/java/dagger/internal/codegen/CompilerOptions.java b/java/dagger/internal/codegen/CompilerOptions.java
deleted file mode 100644
index bc3cbf8..0000000
--- a/java/dagger/internal/codegen/CompilerOptions.java
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import com.squareup.javapoet.AnnotationSpec;
-import dagger.internal.GenerationOptions;
-import javax.lang.model.element.TypeElement;
-import javax.tools.Diagnostic;
-
-/** A collection of options that dictate how the compiler will run. */
-abstract class CompilerOptions {
- abstract boolean usesProducers();
-
- /**
- * Returns true if the fast initialization flag, {@code fastInit}, is enabled.
- *
- * <p>If enabled, the generated code will attempt to optimize for fast component initialization.
- * This is done by reducing the number of factory classes loaded during initialization and the
- * number of eagerly initialized fields at the cost of potential memory leaks and higher
- * per-provision instantiation time.
- */
- abstract boolean fastInit();
-
- abstract boolean formatGeneratedSource();
-
- abstract boolean writeProducerNameInToken();
-
- abstract Diagnostic.Kind nullableValidationKind();
-
- final boolean doCheckForNulls() {
- return nullableValidationKind().equals(Diagnostic.Kind.ERROR);
- }
-
- abstract Diagnostic.Kind privateMemberValidationKind();
-
- abstract Diagnostic.Kind staticMemberValidationKind();
-
- /**
- * If {@code true}, Dagger will generate factories and components even if some members-injected
- * types have {@code private} or {@code static} {@code @Inject}-annotated members.
- *
- * <p>This should only ever be enabled by the TCK tests. Disabling this validation could lead to
- * generating code that does not compile.
- */
- abstract boolean ignorePrivateAndStaticInjectionForComponent();
-
- abstract ValidationType scopeCycleValidationType();
-
- abstract boolean warnIfInjectionFactoryNotGeneratedUpstream();
-
- abstract boolean headerCompilation();
-
- abstract boolean aheadOfTimeSubcomponents();
-
- /**
- * Enables a testing configuration where all superclass {@link ComponentImplementation}s are
- * derived from their serialized forms.
- */
- abstract boolean forceUseSerializedComponentImplementations();
-
- /**
- * If {@code true}, in {@link #aheadOfTimeSubcomponents()} mode, Dagger will emit metadata
- * annotations to deserialize aspects of the {@link ComponentImplementation}.
- *
- * This should only be disabled in compile-testing tests that want to ignore the annotations when
- * asserting on generated source.
- */
- abstract boolean emitModifiableMetadataAnnotations();
-
- abstract boolean useGradleIncrementalProcessing();
-
- /**
- * Returns the validation that should be done for the full binding graph for the element.
- *
- * @throws IllegalArgumentException if {@code element} is not a module or (sub)component
- */
- abstract ValidationType fullBindingGraphValidationType(TypeElement element);
-
- abstract Diagnostic.Kind moduleHasDifferentScopesDiagnosticKind();
-
- abstract ValidationType explicitBindingConflictsWithInjectValidationType();
-
- /**
- * Creates a new {@link CompilerOptions} from the serialized {@link GenerationOptions} of a base
- * component implementation.
- */
- final CompilerOptions withGenerationOptions(GenerationOptions generationOptions) {
- return new ForwardingCompilerOptions(this) {
- @Override
- public boolean fastInit() {
- return generationOptions.fastInit();
- }
- };
- }
-
- /**
- * Returns a {@link GenerationOptions} annotation that serializes any options for this compilation
- * that should be reused in future compilations.
- */
- final AnnotationSpec toGenerationOptionsAnnotation() {
- return AnnotationSpec.builder(GenerationOptions.class)
- .addMember("fastInit", "$L", fastInit())
- .build();
- }
-}
diff --git a/java/dagger/internal/codegen/ComponentAnnotation.java b/java/dagger/internal/codegen/ComponentAnnotation.java
deleted file mode 100644
index a8f2ece..0000000
--- a/java/dagger/internal/codegen/ComponentAnnotation.java
+++ /dev/null
@@ -1,323 +0,0 @@
-/*
- * Copyright (C) 2019 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.AnnotationMirrors.getAnnotationValue;
-import static com.google.auto.common.MoreTypes.asTypeElements;
-import static com.google.auto.common.MoreTypes.isTypeOf;
-import static dagger.internal.codegen.DaggerStreams.toImmutableList;
-import static dagger.internal.codegen.MoreAnnotationValues.asAnnotationValues;
-import static dagger.internal.codegen.langmodel.DaggerElements.getAnyAnnotation;
-
-import com.google.auto.value.AutoValue;
-import com.google.auto.value.extension.memoized.Memoized;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-import dagger.Component;
-import dagger.Subcomponent;
-import dagger.producers.ProducerModule;
-import dagger.producers.ProductionComponent;
-import dagger.producers.ProductionSubcomponent;
-import java.lang.annotation.Annotation;
-import java.util.Collection;
-import java.util.Optional;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.AnnotationValue;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.TypeMirror;
-
-/**
- * A {@code @Component}, {@code @Subcomponent}, {@code @ProductionComponent}, or
- * {@code @ProductionSubcomponent} annotation, or a {@code @Module} or {@code @ProducerModule}
- * annotation that is being treated as a component annotation when validating full binding graphs
- * for modules.
- */
-abstract class ComponentAnnotation {
- /** The root component annotation types. */
- private static final ImmutableSet<Class<? extends Annotation>> ROOT_COMPONENT_ANNOTATIONS =
- ImmutableSet.of(Component.class, ProductionComponent.class);
-
- /** The subcomponent annotation types. */
- private static final ImmutableSet<Class<? extends Annotation>> SUBCOMPONENT_ANNOTATIONS =
- ImmutableSet.of(Subcomponent.class, ProductionSubcomponent.class);
-
- /** All component annotation types. */
- private static final ImmutableSet<Class<? extends Annotation>> ALL_COMPONENT_ANNOTATIONS =
- ImmutableSet.<Class<? extends Annotation>>builder()
- .addAll(ROOT_COMPONENT_ANNOTATIONS)
- .addAll(SUBCOMPONENT_ANNOTATIONS)
- .build();
-
- /** The annotation itself. */
- abstract AnnotationMirror annotation();
-
- /** The simple name of the annotation type. */
- String simpleName() {
- return MoreAnnotationMirrors.simpleName(annotation()).toString();
- }
-
- /**
- * Returns {@code true} if the annotation is a {@code @Subcomponent} or
- * {@code @ProductionSubcomponent}.
- */
- abstract boolean isSubcomponent();
-
- /**
- * Returns {@code true} if the annotation is a {@code @ProductionComponent},
- * {@code @ProductionSubcomponent}, or {@code @ProducerModule}.
- */
- abstract boolean isProduction();
-
- /**
- * Returns {@code true} if the annotation is a real component annotation and not a module
- * annotation.
- */
- abstract boolean isRealComponent();
-
- /** The values listed as {@code dependencies}. */
- abstract ImmutableList<AnnotationValue> dependencyValues();
-
- /** The types listed as {@code dependencies}. */
- ImmutableList<TypeMirror> dependencyTypes() {
- return dependencyValues().stream().map(MoreAnnotationValues::asType).collect(toImmutableList());
- }
-
- /**
- * The types listed as {@code dependencies}.
- *
- * @throws IllegalArgumentException if any of {@link #dependencyTypes()} are error types
- */
- ImmutableList<TypeElement> dependencies() {
- return asTypeElements(dependencyTypes()).asList();
- }
-
- /** The values listed as {@code modules}. */
- abstract ImmutableList<AnnotationValue> moduleValues();
-
- /** The types listed as {@code modules}. */
- ImmutableList<TypeMirror> moduleTypes() {
- return moduleValues().stream().map(MoreAnnotationValues::asType).collect(toImmutableList());
- }
-
- /**
- * The types listed as {@code modules}.
- *
- * @throws IllegalArgumentException if any of {@link #moduleTypes()} are error types
- */
- ImmutableSet<TypeElement> modules() {
- return asTypeElements(moduleTypes());
- }
-
- protected final ImmutableList<AnnotationValue> getAnnotationValues(String parameterName) {
- return asAnnotationValues(getAnnotationValue(annotation(), parameterName));
- }
-
- /**
- * Returns an object representing a root component annotation, not a subcomponent annotation, if
- * one is present on {@code typeElement}.
- */
- static Optional<ComponentAnnotation> rootComponentAnnotation(TypeElement typeElement) {
- return anyComponentAnnotation(typeElement, ROOT_COMPONENT_ANNOTATIONS);
- }
-
- /**
- * Returns an object representing a subcomponent annotation, if one is present on {@code
- * typeElement}.
- */
- static Optional<ComponentAnnotation> subcomponentAnnotation(TypeElement typeElement) {
- return anyComponentAnnotation(typeElement, SUBCOMPONENT_ANNOTATIONS);
- }
-
- /**
- * Returns an object representing a root component or subcomponent annotation, if one is present
- * on {@code typeElement}.
- */
- static Optional<ComponentAnnotation> anyComponentAnnotation(TypeElement typeElement) {
- return anyComponentAnnotation(typeElement, ALL_COMPONENT_ANNOTATIONS);
- }
-
- private static Optional<ComponentAnnotation> anyComponentAnnotation(
- TypeElement typeElement, Collection<Class<? extends Annotation>> annotations) {
- return getAnyAnnotation(typeElement, annotations).map(ComponentAnnotation::componentAnnotation);
- }
-
- /** Returns {@code true} if the argument is a component annotation. */
- static boolean isComponentAnnotation(AnnotationMirror annotation) {
- return ALL_COMPONENT_ANNOTATIONS.stream()
- .anyMatch(annotationClass -> isTypeOf(annotationClass, annotation.getAnnotationType()));
- }
-
- /** Creates an object representing a component or subcomponent annotation. */
- static ComponentAnnotation componentAnnotation(AnnotationMirror annotation) {
- RealComponentAnnotation.Builder annotationBuilder =
- RealComponentAnnotation.builder().annotation(annotation);
-
- if (isTypeOf(Component.class, annotation.getAnnotationType())) {
- return annotationBuilder.isProduction(false).isSubcomponent(false).build();
- }
- if (isTypeOf(Subcomponent.class, annotation.getAnnotationType())) {
- return annotationBuilder.isProduction(false).isSubcomponent(true).build();
- }
- if (isTypeOf(ProductionComponent.class, annotation.getAnnotationType())) {
- return annotationBuilder.isProduction(true).isSubcomponent(false).build();
- }
- if (isTypeOf(ProductionSubcomponent.class, annotation.getAnnotationType())) {
- return annotationBuilder.isProduction(true).isSubcomponent(true).build();
- }
- throw new IllegalArgumentException(
- annotation
- + " must be a Component, Subcomponent, ProductionComponent, "
- + "or ProductionSubcomponent annotation");
- }
-
- /** Creates a fictional component annotation representing a module. */
- static ComponentAnnotation fromModuleAnnotation(ModuleAnnotation moduleAnnotation) {
- return new AutoValue_ComponentAnnotation_FictionalComponentAnnotation(moduleAnnotation);
- }
-
- /** The root component annotation types. */
- static ImmutableSet<Class<? extends Annotation>> rootComponentAnnotations() {
- return ROOT_COMPONENT_ANNOTATIONS;
- }
-
- /** The subcomponent annotation types. */
- static ImmutableSet<Class<? extends Annotation>> subcomponentAnnotations() {
- return SUBCOMPONENT_ANNOTATIONS;
- }
-
- /** All component annotation types. */
- static ImmutableSet<Class<? extends Annotation>> allComponentAnnotations() {
- return ALL_COMPONENT_ANNOTATIONS;
- }
-
- /**
- * An actual component annotation.
- *
- * @see FictionalComponentAnnotation
- */
- @AutoValue
- abstract static class RealComponentAnnotation extends ComponentAnnotation {
-
- @Override
- @Memoized
- ImmutableList<AnnotationValue> dependencyValues() {
- return isSubcomponent() ? ImmutableList.of() : getAnnotationValues("dependencies");
- }
-
- @Override
- @Memoized
- ImmutableList<TypeMirror> dependencyTypes() {
- return super.dependencyTypes();
- }
-
- @Override
- @Memoized
- ImmutableList<TypeElement> dependencies() {
- return super.dependencies();
- }
-
- @Override
- boolean isRealComponent() {
- return true;
- }
-
- @Override
- @Memoized
- ImmutableList<AnnotationValue> moduleValues() {
- return getAnnotationValues("modules");
- }
-
- @Override
- @Memoized
- ImmutableList<TypeMirror> moduleTypes() {
- return super.moduleTypes();
- }
-
- @Override
- @Memoized
- ImmutableSet<TypeElement> modules() {
- return super.modules();
- }
-
- static Builder builder() {
- return new AutoValue_ComponentAnnotation_RealComponentAnnotation.Builder();
- }
-
- @AutoValue.Builder
- interface Builder {
- Builder annotation(AnnotationMirror annotation);
-
- Builder isSubcomponent(boolean isSubcomponent);
-
- Builder isProduction(boolean isProduction);
-
- RealComponentAnnotation build();
- }
- }
-
- /**
- * A fictional component annotation used to represent modules or other collections of bindings as
- * a component.
- */
- @AutoValue
- abstract static class FictionalComponentAnnotation extends ComponentAnnotation {
-
- @Override
- AnnotationMirror annotation() {
- return moduleAnnotation().annotation();
- }
-
- @Override
- boolean isSubcomponent() {
- return false;
- }
-
- @Override
- boolean isProduction() {
- return moduleAnnotation().annotationClass().equals(ProducerModule.class);
- }
-
- @Override
- boolean isRealComponent() {
- return false;
- }
-
- @Override
- ImmutableList<AnnotationValue> dependencyValues() {
- return ImmutableList.of();
- }
-
- @Override
- ImmutableList<AnnotationValue> moduleValues() {
- return moduleAnnotation().includesAsAnnotationValues();
- }
-
- @Override
- @Memoized
- ImmutableList<TypeMirror> moduleTypes() {
- return super.moduleTypes();
- }
-
- @Override
- @Memoized
- ImmutableSet<TypeElement> modules() {
- return super.modules();
- }
-
- abstract ModuleAnnotation moduleAnnotation();
- }
-}
diff --git a/java/dagger/internal/codegen/ComponentBindingExpressions.java b/java/dagger/internal/codegen/ComponentBindingExpressions.java
deleted file mode 100644
index 37cf1e8..0000000
--- a/java/dagger/internal/codegen/ComponentBindingExpressions.java
+++ /dev/null
@@ -1,713 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.base.Verify.verify;
-import static dagger.internal.codegen.BindingRequest.bindingRequest;
-import static dagger.internal.codegen.BindingType.MEMBERS_INJECTION;
-import static dagger.internal.codegen.DelegateBindingExpression.isBindsScopeStrongerThanDependencyScope;
-import static dagger.internal.codegen.MemberSelect.staticFactoryCreation;
-import static dagger.internal.codegen.RequestKinds.isDerivedFromProvider;
-import static dagger.internal.codegen.javapoet.CodeBlocks.makeParametersCodeBlock;
-import static dagger.internal.codegen.javapoet.TypeNames.DOUBLE_CHECK;
-import static dagger.internal.codegen.javapoet.TypeNames.SINGLE_CHECK;
-import static dagger.internal.codegen.langmodel.Accessibility.isRawTypeAccessible;
-import static dagger.internal.codegen.langmodel.Accessibility.isRawTypePubliclyAccessible;
-import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
-import static dagger.model.BindingKind.DELEGATE;
-import static dagger.model.BindingKind.MULTIBOUND_MAP;
-import static dagger.model.BindingKind.MULTIBOUND_SET;
-import static javax.lang.model.element.Modifier.ABSTRACT;
-
-import com.google.auto.common.MoreTypes;
-import com.google.common.collect.ImmutableList;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.MethodSpec;
-import dagger.internal.codegen.ComponentDescriptor.ComponentMethodDescriptor;
-import dagger.internal.codegen.FrameworkFieldInitializer.FrameworkInstanceCreationExpression;
-import dagger.internal.codegen.MethodBindingExpression.MethodImplementationStrategy;
-import dagger.internal.codegen.javapoet.Expression;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.DependencyRequest;
-import dagger.model.RequestKind;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Optional;
-import javax.inject.Inject;
-import javax.inject.Provider;
-import javax.lang.model.SourceVersion;
-import javax.lang.model.type.TypeMirror;
-
-/** A central repository of code expressions used to access any binding available to a component. */
-@PerComponentImplementation
-final class ComponentBindingExpressions {
- // TODO(dpb,ronshapiro): refactor this and ComponentRequirementExpressions into a
- // HierarchicalComponentMap<K, V>, or perhaps this use a flattened ImmutableMap, built from its
- // parents? If so, maybe make BindingExpression.Factory create it.
-
- private final Optional<ComponentBindingExpressions> parent;
- private final BindingGraph graph;
- private final ComponentImplementation componentImplementation;
- private final ComponentRequirementExpressions componentRequirementExpressions;
- private final OptionalFactories optionalFactories;
- private final DaggerTypes types;
- private final DaggerElements elements;
- private final SourceVersion sourceVersion;
- private final CompilerOptions compilerOptions;
- private final MembersInjectionMethods membersInjectionMethods;
- private final InnerSwitchingProviders innerSwitchingProviders;
- private final ModifiableBindingExpressions modifiableBindingExpressions;
- private final Map<BindingRequest, BindingExpression> expressions = new HashMap<>();
-
- @Inject
- ComponentBindingExpressions(
- @ParentComponent Optional<ComponentBindingExpressions> parent,
- BindingGraph graph,
- ComponentImplementation componentImplementation,
- ComponentRequirementExpressions componentRequirementExpressions,
- OptionalFactories optionalFactories,
- DaggerTypes types,
- DaggerElements elements,
- SourceVersion sourceVersion,
- @GenerationCompilerOptions CompilerOptions compilerOptions) {
- this.parent = parent;
- this.graph = graph;
- this.componentImplementation = componentImplementation;
- this.componentRequirementExpressions = checkNotNull(componentRequirementExpressions);
- this.optionalFactories = checkNotNull(optionalFactories);
- this.types = checkNotNull(types);
- this.elements = checkNotNull(elements);
- this.sourceVersion = checkNotNull(sourceVersion);
- this.compilerOptions = checkNotNull(compilerOptions);
- this.membersInjectionMethods =
- new MembersInjectionMethods(componentImplementation, this, graph, elements, types);
- this.innerSwitchingProviders =
- new InnerSwitchingProviders(componentImplementation, this, types);
- this.modifiableBindingExpressions =
- new ModifiableBindingExpressions(
- parent.map(cbe -> cbe.modifiableBindingExpressions),
- this,
- graph,
- componentImplementation,
- compilerOptions,
- types);
- }
-
- /* Returns the {@link ModifiableBindingExpressions} for this component. */
- ModifiableBindingExpressions modifiableBindingExpressions() {
- return modifiableBindingExpressions;
- }
-
- /**
- * Returns an expression that evaluates to the value of a binding request for a binding owned by
- * this component or an ancestor.
- *
- * @param requestingClass the class that will contain the expression
- * @throws IllegalStateException if there is no binding expression that satisfies the request
- */
- Expression getDependencyExpression(BindingRequest request, ClassName requestingClass) {
- return getBindingExpression(request).getDependencyExpression(requestingClass);
- }
-
- /**
- * Equivalent to {@link #getDependencyExpression(BindingRequest, ClassName)} that is used only
- * when the request is for implementation of a component method.
- *
- * @throws IllegalStateException if there is no binding expression that satisfies the request
- */
- Expression getDependencyExpressionForComponentMethod(
- BindingRequest request,
- ComponentMethodDescriptor componentMethod,
- ComponentImplementation componentImplementation) {
- return getBindingExpression(request)
- .getDependencyExpressionForComponentMethod(componentMethod, componentImplementation);
- }
-
- /**
- * Returns the {@link CodeBlock} for the method arguments used with the factory {@code create()}
- * method for the given {@link ContributionBinding binding}.
- */
- CodeBlock getCreateMethodArgumentsCodeBlock(ContributionBinding binding) {
- return makeParametersCodeBlock(getCreateMethodArgumentsCodeBlocks(binding));
- }
-
- private ImmutableList<CodeBlock> getCreateMethodArgumentsCodeBlocks(ContributionBinding binding) {
- ImmutableList.Builder<CodeBlock> arguments = ImmutableList.builder();
-
- if (binding.requiresModuleInstance()) {
- arguments.add(
- componentRequirementExpressions.getExpressionDuringInitialization(
- ComponentRequirement.forModule(binding.contributingModule().get().asType()),
- componentImplementation.name()));
- }
-
- binding.frameworkDependencies().stream()
- .map(BindingRequest::bindingRequest)
- .map(request -> getDependencyExpression(request, componentImplementation.name()))
- .map(Expression::codeBlock)
- .forEach(arguments::add);
-
- return arguments.build();
- }
-
- /**
- * Returns an expression that evaluates to the value of a dependency request, for passing to a
- * binding method, an {@code @Inject}-annotated constructor or member, or a proxy for one.
- *
- * <p>If the method is a generated static {@link InjectionMethods injection method}, each
- * parameter will be {@link Object} if the dependency's raw type is inaccessible. If that is the
- * case for this dependency, the returned expression will use a cast to evaluate to the raw type.
- *
- * @param requestingClass the class that will contain the expression
- */
- Expression getDependencyArgumentExpression(
- DependencyRequest dependencyRequest, ClassName requestingClass) {
-
- TypeMirror dependencyType = dependencyRequest.key().type();
- BindingRequest bindingRequest = bindingRequest(dependencyRequest);
- Expression dependencyExpression = getDependencyExpression(bindingRequest, requestingClass);
-
- if (compilerOptions.aheadOfTimeSubcomponents()) {
- TypeMirror requestedType =
- bindingRequest.requestedType(dependencyRequest.key().type(), types);
- // If dependencyExpression.type() has been erased to it's publicly accessible type in AOT,
- // we must sometimes cast the expression so that it is usable in the current component. To do
- // so, we check that without the cast the assignment would fail, that argument to this proxy
- // method erased the type, and that the raw type of the requested type is actually accessible
- // in the current class so that the cast is valid.
- if (!types.isAssignable(dependencyExpression.type(), requestedType)
- && !isRawTypePubliclyAccessible(requestedType)
- && isRawTypeAccessible(requestedType, requestingClass.packageName())) {
- return dependencyExpression.castTo(types.erasure(requestedType));
- }
- }
-
- if (dependencyRequest.kind().equals(RequestKind.INSTANCE)
- && !isTypeAccessibleFrom(dependencyType, requestingClass.packageName())
- && isRawTypeAccessible(dependencyType, requestingClass.packageName())) {
- return dependencyExpression.castTo(types.erasure(dependencyType));
- }
-
- return dependencyExpression;
- }
-
- /** Returns the implementation of a component method. */
- MethodSpec getComponentMethod(ComponentMethodDescriptor componentMethod) {
- checkArgument(componentMethod.dependencyRequest().isPresent());
- BindingRequest request = bindingRequest(componentMethod.dependencyRequest().get());
- MethodSpec.Builder method =
- MethodSpec.overriding(
- componentMethod.methodElement(),
- MoreTypes.asDeclared(graph.componentTypeElement().asType()),
- types);
- // Even though this is not used if the method is abstract, we need to invoke the binding
- // expression in order for the side of effect of the method being added to the
- // ComponentImplementation
- CodeBlock methodBody =
- getBindingExpression(request)
- .getComponentMethodImplementation(componentMethod, componentImplementation);
- if (!componentImplementation.superclassImplementation().isPresent()
- && !modifiableBindingExpressions
- .getModifiableBindingType(request)
- .hasBaseClassImplementation()
- && !componentImplementation.getModifiableBindingMethod(request).isPresent()) {
- return method.addModifiers(ABSTRACT).build();
- }
- return method.addCode(methodBody).build();
- }
-
- /** Returns the {@link BindingExpression} for the given {@link BindingRequest}. */
- BindingExpression getBindingExpression(BindingRequest request) {
- if (expressions.containsKey(request)) {
- return expressions.get(request);
- }
- Optional<BindingExpression> expression =
- modifiableBindingExpressions.maybeCreateModifiableBindingExpression(request);
- if (!expression.isPresent()) {
- ResolvedBindings resolvedBindings = graph.resolvedBindings(request);
- if (resolvedBindings != null
- && !resolvedBindings.bindingsOwnedBy(graph.componentDescriptor()).isEmpty()) {
- expression = Optional.of(createBindingExpression(resolvedBindings, request));
- }
- }
- if (!expression.isPresent()
- && compilerOptions.aheadOfTimeSubcomponents()
- && request.requestKind().isPresent()
- && isDerivedFromProvider(request.requestKind().get())) {
- RequestKind requestKind = request.requestKind().get();
- expression =
- Optional.of(
- new DerivedFromFrameworkInstanceBindingExpression(
- request.key(), FrameworkType.PROVIDER, requestKind, this, types));
- }
-
- if (expression.isPresent()) {
- expressions.put(request, expression.get());
- return expression.get();
- }
- checkArgument(parent.isPresent(), "no expression found for %s", request);
- return parent.get().getBindingExpression(request);
- }
-
- /** Creates a binding expression. */
- BindingExpression createBindingExpression(
- ResolvedBindings resolvedBindings, BindingRequest request) {
- switch (resolvedBindings.bindingType()) {
- case MEMBERS_INJECTION:
- checkArgument(request.isRequestKind(RequestKind.MEMBERS_INJECTION));
- return new MembersInjectionBindingExpression(resolvedBindings, membersInjectionMethods);
-
- case PROVISION:
- return provisionBindingExpression(resolvedBindings, request);
-
- case PRODUCTION:
- return productionBindingExpression(resolvedBindings, request);
- }
- throw new AssertionError(resolvedBindings);
- }
-
- /**
- * Returns a binding expression that uses a {@link javax.inject.Provider} for provision bindings
- * or a {@link dagger.producers.Producer} for production bindings.
- */
- private BindingExpression frameworkInstanceBindingExpression(ResolvedBindings resolvedBindings) {
- // TODO(user): Consider merging the static factory creation logic into CreationExpressions?
- Optional<MemberSelect> staticMethod =
- useStaticFactoryCreation(resolvedBindings.contributionBinding())
- ? staticFactoryCreation(resolvedBindings)
- : Optional.empty();
- FrameworkInstanceCreationExpression frameworkInstanceCreationExpression =
- resolvedBindings.scope().isPresent()
- ? scope(resolvedBindings, frameworkInstanceCreationExpression(resolvedBindings))
- : frameworkInstanceCreationExpression(resolvedBindings);
- FrameworkInstanceSupplier frameworkInstanceSupplier =
- staticMethod.isPresent()
- ? staticMethod::get
- : new FrameworkFieldInitializer(
- componentImplementation, resolvedBindings, frameworkInstanceCreationExpression);
-
- switch (resolvedBindings.bindingType()) {
- case PROVISION:
- return new ProviderInstanceBindingExpression(
- resolvedBindings, frameworkInstanceSupplier, types, elements);
- case PRODUCTION:
- return new ProducerNodeInstanceBindingExpression(
- resolvedBindings, frameworkInstanceSupplier, types, elements, componentImplementation);
- default:
- throw new AssertionError("invalid binding type: " + resolvedBindings.bindingType());
- }
- }
-
- private FrameworkInstanceCreationExpression scope(
- ResolvedBindings resolvedBindings, FrameworkInstanceCreationExpression unscoped) {
- return () ->
- CodeBlock.of(
- "$T.provider($L)",
- resolvedBindings.scope().get().isReusable() ? SINGLE_CHECK : DOUBLE_CHECK,
- unscoped.creationExpression());
- }
-
- /**
- * Returns a creation expression for a {@link javax.inject.Provider} for provision bindings or a
- * {@link dagger.producers.Producer} for production bindings.
- */
- private FrameworkInstanceCreationExpression frameworkInstanceCreationExpression(
- ResolvedBindings resolvedBindings) {
- checkArgument(!resolvedBindings.bindingType().equals(MEMBERS_INJECTION));
- ContributionBinding binding = resolvedBindings.contributionBinding();
- switch (binding.kind()) {
- case COMPONENT:
- // The cast can be removed when we drop java 7 source support
- return new InstanceFactoryCreationExpression(
- () -> CodeBlock.of("($T) this", binding.key().type()));
-
- case BOUND_INSTANCE:
- return instanceFactoryCreationExpression(
- binding, ComponentRequirement.forBoundInstance(binding));
-
- case COMPONENT_DEPENDENCY:
- return instanceFactoryCreationExpression(
- binding, ComponentRequirement.forDependency(binding.key().type()));
-
- case COMPONENT_PROVISION:
- return new DependencyMethodProviderCreationExpression(
- binding,
- componentImplementation,
- componentRequirementExpressions,
- compilerOptions,
- graph);
-
- case SUBCOMPONENT_CREATOR:
- return new AnonymousProviderCreationExpression(
- binding, this, componentImplementation.name());
-
- case INJECTION:
- case PROVISION:
- return new InjectionOrProvisionProviderCreationExpression(binding, this);
-
- case COMPONENT_PRODUCTION:
- return new DependencyMethodProducerCreationExpression(
- binding, componentImplementation, componentRequirementExpressions, graph);
-
- case PRODUCTION:
- return new ProducerCreationExpression(binding, this);
-
- case MULTIBOUND_SET:
- return new SetFactoryCreationExpression(binding, componentImplementation, this, graph);
-
- case MULTIBOUND_MAP:
- return new MapFactoryCreationExpression(
- binding, componentImplementation, this, graph, elements);
-
- case DELEGATE:
- return new DelegatingFrameworkInstanceCreationExpression(
- binding, componentImplementation, this);
-
- case OPTIONAL:
- return new OptionalFactoryInstanceCreationExpression(
- optionalFactories, binding, componentImplementation, this);
-
- case MEMBERS_INJECTOR:
- return new MembersInjectorProviderCreationExpression((ProvisionBinding) binding, this);
-
- default:
- throw new AssertionError(binding);
- }
- }
-
- private InstanceFactoryCreationExpression instanceFactoryCreationExpression(
- ContributionBinding binding, ComponentRequirement componentRequirement) {
- return new InstanceFactoryCreationExpression(
- binding.nullableType().isPresent(),
- () ->
- componentRequirementExpressions.getExpressionDuringInitialization(
- componentRequirement, componentImplementation.name()));
- }
-
- /** Returns a binding expression for a provision binding. */
- private BindingExpression provisionBindingExpression(
- ResolvedBindings resolvedBindings, BindingRequest request) {
- if (!request.requestKind().isPresent()) {
- verify(
- request.frameworkType().get().equals(FrameworkType.PRODUCER_NODE),
- "expected a PRODUCER_NODE: %s",
- request);
- return producerFromProviderBindingExpression(resolvedBindings);
- }
- RequestKind requestKind = request.requestKind().get();
- switch (requestKind) {
- case INSTANCE:
- return instanceBindingExpression(resolvedBindings);
-
- case PROVIDER:
- return providerBindingExpression(resolvedBindings);
-
- case LAZY:
- case PRODUCED:
- case PROVIDER_OF_LAZY:
- return new DerivedFromFrameworkInstanceBindingExpression(
- resolvedBindings.key(), FrameworkType.PROVIDER, requestKind, this, types);
-
- case PRODUCER:
- return producerFromProviderBindingExpression(resolvedBindings);
-
- case FUTURE:
- return new ImmediateFutureBindingExpression(resolvedBindings, this, types, sourceVersion);
-
- case MEMBERS_INJECTION:
- throw new IllegalArgumentException();
- }
-
- throw new AssertionError();
- }
-
- /** Returns a binding expression for a production binding. */
- private BindingExpression productionBindingExpression(
- ResolvedBindings resolvedBindings, BindingRequest request) {
- if (request.frameworkType().isPresent()) {
- return frameworkInstanceBindingExpression(resolvedBindings);
- } else {
- // If no FrameworkType is present, a RequestKind is guaranteed to be present.
- RequestKind requestKind = request.requestKind().get();
- return new DerivedFromFrameworkInstanceBindingExpression(
- resolvedBindings.key(), FrameworkType.PRODUCER_NODE, requestKind, this, types);
- }
- }
-
- /**
- * Returns a binding expression for {@link RequestKind#PROVIDER} requests.
- *
- * <p>{@code @Binds} bindings that don't {@linkplain #needsCaching(ResolvedBindings) need to be
- * cached} can use a {@link DelegateBindingExpression}.
- *
- * <p>In fastInit mode, use an {@link InnerSwitchingProviders inner switching provider} unless
- * that provider's case statement will simply call {@code get()} on another {@link Provider} (in
- * which case, just use that Provider directly).
- *
- * <p>Otherwise, return a {@link FrameworkInstanceBindingExpression}.
- */
- private BindingExpression providerBindingExpression(ResolvedBindings resolvedBindings) {
- if (resolvedBindings.contributionBinding().kind().equals(DELEGATE)
- && !needsCaching(resolvedBindings)) {
- return new DelegateBindingExpression(
- resolvedBindings, RequestKind.PROVIDER, this, types, elements);
- } else if (compilerOptions.fastInit()
- && frameworkInstanceCreationExpression(resolvedBindings).useInnerSwitchingProvider()
- && !(instanceBindingExpression(resolvedBindings)
- instanceof DerivedFromFrameworkInstanceBindingExpression)) {
- return wrapInMethod(
- resolvedBindings,
- bindingRequest(resolvedBindings.key(), RequestKind.PROVIDER),
- innerSwitchingProviders.newBindingExpression(resolvedBindings.contributionBinding()));
- }
- return frameworkInstanceBindingExpression(resolvedBindings);
- }
-
- /**
- * Returns a binding expression that uses a {@link dagger.producers.Producer} field for a
- * provision binding.
- */
- private FrameworkInstanceBindingExpression producerFromProviderBindingExpression(
- ResolvedBindings resolvedBindings) {
- checkArgument(resolvedBindings.bindingType().equals(BindingType.PROVISION));
- return new ProducerNodeInstanceBindingExpression(
- resolvedBindings,
- new FrameworkFieldInitializer(
- componentImplementation,
- resolvedBindings,
- new ProducerFromProviderCreationExpression(
- resolvedBindings.contributionBinding(), componentImplementation, this)),
- types,
- elements,
- componentImplementation);
- }
-
- /**
- * Returns a binding expression for {@link RequestKind#INSTANCE} requests.
- *
- * <p>If there is a direct expression (not calling {@link Provider#get()}) we can use for an
- * instance of this binding, return it, wrapped in a method if the binding {@linkplain
- * #needsCaching(ResolvedBindings) needs to be cached} or the expression has dependencies.
- *
- * <p>In fastInit mode, we can use direct expressions unless the binding needs to be cached.
- */
- private BindingExpression instanceBindingExpression(ResolvedBindings resolvedBindings) {
- Optional<BindingExpression> maybeDirectInstanceExpression =
- unscopedDirectInstanceExpression(resolvedBindings);
- if (canUseDirectInstanceExpression(resolvedBindings)
- && maybeDirectInstanceExpression.isPresent()) {
- BindingExpression directInstanceExpression = maybeDirectInstanceExpression.get();
- return directInstanceExpression.requiresMethodEncapsulation()
- || needsCaching(resolvedBindings)
- ? wrapInMethod(
- resolvedBindings,
- bindingRequest(resolvedBindings.key(), RequestKind.INSTANCE),
- directInstanceExpression)
- : directInstanceExpression;
- }
- return new DerivedFromFrameworkInstanceBindingExpression(
- resolvedBindings.key(), FrameworkType.PROVIDER, RequestKind.INSTANCE, this, types);
- }
-
- /**
- * Returns an unscoped binding expression for an {@link RequestKind#INSTANCE} that does not call
- * {@code get()} on its provider, if there is one.
- */
- private Optional<BindingExpression> unscopedDirectInstanceExpression(
- ResolvedBindings resolvedBindings) {
- switch (resolvedBindings.contributionBinding().kind()) {
- case DELEGATE:
- return Optional.of(
- new DelegateBindingExpression(
- resolvedBindings, RequestKind.INSTANCE, this, types, elements));
-
- case COMPONENT:
- return Optional.of(
- new ComponentInstanceBindingExpression(
- resolvedBindings, componentImplementation.name()));
-
- case COMPONENT_DEPENDENCY:
- return Optional.of(
- new ComponentRequirementBindingExpression(
- resolvedBindings,
- ComponentRequirement.forDependency(resolvedBindings.key().type()),
- componentRequirementExpressions));
-
- case COMPONENT_PROVISION:
- return Optional.of(
- new ComponentProvisionBindingExpression(
- resolvedBindings, graph, componentRequirementExpressions, compilerOptions));
-
- case SUBCOMPONENT_CREATOR:
- return Optional.of(
- new SubcomponentCreatorBindingExpression(
- resolvedBindings,
- componentImplementation.getSubcomponentCreatorSimpleName(resolvedBindings.key())));
-
- case MULTIBOUND_SET:
- return Optional.of(
- new SetBindingExpression(
- resolvedBindings, componentImplementation, graph, this, types, elements));
-
- case MULTIBOUND_MAP:
- return Optional.of(
- new MapBindingExpression(
- resolvedBindings, componentImplementation, graph, this, types, elements));
-
- case OPTIONAL:
- return Optional.of(
- new OptionalBindingExpression(resolvedBindings, this, types, sourceVersion));
-
- case BOUND_INSTANCE:
- return Optional.of(
- new ComponentRequirementBindingExpression(
- resolvedBindings,
- ComponentRequirement.forBoundInstance(resolvedBindings.contributionBinding()),
- componentRequirementExpressions));
-
- case INJECTION:
- case PROVISION:
- return Optional.of(
- new SimpleMethodBindingExpression(
- resolvedBindings,
- compilerOptions,
- this,
- membersInjectionMethods,
- componentRequirementExpressions,
- types,
- elements,
- sourceVersion));
-
- case MEMBERS_INJECTOR:
- return Optional.empty();
-
- case MEMBERS_INJECTION:
- case COMPONENT_PRODUCTION:
- case PRODUCTION:
- throw new IllegalArgumentException(
- resolvedBindings.contributionBinding().kind().toString());
- }
- throw new AssertionError();
- }
-
- /**
- * Returns {@code true} if the binding should use the static factory creation strategy.
- *
- * <p>In default mode, we always use the static factory creation strategy. In fastInit mode, we
- * prefer to use a SwitchingProvider instead of static factories in order to reduce class loading;
- * however, we allow static factories that can reused across multiple bindings, e.g. {@code
- * MapFactory} or {@code SetFactory}.
- */
- private boolean useStaticFactoryCreation(ContributionBinding binding) {
- return !compilerOptions.fastInit()
- || binding.kind().equals(MULTIBOUND_MAP)
- || binding.kind().equals(MULTIBOUND_SET);
- }
-
- /**
- * Returns {@code true} if we can use a direct (not {@code Provider.get()}) expression for this
- * binding. If the binding doesn't {@linkplain #needsCaching(ResolvedBindings) need to be cached},
- * we can.
- *
- * <p>In fastInit mode, we can use a direct expression even if the binding {@linkplain
- * #needsCaching(ResolvedBindings) needs to be cached}.
- */
- private boolean canUseDirectInstanceExpression(ResolvedBindings resolvedBindings) {
- return !needsCaching(resolvedBindings) || compilerOptions.fastInit();
- }
-
- /**
- * Returns a binding expression that uses a given one as the body of a method that users call. If
- * a component provision method matches it, it will be the method implemented. If it does not
- * match a component provision method and the binding is modifiable, then a new public modifiable
- * binding method will be written. If the binding doesn't match a component method and is not
- * modifiable, then a new private method will be written.
- */
- BindingExpression wrapInMethod(
- ResolvedBindings resolvedBindings,
- BindingRequest request,
- BindingExpression bindingExpression) {
- // If we've already wrapped the expression, then use the delegate.
- if (bindingExpression instanceof MethodBindingExpression) {
- return bindingExpression;
- }
-
- MethodImplementationStrategy methodImplementationStrategy =
- methodImplementationStrategy(resolvedBindings, request);
- Optional<ComponentMethodDescriptor> matchingComponentMethod =
- graph.componentDescriptor().firstMatchingComponentMethod(request);
-
- if (modifiableBindingExpressions.getModifiableBindingType(request).isModifiable()
- && (componentImplementation.superclassImplementation().isPresent()
- || !matchingComponentMethod.isPresent())) {
- return modifiableBindingExpressions.wrapInModifiableMethodBindingExpression(
- request, resolvedBindings, methodImplementationStrategy, bindingExpression);
- } else if (matchingComponentMethod.isPresent()) {
- ComponentMethodDescriptor componentMethod = matchingComponentMethod.get();
- return new ComponentMethodBindingExpression(
- request,
- resolvedBindings,
- methodImplementationStrategy,
- bindingExpression,
- componentImplementation,
- componentMethod,
- types);
- } else {
- return new PrivateMethodBindingExpression(
- request,
- resolvedBindings,
- methodImplementationStrategy,
- bindingExpression,
- componentImplementation,
- types);
- }
- }
-
- private MethodImplementationStrategy methodImplementationStrategy(
- ResolvedBindings resolvedBindings, BindingRequest request) {
- if (compilerOptions.fastInit()) {
- if (request.isRequestKind(RequestKind.PROVIDER)) {
- return MethodImplementationStrategy.SINGLE_CHECK;
- } else if (request.isRequestKind(RequestKind.INSTANCE) && needsCaching(resolvedBindings)) {
- return resolvedBindings.scope().get().isReusable()
- ? MethodImplementationStrategy.SINGLE_CHECK
- : MethodImplementationStrategy.DOUBLE_CHECK;
- }
- }
- return MethodImplementationStrategy.SIMPLE;
- }
-
- /**
- * Returns {@code true} if the component needs to make sure the provided value is cached.
- *
- * <p>The component needs to cache the value for scoped bindings except for {@code @Binds}
- * bindings whose scope is no stronger than their delegate's.
- */
- private boolean needsCaching(ResolvedBindings resolvedBindings) {
- if (!resolvedBindings.scope().isPresent()) {
- return false;
- }
- if (resolvedBindings.contributionBinding().kind().equals(DELEGATE)) {
- return isBindsScopeStrongerThanDependencyScope(resolvedBindings, graph);
- }
- return true;
- }
-}
diff --git a/java/dagger/internal/codegen/ComponentCreatorAnnotation.java b/java/dagger/internal/codegen/ComponentCreatorAnnotation.java
deleted file mode 100644
index 31bbfab..0000000
--- a/java/dagger/internal/codegen/ComponentCreatorAnnotation.java
+++ /dev/null
@@ -1,150 +0,0 @@
-/*
- * Copyright (C) 2019 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreElements.isAnnotationPresent;
-import static com.google.common.base.Ascii.toUpperCase;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.internal.codegen.DaggerStreams.valuesOf;
-import static java.util.stream.Collectors.mapping;
-
-import com.google.common.collect.ImmutableSet;
-import dagger.Component;
-import dagger.Subcomponent;
-import dagger.producers.ProductionComponent;
-import dagger.producers.ProductionSubcomponent;
-import java.lang.annotation.Annotation;
-import java.util.stream.Collector;
-import java.util.stream.Stream;
-import javax.lang.model.element.TypeElement;
-
-/** Simple representation of a component creator annotation type. */
-enum ComponentCreatorAnnotation {
- COMPONENT_BUILDER(Component.Builder.class),
- COMPONENT_FACTORY(Component.Factory.class),
- SUBCOMPONENT_BUILDER(Subcomponent.Builder.class),
- SUBCOMPONENT_FACTORY(Subcomponent.Factory.class),
- PRODUCTION_COMPONENT_BUILDER(ProductionComponent.Builder.class),
- PRODUCTION_COMPONENT_FACTORY(ProductionComponent.Factory.class),
- PRODUCTION_SUBCOMPONENT_BUILDER(ProductionSubcomponent.Builder.class),
- PRODUCTION_SUBCOMPONENT_FACTORY(ProductionSubcomponent.Factory.class),
- ;
-
- private final Class<? extends Annotation> annotation;
- private final ComponentCreatorKind creatorKind;
- private final Class<? extends Annotation> componentAnnotation;
-
- ComponentCreatorAnnotation(Class<? extends Annotation> annotation) {
- this.annotation = annotation;
- this.creatorKind = ComponentCreatorKind.valueOf(toUpperCase(annotation.getSimpleName()));
- this.componentAnnotation = (Class<? extends Annotation>) annotation.getEnclosingClass();
- }
-
- /** The actual annotation type. */
- Class<? extends Annotation> annotation() {
- return annotation;
- }
-
- /** The component annotation type that encloses this creator annotation type. */
- final Class<? extends Annotation> componentAnnotation() {
- return componentAnnotation;
- }
-
- /** Returns {@code true} if the creator annotation is for a subcomponent. */
- final boolean isSubcomponentCreatorAnnotation() {
- return componentAnnotation().getSimpleName().endsWith("Subcomponent");
- }
-
- /**
- * Returns {@code true} if the creator annotation is for a production component or subcomponent.
- */
- final boolean isProductionCreatorAnnotation() {
- return componentAnnotation().getSimpleName().startsWith("Production");
- }
-
- /** The creator kind the annotation is associated with. */
- // TODO(dpb): Remove ComponentCreatorKind.
- ComponentCreatorKind creatorKind() {
- return creatorKind;
- }
-
- @Override
- public final String toString() {
- return annotation().getName();
- }
-
- /** Returns all component creator annotations. */
- static ImmutableSet<Class<? extends Annotation>> allCreatorAnnotations() {
- return stream().collect(toAnnotationClasses());
- }
-
- /** Returns all root component creator annotations. */
- static ImmutableSet<Class<? extends Annotation>> rootComponentCreatorAnnotations() {
- return stream()
- .filter(
- componentCreatorAnnotation ->
- !componentCreatorAnnotation.isSubcomponentCreatorAnnotation())
- .collect(toAnnotationClasses());
- }
-
- /** Returns all subcomponent creator annotations. */
- static ImmutableSet<Class<? extends Annotation>> subcomponentCreatorAnnotations() {
- return stream()
- .filter(
- componentCreatorAnnotation ->
- componentCreatorAnnotation.isSubcomponentCreatorAnnotation())
- .collect(toAnnotationClasses());
- }
-
- /** Returns all production component creator annotations. */
- static ImmutableSet<Class<? extends Annotation>> productionCreatorAnnotations() {
- return stream()
- .filter(
- componentCreatorAnnotation ->
- componentCreatorAnnotation.isProductionCreatorAnnotation())
- .collect(toAnnotationClasses());
- }
-
- /** Returns the legal creator annotations for the given {@code componentAnnotation}. */
- static ImmutableSet<Class<? extends Annotation>> creatorAnnotationsFor(
- ComponentAnnotation componentAnnotation) {
- return stream()
- .filter(
- creatorAnnotation ->
- creatorAnnotation
- .componentAnnotation()
- .getSimpleName()
- .equals(componentAnnotation.simpleName()))
- .collect(toAnnotationClasses());
- }
-
- /** Returns all creator annotations present on the given {@code type}. */
- static ImmutableSet<ComponentCreatorAnnotation> getCreatorAnnotations(TypeElement type) {
- return stream()
- .filter(cca -> isAnnotationPresent(type, cca.annotation()))
- .collect(toImmutableSet());
- }
-
- private static Stream<ComponentCreatorAnnotation> stream() {
- return valuesOf(ComponentCreatorAnnotation.class);
- }
-
- private static Collector<ComponentCreatorAnnotation, ?, ImmutableSet<Class<? extends Annotation>>>
- toAnnotationClasses() {
- return mapping(ComponentCreatorAnnotation::annotation, toImmutableSet());
- }
-}
diff --git a/java/dagger/internal/codegen/ComponentCreatorDescriptor.java b/java/dagger/internal/codegen/ComponentCreatorDescriptor.java
deleted file mode 100644
index f6ec7a2..0000000
--- a/java/dagger/internal/codegen/ComponentCreatorDescriptor.java
+++ /dev/null
@@ -1,222 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreElements.isAnnotationPresent;
-import static com.google.auto.common.MoreTypes.asTypeElement;
-import static com.google.common.base.Verify.verify;
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static dagger.internal.codegen.ComponentCreatorAnnotation.getCreatorAnnotations;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.internal.codegen.ModuleAnnotation.moduleAnnotation;
-
-import com.google.auto.common.MoreTypes;
-import com.google.auto.value.AutoValue;
-import com.google.auto.value.extension.memoized.Memoized;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableSetMultimap;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Multimap;
-import dagger.BindsInstance;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.DependencyRequest;
-import java.util.List;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.element.VariableElement;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.ExecutableType;
-import javax.lang.model.type.TypeMirror;
-
-/**
- * A descriptor for a component <i>creator</i> type: that is, a type annotated with
- * {@code @Component.Builder} (or one of the corresponding production or subcomponent versions).
- */
-@AutoValue
-abstract class ComponentCreatorDescriptor {
-
- /** Returns the annotation marking this creator. */
- abstract ComponentCreatorAnnotation annotation();
-
- /** The kind of this creator. */
- final ComponentCreatorKind kind() {
- return annotation().creatorKind();
- }
-
- /** The annotated creator type. */
- abstract TypeElement typeElement();
-
- /** The method that creates and returns a component instance. */
- abstract ExecutableElement factoryMethod();
-
- /**
- * Multimap of component requirements to setter methods that set that requirement.
- *
- * <p>In a valid creator, there will be exactly one element per component requirement, so this
- * method should only be called when validating the descriptor.
- */
- abstract ImmutableSetMultimap<ComponentRequirement, ExecutableElement> unvalidatedSetterMethods();
-
- /**
- * Multimap of component requirements to factory method parameters that set that requirement.
- *
- * <p>In a valid creator, there will be exactly one element per component requirement, so this
- * method should only be called when validating the descriptor.
- */
- abstract ImmutableSetMultimap<ComponentRequirement, VariableElement>
- unvalidatedFactoryParameters();
-
- /**
- * Multimap of component requirements to elements (methods or parameters) that set that
- * requirement.
- *
- * <p>In a valid creator, there will be exactly one element per component requirement, so this
- * method should only be called when validating the descriptor.
- */
- final ImmutableSetMultimap<ComponentRequirement, Element> unvalidatedRequirementElements() {
- // ComponentCreatorValidator ensures that there are either setter methods or factory method
- // parameters, but not both, so we can cheat a little here since we know that only one of
- // the two multimaps will be non-empty.
- return ImmutableSetMultimap.copyOf( // no actual copy
- unvalidatedSetterMethods().isEmpty()
- ? unvalidatedFactoryParameters()
- : unvalidatedSetterMethods());
- }
-
- /**
- * Map of component requirements to elements (setter methods or factory method parameters) that
- * set them.
- */
- @Memoized
- ImmutableMap<ComponentRequirement, Element> requirementElements() {
- return flatten(unvalidatedRequirementElements());
- }
-
- /** Map of component requirements to setter methods for those requirements. */
- @Memoized
- ImmutableMap<ComponentRequirement, ExecutableElement> setterMethods() {
- return flatten(unvalidatedSetterMethods());
- }
-
- /** Map of component requirements to factory method parameters for those requirements. */
- @Memoized
- ImmutableMap<ComponentRequirement, VariableElement> factoryParameters() {
- return flatten(unvalidatedFactoryParameters());
- }
-
- private static <K, V> ImmutableMap<K, V> flatten(Multimap<K, V> multimap) {
- return ImmutableMap.copyOf(
- Maps.transformValues(multimap.asMap(), values -> getOnlyElement(values)));
- }
-
- /** Returns the set of component requirements this creator allows the user to set. */
- final ImmutableSet<ComponentRequirement> userSettableRequirements() {
- // Note: they should have been validated at the point this is used, so this set is valid.
- return unvalidatedRequirementElements().keySet();
- }
-
- /** Returns the set of requirements for modules and component dependencies for this creator. */
- final ImmutableSet<ComponentRequirement> moduleAndDependencyRequirements() {
- return userSettableRequirements().stream()
- .filter(requirement -> !requirement.isBoundInstance())
- .collect(toImmutableSet());
- }
-
- /** Returns the set of bound instance requirements for this creator. */
- final ImmutableSet<ComponentRequirement> boundInstanceRequirements() {
- return userSettableRequirements().stream()
- .filter(ComponentRequirement::isBoundInstance)
- .collect(toImmutableSet());
- }
-
- /** Returns the element in this creator that sets the given {@code requirement}. */
- final Element elementForRequirement(ComponentRequirement requirement) {
- return requirementElements().get(requirement);
- }
-
- /** Creates a new {@link ComponentCreatorDescriptor} for the given creator {@code type}. */
- static ComponentCreatorDescriptor create(
- DeclaredType type,
- DaggerElements elements,
- DaggerTypes types,
- DependencyRequestFactory dependencyRequestFactory) {
- TypeElement typeElement = asTypeElement(type);
- TypeMirror componentType = typeElement.getEnclosingElement().asType();
-
- ImmutableSetMultimap.Builder<ComponentRequirement, ExecutableElement> setterMethods =
- ImmutableSetMultimap.builder();
-
- ExecutableElement factoryMethod = null;
- for (ExecutableElement method : elements.getUnimplementedMethods(typeElement)) {
- ExecutableType resolvedMethodType = MoreTypes.asExecutable(types.asMemberOf(type, method));
-
- if (types.isSubtype(componentType, resolvedMethodType.getReturnType())) {
- factoryMethod = method;
- } else {
- VariableElement parameter = getOnlyElement(method.getParameters());
- TypeMirror parameterType = getOnlyElement(resolvedMethodType.getParameterTypes());
- setterMethods.put(
- requirement(method, parameter, parameterType, dependencyRequestFactory, method),
- method);
- }
- }
- verify(factoryMethod != null); // validation should have ensured this.
-
- ImmutableSetMultimap.Builder<ComponentRequirement, VariableElement> factoryParameters =
- ImmutableSetMultimap.builder();
-
- ExecutableType resolvedFactoryMethodType =
- MoreTypes.asExecutable(types.asMemberOf(type, factoryMethod));
- List<? extends VariableElement> parameters = factoryMethod.getParameters();
- List<? extends TypeMirror> parameterTypes = resolvedFactoryMethodType.getParameterTypes();
- for (int i = 0; i < parameters.size(); i++) {
- VariableElement parameter = parameters.get(i);
- TypeMirror parameterType = parameterTypes.get(i);
- factoryParameters.put(
- requirement(factoryMethod, parameter, parameterType, dependencyRequestFactory, parameter),
- parameter);
- }
-
- // Validation should have ensured exactly one creator annotation is present on the type.
- ComponentCreatorAnnotation annotation = getOnlyElement(getCreatorAnnotations(typeElement));
- return new AutoValue_ComponentCreatorDescriptor(
- annotation, typeElement, factoryMethod, setterMethods.build(), factoryParameters.build());
- }
-
- private static ComponentRequirement requirement(
- ExecutableElement method,
- VariableElement parameter,
- TypeMirror type,
- DependencyRequestFactory dependencyRequestFactory,
- Element elementForVariableName) {
- if (isAnnotationPresent(method, BindsInstance.class)
- || isAnnotationPresent(parameter, BindsInstance.class)) {
- DependencyRequest request =
- dependencyRequestFactory.forRequiredResolvedVariable(parameter, type);
- String variableName = elementForVariableName.getSimpleName().toString();
- return ComponentRequirement.forBoundInstance(
- request.key(), request.isNullable(), variableName);
- }
-
- return moduleAnnotation(asTypeElement(type)).isPresent()
- ? ComponentRequirement.forModule(type)
- : ComponentRequirement.forDependency(type);
- }
-}
diff --git a/java/dagger/internal/codegen/ComponentCreatorImplementation.java b/java/dagger/internal/codegen/ComponentCreatorImplementation.java
deleted file mode 100644
index a5eb680..0000000
--- a/java/dagger/internal/codegen/ComponentCreatorImplementation.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import com.google.auto.value.AutoValue;
-import com.google.common.collect.ImmutableMap;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.FieldSpec;
-import com.squareup.javapoet.TypeSpec;
-
-/** The implementation of a component creator type. */
-@AutoValue
-abstract class ComponentCreatorImplementation {
-
- /** Creates a new {@link ComponentCreatorImplementation}. */
- static ComponentCreatorImplementation create(
- TypeSpec spec,
- ClassName name,
- ImmutableMap<ComponentRequirement, FieldSpec> fields) {
- return new AutoValue_ComponentCreatorImplementation(spec, name, fields);
- }
-
- /** The type spec for the creator implementation. */
- abstract TypeSpec spec();
-
- /** The name of the creator implementation class. */
- abstract ClassName name();
-
- /**
- * All fields that are present in this implementation or its supertype.
- *
- * <p>In the case of ahead-of-time subcomponents, not all fields will necessarily be passed to
- * the component's constructor (because, for example, it turns out that a particular module that
- * the creator can set is actually inherited from an ancestor module).
- */
- abstract ImmutableMap<ComponentRequirement, FieldSpec> fields();
-}
diff --git a/java/dagger/internal/codegen/ComponentCreatorImplementationFactory.java b/java/dagger/internal/codegen/ComponentCreatorImplementationFactory.java
deleted file mode 100644
index 4f06b90..0000000
--- a/java/dagger/internal/codegen/ComponentCreatorImplementationFactory.java
+++ /dev/null
@@ -1,589 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreTypes.asDeclared;
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkState;
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static com.squareup.javapoet.MethodSpec.constructorBuilder;
-import static com.squareup.javapoet.MethodSpec.methodBuilder;
-import static com.squareup.javapoet.TypeSpec.classBuilder;
-import static dagger.internal.codegen.SourceFiles.simpleVariableName;
-import static dagger.internal.codegen.javapoet.CodeBlocks.toParametersCodeBlock;
-import static dagger.internal.codegen.javapoet.TypeSpecs.addSupertype;
-import static javax.lang.model.element.Modifier.ABSTRACT;
-import static javax.lang.model.element.Modifier.FINAL;
-import static javax.lang.model.element.Modifier.PRIVATE;
-import static javax.lang.model.element.Modifier.PROTECTED;
-import static javax.lang.model.element.Modifier.PUBLIC;
-import static javax.lang.model.element.Modifier.STATIC;
-
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.FieldSpec;
-import com.squareup.javapoet.MethodSpec;
-import com.squareup.javapoet.ParameterSpec;
-import com.squareup.javapoet.TypeName;
-import com.squareup.javapoet.TypeSpec;
-import dagger.internal.Preconditions;
-import dagger.internal.codegen.ComponentRequirement.NullPolicy;
-import dagger.internal.codegen.javapoet.TypeNames;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import java.util.Optional;
-import java.util.Set;
-import javax.inject.Inject;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.Modifier;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.TypeKind;
-
-/** Factory for creating {@link ComponentCreatorImplementation} instances. */
-final class ComponentCreatorImplementationFactory {
-
- private final DaggerElements elements;
- private final DaggerTypes types;
-
- @Inject
- ComponentCreatorImplementationFactory(DaggerElements elements, DaggerTypes types) {
- this.elements = elements;
- this.types = types;
- }
-
- /** Returns a new creator implementation for the given component, if necessary. */
- Optional<ComponentCreatorImplementation> create(
- ComponentImplementation componentImplementation, Optional<BindingGraph> graph) {
- if (!componentImplementation.componentDescriptor().hasCreator()) {
- return Optional.empty();
- }
-
- Optional<ComponentCreatorDescriptor> creatorDescriptor =
- componentImplementation.componentDescriptor().creatorDescriptor();
-
- if (componentImplementation.isAbstract()
- && (hasNoSetterMethods(creatorDescriptor)
- || componentImplementation.superclassImplementation().isPresent())) {
- // 1. Factory-like creators (those with no setter methods) are only generated in concrete
- // components, because they only have a factory method and the factory method must call
- // a concrete component's constructor.
- // 2. The component builder in ahead-of-time mode is generated with the base subcomponent
- // implementation, with the exception of the build method since that requires invoking the
- // constructor of a concrete component implementation. Intermediate component
- // implementations, because they still can't invoke the eventual constructor and have no
- // additional extensions to the builder, can ignore generating a builder implementation.
- return Optional.empty();
- }
-
- Builder builder =
- creatorDescriptor.isPresent()
- ? new BuilderForCreatorDescriptor(
- componentImplementation, creatorDescriptor.get(), graph)
- : new BuilderForGeneratedRootComponentBuilder(componentImplementation);
- return Optional.of(builder.build());
- }
-
- private static boolean hasNoSetterMethods(
- Optional<ComponentCreatorDescriptor> creatorDescriptor) {
- return creatorDescriptor.filter(descriptor -> descriptor.setterMethods().isEmpty()).isPresent();
- }
-
- /** Base class for building a creator implementation. */
- private abstract class Builder {
- final ComponentImplementation componentImplementation;
- final ClassName className;
- final TypeSpec.Builder classBuilder;
-
- private ImmutableMap<ComponentRequirement, FieldSpec> fields;
-
- Builder(ComponentImplementation componentImplementation) {
- this.componentImplementation = componentImplementation;
- this.className = componentImplementation.getCreatorName();
- this.classBuilder = classBuilder(className);
- }
-
- /** Builds the {@link ComponentCreatorImplementation}. */
- ComponentCreatorImplementation build() {
- setModifiers();
- setSupertype();
- this.fields = getOrAddFields();
- addConstructor();
- addSetterMethods();
- addFactoryMethod();
- return ComponentCreatorImplementation.create(classBuilder.build(), className, fields);
- }
-
- /** Returns the descriptor for the component. */
- final ComponentDescriptor componentDescriptor() {
- return componentImplementation.componentDescriptor();
- }
-
- /**
- * The set of requirements that must be passed to the component's constructor in the order
- * they must be passed.
- */
- final ImmutableSet<ComponentRequirement> componentConstructorRequirements() {
- return componentImplementation.requirements();
- }
-
- /** Returns the requirements that have setter methods on the creator type. */
- abstract ImmutableSet<ComponentRequirement> setterMethods();
-
- /**
- * Returns the component requirements that have factory method parameters, mapped to the name
- * for that parameter.
- */
- abstract ImmutableMap<ComponentRequirement, String> factoryMethodParameters();
-
- /**
- * The {@link ComponentRequirement}s that this creator allows users to set. Values are a status
- * for each requirement indicating what's needed for that requirement in the implementation
- * class currently being generated.
- */
- abstract ImmutableMap<ComponentRequirement, RequirementStatus> userSettableRequirements();
-
- /**
- * Component requirements that are both settable by the creator and needed to construct the
- * component.
- */
- private Set<ComponentRequirement> neededUserSettableRequirements() {
- return Sets.intersection(
- userSettableRequirements().keySet(), componentConstructorRequirements());
- }
-
- private void setModifiers() {
- visibility().ifPresent(classBuilder::addModifiers);
- if (!componentImplementation.isNested()) {
- classBuilder.addModifiers(STATIC);
- }
- classBuilder.addModifiers(componentImplementation.isAbstract() ? ABSTRACT : FINAL);
- }
-
- /** Returns the visibility modifier the generated class should have, if any. */
- protected abstract Optional<Modifier> visibility();
-
- /** Sets the superclass being extended or interface being implemented for this creator. */
- protected abstract void setSupertype();
-
- /** Adds a constructor for the creator type, if needed. */
- protected abstract void addConstructor();
-
- private ImmutableMap<ComponentRequirement, FieldSpec> getOrAddFields() {
- // If a base implementation is present, any fields are already defined there and don't need to
- // be created in this implementation.
- return componentImplementation
- .baseCreatorImplementation()
- .map(ComponentCreatorImplementation::fields)
- .orElseGet(this::addFields);
- }
-
- private ImmutableMap<ComponentRequirement, FieldSpec> addFields() {
- // Fields in an abstract creator class need to be visible from subclasses.
- Modifier modifier = componentImplementation.isAbstract() ? PROTECTED : PRIVATE;
- UniqueNameSet fieldNames = new UniqueNameSet();
- ImmutableMap<ComponentRequirement, FieldSpec> result =
- Maps.toMap(
- Sets.intersection(neededUserSettableRequirements(), setterMethods()),
- requirement ->
- FieldSpec.builder(
- TypeName.get(requirement.type()),
- fieldNames.getUniqueName(requirement.variableName()),
- modifier)
- .build());
- classBuilder.addFields(result.values());
- return result;
- }
-
- private void addSetterMethods() {
- Maps.filterKeys(userSettableRequirements(), setterMethods()::contains)
- .forEach(
- (requirement, status) ->
- createSetterMethod(requirement, status).ifPresent(classBuilder::addMethod));
- }
-
- /** Creates a new setter method builder, with no method body, for the given requirement. */
- protected abstract MethodSpec.Builder setterMethodBuilder(ComponentRequirement requirement);
-
- private Optional<MethodSpec> createSetterMethod(
- ComponentRequirement requirement, RequirementStatus status) {
- switch (status) {
- case NEEDED:
- return Optional.of(normalSetterMethod(requirement));
- case UNNEEDED:
- return Optional.of(noopSetterMethod(requirement));
- case UNSETTABLE_REPEATED_MODULE:
- return Optional.of(repeatedModuleSetterMethod(requirement));
- case IMPLEMENTED_IN_SUPERTYPE:
- return Optional.empty();
- }
- throw new AssertionError();
- }
-
- private MethodSpec normalSetterMethod(ComponentRequirement requirement) {
- MethodSpec.Builder method = setterMethodBuilder(requirement);
- ParameterSpec parameter = parameter(method.build());
- method.addStatement(
- "this.$N = $L",
- fields.get(requirement),
- requirement.nullPolicy(elements, types).equals(NullPolicy.ALLOW)
- ? CodeBlock.of("$N", parameter)
- : CodeBlock.of("$T.checkNotNull($N)", Preconditions.class, parameter));
- return maybeReturnThis(method);
- }
-
- private MethodSpec noopSetterMethod(ComponentRequirement requirement) {
- MethodSpec.Builder method = setterMethodBuilder(requirement);
- ParameterSpec parameter = parameter(method.build());
- method
- .addAnnotation(Deprecated.class)
- .addJavadoc(
- "@deprecated This module is declared, but an instance is not used in the component. "
- + "This method is a no-op. For more, see https://dagger.dev/unused-modules.\n")
- .addStatement("$T.checkNotNull($N)", Preconditions.class, parameter);
- return maybeReturnThis(method);
- }
-
- private MethodSpec repeatedModuleSetterMethod(ComponentRequirement requirement) {
- return setterMethodBuilder(requirement)
- .addStatement(
- "throw new $T($T.format($S, $T.class.getCanonicalName()))",
- UnsupportedOperationException.class,
- String.class,
- "%s cannot be set because it is inherited from the enclosing component",
- TypeNames.rawTypeName(TypeName.get(requirement.type())))
- .build();
- }
-
- private ParameterSpec parameter(MethodSpec method) {
- return getOnlyElement(method.parameters);
- }
-
- private MethodSpec maybeReturnThis(MethodSpec.Builder method) {
- MethodSpec built = method.build();
- return built.returnType.equals(TypeName.VOID)
- ? built
- : method.addStatement("return this").build();
- }
-
- private void addFactoryMethod() {
- if (!componentImplementation.isAbstract()) {
- classBuilder.addMethod(factoryMethod());
- }
- }
-
- MethodSpec factoryMethod() {
- MethodSpec.Builder factoryMethod = factoryMethodBuilder();
- factoryMethod
- .returns(ClassName.get(componentDescriptor().typeElement()))
- .addModifiers(PUBLIC);
-
- ImmutableMap<ComponentRequirement, String> factoryMethodParameters =
- factoryMethodParameters();
- userSettableRequirements()
- .keySet()
- .forEach(
- requirement -> {
- if (fields.containsKey(requirement)
- && componentConstructorRequirements().contains(requirement)) {
- // In AOT mode, there can be a field for a requirement even if the component's
- // constructor doesn't need it, because the base class for the creator was created
- // before the final graph for the component was known.
- FieldSpec field = fields.get(requirement);
- addNullHandlingForField(requirement, field, factoryMethod);
- } else if (factoryMethodParameters.containsKey(requirement)) {
- String parameterName = factoryMethodParameters.get(requirement);
- addNullHandlingForParameter(requirement, parameterName, factoryMethod);
- }
- });
- factoryMethod.addStatement(
- "return new $T($L)",
- componentImplementation.name(),
- componentConstructorArgs(factoryMethodParameters));
- return factoryMethod.build();
- }
-
- private void addNullHandlingForField(
- ComponentRequirement requirement, FieldSpec field, MethodSpec.Builder factoryMethod) {
- switch (requirement.nullPolicy(elements, types)) {
- case NEW:
- checkState(requirement.kind().isModule());
- factoryMethod
- .beginControlFlow("if ($N == null)", field)
- .addStatement("this.$N = $L", field, newModuleInstance(requirement))
- .endControlFlow();
- break;
- case THROW:
- // TODO(cgdecker,ronshapiro): ideally this should use the key instead of a class for
- // @BindsInstance requirements, but that's not easily proguardable.
- factoryMethod.addStatement(
- "$T.checkBuilderRequirement($N, $T.class)",
- Preconditions.class,
- field,
- TypeNames.rawTypeName(field.type));
- break;
- case ALLOW:
- break;
- }
- }
-
- private void addNullHandlingForParameter(
- ComponentRequirement requirement, String parameter, MethodSpec.Builder factoryMethod) {
- if (!requirement.nullPolicy(elements, types).equals(NullPolicy.ALLOW)) {
- // Factory method parameters are always required unless they are a nullable
- // binds-instance (i.e. ALLOW)
- factoryMethod.addStatement("$T.checkNotNull($L)", Preconditions.class, parameter);
- }
- }
-
- /** Returns a builder for the creator's factory method. */
- protected abstract MethodSpec.Builder factoryMethodBuilder();
-
- private CodeBlock componentConstructorArgs(
- ImmutableMap<ComponentRequirement, String> factoryMethodParameters) {
- return componentConstructorRequirements().stream()
- .map(
- requirement -> {
- if (fields.containsKey(requirement)) {
- return CodeBlock.of("$N", fields.get(requirement));
- } else if (factoryMethodParameters.containsKey(requirement)) {
- return CodeBlock.of("$L", factoryMethodParameters.get(requirement));
- } else {
- return newModuleInstance(requirement);
- }
- })
- .collect(toParametersCodeBlock());
- }
-
- private CodeBlock newModuleInstance(ComponentRequirement requirement) {
- checkArgument(requirement.kind().isModule()); // this should be guaranteed to be true here
- return ModuleProxies.newModuleInstance(requirement.typeElement(), className, elements);
- }
- }
-
- /** Builder for a creator type defined by a {@code ComponentCreatorDescriptor}. */
- private final class BuilderForCreatorDescriptor extends Builder {
- final ComponentCreatorDescriptor creatorDescriptor;
- private final Optional<BindingGraph> graph;
-
- BuilderForCreatorDescriptor(
- ComponentImplementation componentImplementation,
- ComponentCreatorDescriptor creatorDescriptor,
- Optional<BindingGraph> graph) {
- super(componentImplementation);
- this.creatorDescriptor = creatorDescriptor;
- this.graph = graph;
- }
-
- @Override
- protected ImmutableMap<ComponentRequirement, RequirementStatus> userSettableRequirements() {
- return Maps.toMap(creatorDescriptor.userSettableRequirements(), this::requirementStatus);
- }
-
- @Override
- protected Optional<Modifier> visibility() {
- if (componentImplementation.isAbstract()) {
- // The component creator class of a top-level component implementation in ahead-of-time
- // subcomponents mode must be public, not protected, because the creator's subclass will
- // be a sibling of the component subclass implementation, not nested.
- return Optional.of(componentImplementation.isNested() ? PROTECTED : PUBLIC);
- }
- return Optional.of(PRIVATE);
- }
-
- @Override
- protected void setSupertype() {
- if (componentImplementation.baseCreatorImplementation().isPresent()) {
- // If an abstract base implementation for this creator exists, extend that class.
- classBuilder.superclass(componentImplementation.baseCreatorImplementation().get().name());
- } else {
- addSupertype(classBuilder, creatorDescriptor.typeElement());
- }
- }
-
- @Override
- protected void addConstructor() {
- // Just use the implicit no-arg public constructor.
- }
-
- @Override
- protected ImmutableSet<ComponentRequirement> setterMethods() {
- return ImmutableSet.copyOf(creatorDescriptor.setterMethods().keySet());
- }
-
- @Override
- protected ImmutableMap<ComponentRequirement, String> factoryMethodParameters() {
- return ImmutableMap.copyOf(
- Maps.transformValues(
- creatorDescriptor.factoryParameters(),
- element -> element.getSimpleName().toString()));
- }
-
- private DeclaredType creatorType() {
- return asDeclared(creatorDescriptor.typeElement().asType());
- }
-
- @Override
- protected MethodSpec.Builder factoryMethodBuilder() {
- return MethodSpec.overriding(creatorDescriptor.factoryMethod(), creatorType(), types);
- }
-
- private RequirementStatus requirementStatus(ComponentRequirement requirement) {
- // In ahead-of-time subcomponents mode, all builder methods are defined at the base
- // implementation. The only case where a method needs to be overridden is for a repeated
- // module, which is unknown at the point when a base implementation is generated. We do this
- // at the root for simplicity (and as an aside, repeated modules are never used in google
- // as of 11/28/18, and thus the additional cost of including these methods at the root is
- // negligible).
- if (isRepeatedModule(requirement)) {
- return RequirementStatus.UNSETTABLE_REPEATED_MODULE;
- }
-
- if (hasBaseCreatorImplementation()) {
- return RequirementStatus.IMPLEMENTED_IN_SUPERTYPE;
- }
-
- return componentConstructorRequirements().contains(requirement)
- ? RequirementStatus.NEEDED
- : RequirementStatus.UNNEEDED;
- }
-
- /**
- * Returns whether the given requirement is for a repeat of a module inherited from an ancestor
- * component. This creator is not allowed to set such a module.
- */
- final boolean isRepeatedModule(ComponentRequirement requirement) {
- return !componentConstructorRequirements().contains(requirement)
- && !isOwnedModule(requirement);
- }
-
- /**
- * Returns whether the given {@code requirement} is for a module type owned by the component.
- */
- private boolean isOwnedModule(ComponentRequirement requirement) {
- return graph.map(g -> g.ownedModuleTypes().contains(requirement.typeElement())).orElse(true);
- }
-
- private boolean hasBaseCreatorImplementation() {
- return !componentImplementation.isAbstract()
- && componentImplementation.baseImplementation().isPresent();
- }
-
- @Override
- protected MethodSpec.Builder setterMethodBuilder(ComponentRequirement requirement) {
- ExecutableElement supertypeMethod = creatorDescriptor.setterMethods().get(requirement);
- MethodSpec.Builder method = MethodSpec.overriding(supertypeMethod, creatorType(), types);
- if (!supertypeMethod.getReturnType().getKind().equals(TypeKind.VOID)) {
- // Take advantage of covariant returns so that we don't have to worry about type variables
- method.returns(className);
- }
- return method;
- }
- }
-
- /**
- * Builder for a component builder class that is automatically generated for a root component that
- * does not have its own user-defined creator type (i.e. a {@code ComponentCreatorDescriptor}).
- */
- private final class BuilderForGeneratedRootComponentBuilder extends Builder {
- BuilderForGeneratedRootComponentBuilder(ComponentImplementation componentImplementation) {
- super(componentImplementation);
- }
-
- @Override
- protected ImmutableMap<ComponentRequirement, RequirementStatus> userSettableRequirements() {
- return Maps.toMap(
- setterMethods(),
- requirement ->
- componentConstructorRequirements().contains(requirement)
- ? RequirementStatus.NEEDED
- : RequirementStatus.UNNEEDED);
- }
-
- @Override
- protected Optional<Modifier> visibility() {
- return componentImplementation
- .componentDescriptor()
- .typeElement()
- .getModifiers()
- .contains(PUBLIC) ? Optional.of(PUBLIC) : Optional.empty();
- }
-
- @Override
- protected void setSupertype() {
- // There's never a supertype for a root component auto-generated builder type.
- }
-
- @Override
- protected void addConstructor() {
- classBuilder.addMethod(constructorBuilder().addModifiers(PRIVATE).build());
- }
-
- @Override
- protected ImmutableSet<ComponentRequirement> setterMethods() {
- return componentDescriptor().dependenciesAndConcreteModules();
- }
-
- @Override
- protected ImmutableMap<ComponentRequirement, String> factoryMethodParameters() {
- return ImmutableMap.of();
- }
-
- @Override
- protected MethodSpec.Builder factoryMethodBuilder() {
- return methodBuilder("build");
- }
-
- @Override
- protected MethodSpec.Builder setterMethodBuilder(ComponentRequirement requirement) {
- String name = simpleVariableName(requirement.typeElement());
- return methodBuilder(name)
- .addModifiers(PUBLIC)
- .addParameter(TypeName.get(requirement.type()), name)
- .returns(className);
- }
- }
-
- /** Enumeration of statuses a component requirement may have in a creator. */
- enum RequirementStatus {
- /** An instance is needed to create the component. */
- NEEDED,
-
- /**
- * An instance is not needed to create the component, but the requirement is for a module owned
- * by the component. Setting the requirement is a no-op and any setter method should be marked
- * deprecated on the generated type as a warning to the user.
- */
- UNNEEDED,
-
- /**
- * The requirement may not be set in this creator because the module it is for is already
- * inherited from an ancestor component. Any setter method for it should throw an exception.
- */
- UNSETTABLE_REPEATED_MODULE,
-
- /**
- * The requirement is settable by the creator, but the setter method implementation already
- * exists in a supertype.
- */
- IMPLEMENTED_IN_SUPERTYPE,
- ;
- }
-}
diff --git a/java/dagger/internal/codegen/ComponentCreatorKind.java b/java/dagger/internal/codegen/ComponentCreatorKind.java
deleted file mode 100644
index dc203de..0000000
--- a/java/dagger/internal/codegen/ComponentCreatorKind.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (C) 2019 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.CaseFormat.UPPER_CAMEL;
-import static com.google.common.base.CaseFormat.UPPER_UNDERSCORE;
-
-import com.google.common.base.Ascii;
-
-/** Enumeration of the different kinds of component creators. */
-enum ComponentCreatorKind {
- /** {@code @Component.Builder} or one of its subcomponent/production variants. */
- BUILDER,
-
- /** {@code @Component.Factory} or one of its subcomponent/production variants. */
- FACTORY,
- ;
-
- /** Name to use as (or as part of) a type name for a creator of this kind. */
- String typeName() {
- return UPPER_UNDERSCORE.to(UPPER_CAMEL, name());
- }
-
- /** Name to use for a component's static method returning a creator of this kind. */
- String methodName() {
- return Ascii.toLowerCase(name());
- }
-}
diff --git a/java/dagger/internal/codegen/ComponentCreatorValidator.java b/java/dagger/internal/codegen/ComponentCreatorValidator.java
deleted file mode 100644
index c55dadd..0000000
--- a/java/dagger/internal/codegen/ComponentCreatorValidator.java
+++ /dev/null
@@ -1,390 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreElements.isAnnotationPresent;
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static dagger.internal.codegen.ComponentCreatorAnnotation.getCreatorAnnotations;
-import static javax.lang.model.element.Modifier.ABSTRACT;
-import static javax.lang.model.element.Modifier.PRIVATE;
-import static javax.lang.model.element.Modifier.STATIC;
-import static javax.lang.model.util.ElementFilter.methodsIn;
-
-import com.google.auto.common.MoreElements;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ObjectArrays;
-import dagger.BindsInstance;
-import dagger.internal.codegen.ErrorMessages.ComponentCreatorMessages;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import java.util.List;
-import java.util.Set;
-import javax.inject.Inject;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.Modifier;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.element.VariableElement;
-import javax.lang.model.type.TypeKind;
-import javax.lang.model.type.TypeMirror;
-import javax.lang.model.util.ElementFilter;
-
-/** Validates types annotated with component creator annotations. */
-final class ComponentCreatorValidator {
-
- private final DaggerElements elements;
- private final DaggerTypes types;
-
- @Inject
- ComponentCreatorValidator(DaggerElements elements, DaggerTypes types) {
- this.elements = elements;
- this.types = types;
- }
-
- /** Validates that the given {@code type} is potentially a valid component creator type. */
- public ValidationReport<TypeElement> validate(TypeElement type) {
- ValidationReport.Builder<TypeElement> report = ValidationReport.about(type);
-
- ImmutableSet<ComponentCreatorAnnotation> creatorAnnotations = getCreatorAnnotations(type);
- if (!validateOnlyOneCreatorAnnotation(creatorAnnotations, report)) {
- return report.build();
- }
-
- // Note: there's more validation in ComponentDescriptorValidator:
- // - to make sure the setter methods/factory parameters mirror the deps
- // - to make sure each type or key is set by only one method or parameter
- ElementValidator validator =
- new ElementValidator(type, report, getOnlyElement(creatorAnnotations));
- return validator.validate();
- }
-
- private boolean validateOnlyOneCreatorAnnotation(
- ImmutableSet<ComponentCreatorAnnotation> creatorAnnotations,
- ValidationReport.Builder<?> report) {
- // creatorAnnotations should never be empty because this should only ever be called for
- // types that have been found to have some creator annotation
- if (creatorAnnotations.size() > 1) {
- String error =
- "May not have more than one component Factory or Builder annotation on a type"
- + ": found "
- + creatorAnnotations;
- report.addError(error);
- return false;
- }
-
- return true;
- }
-
- /**
- * Validator for a single {@link TypeElement} that is annotated with a {@code Builder} or {@code
- * Factory} annotation.
- */
- private final class ElementValidator {
- private final TypeElement type;
- private final Element component;
- private final ValidationReport.Builder<TypeElement> report;
- private final ComponentCreatorAnnotation annotation;
- private final ComponentCreatorMessages messages;
-
- private ElementValidator(
- TypeElement type,
- ValidationReport.Builder<TypeElement> report,
- ComponentCreatorAnnotation annotation) {
- this.type = type;
- this.component = type.getEnclosingElement();
- this.report = report;
- this.annotation = annotation;
- this.messages = ErrorMessages.creatorMessagesFor(annotation);
- }
-
- /** Validates the creator type. */
- final ValidationReport<TypeElement> validate() {
- if (!isAnnotationPresent(component, annotation.componentAnnotation())) {
- report.addError(messages.mustBeInComponent());
- }
-
- // If the type isn't a class or interface, don't validate anything else since the rest of the
- // messages will be bogus.
- if (!validateIsClassOrInterface()) {
- return report.build();
- }
-
- validateTypeRequirements();
- switch (annotation.creatorKind()) {
- case FACTORY:
- validateFactory();
- break;
- case BUILDER:
- validateBuilder();
- }
-
- return report.build();
- }
-
- /** Validates that the type is a class or interface type and returns true if it is. */
- private boolean validateIsClassOrInterface() {
- switch (type.getKind()) {
- case CLASS:
- validateConstructor();
- return true;
- case INTERFACE:
- return true;
- default:
- report.addError(messages.mustBeClassOrInterface());
- }
- return false;
- }
-
- private void validateConstructor() {
- List<? extends Element> allElements = type.getEnclosedElements();
- List<ExecutableElement> constructors = ElementFilter.constructorsIn(allElements);
-
- boolean valid = true;
- if (constructors.size() != 1) {
- valid = false;
- } else {
- ExecutableElement constructor = getOnlyElement(constructors);
- valid =
- constructor.getParameters().isEmpty() && !constructor.getModifiers().contains(PRIVATE);
- }
-
- if (!valid) {
- report.addError(messages.invalidConstructor());
- }
- }
-
- /** Validates basic requirements about the type that are common to both creator kinds. */
- private void validateTypeRequirements() {
- if (!type.getTypeParameters().isEmpty()) {
- report.addError(messages.generics());
- }
-
- Set<Modifier> modifiers = type.getModifiers();
- if (modifiers.contains(PRIVATE)) {
- report.addError(messages.isPrivate());
- }
- if (!modifiers.contains(STATIC)) {
- report.addError(messages.mustBeStatic());
- }
- // Note: Must be abstract, so no need to check for final.
- if (!modifiers.contains(ABSTRACT)) {
- report.addError(messages.mustBeAbstract());
- }
- }
-
- private void validateBuilder() {
- ExecutableElement buildMethod = null;
- for (ExecutableElement method : elements.getUnimplementedMethods(type)) {
- switch (method.getParameters().size()) {
- case 0: // If this is potentially a build() method, validate it returns the correct type.
- if (validateFactoryMethodReturnType(method)) {
- if (buildMethod != null) {
- // If we found more than one build-like method, fail.
- error(
- method,
- messages.twoFactoryMethods(),
- messages.inheritedTwoFactoryMethods(),
- buildMethod);
- }
- }
- // We set the buildMethod regardless of the return type to reduce error spam.
- buildMethod = method;
- break;
-
- case 1: // If this correctly had one parameter, make sure the return types are valid.
- validateSetterMethod(method);
- break;
-
- default: // more than one parameter
- error(
- method,
- messages.setterMethodsMustTakeOneArg(),
- messages.inheritedSetterMethodsMustTakeOneArg());
- break;
- }
- }
-
- if (buildMethod == null) {
- report.addError(messages.missingFactoryMethod());
- } else {
- validateNotGeneric(buildMethod);
- }
- }
-
- private void validateSetterMethod(ExecutableElement method) {
- TypeMirror returnType = types.resolveExecutableType(method, type.asType()).getReturnType();
- if (returnType.getKind() != TypeKind.VOID && !types.isSubtype(type.asType(), returnType)) {
- error(
- method,
- messages.setterMethodsMustReturnVoidOrBuilder(),
- messages.inheritedSetterMethodsMustReturnVoidOrBuilder());
- }
-
- validateNotGeneric(method);
-
- VariableElement parameter = method.getParameters().get(0);
-
- boolean methodIsBindsInstance = isAnnotationPresent(method, BindsInstance.class);
- boolean parameterIsBindsInstance = isAnnotationPresent(parameter, BindsInstance.class);
- boolean bindsInstance = methodIsBindsInstance || parameterIsBindsInstance;
-
- if (methodIsBindsInstance && parameterIsBindsInstance) {
- error(
- method,
- messages.bindsInstanceNotAllowedOnBothSetterMethodAndParameter(),
- messages.inheritedBindsInstanceNotAllowedOnBothSetterMethodAndParameter());
- }
-
- if (!bindsInstance && parameter.asType().getKind().isPrimitive()) {
- error(
- method,
- messages.nonBindsInstanceParametersMayNotBePrimitives(),
- messages.inheritedNonBindsInstanceParametersMayNotBePrimitives());
- }
- }
-
- private void validateFactory() {
- ImmutableList<ExecutableElement> abstractMethods =
- elements.getUnimplementedMethods(type).asList();
- switch (abstractMethods.size()) {
- case 0:
- report.addError(messages.missingFactoryMethod());
- return;
- case 1:
- break; // good
- default:
- error(
- abstractMethods.get(1),
- messages.twoFactoryMethods(),
- messages.inheritedTwoFactoryMethods(),
- abstractMethods.get(0));
- return;
- }
-
- validateFactoryMethod(getOnlyElement(abstractMethods));
- }
-
- /** Validates that the given {@code method} is a valid component factory method. */
- private void validateFactoryMethod(ExecutableElement method) {
- validateNotGeneric(method);
-
- if (!validateFactoryMethodReturnType(method)) {
- // If we can't determine that the single method is a valid factory method, don't bother
- // validating its parameters.
- return;
- }
-
- for (VariableElement parameter : method.getParameters()) {
- if (!isAnnotationPresent(parameter, BindsInstance.class)
- && parameter.asType().getKind().isPrimitive()) {
- error(
- method,
- messages.nonBindsInstanceParametersMayNotBePrimitives(),
- messages.inheritedNonBindsInstanceParametersMayNotBePrimitives());
- }
- }
- }
-
- /**
- * Validates that the factory method that actually returns a new component instance. Returns
- * true if the return type was valid.
- */
- private boolean validateFactoryMethodReturnType(ExecutableElement method) {
- TypeMirror returnType = types.resolveExecutableType(method, type.asType()).getReturnType();
-
- if (!types.isSubtype(component.asType(), returnType)) {
- error(
- method,
- messages.factoryMethodMustReturnComponentType(),
- messages.inheritedFactoryMethodMustReturnComponentType());
- return false;
- }
-
- if (isAnnotationPresent(method, BindsInstance.class)) {
- error(
- method,
- messages.factoryMethodMayNotBeAnnotatedWithBindsInstance(),
- messages.inheritedFactoryMethodMayNotBeAnnotatedWithBindsInstance());
- return false;
- }
-
- TypeElement componentType = MoreElements.asType(component);
- if (!types.isSameType(componentType.asType(), returnType)) {
- ImmutableSet<ExecutableElement> methodsOnlyInComponent =
- methodsOnlyInComponent(componentType);
- if (!methodsOnlyInComponent.isEmpty()) {
- report.addWarning(
- messages.factoryMethodReturnsSupertypeWithMissingMethods(
- componentType, type, returnType, method, methodsOnlyInComponent),
- method);
- }
- }
- return true;
- }
-
- /**
- * Generates one of two error messages. If the method is enclosed in the subject, we target the
- * error to the method itself. Otherwise we target the error to the subject and list the method
- * as an argument. (Otherwise we have no way of knowing if the method is being compiled in this
- * pass too, so javac might not be able to pinpoint it's line of code.)
- */
- /*
- * For Component.Builder, the prototypical example would be if someone had:
- * libfoo: interface SharedBuilder { void badSetter(A a, B b); }
- * libbar: BarComponent { BarBuilder extends SharedBuilder } }
- * ... the compiler only validates BarBuilder when compiling libbar, but it fails because
- * of libfoo's SharedBuilder (which could have been compiled in a previous pass).
- * So we can't point to SharedBuilder#badSetter as the subject of the BarBuilder validation
- * failure.
- *
- * This check is a little more strict than necessary -- ideally we'd check if method's enclosing
- * class was included in this compile run. But that's hard, and this is close enough.
- */
- private void error(
- ExecutableElement method,
- String enclosedError,
- String inheritedError,
- Object... extraArgs) {
- if (method.getEnclosingElement().equals(type)) {
- report.addError(String.format(enclosedError, extraArgs), method);
- } else {
- report.addError(String.format(inheritedError, ObjectArrays.concat(extraArgs, method)));
- }
- }
-
- /** Validates that the given {@code method} is not generic. * */
- private void validateNotGeneric(ExecutableElement method) {
- if (!method.getTypeParameters().isEmpty()) {
- error(
- method,
- messages.methodsMayNotHaveTypeParameters(),
- messages.inheritedMethodsMayNotHaveTypeParameters());
- }
- }
-
- /**
- * Returns all methods defind in {@code componentType} which are not inherited from a supertype.
- */
- private ImmutableSet<ExecutableElement> methodsOnlyInComponent(TypeElement componentType) {
- // TODO(ronshapiro): Ideally this shouldn't return methods which are redeclared from a
- // supertype, but do not change the return type. We don't have a good/simple way of checking
- // that, and it doesn't seem likely, so the warning won't be too bad.
- return ImmutableSet.copyOf(methodsIn(componentType.getEnclosedElements()));
- }
- }
-}
diff --git a/java/dagger/internal/codegen/ComponentDescriptor.java b/java/dagger/internal/codegen/ComponentDescriptor.java
deleted file mode 100644
index 769cc4c..0000000
--- a/java/dagger/internal/codegen/ComponentDescriptor.java
+++ /dev/null
@@ -1,376 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.base.Preconditions.checkState;
-import static dagger.internal.codegen.DaggerStreams.toImmutableMap;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.internal.codegen.langmodel.DaggerTypes.isFutureType;
-import static javax.lang.model.element.Modifier.ABSTRACT;
-import static javax.lang.model.type.TypeKind.VOID;
-
-import com.google.auto.value.AutoValue;
-import com.google.auto.value.extension.memoized.Memoized;
-import com.google.common.base.Supplier;
-import com.google.common.base.Suppliers;
-import com.google.common.collect.ImmutableBiMap;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Maps;
-import com.google.errorprone.annotations.CanIgnoreReturnValue;
-import com.google.errorprone.annotations.CheckReturnValue;
-import dagger.Component;
-import dagger.Module;
-import dagger.Subcomponent;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.DependencyRequest;
-import dagger.model.Scope;
-import dagger.producers.CancellationPolicy;
-import dagger.producers.ProductionComponent;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.stream.Stream;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.TypeMirror;
-
-/**
- * A component declaration.
- *
- * <p>Represents one type annotated with {@code @Component}, {@code Subcomponent},
- * {@code @ProductionComponent}, or {@code @ProductionSubcomponent}.
- *
- * <p>When validating bindings installed in modules, a {@link ComponentDescriptor} can also
- * represent a synthetic component for the module, where there is an entry point for each binding in
- * the module.
- */
-@AutoValue
-abstract class ComponentDescriptor {
- /** The annotation that specifies that {@link #typeElement()} is a component. */
- abstract ComponentAnnotation annotation();
-
- /** Returns {@code true} if this is a subcomponent. */
- final boolean isSubcomponent() {
- return annotation().isSubcomponent();
- }
-
- /**
- * Returns {@code true} if this is a production component or subcomponent, or a
- * {@code @ProducerModule} when doing module binding validation.
- */
- final boolean isProduction() {
- return annotation().isProduction();
- }
-
- /**
- * Returns {@code true} if this is a real component, and not a fictional one used to validate
- * module bindings.
- */
- final boolean isRealComponent() {
- return annotation().isRealComponent();
- }
-
- /**
- * The element that defines the component. This is the element to which the {@link #annotation()}
- * was applied.
- */
- abstract TypeElement typeElement();
-
- /**
- * The set of component dependencies listed in {@link Component#dependencies} or {@link
- * ProductionComponent#dependencies()}.
- */
- abstract ImmutableSet<ComponentRequirement> dependencies();
-
- /** The non-abstract {@link #modules()} and the {@link #dependencies()}. */
- final ImmutableSet<ComponentRequirement> dependenciesAndConcreteModules() {
- return Stream.concat(
- moduleTypes().stream()
- .filter(dep -> !dep.getModifiers().contains(ABSTRACT))
- .map(module -> ComponentRequirement.forModule(module.asType())),
- dependencies().stream())
- .collect(toImmutableSet());
- }
-
- /**
- * The {@link ModuleDescriptor modules} declared in {@link Component#modules()} and reachable by
- * traversing {@link Module#includes()}.
- */
- abstract ImmutableSet<ModuleDescriptor> modules();
-
- /** The types of the {@link #modules()}. */
- final ImmutableSet<TypeElement> moduleTypes() {
- return modules().stream().map(ModuleDescriptor::moduleElement).collect(toImmutableSet());
- }
-
- /**
- * The types for which the component will need instances if all of its bindings are used. For the
- * types the component will need in a given binding graph, use {@link
- * BindingGraph#componentRequirements()}.
- *
- * <ul>
- * <li>{@linkplain #modules()} modules} with concrete instance bindings
- * <li>Bound instances
- * <li>{@linkplain #dependencies() dependencies}
- * </ul>
- */
- @Memoized
- ImmutableSet<ComponentRequirement> requirements() {
- ImmutableSet.Builder<ComponentRequirement> requirements = ImmutableSet.builder();
- modules().stream()
- .filter(
- module ->
- module.bindings().stream().anyMatch(ContributionBinding::requiresModuleInstance))
- .map(module -> ComponentRequirement.forModule(module.moduleElement().asType()))
- .forEach(requirements::add);
- requirements.addAll(dependencies());
- requirements.addAll(
- creatorDescriptor()
- .map(ComponentCreatorDescriptor::boundInstanceRequirements)
- .orElse(ImmutableSet.of()));
- return requirements.build();
- }
-
- /**
- * This component's {@linkplain #dependencies() dependencies} keyed by each provision or
- * production method defined by that dependency. Note that the dependencies' types are not simply
- * the enclosing type of the method; a method may be declared by a supertype of the actual
- * dependency.
- */
- abstract ImmutableMap<ExecutableElement, ComponentRequirement> dependenciesByDependencyMethod();
-
- /** The {@linkplain #dependencies() component dependency} that defines a method. */
- final ComponentRequirement getDependencyThatDefinesMethod(Element method) {
- checkArgument(
- method instanceof ExecutableElement, "method must be an executable element: %s", method);
- return checkNotNull(
- dependenciesByDependencyMethod().get(method), "no dependency implements %s", method);
- }
-
- /**
- * The scopes of the component.
- */
- abstract ImmutableSet<Scope> scopes();
-
- /**
- * All {@link Subcomponent}s which are direct children of this component. This includes
- * subcomponents installed from {@link Module#subcomponents()} as well as subcomponent {@linkplain
- * #childComponentsDeclaredByFactoryMethods() factory methods} and {@linkplain
- * #childComponentsDeclaredByBuilderEntryPoints() builder methods}.
- */
- final ImmutableSet<ComponentDescriptor> childComponents() {
- return ImmutableSet.<ComponentDescriptor>builder()
- .addAll(childComponentsDeclaredByFactoryMethods().values())
- .addAll(childComponentsDeclaredByBuilderEntryPoints().values())
- .addAll(childComponentsDeclaredByModules())
- .build();
- }
-
- /**
- * All {@linkplain Subcomponent direct child} components that are declared by a {@linkplain
- * Module#subcomponents() module's subcomponents}.
- */
- abstract ImmutableSet<ComponentDescriptor> childComponentsDeclaredByModules();
-
- /**
- * All {@linkplain Subcomponent direct child} components that are declared by a subcomponent
- * factory method.
- */
- abstract ImmutableBiMap<ComponentMethodDescriptor, ComponentDescriptor>
- childComponentsDeclaredByFactoryMethods();
-
- /** Returns a map of {@link #childComponents()} indexed by {@link #typeElement()}. */
- @Memoized
- ImmutableMap<TypeElement, ComponentDescriptor> childComponentsByElement() {
- return Maps.uniqueIndex(childComponents(), ComponentDescriptor::typeElement);
- }
-
- /** Returns the factory method that declares a child component. */
- final Optional<ComponentMethodDescriptor> getFactoryMethodForChildComponent(
- ComponentDescriptor childComponent) {
- return Optional.ofNullable(
- childComponentsDeclaredByFactoryMethods().inverse().get(childComponent));
- }
-
- /**
- * All {@linkplain Subcomponent direct child} components that are declared by a subcomponent
- * builder method.
- */
- abstract ImmutableBiMap<ComponentMethodDescriptor, ComponentDescriptor>
- childComponentsDeclaredByBuilderEntryPoints();
-
- private final Supplier<ImmutableMap<TypeElement, ComponentDescriptor>>
- childComponentsByBuilderType =
- Suppliers.memoize(
- () ->
- childComponents().stream()
- .filter(child -> child.creatorDescriptor().isPresent())
- .collect(
- toImmutableMap(
- child -> child.creatorDescriptor().get().typeElement(),
- child -> child)));
-
- /** Returns the child component with the given builder type. */
- final ComponentDescriptor getChildComponentWithBuilderType(TypeElement builderType) {
- return checkNotNull(
- childComponentsByBuilderType.get().get(builderType),
- "no child component found for builder type %s",
- builderType.getQualifiedName());
- }
-
- abstract ImmutableSet<ComponentMethodDescriptor> componentMethods();
-
- /** Returns the first component method associated with this binding request, if one exists. */
- Optional<ComponentMethodDescriptor> firstMatchingComponentMethod(BindingRequest request) {
- return componentMethods().stream()
- .filter(method -> doesComponentMethodMatch(method, request))
- .findFirst();
- }
-
- /** Returns true if the component method matches the binding request. */
- private static boolean doesComponentMethodMatch(
- ComponentMethodDescriptor componentMethod, BindingRequest request) {
- return componentMethod
- .dependencyRequest()
- .map(BindingRequest::bindingRequest)
- .filter(request::equals)
- .isPresent();
- }
-
- /** The entry point methods on the component type. Each has a {@link DependencyRequest}. */
- final ImmutableSet<ComponentMethodDescriptor> entryPointMethods() {
- return componentMethods()
- .stream()
- .filter(method -> method.dependencyRequest().isPresent())
- .collect(toImmutableSet());
- }
-
- // TODO(gak): Consider making this non-optional and revising the
- // interaction between the spec & generation
- /** Returns a descriptor for the creator type for this component type, if the user defined one. */
- abstract Optional<ComponentCreatorDescriptor> creatorDescriptor();
-
- /**
- * Returns {@code true} for components that have a creator, either because the user {@linkplain
- * #creatorDescriptor() specified one} or because it's a top-level component with an implicit
- * builder.
- */
- final boolean hasCreator() {
- return !isSubcomponent() || creatorDescriptor().isPresent();
- }
-
- /**
- * Returns the {@link CancellationPolicy} for this component, or an empty optional if either the
- * component is not a production component or no {@code CancellationPolicy} annotation is present.
- */
- final Optional<CancellationPolicy> cancellationPolicy() {
- return isProduction()
- ? Optional.ofNullable(typeElement().getAnnotation(CancellationPolicy.class))
- : Optional.empty();
- }
-
- @Memoized
- @Override
- public int hashCode() {
- // TODO(b/122962745): Only use typeElement().hashCode()
- return Objects.hash(typeElement(), annotation());
- }
-
- // TODO(ronshapiro): simplify the equality semantics
- @Override
- public abstract boolean equals(Object obj);
-
- /** A component method. */
- @AutoValue
- abstract static class ComponentMethodDescriptor {
- /** The method itself. Note that this may be declared on a supertype of the component. */
- abstract ExecutableElement methodElement();
-
- /**
- * The dependency request for production, provision, and subcomponent creator methods. Absent
- * for subcomponent factory methods.
- */
- abstract Optional<DependencyRequest> dependencyRequest();
-
- /** The subcomponent for subcomponent factory methods and subcomponent creator methods. */
- abstract Optional<ComponentDescriptor> subcomponent();
-
- /**
- * Returns the return type of {@link #methodElement()} as resolved in the {@link
- * ComponentDescriptor#typeElement() component type}. If there are no type variables in the
- * return type, this is the equivalent of {@code methodElement().getReturnType()}.
- */
- TypeMirror resolvedReturnType(DaggerTypes types) {
- checkState(dependencyRequest().isPresent());
-
- TypeMirror returnType = methodElement().getReturnType();
- if (returnType.getKind().isPrimitive() || returnType.getKind().equals(VOID)) {
- return returnType;
- }
- return BindingRequest.bindingRequest(dependencyRequest().get())
- .requestedType(dependencyRequest().get().key().type(), types);
- }
-
- /** A {@link ComponentMethodDescriptor}builder for a method. */
- static Builder builder(ExecutableElement method) {
- return new AutoValue_ComponentDescriptor_ComponentMethodDescriptor.Builder()
- .methodElement(method);
- }
-
- /** A builder of {@link ComponentMethodDescriptor}s. */
- @AutoValue.Builder
- @CanIgnoreReturnValue
- interface Builder {
- /** @see ComponentMethodDescriptor#methodElement() */
- Builder methodElement(ExecutableElement methodElement);
-
- /** @see ComponentMethodDescriptor#dependencyRequest() */
- Builder dependencyRequest(DependencyRequest dependencyRequest);
-
- /** @see ComponentMethodDescriptor#subcomponent() */
- Builder subcomponent(ComponentDescriptor subcomponent);
-
- /** Builds the descriptor. */
- @CheckReturnValue
- ComponentMethodDescriptor build();
- }
- }
-
- /** No-argument methods defined on {@link Object} that are ignored for contribution. */
- private static final ImmutableSet<String> NON_CONTRIBUTING_OBJECT_METHOD_NAMES =
- ImmutableSet.of("toString", "hashCode", "clone", "getClass");
-
- /**
- * Returns {@code true} if a method could be a component entry point but not a members-injection
- * method.
- */
- static boolean isComponentContributionMethod(DaggerElements elements, ExecutableElement method) {
- return method.getParameters().isEmpty()
- && !method.getReturnType().getKind().equals(VOID)
- && !elements.getTypeElement(Object.class).equals(method.getEnclosingElement())
- && !NON_CONTRIBUTING_OBJECT_METHOD_NAMES.contains(method.getSimpleName().toString());
- }
-
- /** Returns {@code true} if a method could be a component production entry point. */
- static boolean isComponentProductionMethod(DaggerElements elements, ExecutableElement method) {
- return isComponentContributionMethod(elements, method) && isFutureType(method.getReturnType());
- }
-}
diff --git a/java/dagger/internal/codegen/ComponentDescriptorFactory.java b/java/dagger/internal/codegen/ComponentDescriptorFactory.java
deleted file mode 100644
index 7d87eac..0000000
--- a/java/dagger/internal/codegen/ComponentDescriptorFactory.java
+++ /dev/null
@@ -1,268 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreElements.asType;
-import static com.google.auto.common.MoreTypes.asTypeElement;
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static dagger.internal.codegen.ComponentAnnotation.subcomponentAnnotation;
-import static dagger.internal.codegen.ComponentCreatorAnnotation.creatorAnnotationsFor;
-import static dagger.internal.codegen.ComponentDescriptor.isComponentContributionMethod;
-import static dagger.internal.codegen.ConfigurationAnnotations.enclosedAnnotatedTypes;
-import static dagger.internal.codegen.ConfigurationAnnotations.isSubcomponentCreator;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.internal.codegen.InjectionAnnotations.getQualifier;
-import static dagger.internal.codegen.Scopes.productionScope;
-import static dagger.internal.codegen.Scopes.scopesOf;
-import static javax.lang.model.type.TypeKind.DECLARED;
-import static javax.lang.model.type.TypeKind.VOID;
-import static javax.lang.model.util.ElementFilter.methodsIn;
-
-import com.google.auto.common.MoreTypes;
-import com.google.common.collect.ImmutableBiMap;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import dagger.internal.codegen.ComponentDescriptor.ComponentMethodDescriptor;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.Scope;
-import java.util.Optional;
-import java.util.function.Function;
-import javax.inject.Inject;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.ExecutableType;
-import javax.lang.model.type.TypeMirror;
-
-/** A factory for {@link ComponentDescriptor}s. */
-final class ComponentDescriptorFactory {
- private final DaggerElements elements;
- private final DaggerTypes types;
- private final DependencyRequestFactory dependencyRequestFactory;
- private final ModuleDescriptor.Factory moduleDescriptorFactory;
-
- @Inject
- ComponentDescriptorFactory(
- DaggerElements elements,
- DaggerTypes types,
- DependencyRequestFactory dependencyRequestFactory,
- ModuleDescriptor.Factory moduleDescriptorFactory) {
- this.elements = elements;
- this.types = types;
- this.dependencyRequestFactory = dependencyRequestFactory;
- this.moduleDescriptorFactory = moduleDescriptorFactory;
- }
-
- /** Returns a descriptor for a root component type. */
- ComponentDescriptor rootComponentDescriptor(TypeElement typeElement) {
- return create(
- typeElement,
- checkAnnotation(
- typeElement,
- ComponentAnnotation::rootComponentAnnotation,
- "must have a component annotation"));
- }
-
- /** Returns a descriptor for a subcomponent type. */
- ComponentDescriptor subcomponentDescriptor(TypeElement typeElement) {
- return create(
- typeElement,
- checkAnnotation(
- typeElement,
- ComponentAnnotation::subcomponentAnnotation,
- "must have a subcomponent annotation"));
- }
-
- /**
- * Returns a descriptor for a fictional component based on a module type in order to validate its
- * bindings.
- */
- ComponentDescriptor moduleComponentDescriptor(TypeElement typeElement) {
- return create(
- typeElement,
- ComponentAnnotation.fromModuleAnnotation(
- checkAnnotation(
- typeElement, ModuleAnnotation::moduleAnnotation, "must have a module annotation")));
- }
-
- private static <A> A checkAnnotation(
- TypeElement typeElement,
- Function<TypeElement, Optional<A>> annotationFunction,
- String message) {
- return annotationFunction
- .apply(typeElement)
- .orElseThrow(() -> new IllegalArgumentException(typeElement + " " + message));
- }
-
- private ComponentDescriptor create(
- TypeElement typeElement, ComponentAnnotation componentAnnotation) {
- ImmutableSet<ComponentRequirement> componentDependencies =
- componentAnnotation.dependencyTypes().stream()
- .map(ComponentRequirement::forDependency)
- .collect(toImmutableSet());
-
- ImmutableMap.Builder<ExecutableElement, ComponentRequirement> dependenciesByDependencyMethod =
- ImmutableMap.builder();
-
- for (ComponentRequirement componentDependency : componentDependencies) {
- for (ExecutableElement dependencyMethod :
- methodsIn(elements.getAllMembers(componentDependency.typeElement()))) {
- if (isComponentContributionMethod(elements, dependencyMethod)) {
- dependenciesByDependencyMethod.put(dependencyMethod, componentDependency);
- }
- }
- }
-
- // Start with the component's modules. For fictional components built from a module, start with
- // that module.
- ImmutableSet<TypeElement> modules =
- componentAnnotation.isRealComponent()
- ? componentAnnotation.modules()
- : ImmutableSet.of(typeElement);
-
- ImmutableSet<ModuleDescriptor> transitiveModules =
- moduleDescriptorFactory.transitiveModules(modules);
-
- ImmutableSet.Builder<ComponentDescriptor> subcomponentsFromModules = ImmutableSet.builder();
- for (ModuleDescriptor module : transitiveModules) {
- for (SubcomponentDeclaration subcomponentDeclaration : module.subcomponentDeclarations()) {
- TypeElement subcomponent = subcomponentDeclaration.subcomponentType();
- subcomponentsFromModules.add(subcomponentDescriptor(subcomponent));
- }
- }
-
- ImmutableSet.Builder<ComponentMethodDescriptor> componentMethodsBuilder =
- ImmutableSet.builder();
- ImmutableBiMap.Builder<ComponentMethodDescriptor, ComponentDescriptor>
- subcomponentsByFactoryMethod = ImmutableBiMap.builder();
- ImmutableBiMap.Builder<ComponentMethodDescriptor, ComponentDescriptor>
- subcomponentsByBuilderMethod = ImmutableBiMap.builder();
- if (componentAnnotation.isRealComponent()) {
- ImmutableSet<ExecutableElement> unimplementedMethods =
- elements.getUnimplementedMethods(typeElement);
- for (ExecutableElement componentMethod : unimplementedMethods) {
- ComponentMethodDescriptor componentMethodDescriptor =
- getDescriptorForComponentMethod(typeElement, componentAnnotation, componentMethod);
- componentMethodsBuilder.add(componentMethodDescriptor);
- componentMethodDescriptor
- .subcomponent()
- .ifPresent(
- subcomponent -> {
- // If the dependency request is present, that means the method returns the
- // subcomponent factory.
- if (componentMethodDescriptor.dependencyRequest().isPresent()) {
- subcomponentsByBuilderMethod.put(componentMethodDescriptor, subcomponent);
- } else {
- subcomponentsByFactoryMethod.put(componentMethodDescriptor, subcomponent);
- }
- });
- }
- }
-
- // Validation should have ensured that this set will have at most one element.
- ImmutableSet<DeclaredType> enclosedCreators =
- creatorAnnotationsFor(componentAnnotation).stream()
- .flatMap(
- creatorAnnotation ->
- enclosedAnnotatedTypes(typeElement, creatorAnnotation).stream())
- .collect(toImmutableSet());
- Optional<ComponentCreatorDescriptor> creatorDescriptor =
- enclosedCreators.isEmpty()
- ? Optional.empty()
- : Optional.of(
- ComponentCreatorDescriptor.create(
- getOnlyElement(enclosedCreators), elements, types, dependencyRequestFactory));
-
- ImmutableSet<Scope> scopes = scopesOf(typeElement);
- if (componentAnnotation.isProduction()) {
- scopes = ImmutableSet.<Scope>builder().addAll(scopes).add(productionScope(elements)).build();
- }
-
- return new AutoValue_ComponentDescriptor(
- componentAnnotation,
- typeElement,
- componentDependencies,
- transitiveModules,
- dependenciesByDependencyMethod.build(),
- scopes,
- subcomponentsFromModules.build(),
- subcomponentsByFactoryMethod.build(),
- subcomponentsByBuilderMethod.build(),
- componentMethodsBuilder.build(),
- creatorDescriptor);
- }
-
- private ComponentMethodDescriptor getDescriptorForComponentMethod(
- TypeElement componentElement,
- ComponentAnnotation componentAnnotation,
- ExecutableElement componentMethod) {
- ComponentMethodDescriptor.Builder descriptor =
- ComponentMethodDescriptor.builder(componentMethod);
-
- ExecutableType resolvedComponentMethod =
- MoreTypes.asExecutable(
- types.asMemberOf(MoreTypes.asDeclared(componentElement.asType()), componentMethod));
- TypeMirror returnType = resolvedComponentMethod.getReturnType();
- if (returnType.getKind().equals(DECLARED) && !getQualifier(componentMethod).isPresent()) {
- TypeElement returnTypeElement = asTypeElement(returnType);
- if (subcomponentAnnotation(returnTypeElement).isPresent()) {
- // It's a subcomponent factory method. There is no dependency request, and there could be
- // any number of parameters. Just return the descriptor.
- return descriptor.subcomponent(subcomponentDescriptor(returnTypeElement)).build();
- }
- if (isSubcomponentCreator(returnTypeElement)) {
- descriptor.subcomponent(
- subcomponentDescriptor(asType(returnTypeElement.getEnclosingElement())));
- }
- }
-
- switch (componentMethod.getParameters().size()) {
- case 0:
- checkArgument(
- !returnType.getKind().equals(VOID),
- "component method cannot be void: %s",
- componentMethod);
- descriptor.dependencyRequest(
- componentAnnotation.isProduction()
- ? dependencyRequestFactory.forComponentProductionMethod(
- componentMethod, resolvedComponentMethod)
- : dependencyRequestFactory.forComponentProvisionMethod(
- componentMethod, resolvedComponentMethod));
- break;
-
- case 1:
- checkArgument(
- returnType.getKind().equals(VOID)
- || MoreTypes.equivalence()
- .equivalent(returnType, resolvedComponentMethod.getParameterTypes().get(0)),
- "members injection method must return void or parameter type: %s",
- componentMethod);
- descriptor.dependencyRequest(
- dependencyRequestFactory.forComponentMembersInjectionMethod(
- componentMethod, resolvedComponentMethod));
- break;
-
- default:
- throw new IllegalArgumentException(
- "component method has too many parameters: " + componentMethod);
- }
-
- return descriptor.build();
- }
-}
diff --git a/java/dagger/internal/codegen/ComponentDescriptorValidator.java b/java/dagger/internal/codegen/ComponentDescriptorValidator.java
deleted file mode 100644
index 8f85b3a..0000000
--- a/java/dagger/internal/codegen/ComponentDescriptorValidator.java
+++ /dev/null
@@ -1,484 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreTypes.asDeclared;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.base.Predicates.in;
-import static com.google.common.collect.Collections2.transform;
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static dagger.internal.codegen.ComponentAnnotation.rootComponentAnnotation;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSetMultimap;
-import static dagger.internal.codegen.DiagnosticFormatting.stripCommonTypePrefixes;
-import static dagger.internal.codegen.Formatter.INDENT;
-import static dagger.internal.codegen.Scopes.getReadableSource;
-import static dagger.internal.codegen.Scopes.scopesOf;
-import static dagger.internal.codegen.Scopes.singletonScope;
-import static dagger.internal.codegen.Util.reentrantComputeIfAbsent;
-import static java.util.stream.Collectors.joining;
-import static java.util.stream.Collectors.toList;
-import static javax.tools.Diagnostic.Kind.ERROR;
-
-import com.google.auto.common.MoreElements;
-import com.google.auto.common.MoreTypes;
-import com.google.common.base.Equivalence.Wrapper;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableSetMultimap;
-import com.google.common.collect.Multimaps;
-import com.google.common.collect.Sets;
-import dagger.internal.codegen.ComponentRequirement.NullPolicy;
-import dagger.internal.codegen.ErrorMessages.ComponentCreatorMessages;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.Scope;
-import java.util.ArrayDeque;
-import java.util.Collection;
-import java.util.Deque;
-import java.util.LinkedHashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Optional;
-import java.util.Set;
-import java.util.StringJoiner;
-import javax.inject.Inject;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.Modifier;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.element.VariableElement;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.ExecutableType;
-import javax.lang.model.type.TypeMirror;
-import javax.tools.Diagnostic;
-
-/**
- * Reports errors in the component hierarchy.
- *
- * <ul>
- * <li>Validates scope hierarchy of component dependencies and subcomponents.
- * <li>Reports errors if there are component dependency cycles.
- * <li>Reports errors if any abstract modules have non-abstract instance binding methods.
- * <li>Validates component creator types.
- * </ul>
- */
-// TODO(dpb): Combine with ComponentHierarchyValidator.
-final class ComponentDescriptorValidator {
-
- private final DaggerElements elements;
- private final DaggerTypes types;
- private final CompilerOptions compilerOptions;
- private final MethodSignatureFormatter methodSignatureFormatter;
- private final ComponentHierarchyValidator componentHierarchyValidator;
-
- @Inject
- ComponentDescriptorValidator(
- DaggerElements elements,
- DaggerTypes types,
- CompilerOptions compilerOptions,
- MethodSignatureFormatter methodSignatureFormatter,
- ComponentHierarchyValidator componentHierarchyValidator) {
- this.elements = elements;
- this.types = types;
- this.compilerOptions = compilerOptions;
- this.methodSignatureFormatter = methodSignatureFormatter;
- this.componentHierarchyValidator = componentHierarchyValidator;
- }
-
- ValidationReport<TypeElement> validate(ComponentDescriptor component) {
- ComponentValidation validation = new ComponentValidation(component);
- validation.visitComponent(component);
- validation.report(component).addSubreport(componentHierarchyValidator.validate(component));
- return validation.buildReport();
- }
-
- private final class ComponentValidation {
- final ComponentDescriptor rootComponent;
- final Map<ComponentDescriptor, ValidationReport.Builder<TypeElement>> reports =
- new LinkedHashMap<>();
-
- ComponentValidation(ComponentDescriptor rootComponent) {
- this.rootComponent = checkNotNull(rootComponent);
- }
-
- /** Returns a report that contains all validation messages found during traversal. */
- ValidationReport<TypeElement> buildReport() {
- ValidationReport.Builder<TypeElement> report =
- ValidationReport.about(rootComponent.typeElement());
- reports.values().forEach(subreport -> report.addSubreport(subreport.build()));
- return report.build();
- }
-
- /** Returns the report builder for a (sub)component. */
- private ValidationReport.Builder<TypeElement> report(ComponentDescriptor component) {
- return reentrantComputeIfAbsent(
- reports, component, descriptor -> ValidationReport.about(descriptor.typeElement()));
- }
-
- private void reportComponentItem(
- Diagnostic.Kind kind, ComponentDescriptor component, String message) {
- report(component)
- .addItem(message, kind, component.typeElement(), component.annotation().annotation());
- }
-
- private void reportComponentError(ComponentDescriptor component, String error) {
- reportComponentItem(ERROR, component, error);
- }
-
- void visitComponent(ComponentDescriptor component) {
- validateDependencyScopes(component);
- validateComponentDependencyHierarchy(component);
- validateModules(component);
- validateCreators(component);
- component.childComponents().forEach(this::visitComponent);
- }
-
- /** Validates that component dependencies do not form a cycle. */
- private void validateComponentDependencyHierarchy(ComponentDescriptor component) {
- validateComponentDependencyHierarchy(component, component.typeElement(), new ArrayDeque<>());
- }
-
- /** Recursive method to validate that component dependencies do not form a cycle. */
- private void validateComponentDependencyHierarchy(
- ComponentDescriptor component, TypeElement dependency, Deque<TypeElement> dependencyStack) {
- if (dependencyStack.contains(dependency)) {
- // Current component has already appeared in the component chain.
- StringBuilder message = new StringBuilder();
- message.append(component.typeElement().getQualifiedName());
- message.append(" contains a cycle in its component dependencies:\n");
- dependencyStack.push(dependency);
- appendIndentedComponentsList(message, dependencyStack);
- dependencyStack.pop();
- reportComponentItem(
- compilerOptions.scopeCycleValidationType().diagnosticKind().get(),
- component,
- message.toString());
- } else {
- rootComponentAnnotation(dependency)
- .ifPresent(
- componentAnnotation -> {
- dependencyStack.push(dependency);
-
- for (TypeElement nextDependency : componentAnnotation.dependencies()) {
- validateComponentDependencyHierarchy(
- component, nextDependency, dependencyStack);
- }
-
- dependencyStack.pop();
- });
- }
- }
-
- /**
- * Validates that among the dependencies are at most one scoped dependency, that there are no
- * cycles within the scoping chain, and that singleton components have no scoped dependencies.
- */
- private void validateDependencyScopes(ComponentDescriptor component) {
- ImmutableSet<Scope> scopes = component.scopes();
- ImmutableSet<TypeElement> scopedDependencies =
- scopedTypesIn(
- component
- .dependencies()
- .stream()
- .map(ComponentRequirement::typeElement)
- .collect(toImmutableSet()));
- if (!scopes.isEmpty()) {
- Scope singletonScope = singletonScope(elements);
- // Dagger 1.x scope compatibility requires this be suppress-able.
- if (compilerOptions.scopeCycleValidationType().diagnosticKind().isPresent()
- && scopes.contains(singletonScope)) {
- // Singleton is a special-case representing the longest lifetime, and therefore
- // @Singleton components may not depend on scoped components
- if (!scopedDependencies.isEmpty()) {
- StringBuilder message =
- new StringBuilder(
- "This @Singleton component cannot depend on scoped components:\n");
- appendIndentedComponentsList(message, scopedDependencies);
- reportComponentItem(
- compilerOptions.scopeCycleValidationType().diagnosticKind().get(),
- component,
- message.toString());
- }
- } else if (scopedDependencies.size() > 1) {
- // Scoped components may depend on at most one scoped component.
- StringBuilder message = new StringBuilder();
- for (Scope scope : scopes) {
- message.append(getReadableSource(scope)).append(' ');
- }
- message
- .append(component.typeElement().getQualifiedName())
- .append(" depends on more than one scoped component:\n");
- appendIndentedComponentsList(message, scopedDependencies);
- reportComponentError(component, message.toString());
- } else {
- // Dagger 1.x scope compatibility requires this be suppress-able.
- if (!compilerOptions.scopeCycleValidationType().equals(ValidationType.NONE)) {
- validateDependencyScopeHierarchy(
- component, component.typeElement(), new ArrayDeque<>(), new ArrayDeque<>());
- }
- }
- } else {
- // Scopeless components may not depend on scoped components.
- if (!scopedDependencies.isEmpty()) {
- StringBuilder message =
- new StringBuilder(component.typeElement().getQualifiedName())
- .append(" (unscoped) cannot depend on scoped components:\n");
- appendIndentedComponentsList(message, scopedDependencies);
- reportComponentError(component, message.toString());
- }
- }
- }
-
- private void validateModules(ComponentDescriptor component) {
- for (ModuleDescriptor module : component.modules()) {
- if (module.moduleElement().getModifiers().contains(Modifier.ABSTRACT)) {
- for (ContributionBinding binding : module.bindings()) {
- if (binding.requiresModuleInstance()) {
- report(component).addError(abstractModuleHasInstanceBindingMethodsError(module));
- break;
- }
- }
- }
- }
- }
-
- private String abstractModuleHasInstanceBindingMethodsError(ModuleDescriptor module) {
- String methodAnnotations;
- switch (module.kind()) {
- case MODULE:
- methodAnnotations = "@Provides";
- break;
- case PRODUCER_MODULE:
- methodAnnotations = "@Provides or @Produces";
- break;
- default:
- throw new AssertionError(module.kind());
- }
- return String.format(
- "%s is abstract and has instance %s methods. Consider making the methods static or "
- + "including a non-abstract subclass of the module instead.",
- module.moduleElement(), methodAnnotations);
- }
-
- private void validateCreators(ComponentDescriptor component) {
- if (!component.creatorDescriptor().isPresent()) {
- // If no builder, nothing to validate.
- return;
- }
-
- ComponentCreatorDescriptor creator = component.creatorDescriptor().get();
- ComponentCreatorMessages messages = ErrorMessages.creatorMessagesFor(creator.annotation());
-
- // Requirements for modules and dependencies that the creator can set
- Set<ComponentRequirement> creatorModuleAndDependencyRequirements =
- creator.moduleAndDependencyRequirements();
- // Modules and dependencies the component requires
- Set<ComponentRequirement> componentModuleAndDependencyRequirements =
- component.dependenciesAndConcreteModules();
-
- // Requirements that the creator can set that don't match any requirements that the component
- // actually has.
- Set<ComponentRequirement> inapplicableRequirementsOnCreator =
- Sets.difference(
- creatorModuleAndDependencyRequirements, componentModuleAndDependencyRequirements);
-
- DeclaredType container = asDeclared(creator.typeElement().asType());
- if (!inapplicableRequirementsOnCreator.isEmpty()) {
- Collection<Element> excessElements =
- Multimaps.filterKeys(
- creator.unvalidatedRequirementElements(), in(inapplicableRequirementsOnCreator))
- .values();
- String formatted =
- excessElements.stream()
- .map(element -> formatElement(element, container))
- .collect(joining(", ", "[", "]"));
- report(component)
- .addError(String.format(messages.extraSetters(), formatted), creator.typeElement());
- }
-
- // Component requirements that the creator must be able to set
- Set<ComponentRequirement> mustBePassed =
- Sets.filter(
- componentModuleAndDependencyRequirements,
- input -> input.nullPolicy(elements, types).equals(NullPolicy.THROW));
- // Component requirements that the creator must be able to set, but can't
- Set<ComponentRequirement> missingRequirements =
- Sets.difference(mustBePassed, creatorModuleAndDependencyRequirements);
-
- if (!missingRequirements.isEmpty()) {
- report(component)
- .addError(
- String.format(
- messages.missingSetters(),
- missingRequirements.stream().map(ComponentRequirement::type).collect(toList())),
- creator.typeElement());
- }
-
- // Validate that declared creator requirements (modules, dependencies) have unique types.
- ImmutableSetMultimap<Wrapper<TypeMirror>, Element> declaredRequirementsByType =
- Multimaps.filterKeys(
- creator.unvalidatedRequirementElements(),
- creatorModuleAndDependencyRequirements::contains)
- .entries().stream()
- .collect(
- toImmutableSetMultimap(entry -> entry.getKey().wrappedType(), Entry::getValue));
- declaredRequirementsByType
- .asMap()
- .forEach(
- (typeWrapper, elementsForType) -> {
- if (elementsForType.size() > 1) {
- TypeMirror type = typeWrapper.get();
- // TODO(cgdecker): Attach this error message to the factory method rather than
- // the component type if the elements are factory method parameters AND the
- // factory method is defined by the factory type itself and not by a supertype.
- report(component)
- .addError(
- String.format(
- messages.multipleSettersForModuleOrDependencyType(),
- type,
- transform(
- elementsForType, element -> formatElement(element, container))),
- creator.typeElement());
- }
- });
-
- // TODO(cgdecker): Duplicate binding validation should handle the case of multiple elements
- // that set the same bound-instance Key, but validating that here would make it fail faster
- // for subcomponents.
- }
-
- private String formatElement(Element element, DeclaredType container) {
- // TODO(cgdecker): Extract some or all of this to another class?
- // But note that it does different formatting for parameters than
- // DaggerElements.elementToString(Element).
- switch (element.getKind()) {
- case METHOD:
- return methodSignatureFormatter.format(
- MoreElements.asExecutable(element), Optional.of(container));
- case PARAMETER:
- return formatParameter(MoreElements.asVariable(element), container);
- default:
- // This method shouldn't be called with any other type of element.
- throw new AssertionError();
- }
- }
-
- private String formatParameter(VariableElement parameter, DeclaredType container) {
- // TODO(cgdecker): Possibly leave the type (and annotations?) off of the parameters here and
- // just use their names, since the type will be redundant in the context of the error message.
- StringJoiner joiner = new StringJoiner(" ");
- parameter.getAnnotationMirrors().stream().map(Object::toString).forEach(joiner::add);
- TypeMirror parameterType = resolveParameterType(parameter, container);
- return joiner
- .add(stripCommonTypePrefixes(parameterType.toString()))
- .add(parameter.getSimpleName())
- .toString();
- }
-
- private TypeMirror resolveParameterType(VariableElement parameter, DeclaredType container) {
- ExecutableElement method =
- MoreElements.asExecutable(parameter.getEnclosingElement());
- int parameterIndex = method.getParameters().indexOf(parameter);
-
- ExecutableType methodType = MoreTypes.asExecutable(types.asMemberOf(container, method));
- return methodType.getParameterTypes().get(parameterIndex);
- }
-
- /**
- * Validates that scopes do not participate in a scoping cycle - that is to say, scoped
- * components are in a hierarchical relationship terminating with Singleton.
- *
- * <p>As a side-effect, this means scoped components cannot have a dependency cycle between
- * themselves, since a component's presence within its own dependency path implies a cyclical
- * relationship between scopes. However, cycles in component dependencies are explicitly checked
- * in {@link #validateComponentDependencyHierarchy(ComponentDescriptor)}.
- */
- private void validateDependencyScopeHierarchy(
- ComponentDescriptor component,
- TypeElement dependency,
- Deque<ImmutableSet<Scope>> scopeStack,
- Deque<TypeElement> scopedDependencyStack) {
- ImmutableSet<Scope> scopes = scopesOf(dependency);
- if (stackOverlaps(scopeStack, scopes)) {
- scopedDependencyStack.push(dependency);
- // Current scope has already appeared in the component chain.
- StringBuilder message = new StringBuilder();
- message.append(component.typeElement().getQualifiedName());
- message.append(" depends on scoped components in a non-hierarchical scope ordering:\n");
- appendIndentedComponentsList(message, scopedDependencyStack);
- if (compilerOptions.scopeCycleValidationType().diagnosticKind().isPresent()) {
- reportComponentItem(
- compilerOptions.scopeCycleValidationType().diagnosticKind().get(),
- component,
- message.toString());
- }
- scopedDependencyStack.pop();
- } else {
- // TODO(beder): transitively check scopes of production components too.
- rootComponentAnnotation(dependency)
- .filter(componentAnnotation -> !componentAnnotation.isProduction())
- .ifPresent(
- componentAnnotation -> {
- ImmutableSet<TypeElement> scopedDependencies =
- scopedTypesIn(componentAnnotation.dependencies());
- if (scopedDependencies.size() == 1) {
- // empty can be ignored (base-case), and > 1 is a separately-reported error.
- scopeStack.push(scopes);
- scopedDependencyStack.push(dependency);
- validateDependencyScopeHierarchy(
- component,
- getOnlyElement(scopedDependencies),
- scopeStack,
- scopedDependencyStack);
- scopedDependencyStack.pop();
- scopeStack.pop();
- }
- }); // else: we skip component dependencies which are not components
- }
- }
-
- private <T> boolean stackOverlaps(Deque<ImmutableSet<T>> stack, ImmutableSet<T> set) {
- for (ImmutableSet<T> entry : stack) {
- if (!Sets.intersection(entry, set).isEmpty()) {
- return true;
- }
- }
- return false;
- }
-
- /** Appends and formats a list of indented component types (with their scope annotations). */
- private void appendIndentedComponentsList(StringBuilder message, Iterable<TypeElement> types) {
- for (TypeElement scopedComponent : types) {
- message.append(INDENT);
- for (Scope scope : scopesOf(scopedComponent)) {
- message.append(getReadableSource(scope)).append(' ');
- }
- message
- .append(stripCommonTypePrefixes(scopedComponent.getQualifiedName().toString()))
- .append('\n');
- }
- }
-
- /**
- * Returns a set of type elements containing only those found in the input set that have a
- * scoping annotation.
- */
- private ImmutableSet<TypeElement> scopedTypesIn(Collection<TypeElement> types) {
- return types.stream().filter(type -> !scopesOf(type).isEmpty()).collect(toImmutableSet());
- }
- }
-}
diff --git a/java/dagger/internal/codegen/ComponentGenerator.java b/java/dagger/internal/codegen/ComponentGenerator.java
deleted file mode 100644
index 330ec2d..0000000
--- a/java/dagger/internal/codegen/ComponentGenerator.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Verify.verify;
-import static dagger.internal.codegen.SourceFiles.classFileName;
-
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.TypeSpec;
-import dagger.Component;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import java.util.Optional;
-import javax.annotation.processing.Filer;
-import javax.inject.Inject;
-import javax.lang.model.SourceVersion;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.TypeElement;
-
-/**
- * Generates the implementation of the abstract types annotated with {@link Component}.
- */
-final class ComponentGenerator extends SourceFileGenerator<BindingGraph> {
- private final ComponentImplementationFactory componentImplementationFactory;
-
- @Inject
- ComponentGenerator(
- Filer filer,
- DaggerElements elements,
- SourceVersion sourceVersion,
- ComponentImplementationFactory componentImplementationFactory) {
- super(filer, elements, sourceVersion);
- this.componentImplementationFactory = componentImplementationFactory;
- }
-
- @Override
- ClassName nameGeneratedType(BindingGraph input) {
- return componentName(input.componentTypeElement());
- }
-
- static ClassName componentName(TypeElement componentDefinitionType) {
- ClassName componentName = ClassName.get(componentDefinitionType);
- return ClassName.get(componentName.packageName(), "Dagger" + classFileName(componentName));
- }
-
- @Override
- Element originatingElement(BindingGraph input) {
- return input.componentTypeElement();
- }
-
- @Override
- Optional<TypeSpec.Builder> write(ClassName componentName, BindingGraph bindingGraph) {
- ComponentImplementation componentImplementation =
- componentImplementationFactory.createComponentImplementation(bindingGraph);
- verify(componentImplementation.name().equals(componentName));
- return Optional.of(componentImplementation.generate());
- }
-}
diff --git a/java/dagger/internal/codegen/ComponentHierarchyValidator.java b/java/dagger/internal/codegen/ComponentHierarchyValidator.java
deleted file mode 100644
index d1e5333..0000000
--- a/java/dagger/internal/codegen/ComponentHierarchyValidator.java
+++ /dev/null
@@ -1,268 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Functions.constant;
-import static com.google.common.base.Predicates.and;
-import static com.google.common.base.Predicates.in;
-import static com.google.common.base.Predicates.not;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.internal.codegen.Scopes.getReadableSource;
-import static dagger.internal.codegen.Scopes.uniqueScopeOf;
-
-import com.google.auto.common.MoreTypes;
-import com.google.common.base.Joiner;
-import com.google.common.base.Predicate;
-import com.google.common.collect.FluentIterable;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableSetMultimap;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.LinkedHashMultimap;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Multimaps;
-import com.google.common.collect.SetMultimap;
-import com.google.common.collect.Sets;
-import dagger.internal.codegen.ComponentDescriptor.ComponentMethodDescriptor;
-import dagger.model.Scope;
-import java.util.Collection;
-import java.util.Formatter;
-import java.util.Map;
-import javax.inject.Inject;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.element.VariableElement;
-
-/** Validates the relationships between parent components and subcomponents. */
-final class ComponentHierarchyValidator {
- private static final Joiner COMMA_SEPARATED_JOINER = Joiner.on(", ");
- private final CompilerOptions compilerOptions;
-
- @Inject
- ComponentHierarchyValidator(CompilerOptions compilerOptions) {
- this.compilerOptions = compilerOptions;
- }
-
- ValidationReport<TypeElement> validate(ComponentDescriptor componentDescriptor) {
- ValidationReport.Builder<TypeElement> report =
- ValidationReport.about(componentDescriptor.typeElement());
- validateSubcomponentMethods(
- report,
- componentDescriptor,
- Maps.toMap(componentDescriptor.moduleTypes(), constant(componentDescriptor.typeElement())));
- validateRepeatedScopedDeclarations(report, componentDescriptor, LinkedHashMultimap.create());
-
- if (compilerOptions.scopeCycleValidationType().diagnosticKind().isPresent()) {
- validateScopeHierarchy(
- report, componentDescriptor, LinkedHashMultimap.<ComponentDescriptor, Scope>create());
- }
- validateProductionModuleUniqueness(report, componentDescriptor, LinkedHashMultimap.create());
- return report.build();
- }
-
- private void validateSubcomponentMethods(
- ValidationReport.Builder<?> report,
- ComponentDescriptor componentDescriptor,
- ImmutableMap<TypeElement, TypeElement> existingModuleToOwners) {
- componentDescriptor
- .childComponentsDeclaredByFactoryMethods()
- .forEach(
- (method, childComponent) -> {
- if (childComponent.hasCreator()) {
- report.addError(
- "Components may not have factory methods for subcomponents that define a "
- + "builder.",
- method.methodElement());
- } else {
- validateFactoryMethodParameters(report, method, existingModuleToOwners);
- }
-
- validateSubcomponentMethods(
- report,
- childComponent,
- new ImmutableMap.Builder<TypeElement, TypeElement>()
- .putAll(existingModuleToOwners)
- .putAll(
- Maps.toMap(
- Sets.difference(
- childComponent.moduleTypes(), existingModuleToOwners.keySet()),
- constant(childComponent.typeElement())))
- .build());
- });
- }
-
- private void validateFactoryMethodParameters(
- ValidationReport.Builder<?> report,
- ComponentMethodDescriptor subcomponentMethodDescriptor,
- ImmutableMap<TypeElement, TypeElement> existingModuleToOwners) {
- for (VariableElement factoryMethodParameter :
- subcomponentMethodDescriptor.methodElement().getParameters()) {
- TypeElement moduleType = MoreTypes.asTypeElement(factoryMethodParameter.asType());
- TypeElement originatingComponent = existingModuleToOwners.get(moduleType);
- if (originatingComponent != null) {
- /* Factory method tries to pass a module that is already present in the parent.
- * This is an error. */
- report.addError(
- String.format(
- "%s is present in %s. A subcomponent cannot use an instance of a "
- + "module that differs from its parent.",
- moduleType.getSimpleName(), originatingComponent.getQualifiedName()),
- factoryMethodParameter);
- }
- }
- }
-
- /**
- * Checks that components do not have any scopes that are also applied on any of their ancestors.
- */
- private void validateScopeHierarchy(
- ValidationReport.Builder<TypeElement> report,
- ComponentDescriptor subject,
- SetMultimap<ComponentDescriptor, Scope> scopesByComponent) {
- scopesByComponent.putAll(subject, subject.scopes());
-
- for (ComponentDescriptor childComponent : subject.childComponents()) {
- validateScopeHierarchy(report, childComponent, scopesByComponent);
- }
-
- scopesByComponent.removeAll(subject);
-
- Predicate<Scope> subjectScopes =
- subject.isProduction()
- // TODO(beder): validate that @ProductionScope is only applied on production components
- ? and(in(subject.scopes()), not(Scope::isProductionScope))
- : in(subject.scopes());
- SetMultimap<ComponentDescriptor, Scope> overlappingScopes =
- Multimaps.filterValues(scopesByComponent, subjectScopes);
- if (!overlappingScopes.isEmpty()) {
- StringBuilder error =
- new StringBuilder()
- .append(subject.typeElement().getQualifiedName())
- .append(" has conflicting scopes:");
- for (Map.Entry<ComponentDescriptor, Scope> entry : overlappingScopes.entries()) {
- Scope scope = entry.getValue();
- error
- .append("\n ")
- .append(entry.getKey().typeElement().getQualifiedName())
- .append(" also has ")
- .append(getReadableSource(scope));
- }
- report.addItem(
- error.toString(),
- compilerOptions.scopeCycleValidationType().diagnosticKind().get(),
- subject.typeElement());
- }
- }
-
- private void validateProductionModuleUniqueness(
- ValidationReport.Builder<TypeElement> report,
- ComponentDescriptor componentDescriptor,
- SetMultimap<ComponentDescriptor, ModuleDescriptor> producerModulesByComponent) {
- ImmutableSet<ModuleDescriptor> producerModules =
- componentDescriptor.modules().stream()
- .filter(module -> module.kind().equals(ModuleKind.PRODUCER_MODULE))
- .collect(toImmutableSet());
-
- producerModulesByComponent.putAll(componentDescriptor, producerModules);
- for (ComponentDescriptor childComponent : componentDescriptor.childComponents()) {
- validateProductionModuleUniqueness(report, childComponent, producerModulesByComponent);
- }
- producerModulesByComponent.removeAll(componentDescriptor);
-
- SetMultimap<ComponentDescriptor, ModuleDescriptor> repeatedModules =
- Multimaps.filterValues(producerModulesByComponent, producerModules::contains);
- if (repeatedModules.isEmpty()) {
- return;
- }
-
- StringBuilder error = new StringBuilder();
- Formatter formatter = new Formatter(error);
-
- formatter.format("%s repeats @ProducerModules:", componentDescriptor.typeElement());
-
- for (Map.Entry<ComponentDescriptor, Collection<ModuleDescriptor>> entry :
- repeatedModules.asMap().entrySet()) {
- formatter.format("\n %s also installs: ", entry.getKey().typeElement());
- COMMA_SEPARATED_JOINER
- .appendTo(error, Iterables.transform(entry.getValue(), m -> m.moduleElement()));
- }
-
- report.addError(error.toString());
- }
-
- private void validateRepeatedScopedDeclarations(
- ValidationReport.Builder<TypeElement> report,
- ComponentDescriptor component,
- // TODO(ronshapiro): optimize ModuleDescriptor.hashCode()/equals. Otherwise this could be
- // quite costly
- SetMultimap<ComponentDescriptor, ModuleDescriptor> modulesWithScopes) {
- ImmutableSet<ModuleDescriptor> modules =
- component.modules().stream().filter(this::hasScopedDeclarations).collect(toImmutableSet());
- modulesWithScopes.putAll(component, modules);
- for (ComponentDescriptor childComponent : component.childComponents()) {
- validateRepeatedScopedDeclarations(report, childComponent, modulesWithScopes);
- }
- modulesWithScopes.removeAll(component);
-
- SetMultimap<ComponentDescriptor, ModuleDescriptor> repeatedModules =
- Multimaps.filterValues(modulesWithScopes, modules::contains);
- if (repeatedModules.isEmpty()) {
- return;
- }
-
- report.addError(
- repeatedModulesWithScopeError(component, ImmutableSetMultimap.copyOf(repeatedModules)));
- }
-
- private boolean hasScopedDeclarations(ModuleDescriptor module) {
- return !moduleScopes(module).isEmpty();
- }
-
- private String repeatedModulesWithScopeError(
- ComponentDescriptor component,
- ImmutableSetMultimap<ComponentDescriptor, ModuleDescriptor> repeatedModules) {
- StringBuilder error =
- new StringBuilder()
- .append(component.typeElement().getQualifiedName())
- .append(" repeats modules with scoped bindings or declarations:");
-
- repeatedModules
- .asMap()
- .forEach(
- (conflictingComponent, conflictingModules) -> {
- error
- .append("\n - ")
- .append(conflictingComponent.typeElement().getQualifiedName())
- .append(" also includes:");
- for (ModuleDescriptor conflictingModule : conflictingModules) {
- error
- .append("\n - ")
- .append(conflictingModule.moduleElement().getQualifiedName())
- .append(" with scopes: ")
- .append(COMMA_SEPARATED_JOINER.join(moduleScopes(conflictingModule)));
- }
- });
- return error.toString();
- }
-
- private ImmutableSet<Scope> moduleScopes(ModuleDescriptor module) {
- return FluentIterable.concat(module.allBindingDeclarations())
- .transform(declaration -> uniqueScopeOf(declaration.bindingElement().get()))
- .filter(scope -> scope.isPresent() && !scope.get().isReusable())
- .transform(scope -> scope.get())
- .toSet();
- }
-}
diff --git a/java/dagger/internal/codegen/ComponentHjarProcessingStep.java b/java/dagger/internal/codegen/ComponentHjarProcessingStep.java
index 47857ca..260f65a 100644
--- a/java/dagger/internal/codegen/ComponentHjarProcessingStep.java
+++ b/java/dagger/internal/codegen/ComponentHjarProcessingStep.java
@@ -16,47 +16,27 @@
package dagger.internal.codegen;
-import static com.google.auto.common.MoreElements.isAnnotationPresent;
-import static com.google.common.base.CaseFormat.LOWER_CAMEL;
-import static com.google.common.base.CaseFormat.UPPER_CAMEL;
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.squareup.javapoet.MethodSpec.constructorBuilder;
-import static dagger.internal.codegen.ComponentAnnotation.rootComponentAnnotations;
-import static dagger.internal.codegen.ComponentCreatorKind.BUILDER;
-import static dagger.internal.codegen.ComponentGenerator.componentName;
-import static dagger.internal.codegen.javapoet.TypeSpecs.addSupertype;
-import static javax.lang.model.element.Modifier.ABSTRACT;
-import static javax.lang.model.element.Modifier.FINAL;
-import static javax.lang.model.element.Modifier.PRIVATE;
-import static javax.lang.model.element.Modifier.PUBLIC;
-import static javax.lang.model.element.Modifier.STATIC;
+import static com.google.auto.common.MoreElements.asType;
+import static com.google.common.collect.Sets.union;
+import static dagger.internal.codegen.base.ComponentAnnotation.rootComponentAnnotations;
+import static dagger.internal.codegen.binding.ComponentCreatorAnnotation.rootComponentCreatorAnnotations;
+import static java.util.Collections.disjoint;
import com.google.auto.common.MoreElements;
-import com.google.auto.common.MoreTypes;
-import com.google.common.base.Ascii;
import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Sets;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.MethodSpec;
-import com.squareup.javapoet.TypeName;
-import com.squareup.javapoet.TypeSpec;
-import dagger.BindsInstance;
-import dagger.internal.codegen.ComponentValidator.ComponentValidationReport;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.producers.internal.CancellationListener;
+import dagger.internal.codegen.base.SourceFileGenerator;
+import dagger.internal.codegen.binding.BindingGraph;
+import dagger.internal.codegen.binding.ComponentDescriptor;
+import dagger.internal.codegen.binding.ComponentDescriptorFactory;
+import dagger.internal.codegen.validation.ComponentCreatorValidator;
+import dagger.internal.codegen.validation.ComponentValidator;
+import dagger.internal.codegen.validation.TypeCheckingProcessingStep;
+import dagger.internal.codegen.validation.ValidationReport;
import java.lang.annotation.Annotation;
-import java.util.Optional;
import java.util.Set;
-import java.util.stream.Stream;
-import javax.annotation.processing.Filer;
import javax.annotation.processing.Messager;
import javax.inject.Inject;
-import javax.lang.model.SourceVersion;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.DeclaredType;
/**
* A processing step that emits the API of a generated component, without any actual implementation.
@@ -72,228 +52,57 @@
* normal step. Method bodies are omitted as Turbine ignores them entirely.
*/
final class ComponentHjarProcessingStep extends TypeCheckingProcessingStep<TypeElement> {
- private final SourceVersion sourceVersion;
- private final DaggerElements elements;
- private final DaggerTypes types;
- private final Filer filer;
private final Messager messager;
private final ComponentValidator componentValidator;
+ private final ComponentCreatorValidator creatorValidator;
private final ComponentDescriptorFactory componentDescriptorFactory;
+ private final SourceFileGenerator<ComponentDescriptor> componentGenerator;
@Inject
ComponentHjarProcessingStep(
- SourceVersion sourceVersion,
- DaggerElements elements,
- DaggerTypes types,
- Filer filer,
Messager messager,
ComponentValidator componentValidator,
- ComponentDescriptorFactory componentDescriptorFactory) {
+ ComponentCreatorValidator creatorValidator,
+ ComponentDescriptorFactory componentDescriptorFactory,
+ SourceFileGenerator<ComponentDescriptor> componentGenerator) {
super(MoreElements::asType);
- this.sourceVersion = sourceVersion;
- this.elements = elements;
- this.types = types;
- this.filer = filer;
this.messager = messager;
this.componentValidator = componentValidator;
+ this.creatorValidator = creatorValidator;
this.componentDescriptorFactory = componentDescriptorFactory;
+ this.componentGenerator = componentGenerator;
}
@Override
public Set<Class<? extends Annotation>> annotations() {
- return rootComponentAnnotations();
+ return union(rootComponentAnnotations(), rootComponentCreatorAnnotations());
}
+ // TODO(ronshapiro): Validation might not even be necessary. We should measure it and figure out
+ // if it's worth seeing if removing it will still work. We could potentially add a new catch
+ // clause for any exception that's not TypeNotPresentException and ignore the component entirely
+ // in that case.
@Override
protected void process(
- TypeElement componentTypeElement, ImmutableSet<Class<? extends Annotation>> annotations) {
- // TODO(ronshapiro): component validation might not be necessary. We should measure it and
- // figure out if it's worth seeing if removing it will still work. We could potentially add a
- // new catch clause for any exception that's not TypeNotPresentException and ignore the
- // component entirely in that case.
- ComponentValidationReport validationReport =
- componentValidator.validate(componentTypeElement, ImmutableSet.of(), ImmutableSet.of());
- validationReport.report().printMessagesTo(messager);
- if (validationReport.report().isClean()) {
- new EmptyComponentGenerator(filer, elements, sourceVersion)
- .generate(
- componentDescriptorFactory.rootComponentDescriptor(componentTypeElement), messager);
+ TypeElement element, ImmutableSet<Class<? extends Annotation>> annotations) {
+ if (!disjoint(annotations, rootComponentAnnotations())) {
+ processRootComponent(element);
+ }
+ if (!disjoint(annotations, rootComponentCreatorAnnotations())) {
+ processRootCreator(element);
}
}
- private final class EmptyComponentGenerator extends SourceFileGenerator<ComponentDescriptor> {
- EmptyComponentGenerator(Filer filer, DaggerElements elements, SourceVersion sourceVersion) {
- super(filer, elements, sourceVersion);
- }
-
- @Override
- ClassName nameGeneratedType(ComponentDescriptor input) {
- return componentName(input.typeElement());
- }
-
- @Override
- Element originatingElement(ComponentDescriptor input) {
- return input.typeElement();
- }
-
- @Override
- Optional<TypeSpec.Builder> write(
- ClassName generatedTypeName, ComponentDescriptor componentDescriptor) {
- TypeSpec.Builder generatedComponent =
- TypeSpec.classBuilder(generatedTypeName)
- .addModifiers(FINAL)
- .addMethod(privateConstructor());
- if (componentDescriptor.typeElement().getModifiers().contains(PUBLIC)) {
- generatedComponent.addModifiers(PUBLIC);
- }
-
- TypeElement componentElement = componentDescriptor.typeElement();
- addSupertype(generatedComponent, componentElement);
-
- TypeName builderMethodReturnType;
- ComponentCreatorKind creatorKind;
- boolean noArgFactoryMethod;
- if (componentDescriptor.creatorDescriptor().isPresent()) {
- ComponentCreatorDescriptor creatorDescriptor =
- componentDescriptor.creatorDescriptor().get();
- builderMethodReturnType = ClassName.get(creatorDescriptor.typeElement());
- creatorKind = creatorDescriptor.kind();
- noArgFactoryMethod = creatorDescriptor.factoryParameters().isEmpty();
- } else {
- TypeSpec.Builder builder =
- TypeSpec.classBuilder("Builder")
- .addModifiers(STATIC, FINAL)
- .addMethod(privateConstructor());
- if (componentDescriptor.typeElement().getModifiers().contains(PUBLIC)) {
- builder.addModifiers(PUBLIC);
- }
-
- ClassName builderClassName = generatedTypeName.nestedClass("Builder");
- builderMethodReturnType = builderClassName;
- creatorKind = BUILDER;
- noArgFactoryMethod = true;
- componentRequirements(componentDescriptor)
- .map(requirement -> builderSetterMethod(requirement.typeElement(), builderClassName))
- .forEach(builder::addMethod);
- builder.addMethod(builderBuildMethod(componentDescriptor));
- generatedComponent.addType(builder.build());
- }
-
- generatedComponent.addMethod(staticCreatorMethod(builderMethodReturnType, creatorKind));
-
- if (noArgFactoryMethod
- && !hasBindsInstanceMethods(componentDescriptor)
- && componentRequirements(componentDescriptor)
- .noneMatch(requirement -> requirement.requiresAPassedInstance(elements, types))) {
- generatedComponent.addMethod(createMethod(componentDescriptor));
- }
-
- DeclaredType componentType = MoreTypes.asDeclared(componentElement.asType());
- // TODO(ronshapiro): unify with ComponentImplementationBuilder
- Set<MethodSignature> methodSignatures =
- Sets.newHashSetWithExpectedSize(componentDescriptor.componentMethods().size());
- componentDescriptor
- .componentMethods()
- .stream()
- .filter(
- method -> {
- return methodSignatures.add(
- MethodSignature.forComponentMethod(method, componentType, types));
- })
- .forEach(
- method ->
- generatedComponent.addMethod(
- emptyComponentMethod(componentElement, method.methodElement())));
-
- if (componentDescriptor.isProduction()) {
- generatedComponent
- .addSuperinterface(ClassName.get(CancellationListener.class))
- .addMethod(onProducerFutureCancelledMethod());
- }
-
- return Optional.of(generatedComponent);
+ private void processRootComponent(TypeElement element) {
+ ValidationReport<TypeElement> validationReport = componentValidator.validate(element);
+ validationReport.printMessagesTo(messager);
+ if (validationReport.isClean()) {
+ componentGenerator.generate(
+ componentDescriptorFactory.rootComponentDescriptor(element), messager);
}
}
- private MethodSpec emptyComponentMethod(TypeElement typeElement, ExecutableElement baseMethod) {
- return MethodSpec.overriding(baseMethod, MoreTypes.asDeclared(typeElement.asType()), types)
- .build();
- }
-
- private MethodSpec privateConstructor() {
- return constructorBuilder().addModifiers(PRIVATE).build();
- }
-
- /**
- * Returns the {@link ComponentRequirement}s for a component that does not have a {@link
- * ComponentDescriptor#creatorDescriptor()}.
- */
- private Stream<ComponentRequirement> componentRequirements(ComponentDescriptor component) {
- checkArgument(!component.isSubcomponent());
- return Stream.concat(
- component.dependencies().stream(),
- component.modules().stream()
- .filter(module -> !module.moduleElement().getModifiers().contains(ABSTRACT))
- .map(module -> ComponentRequirement.forModule(module.moduleElement().asType())));
- }
-
- private boolean hasBindsInstanceMethods(ComponentDescriptor componentDescriptor) {
- return componentDescriptor.creatorDescriptor().isPresent()
- && elements
- .getUnimplementedMethods(componentDescriptor.creatorDescriptor().get().typeElement())
- .stream()
- .anyMatch(method -> isBindsInstance(method));
- }
-
- private static boolean isBindsInstance(ExecutableElement method) {
- if (isAnnotationPresent(method, BindsInstance.class)) {
- return true;
- }
-
- if (method.getParameters().size() == 1) {
- return isAnnotationPresent(method.getParameters().get(0), BindsInstance.class);
- }
-
- return false;
- }
-
- private MethodSpec builderSetterMethod(
- TypeElement componentRequirement, ClassName builderClass) {
- String simpleName =
- UPPER_CAMEL.to(LOWER_CAMEL, componentRequirement.getSimpleName().toString());
- return MethodSpec.methodBuilder(simpleName)
- .addModifiers(PUBLIC)
- .addParameter(ClassName.get(componentRequirement), simpleName)
- .returns(builderClass)
- .build();
- }
-
- private MethodSpec builderBuildMethod(ComponentDescriptor component) {
- return MethodSpec.methodBuilder("build")
- .addModifiers(PUBLIC)
- .returns(ClassName.get(component.typeElement()))
- .build();
- }
-
- private MethodSpec staticCreatorMethod(
- TypeName creatorMethodReturnType, ComponentCreatorKind creatorKind) {
- return MethodSpec.methodBuilder(Ascii.toLowerCase(creatorKind.typeName()))
- .addModifiers(PUBLIC, STATIC)
- .returns(creatorMethodReturnType)
- .build();
- }
-
- private MethodSpec createMethod(ComponentDescriptor componentDescriptor) {
- return MethodSpec.methodBuilder("create")
- .addModifiers(PUBLIC, STATIC)
- .returns(ClassName.get(componentDescriptor.typeElement()))
- .build();
- }
-
- private MethodSpec onProducerFutureCancelledMethod() {
- return MethodSpec.methodBuilder("onProducerFutureCancelled")
- .addModifiers(PUBLIC)
- .addParameter(TypeName.BOOLEAN, "mayInterruptIfRunning")
- .build();
+ private void processRootCreator(TypeElement creator) {
+ creatorValidator.validate(asType(creator)).printMessagesTo(messager);
}
}
diff --git a/java/dagger/internal/codegen/ComponentImplementation.java b/java/dagger/internal/codegen/ComponentImplementation.java
deleted file mode 100644
index 340da14..0000000
--- a/java/dagger/internal/codegen/ComponentImplementation.java
+++ /dev/null
@@ -1,929 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.CaseFormat.LOWER_CAMEL;
-import static com.google.common.base.CaseFormat.UPPER_CAMEL;
-import static com.google.common.base.CaseFormat.UPPER_UNDERSCORE;
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.base.Preconditions.checkState;
-import static com.squareup.javapoet.TypeSpec.classBuilder;
-import static dagger.internal.codegen.ComponentCreatorKind.BUILDER;
-import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
-import static dagger.internal.codegen.serialization.ProtoSerialization.toAnnotationValue;
-import static java.util.stream.Collectors.toList;
-import static javax.lang.model.element.Modifier.ABSTRACT;
-import static javax.lang.model.element.Modifier.FINAL;
-import static javax.lang.model.element.Modifier.PUBLIC;
-
-import com.google.auto.value.AutoValue;
-import com.google.common.base.Supplier;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.LinkedHashMultimap;
-import com.google.common.collect.ListMultimap;
-import com.google.common.collect.Maps;
-import com.google.common.collect.MultimapBuilder;
-import com.google.common.collect.SetMultimap;
-import com.google.common.collect.Sets;
-import com.squareup.javapoet.AnnotationSpec;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.FieldSpec;
-import com.squareup.javapoet.MethodSpec;
-import com.squareup.javapoet.TypeSpec;
-import dagger.internal.ConfigureInitializationParameters;
-import dagger.internal.ModifiableBinding;
-import dagger.internal.ModifiableModule;
-import dagger.internal.codegen.ModifiableBindingMethods.ModifiableBindingMethod;
-import dagger.internal.codegen.javapoet.TypeSpecs;
-import dagger.model.DependencyRequest;
-import dagger.model.Key;
-import dagger.model.RequestKind;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.LinkedHashMap;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
-import javax.lang.model.element.Modifier;
-import javax.lang.model.element.NestingKind;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.TypeMirror;
-
-/** The implementation of a component type. */
-final class ComponentImplementation {
- /** A type of field that this component can contain. */
- enum FieldSpecKind {
-
- /** A field required by the component, e.g. module instances. */
- COMPONENT_REQUIREMENT_FIELD,
-
- /**
- * A field for the lock and cached value for {@linkplain PrivateMethodBindingExpression
- * private-method scoped bindings}.
- */
- PRIVATE_METHOD_SCOPED_FIELD,
-
- /** A framework field for type T, e.g. {@code Provider<T>}. */
- FRAMEWORK_FIELD,
-
- /** A static field that always returns an absent {@code Optional} value for the binding. */
- ABSENT_OPTIONAL_FIELD
- }
-
- /** A type of method that this component can contain. */
- // TODO(user, dpb): Change the oder to constructor, initialize, component, then private
- // (including MIM and AOM—why treat those separately?).
- enum MethodSpecKind {
- /** The component constructor. */
- CONSTRUCTOR,
-
- /**
- * In ahead-of-time subcomponents, this method coordinates the invocation of {@link
- * #INITIALIZE_METHOD initialization methods} instead of constructors.
- */
- // TODO(b/117833324): try to merge this with other initialize() methods so it looks more natural
- CONFIGURE_INITIALIZATION_METHOD,
-
- /** A builder method for the component. (Only used by the root component.) */
- BUILDER_METHOD,
-
- /** A private method that wraps dependency expressions. */
- PRIVATE_METHOD,
-
- /** An initialization method that initializes component requirements and framework types. */
- INITIALIZE_METHOD,
-
- /** An implementation of a component interface method. */
- COMPONENT_METHOD,
-
- /** A private method that encapsulates members injection logic for a binding. */
- MEMBERS_INJECTION_METHOD,
-
- /** A static method that always returns an absent {@code Optional} value for the binding. */
- ABSENT_OPTIONAL_METHOD,
-
- /**
- * A method that encapsulates a modifiable binding. A binding is modifiable if it can change
- * across implementations of a subcomponent. This is only relevant for ahead-of-time
- * subcomponents.
- */
- MODIFIABLE_BINDING_METHOD,
-
- /**
- * The {@link dagger.producers.internal.CancellationListener#onProducerFutureCancelled(boolean)}
- * method for a production component.
- */
- CANCELLATION_LISTENER_METHOD,
- ;
- }
-
- /** A type of nested class that this component can contain. */
- enum TypeSpecKind {
- /** A factory class for a present optional binding. */
- PRESENT_FACTORY,
-
- /** A class for the component creator (only used by the root component.) */
- COMPONENT_CREATOR,
-
- /** A provider class for a component provision. */
- COMPONENT_PROVISION_FACTORY,
-
- /** A class for the subcomponent or subcomponent builder. */
- SUBCOMPONENT
- }
-
- /**
- * The method spec for a {@code configureInitialization} method plus details on the component
- * requirements that its parameters are associated with.
- */
- @AutoValue
- abstract static class ConfigureInitializationMethod {
- /** Creates a new {@link ConfigureInitializationMethod}. */
- static ConfigureInitializationMethod create(
- MethodSpec spec, ImmutableSet<ComponentRequirement> parameters) {
- return new AutoValue_ComponentImplementation_ConfigureInitializationMethod(spec, parameters);
- }
-
- /** The spec for the method. */
- abstract MethodSpec spec();
-
- /**
- * The component requirements associated with the method's parameters, in the same order as the
- * parameters.
- */
- abstract ImmutableSet<ComponentRequirement> parameters();
- }
-
- private final CompilerOptions compilerOptions;
- private final ComponentDescriptor componentDescriptor;
- private final Optional<BindingGraph> graph;
- private final ClassName name;
- private final NestingKind nestingKind;
- private final boolean isAbstract;
- private final Optional<ComponentImplementation> superclassImplementation;
- private Optional<ComponentCreatorImplementation> creatorImplementation;
- private final Map<TypeElement, ComponentImplementation> childImplementations = new HashMap<>();
- private final TypeSpec.Builder component;
- private final Optional<SubcomponentNames> subcomponentNames;
- private final UniqueNameSet componentFieldNames = new UniqueNameSet();
- private final UniqueNameSet componentMethodNames = new UniqueNameSet();
- private final List<CodeBlock> initializations = new ArrayList<>();
- private final Set<ComponentRequirement> componentRequirementParameters = new HashSet<>();
- private final List<CodeBlock> componentRequirementInitializations = new ArrayList<>();
- private final Map<ComponentRequirement, String> componentRequirementParameterNames =
- new HashMap<>();
- private final Set<Key> cancellableProducerKeys = new LinkedHashSet<>();
- private final ListMultimap<FieldSpecKind, FieldSpec> fieldSpecsMap =
- MultimapBuilder.enumKeys(FieldSpecKind.class).arrayListValues().build();
- private final ListMultimap<MethodSpecKind, MethodSpec> methodSpecsMap =
- MultimapBuilder.enumKeys(MethodSpecKind.class).arrayListValues().build();
- private final ListMultimap<TypeSpecKind, TypeSpec> typeSpecsMap =
- MultimapBuilder.enumKeys(TypeSpecKind.class).arrayListValues().build();
- private final List<Supplier<TypeSpec>> switchingProviderSupplier = new ArrayList<>();
- private final ModifiableBindingMethods modifiableBindingMethods = new ModifiableBindingMethods();
- private final SetMultimap<BindingRequest, Key> multibindingContributionsMade =
- LinkedHashMultimap.create();
- private Optional<ConfigureInitializationMethod> configureInitializationMethod = Optional.empty();
- private final Map<ComponentRequirement, String> modifiableModuleMethods = new LinkedHashMap<>();
-
- private ComponentImplementation(
- ComponentDescriptor componentDescriptor,
- Optional<BindingGraph> graph,
- ClassName name,
- NestingKind nestingKind,
- Optional<ComponentImplementation> superclassImplementation,
- Optional<SubcomponentNames> subcomponentNames,
- CompilerOptions compilerOptions,
- ImmutableSet<Modifier> modifiers) {
- checkName(name, nestingKind);
- this.compilerOptions = compilerOptions;
- this.componentDescriptor = componentDescriptor;
- this.graph = graph;
- this.name = name;
- this.nestingKind = nestingKind;
- this.isAbstract = modifiers.contains(ABSTRACT);
- this.superclassImplementation = superclassImplementation;
- this.component = classBuilder(name);
- modifiers.forEach(component::addModifiers);
- this.subcomponentNames = subcomponentNames;
- }
-
- /** Returns a component implementation for a top-level component. */
- static ComponentImplementation topLevelComponentImplementation(
- BindingGraph graph,
- ClassName name,
- SubcomponentNames subcomponentNames,
- CompilerOptions compilerOptions) {
- return new ComponentImplementation(
- graph.componentDescriptor(),
- Optional.of(graph),
- name,
- NestingKind.TOP_LEVEL,
- Optional.empty(), // superclass implementation
- Optional.of(subcomponentNames),
- compilerOptions,
- topLevelComponentImplementationModifiers(graph));
- }
-
- private static ImmutableSet<Modifier> topLevelComponentImplementationModifiers(
- BindingGraph graph) {
- ImmutableSet.Builder<Modifier> modifiers = ImmutableSet.builder();
- if (graph.componentTypeElement().getModifiers().contains(PUBLIC)
- || graph.componentDescriptor().isSubcomponent()) {
- // TODO(ronshapiro): perhaps all generated components should be non-public?
- modifiers.add(PUBLIC);
- }
- return modifiers.add(graph.componentDescriptor().isSubcomponent() ? ABSTRACT : FINAL).build();
- }
-
- /** Returns a component implementation that is a child of the current implementation. */
- ComponentImplementation childComponentImplementation(
- BindingGraph graph,
- Optional<ComponentImplementation> superclassImplementation,
- Modifier... modifiers) {
- return new ComponentImplementation(
- graph.componentDescriptor(),
- Optional.of(graph),
- getSubcomponentName(graph.componentDescriptor()),
- NestingKind.MEMBER,
- superclassImplementation,
- subcomponentNames,
- compilerOptions,
- ImmutableSet.copyOf(modifiers));
- }
-
- /**
- * Returns a component implementation that models a previously compiled class. This {@link
- * ComponentImplementation} is not used for code generation itself; it is used to determine what
- * methods need to be implemented in a subclass implementation.
- */
- static ComponentImplementation forDeserializedComponent(
- ComponentDescriptor componentDescriptor,
- ClassName name,
- NestingKind nestingKind,
- Optional<ComponentImplementation> superclassImplementation,
- CompilerOptions compilerOptions) {
- return new ComponentImplementation(
- componentDescriptor,
- Optional.empty(),
- name,
- nestingKind,
- superclassImplementation,
- Optional.empty(),
- compilerOptions,
- ImmutableSet.of(PUBLIC, ABSTRACT));
- }
-
- // TODO(dpb): Just determine the nesting kind from the name.
- private static void checkName(ClassName name, NestingKind nestingKind) {
- switch (nestingKind) {
- case TOP_LEVEL:
- checkArgument(
- name.enclosingClassName() == null, "must be a top-level class name: %s", name);
- break;
-
- case MEMBER:
- checkNotNull(name.enclosingClassName(), "must not be a top-level class name: %s", name);
- break;
-
- default:
- throw new IllegalArgumentException(
- "nestingKind must be TOP_LEVEL or MEMBER: " + nestingKind);
- }
- }
-
- /**
- * Returns {@code true} if this component implementation represents a component that has already
- * been compiled. If this returns true, the implementation will have no {@link #graph
- * BindingGraph}.
- */
- boolean isDeserializedImplementation() {
- return !graph.isPresent();
- }
-
- // TODO(ronshapiro): see if we can remove this method and instead inject it in the objects that
- // need it.
- /** Returns the binding graph for the component being generated. */
- BindingGraph graph() {
- checkState(!isDeserializedImplementation(),
- "A BindingGraph is not available for deserialized component implementations.");
- return graph.get();
- }
-
- /** Returns the descriptor for the component being generated. */
- ComponentDescriptor componentDescriptor() {
- return componentDescriptor;
- }
-
- /** Returns the name of the component. */
- ClassName name() {
- return name;
- }
-
- /** Returns whether or not the implementation is nested within another class. */
- boolean isNested() {
- return nestingKind.isNested();
- }
-
- /** Returns whether or not the implementation is abstract. */
- boolean isAbstract() {
- return isAbstract;
- }
-
- /** Returns the superclass implementation. */
- Optional<ComponentImplementation> superclassImplementation() {
- return superclassImplementation;
- }
-
- /**
- * Returns the base implementation of this component in ahead-of-time subcomponents mode. If this
- * is the base implementation, this returns {@link Optional#empty()}.
- */
- Optional<ComponentImplementation> baseImplementation() {
- return superclassImplementation.isPresent()
- ? Optional.of(Optionals.rootmostValue(this, c -> c.superclassImplementation))
- : Optional.empty();
- }
-
- /**
- * Returns the {@link #configureInitializationMethod()} of the nearest supertype that defines one,
- * if any.
- *
- * <p>Only returns a present value in {@link CompilerOptions#aheadOfTimeSubcomponents()}.
- */
- Optional<ConfigureInitializationMethod> superConfigureInitializationMethod() {
- for (Optional<ComponentImplementation> currentSuper = superclassImplementation;
- currentSuper.isPresent();
- currentSuper = currentSuper.get().superclassImplementation) {
- if (currentSuper.get().configureInitializationMethod.isPresent()) {
- return currentSuper.get().configureInitializationMethod;
- }
- }
- return Optional.empty();
- }
-
- /**
- * The requirements for creating an instance of this component implementation type.
- *
- * <p>If this component implementation is concrete, these requirements will be in the order that
- * the implementation's constructor takes them as parameters.
- */
- ImmutableSet<ComponentRequirement> requirements() {
- // If the base implementation's creator is being generated in ahead-of-time-subcomponents
- // mode, this uses the ComponentDescriptor's requirements() since Dagger doesn't know what
- // modules may end being unused or owned by an ancestor component. Otherwise, we use the
- // necessary component requirements.
- // TODO(ronshapiro): can we remove the second condition here? Or, is it never going to be
- // called, so we should enforce that invariant?
- return isAbstract() && !superclassImplementation().isPresent()
- ? componentDescriptor().requirements()
- : graph().componentRequirements();
- }
-
- /**
- * Returns the {@link MethodSpecKind#CONFIGURE_INITIALIZATION_METHOD} of this implementation if
- * there is one.
- *
- * <p>Only returns a present value in {@link CompilerOptions#aheadOfTimeSubcomponents()}.
- */
- Optional<ConfigureInitializationMethod> configureInitializationMethod() {
- return configureInitializationMethod;
- }
-
- /**
- * Set's this component implementation's {@code configureInitialization()} method and {@linkplain
- * #addMethod(MethodSpecKind, MethodSpec) adds the method}.
- */
- void setConfigureInitializationMethod(ConfigureInitializationMethod method) {
- configureInitializationMethod = Optional.of(method);
- addMethod(
- MethodSpecKind.CONFIGURE_INITIALIZATION_METHOD,
- addConfigureInitializationMetadata(method));
- }
-
- private MethodSpec addConfigureInitializationMetadata(ConfigureInitializationMethod method) {
- if (!shouldEmitModifiableMetadataAnnotations()) {
- return method.spec();
- }
- AnnotationSpec.Builder annotation =
- AnnotationSpec.builder(ConfigureInitializationParameters.class);
- for (ComponentRequirement parameter : method.parameters()) {
- annotation.addMember("value", toAnnotationValue(parameter.toProto()));
- }
-
- return method.spec().toBuilder().addAnnotation(annotation.build()).build();
- }
-
- void setCreatorImplementation(Optional<ComponentCreatorImplementation> creatorImplementation) {
- checkState(
- this.creatorImplementation == null, "setCreatorImplementation has already been called");
- this.creatorImplementation = creatorImplementation;
- }
-
- Optional<ComponentCreatorImplementation> creatorImplementation() {
- checkState(creatorImplementation != null, "setCreatorImplementation has not been called yet");
- return creatorImplementation;
- }
-
- /**
- * Returns the {@link ComponentCreatorImplementation} defined in the base implementation for this
- * component, if one exists.
- */
- Optional<ComponentCreatorImplementation> baseCreatorImplementation() {
- return baseImplementation().flatMap(baseImpl -> baseImpl.creatorImplementation());
- }
-
- /**
- * Returns the kind of this component's creator.
- *
- * @throws IllegalStateException if the component has no creator
- */
- private ComponentCreatorKind creatorKind() {
- checkState(componentDescriptor().hasCreator());
- return componentDescriptor()
- .creatorDescriptor()
- .map(ComponentCreatorDescriptor::kind)
- .orElse(BUILDER);
- }
-
- /**
- * Returns the name of the creator class for this component. It will be a sibling of this
- * generated class unless this is a top-level component, in which case it will be nested.
- */
- ClassName getCreatorName() {
- return isNested()
- ? name.peerClass(subcomponentNames().getCreatorName(componentDescriptor()))
- : name.nestedClass(creatorKind().typeName());
- }
-
- /** Returns the name of the nested implementation class for a child component. */
- ClassName getSubcomponentName(ComponentDescriptor childDescriptor) {
- checkArgument(
- componentDescriptor().childComponents().contains(childDescriptor),
- "%s is not a child component of %s",
- childDescriptor.typeElement(),
- componentDescriptor().typeElement());
- return name.nestedClass(subcomponentNames().get(childDescriptor) + "Impl");
- }
-
- /**
- * Returns the simple name of the creator implementation class for the given subcomponent creator
- * {@link Key}.
- */
- String getSubcomponentCreatorSimpleName(Key key) {
- return subcomponentNames().getCreatorName(key);
- }
-
- private SubcomponentNames subcomponentNames() {
- checkState(
- subcomponentNames.isPresent(),
- "SubcomponentNames is not available for deserialized component implementations.");
- return subcomponentNames.get();
- }
-
- /** Returns the child implementation. */
- Optional<ComponentImplementation> childImplementation(ComponentDescriptor child) {
- return Optional.ofNullable(childImplementations.get(child.typeElement()));
- }
-
- /** Returns {@code true} if {@code type} is accessible from the generated component. */
- boolean isTypeAccessible(TypeMirror type) {
- return isTypeAccessibleFrom(type, name.packageName());
- }
-
- /** Adds the given super type to the component. */
- void addSupertype(TypeElement supertype) {
- TypeSpecs.addSupertype(component, supertype);
- }
-
- /** Adds the given super class to the subcomponent. */
- void addSuperclass(ClassName className) {
- checkState(
- superclassImplementation.isPresent(),
- "Setting the superclass for component [%s] when there is no superclass implementation.",
- name);
- component.superclass(className);
- }
-
- // TODO(dpb): Consider taking FieldSpec, and returning identical FieldSpec with unique name?
- /** Adds the given field to the component. */
- void addField(FieldSpecKind fieldKind, FieldSpec fieldSpec) {
- fieldSpecsMap.put(fieldKind, fieldSpec);
- }
-
- /** Adds the given fields to the component. */
- void addFields(FieldSpecKind fieldKind, Iterable<FieldSpec> fieldSpecs) {
- fieldSpecsMap.putAll(fieldKind, fieldSpecs);
- }
-
- // TODO(dpb): Consider taking MethodSpec, and returning identical MethodSpec with unique name?
- /** Adds the given method to the component. */
- void addMethod(MethodSpecKind methodKind, MethodSpec methodSpec) {
- methodSpecsMap.put(methodKind, methodSpec);
- }
-
- /** Adds the given annotation to the component. */
- void addAnnotation(AnnotationSpec annotation) {
- component.addAnnotation(annotation);
- }
-
- /**
- * Adds the given method to the component. In this case, the method represents an encapsulation of
- * a modifiable binding between implementations of a subcomponent. This is only relevant for
- * ahead-of-time subcomponents.
- */
- void addModifiableBindingMethod(
- ModifiableBindingType type,
- BindingRequest request,
- TypeMirror returnType,
- MethodSpec methodSpec,
- boolean finalized) {
- addModifiableMethod(
- MethodSpecKind.MODIFIABLE_BINDING_METHOD, type, request, returnType, methodSpec, finalized);
- }
-
- /**
- * Adds a component method that is modifiable to the component. In this case, the method
- * represents an encapsulation of a modifiable binding between implementations of a subcomponent.
- * This is only relevant for ahead-of-time subcomponents.
- */
- void addModifiableComponentMethod(
- ModifiableBindingType type,
- BindingRequest request,
- TypeMirror returnType,
- MethodSpec methodSpec,
- boolean finalized) {
- addModifiableMethod(
- MethodSpecKind.COMPONENT_METHOD, type, request, returnType, methodSpec, finalized);
- }
-
- private void addModifiableMethod(
- MethodSpecKind methodKind,
- ModifiableBindingType type,
- BindingRequest request,
- TypeMirror returnType,
- MethodSpec methodSpec,
- boolean finalized) {
- modifiableBindingMethods.addModifiableMethod(
- type, request, returnType, methodSpec, finalized);
- methodSpecsMap.put(methodKind, withModifiableBindingMetadata(methodSpec, type, request));
- }
-
- /** Adds the implementation for the given {@link ModifiableBindingMethod} to the component. */
- void addImplementedModifiableBindingMethod(ModifiableBindingMethod method) {
- modifiableBindingMethods.addReimplementedMethod(method);
- methodSpecsMap.put(
- MethodSpecKind.MODIFIABLE_BINDING_METHOD,
- withModifiableBindingMetadata(method.methodSpec(), method.type(), method.request()));
- }
-
- private MethodSpec withModifiableBindingMetadata(
- MethodSpec method, ModifiableBindingType type, BindingRequest request) {
- if (!shouldEmitModifiableMetadataAnnotations()) {
- return method;
- }
- AnnotationSpec.Builder metadata =
- AnnotationSpec.builder(ModifiableBinding.class)
- .addMember("modifiableBindingType", "$S", type.name())
- .addMember("bindingRequest", toAnnotationValue(request.toProto()));
- for (Key multibindingContribution : multibindingContributionsMade.get(request)) {
- metadata.addMember(
- "multibindingContributions",
- toAnnotationValue(KeyFactory.toProto(multibindingContribution)));
- }
- return method.toBuilder().addAnnotation(metadata.build()).build();
- }
-
- /** Add's a modifiable module method to this implementation. */
- void addModifiableModuleMethod(ComponentRequirement module, MethodSpec method) {
- registerModifiableModuleMethod(module, method.name);
- methodSpecsMap.put(
- MethodSpecKind.MODIFIABLE_BINDING_METHOD, withModifiableModuleMetadata(module, method));
- }
-
- /** Registers a modifiable module method with {@code name} for {@code module}. */
- void registerModifiableModuleMethod(ComponentRequirement module, String name) {
- checkArgument(module.kind().isModule());
- checkState(modifiableModuleMethods.put(module, name) == null);
- }
-
- private MethodSpec withModifiableModuleMetadata(ComponentRequirement module, MethodSpec method) {
- if (!shouldEmitModifiableMetadataAnnotations()) {
- return method;
- }
- return method
- .toBuilder()
- .addAnnotation(
- AnnotationSpec.builder(ModifiableModule.class)
- .addMember("value", toAnnotationValue(module.toProto()))
- .build())
- .build();
- }
-
- /**
- * Returns {@code true} if the generated component should include metadata annotations with
- * information to deserialize this {@link ComponentImplementation} in future compilations.
- */
- boolean shouldEmitModifiableMetadataAnnotations() {
- return isAbstract && compilerOptions.emitModifiableMetadataAnnotations();
- }
-
- /** Adds the given type to the component. */
- void addType(TypeSpecKind typeKind, TypeSpec typeSpec) {
- typeSpecsMap.put(typeKind, typeSpec);
- }
-
- /** Adds the type generated from the given child implementation. */
- void addChild(ComponentDescriptor child, ComponentImplementation childImplementation) {
- childImplementations.put(child.typeElement(), childImplementation);
- addType(TypeSpecKind.SUBCOMPONENT, childImplementation.generate().build());
- }
-
- /** Adds a {@link Supplier} for the SwitchingProvider for the component. */
- void addSwitchingProvider(Supplier<TypeSpec> typeSpecSupplier) {
- switchingProviderSupplier.add(typeSpecSupplier);
- }
-
- /** Adds the given code block to the initialize methods of the component. */
- void addInitialization(CodeBlock codeBlock) {
- initializations.add(codeBlock);
- }
-
- /**
- * Adds the given component requirement as one that should have a parameter in the component's
- * initialization methods.
- */
- void addComponentRequirementParameter(ComponentRequirement requirement) {
- componentRequirementParameters.add(requirement);
- }
-
- /**
- * The set of component requirements that have parameters in the component's initialization
- * methods.
- */
- ImmutableSet<ComponentRequirement> getComponentRequirementParameters() {
- return ImmutableSet.copyOf(componentRequirementParameters);
- }
-
- /** Adds the given code block that initializes a {@link ComponentRequirement}. */
- void addComponentRequirementInitialization(CodeBlock codeBlock) {
- componentRequirementInitializations.add(codeBlock);
- }
-
- /**
- * Marks the given key of a producer as one that should have a cancellation statement in the
- * cancellation listener method of the component.
- */
- void addCancellableProducerKey(Key key) {
- cancellableProducerKeys.add(key);
- }
-
- /** Returns a new, unique field name for the component based on the given name. */
- String getUniqueFieldName(String name) {
- return componentFieldNames.getUniqueName(name);
- }
-
- /** Returns a new, unique method name for the component based on the given name. */
- String getUniqueMethodName(String name) {
- return componentMethodNames.getUniqueName(name);
- }
-
- /** Returns a new, unique method name for a getter method for the given request. */
- String getUniqueMethodName(BindingRequest request) {
- return uniqueMethodName(request, KeyVariableNamer.name(request.key()));
- }
-
- private String uniqueMethodName(BindingRequest request, String bindingName) {
- String baseMethodName =
- "get"
- + LOWER_CAMEL.to(UPPER_CAMEL, bindingName)
- + (request.isRequestKind(RequestKind.INSTANCE)
- ? ""
- : UPPER_UNDERSCORE.to(UPPER_CAMEL, request.kindName()));
- return getUniqueMethodName(baseMethodName);
- }
-
- /** Gets the parameter name to use for the given requirement for this component. */
- String getParameterName(ComponentRequirement requirement) {
- return getParameterName(requirement, requirement.variableName());
- }
-
- /**
- * Gets the parameter name to use for the given requirement for this component, starting with the
- * given base name if no parameter name has already been selected for the requirement.
- */
- String getParameterName(ComponentRequirement requirement, String baseName) {
- return componentRequirementParameterNames.computeIfAbsent(
- requirement, r -> getUniqueFieldName(baseName));
- }
-
- /** Claims a new method name for the component. Does nothing if method name already exists. */
- void claimMethodName(CharSequence name) {
- componentMethodNames.claim(name);
- }
-
- /** Returns the list of {@link CodeBlock}s that need to go in the initialize method. */
- ImmutableList<CodeBlock> getInitializations() {
- return ImmutableList.copyOf(initializations);
- }
-
- /**
- * Returns a list of {@link CodeBlock}s for initializing {@link ComponentRequirement}s.
- *
- * <p>These initializations are kept separate from {@link #getInitializations()} because they must
- * be executed before the initializations of any framework instance initializations in a
- * superclass implementation that may depend on the instances. We cannot use the same strategy
- * that we use for framework instances (i.e. wrap in a {@link dagger.internal.DelegateFactory} or
- * {@link dagger.producers.internal.DelegateProducer} since the types of these initialized fields
- * have no interface type that we can write a proxy for.
- */
- ImmutableList<CodeBlock> getComponentRequirementInitializations() {
- return ImmutableList.copyOf(componentRequirementInitializations);
- }
-
- /**
- * Returns whether or not this component has any {@linkplain #getInitializations() initilizations}
- * or {@linkplain #getComponentRequirementInitializations() component requirement
- * initializations}.
- */
- boolean hasInitializations() {
- return !initializations.isEmpty() || !componentRequirementInitializations.isEmpty();
- }
-
- /**
- * Returns the list of producer {@link Key}s that need cancellation statements in the cancellation
- * listener method.
- */
- ImmutableList<Key> getCancellableProducerKeys() {
- Optional<ComponentImplementation> currentSuperImplementation = superclassImplementation;
- Set<Key> cancelledKeysFromSuperclass = new HashSet<>();
- while (currentSuperImplementation.isPresent()) {
- cancelledKeysFromSuperclass.addAll(currentSuperImplementation.get().cancellableProducerKeys);
- currentSuperImplementation = currentSuperImplementation.get().superclassImplementation;
- }
- return Sets.difference(cancellableProducerKeys, cancelledKeysFromSuperclass)
- .immutableCopy()
- .asList();
- }
-
- /**
- * Returns the {@link ModifiableBindingMethod}s for this subcomponent implementation and its
- * superclasses.
- */
- ImmutableMap<BindingRequest, ModifiableBindingMethod> getModifiableBindingMethods() {
- Map<BindingRequest, ModifiableBindingMethod> modifiableBindingMethodsBuilder =
- new LinkedHashMap<>();
- if (superclassImplementation.isPresent()) {
- modifiableBindingMethodsBuilder.putAll(
- Maps.filterValues(
- superclassImplementation.get().getModifiableBindingMethods(),
- // filters the modifiable methods of a superclass that are finalized in this component
- method -> !modifiableBindingMethods.finalized(method)));
- }
- // replace superclass modifiable binding methods with any that are defined in this component
- // implementation
- modifiableBindingMethodsBuilder.putAll(modifiableBindingMethods.getNonFinalizedMethods());
- return ImmutableMap.copyOf(modifiableBindingMethodsBuilder);
- }
-
- /**
- * Returns the names of every modifiable method of this implementation and any superclass
- * implementations.
- */
- ImmutableSet<String> getAllModifiableMethodNames() {
- ImmutableSet.Builder<String> names = ImmutableSet.builder();
- modifiableBindingMethods.allMethods().forEach(method -> names.add(method.methodSpec().name));
- names.addAll(modifiableModuleMethods.values());
- superclassImplementation.ifPresent(
- superclass -> names.addAll(superclass.getAllModifiableMethodNames()));
- return names.build();
- }
-
- /**
- * Returns the {@link ModifiableBindingMethod} for this subcomponent for the given binding, if it
- * exists.
- */
- Optional<ModifiableBindingMethod> getModifiableBindingMethod(BindingRequest request) {
- Optional<ModifiableBindingMethod> method = modifiableBindingMethods.getMethod(request);
- if (!method.isPresent() && superclassImplementation.isPresent()) {
- return superclassImplementation.get().getModifiableBindingMethod(request);
- }
- return method;
- }
-
- /**
- * Returns the {@link ModifiableBindingMethod} of a supertype for this method's {@code request},
- * if one exists.
- */
- Optional<ModifiableBindingMethod> supertypeModifiableBindingMethod(BindingRequest request) {
- return superclassImplementation()
- .flatMap(superImplementation -> superImplementation.getModifiableBindingMethod(request));
- }
-
- /**
- * Returns the names of modifiable module methods for this implementation and all inherited
- * implementations, keyed by the corresponding module's {@link ComponentRequirement}.
- */
- ImmutableMap<ComponentRequirement, String> getAllModifiableModuleMethods() {
- ImmutableMap.Builder<ComponentRequirement, String> methods = ImmutableMap.builder();
- methods.putAll(modifiableModuleMethods);
- superclassImplementation.ifPresent(
- superclass -> methods.putAll(superclass.getAllModifiableModuleMethods()));
- return methods.build();
- }
-
- /**
- * Returns the name of the modifiable module method for {@code module} that is inherited in this
- * implementation, or empty if none has been defined.
- */
- Optional<String> supertypeModifiableModuleMethodName(ComponentRequirement module) {
- checkArgument(module.kind().isModule());
- if (!superclassImplementation.isPresent()) {
- return Optional.empty();
- }
- String methodName = superclassImplementation.get().modifiableModuleMethods.get(module);
- if (methodName == null) {
- return superclassImplementation.get().supertypeModifiableModuleMethodName(module);
- }
- return Optional.of(methodName);
- }
-
- /** Generates the component and returns the resulting {@link TypeSpec.Builder}. */
- TypeSpec.Builder generate() {
- fieldSpecsMap.asMap().values().forEach(component::addFields);
- methodSpecsMap.asMap().values().forEach(component::addMethods);
- typeSpecsMap.asMap().values().forEach(component::addTypes);
- switchingProviderSupplier.stream().map(Supplier::get).forEach(component::addType);
- return component;
- }
-
- /**
- * Registers a {@ProvisionBinding} representing a multibinding as having been implemented in this
- * component. Multibindings are modifiable across subcomponent implementations and this allows us
- * to know whether a contribution has been made by a superclass implementation. This is only
- * relevant for ahead-of-time subcomponents.
- */
- void registerImplementedMultibinding(
- ContributionBinding multibinding, BindingRequest bindingRequest) {
- checkArgument(multibinding.isSyntheticMultibinding());
- // We register a multibinding as implemented each time we request the multibinding expression,
- // so only modify the set of contributions once.
- if (!multibindingContributionsMade.containsKey(bindingRequest)) {
- registerImplementedMultibindingKeys(
- bindingRequest,
- multibinding.dependencies().stream().map(DependencyRequest::key).collect(toList()));
- }
- }
-
- /**
- * Registers the multibinding contributions represented by {@code keys} as having been implemented
- * in this component. Multibindings are modifiable across subcomponent implementations and this
- * allows us to know whether a contribution has been made by a superclass implementation. This is
- * only relevant for ahead-of-time subcomponents.
- */
- void registerImplementedMultibindingKeys(BindingRequest bindingRequest, Iterable<Key> keys) {
- multibindingContributionsMade.putAll(bindingRequest, keys);
- }
-
- /**
- * Returns the set of multibinding contributions associated with all superclass implementations of
- * a multibinding.
- */
- ImmutableSet<Key> superclassContributionsMade(BindingRequest bindingRequest) {
- return superclassImplementation
- .map(s -> s.getAllMultibindingContributions(bindingRequest))
- .orElse(ImmutableSet.of());
- }
-
- /**
- * Returns the set of multibinding contributions associated with all implementations of a
- * multibinding.
- */
- private ImmutableSet<Key> getAllMultibindingContributions(BindingRequest bindingRequest) {
- return ImmutableSet.copyOf(
- Sets.union(
- multibindingContributionsMade.get(bindingRequest),
- superclassContributionsMade(bindingRequest)));
- }
-}
diff --git a/java/dagger/internal/codegen/ComponentImplementationBuilder.java b/java/dagger/internal/codegen/ComponentImplementationBuilder.java
deleted file mode 100644
index 7579ac9..0000000
--- a/java/dagger/internal/codegen/ComponentImplementationBuilder.java
+++ /dev/null
@@ -1,826 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreElements.getLocalAndInheritedMethods;
-import static com.google.auto.common.MoreTypes.asDeclared;
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkState;
-import static com.google.common.base.Predicates.in;
-import static com.squareup.javapoet.MethodSpec.constructorBuilder;
-import static com.squareup.javapoet.MethodSpec.methodBuilder;
-import static dagger.internal.codegen.BindingRequest.bindingRequest;
-import static dagger.internal.codegen.ComponentCreatorKind.BUILDER;
-import static dagger.internal.codegen.ComponentImplementation.MethodSpecKind.BUILDER_METHOD;
-import static dagger.internal.codegen.ComponentImplementation.MethodSpecKind.CANCELLATION_LISTENER_METHOD;
-import static dagger.internal.codegen.ComponentImplementation.MethodSpecKind.COMPONENT_METHOD;
-import static dagger.internal.codegen.ComponentImplementation.MethodSpecKind.CONSTRUCTOR;
-import static dagger.internal.codegen.ComponentImplementation.MethodSpecKind.INITIALIZE_METHOD;
-import static dagger.internal.codegen.ComponentImplementation.MethodSpecKind.MODIFIABLE_BINDING_METHOD;
-import static dagger.internal.codegen.ComponentImplementation.TypeSpecKind.COMPONENT_CREATOR;
-import static dagger.internal.codegen.ComponentImplementation.TypeSpecKind.SUBCOMPONENT;
-import static dagger.internal.codegen.DaggerStreams.toImmutableList;
-import static dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression.UNCHECKED;
-import static dagger.internal.codegen.javapoet.CodeBlocks.parameterNames;
-import static dagger.internal.codegen.javapoet.CodeBlocks.toParametersCodeBlock;
-import static dagger.producers.CancellationPolicy.Propagation.PROPAGATE;
-import static javax.lang.model.element.Modifier.ABSTRACT;
-import static javax.lang.model.element.Modifier.FINAL;
-import static javax.lang.model.element.Modifier.PRIVATE;
-import static javax.lang.model.element.Modifier.PROTECTED;
-import static javax.lang.model.element.Modifier.PUBLIC;
-import static javax.lang.model.element.Modifier.STATIC;
-
-import com.google.auto.common.MoreTypes;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableListMultimap;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Multimaps;
-import com.google.common.collect.Sets;
-import com.squareup.javapoet.AnnotationSpec;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.MethodSpec;
-import com.squareup.javapoet.ParameterSpec;
-import com.squareup.javapoet.TypeName;
-import com.squareup.javapoet.TypeSpec;
-import dagger.internal.ComponentDefinitionType;
-import dagger.internal.Preconditions;
-import dagger.internal.codegen.ComponentDescriptor.ComponentMethodDescriptor;
-import dagger.internal.codegen.ComponentImplementation.ConfigureInitializationMethod;
-import dagger.internal.codegen.ModifiableBindingMethods.ModifiableBindingMethod;
-import dagger.internal.codegen.javapoet.AnnotationSpecs;
-import dagger.internal.codegen.javapoet.CodeBlocks;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.Key;
-import dagger.producers.internal.CancellationListener;
-import dagger.producers.internal.Producers;
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.function.Function;
-import javax.inject.Inject;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.type.DeclaredType;
-
-/** A builder of {@link ComponentImplementation}s. */
-abstract class ComponentImplementationBuilder {
- private static final String MAY_INTERRUPT_IF_RUNNING = "mayInterruptIfRunning";
-
- /**
- * How many statements per {@code initialize()} or {@code onProducerFutureCancelled()} method
- * before they get partitioned.
- */
- private static final int STATEMENTS_PER_METHOD = 100;
-
- private static final String CANCELLATION_LISTENER_METHOD_NAME = "onProducerFutureCancelled";
-
- // TODO(ronshapiro): replace this with composition instead of inheritance so we don't have
- // non-final fields
- @Inject BindingGraph graph;
- @Inject ComponentBindingExpressions bindingExpressions;
- @Inject ComponentRequirementExpressions componentRequirementExpressions;
- @Inject ComponentImplementation componentImplementation;
- @Inject ComponentCreatorImplementationFactory componentCreatorImplementationFactory;
- @Inject DaggerTypes types;
- @Inject DaggerElements elements;
- @Inject CompilerOptions compilerOptions;
- @Inject ComponentImplementationFactory componentImplementationFactory;
- @Inject TopLevelImplementationComponent topLevelImplementationComponent;
- private boolean done;
-
- /**
- * Returns a {@link ComponentImplementation} for this component. This is only intended to be
- * called once (and will throw on successive invocations). If the component must be regenerated,
- * use a new instance.
- */
- final ComponentImplementation build() {
- checkState(
- !done,
- "ComponentImplementationBuilder has already built the ComponentImplementation for [%s].",
- componentImplementation.name());
- setSupertype();
- componentImplementation.setCreatorImplementation(
- componentCreatorImplementationFactory.create(
- componentImplementation, Optional.of(componentImplementation.graph())));
- componentImplementation
- .creatorImplementation()
- .map(ComponentCreatorImplementation::spec)
- .ifPresent(this::addCreatorClass);
-
- getLocalAndInheritedMethods(graph.componentTypeElement(), types, elements)
- .forEach(method -> componentImplementation.claimMethodName(method.getSimpleName()));
- componentImplementation
- .superclassImplementation()
- .ifPresent(
- superclassImplementation -> {
- superclassImplementation
- .getAllModifiableMethodNames()
- .forEach(componentImplementation::claimMethodName);
- });
-
- addFactoryMethods();
- addInterfaceMethods();
- addChildComponents();
- implementModifiableModuleMethods();
-
- addConstructorAndInitializationMethods();
-
- if (graph.componentDescriptor().isProduction()) {
- addCancellationListenerImplementation();
- }
-
- if (componentImplementation.isAbstract()
- && !componentImplementation.baseImplementation().isPresent()) {
- componentImplementation.addAnnotation(compilerOptions.toGenerationOptionsAnnotation());
- }
-
- if (componentImplementation.shouldEmitModifiableMetadataAnnotations()) {
- componentImplementation.addAnnotation(
- AnnotationSpec.builder(ComponentDefinitionType.class)
- .addMember("value", "$T.class", graph.componentTypeElement())
- .build());
- }
-
- done = true;
- return componentImplementation;
- }
-
- /** Set the supertype for this generated class. */
- private void setSupertype() {
- if (componentImplementation.superclassImplementation().isPresent()) {
- componentImplementation.addSuperclass(
- componentImplementation.superclassImplementation().get().name());
- } else {
- componentImplementation.addSupertype(graph.componentTypeElement());
- }
- }
-
- /**
- * Adds {@code creator} as a nested creator class. Root components and subcomponents will nest
- * this in different classes.
- */
- protected abstract void addCreatorClass(TypeSpec creator);
-
- /** Adds component factory methods. */
- protected abstract void addFactoryMethods();
-
- protected void addInterfaceMethods() {
- // Each component method may have been declared by several supertypes. We want to implement
- // only one method for each distinct signature.
- ImmutableListMultimap<MethodSignature, ComponentMethodDescriptor> componentMethodsBySignature =
- Multimaps.index(graph.componentDescriptor().entryPointMethods(), this::getMethodSignature);
- for (List<ComponentMethodDescriptor> methodsWithSameSignature :
- Multimaps.asMap(componentMethodsBySignature).values()) {
- ComponentMethodDescriptor anyOneMethod = methodsWithSameSignature.stream().findAny().get();
- MethodSpec methodSpec = bindingExpressions.getComponentMethod(anyOneMethod);
-
- if (compilerOptions.aheadOfTimeSubcomponents()) {
- addPossiblyModifiableInterfaceMethod(anyOneMethod, methodSpec);
- } else {
- componentImplementation.addMethod(COMPONENT_METHOD, methodSpec);
- }
- }
- }
-
- /**
- * Adds a component interface method in ahead-of-time subcomponents mode. If the binding that
- * implements the method is modifiable, registers the method.
- */
- private void addPossiblyModifiableInterfaceMethod(
- ComponentMethodDescriptor methodDescriptor, MethodSpec implementedComponentMethod) {
- if (methodDescriptor.dependencyRequest().isPresent()
- && componentImplementation
- .getModifiableBindingMethod(bindingRequest(methodDescriptor.dependencyRequest().get()))
- .isPresent()) {
- // If there are multiple component methods that are modifiable and for the same binding
- // request, implement all but one in the base implementation to delegate to the one that
- // will remain (and be registered) modifiable
- checkState(componentImplementation.isAbstract() && !componentImplementation.isNested());
- componentImplementation.addMethod(
- COMPONENT_METHOD, implementedComponentMethod.toBuilder().addModifiers(FINAL).build());
- } else {
- // TODO(b/117833324): Can this class be the one to interface with ComponentImplementation
- // instead of having it go through ModifiableBindingExpressions?
- bindingExpressions
- .modifiableBindingExpressions()
- .addPossiblyModifiableComponentMethod(methodDescriptor, implementedComponentMethod);
- }
- }
-
- private void addCancellationListenerImplementation() {
- componentImplementation.addSupertype(elements.getTypeElement(CancellationListener.class));
- componentImplementation.claimMethodName(CANCELLATION_LISTENER_METHOD_NAME);
-
- ImmutableList<ParameterSpec> parameters =
- ImmutableList.of(ParameterSpec.builder(boolean.class, MAY_INTERRUPT_IF_RUNNING).build());
-
- MethodSpec.Builder methodBuilder =
- methodBuilder(CANCELLATION_LISTENER_METHOD_NAME)
- .addModifiers(PUBLIC)
- .addAnnotation(Override.class)
- .addParameters(parameters);
- if (componentImplementation.superclassImplementation().isPresent()) {
- methodBuilder.addStatement(
- "super.$L($L)", CANCELLATION_LISTENER_METHOD_NAME, MAY_INTERRUPT_IF_RUNNING);
- }
-
- ImmutableList<CodeBlock> cancellationStatements = cancellationStatements();
-
- if (cancellationStatements.size() < STATEMENTS_PER_METHOD) {
- methodBuilder.addCode(CodeBlocks.concat(cancellationStatements)).build();
- } else {
- ImmutableList<MethodSpec> cancelProducersMethods =
- createPartitionedMethods(
- "cancelProducers",
- parameters,
- cancellationStatements,
- methodName -> methodBuilder(methodName).addModifiers(PRIVATE));
- for (MethodSpec cancelProducersMethod : cancelProducersMethods) {
- methodBuilder.addStatement("$N($L)", cancelProducersMethod, MAY_INTERRUPT_IF_RUNNING);
- componentImplementation.addMethod(CANCELLATION_LISTENER_METHOD, cancelProducersMethod);
- }
- }
-
- Optional<CodeBlock> cancelParentStatement = cancelParentStatement();
- cancelParentStatement.ifPresent(methodBuilder::addCode);
-
- if (cancellationStatements.isEmpty()
- && !cancelParentStatement.isPresent()
- && componentImplementation.superclassImplementation().isPresent()) {
- // Partial child implementations that have no new cancellations don't need to override
- // the method just to call super().
- return;
- }
-
- componentImplementation.addMethod(CANCELLATION_LISTENER_METHOD, methodBuilder.build());
- }
-
- private ImmutableList<CodeBlock> cancellationStatements() {
- // Reversing should order cancellations starting from entry points and going down to leaves
- // rather than the other way around. This shouldn't really matter but seems *slightly*
- // preferable because:
- // When a future that another future depends on is cancelled, that cancellation will propagate
- // up the future graph toward the entry point. Cancelling in reverse order should ensure that
- // everything that depends on a particular node has already been cancelled when that node is
- // cancelled, so there's no need to propagate. Otherwise, when we cancel a leaf node, it might
- // propagate through most of the graph, making most of the cancel calls that follow in the
- // onProducerFutureCancelled method do nothing.
- ImmutableList<Key> cancellationKeys =
- componentImplementation.getCancellableProducerKeys().reverse();
-
- ImmutableList.Builder<CodeBlock> cancellationStatements = ImmutableList.builder();
- for (Key cancellationKey : cancellationKeys) {
- cancellationStatements.add(
- CodeBlock.of(
- "$T.cancel($L, $N);",
- Producers.class,
- bindingExpressions
- .getDependencyExpression(
- bindingRequest(cancellationKey, FrameworkType.PRODUCER_NODE),
- componentImplementation.name())
- .codeBlock(),
- MAY_INTERRUPT_IF_RUNNING));
- }
- return cancellationStatements.build();
- }
-
- protected Optional<CodeBlock> cancelParentStatement() {
- // Returns empty by default. Overridden in subclass(es) to add a statement if and only if the
- // component being generated is a concrete subcomponent implementation with a parent that
- // allows cancellation to propagate to it from subcomponents.
- return Optional.empty();
- }
-
- /**
- * For final components, reimplements all modifiable module methods that may have been modified.
- */
- private void implementModifiableModuleMethods() {
- if (componentImplementation.isAbstract()) {
- return;
- }
- componentImplementation
- .getAllModifiableModuleMethods()
- .forEach(this::implementModifiableModuleMethod);
- }
-
- private void implementModifiableModuleMethod(ComponentRequirement module, String methodName) {
- // TODO(b/117833324): only reimplement methods for modules that were abstract or were repeated
- // by an ancestor component.
- componentImplementation.addMethod(
- MODIFIABLE_BINDING_METHOD,
- methodBuilder(methodName)
- .addAnnotation(Override.class)
- .addModifiers(PROTECTED)
- .returns(TypeName.get(module.type()))
- .addStatement(
- componentRequirementExpressions
- .getExpression(module)
- .getModifiableModuleMethodExpression(componentImplementation.name()))
- .build());
- }
-
- private MethodSignature getMethodSignature(ComponentMethodDescriptor method) {
- return MethodSignature.forComponentMethod(
- method, MoreTypes.asDeclared(graph.componentTypeElement().asType()), types);
- }
-
- private void addChildComponents() {
- for (BindingGraph subgraph : graph.subgraphs()) {
- // TODO(b/117833324): Can an abstract inner subcomponent implementation be elided if it's
- // totally empty?
- componentImplementation.addChild(
- subgraph.componentDescriptor(), buildChildImplementation(subgraph));
- }
- }
-
- private ComponentImplementation buildChildImplementation(BindingGraph childGraph) {
- ComponentImplementation childImplementation =
- compilerOptions.aheadOfTimeSubcomponents()
- ? abstractInnerSubcomponent(childGraph)
- : concreteSubcomponent(childGraph);
- return topLevelImplementationComponent
- .currentImplementationSubcomponentBuilder()
- .componentImplementation(childImplementation)
- .bindingGraph(childGraph)
- .parentBuilder(Optional.of(this))
- .parentBindingExpressions(Optional.of(bindingExpressions))
- .parentRequirementExpressions(Optional.of(componentRequirementExpressions))
- .build()
- .subcomponentBuilder()
- .build();
- }
-
- /** Creates an inner abstract subcomponent implementation. */
- private ComponentImplementation abstractInnerSubcomponent(BindingGraph childGraph) {
- return componentImplementation.childComponentImplementation(
- childGraph,
- Optional.of(
- componentImplementationFactory.findChildSuperclassImplementation(
- childGraph.componentDescriptor(), componentImplementation)),
- PROTECTED,
- componentImplementation.isAbstract() ? ABSTRACT : FINAL);
- }
-
- /** Creates a concrete inner subcomponent implementation. */
- private ComponentImplementation concreteSubcomponent(BindingGraph childGraph) {
- return componentImplementation.childComponentImplementation(
- childGraph,
- Optional.empty(), // superclassImplementation
- PRIVATE,
- FINAL);
- }
-
- /** Creates and adds the constructor and methods needed for initializing the component. */
- private void addConstructorAndInitializationMethods() {
- MethodSpec.Builder constructor = componentConstructorBuilder();
- if (!componentImplementation.isAbstract()) {
- implementInitializationMethod(constructor, initializationParameters());
- } else if (componentImplementation.hasInitializations()) {
- addConfigureInitializationMethod();
- }
- componentImplementation.addMethod(CONSTRUCTOR, constructor.build());
- }
-
- /** Returns a builder for the component's constructor. */
- private MethodSpec.Builder componentConstructorBuilder() {
- return constructorBuilder()
- .addModifiers(componentImplementation.isAbstract() ? PROTECTED : PRIVATE);
- }
-
- /** Adds parameters and code to the given {@code initializationMethod}. */
- private void implementInitializationMethod(
- MethodSpec.Builder initializationMethod,
- ImmutableMap<ComponentRequirement, ParameterSpec> initializationParameters) {
- initializationMethod.addParameters(initializationParameters.values());
- initializationMethod.addCode(
- CodeBlocks.concat(componentImplementation.getComponentRequirementInitializations()));
- componentImplementation
- .superConfigureInitializationMethod()
- .ifPresent(
- superConfigureInitializationMethod ->
- addSuperConfigureInitializationCall(
- initializationMethod,
- initializationParameters,
- superConfigureInitializationMethod));
- addInitializeMethods(initializationMethod, initializationParameters.values().asList());
- }
-
- /** Creates and adds a {@code configureInitializatoin} method to the component. */
- private void addConfigureInitializationMethod() {
- MethodSpec.Builder method = configureInitializationMethodBuilder();
- ImmutableMap<ComponentRequirement, ParameterSpec> parameters = initializationParameters();
- implementInitializationMethod(method, parameters);
- componentImplementation.setConfigureInitializationMethod(
- ConfigureInitializationMethod.create(method.build(), parameters.keySet()));
- }
-
- /** Returns a builder for the component's {@code configureInitialization} method. */
- private MethodSpec.Builder configureInitializationMethodBuilder() {
- String methodName = componentImplementation.getUniqueMethodName("configureInitialization");
- MethodSpec.Builder configureInitialization = methodBuilder(methodName).addModifiers(PROTECTED);
- if (overridesSuperclassConfigureInitialization(configureInitialization.build())) {
- configureInitialization.addAnnotation(Override.class);
- }
- return configureInitialization;
- }
-
- /**
- * Returns whether or not the given method overrides a configureInitialization method from a
- * superclass.
- */
- private boolean overridesSuperclassConfigureInitialization(MethodSpec method) {
- for (Optional<ComponentImplementation> currentSuperImplementation =
- componentImplementation.superclassImplementation();
- currentSuperImplementation.isPresent();
- currentSuperImplementation = currentSuperImplementation.get().superclassImplementation()) {
- Optional<MethodSpec> superConfigureInitializationMethod =
- currentSuperImplementation.get().configureInitializationMethod().map(m -> m.spec());
- if (superConfigureInitializationMethod
- .filter(superMethod -> haveSameSignature(method, superMethod))
- .isPresent()) {
- return true;
- }
- }
-
- return false;
- }
-
- /** Returns whether or not methods {@code a} and {@code b} have the same signature. */
- private boolean haveSameSignature(MethodSpec a, MethodSpec b) {
- return a.name.equals(b.name) && types(a.parameters).equals(types(b.parameters));
- }
-
- private ImmutableList<TypeName> types(List<ParameterSpec> parameters) {
- return parameters.stream().map(parameter -> parameter.type).collect(toImmutableList());
- }
-
- /**
- * Adds a call to the superclass's {@code configureInitialization} method to the given {@code
- * callingMethod}.
- */
- private void addSuperConfigureInitializationCall(
- MethodSpec.Builder callingMethod,
- ImmutableMap<ComponentRequirement, ParameterSpec> parameters,
- ConfigureInitializationMethod superConfigureInitializationMethod) {
- // This component's constructor may not have all of the parameters that the superclass's
- // configureInitialization method takes, because the superclass configureInitialization method
- // necessarily accepts things that it can't know whether will be needed or not. If they aren't
- // needed (as is the case when the constructor doesn't have a parameter for the module), just
- // pass null to super.configureInitialization for that parameter; it won't be used.
- CodeBlock args =
- superConfigureInitializationMethod.parameters().stream()
- .map(
- requirement ->
- parameters.containsKey(requirement)
- ? CodeBlock.of("$N", parameters.get(requirement))
- : CodeBlock.of("null"))
- .collect(toParametersCodeBlock());
-
- String qualifier =
- haveSameSignature(callingMethod.build(), superConfigureInitializationMethod.spec())
- ? "super."
- : "";
- callingMethod.addStatement(
- qualifier + "$N($L)", superConfigureInitializationMethod.spec(), args);
- }
-
- /**
- * Adds any necessary {@code initialize} methods to the component and adds calls to them to the
- * given {@code callingMethod}.
- */
- private void addInitializeMethods(
- MethodSpec.Builder callingMethod, ImmutableList<ParameterSpec> parameters) {
- // TODO(cgdecker): It's not the case that each initialize() method has need for all of the
- // given parameters. In some cases, those parameters may have already been assigned to fields
- // which could be referenced instead. In other cases, an initialize method may just not need
- // some of the parameters because the set of initializations in that partition does not
- // include any reference to them. Right now, the Dagger code has no way of getting that
- // information because, among other things, componentImplementation.getImplementations() just
- // returns a bunch of CodeBlocks with no semantic information. Additionally, we may not know
- // yet whether a field will end up needing to be created for a specific requirement, and we
- // don't want to create a field that ends up only being used during initialization.
- CodeBlock args = parameterNames(parameters);
- ImmutableList<MethodSpec> methods =
- createPartitionedMethods(
- "initialize",
- makeFinal(parameters),
- componentImplementation.getInitializations(),
- methodName ->
- methodBuilder(methodName)
- .addModifiers(PRIVATE)
- /* TODO(gak): Strictly speaking, we only need the suppression here if we are
- * also initializing a raw field in this method, but the structure of this
- * code makes it awkward to pass that bit through. This will be cleaned up
- * when we no longer separate fields and initialization as we do now. */
- .addAnnotation(AnnotationSpecs.suppressWarnings(UNCHECKED)));
- for (MethodSpec method : methods) {
- callingMethod.addStatement("$N($L)", method, args);
- componentImplementation.addMethod(INITIALIZE_METHOD, method);
- }
- }
-
- /**
- * Creates one or more methods, all taking the given {@code parameters}, which partition the given
- * list of {@code statements} among themselves such that no method has more than {@code
- * STATEMENTS_PER_METHOD} statements in it and such that the returned methods, if called in order,
- * will execute the {@code statements} in the given order.
- */
- private ImmutableList<MethodSpec> createPartitionedMethods(
- String methodName,
- Iterable<ParameterSpec> parameters,
- List<CodeBlock> statements,
- Function<String, MethodSpec.Builder> methodBuilderCreator) {
- return Lists.partition(statements, STATEMENTS_PER_METHOD).stream()
- .map(
- partition ->
- methodBuilderCreator
- .apply(componentImplementation.getUniqueMethodName(methodName))
- .addParameters(parameters)
- .addCode(CodeBlocks.concat(partition))
- .build())
- .collect(toImmutableList());
- }
-
- /** Returns the given parameters with a final modifier added. */
- private final ImmutableList<ParameterSpec> makeFinal(Collection<ParameterSpec> parameters) {
- return parameters.stream()
- .map(param -> param.toBuilder().addModifiers(FINAL).build())
- .collect(toImmutableList());
- }
-
- /**
- * Returns the parameters for the constructor or {@code configureInitilization} method as a map
- * from the requirement the parameter fulfills to the spec for the parameter.
- */
- private final ImmutableMap<ComponentRequirement, ParameterSpec> initializationParameters() {
- Map<ComponentRequirement, ParameterSpec> parameters;
- if (componentImplementation.componentDescriptor().hasCreator()) {
- parameters =
- Maps.toMap(componentImplementation.requirements(), ComponentRequirement::toParameterSpec);
- } else if (componentImplementation.isAbstract() && componentImplementation.isNested()) {
- // If we're generating an abstract inner subcomponent, then we are not implementing module
- // instance bindings and have no need for factory method parameters.
- parameters = ImmutableMap.of();
- } else if (graph.factoryMethod().isPresent()) {
- parameters = getFactoryMethodParameters(graph);
- } else if (componentImplementation.isAbstract()) {
- // If we're generating an abstract base implementation of a subcomponent it's acceptable to
- // have neither a creator nor factory method.
- parameters = ImmutableMap.of();
- } else {
- throw new AssertionError(
- "Expected either a component creator or factory method but found neither.");
- }
-
- if (componentImplementation.isAbstract()) {
- parameters = Maps.filterKeys(parameters, in(configureInitializationRequirements()));
- }
- return renameParameters(parameters);
- }
-
- /**
- * Returns the set of requirements for the configureInitialization method: the parameters that are
- * needed either for initializing a component requirement field or for calling the superclass's
- * {@code configureInitialization} method.
- */
- private ImmutableSet<ComponentRequirement> configureInitializationRequirements() {
- ImmutableSet<ComponentRequirement> initializationParameters =
- componentImplementation.getComponentRequirementParameters();
- ImmutableSet<ComponentRequirement> superConfigureInitializationRequirements =
- componentImplementation
- .superConfigureInitializationMethod()
- .map(ConfigureInitializationMethod::parameters)
- .orElse(ImmutableSet.of());
- return Sets.union(initializationParameters, superConfigureInitializationRequirements)
- .immutableCopy();
- }
-
- /**
- * Renames the given parameters to guarantee their names do not conflict with fields in the
- * component to ensure that a parameter is never referenced where a reference to a field was
- * intended.
- */
- // TODO(cgdecker): This is a bit kludgy; it would be preferable to either qualify the field
- // references with "this." or "super." when needed to disambiguate between field and parameter,
- // but that would require more context than is currently available when the code referencing a
- // field is generated.
- private ImmutableMap<ComponentRequirement, ParameterSpec> renameParameters(
- Map<ComponentRequirement, ParameterSpec> parameters) {
- return ImmutableMap.copyOf(
- Maps.transformEntries(
- parameters,
- (requirement, parameter) ->
- renameParameter(
- parameter,
- componentImplementation.getParameterName(requirement, parameter.name))));
- }
-
- private ParameterSpec renameParameter(ParameterSpec parameter, String newName) {
- return ParameterSpec.builder(parameter.type, newName)
- .addAnnotations(parameter.annotations)
- .addModifiers(parameter.modifiers)
- .build();
- }
-
- /** Builds a root component implementation. */
- static final class RootComponentImplementationBuilder extends ComponentImplementationBuilder {
- @Inject
- RootComponentImplementationBuilder(ComponentImplementation componentImplementation) {
- checkArgument(!componentImplementation.superclassImplementation().isPresent());
- }
-
- @Override
- protected void addCreatorClass(TypeSpec creator) {
- componentImplementation.addType(COMPONENT_CREATOR, creator);
- }
-
- @Override
- protected void addFactoryMethods() {
- // Top-level components have a static method that returns a builder or factory for the
- // component. If the user defined a @Component.Builder or @Component.Factory, an
- // implementation of their type is returned. Otherwise, an autogenerated Builder type is
- // returned.
- // TODO(cgdecker): Replace this abomination with a small class?
- // Better yet, change things so that an autogenerated builder type has a descriptor of sorts
- // just like a user-defined creator type.
- ComponentCreatorKind creatorKind;
- ClassName creatorType;
- String factoryMethodName;
- boolean noArgFactoryMethod;
- if (creatorDescriptor().isPresent()) {
- ComponentCreatorDescriptor descriptor = creatorDescriptor().get();
- creatorKind = descriptor.kind();
- creatorType = ClassName.get(descriptor.typeElement());
- factoryMethodName = descriptor.factoryMethod().getSimpleName().toString();
- noArgFactoryMethod = descriptor.factoryParameters().isEmpty();
- } else {
- creatorKind = BUILDER;
- creatorType = componentCreatorName();
- factoryMethodName = "build";
- noArgFactoryMethod = true;
- }
-
- MethodSpec creatorFactoryMethod =
- methodBuilder(creatorKind.methodName())
- .addModifiers(PUBLIC, STATIC)
- .returns(creatorType)
- .addStatement("return new $T()", componentCreatorName())
- .build();
- componentImplementation.addMethod(BUILDER_METHOD, creatorFactoryMethod);
- if (noArgFactoryMethod && canInstantiateAllRequirements()) {
- componentImplementation.addMethod(
- BUILDER_METHOD,
- methodBuilder("create")
- .returns(ClassName.get(super.graph.componentTypeElement()))
- .addModifiers(PUBLIC, STATIC)
- .addStatement(
- "return new $L().$L()", creatorKind.typeName(), factoryMethodName)
- .build());
- }
- }
-
- private Optional<ComponentCreatorDescriptor> creatorDescriptor() {
- return graph.componentDescriptor().creatorDescriptor();
- }
-
- /** {@code true} if all of the graph's required dependencies can be automatically constructed */
- private boolean canInstantiateAllRequirements() {
- return !Iterables.any(
- graph.componentRequirements(),
- dependency -> dependency.requiresAPassedInstance(elements, types));
- }
-
- private ClassName componentCreatorName() {
- return componentImplementation.creatorImplementation().get().name();
- }
- }
-
- /**
- * Builds a subcomponent implementation. If generating ahead-of-time subcomponents, this may be an
- * abstract base class implementation, an abstract inner implementation, or a concrete
- * implementation that extends an abstract base implementation. Otherwise it represents a private,
- * inner, concrete, final implementation of a subcomponent which extends a user defined type.
- */
- static final class SubcomponentImplementationBuilder extends ComponentImplementationBuilder {
- final Optional<ComponentImplementationBuilder> parent;
-
- @Inject
- SubcomponentImplementationBuilder(
- @ParentComponent Optional<ComponentImplementationBuilder> parent) {
- this.parent = parent;
- }
-
- @Override
- protected void addCreatorClass(TypeSpec creator) {
- if (parent.isPresent()) {
- // In an inner implementation of a subcomponent the creator is a peer class.
- parent.get().componentImplementation.addType(SUBCOMPONENT, creator);
- } else {
- componentImplementation.addType(SUBCOMPONENT, creator);
- }
- }
-
- @Override
- protected void addFactoryMethods() {
- // Only construct instances of subcomponents that have concrete implementations.
- if (!componentImplementation.isAbstract()) {
- // Use the parent's factory method to create this subcomponent if the
- // subcomponent was not added via {@link dagger.Module#subcomponents()}.
- graph.factoryMethod().ifPresent(this::createSubcomponentFactoryMethod);
- }
- }
-
- 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 DeclaredType parentType() {
- return asDeclared(parent.get().graph.componentTypeElement().asType());
- }
-
- @Override
- protected void addInterfaceMethods() {
- if (componentImplementation.superclassImplementation().isPresent()) {
- // Since we're overriding a subcomponent implementation we add to its implementation given
- // an expanded binding graph.
-
- ComponentImplementation superclassImplementation =
- componentImplementation.superclassImplementation().get();
- for (ModifiableBindingMethod superclassModifiableBindingMethod :
- superclassImplementation.getModifiableBindingMethods().values()) {
- bindingExpressions
- .modifiableBindingExpressions()
- .possiblyReimplementedMethod(superclassModifiableBindingMethod)
- .ifPresent(componentImplementation::addImplementedModifiableBindingMethod);
- }
- } else {
- super.addInterfaceMethods();
- }
- }
-
- @Override
- protected Optional<CodeBlock> cancelParentStatement() {
- if (!shouldPropagateCancellationToParent()) {
- return Optional.empty();
- }
- return Optional.of(
- CodeBlock.builder()
- .addStatement(
- "$T.this.$N($N)",
- parent.get().componentImplementation.name(),
- CANCELLATION_LISTENER_METHOD_NAME,
- MAY_INTERRUPT_IF_RUNNING)
- .build());
- }
-
- private boolean shouldPropagateCancellationToParent() {
- return parent.isPresent()
- && parent
- .get()
- .componentImplementation
- .componentDescriptor()
- .cancellationPolicy()
- .map(policy -> policy.fromSubcomponents().equals(PROPAGATE))
- .orElse(false);
- }
- }
-
- /**
- * Returns the map of {@link ComponentRequirement}s to {@link ParameterSpec}s for the
- * given graph's factory method.
- */
- private static Map<ComponentRequirement, ParameterSpec> getFactoryMethodParameters(
- BindingGraph graph) {
- return Maps.transformValues(graph.factoryMethodParameters(), ParameterSpec::get);
- }
-}
diff --git a/java/dagger/internal/codegen/ComponentImplementationFactory.java b/java/dagger/internal/codegen/ComponentImplementationFactory.java
deleted file mode 100644
index 9578ece..0000000
--- a/java/dagger/internal/codegen/ComponentImplementationFactory.java
+++ /dev/null
@@ -1,162 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkState;
-import static dagger.internal.codegen.ComponentGenerator.componentName;
-import static dagger.internal.codegen.Util.reentrantComputeIfAbsent;
-import static javax.tools.Diagnostic.Kind.WARNING;
-
-import com.squareup.javapoet.ClassName;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.serialization.ProtoSerialization.InconsistentSerializedProtoException;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Optional;
-import javax.annotation.processing.Messager;
-import javax.inject.Inject;
-import javax.inject.Singleton;
-import javax.lang.model.element.TypeElement;
-
-/** Factory for {@link ComponentImplementation}s. */
-@Singleton
-final class ComponentImplementationFactory implements ClearableCache {
- private final Map<TypeElement, ComponentImplementation> topLevelComponentCache = new HashMap<>();
- private final KeyFactory keyFactory;
- private final CompilerOptions compilerOptions;
- private final BindingGraphFactory bindingGraphFactory;
- private final TopLevelImplementationComponent.Builder topLevelImplementationComponentBuilder;
- private final DeserializedComponentImplementationBuilder
- deserializedComponentImplementationBuilder;
- private final DaggerElements elements;
- private final Messager messager;
-
- @Inject
- ComponentImplementationFactory(
- KeyFactory keyFactory,
- CompilerOptions compilerOptions,
- BindingGraphFactory bindingGraphFactory,
- TopLevelImplementationComponent.Builder topLevelImplementationComponentBuilder,
- DeserializedComponentImplementationBuilder deserializedComponentImplementationBuilder,
- DaggerElements elements,
- Messager messager) {
- this.keyFactory = keyFactory;
- this.compilerOptions = compilerOptions;
- this.bindingGraphFactory = bindingGraphFactory;
- this.topLevelImplementationComponentBuilder = topLevelImplementationComponentBuilder;
- this.deserializedComponentImplementationBuilder = deserializedComponentImplementationBuilder;
- this.elements = elements;
- this.messager = messager;
- }
-
- /**
- * Returns a top-level (non-nested) component implementation for a binding graph.
- *
- * @throws IllegalStateException if the binding graph is for a subcomponent and
- * ahead-of-time-subcomponents mode is not enabled
- */
- ComponentImplementation createComponentImplementation(BindingGraph bindingGraph) {
- return reentrantComputeIfAbsent(
- topLevelComponentCache,
- bindingGraph.componentTypeElement(),
- component -> createComponentImplementationUncached(bindingGraph));
- }
-
- private ComponentImplementation createComponentImplementationUncached(BindingGraph bindingGraph) {
- ComponentImplementation componentImplementation =
- ComponentImplementation.topLevelComponentImplementation(
- bindingGraph,
- componentName(bindingGraph.componentTypeElement()),
- new SubcomponentNames(bindingGraph, keyFactory),
- compilerOptions);
-
- // TODO(dpb): explore using optional bindings for the "parent" bindings
- CurrentImplementationSubcomponent currentImplementationSubcomponent =
- topLevelImplementationComponentBuilder
- .topLevelComponent(componentImplementation)
- .build()
- .currentImplementationSubcomponentBuilder()
- .componentImplementation(componentImplementation)
- .bindingGraph(bindingGraph)
- .parentBuilder(Optional.empty())
- .parentBindingExpressions(Optional.empty())
- .parentRequirementExpressions(Optional.empty())
- .build();
-
- if (componentImplementation.isAbstract()) {
- checkState(
- compilerOptions.aheadOfTimeSubcomponents(),
- "Calling 'componentImplementation()' on %s when not generating ahead-of-time "
- + "subcomponents.",
- bindingGraph.componentTypeElement());
- return currentImplementationSubcomponent.subcomponentBuilder().build();
- } else {
- return currentImplementationSubcomponent.rootComponentBuilder().build();
- }
- }
-
- /** Returns the superclass of the child nested within a superclass of the parent component. */
- ComponentImplementation findChildSuperclassImplementation(
- ComponentDescriptor child, ComponentImplementation parentImplementation) {
- // If the current component has superclass implementations, a superclass may contain a
- // reference to the child. Traverse this component's superimplementation hierarchy looking for
- // the child's implementation. The child superclass implementation may not be present in the
- // direct superclass implementations if the subcomponent builder was previously a pruned
- // binding.
- for (Optional<ComponentImplementation> parent = parentImplementation.superclassImplementation();
- parent.isPresent();
- parent = parent.get().superclassImplementation()) {
- Optional<ComponentImplementation> superclass = parent.get().childImplementation(child);
- if (superclass.isPresent()) {
- return superclass.get();
- }
- }
-
- if (compilerOptions.emitModifiableMetadataAnnotations()) {
- ClassName childSuperclassName = componentName(child.typeElement());
- TypeElement generatedChildSuperclassImplementation =
- elements.getTypeElement(childSuperclassName);
- if (generatedChildSuperclassImplementation != null) {
- try {
- return deserializedComponentImplementationBuilder.create(
- child, generatedChildSuperclassImplementation);
- } catch (InconsistentSerializedProtoException e) {
- messager.printMessage(
- WARNING,
- String.format(
- "%s was compiled with a different version of Dagger than the version in this "
- + "compilation. To ensure the validity of Dagger's generated code, compile "
- + "all Dagger code with the same version.",
- child.typeElement().getQualifiedName()));
- }
- } else if (compilerOptions.forceUseSerializedComponentImplementations()) {
- throw new TypeNotPresentException(childSuperclassName.toString(), null);
- }
- }
-
- // Otherwise, the superclass implementation is top-level, so we must recreate the
- // implementation object for the base implementation of the child by truncating the binding
- // graph at the child.
- BindingGraph truncatedBindingGraph = bindingGraphFactory.create(child, false);
- return createComponentImplementation(truncatedBindingGraph);
- }
-
- @Override
- public void clearCache() {
- topLevelComponentCache.clear();
- }
-}
diff --git a/java/dagger/internal/codegen/ComponentInstanceBindingExpression.java b/java/dagger/internal/codegen/ComponentInstanceBindingExpression.java
deleted file mode 100644
index e98d595..0000000
--- a/java/dagger/internal/codegen/ComponentInstanceBindingExpression.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import dagger.internal.codegen.javapoet.Expression;
-
-/** A binding expression for the instance of the component itself, i.e. {@code this}. */
-final class ComponentInstanceBindingExpression extends SimpleInvocationBindingExpression {
- private final ClassName componentName;
- private final ContributionBinding binding;
-
- ComponentInstanceBindingExpression(ResolvedBindings resolvedBindings, ClassName componentName) {
- super(resolvedBindings);
- this.componentName = componentName;
- this.binding = resolvedBindings.contributionBinding();
- }
-
- @Override
- Expression getDependencyExpression(ClassName requestingClass) {
- return Expression.create(
- binding.key().type(),
- componentName.equals(requestingClass)
- ? CodeBlock.of("this")
- : CodeBlock.of("$T.this", componentName));
- }
-}
diff --git a/java/dagger/internal/codegen/ComponentKind.java b/java/dagger/internal/codegen/ComponentKind.java
deleted file mode 100644
index 8e5b9ba..0000000
--- a/java/dagger/internal/codegen/ComponentKind.java
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreElements.isAnnotationPresent;
-import static com.google.common.collect.Sets.immutableEnumSet;
-import static dagger.internal.codegen.DaggerStreams.stream;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.internal.codegen.DaggerStreams.valuesOf;
-import static java.util.EnumSet.allOf;
-
-import com.google.common.collect.ImmutableSet;
-import dagger.Component;
-import dagger.Module;
-import dagger.Subcomponent;
-import dagger.producers.ProducerModule;
-import dagger.producers.ProductionComponent;
-import dagger.producers.ProductionSubcomponent;
-import java.lang.annotation.Annotation;
-import java.util.Optional;
-import javax.lang.model.element.TypeElement;
-
-/** Enumeration of the different kinds of components. */
-enum ComponentKind {
- /** {@code @Component} */
- COMPONENT(Component.class, true, false),
-
- /** {@code @Subcomponent} */
- SUBCOMPONENT(Subcomponent.class, false, false),
-
- /** {@code @ProductionComponent} */
- PRODUCTION_COMPONENT(ProductionComponent.class, true, true),
-
- /** {@code @ProductionSubcomponent} */
- PRODUCTION_SUBCOMPONENT(ProductionSubcomponent.class, false, true),
-
- /**
- * Kind for a descriptor that was generated from a {@link Module} instead of a component type in
- * order to validate the module's bindings.
- */
- MODULE(Module.class, true, false),
-
- /**
- * Kind for a descriptor was generated from a {@link ProducerModule} instead of a component type
- * in order to validate the module's bindings.
- */
- PRODUCER_MODULE(ProducerModule.class, true, true),
- ;
-
- private static final ImmutableSet<ComponentKind> ROOT_COMPONENT_KINDS =
- valuesOf(ComponentKind.class)
- .filter(kind -> !kind.isForModuleValidation())
- .filter(kind -> kind.isRoot())
- .collect(toImmutableSet());
-
- private static final ImmutableSet<ComponentKind> SUBCOMPONENT_KINDS =
- valuesOf(ComponentKind.class)
- .filter(kind -> !kind.isForModuleValidation())
- .filter(kind -> !kind.isRoot())
- .collect(toImmutableSet());
-
- /** Returns the set of kinds for root components. */
- static ImmutableSet<ComponentKind> rootComponentKinds() {
- return ROOT_COMPONENT_KINDS;
- }
-
- /** Returns the set of kinds for subcomponents. */
- static ImmutableSet<ComponentKind> subcomponentKinds() {
- return SUBCOMPONENT_KINDS;
- }
-
- /** Returns the annotations for components of the given kinds. */
- static ImmutableSet<Class<? extends Annotation>> annotationsFor(Iterable<ComponentKind> kinds) {
- return stream(kinds).map(ComponentKind::annotation).collect(toImmutableSet());
- }
-
- /** Returns the set of component kinds the given {@code element} has annotations for. */
- static ImmutableSet<ComponentKind> getComponentKinds(TypeElement element) {
- return valuesOf(ComponentKind.class)
- .filter(kind -> isAnnotationPresent(element, kind.annotation()))
- .collect(toImmutableSet());
- }
-
- /**
- * Returns the kind of an annotated element if it is annotated with one of the {@linkplain
- * #annotation() annotations}.
- *
- * @throws IllegalArgumentException if the element is annotated with more than one of the
- * annotations
- */
- static Optional<ComponentKind> forAnnotatedElement(TypeElement element) {
- ImmutableSet<ComponentKind> kinds = getComponentKinds(element);
- if (kinds.size() > 1) {
- throw new IllegalArgumentException(
- element + " cannot be annotated with more than one of " + annotationsFor(kinds));
- }
- return kinds.stream().findAny();
- }
-
- private final Class<? extends Annotation> annotation;
- private final boolean isRoot;
- private final boolean production;
-
- ComponentKind(
- Class<? extends Annotation> annotation,
- boolean isRoot,
- boolean production) {
- this.annotation = annotation;
- this.isRoot = isRoot;
- this.production = production;
- }
-
- /** Returns the annotation that marks a component of this kind. */
- Class<? extends Annotation> annotation() {
- return annotation;
- }
-
- /** Returns the kinds of modules that can be used with a component of this kind. */
- ImmutableSet<ModuleKind> legalModuleKinds() {
- return isProducer()
- ? immutableEnumSet(allOf(ModuleKind.class))
- : immutableEnumSet(ModuleKind.MODULE);
- }
-
- /** Returns the kinds of subcomponents a component of this kind can have. */
- ImmutableSet<ComponentKind> legalSubcomponentKinds() {
- return isProducer()
- ? immutableEnumSet(PRODUCTION_SUBCOMPONENT)
- : immutableEnumSet(SUBCOMPONENT, PRODUCTION_SUBCOMPONENT);
- }
-
- /**
- * Returns {@code true} if the descriptor is for a root component (not a subcomponent) or is for
- * {@linkplain #isForModuleValidation() module-validation}.
- */
- boolean isRoot() {
- return isRoot;
- }
-
- /** Returns true if this is a production component. */
- boolean isProducer() {
- return production;
- }
-
- /** Returns {@code true} if the descriptor is for a module in order to validate its bindings. */
- boolean isForModuleValidation() {
- switch (this) {
- case MODULE:
- case PRODUCER_MODULE:
- return true;
- default:
- // fall through
- }
- return false;
- }
-}
diff --git a/java/dagger/internal/codegen/ComponentMethodBindingExpression.java b/java/dagger/internal/codegen/ComponentMethodBindingExpression.java
deleted file mode 100644
index 7e7bbd8..0000000
--- a/java/dagger/internal/codegen/ComponentMethodBindingExpression.java
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import dagger.internal.codegen.ComponentDescriptor.ComponentMethodDescriptor;
-import dagger.internal.codegen.javapoet.Expression;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import javax.lang.model.type.TypeMirror;
-
-/**
- * A binding expression that implements and uses a component method.
- *
- * <p>Dependents of this binding expression will just call the component method.
- */
-final class ComponentMethodBindingExpression extends MethodBindingExpression {
- private final ComponentImplementation componentImplementation;
- private final ComponentMethodDescriptor componentMethod;
-
- ComponentMethodBindingExpression(
- BindingRequest request,
- ResolvedBindings resolvedBindings,
- MethodImplementationStrategy methodImplementationStrategy,
- BindingExpression wrappedBindingExpression,
- ComponentImplementation componentImplementation,
- ComponentMethodDescriptor componentMethod,
- DaggerTypes types) {
- super(
- request,
- resolvedBindings,
- methodImplementationStrategy,
- wrappedBindingExpression,
- componentImplementation,
- types);
- this.componentImplementation = checkNotNull(componentImplementation);
- this.componentMethod = checkNotNull(componentMethod);
- }
-
- @Override
- protected CodeBlock getComponentMethodImplementation(
- ComponentMethodDescriptor componentMethod, ComponentImplementation component) {
- // There could be several methods on the component for the same request key and kind.
- // Only one should use the BindingMethodImplementation; the others can delegate that one. So
- // use methodImplementation.body() only if componentMethod equals the method for this instance.
-
- // Separately, the method might be defined on a supertype that is also a supertype of some
- // parent component. In that case, the same ComponentMethodDescriptor will be used to add a CMBE
- // for the parent and the child. Only the parent's should use the BindingMethodImplementation;
- // the child's can delegate to the parent. So use methodImplementation.body() only if
- // componentName equals the component for this instance.
- return componentMethod.equals(this.componentMethod) && component.equals(componentImplementation)
- ? methodBodyForComponentMethod(componentMethod)
- : super.getComponentMethodImplementation(componentMethod, component);
- }
-
- @Override
- Expression getDependencyExpression(ClassName requestingClass) {
- // If a component method returns a primitive, update the expression's type which might be boxed.
- Expression expression = super.getDependencyExpression(requestingClass);
- TypeMirror methodReturnType = componentMethod.methodElement().getReturnType();
- return methodReturnType.getKind().isPrimitive()
- ? Expression.create(methodReturnType, expression.codeBlock())
- : expression;
- }
-
- @Override
- protected void addMethod() {}
-
- @Override
- protected String methodName() {
- return componentMethod.methodElement().getSimpleName().toString();
- }
-}
diff --git a/java/dagger/internal/codegen/ComponentNodeImpl.java b/java/dagger/internal/codegen/ComponentNodeImpl.java
deleted file mode 100644
index 3a31ec7..0000000
--- a/java/dagger/internal/codegen/ComponentNodeImpl.java
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-
-import com.google.auto.value.AutoValue;
-import com.google.common.collect.ImmutableSet;
-import dagger.model.BindingGraph.ComponentNode;
-import dagger.model.ComponentPath;
-import dagger.model.DependencyRequest;
-import dagger.model.Scope;
-
-/** An implementation of {@link ComponentNode} that also exposes the {@link ComponentDescriptor}. */
-@AutoValue
-abstract class ComponentNodeImpl implements ComponentNode {
- static ComponentNode create(
- ComponentPath componentPath, ComponentDescriptor componentDescriptor) {
- return new AutoValue_ComponentNodeImpl(componentPath, componentDescriptor);
- }
-
- @Override
- public final boolean isSubcomponent() {
- return componentDescriptor().isSubcomponent();
- }
-
- @Override
- public boolean isRealComponent() {
- return componentDescriptor().isRealComponent();
- }
-
- @Override
- public final ImmutableSet<DependencyRequest> entryPoints() {
- return componentDescriptor().entryPointMethods().stream()
- .map(method -> method.dependencyRequest().get())
- .collect(toImmutableSet());
- }
-
- @Override
- public ImmutableSet<Scope> scopes() {
- return componentDescriptor().scopes();
- }
-
- abstract ComponentDescriptor componentDescriptor();
-
- @Override
- public final String toString() {
- return componentPath().toString();
- }
-}
diff --git a/java/dagger/internal/codegen/ComponentProcessingStep.java b/java/dagger/internal/codegen/ComponentProcessingStep.java
index 645c94f..3125ce7 100644
--- a/java/dagger/internal/codegen/ComponentProcessingStep.java
+++ b/java/dagger/internal/codegen/ComponentProcessingStep.java
@@ -16,27 +16,30 @@
package dagger.internal.codegen;
+import static com.google.auto.common.MoreElements.asType;
import static com.google.common.collect.Sets.union;
-import static dagger.internal.codegen.ComponentAnnotation.allComponentAnnotations;
-import static dagger.internal.codegen.ComponentAnnotation.rootComponentAnnotations;
-import static dagger.internal.codegen.ComponentAnnotation.subcomponentAnnotations;
-import static dagger.internal.codegen.ComponentCreatorAnnotation.allCreatorAnnotations;
-import static dagger.internal.codegen.ComponentCreatorAnnotation.rootComponentCreatorAnnotations;
-import static dagger.internal.codegen.ComponentCreatorAnnotation.subcomponentCreatorAnnotations;
-import static dagger.internal.codegen.ValidationType.NONE;
+import static dagger.internal.codegen.base.ComponentAnnotation.allComponentAnnotations;
+import static dagger.internal.codegen.base.ComponentAnnotation.rootComponentAnnotations;
+import static dagger.internal.codegen.base.ComponentAnnotation.subcomponentAnnotations;
+import static dagger.internal.codegen.binding.ComponentCreatorAnnotation.allCreatorAnnotations;
import static java.util.Collections.disjoint;
import com.google.auto.common.BasicAnnotationProcessor.ProcessingStep;
import com.google.auto.common.MoreElements;
-import com.google.common.base.Predicates;
-import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Multimaps;
-import com.google.common.collect.SetMultimap;
-import dagger.internal.codegen.ComponentValidator.ComponentValidationReport;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import dagger.internal.codegen.base.SourceFileGenerator;
+import dagger.internal.codegen.binding.BindingGraph;
+import dagger.internal.codegen.binding.BindingGraphFactory;
+import dagger.internal.codegen.binding.ComponentDescriptor;
+import dagger.internal.codegen.binding.ComponentDescriptorFactory;
+import dagger.internal.codegen.validation.BindingGraphValidator;
+import dagger.internal.codegen.validation.ComponentCreatorValidator;
+import dagger.internal.codegen.validation.ComponentDescriptorValidator;
+import dagger.internal.codegen.validation.ComponentValidator;
+import dagger.internal.codegen.validation.TypeCheckingProcessingStep;
+import dagger.internal.codegen.validation.ValidationReport;
import java.lang.annotation.Annotation;
-import java.util.HashMap;
-import java.util.Map;
import java.util.Set;
import javax.annotation.processing.Messager;
import javax.inject.Inject;
@@ -55,14 +58,7 @@
private final ComponentDescriptorFactory componentDescriptorFactory;
private final BindingGraphFactory bindingGraphFactory;
private final SourceFileGenerator<BindingGraph> componentGenerator;
- private final BindingGraphConverter bindingGraphConverter;
private final BindingGraphValidator bindingGraphValidator;
- private final CompilerOptions compilerOptions;
- private ImmutableSet<Element> subcomponentElements;
- private ImmutableSet<Element> subcomponentCreatorElements;
- private ImmutableMap<Element, ValidationReport<TypeElement>> creatorReportsByComponent;
- private ImmutableMap<Element, ValidationReport<TypeElement>> creatorReportsBySubcomponent;
- private ImmutableMap<Element, ValidationReport<TypeElement>> reportsBySubcomponent;
@Inject
ComponentProcessingStep(
@@ -73,9 +69,7 @@
ComponentDescriptorFactory componentDescriptorFactory,
BindingGraphFactory bindingGraphFactory,
SourceFileGenerator<BindingGraph> componentGenerator,
- BindingGraphConverter bindingGraphConverter,
- BindingGraphValidator bindingGraphValidator,
- CompilerOptions compilerOptions) {
+ BindingGraphValidator bindingGraphValidator) {
super(MoreElements::asType);
this.messager = messager;
this.componentValidator = componentValidator;
@@ -84,9 +78,7 @@
this.componentDescriptorFactory = componentDescriptorFactory;
this.bindingGraphFactory = bindingGraphFactory;
this.componentGenerator = componentGenerator;
- this.bindingGraphConverter = bindingGraphConverter;
this.bindingGraphValidator = bindingGraphValidator;
- this.compilerOptions = compilerOptions;
}
@Override
@@ -95,27 +87,6 @@
}
@Override
- public ImmutableSet<Element> process(
- SetMultimap<Class<? extends Annotation>, Element> elementsByAnnotation) {
- subcomponentElements =
- getElementsFromAnnotations(elementsByAnnotation, subcomponentAnnotations());
- subcomponentCreatorElements =
- getElementsFromAnnotations(elementsByAnnotation, subcomponentCreatorAnnotations());
-
- ImmutableSet.Builder<Element> rejectedElements = ImmutableSet.builder();
-
- creatorReportsByComponent =
- processCreators(
- getElementsFromAnnotations(elementsByAnnotation, rootComponentCreatorAnnotations()),
- rejectedElements);
- creatorReportsBySubcomponent = processCreators(subcomponentCreatorElements, rejectedElements);
- reportsBySubcomponent =
- processSubcomponents(subcomponentElements, subcomponentCreatorElements, rejectedElements);
-
- return rejectedElements.addAll(super.process(elementsByAnnotation)).build();
- }
-
- @Override
protected void process(
TypeElement element, ImmutableSet<Class<? extends Annotation>> annotations) {
if (!disjoint(annotations, rootComponentAnnotations())) {
@@ -124,10 +95,13 @@
if (!disjoint(annotations, subcomponentAnnotations())) {
processSubcomponent(element);
}
+ if (!disjoint(annotations, allCreatorAnnotations())) {
+ processCreator(element);
+ }
}
private void processRootComponent(TypeElement component) {
- if (!isRootComponentValid(component)) {
+ if (!isComponentValid(component)) {
return;
}
ComponentDescriptor componentDescriptor =
@@ -135,112 +109,47 @@
if (!isValid(componentDescriptor)) {
return;
}
- if (!isFullBindingGraphValid(componentDescriptor)) {
+ if (!validateFullBindingGraph(componentDescriptor)) {
return;
}
BindingGraph bindingGraph = bindingGraphFactory.create(componentDescriptor, false);
- if (isValid(bindingGraph)) {
+ if (bindingGraphValidator.isValid(bindingGraph.topLevelBindingGraph())) {
generateComponent(bindingGraph);
}
}
private void processSubcomponent(TypeElement subcomponent) {
- if (!compilerOptions.aheadOfTimeSubcomponents()
- && compilerOptions.fullBindingGraphValidationType(subcomponent).equals(NONE)) {
- return;
- }
- if (!isSubcomponentValid(subcomponent)) {
+ if (!isComponentValid(subcomponent)) {
return;
}
ComponentDescriptor subcomponentDescriptor =
componentDescriptorFactory.subcomponentDescriptor(subcomponent);
// TODO(dpb): ComponentDescriptorValidator for subcomponents, as we do for root components.
- if (!isFullBindingGraphValid(subcomponentDescriptor)) {
- return;
- }
- if (compilerOptions.aheadOfTimeSubcomponents()) {
- BindingGraph bindingGraph = bindingGraphFactory.create(subcomponentDescriptor, false);
- if (isValid(bindingGraph)) {
- generateComponent(bindingGraph);
- }
- }
+ validateFullBindingGraph(subcomponentDescriptor);
}
private void generateComponent(BindingGraph bindingGraph) {
componentGenerator.generate(bindingGraph, messager);
}
- static ImmutableSet<Element> getElementsFromAnnotations(
- final SetMultimap<Class<? extends Annotation>, Element> elementsByAnnotation,
- Set<Class<? extends Annotation>> annotations) {
- return ImmutableSet.copyOf(
- Multimaps.filterKeys(elementsByAnnotation, Predicates.in(annotations)).values());
+ private void processCreator(Element creator) {
+ creatorValidator.validate(MoreElements.asType(creator)).printMessagesTo(messager);
}
- private ImmutableMap<Element, ValidationReport<TypeElement>> processCreators(
- Set<? extends Element> builderElements, ImmutableSet.Builder<Element> rejectedElements) {
- // Can't use an ImmutableMap.Builder here because a component may have (invalidly) more than one
- // builder type, and that would make ImmutableMap.Builder throw.
- Map<Element, ValidationReport<TypeElement>> reports = new HashMap<>();
- for (Element element : builderElements) {
- try {
- ValidationReport<TypeElement> report =
- creatorValidator.validate(MoreElements.asType(element));
- report.printMessagesTo(messager);
- reports.put(element.getEnclosingElement(), report);
- } catch (TypeNotPresentException e) {
- rejectedElements.add(element);
- }
- }
- return ImmutableMap.copyOf(reports);
+ private boolean isComponentValid(Element component) {
+ ValidationReport<?> report = componentValidator.validate(asType(component));
+ report.printMessagesTo(messager);
+ return report.isClean();
}
- private ImmutableMap<Element, ValidationReport<TypeElement>> processSubcomponents(
- Set<? extends Element> subcomponentElements,
- Set<? extends Element> subcomponentBuilderElements,
- ImmutableSet.Builder<Element> rejectedElements) {
- ImmutableMap.Builder<Element, ValidationReport<TypeElement>> reports = ImmutableMap.builder();
- for (Element element : subcomponentElements) {
- try {
- ComponentValidationReport report =
- componentValidator.validate(
- MoreElements.asType(element), subcomponentElements, subcomponentBuilderElements);
- report.report().printMessagesTo(messager);
- reports.put(element, report.report());
- } catch (TypeNotPresentException e) {
- rejectedElements.add(element);
- }
- }
- return reports.build();
- }
-
- private boolean isRootComponentValid(TypeElement rootComponent) {
- ComponentValidationReport validationReport =
- componentValidator.validate(
- rootComponent, subcomponentElements, subcomponentCreatorElements);
- validationReport.report().printMessagesTo(messager);
- return isClean(validationReport);
- }
-
- // TODO(dpb): Clean up generics so this can take TypeElement.
- private boolean isSubcomponentValid(Element subcomponentElement) {
- ValidationReport<?> subcomponentCreatorReport =
- creatorReportsBySubcomponent.get(subcomponentElement);
- if (subcomponentCreatorReport != null && !subcomponentCreatorReport.isClean()) {
- return false;
- }
- ValidationReport<?> subcomponentReport = reportsBySubcomponent.get(subcomponentElement);
- return subcomponentReport == null || subcomponentReport.isClean();
- }
-
- private boolean isFullBindingGraphValid(ComponentDescriptor componentDescriptor) {
- if (compilerOptions
- .fullBindingGraphValidationType(componentDescriptor.typeElement())
- .equals(NONE)) {
+ @CanIgnoreReturnValue
+ private boolean validateFullBindingGraph(ComponentDescriptor componentDescriptor) {
+ TypeElement component = componentDescriptor.typeElement();
+ if (!bindingGraphValidator.shouldDoFullBindingGraphValidation(component)) {
return true;
}
BindingGraph fullBindingGraph = bindingGraphFactory.create(componentDescriptor, true);
- return isValid(fullBindingGraph);
+ return bindingGraphValidator.isValid(fullBindingGraph.topLevelBindingGraph());
}
private boolean isValid(ComponentDescriptor componentDescriptor) {
@@ -249,30 +158,4 @@
componentDescriptorReport.printMessagesTo(messager);
return componentDescriptorReport.isClean();
}
-
- private boolean isValid(BindingGraph bindingGraph) {
- return bindingGraphValidator.isValid(bindingGraphConverter.convert(bindingGraph));
- }
-
- /**
- * Returns true if the component's report is clean, its builder report is clean, and all
- * referenced subcomponent reports and subcomponent builder reports are clean.
- */
- private boolean isClean(ComponentValidationReport report) {
- Element component = report.report().subject();
- ValidationReport<?> componentReport = report.report();
- if (!componentReport.isClean()) {
- return false;
- }
- ValidationReport<?> builderReport = creatorReportsByComponent.get(component);
- if (builderReport != null && !builderReport.isClean()) {
- return false;
- }
- for (Element element : report.referencedSubcomponents()) {
- if (!isSubcomponentValid(element)) {
- return false;
- }
- }
- return true;
- }
}
diff --git a/java/dagger/internal/codegen/ComponentProcessor.java b/java/dagger/internal/codegen/ComponentProcessor.java
index 541a4ab..e392252 100644
--- a/java/dagger/internal/codegen/ComponentProcessor.java
+++ b/java/dagger/internal/codegen/ComponentProcessor.java
@@ -16,25 +16,42 @@
package dagger.internal.codegen;
-import static net.ltgt.gradle.incap.IncrementalAnnotationProcessorType.DYNAMIC;
+import static net.ltgt.gradle.incap.IncrementalAnnotationProcessorType.ISOLATING;
import com.google.auto.common.BasicAnnotationProcessor;
import com.google.auto.service.AutoService;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterables;
-import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.common.collect.Sets;
import com.google.errorprone.annotations.CheckReturnValue;
import dagger.BindsInstance;
import dagger.Component;
import dagger.Module;
import dagger.Provides;
import dagger.internal.codegen.SpiModule.TestingPlugins;
+import dagger.internal.codegen.base.ClearableCache;
+import dagger.internal.codegen.base.SourceFileGenerationException;
+import dagger.internal.codegen.base.SourceFileGenerator;
+import dagger.internal.codegen.binding.InjectBindingRegistry;
+import dagger.internal.codegen.binding.MembersInjectionBinding;
+import dagger.internal.codegen.binding.ProvisionBinding;
+import dagger.internal.codegen.bindinggraphvalidation.BindingGraphValidationModule;
+import dagger.internal.codegen.compileroption.CompilerOptions;
+import dagger.internal.codegen.compileroption.ProcessingEnvironmentCompilerOptions;
+import dagger.internal.codegen.componentgenerator.ComponentGeneratorModule;
+import dagger.internal.codegen.validation.BindingGraphPlugins;
+import dagger.internal.codegen.validation.BindingMethodProcessingStep;
+import dagger.internal.codegen.validation.BindingMethodValidatorsModule;
+import dagger.internal.codegen.validation.BindsInstanceProcessingStep;
+import dagger.internal.codegen.validation.InjectBindingRegistryModule;
+import dagger.internal.codegen.validation.MonitoringModuleProcessingStep;
+import dagger.internal.codegen.validation.MultibindingAnnotationsProcessingStep;
import dagger.spi.BindingGraphPlugin;
import java.util.Arrays;
import java.util.Optional;
import java.util.Set;
+import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.Processor;
import javax.annotation.processing.RoundEnvironment;
import javax.inject.Inject;
@@ -48,7 +65,7 @@
*
* <p>TODO(gak): give this some better documentation
*/
-@IncrementalAnnotationProcessor(DYNAMIC)
+@IncrementalAnnotationProcessor(ISOLATING)
@AutoService(Processor.class)
public class ComponentProcessor extends BasicAnnotationProcessor {
private final Optional<ImmutableSet<BindingGraphPlugin>> testingPlugins;
@@ -58,8 +75,6 @@
@Inject SourceFileGenerator<MembersInjectionBinding> membersInjectorGenerator;
@Inject ImmutableList<ProcessingStep> processingSteps;
@Inject BindingGraphPlugins bindingGraphPlugins;
- @Inject CompilerOptions compilerOptions;
- @Inject DaggerStatisticsCollector statisticsCollector;
@Inject Set<ClearableCache> clearableCaches;
public ComponentProcessor() {
@@ -95,28 +110,19 @@
@Override
public Set<String> getSupportedOptions() {
- ImmutableSet.Builder<String> options = ImmutableSet.builder();
- options.addAll(ProcessingEnvironmentCompilerOptions.supportedOptions());
- options.addAll(bindingGraphPlugins.allSupportedOptions());
- if (compilerOptions.useGradleIncrementalProcessing()) {
- options.add("org.gradle.annotation.processing.isolating");
- }
- return options.build();
+ return Sets.union(
+ ProcessingEnvironmentCompilerOptions.supportedOptions(),
+ bindingGraphPlugins.allSupportedOptions())
+ .immutableCopy();
}
@Override
protected Iterable<? extends ProcessingStep> initSteps() {
- ProcessorComponent.builder()
- .processingEnvironmentModule(new ProcessingEnvironmentModule(processingEnv))
- .testingPlugins(testingPlugins)
- .build()
- .inject(this);
+ ProcessorComponent.factory().create(processingEnv, testingPlugins).inject(this);
- statisticsCollector.processingStarted();
bindingGraphPlugins.initializePlugins();
- return Iterables.transform(
- processingSteps,
- step -> new DaggerStatisticsCollectingProcessingStep(step, statisticsCollector));
+
+ return processingSteps;
}
@Singleton
@@ -124,32 +130,27 @@
modules = {
BindingGraphValidationModule.class,
BindingMethodValidatorsModule.class,
+ ComponentGeneratorModule.class,
InjectBindingRegistryModule.class,
ProcessingEnvironmentModule.class,
ProcessingRoundCacheModule.class,
ProcessingStepsModule.class,
SourceFileGeneratorsModule.class,
- SpiModule.class,
- SystemComponentsModule.class,
- TopLevelImplementationComponent.InstallationModule.class,
+ SpiModule.class
})
interface ProcessorComponent {
void inject(ComponentProcessor processor);
- static Builder builder() {
- return DaggerComponentProcessor_ProcessorComponent.builder();
+ static Factory factory() {
+ return DaggerComponentProcessor_ProcessorComponent.factory();
}
- @CanIgnoreReturnValue
- @Component.Builder
- interface Builder {
- Builder processingEnvironmentModule(ProcessingEnvironmentModule module);
-
- @BindsInstance
- Builder testingPlugins(
- @TestingPlugins Optional<ImmutableSet<BindingGraphPlugin>> testingPlugins);
-
- @CheckReturnValue ProcessorComponent build();
+ @Component.Factory
+ interface Factory {
+ @CheckReturnValue
+ ProcessorComponent create(
+ @BindsInstance ProcessingEnvironment processingEnv,
+ @BindsInstance @TestingPlugins Optional<ImmutableSet<BindingGraphPlugin>> testingPlugins);
}
}
@@ -159,6 +160,9 @@
static ImmutableList<ProcessingStep> processingSteps(
MapKeyProcessingStep mapKeyProcessingStep,
InjectProcessingStep injectProcessingStep,
+ AssistedInjectProcessingStep assistedInjectProcessingStep,
+ AssistedFactoryProcessingStep assistedFactoryProcessingStep,
+ AssistedProcessingStep assistedProcessingStep,
MonitoringModuleProcessingStep monitoringModuleProcessingStep,
MultibindingAnnotationsProcessingStep multibindingAnnotationsProcessingStep,
BindsInstanceProcessingStep bindsInstanceProcessingStep,
@@ -170,15 +174,14 @@
return ImmutableList.of(
mapKeyProcessingStep,
injectProcessingStep,
+ assistedInjectProcessingStep,
+ assistedFactoryProcessingStep,
+ assistedProcessingStep,
monitoringModuleProcessingStep,
multibindingAnnotationsProcessingStep,
bindsInstanceProcessingStep,
moduleProcessingStep,
compilerOptions.headerCompilation()
- // Ahead Of Time subcomponents use the regular hjar filtering in
- // HjarSourceFileGenerator since they must retain protected implementation methods
- // between subcomponents
- && !compilerOptions.aheadOfTimeSubcomponents()
? componentHjarProcessingStep
: componentProcessingStep,
bindingMethodProcessingStep);
@@ -187,10 +190,7 @@
@Override
protected void postRound(RoundEnvironment roundEnv) {
- statisticsCollector.roundFinished();
- if (roundEnv.processingOver()) {
- statisticsCollector.processingStopped();
- } else {
+ if (!roundEnv.processingOver()) {
try {
injectBindingRegistry.generateSourcesForRequiredBindings(
factoryGenerator, membersInjectorGenerator);
diff --git a/java/dagger/internal/codegen/ComponentProvisionBindingExpression.java b/java/dagger/internal/codegen/ComponentProvisionBindingExpression.java
deleted file mode 100644
index b8c6049..0000000
--- a/java/dagger/internal/codegen/ComponentProvisionBindingExpression.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import dagger.internal.Preconditions;
-import dagger.internal.codegen.javapoet.Expression;
-
-/** A binding expression for component provision methods. */
-final class ComponentProvisionBindingExpression extends SimpleInvocationBindingExpression {
- private final ProvisionBinding binding;
- private final BindingGraph bindingGraph;
- private final ComponentRequirementExpressions componentRequirementExpressions;
- private final CompilerOptions compilerOptions;
-
- ComponentProvisionBindingExpression(
- ResolvedBindings resolvedBindings,
- BindingGraph bindingGraph,
- ComponentRequirementExpressions componentRequirementExpressions,
- CompilerOptions compilerOptions) {
- super(resolvedBindings);
- this.binding = (ProvisionBinding) resolvedBindings.contributionBinding();
- this.bindingGraph = checkNotNull(bindingGraph);
- this.componentRequirementExpressions = checkNotNull(componentRequirementExpressions);
- this.compilerOptions = checkNotNull(compilerOptions);
- }
-
- @Override
- Expression getDependencyExpression(ClassName requestingClass) {
- CodeBlock invocation =
- CodeBlock.of(
- "$L.$L()",
- componentRequirementExpressions.getExpression(componentRequirement(), requestingClass),
- binding.bindingElement().get().getSimpleName());
- return Expression.create(
- binding.contributedPrimitiveType().orElse(binding.key().type()),
- maybeCheckForNull(binding, compilerOptions, invocation));
- }
-
- private ComponentRequirement componentRequirement() {
- return bindingGraph
- .componentDescriptor()
- .getDependencyThatDefinesMethod(binding.bindingElement().get());
- }
-
- static CodeBlock maybeCheckForNull(
- ProvisionBinding binding, CompilerOptions compilerOptions, CodeBlock invocation) {
- return binding.shouldCheckForNull(compilerOptions)
- ? CodeBlock.of(
- "$T.checkNotNull($L, $S)",
- Preconditions.class,
- invocation,
- "Cannot return null from a non-@Nullable component method")
- : invocation;
- }
-}
diff --git a/java/dagger/internal/codegen/ComponentRequirement.java b/java/dagger/internal/codegen/ComponentRequirement.java
deleted file mode 100644
index 3bed5da..0000000
--- a/java/dagger/internal/codegen/ComponentRequirement.java
+++ /dev/null
@@ -1,247 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreElements.getLocalAndInheritedMethods;
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static dagger.internal.codegen.SourceFiles.simpleVariableName;
-import static dagger.internal.codegen.Util.componentCanMakeNewInstances;
-import static dagger.internal.codegen.langmodel.DaggerElements.isAnyAnnotationPresent;
-import static javax.lang.model.element.Modifier.ABSTRACT;
-import static javax.lang.model.element.Modifier.STATIC;
-
-import com.google.auto.common.MoreTypes;
-import com.google.auto.value.AutoValue;
-import com.google.common.base.Equivalence;
-import com.google.common.collect.ImmutableSet;
-import com.squareup.javapoet.ParameterSpec;
-import com.squareup.javapoet.TypeName;
-import dagger.Binds;
-import dagger.BindsOptionalOf;
-import dagger.Provides;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.internal.codegen.serialization.ComponentRequirementProto;
-import dagger.internal.codegen.serialization.ComponentRequirementProto.BoundInstanceRequirement;
-import dagger.model.BindingKind;
-import dagger.model.Key;
-import dagger.multibindings.Multibinds;
-import dagger.producers.Produces;
-import java.util.Optional;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.TypeMirror;
-
-/** A type that a component needs an instance of. */
-@AutoValue
-abstract class ComponentRequirement {
- enum Kind {
- /** A type listed in the component's {@code dependencies} attribute. */
- DEPENDENCY,
-
- /** A type listed in the component or subcomponent's {@code modules} attribute. */
- MODULE,
-
- /**
- * An object that is passed to a builder's {@link dagger.BindsInstance @BindsInstance} method.
- */
- BOUND_INSTANCE,
- ;
-
- boolean isBoundInstance() {
- return equals(BOUND_INSTANCE);
- }
-
- boolean isModule() {
- return equals(MODULE);
- }
- }
-
- /** The kind of requirement. */
- abstract Kind kind();
-
- /** Returns true if this is a {@link Kind#BOUND_INSTANCE} requirement. */
- // TODO(ronshapiro): consider removing this and inlining the usages
- final boolean isBoundInstance() {
- return kind().isBoundInstance();
- }
-
- /**
- * The type of the instance the component must have, wrapped so that requirements can be used as
- * value types.
- */
- abstract Equivalence.Wrapper<TypeMirror> wrappedType();
-
- /** The type of the instance the component must have. */
- TypeMirror type() {
- return wrappedType().get();
- }
-
- /** The element associated with the type of this requirement. */
- TypeElement typeElement() {
- return MoreTypes.asTypeElement(type());
- }
-
- /** The action a component builder should take if it {@code null} is passed. */
- enum NullPolicy {
- /** Make a new instance. */
- NEW,
- /** Throw an exception. */
- THROW,
- /** Allow use of null values. */
- ALLOW,
- }
-
- /**
- * An override for the requirement's null policy. If set, this is used as the null policy instead
- * of the default behavior in {@link #nullPolicy}.
- *
- * <p>Some implementations' null policy can be determined upon construction (e.g., for binding
- * instances), but others' require Elements and Types, which must wait until {@link #nullPolicy}
- * is called.
- */
- abstract Optional<NullPolicy> overrideNullPolicy();
-
- /** The requirement's null policy. */
- NullPolicy nullPolicy(DaggerElements elements, DaggerTypes types) {
- if (overrideNullPolicy().isPresent()) {
- return overrideNullPolicy().get();
- }
- switch (kind()) {
- case MODULE:
- return componentCanMakeNewInstances(typeElement())
- ? NullPolicy.NEW
- : requiresAPassedInstance(elements, types) ? NullPolicy.THROW : NullPolicy.ALLOW;
- case DEPENDENCY:
- case BOUND_INSTANCE:
- return NullPolicy.THROW;
- }
- throw new AssertionError();
- }
-
- /**
- * Returns true if the passed {@link ComponentRequirement} requires a passed instance in order to
- * be used within a component.
- */
- boolean requiresAPassedInstance(DaggerElements elements, DaggerTypes types) {
- if (!kind().isModule()) {
- // Bound instances and dependencies always require the user to provide an instance.
- return true;
- }
- return requiresModuleInstance(elements, types) && !componentCanMakeNewInstances(typeElement());
- }
-
- /**
- * Returns {@code true} if an instance is needed for this (module) requirement.
- *
- * <p>An instance is only needed if there is a binding method on the module that is neither {@code
- * abstract} nor {@code static}; if all bindings are one of those, then there should be no
- * possible dependency on instance state in the module's bindings.
- */
- private boolean requiresModuleInstance(DaggerElements elements, DaggerTypes types) {
- ImmutableSet<ExecutableElement> methods =
- getLocalAndInheritedMethods(typeElement(), types, elements);
- return methods.stream()
- .filter(this::isBindingMethod)
- .map(ExecutableElement::getModifiers)
- .anyMatch(modifiers -> !modifiers.contains(ABSTRACT) && !modifiers.contains(STATIC));
- }
-
- private boolean isBindingMethod(ExecutableElement method) {
- // TODO(cgdecker): At the very least, we should have utility methods to consolidate this stuff
- // in one place; listing individual annotations all over the place is brittle.
- return isAnyAnnotationPresent(
- method,
- Provides.class,
- Produces.class,
- // TODO(ronshapiro): it would be cool to have internal meta-annotations that could describe
- // these, like @AbstractBindingMethod
- Binds.class,
- Multibinds.class,
- BindsOptionalOf.class);
- }
-
- /** The key for this requirement, if one is available. */
- abstract Optional<Key> key();
-
- /** Returns the name for this requirement that could be used as a variable. */
- abstract String variableName();
-
- /** Returns a parameter spec for this requirement. */
- ParameterSpec toParameterSpec() {
- return ParameterSpec.builder(TypeName.get(type()), variableName()).build();
- }
-
- /** Creates a proto representation of this requirement. */
- ComponentRequirementProto toProto() {
- switch (kind()) {
- case DEPENDENCY:
- return ComponentRequirementProto.newBuilder()
- .setDependency(TypeProtoConverter.toProto(type()))
- .build();
- case MODULE:
- return ComponentRequirementProto.newBuilder()
- .setModule(TypeProtoConverter.toProto(type()))
- .build();
- case BOUND_INSTANCE:
- return ComponentRequirementProto.newBuilder()
- .setBoundInstance(
- BoundInstanceRequirement.newBuilder()
- .setKey(KeyFactory.toProto(key().get()))
- .setNullable(overrideNullPolicy().equals(Optional.of(NullPolicy.ALLOW)))
- .setVariableName(variableName()))
- .build();
- }
- throw new AssertionError(this);
- }
-
- static ComponentRequirement forDependency(TypeMirror type) {
- return new AutoValue_ComponentRequirement(
- Kind.DEPENDENCY,
- MoreTypes.equivalence().wrap(checkNotNull(type)),
- Optional.empty(),
- Optional.empty(),
- simpleVariableName(MoreTypes.asTypeElement(type)));
- }
-
- static ComponentRequirement forModule(TypeMirror type) {
- return new AutoValue_ComponentRequirement(
- Kind.MODULE,
- MoreTypes.equivalence().wrap(checkNotNull(type)),
- Optional.empty(),
- Optional.empty(),
- simpleVariableName(MoreTypes.asTypeElement(type)));
- }
-
- static ComponentRequirement forBoundInstance(Key key, boolean nullable, String variableName) {
- return new AutoValue_ComponentRequirement(
- Kind.BOUND_INSTANCE,
- MoreTypes.equivalence().wrap(key.type()),
- nullable ? Optional.of(NullPolicy.ALLOW) : Optional.empty(),
- Optional.of(key),
- variableName);
- }
-
- static ComponentRequirement forBoundInstance(ContributionBinding binding) {
- checkArgument(binding.kind().equals(BindingKind.BOUND_INSTANCE));
- return forBoundInstance(
- binding.key(),
- binding.nullableType().isPresent(),
- binding.bindingElement().get().getSimpleName().toString());
- }
-}
diff --git a/java/dagger/internal/codegen/ComponentRequirementBindingExpression.java b/java/dagger/internal/codegen/ComponentRequirementBindingExpression.java
deleted file mode 100644
index d6aa053..0000000
--- a/java/dagger/internal/codegen/ComponentRequirementBindingExpression.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import com.squareup.javapoet.ClassName;
-import dagger.internal.codegen.javapoet.Expression;
-
-/**
- * A binding expression for instances bound with {@link dagger.BindsInstance} and instances of
- * {@linkplain dagger.Component#dependencies() component} and {@linkplain
- * dagger.producers.ProductionComponent#dependencies() production component dependencies}.
- */
-final class ComponentRequirementBindingExpression extends SimpleInvocationBindingExpression {
- private final ComponentRequirement componentRequirement;
- private final ComponentRequirementExpressions componentRequirementExpressions;
-
- ComponentRequirementBindingExpression(
- ResolvedBindings resolvedBindings,
- ComponentRequirement componentRequirement,
- ComponentRequirementExpressions componentRequirementExpressions) {
- super(resolvedBindings);
- this.componentRequirement = componentRequirement;
- this.componentRequirementExpressions = componentRequirementExpressions;
- }
-
- @Override
- Expression getDependencyExpression(ClassName requestingClass) {
- return Expression.create(
- componentRequirement.type(),
- componentRequirementExpressions.getExpression(componentRequirement, requestingClass));
- }
-}
diff --git a/java/dagger/internal/codegen/ComponentRequirementExpression.java b/java/dagger/internal/codegen/ComponentRequirementExpression.java
deleted file mode 100644
index b25c01b..0000000
--- a/java/dagger/internal/codegen/ComponentRequirementExpression.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-
-/**
- * A factory for expressions of {@link ComponentRequirement}s in the generated component. This is
- * <em>not</em> a {@link BindingExpression}, since {@link ComponentRequirement}s do not have a
- * {@link dagger.model.Key}. See {@link ComponentRequirementBindingExpression} for binding
- * expressions that are themselves a component requirement.
- */
-interface ComponentRequirementExpression {
- /**
- * Returns an expression for the {@link ComponentRequirement} to be used when implementing a
- * component method. This may add a field or method to the component in order to reference the
- * component requirement outside of the {@code initialize()} methods.
- */
- CodeBlock getExpression(ClassName requestingClass);
-
- /**
- * Returns an expression for the {@link ComponentRequirement} to be used only within {@code
- * initialize()} methods, where the constructor parameters are available.
- *
- * <p>When accessing this expression from a subcomponent, this may cause a field to be initialized
- * or a method to be added in the component that owns this {@link ComponentRequirement}.
- */
- default CodeBlock getExpressionDuringInitialization(ClassName requestingClass) {
- return getExpression(requestingClass);
- }
-
- /**
- * Returns the expression for the {@link ComponentRequirement} to be used when reimplementing a
- * modifiable module method.
- */
- default CodeBlock getModifiableModuleMethodExpression(ClassName requestingClass) {
- return CodeBlock.of("return $L", getExpression(requestingClass));
- }
-}
diff --git a/java/dagger/internal/codegen/ComponentRequirementExpressions.java b/java/dagger/internal/codegen/ComponentRequirementExpressions.java
deleted file mode 100644
index 4ab58c9..0000000
--- a/java/dagger/internal/codegen/ComponentRequirementExpressions.java
+++ /dev/null
@@ -1,334 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.CaseFormat.LOWER_CAMEL;
-import static com.google.common.base.CaseFormat.UPPER_CAMEL;
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.base.Suppliers.memoize;
-import static com.squareup.javapoet.MethodSpec.methodBuilder;
-import static dagger.internal.codegen.ComponentImplementation.FieldSpecKind.COMPONENT_REQUIREMENT_FIELD;
-import static dagger.internal.codegen.ModuleProxies.newModuleInstance;
-import static javax.lang.model.element.Modifier.ABSTRACT;
-import static javax.lang.model.element.Modifier.FINAL;
-import static javax.lang.model.element.Modifier.PRIVATE;
-import static javax.lang.model.element.Modifier.PROTECTED;
-
-import com.google.common.base.Supplier;
-import com.google.common.base.Suppliers;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.FieldSpec;
-import com.squareup.javapoet.MethodSpec;
-import com.squareup.javapoet.TypeName;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Optional;
-import javax.inject.Inject;
-import javax.lang.model.element.TypeElement;
-
-/**
- * A central repository of expressions used to access any {@link ComponentRequirement} available to
- * a component.
- */
-@PerComponentImplementation
-final class ComponentRequirementExpressions {
-
- // TODO(dpb,ronshapiro): refactor this and ComponentBindingExpressions into a
- // HierarchicalComponentMap<K, V>, or perhaps this use a flattened ImmutableMap, built from its
- // parents? If so, maybe make ComponentRequirementExpression.Factory create it.
-
- private final Optional<ComponentRequirementExpressions> parent;
- private final Map<ComponentRequirement, ComponentRequirementExpression>
- componentRequirementExpressions = new HashMap<>();
- private final BindingGraph graph;
- private final ComponentImplementation componentImplementation;
- private final CompilerOptions compilerOptions;
- private final DaggerElements elements;
-
- // TODO(ronshapiro): give ComponentImplementation a graph() method
- @Inject
- ComponentRequirementExpressions(
- @ParentComponent Optional<ComponentRequirementExpressions> parent,
- BindingGraph graph,
- ComponentImplementation componentImplementation,
- CompilerOptions compilerOptions,
- DaggerElements elements) {
- this.parent = parent;
- this.graph = graph;
- this.componentImplementation = componentImplementation;
- this.compilerOptions = compilerOptions;
- this.elements = elements;
- }
-
- /**
- * Returns an expression for the {@code componentRequirement} to be used when implementing a
- * component method. This may add a field or method to the component in order to reference the
- * component requirement outside of the {@code initialize()} methods.
- */
- CodeBlock getExpression(ComponentRequirement componentRequirement, ClassName requestingClass) {
- return getExpression(componentRequirement).getExpression(requestingClass);
- }
-
- /**
- * Returns an expression for the {@code componentRequirement} to be used only within {@code
- * initialize()} methods, where the component constructor parameters are available.
- *
- * <p>When accessing this expression from a subcomponent, this may cause a field to be initialized
- * or a method to be added in the component that owns this {@link ComponentRequirement}.
- */
- CodeBlock getExpressionDuringInitialization(
- ComponentRequirement componentRequirement, ClassName requestingClass) {
- return getExpression(componentRequirement).getExpressionDuringInitialization(requestingClass);
- }
-
- ComponentRequirementExpression getExpression(ComponentRequirement componentRequirement) {
- if (graph.componentRequirements().contains(componentRequirement)) {
- return componentRequirementExpressions.computeIfAbsent(
- componentRequirement, this::createMethodOrField);
- }
- if (parent.isPresent()) {
- return parent.get().getExpression(componentRequirement);
- }
-
- if (componentRequirement.kind().isModule() && compilerOptions.aheadOfTimeSubcomponents()) {
- return new PrunedModifiableModule(componentRequirement);
- }
-
- throw new IllegalStateException(
- "no component requirement expression found for " + componentRequirement);
- }
-
- /**
- * If {@code requirement} is a module that may be owned by a future ancestor component, returns a
- * modifiable module method. Otherwise, returns a field for {@code requirement}.
- */
- private ComponentRequirementExpression createMethodOrField(ComponentRequirement requirement) {
- if (componentImplementation.isAbstract() && requirement.kind().isModule()) {
- return new ModifiableModule(requirement);
- }
- return createField(requirement);
- }
-
- /** Returns a field for a {@link ComponentRequirement}. */
- private ComponentRequirementExpression createField(ComponentRequirement requirement) {
- if (componentImplementation.componentDescriptor().hasCreator()) {
- return new ComponentParameterField(requirement, componentImplementation, Optional.empty());
- } else if (graph.factoryMethod().isPresent()
- && graph.factoryMethodParameters().containsKey(requirement)) {
- String parameterName =
- graph.factoryMethodParameters().get(requirement).getSimpleName().toString();
- return new ComponentParameterField(
- requirement, componentImplementation, Optional.of(parameterName));
- } else if (requirement.kind().isModule()) {
- return new InstantiableModuleField(requirement, componentImplementation);
- } else {
- throw new AssertionError(
- String.format("Can't create %s in %s", requirement, componentImplementation.name()));
- }
- }
-
- private abstract static class AbstractField implements ComponentRequirementExpression {
- final ComponentRequirement componentRequirement;
- final ComponentImplementation componentImplementation;
- final String fieldName;
- private final Supplier<MemberSelect> field = memoize(this::addField);
-
- private AbstractField(
- ComponentRequirement componentRequirement,
- ComponentImplementation componentImplementation) {
- this.componentRequirement = checkNotNull(componentRequirement);
- this.componentImplementation = checkNotNull(componentImplementation);
- // Note: The field name is being claimed eagerly here even though we don't know at this point
- // whether or not the requirement will even need a field. This is done because:
- // A) ComponentParameterField wants to ensure that it doesn't give the parameter the same name
- // as any field in the component, which requires that it claim a "field name" for itself
- // when naming the parameter.
- // B) The parameter name may be needed before the field name is.
- // C) We want to prefer giving the best name to the field rather than the parameter given its
- // wider scope.
- this.fieldName =
- componentImplementation.getUniqueFieldName(componentRequirement.variableName());
- }
-
- @Override
- public CodeBlock getExpression(ClassName requestingClass) {
- return field.get().getExpressionFor(requestingClass);
- }
-
- private MemberSelect addField() {
- FieldSpec field = createField();
- componentImplementation.addField(COMPONENT_REQUIREMENT_FIELD, field);
- componentImplementation.addComponentRequirementInitialization(fieldInitialization(field));
- return MemberSelect.localField(componentImplementation.name(), fieldName);
- }
-
- private FieldSpec createField() {
- FieldSpec.Builder field =
- FieldSpec.builder(TypeName.get(componentRequirement.type()), fieldName, PRIVATE);
- if (!componentImplementation.isAbstract()) {
- field.addModifiers(FINAL);
- }
- return field.build();
- }
-
- /** Returns the {@link CodeBlock} that initializes the component field during construction. */
- abstract CodeBlock fieldInitialization(FieldSpec componentField);
- }
-
- /**
- * A {@link ComponentRequirementExpression} for {@link ComponentRequirement}s that can be
- * instantiated by the component (i.e. a static class with a no-arg constructor).
- */
- private final class InstantiableModuleField extends AbstractField {
- private final TypeElement moduleElement;
-
- private InstantiableModuleField(
- ComponentRequirement module, ComponentImplementation componentImplementation) {
- super(module, componentImplementation);
- checkArgument(module.kind().isModule());
- this.moduleElement = module.typeElement();
- }
-
- @Override
- CodeBlock fieldInitialization(FieldSpec componentField) {
- return CodeBlock.of(
- "this.$N = $L;",
- componentField,
- newModuleInstance(moduleElement, componentImplementation.name(), elements));
- }
- }
-
- /**
- * A {@link ComponentRequirementExpression} for {@link ComponentRequirement}s that are passed in
- * as parameters to the component's constructor.
- */
- private static final class ComponentParameterField extends AbstractField {
- private final String parameterName;
-
- private ComponentParameterField(
- ComponentRequirement componentRequirement,
- ComponentImplementation componentImplementation,
- Optional<String> name) {
- super(componentRequirement, componentImplementation);
- componentImplementation.addComponentRequirementParameter(componentRequirement);
- // Get the name that the component implementation will use for its parameter for the
- // requirement. If the given name is different than the name of the field created for the
- // requirement (as may be the case when the parameter name is derived from a user-written
- // factory method parameter), just use that as the base name for the parameter. Otherwise,
- // append "Param" to the end of the name to differentiate.
- // In either case, componentImplementation.getParameterName() will ensure that the final name
- // that is used is not the same name as any field in the component even if there's something
- // weird where the component actually has fields named, say, "foo" and "fooParam".
- String baseName = name.filter(n -> !n.equals(fieldName)).orElse(fieldName + "Param");
- this.parameterName = componentImplementation.getParameterName(componentRequirement, baseName);
- }
-
- @Override
- public CodeBlock getExpressionDuringInitialization(ClassName requestingClass) {
- if (componentImplementation.name().equals(requestingClass)) {
- return CodeBlock.of("$L", parameterName);
- } else {
- // requesting this component requirement during initialization of a child component requires
- // it to be accessed from a field and not the parameter (since it is no longer available)
- return getExpression(requestingClass);
- }
- }
-
- @Override
- CodeBlock fieldInitialization(FieldSpec componentField) {
- // Don't checkNotNull here because the parameter may be nullable; if it isn't, the caller
- // should handle checking that before passing the parameter.
- return CodeBlock.of("this.$N = $L;", componentField, parameterName);
- }
- }
-
- private final class ModifiableModule implements ComponentRequirementExpression {
- private final ComponentRequirement module;
- private final Supplier<MemberSelect> method = Suppliers.memoize(this::methodSelect);
-
- private ModifiableModule(ComponentRequirement module) {
- checkArgument(module.kind().isModule());
- this.module = module;
- }
-
- @Override
- public CodeBlock getExpression(ClassName requestingClass) {
- return method.get().getExpressionFor(requestingClass);
- }
-
- private MemberSelect methodSelect() {
- String methodName =
- componentImplementation
- .supertypeModifiableModuleMethodName(module)
- .orElseGet(this::createMethod);
- return MemberSelect.localMethod(componentImplementation.name(), methodName);
- }
-
- private String createMethod() {
- String methodName =
- UPPER_CAMEL.to(
- LOWER_CAMEL,
- componentImplementation.getUniqueMethodName(
- module.typeElement().getSimpleName().toString()));
- MethodSpec.Builder methodBuilder =
- methodBuilder(methodName)
- .addModifiers(PROTECTED)
- .returns(TypeName.get(module.type()));
- // TODO(b/117833324): if the module is instantiable, we could provide an implementation here
- // too. Then, if no ancestor ever repeats the module, there's nothing to do in subclasses.
- if (graph.componentDescriptor().creatorDescriptor().isPresent()) {
- methodBuilder.addStatement(
- "return $L",
- createField(module).getExpression(componentImplementation.name()));
- } else {
- methodBuilder.addModifiers(ABSTRACT);
- }
- componentImplementation.addModifiableModuleMethod(module, methodBuilder.build());
- return methodName;
- }
- }
-
- private static final class PrunedModifiableModule implements ComponentRequirementExpression {
- private final ComponentRequirement module;
-
- private PrunedModifiableModule(ComponentRequirement module) {
- checkArgument(module.kind().isModule());
- this.module = module;
- }
-
- @Override
- public CodeBlock getExpression(ClassName requestingClass) {
- throw new UnsupportedOperationException(module + " is pruned - it cannot be requested");
- }
-
- @Override
- public CodeBlock getModifiableModuleMethodExpression(ClassName requestingClass) {
- return CodeBlock.builder()
- .add(
- "// $L has been pruned from the final resolved binding graph. The result of this "
- + "method should never be used, but it may be called in an initialize() method "
- + "when creating a framework instance of a now-pruned binding. Those framework "
- + "instances should never be used.\n",
- module.typeElement())
- .add("return null")
- .build();
- }
- }
-}
diff --git a/java/dagger/internal/codegen/ComponentTreeTraverser.java b/java/dagger/internal/codegen/ComponentTreeTraverser.java
deleted file mode 100644
index cc1efd2..0000000
--- a/java/dagger/internal/codegen/ComponentTreeTraverser.java
+++ /dev/null
@@ -1,180 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkState;
-import static com.google.common.base.Verify.verify;
-import static dagger.internal.codegen.DaggerStreams.toImmutableList;
-
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Iterators;
-import dagger.internal.codegen.ComponentDescriptor.ComponentMethodDescriptor;
-import dagger.model.ComponentPath;
-import dagger.model.DependencyRequest;
-import java.util.ArrayDeque;
-import java.util.Deque;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-
-/**
- * An object that traverses the entire component hierarchy, starting from the root component.
- *
- * <p>Subclasses can override {@link #visitComponent(BindingGraph)} to perform custom logic at each
- * component in the tree, and {@link #visitSubcomponentFactoryMethod(BindingGraph, BindingGraph,
- * ExecutableElement)} to perform custom logic at each subcomponent factory method.
- */
-public class ComponentTreeTraverser {
-
- /** The path from the root graph to the currently visited graph. */
- private final Deque<BindingGraph> bindingGraphPath = new ArrayDeque<>();
-
- /** The {@link ComponentPath} for each component in {@link #bindingGraphPath}. */
- private final Deque<ComponentPath> componentPaths = new ArrayDeque<>();
-
- /** Constructs a traverser for a root (component, not subcomponent) binding graph. */
- public ComponentTreeTraverser(BindingGraph rootGraph) {
- bindingGraphPath.add(rootGraph);
- componentPaths.add(ComponentPath.create(ImmutableList.of(rootGraph.componentTypeElement())));
- }
-
- /**
- * Calls {@link #visitComponent(BindingGraph)} for the root component.
- *
- * @throws IllegalStateException if a traversal is in progress
- */
- public final void traverseComponents() {
- checkState(bindingGraphPath.size() == 1);
- checkState(componentPaths.size() == 1);
- visitComponent(bindingGraphPath.getFirst());
- }
-
- /**
- * Called once for each component in a component hierarchy.
- *
- * <p>Subclasses can override this method to perform whatever logic is required per component.
- * They should call the {@code super} implementation if they want to continue the traversal in the
- * standard order.
- *
- * <p>This implementation does the following:
- *
- * <ol>
- * <li>If this component is installed in its parent by a subcomponent factory method, calls
- * {@link #visitSubcomponentFactoryMethod(BindingGraph, BindingGraph, ExecutableElement)}.
- * <li>For each entry point in the component, calls {@link #visitEntryPoint(DependencyRequest,
- * BindingGraph)}.
- * <li>For each child component, calls {@link #visitComponent(BindingGraph)}, updating the
- * traversal state.
- * </ol>
- *
- * @param graph the currently visited graph
- */
- protected void visitComponent(BindingGraph graph) {
- if (bindingGraphPath.size() > 1) {
- BindingGraph parent = Iterators.get(bindingGraphPath.descendingIterator(), 1);
- parent
- .componentDescriptor()
- .getFactoryMethodForChildComponent(graph.componentDescriptor())
- .ifPresent(
- childFactoryMethod ->
- visitSubcomponentFactoryMethod(
- graph, parent, childFactoryMethod.methodElement()));
- }
-
- for (ComponentMethodDescriptor entryPointMethod :
- graph.componentDescriptor().entryPointMethods()) {
- visitEntryPoint(entryPointMethod.dependencyRequest().get(), graph);
- }
-
- for (BindingGraph child : graph.subgraphs()) {
- bindingGraphPath.addLast(child);
- ComponentPath childPath =
- ComponentPath.create(
- bindingGraphPath.stream()
- .map(BindingGraph::componentTypeElement)
- .collect(toImmutableList()));
- componentPaths.addLast(childPath);
- try {
- visitComponent(child);
- } finally {
- verify(bindingGraphPath.removeLast().equals(child));
- verify(componentPaths.removeLast().equals(childPath));
- }
- }
- }
-
- /**
- * Called if this component was installed in its parent by a subcomponent factory method.
- *
- * <p>This implementation does nothing.
- *
- * @param graph the currently visited graph
- * @param parent the parent graph
- * @param factoryMethod the factory method in the parent component that declares that the current
- * component is a child
- */
- protected void visitSubcomponentFactoryMethod(
- BindingGraph graph, BindingGraph parent, ExecutableElement factoryMethod) {}
-
- /**
- * Called once for each entry point in a component.
- *
- * <p>Subclasses can override this method to perform whatever logic is required per entry point.
- * They should call the {@code super} implementation if they want to continue the traversal in the
- * standard order.
- *
- * <p>This implementation does nothing.
- *
- * @param graph the graph for the component that contains the entry point
- */
- protected void visitEntryPoint(DependencyRequest entryPoint, BindingGraph graph) {}
-
- /**
- * Returns an immutable snapshot of the path from the root component to the currently visited
- * component.
- */
- protected final ComponentPath componentPath() {
- return componentPaths.getLast();
- }
-
- /**
- * Returns the subpath from the root component to the matching {@code ancestor} of the current
- * component.
- */
- protected final ComponentPath pathFromRootToAncestor(TypeElement ancestor) {
- for (ComponentPath componentPath : componentPaths) {
- if (componentPath.currentComponent().equals(ancestor)) {
- return componentPath;
- }
- }
- throw new IllegalArgumentException(
- String.format("%s is not in the current path: %s", ancestor.getQualifiedName(), this));
- }
-
- /**
- * Returns the BindingGraph for {@code ancestor}, where {@code ancestor} is in the component path
- * of the current traversal.
- */
- protected final BindingGraph graphForAncestor(TypeElement ancestor) {
- for (BindingGraph graph : bindingGraphPath) {
- if (graph.componentTypeElement().equals(ancestor)) {
- return graph;
- }
- }
- throw new IllegalArgumentException(
- String.format("%s is not in the current path: %s", ancestor.getQualifiedName(), this));
- }
-}
diff --git a/java/dagger/internal/codegen/ComponentValidator.java b/java/dagger/internal/codegen/ComponentValidator.java
deleted file mode 100644
index 7739915..0000000
--- a/java/dagger/internal/codegen/ComponentValidator.java
+++ /dev/null
@@ -1,522 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreElements.asType;
-import static com.google.auto.common.MoreElements.getLocalAndInheritedMethods;
-import static com.google.auto.common.MoreElements.isAnnotationPresent;
-import static com.google.auto.common.MoreTypes.asDeclared;
-import static com.google.auto.common.MoreTypes.asExecutable;
-import static com.google.common.base.Verify.verify;
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static com.google.common.collect.Multimaps.asMap;
-import static com.google.common.collect.Sets.intersection;
-import static dagger.internal.codegen.ComponentAnnotation.anyComponentAnnotation;
-import static dagger.internal.codegen.ComponentAnnotation.componentAnnotation;
-import static dagger.internal.codegen.ComponentCreatorAnnotation.creatorAnnotationsFor;
-import static dagger.internal.codegen.ComponentCreatorAnnotation.productionCreatorAnnotations;
-import static dagger.internal.codegen.ComponentCreatorAnnotation.subcomponentCreatorAnnotations;
-import static dagger.internal.codegen.ComponentKind.annotationsFor;
-import static dagger.internal.codegen.ConfigurationAnnotations.enclosedAnnotatedTypes;
-import static dagger.internal.codegen.ConfigurationAnnotations.getTransitiveModules;
-import static dagger.internal.codegen.DaggerStreams.toImmutableList;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.internal.codegen.ErrorMessages.ComponentCreatorMessages.builderMethodRequiresNoArgs;
-import static dagger.internal.codegen.ErrorMessages.ComponentCreatorMessages.moreThanOneRefToSubcomponent;
-import static dagger.internal.codegen.ModuleAnnotation.moduleAnnotation;
-import static dagger.internal.codegen.langmodel.DaggerElements.getAnnotationMirror;
-import static dagger.internal.codegen.langmodel.DaggerElements.getAnyAnnotation;
-import static java.util.Comparator.comparing;
-import static javax.lang.model.element.ElementKind.CLASS;
-import static javax.lang.model.element.ElementKind.INTERFACE;
-import static javax.lang.model.element.Modifier.ABSTRACT;
-import static javax.lang.model.type.TypeKind.VOID;
-import static javax.lang.model.util.ElementFilter.methodsIn;
-
-import com.google.auto.common.MoreTypes;
-import com.google.auto.value.AutoValue;
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.LinkedHashMultimap;
-import com.google.common.collect.Maps;
-import com.google.common.collect.SetMultimap;
-import com.google.common.collect.Sets;
-import dagger.Component;
-import dagger.Reusable;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.DependencyRequest;
-import dagger.model.Key;
-import dagger.producers.CancellationPolicy;
-import dagger.producers.ProductionComponent;
-import java.lang.annotation.Annotation;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Optional;
-import java.util.Set;
-import javax.inject.Inject;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.element.VariableElement;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.ExecutableType;
-import javax.lang.model.type.TypeMirror;
-import javax.lang.model.type.TypeVisitor;
-import javax.lang.model.util.SimpleTypeVisitor6;
-import javax.lang.model.util.SimpleTypeVisitor8;
-
-/**
- * Performs superficial validation of the contract of the {@link Component} and {@link
- * ProductionComponent} annotations.
- */
-final class ComponentValidator {
- private final DaggerElements elements;
- private final DaggerTypes types;
- private final ModuleValidator moduleValidator;
- private final ComponentCreatorValidator creatorValidator;
- private final DependencyRequestValidator dependencyRequestValidator;
- private final MembersInjectionValidator membersInjectionValidator;
- private final MethodSignatureFormatter methodSignatureFormatter;
- private final DependencyRequestFactory dependencyRequestFactory;
-
- @Inject
- ComponentValidator(
- DaggerElements elements,
- DaggerTypes types,
- ModuleValidator moduleValidator,
- ComponentCreatorValidator creatorValidator,
- DependencyRequestValidator dependencyRequestValidator,
- MembersInjectionValidator membersInjectionValidator,
- MethodSignatureFormatter methodSignatureFormatter,
- DependencyRequestFactory dependencyRequestFactory) {
- this.elements = elements;
- this.types = types;
- this.moduleValidator = moduleValidator;
- this.creatorValidator = creatorValidator;
- this.dependencyRequestValidator = dependencyRequestValidator;
- this.membersInjectionValidator = membersInjectionValidator;
- this.methodSignatureFormatter = methodSignatureFormatter;
- this.dependencyRequestFactory = dependencyRequestFactory;
- }
-
- @AutoValue
- abstract static class ComponentValidationReport {
- abstract ImmutableSet<Element> referencedSubcomponents();
-
- abstract ValidationReport<TypeElement> report();
- }
-
- /**
- * Validates the given component subject. Also validates any referenced subcomponents that aren't
- * already included in the {@code validatedSubcomponents} set.
- */
- public ComponentValidationReport validate(
- TypeElement subject,
- Set<? extends Element> validatedSubcomponents,
- Set<? extends Element> validatedSubcomponentCreators) {
- ValidationReport.Builder<TypeElement> report = ValidationReport.about(subject);
-
- ImmutableSet<ComponentKind> componentKinds = ComponentKind.getComponentKinds(subject);
- ImmutableSet<Element> allSubcomponents;
- if (componentKinds.size() > 1) {
- String error =
- "Components may not be annotated with more than one component annotation: found "
- + annotationsFor(componentKinds);
- report.addError(error, subject);
- allSubcomponents = ImmutableSet.of();
- } else {
- ComponentKind componentKind = getOnlyElement(componentKinds);
- ComponentAnnotation componentAnnotation = anyComponentAnnotation(subject).get();
- allSubcomponents =
- validate(
- subject,
- componentAnnotation,
- componentKind,
- validatedSubcomponents,
- validatedSubcomponentCreators,
- report);
- }
-
- return new AutoValue_ComponentValidator_ComponentValidationReport(
- allSubcomponents, report.build());
- }
-
- private ImmutableSet<Element> validate(
- TypeElement subject,
- ComponentAnnotation componentAnnotation,
- ComponentKind componentKind,
- Set<? extends Element> validatedSubcomponents,
- Set<? extends Element> validatedSubcomponentCreators,
- ValidationReport.Builder<TypeElement> report) {
- if (isAnnotationPresent(subject, CancellationPolicy.class) && !componentKind.isProducer()) {
- report.addError(
- "@CancellationPolicy may only be applied to production components and subcomponents",
- subject);
- }
-
- if (!subject.getKind().equals(INTERFACE)
- && !(subject.getKind().equals(CLASS) && subject.getModifiers().contains(ABSTRACT))) {
- report.addError(
- String.format(
- "@%s may only be applied to an interface or abstract class",
- componentKind.annotation().getSimpleName()),
- subject);
- }
-
- ImmutableList<DeclaredType> creators =
- creatorAnnotationsFor(componentAnnotation).stream()
- .flatMap(annotation -> enclosedAnnotatedTypes(subject, annotation).stream())
- .collect(toImmutableList());
- if (creators.size() > 1) {
- report.addError(
- String.format(ErrorMessages.componentMessagesFor(componentKind).moreThanOne(), creators),
- subject);
- }
-
- Optional<AnnotationMirror> reusableAnnotation = getAnnotationMirror(subject, Reusable.class);
- if (reusableAnnotation.isPresent()) {
- report.addError(
- "@Reusable cannot be applied to components or subcomponents",
- subject,
- reusableAnnotation.get());
- }
-
- DeclaredType subjectType = MoreTypes.asDeclared(subject.asType());
-
- SetMultimap<Element, ExecutableElement> referencedSubcomponents = LinkedHashMultimap.create();
- getLocalAndInheritedMethods(subject, types, elements).stream()
- .filter(method -> method.getModifiers().contains(ABSTRACT))
- .forEachOrdered(
- method -> {
- ExecutableType resolvedMethod = asExecutable(types.asMemberOf(subjectType, method));
- List<? extends TypeMirror> parameterTypes = resolvedMethod.getParameterTypes();
- List<? extends VariableElement> parameters = method.getParameters();
- TypeMirror returnType = resolvedMethod.getReturnType();
-
- if (!resolvedMethod.getTypeVariables().isEmpty()) {
- report.addError("Component methods cannot have type variables", method);
- }
-
- // abstract methods are ones we have to implement, so they each need to be validated
- // first, check the return type. if it's a subcomponent, validate that method as such.
- Optional<AnnotationMirror> subcomponentAnnotation =
- checkForAnnotations(
- returnType,
- componentKind.legalSubcomponentKinds().stream()
- .map(ComponentKind::annotation)
- .collect(toImmutableSet()));
- Optional<AnnotationMirror> subcomponentCreatorAnnotation =
- checkForAnnotations(
- returnType,
- componentAnnotation.isProduction()
- ? intersection(
- subcomponentCreatorAnnotations(), productionCreatorAnnotations())
- : subcomponentCreatorAnnotations());
- if (subcomponentAnnotation.isPresent()) {
- referencedSubcomponents.put(MoreTypes.asElement(returnType), method);
- validateSubcomponentMethod(
- report,
- ComponentKind.forAnnotatedElement(MoreTypes.asTypeElement(returnType)).get(),
- method,
- parameters,
- parameterTypes,
- returnType,
- subcomponentAnnotation);
- } else if (subcomponentCreatorAnnotation.isPresent()) {
- referencedSubcomponents.put(
- MoreTypes.asElement(returnType).getEnclosingElement(), method);
- validateSubcomponentCreatorMethod(
- report, method, parameters, returnType, validatedSubcomponentCreators);
- } else {
- // if it's not a subcomponent...
- switch (parameters.size()) {
- case 0:
- // no parameters means that it is a provision method
- dependencyRequestValidator.validateDependencyRequest(
- report, method, returnType);
- break;
- case 1:
- // one parameter means that it's a members injection method
- TypeMirror parameterType = Iterables.getOnlyElement(parameterTypes);
- report.addSubreport(
- membersInjectionValidator.validateMembersInjectionMethod(
- method, parameterType));
- if (!(returnType.getKind().equals(VOID)
- || types.isSameType(returnType, parameterType))) {
- report.addError(
- "Members injection methods may only return the injected type or void.",
- method);
- }
- break;
- default:
- // this isn't any method that we know how to implement...
- report.addError(
- "This method isn't a valid provision method, members injection method or "
- + "subcomponent factory method. Dagger cannot implement this method",
- method);
- break;
- }
- }
- });
-
- checkConflictingEntryPoints(report);
-
- Maps.filterValues(referencedSubcomponents.asMap(), methods -> methods.size() > 1)
- .forEach(
- (subcomponent, methods) ->
- report.addError(
- String.format(moreThanOneRefToSubcomponent(), subcomponent, methods), subject));
-
- validateComponentDependencies(report, componentAnnotation.dependencyTypes());
- report.addSubreport(
- moduleValidator.validateReferencedModules(
- subject,
- componentAnnotation.annotation(),
- componentKind.legalModuleKinds(),
- new HashSet<>()));
-
- // Make sure we validate any subcomponents we're referencing, unless we know we validated
- // them already in this pass.
- // TODO(sameb): If subcomponents refer to each other and both aren't in
- // 'validatedSubcomponents' (e.g, both aren't compiled in this pass),
- // then this can loop forever.
- ImmutableSet.Builder<Element> allSubcomponents =
- ImmutableSet.<Element>builder().addAll(referencedSubcomponents.keySet());
- for (Element subcomponent :
- Sets.difference(referencedSubcomponents.keySet(), validatedSubcomponents)) {
- ComponentValidationReport subreport =
- validate(asType(subcomponent), validatedSubcomponents, validatedSubcomponentCreators);
- report.addItems(subreport.report().items());
- allSubcomponents.addAll(subreport.referencedSubcomponents());
- }
- return allSubcomponents.build();
- }
-
- private void checkConflictingEntryPoints(ValidationReport.Builder<TypeElement> report) {
- DeclaredType componentType = asDeclared(report.getSubject().asType());
-
- // Collect entry point methods that are not overridden by others. If the "same" method is
- // inherited from more than one supertype, each will be in the multimap.
- SetMultimap<String, ExecutableElement> entryPointMethods = HashMultimap.create();
-
- methodsIn(elements.getAllMembers(report.getSubject()))
- .stream()
- .filter(
- method -> isEntryPoint(method, asExecutable(types.asMemberOf(componentType, method))))
- .forEach(
- method ->
- addMethodUnlessOverridden(
- method, entryPointMethods.get(method.getSimpleName().toString())));
-
- for (Set<ExecutableElement> methods : asMap(entryPointMethods).values()) {
- if (distinctKeys(methods, report.getSubject()).size() > 1) {
- reportConflictingEntryPoints(methods, report);
- }
- }
- }
-
- private boolean isEntryPoint(ExecutableElement method, ExecutableType methodType) {
- return method.getModifiers().contains(ABSTRACT)
- && method.getParameters().isEmpty()
- && !methodType.getReturnType().getKind().equals(VOID)
- && methodType.getTypeVariables().isEmpty();
- }
-
- private ImmutableSet<Key> distinctKeys(Set<ExecutableElement> methods, TypeElement component) {
- return methods
- .stream()
- .map(method -> dependencyRequest(method, component))
- .map(DependencyRequest::key)
- .collect(toImmutableSet());
- }
-
- private DependencyRequest dependencyRequest(ExecutableElement method, TypeElement component) {
- ExecutableType methodType =
- asExecutable(types.asMemberOf(asDeclared(component.asType()), method));
- return ComponentKind.forAnnotatedElement(component).get().isProducer()
- ? dependencyRequestFactory.forComponentProductionMethod(method, methodType)
- : dependencyRequestFactory.forComponentProvisionMethod(method, methodType);
- }
-
- private void addMethodUnlessOverridden(ExecutableElement method, Set<ExecutableElement> methods) {
- if (methods.stream().noneMatch(existingMethod -> overridesAsDeclared(existingMethod, method))) {
- methods.removeIf(existingMethod -> overridesAsDeclared(method, existingMethod));
- methods.add(method);
- }
- }
-
- /**
- * Returns {@code true} if {@code overrider} overrides {@code overridden} considered from within
- * the type that declares {@code overrider}.
- */
- // TODO(dpb): Does this break for ECJ?
- private boolean overridesAsDeclared(ExecutableElement overridder, ExecutableElement overridden) {
- return elements.overrides(overridder, overridden, asType(overridder.getEnclosingElement()));
- }
-
- private void reportConflictingEntryPoints(
- Collection<ExecutableElement> methods, ValidationReport.Builder<TypeElement> report) {
- verify(
- methods.stream().map(ExecutableElement::getEnclosingElement).distinct().count()
- == methods.size(),
- "expected each method to be declared on a different type: %s",
- methods);
- StringBuilder message = new StringBuilder("conflicting entry point declarations:");
- methodSignatureFormatter
- .typedFormatter(asDeclared(report.getSubject().asType()))
- .formatIndentedList(
- message,
- ImmutableList.sortedCopyOf(
- comparing(
- method -> asType(method.getEnclosingElement()).getQualifiedName().toString()),
- methods),
- 1);
- report.addError(message.toString());
- }
-
- private void validateSubcomponentMethod(
- final ValidationReport.Builder<TypeElement> report,
- final ComponentKind subcomponentKind,
- ExecutableElement method,
- List<? extends VariableElement> parameters,
- List<? extends TypeMirror> parameterTypes,
- TypeMirror returnType,
- Optional<AnnotationMirror> subcomponentAnnotation) {
- ImmutableSet<TypeElement> moduleTypes =
- componentAnnotation(subcomponentAnnotation.get()).modules();
-
- // TODO(gak): This logic maybe/probably shouldn't live here as it requires us to traverse
- // subcomponents and their modules separately from how it is done in ComponentDescriptor and
- // ModuleDescriptor
- @SuppressWarnings("deprecation")
- ImmutableSet<TypeElement> transitiveModules =
- getTransitiveModules(types, elements, moduleTypes);
-
- Set<TypeElement> variableTypes = Sets.newHashSet();
-
- for (int i = 0; i < parameterTypes.size(); i++) {
- VariableElement parameter = parameters.get(i);
- TypeMirror parameterType = parameterTypes.get(i);
- Optional<TypeElement> moduleType =
- parameterType.accept(
- new SimpleTypeVisitor6<Optional<TypeElement>, Void>() {
- @Override
- protected Optional<TypeElement> defaultAction(TypeMirror e, Void p) {
- return Optional.empty();
- }
-
- @Override
- public Optional<TypeElement> visitDeclared(DeclaredType t, Void p) {
- for (ModuleKind moduleKind : subcomponentKind.legalModuleKinds()) {
- if (isAnnotationPresent(t.asElement(), moduleKind.annotation())) {
- return Optional.of(MoreTypes.asTypeElement(t));
- }
- }
- return Optional.empty();
- }
- },
- null);
- if (moduleType.isPresent()) {
- if (variableTypes.contains(moduleType.get())) {
- report.addError(
- String.format(
- "A module may only occur once an an argument in a Subcomponent factory "
- + "method, but %s was already passed.",
- moduleType.get().getQualifiedName()),
- parameter);
- }
- if (!transitiveModules.contains(moduleType.get())) {
- report.addError(
- String.format(
- "%s is present as an argument to the %s factory method, but is not one of the"
- + " modules used to implement the subcomponent.",
- moduleType.get().getQualifiedName(),
- MoreTypes.asTypeElement(returnType).getQualifiedName()),
- method);
- }
- variableTypes.add(moduleType.get());
- } else {
- report.addError(
- String.format(
- "Subcomponent factory methods may only accept modules, but %s is not.",
- parameterType),
- parameter);
- }
- }
- }
-
- private void validateSubcomponentCreatorMethod(
- ValidationReport.Builder<TypeElement> report,
- ExecutableElement method,
- List<? extends VariableElement> parameters,
- TypeMirror returnType,
- Set<? extends Element> validatedSubcomponentCreators) {
- if (!parameters.isEmpty()) {
- report.addError(builderMethodRequiresNoArgs(), method);
- }
-
- // If we haven't already validated the subcomponent creator itself, validate it now.
- TypeElement creatorElement = MoreTypes.asTypeElement(returnType);
- if (!validatedSubcomponentCreators.contains(creatorElement)) {
- // TODO(sameb): The creator validator right now assumes the element is being compiled
- // in this pass, which isn't true here. We should change error messages to spit out
- // this method as the subject and add the original subject to the message output.
- report.addItems(creatorValidator.validate(creatorElement).items());
- }
- }
-
- private static <T extends Element> void validateComponentDependencies(
- ValidationReport.Builder<T> report, Iterable<TypeMirror> types) {
- for (TypeMirror type : types) {
- type.accept(CHECK_DEPENDENCY_TYPES, report);
- }
- }
-
- private static final TypeVisitor<Void, ValidationReport.Builder<?>> CHECK_DEPENDENCY_TYPES =
- new SimpleTypeVisitor8<Void, ValidationReport.Builder<?>>() {
- @Override
- protected Void defaultAction(TypeMirror type, ValidationReport.Builder<?> report) {
- report.addError(type + " is not a valid component dependency type");
- return null;
- }
-
- @Override
- public Void visitDeclared(DeclaredType type, ValidationReport.Builder<?> report) {
- if (moduleAnnotation(MoreTypes.asTypeElement(type)).isPresent()) {
- report.addError(type + " is a module, which cannot be a component dependency");
- }
- return null;
- }
- };
-
- private static Optional<AnnotationMirror> checkForAnnotations(
- TypeMirror type, final Set<? extends Class<? extends Annotation>> annotations) {
- return type.accept(
- new SimpleTypeVisitor6<Optional<AnnotationMirror>, Void>(Optional.empty()) {
- @Override
- public Optional<AnnotationMirror> visitDeclared(DeclaredType t, Void p) {
- return getAnyAnnotation(t.asElement(), annotations);
- }
- },
- null);
- }
-}
diff --git a/java/dagger/internal/codegen/ConfigurationAnnotations.java b/java/dagger/internal/codegen/ConfigurationAnnotations.java
deleted file mode 100644
index a9bba29..0000000
--- a/java/dagger/internal/codegen/ConfigurationAnnotations.java
+++ /dev/null
@@ -1,157 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.collect.Iterables.consumingIterable;
-import static dagger.internal.codegen.ComponentAnnotation.subcomponentAnnotation;
-import static dagger.internal.codegen.ComponentCreatorAnnotation.subcomponentCreatorAnnotations;
-import static dagger.internal.codegen.ModuleAnnotation.moduleAnnotation;
-import static dagger.internal.codegen.MoreAnnotationMirrors.getTypeListValue;
-import static dagger.internal.codegen.langmodel.DaggerElements.isAnyAnnotationPresent;
-import static javax.lang.model.util.ElementFilter.typesIn;
-
-import com.google.auto.common.MoreElements;
-import com.google.auto.common.MoreTypes;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.Sets;
-import dagger.Component;
-import dagger.Module;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import java.lang.annotation.Annotation;
-import java.util.ArrayDeque;
-import java.util.List;
-import java.util.Optional;
-import java.util.Queue;
-import java.util.Set;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.TypeKind;
-import javax.lang.model.type.TypeMirror;
-
-/**
- * Utility methods related to dagger configuration annotations (e.g.: {@link Component}
- * and {@link Module}).
- */
-final class ConfigurationAnnotations {
-
- static Optional<TypeElement> getSubcomponentCreator(TypeElement subcomponent) {
- checkArgument(subcomponentAnnotation(subcomponent).isPresent());
- for (TypeElement nestedType : typesIn(subcomponent.getEnclosedElements())) {
- if (isSubcomponentCreator(nestedType)) {
- return Optional.of(nestedType);
- }
- }
- return Optional.empty();
- }
-
- static boolean isSubcomponentCreator(Element element) {
- return isAnyAnnotationPresent(element, subcomponentCreatorAnnotations());
- }
-
- // Dagger 1 support.
- static ImmutableList<TypeMirror> getModuleInjects(AnnotationMirror moduleAnnotation) {
- checkNotNull(moduleAnnotation);
- return getTypeListValue(moduleAnnotation, "injects");
- }
-
- /** Returns the first type that specifies this' nullability, or empty if none. */
- static Optional<DeclaredType> getNullableType(Element element) {
- List<? extends AnnotationMirror> mirrors = element.getAnnotationMirrors();
- for (AnnotationMirror mirror : mirrors) {
- if (mirror.getAnnotationType().asElement().getSimpleName().contentEquals("Nullable")) {
- return Optional.of(mirror.getAnnotationType());
- }
- }
- return Optional.empty();
- }
-
- /**
- * Returns the full set of modules transitively {@linkplain Module#includes included} from the
- * given seed modules. If a module is malformed and a type listed in {@link Module#includes} is
- * not annotated with {@link Module}, it is ignored.
- *
- * @deprecated Use {@link ComponentDescriptor#modules()}.
- */
- @Deprecated
- static ImmutableSet<TypeElement> getTransitiveModules(
- DaggerTypes types, DaggerElements elements, Iterable<TypeElement> seedModules) {
- TypeMirror objectType = elements.getTypeElement(Object.class).asType();
- Queue<TypeElement> moduleQueue = new ArrayDeque<>();
- Iterables.addAll(moduleQueue, seedModules);
- Set<TypeElement> moduleElements = Sets.newLinkedHashSet();
- for (TypeElement moduleElement : consumingIterable(moduleQueue)) {
- moduleAnnotation(moduleElement)
- .ifPresent(
- moduleAnnotation -> {
- ImmutableSet.Builder<TypeElement> moduleDependenciesBuilder =
- ImmutableSet.builder();
- moduleDependenciesBuilder.addAll(moduleAnnotation.includes());
- // We don't recur on the parent class because we don't want the parent class as a
- // root that the component depends on, and also because we want the dependencies
- // rooted against this element, not the parent.
- addIncludesFromSuperclasses(
- types, moduleElement, moduleDependenciesBuilder, objectType);
- ImmutableSet<TypeElement> moduleDependencies = moduleDependenciesBuilder.build();
- moduleElements.add(moduleElement);
- for (TypeElement dependencyType : moduleDependencies) {
- if (!moduleElements.contains(dependencyType)) {
- moduleQueue.add(dependencyType);
- }
- }
- });
- }
- return ImmutableSet.copyOf(moduleElements);
- }
-
- /** Returns the enclosed types annotated with the given annotation. */
- static ImmutableList<DeclaredType> enclosedAnnotatedTypes(
- TypeElement typeElement, Class<? extends Annotation> annotation) {
- final ImmutableList.Builder<DeclaredType> builders = ImmutableList.builder();
- for (TypeElement element : typesIn(typeElement.getEnclosedElements())) {
- if (MoreElements.isAnnotationPresent(element, annotation)) {
- builders.add(MoreTypes.asDeclared(element.asType()));
- }
- }
- return builders.build();
- }
-
- /** Traverses includes from superclasses and adds them into the builder. */
- private static void addIncludesFromSuperclasses(
- DaggerTypes types,
- TypeElement element,
- ImmutableSet.Builder<TypeElement> builder,
- TypeMirror objectType) {
- // Also add the superclass to the queue, in case any @Module definitions were on that.
- TypeMirror superclass = element.getSuperclass();
- while (!types.isSameType(objectType, superclass)
- && superclass.getKind().equals(TypeKind.DECLARED)) {
- element = MoreElements.asType(types.asElement(superclass));
- moduleAnnotation(element)
- .ifPresent(moduleAnnotation -> builder.addAll(moduleAnnotation.includes()));
- superclass = element.getSuperclass();
- }
- }
-
- private ConfigurationAnnotations() {}
-}
diff --git a/java/dagger/internal/codegen/ContributionBinding.java b/java/dagger/internal/codegen/ContributionBinding.java
deleted file mode 100644
index 0958bc8..0000000
--- a/java/dagger/internal/codegen/ContributionBinding.java
+++ /dev/null
@@ -1,209 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkState;
-import static dagger.internal.codegen.ContributionBinding.FactoryCreationStrategy.CLASS_CONSTRUCTOR;
-import static dagger.internal.codegen.ContributionBinding.FactoryCreationStrategy.DELEGATE;
-import static dagger.internal.codegen.ContributionBinding.FactoryCreationStrategy.SINGLETON_INSTANCE;
-import static dagger.internal.codegen.MapKeys.unwrapValue;
-import static dagger.internal.codegen.MoreAnnotationMirrors.unwrapOptionalEquivalence;
-import static java.util.Arrays.asList;
-
-import com.google.auto.common.MoreElements;
-import com.google.common.base.Equivalence;
-import com.google.errorprone.annotations.CanIgnoreReturnValue;
-import com.google.errorprone.annotations.CheckReturnValue;
-import dagger.internal.codegen.ContributionType.HasContributionType;
-import dagger.model.BindingKind;
-import dagger.model.DependencyRequest;
-import dagger.model.Key;
-import java.util.Optional;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.AnnotationValue;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.TypeMirror;
-
-/**
- * An abstract class for a value object representing the mechanism by which a {@link Key} can be
- * contributed to a dependency graph.
- */
-abstract class ContributionBinding extends Binding implements HasContributionType {
-
- /** Returns the type that specifies this' nullability, absent if not nullable. */
- abstract Optional<DeclaredType> nullableType();
-
- abstract Optional<Equivalence.Wrapper<AnnotationMirror>> wrappedMapKeyAnnotation();
-
- final Optional<AnnotationMirror> mapKeyAnnotation() {
- return unwrapOptionalEquivalence(wrappedMapKeyAnnotation());
- }
-
- /**
- * If this is a map contribution, returns the key of its map entry.
- *
- * @throws IllegalStateException if {@link #mapKeyAnnotation()} returns an empty value.
- */
- final Object mapKey() {
- checkState(mapKeyAnnotation().isPresent());
- AnnotationMirror mapKeyAnnotation = mapKeyAnnotation().get();
- return unwrapValue(mapKeyAnnotation).map(AnnotationValue::getValue).orElse(mapKeyAnnotation);
- }
-
- /** If {@link #bindingElement()} is a method that returns a primitive type, returns that type. */
- final Optional<TypeMirror> contributedPrimitiveType() {
- return bindingElement()
- .filter(bindingElement -> bindingElement instanceof ExecutableElement)
- .map(bindingElement -> MoreElements.asExecutable(bindingElement).getReturnType())
- .filter(type -> type.getKind().isPrimitive());
- }
-
- @Override
- public final boolean isNullable() {
- return nullableType().isPresent();
- }
-
- /**
- * The strategy for getting an instance of a factory for a {@link ContributionBinding}.
- */
- enum FactoryCreationStrategy {
- /** The factory class is a single instance. */
- SINGLETON_INSTANCE,
- /** The factory must be created by calling the constructor. */
- CLASS_CONSTRUCTOR,
- /** The factory is simply delegated to another. */
- DELEGATE,
- }
-
- /**
- * Returns the {@link FactoryCreationStrategy} appropriate for a binding.
- *
- * <p>Delegate bindings use the {@link FactoryCreationStrategy#DELEGATE} strategy.
- *
- * <p>Bindings without dependencies that don't require a module instance use the {@link
- * FactoryCreationStrategy#SINGLETON_INSTANCE} strategy.
- *
- * <p>All other bindings use the {@link FactoryCreationStrategy#CLASS_CONSTRUCTOR} strategy.
- */
- final FactoryCreationStrategy factoryCreationStrategy() {
- switch (kind()) {
- case DELEGATE:
- return DELEGATE;
- case PROVISION:
- return dependencies().isEmpty() && !requiresModuleInstance()
- ? SINGLETON_INSTANCE
- : CLASS_CONSTRUCTOR;
- case INJECTION:
- case MULTIBOUND_SET:
- case MULTIBOUND_MAP:
- return dependencies().isEmpty() ? SINGLETON_INSTANCE : CLASS_CONSTRUCTOR;
- default:
- return CLASS_CONSTRUCTOR;
- }
- }
-
- /**
- * The {@link TypeMirror type} for the {@code Factory<T>} or {@code Producer<T>} which is created
- * for this binding. Uses the binding's key, V in the case of {@code Map<K, FrameworkClass<V>>>},
- * and E {@code Set<E>} for {@link dagger.multibindings.IntoSet @IntoSet} methods.
- */
- final TypeMirror contributedType() {
- switch (contributionType()) {
- case MAP:
- return MapType.from(key()).unwrappedFrameworkValueType();
- case SET:
- return SetType.from(key()).elementType();
- case SET_VALUES:
- case UNIQUE:
- return key().type();
- }
- throw new AssertionError();
- }
-
- final boolean isSyntheticMultibinding() {
- switch (kind()) {
- case MULTIBOUND_SET:
- case MULTIBOUND_MAP:
- return true;
- default:
- return false;
- }
- }
-
- /** Whether the bound type has a generated implementation. */
- final boolean requiresGeneratedInstance() {
- switch (kind()) {
- case COMPONENT:
- case SUBCOMPONENT_CREATOR:
- return true;
- default:
- return false;
- }
- }
-
- /**
- * Returns {@link BindingKind#MULTIBOUND_SET} or {@link
- * BindingKind#MULTIBOUND_MAP} if the key is a set or map.
- *
- * @throws IllegalArgumentException if {@code key} is neither a set nor a map
- */
- static BindingKind bindingKindForMultibindingKey(Key key) {
- if (SetType.isSet(key)) {
- return BindingKind.MULTIBOUND_SET;
- } else if (MapType.isMap(key)) {
- return BindingKind.MULTIBOUND_MAP;
- } else {
- throw new IllegalArgumentException(String.format("key is not for a set or map: %s", key));
- }
- }
-
- /**
- * Base builder for {@link com.google.auto.value.AutoValue @AutoValue} subclasses of {@link
- * ContributionBinding}.
- */
- @CanIgnoreReturnValue
- abstract static class Builder<C extends ContributionBinding, B extends Builder<C, B>> {
- abstract B dependencies(Iterable<DependencyRequest> dependencies);
-
- B dependencies(DependencyRequest... dependencies) {
- return dependencies(asList(dependencies));
- }
-
- abstract B unresolved(C unresolved);
-
- abstract B contributionType(ContributionType contributionType);
-
- abstract B bindingElement(Element bindingElement);
-
- abstract B contributingModule(TypeElement contributingModule);
-
- abstract B key(Key key);
-
- abstract B nullableType(Optional<DeclaredType> nullableType);
-
- abstract B wrappedMapKeyAnnotation(
- Optional<Equivalence.Wrapper<AnnotationMirror>> wrappedMapKeyAnnotation);
-
- abstract B kind(BindingKind kind);
-
- @CheckReturnValue
- abstract C build();
- }
-}
diff --git a/java/dagger/internal/codegen/ContributionType.java b/java/dagger/internal/codegen/ContributionType.java
deleted file mode 100644
index 66b5289..0000000
--- a/java/dagger/internal/codegen/ContributionType.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreElements.isAnnotationPresent;
-
-import dagger.Provides;
-import dagger.multibindings.ElementsIntoSet;
-import dagger.multibindings.IntoMap;
-import dagger.multibindings.IntoSet;
-import javax.lang.model.element.Element;
-
-/** Whether a binding or declaration is for a unique contribution or a map or set multibinding. */
-enum ContributionType {
- /** Represents map bindings. */
- MAP,
- /** Represents set bindings. */
- SET,
- /** Represents set values bindings. */
- SET_VALUES,
- /** Represents a valid non-collection binding. */
- UNIQUE,
- ;
-
- /** An object that is associated with a {@link ContributionType}. */
- interface HasContributionType {
-
- /** The contribution type of this object. */
- ContributionType contributionType();
- }
-
- /** {@code true} if this is for a multibinding. */
- boolean isMultibinding() {
- return !this.equals(UNIQUE);
- }
-
- /**
- * The contribution type from a binding element's annotations. Presumes a well-formed binding
- * element (at most one of @IntoSet, @IntoMap, @ElementsIntoSet and @Provides.type). {@link
- * BindingMethodValidator} and {@link BindsInstanceProcessingStep} validate correctness on their
- * own.
- */
- static ContributionType fromBindingElement(Element element) {
- if (isAnnotationPresent(element, IntoMap.class)) {
- return ContributionType.MAP;
- } else if (isAnnotationPresent(element, IntoSet.class)) {
- return ContributionType.SET;
- } else if (isAnnotationPresent(element, ElementsIntoSet.class)) {
- return ContributionType.SET_VALUES;
- }
- return ContributionType.UNIQUE;
- }
-}
diff --git a/java/dagger/internal/codegen/CurrentImplementationSubcomponent.java b/java/dagger/internal/codegen/CurrentImplementationSubcomponent.java
deleted file mode 100644
index c78d60d..0000000
--- a/java/dagger/internal/codegen/CurrentImplementationSubcomponent.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import dagger.BindsInstance;
-import dagger.Subcomponent;
-import dagger.internal.codegen.ComponentImplementationBuilder.RootComponentImplementationBuilder;
-import dagger.internal.codegen.ComponentImplementationBuilder.SubcomponentImplementationBuilder;
-import java.util.Optional;
-
-/**
- * A subcomponent that injects all objects that are responsible for creating a single {@link
- * ComponentImplementation} instance. Each child {@link ComponentImplementation} will have its own
- * instance of {@link CurrentImplementationSubcomponent}.
- */
-@Subcomponent(modules = GenerationOptionsModule.class)
-@PerComponentImplementation
-interface CurrentImplementationSubcomponent {
- RootComponentImplementationBuilder rootComponentBuilder();
-
- SubcomponentImplementationBuilder subcomponentBuilder();
-
- @Subcomponent.Builder
- interface Builder {
- @BindsInstance
- Builder componentImplementation(ComponentImplementation componentImplementation);
-
- @BindsInstance
- Builder bindingGraph(BindingGraph bindingGraph);
-
- @BindsInstance
- Builder parentBuilder(@ParentComponent Optional<ComponentImplementationBuilder> parentBuilder);
-
- @BindsInstance
- Builder parentBindingExpressions(
- @ParentComponent Optional<ComponentBindingExpressions> parentBindingExpressions);
-
- @BindsInstance
- Builder parentRequirementExpressions(
- @ParentComponent Optional<ComponentRequirementExpressions> parentRequirementExpressions);
-
- CurrentImplementationSubcomponent build();
- }
-}
diff --git a/java/dagger/internal/codegen/DaggerGraphs.java b/java/dagger/internal/codegen/DaggerGraphs.java
deleted file mode 100644
index dda6c11..0000000
--- a/java/dagger/internal/codegen/DaggerGraphs.java
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.collect.Sets.difference;
-import static com.google.common.graph.Graphs.reachableNodes;
-
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.graph.Graph;
-import com.google.common.graph.SuccessorsFunction;
-import java.util.ArrayDeque;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Queue;
-import java.util.Set;
-
-/** Utility methods for {@link com.google.common.graph} types. */
-public final class DaggerGraphs {
- /**
- * Returns a shortest path from {@code nodeU} to {@code nodeV} in {@code graph} as a list of the
- * nodes visited in sequence, including both {@code nodeU} and {@code nodeV}. (Note that there may
- * be many possible shortest paths.)
- *
- * <p>If {@code nodeV} is not {@link
- * com.google.common.graph.Graphs#reachableNodes(com.google.common.graph.Graph, Object) reachable}
- * from {@code nodeU}, the list returned is empty.
- *
- * @throws IllegalArgumentException if {@code nodeU} or {@code nodeV} is not present in {@code
- * graph}
- */
- public static <N> ImmutableList<N> shortestPath(SuccessorsFunction<N> graph, N nodeU, N nodeV) {
- if (nodeU.equals(nodeV)) {
- return ImmutableList.of(nodeU);
- }
- Set<N> successors = ImmutableSet.copyOf(graph.successors(nodeU));
- if (successors.contains(nodeV)) {
- return ImmutableList.of(nodeU, nodeV);
- }
-
- Map<N, N> visitedNodeToPathPredecessor = new HashMap<>(); // encodes shortest path tree
- for (N node : successors) {
- visitedNodeToPathPredecessor.put(node, nodeU);
- }
- Queue<N> currentNodes = new ArrayDeque<N>(successors);
- Queue<N> nextNodes = new ArrayDeque<N>();
-
- // Perform a breadth-first traversal starting with the successors of nodeU.
- while (!currentNodes.isEmpty()) {
- while (!currentNodes.isEmpty()) {
- N currentNode = currentNodes.remove();
- for (N nextNode : graph.successors(currentNode)) {
- if (visitedNodeToPathPredecessor.containsKey(nextNode)) {
- continue; // we already have a shortest path to nextNode
- }
- visitedNodeToPathPredecessor.put(nextNode, currentNode);
- if (nextNode.equals(nodeV)) {
- ImmutableList.Builder<N> builder = ImmutableList.builder();
- N node = nodeV;
- builder.add(node);
- while (!node.equals(nodeU)) {
- node = visitedNodeToPathPredecessor.get(node);
- builder.add(node);
- }
- return builder.build().reverse();
- }
- nextNodes.add(nextNode);
- }
- }
- Queue<N> emptyQueue = currentNodes;
- currentNodes = nextNodes;
- nextNodes = emptyQueue; // reusing empty queue faster than allocating new one
- }
-
- return ImmutableList.of();
- }
-
- /** Returns the nodes in a graph that are not reachable from a node. */
- public static <N> ImmutableSet<N> unreachableNodes(Graph<N> graph, N node) {
- return ImmutableSet.copyOf(difference(graph.nodes(), reachableNodes(graph, node)));
- }
-
- private DaggerGraphs() {}
-}
diff --git a/java/dagger/internal/codegen/DaggerKythePlugin.java b/java/dagger/internal/codegen/DaggerKythePlugin.java
deleted file mode 100644
index 5a685ef..0000000
--- a/java/dagger/internal/codegen/DaggerKythePlugin.java
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// This must be in the dagger.internal.codegen package since Dagger doesn't expose its APIs publicly
-// https://github.com/google/dagger/issues/773 could present an opportunity to put this somewhere in
-// the regular kythe/java tree.
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.BindingRequest.bindingRequest;
-import static dagger.internal.codegen.langmodel.DaggerElements.isAnyAnnotationPresent;
-
-import com.google.auto.service.AutoService;
-import com.google.common.collect.Iterables;
-import com.google.devtools.kythe.analyzers.base.EntrySet;
-import com.google.devtools.kythe.analyzers.base.FactEmitter;
-import com.google.devtools.kythe.analyzers.base.KytheEntrySets;
-import com.google.devtools.kythe.analyzers.java.Plugin;
-import com.google.devtools.kythe.proto.Storage.VName;
-import com.sun.tools.javac.code.Symbol;
-import com.sun.tools.javac.tree.JCTree.JCClassDecl;
-import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;
-import com.sun.tools.javac.util.Context;
-import dagger.BindsInstance;
-import dagger.Component;
-import dagger.model.DependencyRequest;
-import dagger.model.Key;
-import dagger.producers.ProductionComponent;
-import java.util.Optional;
-import java.util.logging.Logger;
-import javax.inject.Inject;
-import javax.inject.Singleton;
-import javax.lang.model.element.Element;
-
-/**
- * A plugin which emits nodes and edges for <a href="https://github.com/google/dagger">Dagger</a>
- * specific code.
- */
-@AutoService(Plugin.class)
-public class DaggerKythePlugin extends Plugin.Scanner<Void, Void> {
- // TODO(ronshapiro): use flogger
- private static final Logger logger = Logger.getLogger(DaggerKythePlugin.class.getCanonicalName());
- private FactEmitter emitter;
- @Inject ComponentDescriptorFactory componentDescriptorFactory;
- @Inject BindingGraphFactory bindingGraphFactory;
-
- @Override
- public Void visitClassDef(JCClassDecl tree, Void p) {
- if (tree.sym != null
- && isAnyAnnotationPresent(tree.sym, Component.class, ProductionComponent.class)) {
- addNodesForGraph(
- bindingGraphFactory.create(
- componentDescriptorFactory.rootComponentDescriptor(tree.sym), false));
- }
- return super.visitClassDef(tree, p);
- }
-
- private void addNodesForGraph(BindingGraph graph) {
- addDependencyEdges(graph);
- addModuleEdges(graph);
- addChildComponentEdges(graph);
-
- graph.subgraphs().forEach(this::addNodesForGraph);
- }
-
- private void addDependencyEdges(BindingGraph graph) {
- for (ResolvedBindings resolvedBinding : graph.resolvedBindings()) {
- for (Binding binding : resolvedBinding.bindings()) {
- for (DependencyRequest dependency : binding.explicitDependencies()) {
- addEdgesForDependencyRequest(dependency, dependency.key(), graph);
- }
- }
- }
-
- for (ComponentDescriptor.ComponentMethodDescriptor componentMethod :
- graph.componentDescriptor().componentMethods()) {
- componentMethod
- .dependencyRequest()
- .ifPresent(request -> addEdgesForDependencyRequest(request, request.key(), graph));
- }
- }
-
- /**
- * Add {@code /inject/satisfiedby} edges from {@code dependency}'s {@link
- * DependencyRequest#requestElement()} to any {@link BindingDeclaration#bindingElement() binding
- * elements} that satisfy the request.
- *
- * <p>This collapses requests for synthetic bindings so that a request for a multibound key
- * points to all of the contributions for the multibound object. It does so by recursively calling
- * this method, with each dependency's key as the {@code targetKey}.
- */
- private void addEdgesForDependencyRequest(
- DependencyRequest dependency, Key targetKey, BindingGraph graph) {
- if (!dependency.requestElement().isPresent()) {
- return;
- }
- BindingRequest request = bindingRequest(targetKey, dependency.kind());
- ResolvedBindings resolvedBindings = graph.resolvedBindings(request);
- for (Binding binding : resolvedBindings.bindings()) {
- if (binding.bindingElement().isPresent()) {
- addDependencyEdge(dependency, binding);
- } else {
- for (DependencyRequest subsequentDependency : binding.explicitDependencies()) {
- addEdgesForDependencyRequest(dependency, subsequentDependency.key(), graph);
- }
- }
- }
- for (BindingDeclaration bindingDeclaration :
- Iterables.concat(
- resolvedBindings.multibindingDeclarations(),
- resolvedBindings.optionalBindingDeclarations())) {
- addDependencyEdge(dependency, bindingDeclaration);
- }
- }
-
- private void addDependencyEdge(
- DependencyRequest dependency, BindingDeclaration bindingDeclaration) {
- Element requestElement = dependency.requestElement().get();
- Element bindingElement = bindingDeclaration.bindingElement().get();
- Optional<VName> requestElementNode = jvmNode(requestElement, "request element");
- Optional<VName> bindingElementNode = jvmNode(bindingElement, "binding element");
- emitEdge(requestElementNode, "/inject/satisfiedby", bindingElementNode);
- // TODO(ronshapiro): emit facts about the component that satisfies the edge
- }
-
- private void addModuleEdges(BindingGraph graph) {
- Optional<VName> componentNode = jvmNode(graph.componentTypeElement(), "component");
- for (ModuleDescriptor module : graph.componentDescriptor().modules()) {
- Optional<VName> moduleNode = jvmNode(module.moduleElement(), "module");
- emitEdge(componentNode, "/inject/installsmodule", moduleNode);
- }
- }
-
- private void addChildComponentEdges(BindingGraph graph) {
- Optional<VName> componentNode = jvmNode(graph.componentTypeElement(), "component");
- for (BindingGraph subgraph : graph.subgraphs()) {
- Optional<VName> subcomponentNode =
- jvmNode(subgraph.componentTypeElement(), "child component");
- emitEdge(componentNode, "/inject/childcomponent", subcomponentNode);
- }
- }
-
- private Optional<VName> jvmNode(Element element, String name) {
- Optional<VName> jvmNode = kytheGraph.getJvmNode((Symbol) element).map(KytheNode::getVName);
- if (!jvmNode.isPresent()) {
- logger.warning(String.format("Missing JVM node for %s: %s", name, element));
- }
- return jvmNode;
- }
-
- private void emitEdge(Optional<VName> source, String edgeName, Optional<VName> target) {
- source.ifPresent(
- s -> target.ifPresent(t -> new EntrySet.Builder(s, edgeName, t).build().emit(emitter)));
- }
-
- @Override
- public void run(
- JCCompilationUnit compilationUnit, KytheEntrySets entrySets, KytheGraph kytheGraph) {
- if (bindingGraphFactory == null) {
- emitter = entrySets.getEmitter();
- DaggerDaggerKythePlugin_PluginComponent.builder()
- .context(kytheGraph.getJavaContext())
- .build()
- .inject(this);
- }
- super.run(compilationUnit, entrySets, kytheGraph);
- }
-
- @Singleton
- @Component(modules = JavacPluginModule.class)
- interface PluginComponent {
- void inject(DaggerKythePlugin plugin);
-
- @Component.Builder
- interface Builder {
- @BindsInstance
- Builder context(Context context);
-
- PluginComponent build();
- }
- }
-}
diff --git a/java/dagger/internal/codegen/DaggerStatistics.java b/java/dagger/internal/codegen/DaggerStatistics.java
deleted file mode 100644
index 790ec76..0000000
--- a/java/dagger/internal/codegen/DaggerStatistics.java
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import com.google.auto.common.BasicAnnotationProcessor.ProcessingStep;
-import com.google.auto.value.AutoValue;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.google.errorprone.annotations.CanIgnoreReturnValue;
-import java.time.Duration;
-
-/** Statistics collected over the course of Dagger annotation processing. */
-@AutoValue
-abstract class DaggerStatistics {
- /** Returns a new {@link Builder}. */
- static Builder builder() {
- return new AutoValue_DaggerStatistics.Builder();
- }
-
- /** Returns a new {@link RoundStatistics} builder. */
- static RoundStatistics.Builder roundBuilder() {
- return new AutoValue_DaggerStatistics_RoundStatistics.Builder();
- }
-
- /** Total time spent in Dagger annotation processing. */
- abstract Duration totalProcessingTime();
-
- /** List of statistics for processing rounds that the Dagger processor handled. */
- abstract ImmutableList<RoundStatistics> rounds();
-
- /** Builder for {@link DaggerStatistics}. */
- @AutoValue.Builder
- abstract static class Builder {
- /** Sets the given duration for the total time spent in Dagger processing. */
- @CanIgnoreReturnValue
- abstract Builder setTotalProcessingTime(Duration totalProcessingTime);
-
- /** Returns a builder for adding processing round statistics. */
- abstract ImmutableList.Builder<RoundStatistics> roundsBuilder();
-
- /** Adds the given {@code round} statistics. */
- @CanIgnoreReturnValue
- final Builder addRound(RoundStatistics round) {
- roundsBuilder().add(round);
- return this;
- }
-
- /** Creates a new {@link DaggerStatistics} instance. */
- abstract DaggerStatistics build();
- }
-
- /** Statistics for each processing step in a single processing round. */
- @AutoValue
- abstract static class RoundStatistics {
- /** Map of processing step class to duration of that step for this round. */
- abstract ImmutableMap<Class<? extends ProcessingStep>, Duration> stepDurations();
-
- /** Builder for {@link RoundStatistics}. */
- @AutoValue.Builder
- abstract static class Builder {
- /** Returns a builder for adding durations for each processing step for the round. */
- abstract ImmutableMap.Builder<Class<? extends ProcessingStep>, Duration>
- stepDurationsBuilder();
-
- /** Adds the given {@code duration} for the given {@code step}. */
- @CanIgnoreReturnValue
- final Builder addStepDuration(ProcessingStep step, Duration duration) {
- stepDurationsBuilder().put(step.getClass(), duration);
- return this;
- }
-
- /** Creates a new {@link RoundStatistics} instance. */
- abstract RoundStatistics build();
- }
- }
-}
diff --git a/java/dagger/internal/codegen/DaggerStatisticsCollectingProcessingStep.java b/java/dagger/internal/codegen/DaggerStatisticsCollectingProcessingStep.java
deleted file mode 100644
index 51f6fc3..0000000
--- a/java/dagger/internal/codegen/DaggerStatisticsCollectingProcessingStep.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright (C) 2019 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.auto.common.BasicAnnotationProcessor.ProcessingStep;
-import com.google.common.collect.SetMultimap;
-import java.lang.annotation.Annotation;
-import java.util.Set;
-import javax.lang.model.element.Element;
-
-/**
- * {@link ProcessingStep} that delegates to another {@code ProcessingStep} and collects timing
- * statistics for each processing round for that step.
- */
-final class DaggerStatisticsCollectingProcessingStep implements ProcessingStep {
-
- private final ProcessingStep delegate;
- private final DaggerStatisticsCollector statisticsCollector;
-
- DaggerStatisticsCollectingProcessingStep(
- ProcessingStep delegate, DaggerStatisticsCollector statisticsCollector) {
- this.delegate = checkNotNull(delegate);
- this.statisticsCollector = checkNotNull(statisticsCollector);
- }
-
- @Override
- public Set<? extends Class<? extends Annotation>> annotations() {
- return delegate.annotations();
- }
-
- @Override
- public Set<? extends Element> process(
- SetMultimap<Class<? extends Annotation>, Element> elementsByAnnotation) {
- statisticsCollector.stepStarted(delegate);
- try {
- return delegate.process(elementsByAnnotation);
- } finally {
- statisticsCollector.stepFinished(delegate);
- }
- }
-}
diff --git a/java/dagger/internal/codegen/DaggerStatisticsCollector.java b/java/dagger/internal/codegen/DaggerStatisticsCollector.java
deleted file mode 100644
index e14fbb7..0000000
--- a/java/dagger/internal/codegen/DaggerStatisticsCollector.java
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkState;
-import static java.util.concurrent.TimeUnit.NANOSECONDS;
-
-import com.google.auto.common.BasicAnnotationProcessor.ProcessingStep;
-import com.google.common.base.Stopwatch;
-import com.google.common.base.Ticker;
-import java.time.Duration;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Optional;
-import javax.inject.Inject;
-import javax.inject.Singleton;
-
-/** Collects {@link DaggerStatistics} over the course of Dagger annotation processing. */
-@Singleton // for state sharing
-final class DaggerStatisticsCollector {
-
- private final Ticker ticker;
- private final Stopwatch totalRuntimeStopwatch;
- private final Map<ProcessingStep, Stopwatch> stepStopwatches = new HashMap<>();
-
- private final DaggerStatistics.Builder statisticsBuilder = DaggerStatistics.builder();
- private DaggerStatistics.RoundStatistics.Builder roundBuilder = DaggerStatistics.roundBuilder();
-
- private final Optional<DaggerStatisticsRecorder> statisticsRecorder;
-
- @Inject
- DaggerStatisticsCollector(Ticker ticker, Optional<DaggerStatisticsRecorder> statisticsRecorder) {
- this.ticker = ticker;
- this.totalRuntimeStopwatch = Stopwatch.createUnstarted(ticker);
- this.statisticsRecorder = statisticsRecorder;
- }
-
- /** Called when Dagger annotation processing starts. */
- void processingStarted() {
- checkState(!totalRuntimeStopwatch.isRunning());
- totalRuntimeStopwatch.start();
- }
-
- /** Called when the given {@code step} starts processing for a round. */
- void stepStarted(ProcessingStep step) {
- Stopwatch stopwatch =
- stepStopwatches.computeIfAbsent(step, unused -> Stopwatch.createUnstarted(ticker));
- stopwatch.start();
- }
-
- /** Called when the given {@code step} finishes processing for a round. */
- void stepFinished(ProcessingStep step) {
- Stopwatch stopwatch = stepStopwatches.get(step);
- roundBuilder.addStepDuration(step, elapsedTime(stopwatch));
- stopwatch.reset();
- }
-
- /** Called when Dagger finishes a processing round. */
- void roundFinished() {
- statisticsBuilder.addRound(roundBuilder.build());
- roundBuilder = DaggerStatistics.roundBuilder();
- }
-
- /** Called when Dagger annotation processing completes. */
- void processingStopped() {
- checkState(totalRuntimeStopwatch.isRunning());
- totalRuntimeStopwatch.stop();
- statisticsBuilder.setTotalProcessingTime(elapsedTime(totalRuntimeStopwatch));
-
- statisticsRecorder.ifPresent(
- recorder -> recorder.recordStatistics(statisticsBuilder.build()));
- }
-
- @SuppressWarnings("StopwatchNanosToDuration") // intentional
- private Duration elapsedTime(Stopwatch stopwatch) {
- // Using the java 7 method here as opposed to the Duration-returning version to avoid issues
- // when other annotation processors rely on java 7's guava
- return Duration.ofNanos(stopwatch.elapsed(NANOSECONDS));
- }
-}
diff --git a/java/dagger/internal/codegen/DaggerStatisticsRecorder.java b/java/dagger/internal/codegen/DaggerStatisticsRecorder.java
deleted file mode 100644
index 66f41d1..0000000
--- a/java/dagger/internal/codegen/DaggerStatisticsRecorder.java
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-/** Records collected {@link DaggerStatistics}. */
-interface DaggerStatisticsRecorder {
- /** Records the given {@code statistics}. */
- void recordStatistics(DaggerStatistics statistics);
-}
diff --git a/java/dagger/internal/codegen/DaggerStreams.java b/java/dagger/internal/codegen/DaggerStreams.java
deleted file mode 100644
index 50d17a6..0000000
--- a/java/dagger/internal/codegen/DaggerStreams.java
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * Copyright (C) 2013 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static java.util.stream.Collectors.collectingAndThen;
-import static java.util.stream.Collectors.toList;
-
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableSetMultimap;
-import com.google.common.collect.Maps;
-import java.util.Collection;
-import java.util.EnumSet;
-import java.util.Map;
-import java.util.Optional;
-import java.util.function.Function;
-import java.util.stream.Collector;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-import java.util.stream.StreamSupport;
-
-/** Utilities for streams. */
-public final class DaggerStreams {
-
- /**
- * Returns a {@link Collector} that accumulates the input elements into a new {@link
- * ImmutableList}, in encounter order.
- */
- // TODO(b/68008628): Use ImmutableList.toImmutableList().
- public static <T> Collector<T, ?, ImmutableList<T>> toImmutableList() {
- return collectingAndThen(toList(), ImmutableList::copyOf);
- }
-
- /**
- * Returns a {@link Collector} that accumulates the input elements into a new {@link
- * ImmutableSet}, in encounter order.
- */
- // TODO(b/68008628): Use ImmutableSet.toImmutableSet().
- public static <T> Collector<T, ?, ImmutableSet<T>> toImmutableSet() {
- return collectingAndThen(toList(), ImmutableSet::copyOf);
- }
-
- /**
- * Returns a {@link Collector} that accumulates elements into an {@code ImmutableMap} whose keys
- * and values are the result of applying the provided mapping functions to the input elements.
- * Entries appear in the result {@code ImmutableMap} in encounter order.
- */
- // TODO(b/68008628): Use ImmutableMap.toImmutableMap().
- public static <T, K, V> Collector<T, ?, ImmutableMap<K, V>> toImmutableMap(
- Function<? super T, K> keyMapper, Function<? super T, V> valueMapper) {
- return Collectors.mapping(
- value -> Maps.immutableEntry(keyMapper.apply(value), valueMapper.apply(value)),
- Collector.of(
- ImmutableMap::builder,
- (ImmutableMap.Builder<K, V> builder, Map.Entry<K, V> entry) -> builder.put(entry),
- (left, right) -> left.putAll(right.build()),
- ImmutableMap.Builder::build));
- }
-
- /**
- * Returns a {@link Collector} that accumulates elements into an {@code ImmutableSetMultimap}
- * whose keys and values are the result of applying the provided mapping functions to the input
- * elements. Entries appear in the result {@code ImmutableSetMultimap} in encounter order.
- */
- // TODO(b/68008628): Use ImmutableSetMultimap.toImmutableSetMultimap().
- public static <T, K, V> Collector<T, ?, ImmutableSetMultimap<K, V>> toImmutableSetMultimap(
- Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper) {
- return Collectors.mapping(
- value -> Maps.immutableEntry(keyMapper.apply(value), valueMapper.apply(value)),
- Collector.of(
- ImmutableSetMultimap::builder,
- (ImmutableSetMultimap.Builder<K, V> builder, Map.Entry<K, V> entry) ->
- builder.put(entry),
- (left, right) -> left.putAll(right.build()),
- ImmutableSetMultimap.Builder::build));
- }
-
- /**
- * Returns a function from {@link Object} to {@code Stream<T>}, which returns a stream containing
- * its input if its input is an instance of {@code T}.
- *
- * <p>Use as an argument to {@link Stream#flatMap(Function)}:
- *
- * <pre>{@code Stream<Bar>} barStream = fooStream.flatMap(instancesOf(Bar.class));</pre>
- */
- public static <T> Function<Object, Stream<T>> instancesOf(Class<T> to) {
- return f -> to.isInstance(f) ? Stream.of(to.cast(f)) : Stream.empty();
- }
-
- /** Returns a stream of all values of the given {@code enumType}. */
- public static <E extends Enum<E>> Stream<E> valuesOf(Class<E> enumType) {
- return EnumSet.allOf(enumType).stream();
- }
-
- /**
- * A function that you can use to extract the present values from a stream of {@link Optional}s.
- *
- * <pre>{@code
- * Set<Foo> foos =
- * optionalFoos()
- * .flatMap(DaggerStreams.presentValues())
- * .collect(toSet());
- * }</pre>
- */
- public static <T> Function<Optional<T>, Stream<T>> presentValues() {
- return optional -> optional.map(Stream::of).orElse(Stream.empty());
- }
-
- /**
- * Returns a sequential {@link Stream} of the contents of {@code iterable}, delegating to {@link
- * Collection#stream} if possible.
- */
- public static <T> Stream<T> stream(Iterable<T> iterable) {
- return (iterable instanceof Collection)
- ? ((Collection<T>) iterable).stream()
- : StreamSupport.stream(iterable.spliterator(), false);
- }
-
- private DaggerStreams() {}
-}
diff --git a/java/dagger/internal/codegen/DeferredModifiableBindingExpression.java b/java/dagger/internal/codegen/DeferredModifiableBindingExpression.java
deleted file mode 100644
index c41cf2c..0000000
--- a/java/dagger/internal/codegen/DeferredModifiableBindingExpression.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import dagger.internal.codegen.ComponentDescriptor.ComponentMethodDescriptor;
-import dagger.internal.codegen.ModifiableBindingMethods.ModifiableBindingMethod;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import java.util.Optional;
-import javax.lang.model.type.TypeMirror;
-
-/**
- * A {@link ModifiableAbstractMethodBindingExpression} for a binding that exists but is not ready to
- * be expressed in this compilation unit and should be deferred until a future compilation.
- * Generates a method that will be implemented in the future compilation.
- *
- * <p>A deferred modifiable binding expression is used when:
- *
- * <ul>
- * <li>The generated code for a binding requires an instance of a type that is generated in the
- * root component compilation unit.
- * <li>A {@linkplain ModifiableBindingType#BINDS_METHOD_WITH_MISSING_DEPENDENCY {@code @Binds}
- * method's dependency is missing} in a subcomponent.
- * </ul>
- */
-final class DeferredModifiableBindingExpression extends ModifiableAbstractMethodBindingExpression {
- private final ComponentImplementation componentImplementation;
- private final ContributionBinding binding;
- private final BindingRequest request;
-
- DeferredModifiableBindingExpression(
- ComponentImplementation componentImplementation,
- ModifiableBindingType modifiableBindingType,
- ContributionBinding binding,
- BindingRequest request,
- Optional<ModifiableBindingMethod> matchingModifiableBindingMethod,
- Optional<ComponentMethodDescriptor> matchingComponentMethod,
- DaggerTypes types) {
- super(
- componentImplementation,
- modifiableBindingType,
- request,
- matchingModifiableBindingMethod,
- matchingComponentMethod,
- types);
- this.componentImplementation = checkNotNull(componentImplementation);
- this.binding = checkNotNull(binding);
- this.request = checkNotNull(request);
- }
-
- @Override
- String chooseMethodName() {
- return componentImplementation.getUniqueMethodName(request);
- }
-
- @Override
- protected TypeMirror contributedType() {
- return binding.contributedType();
- }
-}
diff --git a/java/dagger/internal/codegen/DelegateBindingExpression.java b/java/dagger/internal/codegen/DelegateBindingExpression.java
deleted file mode 100644
index 8cdf6d1..0000000
--- a/java/dagger/internal/codegen/DelegateBindingExpression.java
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static dagger.internal.codegen.BindingRequest.bindingRequest;
-import static dagger.internal.codegen.RequestKinds.requestType;
-import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
-import static dagger.model.BindingKind.DELEGATE;
-
-import com.squareup.javapoet.ClassName;
-import dagger.internal.codegen.javapoet.Expression;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.RequestKind;
-import javax.lang.model.type.TypeMirror;
-
-/** A {@link BindingExpression} for {@code @Binds} methods. */
-final class DelegateBindingExpression extends BindingExpression {
- private final ContributionBinding binding;
- private final RequestKind requestKind;
- private final ComponentBindingExpressions componentBindingExpressions;
- private final DaggerTypes types;
- private final BindsTypeChecker bindsTypeChecker;
-
- DelegateBindingExpression(
- ResolvedBindings resolvedBindings,
- RequestKind requestKind,
- ComponentBindingExpressions componentBindingExpressions,
- DaggerTypes types,
- DaggerElements elements) {
- this.binding = checkNotNull(resolvedBindings.contributionBinding());
- this.requestKind = checkNotNull(requestKind);
- this.componentBindingExpressions = checkNotNull(componentBindingExpressions);
- this.types = checkNotNull(types);
- this.bindsTypeChecker = new BindsTypeChecker(types, elements);
- }
-
- /**
- * Returns {@code true} if the {@code @Binds} binding's scope is stronger than the scope of the
- * binding it depends on.
- */
- static boolean isBindsScopeStrongerThanDependencyScope(
- ResolvedBindings resolvedBindings, BindingGraph graph) {
- ContributionBinding bindsBinding = resolvedBindings.contributionBinding();
- checkArgument(bindsBinding.kind().equals(DELEGATE));
- Binding dependencyBinding =
- graph
- .contributionBindings()
- .get(getOnlyElement(bindsBinding.dependencies()).key())
- .binding();
- ScopeKind bindsScope = ScopeKind.get(bindsBinding, graph);
- ScopeKind dependencyScope = ScopeKind.get(dependencyBinding, graph);
- return bindsScope.isStrongerScopeThan(dependencyScope);
- }
-
- @Override
- Expression getDependencyExpression(ClassName requestingClass) {
- Expression delegateExpression =
- componentBindingExpressions.getDependencyExpression(
- bindingRequest(getOnlyElement(binding.dependencies()).key(), requestKind),
- requestingClass);
-
- TypeMirror contributedType = binding.contributedType();
- switch (requestKind) {
- case INSTANCE:
- return instanceRequiresCast(delegateExpression, requestingClass)
- ? delegateExpression.castTo(contributedType)
- : delegateExpression;
- default:
- return castToRawTypeIfNecessary(
- delegateExpression, requestType(requestKind, contributedType, types));
- }
- }
-
- private boolean instanceRequiresCast(Expression delegateExpression, ClassName requestingClass) {
- // delegateExpression.type() could be Object if expression is satisfied with a raw
- // Provider's get() method.
- return !bindsTypeChecker.isAssignable(
- delegateExpression.type(), binding.contributedType(), binding.contributionType())
- && isTypeAccessibleFrom(binding.contributedType(), requestingClass.packageName());
- }
-
- /**
- * If {@code delegateExpression} can be assigned to {@code desiredType} safely, then {@code
- * delegateExpression} is returned unchanged. If the {@code delegateExpression} is already a raw
- * type, returns {@code delegateExpression} as well, as casting would have no effect. Otherwise,
- * returns a {@link Expression#castTo(TypeMirror) casted} version of {@code delegateExpression}
- * to the raw type of {@code desiredType}.
- */
- // TODO(ronshapiro): this probably can be generalized for usage in InjectionMethods
- private Expression castToRawTypeIfNecessary(
- Expression delegateExpression, TypeMirror desiredType) {
- if (types.isAssignable(delegateExpression.type(), desiredType)) {
- return delegateExpression;
- }
- return delegateExpression.castTo(types.erasure(desiredType));
- }
-
- private enum ScopeKind {
- UNSCOPED,
- SINGLE_CHECK,
- DOUBLE_CHECK,
- ;
-
- static ScopeKind get(Binding binding, BindingGraph graph) {
- return binding
- .scope()
- .map(scope -> scope.isReusable() ? SINGLE_CHECK : DOUBLE_CHECK)
- .orElse(UNSCOPED);
- }
-
- boolean isStrongerScopeThan(ScopeKind other) {
- return this.ordinal() > other.ordinal();
- }
- }
-}
diff --git a/java/dagger/internal/codegen/DelegateDeclaration.java b/java/dagger/internal/codegen/DelegateDeclaration.java
deleted file mode 100644
index 67991de..0000000
--- a/java/dagger/internal/codegen/DelegateDeclaration.java
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static dagger.internal.codegen.MapKeys.getMapKey;
-import static dagger.internal.codegen.MoreAnnotationMirrors.wrapOptionalInEquivalence;
-
-import com.google.auto.common.MoreElements;
-import com.google.auto.common.MoreTypes;
-import com.google.auto.value.AutoValue;
-import com.google.auto.value.extension.memoized.Memoized;
-import com.google.common.base.Equivalence;
-import com.google.common.collect.Iterables;
-import dagger.Binds;
-import dagger.internal.codegen.ContributionType.HasContributionType;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.DependencyRequest;
-import java.util.Optional;
-import javax.inject.Inject;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.ExecutableType;
-
-/**
- * The declaration for a delegate binding established by a {@link Binds} method.
- */
-@AutoValue
-abstract class DelegateDeclaration extends BindingDeclaration implements HasContributionType {
- abstract DependencyRequest delegateRequest();
-
- abstract Optional<Equivalence.Wrapper<AnnotationMirror>> wrappedMapKey();
-
- @Memoized
- @Override
- public abstract int hashCode();
-
- @Override
- public abstract boolean equals(Object obj);
-
- static final class Factory {
- private final DaggerTypes types;
- private final KeyFactory keyFactory;
- private final DependencyRequestFactory dependencyRequestFactory;
-
- @Inject
- Factory(
- DaggerTypes types,
- KeyFactory keyFactory,
- DependencyRequestFactory dependencyRequestFactory) {
- this.types = types;
- this.keyFactory = keyFactory;
- this.dependencyRequestFactory = dependencyRequestFactory;
- }
-
- DelegateDeclaration create(
- ExecutableElement bindsMethod, TypeElement contributingModule) {
- checkArgument(MoreElements.isAnnotationPresent(bindsMethod, Binds.class));
- ExecutableType resolvedMethod =
- MoreTypes.asExecutable(
- types.asMemberOf(MoreTypes.asDeclared(contributingModule.asType()), bindsMethod));
- DependencyRequest delegateRequest =
- dependencyRequestFactory.forRequiredResolvedVariable(
- Iterables.getOnlyElement(bindsMethod.getParameters()),
- Iterables.getOnlyElement(resolvedMethod.getParameterTypes()));
- return new AutoValue_DelegateDeclaration(
- ContributionType.fromBindingElement(bindsMethod),
- keyFactory.forBindsMethod(bindsMethod, contributingModule),
- Optional.<Element>of(bindsMethod),
- Optional.of(contributingModule),
- delegateRequest,
- wrapOptionalInEquivalence(getMapKey(bindsMethod)));
- }
- }
-}
diff --git a/java/dagger/internal/codegen/DelegatingFrameworkInstanceCreationExpression.java b/java/dagger/internal/codegen/DelegatingFrameworkInstanceCreationExpression.java
deleted file mode 100644
index 7524cdf..0000000
--- a/java/dagger/internal/codegen/DelegatingFrameworkInstanceCreationExpression.java
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static dagger.internal.codegen.BindingRequest.bindingRequest;
-
-import com.squareup.javapoet.CodeBlock;
-import dagger.internal.codegen.FrameworkFieldInitializer.FrameworkInstanceCreationExpression;
-import dagger.internal.codegen.javapoet.CodeBlocks;
-import dagger.model.DependencyRequest;
-
-/** A framework instance creation expression for a {@link dagger.Binds @Binds} binding. */
-final class DelegatingFrameworkInstanceCreationExpression
- implements FrameworkInstanceCreationExpression {
-
- private final ContributionBinding binding;
- private final ComponentImplementation componentImplementation;
- private final ComponentBindingExpressions componentBindingExpressions;
-
- DelegatingFrameworkInstanceCreationExpression(
- ContributionBinding binding,
- ComponentImplementation componentImplementation,
- ComponentBindingExpressions componentBindingExpressions) {
- this.binding = checkNotNull(binding);
- this.componentImplementation = checkNotNull(componentImplementation);
- this.componentBindingExpressions = checkNotNull(componentBindingExpressions);
- }
-
- @Override
- public CodeBlock creationExpression() {
- DependencyRequest dependency = getOnlyElement(binding.dependencies());
- return CodeBlocks.cast(
- componentBindingExpressions
- .getDependencyExpression(
- bindingRequest(dependency.key(), binding.frameworkType()),
- componentImplementation.name())
- .codeBlock(),
- binding.frameworkType().frameworkClass());
- }
-}
diff --git a/java/dagger/internal/codegen/DependencyCycleValidator.java b/java/dagger/internal/codegen/DependencyCycleValidator.java
deleted file mode 100644
index d5d4b62..0000000
--- a/java/dagger/internal/codegen/DependencyCycleValidator.java
+++ /dev/null
@@ -1,319 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.collect.Iterables.getLast;
-import static com.google.common.collect.Iterables.limit;
-import static com.google.common.collect.Iterables.skip;
-import static com.google.common.collect.Sets.newHashSetWithExpectedSize;
-import static dagger.internal.codegen.DaggerGraphs.shortestPath;
-import static dagger.internal.codegen.DaggerStreams.instancesOf;
-import static dagger.internal.codegen.DaggerStreams.toImmutableList;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.internal.codegen.RequestKinds.extractKeyType;
-import static dagger.internal.codegen.RequestKinds.getRequestKind;
-import static javax.tools.Diagnostic.Kind.ERROR;
-
-import com.google.auto.value.AutoValue;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterables;
-import com.google.common.graph.EndpointPair;
-import com.google.common.graph.ImmutableNetwork;
-import com.google.common.graph.MutableNetwork;
-import com.google.common.graph.NetworkBuilder;
-import dagger.model.BindingGraph;
-import dagger.model.BindingGraph.ComponentNode;
-import dagger.model.BindingGraph.DependencyEdge;
-import dagger.model.BindingGraph.Node;
-import dagger.model.BindingKind;
-import dagger.model.DependencyRequest;
-import dagger.model.RequestKind;
-import dagger.spi.BindingGraphPlugin;
-import dagger.spi.DiagnosticReporter;
-import java.util.List;
-import java.util.Optional;
-import java.util.Set;
-import java.util.stream.Stream;
-import javax.inject.Inject;
-import javax.inject.Provider;
-import javax.lang.model.type.TypeMirror;
-
-/** Reports errors for dependency cycles. */
-final class DependencyCycleValidator implements BindingGraphPlugin {
-
- private final DependencyRequestFormatter dependencyRequestFormatter;
-
- @Inject
- DependencyCycleValidator(DependencyRequestFormatter dependencyRequestFormatter) {
- this.dependencyRequestFormatter = dependencyRequestFormatter;
- }
-
- @Override
- public String pluginName() {
- return "Dagger/DependencyCycle";
- }
-
- @Override
- public void visitGraph(BindingGraph bindingGraph, DiagnosticReporter diagnosticReporter) {
- ImmutableNetwork<Node, DependencyEdge> dependencyGraph =
- nonCycleBreakingDependencyGraph(bindingGraph);
- // Check each endpoint pair only once, no matter how many parallel edges connect them.
- Set<EndpointPair<Node>> dependencyEndpointPairs = dependencyGraph.asGraph().edges();
- Set<EndpointPair<Node>> visited = newHashSetWithExpectedSize(dependencyEndpointPairs.size());
- for (EndpointPair<Node> endpointPair : dependencyEndpointPairs) {
- cycleContainingEndpointPair(endpointPair, dependencyGraph, visited)
- .ifPresent(cycle -> reportCycle(cycle, bindingGraph, diagnosticReporter));
- }
- }
-
- private Optional<Cycle<Node>> cycleContainingEndpointPair(
- EndpointPair<Node> endpoints,
- ImmutableNetwork<Node, DependencyEdge> dependencyGraph,
- Set<EndpointPair<Node>> visited) {
- if (!visited.add(endpoints)) {
- // don't recheck endpoints we already know are part of a cycle
- return Optional.empty();
- }
-
- // If there's a path from the target back to the source, there's a cycle.
- ImmutableList<Node> cycleNodes =
- shortestPath(dependencyGraph, endpoints.target(), endpoints.source());
- if (cycleNodes.isEmpty()) {
- return Optional.empty();
- }
-
- Cycle<Node> cycle = Cycle.fromPath(cycleNodes);
- visited.addAll(cycle.endpointPairs()); // no need to check any edge in this cycle again
- return Optional.of(cycle);
- }
-
- /**
- * Reports a dependency cycle at the dependency into the cycle that is closest to an entry point.
- *
- * <p>For cycles found in reachable binding graphs, looks for the shortest path from the component
- * that contains the cycle (all bindings in a cycle must be in the same component; see below) to
- * some binding in the cycle. Then looks for the last dependency in that path that is not in the
- * cycle; that is the dependency that will be reported, so that the dependency trace will end just
- * before the cycle.
- *
- * <p>For cycles found during full binding graph validation, just reports the component that
- * contains the cycle.
- *
- * <p>Proof (by counterexample) that all bindings in a cycle must be in the same component: Assume
- * one binding in the cycle is in a parent component. Bindings cannot depend on bindings in child
- * components, so that binding cannot depend on the next binding in the cycle.
- */
- private void reportCycle(
- Cycle<Node> cycle, BindingGraph bindingGraph, DiagnosticReporter diagnosticReporter) {
- if (bindingGraph.isFullBindingGraph()) {
- diagnosticReporter.reportComponent(
- ERROR,
- bindingGraph.componentNode(cycle.nodes().asList().get(0).componentPath()).get(),
- errorMessage(cycle, bindingGraph));
- return;
- }
-
- ImmutableList<Node> path = shortestPathToCycleFromAnEntryPoint(cycle, bindingGraph);
- Node cycleStartNode = path.get(path.size() - 1);
- Node previousNode = path.get(path.size() - 2);
- DependencyEdge dependencyToReport =
- chooseDependencyEdgeConnecting(previousNode, cycleStartNode, bindingGraph);
- diagnosticReporter.reportDependency(
- ERROR, dependencyToReport, errorMessage(cycle.shift(cycleStartNode), bindingGraph));
- }
-
- private ImmutableList<Node> shortestPathToCycleFromAnEntryPoint(
- Cycle<Node> cycle, BindingGraph bindingGraph) {
- Node someCycleNode = cycle.nodes().asList().get(0);
- ComponentNode componentContainingCycle =
- bindingGraph.componentNode(someCycleNode.componentPath()).get();
- ImmutableList<Node> pathToCycle =
- shortestPath(bindingGraph.network(), componentContainingCycle, someCycleNode);
- return subpathToCycle(pathToCycle, cycle);
- }
-
- /**
- * Returns the subpath from the head of {@code path} to the first node in {@code path} that's in
- * the cycle.
- */
- private ImmutableList<Node> subpathToCycle(ImmutableList<Node> path, Cycle<Node> cycle) {
- ImmutableList.Builder<Node> subpath = ImmutableList.builder();
- for (Node node : path) {
- subpath.add(node);
- if (cycle.nodes().contains(node)) {
- return subpath.build();
- }
- }
- throw new IllegalArgumentException(
- "path " + path + " doesn't contain any nodes in cycle " + cycle);
- }
-
- private String errorMessage(Cycle<Node> cycle, BindingGraph graph) {
- StringBuilder message = new StringBuilder("Found a dependency cycle:");
- ImmutableList<DependencyRequest> cycleRequests =
- cycle.endpointPairs().stream()
- // TODO(dpb): Would be nice to take the dependency graph here.
- .map(endpointPair -> nonCycleBreakingEdge(endpointPair, graph))
- .map(DependencyEdge::dependencyRequest)
- .collect(toImmutableList())
- .reverse();
- dependencyRequestFormatter.formatIndentedList(message, cycleRequests, 0);
- return message.toString();
- }
-
- /**
- * Returns one of the edges between two nodes that doesn't {@linkplain
- * #breaksCycle(DependencyEdge, BindingGraph) break} a cycle.
- */
- private DependencyEdge nonCycleBreakingEdge(EndpointPair<Node> endpointPair, BindingGraph graph) {
- return graph.network().edgesConnecting(endpointPair.source(), endpointPair.target()).stream()
- .flatMap(instancesOf(DependencyEdge.class))
- .filter(edge -> !breaksCycle(edge, graph))
- .findFirst()
- .get();
- }
-
- private boolean breaksCycle(DependencyEdge edge, BindingGraph graph) {
- if (edge.dependencyRequest().key().multibindingContributionIdentifier().isPresent()) {
- return false;
- }
- if (breaksCycle(edge.dependencyRequest().key().type(), edge.dependencyRequest().kind())) {
- return true;
- }
- Node target = graph.network().incidentNodes(edge).target();
- if (target instanceof dagger.model.Binding
- && ((dagger.model.Binding) target).kind().equals(BindingKind.OPTIONAL)) {
- /* For @BindsOptionalOf bindings, unwrap the type inside the Optional. If the unwrapped type
- * breaks the cycle, so does the optional binding. */
- TypeMirror optionalValueType = OptionalType.from(edge.dependencyRequest().key()).valueType();
- RequestKind requestKind = getRequestKind(optionalValueType);
- return breaksCycle(extractKeyType(requestKind, optionalValueType), requestKind);
- }
- return false;
- }
-
- private boolean breaksCycle(TypeMirror requestedType, RequestKind requestKind) {
- switch (requestKind) {
- case PROVIDER:
- case LAZY:
- case PROVIDER_OF_LAZY:
- return true;
-
- case INSTANCE:
- if (MapType.isMap(requestedType)) {
- MapType mapType = MapType.from(requestedType);
- return !mapType.isRawType() && mapType.valuesAreTypeOf(Provider.class);
- }
- // fall through
-
- default:
- return false;
- }
- }
-
- private DependencyEdge chooseDependencyEdgeConnecting(
- Node source, Node target, BindingGraph bindingGraph) {
- return bindingGraph.network().edgesConnecting(source, target).stream()
- .flatMap(instancesOf(DependencyEdge.class))
- .findFirst()
- .get();
- }
-
- /** Returns the subgraph containing only {@link DependencyEdge}s that would not break a cycle. */
- // TODO(dpb): Return a network containing only Binding nodes.
- private ImmutableNetwork<Node, DependencyEdge> nonCycleBreakingDependencyGraph(
- BindingGraph bindingGraph) {
- MutableNetwork<Node, DependencyEdge> dependencyNetwork =
- NetworkBuilder.from(bindingGraph.network())
- .expectedNodeCount(bindingGraph.network().nodes().size())
- .expectedEdgeCount(bindingGraph.dependencyEdges().size())
- .build();
- bindingGraph.dependencyEdges().stream()
- .filter(edge -> !breaksCycle(edge, bindingGraph))
- .forEach(
- edge -> {
- EndpointPair<Node> endpoints = bindingGraph.network().incidentNodes(edge);
- dependencyNetwork.addEdge(endpoints.source(), endpoints.target(), edge);
- });
- return ImmutableNetwork.copyOf(dependencyNetwork);
- }
-
- /**
- * An ordered set of endpoint pairs representing the edges in the cycle. The target of each pair
- * is the source of the next pair. The target of the last pair is the source of the first pair.
- */
- @AutoValue
- abstract static class Cycle<N> {
- /**
- * The ordered set of endpoint pairs representing the edges in the cycle. The target of each
- * pair is the source of the next pair. The target of the last pair is the source of the first
- * pair.
- */
- abstract ImmutableSet<EndpointPair<N>> endpointPairs();
-
- /** Returns the nodes that participate in the cycle. */
- ImmutableSet<N> nodes() {
- return endpointPairs().stream()
- .flatMap(pair -> Stream.of(pair.source(), pair.target()))
- .collect(toImmutableSet());
- }
-
- /** Returns the number of edges in the cycle. */
- int size() {
- return endpointPairs().size();
- }
-
- /**
- * Shifts this cycle so that it starts with a specific node.
- *
- * @return a cycle equivalent to this one but whose first pair starts with {@code startNode}
- */
- Cycle<N> shift(N startNode) {
- int startIndex = Iterables.indexOf(endpointPairs(), pair -> pair.source().equals(startNode));
- checkArgument(
- startIndex >= 0, "startNode (%s) is not part of this cycle: %s", startNode, this);
- if (startIndex == 0) {
- return this;
- }
- ImmutableSet.Builder<EndpointPair<N>> shifted = ImmutableSet.builder();
- shifted.addAll(skip(endpointPairs(), startIndex));
- shifted.addAll(limit(endpointPairs(), size() - startIndex));
- return new AutoValue_DependencyCycleValidator_Cycle<>(shifted.build());
- }
-
- @Override
- public final String toString() {
- return endpointPairs().toString();
- }
-
- /**
- * Creates a {@link Cycle} from a nonempty list of nodes, assuming there is an edge between each
- * pair of nodes as well as an edge from the last node to the first.
- */
- static <N> Cycle<N> fromPath(List<N> nodes) {
- checkArgument(!nodes.isEmpty());
- ImmutableSet.Builder<EndpointPair<N>> cycle = ImmutableSet.builder();
- cycle.add(EndpointPair.ordered(getLast(nodes), nodes.get(0)));
- for (int i = 0; i < nodes.size() - 1; i++) {
- cycle.add(EndpointPair.ordered(nodes.get(i), nodes.get(i + 1)));
- }
- return new AutoValue_DependencyCycleValidator_Cycle<>(cycle.build());
- }
- }
-}
diff --git a/java/dagger/internal/codegen/DependencyEdgeImpl.java b/java/dagger/internal/codegen/DependencyEdgeImpl.java
deleted file mode 100644
index 64b0845..0000000
--- a/java/dagger/internal/codegen/DependencyEdgeImpl.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import dagger.model.BindingGraph.DependencyEdge;
-import dagger.model.DependencyRequest;
-
-/** An implementation of {@link DependencyEdge}. */
-final class DependencyEdgeImpl implements DependencyEdge {
-
- private final DependencyRequest dependencyRequest;
- private final boolean entryPoint;
-
- DependencyEdgeImpl(DependencyRequest dependencyRequest, boolean entryPoint) {
- this.dependencyRequest = dependencyRequest;
- this.entryPoint = entryPoint;
- }
-
- @Override
- public DependencyRequest dependencyRequest() {
- return dependencyRequest;
- }
-
- @Override
- public boolean isEntryPoint() {
- return entryPoint;
- }
-
- @Override
- public String toString() {
- String string =
- dependencyRequest
- .requestElement()
- .map(ElementFormatter::elementToString)
- .orElseGet(
- () ->
- "synthetic request for "
- + dependencyRequest.kind().format(dependencyRequest.key()));
- return entryPoint ? string + " (entry point)" : string;
- }
-}
diff --git a/java/dagger/internal/codegen/DependencyMethodProducerCreationExpression.java b/java/dagger/internal/codegen/DependencyMethodProducerCreationExpression.java
deleted file mode 100644
index b42f9c4..0000000
--- a/java/dagger/internal/codegen/DependencyMethodProducerCreationExpression.java
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.squareup.javapoet.MethodSpec.methodBuilder;
-import static com.squareup.javapoet.TypeSpec.anonymousClassBuilder;
-import static dagger.internal.codegen.javapoet.TypeNames.dependencyMethodProducerOf;
-import static dagger.internal.codegen.javapoet.TypeNames.listenableFutureOf;
-import static javax.lang.model.element.Modifier.FINAL;
-import static javax.lang.model.element.Modifier.PRIVATE;
-import static javax.lang.model.element.Modifier.PUBLIC;
-
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.FieldSpec;
-import com.squareup.javapoet.TypeName;
-import dagger.internal.codegen.FrameworkFieldInitializer.FrameworkInstanceCreationExpression;
-
-/**
- * A {@link dagger.producers.Producer} creation expression for a production method on a production
- * component's {@linkplain dagger.producers.ProductionComponent#dependencies()} dependency} that
- * returns a {@link com.google.common.util.concurrent.ListenableFuture}.
- */
-// TODO(dpb): Resolve with DependencyMethodProviderCreationExpression.
-final class DependencyMethodProducerCreationExpression
- implements FrameworkInstanceCreationExpression {
- private final ContributionBinding binding;
- private final ComponentImplementation componentImplementation;
- private final ComponentRequirementExpressions componentRequirementExpressions;
- private final BindingGraph graph;
-
- DependencyMethodProducerCreationExpression(
- ContributionBinding binding,
- ComponentImplementation componentImplementation,
- ComponentRequirementExpressions componentRequirementExpressions,
- BindingGraph graph) {
- this.binding = checkNotNull(binding);
- this.componentImplementation = checkNotNull(componentImplementation);
- this.componentRequirementExpressions = checkNotNull(componentRequirementExpressions);
- this.graph = checkNotNull(graph);
- }
-
- @Override
- public CodeBlock creationExpression() {
- ComponentRequirement dependency =
- graph.componentDescriptor().getDependencyThatDefinesMethod(binding.bindingElement().get());
- FieldSpec dependencyField =
- FieldSpec.builder(
- ClassName.get(dependency.typeElement()), dependency.variableName(), PRIVATE, FINAL)
- .initializer(
- componentRequirementExpressions.getExpressionDuringInitialization(
- dependency,
- // This isn't a real class name, but we want the requesting class for the
- // expression to *not* be the same class as the component implementation,
- // because it isn't... it's an anonymous inner class.
- // TODO(cgdecker): If we didn't use an anonymous inner class here but instead
- // generated a named nested class as with
- // DependencyMethodProviderCreationExpression, we wouldn't need to deal with
- // this and might be able to avoid potentially creating an extra field in the
- // component?
- componentImplementation.name().nestedClass("Anonymous")))
- .build();
- // TODO(b/70395982): Explore using a private static type instead of an anonymous class.
- TypeName keyType = TypeName.get(binding.key().type());
- return CodeBlock.of(
- "$L",
- anonymousClassBuilder("")
- .superclass(dependencyMethodProducerOf(keyType))
- .addField(dependencyField)
- .addMethod(
- methodBuilder("callDependencyMethod")
- .addAnnotation(Override.class)
- .addModifiers(PUBLIC)
- .returns(listenableFutureOf(keyType))
- .addStatement(
- "return $N.$L()",
- dependencyField,
- binding.bindingElement().get().getSimpleName())
- .build())
- .build());
- }
-}
diff --git a/java/dagger/internal/codegen/DependencyMethodProviderCreationExpression.java b/java/dagger/internal/codegen/DependencyMethodProviderCreationExpression.java
deleted file mode 100644
index 8532481..0000000
--- a/java/dagger/internal/codegen/DependencyMethodProviderCreationExpression.java
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.squareup.javapoet.MethodSpec.constructorBuilder;
-import static com.squareup.javapoet.MethodSpec.methodBuilder;
-import static com.squareup.javapoet.TypeSpec.classBuilder;
-import static dagger.internal.codegen.ComponentImplementation.TypeSpecKind.COMPONENT_PROVISION_FACTORY;
-import static dagger.internal.codegen.javapoet.TypeNames.providerOf;
-import static javax.lang.model.element.Modifier.FINAL;
-import static javax.lang.model.element.Modifier.PRIVATE;
-import static javax.lang.model.element.Modifier.PUBLIC;
-import static javax.lang.model.element.Modifier.STATIC;
-
-import com.google.auto.common.MoreTypes;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.MethodSpec;
-import com.squareup.javapoet.TypeName;
-import dagger.internal.codegen.FrameworkFieldInitializer.FrameworkInstanceCreationExpression;
-import javax.lang.model.element.Element;
-
-/**
- * A {@link javax.inject.Provider} creation expression for a provision method on a component's
- * {@linkplain dagger.Component#dependencies()} dependency}.
- */
-// TODO(dpb): Resolve with DependencyMethodProducerCreationExpression.
-final class DependencyMethodProviderCreationExpression
- implements FrameworkInstanceCreationExpression {
-
- private final ComponentImplementation componentImplementation;
- private final ComponentRequirementExpressions componentRequirementExpressions;
- private final CompilerOptions compilerOptions;
- private final BindingGraph graph;
- private final ContributionBinding binding;
-
- DependencyMethodProviderCreationExpression(
- ContributionBinding binding,
- ComponentImplementation componentImplementation,
- ComponentRequirementExpressions componentRequirementExpressions,
- CompilerOptions compilerOptions,
- BindingGraph graph) {
- this.binding = checkNotNull(binding);
- this.componentImplementation = checkNotNull(componentImplementation);
- this.componentRequirementExpressions = checkNotNull(componentRequirementExpressions);
- this.compilerOptions = checkNotNull(compilerOptions);
- this.graph = checkNotNull(graph);
- }
-
- @Override
- public CodeBlock creationExpression() {
- // TODO(sameb): The Provider.get() throws a very vague NPE. The stack trace doesn't
- // help to figure out what the method or return type is. If we include a string
- // of the return type or method name in the error message, that can defeat obfuscation.
- // We can easily include the raw type (no generics) + annotation type (no values),
- // using .class & String.format -- but that wouldn't be the whole story.
- // What should we do?
- CodeBlock invocation =
- ComponentProvisionBindingExpression.maybeCheckForNull(
- (ProvisionBinding) binding,
- compilerOptions,
- CodeBlock.of(
- "$N.$N()", dependency().variableName(), provisionMethod().getSimpleName()));
- ClassName dependencyClassName = ClassName.get(dependency().typeElement());
- TypeName keyType = TypeName.get(binding.key().type());
- MethodSpec.Builder getMethod =
- methodBuilder("get")
- .addAnnotation(Override.class)
- .addModifiers(PUBLIC)
- .returns(keyType)
- .addStatement("return $L", invocation);
- if (binding.nullableType().isPresent()) {
- getMethod.addAnnotation(ClassName.get(MoreTypes.asTypeElement(binding.nullableType().get())));
- }
- componentImplementation.addType(
- COMPONENT_PROVISION_FACTORY,
- classBuilder(factoryClassName())
- .addSuperinterface(providerOf(keyType))
- .addModifiers(PRIVATE, STATIC)
- .addField(dependencyClassName, dependency().variableName(), PRIVATE, FINAL)
- .addMethod(
- constructorBuilder()
- .addParameter(dependencyClassName, dependency().variableName())
- .addStatement("this.$1L = $1L", dependency().variableName())
- .build())
- .addMethod(getMethod.build())
- .build());
- return CodeBlock.of(
- "new $T($L)",
- factoryClassName(),
- componentRequirementExpressions.getExpressionDuringInitialization(
- dependency(), componentImplementation.name()));
- }
-
- private ClassName factoryClassName() {
- String factoryName =
- ClassName.get(dependency().typeElement()).toString().replace('.', '_')
- + "_"
- + binding.bindingElement().get().getSimpleName();
- return componentImplementation.name().nestedClass(factoryName);
- }
-
- private ComponentRequirement dependency() {
- return graph.componentDescriptor().getDependencyThatDefinesMethod(provisionMethod());
- }
-
- private Element provisionMethod() {
- return binding.bindingElement().get();
- }
-}
diff --git a/java/dagger/internal/codegen/DependencyRequestFactory.java b/java/dagger/internal/codegen/DependencyRequestFactory.java
deleted file mode 100644
index 3ad12e2..0000000
--- a/java/dagger/internal/codegen/DependencyRequestFactory.java
+++ /dev/null
@@ -1,237 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreTypes.isTypeOf;
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.base.Preconditions.checkState;
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static dagger.internal.codegen.ConfigurationAnnotations.getNullableType;
-import static dagger.internal.codegen.RequestKinds.extractKeyType;
-import static dagger.internal.codegen.RequestKinds.frameworkClass;
-import static dagger.internal.codegen.RequestKinds.getRequestKind;
-import static dagger.model.RequestKind.FUTURE;
-import static dagger.model.RequestKind.INSTANCE;
-import static dagger.model.RequestKind.MEMBERS_INJECTION;
-import static dagger.model.RequestKind.PRODUCER;
-import static dagger.model.RequestKind.PROVIDER;
-
-import com.google.common.collect.ImmutableSet;
-import com.google.common.util.concurrent.ListenableFuture;
-import dagger.Lazy;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.DependencyRequest;
-import dagger.model.Key;
-import dagger.model.RequestKind;
-import java.util.List;
-import java.util.Optional;
-import javax.inject.Inject;
-import javax.inject.Provider;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.VariableElement;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.ExecutableType;
-import javax.lang.model.type.TypeMirror;
-
-/**
- * Factory for {@link DependencyRequest}s.
- *
- * <p>Any factory method may throw {@link TypeNotPresentException} if a type is not available, which
- * may mean that the type will be generated in a later round of processing.
- */
-final class DependencyRequestFactory {
- private final KeyFactory keyFactory;
- private final DaggerTypes types;
-
- @Inject
- DependencyRequestFactory(KeyFactory keyFactory, DaggerTypes types) {
- this.keyFactory = keyFactory;
- this.types = types;
- }
-
- ImmutableSet<DependencyRequest> forRequiredResolvedVariables(
- List<? extends VariableElement> variables, List<? extends TypeMirror> resolvedTypes) {
- checkState(resolvedTypes.size() == variables.size());
- ImmutableSet.Builder<DependencyRequest> builder = ImmutableSet.builder();
- for (int i = 0; i < variables.size(); i++) {
- builder.add(forRequiredResolvedVariable(variables.get(i), resolvedTypes.get(i)));
- }
- return builder.build();
- }
-
- /**
- * Creates synthetic dependency requests for each individual multibinding contribution in {@code
- * multibindingContributions}.
- */
- ImmutableSet<DependencyRequest> forMultibindingContributions(
- Key multibindingKey, Iterable<ContributionBinding> multibindingContributions) {
- ImmutableSet.Builder<DependencyRequest> requests = ImmutableSet.builder();
- for (ContributionBinding multibindingContribution : multibindingContributions) {
- requests.add(forMultibindingContribution(multibindingKey, multibindingContribution));
- }
- return requests.build();
- }
-
- /** Creates a synthetic dependency request for one individual {@code multibindingContribution}. */
- private DependencyRequest forMultibindingContribution(
- Key multibindingKey, ContributionBinding multibindingContribution) {
- checkArgument(
- multibindingContribution.key().multibindingContributionIdentifier().isPresent(),
- "multibindingContribution's key must have a multibinding contribution identifier: %s",
- multibindingContribution);
- return DependencyRequest.builder()
- .kind(multibindingContributionRequestKind(multibindingKey, multibindingContribution))
- .key(multibindingContribution.key())
- .build();
- }
-
- // TODO(b/28555349): support PROVIDER_OF_LAZY here too
- private static final ImmutableSet<RequestKind> WRAPPING_MAP_VALUE_FRAMEWORK_TYPES =
- ImmutableSet.of(PROVIDER, PRODUCER);
-
- private RequestKind multibindingContributionRequestKind(
- Key multibindingKey, ContributionBinding multibindingContribution) {
- switch (multibindingContribution.contributionType()) {
- case MAP:
- MapType mapType = MapType.from(multibindingKey);
- for (RequestKind kind : WRAPPING_MAP_VALUE_FRAMEWORK_TYPES) {
- if (mapType.valuesAreTypeOf(frameworkClass(kind))) {
- return kind;
- }
- }
- // fall through
- case SET:
- case SET_VALUES:
- return INSTANCE;
- case UNIQUE:
- throw new IllegalArgumentException(
- "multibindingContribution must be a multibinding: " + multibindingContribution);
- }
- throw new AssertionError(multibindingContribution.toString());
- }
-
- DependencyRequest forRequiredResolvedVariable(
- VariableElement variableElement, TypeMirror resolvedType) {
- checkNotNull(variableElement);
- checkNotNull(resolvedType);
- Optional<AnnotationMirror> qualifier = InjectionAnnotations.getQualifier(variableElement);
- return newDependencyRequest(variableElement, resolvedType, qualifier);
- }
-
- DependencyRequest forComponentProvisionMethod(
- ExecutableElement provisionMethod, ExecutableType provisionMethodType) {
- checkNotNull(provisionMethod);
- checkNotNull(provisionMethodType);
- checkArgument(
- provisionMethod.getParameters().isEmpty(),
- "Component provision methods must be empty: %s",
- provisionMethod);
- Optional<AnnotationMirror> qualifier = InjectionAnnotations.getQualifier(provisionMethod);
- return newDependencyRequest(provisionMethod, provisionMethodType.getReturnType(), qualifier);
- }
-
- DependencyRequest forComponentProductionMethod(
- ExecutableElement productionMethod, ExecutableType productionMethodType) {
- checkNotNull(productionMethod);
- checkNotNull(productionMethodType);
- checkArgument(
- productionMethod.getParameters().isEmpty(),
- "Component production methods must be empty: %s",
- productionMethod);
- TypeMirror type = productionMethodType.getReturnType();
- Optional<AnnotationMirror> qualifier = InjectionAnnotations.getQualifier(productionMethod);
- // Only a component production method can be a request for a ListenableFuture, so we
- // special-case it here.
- if (isTypeOf(ListenableFuture.class, type)) {
- return DependencyRequest.builder()
- .kind(FUTURE)
- .key(keyFactory.forQualifiedType(qualifier, types.unwrapType(type)))
- .requestElement(productionMethod)
- .build();
- } else {
- return newDependencyRequest(productionMethod, type, qualifier);
- }
- }
-
- DependencyRequest forComponentMembersInjectionMethod(
- ExecutableElement membersInjectionMethod, ExecutableType membersInjectionMethodType) {
- checkNotNull(membersInjectionMethod);
- checkNotNull(membersInjectionMethodType);
- Optional<AnnotationMirror> qualifier =
- InjectionAnnotations.getQualifier(membersInjectionMethod);
- checkArgument(!qualifier.isPresent());
- TypeMirror membersInjectedType = getOnlyElement(membersInjectionMethodType.getParameterTypes());
- return DependencyRequest.builder()
- .kind(MEMBERS_INJECTION)
- .key(keyFactory.forMembersInjectedType(membersInjectedType))
- .requestElement(membersInjectionMethod)
- .build();
- }
-
- DependencyRequest forProductionImplementationExecutor() {
- return DependencyRequest.builder()
- .kind(PROVIDER)
- .key(keyFactory.forProductionImplementationExecutor())
- .build();
- }
-
- DependencyRequest forProductionComponentMonitor() {
- return DependencyRequest.builder()
- .kind(PROVIDER)
- .key(keyFactory.forProductionComponentMonitor())
- .build();
- }
-
- /**
- * Returns a synthetic request for the present value of an optional binding generated from a
- * {@link dagger.BindsOptionalOf} declaration.
- */
- DependencyRequest forSyntheticPresentOptionalBinding(Key requestKey, RequestKind kind) {
- Optional<Key> key = keyFactory.unwrapOptional(requestKey);
- checkArgument(key.isPresent(), "not a request for optional: %s", requestKey);
- return DependencyRequest.builder()
- .kind(kind)
- .key(key.get())
- .isNullable(
- allowsNull(getRequestKind(OptionalType.from(requestKey).valueType()), Optional.empty()))
- .build();
- }
-
- private DependencyRequest newDependencyRequest(
- Element requestElement, TypeMirror type, Optional<AnnotationMirror> qualifier) {
- RequestKind requestKind = getRequestKind(type);
- return DependencyRequest.builder()
- .kind(requestKind)
- .key(keyFactory.forQualifiedType(qualifier, extractKeyType(requestKind, type)))
- .requestElement(requestElement)
- .isNullable(allowsNull(requestKind, getNullableType(requestElement)))
- .build();
- }
-
- /**
- * Returns {@code true} if a given request element allows null values. {@link
- * RequestKind#INSTANCE} requests must be annotated with {@code @Nullable} in order to allow null
- * values. All other request kinds implicitly allow null values because they are are wrapped
- * inside {@link Provider}, {@link Lazy}, etc.
- */
- private boolean allowsNull(RequestKind kind, Optional<DeclaredType> nullableType) {
- return nullableType.isPresent() || !kind.equals(INSTANCE);
- }
-}
diff --git a/java/dagger/internal/codegen/DependencyRequestFormatter.java b/java/dagger/internal/codegen/DependencyRequestFormatter.java
deleted file mode 100644
index 25becaf..0000000
--- a/java/dagger/internal/codegen/DependencyRequestFormatter.java
+++ /dev/null
@@ -1,151 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.ElementFormatter.elementToString;
-import static dagger.internal.codegen.RequestKinds.requestType;
-
-import com.google.errorprone.annotations.CanIgnoreReturnValue;
-import dagger.Provides;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.DependencyRequest;
-import dagger.producers.Produces;
-import java.util.Optional;
-import javax.inject.Inject;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ElementVisitor;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.element.VariableElement;
-import javax.lang.model.type.TypeMirror;
-import javax.lang.model.util.ElementKindVisitor8;
-
-/**
- * Formats a {@link DependencyRequest} into a {@link String} suitable for an error message listing a
- * chain of dependencies.
- *
- * <dl>
- * <dt>For component provision methods
- * <dd>{@code @Qualifier SomeType is provided at\n ComponentType.method()}
- * <dt>For component injection methods
- * <dd>{@code SomeType is injected at\n ComponentType.method(foo)}
- * <dt>For parameters to {@link Provides @Provides}, {@link Produces @Produces}, or {@link
- * Inject @Inject} methods:
- * <dd>{@code @Qualified ResolvedType is injected at\n EnclosingType.method([…, ]param[, …])}
- * <dt>For parameters to {@link Inject @Inject} constructors:
- * <dd>{@code @Qualified ResolvedType is injected at\n EnclosingType([…, ]param[, …])}
- * <dt>For {@link Inject @Inject} fields:
- * <dd>{@code @Qualified ResolvedType is injected at\n EnclosingType.field}
- * </dl>
- */
-final class DependencyRequestFormatter extends Formatter<DependencyRequest> {
-
- private final DaggerTypes types;
-
- @Inject
- DependencyRequestFormatter(DaggerTypes types) {
- this.types = types;
- }
-
- @Override
- public String format(DependencyRequest request) {
- return request
- .requestElement()
- .map(element -> element.accept(formatVisitor, request))
- .orElse("");
- }
-
- /**
- * Appends a newline and the formatted dependency request unless {@link
- * #format(DependencyRequest)} returns the empty string.
- */
- @CanIgnoreReturnValue
- StringBuilder appendFormatLine(StringBuilder builder, DependencyRequest dependencyRequest) {
- String formatted = format(dependencyRequest);
- if (!formatted.isEmpty()) {
- builder.append('\n').append(formatted);
- }
- return builder;
- }
-
- private final ElementVisitor<String, DependencyRequest> formatVisitor =
- new ElementKindVisitor8<String, DependencyRequest>() {
-
- @Override
- public String visitExecutableAsMethod(ExecutableElement method, DependencyRequest request) {
- return INDENT
- + request.key()
- + " is "
- + componentMethodRequestVerb(request)
- + " at\n"
- + DOUBLE_INDENT
- + elementToString(method);
- }
-
- @Override
- public String visitVariable(VariableElement variable, DependencyRequest request) {
- TypeMirror requestedType = requestType(request.kind(), request.key().type(), types);
- return INDENT
- + formatQualifier(request.key().qualifier())
- + requestedType
- + " is injected at\n"
- + DOUBLE_INDENT
- + elementToString(variable);
- }
-
- @Override
- public String visitType(TypeElement e, DependencyRequest request) {
- return ""; // types by themselves provide no useful information.
- }
-
- @Override
- protected String defaultAction(Element element, DependencyRequest request) {
- throw new IllegalStateException(
- "Invalid request " + element.getKind() + " element " + element);
- }
- };
-
- private String formatQualifier(Optional<AnnotationMirror> maybeQualifier) {
- return maybeQualifier.map(qualifier -> qualifier + " ").orElse("");
- }
-
- /**
- * Returns the verb for a component method dependency request. Returns "produced", "provided", or
- * "injected", depending on the kind of request.
- */
- private String componentMethodRequestVerb(DependencyRequest request) {
- switch (request.kind()) {
- case FUTURE:
- case PRODUCER:
- return "produced";
-
- case INSTANCE:
- case LAZY:
- case PROVIDER:
- case PROVIDER_OF_LAZY:
- return "provided";
-
- case MEMBERS_INJECTION:
- return "injected";
-
- case PRODUCED:
- break;
- }
- throw new AssertionError("illegal request kind for method: " + request);
- }
-}
diff --git a/java/dagger/internal/codegen/DependencyRequestValidator.java b/java/dagger/internal/codegen/DependencyRequestValidator.java
deleted file mode 100644
index 1a99818..0000000
--- a/java/dagger/internal/codegen/DependencyRequestValidator.java
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.InjectionAnnotations.getQualifiers;
-import static dagger.internal.codegen.RequestKinds.extractKeyType;
-import static dagger.internal.codegen.RequestKinds.getRequestKind;
-import static javax.lang.model.type.TypeKind.WILDCARD;
-
-import com.google.auto.common.MoreTypes;
-import com.google.common.collect.ImmutableSet;
-import dagger.MembersInjector;
-import javax.inject.Inject;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.VariableElement;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.TypeMirror;
-
-/** Validation for dependency requests. */
-final class DependencyRequestValidator {
- private final MembersInjectionValidator membersInjectionValidator;
-
- @Inject
- DependencyRequestValidator(MembersInjectionValidator membersInjectionValidator) {
- this.membersInjectionValidator = membersInjectionValidator;
- }
-
- /**
- * Adds an error if the given dependency request has more than one qualifier annotation or is a
- * non-instance request with a wildcard type.
- */
- void validateDependencyRequest(
- ValidationReport.Builder<?> report, Element requestElement, TypeMirror requestType) {
- ImmutableSet<? extends AnnotationMirror> qualifiers = getQualifiers(requestElement);
- if (qualifiers.size() > 1) {
- for (AnnotationMirror qualifier : qualifiers) {
- report.addError(
- "A single dependency request may not use more than one @Qualifier",
- requestElement,
- qualifier);
- }
- }
-
- TypeMirror keyType = extractKeyType(getRequestKind(requestType), requestType);
- if (keyType.getKind().equals(WILDCARD)) {
- // TODO(ronshapiro): Explore creating this message using RequestKinds.
- report.addError(
- "Dagger does not support injecting Provider<T>, Lazy<T>, Producer<T>, "
- + "or Produced<T> when T is a wildcard type such as "
- + keyType,
- requestElement);
- }
- if (MoreTypes.isType(keyType) && MoreTypes.isTypeOf(MembersInjector.class, keyType)) {
- DeclaredType membersInjectorType = MoreTypes.asDeclared(keyType);
- if (membersInjectorType.getTypeArguments().isEmpty()) {
- report.addError("Cannot inject a raw MembersInjector", requestElement);
- } else {
- report.addSubreport(
- membersInjectionValidator.validateMembersInjectionRequest(
- requestElement, membersInjectorType.getTypeArguments().get(0)));
- }
- }
- }
-
- /**
- * Adds an error if the given dependency request is for a {@link dagger.producers.Producer} or
- * {@link dagger.producers.Produced}.
- *
- * <p>Only call this when processing a provision binding.
- */
- // TODO(dpb): Should we disallow Producer entry points in non-production components?
- void checkNotProducer(ValidationReport.Builder<?> report, VariableElement requestElement) {
- TypeMirror requestType = requestElement.asType();
- if (FrameworkTypes.isProducerType(requestType)) {
- report.addError(
- String.format(
- "%s may only be injected in @Produces methods",
- MoreTypes.asTypeElement(requestType).getSimpleName()),
- requestElement);
- }
- }
-}
diff --git a/java/dagger/internal/codegen/DependencyVariableNamer.java b/java/dagger/internal/codegen/DependencyVariableNamer.java
deleted file mode 100644
index 21f2d32..0000000
--- a/java/dagger/internal/codegen/DependencyVariableNamer.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.SourceFiles.simpleVariableName;
-
-import com.google.auto.common.MoreTypes;
-import com.google.common.base.Ascii;
-import com.google.common.base.CaseFormat;
-import dagger.Lazy;
-import dagger.model.DependencyRequest;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-import javax.inject.Provider;
-
-/**
- * Picks a reasonable name for what we think is being provided from the variable name associated
- * with the {@link DependencyRequest}. I.e. strips out words like "lazy" and "provider" if we
- * believe that those refer to {@link Lazy} and {@link Provider} rather than the type being
- * provided.
- */
-//TODO(gak): develop the heuristics to get better names
-final class DependencyVariableNamer {
- private static final Pattern LAZY_PROVIDER_PATTERN = Pattern.compile("lazy(\\w+)Provider");
-
- static String name(DependencyRequest dependency) {
- if (!dependency.requestElement().isPresent()) {
- return simpleVariableName(MoreTypes.asTypeElement(dependency.key().type()));
- }
-
- String variableName = dependency.requestElement().get().getSimpleName().toString();
- if (Ascii.isUpperCase(variableName.charAt(0))) {
- variableName = toLowerCamel(variableName);
- }
- switch (dependency.kind()) {
- case INSTANCE:
- return variableName;
- case LAZY:
- return variableName.startsWith("lazy") && !variableName.equals("lazy")
- ? toLowerCamel(variableName.substring(4))
- : variableName;
- case PROVIDER_OF_LAZY:
- Matcher matcher = LAZY_PROVIDER_PATTERN.matcher(variableName);
- if (matcher.matches()) {
- return toLowerCamel(matcher.group(1));
- }
- // fall through
- case PROVIDER:
- return variableName.endsWith("Provider") && !variableName.equals("Provider")
- ? variableName.substring(0, variableName.length() - 8)
- : variableName;
- case PRODUCED:
- return variableName.startsWith("produced") && !variableName.equals("produced")
- ? toLowerCamel(variableName.substring(8))
- : variableName;
- case PRODUCER:
- return variableName.endsWith("Producer") && !variableName.equals("Producer")
- ? variableName.substring(0, variableName.length() - 8)
- : variableName;
- default:
- throw new AssertionError();
- }
- }
-
- private static String toLowerCamel(String name) {
- return CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL, name);
- }
-}
diff --git a/java/dagger/internal/codegen/DependsOnProductionExecutorValidator.java b/java/dagger/internal/codegen/DependsOnProductionExecutorValidator.java
deleted file mode 100644
index e611d22..0000000
--- a/java/dagger/internal/codegen/DependsOnProductionExecutorValidator.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.DaggerStreams.instancesOf;
-import static javax.tools.Diagnostic.Kind.ERROR;
-
-import dagger.model.BindingGraph;
-import dagger.model.BindingGraph.MaybeBinding;
-import dagger.model.Key;
-import dagger.spi.BindingGraphPlugin;
-import dagger.spi.DiagnosticReporter;
-import javax.inject.Inject;
-
-/**
- * Reports an error on all bindings that depend explicitly on the {@code @Production Executor} key.
- */
-// TODO(dpb,beder): Validate this during @Inject/@Provides/@Produces validation.
-final class DependsOnProductionExecutorValidator implements BindingGraphPlugin {
- private final CompilerOptions compilerOptions;
- private final KeyFactory keyFactory;
-
- @Inject
- DependsOnProductionExecutorValidator(CompilerOptions compilerOptions, KeyFactory keyFactory) {
- this.compilerOptions = compilerOptions;
- this.keyFactory = keyFactory;
- }
-
- @Override
- public String pluginName() {
- return "Dagger/DependsOnProductionExecutor";
- }
-
- @Override
- public void visitGraph(BindingGraph bindingGraph, DiagnosticReporter diagnosticReporter) {
- if (!compilerOptions.usesProducers()) {
- return;
- }
-
- Key productionImplementationExecutorKey = keyFactory.forProductionImplementationExecutor();
- Key productionExecutorKey = keyFactory.forProductionExecutor();
-
- bindingGraph.network().nodes().stream()
- .flatMap(instancesOf(MaybeBinding.class))
- .filter(node -> node.key().equals(productionExecutorKey))
- .flatMap(productionExecutor -> bindingGraph.requestingBindings(productionExecutor).stream())
- .filter(binding -> !binding.key().equals(productionImplementationExecutorKey))
- .forEach(binding -> reportError(diagnosticReporter, binding));
- }
-
- private void reportError(DiagnosticReporter diagnosticReporter, dagger.model.Binding binding) {
- diagnosticReporter.reportBinding(
- ERROR, binding, "%s may not depend on the production executor", binding.key());
- }
-}
diff --git a/java/dagger/internal/codegen/DerivedFromFrameworkInstanceBindingExpression.java b/java/dagger/internal/codegen/DerivedFromFrameworkInstanceBindingExpression.java
deleted file mode 100644
index 4f2f622..0000000
--- a/java/dagger/internal/codegen/DerivedFromFrameworkInstanceBindingExpression.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.base.Preconditions.checkState;
-import static dagger.internal.codegen.BindingRequest.bindingRequest;
-
-import com.squareup.javapoet.ClassName;
-import dagger.internal.codegen.ComponentDescriptor.ComponentMethodDescriptor;
-import dagger.internal.codegen.javapoet.Expression;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.Key;
-import dagger.model.RequestKind;
-import javax.lang.model.type.TypeMirror;
-
-/** A binding expression that depends on a framework instance. */
-final class DerivedFromFrameworkInstanceBindingExpression extends BindingExpression {
-
- private final BindingRequest frameworkRequest;
- private final RequestKind requestKind;
- private final FrameworkType frameworkType;
- private final ComponentBindingExpressions componentBindingExpressions;
- private final DaggerTypes types;
-
- DerivedFromFrameworkInstanceBindingExpression(
- Key key,
- FrameworkType frameworkType,
- RequestKind requestKind,
- ComponentBindingExpressions componentBindingExpressions,
- DaggerTypes types) {
- this.frameworkRequest = bindingRequest(key, frameworkType);
- this.requestKind = checkNotNull(requestKind);
- this.frameworkType = checkNotNull(frameworkType);
- this.componentBindingExpressions = checkNotNull(componentBindingExpressions);
- this.types = checkNotNull(types);
- }
-
- @Override
- Expression getDependencyExpression(ClassName requestingClass) {
- return frameworkType.to(
- requestKind,
- componentBindingExpressions.getDependencyExpression(frameworkRequest, requestingClass),
- types);
- }
-
- @Override
- Expression getDependencyExpressionForComponentMethod(
- ComponentMethodDescriptor componentMethod, ComponentImplementation component) {
- Expression frameworkInstance =
- componentBindingExpressions.getDependencyExpressionForComponentMethod(
- frameworkRequest, componentMethod, component);
- Expression forRequestKind = frameworkType.to(requestKind, frameworkInstance, types);
- TypeMirror rawReturnType = types.erasure(componentMethod.resolvedReturnType(types));
- if (!types.isAssignable(forRequestKind.type(), rawReturnType)) {
- checkState(
- component.isAbstract(),
- "FrameworkType.to() should always return an accessible type unless we're in "
- + "ahead-of-time mode, where the framework instance type is erased since it's not "
- + "publicly accessible, but the return type is accessible to the package. "
- + "\n Component: %s, method: %s",
- component.name(),
- componentMethod);
- return forRequestKind.castTo(rawReturnType);
- }
- return forRequestKind;
- }
-}
diff --git a/java/dagger/internal/codegen/DeserializedComponentImplementationBuilder.java b/java/dagger/internal/codegen/DeserializedComponentImplementationBuilder.java
deleted file mode 100644
index 45e99a8..0000000
--- a/java/dagger/internal/codegen/DeserializedComponentImplementationBuilder.java
+++ /dev/null
@@ -1,256 +0,0 @@
-/*
- * Copyright (C) 2019 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.AnnotationMirrors.getAnnotationValue;
-import static com.google.auto.common.MoreElements.getAnnotationMirror;
-import static com.google.auto.common.MoreElements.isAnnotationPresent;
-import static com.squareup.javapoet.MethodSpec.methodBuilder;
-import static dagger.internal.codegen.BindingRequest.bindingRequest;
-import static dagger.internal.codegen.DaggerStreams.toImmutableList;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.internal.codegen.MoreAnnotationValues.asAnnotationValues;
-import static dagger.internal.codegen.serialization.ProtoSerialization.fromAnnotationValue;
-import static javax.lang.model.element.Modifier.FINAL;
-import static javax.lang.model.util.ElementFilter.methodsIn;
-import static javax.lang.model.util.ElementFilter.typesIn;
-
-import com.google.auto.common.MoreTypes;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.MethodSpec;
-import com.squareup.javapoet.TypeName;
-import dagger.internal.ComponentDefinitionType;
-import dagger.internal.ConfigureInitializationParameters;
-import dagger.internal.ModifiableBinding;
-import dagger.internal.ModifiableModule;
-import dagger.internal.codegen.ComponentImplementation.ConfigureInitializationMethod;
-import dagger.internal.codegen.serialization.BindingRequestProto;
-import dagger.internal.codegen.serialization.ComponentRequirementProto;
-import dagger.internal.codegen.serialization.FrameworkTypeWrapper;
-import dagger.internal.codegen.serialization.KeyProto;
-import dagger.model.Key;
-import dagger.model.RequestKind;
-import java.util.Optional;
-import javax.inject.Inject;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.AnnotationValue;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.TypeMirror;
-
-/**
- * Reconstructs {@link ComponentImplementation}s that have already been compiled. Uses metadata
- * annotations on the generated type and it's methods to reconstitute the equivalent {@link
- * ComponentImplementation} state.
- */
-final class DeserializedComponentImplementationBuilder {
- private final CompilerOptions compilerOptions;
- private final ComponentCreatorImplementationFactory componentCreatorImplementationFactory;
- private final TypeProtoConverter typeProtoConverter;
- private final KeyFactory keyFactory;
-
- @Inject
- DeserializedComponentImplementationBuilder(
- CompilerOptions compilerOptions,
- ComponentCreatorImplementationFactory componentCreatorImplementationFactory,
- TypeProtoConverter typeProtoConverter,
- KeyFactory keyFactory) {
- this.compilerOptions = compilerOptions;
- this.componentCreatorImplementationFactory = componentCreatorImplementationFactory;
- this.typeProtoConverter = typeProtoConverter;
- this.keyFactory = keyFactory;
- }
-
- /** Creates a new {@link ComponentImplementation} from a compiled component. */
- ComponentImplementation create(ComponentDescriptor component, TypeElement generatedComponent) {
- Optional<ComponentImplementation> superclassImplementation =
- deserializedSuperclassImplementation(
- component, MoreTypes.asTypeElement(generatedComponent.getSuperclass()));
-
- ComponentImplementation componentImplementation =
- ComponentImplementation.forDeserializedComponent(
- component,
- ClassName.get(generatedComponent),
- generatedComponent.getNestingKind(),
- superclassImplementation,
- compilerOptions);
-
- componentImplementation.setCreatorImplementation(
- superclassImplementation.isPresent()
- ? Optional.empty()
- : componentCreatorImplementationFactory.create(
- componentImplementation, Optional.empty()));
-
- // TODO(b/117833324): Consider omitting superclass implementations, so that only one instance of
- // ComponentImplementation needs to be created (in most cases, we don't care about nested levels
- // of superclass implementations, except for the base implementation). If that's possible, use
- // getLocalAndInheritedMethods instead of getEnclosedElements() here.
- for (ExecutableElement method : methodsIn(generatedComponent.getEnclosedElements())) {
- getAnnotationMirror(method, ModifiableBinding.class)
- .asSet()
- .forEach(
- annotation ->
- addModifiableBindingMethod(componentImplementation, method, annotation));
-
- getAnnotationMirror(method, ModifiableModule.class)
- .asSet()
- .forEach(
- annotation -> addModifiableModuleMethod(componentImplementation, method, annotation));
-
- getAnnotationMirror(method, ConfigureInitializationParameters.class)
- .asSet()
- .forEach(
- annotation ->
- setConfigureInitializationMethod(componentImplementation, method, annotation));
- }
-
- for (TypeElement nestedType : typesIn(generatedComponent.getEnclosedElements())) {
- addChildImplementation(component, componentImplementation, nestedType);
- }
-
- return componentImplementation;
- }
-
- private Optional<ComponentImplementation> deserializedSuperclassImplementation(
- ComponentDescriptor component, TypeElement superclassElement) {
- return isAnnotationPresent(superclassElement, ComponentDefinitionType.class)
- ? Optional.of(create(component, superclassElement))
- : Optional.empty();
- }
-
- private void addModifiableBindingMethod(
- ComponentImplementation componentImplementation,
- ExecutableElement method,
- AnnotationMirror metadataAnnotation) {
- ModifiableBindingType modifiableBindingType =
- ModifiableBindingType.valueOf(
- getAnnotationValue(metadataAnnotation, "modifiableBindingType").getValue().toString());
-
- BindingRequest request =
- parseBindingRequest(getAnnotationValue(metadataAnnotation, "bindingRequest"));
-
- ImmutableList<Key> multibindingContributions =
- asAnnotationValues(getAnnotationValue(metadataAnnotation, "multibindingContributions"))
- .stream()
- .map(this::parseKey)
- .collect(toImmutableList());
-
- componentImplementation.addModifiableBindingMethod(
- modifiableBindingType,
- request,
- method.getReturnType(),
- methodDeclaration(method),
- method.getModifiers().contains(FINAL));
- componentImplementation.registerImplementedMultibindingKeys(request, multibindingContributions);
- }
-
- private BindingRequest fromProto(BindingRequestProto bindingRequest) {
- Key key = keyFactory.fromProto(bindingRequest.getKey());
- return bindingRequest.getFrameworkType().equals(FrameworkTypeWrapper.FrameworkType.UNKNOWN)
- ? bindingRequest(key, RequestKind.valueOf(bindingRequest.getRequestKind().name()))
- : bindingRequest(key, FrameworkType.valueOf(bindingRequest.getFrameworkType().name()));
- }
-
- /**
- * Returns a {@link MethodSpec} for a {@link
- * dagger.internal.codegen.ModifiableBindingMethods.ModifiableBindingMethod}. The method contents
- * are not relevant since this represents a method that has already been compiled.
- *
- * <p>Ideally this could be {@code MethodSpec.overriding(method).build()}, but that doesn't work
- * for {@code final} methods
- */
- private MethodSpec methodDeclaration(ExecutableElement method) {
- return methodBuilder(method.getSimpleName().toString())
- .addModifiers(method.getModifiers())
- .returns(TypeName.get(method.getReturnType()))
- .build();
- }
-
- private void addModifiableModuleMethod(
- ComponentImplementation componentImplementation,
- ExecutableElement method,
- AnnotationMirror metadataAnnotation) {
- ComponentRequirement moduleRequirement =
- parseComponentRequirement(getAnnotationValue(metadataAnnotation, "value"));
- componentImplementation.registerModifiableModuleMethod(
- moduleRequirement, method.getSimpleName().toString());
- }
-
- private void setConfigureInitializationMethod(
- ComponentImplementation componentImplementation,
- ExecutableElement method,
- AnnotationMirror metadataAnnotation) {
- ImmutableSet<ComponentRequirement> parameters =
- asAnnotationValues(getAnnotationValue(metadataAnnotation, "value")).stream()
- .map(this::parseComponentRequirement)
- .collect(toImmutableSet());
-
- componentImplementation.setConfigureInitializationMethod(
- ConfigureInitializationMethod.create(MethodSpec.overriding(method).build(), parameters));
- }
-
- private void addChildImplementation(
- ComponentDescriptor component,
- ComponentImplementation componentImplementation,
- TypeElement nestedType) {
- getAnnotationMirror(nestedType, ComponentDefinitionType.class)
- .transform(annotation -> (TypeMirror) getAnnotationValue(annotation, "value").getValue())
- .transform(MoreTypes::asTypeElement)
- .asSet()
- .forEach(
- componentDefinitionType -> {
- ComponentDescriptor child =
- component.childComponentsByElement().get(componentDefinitionType);
- componentImplementation.addChild(child, create(child, nestedType));
- });
- }
-
- private Key parseKey(AnnotationValue annotationValue) {
- return keyFactory.fromProto(
- fromAnnotationValue(annotationValue, KeyProto.getDefaultInstance()));
- }
-
- private BindingRequest parseBindingRequest(AnnotationValue annotationValue) {
- return fromProto(
- fromAnnotationValue(annotationValue, BindingRequestProto.getDefaultInstance()));
- }
-
- private ComponentRequirement parseComponentRequirement(AnnotationValue annotationValue) {
- return fromProto(
- fromAnnotationValue(annotationValue, ComponentRequirementProto.getDefaultInstance()));
- }
-
- private ComponentRequirement fromProto(ComponentRequirementProto proto) {
- switch (proto.getRequirementCase()) {
- case MODULE:
- return ComponentRequirement.forModule(typeProtoConverter.fromProto(proto.getModule()));
- case DEPENDENCY:
- return ComponentRequirement.forDependency(
- typeProtoConverter.fromProto(proto.getDependency()));
- case BOUND_INSTANCE:
- return ComponentRequirement.forBoundInstance(
- keyFactory.fromProto(proto.getBoundInstance().getKey()),
- proto.getBoundInstance().getNullable(),
- proto.getBoundInstance().getVariableName());
- case REQUIREMENT_NOT_SET:
- // fall through
- }
- throw new AssertionError(proto);
- }
-}
diff --git a/java/dagger/internal/codegen/DiagnosticFormatting.java b/java/dagger/internal/codegen/DiagnosticFormatting.java
deleted file mode 100644
index 8502ecb..0000000
--- a/java/dagger/internal/codegen/DiagnosticFormatting.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-/**
- * Utility methods for formatting diagnostics to the {@link javax.annotation.processing.Messager}.
- */
-final class DiagnosticFormatting {
-
- /**
- * A regular expression to match a small list of specific packages deemed to be unhelpful to
- * display in fully qualified types in error messages.
- *
- * <p>Note: This should never be applied to messages themselves.
- */
- private static final Pattern COMMON_PACKAGE_PATTERN =
- Pattern.compile(
- "(?:^|[^.a-z_])" // What we want to match on but not capture.
- + "((?:" // Start a group with a non-capturing or part
- + "java[.]lang"
- + "|java[.]util"
- + "|javax[.]inject"
- + "|dagger"
- + "|com[.]google[.]common[.]base"
- + "|com[.]google[.]common[.]collect"
- + ")[.])" // Always end with a literal .
- + "[A-Z]"); // What we want to match on but not capture.
-
- /**
- * A method to strip out common packages and a few rare type prefixes from types' string
- * representation before being used in error messages.
- *
- * <p>This type assumes a String value that is a valid fully qualified (and possibly
- * parameterized) type, and should NOT be used with arbitrary text, especially prose error
- * messages.
- *
- * <p>TODO(cgruber): Tighten these to take type representations (mirrors and elements) to avoid
- * accidental mis-use by running errors through this method.
- */
- static String stripCommonTypePrefixes(String type) {
- // Do regex magic to remove common packages we care to shorten.
- Matcher matcher = COMMON_PACKAGE_PATTERN.matcher(type);
- StringBuilder result = new StringBuilder();
- int index = 0;
- while (matcher.find()) {
- result.append(type.subSequence(index, matcher.start(1)));
- index = matcher.end(1); // Skip the matched pattern content.
- }
- result.append(type.subSequence(index, type.length()));
- return result.toString();
- }
-
- private DiagnosticFormatting() {}
-}
diff --git a/java/dagger/internal/codegen/DiagnosticReporterFactory.java b/java/dagger/internal/codegen/DiagnosticReporterFactory.java
deleted file mode 100644
index f657cee..0000000
--- a/java/dagger/internal/codegen/DiagnosticReporterFactory.java
+++ /dev/null
@@ -1,519 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreTypes.asTypeElement;
-import static com.google.common.base.Predicates.equalTo;
-import static com.google.common.base.Verify.verify;
-import static com.google.common.collect.Iterables.filter;
-import static com.google.common.collect.Iterables.getLast;
-import static com.google.common.collect.Iterables.indexOf;
-import static com.google.common.collect.Iterables.transform;
-import static com.google.common.collect.Lists.asList;
-import static dagger.internal.codegen.DaggerGraphs.shortestPath;
-import static dagger.internal.codegen.DaggerStreams.instancesOf;
-import static dagger.internal.codegen.DaggerStreams.presentValues;
-import static dagger.internal.codegen.DaggerStreams.toImmutableList;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.internal.codegen.ElementFormatter.elementToString;
-import static dagger.internal.codegen.ValidationType.NONE;
-import static dagger.internal.codegen.langmodel.DaggerElements.DECLARATION_ORDER;
-import static dagger.internal.codegen.langmodel.DaggerElements.closestEnclosingTypeElement;
-import static dagger.internal.codegen.langmodel.DaggerElements.elementEncloses;
-import static java.util.Collections.min;
-import static java.util.Comparator.comparing;
-import static java.util.Comparator.comparingInt;
-import static javax.tools.Diagnostic.Kind.ERROR;
-
-import com.google.auto.common.MoreElements;
-import com.google.common.cache.CacheBuilder;
-import com.google.common.cache.CacheLoader;
-import com.google.common.cache.LoadingCache;
-import com.google.common.collect.HashBasedTable;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.Table;
-import com.google.errorprone.annotations.FormatMethod;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.BindingGraph;
-import dagger.model.BindingGraph.ChildFactoryMethodEdge;
-import dagger.model.BindingGraph.ComponentNode;
-import dagger.model.BindingGraph.DependencyEdge;
-import dagger.model.BindingGraph.Edge;
-import dagger.model.BindingGraph.MaybeBinding;
-import dagger.model.BindingGraph.Node;
-import dagger.model.ComponentPath;
-import dagger.spi.BindingGraphPlugin;
-import dagger.spi.DiagnosticReporter;
-import java.util.Comparator;
-import java.util.Set;
-import java.util.function.Function;
-import javax.annotation.processing.Messager;
-import javax.inject.Inject;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.TypeElement;
-import javax.tools.Diagnostic;
-import org.checkerframework.checker.nullness.compatqual.NullableDecl;
-
-/** A factory for {@link DiagnosticReporter}s. */
-// TODO(ronshapiro): If multiple plugins print errors on the same node/edge, should we condense the
-// messages and only print the dependency trace once?
-final class DiagnosticReporterFactory {
- private final DaggerTypes types;
- private final Messager messager;
- private final DependencyRequestFormatter dependencyRequestFormatter;
- private final ElementFormatter elementFormatter;
- private final CompilerOptions compilerOptions;
-
- @Inject
- DiagnosticReporterFactory(
- DaggerTypes types,
- Messager messager,
- DependencyRequestFormatter dependencyRequestFormatter,
- ElementFormatter elementFormatter,
- CompilerOptions compilerOptions) {
- this.types = types;
- this.messager = messager;
- this.dependencyRequestFormatter = dependencyRequestFormatter;
- this.elementFormatter = elementFormatter;
- this.compilerOptions = compilerOptions;
- }
-
- /** Creates a reporter for a binding graph and a plugin. */
- DiagnosticReporterImpl reporter(BindingGraph graph, BindingGraphPlugin plugin) {
- return new DiagnosticReporterImpl(graph, plugin.pluginName());
- }
-
- private static <K, V> Function<K, V> memoize(Function<K, V> uncached) {
- // If Android Guava is on the processor path, then c.g.c.b.Function (which LoadingCache
- // implements) does not extend j.u.f.Function.
-
- // First, explicitly convert uncached to c.g.c.b.Function because CacheLoader.from() expects
- // one.
- com.google.common.base.Function<K, V> uncachedAsBaseFunction = uncached::apply;
-
- LoadingCache<K, V> cache =
- CacheBuilder.newBuilder().build(CacheLoader.from(uncachedAsBaseFunction));
-
- // Second, explicitly convert LoadingCache to j.u.f.Function.
- @SuppressWarnings("deprecation") // uncachedAsBaseFunction throws only unchecked exceptions
- Function<K, V> memoized = cache::apply;
-
- return memoized;
- }
-
- /**
- * A {@link DiagnosticReporter} that keeps track of which {@linkplain Diagnostic.Kind kinds} of
- * diagnostics were reported.
- */
- final class DiagnosticReporterImpl implements DiagnosticReporter {
-
- /** A cached function from type to all of its supertypes in breadth-first order. */
- private final Function<TypeElement, Iterable<TypeElement>> supertypes =
- memoize(
- component ->
- transform(types.supertypes(component.asType()), type -> asTypeElement(type)));
-
- /** The shortest path (value) from an entry point (column) to a binding (row). */
- private final Table<MaybeBinding, DependencyEdge, ImmutableList<Node>> shortestPaths =
- HashBasedTable.create();
-
- private final BindingGraph graph;
- private final String plugin;
- private final TypeElement rootComponent;
- private final ImmutableSet.Builder<Diagnostic.Kind> reportedDiagnosticKinds =
- ImmutableSet.builder();
-
- DiagnosticReporterImpl(BindingGraph graph, String plugin) {
- this.graph = graph;
- this.plugin = plugin;
- this.rootComponent = graph.rootComponentNode().componentPath().currentComponent();
- }
-
- /** Returns which {@linkplain Diagnostic.Kind kinds} of diagnostics were reported. */
- ImmutableSet<Diagnostic.Kind> reportedDiagnosticKinds() {
- return reportedDiagnosticKinds.build();
- }
-
- @Override
- public void reportComponent(
- Diagnostic.Kind diagnosticKind, ComponentNode componentNode, String messageFormat) {
- StringBuilder message = new StringBuilder(messageFormat);
- appendComponentPathUnlessAtRoot(message, componentNode);
- // TODO(dpb): Report at the component node component.
- printMessage(diagnosticKind, message, rootComponent);
- }
-
- @Override
- @FormatMethod
- public void reportComponent(
- Diagnostic.Kind diagnosticKind,
- ComponentNode componentNode,
- String messageFormat,
- Object firstArg,
- Object... moreArgs) {
- reportComponent(
- diagnosticKind, componentNode, formatMessage(messageFormat, firstArg, moreArgs));
- }
-
- // TODO(ronshapiro): should this also include the binding element?
- @Override
- public void reportBinding(
- Diagnostic.Kind diagnosticKind, MaybeBinding binding, String message) {
- printMessage(diagnosticKind, message + new DiagnosticInfo(binding), rootComponent);
- }
-
- @Override
- public void reportBinding(
- Diagnostic.Kind diagnosticKind,
- MaybeBinding binding,
- String messageFormat,
- Object firstArg,
- Object... moreArgs) {
- reportBinding(diagnosticKind, binding, formatMessage(messageFormat, firstArg, moreArgs));
- }
-
- @Override
- public void reportDependency(
- Diagnostic.Kind diagnosticKind, DependencyEdge dependencyEdge, String message) {
- printMessage(diagnosticKind, message + new DiagnosticInfo(dependencyEdge), rootComponent);
- }
-
- @Override
- public void reportDependency(
- Diagnostic.Kind diagnosticKind,
- DependencyEdge dependencyEdge,
- String messageFormat,
- Object firstArg,
- Object... moreArgs) {
- reportDependency(
- diagnosticKind, dependencyEdge, formatMessage(messageFormat, firstArg, moreArgs));
- }
-
- @Override
- public void reportSubcomponentFactoryMethod(
- Diagnostic.Kind diagnosticKind,
- ChildFactoryMethodEdge childFactoryMethodEdge,
- String message) {
- printMessage(diagnosticKind, message, childFactoryMethodEdge.factoryMethod());
- }
-
- @Override
- public void reportSubcomponentFactoryMethod(
- Diagnostic.Kind diagnosticKind,
- ChildFactoryMethodEdge childFactoryMethodEdge,
- String messageFormat,
- Object firstArg,
- Object... moreArgs) {
- reportSubcomponentFactoryMethod(
- diagnosticKind, childFactoryMethodEdge, formatMessage(messageFormat, firstArg, moreArgs));
- }
-
- private String formatMessage(String messageFormat, Object firstArg, Object[] moreArgs) {
- return String.format(messageFormat, asList(firstArg, moreArgs).toArray());
- }
-
- private Node source(Edge edge) {
- return graph.network().incidentNodes(edge).source();
- }
-
- void printMessage(
- Diagnostic.Kind diagnosticKind,
- CharSequence message,
- @NullableDecl Element elementToReport) {
- if (graph.isFullBindingGraph()) {
- ValidationType validationType =
- compilerOptions.fullBindingGraphValidationType(rootComponent);
- if (validationType.equals(NONE)) {
- return;
- }
- if (diagnosticKind.equals(ERROR)) {
- diagnosticKind = validationType.diagnosticKind().get();
- }
- }
- reportedDiagnosticKinds.add(diagnosticKind);
- StringBuilder fullMessage = new StringBuilder();
- appendBracketPrefix(fullMessage, plugin);
-
- // TODO(ronshapiro): should we create a HashSet out of elementEncloses() so we don't
- // need to do an O(n) contains() each time?
- if (elementToReport != null && !elementEncloses(rootComponent, elementToReport)) {
- appendBracketPrefix(fullMessage, elementToString(elementToReport));
- elementToReport = rootComponent;
- }
-
- messager.printMessage(diagnosticKind, fullMessage.append(message), elementToReport);
- }
-
- private void appendComponentPathUnlessAtRoot(StringBuilder message, Node node) {
- if (!node.componentPath().equals(graph.rootComponentNode().componentPath())) {
- message.append(String.format(" [%s]", node.componentPath()));
- }
- }
-
- private void appendBracketPrefix(StringBuilder message, String prefix) {
- message.append(String.format("[%s] ", prefix));
- }
-
- /** The diagnostic information associated with an error. */
- private final class DiagnosticInfo {
- final ImmutableList<DependencyEdge> dependencyTrace;
- final ImmutableSet<DependencyEdge> requests;
- final ImmutableSet<DependencyEdge> entryPoints;
-
- DiagnosticInfo(MaybeBinding binding) {
- entryPoints = graph.entryPointEdgesDependingOnBinding(binding);
- requests = requests(binding);
- dependencyTrace = dependencyTrace(binding, entryPoints);
- }
-
- DiagnosticInfo(DependencyEdge dependencyEdge) {
- requests = ImmutableSet.of(dependencyEdge);
- ImmutableList.Builder<DependencyEdge> dependencyTraceBuilder = ImmutableList.builder();
- dependencyTraceBuilder.add(dependencyEdge);
-
- if (dependencyEdge.isEntryPoint()) {
- entryPoints = ImmutableSet.of(dependencyEdge);
- } else {
- // It's not an entry point, so it's part of a binding
- dagger.model.Binding binding = (dagger.model.Binding) source(dependencyEdge);
- entryPoints = graph.entryPointEdgesDependingOnBinding(binding);
- dependencyTraceBuilder.addAll(dependencyTrace(binding, entryPoints));
- }
- dependencyTrace = dependencyTraceBuilder.build();
- }
-
- @Override
- public String toString() {
- StringBuilder message =
- graph.isFullBindingGraph()
- ? new StringBuilder()
- : new StringBuilder(dependencyTrace.size() * 100 /* a guess heuristic */);
-
- // Print the dependency trace unless it's a full binding graph
- if (!graph.isFullBindingGraph()) {
- dependencyTrace.forEach(
- edge ->
- dependencyRequestFormatter.appendFormatLine(message, edge.dependencyRequest()));
- if (!dependencyTrace.isEmpty()) {
- appendComponentPathUnlessAtRoot(message, source(getLast(dependencyTrace)));
- }
- }
-
- // Print any dependency requests that aren't shown as part of the dependency trace.
- ImmutableSet<Element> requestsToPrint =
- requests.stream()
- // if printing entry points, skip entry points and the traced request
- .filter(
- request ->
- graph.isFullBindingGraph()
- || (!request.isEntryPoint() && !isTracedRequest(request)))
- .map(request -> request.dependencyRequest().requestElement())
- .flatMap(presentValues())
- .collect(toImmutableSet());
- if (!requestsToPrint.isEmpty()) {
- message
- .append("\nIt is")
- .append(graph.isFullBindingGraph() ? " " : " also ")
- .append("requested at:");
- elementFormatter.formatIndentedList(message, requestsToPrint, 1);
- }
-
- // Print the remaining entry points, showing which component they're in, unless it's a full
- // binding graph
- if (!graph.isFullBindingGraph() && entryPoints.size() > 1) {
- message.append("\nThe following other entry points also depend on it:");
- entryPointFormatter.formatIndentedList(
- message,
- entryPoints.stream()
- .filter(entryPoint -> !entryPoint.equals(getLast(dependencyTrace)))
- .sorted(
- // 1. List entry points in components closest to the root first.
- // 2. List entry points declared in a component before those in a supertype.
- // 3. List entry points in declaration order in their declaring type.
- rootComponentFirst()
- .thenComparing(nearestComponentSupertypeFirst())
- .thenComparing(requestElementDeclarationOrder()))
- .collect(toImmutableList()),
- 1);
- }
- return message.toString();
- }
-
- private final Formatter<DependencyEdge> entryPointFormatter =
- new Formatter<DependencyEdge>() {
- @Override
- public String format(DependencyEdge object) {
- Element requestElement = object.dependencyRequest().requestElement().get();
- StringBuilder element = new StringBuilder(elementToString(requestElement));
-
- // For entry points declared in subcomponents or supertypes of the root component,
- // append the component path to make clear to the user which component it's in.
- ComponentPath componentPath = source(object).componentPath();
- if (!componentPath.atRoot()
- || !requestElement.getEnclosingElement().equals(rootComponent)) {
- element.append(String.format(" [%s]", componentPath));
- }
- return element.toString();
- }
- };
-
- private boolean isTracedRequest(DependencyEdge request) {
- return !dependencyTrace.isEmpty() && request.equals(dependencyTrace.get(0));
- }
-
- /**
- * Returns the dependency trace from one of the {@code entryPoints} to {@code binding} to
- * {@code message} as a list <i>ending with</i> the entry point.
- */
- // TODO(ronshapiro): Adding a DependencyPath type to dagger.model could be useful, i.e.
- // bindingGraph.shortestPathFromEntryPoint(DependencyEdge, MaybeBindingNode)
- ImmutableList<DependencyEdge> dependencyTrace(
- MaybeBinding binding, ImmutableSet<DependencyEdge> entryPoints) {
- // Module binding graphs may have bindings unreachable from any entry points. If there are
- // no entry points for this DiagnosticInfo, don't try to print a dependency trace.
- if (entryPoints.isEmpty()) {
- return ImmutableList.of();
- }
- // Show the full dependency trace for one entry point.
- DependencyEdge entryPointForTrace =
- min(
- entryPoints,
- // prefer entry points in components closest to the root
- rootComponentFirst()
- // then prefer entry points with a short dependency path to the error
- .thenComparing(shortestDependencyPathFirst(binding))
- // then prefer entry points declared in the component to those declared in a
- // supertype
- .thenComparing(nearestComponentSupertypeFirst())
- // finally prefer entry points declared first in their enclosing type
- .thenComparing(requestElementDeclarationOrder()));
-
- ImmutableList<Node> shortestBindingPath =
- shortestPathFromEntryPoint(entryPointForTrace, binding);
- verify(
- !shortestBindingPath.isEmpty(),
- "no dependency path from %s to %s in %s",
- entryPointForTrace,
- binding,
- graph);
-
- ImmutableList.Builder<DependencyEdge> dependencyTrace = ImmutableList.builder();
- dependencyTrace.add(entryPointForTrace);
- for (int i = 0; i < shortestBindingPath.size() - 1; i++) {
- Set<Edge> dependenciesBetween =
- graph
- .network()
- .edgesConnecting(shortestBindingPath.get(i), shortestBindingPath.get(i + 1));
- // If a binding requests a key more than once, any of them should be fine to get to the
- // shortest path
- dependencyTrace.add((DependencyEdge) Iterables.get(dependenciesBetween, 0));
- }
- return dependencyTrace.build().reverse();
- }
-
- /** Returns all the nonsynthetic dependency requests for a binding. */
- ImmutableSet<DependencyEdge> requests(MaybeBinding binding) {
- return graph.network().inEdges(binding).stream()
- .flatMap(instancesOf(DependencyEdge.class))
- .filter(edge -> edge.dependencyRequest().requestElement().isPresent())
- .sorted(requestEnclosingTypeName().thenComparing(requestElementDeclarationOrder()))
- .collect(toImmutableSet());
- }
-
- /**
- * Returns a comparator that sorts entry points in components whose paths from the root are
- * shorter first.
- */
- Comparator<DependencyEdge> rootComponentFirst() {
- return comparingInt(entryPoint -> source(entryPoint).componentPath().components().size());
- }
-
- /**
- * Returns a comparator that puts entry points whose shortest dependency path to {@code
- * binding} is shortest first.
- */
- Comparator<DependencyEdge> shortestDependencyPathFirst(MaybeBinding binding) {
- return comparing(entryPoint -> shortestPathFromEntryPoint(entryPoint, binding).size());
- }
-
- ImmutableList<Node> shortestPathFromEntryPoint(
- DependencyEdge entryPoint, MaybeBinding binding) {
- return shortestPaths
- .row(binding)
- .computeIfAbsent(
- entryPoint,
- ep ->
- shortestPath(
- node ->
- filter(
- graph.network().successors(node), MaybeBinding.class::isInstance),
- graph.network().incidentNodes(ep).target(),
- binding));
- }
-
- /**
- * Returns a comparator that sorts entry points in by the distance of the type that declares
- * them from the type of the component that contains them.
- *
- * <p>For instance, an entry point declared directly in the component type would sort before
- * one declared in a direct supertype, which would sort before one declared in a supertype of
- * a supertype.
- */
- Comparator<DependencyEdge> nearestComponentSupertypeFirst() {
- return comparingInt(
- entryPoint ->
- indexOf(
- supertypes.apply(componentContainingEntryPoint(entryPoint)),
- equalTo(typeDeclaringEntryPoint(entryPoint))));
- }
-
- TypeElement componentContainingEntryPoint(DependencyEdge entryPoint) {
- return source(entryPoint).componentPath().currentComponent();
- }
-
- TypeElement typeDeclaringEntryPoint(DependencyEdge entryPoint) {
- return MoreElements.asType(
- entryPoint.dependencyRequest().requestElement().get().getEnclosingElement());
- }
-
- /**
- * Returns a comparator that sorts dependency edges lexicographically by the qualified name of
- * the type that contains them. Only appropriate for edges with request elements.
- */
- Comparator<DependencyEdge> requestEnclosingTypeName() {
- return comparing(
- edge ->
- closestEnclosingTypeElement(edge.dependencyRequest().requestElement().get())
- .getQualifiedName()
- .toString());
- }
-
- /**
- * Returns a comparator that sorts edges in the order in which their request elements were
- * declared in their declaring type.
- *
- * <p>Only useful to compare edges whose request elements were declared in the same type.
- */
- Comparator<DependencyEdge> requestElementDeclarationOrder() {
- return comparing(
- edge -> edge.dependencyRequest().requestElement().get(), DECLARATION_ORDER);
- }
- }
- }
-}
diff --git a/java/dagger/internal/codegen/DuplicateBindingsValidator.java b/java/dagger/internal/codegen/DuplicateBindingsValidator.java
deleted file mode 100644
index 3eed45f..0000000
--- a/java/dagger/internal/codegen/DuplicateBindingsValidator.java
+++ /dev/null
@@ -1,332 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Verify.verify;
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSetMultimap;
-import static dagger.internal.codegen.Formatter.INDENT;
-import static dagger.internal.codegen.Optionals.emptiesLast;
-import static dagger.model.BindingKind.INJECTION;
-import static dagger.model.BindingKind.MEMBERS_INJECTION;
-import static java.util.Comparator.comparing;
-import static javax.tools.Diagnostic.Kind.ERROR;
-
-import com.google.auto.value.AutoValue;
-import com.google.common.collect.ImmutableCollection;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableListMultimap;
-import com.google.common.collect.ImmutableMultiset;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableSetMultimap;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.Multimap;
-import com.google.common.collect.Multimaps;
-import com.google.common.collect.Sets;
-import dagger.model.Binding;
-import dagger.model.BindingGraph;
-import dagger.model.BindingKind;
-import dagger.model.ComponentPath;
-import dagger.model.Key;
-import dagger.spi.BindingGraphPlugin;
-import dagger.spi.DiagnosticReporter;
-import java.util.Comparator;
-import java.util.HashSet;
-import java.util.Optional;
-import java.util.Set;
-import java.util.function.Predicate;
-import javax.inject.Inject;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.TypeElement;
-import javax.tools.Diagnostic.Kind;
-
-/** Reports errors for conflicting bindings with the same key. */
-final class DuplicateBindingsValidator implements BindingGraphPlugin {
-
- // 1. contributing module or enclosing type
- // 2. binding element's simple name
- // 3. binding element's type
- private static final Comparator<BindingDeclaration> BINDING_DECLARATION_COMPARATOR =
- comparing(
- (BindingDeclaration declaration) ->
- declaration.contributingModule().isPresent()
- ? declaration.contributingModule()
- : declaration.bindingTypeElement(),
- emptiesLast(comparing((TypeElement type) -> type.getQualifiedName().toString())))
- .thenComparing(
- (BindingDeclaration declaration) -> declaration.bindingElement(),
- emptiesLast(
- comparing((Element element) -> element.getSimpleName().toString())
- .thenComparing((Element element) -> element.asType().toString())));
-
- private static final Comparator<Binding> BY_LENGTH_OF_COMPONENT_PATH =
- comparing(binding -> binding.componentPath().components().size());
-
- private final BindingDeclarationFormatter bindingDeclarationFormatter;
- private final CompilerOptions compilerOptions;
-
- @Inject
- DuplicateBindingsValidator(
- BindingDeclarationFormatter bindingDeclarationFormatter, CompilerOptions compilerOptions) {
- this.bindingDeclarationFormatter = bindingDeclarationFormatter;
- this.compilerOptions = compilerOptions;
- }
-
- @Override
- public String pluginName() {
- return "Dagger/DuplicateBindings";
- }
-
- @Override
- public void visitGraph(BindingGraph bindingGraph, DiagnosticReporter diagnosticReporter) {
- // If two unrelated subcomponents have the same duplicate bindings only because they install the
- // same two modules, then fixing the error in one subcomponent will uncover the second
- // subcomponent to fix.
- // TODO(ronshapiro): Explore ways to address such underreporting without overreporting.
- Set<ImmutableSet<BindingElement>> reportedDuplicateBindingSets = new HashSet<>();
- duplicateBindingSets(bindingGraph)
- .forEach(
- duplicateBindings -> {
- // Only report each set of duplicate bindings once, ignoring the installed component.
- if (reportedDuplicateBindingSets.add(duplicateBindings.keySet())) {
- reportDuplicateBindings(duplicateBindings, bindingGraph, diagnosticReporter);
- }
- });
- }
-
- /**
- * Returns sets of duplicate bindings. Bindings are duplicates if they bind the same key and are
- * visible from the same component. Two bindings that differ only in the component that owns them
- * are not considered to be duplicates, because that means the same binding was "copied" down to a
- * descendant component because it depends on local multibindings or optional bindings. Hence each
- * "set" is represented as a multimap from binding element (ignoring component path) to binding.
- */
- private ImmutableSet<ImmutableSetMultimap<BindingElement, Binding>> duplicateBindingSets(
- BindingGraph bindingGraph) {
- return groupBindingsByKey(bindingGraph).stream()
- .flatMap(bindings -> mutuallyVisibleSubsets(bindings).stream())
- .map(BindingElement::index)
- .filter(duplicates -> duplicates.keySet().size() > 1)
- .collect(toImmutableSet());
- }
-
- private static ImmutableSet<ImmutableSet<Binding>> groupBindingsByKey(BindingGraph bindingGraph) {
- return valueSetsForEachKey(
- bindingGraph.bindings().stream()
- .filter(binding -> !binding.kind().equals(MEMBERS_INJECTION))
- .collect(toImmutableSetMultimap(Binding::key, binding -> binding)));
- }
-
- /**
- * Returns the subsets of the input set that contain bindings that are all visible from the same
- * component. A binding is visible from its component and all its descendants.
- */
- private static ImmutableSet<ImmutableSet<Binding>> mutuallyVisibleSubsets(
- Set<Binding> duplicateBindings) {
- ImmutableListMultimap<ComponentPath, Binding> bindingsByComponentPath =
- Multimaps.index(duplicateBindings, Binding::componentPath);
- ImmutableSetMultimap.Builder<ComponentPath, Binding> mutuallyVisibleBindings =
- ImmutableSetMultimap.builder();
- bindingsByComponentPath
- .asMap()
- .forEach(
- (componentPath, bindings) -> {
- mutuallyVisibleBindings.putAll(componentPath, bindings);
- for (ComponentPath ancestor = componentPath; !ancestor.atRoot(); ) {
- ancestor = ancestor.parent();
- ImmutableList<Binding> bindingsInAncestor = bindingsByComponentPath.get(ancestor);
- mutuallyVisibleBindings.putAll(componentPath, bindingsInAncestor);
- }
- });
- return valueSetsForEachKey(mutuallyVisibleBindings.build());
- }
-
- private void reportDuplicateBindings(
- ImmutableSetMultimap<BindingElement, Binding> duplicateBindings,
- BindingGraph bindingGraph,
- DiagnosticReporter diagnosticReporter) {
- if (explicitBindingConfictsWithInject(duplicateBindings.keySet())) {
- compilerOptions
- .explicitBindingConflictsWithInjectValidationType()
- .diagnosticKind()
- .ifPresent(
- diagnosticKind ->
- reportExplicitBindingConflictsWithInject(
- duplicateBindings, diagnosticReporter, diagnosticKind));
- return;
- }
- ImmutableSet<Binding> bindings = ImmutableSet.copyOf(duplicateBindings.values());
- Binding oneBinding = bindings.asList().get(0);
- diagnosticReporter.reportBinding(
- ERROR,
- oneBinding,
- Iterables.any(bindings, binding -> binding.kind().isMultibinding())
- ? incompatibleBindingsMessage(oneBinding.key(), bindings, bindingGraph)
- : duplicateBindingMessage(oneBinding.key(), bindings, bindingGraph));
- }
-
- /**
- * Returns {@code true} if the bindings contain one {@code @Inject} binding and one that isn't.
- */
- private static boolean explicitBindingConfictsWithInject(
- ImmutableSet<BindingElement> duplicateBindings) {
- ImmutableMultiset<BindingKind> bindingKinds =
- Multimaps.index(duplicateBindings, BindingElement::bindingKind).keys();
- return bindingKinds.count(INJECTION) == 1 && bindingKinds.size() == 2;
- }
-
- private void reportExplicitBindingConflictsWithInject(
- ImmutableSetMultimap<BindingElement, Binding> duplicateBindings,
- DiagnosticReporter diagnosticReporter,
- Kind diagnosticKind) {
- Binding injectBinding =
- rootmostBindingWithKind(k -> k.equals(INJECTION), duplicateBindings.values());
- Binding explicitBinding =
- rootmostBindingWithKind(k -> !k.equals(INJECTION), duplicateBindings.values());
- StringBuilder message =
- new StringBuilder()
- .append(explicitBinding.key())
- .append(" is bound multiple times:")
- .append(formatWithComponentPath(injectBinding))
- .append(formatWithComponentPath(explicitBinding))
- .append(
- "\nThis condition was never validated before, and will soon be an error. "
- + "See https://dagger.dev/conflicting-inject.");
-
- diagnosticReporter.reportBinding(diagnosticKind, explicitBinding, message.toString());
- }
-
- private String formatWithComponentPath(Binding binding) {
- return String.format(
- "\n%s%s [%s]",
- Formatter.INDENT,
- bindingDeclarationFormatter.format(((BindingNode) binding).delegate()),
- binding.componentPath());
- }
-
- private String duplicateBindingMessage(
- Key key, ImmutableSet<Binding> duplicateBindings, BindingGraph graph) {
- StringBuilder message = new StringBuilder().append(key).append(" is bound multiple times:");
- formatDeclarations(message, 1, declarations(graph, duplicateBindings));
- return message.toString();
- }
-
- private String incompatibleBindingsMessage(
- Key key, ImmutableSet<Binding> duplicateBindings, BindingGraph graph) {
- ImmutableSet<dagger.model.Binding> multibindings =
- duplicateBindings.stream()
- .filter(binding -> binding.kind().isMultibinding())
- .collect(toImmutableSet());
- verify(
- multibindings.size() == 1, "expected only one multibinding for %s: %s", key, multibindings);
- StringBuilder message = new StringBuilder();
- java.util.Formatter messageFormatter = new java.util.Formatter(message);
- messageFormatter.format("%s has incompatible bindings or declarations:\n", key);
- message.append(INDENT);
- dagger.model.Binding multibinding = getOnlyElement(multibindings);
- messageFormatter.format("%s bindings and declarations:", multibindingTypeString(multibinding));
- formatDeclarations(message, 2, declarations(graph, multibindings));
-
- Set<dagger.model.Binding> uniqueBindings =
- Sets.filter(duplicateBindings, binding -> !binding.equals(multibinding));
- message.append('\n').append(INDENT).append("Unique bindings and declarations:");
- formatDeclarations(
- message,
- 2,
- Sets.filter(
- declarations(graph, uniqueBindings),
- declaration -> !(declaration instanceof MultibindingDeclaration)));
- return message.toString();
- }
-
- private void formatDeclarations(
- StringBuilder builder,
- int indentLevel,
- Iterable<? extends BindingDeclaration> bindingDeclarations) {
- bindingDeclarationFormatter.formatIndentedList(
- builder, ImmutableList.copyOf(bindingDeclarations), indentLevel);
- }
-
- private ImmutableSet<BindingDeclaration> declarations(
- BindingGraph graph, Set<dagger.model.Binding> bindings) {
- return bindings.stream()
- .flatMap(binding -> declarations(graph, binding).stream())
- .distinct()
- .sorted(BINDING_DECLARATION_COMPARATOR)
- .collect(toImmutableSet());
- }
-
- private ImmutableSet<BindingDeclaration> declarations(
- BindingGraph graph, dagger.model.Binding binding) {
- ImmutableSet.Builder<BindingDeclaration> declarations = ImmutableSet.builder();
- BindingNode bindingNode = (BindingNode) binding;
- bindingNode.associatedDeclarations().forEach(declarations::add);
- if (bindingDeclarationFormatter.canFormat(bindingNode.delegate())) {
- declarations.add(bindingNode.delegate());
- } else {
- graph.requestedBindings(binding).stream()
- .flatMap(requestedBinding -> declarations(graph, requestedBinding).stream())
- .forEach(declarations::add);
- }
- return declarations.build();
- }
-
- private String multibindingTypeString(dagger.model.Binding multibinding) {
- switch (multibinding.kind()) {
- case MULTIBOUND_MAP:
- return "Map";
- case MULTIBOUND_SET:
- return "Set";
- default:
- throw new AssertionError(multibinding);
- }
- }
-
- private static <E> ImmutableSet<ImmutableSet<E>> valueSetsForEachKey(Multimap<?, E> multimap) {
- return multimap.asMap().values().stream().map(ImmutableSet::copyOf).collect(toImmutableSet());
- }
-
- /** Returns the binding of the given kind that is closest to the root component. */
- private static Binding rootmostBindingWithKind(
- Predicate<BindingKind> bindingKindPredicate, ImmutableCollection<Binding> bindings) {
- return bindings.stream()
- .filter(b -> bindingKindPredicate.test(b.kind()))
- .min(BY_LENGTH_OF_COMPONENT_PATH)
- .get();
- }
-
- /** The identifying information about a binding, excluding its {@link Binding#componentPath()}. */
- @AutoValue
- abstract static class BindingElement {
-
- abstract BindingKind bindingKind();
-
- abstract Optional<Element> bindingElement();
-
- abstract Optional<TypeElement> contributingModule();
-
- static ImmutableSetMultimap<BindingElement, Binding> index(Set<Binding> bindings) {
- return bindings.stream().collect(toImmutableSetMultimap(BindingElement::forBinding, b -> b));
- }
-
- private static BindingElement forBinding(Binding binding) {
- return new AutoValue_DuplicateBindingsValidator_BindingElement(
- binding.kind(), binding.bindingElement(), binding.contributingModule());
- }
- }
-}
diff --git a/java/dagger/internal/codegen/ElementFormatter.java b/java/dagger/internal/codegen/ElementFormatter.java
deleted file mode 100644
index 40d7606..0000000
--- a/java/dagger/internal/codegen/ElementFormatter.java
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * Copyright (C) 2013 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreElements.asExecutable;
-import static java.util.stream.Collectors.joining;
-
-import javax.inject.Inject;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ElementVisitor;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.element.VariableElement;
-import javax.lang.model.util.ElementKindVisitor8;
-
-/**
- * Formats elements into a useful string representation.
- *
- * <p>Elements directly enclosed by a type are preceded by the enclosing type's qualified name.
- *
- * <p>Parameters are given with their enclosing executable, with other parameters elided.
- */
-final class ElementFormatter extends Formatter<Element> {
- @Inject
- ElementFormatter() {}
-
- @Override
- public String format(Element element) {
- return elementToString(element);
- }
-
- /**
- * Returns a useful string form for an element.
- *
- * <p>Elements directly enclosed by a type are preceded by the enclosing type's qualified name.
- *
- * <p>Parameters are given with their enclosing executable, with other parameters elided.
- */
- static String elementToString(Element element) {
- return element.accept(ELEMENT_TO_STRING, null);
- }
-
- private static final ElementVisitor<String, Void> ELEMENT_TO_STRING =
- new ElementKindVisitor8<String, Void>() {
- @Override
- public String visitExecutable(ExecutableElement executableElement, Void aVoid) {
- return enclosingTypeAndMemberName(executableElement)
- .append(
- executableElement.getParameters().stream()
- .map(parameter -> parameter.asType().toString())
- .collect(joining(", ", "(", ")")))
- .toString();
- }
-
- @Override
- public String visitVariableAsParameter(VariableElement parameter, Void aVoid) {
- ExecutableElement methodOrConstructor = asExecutable(parameter.getEnclosingElement());
- return enclosingTypeAndMemberName(methodOrConstructor)
- .append('(')
- .append(
- formatArgumentInList(
- methodOrConstructor.getParameters().indexOf(parameter),
- methodOrConstructor.getParameters().size(),
- parameter.getSimpleName()))
- .append(')')
- .toString();
- }
-
- @Override
- public String visitVariableAsField(VariableElement field, Void aVoid) {
- return enclosingTypeAndMemberName(field).toString();
- }
-
- @Override
- public String visitType(TypeElement type, Void aVoid) {
- return type.getQualifiedName().toString();
- }
-
- @Override
- protected String defaultAction(Element element, Void aVoid) {
- throw new UnsupportedOperationException(
- "Can't determine string for " + element.getKind() + " element " + element);
- }
-
- private StringBuilder enclosingTypeAndMemberName(Element element) {
- StringBuilder name = new StringBuilder(element.getEnclosingElement().accept(this, null));
- if (!element.getSimpleName().contentEquals("<init>")) {
- name.append('.').append(element.getSimpleName());
- }
- return name;
- }
- };
-}
diff --git a/java/dagger/internal/codegen/ErrorMessages.java b/java/dagger/internal/codegen/ErrorMessages.java
deleted file mode 100644
index 4195e1a..0000000
--- a/java/dagger/internal/codegen/ErrorMessages.java
+++ /dev/null
@@ -1,356 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import com.google.common.base.Joiner;
-import com.google.common.collect.ImmutableMap;
-import java.util.Set;
-import java.util.function.Function;
-import java.util.function.UnaryOperator;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.TypeMirror;
-
-/** The collection of error messages to be reported back to users. */
-final class ErrorMessages {
-
- private static final UnaryOperator<String> PRODUCTION =
- s ->
- s.replace("component", "production component")
- .replace("Component", "ProductionComponent");
-
- private static final UnaryOperator<String> SUBCOMPONENT =
- s -> s.replace("component", "subcomponent").replace("Component", "Subcomponent");
-
- private static final UnaryOperator<String> FACTORY = s -> s.replace("Builder", "Factory");
-
- private static final ImmutableMap<ComponentKind, Function<String, String>>
- COMPONENT_TRANSFORMATIONS =
- ImmutableMap.of(
- ComponentKind.COMPONENT, UnaryOperator.identity(),
- ComponentKind.SUBCOMPONENT, SUBCOMPONENT,
- ComponentKind.PRODUCTION_COMPONENT, PRODUCTION,
- ComponentKind.PRODUCTION_SUBCOMPONENT, PRODUCTION.andThen(SUBCOMPONENT));
-
- static ComponentMessages componentMessagesFor(ComponentKind componentKind) {
- return new ComponentMessages(COMPONENT_TRANSFORMATIONS.get(componentKind));
- }
-
- static ComponentMessages componentMessagesFor(ComponentAnnotation componentAnnotation) {
- return new ComponentMessages(
- transformation(componentAnnotation.isProduction(), componentAnnotation.isSubcomponent()));
- }
-
- static ComponentCreatorMessages creatorMessagesFor(ComponentCreatorAnnotation creatorAnnotation) {
- Function<String, String> transformation =
- transformation(
- creatorAnnotation.isProductionCreatorAnnotation(),
- creatorAnnotation.isSubcomponentCreatorAnnotation());
- switch (creatorAnnotation.creatorKind()) {
- case BUILDER:
- return new BuilderMessages(transformation);
- case FACTORY:
- return new FactoryMessages(transformation);
- }
- throw new AssertionError(creatorAnnotation);
- }
-
- private static Function<String, String> transformation(
- boolean isProduction, boolean isSubcomponent) {
- Function<String, String> transformation = isProduction ? PRODUCTION : UnaryOperator.identity();
- return isSubcomponent ? transformation.andThen(SUBCOMPONENT) : transformation;
- }
-
- private abstract static class Messages {
- private final Function<String, String> transformation;
-
- Messages(Function<String, String> transformation) {
- this.transformation = transformation;
- }
-
- protected final String process(String s) {
- return transformation.apply(s);
- }
- }
-
- /** Errors for components. */
- static final class ComponentMessages extends Messages {
- ComponentMessages(Function<String, String> transformation) {
- super(transformation);
- }
-
- final String moreThanOne() {
- return process("@Component has more than one @Component.Builder or @Component.Factory: %s");
- }
- }
-
- /** Errors for component creators. */
- abstract static class ComponentCreatorMessages extends Messages {
- ComponentCreatorMessages(Function<String, String> transformation) {
- super(transformation);
- }
-
- static String builderMethodRequiresNoArgs() {
- return "Methods returning a @Component.Builder must have no arguments";
- }
-
- static String moreThanOneRefToSubcomponent() {
- return "Only one method can create a given subcomponent. %s is created by: %s";
- }
-
- final String invalidConstructor() {
- return process("@Component.Builder classes must have exactly one constructor,"
- + " and it must not be private or have any parameters");
- }
-
- final String generics() {
- return process("@Component.Builder types must not have any generic types");
- }
-
- final String mustBeInComponent() {
- return process("@Component.Builder types must be nested within a @Component");
- }
-
- final String mustBeClassOrInterface() {
- return process("@Component.Builder types must be abstract classes or interfaces");
- }
-
- final String isPrivate() {
- return process("@Component.Builder types must not be private");
- }
-
- final String mustBeStatic() {
- return process("@Component.Builder types must be static");
- }
-
- final String mustBeAbstract() {
- return process("@Component.Builder types must be abstract");
- }
-
- abstract String missingFactoryMethod();
-
- abstract String multipleSettersForModuleOrDependencyType();
-
- abstract String extraSetters();
-
- abstract String missingSetters();
-
- abstract String twoFactoryMethods();
-
- abstract String inheritedTwoFactoryMethods();
-
- abstract String factoryMethodMustReturnComponentType();
-
- final String inheritedFactoryMethodMustReturnComponentType() {
- return factoryMethodMustReturnComponentType() + ". Inherited method: %s";
- }
-
- abstract String factoryMethodMayNotBeAnnotatedWithBindsInstance();
-
- final String inheritedFactoryMethodMayNotBeAnnotatedWithBindsInstance() {
- return factoryMethodMayNotBeAnnotatedWithBindsInstance() + ". Inherited method: %s";
- }
-
- final String setterMethodsMustTakeOneArg() {
- return process("@Component.Builder methods must not have more than one argument");
- }
-
- final String inheritedSetterMethodsMustTakeOneArg() {
- return setterMethodsMustTakeOneArg() + ". Inherited method: %s";
- }
-
- final String setterMethodsMustReturnVoidOrBuilder() {
- return process("@Component.Builder setter methods must return void, the builder,"
- + " or a supertype of the builder");
- }
-
- final String inheritedSetterMethodsMustReturnVoidOrBuilder() {
- return setterMethodsMustReturnVoidOrBuilder() + ". Inherited method: %s";
- }
-
- final String methodsMayNotHaveTypeParameters() {
- return process("@Component.Builder methods must not have type parameters");
- }
-
- final String inheritedMethodsMayNotHaveTypeParameters() {
- return methodsMayNotHaveTypeParameters() + ". Inherited method: %s";
- }
-
- abstract String nonBindsInstanceParametersMayNotBePrimitives();
-
- final String inheritedNonBindsInstanceParametersMayNotBePrimitives() {
- return nonBindsInstanceParametersMayNotBePrimitives() + ". Inherited method: %s";
- }
-
- final String factoryMethodReturnsSupertypeWithMissingMethods(
- TypeElement component,
- TypeElement componentBuilder,
- TypeMirror returnType,
- ExecutableElement buildMethod,
- Set<ExecutableElement> additionalMethods) {
- return String.format(
- "%1$s.%2$s() returns %3$s, but %4$s declares additional component method(s): %5$s. In "
- + "order to provide type-safe access to these methods, override %2$s() to return "
- + "%4$s",
- componentBuilder.getQualifiedName(),
- buildMethod.getSimpleName(),
- returnType,
- component.getQualifiedName(),
- Joiner.on(", ").join(additionalMethods));
- }
-
- final String bindsInstanceNotAllowedOnBothSetterMethodAndParameter() {
- return process("@Component.Builder setter methods may not have @BindsInstance on both the "
- + "method and its parameter; choose one or the other");
- }
-
- final String inheritedBindsInstanceNotAllowedOnBothSetterMethodAndParameter() {
- return bindsInstanceNotAllowedOnBothSetterMethodAndParameter() + ". Inherited method: %s";
- }
- }
-
- private static final class BuilderMessages extends ComponentCreatorMessages {
- BuilderMessages(Function<String, String> transformation) {
- super(transformation);
- }
-
- @Override
- String missingFactoryMethod() {
- return process(
- "@Component.Builder types must have exactly one no-args method that "
- + " returns the @Component type");
- }
-
- @Override
- String multipleSettersForModuleOrDependencyType() {
- return process(
- "@Component.Builder types must not have more than one setter method per module or "
- + "dependency, but %s is set by %s");
- }
-
- @Override
- String extraSetters() {
- return process(
- "@Component.Builder has setters for modules or components that aren't required: %s");
- }
-
- @Override
- String missingSetters() {
- return process(
- "@Component.Builder is missing setters for required modules or components: %s");
- }
-
- @Override
- String twoFactoryMethods() {
- return process(
- "@Component.Builder types must have exactly one zero-arg method, and that"
- + " method must return the @Component type. Already found: %s");
- }
-
- @Override
- String inheritedTwoFactoryMethods() {
- return process(
- "@Component.Builder types must have exactly one zero-arg method, and that"
- + " method must return the @Component type. Found %s and %s");
- }
-
- @Override
- String factoryMethodMustReturnComponentType() {
- return process(
- "@Component.Builder methods that have no arguments must return the @Component type or a "
- + "supertype of the @Component");
- }
-
- @Override
- String factoryMethodMayNotBeAnnotatedWithBindsInstance() {
- return process(
- "@Component.Builder no-arg build methods may not be annotated with @BindsInstance");
- }
-
- @Override
- String nonBindsInstanceParametersMayNotBePrimitives() {
- return process(
- "@Component.Builder methods that are not annotated with @BindsInstance "
- + "must take either a module or a component dependency, not a primitive");
- }
- }
-
- private static final class FactoryMessages extends ComponentCreatorMessages {
- FactoryMessages(Function<String, String> transformation) {
- super(transformation.andThen(FACTORY));
- }
-
- @Override
- String missingFactoryMethod() {
- return process(
- "@Component.Factory types must have exactly one method that "
- + "returns the @Component type");
- }
-
- @Override
- String multipleSettersForModuleOrDependencyType() {
- return process(
- "@Component.Factory methods must not have more than one parameter per module or "
- + "dependency, but %s is set by %s");
- }
-
- @Override
- String extraSetters() {
- return process(
- "@Component.Factory method has parameters for modules or components that aren't "
- + "required: %s");
- }
-
- @Override
- String missingSetters() {
- return process(
- "@Component.Factory method is missing parameters for required modules or components: %s");
- }
-
- @Override
- String twoFactoryMethods() {
- return process(
- "@Component.Factory types must have exactly one abstract method. Already found: %s");
- }
-
- @Override
- String inheritedTwoFactoryMethods() {
- return twoFactoryMethods();
- }
-
- @Override
- String factoryMethodMustReturnComponentType() {
- return process(
- "@Component.Factory abstract methods must return the @Component type or a "
- + "supertype of the @Component");
- }
-
- @Override
- String factoryMethodMayNotBeAnnotatedWithBindsInstance() {
- return process("@Component.Factory method may not be annotated with @BindsInstance");
- }
-
- @Override
- String nonBindsInstanceParametersMayNotBePrimitives() {
- return process(
- "@Component.Factory method parameters that are not annotated with @BindsInstance "
- + "must be either a module or a component dependency, not a primitive");
- }
- }
-
- private ErrorMessages() {}
-}
diff --git a/java/dagger/internal/codegen/FactoryGenerator.java b/java/dagger/internal/codegen/FactoryGenerator.java
deleted file mode 100644
index d367bc5..0000000
--- a/java/dagger/internal/codegen/FactoryGenerator.java
+++ /dev/null
@@ -1,290 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.collect.Maps.transformValues;
-import static com.squareup.javapoet.MethodSpec.constructorBuilder;
-import static com.squareup.javapoet.MethodSpec.methodBuilder;
-import static com.squareup.javapoet.TypeSpec.classBuilder;
-import static dagger.internal.codegen.ContributionBinding.FactoryCreationStrategy.DELEGATE;
-import static dagger.internal.codegen.ContributionBinding.FactoryCreationStrategy.SINGLETON_INSTANCE;
-import static dagger.internal.codegen.GwtCompatibility.gwtIncompatibleAnnotation;
-import static dagger.internal.codegen.SourceFiles.bindingTypeElementTypeVariableNames;
-import static dagger.internal.codegen.SourceFiles.frameworkFieldUsages;
-import static dagger.internal.codegen.SourceFiles.frameworkTypeUsageStatement;
-import static dagger.internal.codegen.SourceFiles.generateBindingFieldsForDependencies;
-import static dagger.internal.codegen.SourceFiles.generatedClassNameForBinding;
-import static dagger.internal.codegen.SourceFiles.parameterizedGeneratedTypeNameForBinding;
-import static dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression.RAWTYPES;
-import static dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression.UNCHECKED;
-import static dagger.internal.codegen.javapoet.AnnotationSpecs.suppressWarnings;
-import static dagger.internal.codegen.javapoet.CodeBlocks.makeParametersCodeBlock;
-import static dagger.internal.codegen.javapoet.TypeNames.factoryOf;
-import static dagger.model.BindingKind.PROVISION;
-import static javax.lang.model.element.Modifier.FINAL;
-import static javax.lang.model.element.Modifier.PRIVATE;
-import static javax.lang.model.element.Modifier.PUBLIC;
-import static javax.lang.model.element.Modifier.STATIC;
-
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Lists;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.FieldSpec;
-import com.squareup.javapoet.MethodSpec;
-import com.squareup.javapoet.ParameterSpec;
-import com.squareup.javapoet.TypeName;
-import com.squareup.javapoet.TypeSpec;
-import dagger.internal.Factory;
-import dagger.internal.Preconditions;
-import dagger.internal.codegen.InjectionMethods.InjectionSiteMethod;
-import dagger.internal.codegen.InjectionMethods.ProvisionMethod;
-import dagger.internal.codegen.javapoet.CodeBlocks;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.Key;
-import java.util.List;
-import java.util.Optional;
-import javax.annotation.processing.Filer;
-import javax.inject.Inject;
-import javax.lang.model.SourceVersion;
-import javax.lang.model.element.Element;
-
-/**
- * Generates {@link Factory} implementations from {@link ProvisionBinding} instances for
- * {@link Inject} constructors.
- */
-final class FactoryGenerator extends SourceFileGenerator<ProvisionBinding> {
- private final DaggerTypes types;
- private final DaggerElements elements;
- private final CompilerOptions compilerOptions;
-
- @Inject
- FactoryGenerator(
- Filer filer,
- SourceVersion sourceVersion,
- DaggerTypes types,
- DaggerElements elements,
- CompilerOptions compilerOptions) {
- super(filer, elements, sourceVersion);
- this.types = types;
- this.elements = elements;
- this.compilerOptions = compilerOptions;
- }
-
- @Override
- ClassName nameGeneratedType(ProvisionBinding binding) {
- return generatedClassNameForBinding(binding);
- }
-
- @Override
- Element originatingElement(ProvisionBinding binding) {
- // we only create factories for bindings that have a binding element
- return binding.bindingElement().get();
- }
-
- @Override
- Optional<TypeSpec.Builder> write(ClassName generatedTypeName, ProvisionBinding binding) {
- // We don't want to write out resolved bindings -- we want to write out the generic version.
- checkArgument(!binding.unresolved().isPresent());
- checkArgument(binding.bindingElement().isPresent());
-
- return binding.factoryCreationStrategy().equals(DELEGATE)
- ? Optional.empty()
- : Optional.of(factoryBuilder(binding));
- }
-
- private TypeSpec.Builder factoryBuilder(ProvisionBinding binding) {
- TypeSpec.Builder factoryBuilder =
- classBuilder(nameGeneratedType(binding))
- .addModifiers(PUBLIC, FINAL)
- .addSuperinterface(factoryTypeName(binding))
- .addTypeVariables(bindingTypeElementTypeVariableNames(binding));
-
- addConstructorAndFields(binding, factoryBuilder);
- factoryBuilder.addMethod(getMethod(binding));
- addCreateMethod(binding, factoryBuilder);
-
- factoryBuilder.addMethod(
- ProvisionMethod.create(binding, compilerOptions, elements).toMethodSpec());
- gwtIncompatibleAnnotation(binding).ifPresent(factoryBuilder::addAnnotation);
-
- return factoryBuilder;
- }
-
- private void addConstructorAndFields(ProvisionBinding binding, TypeSpec.Builder factoryBuilder) {
- if (binding.factoryCreationStrategy().equals(SINGLETON_INSTANCE)) {
- return;
- }
- // TODO(user): Make the constructor private?
- MethodSpec.Builder constructor = constructorBuilder().addModifiers(PUBLIC);
- constructorParams(binding).forEach(
- param -> {
- constructor.addParameter(param).addStatement("this.$1N = $1N", param);
- factoryBuilder.addField(
- FieldSpec.builder(param.type, param.name, PRIVATE, FINAL).build());
- });
- factoryBuilder.addMethod(constructor.build());
- }
-
- private ImmutableList<ParameterSpec> constructorParams(ProvisionBinding binding) {
- ImmutableList.Builder<ParameterSpec> params = ImmutableList.builder();
- moduleParameter(binding).ifPresent(params::add);
- frameworkFields(binding).values().forEach(field -> params.add(toParameter(field)));
- return params.build();
- }
-
- private Optional<ParameterSpec> moduleParameter(ProvisionBinding binding) {
- if (binding.requiresModuleInstance()) {
- // TODO(user, dpb): Should this use contributingModule()?
- TypeName type = TypeName.get(binding.bindingTypeElement().get().asType());
- return Optional.of(ParameterSpec.builder(type, "module").build());
- }
- return Optional.empty();
- }
-
- private ImmutableMap<Key, FieldSpec> frameworkFields(ProvisionBinding binding) {
- UniqueNameSet uniqueFieldNames = new UniqueNameSet();
- // TODO(user, dpb): Add a test for the case when a Factory parameter is named "module".
- if (binding.requiresModuleInstance()) {
- uniqueFieldNames.claim("module");
- }
- return ImmutableMap.copyOf(
- transformValues(
- generateBindingFieldsForDependencies(binding),
- field ->
- FieldSpec.builder(
- field.type(), uniqueFieldNames.getUniqueName(field.name()), PRIVATE, FINAL)
- .build()));
- }
-
- private void addCreateMethod(ProvisionBinding binding, TypeSpec.Builder factoryBuilder) {
- // If constructing a factory for @Inject or @Provides bindings, we use a static create method
- // so that generated components can avoid having to refer to the generic types
- // of the factory. (Otherwise they may have visibility problems referring to the types.)
- MethodSpec.Builder createMethodBuilder =
- methodBuilder("create")
- .addModifiers(PUBLIC, STATIC)
- .returns(parameterizedGeneratedTypeNameForBinding(binding))
- .addTypeVariables(bindingTypeElementTypeVariableNames(binding));
-
- switch (binding.factoryCreationStrategy()) {
- case SINGLETON_INSTANCE:
- FieldSpec.Builder instanceFieldBuilder =
- FieldSpec.builder(nameGeneratedType(binding), "INSTANCE", PRIVATE, STATIC, FINAL)
- .initializer("new $T()", nameGeneratedType(binding));
-
- if (!bindingTypeElementTypeVariableNames(binding).isEmpty()) {
- // If the factory has type parameters, ignore them in the field declaration & initializer
- instanceFieldBuilder.addAnnotation(suppressWarnings(RAWTYPES));
-
- createMethodBuilder.addAnnotation(suppressWarnings(UNCHECKED));
- }
- createMethodBuilder.addStatement("return INSTANCE");
- factoryBuilder.addField(instanceFieldBuilder.build());
- break;
- case CLASS_CONSTRUCTOR:
- List<ParameterSpec> params = constructorParams(binding);
- createMethodBuilder.addParameters(params);
- createMethodBuilder.addStatement(
- "return new $T($L)",
- parameterizedGeneratedTypeNameForBinding(binding),
- makeParametersCodeBlock(Lists.transform(params, input -> CodeBlock.of("$N", input))));
- break;
- default:
- throw new AssertionError();
- }
- factoryBuilder.addMethod(createMethodBuilder.build());
- }
-
- private MethodSpec getMethod(ProvisionBinding binding) {
- TypeName providedTypeName = providedTypeName(binding);
- MethodSpec.Builder getMethod =
- methodBuilder("get")
- .addAnnotation(Override.class)
- .addModifiers(PUBLIC)
- .returns(providedTypeName);
-
- ImmutableMap<Key, FieldSpec> frameworkFields = frameworkFields(binding);
- CodeBlock parametersCodeBlock =
- makeParametersCodeBlock(
- frameworkFieldUsages(binding.provisionDependencies(), frameworkFields).values());
-
- if (binding.kind().equals(PROVISION)) {
- binding
- .nullableType()
- .ifPresent(nullableType -> CodeBlocks.addAnnotation(getMethod, nullableType));
- getMethod.addStatement(
- "return $L",
- ProvisionMethod.invoke(
- binding,
- request ->
- frameworkTypeUsageStatement(
- CodeBlock.of("$N", frameworkFields.get(request.key())), request.kind()),
- nameGeneratedType(binding),
- binding.requiresModuleInstance()
- ? Optional.of(CodeBlock.of("module"))
- : Optional.empty(),
- compilerOptions,
- elements));
- } else if (!binding.injectionSites().isEmpty()) {
- CodeBlock instance = CodeBlock.of("instance");
- getMethod
- .addStatement("$1T $2L = new $1T($3L)", providedTypeName, instance, parametersCodeBlock)
- .addCode(
- InjectionSiteMethod.invokeAll(
- binding.injectionSites(),
- nameGeneratedType(binding),
- instance,
- binding.key().type(),
- types,
- frameworkFieldUsages(binding.dependencies(), frameworkFields)::get,
- elements))
- .addStatement("return $L", instance);
- } else {
- getMethod.addStatement(
- "return new $T($L)", providedTypeName, parametersCodeBlock);
- }
- return getMethod.build();
- }
-
- private static TypeName providedTypeName(ProvisionBinding binding) {
- return TypeName.get(binding.contributedType());
- }
-
- private static TypeName factoryTypeName(ProvisionBinding binding) {
- return factoryOf(providedTypeName(binding));
- }
-
- private static ParameterSpec toParameter(FieldSpec field) {
- return ParameterSpec.builder(field.type, field.name).build();
- }
-
- /**
- * Returns {@code Preconditions.checkNotNull(providesMethodInvocation)} with a message suitable
- * for {@code @Provides} methods.
- */
- static CodeBlock checkNotNullProvidesMethod(CodeBlock providesMethodInvocation) {
- return CodeBlock.of(
- "$T.checkNotNull($L, $S)",
- Preconditions.class,
- providesMethodInvocation,
- "Cannot return null from a non-@Nullable @Provides method");
- }
-}
diff --git a/java/dagger/internal/codegen/FeatureStatus.java b/java/dagger/internal/codegen/FeatureStatus.java
deleted file mode 100644
index 9ff254e..0000000
--- a/java/dagger/internal/codegen/FeatureStatus.java
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-/** Allows options to control how features in component processing are enabled. */
-enum FeatureStatus {
- ENABLED,
- DISABLED;
-}
diff --git a/java/dagger/internal/codegen/Formatter.java b/java/dagger/internal/codegen/Formatter.java
deleted file mode 100644
index 53d4f9a..0000000
--- a/java/dagger/internal/codegen/Formatter.java
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkElementIndex;
-
-import com.google.common.base.Function;
-import com.google.common.collect.Iterables;
-
-/**
- * A formatter which transforms an instance of a particular type into a string
- * representation.
- *
- * @param <T> the type of the object to be transformed.
- */
-abstract class Formatter<T> implements Function<T, String> {
-
- static final String INDENT = " ";
- static final String DOUBLE_INDENT = INDENT + INDENT;
- private static final int LIST_LIMIT = 10;
-
- /**
- * Performs the transformation of an object into a string representation.
- */
- public abstract String format(T object);
-
- /**
- * Performs the transformation of an object into a string representation in conformity with the
- * {@link Function}{@code <T, String>} contract, delegating to {@link #format(Object)}.
- *
- * @deprecated Call {@link #format(Object)} instead. This method exists to make formatters easy to
- * use when functions are required, but shouldn't be called directly.
- */
- @SuppressWarnings("javadoc")
- @Deprecated
- @Override
- public final String apply(T object) {
- return format(object);
- }
-
- /** Formats {@code items}, one per line. Stops after {@value #LIST_LIMIT} items. */
- public void formatIndentedList(
- StringBuilder builder, Iterable<? extends T> items, int indentLevel) {
- for (T item : Iterables.limit(items, LIST_LIMIT)) {
- String formatted = format(item);
- if (formatted.isEmpty()) {
- continue;
- }
- builder.append('\n');
- appendIndent(builder, indentLevel);
- builder.append(formatted);
- }
- int numberOfOtherItems = Iterables.size(items) - LIST_LIMIT;
- if (numberOfOtherItems > 0) {
- builder.append('\n');
- appendIndent(builder, indentLevel);
- builder.append("and ").append(numberOfOtherItems).append(" other");
- }
- if (numberOfOtherItems > 1) {
- builder.append('s');
- }
- }
-
- private void appendIndent(StringBuilder builder, int indentLevel) {
- for (int i = 0; i < indentLevel; i++) {
- builder.append(INDENT);
- }
- }
-
- static String formatArgumentInList(int index, int size, CharSequence name) {
- checkElementIndex(index, size);
- StringBuilder builder = new StringBuilder();
- if (index > 0) {
- builder.append("…, ");
- }
- builder.append(name);
- if (index < size - 1) {
- builder.append(", …");
- }
- return builder.toString();
- }
-}
diff --git a/java/dagger/internal/codegen/ForwardingCompilerOptions.java b/java/dagger/internal/codegen/ForwardingCompilerOptions.java
deleted file mode 100644
index 4a1deda..0000000
--- a/java/dagger/internal/codegen/ForwardingCompilerOptions.java
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- * Copyright (C) 2019 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import javax.lang.model.element.TypeElement;
-import javax.tools.Diagnostic;
-
-/** A {@link CompilerOptions} object that delegates to another one. */
-class ForwardingCompilerOptions extends CompilerOptions {
-
- private final CompilerOptions delegate;
-
- ForwardingCompilerOptions(CompilerOptions delegate) {
- this.delegate = checkNotNull(delegate);
- }
-
- @Override
- boolean usesProducers() {
- return delegate.usesProducers();
- }
-
- @Override
- boolean fastInit() {
- return delegate.fastInit();
- }
-
- @Override
- boolean formatGeneratedSource() {
- return delegate.formatGeneratedSource();
- }
-
- @Override
- boolean writeProducerNameInToken() {
- return delegate.writeProducerNameInToken();
- }
-
- @Override
- Diagnostic.Kind nullableValidationKind() {
- return delegate.nullableValidationKind();
- }
-
- @Override
- Diagnostic.Kind privateMemberValidationKind() {
- return delegate.privateMemberValidationKind();
- }
-
- @Override
- Diagnostic.Kind staticMemberValidationKind() {
- return delegate.staticMemberValidationKind();
- }
-
- @Override
- boolean ignorePrivateAndStaticInjectionForComponent() {
- return delegate.ignorePrivateAndStaticInjectionForComponent();
- }
-
- @Override
- ValidationType scopeCycleValidationType() {
- return delegate.scopeCycleValidationType();
- }
-
- @Override
- boolean warnIfInjectionFactoryNotGeneratedUpstream() {
- return delegate.warnIfInjectionFactoryNotGeneratedUpstream();
- }
-
- @Override
- boolean headerCompilation() {
- return delegate.headerCompilation();
- }
-
- @Override
- boolean aheadOfTimeSubcomponents() {
- return delegate.aheadOfTimeSubcomponents();
- }
-
- @Override
- boolean forceUseSerializedComponentImplementations() {
- return delegate.forceUseSerializedComponentImplementations();
- }
-
- @Override
- boolean emitModifiableMetadataAnnotations() {
- return delegate.emitModifiableMetadataAnnotations();
- }
-
- @Override
- boolean useGradleIncrementalProcessing() {
- return delegate.useGradleIncrementalProcessing();
- }
-
- @Override
- ValidationType fullBindingGraphValidationType(TypeElement element) {
- return delegate.fullBindingGraphValidationType(element);
- }
-
- @Override
- Diagnostic.Kind moduleHasDifferentScopesDiagnosticKind() {
- return delegate.moduleHasDifferentScopesDiagnosticKind();
- }
-
- @Override
- ValidationType explicitBindingConflictsWithInjectValidationType() {
- return delegate.explicitBindingConflictsWithInjectValidationType();
- }
-}
diff --git a/java/dagger/internal/codegen/FrameworkDependency.java b/java/dagger/internal/codegen/FrameworkDependency.java
deleted file mode 100644
index feea7a0..0000000
--- a/java/dagger/internal/codegen/FrameworkDependency.java
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import com.google.auto.value.AutoValue;
-import dagger.model.Key;
-
-/**
- * The framework class and binding key for a resolved dependency of a binding. If a binding has
- * several dependencies for a key, then only one instance of this class will represent them all.
- *
- * <p>In the following example, the binding {@code provideFoo()} has two dependency requests:
- *
- * <ol>
- * <li>{@code Bar bar}
- * <li>{@code Provider<Bar> barProvider}
- * </ol>
- *
- * But they both can be satisfied with the same instance of {@code Provider<Bar>}. So one instance
- * of {@code FrameworkDependency} will be used for both. Its {@link #key()} will be for {@code Bar},
- * and its {@link #frameworkType()} will be {@link FrameworkType#PROVIDER}.
- *
- * <pre><code>
- * {@literal @Provides} static Foo provideFoo(Bar bar, {@literal Provider<Bar>} barProvider) {
- * return new Foo(…);
- * }
- * </code></pre>
- */
-@AutoValue
-abstract class FrameworkDependency {
-
- /** The fully-resolved key shared by all the dependency requests. */
- abstract Key key();
-
- /** The type of the framework dependency. */
- abstract FrameworkType frameworkType();
-
- /** The framework class to use for this dependency. */
- final Class<?> frameworkClass() {
- return frameworkType().frameworkClass();
- }
-
- /** Returns a new instance with the given key and type. */
- static FrameworkDependency create(Key key, FrameworkType frameworkType) {
- return new AutoValue_FrameworkDependency(key, frameworkType);
- }
-}
diff --git a/java/dagger/internal/codegen/FrameworkField.java b/java/dagger/internal/codegen/FrameworkField.java
deleted file mode 100644
index de2ada0..0000000
--- a/java/dagger/internal/codegen/FrameworkField.java
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.model.BindingKind.MEMBERS_INJECTOR;
-
-import com.google.auto.value.AutoValue;
-import com.google.common.base.CaseFormat;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.ParameterizedTypeName;
-import com.squareup.javapoet.TypeName;
-import java.util.Optional;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ElementVisitor;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.element.VariableElement;
-import javax.lang.model.type.TypeMirror;
-import javax.lang.model.util.ElementKindVisitor8;
-
-/**
- * A value object that represents a field in the generated Component class.
- *
- * <p>Examples:
- * <ul>
- * <li>{@code Provider<String>}
- * <li>{@code Producer<Widget>}
- * <li>{@code Provider<Map<SomeMapKey, MapValue>>}.
- * </ul>
- */
-@AutoValue
-abstract class FrameworkField {
-
- /**
- * Creates a framework field.
- *
- * @param frameworkClassName the name of the framework class (e.g., {@link javax.inject.Provider})
- * @param valueTypeName the name of the type parameter of the framework class (e.g., {@code Foo}
- * for {@code Provider<Foo>}
- * @param fieldName the name of the field
- */
- static FrameworkField create(
- ClassName frameworkClassName, TypeName valueTypeName, String fieldName) {
- String suffix = frameworkClassName.simpleName();
- return new AutoValue_FrameworkField(
- ParameterizedTypeName.get(frameworkClassName, valueTypeName),
- fieldName.endsWith(suffix) ? fieldName : fieldName + suffix);
- }
-
- /**
- * A framework field for a {@link ResolvedBindings}.
- *
- * @param frameworkClass if present, the field will use this framework class instead of the normal
- * one for the bindings
- */
- static FrameworkField forResolvedBindings(
- ResolvedBindings resolvedBindings, Optional<ClassName> frameworkClass) {
- return create(
- frameworkClass.orElse(
- ClassName.get(
- FrameworkType.forBindingType(resolvedBindings.bindingType()).frameworkClass())),
- TypeName.get(fieldValueType(resolvedBindings)),
- frameworkFieldName(resolvedBindings));
- }
-
- private static TypeMirror fieldValueType(ResolvedBindings resolvedBindings) {
- return resolvedBindings.isMultibindingContribution()
- ? resolvedBindings.contributionBinding().contributedType()
- : resolvedBindings.key().type();
- }
-
- private static String frameworkFieldName(ResolvedBindings resolvedBindings) {
- if (!resolvedBindings.contributionBindings().isEmpty()) {
- ContributionBinding binding = resolvedBindings.contributionBinding();
- if (binding.bindingElement().isPresent()) {
- String name = BINDING_ELEMENT_NAME.visit(binding.bindingElement().get(), binding);
- return binding.kind().equals(MEMBERS_INJECTOR)
- ? name + "MembersInjector"
- : name;
- }
- }
- return KeyVariableNamer.name(resolvedBindings.key());
- }
-
- private static final ElementVisitor<String, Binding> BINDING_ELEMENT_NAME =
- new ElementKindVisitor8<String, Binding>() {
-
- @Override
- protected String defaultAction(Element e, Binding p) {
- throw new IllegalArgumentException("Unexpected binding " + p);
- }
-
- @Override
- public String visitExecutableAsConstructor(ExecutableElement e, Binding p) {
- return visit(e.getEnclosingElement(), p);
- }
-
- @Override
- public String visitExecutableAsMethod(ExecutableElement e, Binding p) {
- return e.getSimpleName().toString();
- }
-
- @Override
- public String visitType(TypeElement e, Binding p) {
- return CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL, e.getSimpleName().toString());
- }
-
- @Override
- public String visitVariableAsParameter(VariableElement e, Binding p) {
- return e.getSimpleName().toString();
- }
- };
-
- abstract ParameterizedTypeName type();
- abstract String name();
-}
diff --git a/java/dagger/internal/codegen/FrameworkFieldInitializer.java b/java/dagger/internal/codegen/FrameworkFieldInitializer.java
deleted file mode 100644
index a3de083..0000000
--- a/java/dagger/internal/codegen/FrameworkFieldInitializer.java
+++ /dev/null
@@ -1,217 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static dagger.internal.codegen.ComponentImplementation.FieldSpecKind.FRAMEWORK_FIELD;
-import static dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression.RAWTYPES;
-import static javax.lang.model.element.Modifier.PRIVATE;
-
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.FieldSpec;
-import com.squareup.javapoet.TypeName;
-import dagger.internal.DelegateFactory;
-import dagger.internal.codegen.javapoet.AnnotationSpecs;
-import dagger.internal.codegen.javapoet.TypeNames;
-import dagger.producers.internal.DelegateProducer;
-import java.util.Optional;
-
-/**
- * An object that can initialize a framework-type component field for a binding. An instance should
- * be created for each field.
- */
-class FrameworkFieldInitializer implements FrameworkInstanceSupplier {
-
- /**
- * An object that can determine the expression to use to assign to the component field for a
- * binding.
- */
- interface FrameworkInstanceCreationExpression {
- /** Returns the expression to use to assign to the component field for the binding. */
- CodeBlock creationExpression();
-
- /**
- * Returns the framework class to use for the field, if different from the one implied by the
- * binding. This implementation returns {@link Optional#empty()}.
- */
- default Optional<ClassName> alternativeFrameworkClass() {
- return Optional.empty();
- }
-
- /**
- * Returns {@code true} if instead of using {@link #creationExpression()} to create a framework
- * instance, a case in {@link InnerSwitchingProviders} should be created for this binding.
- */
- // TODO(ronshapiro): perhaps this isn't the right approach. Instead of saying "Use
- // SetFactory.EMPTY because you will only get 1 class for all types of bindings that use
- // SetFactory", maybe we should still use an inner switching provider but the same switching
- // provider index for all cases.
- default boolean useInnerSwitchingProvider() {
- return true;
- }
- }
-
- private final ComponentImplementation componentImplementation;
- private final ResolvedBindings resolvedBindings;
- private final FrameworkInstanceCreationExpression frameworkInstanceCreationExpression;
- private FieldSpec fieldSpec;
- private InitializationState fieldInitializationState = InitializationState.UNINITIALIZED;
-
- FrameworkFieldInitializer(
- ComponentImplementation componentImplementation,
- ResolvedBindings resolvedBindings,
- FrameworkInstanceCreationExpression frameworkInstanceCreationExpression) {
- this.componentImplementation = checkNotNull(componentImplementation);
- this.resolvedBindings = checkNotNull(resolvedBindings);
- this.frameworkInstanceCreationExpression = checkNotNull(frameworkInstanceCreationExpression);
- }
-
- /**
- * Returns the {@link MemberSelect} for the framework field, and adds the field and its
- * initialization code to the component if it's needed and not already added.
- */
- @Override
- public final MemberSelect memberSelect() {
- initializeField();
- return MemberSelect.localField(componentImplementation.name(), checkNotNull(fieldSpec).name);
- }
-
- /** Adds the field and its initialization code to the component. */
- private void initializeField() {
- switch (fieldInitializationState) {
- case UNINITIALIZED:
- // Change our state in case we are recursively invoked via initializeBindingExpression
- fieldInitializationState = InitializationState.INITIALIZING;
- CodeBlock.Builder codeBuilder = CodeBlock.builder();
- CodeBlock fieldInitialization = frameworkInstanceCreationExpression.creationExpression();
- CodeBlock initCode = CodeBlock.of("this.$N = $L;", getOrCreateField(), fieldInitialization);
-
- if (isReplacingSuperclassFrameworkInstance()
- || fieldInitializationState == InitializationState.DELEGATED) {
- codeBuilder.add(
- "$T.setDelegate($N, $L);", delegateType(), fieldSpec, fieldInitialization);
- } else {
- codeBuilder.add(initCode);
- }
- componentImplementation.addInitialization(codeBuilder.build());
-
- fieldInitializationState = InitializationState.INITIALIZED;
- break;
-
- case INITIALIZING:
- // We were recursively invoked, so create a delegate factory instead
- fieldInitializationState = InitializationState.DELEGATED;
- componentImplementation.addInitialization(
- CodeBlock.of("this.$N = new $T<>();", getOrCreateField(), delegateType()));
- break;
-
- case DELEGATED:
- case INITIALIZED:
- break;
- }
- }
-
- /**
- * Adds a field representing the resolved bindings, optionally forcing it to use a particular
- * binding type (instead of the type the resolved bindings would typically use).
- */
- private FieldSpec getOrCreateField() {
- if (fieldSpec != null) {
- return fieldSpec;
- }
- boolean useRawType = !componentImplementation.isTypeAccessible(resolvedBindings.key().type());
- FrameworkField contributionBindingField =
- FrameworkField.forResolvedBindings(
- resolvedBindings, frameworkInstanceCreationExpression.alternativeFrameworkClass());
-
- TypeName fieldType =
- useRawType ? contributionBindingField.type().rawType : contributionBindingField.type();
-
- FieldSpec.Builder contributionField =
- FieldSpec.builder(
- fieldType, componentImplementation.getUniqueFieldName(contributionBindingField.name()));
- contributionField.addModifiers(PRIVATE);
- if (useRawType) {
- contributionField.addAnnotation(AnnotationSpecs.suppressWarnings(RAWTYPES));
- }
-
- if (isReplacingSuperclassFrameworkInstance()) {
- // If a binding is modified in a subclass, the framework instance will be replaced in the
- // subclass implementation. The superclass framework instance initialization will run first,
- // however, and may refer to the modifiable binding method returning this type's modified
- // framework instance before it is initialized, so we use a delegate factory as a placeholder
- // until it has properly been initialized.
- contributionField.initializer("new $T<>()", delegateType());
- }
-
- fieldSpec = contributionField.build();
- componentImplementation.addField(FRAMEWORK_FIELD, fieldSpec);
-
- return fieldSpec;
- }
-
- /**
- * Returns true if this framework field is replacing a superclass's implementation of the
- * framework field.
- */
- private boolean isReplacingSuperclassFrameworkInstance() {
- return componentImplementation
- .superclassImplementation()
- .flatMap(
- superclassImplementation ->
- // TODO(b/117833324): can we constrain this further?
- superclassImplementation.getModifiableBindingMethod(
- BindingRequest.bindingRequest(
- resolvedBindings.key(),
- isProvider() ? FrameworkType.PROVIDER : FrameworkType.PRODUCER_NODE)))
- .isPresent();
- }
-
- private Class<?> delegateType() {
- return isProvider() ? DelegateFactory.class : DelegateProducer.class;
- }
-
- private boolean isProvider() {
- return resolvedBindings.bindingType().equals(BindingType.PROVISION)
- && frameworkInstanceCreationExpression
- .alternativeFrameworkClass()
- .map(TypeNames.PROVIDER::equals)
- .orElse(true);
- }
-
- /** Initialization state for a factory field. */
- private enum InitializationState {
- /** The field is {@code null}. */
- UNINITIALIZED,
-
- /**
- * The field's dependencies are being set up. If the field is needed in this state, use a {@link
- * DelegateFactory}.
- */
- INITIALIZING,
-
- /**
- * The field's dependencies are being set up, but the field can be used because it has already
- * been set to a {@link DelegateFactory}.
- */
- DELEGATED,
-
- /** The field is set to an undelegated factory. */
- INITIALIZED;
- }
-}
diff --git a/java/dagger/internal/codegen/FrameworkInstanceBindingExpression.java b/java/dagger/internal/codegen/FrameworkInstanceBindingExpression.java
deleted file mode 100644
index 6f62d66..0000000
--- a/java/dagger/internal/codegen/FrameworkInstanceBindingExpression.java
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
-
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.FieldSpec;
-import dagger.internal.codegen.javapoet.Expression;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.TypeMirror;
-
-/** A binding expression that uses a {@link FrameworkType} field. */
-abstract class FrameworkInstanceBindingExpression extends BindingExpression {
- private final ResolvedBindings resolvedBindings;
- private final FrameworkInstanceSupplier frameworkInstanceSupplier;
- private final DaggerTypes types;
- private final DaggerElements elements;
-
- FrameworkInstanceBindingExpression(
- ResolvedBindings resolvedBindings,
- FrameworkInstanceSupplier frameworkInstanceSupplier,
- DaggerTypes types,
- DaggerElements elements) {
- this.resolvedBindings = checkNotNull(resolvedBindings);
- this.frameworkInstanceSupplier = checkNotNull(frameworkInstanceSupplier);
- this.types = checkNotNull(types);
- this.elements = checkNotNull(elements);
- }
-
- /**
- * The expression for the framework instance for this binding. The field will be {@link
- * ComponentImplementation#addInitialization(CodeBlock) initialized} and {@link
- * ComponentImplementation#addField(ComponentImplementation.FieldSpecKind, FieldSpec) added} to
- * the component the first time this method is invoked.
- */
- @Override
- Expression getDependencyExpression(ClassName requestingClass) {
- MemberSelect memberSelect = frameworkInstanceSupplier.memberSelect();
- TypeMirror contributedType = resolvedBindings.contributionBinding().contributedType();
- TypeMirror expressionType =
- isTypeAccessibleFrom(contributedType, requestingClass.packageName())
- || isInlinedFactoryCreation(memberSelect)
- ? types.wrapType(contributedType, frameworkType().frameworkClass())
- : rawFrameworkType();
- return Expression.create(expressionType, memberSelect.getExpressionFor(requestingClass));
- }
-
- /** Returns the framework type for the binding. */
- protected abstract FrameworkType frameworkType();
-
- /**
- * Returns {@code true} if a factory is created inline each time it is requested. For example, in
- * the initialization {@code this.fooProvider = Foo_Factory.create(Bar_Factory.create());}, {@code
- * Bar_Factory} is considered to be inline.
- *
- * <p>This is used in {@link #getDependencyExpression(ClassName)} when determining the type of a
- * factory. Normally if the {@link ContributionBinding#contributedType()} is not accessible from
- * the component, the type of the expression will be a raw {@link javax.inject.Provider}. However,
- * if the factory is created inline, even if contributed type is not accessible, javac will still
- * be able to determine the type that is returned from the {@code Foo_Factory.create()} method.
- */
- private static boolean isInlinedFactoryCreation(MemberSelect memberSelect) {
- return memberSelect.staticMember();
- }
-
- private DeclaredType rawFrameworkType() {
- return types.getDeclaredType(elements.getTypeElement(frameworkType().frameworkClass()));
- }
-}
diff --git a/java/dagger/internal/codegen/FrameworkInstanceSupplier.java b/java/dagger/internal/codegen/FrameworkInstanceSupplier.java
deleted file mode 100644
index 4c45630..0000000
--- a/java/dagger/internal/codegen/FrameworkInstanceSupplier.java
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-/** An object that supplies a {@link MemberSelect} for a framework instance. */
-interface FrameworkInstanceSupplier {
- /** Returns a {@link MemberSelect}, with possible side effects on the first call. */
- MemberSelect memberSelect();
-}
diff --git a/java/dagger/internal/codegen/FrameworkType.java b/java/dagger/internal/codegen/FrameworkType.java
deleted file mode 100644
index f4e3779..0000000
--- a/java/dagger/internal/codegen/FrameworkType.java
+++ /dev/null
@@ -1,222 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.CaseFormat.UPPER_CAMEL;
-import static com.google.common.base.CaseFormat.UPPER_UNDERSCORE;
-import static dagger.model.RequestKind.INSTANCE;
-
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.ParameterizedTypeName;
-import com.squareup.javapoet.TypeName;
-import dagger.Lazy;
-import dagger.internal.DoubleCheck;
-import dagger.internal.ProviderOfLazy;
-import dagger.internal.codegen.javapoet.Expression;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.DependencyRequest;
-import dagger.model.RequestKind;
-import dagger.producers.Produced;
-import dagger.producers.Producer;
-import dagger.producers.internal.Producers;
-import java.util.Optional;
-import javax.inject.Provider;
-import javax.lang.model.type.TypeMirror;
-
-/** One of the core types initialized as fields in a generated component. */
-enum FrameworkType {
- /** A {@link Provider}. */
- PROVIDER {
- @Override
- Class<?> frameworkClass() {
- return Provider.class;
- }
-
- @Override
- Optional<RequestKind> requestKind() {
- return Optional.of(RequestKind.PROVIDER);
- }
-
- @Override
- CodeBlock to(RequestKind requestKind, CodeBlock from) {
- switch (requestKind) {
- case INSTANCE:
- return CodeBlock.of("$L.get()", from);
-
- case LAZY:
- return CodeBlock.of("$T.lazy($L)", DoubleCheck.class, from);
-
- case PROVIDER:
- return from;
-
- case PROVIDER_OF_LAZY:
- return CodeBlock.of("$T.create($L)", ProviderOfLazy.class, from);
-
- case PRODUCER:
- return CodeBlock.of("$T.producerFromProvider($L)", Producers.class, from);
-
- case FUTURE:
- return CodeBlock.of("$T.immediateFuture($L)", Futures.class, to(INSTANCE, from));
-
- case PRODUCED:
- return CodeBlock.of("$T.successful($L)", Produced.class, to(INSTANCE, from));
-
- default:
- throw new IllegalArgumentException(
- String.format("Cannot request a %s from a %s", requestKind, this));
- }
- }
-
- @Override
- Expression to(RequestKind requestKind, Expression from, DaggerTypes types) {
- CodeBlock codeBlock = to(requestKind, from.codeBlock());
- switch (requestKind) {
- case INSTANCE:
- return Expression.create(types.unwrapTypeOrObject(from.type()), codeBlock);
-
- case PROVIDER:
- return from;
-
- case PROVIDER_OF_LAZY:
- TypeMirror lazyType = types.rewrapType(from.type(), Lazy.class);
- return Expression.create(types.wrapType(lazyType, Provider.class), codeBlock);
-
- case FUTURE:
- return Expression.create(
- types.rewrapType(from.type(), ListenableFuture.class), codeBlock);
-
- default:
- return Expression.create(
- types.rewrapType(from.type(), RequestKinds.frameworkClass(requestKind)), codeBlock);
- }
- }
- },
-
- /** A {@link Producer}. */
- PRODUCER_NODE {
- @Override
- Class<?> frameworkClass() {
- // TODO(cgdecker): Replace this with new class for representing internal producer nodes.
- // Currently the new class is CancellableProducer, but it may be changed to ProducerNode and
- // made to not implement Producer.
- return Producer.class;
- }
-
- @Override
- Optional<RequestKind> requestKind() {
- return Optional.empty();
- }
-
- @Override
- CodeBlock to(RequestKind requestKind, CodeBlock from) {
- switch (requestKind) {
- case FUTURE:
- return CodeBlock.of("$L.get()", from);
-
- case PRODUCER:
- return from;
-
- default:
- throw new IllegalArgumentException(
- String.format("Cannot request a %s from a %s", requestKind, this));
- }
- }
-
- @Override
- Expression to(RequestKind requestKind, Expression from, DaggerTypes types) {
- switch (requestKind) {
- case FUTURE:
- return Expression.create(
- types.rewrapType(from.type(), ListenableFuture.class),
- to(requestKind, from.codeBlock()));
-
- case PRODUCER:
- return Expression.create(from.type(), to(requestKind, from.codeBlock()));
-
- default:
- throw new IllegalArgumentException(
- String.format("Cannot request a %s from a %s", requestKind, this));
- }
- }
- },
- ;
-
- /** Returns the framework type appropriate for fields for a given binding type. */
- static FrameworkType forBindingType(BindingType bindingType) {
- switch (bindingType) {
- case PROVISION:
- return PROVIDER;
- case PRODUCTION:
- return PRODUCER_NODE;
- case MEMBERS_INJECTION:
- }
- throw new AssertionError(bindingType);
- }
-
- /** Returns the framework type that exactly matches the given request kind, if one exists. */
- static Optional<FrameworkType> forRequestKind(RequestKind requestKind) {
- switch (requestKind) {
- case PROVIDER:
- return Optional.of(FrameworkType.PROVIDER);
- default:
- return Optional.empty();
- }
- }
-
- /** The class of fields of this type. */
- abstract Class<?> frameworkClass();
-
- /** Returns the {@link #frameworkClass()} parameterized with a type. */
- ParameterizedTypeName frameworkClassOf(TypeName valueType) {
- return ParameterizedTypeName.get(ClassName.get(frameworkClass()), valueType);
- }
-
- /** The request kind that an instance of this framework type can satisfy directly, if any. */
- abstract Optional<RequestKind> requestKind();
-
- /**
- * Returns a {@link CodeBlock} that evaluates to a requested object given an expression that
- * evaluates to an instance of this framework type.
- *
- * @param requestKind the kind of {@link DependencyRequest} that the returned expression can
- * satisfy
- * @param from a {@link CodeBlock} that evaluates to an instance of this framework type
- * @throws IllegalArgumentException if a valid expression cannot be generated for {@code
- * requestKind}
- */
- abstract CodeBlock to(RequestKind requestKind, CodeBlock from);
-
- /**
- * Returns an {@link Expression} that evaluates to a requested object given an expression that
- * evaluates to an instance of this framework type.
- *
- * @param requestKind the kind of {@link DependencyRequest} that the returned expression can
- * satisfy
- * @param from an expression that evaluates to an instance of this framework type
- * @throws IllegalArgumentException if a valid expression cannot be generated for {@code
- * requestKind}
- */
- abstract Expression to(RequestKind requestKind, Expression from, DaggerTypes types);
-
- @Override
- public String toString() {
- return UPPER_UNDERSCORE.to(UPPER_CAMEL, super.toString());
- }
-}
diff --git a/java/dagger/internal/codegen/FrameworkTypeMapper.java b/java/dagger/internal/codegen/FrameworkTypeMapper.java
deleted file mode 100644
index 7746692..0000000
--- a/java/dagger/internal/codegen/FrameworkTypeMapper.java
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static dagger.internal.codegen.BindingType.PRODUCTION;
-import static java.util.stream.Collectors.toSet;
-
-import dagger.model.DependencyRequest;
-import dagger.model.Key;
-import dagger.model.RequestKind;
-import dagger.producers.Producer;
-import java.util.Set;
-import javax.inject.Provider;
-
-/**
- * A mapper for associating a {@link RequestKind} to a {@link FrameworkType}, dependent on the type
- * of code to be generated (e.g., for {@link Provider} or {@link Producer}).
- */
-enum FrameworkTypeMapper {
- FOR_PROVIDER() {
- @Override
- public FrameworkType getFrameworkType(RequestKind requestKind) {
- switch (requestKind) {
- case INSTANCE:
- case PROVIDER:
- case PROVIDER_OF_LAZY:
- case LAZY:
- return FrameworkType.PROVIDER;
- case PRODUCED:
- case PRODUCER:
- throw new IllegalArgumentException(requestKind.toString());
- default:
- throw new AssertionError(requestKind);
- }
- }
- },
- FOR_PRODUCER() {
- @Override
- public FrameworkType getFrameworkType(RequestKind requestKind) {
- switch (requestKind) {
- case INSTANCE:
- case PRODUCED:
- case PRODUCER:
- return FrameworkType.PRODUCER_NODE;
- case PROVIDER:
- case PROVIDER_OF_LAZY:
- case LAZY:
- return FrameworkType.PROVIDER;
- default:
- throw new AssertionError(requestKind);
- }
- }
- };
-
- static FrameworkTypeMapper forBindingType(BindingType bindingType) {
- return bindingType.equals(PRODUCTION) ? FOR_PRODUCER : FOR_PROVIDER;
- }
-
- abstract FrameworkType getFrameworkType(RequestKind requestKind);
-
- /**
- * Returns the {@link FrameworkType} to use for a collection of requests of the same {@link Key}.
- * This allows factories to only take a single argument for multiple requests of the same key.
- */
- FrameworkType getFrameworkType(Set<DependencyRequest> requests) {
- Set<FrameworkType> frameworkTypes =
- requests.stream().map(request -> getFrameworkType(request.kind())).collect(toSet());
- return frameworkTypes.size() == 1 ? getOnlyElement(frameworkTypes) : FrameworkType.PROVIDER;
- }
-}
diff --git a/java/dagger/internal/codegen/FrameworkTypes.java b/java/dagger/internal/codegen/FrameworkTypes.java
deleted file mode 100644
index 19d2eda..0000000
--- a/java/dagger/internal/codegen/FrameworkTypes.java
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreTypes.isType;
-
-import com.google.auto.common.MoreTypes;
-import com.google.common.collect.ImmutableSet;
-import dagger.Lazy;
-import dagger.MembersInjector;
-import dagger.producers.Produced;
-import dagger.producers.Producer;
-import java.util.Set;
-import javax.inject.Provider;
-import javax.lang.model.type.TypeMirror;
-
-/**
- * A collection of utility methods for dealing with Dagger framework types. A framework type is any
- * type that the framework itself defines.
- */
-final class FrameworkTypes {
- private static final ImmutableSet<Class<?>> PROVISION_TYPES =
- ImmutableSet.of(Provider.class, Lazy.class, MembersInjector.class);
-
- // NOTE(beder): ListenableFuture is not considered a producer framework type because it is not
- // defined by the framework, so we can't treat it specially in ordinary Dagger.
- private static final ImmutableSet<Class<?>> PRODUCTION_TYPES =
- ImmutableSet.of(Produced.class, Producer.class);
-
- /** Returns true if the type represents a producer-related framework type. */
- static boolean isProducerType(TypeMirror type) {
- return isType(type) && typeIsOneOf(PRODUCTION_TYPES, type);
- }
-
- /** Returns true if the type represents a framework type. */
- static boolean isFrameworkType(TypeMirror type) {
- return isType(type)
- && (typeIsOneOf(PROVISION_TYPES, type)
- || typeIsOneOf(PRODUCTION_TYPES, type));
- }
-
- private static boolean typeIsOneOf(Set<Class<?>> classes, TypeMirror type) {
- for (Class<?> clazz : classes) {
- if (MoreTypes.isTypeOf(clazz, type)) {
- return true;
- }
- }
- return false;
- }
-
- private FrameworkTypes() {}
-}
diff --git a/java/dagger/internal/codegen/GenerationCompilerOptions.java b/java/dagger/internal/codegen/GenerationCompilerOptions.java
deleted file mode 100644
index 1b14a7e..0000000
--- a/java/dagger/internal/codegen/GenerationCompilerOptions.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static java.lang.annotation.RetentionPolicy.RUNTIME;
-
-import java.lang.annotation.Retention;
-import javax.inject.Qualifier;
-
-/**
- * A {@link Qualifier} for bindings associated with the serialization/deserialization of {@link
- * dagger.internal.GenerationOptions}.
- */
-@Retention(RUNTIME)
-@Qualifier
-@interface GenerationCompilerOptions {}
diff --git a/java/dagger/internal/codegen/GenerationOptionsModule.java b/java/dagger/internal/codegen/GenerationOptionsModule.java
deleted file mode 100644
index aa3c461..0000000
--- a/java/dagger/internal/codegen/GenerationOptionsModule.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import dagger.Module;
-import dagger.Provides;
-import dagger.internal.GenerationOptions;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import java.util.Optional;
-
-/** Adds bindings for serializing and rereading {@link GenerationOptions}. */
-@Module
-interface GenerationOptionsModule {
- @Provides
- @PerComponentImplementation
- @GenerationCompilerOptions
- static CompilerOptions generationOptions(
- CompilerOptions defaultOptions,
- ComponentImplementation componentImplementation,
- DaggerElements elements) {
- // Avoid looking up types that don't exist. Performance improves for large components.
- if (!defaultOptions.aheadOfTimeSubcomponents()) {
- return defaultOptions;
- }
- // Inspect the base implementation for the @GenerationOptions annotation. Even if
- // componentImplementation is the base implementation, inspect it for the case where we are
- // recomputing the ComponentImplementation from a previous compilation.
- // TODO(b/117833324): consider adding a method that returns baseImplementation.orElse(this).
- // The current state of the world is a little confusing and maybe not intuitive: the base
- // implementation has no base implementation, but it _is_ a base implementation.
- return Optional.of(componentImplementation.baseImplementation().orElse(componentImplementation))
- .map(baseImplementation -> elements.getTypeElement(baseImplementation.name()))
- // If this returns null, the type has not been generated yet and Optional will switch to an
- // empty state. This means that we're currently generating componentImplementation, or that
- // the base implementation is being generated in this round, and thus the options passed to
- // this compilation are applicable
- .map(typeElement -> typeElement.getAnnotation(GenerationOptions.class))
- .map(defaultOptions::withGenerationOptions)
- .orElse(defaultOptions);
- }
-}
diff --git a/java/dagger/internal/codegen/GwtCompatibility.java b/java/dagger/internal/codegen/GwtCompatibility.java
deleted file mode 100644
index 34d8f6d..0000000
--- a/java/dagger/internal/codegen/GwtCompatibility.java
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkArgument;
-
-import com.squareup.javapoet.AnnotationSpec;
-import java.util.Optional;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.Name;
-
-final class GwtCompatibility {
-
- /**
- * Returns a {@code @GwtIncompatible} annotation that is applied to {@code binding}'s {@link
- * Binding#bindingElement()} or any enclosing type.
- */
- static Optional<AnnotationSpec> gwtIncompatibleAnnotation(Binding binding) {
- checkArgument(binding.bindingElement().isPresent());
- Element element = binding.bindingElement().get();
- while (element != null) {
- Optional<AnnotationSpec> gwtIncompatible =
- element
- .getAnnotationMirrors()
- .stream()
- .filter(annotation -> isGwtIncompatible(annotation))
- .map(AnnotationSpec::get)
- .findFirst();
- if (gwtIncompatible.isPresent()) {
- return gwtIncompatible;
- }
- element = element.getEnclosingElement();
- }
- return Optional.empty();
- }
-
- private static boolean isGwtIncompatible(AnnotationMirror annotation) {
- Name simpleName = annotation.getAnnotationType().asElement().getSimpleName();
- return simpleName.contentEquals("GwtIncompatible");
- }
-}
diff --git a/java/dagger/internal/codegen/HjarSourceFileGenerator.java b/java/dagger/internal/codegen/HjarSourceFileGenerator.java
deleted file mode 100644
index 5c36322..0000000
--- a/java/dagger/internal/codegen/HjarSourceFileGenerator.java
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.squareup.javapoet.MethodSpec.constructorBuilder;
-import static com.squareup.javapoet.MethodSpec.methodBuilder;
-import static com.squareup.javapoet.TypeSpec.classBuilder;
-import static javax.lang.model.element.Modifier.PRIVATE;
-
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.FieldSpec;
-import com.squareup.javapoet.MethodSpec;
-import com.squareup.javapoet.TypeSpec;
-import java.util.Optional;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.Modifier;
-
-/**
- * A source file generator that only writes the relevant code necessary for Bazel to create a
- * correct header (ABI) jar.
- */
-final class HjarSourceFileGenerator<T> extends SourceFileGenerator<T> {
- private final SourceFileGenerator<T> delegate;
-
- private HjarSourceFileGenerator(SourceFileGenerator<T> delegate) {
- super(delegate);
- this.delegate = delegate;
- }
-
- static <T> SourceFileGenerator<T> wrap(SourceFileGenerator<T> delegate) {
- return new HjarSourceFileGenerator<>(delegate);
- }
-
- @Override
- ClassName nameGeneratedType(T input) {
- return delegate.nameGeneratedType(input);
- }
-
- @Override
- Element originatingElement(T input) {
- return delegate.originatingElement(input);
- }
-
- @Override
- Optional<TypeSpec.Builder> write(ClassName generatedTypeName, T input) {
- return delegate
- .write(generatedTypeName, input)
- .map(completeType -> skeletonType(completeType.build()));
- }
-
- private TypeSpec.Builder skeletonType(TypeSpec completeType) {
- TypeSpec.Builder skeleton =
- classBuilder(completeType.name)
- .addSuperinterfaces(completeType.superinterfaces)
- .addTypeVariables(completeType.typeVariables)
- .addModifiers(completeType.modifiers.toArray(new Modifier[0]))
- .addAnnotations(completeType.annotations);
-
- if (!completeType.superclass.equals(ClassName.OBJECT)) {
- skeleton.superclass(completeType.superclass);
- }
-
- completeType.methodSpecs.stream()
- .filter(method -> !method.modifiers.contains(PRIVATE) || method.isConstructor())
- .map(this::skeletonMethod)
- .forEach(skeleton::addMethod);
-
- completeType.fieldSpecs.stream()
- .filter(field -> !field.modifiers.contains(PRIVATE))
- .map(this::skeletonField)
- .forEach(skeleton::addField);
-
- completeType.typeSpecs.stream()
- .map(type -> skeletonType(type).build())
- .forEach(skeleton::addType);
-
- return skeleton;
- }
-
- private MethodSpec skeletonMethod(MethodSpec completeMethod) {
- MethodSpec.Builder skeleton =
- completeMethod.isConstructor()
- ? constructorBuilder()
- : methodBuilder(completeMethod.name).returns(completeMethod.returnType);
-
- if (completeMethod.isConstructor()) {
- // Code in Turbine must (for technical reasons in javac) have a valid super() call for
- // constructors, otherwise javac will bark, and Turbine has no way to avoid this. So we retain
- // constructor method bodies if they do exist
- skeleton.addCode(completeMethod.code);
- }
-
- return skeleton
- .addModifiers(completeMethod.modifiers)
- .addTypeVariables(completeMethod.typeVariables)
- .addParameters(completeMethod.parameters)
- .addExceptions(completeMethod.exceptions)
- .varargs(completeMethod.varargs)
- .addAnnotations(completeMethod.annotations)
- .build();
- }
-
- private FieldSpec skeletonField(FieldSpec completeField) {
- return FieldSpec.builder(
- completeField.type,
- completeField.name,
- completeField.modifiers.toArray(new Modifier[0]))
- .addAnnotations(completeField.annotations)
- .build();
- }
-}
diff --git a/java/dagger/internal/codegen/ImmediateFutureBindingExpression.java b/java/dagger/internal/codegen/ImmediateFutureBindingExpression.java
deleted file mode 100644
index 69b107c..0000000
--- a/java/dagger/internal/codegen/ImmediateFutureBindingExpression.java
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static dagger.internal.codegen.BindingRequest.bindingRequest;
-
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import dagger.internal.codegen.javapoet.Expression;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.Key;
-import dagger.model.RequestKind;
-import javax.lang.model.SourceVersion;
-
-final class ImmediateFutureBindingExpression extends BindingExpression {
-
- private final ComponentBindingExpressions componentBindingExpressions;
- private final DaggerTypes types;
- private final SourceVersion sourceVersion;
- private final Key key;
-
- ImmediateFutureBindingExpression(
- ResolvedBindings resolvedBindings,
- ComponentBindingExpressions componentBindingExpressions,
- DaggerTypes types,
- SourceVersion sourceVersion) {
- this.componentBindingExpressions = checkNotNull(componentBindingExpressions);
- this.types = checkNotNull(types);
- this.sourceVersion = checkNotNull(sourceVersion);
- this.key = resolvedBindings.key();
- }
-
- @Override
- Expression getDependencyExpression(ClassName requestingClass) {
- return Expression.create(
- types.wrapType(key.type(), ListenableFuture.class),
- CodeBlock.of("$T.immediateFuture($L)", Futures.class, instanceExpression(requestingClass)));
- }
-
- private CodeBlock instanceExpression(ClassName requestingClass) {
- Expression expression =
- componentBindingExpressions.getDependencyExpression(
- bindingRequest(key, RequestKind.INSTANCE), requestingClass);
- if (sourceVersion.compareTo(SourceVersion.RELEASE_7) <= 0) {
- // Java 7 type inference is not as strong as in Java 8, and therefore some generated code must
- // cast.
- //
- // For example, javac7 cannot detect that Futures.immediateFuture(ImmutableSet.of("T"))
- // can safely be assigned to ListenableFuture<Set<T>>.
- if (!types.isSameType(expression.type(), key.type())) {
- return CodeBlock.of(
- "($T) $L", types.accessibleType(key.type(), requestingClass), expression.codeBlock());
- }
- }
- return expression.codeBlock();
- }
-}
diff --git a/java/dagger/internal/codegen/InaccessibleMapKeyProxyGenerator.java b/java/dagger/internal/codegen/InaccessibleMapKeyProxyGenerator.java
deleted file mode 100644
index 19c4d19..0000000
--- a/java/dagger/internal/codegen/InaccessibleMapKeyProxyGenerator.java
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.squareup.javapoet.MethodSpec.constructorBuilder;
-import static com.squareup.javapoet.TypeSpec.classBuilder;
-import static javax.lang.model.element.Modifier.FINAL;
-import static javax.lang.model.element.Modifier.PRIVATE;
-import static javax.lang.model.element.Modifier.PUBLIC;
-
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.TypeSpec;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import java.util.Optional;
-import javax.annotation.processing.Filer;
-import javax.inject.Inject;
-import javax.lang.model.SourceVersion;
-import javax.lang.model.element.Element;
-
-/**
- * Generates a class that exposes a non-{@code public} {@link
- * ContributionBinding#mapKeyAnnotation()} @MapKey} annotation.
- */
-final class InaccessibleMapKeyProxyGenerator extends SourceFileGenerator<ContributionBinding> {
- private final DaggerTypes types;
- private final DaggerElements elements;
-
- @Inject
- InaccessibleMapKeyProxyGenerator(
- Filer filer, DaggerTypes types, DaggerElements elements, SourceVersion sourceVersion) {
- super(filer, elements, sourceVersion);
- this.types = types;
- this.elements = elements;
- }
-
- @Override
- ClassName nameGeneratedType(ContributionBinding binding) {
- return MapKeys.mapKeyProxyClassName(binding);
- }
-
- @Override
- Element originatingElement(ContributionBinding binding) {
- // a map key is only ever present on bindings that have a binding element
- return binding.bindingElement().get();
- }
-
- @Override
- Optional<TypeSpec.Builder> write(ClassName generatedName, ContributionBinding binding) {
- return MapKeys.mapKeyFactoryMethod(binding, types, elements)
- .map(
- method ->
- classBuilder(generatedName)
- .addModifiers(PUBLIC, FINAL)
- .addMethod(constructorBuilder().addModifiers(PRIVATE).build())
- .addMethod(method));
- }
-}
diff --git a/java/dagger/internal/codegen/IncompatiblyScopedBindingsValidator.java b/java/dagger/internal/codegen/IncompatiblyScopedBindingsValidator.java
deleted file mode 100644
index d649e46..0000000
--- a/java/dagger/internal/codegen/IncompatiblyScopedBindingsValidator.java
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.Formatter.INDENT;
-import static dagger.internal.codegen.Scopes.getReadableSource;
-import static dagger.internal.codegen.langmodel.DaggerElements.closestEnclosingTypeElement;
-import static dagger.model.BindingKind.INJECTION;
-import static java.util.stream.Collectors.joining;
-import static javax.tools.Diagnostic.Kind.ERROR;
-
-import com.google.auto.common.MoreElements;
-import com.google.common.collect.ImmutableSetMultimap;
-import com.google.common.collect.Multimaps;
-import dagger.model.Binding;
-import dagger.model.BindingGraph;
-import dagger.model.BindingGraph.ComponentNode;
-import dagger.spi.BindingGraphPlugin;
-import dagger.spi.DiagnosticReporter;
-import java.util.Optional;
-import java.util.Set;
-import javax.inject.Inject;
-import javax.tools.Diagnostic;
-
-/**
- * Reports an error for any component that uses bindings with scopes that are not assigned to the
- * component.
- */
-final class IncompatiblyScopedBindingsValidator implements BindingGraphPlugin {
-
- private final MethodSignatureFormatter methodSignatureFormatter;
- private final CompilerOptions compilerOptions;
-
- @Inject
- IncompatiblyScopedBindingsValidator(
- MethodSignatureFormatter methodSignatureFormatter, CompilerOptions compilerOptions) {
- this.methodSignatureFormatter = methodSignatureFormatter;
- this.compilerOptions = compilerOptions;
- }
-
- @Override
- public String pluginName() {
- return "Dagger/IncompatiblyScopedBindings";
- }
-
- @Override
- public void visitGraph(BindingGraph bindingGraph, DiagnosticReporter diagnosticReporter) {
- ImmutableSetMultimap.Builder<ComponentNode, dagger.model.Binding> incompatibleBindings =
- ImmutableSetMultimap.builder();
- for (dagger.model.Binding binding : bindingGraph.bindings()) {
- binding
- .scope()
- .filter(scope -> !scope.isReusable())
- .ifPresent(
- scope -> {
- ComponentNode componentNode =
- bindingGraph.componentNode(binding.componentPath()).get();
- if (!componentNode.scopes().contains(scope)) {
- // @Inject bindings in module or subcomponent binding graphs will appear at the
- // properly scoped ancestor component, so ignore them here.
- if (binding.kind().equals(INJECTION)
- && (bindingGraph.rootComponentNode().isSubcomponent()
- || !bindingGraph.rootComponentNode().isRealComponent())) {
- return;
- }
- incompatibleBindings.put(componentNode, binding);
- }
- });
- }
- Multimaps.asMap(incompatibleBindings.build())
- .forEach((componentNode, bindings) -> report(componentNode, bindings, diagnosticReporter));
- }
-
- private void report(
- ComponentNode componentNode,
- Set<Binding> bindings,
- DiagnosticReporter diagnosticReporter) {
- Diagnostic.Kind diagnosticKind = ERROR;
- StringBuilder message =
- new StringBuilder(componentNode.componentPath().currentComponent().getQualifiedName());
-
- if (!componentNode.isRealComponent()) {
- // If the "component" is really a module, it will have no scopes attached. We want to report
- // if there is more than one scope in that component.
- if (bindings.stream().map(Binding::scope).map(Optional::get).distinct().count() <= 1) {
- return;
- }
- message.append(" contains bindings with different scopes:");
- diagnosticKind = compilerOptions.moduleHasDifferentScopesDiagnosticKind();
- } else if (componentNode.scopes().isEmpty()) {
- message.append(" (unscoped) may not reference scoped bindings:");
- } else {
- message
- .append(" scoped with ")
- .append(
- componentNode.scopes().stream().map(Scopes::getReadableSource).collect(joining(" ")))
- .append(" may not reference bindings with different scopes:");
- }
-
- // TODO(ronshapiro): Should we group by scope?
- for (Binding binding : bindings) {
- message.append('\n').append(INDENT);
-
- // TODO(dpb): Use BindingDeclarationFormatter.
- // But that doesn't print scopes for @Inject-constructed types.
- switch (binding.kind()) {
- case DELEGATE:
- case PROVISION:
- message.append(
- methodSignatureFormatter.format(
- MoreElements.asExecutable(binding.bindingElement().get())));
- break;
-
- case INJECTION:
- message
- .append(getReadableSource(binding.scope().get()))
- .append(" class ")
- .append(
- closestEnclosingTypeElement(binding.bindingElement().get()).getQualifiedName());
- break;
-
- default:
- throw new AssertionError(binding);
- }
- }
- diagnosticReporter.reportComponent(diagnosticKind, componentNode, message.toString());
- }
-}
diff --git a/java/dagger/internal/codegen/InjectBindingRegistry.java b/java/dagger/internal/codegen/InjectBindingRegistry.java
deleted file mode 100644
index 2840d75..0000000
--- a/java/dagger/internal/codegen/InjectBindingRegistry.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import com.google.errorprone.annotations.CanIgnoreReturnValue;
-import dagger.Component;
-import dagger.Provides;
-import dagger.model.Key;
-import java.util.Optional;
-import javax.inject.Inject;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-
-/**
- * Maintains the collection of provision bindings from {@link Inject} constructors and members
- * injection bindings from {@link Inject} fields and methods known to the annotation processor. Note
- * that this registry <b>does not</b> handle any explicit bindings (those from {@link Provides}
- * methods, {@link Component} dependencies, etc.).
- */
-interface InjectBindingRegistry {
- /**
- * Returns a {@link ProvisionBinding} for {@code key}. If none has been registered yet, registers
- * one.
- */
- Optional<ProvisionBinding> getOrFindProvisionBinding(Key key);
-
- /**
- * Returns a {@link MembersInjectionBinding} for {@code key}. If none has been registered yet,
- * registers one, along with all necessary members injection bindings for superclasses.
- */
- Optional<MembersInjectionBinding> getOrFindMembersInjectionBinding(Key key);
-
- /**
- * Returns a {@link ProvisionBinding} for a {@link dagger.MembersInjector} of {@code key}. If none
- * has been registered yet, registers one.
- */
- Optional<ProvisionBinding> getOrFindMembersInjectorProvisionBinding(Key key);
-
- @CanIgnoreReturnValue
- Optional<ProvisionBinding> tryRegisterConstructor(ExecutableElement constructorElement);
-
- @CanIgnoreReturnValue
- Optional<MembersInjectionBinding> tryRegisterMembersInjectedType(TypeElement typeElement);
-
- /**
- * This method ensures that sources for all registered {@link Binding bindings} (either explicitly
- * or implicitly via {@link #getOrFindMembersInjectionBinding} or {@link
- * #getOrFindProvisionBinding}) are generated.
- */
- void generateSourcesForRequiredBindings(
- SourceFileGenerator<ProvisionBinding> factoryGenerator,
- SourceFileGenerator<MembersInjectionBinding> membersInjectorGenerator)
- throws SourceFileGenerationException;
-}
diff --git a/java/dagger/internal/codegen/InjectBindingRegistryImpl.java b/java/dagger/internal/codegen/InjectBindingRegistryImpl.java
deleted file mode 100644
index 45dc391..0000000
--- a/java/dagger/internal/codegen/InjectBindingRegistryImpl.java
+++ /dev/null
@@ -1,340 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.base.Preconditions.checkState;
-import static dagger.internal.codegen.InjectionAnnotations.injectedConstructors;
-import static dagger.internal.codegen.Keys.isValidImplicitProvisionKey;
-import static dagger.internal.codegen.Keys.isValidMembersInjectionKey;
-import static dagger.internal.codegen.SourceFiles.generatedClassNameForBinding;
-
-import com.google.auto.common.MoreElements;
-import com.google.auto.common.MoreTypes;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
-import com.google.errorprone.annotations.CanIgnoreReturnValue;
-import com.squareup.javapoet.ClassName;
-import dagger.Component;
-import dagger.MembersInjector;
-import dagger.Provides;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.Key;
-import java.util.ArrayDeque;
-import java.util.Deque;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
-import javax.annotation.processing.Messager;
-import javax.inject.Inject;
-import javax.inject.Provider;
-import javax.inject.Singleton;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.TypeMirror;
-import javax.tools.Diagnostic.Kind;
-
-/**
- * Maintains the collection of provision bindings from {@link Inject} constructors and members
- * injection bindings from {@link Inject} fields and methods known to the annotation processor.
- * Note that this registry <b>does not</b> handle any explicit bindings (those from {@link Provides}
- * methods, {@link Component} dependencies, etc.).
- */
-@Singleton
-final class InjectBindingRegistryImpl implements InjectBindingRegistry {
- private final DaggerElements elements;
- private final DaggerTypes types;
- private final Messager messager;
- private final InjectValidator injectValidator;
- private final InjectValidator injectValidatorWhenGeneratingCode;
- private final KeyFactory keyFactory;
- private final BindingFactory bindingFactory;
- private final CompilerOptions compilerOptions;
-
- final class BindingsCollection<B extends Binding> {
- private final Class<?> factoryClass;
- private final Map<Key, B> bindingsByKey = Maps.newLinkedHashMap();
- private final Deque<B> bindingsRequiringGeneration = new ArrayDeque<>();
- private final Set<Key> materializedBindingKeys = Sets.newLinkedHashSet();
-
- BindingsCollection(Class<?> factoryClass) {
- this.factoryClass = factoryClass;
- }
-
- void generateBindings(SourceFileGenerator<B> generator) throws SourceFileGenerationException {
- for (B binding = bindingsRequiringGeneration.poll();
- binding != null;
- binding = bindingsRequiringGeneration.poll()) {
- checkState(!binding.unresolved().isPresent());
- if (injectValidatorWhenGeneratingCode.isValidType(binding.key().type())) {
- generator.generate(binding);
- }
- materializedBindingKeys.add(binding.key());
- }
- // Because Elements instantiated across processing rounds are not guaranteed to be equals() to
- // the logically same element, clear the cache after generating
- bindingsByKey.clear();
- }
-
- /** Returns a previously cached binding. */
- B getBinding(Key key) {
- return bindingsByKey.get(key);
- }
-
- /** Caches the binding and generates it if it needs generation. */
- void tryRegisterBinding(B binding, boolean warnIfNotAlreadyGenerated) {
- tryToCacheBinding(binding);
- tryToGenerateBinding(binding, warnIfNotAlreadyGenerated);
- }
-
- /**
- * Tries to generate a binding, not generating if it already is generated. For resolved
- * bindings, this will try to generate the unresolved version of the binding.
- */
- void tryToGenerateBinding(B binding, boolean warnIfNotAlreadyGenerated) {
- if (shouldGenerateBinding(binding, generatedClassNameForBinding(binding))) {
- bindingsRequiringGeneration.offer(binding);
- if (compilerOptions.warnIfInjectionFactoryNotGeneratedUpstream()
- && warnIfNotAlreadyGenerated) {
- messager.printMessage(
- Kind.NOTE,
- String.format(
- "Generating a %s for %s. "
- + "Prefer to run the dagger processor over that class instead.",
- factoryClass.getSimpleName(),
- types.erasure(binding.key().type()))); // erasure to strip <T> from msgs.
- }
- }
- }
-
- /** Returns true if the binding needs to be generated. */
- private boolean shouldGenerateBinding(B binding, ClassName factoryName) {
- return !binding.unresolved().isPresent()
- && !materializedBindingKeys.contains(binding.key())
- && !bindingsRequiringGeneration.contains(binding)
- && elements.getTypeElement(factoryName) == null;
- }
-
- /** Caches the binding for future lookups by key. */
- private void tryToCacheBinding(B binding) {
- // We only cache resolved bindings or unresolved bindings w/o type arguments.
- // Unresolved bindings w/ type arguments aren't valid for the object graph.
- if (binding.unresolved().isPresent()
- || binding.bindingTypeElement().get().getTypeParameters().isEmpty()) {
- Key key = binding.key();
- Binding previousValue = bindingsByKey.put(key, binding);
- checkState(previousValue == null || binding.equals(previousValue),
- "couldn't register %s. %s was already registered for %s",
- binding, previousValue, key);
- }
- }
- }
-
- private final BindingsCollection<ProvisionBinding> provisionBindings =
- new BindingsCollection<>(Provider.class);
- private final BindingsCollection<MembersInjectionBinding> membersInjectionBindings =
- new BindingsCollection<>(MembersInjector.class);
-
- @Inject
- InjectBindingRegistryImpl(
- DaggerElements elements,
- DaggerTypes types,
- Messager messager,
- InjectValidator injectValidator,
- KeyFactory keyFactory,
- BindingFactory bindingFactory,
- CompilerOptions compilerOptions) {
- this.elements = elements;
- this.types = types;
- this.messager = messager;
- this.injectValidator = injectValidator;
- this.injectValidatorWhenGeneratingCode = injectValidator.whenGeneratingCode();
- this.keyFactory = keyFactory;
- this.bindingFactory = bindingFactory;
- this.compilerOptions = compilerOptions;
- }
-
- // TODO(dpb): make the SourceFileGenerators fields so they don't have to be passed in
- @Override
- public void generateSourcesForRequiredBindings(
- SourceFileGenerator<ProvisionBinding> factoryGenerator,
- SourceFileGenerator<MembersInjectionBinding> membersInjectorGenerator)
- throws SourceFileGenerationException {
- provisionBindings.generateBindings(factoryGenerator);
- membersInjectionBindings.generateBindings(membersInjectorGenerator);
- }
-
- /**
- * Registers the binding for generation and later lookup. If the binding is resolved, we also
- * attempt to register an unresolved version of it.
- */
- private void registerBinding(ProvisionBinding binding, boolean warnIfNotAlreadyGenerated) {
- provisionBindings.tryRegisterBinding(binding, warnIfNotAlreadyGenerated);
- if (binding.unresolved().isPresent()) {
- provisionBindings.tryToGenerateBinding(binding.unresolved().get(), warnIfNotAlreadyGenerated);
- }
- }
-
- /**
- * Registers the binding for generation and later lookup. If the binding is resolved, we also
- * attempt to register an unresolved version of it.
- */
- private void registerBinding(MembersInjectionBinding binding, boolean warnIfNotAlreadyGenerated) {
- /*
- * We generate MembersInjector classes for types with @Inject constructors only if they have any
- * injection sites.
- *
- * We generate MembersInjector classes for types without @Inject constructors only if they have
- * local (non-inherited) injection sites.
- *
- * Warn only when registering bindings post-hoc for those types.
- */
- warnIfNotAlreadyGenerated =
- warnIfNotAlreadyGenerated
- && (!injectedConstructors(binding.membersInjectedType()).isEmpty()
- ? !binding.injectionSites().isEmpty()
- : binding.hasLocalInjectionSites());
- membersInjectionBindings.tryRegisterBinding(binding, warnIfNotAlreadyGenerated);
- if (binding.unresolved().isPresent()) {
- membersInjectionBindings.tryToGenerateBinding(
- binding.unresolved().get(), warnIfNotAlreadyGenerated);
- }
- }
-
- @Override
- public Optional<ProvisionBinding> tryRegisterConstructor(ExecutableElement constructorElement) {
- return tryRegisterConstructor(constructorElement, Optional.empty(), false);
- }
-
- @CanIgnoreReturnValue
- private Optional<ProvisionBinding> tryRegisterConstructor(
- ExecutableElement constructorElement,
- Optional<TypeMirror> resolvedType,
- boolean warnIfNotAlreadyGenerated) {
- TypeElement typeElement = MoreElements.asType(constructorElement.getEnclosingElement());
- DeclaredType type = MoreTypes.asDeclared(typeElement.asType());
- Key key = keyFactory.forInjectConstructorWithResolvedType(type);
- ProvisionBinding cachedBinding = provisionBindings.getBinding(key);
- if (cachedBinding != null) {
- return Optional.of(cachedBinding);
- }
-
- ValidationReport<TypeElement> report = injectValidator.validateConstructor(constructorElement);
- report.printMessagesTo(messager);
- if (report.isClean()) {
- ProvisionBinding binding = bindingFactory.injectionBinding(constructorElement, resolvedType);
- registerBinding(binding, warnIfNotAlreadyGenerated);
- if (!binding.injectionSites().isEmpty()) {
- tryRegisterMembersInjectedType(typeElement, resolvedType, warnIfNotAlreadyGenerated);
- }
- return Optional.of(binding);
- }
- return Optional.empty();
- }
-
- @Override
- public Optional<MembersInjectionBinding> tryRegisterMembersInjectedType(TypeElement typeElement) {
- return tryRegisterMembersInjectedType(typeElement, Optional.empty(), false);
- }
-
- @CanIgnoreReturnValue
- private Optional<MembersInjectionBinding> tryRegisterMembersInjectedType(
- TypeElement typeElement,
- Optional<TypeMirror> resolvedType,
- boolean warnIfNotAlreadyGenerated) {
- DeclaredType type = MoreTypes.asDeclared(typeElement.asType());
- Key key = keyFactory.forInjectConstructorWithResolvedType(type);
- MembersInjectionBinding cachedBinding = membersInjectionBindings.getBinding(key);
- if (cachedBinding != null) {
- return Optional.of(cachedBinding);
- }
-
- ValidationReport<TypeElement> report =
- injectValidator.validateMembersInjectionType(typeElement);
- report.printMessagesTo(messager);
- if (report.isClean()) {
- MembersInjectionBinding binding = bindingFactory.membersInjectionBinding(type, resolvedType);
- registerBinding(binding, warnIfNotAlreadyGenerated);
- for (Optional<DeclaredType> supertype = types.nonObjectSuperclass(type);
- supertype.isPresent();
- supertype = types.nonObjectSuperclass(supertype.get())) {
- getOrFindMembersInjectionBinding(keyFactory.forMembersInjectedType(supertype.get()));
- }
- return Optional.of(binding);
- }
- return Optional.empty();
- }
-
- @CanIgnoreReturnValue
- @Override
- public Optional<ProvisionBinding> getOrFindProvisionBinding(Key key) {
- checkNotNull(key);
- if (!isValidImplicitProvisionKey(key, types)) {
- return Optional.empty();
- }
- ProvisionBinding binding = provisionBindings.getBinding(key);
- if (binding != null) {
- return Optional.of(binding);
- }
-
- // ok, let's see if we can find an @Inject constructor
- TypeElement element = MoreElements.asType(types.asElement(key.type()));
- ImmutableSet<ExecutableElement> injectConstructors = injectedConstructors(element);
- switch (injectConstructors.size()) {
- case 0:
- // No constructor found.
- return Optional.empty();
- case 1:
- return tryRegisterConstructor(
- Iterables.getOnlyElement(injectConstructors), Optional.of(key.type()), true);
- default:
- throw new IllegalStateException("Found multiple @Inject constructors: "
- + injectConstructors);
- }
- }
-
- @CanIgnoreReturnValue
- @Override
- public Optional<MembersInjectionBinding> getOrFindMembersInjectionBinding(Key key) {
- checkNotNull(key);
- // TODO(gak): is checking the kind enough?
- checkArgument(isValidMembersInjectionKey(key));
- MembersInjectionBinding binding = membersInjectionBindings.getBinding(key);
- if (binding != null) {
- return Optional.of(binding);
- }
- Optional<MembersInjectionBinding> newBinding =
- tryRegisterMembersInjectedType(
- MoreTypes.asTypeElement(key.type()), Optional.of(key.type()), true);
- return newBinding;
- }
-
- @Override
- public Optional<ProvisionBinding> getOrFindMembersInjectorProvisionBinding(Key key) {
- if (!isValidMembersInjectionKey(key)) {
- return Optional.empty();
- }
- Key membersInjectionKey = keyFactory.forMembersInjectedType(types.unwrapType(key.type()));
- return getOrFindMembersInjectionBinding(membersInjectionKey)
- .map(binding -> bindingFactory.membersInjectorBinding(key, binding));
- }
-}
diff --git a/java/dagger/internal/codegen/InjectBindingRegistryModule.java b/java/dagger/internal/codegen/InjectBindingRegistryModule.java
deleted file mode 100644
index 4563362..0000000
--- a/java/dagger/internal/codegen/InjectBindingRegistryModule.java
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import dagger.Binds;
-import dagger.Module;
-
-@Module
-interface InjectBindingRegistryModule {
- @Binds
- InjectBindingRegistry injectBindingRegistry(InjectBindingRegistryImpl impl);
-}
diff --git a/java/dagger/internal/codegen/InjectBindingValidator.java b/java/dagger/internal/codegen/InjectBindingValidator.java
deleted file mode 100644
index 183d162..0000000
--- a/java/dagger/internal/codegen/InjectBindingValidator.java
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.model.BindingKind.INJECTION;
-
-import com.google.auto.common.MoreTypes;
-import dagger.internal.codegen.ValidationReport.Item;
-import dagger.model.BindingGraph;
-import dagger.spi.BindingGraphPlugin;
-import dagger.spi.DiagnosticReporter;
-import javax.inject.Inject;
-import javax.lang.model.element.TypeElement;
-
-/** Validates bindings from {@code @Inject}-annotated constructors. */
-final class InjectBindingValidator implements BindingGraphPlugin {
-
- private final InjectValidator injectValidator;
-
- @Inject
- InjectBindingValidator(InjectValidator injectValidator) {
- this.injectValidator = injectValidator.whenGeneratingCode();
- }
-
- @Override
- public String pluginName() {
- return "Dagger/InjectBinding";
- }
-
- @Override
- public void visitGraph(BindingGraph bindingGraph, DiagnosticReporter diagnosticReporter) {
- bindingGraph.bindings().stream()
- .filter(binding -> binding.kind().equals(INJECTION)) // TODO(dpb): Move to BindingGraph
- .forEach(binding -> validateInjectionBinding(binding, diagnosticReporter));
- }
-
- private void validateInjectionBinding(
- dagger.model.Binding node, DiagnosticReporter diagnosticReporter) {
- ValidationReport<TypeElement> typeReport =
- injectValidator.validateType(MoreTypes.asTypeElement(node.key().type()));
- for (Item item : typeReport.allItems()) {
- diagnosticReporter.reportBinding(item.kind(), node, item.message());
- }
- }
-}
diff --git a/java/dagger/internal/codegen/InjectProcessingStep.java b/java/dagger/internal/codegen/InjectProcessingStep.java
index be8c975..5374592 100644
--- a/java/dagger/internal/codegen/InjectProcessingStep.java
+++ b/java/dagger/internal/codegen/InjectProcessingStep.java
@@ -18,6 +18,10 @@
import com.google.auto.common.MoreElements;
import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import dagger.assisted.AssistedInject;
+import dagger.internal.codegen.binding.InjectBindingRegistry;
+import dagger.internal.codegen.validation.TypeCheckingProcessingStep;
import java.lang.annotation.Annotation;
import java.util.Set;
import javax.inject.Inject;
@@ -34,6 +38,7 @@
// TODO(gak): add some error handling for bad source files
final class InjectProcessingStep extends TypeCheckingProcessingStep<Element> {
private final ElementVisitor<Void, Void> visitor;
+ private final Set<Element> processedElements = Sets.newLinkedHashSet();
@Inject
InjectProcessingStep(InjectBindingRegistry injectBindingRegistry) {
@@ -65,12 +70,20 @@
@Override
public Set<Class<? extends Annotation>> annotations() {
- return ImmutableSet.of(Inject.class);
+ return ImmutableSet.of(Inject.class, AssistedInject.class);
}
@Override
protected void process(
Element injectElement, ImmutableSet<Class<? extends Annotation>> annotations) {
+ // Only process an element once to avoid getting duplicate errors when an element is annotated
+ // with multiple inject annotations.
+ if (processedElements.contains(injectElement)) {
+ return;
+ }
+
injectElement.accept(visitor, null);
+
+ processedElements.add(injectElement);
}
}
diff --git a/java/dagger/internal/codegen/InjectValidator.java b/java/dagger/internal/codegen/InjectValidator.java
deleted file mode 100644
index d3c4ce8..0000000
--- a/java/dagger/internal/codegen/InjectValidator.java
+++ /dev/null
@@ -1,332 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreElements.isAnnotationPresent;
-import static dagger.internal.codegen.InjectionAnnotations.getQualifiers;
-import static dagger.internal.codegen.InjectionAnnotations.injectedConstructors;
-import static dagger.internal.codegen.Scopes.scopesOf;
-import static javax.lang.model.element.Modifier.ABSTRACT;
-import static javax.lang.model.element.Modifier.FINAL;
-import static javax.lang.model.element.Modifier.PRIVATE;
-import static javax.lang.model.element.Modifier.STATIC;
-import static javax.lang.model.type.TypeKind.DECLARED;
-
-import com.google.auto.common.MoreElements;
-import com.google.auto.common.MoreTypes;
-import com.google.common.collect.ImmutableSet;
-import dagger.internal.codegen.langmodel.Accessibility;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.Scope;
-import java.util.Optional;
-import java.util.Set;
-import javax.inject.Inject;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.Modifier;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.element.VariableElement;
-import javax.lang.model.type.TypeKind;
-import javax.lang.model.type.TypeMirror;
-import javax.lang.model.util.ElementFilter;
-import javax.tools.Diagnostic;
-import javax.tools.Diagnostic.Kind;
-
-/**
- * A {@linkplain ValidationReport validator} for {@link Inject}-annotated elements and the types
- * that contain them.
- */
-final class InjectValidator {
- private final DaggerTypes types;
- private final DaggerElements elements;
- private final CompilerOptions compilerOptions;
- private final DependencyRequestValidator dependencyRequestValidator;
- private final Optional<Diagnostic.Kind> privateAndStaticInjectionDiagnosticKind;
-
- @Inject
- InjectValidator(
- DaggerTypes types,
- DaggerElements elements,
- DependencyRequestValidator dependencyRequestValidator,
- CompilerOptions compilerOptions) {
- this(types, elements, compilerOptions, dependencyRequestValidator, Optional.empty());
- }
-
- private InjectValidator(
- DaggerTypes types,
- DaggerElements elements,
- CompilerOptions compilerOptions,
- DependencyRequestValidator dependencyRequestValidator,
- Optional<Kind> privateAndStaticInjectionDiagnosticKind) {
- this.types = types;
- this.elements = elements;
- this.compilerOptions = compilerOptions;
- this.dependencyRequestValidator = dependencyRequestValidator;
- this.privateAndStaticInjectionDiagnosticKind = privateAndStaticInjectionDiagnosticKind;
- }
-
- /**
- * Returns a new validator that performs the same validation as this one, but is strict about
- * rejecting optionally-specified JSR 330 behavior that Dagger doesn't support (unless {@code
- * -Adagger.ignorePrivateAndStaticInjectionForComponent=enabled} was set in the javac options).
- */
- InjectValidator whenGeneratingCode() {
- return compilerOptions.ignorePrivateAndStaticInjectionForComponent()
- ? this
- : new InjectValidator(
- types,
- elements,
- compilerOptions,
- dependencyRequestValidator,
- Optional.of(Diagnostic.Kind.ERROR));
- }
-
- ValidationReport<TypeElement> validateConstructor(ExecutableElement constructorElement) {
- ValidationReport.Builder<TypeElement> builder =
- ValidationReport.about(MoreElements.asType(constructorElement.getEnclosingElement()));
- if (constructorElement.getModifiers().contains(PRIVATE)) {
- builder.addError(
- "Dagger does not support injection into private constructors", constructorElement);
- }
-
- for (AnnotationMirror qualifier : getQualifiers(constructorElement)) {
- builder.addError(
- "@Qualifier annotations are not allowed on @Inject constructors",
- constructorElement,
- qualifier);
- }
-
- for (Scope scope : scopesOf(constructorElement)) {
- builder.addError(
- "@Scope annotations are not allowed on @Inject constructors; annotate the class instead",
- constructorElement,
- scope.scopeAnnotation());
- }
-
- for (VariableElement parameter : constructorElement.getParameters()) {
- validateDependencyRequest(builder, parameter);
- }
-
- if (throwsCheckedExceptions(constructorElement)) {
- builder.addItem(
- "Dagger does not support checked exceptions on @Inject constructors",
- privateMemberDiagnosticKind(),
- constructorElement);
- }
-
- checkInjectIntoPrivateClass(constructorElement, builder);
-
- TypeElement enclosingElement =
- MoreElements.asType(constructorElement.getEnclosingElement());
-
- Set<Modifier> typeModifiers = enclosingElement.getModifiers();
- if (typeModifiers.contains(ABSTRACT)) {
- builder.addError(
- "@Inject is nonsense on the constructor of an abstract class", constructorElement);
- }
-
- if (enclosingElement.getNestingKind().isNested()
- && !typeModifiers.contains(STATIC)) {
- builder.addError(
- "@Inject constructors are invalid on inner classes. "
- + "Did you mean to make the class static?",
- constructorElement);
- }
-
- // This is computationally expensive, but probably preferable to a giant index
- ImmutableSet<ExecutableElement> injectConstructors = injectedConstructors(enclosingElement);
-
- if (injectConstructors.size() > 1) {
- builder.addError("Types may only contain one @Inject constructor", constructorElement);
- }
-
- ImmutableSet<Scope> scopes = scopesOf(enclosingElement);
- if (scopes.size() > 1) {
- for (Scope scope : scopes) {
- builder.addError(
- "A single binding may not declare more than one @Scope",
- enclosingElement,
- scope.scopeAnnotation());
- }
- }
-
- return builder.build();
- }
-
- private ValidationReport<VariableElement> validateField(VariableElement fieldElement) {
- ValidationReport.Builder<VariableElement> builder = ValidationReport.about(fieldElement);
- Set<Modifier> modifiers = fieldElement.getModifiers();
- if (modifiers.contains(FINAL)) {
- builder.addError("@Inject fields may not be final", fieldElement);
- }
-
- if (modifiers.contains(PRIVATE)) {
- builder.addItem(
- "Dagger does not support injection into private fields",
- privateMemberDiagnosticKind(),
- fieldElement);
- }
-
- if (modifiers.contains(STATIC)) {
- builder.addItem(
- "Dagger does not support injection into static fields",
- staticMemberDiagnosticKind(),
- fieldElement);
- }
-
- validateDependencyRequest(builder, fieldElement);
-
- return builder.build();
- }
-
- private ValidationReport<ExecutableElement> validateMethod(ExecutableElement methodElement) {
- ValidationReport.Builder<ExecutableElement> builder = ValidationReport.about(methodElement);
- Set<Modifier> modifiers = methodElement.getModifiers();
- if (modifiers.contains(ABSTRACT)) {
- builder.addError("Methods with @Inject may not be abstract", methodElement);
- }
-
- if (modifiers.contains(PRIVATE)) {
- builder.addItem(
- "Dagger does not support injection into private methods",
- privateMemberDiagnosticKind(),
- methodElement);
- }
-
- if (modifiers.contains(STATIC)) {
- builder.addItem(
- "Dagger does not support injection into static methods",
- staticMemberDiagnosticKind(),
- methodElement);
- }
-
- if (!methodElement.getTypeParameters().isEmpty()) {
- builder.addError("Methods with @Inject may not declare type parameters", methodElement);
- }
-
- for (VariableElement parameter : methodElement.getParameters()) {
- validateDependencyRequest(builder, parameter);
- }
-
- return builder.build();
- }
-
- private void validateDependencyRequest(
- ValidationReport.Builder<?> builder, VariableElement parameter) {
- dependencyRequestValidator.validateDependencyRequest(builder, parameter, parameter.asType());
- dependencyRequestValidator.checkNotProducer(builder, parameter);
- }
-
- ValidationReport<TypeElement> validateMembersInjectionType(TypeElement typeElement) {
- // TODO(beder): This element might not be currently compiled, so this error message could be
- // left in limbo. Find an appropriate way to display the error message in that case.
- ValidationReport.Builder<TypeElement> builder = ValidationReport.about(typeElement);
- boolean hasInjectedMembers = false;
- for (VariableElement element : ElementFilter.fieldsIn(typeElement.getEnclosedElements())) {
- if (MoreElements.isAnnotationPresent(element, Inject.class)) {
- hasInjectedMembers = true;
- ValidationReport<VariableElement> report = validateField(element);
- if (!report.isClean()) {
- builder.addSubreport(report);
- }
- }
- }
- for (ExecutableElement element : ElementFilter.methodsIn(typeElement.getEnclosedElements())) {
- if (MoreElements.isAnnotationPresent(element, Inject.class)) {
- hasInjectedMembers = true;
- ValidationReport<ExecutableElement> report = validateMethod(element);
- if (!report.isClean()) {
- builder.addSubreport(report);
- }
- }
- }
-
- if (hasInjectedMembers) {
- checkInjectIntoPrivateClass(typeElement, builder);
- }
- TypeMirror superclass = typeElement.getSuperclass();
- if (!superclass.getKind().equals(TypeKind.NONE)) {
- ValidationReport<TypeElement> report = validateType(MoreTypes.asTypeElement(superclass));
- if (!report.isClean()) {
- builder.addSubreport(report);
- }
- }
- return builder.build();
- }
-
- ValidationReport<TypeElement> validateType(TypeElement typeElement) {
- ValidationReport.Builder<TypeElement> builder = ValidationReport.about(typeElement);
- ValidationReport<TypeElement> membersInjectionReport =
- validateMembersInjectionType(typeElement);
- if (!membersInjectionReport.isClean()) {
- builder.addSubreport(membersInjectionReport);
- }
- for (ExecutableElement element :
- ElementFilter.constructorsIn(typeElement.getEnclosedElements())) {
- if (isAnnotationPresent(element, Inject.class)) {
- ValidationReport<TypeElement> report = validateConstructor(element);
- if (!report.isClean()) {
- builder.addSubreport(report);
- }
- }
- }
- return builder.build();
- }
-
- boolean isValidType(TypeMirror type) {
- if (!type.getKind().equals(DECLARED)) {
- return true;
- }
- return validateType(MoreTypes.asTypeElement(type)).isClean();
- }
-
- /** Returns true if the given method element declares a checked exception. */
- private boolean throwsCheckedExceptions(ExecutableElement methodElement) {
- TypeMirror runtimeExceptionType = elements.getTypeElement(RuntimeException.class).asType();
- TypeMirror errorType = elements.getTypeElement(Error.class).asType();
- for (TypeMirror thrownType : methodElement.getThrownTypes()) {
- if (!types.isSubtype(thrownType, runtimeExceptionType)
- && !types.isSubtype(thrownType, errorType)) {
- return true;
- }
- }
- return false;
- }
-
- private void checkInjectIntoPrivateClass(
- Element element, ValidationReport.Builder<TypeElement> builder) {
- if (!Accessibility.isElementAccessibleFromOwnPackage(
- DaggerElements.closestEnclosingTypeElement(element))) {
- builder.addItem(
- "Dagger does not support injection into private classes",
- privateMemberDiagnosticKind(),
- element);
- }
- }
-
- private Diagnostic.Kind privateMemberDiagnosticKind() {
- return privateAndStaticInjectionDiagnosticKind.orElse(
- compilerOptions.privateMemberValidationKind());
- }
-
- private Diagnostic.Kind staticMemberDiagnosticKind() {
- return privateAndStaticInjectionDiagnosticKind.orElse(
- compilerOptions.staticMemberValidationKind());
- }
-}
diff --git a/java/dagger/internal/codegen/InjectionAnnotations.java b/java/dagger/internal/codegen/InjectionAnnotations.java
deleted file mode 100644
index 521ad43..0000000
--- a/java/dagger/internal/codegen/InjectionAnnotations.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreElements.isAnnotationPresent;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static javax.lang.model.util.ElementFilter.constructorsIn;
-
-import com.google.auto.common.AnnotationMirrors;
-import com.google.auto.common.SuperficialValidation;
-import com.google.common.collect.FluentIterable;
-import com.google.common.collect.ImmutableSet;
-import java.util.Optional;
-import javax.inject.Inject;
-import javax.inject.Qualifier;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-
-/**
- * Utilities relating to annotations defined in the {@code javax.inject} package.
- */
-final class InjectionAnnotations {
- static Optional<AnnotationMirror> getQualifier(Element e) {
- if (!SuperficialValidation.validateElement(e)) {
- throw new TypeNotPresentException(e.toString(), null);
- }
- checkNotNull(e);
- ImmutableSet<? extends AnnotationMirror> qualifierAnnotations = getQualifiers(e);
- switch (qualifierAnnotations.size()) {
- case 0:
- return Optional.empty();
- case 1:
- return Optional.<AnnotationMirror>of(qualifierAnnotations.iterator().next());
- default:
- throw new IllegalArgumentException(
- e + " was annotated with more than one @Qualifier annotation");
- }
- }
-
- static ImmutableSet<? extends AnnotationMirror> getQualifiers(Element element) {
- return AnnotationMirrors.getAnnotatedAnnotations(element, Qualifier.class);
- }
-
- /** Returns the constructors in {@code type} that are annotated with {@link Inject}. */
- static ImmutableSet<ExecutableElement> injectedConstructors(TypeElement type) {
- return FluentIterable.from(constructorsIn(type.getEnclosedElements()))
- .filter(constructor -> isAnnotationPresent(constructor, Inject.class))
- .toSet();
- }
-
- private InjectionAnnotations() {}
-}
diff --git a/java/dagger/internal/codegen/InjectionMethod.java b/java/dagger/internal/codegen/InjectionMethod.java
deleted file mode 100644
index 2785b18..0000000
--- a/java/dagger/internal/codegen/InjectionMethod.java
+++ /dev/null
@@ -1,210 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.squareup.javapoet.MethodSpec.methodBuilder;
-import static dagger.internal.codegen.javapoet.CodeBlocks.makeParametersCodeBlock;
-import static dagger.internal.codegen.langmodel.Accessibility.isRawTypePubliclyAccessible;
-import static javax.lang.model.element.Modifier.PUBLIC;
-import static javax.lang.model.element.Modifier.STATIC;
-
-import com.google.auto.value.AutoValue;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.google.errorprone.annotations.CanIgnoreReturnValue;
-import com.google.errorprone.annotations.CheckReturnValue;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.MethodSpec;
-import com.squareup.javapoet.ParameterSpec;
-import com.squareup.javapoet.TypeName;
-import com.squareup.javapoet.TypeVariableName;
-import dagger.internal.codegen.javapoet.CodeBlocks;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import java.util.List;
-import java.util.Optional;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.Parameterizable;
-import javax.lang.model.element.VariableElement;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.TypeMirror;
-
-/**
- * A static method that implements provision and/or injection in one step:
- *
- * <ul>
- * <li>methods that invoke {@code @Inject} constructors and do members injection if necessary
- * <li>methods that call {@code @Provides} module methods
- * <li>methods that perform members injection
- * </ul>
- *
- * <p>Note that although this type uses {@code @AutoValue}, it uses instance equality. It uses
- * {@code @AutoValue} to avoid the boilerplate of writing a correct builder, but is not intended to
- * actually be a value type.
- */
-@AutoValue
-abstract class InjectionMethod {
- abstract String name();
-
- abstract boolean varargs();
-
- abstract ImmutableList<TypeVariableName> typeVariables();
-
- abstract ImmutableMap<ParameterSpec, TypeMirror> parameters();
-
- abstract Optional<TypeMirror> returnType();
-
- abstract Optional<DeclaredType> nullableAnnotation();
-
- abstract ImmutableList<TypeMirror> exceptions();
-
- abstract CodeBlock methodBody();
-
- abstract ClassName enclosingClass();
-
- MethodSpec toMethodSpec() {
- MethodSpec.Builder builder =
- methodBuilder(name())
- .addModifiers(PUBLIC, STATIC)
- .varargs(varargs())
- .addTypeVariables(typeVariables())
- .addParameters(parameters().keySet())
- .addCode(methodBody());
- returnType().map(TypeName::get).ifPresent(builder::returns);
- nullableAnnotation()
- .ifPresent(nullableType -> CodeBlocks.addAnnotation(builder, nullableType));
- exceptions().stream().map(TypeName::get).forEach(builder::addException);
- return builder.build();
- }
-
- CodeBlock invoke(List<CodeBlock> arguments, ClassName requestingClass) {
- checkArgument(arguments.size() == parameters().size());
- CodeBlock.Builder invocation = CodeBlock.builder();
- if (!enclosingClass().equals(requestingClass)) {
- invocation.add("$T.", enclosingClass());
- }
- return invocation.add("$L($L)", name(), makeParametersCodeBlock(arguments)).build();
- }
-
- @Override
- public final int hashCode() {
- return System.identityHashCode(this);
- }
-
- @Override
- public final boolean equals(Object obj) {
- return this == obj;
- }
-
- static Builder builder(DaggerElements elements) {
- Builder builder = new AutoValue_InjectionMethod.Builder();
- builder.elements = elements;
- builder.varargs(false).exceptions(ImmutableList.of()).nullableAnnotation(Optional.empty());
- return builder;
- }
-
- @CanIgnoreReturnValue
- @AutoValue.Builder
- abstract static class Builder {
- private final UniqueNameSet parameterNames = new UniqueNameSet();
- private final CodeBlock.Builder methodBody = CodeBlock.builder();
- private DaggerElements elements;
-
- abstract ImmutableMap.Builder<ParameterSpec, TypeMirror> parametersBuilder();
- abstract ImmutableList.Builder<TypeVariableName> typeVariablesBuilder();
- abstract Builder name(String name);
- abstract Builder varargs(boolean varargs);
- abstract Builder returnType(TypeMirror returnType);
- abstract Builder exceptions(Iterable<? extends TypeMirror> exceptions);
- abstract Builder nullableAnnotation(Optional<DeclaredType> nullableAnnotation);
- abstract Builder methodBody(CodeBlock methodBody);
-
- final CodeBlock.Builder methodBodyBuilder() {
- return methodBody;
- }
-
- abstract Builder enclosingClass(ClassName enclosingClass);
-
- /**
- * Adds a parameter for the given name and type. If another parameter has already been added
- * with the same name, the name is disambiguated.
- */
- ParameterSpec addParameter(String name, TypeMirror type) {
- ParameterSpec parameter =
- ParameterSpec.builder(TypeName.get(type), parameterNames.getUniqueName(name)).build();
- parametersBuilder().put(parameter, type);
- return parameter;
- }
-
- /**
- * Calls {@link #copyParameter(VariableElement)} for each parameter of of {@code method}, and
- * concatenates the results of each call, {@link CodeBlocks#makeParametersCodeBlock(Iterable)
- * separated with commas}.
- */
- CodeBlock copyParameters(ExecutableElement method) {
- ImmutableList.Builder<CodeBlock> argumentsBuilder = ImmutableList.builder();
- for (VariableElement parameter : method.getParameters()) {
- argumentsBuilder.add(copyParameter(parameter));
- }
- varargs(method.isVarArgs());
- return makeParametersCodeBlock(argumentsBuilder.build());
- }
-
- /**
- * Adds {@code parameter} as a parameter of this method, using a publicly accessible version of
- * the parameter's type. Returns a {@link CodeBlock} of the usage of this parameter within the
- * injection method's {@link #methodBody()}.
- */
- CodeBlock copyParameter(VariableElement parameter) {
- TypeMirror elementType = parameter.asType();
- boolean useObject = !isRawTypePubliclyAccessible(elementType);
- TypeMirror publicType = useObject ? objectType() : elementType;
- ParameterSpec parameterSpec = addParameter(parameter.getSimpleName().toString(), publicType);
- return useObject
- ? CodeBlock.of("($T) $N", elementType, parameterSpec)
- : CodeBlock.of("$N", parameterSpec);
- }
-
- private TypeMirror objectType() {
- return elements.getTypeElement(Object.class).asType();
- }
-
- /**
- * Adds each type parameter of {@code parameterizable} as a type parameter of this injection
- * method.
- */
- Builder copyTypeParameters(Parameterizable parameterizable) {
- parameterizable.getTypeParameters().stream()
- .map(TypeVariableName::get)
- .forEach(typeVariablesBuilder()::add);
- return this;
- }
-
- Builder copyThrows(ExecutableElement element) {
- exceptions(element.getThrownTypes());
- return this;
- }
-
- @CheckReturnValue
- final InjectionMethod build() {
- return methodBody(methodBody.build()).buildInternal();
- }
-
- abstract InjectionMethod buildInternal();
- }
-}
diff --git a/java/dagger/internal/codegen/InjectionMethods.java b/java/dagger/internal/codegen/InjectionMethods.java
deleted file mode 100644
index d61aaa5..0000000
--- a/java/dagger/internal/codegen/InjectionMethods.java
+++ /dev/null
@@ -1,544 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.CaseFormat.LOWER_CAMEL;
-import static com.google.common.base.CaseFormat.UPPER_CAMEL;
-import static com.google.common.base.Preconditions.checkArgument;
-import static dagger.internal.codegen.ConfigurationAnnotations.getNullableType;
-import static dagger.internal.codegen.DaggerStreams.toImmutableList;
-import static dagger.internal.codegen.FactoryGenerator.checkNotNullProvidesMethod;
-import static dagger.internal.codegen.RequestKinds.requestTypeName;
-import static dagger.internal.codegen.SourceFiles.generatedClassNameForBinding;
-import static dagger.internal.codegen.SourceFiles.membersInjectorNameForType;
-import static dagger.internal.codegen.javapoet.CodeBlocks.toConcatenatedCodeBlock;
-import static dagger.internal.codegen.javapoet.TypeNames.rawTypeName;
-import static dagger.internal.codegen.langmodel.Accessibility.isElementAccessibleFrom;
-import static dagger.internal.codegen.langmodel.Accessibility.isRawTypeAccessible;
-import static dagger.internal.codegen.langmodel.Accessibility.isRawTypePubliclyAccessible;
-import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
-import static java.util.stream.Collectors.toList;
-import static javax.lang.model.element.Modifier.STATIC;
-import static javax.lang.model.type.TypeKind.VOID;
-
-import com.google.auto.common.MoreElements;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.ParameterSpec;
-import com.squareup.javapoet.TypeName;
-import dagger.internal.codegen.MembersInjectionBinding.InjectionSite;
-import dagger.internal.codegen.javapoet.Expression;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.DependencyRequest;
-import dagger.model.RequestKind;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Optional;
-import java.util.function.Function;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.element.VariableElement;
-import javax.lang.model.type.TypeKind;
-import javax.lang.model.type.TypeMirror;
-
-/** Convenience methods for creating and invoking {@link InjectionMethod}s. */
-final class InjectionMethods {
-
- /**
- * A method that returns an object from a {@code @Provides} method or an {@code @Inject}ed
- * constructor. Its parameters match the dependency requests for constructor and members
- * injection.
- *
- * <p>For {@code @Provides} methods named "foo", the method name is "proxyFoo". If the
- * {@code @Provides} method and its raw parameter types are publicly accessible, no method is
- * necessary and this method returns {@link Optional#empty()}.
- *
- * <p>Example:
- *
- * <pre><code>
- * abstract class FooModule {
- * {@literal @Provides} static Foo provideFoo(Bar bar, Baz baz) { … }
- * }
- *
- * public static proxyProvideFoo(Bar bar, Baz baz) { … }
- * </code></pre>
- *
- * <p>For {@code @Inject}ed constructors, the method name is "newFoo". If the constructor and its
- * raw parameter types are publicly accessible, no method is necessary and this method returns
- * {@code Optional#empty()}.
- *
- * <p>Example:
- *
- * <pre><code>
- * class Foo {
- * {@literal @Inject} Foo(Bar bar) {}
- * }
- *
- * public static Foo newFoo(Bar bar) { … }
- * </code></pre>
- */
- static final class ProvisionMethod {
- /**
- * Names of methods that are already defined in factories and shouldn't be used for the proxy
- * method name.
- */
- private static final ImmutableSet<String> BANNED_PROXY_NAMES = ImmutableSet.of("get", "create");
-
- /**
- * Returns a method that invokes the binding's {@linkplain ProvisionBinding#bindingElement()
- * constructor} and injects the instance's members.
- */
- static InjectionMethod create(
- ProvisionBinding binding, CompilerOptions compilerOptions, DaggerElements elements) {
- ClassName proxyEnclosingClass = generatedClassNameForBinding(binding);
- ExecutableElement element = MoreElements.asExecutable(binding.bindingElement().get());
- switch (element.getKind()) {
- case CONSTRUCTOR:
- return constructorProxy(proxyEnclosingClass, element, elements);
- case METHOD:
- return methodProxy(
- proxyEnclosingClass,
- element,
- methodName(element),
- ReceiverAccessibility.IGNORE,
- CheckNotNullPolicy.get(binding, compilerOptions),
- elements);
- default:
- throw new AssertionError(element);
- }
- }
-
- /**
- * Invokes the injection method for {@code binding}, with the dependencies transformed with the
- * {@code dependencyUsage} function.
- */
- // TODO(ronshapiro): Further extract a ProvisionMethod type that composes an InjectionMethod, so
- // users can write ProvisionMethod.create().invoke()
- static CodeBlock invoke(
- ProvisionBinding binding,
- Function<DependencyRequest, CodeBlock> dependencyUsage,
- ClassName requestingClass,
- Optional<CodeBlock> moduleReference,
- CompilerOptions compilerOptions,
- DaggerElements elements) {
- ImmutableList.Builder<CodeBlock> arguments = ImmutableList.builder();
- moduleReference.ifPresent(arguments::add);
- arguments.addAll(
- injectionMethodArguments(
- binding.provisionDependencies(), dependencyUsage, requestingClass));
- // TODO(ronshapiro): make InjectionMethods @Injectable
- return create(binding, compilerOptions, elements).invoke(arguments.build(), requestingClass);
- }
-
- private static InjectionMethod constructorProxy(
- ClassName proxyEnclosingClass, ExecutableElement constructor, DaggerElements elements) {
- TypeElement enclosingType = MoreElements.asType(constructor.getEnclosingElement());
- InjectionMethod.Builder injectionMethod =
- InjectionMethod.builder(elements)
- .name(methodName(constructor))
- .returnType(enclosingType.asType())
- .enclosingClass(proxyEnclosingClass);
-
- injectionMethod
- .copyTypeParameters(enclosingType)
- .copyThrows(constructor);
-
- CodeBlock arguments = injectionMethod.copyParameters(constructor);
- injectionMethod
- .methodBodyBuilder()
- .addStatement("return new $T($L)", enclosingType, arguments);
- return injectionMethod.build();
- }
-
- /**
- * Returns {@code true} if injecting an instance of {@code binding} from {@code callingPackage}
- * requires the use of an injection method.
- */
- static boolean requiresInjectionMethod(
- ProvisionBinding binding,
- ImmutableList<Expression> arguments,
- CompilerOptions compilerOptions,
- String callingPackage,
- DaggerTypes types) {
- ExecutableElement method = MoreElements.asExecutable(binding.bindingElement().get());
- return !binding.injectionSites().isEmpty()
- || binding.shouldCheckForNull(compilerOptions)
- || !isElementAccessibleFrom(method, callingPackage)
- || !areParametersAssignable(method, arguments, types)
- // This check should be removable once we drop support for -source 7
- || method.getParameters().stream()
- .map(VariableElement::asType)
- .anyMatch(type -> !isRawTypeAccessible(type, callingPackage));
- }
-
- private static boolean areParametersAssignable(
- ExecutableElement element, ImmutableList<Expression> arguments, DaggerTypes types) {
- List<? extends VariableElement> parameters = element.getParameters();
- checkArgument(parameters.size() == arguments.size());
- for (int i = 0; i < parameters.size(); i++) {
- if (!types.isAssignable(arguments.get(i).type(), parameters.get(i).asType())) {
- return false;
- }
- }
- return true;
- }
-
- /**
- * Returns the name of the {@code static} method that wraps {@code method}. For methods that are
- * associated with {@code @Inject} constructors, the method will also inject all {@link
- * InjectionSite}s.
- */
- private static String methodName(ExecutableElement method) {
- switch (method.getKind()) {
- case CONSTRUCTOR:
- return "newInstance";
- case METHOD:
- String methodName = method.getSimpleName().toString();
- return BANNED_PROXY_NAMES.contains(methodName)
- ? "proxy" + LOWER_CAMEL.to(UPPER_CAMEL, methodName)
- : methodName;
- default:
- throw new AssertionError(method);
- }
- }
- }
-
- /**
- * A static method that injects one member of an instance of a type. Its first parameter is an
- * instance of the type to be injected. The remaining parameters match the dependency requests for
- * the injection site.
- *
- * <p>Example:
- *
- * <pre><code>
- * class Foo {
- * {@literal @Inject} Bar bar;
- * {@literal @Inject} void setThings(Baz baz, Qux qux) {}
- * }
- *
- * public static injectBar(Foo instance, Bar bar) { … }
- * public static injectSetThings(Foo instance, Baz baz, Qux qux) { … }
- * </code></pre>
- */
- static final class InjectionSiteMethod {
- /**
- * When a type has an inaccessible member from a supertype (e.g. an @Inject field in a parent
- * that's in a different package), a method in the supertype's package must be generated to give
- * the subclass's members injector a way to inject it. Each potentially inaccessible member
- * receives its own method, as the subclass may need to inject them in a different order from
- * the parent class.
- */
- static InjectionMethod create(InjectionSite injectionSite, DaggerElements elements) {
- String methodName = methodName(injectionSite);
- ClassName proxyEnclosingClass = membersInjectorNameForType(
- MoreElements.asType(injectionSite.element().getEnclosingElement()));
- switch (injectionSite.kind()) {
- case METHOD:
- return methodProxy(
- proxyEnclosingClass,
- MoreElements.asExecutable(injectionSite.element()),
- methodName,
- ReceiverAccessibility.CAST_IF_NOT_PUBLIC,
- CheckNotNullPolicy.IGNORE,
- elements);
- case FIELD:
- return fieldProxy(
- proxyEnclosingClass,
- MoreElements.asVariable(injectionSite.element()),
- methodName,
- elements);
- }
- throw new AssertionError(injectionSite);
- }
-
- /**
- * Invokes each of the injection methods for {@code injectionSites}, with the dependencies
- * transformed using the {@code dependencyUsage} function.
- *
- * @param instanceType the type of the {@code instance} parameter
- */
- static CodeBlock invokeAll(
- ImmutableSet<InjectionSite> injectionSites,
- ClassName generatedTypeName,
- CodeBlock instanceCodeBlock,
- TypeMirror instanceType,
- DaggerTypes types,
- Function<DependencyRequest, CodeBlock> dependencyUsage,
- DaggerElements elements) {
- return injectionSites
- .stream()
- .map(
- injectionSite -> {
- TypeMirror injectSiteType =
- types.erasure(injectionSite.element().getEnclosingElement().asType());
-
- // If instance has been declared as Object because it is not accessible from the
- // component, but the injectionSite is in a supertype of instanceType that is
- // publicly accessible, the InjectionSiteMethod will request the actual type and not
- // Object as the first parameter. If so, cast to the supertype which is accessible
- // from within generatedTypeName
- CodeBlock maybeCastedInstance =
- !types.isSubtype(instanceType, injectSiteType)
- && isTypeAccessibleFrom(injectSiteType, generatedTypeName.packageName())
- ? CodeBlock.of("($T) $L", injectSiteType, instanceCodeBlock)
- : instanceCodeBlock;
- return CodeBlock.of(
- "$L;",
- invoke(
- injectionSite,
- generatedTypeName,
- maybeCastedInstance,
- dependencyUsage,
- elements));
- })
- .collect(toConcatenatedCodeBlock());
- }
-
- /**
- * Invokes the injection method for {@code injectionSite}, with the dependencies transformed
- * using the {@code dependencyUsage} function.
- */
- private static CodeBlock invoke(
- InjectionSite injectionSite,
- ClassName generatedTypeName,
- CodeBlock instanceCodeBlock,
- Function<DependencyRequest, CodeBlock> dependencyUsage,
- DaggerElements elements) {
- List<CodeBlock> arguments = new ArrayList<>();
- arguments.add(instanceCodeBlock);
- if (!injectionSite.dependencies().isEmpty()) {
- arguments.addAll(
- injectionSite
- .dependencies()
- .stream()
- .map(dependencyUsage)
- .collect(toList()));
- }
- return create(injectionSite, elements).invoke(arguments, generatedTypeName);
- }
-
- /*
- * TODO(ronshapiro): this isn't perfect, as collisions could still exist. Some examples:
- *
- * - @Inject void members() {} will generate a method that conflicts with the instance
- * method `injectMembers(T)`
- * - Adding the index could conflict with another member:
- * @Inject void a(Object o) {}
- * @Inject void a(String s) {}
- * @Inject void a1(String s) {}
- *
- * Here, Method a(String) will add the suffix "1", which will conflict with the method
- * generated for a1(String)
- * - Members named "members" or "methods" could also conflict with the {@code static} injection
- * method.
- */
- private static String methodName(InjectionSite injectionSite) {
- int index = injectionSite.indexAmongAtInjectMembersWithSameSimpleName();
- String indexString = index == 0 ? "" : String.valueOf(index + 1);
- return "inject"
- + LOWER_CAMEL.to(UPPER_CAMEL, injectionSite.element().getSimpleName().toString())
- + indexString;
- }
- }
-
- /**
- * Returns an argument list suitable for calling an injection method. Down-casts any arguments
- * that are {@code Object} (or {@code Provider<Object>}) at the caller but not the method.
- *
- * @param dependencies the dependencies used by the method
- * @param dependencyUsage function to apply on each of {@code dependencies} before casting
- * @param requestingClass the class calling the injection method
- */
- private static ImmutableList<CodeBlock> injectionMethodArguments(
- ImmutableSet<DependencyRequest> dependencies,
- Function<DependencyRequest, CodeBlock> dependencyUsage,
- ClassName requestingClass) {
- return dependencies.stream()
- .map(dep -> injectionMethodArgument(dep, dependencyUsage.apply(dep), requestingClass))
- .collect(toImmutableList());
- }
-
- private static CodeBlock injectionMethodArgument(
- DependencyRequest dependency, CodeBlock argument, ClassName generatedTypeName) {
- TypeMirror keyType = dependency.key().type();
- CodeBlock.Builder codeBlock = CodeBlock.builder();
- if (!isRawTypeAccessible(keyType, generatedTypeName.packageName())
- && isTypeAccessibleFrom(keyType, generatedTypeName.packageName())) {
- if (!dependency.kind().equals(RequestKind.INSTANCE)) {
- TypeName usageTypeName = accessibleType(dependency);
- codeBlock.add("($T) ($T)", usageTypeName, rawTypeName(usageTypeName));
- } else if (dependency.requestElement().get().asType().getKind().equals(TypeKind.TYPEVAR)) {
- codeBlock.add("($T)", keyType);
- }
- }
- return codeBlock.add(argument).build();
- }
-
- /**
- * Returns the parameter type for {@code dependency}. If the raw type is not accessible, returns
- * {@link Object}.
- */
- private static TypeName accessibleType(DependencyRequest dependency) {
- TypeName typeName = requestTypeName(dependency.kind(), accessibleType(dependency.key().type()));
- return dependency
- .requestElement()
- .map(element -> element.asType().getKind().isPrimitive())
- .orElse(false)
- ? typeName.unbox()
- : typeName;
- }
-
- /**
- * Returns the accessible type for {@code type}. If the raw type is not accessible, returns {@link
- * Object}.
- */
- private static TypeName accessibleType(TypeMirror type) {
- return isRawTypePubliclyAccessible(type) ? TypeName.get(type) : TypeName.OBJECT;
- }
-
- /**
- * Returns the accessible type for {@code type}. If the raw type is not accessible, returns {@link
- * Object}.
- */
- // TODO(ronshapiro): Can we use DaggerTypes.publiclyAccessibleType in place of this method?
- private static TypeMirror accessibleType(TypeMirror type, DaggerElements elements) {
- return isRawTypePubliclyAccessible(type)
- ? type
- : elements.getTypeElement(Object.class).asType();
- }
-
- private enum ReceiverAccessibility {
- CAST_IF_NOT_PUBLIC {
- @Override
- TypeMirror parameterType(TypeMirror type, DaggerElements elements) {
- return accessibleType(type, elements);
- }
-
- @Override
- CodeBlock potentiallyCast(CodeBlock instance, TypeMirror instanceType) {
- return instanceWithPotentialCast(instance, instanceType);
- }
- },
- IGNORE {
- @Override
- TypeMirror parameterType(TypeMirror type, DaggerElements elements) {
- return type;
- }
-
- @Override
- CodeBlock potentiallyCast(CodeBlock instance, TypeMirror instanceType) {
- return instance;
- }
- },
- ;
-
- abstract TypeMirror parameterType(TypeMirror type, DaggerElements elements);
- abstract CodeBlock potentiallyCast(CodeBlock instance, TypeMirror instanceType);
- }
-
- private static CodeBlock instanceWithPotentialCast(CodeBlock instance, TypeMirror instanceType) {
- return isRawTypePubliclyAccessible(instanceType)
- ? instance
- : CodeBlock.of("(($T) $L)", instanceType, instance);
- }
-
- private enum CheckNotNullPolicy {
- IGNORE, CHECK_FOR_NULL;
- CodeBlock checkForNull(CodeBlock maybeNull) {
- if (this.equals(IGNORE)) {
- return maybeNull;
- }
- return checkNotNullProvidesMethod(maybeNull);
- }
-
- static CheckNotNullPolicy get(ProvisionBinding binding, CompilerOptions compilerOptions) {
- return binding.shouldCheckForNull(compilerOptions) ? CHECK_FOR_NULL : IGNORE;
- }
- }
-
- private static InjectionMethod methodProxy(
- ClassName proxyEnclosingClass,
- ExecutableElement method,
- String methodName,
- ReceiverAccessibility receiverAccessibility,
- CheckNotNullPolicy checkNotNullPolicy,
- DaggerElements elements) {
- TypeElement enclosingType = MoreElements.asType(method.getEnclosingElement());
- InjectionMethod.Builder injectionMethod =
- InjectionMethod.builder(elements).name(methodName).enclosingClass(proxyEnclosingClass);
- ParameterSpec instance = null;
- if (!method.getModifiers().contains(STATIC)) {
- instance =
- injectionMethod.addParameter(
- "instance", receiverAccessibility.parameterType(enclosingType.asType(), elements));
- }
-
- CodeBlock arguments = injectionMethod.copyParameters(method);
- if (!method.getReturnType().getKind().equals(VOID)) {
- injectionMethod
- .returnType(method.getReturnType())
- .nullableAnnotation(getNullableType(method));
- injectionMethod.methodBodyBuilder().add("return ");
- }
- CodeBlock.Builder proxyInvocation = CodeBlock.builder();
- if (method.getModifiers().contains(STATIC)) {
- proxyInvocation.add("$T", rawTypeName(TypeName.get(enclosingType.asType())));
- } else {
- injectionMethod.copyTypeParameters(enclosingType);
- proxyInvocation.add(
- receiverAccessibility.potentiallyCast(
- CodeBlock.of("$N", instance), enclosingType.asType()));
- }
-
- injectionMethod
- .copyTypeParameters(method)
- .copyThrows(method);
-
- proxyInvocation.add(".$N($L)", method.getSimpleName(), arguments);
- injectionMethod
- .methodBodyBuilder()
- .add(checkNotNullPolicy.checkForNull(proxyInvocation.build()))
- .add(";\n");
- return injectionMethod.build();
- }
-
- private static InjectionMethod fieldProxy(
- ClassName proxyEnclosingClass,
- VariableElement field,
- String methodName,
- DaggerElements elements) {
- TypeElement enclosingType = MoreElements.asType(field.getEnclosingElement());
- InjectionMethod.Builder injectionMethod =
- InjectionMethod.builder(elements).name(methodName).enclosingClass(proxyEnclosingClass);
- injectionMethod.copyTypeParameters(enclosingType);
-
- ParameterSpec instance =
- injectionMethod.addParameter("instance", accessibleType(enclosingType.asType(), elements));
- CodeBlock parameter = injectionMethod.copyParameter(field);
- injectionMethod
- .methodBodyBuilder()
- .addStatement(
- "$L.$L = $L",
- instanceWithPotentialCast(CodeBlock.of("$N", instance), enclosingType.asType()),
- field.getSimpleName(),
- parameter);
- return injectionMethod.build();
- }
-}
diff --git a/java/dagger/internal/codegen/InjectionOrProvisionProviderCreationExpression.java b/java/dagger/internal/codegen/InjectionOrProvisionProviderCreationExpression.java
deleted file mode 100644
index 2d2e8cb..0000000
--- a/java/dagger/internal/codegen/InjectionOrProvisionProviderCreationExpression.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static dagger.internal.codegen.SourceFiles.generatedClassNameForBinding;
-import static dagger.model.BindingKind.INJECTION;
-
-import com.squareup.javapoet.CodeBlock;
-import dagger.internal.codegen.FrameworkFieldInitializer.FrameworkInstanceCreationExpression;
-import dagger.internal.codegen.javapoet.CodeBlocks;
-import javax.inject.Provider;
-
-/**
- * A {@link Provider} creation expression for an {@link javax.inject.Inject @Inject}-constructed
- * class or a {@link dagger.Provides @Provides}-annotated module method.
- */
-// TODO(dpb): Resolve with ProducerCreationExpression.
-final class InjectionOrProvisionProviderCreationExpression
- implements FrameworkInstanceCreationExpression {
-
- private final ContributionBinding binding;
- private final ComponentBindingExpressions componentBindingExpressions;
-
- InjectionOrProvisionProviderCreationExpression(
- ContributionBinding binding, ComponentBindingExpressions componentBindingExpressions) {
- this.binding = checkNotNull(binding);
- this.componentBindingExpressions = checkNotNull(componentBindingExpressions);
- }
-
- @Override
- public CodeBlock creationExpression() {
- CodeBlock createFactory =
- CodeBlock.of(
- "$T.create($L)",
- generatedClassNameForBinding(binding),
- componentBindingExpressions.getCreateMethodArgumentsCodeBlock(binding));
-
- // When scoping a parameterized factory for an @Inject class, Java 7 cannot always infer the
- // type properly, so cast to a raw framework type before scoping.
- if (binding.kind().equals(INJECTION)
- && binding.unresolved().isPresent()
- && binding.scope().isPresent()) {
- return CodeBlocks.cast(createFactory, Provider.class);
- } else {
- return createFactory;
- }
- }
-}
diff --git a/java/dagger/internal/codegen/InjectionSiteFactory.java b/java/dagger/internal/codegen/InjectionSiteFactory.java
deleted file mode 100644
index d09f91d..0000000
--- a/java/dagger/internal/codegen/InjectionSiteFactory.java
+++ /dev/null
@@ -1,161 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreElements.isAnnotationPresent;
-import static dagger.internal.codegen.MembersInjectionBinding.InjectionSite.Kind.METHOD;
-import static dagger.internal.codegen.langmodel.DaggerElements.DECLARATION_ORDER;
-import static javax.lang.model.element.Modifier.PRIVATE;
-import static javax.lang.model.element.Modifier.STATIC;
-
-import com.google.auto.common.MoreElements;
-import com.google.auto.common.MoreTypes;
-import com.google.common.collect.ImmutableSortedSet;
-import com.google.common.collect.LinkedHashMultimap;
-import com.google.common.collect.SetMultimap;
-import dagger.internal.codegen.MembersInjectionBinding.InjectionSite;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Optional;
-import java.util.Set;
-import javax.inject.Inject;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ElementVisitor;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.element.VariableElement;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.ExecutableType;
-import javax.lang.model.type.TypeMirror;
-import javax.lang.model.util.ElementKindVisitor8;
-
-/** A factory for {@link Binding} objects. */
-final class InjectionSiteFactory {
- private final ElementVisitor<Optional<InjectionSite>, DeclaredType> injectionSiteVisitor =
- new ElementKindVisitor8<Optional<InjectionSite>, DeclaredType>(Optional.empty()) {
- @Override
- public Optional<InjectionSite> visitExecutableAsMethod(
- ExecutableElement method, DeclaredType type) {
- ExecutableType resolved = MoreTypes.asExecutable(types.asMemberOf(type, method));
- return Optional.of(
- InjectionSite.method(
- method,
- dependencyRequestFactory.forRequiredResolvedVariables(
- method.getParameters(), resolved.getParameterTypes())));
- }
-
- @Override
- public Optional<InjectionSite> visitVariableAsField(
- VariableElement field, DeclaredType type) {
- if (!isAnnotationPresent(field, Inject.class)
- || field.getModifiers().contains(PRIVATE)
- || field.getModifiers().contains(STATIC)) {
- return Optional.empty();
- }
- TypeMirror resolved = types.asMemberOf(type, field);
- return Optional.of(
- InjectionSite.field(
- field, dependencyRequestFactory.forRequiredResolvedVariable(field, resolved)));
- }
- };
-
- private final DaggerTypes types;
- private final DaggerElements elements;
- private final DependencyRequestFactory dependencyRequestFactory;
-
- @Inject
- InjectionSiteFactory(
- DaggerTypes types,
- DaggerElements elements,
- DependencyRequestFactory dependencyRequestFactory) {
- this.types = types;
- this.elements = elements;
- this.dependencyRequestFactory = dependencyRequestFactory;
- }
-
- /** Returns the injection sites for a type. */
- ImmutableSortedSet<InjectionSite> getInjectionSites(DeclaredType declaredType) {
- Set<InjectionSite> injectionSites = new HashSet<>();
- List<TypeElement> ancestors = new ArrayList<>();
- SetMultimap<String, ExecutableElement> overriddenMethodMap = LinkedHashMultimap.create();
- for (Optional<DeclaredType> currentType = Optional.of(declaredType);
- currentType.isPresent();
- currentType = types.nonObjectSuperclass(currentType.get())) {
- DeclaredType type = currentType.get();
- ancestors.add(MoreElements.asType(type.asElement()));
- for (Element enclosedElement : type.asElement().getEnclosedElements()) {
- Optional<InjectionSite> maybeInjectionSite =
- injectionSiteVisitor.visit(enclosedElement, type);
- if (maybeInjectionSite.isPresent()) {
- InjectionSite injectionSite = maybeInjectionSite.get();
- if (shouldBeInjected(injectionSite.element(), overriddenMethodMap)) {
- injectionSites.add(injectionSite);
- }
- if (injectionSite.kind().equals(METHOD)) {
- ExecutableElement injectionSiteMethod =
- MoreElements.asExecutable(injectionSite.element());
- overriddenMethodMap.put(
- injectionSiteMethod.getSimpleName().toString(), injectionSiteMethod);
- }
- }
- }
- }
- return ImmutableSortedSet.copyOf(
- // supertypes before subtypes
- Comparator.comparing(
- (InjectionSite injectionSite) ->
- ancestors.indexOf(injectionSite.element().getEnclosingElement()))
- .reversed()
- // fields before methods
- .thenComparing(injectionSite -> injectionSite.element().getKind())
- // then sort by whichever element comes first in the parent
- // this isn't necessary, but makes the processor nice and predictable
- .thenComparing(InjectionSite::element, DECLARATION_ORDER),
- injectionSites);
- }
-
- private boolean shouldBeInjected(
- Element injectionSite, SetMultimap<String, ExecutableElement> overriddenMethodMap) {
- if (!isAnnotationPresent(injectionSite, Inject.class)
- || injectionSite.getModifiers().contains(PRIVATE)
- || injectionSite.getModifiers().contains(STATIC)) {
- return false;
- }
-
- if (injectionSite.getKind().isField()) { // Inject all fields (self and ancestors)
- return true;
- }
-
- // For each method with the same name belonging to any descendant class, return false if any
- // method has already overridden the injectionSite method. To decrease the number of methods
- // that are checked, we store the already injected methods in a SetMultimap and only
- // check the methods with the same name.
- ExecutableElement injectionSiteMethod = MoreElements.asExecutable(injectionSite);
- TypeElement injectionSiteType = MoreElements.asType(injectionSite.getEnclosingElement());
- for (ExecutableElement method :
- overriddenMethodMap.get(injectionSiteMethod.getSimpleName().toString())) {
- if (elements.overrides(method, injectionSiteMethod, injectionSiteType)) {
- return false;
- }
- }
- return true;
- }
-}
diff --git a/java/dagger/internal/codegen/InnerSwitchingProviders.java b/java/dagger/internal/codegen/InnerSwitchingProviders.java
deleted file mode 100644
index 74c4366..0000000
--- a/java/dagger/internal/codegen/InnerSwitchingProviders.java
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.squareup.javapoet.MethodSpec.constructorBuilder;
-import static dagger.internal.codegen.BindingRequest.bindingRequest;
-import static dagger.model.RequestKind.INSTANCE;
-import static javax.lang.model.element.Modifier.FINAL;
-import static javax.lang.model.element.Modifier.PRIVATE;
-
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.TypeName;
-import com.squareup.javapoet.TypeSpec;
-import dagger.internal.codegen.javapoet.Expression;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.Key;
-import javax.inject.Provider;
-import javax.lang.model.type.TypeMirror;
-
-/**
- * Generates {@linkplain BindingExpression binding expressions} for a binding that is represented by
- * an inner {@code SwitchingProvider} class.
- */
-final class InnerSwitchingProviders extends SwitchingProviders {
- private final ComponentBindingExpressions componentBindingExpressions;
- private final DaggerTypes types;
-
- InnerSwitchingProviders(
- ComponentImplementation componentImplementation,
- ComponentBindingExpressions componentBindingExpressions,
- DaggerTypes types) {
- super(componentImplementation, types);
- this.componentBindingExpressions = componentBindingExpressions;
- this.types = types;
- }
-
- /**
- * Returns the binding expression for a binding that satisfies a {@link Provider} requests with a
- * inner {@code SwitchingProvider} class.
- */
- BindingExpression newBindingExpression(ContributionBinding binding) {
- return new BindingExpression() {
- @Override
- Expression getDependencyExpression(ClassName requestingClass) {
- return getProviderExpression(new SwitchCase(binding, requestingClass));
- }
- };
- }
-
- @Override
- protected TypeSpec createSwitchingProviderType(TypeSpec.Builder builder) {
- return builder
- .addModifiers(PRIVATE, FINAL)
- .addField(TypeName.INT, "id", PRIVATE, FINAL)
- .addMethod(
- constructorBuilder()
- .addParameter(TypeName.INT, "id")
- .addStatement("this.id = id")
- .build())
- .build();
- }
-
- private final class SwitchCase implements SwitchingProviders.SwitchCase {
- private final ContributionBinding binding;
- private final ClassName requestingClass;
-
- SwitchCase(ContributionBinding binding, ClassName requestingClass) {
- this.binding = binding;
- this.requestingClass = requestingClass;
- }
-
- @Override
- public Key key() {
- return binding.key();
- }
-
- @Override
- public Expression getProviderExpression(ClassName switchingProviderClass, int switchId) {
- TypeMirror instanceType = types.accessibleType(binding.contributedType(), requestingClass);
- return Expression.create(
- types.wrapType(instanceType, Provider.class),
- CodeBlock.of("new $T<>($L)", switchingProviderClass, switchId));
- }
-
- @Override
- public Expression getReturnExpression(ClassName switchingProviderClass) {
- return componentBindingExpressions.getDependencyExpression(
- bindingRequest(binding.key(), INSTANCE), switchingProviderClass);
- }
- }
-}
diff --git a/java/dagger/internal/codegen/InstanceFactoryCreationExpression.java b/java/dagger/internal/codegen/InstanceFactoryCreationExpression.java
deleted file mode 100644
index c9b26d7..0000000
--- a/java/dagger/internal/codegen/InstanceFactoryCreationExpression.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.squareup.javapoet.CodeBlock;
-import dagger.internal.InstanceFactory;
-import dagger.internal.codegen.FrameworkFieldInitializer.FrameworkInstanceCreationExpression;
-import java.util.function.Supplier;
-
-/**
- * A {@link FrameworkInstanceCreationExpression} that creates an {@link InstanceFactory} for an
- * instance.
- */
-final class InstanceFactoryCreationExpression implements FrameworkInstanceCreationExpression {
-
- private final boolean nullable;
- private final Supplier<CodeBlock> instanceExpression;
-
- InstanceFactoryCreationExpression(Supplier<CodeBlock> instanceExpression) {
- this(false, instanceExpression);
- }
-
- InstanceFactoryCreationExpression(boolean nullable, Supplier<CodeBlock> instanceExpression) {
- this.nullable = nullable;
- this.instanceExpression = checkNotNull(instanceExpression);
- }
-
- @Override
- public CodeBlock creationExpression() {
- return CodeBlock.of(
- "$T.$L($L)",
- InstanceFactory.class,
- nullable ? "createNullable" : "create",
- instanceExpression.get());
- }
-
- @Override
- public boolean useInnerSwitchingProvider() {
- return false;
- }
-}
diff --git a/java/dagger/internal/codegen/JavacPluginModule.java b/java/dagger/internal/codegen/JavacPluginModule.java
deleted file mode 100644
index bc5b66e..0000000
--- a/java/dagger/internal/codegen/JavacPluginModule.java
+++ /dev/null
@@ -1,184 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.ValidationType.NONE;
-import static javax.tools.Diagnostic.Kind.NOTE;
-
-import com.sun.tools.javac.model.JavacElements;
-import com.sun.tools.javac.model.JavacTypes;
-import com.sun.tools.javac.util.Context;
-import dagger.Binds;
-import dagger.Module;
-import dagger.Provides;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import javax.annotation.processing.Messager;
-import javax.inject.Inject;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.AnnotationValue;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.util.Types;
-import javax.tools.Diagnostic;
-
-/**
- * A module that provides a {@link BindingGraphFactory} and {@link ComponentDescriptorFactory} for
- * use in {@code javac} plugins. Requires a binding for the {@code javac} {@link Context}.
- */
-@Module(includes = InjectBindingRegistryModule.class)
-abstract class JavacPluginModule {
- @Provides
- static CompilerOptions compilerOptions() {
- return new CompilerOptions() {
- @Override
- boolean usesProducers() {
- return true;
- }
-
- @Override
- boolean fastInit() {
- return false;
- }
-
- @Override
- boolean formatGeneratedSource() {
- return false;
- }
-
- @Override
- boolean writeProducerNameInToken() {
- return true;
- }
-
- @Override
- Diagnostic.Kind nullableValidationKind() {
- return NOTE;
- }
-
- @Override
- Diagnostic.Kind privateMemberValidationKind() {
- return NOTE;
- }
-
- @Override
- Diagnostic.Kind staticMemberValidationKind() {
- return NOTE;
- }
-
- @Override
- boolean ignorePrivateAndStaticInjectionForComponent() {
- return false;
- }
-
- @Override
- ValidationType scopeCycleValidationType() {
- return NONE;
- }
-
- @Override
- boolean warnIfInjectionFactoryNotGeneratedUpstream() {
- return false;
- }
-
- @Override
- boolean headerCompilation() {
- return false;
- }
-
- @Override
- boolean aheadOfTimeSubcomponents() {
- return false;
- }
-
- @Override
- boolean forceUseSerializedComponentImplementations() {
- return false;
- }
-
- @Override
- boolean emitModifiableMetadataAnnotations() {
- return false;
- }
-
- @Override
- boolean useGradleIncrementalProcessing() {
- return false;
- }
-
- @Override
- ValidationType fullBindingGraphValidationType(TypeElement element) {
- return NONE;
- }
-
- @Override
- Diagnostic.Kind moduleHasDifferentScopesDiagnosticKind() {
- return NOTE;
- }
-
- @Override
- ValidationType explicitBindingConflictsWithInjectValidationType() {
- return NONE;
- }
- };
- }
-
- @Binds
- abstract Messager messager(NullMessager nullMessager);
-
- static final class NullMessager implements Messager {
-
- @Inject
- NullMessager() {}
-
- @Override
- public void printMessage(Diagnostic.Kind kind, CharSequence charSequence) {}
-
- @Override
- public void printMessage(Diagnostic.Kind kind, CharSequence charSequence, Element element) {}
-
- @Override
- public void printMessage(
- Diagnostic.Kind kind,
- CharSequence charSequence,
- Element element,
- AnnotationMirror annotationMirror) {}
-
- @Override
- public void printMessage(
- Diagnostic.Kind kind,
- CharSequence charSequence,
- Element element,
- AnnotationMirror annotationMirror,
- AnnotationValue annotationValue) {}
- }
-
- @Provides
- static DaggerElements daggerElements(Context javaContext) {
- return new DaggerElements(
- JavacElements.instance(javaContext), JavacTypes.instance(javaContext));
- }
-
- @Provides
- static DaggerTypes daggerTypes(Context javaContext, DaggerElements elements) {
- return new DaggerTypes(JavacTypes.instance(javaContext), elements);
- }
-
- @Binds abstract Types types(DaggerTypes daggerTypes);
-
- private JavacPluginModule() {}
-}
diff --git a/java/dagger/internal/codegen/KeyFactory.java b/java/dagger/internal/codegen/KeyFactory.java
deleted file mode 100644
index b6ac27f..0000000
--- a/java/dagger/internal/codegen/KeyFactory.java
+++ /dev/null
@@ -1,469 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreElements.isAnnotationPresent;
-import static com.google.auto.common.MoreTypes.asExecutable;
-import static com.google.auto.common.MoreTypes.isType;
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.internal.codegen.InjectionAnnotations.getQualifier;
-import static dagger.internal.codegen.MapKeys.getMapKey;
-import static dagger.internal.codegen.MapKeys.mapKeyType;
-import static dagger.internal.codegen.Optionals.firstPresent;
-import static dagger.internal.codegen.RequestKinds.extractKeyType;
-import static dagger.internal.codegen.RequestKinds.getRequestKind;
-import static dagger.internal.codegen.langmodel.DaggerTypes.isFutureType;
-import static java.util.Arrays.asList;
-import static javax.lang.model.element.ElementKind.METHOD;
-
-import com.google.auto.common.MoreTypes;
-import com.google.common.collect.ImmutableSet;
-import dagger.Binds;
-import dagger.BindsOptionalOf;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.internal.codegen.serialization.KeyProto;
-import dagger.model.Key;
-import dagger.model.Key.MultibindingContributionIdentifier;
-import dagger.model.RequestKind;
-import dagger.multibindings.Multibinds;
-import dagger.producers.Produced;
-import dagger.producers.Producer;
-import dagger.producers.Production;
-import dagger.producers.internal.ProductionImplementation;
-import dagger.producers.monitoring.ProductionComponentMonitor;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
-import java.util.concurrent.Executor;
-import java.util.stream.Stream;
-import javax.inject.Inject;
-import javax.inject.Provider;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.ExecutableType;
-import javax.lang.model.type.PrimitiveType;
-import javax.lang.model.type.TypeMirror;
-
-/** A factory for {@link Key}s. */
-final class KeyFactory {
- private final DaggerTypes types;
- private final DaggerElements elements;
- private final TypeProtoConverter typeProtoConverter;
- private final AnnotationProtoConverter annotationProtoConverter;
-
- @Inject
- KeyFactory(
- DaggerTypes types,
- DaggerElements elements,
- TypeProtoConverter typeProtoConverter,
- AnnotationProtoConverter annotationProtoConverter) {
- this.types = checkNotNull(types);
- this.elements = checkNotNull(elements);
- this.typeProtoConverter = typeProtoConverter;
- this.annotationProtoConverter = annotationProtoConverter;
- }
-
- private TypeMirror boxPrimitives(TypeMirror type) {
- return type.getKind().isPrimitive() ? types.boxedClass((PrimitiveType) type).asType() : type;
- }
-
- private DeclaredType setOf(TypeMirror elementType) {
- return types.getDeclaredType(elements.getTypeElement(Set.class), boxPrimitives(elementType));
- }
-
- private DeclaredType mapOf(TypeMirror keyType, TypeMirror valueType) {
- return types.getDeclaredType(
- elements.getTypeElement(Map.class), boxPrimitives(keyType), boxPrimitives(valueType));
- }
-
- /** Returns {@code Map<KeyType, FrameworkType<ValueType>>}. */
- private TypeMirror mapOfFrameworkType(
- TypeMirror keyType, TypeElement frameworkType, TypeMirror valueType) {
- return mapOf(keyType, types.getDeclaredType(frameworkType, boxPrimitives(valueType)));
- }
-
- Key forComponentMethod(ExecutableElement componentMethod) {
- checkArgument(componentMethod.getKind().equals(METHOD));
- return forMethod(componentMethod, componentMethod.getReturnType());
- }
-
- Key forProductionComponentMethod(ExecutableElement componentMethod) {
- checkArgument(componentMethod.getKind().equals(METHOD));
- TypeMirror returnType = componentMethod.getReturnType();
- TypeMirror keyType =
- isFutureType(returnType)
- ? getOnlyElement(MoreTypes.asDeclared(returnType).getTypeArguments())
- : returnType;
- return forMethod(componentMethod, keyType);
- }
-
- Key forSubcomponentCreatorMethod(
- ExecutableElement subcomponentCreatorMethod, DeclaredType declaredContainer) {
- checkArgument(subcomponentCreatorMethod.getKind().equals(METHOD));
- ExecutableType resolvedMethod =
- asExecutable(types.asMemberOf(declaredContainer, subcomponentCreatorMethod));
- return Key.builder(resolvedMethod.getReturnType()).build();
- }
-
- Key forSubcomponentCreator(TypeMirror creatorType) {
- return Key.builder(creatorType).build();
- }
-
- Key forProvidesMethod(ExecutableElement method, TypeElement contributingModule) {
- return forBindingMethod(
- method, contributingModule, Optional.of(elements.getTypeElement(Provider.class)));
- }
-
- Key forProducesMethod(ExecutableElement method, TypeElement contributingModule) {
- return forBindingMethod(
- method, contributingModule, Optional.of(elements.getTypeElement(Producer.class)));
- }
-
- /** Returns the key bound by a {@link Binds} method. */
- Key forBindsMethod(ExecutableElement method, TypeElement contributingModule) {
- checkArgument(isAnnotationPresent(method, Binds.class));
- return forBindingMethod(method, contributingModule, Optional.empty());
- }
-
- /** Returns the base key bound by a {@link BindsOptionalOf} method. */
- Key forBindsOptionalOfMethod(ExecutableElement method, TypeElement contributingModule) {
- checkArgument(isAnnotationPresent(method, BindsOptionalOf.class));
- return forBindingMethod(method, contributingModule, Optional.empty());
- }
-
- private Key forBindingMethod(
- ExecutableElement method,
- TypeElement contributingModule,
- Optional<TypeElement> frameworkType) {
- checkArgument(method.getKind().equals(METHOD));
- ExecutableType methodType =
- MoreTypes.asExecutable(
- types.asMemberOf(MoreTypes.asDeclared(contributingModule.asType()), method));
- ContributionType contributionType = ContributionType.fromBindingElement(method);
- TypeMirror returnType = methodType.getReturnType();
- if (frameworkType.isPresent()
- && frameworkType.get().equals(elements.getTypeElement(Producer.class))
- && isType(returnType)) {
- if (isFutureType(methodType.getReturnType())) {
- returnType = getOnlyElement(MoreTypes.asDeclared(returnType).getTypeArguments());
- } else if (contributionType.equals(ContributionType.SET_VALUES)
- && SetType.isSet(returnType)) {
- SetType setType = SetType.from(returnType);
- if (isFutureType(setType.elementType())) {
- returnType =
- types.getDeclaredType(
- elements.getTypeElement(Set.class), types.unwrapType(setType.elementType()));
- }
- }
- }
- TypeMirror keyType = bindingMethodKeyType(returnType, method, contributionType, frameworkType);
- Key key = forMethod(method, keyType);
- return contributionType.equals(ContributionType.UNIQUE)
- ? key
- : key.toBuilder()
- .multibindingContributionIdentifier(
- new MultibindingContributionIdentifier(method, contributingModule))
- .build();
- }
-
- /**
- * Returns the key for a {@link Multibinds @Multibinds} method.
- *
- * <p>The key's type is either {@code Set<T>} or {@code Map<K, Provider<V>>}. The latter works
- * even for maps used by {@code Producer}s.
- */
- Key forMultibindsMethod(ExecutableType executableType, ExecutableElement method) {
- checkArgument(method.getKind().equals(METHOD), "%s must be a method", method);
- TypeMirror returnType = executableType.getReturnType();
- TypeMirror keyType =
- MapType.isMap(returnType)
- ? mapOfFrameworkType(
- MapType.from(returnType).keyType(),
- elements.getTypeElement(Provider.class),
- MapType.from(returnType).valueType())
- : returnType;
- return forMethod(method, keyType);
- }
-
- private TypeMirror bindingMethodKeyType(
- TypeMirror returnType,
- ExecutableElement method,
- ContributionType contributionType,
- Optional<TypeElement> frameworkType) {
- switch (contributionType) {
- case UNIQUE:
- return returnType;
- case SET:
- return setOf(returnType);
- case MAP:
- TypeMirror mapKeyType = mapKeyType(getMapKey(method).get(), types);
- return frameworkType.isPresent()
- ? mapOfFrameworkType(mapKeyType, frameworkType.get(), returnType)
- : mapOf(mapKeyType, returnType);
- case SET_VALUES:
- // TODO(gak): do we want to allow people to use "covariant return" here?
- checkArgument(SetType.isSet(returnType));
- return returnType;
- }
- throw new AssertionError();
- }
-
- /**
- * Returns the key for a binding associated with a {@link DelegateDeclaration}.
- *
- * <p>If {@code delegateDeclaration} is {@code @IntoMap}, transforms the {@code Map<K, V>} key
- * from {@link DelegateDeclaration#key()} to {@code Map<K, FrameworkType<V>>}. If {@code
- * delegateDeclaration} is not a map contribution, its key is returned.
- */
- Key forDelegateBinding(DelegateDeclaration delegateDeclaration, Class<?> frameworkType) {
- return delegateDeclaration.contributionType().equals(ContributionType.MAP)
- ? wrapMapValue(delegateDeclaration.key(), frameworkType)
- : delegateDeclaration.key();
- }
-
- private Key forMethod(ExecutableElement method, TypeMirror keyType) {
- return forQualifiedType(getQualifier(method), keyType);
- }
-
- Key forInjectConstructorWithResolvedType(TypeMirror type) {
- return Key.builder(type).build();
- }
-
- // TODO(ronshapiro): Remove these conveniences which are simple wrappers around Key.Builder
- Key forType(TypeMirror type) {
- return Key.builder(type).build();
- }
-
- Key forMembersInjectedType(TypeMirror type) {
- return Key.builder(type).build();
- }
-
- Key forQualifiedType(Optional<AnnotationMirror> qualifier, TypeMirror type) {
- return Key.builder(boxPrimitives(type)).qualifier(qualifier).build();
- }
-
- Key forProductionExecutor() {
- return Key.builder(elements.getTypeElement(Executor.class).asType())
- .qualifier(SimpleAnnotationMirror.of(elements.getTypeElement(Production.class)))
- .build();
- }
-
- Key forProductionImplementationExecutor() {
- return Key.builder(elements.getTypeElement(Executor.class).asType())
- .qualifier(SimpleAnnotationMirror.of(elements.getTypeElement(ProductionImplementation.class)))
- .build();
- }
-
- Key forProductionComponentMonitor() {
- return Key.builder(elements.getTypeElement(ProductionComponentMonitor.class).asType()).build();
- }
-
- /**
- * If {@code requestKey} is for a {@code Map<K, V>} or {@code Map<K, Produced<V>>}, returns keys
- * for {@code Map<K, Provider<V>>} and {@code Map<K, Producer<V>>} (if Dagger-Producers is on
- * the classpath).
- */
- ImmutableSet<Key> implicitFrameworkMapKeys(Key requestKey) {
- return Stream.of(implicitMapProviderKeyFrom(requestKey), implicitMapProducerKeyFrom(requestKey))
- .filter(Optional::isPresent)
- .map(Optional::get)
- .collect(toImmutableSet());
- }
-
- /**
- * Optionally extract a {@link Key} for the underlying provision binding(s) if such a valid key
- * can be inferred from the given key. Specifically, if the key represents a {@link Map}{@code
- * <K, V>} or {@code Map<K, Producer<V>>}, a key of {@code Map<K, Provider<V>>} will be
- * returned.
- */
- Optional<Key> implicitMapProviderKeyFrom(Key possibleMapKey) {
- return firstPresent(
- rewrapMapKey(possibleMapKey, Produced.class, Provider.class),
- wrapMapKey(possibleMapKey, Provider.class));
- }
-
- /**
- * Optionally extract a {@link Key} for the underlying production binding(s) if such a
- * valid key can be inferred from the given key. Specifically, if the key represents a
- * {@link Map}{@code <K, V>} or {@code Map<K, Produced<V>>}, a key of
- * {@code Map<K, Producer<V>>} will be returned.
- */
- Optional<Key> implicitMapProducerKeyFrom(Key possibleMapKey) {
- return firstPresent(
- rewrapMapKey(possibleMapKey, Produced.class, Producer.class),
- wrapMapKey(possibleMapKey, Producer.class));
- }
-
- /**
- * If {@code key}'s type is {@code Map<K, Provider<V>>}, {@code Map<K, Producer<V>>}, or {@code
- * Map<K, Produced<V>>}, returns a key with the same qualifier and {@link
- * Key#multibindingContributionIdentifier()} whose type is simply {@code Map<K, V>}.
- *
- * <p>Otherwise, returns {@code key}.
- */
- Key unwrapMapValueType(Key key) {
- if (MapType.isMap(key)) {
- MapType mapType = MapType.from(key);
- if (!mapType.isRawType()) {
- for (Class<?> frameworkClass : asList(Provider.class, Producer.class, Produced.class)) {
- if (mapType.valuesAreTypeOf(frameworkClass)) {
- return key.toBuilder()
- .type(mapOf(mapType.keyType(), mapType.unwrappedValueType(frameworkClass)))
- .build();
- }
- }
- }
- }
- return key;
- }
-
- /**
- * Converts a {@link Key} of type {@code Map<K, V>} to {@code Map<K, Provider<V>>}.
- */
- private Key wrapMapValue(Key key, Class<?> newWrappingClass) {
- checkArgument(
- FrameworkTypes.isFrameworkType(elements.getTypeElement(newWrappingClass).asType()));
- return wrapMapKey(key, newWrappingClass).get();
- }
-
- /**
- * If {@code key}'s type is {@code Map<K, CurrentWrappingClass<Bar>>}, returns a key with type
- * {@code Map<K, NewWrappingClass<Bar>>} with the same qualifier. Otherwise returns {@link
- * Optional#empty()}.
- *
- * <p>Returns {@link Optional#empty()} if {@code newWrappingClass} is not in the classpath.
- *
- * @throws IllegalArgumentException if {@code newWrappingClass} is the same as {@code
- * currentWrappingClass}
- */
- Optional<Key> rewrapMapKey(
- Key possibleMapKey, Class<?> currentWrappingClass, Class<?> newWrappingClass) {
- checkArgument(!currentWrappingClass.equals(newWrappingClass));
- if (MapType.isMap(possibleMapKey)) {
- MapType mapType = MapType.from(possibleMapKey);
- if (!mapType.isRawType() && mapType.valuesAreTypeOf(currentWrappingClass)) {
- TypeElement wrappingElement = elements.getTypeElement(newWrappingClass);
- if (wrappingElement == null) {
- // This target might not be compiled with Producers, so wrappingClass might not have an
- // associated element.
- return Optional.empty();
- }
- DeclaredType wrappedValueType =
- types.getDeclaredType(
- wrappingElement, mapType.unwrappedValueType(currentWrappingClass));
- return Optional.of(
- possibleMapKey.toBuilder().type(mapOf(mapType.keyType(), wrappedValueType)).build());
- }
- }
- return Optional.empty();
- }
-
- /**
- * If {@code key}'s type is {@code Map<K, Foo>} and {@code Foo} is not {@code WrappingClass
- * <Bar>}, returns a key with type {@code Map<K, WrappingClass<Foo>>} with the same qualifier.
- * Otherwise returns {@link Optional#empty()}.
- *
- * <p>Returns {@link Optional#empty()} if {@code WrappingClass} is not in the classpath.
- */
- private Optional<Key> wrapMapKey(Key possibleMapKey, Class<?> wrappingClass) {
- if (MapType.isMap(possibleMapKey)) {
- MapType mapType = MapType.from(possibleMapKey);
- if (!mapType.isRawType() && !mapType.valuesAreTypeOf(wrappingClass)) {
- TypeElement wrappingElement = elements.getTypeElement(wrappingClass);
- if (wrappingElement == null) {
- // This target might not be compiled with Producers, so wrappingClass might not have an
- // associated element.
- return Optional.empty();
- }
- DeclaredType wrappedValueType = types.getDeclaredType(wrappingElement, mapType.valueType());
- return Optional.of(
- possibleMapKey.toBuilder().type(mapOf(mapType.keyType(), wrappedValueType)).build());
- }
- }
- return Optional.empty();
- }
-
- /**
- * If {@code key}'s type is {@code Set<WrappingClass<Bar>>}, returns a key with type {@code Set
- * <Bar>} with the same qualifier. Otherwise returns {@link Optional#empty()}.
- */
- Optional<Key> unwrapSetKey(Key key, Class<?> wrappingClass) {
- if (SetType.isSet(key)) {
- SetType setType = SetType.from(key);
- if (!setType.isRawType() && setType.elementsAreTypeOf(wrappingClass)) {
- return Optional.of(
- key.toBuilder().type(setOf(setType.unwrappedElementType(wrappingClass))).build());
- }
- }
- return Optional.empty();
- }
-
- /**
- * If {@code key}'s type is {@code Optional<T>} for some {@code T}, returns a key with the same
- * qualifier whose type is {@linkplain RequestKinds#extractKeyType(RequestKind, TypeMirror)}
- * extracted} from {@code T}.
- */
- Optional<Key> unwrapOptional(Key key) {
- if (!OptionalType.isOptional(key)) {
- return Optional.empty();
- }
-
- TypeMirror optionalValueType = OptionalType.from(key).valueType();
- return Optional.of(
- key.toBuilder()
- .type(extractKeyType(getRequestKind(optionalValueType), optionalValueType))
- .build());
- }
-
- /** Translates a {@link Key} to a proto representation. */
- static KeyProto toProto(Key key) {
- KeyProto.Builder builder =
- KeyProto.newBuilder().setType(TypeProtoConverter.toProto(key.type()));
- key.qualifier().map(AnnotationProtoConverter::toProto).ifPresent(builder::setQualifier);
- key.multibindingContributionIdentifier()
- .ifPresent(
- mci ->
- builder
- .getMultibindingContributionIdentifierBuilder()
- .setModule(mci.module())
- .setBindingElement(mci.bindingElement()));
- return builder.build();
- }
-
- /** Creates a {@link Key} from its proto representation. */
- Key fromProto(KeyProto key) {
- Key.Builder builder = Key.builder(typeProtoConverter.fromProto(key.getType()));
- if (key.hasQualifier()) {
- builder.qualifier(annotationProtoConverter.fromProto(key.getQualifier()));
- }
- if (key.hasMultibindingContributionIdentifier()) {
- KeyProto.MultibindingContributionIdentifier multibindingContributionIdentifier =
- key.getMultibindingContributionIdentifier();
- builder.multibindingContributionIdentifier(
- new MultibindingContributionIdentifier(
- multibindingContributionIdentifier.getBindingElement(),
- multibindingContributionIdentifier.getModule()));
- }
- return builder.build();
- }
-}
diff --git a/java/dagger/internal/codegen/KeyVariableNamer.java b/java/dagger/internal/codegen/KeyVariableNamer.java
deleted file mode 100644
index 407f208..0000000
--- a/java/dagger/internal/codegen/KeyVariableNamer.java
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.CaseFormat.LOWER_CAMEL;
-import static com.google.common.base.CaseFormat.UPPER_CAMEL;
-import static dagger.internal.codegen.SourceFiles.protectAgainstKeywords;
-
-import com.google.auto.common.MoreTypes;
-import com.google.common.collect.ImmutableSet;
-import dagger.model.DependencyRequest;
-import dagger.model.Key;
-import java.util.Iterator;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.ArrayType;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.PrimitiveType;
-import javax.lang.model.type.TypeMirror;
-import javax.lang.model.type.TypeVisitor;
-import javax.lang.model.util.SimpleTypeVisitor8;
-
-/**
- * Suggests a variable name for a type based on a {@link Key}. Prefer {@link
- * DependencyVariableNamer} for cases where a specific {@link DependencyRequest} is present.
- */
-final class KeyVariableNamer {
- /** Simple names that are very common. Inspired by https://errorprone.info/bugpattern/BadImport */
- private static final ImmutableSet<String> VERY_SIMPLE_NAMES =
- ImmutableSet.of(
- "Builder",
- "Factory",
- "Component",
- "Subcomponent",
- "Injector");
-
- private static final TypeVisitor<Void, StringBuilder> TYPE_NAMER =
- new SimpleTypeVisitor8<Void, StringBuilder>() {
- @Override
- public Void visitDeclared(DeclaredType declaredType, StringBuilder builder) {
- TypeElement element = MoreTypes.asTypeElement(declaredType);
- if (element.getNestingKind().isNested()
- && VERY_SIMPLE_NAMES.contains(element.getSimpleName().toString())) {
- builder.append(element.getEnclosingElement().getSimpleName());
- }
-
- builder.append(element.getSimpleName());
- Iterator<? extends TypeMirror> argumentIterator =
- declaredType.getTypeArguments().iterator();
- if (argumentIterator.hasNext()) {
- builder.append("Of");
- TypeMirror first = argumentIterator.next();
- first.accept(this, builder);
- while (argumentIterator.hasNext()) {
- builder.append("And");
- argumentIterator.next().accept(this, builder);
- }
- }
- return null;
- }
-
- @Override
- public Void visitPrimitive(PrimitiveType type, StringBuilder builder) {
- builder.append(LOWER_CAMEL.to(UPPER_CAMEL, type.toString()));
- return null;
- }
-
- @Override
- public Void visitArray(ArrayType type, StringBuilder builder) {
- type.getComponentType().accept(this, builder);
- builder.append("Array");
- return null;
- }
- };
-
- private KeyVariableNamer() {}
-
- static String name(Key key) {
- if (key.multibindingContributionIdentifier().isPresent()) {
- return key.multibindingContributionIdentifier().get().bindingElement();
- }
-
- StringBuilder builder = new StringBuilder();
-
- if (key.qualifier().isPresent()) {
- // TODO(gak): Use a better name for fields with qualifiers with members.
- builder.append(key.qualifier().get().getAnnotationType().asElement().getSimpleName());
- }
-
- key.type().accept(TYPE_NAMER, builder);
-
- return protectAgainstKeywords(UPPER_CAMEL.to(LOWER_CAMEL, builder.toString()));
- }
-}
diff --git a/java/dagger/internal/codegen/Keys.java b/java/dagger/internal/codegen/Keys.java
deleted file mode 100644
index 670fda7..0000000
--- a/java/dagger/internal/codegen/Keys.java
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import com.google.auto.common.MoreElements;
-import com.google.auto.common.MoreTypes;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.Key;
-import java.util.Optional;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.ElementKind;
-import javax.lang.model.element.Modifier;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.TypeKind;
-import javax.lang.model.type.TypeMirror;
-import javax.lang.model.util.SimpleTypeVisitor6;
-
-/** Utility methods related to {@link Key}s. */
-final class Keys {
- static boolean isValidMembersInjectionKey(Key key) {
- return !key.qualifier().isPresent()
- && !key.multibindingContributionIdentifier().isPresent()
- && key.type().getKind().equals(TypeKind.DECLARED);
- }
-
- /**
- * Returns {@code true} if this is valid as an implicit key (that is, if it's valid for a
- * just-in-time binding by discovering an {@code @Inject} constructor).
- */
- static boolean isValidImplicitProvisionKey(Key key, DaggerTypes types) {
- return isValidImplicitProvisionKey(key.qualifier(), key.type(), types);
- }
-
- /**
- * Returns {@code true} if a key with {@code qualifier} and {@code type} is valid as an implicit
- * key (that is, if it's valid for a just-in-time binding by discovering an {@code @Inject}
- * constructor).
- */
- static boolean isValidImplicitProvisionKey(
- Optional<? extends AnnotationMirror> qualifier, TypeMirror type, final DaggerTypes types) {
- // Qualifiers disqualify implicit provisioning.
- if (qualifier.isPresent()) {
- return false;
- }
-
- return type.accept(
- new SimpleTypeVisitor6<Boolean, Void>(false) {
- @Override
- public Boolean visitDeclared(DeclaredType type, Void ignored) {
- // Non-classes or abstract classes aren't allowed.
- TypeElement element = MoreElements.asType(type.asElement());
- if (!element.getKind().equals(ElementKind.CLASS)
- || element.getModifiers().contains(Modifier.ABSTRACT)) {
- return false;
- }
-
- // If the key has type arguments, validate that each type argument is declared.
- // Otherwise the type argument may be a wildcard (or other type), and we can't
- // resolve that to actual types.
- for (TypeMirror arg : type.getTypeArguments()) {
- if (arg.getKind() != TypeKind.DECLARED) {
- return false;
- }
- }
-
- // Also validate that the key is not the erasure of a generic type.
- // If it is, that means the user referred to Foo<T> as just 'Foo',
- // which we don't allow. (This is a judgement call -- we *could*
- // allow it and instantiate the type bounds... but we don't.)
- return MoreTypes.asDeclared(element.asType()).getTypeArguments().isEmpty()
- || !types.isSameType(types.erasure(element.asType()), type);
- }
- },
- null);
- }
-}
diff --git a/java/dagger/internal/codegen/MapBindingExpression.java b/java/dagger/internal/codegen/MapBindingExpression.java
deleted file mode 100644
index 526c493..0000000
--- a/java/dagger/internal/codegen/MapBindingExpression.java
+++ /dev/null
@@ -1,176 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static dagger.internal.codegen.BindingRequest.bindingRequest;
-import static dagger.internal.codegen.MapKeys.getMapKeyExpression;
-import static dagger.internal.codegen.javapoet.CodeBlocks.toParametersCodeBlock;
-import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
-import static dagger.model.BindingKind.MULTIBOUND_MAP;
-import static javax.lang.model.util.ElementFilter.methodsIn;
-
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Maps;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import dagger.internal.MapBuilder;
-import dagger.internal.codegen.javapoet.Expression;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.BindingKind;
-import dagger.model.DependencyRequest;
-import java.util.Collections;
-import java.util.Optional;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.TypeMirror;
-
-/** A {@link BindingExpression} for multibound maps. */
-final class MapBindingExpression extends MultibindingExpression {
- /** Maximum number of key-value pairs that can be passed to ImmutableMap.of(K, V, K, V, ...). */
- private static final int MAX_IMMUTABLE_MAP_OF_KEY_VALUE_PAIRS = 5;
-
- private final ProvisionBinding binding;
- private final ImmutableMap<DependencyRequest, ContributionBinding> dependencies;
- private final ComponentBindingExpressions componentBindingExpressions;
- private final DaggerTypes types;
- private final DaggerElements elements;
-
- MapBindingExpression(
- ResolvedBindings resolvedBindings,
- ComponentImplementation componentImplementation,
- BindingGraph graph,
- ComponentBindingExpressions componentBindingExpressions,
- DaggerTypes types,
- DaggerElements elements) {
- super(resolvedBindings, componentImplementation);
- this.binding = (ProvisionBinding) resolvedBindings.contributionBinding();
- BindingKind bindingKind = this.binding.kind();
- checkArgument(bindingKind.equals(MULTIBOUND_MAP), bindingKind);
- this.componentBindingExpressions = componentBindingExpressions;
- this.types = types;
- this.elements = elements;
- this.dependencies =
- Maps.toMap(
- binding.dependencies(),
- dep -> graph.contributionBindings().get(dep.key()).contributionBinding());
- }
-
- @Override
- protected Expression buildDependencyExpression(ClassName requestingClass) {
- Optional<CodeBlock> superMethodCall = superMethodCall();
- // TODO(ronshapiro): We should also make an ImmutableMap version of MapFactory
- boolean isImmutableMapAvailable = isImmutableMapAvailable();
- // TODO(ronshapiro, gak): Use Maps.immutableEnumMap() if it's available?
- if (isImmutableMapAvailable
- && dependencies.size() <= MAX_IMMUTABLE_MAP_OF_KEY_VALUE_PAIRS
- && !superMethodCall.isPresent()) {
- return Expression.create(
- immutableMapType(),
- CodeBlock.builder()
- .add("$T.", ImmutableMap.class)
- .add(maybeTypeParameters(requestingClass))
- .add(
- "of($L)",
- dependencies
- .keySet()
- .stream()
- .map(dependency -> keyAndValueExpression(dependency, requestingClass))
- .collect(toParametersCodeBlock()))
- .build());
- }
- switch (dependencies.size()) {
- case 0:
- return collectionsStaticFactoryInvocation(requestingClass, CodeBlock.of("emptyMap()"));
- case 1:
- return collectionsStaticFactoryInvocation(
- requestingClass,
- CodeBlock.of(
- "singletonMap($L)",
- keyAndValueExpression(getOnlyElement(dependencies.keySet()), requestingClass)));
- default:
- CodeBlock.Builder instantiation = CodeBlock.builder();
- instantiation
- .add("$T.", isImmutableMapAvailable ? ImmutableMap.class : MapBuilder.class)
- .add(maybeTypeParameters(requestingClass));
- if (isImmutableMapBuilderWithExpectedSizeAvailable()) {
- instantiation.add("builderWithExpectedSize($L)", dependencies.size());
- } else if (isImmutableMapAvailable) {
- instantiation.add("builder()");
- } else {
- instantiation.add("newMapBuilder($L)", dependencies.size());
- }
- for (DependencyRequest dependency : getNewContributions(dependencies.keySet())) {
- instantiation.add(".put($L)", keyAndValueExpression(dependency, requestingClass));
- }
- if (superMethodCall.isPresent()) {
- instantiation.add(CodeBlock.of(".putAll($L)", superMethodCall.get()));
- }
- return Expression.create(
- isImmutableMapAvailable ? immutableMapType() : binding.key().type(),
- instantiation.add(".build()").build());
- }
- }
-
- private DeclaredType immutableMapType() {
- MapType mapType = MapType.from(binding.key());
- return types.getDeclaredType(
- elements.getTypeElement(ImmutableMap.class), mapType.keyType(), mapType.valueType());
- }
-
- private CodeBlock keyAndValueExpression(DependencyRequest dependency, ClassName requestingClass) {
- return CodeBlock.of(
- "$L, $L",
- getMapKeyExpression(dependencies.get(dependency), requestingClass, elements),
- componentBindingExpressions
- .getDependencyExpression(bindingRequest(dependency), requestingClass)
- .codeBlock());
- }
-
- private Expression collectionsStaticFactoryInvocation(
- ClassName requestingClass, CodeBlock methodInvocation) {
- return Expression.create(
- binding.key().type(),
- CodeBlock.builder()
- .add("$T.", Collections.class)
- .add(maybeTypeParameters(requestingClass))
- .add(methodInvocation)
- .build());
- }
-
- private CodeBlock maybeTypeParameters(ClassName requestingClass) {
- TypeMirror bindingKeyType = binding.key().type();
- MapType mapType = MapType.from(binding.key());
- return isTypeAccessibleFrom(bindingKeyType, requestingClass.packageName())
- ? CodeBlock.of("<$T, $T>", mapType.keyType(), mapType.valueType())
- : CodeBlock.of("");
- }
-
- private boolean isImmutableMapBuilderWithExpectedSizeAvailable() {
- if (isImmutableMapAvailable()) {
- return methodsIn(elements.getTypeElement(ImmutableMap.class).getEnclosedElements())
- .stream()
- .anyMatch(method -> method.getSimpleName().contentEquals("builderWithExpectedSize"));
- }
- return false;
- }
-
- private boolean isImmutableMapAvailable() {
- return elements.getTypeElement(ImmutableMap.class) != null;
- }
-}
diff --git a/java/dagger/internal/codegen/MapFactoryCreationExpression.java b/java/dagger/internal/codegen/MapFactoryCreationExpression.java
deleted file mode 100644
index 187b792..0000000
--- a/java/dagger/internal/codegen/MapFactoryCreationExpression.java
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static dagger.internal.codegen.MapKeys.getMapKeyExpression;
-import static dagger.internal.codegen.SourceFiles.mapFactoryClassName;
-
-import com.google.common.collect.ImmutableSet;
-import com.squareup.javapoet.CodeBlock;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.model.DependencyRequest;
-import dagger.producers.Produced;
-import dagger.producers.Producer;
-import javax.inject.Provider;
-import javax.lang.model.type.TypeMirror;
-
-/** A factory creation expression for a multibound map. */
-final class MapFactoryCreationExpression extends MultibindingFactoryCreationExpression {
-
- private final ComponentImplementation componentImplementation;
- private final BindingGraph graph;
- private final ContributionBinding binding;
- private final DaggerElements elements;
-
- MapFactoryCreationExpression(
- ContributionBinding binding,
- ComponentImplementation componentImplementation,
- ComponentBindingExpressions componentBindingExpressions,
- BindingGraph graph,
- DaggerElements elements) {
- super(binding, componentImplementation, componentBindingExpressions);
- this.binding = checkNotNull(binding);
- this.componentImplementation = checkNotNull(componentImplementation);
- this.graph = checkNotNull(graph);
- this.elements = checkNotNull(elements);
- }
-
- @Override
- public CodeBlock creationExpression() {
- CodeBlock.Builder builder = CodeBlock.builder().add("$T.", mapFactoryClassName(binding));
- if (!useRawType()) {
- MapType mapType = MapType.from(binding.key().type());
- // TODO(ronshapiro): either inline this into mapFactoryClassName, or add a
- // mapType.unwrappedValueType() method that doesn't require a framework type
- TypeMirror valueType = mapType.valueType();
- for (Class<?> frameworkClass :
- ImmutableSet.of(Provider.class, Producer.class, Produced.class)) {
- if (mapType.valuesAreTypeOf(frameworkClass)) {
- valueType = mapType.unwrappedValueType(frameworkClass);
- break;
- }
- }
- builder.add("<$T, $T>", mapType.keyType(), valueType);
- }
-
- builder.add("builder($L)", binding.dependencies().size());
-
- superContributions()
- .ifPresent(superContributions -> builder.add(".putAll($L)", superContributions));
-
- for (DependencyRequest dependency : dependenciesToImplement()) {
- ContributionBinding contributionBinding =
- graph.contributionBindings().get(dependency.key()).contributionBinding();
- builder.add(
- ".put($L, $L)",
- getMapKeyExpression(contributionBinding, componentImplementation.name(), elements),
- multibindingDependencyExpression(dependency));
- }
- builder.add(".build()");
-
- componentImplementation.registerImplementedMultibinding(binding, bindingRequest());
-
- return builder.build();
- }
-}
diff --git a/java/dagger/internal/codegen/MapKeyAccessibility.java b/java/dagger/internal/codegen/MapKeyAccessibility.java
deleted file mode 100644
index ce27877..0000000
--- a/java/dagger/internal/codegen/MapKeyAccessibility.java
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
-
-import dagger.internal.codegen.langmodel.Accessibility;
-import java.util.Collection;
-import java.util.List;
-import java.util.function.Predicate;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.AnnotationValue;
-import javax.lang.model.element.VariableElement;
-import javax.lang.model.type.TypeMirror;
-import javax.lang.model.util.SimpleAnnotationValueVisitor8;
-
-final class MapKeyAccessibility extends SimpleAnnotationValueVisitor8<Boolean, Void> {
- private final Predicate<TypeMirror> accessibilityChecker;
-
- private MapKeyAccessibility(Predicate<TypeMirror> accessibilityChecker) {
- this.accessibilityChecker = accessibilityChecker;
- }
-
- @Override
- public Boolean visitAnnotation(AnnotationMirror annotation, Void aVoid) {
- // The annotation type is not checked, as the generated code will refer to the @AutoAnnotation
- // generated type which is always public
- return visitValues(annotation.getElementValues().values());
- }
-
- @Override
- public Boolean visitArray(List<? extends AnnotationValue> values, Void aVoid) {
- return visitValues(values);
- }
-
- private boolean visitValues(Collection<? extends AnnotationValue> values) {
- return values.stream().allMatch(value -> value.accept(this, null));
- }
-
- @Override
- public Boolean visitEnumConstant(VariableElement enumConstant, Void aVoid) {
- return accessibilityChecker.test(enumConstant.getEnclosingElement().asType());
- }
-
- @Override
- public Boolean visitType(TypeMirror type, Void aVoid) {
- return accessibilityChecker.test(type);
- }
-
- @Override
- protected Boolean defaultAction(Object o, Void aVoid) {
- return true;
- }
-
- static boolean isMapKeyAccessibleFrom(AnnotationMirror annotation, String accessingPackage) {
- return new MapKeyAccessibility(type -> isTypeAccessibleFrom(type, accessingPackage))
- .visitAnnotation(annotation, null);
- }
-
- static boolean isMapKeyPubliclyAccessible(AnnotationMirror annotation) {
- return new MapKeyAccessibility(Accessibility::isTypePubliclyAccessible)
- .visitAnnotation(annotation, null);
- }
-}
diff --git a/java/dagger/internal/codegen/MapKeyProcessingStep.java b/java/dagger/internal/codegen/MapKeyProcessingStep.java
index 19975a7..50693da 100644
--- a/java/dagger/internal/codegen/MapKeyProcessingStep.java
+++ b/java/dagger/internal/codegen/MapKeyProcessingStep.java
@@ -16,7 +16,7 @@
package dagger.internal.codegen;
-import static dagger.internal.codegen.MapKeys.getUnwrappedMapKeyType;
+import static dagger.internal.codegen.binding.MapKeys.getUnwrappedMapKeyType;
import static javax.lang.model.element.ElementKind.ANNOTATION_TYPE;
import com.google.auto.common.MoreElements;
@@ -24,6 +24,11 @@
import com.google.common.collect.ImmutableSet;
import dagger.MapKey;
import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.internal.codegen.validation.MapKeyValidator;
+import dagger.internal.codegen.validation.TypeCheckingProcessingStep;
+import dagger.internal.codegen.validation.ValidationReport;
+import dagger.internal.codegen.writing.AnnotationCreatorGenerator;
+import dagger.internal.codegen.writing.UnwrappedMapKeyGenerator;
import java.lang.annotation.Annotation;
import java.util.Set;
import javax.annotation.processing.Messager;
@@ -37,7 +42,7 @@
* The annotation processor responsible for validating the mapKey annotation and auto-generate
* implementation of annotations marked with {@link MapKey @MapKey} where necessary.
*/
-public class MapKeyProcessingStep extends TypeCheckingProcessingStep<TypeElement> {
+final class MapKeyProcessingStep extends TypeCheckingProcessingStep<TypeElement> {
private final Messager messager;
private final DaggerTypes types;
private final MapKeyValidator mapKeyValidator;
diff --git a/java/dagger/internal/codegen/MapKeyValidator.java b/java/dagger/internal/codegen/MapKeyValidator.java
deleted file mode 100644
index f2568ef..0000000
--- a/java/dagger/internal/codegen/MapKeyValidator.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static javax.lang.model.util.ElementFilter.methodsIn;
-
-import dagger.MapKey;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import java.util.List;
-import javax.inject.Inject;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.TypeKind;
-
-/**
- * A validator for {@link MapKey} annotations.
- */
-// TODO(dpb,gak): Should unwrapped MapKeys be required to have their single member be named "value"?
-final class MapKeyValidator {
- private final DaggerElements elements;
-
- @Inject
- MapKeyValidator(DaggerElements elements) {
- this.elements = elements;
- }
-
- ValidationReport<Element> validate(Element element) {
- ValidationReport.Builder<Element> builder = ValidationReport.about(element);
- List<ExecutableElement> members = methodsIn(((TypeElement) element).getEnclosedElements());
- if (members.isEmpty()) {
- builder.addError("Map key annotations must have members", element);
- } else if (element.getAnnotation(MapKey.class).unwrapValue()) {
- if (members.size() > 1) {
- builder.addError(
- "Map key annotations with unwrapped values must have exactly one member", element);
- } else if (members.get(0).getReturnType().getKind() == TypeKind.ARRAY) {
- builder.addError("Map key annotations with unwrapped values cannot use arrays", element);
- }
- } else if (autoAnnotationIsMissing()) {
- builder.addError(
- "@AutoAnnotation is a necessary dependency if @MapKey(unwrapValue = false). Add a "
- + "dependency on com.google.auto.value:auto-value:<current version>");
- }
- return builder.build();
- }
-
- private boolean autoAnnotationIsMissing() {
- return elements.getTypeElement("com.google.auto.value.AutoAnnotation") == null;
- }
-}
diff --git a/java/dagger/internal/codegen/MapKeys.java b/java/dagger/internal/codegen/MapKeys.java
deleted file mode 100644
index d8da6af..0000000
--- a/java/dagger/internal/codegen/MapKeys.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.AnnotationMirrors.getAnnotatedAnnotations;
-import static com.google.auto.common.AnnotationMirrors.getAnnotationValuesWithDefaults;
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static com.squareup.javapoet.MethodSpec.methodBuilder;
-import static dagger.internal.codegen.MapKeyAccessibility.isMapKeyPubliclyAccessible;
-import static dagger.internal.codegen.SourceFiles.elementBasedClassName;
-import static javax.lang.model.element.Modifier.PUBLIC;
-import static javax.lang.model.element.Modifier.STATIC;
-import static javax.lang.model.util.ElementFilter.methodsIn;
-
-import com.google.auto.common.MoreElements;
-import com.google.auto.common.MoreTypes;
-import com.google.common.collect.ImmutableSet;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.MethodSpec;
-import com.squareup.javapoet.TypeName;
-import dagger.MapKey;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import java.util.NoSuchElementException;
-import java.util.Optional;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.AnnotationValue;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ElementKind;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.ArrayType;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.PrimitiveType;
-import javax.lang.model.type.TypeMirror;
-import javax.lang.model.util.SimpleTypeVisitor6;
-
-/**
- * Methods for extracting {@link MapKey} annotations and key code blocks from binding elements.
- */
-final class MapKeys {
-
- /**
- * If {@code bindingElement} is annotated with a {@link MapKey} annotation, returns it.
- *
- * @throws IllegalArgumentException if the element is annotated with more than one {@code MapKey}
- * annotation
- */
- static Optional<AnnotationMirror> getMapKey(Element bindingElement) {
- ImmutableSet<? extends AnnotationMirror> mapKeys = getMapKeys(bindingElement);
- return mapKeys.isEmpty()
- ? Optional.empty()
- : Optional.<AnnotationMirror>of(getOnlyElement(mapKeys));
- }
-
- /**
- * Returns all of the {@link MapKey} annotations that annotate {@code bindingElement}.
- */
- static ImmutableSet<? extends AnnotationMirror> getMapKeys(Element bindingElement) {
- return getAnnotatedAnnotations(bindingElement, MapKey.class);
- }
-
- /**
- * Returns the annotation value if {@code mapKey}'s type is annotated with
- * {@link MapKey @MapKey(unwrapValue = true)}.
- *
- * @throws IllegalArgumentException if {@code mapKey}'s type is not annotated with
- * {@link MapKey @MapKey} at all.
- */
- static Optional<? extends AnnotationValue> unwrapValue(AnnotationMirror mapKey) {
- MapKey mapKeyAnnotation = mapKey.getAnnotationType().asElement().getAnnotation(MapKey.class);
- checkArgument(
- mapKeyAnnotation != null, "%s is not annotated with @MapKey", mapKey.getAnnotationType());
- return mapKeyAnnotation.unwrapValue()
- ? Optional.of(getOnlyElement(getAnnotationValuesWithDefaults(mapKey).values()))
- : Optional.empty();
- }
-
- static TypeMirror mapKeyType(AnnotationMirror mapKeyAnnotation, DaggerTypes types) {
- return unwrapValue(mapKeyAnnotation).isPresent()
- ? getUnwrappedMapKeyType(mapKeyAnnotation.getAnnotationType(), types)
- : mapKeyAnnotation.getAnnotationType();
- }
-
- /**
- * Returns the map key type for an unwrapped {@link MapKey} annotation type. If the single member
- * type is primitive, returns the boxed type.
- *
- * @throws IllegalArgumentException if {@code mapKeyAnnotationType} is not an annotation type or
- * has more than one member, or if its single member is an array
- * @throws NoSuchElementException if the annotation has no members
- */
- static DeclaredType getUnwrappedMapKeyType(
- final DeclaredType mapKeyAnnotationType, final DaggerTypes types) {
- checkArgument(
- MoreTypes.asTypeElement(mapKeyAnnotationType).getKind() == ElementKind.ANNOTATION_TYPE,
- "%s is not an annotation type",
- mapKeyAnnotationType);
-
- final ExecutableElement onlyElement =
- getOnlyElement(methodsIn(mapKeyAnnotationType.asElement().getEnclosedElements()));
-
- SimpleTypeVisitor6<DeclaredType, Void> keyTypeElementVisitor =
- new SimpleTypeVisitor6<DeclaredType, Void>() {
-
- @Override
- public DeclaredType visitArray(ArrayType t, Void p) {
- throw new IllegalArgumentException(
- mapKeyAnnotationType + "." + onlyElement.getSimpleName() + " cannot be an array");
- }
-
- @Override
- public DeclaredType visitPrimitive(PrimitiveType t, Void p) {
- return MoreTypes.asDeclared(types.boxedClass(t).asType());
- }
-
- @Override
- public DeclaredType visitDeclared(DeclaredType t, Void p) {
- return t;
- }
- };
- return keyTypeElementVisitor.visit(onlyElement.getReturnType());
- }
-
- /**
- * Returns a code block for {@code binding}'s {@link ContributionBinding#mapKeyAnnotation() map
- * key}. If for whatever reason the map key is not accessible from within {@code requestingClass}
- * (i.e. it has a package-private {@code enum} from a different package), this will return an
- * invocation of a proxy-method giving it access.
- *
- * @throws IllegalStateException if {@code binding} is not a {@link dagger.multibindings.IntoMap
- * map} contribution.
- */
- static CodeBlock getMapKeyExpression(
- ContributionBinding binding, ClassName requestingClass, DaggerElements elements) {
- AnnotationMirror mapKeyAnnotation = binding.mapKeyAnnotation().get();
- return MapKeyAccessibility.isMapKeyAccessibleFrom(
- mapKeyAnnotation, requestingClass.packageName())
- ? directMapKeyExpression(mapKeyAnnotation, elements)
- : CodeBlock.of("$T.create()", mapKeyProxyClassName(binding));
- }
-
- /**
- * Returns a code block for the map key annotation {@code mapKey}.
- *
- * <p>This method assumes the map key will be accessible in the context that the returned {@link
- * CodeBlock} is used. Use {@link #getMapKeyExpression(ContributionBinding, ClassName,
- * DaggerElements)} when that assumption is not guaranteed.
- *
- * @throws IllegalArgumentException if the element is annotated with more than one {@code MapKey}
- * annotation
- * @throws IllegalStateException if {@code bindingElement} is not annotated with a {@code MapKey}
- * annotation
- */
- private static CodeBlock directMapKeyExpression(
- AnnotationMirror mapKey, DaggerElements elements) {
- Optional<? extends AnnotationValue> unwrappedValue = unwrapValue(mapKey);
- AnnotationExpression annotationExpression = new AnnotationExpression(mapKey);
-
- if (MoreTypes.asTypeElement(mapKey.getAnnotationType())
- .getQualifiedName()
- .contentEquals("dagger.android.AndroidInjectionKey")) {
- TypeElement unwrappedType =
- elements.checkTypePresent((String) unwrappedValue.get().getValue());
- return CodeBlock.of(
- "$T.of($S)",
- ClassName.get("dagger.android.internal", "AndroidInjectionKeys"),
- ClassName.get(unwrappedType).reflectionName());
- }
-
- if (unwrappedValue.isPresent()) {
- TypeMirror unwrappedValueType =
- getOnlyElement(getAnnotationValuesWithDefaults(mapKey).keySet()).getReturnType();
- return annotationExpression.getValueExpression(unwrappedValueType, unwrappedValue.get());
- } else {
- return annotationExpression.getAnnotationInstanceExpression();
- }
- }
-
- /**
- * Returns the {@link ClassName} in which {@link #mapKeyFactoryMethod(ContributionBinding,
- * DaggerTypes, DaggerElements)} is generated.
- */
- static ClassName mapKeyProxyClassName(ContributionBinding binding) {
- return elementBasedClassName(
- MoreElements.asExecutable(binding.bindingElement().get()), "MapKey");
- }
-
- /**
- * A {@code static create()} method to be added to {@link
- * #mapKeyProxyClassName(ContributionBinding)} when the {@code @MapKey} annotation is not publicly
- * accessible.
- */
- static Optional<MethodSpec> mapKeyFactoryMethod(
- ContributionBinding binding, DaggerTypes types, DaggerElements elements) {
- return binding
- .mapKeyAnnotation()
- .filter(mapKey -> !isMapKeyPubliclyAccessible(mapKey))
- .map(
- mapKey ->
- methodBuilder("create")
- .addModifiers(PUBLIC, STATIC)
- .returns(TypeName.get(mapKeyType(mapKey, types)))
- .addStatement("return $L", directMapKeyExpression(mapKey, elements))
- .build());
- }
-
- private MapKeys() {}
-}
diff --git a/java/dagger/internal/codegen/MapMultibindingValidator.java b/java/dagger/internal/codegen/MapMultibindingValidator.java
deleted file mode 100644
index 346d271..0000000
--- a/java/dagger/internal/codegen/MapMultibindingValidator.java
+++ /dev/null
@@ -1,199 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.collect.Multimaps.filterKeys;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSetMultimap;
-import static dagger.internal.codegen.Formatter.INDENT;
-import static dagger.model.BindingKind.MULTIBOUND_MAP;
-import static javax.tools.Diagnostic.Kind.ERROR;
-
-import com.google.auto.common.MoreTypes;
-import com.google.common.base.Equivalence;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableSetMultimap;
-import com.google.common.collect.Multimaps;
-import com.google.common.collect.SetMultimap;
-import dagger.model.BindingGraph;
-import dagger.model.Key;
-import dagger.producers.Producer;
-import dagger.spi.BindingGraphPlugin;
-import dagger.spi.DiagnosticReporter;
-import java.util.Set;
-import javax.inject.Inject;
-import javax.inject.Provider;
-import javax.lang.model.type.DeclaredType;
-
-/**
- * Reports an error for any map binding with either more than one contribution with the same map key
- * or contributions with inconsistent map key annotation types.
- */
-final class MapMultibindingValidator implements BindingGraphPlugin {
-
- private final BindingDeclarationFormatter bindingDeclarationFormatter;
- private final KeyFactory keyFactory;
-
- @Inject
- MapMultibindingValidator(
- BindingDeclarationFormatter bindingDeclarationFormatter, KeyFactory keyFactory) {
- this.bindingDeclarationFormatter = bindingDeclarationFormatter;
- this.keyFactory = keyFactory;
- }
-
- @Override
- public String pluginName() {
- return "Dagger/MapKeys";
- }
-
- @Override
- public void visitGraph(BindingGraph bindingGraph, DiagnosticReporter diagnosticReporter) {
- mapMultibindings(bindingGraph)
- .forEach(
- binding -> {
- ImmutableSet<ContributionBinding> contributions =
- mapBindingContributions(binding, bindingGraph);
- checkForDuplicateMapKeys(binding, contributions, diagnosticReporter);
- checkForInconsistentMapKeyAnnotationTypes(binding, contributions, diagnosticReporter);
- });
- }
-
- /**
- * Returns the map multibindings in the binding graph. If a graph contains bindings for more than
- * one of the following for the same {@code K} and {@code V}, then only the first one found will
- * be returned so we don't report the same map contribution problem more than once.
- *
- * <ol>
- * <li>{@code Map<K, V>}
- * <li>{@code Map<K, Provider<V>>}
- * <li>{@code Map<K, Producer<V>>}
- * </ol>
- */
- private ImmutableSet<dagger.model.Binding> mapMultibindings(BindingGraph bindingGraph) {
- ImmutableSetMultimap<Key, dagger.model.Binding> mapMultibindings =
- bindingGraph.bindings().stream()
- .filter(node -> node.kind().equals(MULTIBOUND_MAP))
- .collect(toImmutableSetMultimap(dagger.model.Binding::key, node -> node));
-
- // Mutlbindings for Map<K, V>
- SetMultimap<Key, dagger.model.Binding> plainValueMapMultibindings =
- filterKeys(mapMultibindings, key -> !MapType.from(key).valuesAreFrameworkType());
-
- // Multibindings for Map<K, Provider<V>> where Map<K, V> isn't in plainValueMapMultibindings
- SetMultimap<Key, dagger.model.Binding> providerValueMapMultibindings =
- filterKeys(
- mapMultibindings,
- key ->
- MapType.from(key).valuesAreTypeOf(Provider.class)
- && !plainValueMapMultibindings.containsKey(keyFactory.unwrapMapValueType(key)));
-
- // Multibindings for Map<K, Producer<V>> where Map<K, V> isn't in plainValueMapMultibindings and
- // Map<K, Provider<V>> isn't in providerValueMapMultibindings
- SetMultimap<Key, dagger.model.Binding> producerValueMapMultibindings =
- filterKeys(
- mapMultibindings,
- key ->
- MapType.from(key).valuesAreTypeOf(Producer.class)
- && !plainValueMapMultibindings.containsKey(keyFactory.unwrapMapValueType(key))
- && !providerValueMapMultibindings.containsKey(
- keyFactory.rewrapMapKey(key, Producer.class, Provider.class).get()));
-
- return new ImmutableSet.Builder<dagger.model.Binding>()
- .addAll(plainValueMapMultibindings.values())
- .addAll(providerValueMapMultibindings.values())
- .addAll(producerValueMapMultibindings.values())
- .build();
- }
-
- private ImmutableSet<ContributionBinding> mapBindingContributions(
- dagger.model.Binding binding, BindingGraph bindingGraph) {
- checkArgument(binding.kind().equals(MULTIBOUND_MAP));
- return bindingGraph.requestedBindings(binding).stream()
- .map(b -> (BindingNode) b)
- .map(b -> (ContributionBinding) b.delegate())
- .collect(toImmutableSet());
- }
-
- private void checkForDuplicateMapKeys(
- dagger.model.Binding multiboundMapBinding,
- ImmutableSet<ContributionBinding> contributions,
- DiagnosticReporter diagnosticReporter) {
- ImmutableSetMultimap<Object, ContributionBinding> contributionsByMapKey =
- ImmutableSetMultimap.copyOf(Multimaps.index(contributions, ContributionBinding::mapKey));
-
- for (Set<ContributionBinding> contributionsForOneMapKey :
- Multimaps.asMap(contributionsByMapKey).values()) {
- if (contributionsForOneMapKey.size() > 1) {
- diagnosticReporter.reportBinding(
- ERROR,
- multiboundMapBinding,
- duplicateMapKeyErrorMessage(contributionsForOneMapKey, multiboundMapBinding.key()));
- }
- }
- }
-
- private void checkForInconsistentMapKeyAnnotationTypes(
- dagger.model.Binding multiboundMapBinding,
- ImmutableSet<ContributionBinding> contributions,
- DiagnosticReporter diagnosticReporter) {
- ImmutableSetMultimap<Equivalence.Wrapper<DeclaredType>, ContributionBinding>
- contributionsByMapKeyAnnotationType = indexByMapKeyAnnotationType(contributions);
-
- if (contributionsByMapKeyAnnotationType.keySet().size() > 1) {
- diagnosticReporter.reportBinding(
- ERROR,
- multiboundMapBinding,
- inconsistentMapKeyAnnotationTypesErrorMessage(
- contributionsByMapKeyAnnotationType, multiboundMapBinding.key()));
- }
- }
-
- private static ImmutableSetMultimap<Equivalence.Wrapper<DeclaredType>, ContributionBinding>
- indexByMapKeyAnnotationType(ImmutableSet<ContributionBinding> contributions) {
- return ImmutableSetMultimap.copyOf(
- Multimaps.index(
- contributions,
- mapBinding ->
- MoreTypes.equivalence()
- .wrap(mapBinding.mapKeyAnnotation().get().getAnnotationType())));
- }
-
- private String inconsistentMapKeyAnnotationTypesErrorMessage(
- ImmutableSetMultimap<Equivalence.Wrapper<DeclaredType>, ContributionBinding>
- contributionsByMapKeyAnnotationType,
- Key mapBindingKey) {
- StringBuilder message =
- new StringBuilder(mapBindingKey.toString())
- .append(" uses more than one @MapKey annotation type");
- Multimaps.asMap(contributionsByMapKeyAnnotationType)
- .forEach(
- (annotationType, contributions) -> {
- message.append('\n').append(INDENT).append(annotationType.get()).append(':');
- bindingDeclarationFormatter.formatIndentedList(message, contributions, 2);
- });
- return message.toString();
- }
-
- private String duplicateMapKeyErrorMessage(
- Set<ContributionBinding> contributionsForOneMapKey, Key mapBindingKey) {
- StringBuilder message =
- new StringBuilder("The same map key is bound more than once for ").append(mapBindingKey);
- bindingDeclarationFormatter.formatIndentedList(message, contributionsForOneMapKey, 1);
- return message.toString();
- }
-}
diff --git a/java/dagger/internal/codegen/MapType.java b/java/dagger/internal/codegen/MapType.java
deleted file mode 100644
index 73ecdbf..0000000
--- a/java/dagger/internal/codegen/MapType.java
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkState;
-
-import com.google.auto.common.MoreTypes;
-import com.google.auto.value.AutoValue;
-import com.google.common.base.Equivalence;
-import dagger.model.Key;
-import java.util.Map;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.TypeMirror;
-
-/**
- * Information about a {@link Map} {@link TypeMirror}.
- */
-@AutoValue
-abstract class MapType {
- /**
- * The map type itself, wrapped using {@link MoreTypes#equivalence()}. Use
- * {@link #declaredMapType()} instead.
- */
- protected abstract Equivalence.Wrapper<DeclaredType> wrappedDeclaredMapType();
-
- /**
- * The map type itself.
- */
- DeclaredType declaredMapType() {
- return wrappedDeclaredMapType().get();
- }
-
- /**
- * {@code true} if the map type is the raw {@link Map} type.
- */
- boolean isRawType() {
- return declaredMapType().getTypeArguments().isEmpty();
- }
-
- /**
- * The map key type.
- *
- * @throws IllegalStateException if {@link #isRawType()} is true.
- */
- TypeMirror keyType() {
- checkState(!isRawType());
- return declaredMapType().getTypeArguments().get(0);
- }
-
- /**
- * The map value type.
- *
- * @throws IllegalStateException if {@link #isRawType()} is true.
- */
- TypeMirror valueType() {
- checkState(!isRawType());
- return declaredMapType().getTypeArguments().get(1);
- }
-
- /**
- * {@code true} if {@link #valueType()} is a {@code clazz}.
- *
- * @throws IllegalStateException if {@link #isRawType()} is true.
- */
- boolean valuesAreTypeOf(Class<?> clazz) {
- return MoreTypes.isType(valueType()) && MoreTypes.isTypeOf(clazz, valueType());
- }
-
- /**
- * Returns {@code true} if the {@linkplain #valueType() value type} of the {@link Map} is a
- * {@linkplain FrameworkTypes#isFrameworkType(TypeMirror) framework type}.
- */
- boolean valuesAreFrameworkType() {
- return FrameworkTypes.isFrameworkType(valueType());
- }
-
- /**
- * {@code V} if {@link #valueType()} is a framework type like {@code Provider<V>} or {@code
- * Producer<V>}.
- *
- * @throws IllegalStateException if {@link #isRawType()} is true or {@link #valueType()} is not a
- * framework type
- */
- TypeMirror unwrappedFrameworkValueType() {
- checkState(
- valuesAreFrameworkType(), "called unwrappedFrameworkValueType() on %s", declaredMapType());
- return uncheckedUnwrappedValueType();
- }
-
- /**
- * {@code V} if {@link #valueType()} is a {@code WrappingClass<V>}.
- *
- * @throws IllegalStateException if {@link #isRawType()} is true or {@link #valueType()} is not a
- * {@code WrappingClass<V>}
- * @throws IllegalArgumentException if {@code wrappingClass} does not have exactly one type
- * parameter
- */
- TypeMirror unwrappedValueType(Class<?> wrappingClass) {
- checkArgument(
- wrappingClass.getTypeParameters().length == 1,
- "%s must have exactly one type parameter",
- wrappingClass);
- checkState(valuesAreTypeOf(wrappingClass), "expected values to be %s: %s", wrappingClass, this);
- return uncheckedUnwrappedValueType();
- }
-
- private TypeMirror uncheckedUnwrappedValueType() {
- return MoreTypes.asDeclared(valueType()).getTypeArguments().get(0);
- }
-
- /**
- * {@code true} if {@code type} is a {@link Map} type.
- */
- static boolean isMap(TypeMirror type) {
- return MoreTypes.isType(type) && MoreTypes.isTypeOf(Map.class, type);
- }
-
- /**
- * {@code true} if {@code key.type()} is a {@link Map} type.
- */
- static boolean isMap(Key key) {
- return isMap(key.type());
- }
-
- /**
- * Returns a {@link MapType} for {@code type}.
- *
- * @throws IllegalArgumentException if {@code type} is not a {@link Map} type
- */
- static MapType from(TypeMirror type) {
- checkArgument(isMap(type), "%s is not a Map", type);
- return new AutoValue_MapType(MoreTypes.equivalence().wrap(MoreTypes.asDeclared(type)));
- }
-
- /**
- * Returns a {@link MapType} for {@code key}'s {@link Key#type() type}.
- *
- * @throws IllegalArgumentException if {@code key.type()} is not a {@link Map} type
- */
- static MapType from(Key key) {
- return from(key.type());
- }
-}
diff --git a/java/dagger/internal/codegen/MemberSelect.java b/java/dagger/internal/codegen/MemberSelect.java
deleted file mode 100644
index c42c7c9..0000000
--- a/java/dagger/internal/codegen/MemberSelect.java
+++ /dev/null
@@ -1,274 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static dagger.internal.codegen.ContributionBinding.FactoryCreationStrategy.SINGLETON_INSTANCE;
-import static dagger.internal.codegen.SourceFiles.bindingTypeElementTypeVariableNames;
-import static dagger.internal.codegen.SourceFiles.generatedClassNameForBinding;
-import static dagger.internal.codegen.SourceFiles.setFactoryClassName;
-import static dagger.internal.codegen.javapoet.CodeBlocks.toParametersCodeBlock;
-import static dagger.internal.codegen.javapoet.TypeNames.FACTORY;
-import static dagger.internal.codegen.javapoet.TypeNames.MAP_FACTORY;
-import static dagger.internal.codegen.javapoet.TypeNames.PRODUCER;
-import static dagger.internal.codegen.javapoet.TypeNames.PRODUCERS;
-import static dagger.internal.codegen.javapoet.TypeNames.PROVIDER;
-import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
-import static javax.lang.model.type.TypeKind.DECLARED;
-
-import com.google.auto.common.MoreTypes;
-import com.google.common.collect.ImmutableList;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.TypeVariableName;
-import dagger.internal.codegen.javapoet.CodeBlocks;
-import java.util.List;
-import java.util.Optional;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.TypeMirror;
-
-/**
- * Represents a {@link com.sun.source.tree.MemberSelectTree} as a {@link CodeBlock}.
- */
-abstract class MemberSelect {
-
- /**
- * Returns a {@link MemberSelect} that accesses the field given by {@code fieldName} owned by
- * {@code owningClass}. In this context "local" refers to the fact that the field is owned by the
- * type (or an enclosing type) from which the code block will be used. The returned
- * {@link MemberSelect} will not be valid for accessing the field from a different class
- * (regardless of accessibility).
- */
- static MemberSelect localField(ClassName owningClass, String fieldName) {
- return new LocalField(owningClass, fieldName);
- }
-
- private static final class LocalField extends MemberSelect {
- final String fieldName;
-
- LocalField(ClassName owningClass, String fieldName) {
- super(owningClass, false);
- this.fieldName = checkNotNull(fieldName);
- }
-
- @Override
- CodeBlock getExpressionFor(ClassName usingClass) {
- return owningClass().equals(usingClass)
- ? CodeBlock.of("$N", fieldName)
- : CodeBlock.of("$T.this.$N", owningClass(), fieldName);
- }
- }
-
- /**
- * Returns a {@link MemberSelect} that accesses the method given by {@code methodName} owned by
- * {@code owningClass}. In this context "local" refers to the fact that the method is owned by the
- * type (or an enclosing type) from which the code block will be used. The returned {@link
- * MemberSelect} will not be valid for accessing the method from a different class (regardless of
- * accessibility).
- */
- static MemberSelect localMethod(ClassName owningClass, String methodName) {
- return new LocalMethod(owningClass, methodName);
- }
-
- private static final class LocalMethod extends MemberSelect {
- final String methodName;
-
- LocalMethod(ClassName owningClass, String methodName) {
- super(owningClass, false);
- this.methodName = checkNotNull(methodName);
- }
-
- @Override
- CodeBlock getExpressionFor(ClassName usingClass) {
- return owningClass().equals(usingClass)
- ? CodeBlock.of("$N()", methodName)
- : CodeBlock.of("$T.this.$N()", owningClass(), methodName);
- }
- }
-
- /**
- * If {@code resolvedBindings} is an unscoped provision binding with no factory arguments or a
- * no-op members injection binding, then we don't need a field to hold its factory. In that case,
- * this method returns the static member select that returns the factory or no-op members
- * injector.
- */
- static Optional<MemberSelect> staticFactoryCreation(ResolvedBindings resolvedBindings) {
- if (resolvedBindings.contributionBindings().isEmpty()) {
- throw new AssertionError(
- "Expected a contribution binding, but none found. *THIS IS A DAGGER BUG* - please "
- + "report it on Github with as much context as you can provide. Thanks!"
- + "\n\nKey: "
- + resolvedBindings.key()
- + "\nMultibinding declarations: "
- + resolvedBindings.multibindingDeclarations()
- + "\nSubcomponent declarations: "
- + resolvedBindings.subcomponentDeclarations()
- + "\nOptional binding declarations: "
- + resolvedBindings.optionalBindingDeclarations());
- }
- ContributionBinding contributionBinding = resolvedBindings.contributionBinding();
- if (contributionBinding.factoryCreationStrategy().equals(SINGLETON_INSTANCE)
- && !contributionBinding.scope().isPresent()) {
- switch (contributionBinding.kind()) {
- case MULTIBOUND_MAP:
- return Optional.of(emptyMapFactory(contributionBinding));
-
- case MULTIBOUND_SET:
- return Optional.of(emptySetFactory(contributionBinding));
-
- case INJECTION:
- case PROVISION:
- TypeMirror keyType = resolvedBindings.key().type();
- if (keyType.getKind().equals(DECLARED)) {
- ImmutableList<TypeVariableName> typeVariables =
- bindingTypeElementTypeVariableNames(contributionBinding);
- if (!typeVariables.isEmpty()) {
- List<? extends TypeMirror> typeArguments =
- ((DeclaredType) keyType).getTypeArguments();
- return Optional.of(
- MemberSelect.parameterizedFactoryCreateMethod(
- generatedClassNameForBinding(contributionBinding), typeArguments));
- }
- }
- // fall through
-
- default:
- return Optional.of(
- new StaticMethod(
- generatedClassNameForBinding(contributionBinding), CodeBlock.of("create()")));
- }
- }
-
- return Optional.empty();
- }
-
- /**
- * Returns a {@link MemberSelect} for the instance of a {@code create()} method on a factory. This
- * only applies for factories that do not have any dependencies.
- */
- private static MemberSelect parameterizedFactoryCreateMethod(
- ClassName owningClass, List<? extends TypeMirror> parameters) {
- return new ParameterizedStaticMethod(
- owningClass, ImmutableList.copyOf(parameters), CodeBlock.of("create()"), FACTORY);
- }
-
- private static final class StaticMethod extends MemberSelect {
- final CodeBlock methodCodeBlock;
-
- StaticMethod(ClassName owningClass, CodeBlock methodCodeBlock) {
- super(owningClass, true);
- this.methodCodeBlock = checkNotNull(methodCodeBlock);
- }
-
- @Override
- CodeBlock getExpressionFor(ClassName usingClass) {
- return owningClass().equals(usingClass)
- ? methodCodeBlock
- : CodeBlock.of("$T.$L", owningClass(), methodCodeBlock);
- }
- }
-
- /** A {@link MemberSelect} for a factory of an empty map. */
- private static MemberSelect emptyMapFactory(ContributionBinding contributionBinding) {
- BindingType bindingType = contributionBinding.bindingType();
- ImmutableList<TypeMirror> typeParameters =
- ImmutableList.copyOf(
- MoreTypes.asDeclared(contributionBinding.key().type()).getTypeArguments());
- if (bindingType.equals(BindingType.PRODUCTION)) {
- return new ParameterizedStaticMethod(
- PRODUCERS, typeParameters, CodeBlock.of("emptyMapProducer()"), PRODUCER);
- } else {
- return new ParameterizedStaticMethod(
- MAP_FACTORY, typeParameters, CodeBlock.of("emptyMapProvider()"), PROVIDER);
- }
- }
-
- /**
- * A static member select for an empty set factory. Calls {@link
- * dagger.internal.SetFactory#empty()}, {@link dagger.producers.internal.SetProducer#empty()}, or
- * {@link dagger.producers.internal.SetOfProducedProducer#empty()}, depending on the set bindings.
- */
- private static MemberSelect emptySetFactory(ContributionBinding binding) {
- return new ParameterizedStaticMethod(
- setFactoryClassName(binding),
- ImmutableList.of(SetType.from(binding.key()).elementType()),
- CodeBlock.of("empty()"),
- FACTORY);
- }
-
- private static final class ParameterizedStaticMethod extends MemberSelect {
- final ImmutableList<TypeMirror> typeParameters;
- final CodeBlock methodCodeBlock;
- final ClassName rawReturnType;
-
- ParameterizedStaticMethod(
- ClassName owningClass,
- ImmutableList<TypeMirror> typeParameters,
- CodeBlock methodCodeBlock,
- ClassName rawReturnType) {
- super(owningClass, true);
- this.typeParameters = typeParameters;
- this.methodCodeBlock = methodCodeBlock;
- this.rawReturnType = rawReturnType;
- }
-
- @Override
- CodeBlock getExpressionFor(ClassName usingClass) {
- boolean accessible = true;
- for (TypeMirror typeParameter : typeParameters) {
- accessible &= isTypeAccessibleFrom(typeParameter, usingClass.packageName());
- }
-
- if (accessible) {
- return CodeBlock.of(
- "$T.<$L>$L",
- owningClass(),
- typeParameters.stream().map(CodeBlocks::type).collect(toParametersCodeBlock()),
- methodCodeBlock);
- } else {
- return CodeBlock.of("(($T) $T.$L)", rawReturnType, owningClass(), methodCodeBlock);
- }
- }
- }
-
- private final ClassName owningClass;
- private final boolean staticMember;
-
- MemberSelect(ClassName owningClass, boolean staticMemeber) {
- this.owningClass = owningClass;
- this.staticMember = staticMemeber;
- }
-
- /** Returns the class that owns the member being selected. */
- ClassName owningClass() {
- return owningClass;
- }
-
- /**
- * Returns true if the member being selected is static and does not require an instance of
- * {@link #owningClass()}.
- */
- boolean staticMember() {
- return staticMember;
- }
-
- /**
- * Returns a {@link CodeBlock} suitable for accessing the member from the given {@code
- * usingClass}.
- */
- abstract CodeBlock getExpressionFor(ClassName usingClass);
-}
diff --git a/java/dagger/internal/codegen/MembersInjectionBinding.java b/java/dagger/internal/codegen/MembersInjectionBinding.java
deleted file mode 100644
index 4918fa1..0000000
--- a/java/dagger/internal/codegen/MembersInjectionBinding.java
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreElements.isAnnotationPresent;
-import static java.util.stream.Collectors.toList;
-
-import com.google.auto.value.AutoValue;
-import com.google.auto.value.extension.memoized.Memoized;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableSortedSet;
-import dagger.model.BindingKind;
-import dagger.model.DependencyRequest;
-import java.util.Optional;
-import javax.inject.Inject;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.Modifier;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.element.VariableElement;
-
-/**
- * Represents the full members injection of a particular type.
- */
-@AutoValue
-abstract class MembersInjectionBinding extends Binding {
- @Override
- public final Optional<Element> bindingElement() {
- return Optional.of(membersInjectedType());
- }
-
- abstract TypeElement membersInjectedType();
-
- @Override
- abstract Optional<MembersInjectionBinding> unresolved();
-
- @Override
- public Optional<TypeElement> contributingModule() {
- return Optional.empty();
- }
-
- /** The set of individual sites where {@link Inject} is applied. */
- abstract ImmutableSortedSet<InjectionSite> injectionSites();
-
- @Override
- BindingType bindingType() {
- return BindingType.MEMBERS_INJECTION;
- }
-
- @Override
- public BindingKind kind() {
- return BindingKind.MEMBERS_INJECTION;
- }
-
- @Override
- public boolean isNullable() {
- return false;
- }
-
- /**
- * Returns {@code true} if any of this binding's injection sites are directly on the bound type.
- */
- boolean hasLocalInjectionSites() {
- return injectionSites()
- .stream()
- .anyMatch(
- injectionSite ->
- injectionSite.element().getEnclosingElement().equals(membersInjectedType()));
- }
-
- @Override
- boolean requiresModuleInstance() {
- return false;
- }
-
- @Memoized
- @Override
- public abstract int hashCode();
-
- // TODO(ronshapiro,dpb): simplify the equality semantics
- @Override
- public abstract boolean equals(Object obj);
-
- @AutoValue
- abstract static class InjectionSite {
- enum Kind {
- FIELD,
- METHOD,
- }
-
- abstract Kind kind();
-
- abstract Element element();
-
- abstract ImmutableSet<DependencyRequest> dependencies();
-
- /**
- * Returns the index of {@link #element()} in its parents {@code @Inject} members that have the
- * same simple name. This method filters out private elements so that the results will be
- * consistent independent of whether the build system uses header jars or not.
- */
- @Memoized
- int indexAmongAtInjectMembersWithSameSimpleName() {
- return element()
- .getEnclosingElement()
- .getEnclosedElements()
- .stream()
- .filter(element -> isAnnotationPresent(element, Inject.class))
- .filter(element -> !element.getModifiers().contains(Modifier.PRIVATE))
- .filter(element -> element.getSimpleName().equals(this.element().getSimpleName()))
- .collect(toList())
- .indexOf(element());
- }
-
- static InjectionSite field(VariableElement element, DependencyRequest dependency) {
- return new AutoValue_MembersInjectionBinding_InjectionSite(
- Kind.FIELD, element, ImmutableSet.of(dependency));
- }
-
- static InjectionSite method(
- ExecutableElement element, Iterable<DependencyRequest> dependencies) {
- return new AutoValue_MembersInjectionBinding_InjectionSite(
- Kind.METHOD, element, ImmutableSet.copyOf(dependencies));
- }
- }
-}
diff --git a/java/dagger/internal/codegen/MembersInjectionBindingExpression.java b/java/dagger/internal/codegen/MembersInjectionBindingExpression.java
deleted file mode 100644
index e9a8ffc..0000000
--- a/java/dagger/internal/codegen/MembersInjectionBindingExpression.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static javax.lang.model.type.TypeKind.VOID;
-
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.ParameterSpec;
-import dagger.internal.codegen.ComponentDescriptor.ComponentMethodDescriptor;
-import dagger.internal.codegen.javapoet.Expression;
-import javax.lang.model.element.ExecutableElement;
-
-/**
- * A binding expression for members injection component methods. See {@link
- * MembersInjectionMethods}.
- */
-final class MembersInjectionBindingExpression extends BindingExpression {
- private final MembersInjectionBinding binding;
- private final MembersInjectionMethods membersInjectionMethods;
-
- MembersInjectionBindingExpression(
- ResolvedBindings resolvedBindings, MembersInjectionMethods membersInjectionMethods) {
- this.binding = resolvedBindings.membersInjectionBinding().get();
- this.membersInjectionMethods = membersInjectionMethods;
- }
-
- @Override
- Expression getDependencyExpression(ClassName requestingClass) {
- throw new UnsupportedOperationException(binding.toString());
- }
-
- // TODO(ronshapiro): This class doesn't need to be a BindingExpression, as
- // getDependencyExpression() should never be called for members injection methods. It's probably
- // better suited as a method on MembersInjectionMethods
- @Override
- protected CodeBlock getComponentMethodImplementation(
- ComponentMethodDescriptor componentMethod, ComponentImplementation component) {
- ExecutableElement methodElement = componentMethod.methodElement();
- ParameterSpec parameter = ParameterSpec.get(getOnlyElement(methodElement.getParameters()));
-
- if (binding.injectionSites().isEmpty()) {
- return methodElement.getReturnType().getKind().equals(VOID)
- ? CodeBlock.of("")
- : CodeBlock.of("return $N;", parameter);
- } else {
- return methodElement.getReturnType().getKind().equals(VOID)
- ? CodeBlock.of("$L;", membersInjectionInvocation(parameter))
- : CodeBlock.of("return $L;", membersInjectionInvocation(parameter));
- }
- }
-
- CodeBlock membersInjectionInvocation(ParameterSpec target) {
- return CodeBlock.of("$N($N)", membersInjectionMethods.getOrCreate(binding.key()), target);
- }
-}
diff --git a/java/dagger/internal/codegen/MembersInjectionMethods.java b/java/dagger/internal/codegen/MembersInjectionMethods.java
deleted file mode 100644
index 1e04669..0000000
--- a/java/dagger/internal/codegen/MembersInjectionMethods.java
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.squareup.javapoet.MethodSpec.methodBuilder;
-import static dagger.internal.codegen.ComponentImplementation.MethodSpecKind.MEMBERS_INJECTION_METHOD;
-import static dagger.internal.codegen.Util.reentrantComputeIfAbsent;
-import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
-import static javax.lang.model.element.Modifier.PRIVATE;
-
-import com.google.common.collect.ImmutableSet;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.MethodSpec;
-import com.squareup.javapoet.ParameterSpec;
-import com.squareup.javapoet.TypeName;
-import dagger.internal.codegen.InjectionMethods.InjectionSiteMethod;
-import dagger.internal.codegen.MembersInjectionBinding.InjectionSite;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.Key;
-import java.util.LinkedHashMap;
-import java.util.Map;
-import javax.lang.model.element.Name;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.TypeMirror;
-
-/** Manages the member injection methods for a component. */
-final class MembersInjectionMethods {
- private final Map<Key, MethodSpec> membersInjectionMethods = new LinkedHashMap<>();
- private final ComponentImplementation componentImplementation;
- private final ComponentBindingExpressions bindingExpressions;
- private final BindingGraph graph;
- private final DaggerElements elements;
- private final DaggerTypes types;
-
- MembersInjectionMethods(
- ComponentImplementation componentImplementation,
- ComponentBindingExpressions bindingExpressions,
- BindingGraph graph,
- DaggerElements elements,
- DaggerTypes types) {
- this.componentImplementation = checkNotNull(componentImplementation);
- this.bindingExpressions = checkNotNull(bindingExpressions);
- this.graph = checkNotNull(graph);
- this.elements = checkNotNull(elements);
- this.types = checkNotNull(types);
- }
-
- /**
- * Returns the members injection {@link MethodSpec} for the given {@link Key}, creating it if
- * necessary.
- */
- MethodSpec getOrCreate(Key key) {
- return reentrantComputeIfAbsent(membersInjectionMethods, key, this::membersInjectionMethod);
- }
-
- private MethodSpec membersInjectionMethod(Key key) {
- ResolvedBindings resolvedBindings =
- graph.membersInjectionBindings().getOrDefault(key, graph.contributionBindings().get(key));
- Binding binding = resolvedBindings.binding();
- TypeMirror keyType = binding.key().type();
- TypeMirror membersInjectedType =
- isTypeAccessibleFrom(keyType, componentImplementation.name().packageName())
- ? keyType
- : elements.getTypeElement(Object.class).asType();
- TypeName membersInjectedTypeName = TypeName.get(membersInjectedType);
- Name bindingTypeName = binding.bindingTypeElement().get().getSimpleName();
- // TODO(ronshapiro): include type parameters in this name e.g. injectFooOfT, and outer class
- // simple names Foo.Builder -> injectFooBuilder
- String methodName = componentImplementation.getUniqueMethodName("inject" + bindingTypeName);
- ParameterSpec parameter = ParameterSpec.builder(membersInjectedTypeName, "instance").build();
- MethodSpec.Builder methodBuilder =
- methodBuilder(methodName)
- .addModifiers(PRIVATE)
- .returns(membersInjectedTypeName)
- .addParameter(parameter);
- TypeElement canIgnoreReturnValue =
- elements.getTypeElement("com.google.errorprone.annotations.CanIgnoreReturnValue");
- if (canIgnoreReturnValue != null) {
- methodBuilder.addAnnotation(ClassName.get(canIgnoreReturnValue));
- }
- CodeBlock instance = CodeBlock.of("$N", parameter);
- methodBuilder.addCode(
- InjectionSiteMethod.invokeAll(
- injectionSites(binding),
- componentImplementation.name(),
- instance,
- membersInjectedType,
- types,
- request ->
- bindingExpressions
- .getDependencyArgumentExpression(request, componentImplementation.name())
- .codeBlock(),
- elements));
- methodBuilder.addStatement("return $L", instance);
-
- MethodSpec method = methodBuilder.build();
- componentImplementation.addMethod(MEMBERS_INJECTION_METHOD, method);
- return method;
- }
-
- private static ImmutableSet<InjectionSite> injectionSites(Binding binding) {
- if (binding instanceof ProvisionBinding) {
- return ((ProvisionBinding) binding).injectionSites();
- } else if (binding instanceof MembersInjectionBinding) {
- return ((MembersInjectionBinding) binding).injectionSites();
- }
- throw new IllegalArgumentException(binding.key().toString());
- }
-}
diff --git a/java/dagger/internal/codegen/MembersInjectionValidator.java b/java/dagger/internal/codegen/MembersInjectionValidator.java
deleted file mode 100644
index 036315e..0000000
--- a/java/dagger/internal/codegen/MembersInjectionValidator.java
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static dagger.internal.codegen.InjectionAnnotations.getQualifiers;
-
-import com.google.auto.common.MoreElements;
-import javax.inject.Inject;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.type.ArrayType;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.PrimitiveType;
-import javax.lang.model.type.TypeMirror;
-import javax.lang.model.type.TypeVisitor;
-import javax.lang.model.util.SimpleTypeVisitor8;
-
-/**
- * Validates members injection requests (members injection methods on components and requests for
- * {@code MembersInjector<Foo>}).
- */
-final class MembersInjectionValidator {
-
- @Inject
- MembersInjectionValidator() {}
-
- /** Reports errors if a request for a {@code MembersInjector<Foo>}) is invalid. */
- ValidationReport<Element> validateMembersInjectionRequest(
- Element requestElement, TypeMirror membersInjectedType) {
- ValidationReport.Builder<Element> report = ValidationReport.about(requestElement);
- checkQualifiers(report, requestElement);
- membersInjectedType.accept(VALIDATE_MEMBERS_INJECTED_TYPE, report);
- return report.build();
- }
-
- /**
- * Reports errors if a members injection method on a component is invalid.
- *
- * @throws IllegalArgumentException if the method doesn't have exactly one parameter
- */
- ValidationReport<ExecutableElement> validateMembersInjectionMethod(
- ExecutableElement method, TypeMirror membersInjectedType) {
- checkArgument(
- method.getParameters().size() == 1, "expected a method with one parameter: %s", method);
-
- ValidationReport.Builder<ExecutableElement> report = ValidationReport.about(method);
- checkQualifiers(report, method);
- checkQualifiers(report, method.getParameters().get(0));
- membersInjectedType.accept(VALIDATE_MEMBERS_INJECTED_TYPE, report);
- return report.build();
- }
-
- private void checkQualifiers(ValidationReport.Builder<?> report, Element element) {
- for (AnnotationMirror qualifier : getQualifiers(element)) {
- report.addError("Cannot inject members into qualified types", element, qualifier);
- break; // just report on the first qualifier, in case there is more than one
- }
- }
-
- private static final TypeVisitor<Void, ValidationReport.Builder<?>>
- VALIDATE_MEMBERS_INJECTED_TYPE =
- new SimpleTypeVisitor8<Void, ValidationReport.Builder<?>>() {
- // Only declared types can be members-injected.
- @Override
- protected Void defaultAction(TypeMirror type, ValidationReport.Builder<?> report) {
- report.addError("Cannot inject members into " + type);
- return null;
- }
-
- @Override
- public Void visitDeclared(DeclaredType type, ValidationReport.Builder<?> report) {
- if (type.getTypeArguments().isEmpty()) {
- // If the type is the erasure of a generic type, that means the user referred to
- // Foo<T> as just 'Foo', which we don't allow. (This is a judgement call; we
- // *could* allow it and instantiate the type bounds, but we don't.)
- if (!MoreElements.asType(type.asElement()).getTypeParameters().isEmpty()) {
- report.addError("Cannot inject members into raw type " + type);
- }
- } else {
- // If the type has arguments, validate that each type argument is declared.
- // Otherwise the type argument may be a wildcard (or other type), and we can't
- // resolve that to actual types. For array type arguments, validate the type of the
- // array.
- for (TypeMirror arg : type.getTypeArguments()) {
- if (!arg.accept(DECLARED_OR_ARRAY, null)) {
- report.addError(
- "Cannot inject members into types with unbounded type arguments: " + type);
- }
- }
- }
- return null;
- }
- };
-
- // TODO(dpb): Can this be inverted so it explicitly rejects wildcards or type variables?
- // This logic is hard to describe.
- private static final TypeVisitor<Boolean, Void> DECLARED_OR_ARRAY =
- new SimpleTypeVisitor8<Boolean, Void>(false) {
- @Override
- public Boolean visitArray(ArrayType arrayType, Void p) {
- return arrayType
- .getComponentType()
- .accept(
- new SimpleTypeVisitor8<Boolean, Void>(false) {
- @Override
- public Boolean visitDeclared(DeclaredType declaredType, Void p) {
- for (TypeMirror arg : declaredType.getTypeArguments()) {
- if (!arg.accept(this, null)) {
- return false;
- }
- }
- return true;
- }
-
- @Override
- public Boolean visitArray(ArrayType arrayType, Void p) {
- return arrayType.getComponentType().accept(this, null);
- }
-
- @Override
- public Boolean visitPrimitive(PrimitiveType primitiveType, Void p) {
- return true;
- }
- },
- null);
- }
-
- @Override
- public Boolean visitDeclared(DeclaredType t, Void p) {
- return true;
- }
- };
-}
diff --git a/java/dagger/internal/codegen/MembersInjectorGenerator.java b/java/dagger/internal/codegen/MembersInjectorGenerator.java
deleted file mode 100644
index 4360af7..0000000
--- a/java/dagger/internal/codegen/MembersInjectorGenerator.java
+++ /dev/null
@@ -1,204 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkState;
-import static com.squareup.javapoet.MethodSpec.constructorBuilder;
-import static com.squareup.javapoet.MethodSpec.methodBuilder;
-import static com.squareup.javapoet.TypeSpec.classBuilder;
-import static dagger.internal.codegen.GwtCompatibility.gwtIncompatibleAnnotation;
-import static dagger.internal.codegen.SourceFiles.bindingTypeElementTypeVariableNames;
-import static dagger.internal.codegen.SourceFiles.frameworkFieldUsages;
-import static dagger.internal.codegen.SourceFiles.generateBindingFieldsForDependencies;
-import static dagger.internal.codegen.SourceFiles.membersInjectorNameForType;
-import static dagger.internal.codegen.SourceFiles.parameterizedGeneratedTypeNameForBinding;
-import static dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression.RAWTYPES;
-import static dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression.UNCHECKED;
-import static dagger.internal.codegen.javapoet.AnnotationSpecs.suppressWarnings;
-import static dagger.internal.codegen.javapoet.CodeBlocks.toParametersCodeBlock;
-import static dagger.internal.codegen.javapoet.TypeNames.membersInjectorOf;
-import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
-import static javax.lang.model.element.Modifier.FINAL;
-import static javax.lang.model.element.Modifier.PRIVATE;
-import static javax.lang.model.element.Modifier.PUBLIC;
-import static javax.lang.model.element.Modifier.STATIC;
-
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.FieldSpec;
-import com.squareup.javapoet.MethodSpec;
-import com.squareup.javapoet.ParameterSpec;
-import com.squareup.javapoet.TypeName;
-import com.squareup.javapoet.TypeSpec;
-import com.squareup.javapoet.TypeVariableName;
-import dagger.MembersInjector;
-import dagger.internal.codegen.InjectionMethods.InjectionSiteMethod;
-import dagger.internal.codegen.MembersInjectionBinding.InjectionSite;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.Key;
-import java.util.Map.Entry;
-import java.util.Optional;
-import javax.annotation.processing.Filer;
-import javax.inject.Inject;
-import javax.lang.model.SourceVersion;
-import javax.lang.model.element.Element;
-
-/**
- * Generates {@link MembersInjector} implementations from {@link MembersInjectionBinding} instances.
- */
-final class MembersInjectorGenerator extends SourceFileGenerator<MembersInjectionBinding> {
- private final DaggerTypes types;
- private final DaggerElements elements;
-
- @Inject
- MembersInjectorGenerator(
- Filer filer, DaggerElements elements, DaggerTypes types, SourceVersion sourceVersion) {
- super(filer, elements, sourceVersion);
- this.types = types;
- this.elements = elements;
- }
-
- @Override
- ClassName nameGeneratedType(MembersInjectionBinding binding) {
- return membersInjectorNameForType(binding.membersInjectedType());
- }
-
- @Override
- Element originatingElement(MembersInjectionBinding binding) {
- return binding.membersInjectedType();
- }
-
- @Override
- Optional<TypeSpec.Builder> write(ClassName generatedTypeName, MembersInjectionBinding binding) {
- // Empty members injection bindings are special and don't need source files.
- if (binding.injectionSites().isEmpty()) {
- return Optional.empty();
- }
- // We don't want to write out resolved bindings -- we want to write out the generic version.
- checkState(
- !binding.unresolved().isPresent(),
- "tried to generate a MembersInjector for a binding of a resolved generic type: %s",
- binding);
-
- ImmutableList<TypeVariableName> typeParameters = bindingTypeElementTypeVariableNames(binding);
- TypeSpec.Builder injectorTypeBuilder =
- classBuilder(generatedTypeName)
- .addModifiers(PUBLIC, FINAL)
- .addTypeVariables(typeParameters);
-
- TypeName injectedTypeName = TypeName.get(binding.key().type());
- TypeName implementedType = membersInjectorOf(injectedTypeName);
- injectorTypeBuilder.addSuperinterface(implementedType);
-
- MethodSpec.Builder injectMembersBuilder =
- methodBuilder("injectMembers")
- .addModifiers(PUBLIC)
- .addAnnotation(Override.class)
- .addParameter(injectedTypeName, "instance");
-
- ImmutableMap<Key, FrameworkField> fields = generateBindingFieldsForDependencies(binding);
-
- ImmutableMap.Builder<Key, FieldSpec> dependencyFieldsBuilder = ImmutableMap.builder();
-
- MethodSpec.Builder constructorBuilder = constructorBuilder().addModifiers(PUBLIC);
-
- // We use a static create method so that generated components can avoid having
- // to refer to the generic types of the factory.
- // (Otherwise they may have visibility problems referring to the types.)
- MethodSpec.Builder createMethodBuilder =
- methodBuilder("create")
- .returns(implementedType)
- .addModifiers(PUBLIC, STATIC)
- .addTypeVariables(typeParameters);
-
- createMethodBuilder.addCode(
- "return new $T(", parameterizedGeneratedTypeNameForBinding(binding));
- ImmutableList.Builder<CodeBlock> constructorInvocationParameters = ImmutableList.builder();
-
- boolean usesRawFrameworkTypes = false;
- UniqueNameSet fieldNames = new UniqueNameSet();
- for (Entry<Key, FrameworkField> fieldEntry : fields.entrySet()) {
- Key dependencyKey = fieldEntry.getKey();
- FrameworkField bindingField = fieldEntry.getValue();
-
- // If the dependency type is not visible to this members injector, then use the raw framework
- // type for the field.
- boolean useRawFrameworkType =
- !isTypeAccessibleFrom(dependencyKey.type(), generatedTypeName.packageName());
-
- String fieldName = fieldNames.getUniqueName(bindingField.name());
- TypeName fieldType = useRawFrameworkType ? bindingField.type().rawType : bindingField.type();
- FieldSpec.Builder fieldBuilder = FieldSpec.builder(fieldType, fieldName, PRIVATE, FINAL);
- ParameterSpec.Builder parameterBuilder = ParameterSpec.builder(fieldType, fieldName);
-
- // If we're using the raw type for the field, then suppress the injectMembers method's
- // unchecked-type warning and the field's and the constructor and create-method's
- // parameters' raw-type warnings.
- if (useRawFrameworkType) {
- usesRawFrameworkTypes = true;
- fieldBuilder.addAnnotation(suppressWarnings(RAWTYPES));
- parameterBuilder.addAnnotation(suppressWarnings(RAWTYPES));
- }
- constructorBuilder.addParameter(parameterBuilder.build());
- createMethodBuilder.addParameter(parameterBuilder.build());
-
- FieldSpec field = fieldBuilder.build();
- injectorTypeBuilder.addField(field);
- constructorBuilder.addStatement("this.$1N = $1N", field);
- dependencyFieldsBuilder.put(dependencyKey, field);
- constructorInvocationParameters.add(CodeBlock.of("$N", field));
- }
-
- createMethodBuilder.addCode(
- constructorInvocationParameters.build().stream().collect(toParametersCodeBlock()));
- createMethodBuilder.addCode(");");
-
- injectorTypeBuilder.addMethod(constructorBuilder.build());
- injectorTypeBuilder.addMethod(createMethodBuilder.build());
-
- ImmutableMap<Key, FieldSpec> dependencyFields = dependencyFieldsBuilder.build();
-
- injectMembersBuilder.addCode(
- InjectionSiteMethod.invokeAll(
- binding.injectionSites(),
- generatedTypeName,
- CodeBlock.of("instance"),
- binding.key().type(),
- types,
- frameworkFieldUsages(binding.dependencies(), dependencyFields)::get,
- elements));
-
- if (usesRawFrameworkTypes) {
- injectMembersBuilder.addAnnotation(suppressWarnings(UNCHECKED));
- }
- injectorTypeBuilder.addMethod(injectMembersBuilder.build());
-
- for (InjectionSite injectionSite : binding.injectionSites()) {
- if (injectionSite.element().getEnclosingElement().equals(binding.membersInjectedType())) {
- injectorTypeBuilder.addMethod(
- InjectionSiteMethod.create(injectionSite, elements).toMethodSpec());
- }
- }
-
- gwtIncompatibleAnnotation(binding).ifPresent(injectorTypeBuilder::addAnnotation);
-
- return Optional.of(injectorTypeBuilder);
- }
-}
diff --git a/java/dagger/internal/codegen/MembersInjectorProviderCreationExpression.java b/java/dagger/internal/codegen/MembersInjectorProviderCreationExpression.java
deleted file mode 100644
index 8e863e5..0000000
--- a/java/dagger/internal/codegen/MembersInjectorProviderCreationExpression.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static dagger.internal.codegen.SourceFiles.membersInjectorNameForType;
-import static dagger.internal.codegen.javapoet.TypeNames.INSTANCE_FACTORY;
-import static dagger.internal.codegen.javapoet.TypeNames.MEMBERS_INJECTORS;
-
-import com.google.auto.common.MoreTypes;
-import com.squareup.javapoet.CodeBlock;
-import dagger.internal.codegen.FrameworkFieldInitializer.FrameworkInstanceCreationExpression;
-import javax.lang.model.type.TypeMirror;
-
-/** A {@code Provider<MembersInjector<Foo>>} creation expression. */
-final class MembersInjectorProviderCreationExpression
- implements FrameworkInstanceCreationExpression {
-
- private final ComponentBindingExpressions componentBindingExpressions;
- private final ProvisionBinding binding;
-
- MembersInjectorProviderCreationExpression(
- ProvisionBinding binding, ComponentBindingExpressions componentBindingExpressions) {
- this.binding = checkNotNull(binding);
- this.componentBindingExpressions = checkNotNull(componentBindingExpressions);
- }
-
- @Override
- public CodeBlock creationExpression() {
- TypeMirror membersInjectedType =
- getOnlyElement(MoreTypes.asDeclared(binding.key().type()).getTypeArguments());
-
- CodeBlock membersInjector =
- binding.injectionSites().isEmpty()
- ? CodeBlock.of("$T.<$T>noOp()", MEMBERS_INJECTORS, membersInjectedType)
- : CodeBlock.of(
- "$T.create($L)",
- membersInjectorNameForType(MoreTypes.asTypeElement(membersInjectedType)),
- componentBindingExpressions.getCreateMethodArgumentsCodeBlock(binding));
-
- // TODO(ronshapiro): consider adding a MembersInjectorBindingExpression to return this directly
- // (as it's rarely requested as a Provider).
- return CodeBlock.of("$T.create($L)", INSTANCE_FACTORY, membersInjector);
- }
-
- @Override
- public boolean useInnerSwitchingProvider() {
- return !binding.injectionSites().isEmpty();
- }
-}
diff --git a/java/dagger/internal/codegen/MethodBindingExpression.java b/java/dagger/internal/codegen/MethodBindingExpression.java
deleted file mode 100644
index 2120e80..0000000
--- a/java/dagger/internal/codegen/MethodBindingExpression.java
+++ /dev/null
@@ -1,323 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.base.Preconditions.checkState;
-import static dagger.internal.codegen.ComponentImplementation.FieldSpecKind.PRIVATE_METHOD_SCOPED_FIELD;
-import static javax.lang.model.element.Modifier.PRIVATE;
-import static javax.lang.model.element.Modifier.VOLATILE;
-
-import com.google.common.base.Supplier;
-import com.google.common.base.Suppliers;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.FieldSpec;
-import com.squareup.javapoet.TypeName;
-import dagger.internal.DoubleCheck;
-import dagger.internal.MemoizedSentinel;
-import dagger.internal.codegen.ComponentDescriptor.ComponentMethodDescriptor;
-import dagger.internal.codegen.ModifiableBindingMethods.ModifiableBindingMethod;
-import dagger.internal.codegen.javapoet.Expression;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.RequestKind;
-import java.util.Optional;
-import javax.lang.model.type.TypeMirror;
-
-/** A binding expression that wraps another in a nullary method on the component. */
-abstract class MethodBindingExpression extends BindingExpression {
- private final BindingRequest request;
- private final ResolvedBindings resolvedBindings;
- private final ContributionBinding binding;
- private final BindingMethodImplementation bindingMethodImplementation;
- private final ComponentImplementation componentImplementation;
- private final ProducerEntryPointView producerEntryPointView;
- private final BindingExpression wrappedBindingExpression;
- private final DaggerTypes types;
-
- protected MethodBindingExpression(
- BindingRequest request,
- ResolvedBindings resolvedBindings,
- MethodImplementationStrategy methodImplementationStrategy,
- BindingExpression wrappedBindingExpression,
- ComponentImplementation componentImplementation,
- DaggerTypes types) {
- this.request = checkNotNull(request);
- this.resolvedBindings = resolvedBindings;
- this.binding = resolvedBindings.contributionBinding();
- this.bindingMethodImplementation = bindingMethodImplementation(methodImplementationStrategy);
- this.wrappedBindingExpression = checkNotNull(wrappedBindingExpression);
- this.componentImplementation = checkNotNull(componentImplementation);
- this.producerEntryPointView = new ProducerEntryPointView(types);
- this.types = checkNotNull(types);
- }
-
- @Override
- Expression getDependencyExpression(ClassName requestingClass) {
- if (request.frameworkType().isPresent()) {
- // Initializing a framework instance that participates in a cycle requires that the underlying
- // FrameworkInstanceBindingExpression is invoked in order for a cycle to be detected properly.
- // When a MethodBindingExpression wraps a FrameworkInstanceBindingExpression, the wrapped
- // expression will only be invoked once to implement the method body. This is a hack to work
- // around that weirdness - methodImplementation.body() will invoke the framework instance
- // initialization again in case the field is not fully initialized.
- // TODO(b/121196706): use a less hacky approach to fix this bug
- Object unused = methodBody();
- }
-
- addMethod();
- return Expression.create(
- returnType(),
- requestingClass.equals(componentImplementation.name())
- ? CodeBlock.of("$N()", methodName())
- : CodeBlock.of("$T.this.$N()", componentImplementation.name(), methodName()));
- }
-
- @Override
- final CodeBlock getModifiableBindingMethodImplementation(
- ModifiableBindingMethod modifiableBindingMethod,
- ComponentImplementation component,
- DaggerTypes types) {
- // A matching modifiable binding method means that we have previously created the binding method
- // and we are now implementing it. If there is no matching method we need to first create the
- // method. We create the method by deferring to getDependencyExpression (defined above) via a
- // call to super.getModifiableBindingMethodImplementation().
- if (supertypeModifiableBindingMethod().isPresent()) {
- checkState(
- supertypeModifiableBindingMethod().get().fulfillsSameRequestAs(modifiableBindingMethod));
- return methodBody();
- }
- return super.getModifiableBindingMethodImplementation(
- modifiableBindingMethod, component, types);
- }
-
- protected final Optional<ModifiableBindingMethod> supertypeModifiableBindingMethod() {
- return componentImplementation.supertypeModifiableBindingMethod(request);
- }
-
- @Override
- Expression getDependencyExpressionForComponentMethod(ComponentMethodDescriptor componentMethod,
- ComponentImplementation component) {
- return producerEntryPointView
- .getProducerEntryPointField(this, componentMethod, component)
- .orElseGet(
- () -> super.getDependencyExpressionForComponentMethod(componentMethod, component));
- }
-
- /** Adds the method to the component (if necessary) the first time it's called. */
- protected abstract void addMethod();
-
- /** Returns the name of the method to call. */
- protected abstract String methodName();
-
- /**
- * Returns {@code true} if the method of this binding expression is modifiable and is not a
- * component method.
- */
- protected boolean isModifiableImplementationMethod() {
- return false;
- }
-
- /** The method's body. */
- protected final CodeBlock methodBody() {
- return implementation(
- wrappedBindingExpression.getDependencyExpression(componentImplementation.name())
- ::codeBlock);
- }
-
- /** The method's body if this method is a component method. */
- protected final CodeBlock methodBodyForComponentMethod(
- ComponentMethodDescriptor componentMethod) {
- return implementation(
- wrappedBindingExpression.getDependencyExpressionForComponentMethod(
- componentMethod, componentImplementation)
- ::codeBlock);
- }
-
- private CodeBlock implementation(Supplier<CodeBlock> simpleBindingExpression) {
- return bindingMethodImplementation.implementation(simpleBindingExpression);
- }
-
- private BindingMethodImplementation bindingMethodImplementation(
- MethodImplementationStrategy methodImplementationStrategy) {
- switch (methodImplementationStrategy) {
- case SIMPLE:
- return new SimpleMethodImplementation();
- case SINGLE_CHECK:
- return new SingleCheckedMethodImplementation();
- case DOUBLE_CHECK:
- return new DoubleCheckedMethodImplementation();
- }
- throw new AssertionError(methodImplementationStrategy);
- }
-
- /** Returns the return type for the dependency request. */
- protected TypeMirror returnType() {
- if (request.isRequestKind(RequestKind.INSTANCE)
- && binding.contributedPrimitiveType().isPresent()) {
- return binding.contributedPrimitiveType().get();
- }
-
- if (matchingComponentMethod().isPresent()) {
- // Component methods are part of the user-defined API, and thus we must use the user-defined
- // type.
- return matchingComponentMethod().get().resolvedReturnType(types);
- }
-
- // If the component is abstract, this method may be overridden by another implementation in a
- // different package for which requestedType is inaccessible. In order to make that method
- // overridable, we use the publicly accessible type. If the method is private, we don't need to
- // worry about this, and instead just need to check accessibility of the file we're about to
- // write
- TypeMirror requestedType = request.requestedType(binding.contributedType(), types);
- return isModifiableImplementationMethod()
- ? types.publiclyAccessibleType(requestedType)
- : types.accessibleType(requestedType, componentImplementation.name());
- }
-
- private Optional<ComponentMethodDescriptor> matchingComponentMethod() {
- return componentImplementation.componentDescriptor().firstMatchingComponentMethod(request);
- }
-
- /** Strateg for implementing the body of this method. */
- enum MethodImplementationStrategy {
- SIMPLE,
- SINGLE_CHECK,
- DOUBLE_CHECK,
- ;
- }
-
- private abstract static class BindingMethodImplementation {
- /**
- * Returns the method body, which contains zero or more statements (including semicolons).
- *
- * <p>If the implementation has a non-void return type, the body will also include the {@code
- * return} statement.
- *
- * @param simpleBindingExpression the expression to retrieve an instance of this binding without
- * the wrapping method.
- */
- abstract CodeBlock implementation(Supplier<CodeBlock> simpleBindingExpression);
- }
-
- /** Returns the {@code wrappedBindingExpression} directly. */
- private static final class SimpleMethodImplementation extends BindingMethodImplementation {
- @Override
- CodeBlock implementation(Supplier<CodeBlock> simpleBindingExpression) {
- return CodeBlock.of("return $L;", simpleBindingExpression.get());
- }
- }
-
- /**
- * Defines a method body for single checked caching of the given {@code wrappedBindingExpression}.
- */
- private final class SingleCheckedMethodImplementation extends BindingMethodImplementation {
- private final Supplier<FieldSpec> field = Suppliers.memoize(this::createField);
-
- @Override
- CodeBlock implementation(Supplier<CodeBlock> simpleBindingExpression) {
- String fieldExpression = field.get().name.equals("local") ? "this.local" : field.get().name;
-
- CodeBlock.Builder builder = CodeBlock.builder()
- .addStatement("Object local = $N", fieldExpression);
-
- if (isNullable()) {
- builder.beginControlFlow("if (local instanceof $T)", MemoizedSentinel.class);
- } else {
- builder.beginControlFlow("if (local == null)");
- }
-
- return builder
- .addStatement("local = $L", simpleBindingExpression.get())
- .addStatement("$N = ($T) local", fieldExpression, returnType())
- .endControlFlow()
- .addStatement("return ($T) local", returnType())
- .build();
- }
-
- FieldSpec createField() {
- String name =
- componentImplementation.getUniqueFieldName(
- request.isRequestKind(RequestKind.INSTANCE)
- ? KeyVariableNamer.name(binding.key())
- // TODO(ronshapiro): Use KeyVariableNamer directly so we don't need to use a
- // ResolvedBindings instance and construct a whole framework field just to get the
- // name
- : FrameworkField.forResolvedBindings(resolvedBindings, Optional.empty()).name());
-
- FieldSpec.Builder builder = FieldSpec.builder(fieldType(), name, PRIVATE, VOLATILE);
- if (isNullable()) {
- builder.initializer("new $T()", MemoizedSentinel.class);
- }
-
- FieldSpec field = builder.build();
- componentImplementation.addField(PRIVATE_METHOD_SCOPED_FIELD, field);
- return field;
- }
-
- TypeName fieldType() {
- if (isNullable()) {
- // Nullable instances use `MemoizedSentinel` instead of `null` as the initialization value,
- // so the field type must accept that and the return type
- return TypeName.OBJECT;
- }
- TypeName returnType = TypeName.get(returnType());
- return returnType.isPrimitive() ? returnType.box() : returnType;
- }
-
- private boolean isNullable() {
- return request.isRequestKind(RequestKind.INSTANCE) && binding.isNullable();
- }
- }
-
- /**
- * Defines a method body for double checked caching of the given {@code wrappedBindingExpression}.
- */
- private final class DoubleCheckedMethodImplementation extends BindingMethodImplementation {
- private final Supplier<String> fieldName = Suppliers.memoize(this::createField);
-
- @Override
- CodeBlock implementation(Supplier<CodeBlock> simpleBindingExpression) {
- String fieldExpression = fieldName.get().equals("local") ? "this.local" : fieldName.get();
- return CodeBlock.builder()
- .addStatement("$T local = $L", TypeName.OBJECT, fieldExpression)
- .beginControlFlow("if (local instanceof $T)", MemoizedSentinel.class)
- .beginControlFlow("synchronized (local)")
- .addStatement("local = $L", fieldExpression)
- .beginControlFlow("if (local instanceof $T)", MemoizedSentinel.class)
- .addStatement("local = $L", simpleBindingExpression.get())
- .addStatement("$1L = $2T.reentrantCheck($1L, local)", fieldExpression, DoubleCheck.class)
- .endControlFlow()
- .endControlFlow()
- .endControlFlow()
- .addStatement("return ($T) local", returnType())
- .build();
- }
-
- private String createField() {
- String name =
- componentImplementation.getUniqueFieldName(KeyVariableNamer.name(binding.key()));
- componentImplementation.addField(
- PRIVATE_METHOD_SCOPED_FIELD,
- FieldSpec.builder(TypeName.OBJECT, name, PRIVATE, VOLATILE)
- .initializer("new $T()", MemoizedSentinel.class)
- .build());
- return name;
- }
- }
-
-}
diff --git a/java/dagger/internal/codegen/MethodSignature.java b/java/dagger/internal/codegen/MethodSignature.java
deleted file mode 100644
index ef5c9c5..0000000
--- a/java/dagger/internal/codegen/MethodSignature.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.DaggerStreams.toImmutableList;
-
-import com.google.auto.common.MoreTypes;
-import com.google.auto.value.AutoValue;
-import com.google.common.base.Equivalence;
-import com.google.common.collect.ImmutableList;
-import dagger.internal.codegen.ComponentDescriptor.ComponentMethodDescriptor;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import java.util.List;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.ExecutableType;
-import javax.lang.model.type.TypeMirror;
-
-@AutoValue
-abstract class MethodSignature {
-
- abstract String name();
-
- abstract ImmutableList<? extends Equivalence.Wrapper<? extends TypeMirror>> parameterTypes();
-
- abstract ImmutableList<? extends Equivalence.Wrapper<? extends TypeMirror>> thrownTypes();
-
- static MethodSignature forComponentMethod(
- ComponentMethodDescriptor componentMethod, DeclaredType componentType, DaggerTypes types) {
- ExecutableType methodType =
- MoreTypes.asExecutable(types.asMemberOf(componentType, componentMethod.methodElement()));
- return new AutoValue_MethodSignature(
- componentMethod.methodElement().getSimpleName().toString(),
- wrapInEquivalence(methodType.getParameterTypes()),
- wrapInEquivalence(methodType.getThrownTypes()));
- }
-
- private static ImmutableList<? extends Equivalence.Wrapper<? extends TypeMirror>>
- wrapInEquivalence(List<? extends TypeMirror> types) {
- return types.stream().map(MoreTypes.equivalence()::wrap).collect(toImmutableList());
- }
-}
diff --git a/java/dagger/internal/codegen/MethodSignatureFormatter.java b/java/dagger/internal/codegen/MethodSignatureFormatter.java
deleted file mode 100644
index 012d5b0..0000000
--- a/java/dagger/internal/codegen/MethodSignatureFormatter.java
+++ /dev/null
@@ -1,139 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkState;
-import static dagger.internal.codegen.DiagnosticFormatting.stripCommonTypePrefixes;
-import static dagger.internal.codegen.InjectionAnnotations.getQualifier;
-
-import com.google.auto.common.MoreElements;
-import com.google.auto.common.MoreTypes;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Optional;
-import javax.inject.Inject;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.element.VariableElement;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.ExecutableType;
-import javax.lang.model.type.TypeMirror;
-
-/**
- * Formats the signature of an {@link ExecutableElement} suitable for use in error messages.
- */
-final class MethodSignatureFormatter extends Formatter<ExecutableElement> {
- private final DaggerTypes types;
-
- @Inject
- MethodSignatureFormatter(DaggerTypes types) {
- this.types = types;
- }
-
- /**
- * A formatter that uses the type where the method is declared for the annotations and name of the
- * method, but the method's resolved type as a member of {@code declaredType} for the key.
- */
- Formatter<ExecutableElement> typedFormatter(DeclaredType declaredType) {
- return new Formatter<ExecutableElement>() {
- @Override
- public String format(ExecutableElement method) {
- return MethodSignatureFormatter.this.format(
- method,
- MoreTypes.asExecutable(types.asMemberOf(declaredType, method)),
- MoreElements.asType(method.getEnclosingElement()));
- }
- };
- }
-
- @Override public String format(ExecutableElement method) {
- return format(method, Optional.empty());
- }
-
- /**
- * Formats an ExecutableElement as if it were contained within the container, if the container is
- * present.
- */
- public String format(ExecutableElement method, Optional<DeclaredType> container) {
- TypeElement type = MoreElements.asType(method.getEnclosingElement());
- ExecutableType executableType = MoreTypes.asExecutable(method.asType());
- if (container.isPresent()) {
- executableType = MoreTypes.asExecutable(types.asMemberOf(container.get(), method));
- type = MoreElements.asType(container.get().asElement());
- }
- return format(method, executableType, type);
- }
-
- private String format(
- ExecutableElement method, ExecutableType methodType, TypeElement declaringType) {
- StringBuilder builder = new StringBuilder();
- // TODO(cgruber): AnnotationMirror formatter.
- List<? extends AnnotationMirror> annotations = method.getAnnotationMirrors();
- if (!annotations.isEmpty()) {
- Iterator<? extends AnnotationMirror> annotationIterator = annotations.iterator();
- for (int i = 0; annotationIterator.hasNext(); i++) {
- if (i > 0) {
- builder.append(' ');
- }
- builder.append(formatAnnotation(annotationIterator.next()));
- }
- builder.append(' ');
- }
- if (method.getSimpleName().contentEquals("<init>")) {
- builder.append(declaringType.getQualifiedName());
- } else {
- builder
- .append(nameOfType(methodType.getReturnType()))
- .append(' ')
- .append(declaringType.getQualifiedName())
- .append('.')
- .append(method.getSimpleName());
- }
- builder.append('(');
- checkState(method.getParameters().size() == methodType.getParameterTypes().size());
- Iterator<? extends VariableElement> parameters = method.getParameters().iterator();
- Iterator<? extends TypeMirror> parameterTypes = methodType.getParameterTypes().iterator();
- for (int i = 0; parameters.hasNext(); i++) {
- if (i > 0) {
- builder.append(", ");
- }
- appendParameter(builder, parameters.next(), parameterTypes.next());
- }
- builder.append(')');
- return builder.toString();
- }
-
- private static void appendParameter(StringBuilder builder, VariableElement parameter,
- TypeMirror type) {
- getQualifier(parameter)
- .ifPresent(
- qualifier -> {
- builder.append(formatAnnotation(qualifier)).append(' ');
- });
- builder.append(nameOfType(type));
- }
-
- private static String nameOfType(TypeMirror type) {
- return stripCommonTypePrefixes(type.toString());
- }
-
- private static String formatAnnotation(AnnotationMirror annotation) {
- return stripCommonTypePrefixes(annotation.toString());
- }
-}
diff --git a/java/dagger/internal/codegen/MissingBindingExpression.java b/java/dagger/internal/codegen/MissingBindingExpression.java
deleted file mode 100644
index 610d052..0000000
--- a/java/dagger/internal/codegen/MissingBindingExpression.java
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import dagger.internal.codegen.ComponentDescriptor.ComponentMethodDescriptor;
-import dagger.internal.codegen.ModifiableBindingMethods.ModifiableBindingMethod;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import java.util.Optional;
-import javax.lang.model.type.TypeMirror;
-
-/**
- * A {@link ModifiableAbstractMethodBindingExpression} for a binding that is missing when generating
- * the abstract base class implementation of a subcomponent. The (unimplemented) method is added to
- * the {@link ComponentImplementation} when the dependency expression is requested. The method is
- * overridden when generating the implementation of an ancestor component.
- */
-final class MissingBindingExpression extends ModifiableAbstractMethodBindingExpression {
- private final ComponentImplementation componentImplementation;
- private final BindingRequest request;
-
- MissingBindingExpression(
- ComponentImplementation componentImplementation,
- BindingRequest request,
- Optional<ModifiableBindingMethod> matchingModifiableBindingMethod,
- Optional<ComponentMethodDescriptor> matchingComponentMethod,
- DaggerTypes types) {
- super(
- componentImplementation,
- ModifiableBindingType.MISSING,
- request,
- matchingModifiableBindingMethod,
- matchingComponentMethod,
- types);
- this.componentImplementation = componentImplementation;
- this.request = request;
- }
-
- @Override
- String chooseMethodName() {
- return componentImplementation.getUniqueMethodName(request);
- }
-
- @Override
- protected TypeMirror contributedType() {
- return request.key().type();
- }
-}
diff --git a/java/dagger/internal/codegen/MissingBindingValidator.java b/java/dagger/internal/codegen/MissingBindingValidator.java
deleted file mode 100644
index f39361d..0000000
--- a/java/dagger/internal/codegen/MissingBindingValidator.java
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Verify.verify;
-import static dagger.internal.codegen.DaggerStreams.instancesOf;
-import static dagger.internal.codegen.Keys.isValidImplicitProvisionKey;
-import static dagger.internal.codegen.Keys.isValidMembersInjectionKey;
-import static dagger.internal.codegen.RequestKinds.canBeSatisfiedByProductionBinding;
-import static javax.tools.Diagnostic.Kind.ERROR;
-
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.BindingGraph;
-import dagger.model.BindingGraph.ComponentNode;
-import dagger.model.BindingGraph.DependencyEdge;
-import dagger.model.BindingGraph.MissingBinding;
-import dagger.model.BindingGraph.Node;
-import dagger.model.Key;
-import dagger.spi.BindingGraphPlugin;
-import dagger.spi.DiagnosticReporter;
-import javax.inject.Inject;
-import javax.lang.model.type.TypeKind;
-
-/** Reports errors for missing bindings. */
-final class MissingBindingValidator implements BindingGraphPlugin {
-
- private final DaggerTypes types;
- private final InjectBindingRegistry injectBindingRegistry;
-
- @Inject
- MissingBindingValidator(
- DaggerTypes types, InjectBindingRegistry injectBindingRegistry) {
- this.types = types;
- this.injectBindingRegistry = injectBindingRegistry;
- }
-
- @Override
- public String pluginName() {
- return "Dagger/MissingBinding";
- }
-
- @Override
- public void visitGraph(BindingGraph graph, DiagnosticReporter diagnosticReporter) {
- // Don't report missing bindings when validating a full binding graph or a graph built from a
- // subcomponent.
- if (graph.isFullBindingGraph() || graph.rootComponentNode().isSubcomponent()) {
- return;
- }
- graph
- .missingBindings()
- .forEach(missingBinding -> reportMissingBinding(missingBinding, graph, diagnosticReporter));
- }
-
- private void reportMissingBinding(
- MissingBinding missingBinding, BindingGraph graph, DiagnosticReporter diagnosticReporter) {
- diagnosticReporter.reportBinding(
- ERROR, missingBinding, missingBindingErrorMessage(missingBinding, graph));
- }
-
- private String missingBindingErrorMessage(MissingBinding missingBinding, BindingGraph graph) {
- Key key = missingBinding.key();
- StringBuilder errorMessage = new StringBuilder();
- // Wildcards should have already been checked by DependencyRequestValidator.
- verify(!key.type().getKind().equals(TypeKind.WILDCARD), "unexpected wildcard request: %s", key);
- // TODO(ronshapiro): replace "provided" with "satisfied"?
- errorMessage.append(key).append(" cannot be provided without ");
- if (isValidImplicitProvisionKey(key, types)) {
- errorMessage.append("an @Inject constructor or ");
- }
- errorMessage.append("an @Provides-"); // TODO(dpb): s/an/a
- if (allIncomingDependenciesCanUseProduction(missingBinding, graph)) {
- errorMessage.append(" or @Produces-");
- }
- errorMessage.append("annotated method.");
- if (isValidMembersInjectionKey(key) && typeHasInjectionSites(key)) {
- errorMessage.append(
- " This type supports members injection but cannot be implicitly provided.");
- }
- graph.bindings(key).stream()
- .map(binding -> binding.componentPath().currentComponent())
- .distinct()
- .forEach(
- component ->
- errorMessage
- .append("\nA binding with matching key exists in component: ")
- .append(component.getQualifiedName()));
- return errorMessage.toString();
- }
-
- private boolean allIncomingDependenciesCanUseProduction(
- MissingBinding missingBinding, BindingGraph graph) {
- return graph.network().inEdges(missingBinding).stream()
- .flatMap(instancesOf(DependencyEdge.class))
- .allMatch(edge -> dependencyCanBeProduction(edge, graph));
- }
-
- // TODO(ronshapiro): merge with
- // ProvisionDependencyOnProduerBindingValidator.dependencyCanUseProduction
- private boolean dependencyCanBeProduction(DependencyEdge edge, BindingGraph graph) {
- Node source = graph.network().incidentNodes(edge).source();
- if (source instanceof ComponentNode) {
- return canBeSatisfiedByProductionBinding(edge.dependencyRequest().kind());
- }
- if (source instanceof dagger.model.Binding) {
- return ((dagger.model.Binding) source).isProduction();
- }
- throw new IllegalArgumentException(
- "expected a dagger.model.Binding or ComponentNode: " + source);
- }
-
- private boolean typeHasInjectionSites(Key key) {
- return injectBindingRegistry
- .getOrFindMembersInjectionBinding(key)
- .map(binding -> !binding.injectionSites().isEmpty())
- .orElse(false);
- }
-}
diff --git a/java/dagger/internal/codegen/ModifiableAbstractMethodBindingExpression.java b/java/dagger/internal/codegen/ModifiableAbstractMethodBindingExpression.java
deleted file mode 100644
index 412acae..0000000
--- a/java/dagger/internal/codegen/ModifiableAbstractMethodBindingExpression.java
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static javax.lang.model.element.Modifier.ABSTRACT;
-import static javax.lang.model.element.Modifier.PROTECTED;
-
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.MethodSpec;
-import com.squareup.javapoet.TypeName;
-import dagger.internal.codegen.ComponentDescriptor.ComponentMethodDescriptor;
-import dagger.internal.codegen.ModifiableBindingMethods.ModifiableBindingMethod;
-import dagger.internal.codegen.javapoet.Expression;
-import dagger.internal.codegen.langmodel.Accessibility;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import java.util.Optional;
-import javax.lang.model.type.TypeMirror;
-
-/**
- * A {@link BindingExpression} that invokes a method that encapsulates a binding that cannot be
- * satisfied when generating the abstract base class implementation of a subcomponent. The
- * (unimplemented) method is added to the {@link ComponentImplementation} when the dependency
- * expression is requested. The method is overridden when generating the implementation of an
- * ancestor component.
- */
-abstract class ModifiableAbstractMethodBindingExpression extends BindingExpression {
- private final ComponentImplementation componentImplementation;
- private final ModifiableBindingType modifiableBindingType;
- private final BindingRequest request;
- private final Optional<ComponentMethodDescriptor> matchingComponentMethod;
- private final DaggerTypes types;
- private Optional<String> methodName;
-
- ModifiableAbstractMethodBindingExpression(
- ComponentImplementation componentImplementation,
- ModifiableBindingType modifiableBindingType,
- BindingRequest request,
- Optional<ModifiableBindingMethod> matchingModifiableBindingMethod,
- Optional<ComponentMethodDescriptor> matchingComponentMethod,
- DaggerTypes types) {
- this.componentImplementation = componentImplementation;
- this.modifiableBindingType = modifiableBindingType;
- this.request = request;
- this.matchingComponentMethod = matchingComponentMethod;
- this.types = types;
- this.methodName =
- initializeMethodName(matchingComponentMethod, matchingModifiableBindingMethod);
- }
-
- /**
- * If this binding corresponds to an existing component method, or a known modifiable binding
- * method, use them to initialize the method name, which is a signal to call the existing method
- * rather than emit an abstract method.
- */
- private static Optional<String> initializeMethodName(
- Optional<ComponentMethodDescriptor> matchingComponentMethod,
- Optional<ModifiableBindingMethod> matchingModifiableBindingMethod) {
- if (matchingComponentMethod.isPresent()) {
- return Optional.of(matchingComponentMethod.get().methodElement().getSimpleName().toString());
- }
- if (matchingModifiableBindingMethod.isPresent()) {
- return Optional.of(matchingModifiableBindingMethod.get().methodSpec().name);
- }
- return Optional.empty();
- }
-
- @Override
- final Expression getDependencyExpression(ClassName requestingClass) {
- addUnimplementedMethod();
- return Expression.create(
- returnType(),
- componentImplementation.name().equals(requestingClass)
- ? CodeBlock.of("$N()", methodName.get())
- : CodeBlock.of("$T.this.$N()", componentImplementation.name(), methodName.get()));
- }
-
- private void addUnimplementedMethod() {
- if (!methodName.isPresent()) {
- // Only add the method once in case of repeated references to the missing binding.
- methodName = Optional.of(chooseMethodName());
- TypeMirror returnType = returnType();
- componentImplementation.addModifiableBindingMethod(
- modifiableBindingType,
- request,
- returnType,
- MethodSpec.methodBuilder(methodName.get())
- .addModifiers(PROTECTED, ABSTRACT)
- .returns(TypeName.get(returnType))
- .build(),
- false /* finalized */);
- }
- }
-
- /**
- * The return type of this abstract method expression:
- *
- * <ul>
- * <li>If there's a {@code matchingComponentMethod}, use its return type.
- * <li>Otherwise, use the {@linkplain DaggerTypes#publiclyAccessibleType(TypeMirror) publicly
- * accessible type} of the request. We can't use the {@linkplain
- * Accessibility#isTypeAccessibleFrom(TypeMirror, String) type accessible from the current
- * implementation's package} because a subclass implementation may be in a different package
- * from which the request type is not accessible.
- * </ul>
- */
- private TypeMirror returnType() {
- if (matchingComponentMethod.isPresent()) {
- return matchingComponentMethod.get().resolvedReturnType(types);
- }
-
- TypeMirror requestedType = request.requestedType(contributedType(), types);
- return types.publiclyAccessibleType(requestedType);
- }
-
- /**
- * The {@link ContributionBinding#contributedType() type contributed} by the binding of this
- * expression. For missing bindings, this will be the key type.
- */
- protected abstract TypeMirror contributedType();
-
- /** Returns a unique 'getter' method name for the current component. */
- abstract String chooseMethodName();
-}
diff --git a/java/dagger/internal/codegen/ModifiableBindingExpressions.java b/java/dagger/internal/codegen/ModifiableBindingExpressions.java
deleted file mode 100644
index 76bcb8b..0000000
--- a/java/dagger/internal/codegen/ModifiableBindingExpressions.java
+++ /dev/null
@@ -1,526 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkState;
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static dagger.internal.codegen.BindingRequest.bindingRequest;
-import static java.util.stream.Collectors.toList;
-import static javax.lang.model.element.Modifier.FINAL;
-import static javax.lang.model.element.Modifier.PROTECTED;
-import static javax.lang.model.element.Modifier.PUBLIC;
-
-import com.google.common.collect.ImmutableSet;
-import com.squareup.javapoet.MethodSpec;
-import dagger.internal.codegen.ComponentDescriptor.ComponentMethodDescriptor;
-import dagger.internal.codegen.ComponentImplementation.MethodSpecKind;
-import dagger.internal.codegen.MethodBindingExpression.MethodImplementationStrategy;
-import dagger.internal.codegen.ModifiableBindingMethods.ModifiableBindingMethod;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.BindingKind;
-import dagger.model.DependencyRequest;
-import java.util.Optional;
-
-/**
- * A central repository of code expressions used to access modifiable bindings available to a
- * component. A binding is modifiable if it can be modified across implementations of a
- * subcomponent. This is only relevant for ahead-of-time subcomponents.
- */
-final class ModifiableBindingExpressions {
- private final Optional<ModifiableBindingExpressions> parent;
- private final ComponentBindingExpressions bindingExpressions;
- private final BindingGraph graph;
- private final ComponentImplementation componentImplementation;
- private final CompilerOptions compilerOptions;
- private final DaggerTypes types;
-
- ModifiableBindingExpressions(
- Optional<ModifiableBindingExpressions> parent,
- ComponentBindingExpressions bindingExpressions,
- BindingGraph graph,
- ComponentImplementation componentImplementation,
- CompilerOptions compilerOptions,
- DaggerTypes types) {
- this.parent = parent;
- this.bindingExpressions = bindingExpressions;
- this.graph = graph;
- this.componentImplementation = componentImplementation;
- this.compilerOptions = compilerOptions;
- this.types = types;
- }
-
- /**
- * Adds {@code method} to the component implementation. If the binding for the method is
- * modifiable, also registers the relevant modifiable binding information.
- */
- void addPossiblyModifiableComponentMethod(
- ComponentMethodDescriptor componentMethod, MethodSpec method) {
- BindingRequest request = bindingRequest(componentMethod.dependencyRequest().get());
- ModifiableBindingType modifiableBindingType = getModifiableBindingType(request);
- if (modifiableBindingType.isModifiable()) {
- componentImplementation.addModifiableComponentMethod(
- modifiableBindingType,
- request,
- componentMethod.resolvedReturnType(types),
- method,
- newModifiableBindingWillBeFinalized(modifiableBindingType, request));
- } else {
- componentImplementation.addMethod(MethodSpecKind.COMPONENT_METHOD, method);
- }
- }
-
- /**
- * Returns the implementation of a modifiable binding method originally defined in a supertype
- * implementation of this subcomponent. Returns {@link Optional#empty()} when the binding cannot
- * or should not be modified by the current binding graph.
- */
- Optional<ModifiableBindingMethod> possiblyReimplementedMethod(
- ModifiableBindingMethod modifiableBindingMethod) {
- checkState(componentImplementation.superclassImplementation().isPresent());
- BindingRequest request = modifiableBindingMethod.request();
- ModifiableBindingType newModifiableBindingType = getModifiableBindingType(request);
- ModifiableBindingType oldModifiableBindingType = modifiableBindingMethod.type();
- boolean modifiableBindingTypeChanged =
- !newModifiableBindingType.equals(oldModifiableBindingType);
-
- ResolvedBindings resolvedBindings = graph.resolvedBindings(request);
- // Don't reimplement modifiable bindings that were perceived to be provision bindings in a
- // superclass implementation but are now production bindings.
- if ((modifiableBindingTypeChanged
- // Optional bindings don't need the same treatment since the only transition they can
- // make is empty -> present. In that case, the Producer<Optional<T>> will be overridden
- // and the absentOptionalProvider() will be a dangling reference that is never attempted
- // to be overridden.
- || newModifiableBindingType.equals(ModifiableBindingType.MULTIBINDING))
- && resolvedBindings != null
- && resolvedBindings.bindingType().equals(BindingType.PRODUCTION)
- && !request.canBeSatisfiedByProductionBinding()) {
- return oldModifiableBindingType.hasBaseClassImplementation()
- ? Optional.empty()
- : Optional.of(
- reimplementedMethod(
- modifiableBindingMethod,
- newModifiableBindingType,
- new PrunedConcreteMethodBindingExpression(),
- componentImplementation.isAbstract()));
- }
-
- if (modifiableBindingTypeChanged
- && !newModifiableBindingType.hasBaseClassImplementation()
- && (oldModifiableBindingType.hasBaseClassImplementation()
- || componentImplementation.isAbstract())) {
- // We don't want to override one abstract method with another one. However, If the component
- // is not abstract (such as a transition from GENERATED_INSTANCE -> MISSING), we must provide
- // an implementation like normal.
- return Optional.empty();
- }
-
- if (modifiableBindingTypeChanged
- || shouldModifyImplementation(newModifiableBindingType, request)) {
- boolean markMethodFinal =
- knownModifiableBindingWillBeFinalized(modifiableBindingMethod)
- // no need to mark the method final if the component implementation will be final
- && componentImplementation.isAbstract();
- return Optional.of(
- reimplementedMethod(
- modifiableBindingMethod,
- newModifiableBindingType,
- bindingExpressions.getBindingExpression(request),
- markMethodFinal));
- }
- return Optional.empty();
- }
-
- /**
- * Returns a new {@link ModifiableBindingMethod} that overrides {@code supertypeMethod} and is
- * implemented with {@code bindingExpression}.
- */
- private ModifiableBindingMethod reimplementedMethod(
- ModifiableBindingMethod supertypeMethod,
- ModifiableBindingType newModifiableBindingType,
- BindingExpression bindingExpression,
- boolean markMethodFinal) {
- MethodSpec baseMethod = supertypeMethod.methodSpec();
- return supertypeMethod.reimplement(
- newModifiableBindingType,
- MethodSpec.methodBuilder(baseMethod.name)
- .addModifiers(baseMethod.modifiers.contains(PUBLIC) ? PUBLIC : PROTECTED)
- .addModifiers(markMethodFinal ? ImmutableSet.of(FINAL) : ImmutableSet.of())
- .returns(baseMethod.returnType)
- .addAnnotation(Override.class)
- .addCode(
- bindingExpression.getModifiableBindingMethodImplementation(
- supertypeMethod, componentImplementation, types))
- .build(),
- markMethodFinal);
- }
-
- /**
- * Returns true if a modifiable binding method that was registered in a superclass implementation
- * of this subcomponent should be marked as "finalized" if it is being overridden by this
- * subcomponent implementation. "Finalized" means we should not attempt to modify the binding in
- * any subcomponent subclass.
- */
- private boolean knownModifiableBindingWillBeFinalized(
- ModifiableBindingMethod modifiableBindingMethod) {
- ModifiableBindingType newModifiableBindingType =
- getModifiableBindingType(modifiableBindingMethod.request());
- if (!newModifiableBindingType.isModifiable()) {
- // If a modifiable binding has become non-modifiable it is final by definition.
- return true;
- }
- return modifiableBindingWillBeFinalized(
- newModifiableBindingType,
- shouldModifyImplementation(newModifiableBindingType, modifiableBindingMethod.request()));
- }
-
- /**
- * Returns true if a newly discovered modifiable binding method, once it is defined in this
- * subcomponent implementation, should be marked as "finalized", meaning we should not attempt to
- * modify the binding in any subcomponent subclass.
- */
- private boolean newModifiableBindingWillBeFinalized(
- ModifiableBindingType modifiableBindingType, BindingRequest request) {
- return modifiableBindingWillBeFinalized(
- modifiableBindingType, shouldModifyImplementation(modifiableBindingType, request));
- }
-
- /**
- * Returns true if we shouldn't attempt to further modify a modifiable binding once we complete
- * the implementation for the current subcomponent.
- */
- private boolean modifiableBindingWillBeFinalized(
- ModifiableBindingType modifiableBindingType, boolean modifyingBinding) {
- switch (modifiableBindingType) {
- case MISSING:
- case BINDS_METHOD_WITH_MISSING_DEPENDENCY:
- case GENERATED_INSTANCE:
- case OPTIONAL:
- case INJECTION:
- // Once we modify any of the above a single time, then they are finalized.
- return modifyingBinding;
- case MULTIBINDING:
- return false;
- default:
- throw new IllegalStateException(
- String.format(
- "Building binding expression for unsupported ModifiableBindingType [%s].",
- modifiableBindingType));
- }
- }
-
- /**
- * Creates a binding expression for a binding if it may be modified across implementations of a
- * subcomponent.
- */
- Optional<BindingExpression> maybeCreateModifiableBindingExpression(BindingRequest request) {
- ModifiableBindingType type = getModifiableBindingType(request);
- if (!type.isModifiable()) {
- return Optional.empty();
- }
- return Optional.of(createModifiableBindingExpression(type, request));
- }
-
- /** Creates a binding expression for a modifiable binding. */
- private BindingExpression createModifiableBindingExpression(
- ModifiableBindingType type, BindingRequest request) {
- ResolvedBindings resolvedBindings = graph.resolvedBindings(request);
- Optional<ModifiableBindingMethod> matchingModifiableBindingMethod =
- componentImplementation.getModifiableBindingMethod(request);
- Optional<ComponentMethodDescriptor> matchingComponentMethod =
- graph.componentDescriptor().firstMatchingComponentMethod(request);
- switch (type) {
- case GENERATED_INSTANCE:
- // If the subcomponent is abstract then we need to define an (un-implemented)
- // DeferredModifiableBindingExpression.
- if (componentImplementation.isAbstract()) {
- return new DeferredModifiableBindingExpression(
- componentImplementation,
- type,
- resolvedBindings.contributionBinding(),
- request,
- matchingModifiableBindingMethod,
- matchingComponentMethod,
- types);
- }
- // Otherwise return a concrete implementation.
- return bindingExpressions.createBindingExpression(resolvedBindings, request);
-
- case MISSING:
- // If we need an expression for a missing binding and the current implementation is
- // abstract, then we need an (un-implemented) MissingBindingExpression.
- if (componentImplementation.isAbstract()) {
- return new MissingBindingExpression(
- componentImplementation,
- request,
- matchingModifiableBindingMethod,
- matchingComponentMethod,
- types);
- }
- // Otherwise we assume that it is valid to have a missing binding as it is part of a
- // dependency chain that has been passively pruned.
- // TODO(b/117833324): Identify pruned bindings when generating the subcomponent
- // implementation in which the bindings are pruned. If we hold a reference to the binding
- // graph used to generate a given implementation then we can compare a implementation's
- // graph with its superclass implementation's graph to detect pruned dependency branches.
- return new PrunedConcreteMethodBindingExpression();
-
- case BINDS_METHOD_WITH_MISSING_DEPENDENCY:
- checkState(componentImplementation.isAbstract());
- return new DeferredModifiableBindingExpression(
- componentImplementation,
- type,
- resolvedBindings.contributionBinding(),
- request,
- matchingModifiableBindingMethod,
- matchingComponentMethod,
- types);
-
- case OPTIONAL:
- case MULTIBINDING:
- case INJECTION:
- return bindingExpressions.wrapInMethod(
- resolvedBindings,
- request,
- bindingExpressions.createBindingExpression(resolvedBindings, request));
- default:
- throw new IllegalStateException(
- String.format(
- "Building binding expression for unsupported ModifiableBindingType [%s].", type));
- }
- }
-
- /**
- * The reason why a binding may need to be modified across implementations of a subcomponent, if
- * at all.
- */
- ModifiableBindingType getModifiableBindingType(BindingRequest request) {
- if (!compilerOptions.aheadOfTimeSubcomponents()) {
- return ModifiableBindingType.NONE;
- }
-
- // When generating a component the binding is not considered modifiable. Bindings are modifiable
- // only across subcomponent implementations.
- if (!componentImplementation.componentDescriptor().isSubcomponent()) {
- return ModifiableBindingType.NONE;
- }
-
- if (request.requestKind().filter(RequestKinds::isDerivedFromProvider).isPresent()) {
- return ModifiableBindingType.NONE;
- }
-
- if (resolvedInThisComponent(request)) {
- ResolvedBindings resolvedBindings = graph.resolvedBindings(request);
- if (resolvedBindings.contributionBindings().isEmpty()) {
- // TODO(ronshapiro): Confirm whether a resolved binding must have a single contribution
- // binding.
- return ModifiableBindingType.NONE;
- }
-
- ContributionBinding binding = resolvedBindings.contributionBinding();
- if (binding.requiresGeneratedInstance()) {
- return ModifiableBindingType.GENERATED_INSTANCE;
- }
-
- if (binding.kind().equals(BindingKind.DELEGATE)
- && graph
- .contributionBindings()
- .get(getOnlyElement(binding.dependencies()).key())
- .isEmpty()) {
- return ModifiableBindingType.BINDS_METHOD_WITH_MISSING_DEPENDENCY;
- }
-
- if (binding.kind().equals(BindingKind.OPTIONAL) && binding.dependencies().isEmpty()) {
- // only empty optional bindings can be modified
- return ModifiableBindingType.OPTIONAL;
- }
-
- if (binding.isSyntheticMultibinding()) {
- return ModifiableBindingType.MULTIBINDING;
- }
-
- if (binding.kind().equals(BindingKind.INJECTION)) {
- return ModifiableBindingType.INJECTION;
- }
- } else if (!resolvableBinding(request)) {
- return ModifiableBindingType.MISSING;
- }
-
- return ModifiableBindingType.NONE;
- }
-
- /**
- * Returns true if the current binding graph can, and should, modify a binding by overriding a
- * modifiable binding method.
- */
- private boolean shouldModifyImplementation(
- ModifiableBindingType modifiableBindingType, BindingRequest request) {
- ResolvedBindings resolvedBindings = graph.resolvedBindings(request);
- if (request.requestKind().isPresent()) {
- switch (request.requestKind().get()) {
- case FUTURE:
- // Futures backed by production bindings are always requested by a Producer.get() call, so
- // if the binding is modifiable, the producer will be wrapped in a modifiable method and
- // the future can refer to that method; even if the producer binding is modified,
- // getModifiableProducer().get() will never need to be modified. Furthermore, because
- // cancellation is treated by wrapped producers, and those producers point to the
- // modifiable producer wrapper methods, we never need or want to change the access of
- // these wrapped producers for entry methods
- //
- // Futures backed by provision bindings are inlined and contain no wrapping producer, so
- // if the binding is modifiable and is resolved as a provision binding in a superclass
- // but later resolved as a production binding, we can't take the same shortcut as before.
- Optional<ComponentImplementation> superclassImplementation =
- componentImplementation.superclassImplementation();
- if (superclassImplementation.isPresent()) {
- if (superclassImplementation.get().isDeserializedImplementation()) {
- // TODO(b/117833324): consider serializing the binding type so that we don't need to
- // branch here. Or, instead, consider removing this optimization entirely if there
- // aren't that many FUTURE entry point methods to justify the extra code.
- break;
- } else {
- return bindingTypeChanged(request, resolvedBindings);
- }
- }
- return false;
-
- case LAZY:
- case PROVIDER_OF_LAZY:
- // Lazy and ProviderOfLazy are always created from a Provider, and therefore this request
- // never needs to be modifiable. It will refer (via DoubleCheck.lazy() or
- // ProviderOfLazy.create()) to the modifiable method and not the framework instance.
- return false;
-
- case MEMBERS_INJECTION:
- case PRODUCED:
- // MEMBERS_INJECTION has a completely different code path for binding expressions, and
- // PRODUCED requests are only requestable in @Produces methods, which are hidden from
- // generated components inside Producer factories
- throw new AssertionError(request);
-
- case INSTANCE:
- case PROVIDER:
- case PRODUCER:
- // These may be modifiable, so run through the regular logic. They're spelled out
- // explicitly so that ErrorProne will detect if a new enum value is created and missing
- // from this list.
- break;
- }
- }
-
- switch (modifiableBindingType) {
- case GENERATED_INSTANCE:
- return !componentImplementation.isAbstract();
-
- case MISSING:
- // TODO(b/117833324): investigate beder@'s comment about having intermediate component
- // ancestors satisfy missing bindings of their children with their own missing binding
- // methods so that we can minimize the cases where we need to reach into doubly-nested
- // descendant component implementations.
-
- // Implement a missing binding if it is resolvable, or if we're generating a concrete
- // subcomponent implementation. If a binding is still missing when the subcomponent
- // implementation is concrete then it is assumed to be part of a dependency that would have
- // been passively pruned when implementing the full component hierarchy.
- return resolvableBinding(request) || !componentImplementation.isAbstract();
-
- case BINDS_METHOD_WITH_MISSING_DEPENDENCY:
- DependencyRequest dependency =
- getOnlyElement(resolvedBindings.contributionBinding().dependencies());
- return !graph.contributionBindings().get(dependency.key()).isEmpty();
-
- case OPTIONAL:
- // Only override optional binding methods if we have a non-empty binding.
- return !resolvedBindings.contributionBinding().dependencies().isEmpty();
-
- case MULTIBINDING:
- // Only modify a multibinding if there are new contributions.
- return !componentImplementation
- .superclassContributionsMade(request)
- .containsAll(
- resolvedBindings.contributionBinding().dependencies().stream()
- .map(DependencyRequest::key)
- .collect(toList()));
-
- case INJECTION:
- return !resolvedBindings.contributionBinding().kind().equals(BindingKind.INJECTION);
-
- default:
- throw new IllegalStateException(
- String.format(
- "Overriding modifiable binding method with unsupported ModifiableBindingType [%s].",
- modifiableBindingType));
- }
- }
-
- /**
- * Returns {@code true} if the {@link BindingType} for {@code request} is not the same in this
- * implementation and it's superclass implementation.
- */
- private boolean bindingTypeChanged(BindingRequest request, ResolvedBindings resolvedBindings) {
- BindingGraph superclassGraph =
- componentImplementation.superclassImplementation().get().graph();
- ResolvedBindings superclassBindings = superclassGraph.resolvedBindings(request);
- return superclassBindings != null
- && resolvedBindings != null
- && !superclassBindings.bindingType().equals(resolvedBindings.bindingType());
- }
-
- /**
- * Returns true if the binding can be resolved by the graph for this component or any parent
- * component.
- */
- private boolean resolvableBinding(BindingRequest request) {
- for (ModifiableBindingExpressions expressions = this;
- expressions != null;
- expressions = expressions.parent.orElse(null)) {
- if (expressions.resolvedInThisComponent(request)) {
- return true;
- }
- }
- return false;
- }
-
- /** Returns true if the binding can be resolved by the graph for this component. */
- private boolean resolvedInThisComponent(BindingRequest request) {
- ResolvedBindings resolvedBindings = graph.resolvedBindings(request);
- return resolvedBindings != null
- && !resolvedBindings.bindingsOwnedBy(graph.componentDescriptor()).isEmpty();
- }
-
- /**
- * Wraps a modifiable binding expression in a method that can be overridden in a subclass
- * implementation.
- */
- BindingExpression wrapInModifiableMethodBindingExpression(
- BindingRequest request,
- ResolvedBindings resolvedBindings,
- MethodImplementationStrategy methodImplementationStrategy,
- BindingExpression wrappedBindingExpression) {
- ModifiableBindingType modifiableBindingType = getModifiableBindingType(request);
- checkState(modifiableBindingType.isModifiable());
- return new ModifiableConcreteMethodBindingExpression(
- request,
- resolvedBindings,
- methodImplementationStrategy,
- wrappedBindingExpression,
- modifiableBindingType,
- componentImplementation,
- newModifiableBindingWillBeFinalized(modifiableBindingType, request),
- types);
- }
-}
diff --git a/java/dagger/internal/codegen/ModifiableBindingMethods.java b/java/dagger/internal/codegen/ModifiableBindingMethods.java
deleted file mode 100644
index ead708d..0000000
--- a/java/dagger/internal/codegen/ModifiableBindingMethods.java
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Verify.verify;
-
-import com.google.auto.common.MoreTypes;
-import com.google.auto.value.AutoValue;
-import com.google.common.base.Equivalence;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Maps;
-import com.squareup.javapoet.MethodSpec;
-import java.util.Map;
-import java.util.Optional;
-import javax.lang.model.type.TypeMirror;
-
-/**
- * A registry for those methods which each wrap a binding whose definition may be modified across
- * each class in the class hierarchy implementing a subcomponent. Subcomponent implementations are
- * spread across a class hierarchy when generating ahead-of-time subcomponents. There is one
- * subcomponent implementation class for each of the subcomponent's ancestor components. An instance
- * of {@link ModifiableBindingMethod} is associated with a single class in this hierarchy. For a
- * given subcomponent implementation class we can use the {@link ModifiableBindingMethod}s of its
- * superclasses to know what binding methods to attempt to modify.
- */
-final class ModifiableBindingMethods {
- private final Map<BindingRequest, ModifiableBindingMethod> methods = Maps.newLinkedHashMap();
-
- /** Registers a new method encapsulating a modifiable binding. */
- void addModifiableMethod(
- ModifiableBindingType type,
- BindingRequest request,
- TypeMirror returnType,
- MethodSpec method,
- boolean finalized) {
- // It's ok for the type to not be modifiable, since it could be overriding a previously
- // modifiable method (such as with addReimplementedMethod).
- addMethod(ModifiableBindingMethod.create(type, request, returnType, method, finalized));
- }
-
- /** Registers a reimplemented modifiable method. */
- void addReimplementedMethod(ModifiableBindingMethod method) {
- addMethod(method);
- }
-
- private void addMethod(ModifiableBindingMethod method) {
- ModifiableBindingMethod previousMethod = methods.put(method.request(), method);
- verify(
- previousMethod == null,
- "registering %s but %s is already registered for the same binding request",
- method,
- previousMethod);
- }
-
- /** Returns all {@link ModifiableBindingMethod}s that have not been marked as finalized. */
- ImmutableMap<BindingRequest, ModifiableBindingMethod> getNonFinalizedMethods() {
- return ImmutableMap.copyOf(Maps.filterValues(methods, m -> !m.finalized()));
- }
-
- /** Returns the {@link ModifiableBindingMethod} for the given binding if present. */
- Optional<ModifiableBindingMethod> getMethod(BindingRequest request) {
- return Optional.ofNullable(methods.get(request));
- }
-
- /** Returns all of the {@link ModifiableBindingMethod}s. */
- ImmutableList<ModifiableBindingMethod> allMethods() {
- return ImmutableList.copyOf(methods.values());
- }
-
- /** Whether a given binding has been marked as finalized. */
- // TODO(ronshapiro): possibly rename this to something that indicates that the BindingRequest for
- // `method` has been finalized in *this* component implementation?
- boolean finalized(ModifiableBindingMethod method) {
- ModifiableBindingMethod storedMethod = methods.get(method.request());
- return storedMethod != null && storedMethod.finalized();
- }
-
- @AutoValue
- abstract static class ModifiableBindingMethod {
- private static ModifiableBindingMethod create(
- ModifiableBindingType type,
- BindingRequest request,
- TypeMirror returnType,
- MethodSpec methodSpec,
- boolean finalized) {
- return new AutoValue_ModifiableBindingMethods_ModifiableBindingMethod(
- type, request, MoreTypes.equivalence().wrap(returnType), methodSpec, finalized);
- }
-
- /** Creates a {@ModifiableBindingMethod} that reimplements the current method. */
- ModifiableBindingMethod reimplement(
- ModifiableBindingType newModifiableBindingType,
- MethodSpec newImplementation,
- boolean finalized) {
- return new AutoValue_ModifiableBindingMethods_ModifiableBindingMethod(
- newModifiableBindingType, request(), returnTypeWrapper(), newImplementation, finalized);
- }
-
- abstract ModifiableBindingType type();
-
- abstract BindingRequest request();
-
- final TypeMirror returnType() {
- return returnTypeWrapper().get();
- }
-
- abstract Equivalence.Wrapper<TypeMirror> returnTypeWrapper();
-
- abstract MethodSpec methodSpec();
-
- abstract boolean finalized();
-
- /** Whether a {@link ModifiableBindingMethod} is for the same binding request. */
- boolean fulfillsSameRequestAs(ModifiableBindingMethod other) {
- return request().equals(other.request());
- }
- }
-}
diff --git a/java/dagger/internal/codegen/ModifiableBindingType.java b/java/dagger/internal/codegen/ModifiableBindingType.java
deleted file mode 100644
index 7e43ec1..0000000
--- a/java/dagger/internal/codegen/ModifiableBindingType.java
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import com.google.common.collect.ImmutableSet;
-
-/**
- * A label for a binding indicating whether, and how, it may be redefined across implementations of
- * a subcomponent.
- *
- * <p>A subcomponent has multiple implementations only when generating ahead-of-time subcomponents.
- * Specifically, each subcomponent type in a component hierarchy is implemented as an abstract
- * class, and descendent components are implemented as abstract inner classes. A consequence of this
- * is that a given subcomponent has an implementation for each ancestor component. Each
- * implementation represents a different sub-binding-graph of the full subcomponent. A binding is
- * modifiable if it's definition may change depending on the characteristics of its ancestor
- * components.
- */
-enum ModifiableBindingType {
- /** A binding that is not modifiable */
- NONE,
-
- /**
- * A binding that is missing when generating the abstract base class implementation of a
- * subcomponent.
- */
- MISSING,
-
- /**
- * A binding that requires an instance of a generated type. These binding are modifiable in the
- * sense that they are encapsulated in a method when they are first required, possibly in an
- * abstract implementation of a subcomponent, where, in general, no concrete instances of
- * generated types are available, and the method is satisfied in a final concrete implementation.
- */
- GENERATED_INSTANCE,
-
- /**
- * Multibindings may have contributions come from any ancestor component. Therefore, each
- * implementation of a subcomponent may have newly available contributions, and so the binding
- * method is reimplemented with each subcomponent implementation.
- */
- MULTIBINDING,
-
- /**
- * A Optional binding that may be empty when looking at a partial binding graph, but bound to a
- * value when considering the complete binding graph, thus modifiable across subcomponent
- * implementations.
- */
- OPTIONAL,
-
- /**
- * If a binding is defined according to an {@code @Inject} annotated constructor on the object it
- * is valid for that binding to be redefined a single time by an {@code @Provides} annotated
- * module method. It is possible that the {@code @Provides} binding isn't available in a partial
- * binding graph, but becomes available when considering a more complete binding graph, therefore
- * such bindings are modifiable across subcomponent implementations.
- */
- INJECTION,
-
- /**
- * A {@link dagger.Binds} method whose dependency is {@link #MISSING}.
- *
- * <p>There's not much to do for @Binds bindings if the dependency is missing - at best, if the
- * dependency is a weaker scope/unscoped, we save only a few lines that implement the scoping. But
- * it's also possible, if the dependency is the same or stronger scope, that no extra code is
- * necessary, in which case we'd be overriding a method that just returns another.
- */
- BINDS_METHOD_WITH_MISSING_DEPENDENCY,
- ;
-
- private static final ImmutableSet<ModifiableBindingType> TYPES_WITH_BASE_CLASS_IMPLEMENTATIONS =
- ImmutableSet.of(NONE, INJECTION, MULTIBINDING, OPTIONAL);
-
- boolean isModifiable() {
- return !equals(NONE);
- }
-
- /**
- * Returns true if the method encapsulating the modifiable binding should have a concrete
- * implementation in the abstract base class for a subcomponent.
- */
- boolean hasBaseClassImplementation() {
- return TYPES_WITH_BASE_CLASS_IMPLEMENTATIONS.contains(this);
- }
-}
diff --git a/java/dagger/internal/codegen/ModifiableConcreteMethodBindingExpression.java b/java/dagger/internal/codegen/ModifiableConcreteMethodBindingExpression.java
deleted file mode 100644
index 907466b..0000000
--- a/java/dagger/internal/codegen/ModifiableConcreteMethodBindingExpression.java
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.base.Preconditions.checkState;
-import static com.squareup.javapoet.MethodSpec.methodBuilder;
-import static javax.lang.model.element.Modifier.PRIVATE;
-import static javax.lang.model.element.Modifier.PROTECTED;
-
-import com.squareup.javapoet.TypeName;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import java.util.Optional;
-
-/**
- * A binding expression that wraps a modifiable binding expression in a public, no-arg method.
- *
- * <p>Dependents of this binding expression will just call the modifiable binding method.
- */
-final class ModifiableConcreteMethodBindingExpression extends MethodBindingExpression {
-
- private final BindingRequest request;
- private final ModifiableBindingType modifiableBindingType;
- private final ComponentImplementation componentImplementation;
- private final boolean bindingCannotBeModified;
- private Optional<String> methodName = Optional.empty();
-
- ModifiableConcreteMethodBindingExpression(
- BindingRequest request,
- ResolvedBindings resolvedBindings,
- MethodImplementationStrategy methodImplementationStrategy,
- BindingExpression wrappedBindingExpression,
- ModifiableBindingType modifiableBindingType,
- ComponentImplementation componentImplementation,
- boolean bindingCannotBeModified,
- DaggerTypes types) {
- super(
- request,
- resolvedBindings,
- methodImplementationStrategy,
- wrappedBindingExpression,
- componentImplementation,
- types);
- this.request = checkNotNull(request);
- this.modifiableBindingType = checkNotNull(modifiableBindingType);
- this.componentImplementation = checkNotNull(componentImplementation);
- this.bindingCannotBeModified = bindingCannotBeModified;
- }
-
- @Override
- protected void addMethod() {
- if (methodName.isPresent()) {
- return;
- }
-
- if (supertypeModifiableBindingMethod().isPresent()) {
- methodName = supertypeModifiableBindingMethod().map(method -> method.methodSpec().name);
- return;
- }
-
- // Add the modifiable binding method to the component if we haven't already.
- methodName = Optional.of(componentImplementation.getUniqueMethodName(request));
- componentImplementation.addModifiableBindingMethod(
- modifiableBindingType,
- request,
- returnType(),
- methodBuilder(methodName.get())
- .addModifiers(bindingCannotBeModified ? PRIVATE : PROTECTED)
- .returns(TypeName.get(returnType()))
- .addCode(methodBody())
- .build(),
- bindingCannotBeModified);
- }
-
- @Override
- protected String methodName() {
- checkState(methodName.isPresent(), "addMethod() must be called before methodName().");
- return methodName.get();
- }
-
- @Override
- protected boolean isModifiableImplementationMethod() {
- return true;
- }
-}
diff --git a/java/dagger/internal/codegen/ModuleAnnotation.java b/java/dagger/internal/codegen/ModuleAnnotation.java
deleted file mode 100644
index 27dd071..0000000
--- a/java/dagger/internal/codegen/ModuleAnnotation.java
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * Copyright (C) 2019 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.AnnotationMirrors.getAnnotationValue;
-import static com.google.auto.common.MoreTypes.asTypeElement;
-import static com.google.common.base.Preconditions.checkArgument;
-import static dagger.internal.codegen.DaggerStreams.toImmutableList;
-import static dagger.internal.codegen.MoreAnnotationValues.asAnnotationValues;
-import static dagger.internal.codegen.langmodel.DaggerElements.getAnyAnnotation;
-
-import com.google.auto.common.MoreTypes;
-import com.google.auto.value.AutoValue;
-import com.google.auto.value.extension.memoized.Memoized;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-import dagger.Module;
-import dagger.producers.ProducerModule;
-import java.lang.annotation.Annotation;
-import java.util.Optional;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.AnnotationValue;
-import javax.lang.model.element.TypeElement;
-
-/** A {@code @Module} or {@code @ProducerModule} annotation. */
-@AutoValue
-abstract class ModuleAnnotation {
- private static final ImmutableSet<Class<? extends Annotation>> MODULE_ANNOTATIONS =
- ImmutableSet.of(Module.class, ProducerModule.class);
-
- /** The annotation itself. */
- // This does not use AnnotationMirrors.equivalence() because we want the actual annotation
- // instance.
- abstract AnnotationMirror annotation();
-
- /** The type of the annotation. */
- @Memoized
- Class<?> annotationClass() {
- try {
- return Class.forName(
- asTypeElement(annotation().getAnnotationType()).getQualifiedName().toString());
- } catch (ClassNotFoundException e) {
- AssertionError assertionError = new AssertionError();
- assertionError.initCause(e);
- throw assertionError;
- }
- }
-
- /**
- * The types specified in the {@code includes} attribute.
- *
- * @throws IllegalArgumentException if any of the values are error types
- */
- @Memoized
- ImmutableList<TypeElement> includes() {
- return includesAsAnnotationValues().stream()
- .map(MoreAnnotationValues::asType)
- .map(MoreTypes::asTypeElement)
- .collect(toImmutableList());
- }
-
- /** The values specified in the {@code includes} attribute. */
- @Memoized
- ImmutableList<AnnotationValue> includesAsAnnotationValues() {
- return asAnnotationValues(getAnnotationValue(annotation(), "includes"));
- }
-
- /**
- * The types specified in the {@code subcomponents} attribute.
- *
- * @throws IllegalArgumentException if any of the values are error types
- */
- @Memoized
- ImmutableList<TypeElement> subcomponents() {
- return subcomponentsAsAnnotationValues().stream()
- .map(MoreAnnotationValues::asType)
- .map(MoreTypes::asTypeElement)
- .collect(toImmutableList());
- }
-
- /** The values specified in the {@code subcomponents} attribute. */
- @Memoized
- ImmutableList<AnnotationValue> subcomponentsAsAnnotationValues() {
- return asAnnotationValues(getAnnotationValue(annotation(), "subcomponents"));
- }
-
- /** Returns {@code true} if the argument is a {@code @Module} or {@code @ProducerModule}. */
- static boolean isModuleAnnotation(AnnotationMirror annotation) {
- return MODULE_ANNOTATIONS.stream()
- .map(Class::getCanonicalName)
- .anyMatch(asTypeElement(annotation.getAnnotationType()).getQualifiedName()::contentEquals);
- }
-
- /** The module annotation types. */
- static ImmutableSet<Class<? extends Annotation>> moduleAnnotations() {
- return MODULE_ANNOTATIONS;
- }
-
- /**
- * Creates an object that represents a {@code @Module} or {@code @ProducerModule}.
- *
- * @throws IllegalArgumentException if {@link #isModuleAnnotation(AnnotationMirror)} returns
- * {@code false}
- */
- static ModuleAnnotation moduleAnnotation(AnnotationMirror annotation) {
- checkArgument(
- isModuleAnnotation(annotation),
- "%s is not a Module or ProducerModule annotation",
- annotation);
- return new AutoValue_ModuleAnnotation(annotation);
- }
-
- /**
- * Returns an object representing the {@code @Module} or {@code @ProducerModule} annotation if one
- * annotates {@code typeElement}.
- */
- static Optional<ModuleAnnotation> moduleAnnotation(TypeElement typeElement) {
- return getAnyAnnotation(typeElement, Module.class, ProducerModule.class)
- .map(ModuleAnnotation::moduleAnnotation);
- }
-}
diff --git a/java/dagger/internal/codegen/ModuleConstructorProxyGenerator.java b/java/dagger/internal/codegen/ModuleConstructorProxyGenerator.java
deleted file mode 100644
index 5f0d687..0000000
--- a/java/dagger/internal/codegen/ModuleConstructorProxyGenerator.java
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.squareup.javapoet.MethodSpec.constructorBuilder;
-import static com.squareup.javapoet.MethodSpec.methodBuilder;
-import static com.squareup.javapoet.TypeSpec.classBuilder;
-import static dagger.internal.codegen.ModuleKind.checkIsModule;
-import static dagger.internal.codegen.ModuleProxies.nonPublicNullaryConstructor;
-import static javax.lang.model.element.Modifier.FINAL;
-import static javax.lang.model.element.Modifier.PRIVATE;
-import static javax.lang.model.element.Modifier.PUBLIC;
-import static javax.lang.model.element.Modifier.STATIC;
-
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.TypeSpec;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import java.util.Optional;
-import javax.annotation.processing.Filer;
-import javax.inject.Inject;
-import javax.lang.model.SourceVersion;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.TypeElement;
-
-/**
- * Generates a {@code public static} method that calls {@code new SomeModule()} for modules that
- * don't have {@linkplain ModuleProxies#nonPublicNullaryConstructor(TypeElement,
- * DaggerElements) publicly accessible constructors}.
- */
-// TODO(dpb): See if this can become a SourceFileGenerator<ModuleDescriptor> instead. Doing so may
-// cause ModuleProcessingStep to defer elements multiple times.
-final class ModuleConstructorProxyGenerator extends SourceFileGenerator<TypeElement> {
- private final DaggerElements elements;
-
- @Inject
- ModuleConstructorProxyGenerator(
- Filer filer, DaggerElements elements, SourceVersion sourceVersion) {
- super(filer, elements, sourceVersion);
- this.elements = elements;
- }
-
- @Override
- ClassName nameGeneratedType(TypeElement moduleElement) {
- return ModuleProxies.constructorProxyTypeName(moduleElement);
- }
-
- @Override
- Element originatingElement(TypeElement moduleElement) {
- return moduleElement;
- }
-
- @Override
- Optional<TypeSpec.Builder> write(ClassName generatedTypeName, TypeElement moduleElement) {
- checkIsModule(moduleElement);
- return nonPublicNullaryConstructor(moduleElement, elements).isPresent()
- ? Optional.of(buildProxy(generatedTypeName, moduleElement))
- : Optional.empty();
- }
-
- private TypeSpec.Builder buildProxy(ClassName generatedTypeName, TypeElement moduleElement) {
- return classBuilder(generatedTypeName)
- .addModifiers(PUBLIC, FINAL)
- .addMethod(constructorBuilder().addModifiers(PRIVATE).build())
- .addMethod(
- methodBuilder("newInstance")
- .addModifiers(PUBLIC, STATIC)
- .returns(ClassName.get(moduleElement))
- .addStatement("return new $T()", moduleElement)
- .build());
- }
-}
diff --git a/java/dagger/internal/codegen/ModuleDescriptor.java b/java/dagger/internal/codegen/ModuleDescriptor.java
deleted file mode 100644
index ac7a4b7..0000000
--- a/java/dagger/internal/codegen/ModuleDescriptor.java
+++ /dev/null
@@ -1,225 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreElements.getPackage;
-import static com.google.auto.common.MoreElements.isAnnotationPresent;
-import static com.google.common.base.CaseFormat.LOWER_CAMEL;
-import static com.google.common.base.CaseFormat.UPPER_CAMEL;
-import static com.google.common.base.Verify.verify;
-import static com.google.common.collect.Iterables.transform;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.internal.codegen.ModuleAnnotation.moduleAnnotation;
-import static dagger.internal.codegen.SourceFiles.classFileName;
-import static dagger.internal.codegen.Util.reentrantComputeIfAbsent;
-import static dagger.internal.codegen.langmodel.DaggerElements.isAnnotationPresent;
-import static javax.lang.model.type.TypeKind.DECLARED;
-import static javax.lang.model.type.TypeKind.NONE;
-import static javax.lang.model.util.ElementFilter.methodsIn;
-
-import com.google.auto.common.MoreElements;
-import com.google.auto.common.MoreTypes;
-import com.google.auto.value.AutoValue;
-import com.google.auto.value.extension.memoized.Memoized;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.graph.Traverser;
-import com.google.errorprone.annotations.CanIgnoreReturnValue;
-import com.squareup.javapoet.ClassName;
-import dagger.Binds;
-import dagger.BindsOptionalOf;
-import dagger.Module;
-import dagger.Provides;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.model.Key;
-import dagger.multibindings.Multibinds;
-import dagger.producers.Produces;
-import java.util.HashMap;
-import java.util.LinkedHashSet;
-import java.util.Map;
-import java.util.Set;
-import javax.inject.Inject;
-import javax.inject.Singleton;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.TypeMirror;
-
-@AutoValue
-abstract class ModuleDescriptor {
-
- abstract TypeElement moduleElement();
-
- abstract ImmutableSet<TypeElement> includedModules();
-
- abstract ImmutableSet<ContributionBinding> bindings();
-
- /** The multibinding declarations contained in this module. */
- abstract ImmutableSet<MultibindingDeclaration> multibindingDeclarations();
-
- /** The {@link Module#subcomponents() subcomponent declarations} contained in this module. */
- abstract ImmutableSet<SubcomponentDeclaration> subcomponentDeclarations();
-
- /** The {@link Binds} method declarations that define delegate bindings. */
- abstract ImmutableSet<DelegateDeclaration> delegateDeclarations();
-
- /** The {@link BindsOptionalOf} method declarations that define optional bindings. */
- abstract ImmutableSet<OptionalBindingDeclaration> optionalDeclarations();
-
- /** The kind of the module. */
- abstract ModuleKind kind();
-
- /** Returns all of the bindings declared in this module. */
- @Memoized
- ImmutableSet<BindingDeclaration> allBindingDeclarations() {
- return ImmutableSet.<BindingDeclaration>builder()
- .addAll(bindings())
- .addAll(delegateDeclarations())
- .addAll(multibindingDeclarations())
- .addAll(optionalDeclarations())
- .addAll(subcomponentDeclarations())
- .build();
- }
-
- /** Returns the keys of all bindings declared by this module. */
- ImmutableSet<Key> allBindingKeys() {
- return allBindingDeclarations().stream().map(BindingDeclaration::key).collect(toImmutableSet());
- }
-
- @Singleton
- static final class Factory implements ClearableCache {
- private final DaggerElements elements;
- private final BindingFactory bindingFactory;
- private final MultibindingDeclaration.Factory multibindingDeclarationFactory;
- private final DelegateDeclaration.Factory bindingDelegateDeclarationFactory;
- private final SubcomponentDeclaration.Factory subcomponentDeclarationFactory;
- private final OptionalBindingDeclaration.Factory optionalBindingDeclarationFactory;
- private final Map<TypeElement, ModuleDescriptor> cache = new HashMap<>();
-
- @Inject
- Factory(
- DaggerElements elements,
- BindingFactory bindingFactory,
- MultibindingDeclaration.Factory multibindingDeclarationFactory,
- DelegateDeclaration.Factory bindingDelegateDeclarationFactory,
- SubcomponentDeclaration.Factory subcomponentDeclarationFactory,
- OptionalBindingDeclaration.Factory optionalBindingDeclarationFactory) {
- this.elements = elements;
- this.bindingFactory = bindingFactory;
- this.multibindingDeclarationFactory = multibindingDeclarationFactory;
- this.bindingDelegateDeclarationFactory = bindingDelegateDeclarationFactory;
- this.subcomponentDeclarationFactory = subcomponentDeclarationFactory;
- this.optionalBindingDeclarationFactory = optionalBindingDeclarationFactory;
- }
-
- ModuleDescriptor create(TypeElement moduleElement) {
- return reentrantComputeIfAbsent(cache, moduleElement, this::createUncached);
- }
-
- ModuleDescriptor createUncached(TypeElement moduleElement) {
- ImmutableSet.Builder<ContributionBinding> bindings = ImmutableSet.builder();
- ImmutableSet.Builder<DelegateDeclaration> delegates = ImmutableSet.builder();
- ImmutableSet.Builder<MultibindingDeclaration> multibindingDeclarations =
- ImmutableSet.builder();
- ImmutableSet.Builder<OptionalBindingDeclaration> optionalDeclarations =
- ImmutableSet.builder();
-
- for (ExecutableElement moduleMethod : methodsIn(elements.getAllMembers(moduleElement))) {
- if (isAnnotationPresent(moduleMethod, Provides.class)) {
- bindings.add(bindingFactory.providesMethodBinding(moduleMethod, moduleElement));
- }
- if (isAnnotationPresent(moduleMethod, Produces.class)) {
- bindings.add(bindingFactory.producesMethodBinding(moduleMethod, moduleElement));
- }
- if (isAnnotationPresent(moduleMethod, Binds.class)) {
- delegates.add(bindingDelegateDeclarationFactory.create(moduleMethod, moduleElement));
- }
- if (isAnnotationPresent(moduleMethod, Multibinds.class)) {
- multibindingDeclarations.add(
- multibindingDeclarationFactory.forMultibindsMethod(moduleMethod, moduleElement));
- }
- if (isAnnotationPresent(moduleMethod, BindsOptionalOf.class)) {
- optionalDeclarations.add(
- optionalBindingDeclarationFactory.forMethod(moduleMethod, moduleElement));
- }
- }
-
- return new AutoValue_ModuleDescriptor(
- moduleElement,
- ImmutableSet.copyOf(collectIncludedModules(new LinkedHashSet<>(), moduleElement)),
- bindings.build(),
- multibindingDeclarations.build(),
- subcomponentDeclarationFactory.forModule(moduleElement),
- delegates.build(),
- optionalDeclarations.build(),
- ModuleKind.forAnnotatedElement(moduleElement).get());
- }
-
- /** Returns all the modules transitively included by given modules, including the arguments. */
- ImmutableSet<ModuleDescriptor> transitiveModules(Iterable<TypeElement> modules) {
- return ImmutableSet.copyOf(
- Traverser.forGraph(
- (ModuleDescriptor module) -> transform(module.includedModules(), this::create))
- .depthFirstPreOrder(transform(modules, this::create)));
- }
-
- @CanIgnoreReturnValue
- private Set<TypeElement> collectIncludedModules(
- Set<TypeElement> includedModules, TypeElement moduleElement) {
- TypeMirror superclass = moduleElement.getSuperclass();
- if (!superclass.getKind().equals(NONE)) {
- verify(superclass.getKind().equals(DECLARED));
- TypeElement superclassElement = MoreTypes.asTypeElement(superclass);
- if (!superclassElement.getQualifiedName().contentEquals(Object.class.getCanonicalName())) {
- collectIncludedModules(includedModules, superclassElement);
- }
- }
- moduleAnnotation(moduleElement)
- .ifPresent(
- moduleAnnotation -> {
- includedModules.addAll(moduleAnnotation.includes());
- includedModules.addAll(implicitlyIncludedModules(moduleElement));
- });
- return includedModules;
- }
-
- // @ContributesAndroidInjector generates a module that is implicitly included in the enclosing
- // module
- private ImmutableSet<TypeElement> implicitlyIncludedModules(TypeElement moduleElement) {
- TypeElement contributesAndroidInjector =
- elements.getTypeElement("dagger.android.ContributesAndroidInjector");
- if (contributesAndroidInjector == null) {
- return ImmutableSet.of();
- }
- return methodsIn(moduleElement.getEnclosedElements()).stream()
- .filter(method -> isAnnotationPresent(method, contributesAndroidInjector.asType()))
- .map(method -> elements.checkTypePresent(implicitlyIncludedModuleName(method)))
- .collect(toImmutableSet());
- }
-
- private String implicitlyIncludedModuleName(ExecutableElement method) {
- return getPackage(method).getQualifiedName()
- + "."
- + classFileName(ClassName.get(MoreElements.asType(method.getEnclosingElement())))
- + "_"
- + LOWER_CAMEL.to(UPPER_CAMEL, method.getSimpleName().toString());
- }
-
- @Override
- public void clearCache() {
- cache.clear();
- }
- }
-}
diff --git a/java/dagger/internal/codegen/ModuleGenerator.java b/java/dagger/internal/codegen/ModuleGenerator.java
deleted file mode 100644
index 161b47b..0000000
--- a/java/dagger/internal/codegen/ModuleGenerator.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static java.lang.annotation.RetentionPolicy.RUNTIME;
-
-import java.lang.annotation.Retention;
-import javax.inject.Qualifier;
-
-/** Qualifier for a {@link SourceFileGenerator} for modules. */
-@Qualifier
-@Retention(RUNTIME)
-@interface ModuleGenerator {}
diff --git a/java/dagger/internal/codegen/ModuleKind.java b/java/dagger/internal/codegen/ModuleKind.java
deleted file mode 100644
index c93d8ce..0000000
--- a/java/dagger/internal/codegen/ModuleKind.java
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.internal.codegen.langmodel.DaggerElements.getAnnotationMirror;
-
-import com.google.auto.common.MoreElements;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Sets;
-import dagger.Module;
-import dagger.producers.ProducerModule;
-import java.lang.annotation.Annotation;
-import java.util.EnumSet;
-import java.util.Optional;
-import java.util.Set;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.TypeElement;
-
-/** Enumeration of the kinds of modules. */
-enum ModuleKind {
- /** {@code @Module} */
- MODULE(Module.class),
-
- /** {@code @ProducerModule} */
- PRODUCER_MODULE(ProducerModule.class);
-
- /** Returns the annotations for modules of the given kinds. */
- static ImmutableSet<Class<? extends Annotation>> annotationsFor(Set<ModuleKind> kinds) {
- return kinds.stream().map(ModuleKind::annotation).collect(toImmutableSet());
- }
-
- /**
- * Returns the kind of an annotated element if it is annotated with one of the module {@linkplain
- * #annotation() annotations}.
- *
- * @throws IllegalArgumentException if the element is annotated with more than one of the module
- * annotations
- */
- static Optional<ModuleKind> forAnnotatedElement(TypeElement element) {
- Set<ModuleKind> kinds = EnumSet.noneOf(ModuleKind.class);
- for (ModuleKind kind : values()) {
- if (MoreElements.isAnnotationPresent(element, kind.annotation())) {
- kinds.add(kind);
- }
- }
-
- if (kinds.size() > 1) {
- throw new IllegalArgumentException(
- element + " cannot be annotated with more than one of " + annotationsFor(kinds));
- }
- return kinds.stream().findAny();
- }
-
- static void checkIsModule(TypeElement moduleElement) {
- checkArgument(forAnnotatedElement(moduleElement).isPresent());
- }
-
- private final Class<? extends Annotation> moduleAnnotation;
-
- ModuleKind(Class<? extends Annotation> moduleAnnotation) {
- this.moduleAnnotation = moduleAnnotation;
- }
-
- /**
- * Returns the annotation mirror for this module kind on the given type.
- *
- * @throws IllegalArgumentException if the annotation is not present on the type
- */
- AnnotationMirror getModuleAnnotation(TypeElement element) {
- Optional<AnnotationMirror> result = getAnnotationMirror(element, moduleAnnotation);
- checkArgument(
- result.isPresent(), "annotation %s is not present on type %s", moduleAnnotation, element);
- return result.get();
- }
-
- /** Returns the annotation that marks a module of this kind. */
- Class<? extends Annotation> annotation() {
- return moduleAnnotation;
- }
-
- /** Returns the kinds of modules that a module of this kind is allowed to include. */
- ImmutableSet<ModuleKind> legalIncludedModuleKinds() {
- switch (this) {
- case MODULE:
- return Sets.immutableEnumSet(MODULE);
- case PRODUCER_MODULE:
- return Sets.immutableEnumSet(MODULE, PRODUCER_MODULE);
- }
- throw new AssertionError(this);
- }
-}
diff --git a/java/dagger/internal/codegen/ModuleProcessingStep.java b/java/dagger/internal/codegen/ModuleProcessingStep.java
index 27cd531..2bf3354 100644
--- a/java/dagger/internal/codegen/ModuleProcessingStep.java
+++ b/java/dagger/internal/codegen/ModuleProcessingStep.java
@@ -28,7 +28,19 @@
import dagger.Binds;
import dagger.Module;
import dagger.Provides;
-import dagger.internal.codegen.DelegateDeclaration.Factory;
+import dagger.internal.codegen.base.SourceFileGenerator;
+import dagger.internal.codegen.binding.BindingFactory;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.binding.DelegateDeclaration;
+import dagger.internal.codegen.binding.DelegateDeclaration.Factory;
+import dagger.internal.codegen.binding.ProductionBinding;
+import dagger.internal.codegen.binding.ProvisionBinding;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.internal.codegen.validation.ModuleValidator;
+import dagger.internal.codegen.validation.TypeCheckingProcessingStep;
+import dagger.internal.codegen.validation.ValidationReport;
+import dagger.internal.codegen.writing.InaccessibleMapKeyProxyGenerator;
+import dagger.internal.codegen.writing.ModuleGenerator;
import dagger.producers.ProducerModule;
import dagger.producers.Produces;
import java.lang.annotation.Annotation;
@@ -53,6 +65,7 @@
private final SourceFileGenerator<TypeElement> moduleConstructorProxyGenerator;
private final InaccessibleMapKeyProxyGenerator inaccessibleMapKeyProxyGenerator;
private final DelegateDeclaration.Factory delegateDeclarationFactory;
+ private final KotlinMetadataUtil metadataUtil;
private final Set<TypeElement> processedModuleElements = Sets.newLinkedHashSet();
@Inject
@@ -64,7 +77,8 @@
SourceFileGenerator<ProductionBinding> producerFactoryGenerator,
@ModuleGenerator SourceFileGenerator<TypeElement> moduleConstructorProxyGenerator,
InaccessibleMapKeyProxyGenerator inaccessibleMapKeyProxyGenerator,
- Factory delegateDeclarationFactory) {
+ Factory delegateDeclarationFactory,
+ KotlinMetadataUtil metadataUtil) {
super(MoreElements::asType);
this.messager = messager;
this.moduleValidator = moduleValidator;
@@ -74,6 +88,7 @@
this.moduleConstructorProxyGenerator = moduleConstructorProxyGenerator;
this.inaccessibleMapKeyProxyGenerator = inaccessibleMapKeyProxyGenerator;
this.delegateDeclarationFactory = delegateDeclarationFactory;
+ this.metadataUtil = metadataUtil;
}
@Override
@@ -95,23 +110,38 @@
if (processedModuleElements.contains(module)) {
return;
}
+ // For backwards compatibility, we allow a companion object to be annotated with @Module even
+ // though it's no longer required. However, we skip processing the companion object itself
+ // because it will now be processed when processing the companion object's enclosing class.
+ if (metadataUtil.isCompanionObjectClass(module)) {
+ // TODO(danysantiago): Be strict about annotating companion objects with @Module,
+ // i.e. tell user to annotate parent instead.
+ return;
+ }
ValidationReport<TypeElement> report = moduleValidator.validate(module);
report.printMessagesTo(messager);
if (report.isClean()) {
- for (ExecutableElement method : methodsIn(module.getEnclosedElements())) {
- if (isAnnotationPresent(method, Provides.class)) {
- generate(factoryGenerator, bindingFactory.providesMethodBinding(method, module));
- } else if (isAnnotationPresent(method, Produces.class)) {
- generate(producerFactoryGenerator, bindingFactory.producesMethodBinding(method, module));
- } else if (isAnnotationPresent(method, Binds.class)) {
- inaccessibleMapKeyProxyGenerator.generate(bindsMethodBinding(module, method), messager);
- }
+ generateForMethodsIn(module);
+ if (metadataUtil.hasEnclosedCompanionObject(module)) {
+ generateForMethodsIn(metadataUtil.getEnclosedCompanionObject(module));
}
- moduleConstructorProxyGenerator.generate(module, messager);
}
processedModuleElements.add(module);
}
+ private void generateForMethodsIn(TypeElement module) {
+ for (ExecutableElement method : methodsIn(module.getEnclosedElements())) {
+ if (isAnnotationPresent(method, Provides.class)) {
+ generate(factoryGenerator, bindingFactory.providesMethodBinding(method, module));
+ } else if (isAnnotationPresent(method, Produces.class)) {
+ generate(producerFactoryGenerator, bindingFactory.producesMethodBinding(method, module));
+ } else if (isAnnotationPresent(method, Binds.class)) {
+ inaccessibleMapKeyProxyGenerator.generate(bindsMethodBinding(module, method), messager);
+ }
+ }
+ moduleConstructorProxyGenerator.generate(module, messager);
+ }
+
private <B extends ContributionBinding> void generate(
SourceFileGenerator<B> generator, B binding) {
generator.generate(binding, messager);
diff --git a/java/dagger/internal/codegen/ModuleProxies.java b/java/dagger/internal/codegen/ModuleProxies.java
deleted file mode 100644
index 6426e69..0000000
--- a/java/dagger/internal/codegen/ModuleProxies.java
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.langmodel.Accessibility.isElementAccessibleFrom;
-import static javax.lang.model.element.Modifier.ABSTRACT;
-import static javax.lang.model.element.Modifier.PRIVATE;
-import static javax.lang.model.element.Modifier.STATIC;
-import static javax.lang.model.util.ElementFilter.constructorsIn;
-
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import dagger.internal.codegen.langmodel.Accessibility;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import java.util.Optional;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-
-/** Convenience methods for generating and using module constructor proxy methods. */
-final class ModuleProxies {
- /** The name of the class that hosts the module constructor proxy method. */
- static ClassName constructorProxyTypeName(TypeElement moduleElement) {
- ModuleKind.checkIsModule(moduleElement);
- ClassName moduleClassName = ClassName.get(moduleElement);
- return moduleClassName
- .topLevelClassName()
- .peerClass(SourceFiles.classFileName(moduleClassName) + "_Proxy");
- }
-
- /**
- * The module constructor being proxied. A proxy is generated if it is not publicly accessible and
- * has no arguments. If an implicit reference to the enclosing class exists, or the module is
- * abstract, no proxy method can be generated.
- */
- // TODO(ronshapiro): make this an @Injectable class that injects DaggerElements
- static Optional<ExecutableElement> nonPublicNullaryConstructor(
- TypeElement moduleElement, DaggerElements elements) {
- ModuleKind.checkIsModule(moduleElement);
- if (moduleElement.getModifiers().contains(ABSTRACT)
- || (moduleElement.getNestingKind().isNested()
- && !moduleElement.getModifiers().contains(STATIC))) {
- return Optional.empty();
- }
- return constructorsIn(elements.getAllMembers(moduleElement)).stream()
- .filter(constructor -> !Accessibility.isElementPubliclyAccessible(constructor))
- .filter(constructor -> !constructor.getModifiers().contains(PRIVATE))
- .filter(constructor -> constructor.getParameters().isEmpty())
- .findAny();
- }
-
- /**
- * Returns a code block that creates a new module instance, either by invoking the nullary
- * constructor if it's accessible from {@code requestingClass} or else by invoking the
- * constructor's generated proxy method.
- */
- static CodeBlock newModuleInstance(
- TypeElement moduleElement, ClassName requestingClass, DaggerElements elements) {
- ModuleKind.checkIsModule(moduleElement);
- String packageName = requestingClass.packageName();
- return nonPublicNullaryConstructor(moduleElement, elements)
- .filter(constructor -> !isElementAccessibleFrom(constructor, packageName))
- .map(
- constructor ->
- CodeBlock.of("$T.newInstance()", constructorProxyTypeName(moduleElement)))
- .orElse(CodeBlock.of("new $T()", moduleElement));
- }
-}
diff --git a/java/dagger/internal/codegen/ModuleValidator.java b/java/dagger/internal/codegen/ModuleValidator.java
deleted file mode 100644
index 094bf34..0000000
--- a/java/dagger/internal/codegen/ModuleValidator.java
+++ /dev/null
@@ -1,644 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.AnnotationMirrors.getAnnotatedAnnotations;
-import static com.google.auto.common.Visibility.PRIVATE;
-import static com.google.auto.common.Visibility.PUBLIC;
-import static com.google.auto.common.Visibility.effectiveVisibilityOfElement;
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static dagger.internal.codegen.ComponentAnnotation.componentAnnotation;
-import static dagger.internal.codegen.ComponentAnnotation.isComponentAnnotation;
-import static dagger.internal.codegen.ComponentAnnotation.subcomponentAnnotation;
-import static dagger.internal.codegen.ComponentCreatorAnnotation.getCreatorAnnotations;
-import static dagger.internal.codegen.ConfigurationAnnotations.getSubcomponentCreator;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.internal.codegen.ModuleAnnotation.isModuleAnnotation;
-import static dagger.internal.codegen.ModuleAnnotation.moduleAnnotation;
-import static dagger.internal.codegen.MoreAnnotationMirrors.simpleName;
-import static dagger.internal.codegen.MoreAnnotationValues.asType;
-import static dagger.internal.codegen.Util.reentrantComputeIfAbsent;
-import static dagger.internal.codegen.ValidationType.NONE;
-import static dagger.internal.codegen.langmodel.DaggerElements.getAnnotationMirror;
-import static dagger.internal.codegen.langmodel.DaggerElements.isAnyAnnotationPresent;
-import static java.util.EnumSet.noneOf;
-import static java.util.stream.Collectors.joining;
-import static javax.lang.model.element.Modifier.ABSTRACT;
-import static javax.lang.model.element.Modifier.STATIC;
-import static javax.lang.model.util.ElementFilter.methodsIn;
-
-import com.google.auto.common.MoreElements;
-import com.google.auto.common.MoreTypes;
-import com.google.auto.common.Visibility;
-import com.google.common.base.Joiner;
-import com.google.common.collect.ArrayListMultimap;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ListMultimap;
-import com.google.common.collect.Sets;
-import com.google.errorprone.annotations.FormatMethod;
-import dagger.Module;
-import dagger.Subcomponent;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.BindingGraph;
-import dagger.producers.ProducerModule;
-import dagger.producers.ProductionSubcomponent;
-import java.lang.annotation.Annotation;
-import java.util.Collection;
-import java.util.EnumSet;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Optional;
-import java.util.Set;
-import javax.inject.Inject;
-import javax.inject.Scope;
-import javax.inject.Singleton;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.AnnotationValue;
-import javax.lang.model.element.ElementKind;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.TypeMirror;
-import javax.lang.model.util.SimpleAnnotationValueVisitor8;
-import javax.lang.model.util.SimpleTypeVisitor8;
-
-/**
- * A {@linkplain ValidationReport validator} for {@link Module}s or {@link ProducerModule}s.
- */
-@Singleton
-final class ModuleValidator {
- private static final ImmutableSet<Class<? extends Annotation>> SUBCOMPONENT_TYPES =
- ImmutableSet.of(Subcomponent.class, ProductionSubcomponent.class);
- private static final ImmutableSet<Class<? extends Annotation>> SUBCOMPONENT_CREATOR_TYPES =
- ImmutableSet.of(
- Subcomponent.Builder.class,
- Subcomponent.Factory.class,
- ProductionSubcomponent.Builder.class,
- ProductionSubcomponent.Factory.class);
- private static final Optional<Class<?>> ANDROID_PROCESSOR;
- private static final String CONTRIBUTES_ANDROID_INJECTOR_NAME =
- "dagger.android.ContributesAndroidInjector";
- private static final String ANDROID_PROCESSOR_NAME = "dagger.android.processor.AndroidProcessor";
-
- static {
- Class<?> clazz;
- try {
- clazz = Class.forName(ANDROID_PROCESSOR_NAME, false, ModuleValidator.class.getClassLoader());
- } catch (ClassNotFoundException ignored) {
- clazz = null;
- }
- ANDROID_PROCESSOR = Optional.ofNullable(clazz);
- }
-
- private final DaggerTypes types;
- private final DaggerElements elements;
- private final AnyBindingMethodValidator anyBindingMethodValidator;
- private final MethodSignatureFormatter methodSignatureFormatter;
- private final ComponentDescriptorFactory componentDescriptorFactory;
- private final BindingGraphFactory bindingGraphFactory;
- private final BindingGraphConverter bindingGraphConverter;
- private final BindingGraphValidator bindingGraphValidator;
- private final CompilerOptions compilerOptions;
- private final Map<TypeElement, ValidationReport<TypeElement>> cache = new HashMap<>();
- private final Set<TypeElement> knownModules = new HashSet<>();
-
- @Inject
- ModuleValidator(
- DaggerTypes types,
- DaggerElements elements,
- AnyBindingMethodValidator anyBindingMethodValidator,
- MethodSignatureFormatter methodSignatureFormatter,
- ComponentDescriptorFactory componentDescriptorFactory,
- BindingGraphFactory bindingGraphFactory,
- BindingGraphConverter bindingGraphConverter,
- BindingGraphValidator bindingGraphValidator,
- CompilerOptions compilerOptions) {
- this.types = types;
- this.elements = elements;
- this.anyBindingMethodValidator = anyBindingMethodValidator;
- this.methodSignatureFormatter = methodSignatureFormatter;
- this.componentDescriptorFactory = componentDescriptorFactory;
- this.bindingGraphFactory = bindingGraphFactory;
- this.bindingGraphConverter = bindingGraphConverter;
- this.bindingGraphValidator = bindingGraphValidator;
- this.compilerOptions = compilerOptions;
- }
-
- /**
- * Adds {@code modules} to the set of module types that will be validated during this compilation
- * step. If a component or module includes a module that is not in this set, that included module
- * is assumed to be valid because it was processed in a previous compilation step. If it were
- * invalid, that previous compilation step would have failed and blocked this one.
- *
- * <p>This logic depends on this method being called before {@linkplain #validate(TypeElement)
- * validating} any module or {@linkplain #validateReferencedModules(TypeElement, AnnotationMirror,
- * ImmutableSet, Set) component}.
- */
- void addKnownModules(Collection<TypeElement> modules) {
- knownModules.addAll(modules);
- }
-
- /** Returns a validation report for a module type. */
- ValidationReport<TypeElement> validate(TypeElement module) {
- return validate(module, new HashSet<>());
- }
-
- private ValidationReport<TypeElement> validate(
- TypeElement module, Set<TypeElement> visitedModules) {
- if (visitedModules.add(module)) {
- return reentrantComputeIfAbsent(cache, module, m -> validateUncached(module, visitedModules));
- }
- return ValidationReport.about(module).build();
- }
-
- private ValidationReport<TypeElement> validateUncached(
- TypeElement module, Set<TypeElement> visitedModules) {
- ValidationReport.Builder<TypeElement> builder = ValidationReport.about(module);
- ModuleKind moduleKind = ModuleKind.forAnnotatedElement(module).get();
-
- ListMultimap<String, ExecutableElement> allMethodsByName = ArrayListMultimap.create();
- ListMultimap<String, ExecutableElement> bindingMethodsByName = ArrayListMultimap.create();
-
- Set<ModuleMethodKind> methodKinds = noneOf(ModuleMethodKind.class);
- TypeElement contributesAndroidInjectorElement =
- elements.getTypeElement(CONTRIBUTES_ANDROID_INJECTOR_NAME);
- TypeMirror contributesAndroidInjector =
- contributesAndroidInjectorElement != null
- ? contributesAndroidInjectorElement.asType()
- : null;
- for (ExecutableElement moduleMethod : methodsIn(module.getEnclosedElements())) {
- if (anyBindingMethodValidator.isBindingMethod(moduleMethod)) {
- builder.addSubreport(anyBindingMethodValidator.validate(moduleMethod));
- bindingMethodsByName.put(moduleMethod.getSimpleName().toString(), moduleMethod);
- methodKinds.add(ModuleMethodKind.ofMethod(moduleMethod));
- }
- allMethodsByName.put(moduleMethod.getSimpleName().toString(), moduleMethod);
-
- for (AnnotationMirror annotation : moduleMethod.getAnnotationMirrors()) {
- if (!ANDROID_PROCESSOR.isPresent()
- && MoreTypes.equivalence()
- .equivalent(contributesAndroidInjector, annotation.getAnnotationType())) {
- builder.addSubreport(
- ValidationReport.about(moduleMethod)
- .addError(
- String.format(
- "@%s was used, but %s was not found on the processor path",
- CONTRIBUTES_ANDROID_INJECTOR_NAME, ANDROID_PROCESSOR_NAME))
- .build());
- break;
- }
- }
- }
-
- if (methodKinds.containsAll(
- EnumSet.of(ModuleMethodKind.ABSTRACT_DECLARATION, ModuleMethodKind.INSTANCE_BINDING))) {
- builder.addError(
- String.format(
- "A @%s may not contain both non-static and abstract binding methods",
- moduleKind.annotation().getSimpleName()));
- }
-
- validateModuleVisibility(module, moduleKind, builder);
- validateMethodsWithSameName(builder, bindingMethodsByName);
- if (module.getKind() != ElementKind.INTERFACE) {
- validateBindingMethodOverrides(module, builder, allMethodsByName, bindingMethodsByName);
- }
- validateModifiers(module, builder);
- validateReferencedModules(module, moduleKind, visitedModules, builder);
- validateReferencedSubcomponents(module, moduleKind, builder);
- validateNoScopeAnnotationsOnModuleElement(module, moduleKind, builder);
- validateSelfCycles(module, builder);
-
- if (builder.build().isClean()
- && !compilerOptions.fullBindingGraphValidationType(module).equals(NONE)) {
- validateModuleBindings(module, builder);
- }
-
- return builder.build();
- }
-
- private void validateReferencedSubcomponents(
- final TypeElement subject,
- ModuleKind moduleKind,
- final ValidationReport.Builder<TypeElement> builder) {
- // TODO(ronshapiro): use validateTypesAreDeclared when it is checked in
- ModuleAnnotation moduleAnnotation = moduleAnnotation(moduleKind.getModuleAnnotation(subject));
- for (AnnotationValue subcomponentAttribute :
- moduleAnnotation.subcomponentsAsAnnotationValues()) {
- asType(subcomponentAttribute)
- .accept(
- new SimpleTypeVisitor8<Void, Void>() {
- @Override
- protected Void defaultAction(TypeMirror e, Void aVoid) {
- builder.addError(
- e + " is not a valid subcomponent type",
- subject,
- moduleAnnotation.annotation(),
- subcomponentAttribute);
- return null;
- }
-
- @Override
- public Void visitDeclared(DeclaredType declaredType, Void aVoid) {
- TypeElement attributeType = MoreTypes.asTypeElement(declaredType);
- if (isAnyAnnotationPresent(attributeType, SUBCOMPONENT_TYPES)) {
- validateSubcomponentHasBuilder(
- attributeType, moduleAnnotation.annotation(), builder);
- } else {
- builder.addError(
- isAnyAnnotationPresent(attributeType, SUBCOMPONENT_CREATOR_TYPES)
- ? moduleSubcomponentsIncludesCreator(attributeType)
- : moduleSubcomponentsIncludesNonSubcomponent(attributeType),
- subject,
- moduleAnnotation.annotation(),
- subcomponentAttribute);
- }
-
- return null;
- }
- },
- null);
- }
- }
-
- private static String moduleSubcomponentsIncludesNonSubcomponent(TypeElement notSubcomponent) {
- return notSubcomponent.getQualifiedName()
- + " is not a @Subcomponent or @ProductionSubcomponent";
- }
-
- private static String moduleSubcomponentsIncludesCreator(
- TypeElement moduleSubcomponentsAttribute) {
- TypeElement subcomponentType =
- MoreElements.asType(moduleSubcomponentsAttribute.getEnclosingElement());
- ComponentCreatorAnnotation creatorAnnotation =
- getOnlyElement(getCreatorAnnotations(moduleSubcomponentsAttribute));
- return String.format(
- "%s is a @%s.%s. Did you mean to use %s?",
- moduleSubcomponentsAttribute.getQualifiedName(),
- subcomponentAnnotation(subcomponentType).get().simpleName(),
- creatorAnnotation.creatorKind().typeName(),
- subcomponentType.getQualifiedName());
- }
-
- private static void validateSubcomponentHasBuilder(
- TypeElement subcomponentAttribute,
- AnnotationMirror moduleAnnotation,
- ValidationReport.Builder<TypeElement> builder) {
- if (getSubcomponentCreator(subcomponentAttribute).isPresent()) {
- return;
- }
- builder.addError(
- moduleSubcomponentsDoesntHaveCreator(subcomponentAttribute, moduleAnnotation),
- builder.getSubject(),
- moduleAnnotation);
- }
-
- private static String moduleSubcomponentsDoesntHaveCreator(
- TypeElement subcomponent, AnnotationMirror moduleAnnotation) {
- return String.format(
- "%1$s doesn't have a @%2$s.Builder or @%2$s.Factory, which is required when used with "
- + "@%3$s.subcomponents",
- subcomponent.getQualifiedName(),
- subcomponentAnnotation(subcomponent).get().simpleName(),
- simpleName(moduleAnnotation));
- }
-
- enum ModuleMethodKind {
- ABSTRACT_DECLARATION,
- INSTANCE_BINDING,
- STATIC_BINDING,
- ;
-
- static ModuleMethodKind ofMethod(ExecutableElement moduleMethod) {
- if (moduleMethod.getModifiers().contains(STATIC)) {
- return STATIC_BINDING;
- } else if (moduleMethod.getModifiers().contains(ABSTRACT)) {
- return ABSTRACT_DECLARATION;
- } else {
- return INSTANCE_BINDING;
- }
- }
- }
-
- private void validateModifiers(
- TypeElement subject, ValidationReport.Builder<TypeElement> builder) {
- // This coupled with the check for abstract modules in ComponentValidator guarantees that
- // only modules without type parameters are referenced from @Component(modules={...}).
- if (!subject.getTypeParameters().isEmpty() && !subject.getModifiers().contains(ABSTRACT)) {
- builder.addError("Modules with type parameters must be abstract", subject);
- }
- }
-
- private void validateMethodsWithSameName(
- ValidationReport.Builder<TypeElement> builder,
- ListMultimap<String, ExecutableElement> bindingMethodsByName) {
- for (Entry<String, Collection<ExecutableElement>> entry :
- bindingMethodsByName.asMap().entrySet()) {
- if (entry.getValue().size() > 1) {
- for (ExecutableElement offendingMethod : entry.getValue()) {
- builder.addError(
- String.format(
- "Cannot have more than one binding method with the same name in a single module"),
- offendingMethod);
- }
- }
- }
- }
-
- private void validateReferencedModules(
- TypeElement subject,
- ModuleKind moduleKind,
- Set<TypeElement> visitedModules,
- ValidationReport.Builder<TypeElement> builder) {
- // Validate that all the modules we include are valid for inclusion.
- AnnotationMirror mirror = moduleKind.getModuleAnnotation(subject);
- builder.addSubreport(
- validateReferencedModules(
- subject, mirror, moduleKind.legalIncludedModuleKinds(), visitedModules));
- }
-
- /**
- * Validates modules included in a given module or installed in a given component.
- *
- * <p>Checks that the referenced modules are non-generic types annotated with {@code @Module} or
- * {@code @ProducerModule}.
- *
- * <p>If the referenced module is in the {@linkplain #addKnownModules(Collection) known modules
- * set} and has errors, reports an error at that module's inclusion.
- *
- * @param annotatedType the annotated module or component
- * @param annotation the annotation specifying the referenced modules ({@code @Component},
- * {@code @ProductionComponent}, {@code @Subcomponent}, {@code @ProductionSubcomponent},
- * {@code @Module}, or {@code @ProducerModule})
- * @param validModuleKinds the module kinds that the annotated type is permitted to include
- */
- ValidationReport<TypeElement> validateReferencedModules(
- TypeElement annotatedType,
- AnnotationMirror annotation,
- ImmutableSet<ModuleKind> validModuleKinds,
- Set<TypeElement> visitedModules) {
- ValidationReport.Builder<TypeElement> subreport = ValidationReport.about(annotatedType);
- ImmutableSet<? extends Class<? extends Annotation>> validModuleAnnotations =
- validModuleKinds.stream().map(ModuleKind::annotation).collect(toImmutableSet());
-
- for (AnnotationValue includedModule : getModules(annotation)) {
- asType(includedModule)
- .accept(
- new SimpleTypeVisitor8<Void, Void>() {
- @Override
- protected Void defaultAction(TypeMirror mirror, Void p) {
- reportError("%s is not a valid module type.", mirror);
- return null;
- }
-
- @Override
- public Void visitDeclared(DeclaredType t, Void p) {
- TypeElement module = MoreElements.asType(t.asElement());
- if (!t.getTypeArguments().isEmpty()) {
- reportError(
- "%s is listed as a module, but has type parameters",
- module.getQualifiedName());
- }
- if (!isAnyAnnotationPresent(module, validModuleAnnotations)) {
- reportError(
- "%s is listed as a module, but is not annotated with %s",
- module.getQualifiedName(),
- (validModuleAnnotations.size() > 1 ? "one of " : "")
- + validModuleAnnotations
- .stream()
- .map(otherClass -> "@" + otherClass.getSimpleName())
- .collect(joining(", ")));
- } else if (knownModules.contains(module)
- && !validate(module, visitedModules).isClean()) {
- reportError("%s has errors", module.getQualifiedName());
- }
- return null;
- }
-
- @FormatMethod
- private void reportError(String format, Object... args) {
- subreport.addError(
- String.format(format, args), annotatedType, annotation, includedModule);
- }
- },
- null);
- }
- return subreport.build();
- }
-
- private static ImmutableList<AnnotationValue> getModules(AnnotationMirror annotation) {
- if (isModuleAnnotation(annotation)) {
- return moduleAnnotation(annotation).includesAsAnnotationValues();
- }
- if (isComponentAnnotation(annotation)) {
- return componentAnnotation(annotation).moduleValues();
- }
- throw new IllegalArgumentException(String.format("unsupported annotation: %s", annotation));
- }
-
- private void validateBindingMethodOverrides(
- TypeElement subject,
- ValidationReport.Builder<TypeElement> builder,
- ListMultimap<String, ExecutableElement> allMethodsByName,
- ListMultimap<String, ExecutableElement> bindingMethodsByName) {
- // For every binding method, confirm it overrides nothing *and* nothing overrides it.
- // Consider the following hierarchy:
- // class Parent {
- // @Provides Foo a() {}
- // @Provides Foo b() {}
- // Foo c() {}
- // }
- // class Child extends Parent {
- // @Provides Foo a() {}
- // Foo b() {}
- // @Provides Foo c() {}
- // }
- // In each of those cases, we want to fail. "a" is clear, "b" because Child is overriding
- // a binding method in Parent, and "c" because Child is defining a binding method that overrides
- // Parent.
- TypeElement currentClass = subject;
- TypeMirror objectType = elements.getTypeElement(Object.class).asType();
- // We keep track of methods that failed so we don't spam with multiple failures.
- Set<ExecutableElement> failedMethods = Sets.newHashSet();
- while (!types.isSameType(currentClass.getSuperclass(), objectType)) {
- currentClass = MoreElements.asType(types.asElement(currentClass.getSuperclass()));
- List<ExecutableElement> superclassMethods = methodsIn(currentClass.getEnclosedElements());
- for (ExecutableElement superclassMethod : superclassMethods) {
- String name = superclassMethod.getSimpleName().toString();
- // For each method in the superclass, confirm our binding methods don't override it
- for (ExecutableElement bindingMethod : bindingMethodsByName.get(name)) {
- if (failedMethods.add(bindingMethod)
- && elements.overrides(bindingMethod, superclassMethod, subject)) {
- builder.addError(
- String.format(
- "Binding methods may not override another method. Overrides: %s",
- methodSignatureFormatter.format(superclassMethod)),
- bindingMethod);
- }
- }
- // For each binding method in superclass, confirm our methods don't override it.
- if (anyBindingMethodValidator.isBindingMethod(superclassMethod)) {
- for (ExecutableElement method : allMethodsByName.get(name)) {
- if (failedMethods.add(method)
- && elements.overrides(method, superclassMethod, subject)) {
- builder.addError(
- String.format(
- "Binding methods may not be overridden in modules. Overrides: %s",
- methodSignatureFormatter.format(superclassMethod)),
- method);
- }
- }
- }
- allMethodsByName.put(superclassMethod.getSimpleName().toString(), superclassMethod);
- }
- }
- }
-
- private void validateModuleVisibility(
- final TypeElement moduleElement,
- ModuleKind moduleKind,
- final ValidationReport.Builder<?> reportBuilder) {
- ModuleAnnotation moduleAnnotation =
- moduleAnnotation(getAnnotationMirror(moduleElement, moduleKind.annotation()).get());
- Visibility moduleVisibility = Visibility.ofElement(moduleElement);
- Visibility moduleEffectiveVisibility = effectiveVisibilityOfElement(moduleElement);
- if (moduleVisibility.equals(PRIVATE)) {
- reportBuilder.addError("Modules cannot be private.", moduleElement);
- } else if (moduleEffectiveVisibility.equals(PRIVATE)) {
- reportBuilder.addError("Modules cannot be enclosed in private types.", moduleElement);
- }
-
- switch (moduleElement.getNestingKind()) {
- case ANONYMOUS:
- throw new IllegalStateException("Can't apply @Module to an anonymous class");
- case LOCAL:
- throw new IllegalStateException("Local classes shouldn't show up in the processor");
- case MEMBER:
- case TOP_LEVEL:
- if (moduleEffectiveVisibility.equals(PUBLIC)) {
- ImmutableSet<TypeElement> invalidVisibilityIncludes =
- getModuleIncludesWithInvalidVisibility(moduleAnnotation);
- if (!invalidVisibilityIncludes.isEmpty()) {
- reportBuilder.addError(
- String.format(
- "This module is public, but it includes non-public (or effectively non-public) "
- + "modules (%s) that have non-static, non-abstract binding methods. Either "
- + "reduce the visibility of this module, make the included modules "
- + "public, or make all of the binding methods on the included modules "
- + "abstract or static.",
- formatListForErrorMessage(invalidVisibilityIncludes.asList())),
- moduleElement);
- }
- }
- }
- }
-
- private ImmutableSet<TypeElement> getModuleIncludesWithInvalidVisibility(
- ModuleAnnotation moduleAnnotation) {
- return moduleAnnotation.includes().stream()
- .filter(include -> !effectiveVisibilityOfElement(include).equals(PUBLIC))
- .filter(this::requiresModuleInstance)
- .collect(toImmutableSet());
- }
-
- /**
- * Returns {@code true} if a module instance is needed for any of the binding methods on the
- * given {@code module}. This is the case when the module has any binding methods that are neither
- * {@code abstract} nor {@code static}.
- */
- private boolean requiresModuleInstance(TypeElement module) {
- // Note elements.getAllMembers(module) rather than module.getEnclosedElements() here: we need to
- // include binding methods declared in supertypes because unlike most other validations being
- // done in this class, which assume that supertype binding methods will be validated in a
- // separate call to the validator since the supertype itself must be a @Module, we need to look
- // at all the binding methods in the module's type hierarchy here.
- return methodsIn(elements.getAllMembers(module)).stream()
- .filter(method -> anyBindingMethodValidator.isBindingMethod(method))
- .map(ExecutableElement::getModifiers)
- .anyMatch(modifiers -> !modifiers.contains(ABSTRACT) && !modifiers.contains(STATIC));
- }
-
- private void validateNoScopeAnnotationsOnModuleElement(
- TypeElement module, ModuleKind moduleKind, ValidationReport.Builder<TypeElement> report) {
- for (AnnotationMirror scope : getAnnotatedAnnotations(module, Scope.class)) {
- report.addError(
- String.format(
- "@%ss cannot be scoped. Did you mean to scope a method instead?",
- moduleKind.annotation().getSimpleName()),
- module,
- scope);
- }
- }
-
- private void validateSelfCycles(
- TypeElement module, ValidationReport.Builder<TypeElement> builder) {
- ModuleAnnotation moduleAnnotation = moduleAnnotation(module).get();
- moduleAnnotation
- .includesAsAnnotationValues()
- .forEach(
- value ->
- value.accept(
- new SimpleAnnotationValueVisitor8<Void, Void>() {
- @Override
- public Void visitType(TypeMirror includedModule, Void aVoid) {
- if (MoreTypes.equivalence().equivalent(module.asType(), includedModule)) {
- String moduleKind = moduleAnnotation.annotationClass().getSimpleName();
- builder.addError(
- String.format("@%s cannot include themselves.", moduleKind),
- module,
- moduleAnnotation.annotation(),
- value);
- }
- return null;
- }
- },
- null));
- }
-
- private void validateModuleBindings(
- TypeElement module, ValidationReport.Builder<TypeElement> report) {
- BindingGraph bindingGraph =
- bindingGraphConverter.convert(
- bindingGraphFactory.create(
- componentDescriptorFactory.moduleComponentDescriptor(module), true));
- if (!bindingGraphValidator.isValid(bindingGraph)) {
- // Since the validator uses a DiagnosticReporter to report errors, the ValdiationReport won't
- // have any Items for them. We have to tell the ValidationReport that some errors were
- // reported for the subject.
- report.markDirty();
- }
- }
-
- private static String formatListForErrorMessage(List<?> things) {
- switch (things.size()) {
- case 0:
- return "";
- case 1:
- return things.get(0).toString();
- default:
- StringBuilder output = new StringBuilder();
- Joiner.on(", ").appendTo(output, things.subList(0, things.size() - 1));
- output.append(" and ").append(things.get(things.size() - 1));
- return output.toString();
- }
- }
-}
diff --git a/java/dagger/internal/codegen/MonitoringModuleGenerator.java b/java/dagger/internal/codegen/MonitoringModuleGenerator.java
deleted file mode 100644
index 1738fe9..0000000
--- a/java/dagger/internal/codegen/MonitoringModuleGenerator.java
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.squareup.javapoet.MethodSpec.constructorBuilder;
-import static com.squareup.javapoet.MethodSpec.methodBuilder;
-import static com.squareup.javapoet.TypeSpec.classBuilder;
-import static dagger.internal.codegen.javapoet.TypeNames.PRODUCTION_COMPONENT_MONITOR_FACTORY;
-import static dagger.internal.codegen.javapoet.TypeNames.providerOf;
-import static dagger.internal.codegen.javapoet.TypeNames.setOf;
-import static javax.lang.model.element.Modifier.ABSTRACT;
-import static javax.lang.model.element.Modifier.PRIVATE;
-import static javax.lang.model.element.Modifier.STATIC;
-
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.MethodSpec;
-import com.squareup.javapoet.TypeSpec;
-import dagger.Module;
-import dagger.Provides;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.multibindings.Multibinds;
-import dagger.producers.ProductionScope;
-import dagger.producers.monitoring.ProductionComponentMonitor;
-import dagger.producers.monitoring.internal.Monitors;
-import java.util.Optional;
-import javax.annotation.processing.Filer;
-import javax.inject.Inject;
-import javax.lang.model.SourceVersion;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.TypeElement;
-
-/** Generates a monitoring module for use with production components. */
-final class MonitoringModuleGenerator extends SourceFileGenerator<TypeElement> {
-
- @Inject
- MonitoringModuleGenerator(Filer filer, DaggerElements elements, SourceVersion sourceVersion) {
- super(filer, elements, sourceVersion);
- }
-
- @Override
- ClassName nameGeneratedType(TypeElement componentElement) {
- return SourceFiles.generatedMonitoringModuleName(componentElement);
- }
-
- @Override
- Element originatingElement(TypeElement componentElement) {
- return componentElement;
- }
-
- @Override
- Optional<TypeSpec.Builder> write(ClassName generatedTypeName, TypeElement componentElement) {
- return Optional.of(
- classBuilder(generatedTypeName)
- .addAnnotation(Module.class)
- .addModifiers(ABSTRACT)
- .addMethod(privateConstructor())
- .addMethod(setOfFactories())
- .addMethod(monitor(componentElement)));
- }
-
- private MethodSpec privateConstructor() {
- return constructorBuilder().addModifiers(PRIVATE).build();
- }
-
- private MethodSpec setOfFactories() {
- return methodBuilder("setOfFactories")
- .addAnnotation(Multibinds.class)
- .addModifiers(ABSTRACT)
- .returns(setOf(PRODUCTION_COMPONENT_MONITOR_FACTORY))
- .build();
- }
-
- private MethodSpec monitor(TypeElement componentElement) {
- return methodBuilder("monitor")
- .returns(ProductionComponentMonitor.class)
- .addModifiers(STATIC)
- .addAnnotation(Provides.class)
- .addAnnotation(ProductionScope.class)
- .addParameter(providerOf(ClassName.get(componentElement.asType())), "component")
- .addParameter(
- providerOf(setOf(PRODUCTION_COMPONENT_MONITOR_FACTORY)), "factories")
- .addStatement(
- "return $T.createMonitorForComponent(component, factories)", Monitors.class)
- .build();
- }
-}
diff --git a/java/dagger/internal/codegen/MonitoringModuleProcessingStep.java b/java/dagger/internal/codegen/MonitoringModuleProcessingStep.java
deleted file mode 100644
index 55ae579..0000000
--- a/java/dagger/internal/codegen/MonitoringModuleProcessingStep.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import com.google.auto.common.MoreElements;
-import com.google.common.collect.ImmutableSet;
-import dagger.producers.ProductionComponent;
-import dagger.producers.ProductionSubcomponent;
-import java.lang.annotation.Annotation;
-import java.util.Set;
-import javax.annotation.processing.Messager;
-import javax.inject.Inject;
-import javax.lang.model.element.TypeElement;
-
-/**
- * A processing step that is responsible for generating a special module for a {@link
- * ProductionComponent} or {@link ProductionSubcomponent}.
- */
-final class MonitoringModuleProcessingStep extends TypeCheckingProcessingStep<TypeElement> {
- private final Messager messager;
- private final MonitoringModuleGenerator monitoringModuleGenerator;
-
- @Inject
- MonitoringModuleProcessingStep(
- Messager messager, MonitoringModuleGenerator monitoringModuleGenerator) {
- super(MoreElements::asType);
- this.messager = messager;
- this.monitoringModuleGenerator = monitoringModuleGenerator;
- }
-
- @Override
- public Set<? extends Class<? extends Annotation>> annotations() {
- return ImmutableSet.of(ProductionComponent.class, ProductionSubcomponent.class);
- }
-
- @Override
- protected void process(
- TypeElement element, ImmutableSet<Class<? extends Annotation>> annotations) {
- monitoringModuleGenerator.generate(MoreElements.asType(element), messager);
- }
-}
diff --git a/java/dagger/internal/codegen/MoreAnnotationMirrors.java b/java/dagger/internal/codegen/MoreAnnotationMirrors.java
deleted file mode 100644
index 92825a0..0000000
--- a/java/dagger/internal/codegen/MoreAnnotationMirrors.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.AnnotationMirrors.getAnnotationValue;
-import static dagger.internal.codegen.DaggerStreams.toImmutableList;
-import static dagger.internal.codegen.MoreAnnotationValues.asAnnotationValues;
-
-import com.google.auto.common.AnnotationMirrors;
-import com.google.common.base.Equivalence;
-import com.google.common.collect.ImmutableList;
-import java.util.Optional;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.Name;
-import javax.lang.model.type.TypeMirror;
-
-/**
- * A utility class for working with {@link AnnotationMirror} instances, similar to {@link
- * AnnotationMirrors}.
- */
-final class MoreAnnotationMirrors {
-
- private MoreAnnotationMirrors() {}
-
- /**
- * Wraps an {@link Optional} of a type in an {@code Optional} of a {@link Equivalence.Wrapper} for
- * that type.
- */
- static Optional<Equivalence.Wrapper<AnnotationMirror>> wrapOptionalInEquivalence(
- Optional<AnnotationMirror> optional) {
- return optional.map(AnnotationMirrors.equivalence()::wrap);
- }
-
- /**
- * Unwraps an {@link Optional} of a {@link Equivalence.Wrapper} into an {@code Optional} of the
- * underlying type.
- */
- static Optional<AnnotationMirror> unwrapOptionalEquivalence(
- Optional<Equivalence.Wrapper<AnnotationMirror>> wrappedOptional) {
- return wrappedOptional.map(Equivalence.Wrapper::get);
- }
-
- static Name simpleName(AnnotationMirror annotationMirror) {
- return annotationMirror.getAnnotationType().asElement().getSimpleName();
- }
-
- /**
- * Returns the list of types that is the value named {@code name} from {@code annotationMirror}.
- *
- * @throws IllegalArgumentException unless that member represents an array of types
- */
- static ImmutableList<TypeMirror> getTypeListValue(
- AnnotationMirror annotationMirror, String name) {
- return asAnnotationValues(getAnnotationValue(annotationMirror, name))
- .stream()
- .map(MoreAnnotationValues::asType)
- .collect(toImmutableList());
- }
-}
diff --git a/java/dagger/internal/codegen/MoreAnnotationValues.java b/java/dagger/internal/codegen/MoreAnnotationValues.java
deleted file mode 100644
index 84a4d94..0000000
--- a/java/dagger/internal/codegen/MoreAnnotationValues.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright (C) 2013 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import com.google.common.collect.ImmutableList;
-import java.util.List;
-import javax.lang.model.element.AnnotationValue;
-import javax.lang.model.element.AnnotationValueVisitor;
-import javax.lang.model.type.TypeMirror;
-import javax.lang.model.util.SimpleAnnotationValueVisitor8;
-
-/** Utility methods for working with {@link AnnotationValue} instances. */
-final class MoreAnnotationValues {
- /**
- * Returns the list of values represented by an array annotation value.
- *
- * @throws IllegalArgumentException unless {@code annotationValue} represents an array
- */
- static ImmutableList<AnnotationValue> asAnnotationValues(AnnotationValue annotationValue) {
- return annotationValue.accept(AS_ANNOTATION_VALUES, null);
- }
-
- private static final AnnotationValueVisitor<ImmutableList<AnnotationValue>, String>
- AS_ANNOTATION_VALUES =
- new SimpleAnnotationValueVisitor8<ImmutableList<AnnotationValue>, String>() {
- @Override
- public ImmutableList<AnnotationValue> visitArray(
- List<? extends AnnotationValue> vals, String elementName) {
- return ImmutableList.copyOf(vals);
- }
-
- @Override
- protected ImmutableList<AnnotationValue> defaultAction(Object o, String elementName) {
- throw new IllegalArgumentException(elementName + " is not an array: " + o);
- }
- };
-
- /**
- * Returns the type represented by an annotation value.
- *
- * @throws IllegalArgumentException unless {@code annotationValue} represents a single type
- */
- static TypeMirror asType(AnnotationValue annotationValue) {
- return AS_TYPE.visit(annotationValue);
- }
-
- private static final AnnotationValueVisitor<TypeMirror, Void> AS_TYPE =
- new SimpleAnnotationValueVisitor8<TypeMirror, Void>() {
- @Override
- public TypeMirror visitType(TypeMirror t, Void p) {
- return t;
- }
-
- @Override
- protected TypeMirror defaultAction(Object o, Void p) {
- throw new TypeNotPresentException(o.toString(), null);
- }
- };
-
- private MoreAnnotationValues() {}
-}
diff --git a/java/dagger/internal/codegen/MultibindingAnnotations.java b/java/dagger/internal/codegen/MultibindingAnnotations.java
deleted file mode 100644
index b478704..0000000
--- a/java/dagger/internal/codegen/MultibindingAnnotations.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.langmodel.DaggerElements.getAllAnnotations;
-
-import com.google.common.collect.ImmutableSet;
-import dagger.multibindings.ElementsIntoSet;
-import dagger.multibindings.IntoMap;
-import dagger.multibindings.IntoSet;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.Element;
-
-/**
- * Utility methods related to processing {@link IntoSet}, {@link ElementsIntoSet}, and {@link
- * IntoMap}.
- */
-final class MultibindingAnnotations {
- static ImmutableSet<AnnotationMirror> forElement(Element method) {
- return getAllAnnotations(method, IntoSet.class, ElementsIntoSet.class, IntoMap.class);
- }
-}
diff --git a/java/dagger/internal/codegen/MultibindingAnnotationsProcessingStep.java b/java/dagger/internal/codegen/MultibindingAnnotationsProcessingStep.java
deleted file mode 100644
index 2bb0a7e..0000000
--- a/java/dagger/internal/codegen/MultibindingAnnotationsProcessingStep.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.langmodel.DaggerElements.getAnnotationMirror;
-import static javax.tools.Diagnostic.Kind.ERROR;
-
-import com.google.auto.common.MoreElements;
-import com.google.common.collect.ImmutableSet;
-import dagger.multibindings.ElementsIntoSet;
-import dagger.multibindings.IntoMap;
-import dagger.multibindings.IntoSet;
-import java.lang.annotation.Annotation;
-import java.util.Set;
-import javax.annotation.processing.Messager;
-import javax.inject.Inject;
-import javax.lang.model.element.ExecutableElement;
-
-/**
- * Processing step that verifies that {@link IntoSet}, {@link ElementsIntoSet} and {@link IntoMap}
- * are not present on non-binding methods.
- */
-final class MultibindingAnnotationsProcessingStep
- extends TypeCheckingProcessingStep<ExecutableElement> {
- private final AnyBindingMethodValidator anyBindingMethodValidator;
- private final Messager messager;
-
- @Inject
- MultibindingAnnotationsProcessingStep(
- AnyBindingMethodValidator anyBindingMethodValidator, Messager messager) {
- super(MoreElements::asExecutable);
- this.anyBindingMethodValidator = anyBindingMethodValidator;
- this.messager = messager;
- }
-
- @Override
- public Set<? extends Class<? extends Annotation>> annotations() {
- return ImmutableSet.of(IntoSet.class, ElementsIntoSet.class, IntoMap.class);
- }
-
- @Override
- protected void process(
- ExecutableElement method, ImmutableSet<Class<? extends Annotation>> annotations) {
- if (!anyBindingMethodValidator.isBindingMethod(method)) {
- annotations.forEach(
- annotation ->
- messager.printMessage(
- ERROR,
- "Multibinding annotations may only be on @Provides, @Produces, or @Binds methods",
- method,
- getAnnotationMirror(method, annotation).get()));
- }
- }
-}
diff --git a/java/dagger/internal/codegen/MultibindingDeclaration.java b/java/dagger/internal/codegen/MultibindingDeclaration.java
deleted file mode 100644
index c3724dc..0000000
--- a/java/dagger/internal/codegen/MultibindingDeclaration.java
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreElements.isAnnotationPresent;
-import static com.google.common.base.Preconditions.checkArgument;
-
-import com.google.auto.common.MoreTypes;
-import com.google.auto.value.AutoValue;
-import com.google.auto.value.extension.memoized.Memoized;
-import dagger.internal.codegen.ContributionType.HasContributionType;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.Key;
-import dagger.multibindings.Multibinds;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
-import javax.inject.Inject;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.ExecutableType;
-import javax.lang.model.type.TypeMirror;
-
-/**
- * A declaration that a multibinding with a certain key is available to be injected in a component
- * even if the component has no multibindings for that key. Identified by a map- or set-returning
- * method annotated with {@link Multibinds @Multibinds}.
- */
-@AutoValue
-abstract class MultibindingDeclaration extends BindingDeclaration implements HasContributionType {
-
- /**
- * The map or set key whose availability is declared. For maps, this will be {@code Map<K,
- * Provider<V>>}. For sets, this will be {@code Set<T>}.
- */
- @Override
- public abstract Key key();
-
- /**
- * {@link ContributionType#SET} if the declared type is a {@link Set}, or
- * {@link ContributionType#MAP} if it is a {@link Map}.
- */
- @Override
- public abstract ContributionType contributionType();
-
- @Memoized
- @Override
- public abstract int hashCode();
-
- @Override
- public abstract boolean equals(Object obj);
-
- /**
- * A factory for {@link MultibindingDeclaration}s.
- */
- static final class Factory {
- private final DaggerTypes types;
- private final KeyFactory keyFactory;
-
- @Inject
- Factory(DaggerTypes types, KeyFactory keyFactory) {
- this.types = types;
- this.keyFactory = keyFactory;
- }
-
- /** A multibinding declaration for a {@link Multibinds @Multibinds} method. */
- MultibindingDeclaration forMultibindsMethod(
- ExecutableElement moduleMethod, TypeElement moduleElement) {
- checkArgument(isAnnotationPresent(moduleMethod, Multibinds.class));
- return forDeclaredMethod(
- moduleMethod,
- MoreTypes.asExecutable(
- types.asMemberOf(MoreTypes.asDeclared(moduleElement.asType()), moduleMethod)),
- moduleElement);
- }
-
- private MultibindingDeclaration forDeclaredMethod(
- ExecutableElement method,
- ExecutableType methodType,
- TypeElement contributingType) {
- TypeMirror returnType = methodType.getReturnType();
- checkArgument(
- SetType.isSet(returnType) || MapType.isMap(returnType),
- "%s must return a set or map",
- method);
- return new AutoValue_MultibindingDeclaration(
- Optional.<Element>of(method),
- Optional.of(contributingType),
- keyFactory.forMultibindsMethod(methodType, method),
- contributionType(returnType));
- }
-
- private ContributionType contributionType(TypeMirror returnType) {
- if (MapType.isMap(returnType)) {
- return ContributionType.MAP;
- } else if (SetType.isSet(returnType)) {
- return ContributionType.SET;
- } else {
- throw new IllegalArgumentException("Must be Map or Set: " + returnType);
- }
- }
- }
-}
diff --git a/java/dagger/internal/codegen/MultibindingExpression.java b/java/dagger/internal/codegen/MultibindingExpression.java
deleted file mode 100644
index f0523eb..0000000
--- a/java/dagger/internal/codegen/MultibindingExpression.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Sets;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import dagger.internal.codegen.ModifiableBindingMethods.ModifiableBindingMethod;
-import dagger.internal.codegen.javapoet.Expression;
-import dagger.model.DependencyRequest;
-import dagger.model.Key;
-import dagger.model.RequestKind;
-import java.util.Optional;
-import java.util.Set;
-
-/** An abstract base class for multibinding {@link BindingExpression}s. */
-abstract class MultibindingExpression extends SimpleInvocationBindingExpression {
- private final ProvisionBinding binding;
- private final ComponentImplementation componentImplementation;
-
- MultibindingExpression(
- ResolvedBindings resolvedBindings, ComponentImplementation componentImplementation) {
- super(resolvedBindings);
- this.componentImplementation = componentImplementation;
- this.binding = (ProvisionBinding) resolvedBindings.contributionBinding();
- }
-
- @Override
- Expression getDependencyExpression(ClassName requestingClass) {
- Expression expression = buildDependencyExpression(requestingClass);
- componentImplementation.registerImplementedMultibinding(binding, bindingRequest());
- return expression;
- }
-
- /**
- * Returns an expression that evaluates to the value of a multibinding request for the given
- * requesting class.
- */
- protected abstract Expression buildDependencyExpression(ClassName requestingClass);
-
- /**
- * Returns the subset of {@code dependencies} that represent multibinding contributions that were
- * not included in a superclass implementation of this multibinding method. This is relevant only
- * for ahead-of-time subcomponents. When not generating ahead-of-time subcomponents there is only
- * one implementation of a multibinding expression and all {@link DependencyRequest}s from the
- * argment are returned.
- */
- protected Set<DependencyRequest> getNewContributions(
- ImmutableSet<DependencyRequest> dependencies) {
- ImmutableSet<Key> superclassContributions = superclassContributions();
- return Sets.filter(
- dependencies, dependency -> !superclassContributions.contains(dependency.key()));
- }
-
- /**
- * Returns the {@link CodeBlock} representing a call to a superclass implementation of the
- * modifiable binding method that encapsulates this binding, if it exists. This is only possible
- * when generating ahead-of-time subcomponents.
- */
- protected Optional<CodeBlock> superMethodCall() {
- if (componentImplementation.superclassImplementation().isPresent()) {
- Optional<ModifiableBindingMethod> method =
- componentImplementation.getModifiableBindingMethod(bindingRequest());
- if (method.isPresent()) {
- if (!superclassContributions().isEmpty()) {
- return Optional.of(CodeBlock.of("super.$L()", method.get().methodSpec().name));
- }
- }
- }
- return Optional.empty();
- }
-
- private BindingRequest bindingRequest() {
- return BindingRequest.bindingRequest(binding.key(), RequestKind.INSTANCE);
- }
-
- private ImmutableSet<Key> superclassContributions() {
- return componentImplementation.superclassContributionsMade(bindingRequest());
- }
-}
diff --git a/java/dagger/internal/codegen/MultibindingFactoryCreationExpression.java b/java/dagger/internal/codegen/MultibindingFactoryCreationExpression.java
deleted file mode 100644
index abe161a..0000000
--- a/java/dagger/internal/codegen/MultibindingFactoryCreationExpression.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-
-import com.google.common.collect.ImmutableSet;
-import com.squareup.javapoet.CodeBlock;
-import dagger.internal.codegen.FrameworkFieldInitializer.FrameworkInstanceCreationExpression;
-import dagger.internal.codegen.ModifiableBindingMethods.ModifiableBindingMethod;
-import dagger.internal.codegen.javapoet.CodeBlocks;
-import dagger.model.DependencyRequest;
-import dagger.model.Key;
-import java.util.Optional;
-
-/** An abstract factory creation expression for multibindings. */
-abstract class MultibindingFactoryCreationExpression
- implements FrameworkInstanceCreationExpression {
- private final ComponentImplementation componentImplementation;
- private final ComponentBindingExpressions componentBindingExpressions;
- private final ContributionBinding binding;
-
- MultibindingFactoryCreationExpression(
- ContributionBinding binding,
- ComponentImplementation componentImplementation,
- ComponentBindingExpressions componentBindingExpressions) {
- this.binding = checkNotNull(binding);
- this.componentImplementation = checkNotNull(componentImplementation);
- this.componentBindingExpressions = checkNotNull(componentBindingExpressions);
- }
-
- /** Returns the expression for a dependency of this multibinding. */
- protected final CodeBlock multibindingDependencyExpression(DependencyRequest dependency) {
- CodeBlock expression =
- componentBindingExpressions
- .getDependencyExpression(
- BindingRequest.bindingRequest(dependency.key(), binding.frameworkType()),
- componentImplementation.name())
- .codeBlock();
-
- return useRawType()
- ? CodeBlocks.cast(expression, binding.frameworkType().frameworkClass())
- : expression;
- }
-
- protected final ImmutableSet<DependencyRequest> dependenciesToImplement() {
- ImmutableSet<Key> alreadyImplementedKeys =
- componentImplementation.superclassContributionsMade(bindingRequest());
- return binding.dependencies().stream()
- .filter(dependency -> !alreadyImplementedKeys.contains(dependency.key()))
- .collect(toImmutableSet());
- }
-
- protected Optional<CodeBlock> superContributions() {
- if (dependenciesToImplement().size() == binding.dependencies().size()) {
- return Optional.empty();
- }
- ModifiableBindingMethod superMethod =
- componentImplementation.getModifiableBindingMethod(bindingRequest()).get();
- return Optional.of(CodeBlock.of("super.$N()", superMethod.methodSpec().name));
- }
-
- /** The binding request for this framework instance. */
- protected final BindingRequest bindingRequest() {
- return BindingRequest.bindingRequest(binding.key(), binding.frameworkType());
- }
-
- /**
- * Returns true if the {@linkplain ContributionBinding#key() key type} is inaccessible from the
- * component, and therefore a raw type must be used.
- */
- protected final boolean useRawType() {
- return !componentImplementation.isTypeAccessible(binding.key().type());
- }
-
- @Override
- public final boolean useInnerSwitchingProvider() {
- return !binding.dependencies().isEmpty();
- }
-}
diff --git a/java/dagger/internal/codegen/MultibindsMethodValidator.java b/java/dagger/internal/codegen/MultibindsMethodValidator.java
deleted file mode 100644
index bc97d30..0000000
--- a/java/dagger/internal/codegen/MultibindsMethodValidator.java
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.BindingElementValidator.AllowsMultibindings.NO_MULTIBINDINGS;
-import static dagger.internal.codegen.BindingElementValidator.AllowsScoping.NO_SCOPING;
-import static dagger.internal.codegen.BindingMethodValidator.Abstractness.MUST_BE_ABSTRACT;
-import static dagger.internal.codegen.BindingMethodValidator.ExceptionSuperclass.NO_EXCEPTIONS;
-import static dagger.internal.codegen.FrameworkTypes.isFrameworkType;
-
-import com.google.auto.common.MoreTypes;
-import com.google.common.collect.ImmutableSet;
-import dagger.Module;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.multibindings.Multibinds;
-import dagger.producers.ProducerModule;
-import javax.inject.Inject;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.type.TypeMirror;
-
-/** A validator for {@link Multibinds} methods. */
-class MultibindsMethodValidator extends BindingMethodValidator {
-
- /** Creates a validator for {@link Multibinds @Multibinds} methods. */
- @Inject
- MultibindsMethodValidator(
- DaggerElements elements,
- DaggerTypes types,
- DependencyRequestValidator dependencyRequestValidator) {
- super(
- elements,
- types,
- Multibinds.class,
- ImmutableSet.of(Module.class, ProducerModule.class),
- dependencyRequestValidator,
- MUST_BE_ABSTRACT,
- NO_EXCEPTIONS,
- NO_MULTIBINDINGS,
- NO_SCOPING);
- }
-
- @Override
- protected ElementValidator elementValidator(ExecutableElement element) {
- return new Validator(element);
- }
-
- private class Validator extends MethodValidator {
- Validator(ExecutableElement element) {
- super(element);
- }
-
- @Override
- protected void checkParameters() {
- if (!element.getParameters().isEmpty()) {
- report.addError(bindingMethods("cannot have parameters"));
- }
- }
-
- /** Adds an error unless the method returns a {@code Map<K, V>} or {@code Set<T>}. */
- @Override
- protected void checkType() {
- if (!isPlainMap(element.getReturnType())
- && !isPlainSet(element.getReturnType())) {
- report.addError(bindingMethods("must return Map<K, V> or Set<T>"));
- }
- }
-
- private boolean isPlainMap(TypeMirror returnType) {
- if (!MapType.isMap(returnType)) {
- return false;
- }
- MapType mapType = MapType.from(returnType);
- return !mapType.isRawType()
- && MoreTypes.isType(mapType.valueType()) // No wildcards.
- && !isFrameworkType(mapType.valueType());
- }
-
- private boolean isPlainSet(TypeMirror returnType) {
- if (!SetType.isSet(returnType)) {
- return false;
- }
- SetType setType = SetType.from(returnType);
- return !setType.isRawType()
- && MoreTypes.isType(setType.elementType()) // No wildcards.
- && !isFrameworkType(setType.elementType());
- }
- }
-}
diff --git a/java/dagger/internal/codegen/NullableBindingValidator.java b/java/dagger/internal/codegen/NullableBindingValidator.java
deleted file mode 100644
index 1452c3f..0000000
--- a/java/dagger/internal/codegen/NullableBindingValidator.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.DaggerStreams.instancesOf;
-import static dagger.internal.codegen.DaggerStreams.toImmutableList;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-import dagger.model.BindingGraph;
-import dagger.model.BindingGraph.DependencyEdge;
-import dagger.spi.BindingGraphPlugin;
-import dagger.spi.DiagnosticReporter;
-import javax.inject.Inject;
-
-/**
- * Reports errors or warnings (depending on the {@code -Adagger.nullableValidation} value) for each
- * non-nullable dependency request that is satisfied by a nullable binding.
- */
-final class NullableBindingValidator implements BindingGraphPlugin {
-
- private final CompilerOptions compilerOptions;
-
- @Inject
- NullableBindingValidator(CompilerOptions compilerOptions) {
- this.compilerOptions = compilerOptions;
- }
-
- @Override
- public void visitGraph(BindingGraph bindingGraph, DiagnosticReporter diagnosticReporter) {
- for (dagger.model.Binding binding : nullableBindings(bindingGraph)) {
- for (DependencyEdge dependencyEdge : nonNullableDependencies(bindingGraph, binding)) {
- diagnosticReporter.reportDependency(
- compilerOptions.nullableValidationKind(),
- dependencyEdge,
- nullableToNonNullable(
- binding.key().toString(),
- binding.toString())); // binding.toString() will include the @Nullable
- }
- }
- }
-
- @Override
- public String pluginName() {
- return "Dagger/Nullable";
- }
-
- private ImmutableList<dagger.model.Binding> nullableBindings(BindingGraph bindingGraph) {
- return bindingGraph.bindings().stream()
- .filter(binding -> binding.isNullable())
- .collect(toImmutableList());
- }
-
- private ImmutableSet<DependencyEdge> nonNullableDependencies(
- BindingGraph bindingGraph, dagger.model.Binding binding) {
- return bindingGraph.network().inEdges(binding).stream()
- .flatMap(instancesOf(DependencyEdge.class))
- .filter(edge -> !edge.dependencyRequest().isNullable())
- .collect(toImmutableSet());
- }
-
- @VisibleForTesting
- static String nullableToNonNullable(String key, String binding) {
- return String.format("%s is not nullable, but is being provided by %s", key, binding);
- }
-}
diff --git a/java/dagger/internal/codegen/OptionalBindingDeclaration.java b/java/dagger/internal/codegen/OptionalBindingDeclaration.java
deleted file mode 100644
index b26ab91..0000000
--- a/java/dagger/internal/codegen/OptionalBindingDeclaration.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreElements.isAnnotationPresent;
-import static com.google.common.base.Preconditions.checkArgument;
-
-import com.google.auto.value.AutoValue;
-import com.google.auto.value.extension.memoized.Memoized;
-import dagger.BindsOptionalOf;
-import dagger.model.Key;
-import java.util.Optional;
-import javax.inject.Inject;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-
-/** A {@link BindsOptionalOf} declaration. */
-@AutoValue
-abstract class OptionalBindingDeclaration extends BindingDeclaration {
-
- /**
- * {@inheritDoc}
- *
- * <p>The key's type is the method's return type, even though the synthetic bindings will be for
- * {@code Optional} of derived types.
- */
- @Override
- public abstract Key key();
-
- @Memoized
- @Override
- public abstract int hashCode();
-
- @Override
- public abstract boolean equals(Object obj);
-
- static class Factory {
- private final KeyFactory keyFactory;
-
- @Inject
- Factory(KeyFactory keyFactory) {
- this.keyFactory = keyFactory;
- }
-
- OptionalBindingDeclaration forMethod(ExecutableElement method, TypeElement contributingModule) {
- checkArgument(isAnnotationPresent(method, BindsOptionalOf.class));
- return new AutoValue_OptionalBindingDeclaration(
- Optional.<Element>of(method),
- Optional.of(contributingModule),
- keyFactory.forBindsOptionalOfMethod(method, contributingModule));
- }
- }
-}
diff --git a/java/dagger/internal/codegen/OptionalBindingExpression.java b/java/dagger/internal/codegen/OptionalBindingExpression.java
deleted file mode 100644
index dbb0e37..0000000
--- a/java/dagger/internal/codegen/OptionalBindingExpression.java
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static dagger.internal.codegen.BindingRequest.bindingRequest;
-import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
-
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import dagger.internal.codegen.OptionalType.OptionalKind;
-import dagger.internal.codegen.javapoet.Expression;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.DependencyRequest;
-import javax.inject.Inject;
-import javax.lang.model.SourceVersion;
-
-/** A binding expression for optional bindings. */
-final class OptionalBindingExpression extends SimpleInvocationBindingExpression {
- private final ProvisionBinding binding;
- private final ComponentBindingExpressions componentBindingExpressions;
- private final DaggerTypes types;
- private final SourceVersion sourceVersion;
-
- @Inject
- OptionalBindingExpression(
- ResolvedBindings resolvedBindings,
- ComponentBindingExpressions componentBindingExpressions,
- DaggerTypes types,
- SourceVersion sourceVersion) {
- super(resolvedBindings);
- this.binding = (ProvisionBinding) resolvedBindings.contributionBinding();
- this.componentBindingExpressions = componentBindingExpressions;
- this.types = types;
- this.sourceVersion = sourceVersion;
- }
-
- @Override
- Expression getDependencyExpression(ClassName requestingClass) {
- OptionalType optionalType = OptionalType.from(binding.key());
- OptionalKind optionalKind = optionalType.kind();
- if (binding.dependencies().isEmpty()) {
- if (sourceVersion.compareTo(SourceVersion.RELEASE_7) <= 0) {
- // When compiling with -source 7, javac's type inference isn't strong enough to detect
- // Futures.immediateFuture(Optional.absent()) for keys that aren't Object. It also has
- // issues
- // when used as an argument to some members injection proxy methods (see
- // https://github.com/google/dagger/issues/916)
- if (isTypeAccessibleFrom(binding.key().type(), requestingClass.packageName())) {
- return Expression.create(
- binding.key().type(), optionalKind.parameterizedAbsentValueExpression(optionalType));
- }
- }
- return Expression.create(binding.key().type(), optionalKind.absentValueExpression());
- }
- DependencyRequest dependency = getOnlyElement(binding.dependencies());
-
- CodeBlock dependencyExpression =
- componentBindingExpressions
- .getDependencyExpression(bindingRequest(dependency), requestingClass)
- .codeBlock();
-
- // If the dependency type is inaccessible, then we have to use Optional.<Object>of(...), or else
- // we will get "incompatible types: inference variable has incompatible bounds.
- return isTypeAccessibleFrom(dependency.key().type(), requestingClass.packageName())
- ? Expression.create(
- binding.key().type(), optionalKind.presentExpression(dependencyExpression))
- : Expression.create(
- types.erasure(binding.key().type()),
- optionalKind.presentObjectExpression(dependencyExpression));
- }
-
- @Override
- boolean requiresMethodEncapsulation() {
- // TODO(dpb): Maybe require it for present bindings.
- return false;
- }
-}
diff --git a/java/dagger/internal/codegen/OptionalFactories.java b/java/dagger/internal/codegen/OptionalFactories.java
deleted file mode 100644
index 51c9939..0000000
--- a/java/dagger/internal/codegen/OptionalFactories.java
+++ /dev/null
@@ -1,439 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.CaseFormat.UPPER_CAMEL;
-import static com.google.common.base.CaseFormat.UPPER_UNDERSCORE;
-import static com.google.common.base.Verify.verify;
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static com.squareup.javapoet.MethodSpec.constructorBuilder;
-import static com.squareup.javapoet.MethodSpec.methodBuilder;
-import static com.squareup.javapoet.TypeSpec.anonymousClassBuilder;
-import static com.squareup.javapoet.TypeSpec.classBuilder;
-import static dagger.internal.codegen.ComponentImplementation.FieldSpecKind.ABSENT_OPTIONAL_FIELD;
-import static dagger.internal.codegen.ComponentImplementation.MethodSpecKind.ABSENT_OPTIONAL_METHOD;
-import static dagger.internal.codegen.ComponentImplementation.TypeSpecKind.PRESENT_FACTORY;
-import static dagger.internal.codegen.RequestKinds.requestTypeName;
-import static dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression.RAWTYPES;
-import static dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression.UNCHECKED;
-import static dagger.internal.codegen.javapoet.TypeNames.PROVIDER;
-import static dagger.internal.codegen.javapoet.TypeNames.abstractProducerOf;
-import static dagger.internal.codegen.javapoet.TypeNames.listenableFutureOf;
-import static dagger.internal.codegen.javapoet.TypeNames.providerOf;
-import static javax.lang.model.element.Modifier.FINAL;
-import static javax.lang.model.element.Modifier.PRIVATE;
-import static javax.lang.model.element.Modifier.PUBLIC;
-import static javax.lang.model.element.Modifier.STATIC;
-
-import com.google.auto.value.AutoValue;
-import com.google.common.base.Function;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
-import com.google.common.util.concurrent.MoreExecutors;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.FieldSpec;
-import com.squareup.javapoet.MethodSpec;
-import com.squareup.javapoet.ParameterSpec;
-import com.squareup.javapoet.ParameterizedTypeName;
-import com.squareup.javapoet.TypeName;
-import com.squareup.javapoet.TypeSpec;
-import com.squareup.javapoet.TypeVariableName;
-import dagger.internal.InstanceFactory;
-import dagger.internal.Preconditions;
-import dagger.internal.codegen.OptionalType.OptionalKind;
-import dagger.internal.codegen.javapoet.AnnotationSpecs;
-import dagger.model.RequestKind;
-import dagger.producers.Producer;
-import dagger.producers.internal.Producers;
-import java.util.Comparator;
-import java.util.Map;
-import java.util.Optional;
-import java.util.TreeMap;
-import java.util.concurrent.Executor;
-import javax.inject.Inject;
-import javax.inject.Provider;
-
-/** The nested class and static methods required by the component to implement optional bindings. */
-// TODO(dpb): Name members simply if a component uses only one of Guava or JDK Optional.
-@PerGeneratedFile
-final class OptionalFactories {
- private final ComponentImplementation componentImplementation;
-
- @Inject OptionalFactories(@TopLevel ComponentImplementation componentImplementation) {
- this.componentImplementation = componentImplementation;
- }
-
- /**
- * The factory classes that implement {@code Provider<Optional<T>>} or {@code
- * Producer<Optional<T>>} for present optional bindings for a given kind of dependency request
- * within the component.
- *
- * <p>The key is the {@code Provider<Optional<T>>} type.
- */
- private final Map<PresentFactorySpec, TypeSpec> presentFactoryClasses =
- new TreeMap<>(
- Comparator.comparing(PresentFactorySpec::valueKind)
- .thenComparing(PresentFactorySpec::frameworkType)
- .thenComparing(PresentFactorySpec::optionalKind));
-
- /**
- * The static methods that return a {@code Provider<Optional<T>>} that always returns an absent
- * value.
- */
- private final Map<OptionalKind, MethodSpec> absentOptionalProviderMethods = new TreeMap<>();
-
- /**
- * The static fields for {@code Provider<Optional<T>>} objects that always return an absent value.
- */
- private final Map<OptionalKind, FieldSpec> absentOptionalProviderFields = new TreeMap<>();
-
- /**
- * Returns an expression that calls a static method that returns a {@code Provider<Optional<T>>}
- * for absent optional bindings.
- */
- CodeBlock absentOptionalProvider(ContributionBinding binding) {
- verify(
- binding.bindingType().equals(BindingType.PROVISION),
- "Absent optional bindings should be provisions: %s",
- binding);
- OptionalKind optionalKind = OptionalType.from(binding.key()).kind();
- return CodeBlock.of(
- "$N()",
- absentOptionalProviderMethods.computeIfAbsent(
- optionalKind,
- kind -> {
- MethodSpec method = absentOptionalProviderMethod(kind);
- componentImplementation.addMethod(ABSENT_OPTIONAL_METHOD, method);
- return method;
- }));
- }
-
- /**
- * Creates a method specification for a {@code Provider<Optional<T>>} that always returns an
- * absent value.
- */
- private MethodSpec absentOptionalProviderMethod(OptionalKind optionalKind) {
- TypeVariableName typeVariable = TypeVariableName.get("T");
- return methodBuilder(
- String.format(
- "absent%sProvider", UPPER_UNDERSCORE.to(UPPER_CAMEL, optionalKind.name())))
- .addModifiers(PRIVATE, STATIC)
- .addTypeVariable(typeVariable)
- .returns(providerOf(optionalKind.of(typeVariable)))
- .addJavadoc(
- "Returns a {@link $T} that returns {@code $L}.",
- Provider.class,
- optionalKind.absentValueExpression())
- .addCode("$L // safe covariant cast\n", AnnotationSpecs.suppressWarnings(UNCHECKED))
- .addCode(
- "$1T provider = ($1T) $2N;",
- providerOf(optionalKind.of(typeVariable)),
- absentOptionalProviderFields.computeIfAbsent(
- optionalKind,
- kind -> {
- FieldSpec field = absentOptionalProviderField(kind);
- componentImplementation.addField(ABSENT_OPTIONAL_FIELD, field);
- return field;
- }))
- .addCode("return provider;")
- .build();
- }
-
- /**
- * Creates a field specification for a {@code Provider<Optional<T>>} that always returns an absent
- * value.
- */
- private FieldSpec absentOptionalProviderField(OptionalKind optionalKind) {
- return FieldSpec.builder(
- PROVIDER,
- String.format("ABSENT_%s_PROVIDER", optionalKind.name()),
- PRIVATE,
- STATIC,
- FINAL)
- .addAnnotation(AnnotationSpecs.suppressWarnings(RAWTYPES))
- .initializer("$T.create($L)", InstanceFactory.class, optionalKind.absentValueExpression())
- .addJavadoc(
- "A {@link $T} that returns {@code $L}.",
- Provider.class,
- optionalKind.absentValueExpression())
- .build();
- }
-
- /** Information about the type of a factory for present bindings. */
- @AutoValue
- abstract static class PresentFactorySpec {
- /** Whether the factory is a {@link Provider} or a {@link Producer}. */
- abstract FrameworkType frameworkType();
-
- /** What kind of {@code Optional} is returned. */
- abstract OptionalKind optionalKind();
-
- /** The kind of request satisfied by the value of the {@code Optional}. */
- abstract RequestKind valueKind();
-
- /** The type variable for the factory class. */
- TypeVariableName typeVariable() {
- return TypeVariableName.get("T");
- }
-
- /** The type contained by the {@code Optional}. */
- TypeName valueType() {
- return requestTypeName(valueKind(), typeVariable());
- }
-
- /** The type provided or produced by the factory. */
- ParameterizedTypeName optionalType() {
- return optionalKind().of(valueType());
- }
-
- /** The type of the factory. */
- ParameterizedTypeName factoryType() {
- return frameworkType().frameworkClassOf(optionalType());
- }
-
- /** The type of the delegate provider or producer. */
- ParameterizedTypeName delegateType() {
- return frameworkType().frameworkClassOf(typeVariable());
- }
-
- /** Returns the superclass the generated factory should have, if any. */
- Optional<ParameterizedTypeName> superclass() {
- switch (frameworkType()) {
- case PRODUCER_NODE:
- // TODO(cgdecker): This probably isn't a big issue for now, but it's possible this
- // shouldn't be an AbstractProducer:
- // - As AbstractProducer, it'll only call the delegate's get() method once and then cache
- // that result (essentially) rather than calling the delegate's get() method each time
- // its get() method is called (which was what it did before the cancellation change).
- // - It's not 100% clear to me whether the view-creation methods should return a view of
- // the same view created by the delegate or if they should just return their own views.
- return Optional.of(abstractProducerOf(optionalType()));
- default:
- return Optional.empty();
- }
- }
-
- /** Returns the superinterface the generated factory should have, if any. */
- Optional<ParameterizedTypeName> superinterface() {
- switch (frameworkType()) {
- case PROVIDER:
- return Optional.of(factoryType());
- default:
- return Optional.empty();
- }
- }
-
- /** Returns the name of the factory method to generate. */
- String factoryMethodName() {
- switch (frameworkType()) {
- case PROVIDER:
- return "get";
- case PRODUCER_NODE:
- return "compute";
- }
- throw new AssertionError(frameworkType());
- }
-
- /** The name of the factory class. */
- String factoryClassName() {
- return new StringBuilder("Present")
- .append(UPPER_UNDERSCORE.to(UPPER_CAMEL, optionalKind().name()))
- .append(UPPER_UNDERSCORE.to(UPPER_CAMEL, valueKind().toString()))
- .append(frameworkType().frameworkClass().getSimpleName())
- .toString();
- }
-
- private static PresentFactorySpec of(ContributionBinding binding) {
- return new AutoValue_OptionalFactories_PresentFactorySpec(
- FrameworkType.forBindingType(binding.bindingType()),
- OptionalType.from(binding.key()).kind(),
- getOnlyElement(binding.dependencies()).kind());
- }
- }
-
- /**
- * Returns an expression for an instance of a nested class that implements {@code
- * Provider<Optional<T>>} or {@code Producer<Optional<T>>} for a present optional binding, where
- * {@code T} represents dependency requests of that kind.
- *
- * <ul>
- * <li>If {@code optionalRequestKind} is {@link RequestKind#INSTANCE}, the class implements
- * {@code ProviderOrProducer<Optional<T>>}.
- * <li>If {@code optionalRequestKind} is {@link RequestKind#PROVIDER}, the class implements
- * {@code Provider<Optional<Provider<T>>>}.
- * <li>If {@code optionalRequestKind} is {@link RequestKind#LAZY}, the class implements {@code
- * Provider<Optional<Lazy<T>>>}.
- * <li>If {@code optionalRequestKind} is {@link RequestKind#PROVIDER_OF_LAZY}, the class
- * implements {@code Provider<Optional<Provider<Lazy<T>>>>}.
- * <li>If {@code optionalRequestKind} is {@link RequestKind#PRODUCER}, the class implements
- * {@code Producer<Optional<Producer<T>>>}.
- * <li>If {@code optionalRequestKind} is {@link RequestKind#PRODUCED}, the class implements
- * {@code Producer<Optional<Produced<T>>>}.
- * </ul>
- *
- * @param delegateFactory an expression for a {@link Provider} or {@link Producer} of the
- * underlying type
- */
- CodeBlock presentOptionalFactory(ContributionBinding binding, CodeBlock delegateFactory) {
- return CodeBlock.of(
- "$N.of($L)",
- presentFactoryClasses.computeIfAbsent(
- PresentFactorySpec.of(binding),
- spec -> {
- TypeSpec type = presentOptionalFactoryClass(spec);
- componentImplementation.addType(PRESENT_FACTORY, type);
- return type;
- }),
- delegateFactory);
- }
-
- private TypeSpec presentOptionalFactoryClass(PresentFactorySpec spec) {
- FieldSpec delegateField =
- FieldSpec.builder(spec.delegateType(), "delegate", PRIVATE, FINAL).build();
- ParameterSpec delegateParameter = ParameterSpec.builder(delegateField.type, "delegate").build();
- TypeSpec.Builder factoryClassBuilder =
- classBuilder(spec.factoryClassName())
- .addTypeVariable(spec.typeVariable())
- .addModifiers(PRIVATE, STATIC, FINAL)
- .addJavadoc(
- "A {@code $T} that uses a delegate {@code $T}.",
- spec.factoryType(),
- delegateField.type);
-
- spec.superclass().ifPresent(factoryClassBuilder::superclass);
- spec.superinterface().ifPresent(factoryClassBuilder::addSuperinterface);
-
- return factoryClassBuilder
- .addField(delegateField)
- .addMethod(
- constructorBuilder()
- .addModifiers(PRIVATE)
- .addParameter(delegateParameter)
- .addCode(
- "this.$N = $T.checkNotNull($N);",
- delegateField,
- Preconditions.class,
- delegateParameter)
- .build())
- .addMethod(presentOptionalFactoryGetMethod(spec, delegateField))
- .addMethod(
- methodBuilder("of")
- .addModifiers(PRIVATE, STATIC)
- .addTypeVariable(spec.typeVariable())
- .returns(spec.factoryType())
- .addParameter(delegateParameter)
- .addCode(
- "return new $L<$T>($N);",
- spec.factoryClassName(),
- spec.typeVariable(),
- delegateParameter)
- .build())
- .build();
- }
-
- private MethodSpec presentOptionalFactoryGetMethod(
- PresentFactorySpec spec, FieldSpec delegateField) {
- MethodSpec.Builder getMethodBuilder =
- methodBuilder(spec.factoryMethodName()).addAnnotation(Override.class).addModifiers(PUBLIC);
-
- switch (spec.frameworkType()) {
- case PROVIDER:
- return getMethodBuilder
- .returns(spec.optionalType())
- .addCode(
- "return $L;",
- spec.optionalKind()
- .presentExpression(
- FrameworkType.PROVIDER.to(
- spec.valueKind(), CodeBlock.of("$N", delegateField))))
- .build();
-
- case PRODUCER_NODE:
- getMethodBuilder.returns(listenableFutureOf(spec.optionalType()));
-
- switch (spec.valueKind()) {
- case FUTURE: // return a ListenableFuture<Optional<ListenableFuture<T>>>
- case PRODUCER: // return a ListenableFuture<Optional<Producer<T>>>
- return getMethodBuilder
- .addCode(
- "return $T.immediateFuture($L);",
- Futures.class,
- spec.optionalKind()
- .presentExpression(
- FrameworkType.PRODUCER_NODE.to(
- spec.valueKind(), CodeBlock.of("$N", delegateField))))
- .build();
-
- case INSTANCE: // return a ListenableFuture<Optional<T>>
- return getMethodBuilder
- .addCode(
- "return $L;",
- transformFutureToOptional(
- spec.optionalKind(),
- spec.typeVariable(),
- CodeBlock.of("$N.get()", delegateField)))
- .build();
-
- case PRODUCED: // return a ListenableFuture<Optional<Produced<T>>>
- return getMethodBuilder
- .addCode(
- "return $L;",
- transformFutureToOptional(
- spec.optionalKind(),
- spec.valueType(),
- CodeBlock.of(
- "$T.createFutureProduced($N.get())", Producers.class, delegateField)))
- .build();
-
- default:
- throw new UnsupportedOperationException(
- spec.factoryType() + " objects are not supported");
- }
- }
- throw new AssertionError(spec.frameworkType());
- }
-
- /**
- * An expression that uses {@link Futures#transform(ListenableFuture, Function, Executor)} to
- * transform a {@code ListenableFuture<inputType>} into a {@code
- * ListenableFuture<Optional<inputType>>}.
- *
- * @param inputFuture an expression of type {@code ListenableFuture<inputType>}
- */
- private static CodeBlock transformFutureToOptional(
- OptionalKind optionalKind, TypeName inputType, CodeBlock inputFuture) {
- return CodeBlock.of(
- "$T.transform($L, $L, $T.directExecutor())",
- Futures.class,
- inputFuture,
- anonymousClassBuilder("")
- .addSuperinterface(
- ParameterizedTypeName.get(
- ClassName.get(Function.class), inputType, optionalKind.of(inputType)))
- .addMethod(
- methodBuilder("apply")
- .addAnnotation(Override.class)
- .addModifiers(PUBLIC)
- .returns(optionalKind.of(inputType))
- .addParameter(inputType, "input")
- .addCode("return $L;", optionalKind.presentExpression(CodeBlock.of("input")))
- .build())
- .build(),
- MoreExecutors.class);
- }
-}
diff --git a/java/dagger/internal/codegen/OptionalFactoryInstanceCreationExpression.java b/java/dagger/internal/codegen/OptionalFactoryInstanceCreationExpression.java
deleted file mode 100644
index ba9e25f..0000000
--- a/java/dagger/internal/codegen/OptionalFactoryInstanceCreationExpression.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static dagger.internal.codegen.BindingRequest.bindingRequest;
-
-import com.squareup.javapoet.CodeBlock;
-import dagger.internal.codegen.FrameworkFieldInitializer.FrameworkInstanceCreationExpression;
-
-/**
- * A {@link FrameworkInstanceCreationExpression} for {@link dagger.model.BindingKind#OPTIONAL
- * optional bindings}.
- */
-final class OptionalFactoryInstanceCreationExpression
- implements FrameworkInstanceCreationExpression {
- private final OptionalFactories optionalFactories;
- private final ContributionBinding binding;
- private final ComponentImplementation componentImplementation;
- private final ComponentBindingExpressions componentBindingExpressions;
-
- OptionalFactoryInstanceCreationExpression(
- OptionalFactories optionalFactories,
- ContributionBinding binding,
- ComponentImplementation componentImplementation,
- ComponentBindingExpressions componentBindingExpressions) {
- this.optionalFactories = optionalFactories;
- this.binding = binding;
- this.componentImplementation = componentImplementation;
- this.componentBindingExpressions = componentBindingExpressions;
- }
-
- @Override
- public CodeBlock creationExpression() {
- return binding.dependencies().isEmpty()
- ? optionalFactories.absentOptionalProvider(binding)
- : optionalFactories.presentOptionalFactory(
- binding,
- componentBindingExpressions
- .getDependencyExpression(
- bindingRequest(
- getOnlyElement(binding.dependencies()).key(), binding.frameworkType()),
- componentImplementation.name())
- .codeBlock());
- }
-
- @Override
- public boolean useInnerSwitchingProvider() {
- // Share providers for empty optionals from OptionalFactories so we don't have numerous
- // switch cases that all return Optional.empty().
- return !binding.dependencies().isEmpty();
- }
-}
diff --git a/java/dagger/internal/codegen/OptionalType.java b/java/dagger/internal/codegen/OptionalType.java
deleted file mode 100644
index 0fdbf68..0000000
--- a/java/dagger/internal/codegen/OptionalType.java
+++ /dev/null
@@ -1,159 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkArgument;
-
-import com.google.auto.common.MoreElements;
-import com.google.auto.common.MoreTypes;
-import com.google.auto.value.AutoValue;
-import com.google.common.base.Equivalence;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.ParameterizedTypeName;
-import com.squareup.javapoet.TypeName;
-import dagger.model.Key;
-import java.util.Optional;
-import javax.lang.model.element.Name;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.TypeMirror;
-import javax.lang.model.type.TypeVisitor;
-import javax.lang.model.util.SimpleTypeVisitor8;
-
-/**
- * Information about an {@code Optional} {@link TypeMirror}.
- *
- * <p>{@link com.google.common.base.Optional} and {@link java.util.Optional} are supported.
- */
-@AutoValue
-abstract class OptionalType {
-
- /** A variant of {@code Optional}. */
- enum OptionalKind {
- /** {@link com.google.common.base.Optional}. */
- GUAVA_OPTIONAL(com.google.common.base.Optional.class, "absent"),
-
- /** {@link java.util.Optional}. */
- JDK_OPTIONAL(java.util.Optional.class, "empty"),
- ;
-
- private final Class<?> clazz;
- private final String absentFactoryMethodName;
-
- OptionalKind(Class<?> clazz, String absentFactoryMethodName) {
- this.clazz = clazz;
- this.absentFactoryMethodName = absentFactoryMethodName;
- }
-
- /** Returns {@code valueType} wrapped in the correct class. */
- ParameterizedTypeName of(TypeName valueType) {
- return ParameterizedTypeName.get(ClassName.get(clazz), valueType);
- }
-
- /** Returns an expression for the absent/empty value. */
- CodeBlock absentValueExpression() {
- return CodeBlock.of("$T.$L()", clazz, absentFactoryMethodName);
- }
-
- /**
- * Returns an expression for the absent/empty value, parameterized with {@link #valueType()}.
- */
- CodeBlock parameterizedAbsentValueExpression(OptionalType optionalType) {
- return CodeBlock.of("$T.<$T>$L()", clazz, optionalType.valueType(), absentFactoryMethodName);
- }
-
- /** Returns an expression for the present {@code value}. */
- CodeBlock presentExpression(CodeBlock value) {
- return CodeBlock.of("$T.of($L)", clazz, value);
- }
-
- /**
- * Returns an expression for the present {@code value}, returning {@code Optional<Object>} no
- * matter what type the value is.
- */
- CodeBlock presentObjectExpression(CodeBlock value) {
- return CodeBlock.of("$T.<$T>of($L)", clazz, Object.class, value);
- }
- }
-
- private static final TypeVisitor<Optional<OptionalKind>, Void> OPTIONAL_KIND =
- new SimpleTypeVisitor8<Optional<OptionalKind>, Void>(Optional.empty()) {
- @Override
- public Optional<OptionalKind> visitDeclared(DeclaredType t, Void p) {
- for (OptionalKind optionalKind : OptionalKind.values()) {
- Name qualifiedName = MoreElements.asType(t.asElement()).getQualifiedName();
- if (qualifiedName.contentEquals(optionalKind.clazz.getCanonicalName())) {
- return Optional.of(optionalKind);
- }
- }
- return Optional.empty();
- }
- };
-
- /**
- * The optional type itself, wrapped using {@link MoreTypes#equivalence()}.
- *
- * @deprecated Use {@link #declaredOptionalType()} instead.
- */
- @Deprecated
- protected abstract Equivalence.Wrapper<DeclaredType> wrappedDeclaredOptionalType();
-
- /** The optional type itself. */
- @SuppressWarnings("deprecation")
- DeclaredType declaredOptionalType() {
- return wrappedDeclaredOptionalType().get();
- }
-
- /** Which {@code Optional} type is used. */
- OptionalKind kind() {
- return declaredOptionalType().accept(OPTIONAL_KIND, null).get();
- }
-
- /** The value type. */
- TypeMirror valueType() {
- return declaredOptionalType().getTypeArguments().get(0);
- }
-
- /** Returns {@code true} if {@code type} is an {@code Optional} type. */
- static boolean isOptional(TypeMirror type) {
- return type.accept(OPTIONAL_KIND, null).isPresent();
- }
-
- /** Returns {@code true} if {@code key.type()} is an {@code Optional} type. */
- static boolean isOptional(Key key) {
- return isOptional(key.type());
- }
-
- /**
- * Returns a {@link OptionalType} for {@code type}.
- *
- * @throws IllegalArgumentException if {@code type} is not an {@code Optional} type
- */
- static OptionalType from(TypeMirror type) {
- checkArgument(isOptional(type), "%s must be an Optional", type);
- return new AutoValue_OptionalType(MoreTypes.equivalence().wrap(MoreTypes.asDeclared(type)));
- }
-
- /**
- * Returns a {@link OptionalType} for {@code key}'s {@link Key#type() type}.
- *
- * @throws IllegalArgumentException if {@code key.type()} is not an {@code Optional} type
- */
- static OptionalType from(Key key) {
- return from(key.type());
- }
-}
diff --git a/java/dagger/internal/codegen/Optionals.java b/java/dagger/internal/codegen/Optionals.java
deleted file mode 100644
index 1021c35..0000000
--- a/java/dagger/internal/codegen/Optionals.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.collect.Lists.asList;
-
-import java.util.Comparator;
-import java.util.Optional;
-import java.util.function.Function;
-
-/** Utilities for {@link Optional}s. */
-final class Optionals {
- /**
- * A {@link Comparator} that puts empty {@link Optional}s before present ones, and compares
- * present {@link Optional}s by their values.
- */
- static <C extends Comparable<C>> Comparator<Optional<C>> optionalComparator() {
- return Comparator.comparing((Optional<C> optional) -> optional.isPresent())
- .thenComparing(Optional::get);
- }
-
- static <T> Comparator<Optional<T>> emptiesLast(Comparator<? super T> valueComparator) {
- checkNotNull(valueComparator);
- return Comparator.comparing(o -> o.orElse(null), Comparator.nullsLast(valueComparator));
- }
-
- /** Returns the first argument that is present, or empty if none are. */
- @SafeVarargs
- static <T> Optional<T> firstPresent(Optional<T> first, Optional<T> second, Optional<T>... rest) {
- return asList(first, second, rest)
- .stream()
- .filter(Optional::isPresent)
- .findFirst()
- .orElse(Optional.empty());
- }
-
- /**
- * Walks a chain of present optionals as defined by successive calls to {@code nextFunction},
- * returning the value of the final optional that is present. The first optional in the chain is
- * the result of {@code nextFunction(start)}.
- */
- static <T> T rootmostValue(T start, Function<T, Optional<T>> nextFunction) {
- T current = start;
- for (Optional<T> next = nextFunction.apply(start);
- next.isPresent();
- next = nextFunction.apply(current)) {
- current = next.get();
- }
- return current;
- }
-
- private Optionals() {}
-}
diff --git a/java/dagger/internal/codegen/ParentComponent.java b/java/dagger/internal/codegen/ParentComponent.java
deleted file mode 100644
index 2d2b583..0000000
--- a/java/dagger/internal/codegen/ParentComponent.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static java.lang.annotation.RetentionPolicy.RUNTIME;
-
-import java.lang.annotation.Retention;
-import javax.inject.Qualifier;
-
-/**
- * A {@link Qualifier} for bindings that are associated with a component implementation's
- * parent component.
- */
-@Retention(RUNTIME)
-@Qualifier
-@interface ParentComponent {}
diff --git a/java/dagger/internal/codegen/PerComponentImplementation.java b/java/dagger/internal/codegen/PerComponentImplementation.java
deleted file mode 100644
index 5d4ba18..0000000
--- a/java/dagger/internal/codegen/PerComponentImplementation.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static java.lang.annotation.RetentionPolicy.RUNTIME;
-
-import java.lang.annotation.Retention;
-import javax.inject.Scope;
-
-/** A {@link Scope} that encompasses a single component implementation. */
-@Retention(RUNTIME)
-@Scope
-@interface PerComponentImplementation {}
diff --git a/java/dagger/internal/codegen/PerGeneratedFile.java b/java/dagger/internal/codegen/PerGeneratedFile.java
deleted file mode 100644
index c30e67a..0000000
--- a/java/dagger/internal/codegen/PerGeneratedFile.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static java.lang.annotation.RetentionPolicy.RUNTIME;
-
-import java.lang.annotation.Retention;
-import javax.inject.Scope;
-
-/**
- * A {@link Scope} that encompasses a top-level component implementation and any of its inner
- * descendant component implementations in the same generated file.
- */
-@Retention(RUNTIME)
-@Scope
-@interface PerGeneratedFile {}
diff --git a/java/dagger/internal/codegen/PrivateMethodBindingExpression.java b/java/dagger/internal/codegen/PrivateMethodBindingExpression.java
deleted file mode 100644
index 482c123..0000000
--- a/java/dagger/internal/codegen/PrivateMethodBindingExpression.java
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.base.Preconditions.checkState;
-import static com.squareup.javapoet.MethodSpec.methodBuilder;
-import static dagger.internal.codegen.ComponentImplementation.MethodSpecKind.PRIVATE_METHOD;
-import static javax.lang.model.element.Modifier.PRIVATE;
-
-import com.squareup.javapoet.TypeName;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-
-/**
- * A binding expression that wraps the dependency expressions in a private, no-arg method.
- *
- * <p>Dependents of this binding expression will just call the no-arg private method.
- */
-final class PrivateMethodBindingExpression extends MethodBindingExpression {
- private final BindingRequest request;
- private final ComponentImplementation componentImplementation;
- private String methodName;
-
- PrivateMethodBindingExpression(
- BindingRequest request,
- ResolvedBindings resolvedBindings,
- MethodImplementationStrategy methodImplementationStrategy,
- BindingExpression wrappedBindingExpression,
- ComponentImplementation componentImplementation,
- DaggerTypes types) {
- super(
- request,
- resolvedBindings,
- methodImplementationStrategy,
- wrappedBindingExpression,
- componentImplementation,
- types);
- this.request = checkNotNull(request);
- this.componentImplementation = checkNotNull(componentImplementation);
- }
-
- @Override
- protected void addMethod() {
- if (methodName == null) {
- // Have to set methodName field before implementing the method in order to handle recursion.
- methodName = componentImplementation.getUniqueMethodName(request);
- // TODO(user): Fix the order that these generated methods are written to the component.
- componentImplementation.addMethod(
- PRIVATE_METHOD,
- methodBuilder(methodName)
- .addModifiers(PRIVATE)
- .returns(TypeName.get(returnType()))
- .addCode(methodBody())
- .build());
- }
- }
-
- @Override
- protected String methodName() {
- checkState(methodName != null, "addMethod() must be called before methodName()");
- return methodName;
- }
-}
diff --git a/java/dagger/internal/codegen/ProcessingEnvironmentCompilerOptions.java b/java/dagger/internal/codegen/ProcessingEnvironmentCompilerOptions.java
deleted file mode 100644
index cf2475d..0000000
--- a/java/dagger/internal/codegen/ProcessingEnvironmentCompilerOptions.java
+++ /dev/null
@@ -1,484 +0,0 @@
-/*
- * Copyright (C) 2019 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.CaseFormat.LOWER_CAMEL;
-import static com.google.common.base.CaseFormat.UPPER_UNDERSCORE;
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.collect.Sets.immutableEnumSet;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.internal.codegen.FeatureStatus.DISABLED;
-import static dagger.internal.codegen.FeatureStatus.ENABLED;
-import static dagger.internal.codegen.ProcessingEnvironmentCompilerOptions.Feature.EMIT_MODIFIABLE_METADATA_ANNOTATIONS;
-import static dagger.internal.codegen.ProcessingEnvironmentCompilerOptions.Feature.EXPERIMENTAL_AHEAD_OF_TIME_SUBCOMPONENTS;
-import static dagger.internal.codegen.ProcessingEnvironmentCompilerOptions.Feature.EXPERIMENTAL_ANDROID_MODE;
-import static dagger.internal.codegen.ProcessingEnvironmentCompilerOptions.Feature.FAST_INIT;
-import static dagger.internal.codegen.ProcessingEnvironmentCompilerOptions.Feature.FLOATING_BINDS_METHODS;
-import static dagger.internal.codegen.ProcessingEnvironmentCompilerOptions.Feature.FORCE_USE_SERIALIZED_COMPONENT_IMPLEMENTATIONS;
-import static dagger.internal.codegen.ProcessingEnvironmentCompilerOptions.Feature.FORMAT_GENERATED_SOURCE;
-import static dagger.internal.codegen.ProcessingEnvironmentCompilerOptions.Feature.IGNORE_PRIVATE_AND_STATIC_INJECTION_FOR_COMPONENT;
-import static dagger.internal.codegen.ProcessingEnvironmentCompilerOptions.Feature.WARN_IF_INJECTION_FACTORY_NOT_GENERATED_UPSTREAM;
-import static dagger.internal.codegen.ProcessingEnvironmentCompilerOptions.Feature.WRITE_PRODUCER_NAME_IN_TOKEN;
-import static dagger.internal.codegen.ProcessingEnvironmentCompilerOptions.KeyOnlyOption.HEADER_COMPILATION;
-import static dagger.internal.codegen.ProcessingEnvironmentCompilerOptions.KeyOnlyOption.USE_GRADLE_INCREMENTAL_PROCESSING;
-import static dagger.internal.codegen.ProcessingEnvironmentCompilerOptions.Validation.DISABLE_INTER_COMPONENT_SCOPE_VALIDATION;
-import static dagger.internal.codegen.ProcessingEnvironmentCompilerOptions.Validation.EXPLICIT_BINDING_CONFLICTS_WITH_INJECT;
-import static dagger.internal.codegen.ProcessingEnvironmentCompilerOptions.Validation.FULL_BINDING_GRAPH_VALIDATION;
-import static dagger.internal.codegen.ProcessingEnvironmentCompilerOptions.Validation.MODULE_HAS_DIFFERENT_SCOPES_VALIDATION;
-import static dagger.internal.codegen.ProcessingEnvironmentCompilerOptions.Validation.NULLABLE_VALIDATION;
-import static dagger.internal.codegen.ProcessingEnvironmentCompilerOptions.Validation.PRIVATE_MEMBER_VALIDATION;
-import static dagger.internal.codegen.ProcessingEnvironmentCompilerOptions.Validation.STATIC_MEMBER_VALIDATION;
-import static dagger.internal.codegen.ValidationType.ERROR;
-import static dagger.internal.codegen.ValidationType.NONE;
-import static dagger.internal.codegen.ValidationType.WARNING;
-import static java.util.stream.Collectors.joining;
-import static java.util.stream.Stream.concat;
-
-import com.google.common.base.Ascii;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import dagger.producers.Produces;
-import java.util.Arrays;
-import java.util.EnumSet;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
-import java.util.stream.Stream;
-import javax.annotation.processing.ProcessingEnvironment;
-import javax.lang.model.element.TypeElement;
-import javax.tools.Diagnostic;
-
-final class ProcessingEnvironmentCompilerOptions extends CompilerOptions {
- /** Returns a valid {@link CompilerOptions} parsed from the processing environment. */
- static CompilerOptions create(ProcessingEnvironment processingEnvironment) {
- return new ProcessingEnvironmentCompilerOptions(processingEnvironment).checkValid();
- }
-
- private final ProcessingEnvironment processingEnvironment;
- private final Map<EnumOption<?>, Object> enumOptions = new HashMap<>();
- private final Map<EnumOption<?>, ImmutableMap<String, ? extends Enum<?>>> allCommandLineOptions =
- new HashMap<>();
-
- private ProcessingEnvironmentCompilerOptions(ProcessingEnvironment processingEnvironment) {
- this.processingEnvironment = processingEnvironment;
- }
-
- @Override
- boolean usesProducers() {
- return processingEnvironment.getElementUtils().getTypeElement(Produces.class.getCanonicalName())
- != null;
- }
-
- @Override
- boolean headerCompilation() {
- return isEnabled(HEADER_COMPILATION);
- }
-
- @Override
- boolean fastInit() {
- return isEnabled(FAST_INIT);
- }
-
- @Override
- boolean formatGeneratedSource() {
- return isEnabled(FORMAT_GENERATED_SOURCE);
- }
-
- @Override
- boolean writeProducerNameInToken() {
- return isEnabled(WRITE_PRODUCER_NAME_IN_TOKEN);
- }
-
- @Override
- Diagnostic.Kind nullableValidationKind() {
- return diagnosticKind(NULLABLE_VALIDATION);
- }
-
- @Override
- Diagnostic.Kind privateMemberValidationKind() {
- return diagnosticKind(PRIVATE_MEMBER_VALIDATION);
- }
-
- @Override
- Diagnostic.Kind staticMemberValidationKind() {
- return diagnosticKind(STATIC_MEMBER_VALIDATION);
- }
-
- @Override
- boolean ignorePrivateAndStaticInjectionForComponent() {
- return isEnabled(IGNORE_PRIVATE_AND_STATIC_INJECTION_FOR_COMPONENT);
- }
-
- @Override
- ValidationType scopeCycleValidationType() {
- return parseOption(DISABLE_INTER_COMPONENT_SCOPE_VALIDATION);
- }
-
- @Override
- boolean warnIfInjectionFactoryNotGeneratedUpstream() {
- return isEnabled(WARN_IF_INJECTION_FACTORY_NOT_GENERATED_UPSTREAM);
- }
-
- @Override
- boolean aheadOfTimeSubcomponents() {
- return isEnabled(EXPERIMENTAL_AHEAD_OF_TIME_SUBCOMPONENTS);
- }
-
- @Override
- boolean forceUseSerializedComponentImplementations() {
- return isEnabled(FORCE_USE_SERIALIZED_COMPONENT_IMPLEMENTATIONS);
- }
-
- @Override
- boolean emitModifiableMetadataAnnotations() {
- return isEnabled(EMIT_MODIFIABLE_METADATA_ANNOTATIONS);
- }
-
- @Override
- boolean useGradleIncrementalProcessing() {
- return isEnabled(USE_GRADLE_INCREMENTAL_PROCESSING);
- }
-
- @Override
- ValidationType fullBindingGraphValidationType(TypeElement element) {
- return fullBindingGraphValidationType();
- }
-
- private ValidationType fullBindingGraphValidationType() {
- return parseOption(FULL_BINDING_GRAPH_VALIDATION);
- }
-
- @Override
- Diagnostic.Kind moduleHasDifferentScopesDiagnosticKind() {
- return diagnosticKind(MODULE_HAS_DIFFERENT_SCOPES_VALIDATION);
- }
-
- @Override
- ValidationType explicitBindingConflictsWithInjectValidationType() {
- return parseOption(EXPLICIT_BINDING_CONFLICTS_WITH_INJECT);
- }
-
- private boolean isEnabled(KeyOnlyOption keyOnlyOption) {
- return processingEnvironment.getOptions().containsKey(keyOnlyOption.toString());
- }
-
- private boolean isEnabled(Feature feature) {
- return parseOption(feature).equals(ENABLED);
- }
-
- private Diagnostic.Kind diagnosticKind(Validation validation) {
- return parseOption(validation).diagnosticKind().get();
- }
-
- @SuppressWarnings("CheckReturnValue")
- private ProcessingEnvironmentCompilerOptions checkValid() {
- for (KeyOnlyOption keyOnlyOption : KeyOnlyOption.values()) {
- isEnabled(keyOnlyOption);
- }
- for (Feature feature : Feature.values()) {
- parseOption(feature);
- }
- for (Validation validation : Validation.values()) {
- parseOption(validation);
- }
- noLongerRecognized(EXPERIMENTAL_ANDROID_MODE);
- noLongerRecognized(FLOATING_BINDS_METHODS);
- return this;
- }
-
- private void noLongerRecognized(CommandLineOption commandLineOption) {
- if (processingEnvironment.getOptions().containsKey(commandLineOption.toString())) {
- processingEnvironment
- .getMessager()
- .printMessage(
- Diagnostic.Kind.WARNING, commandLineOption + " is no longer recognized by Dagger");
- }
- }
-
- private interface CommandLineOption {
- /** The key of the option (appears after "-A"). */
- @Override
- String toString();
-
- /**
- * Returns all aliases besides {@link #toString()}, such as old names for an option, in order of
- * precedence.
- */
- default ImmutableList<String> aliases() {
- return ImmutableList.of();
- }
-
- /** All the command-line names for this option, in order of precedence. */
- default Stream<String> allNames() {
- return concat(Stream.of(toString()), aliases().stream());
- }
- }
-
- /** An option that can be set on the command line. */
- private interface EnumOption<E extends Enum<E>> extends CommandLineOption {
- /** The default value for this option. */
- E defaultValue();
-
- /** The valid values for this option. */
- Set<E> validValues();
- }
-
- enum KeyOnlyOption implements CommandLineOption {
- HEADER_COMPILATION {
- @Override
- public String toString() {
- return "experimental_turbine_hjar";
- }
- },
-
- USE_GRADLE_INCREMENTAL_PROCESSING {
- @Override
- public String toString() {
- return "dagger.gradle.incremental";
- }
- },
- }
-
- /**
- * A feature that can be enabled or disabled on the command line by setting {@code -Akey=ENABLED}
- * or {@code -Akey=DISABLED}.
- */
- enum Feature implements EnumOption<FeatureStatus> {
- FAST_INIT,
-
- EXPERIMENTAL_ANDROID_MODE,
-
- FORMAT_GENERATED_SOURCE,
-
- WRITE_PRODUCER_NAME_IN_TOKEN,
-
- WARN_IF_INJECTION_FACTORY_NOT_GENERATED_UPSTREAM,
-
- IGNORE_PRIVATE_AND_STATIC_INJECTION_FOR_COMPONENT,
-
- EXPERIMENTAL_AHEAD_OF_TIME_SUBCOMPONENTS,
-
- FORCE_USE_SERIALIZED_COMPONENT_IMPLEMENTATIONS,
-
- EMIT_MODIFIABLE_METADATA_ANNOTATIONS(ENABLED),
-
- FLOATING_BINDS_METHODS,
- ;
-
- final FeatureStatus defaultValue;
-
- Feature() {
- this(DISABLED);
- }
-
- Feature(FeatureStatus defaultValue) {
- this.defaultValue = defaultValue;
- }
-
- @Override
- public FeatureStatus defaultValue() {
- return defaultValue;
- }
-
- @Override
- public Set<FeatureStatus> validValues() {
- return EnumSet.allOf(FeatureStatus.class);
- }
-
- @Override
- public String toString() {
- return optionName(this);
- }
- }
-
- /** The diagnostic kind or validation type for a kind of validation. */
- enum Validation implements EnumOption<ValidationType> {
- DISABLE_INTER_COMPONENT_SCOPE_VALIDATION(),
-
- NULLABLE_VALIDATION(ERROR, WARNING),
-
- PRIVATE_MEMBER_VALIDATION(ERROR, WARNING),
-
- STATIC_MEMBER_VALIDATION(ERROR, WARNING),
-
- /** Whether to validate full binding graphs for components, subcomponents, and modules. */
- FULL_BINDING_GRAPH_VALIDATION(NONE, ERROR, WARNING) {
- @Override
- public ImmutableList<String> aliases() {
- return ImmutableList.of("dagger.moduleBindingValidation");
- }
- },
-
- /**
- * How to report conflicting scoped bindings when validating partial binding graphs associated
- * with modules.
- */
- MODULE_HAS_DIFFERENT_SCOPES_VALIDATION(ERROR, WARNING),
-
- /**
- * How to report that an explicit binding in a subcomponent conflicts with an {@code @Inject}
- * constructor used in an ancestor component.
- */
- EXPLICIT_BINDING_CONFLICTS_WITH_INJECT(WARNING, ERROR, NONE),
- ;
-
- final ValidationType defaultType;
- final ImmutableSet<ValidationType> validTypes;
-
- Validation() {
- this(ERROR, WARNING, NONE);
- }
-
- Validation(ValidationType defaultType, ValidationType... moreValidTypes) {
- this.defaultType = defaultType;
- this.validTypes = immutableEnumSet(defaultType, moreValidTypes);
- }
-
- @Override
- public ValidationType defaultValue() {
- return defaultType;
- }
-
- @Override
- public Set<ValidationType> validValues() {
- return validTypes;
- }
-
- @Override
- public String toString() {
- return optionName(this);
- }
- }
-
- private static String optionName(Enum<? extends EnumOption<?>> option) {
- return "dagger." + UPPER_UNDERSCORE.to(LOWER_CAMEL, option.name());
- }
-
- /** The supported command-line options. */
- static ImmutableSet<String> supportedOptions() {
- // need explicit type parameter to avoid a runtime stream error
- return Stream.<CommandLineOption[]>of(
- KeyOnlyOption.values(), Feature.values(), Validation.values())
- .flatMap(Arrays::stream)
- .flatMap(CommandLineOption::allNames)
- .collect(toImmutableSet());
- }
-
- /**
- * Returns the value for the option as set on the command line by any name, or the default value
- * if not set.
- *
- * <p>If more than one name is used to set the value, but all names specify the same value,
- * reports a warning and returns that value.
- *
- * <p>If more than one name is used to set the value, and not all names specify the same value,
- * reports an error and returns the default value.
- */
- private <T extends Enum<T>> T parseOption(EnumOption<T> option) {
- @SuppressWarnings("unchecked") // we only put covariant values into the map
- T value = (T) enumOptions.computeIfAbsent(option, this::parseOptionUncached);
- return value;
- }
-
- private <T extends Enum<T>> T parseOptionUncached(EnumOption<T> option) {
- ImmutableMap<String, T> values = parseOptionWithAllNames(option);
-
- // If no value is specified, return the default value.
- if (values.isEmpty()) {
- return option.defaultValue();
- }
-
- // If all names have the same value, return that.
- if (values.asMultimap().inverse().keySet().size() == 1) {
- // Warn if an option was set with more than one name. That would be an error if the values
- // differed.
- if (values.size() > 1) {
- reportUseOfDifferentNamesForOption(Diagnostic.Kind.WARNING, option, values.keySet());
- }
- return values.values().asList().get(0);
- }
-
- // If different names have different values, report an error and return the default
- // value.
- reportUseOfDifferentNamesForOption(Diagnostic.Kind.ERROR, option, values.keySet());
- return option.defaultValue();
- }
-
- private void reportUseOfDifferentNamesForOption(
- Diagnostic.Kind diagnosticKind, EnumOption<?> option, ImmutableSet<String> usedNames) {
- processingEnvironment
- .getMessager()
- .printMessage(
- diagnosticKind,
- String.format(
- "Only one of the equivalent options (%s) should be used; prefer -A%s",
- usedNames.stream().map(name -> "-A" + name).collect(joining(", ")), option));
- }
-
- private <T extends Enum<T>> ImmutableMap<String, T> parseOptionWithAllNames(
- EnumOption<T> option) {
- @SuppressWarnings("unchecked") // map is covariant
- ImmutableMap<String, T> aliasValues =
- (ImmutableMap<String, T>)
- allCommandLineOptions.computeIfAbsent(option, this::parseOptionWithAllNamesUncached);
- return aliasValues;
- }
-
- private <T extends Enum<T>> ImmutableMap<String, T> parseOptionWithAllNamesUncached(
- EnumOption<T> option) {
- ImmutableMap.Builder<String, T> values = ImmutableMap.builder();
- getUsedNames(option)
- .forEach(
- name -> parseOptionWithName(option, name).ifPresent(value -> values.put(name, value)));
- return values.build();
- }
-
- private <T extends Enum<T>> Optional<T> parseOptionWithName(EnumOption<T> option, String key) {
- checkArgument(processingEnvironment.getOptions().containsKey(key), "key %s not found", key);
- String stringValue = processingEnvironment.getOptions().get(key);
- if (stringValue == null) {
- processingEnvironment
- .getMessager()
- .printMessage(Diagnostic.Kind.ERROR, "Processor option -A" + key + " needs a value");
- } else {
- try {
- T value =
- Enum.valueOf(option.defaultValue().getDeclaringClass(), Ascii.toUpperCase(stringValue));
- if (option.validValues().contains(value)) {
- return Optional.of(value);
- }
- } catch (IllegalArgumentException e) {
- // handled below
- }
- processingEnvironment
- .getMessager()
- .printMessage(
- Diagnostic.Kind.ERROR,
- String.format(
- "Processor option -A%s may only have the values %s "
- + "(case insensitive), found: %s",
- key, option.validValues(), stringValue));
- }
- return Optional.empty();
- }
-
- private Stream<String> getUsedNames(CommandLineOption option) {
- return option.allNames().filter(name -> processingEnvironment.getOptions().containsKey(name));
- }
-}
diff --git a/java/dagger/internal/codegen/ProcessingEnvironmentModule.java b/java/dagger/internal/codegen/ProcessingEnvironmentModule.java
index 1730574..8a535fe 100644
--- a/java/dagger/internal/codegen/ProcessingEnvironmentModule.java
+++ b/java/dagger/internal/codegen/ProcessingEnvironmentModule.java
@@ -16,15 +16,18 @@
package dagger.internal.codegen;
-import static com.google.common.base.Preconditions.checkNotNull;
-
import com.google.googlejavaformat.java.filer.FormattingFiler;
+import dagger.Binds;
import dagger.Module;
import dagger.Provides;
import dagger.Reusable;
+import dagger.internal.codegen.SpiModule.ProcessorClassLoader;
+import dagger.internal.codegen.compileroption.CompilerOptions;
+import dagger.internal.codegen.compileroption.ProcessingEnvironmentCompilerOptions;
+import dagger.internal.codegen.compileroption.ProcessingOptions;
import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.spi.BindingGraphPlugin;
import java.util.Map;
-import java.util.Optional;
import javax.annotation.processing.Filer;
import javax.annotation.processing.Messager;
import javax.annotation.processing.ProcessingEnvironment;
@@ -33,27 +36,25 @@
/** Bindings that depend on the {@link ProcessingEnvironment}. */
@Module
-final class ProcessingEnvironmentModule {
-
- private final ProcessingEnvironment processingEnvironment;
-
- ProcessingEnvironmentModule(ProcessingEnvironment processingEnvironment) {
- this.processingEnvironment = checkNotNull(processingEnvironment);
- }
+interface ProcessingEnvironmentModule {
+ @Binds
+ @Reusable // to avoid parsing options more than once
+ CompilerOptions bindCompilerOptions(
+ ProcessingEnvironmentCompilerOptions processingEnvironmentCompilerOptions);
@Provides
@ProcessingOptions
- Map<String, String> processingOptions() {
+ static Map<String, String> processingOptions(ProcessingEnvironment processingEnvironment) {
return processingEnvironment.getOptions();
}
@Provides
- Messager messager() {
+ static Messager messager(ProcessingEnvironment processingEnvironment) {
return processingEnvironment.getMessager();
}
@Provides
- Filer filer(CompilerOptions compilerOptions) {
+ static Filer filer(CompilerOptions compilerOptions, ProcessingEnvironment processingEnvironment) {
if (compilerOptions.headerCompilation() || !compilerOptions.formatGeneratedSource()) {
return processingEnvironment.getFiler();
} else {
@@ -62,28 +63,23 @@
}
@Provides
- Types types() {
+ static Types types(ProcessingEnvironment processingEnvironment) {
return processingEnvironment.getTypeUtils();
}
@Provides
- SourceVersion sourceVersion() {
+ static SourceVersion sourceVersion(ProcessingEnvironment processingEnvironment) {
return processingEnvironment.getSourceVersion();
}
@Provides
- DaggerElements daggerElements() {
+ static DaggerElements daggerElements(ProcessingEnvironment processingEnvironment) {
return new DaggerElements(processingEnvironment);
}
@Provides
- @Reusable // to avoid parsing options more than once
- CompilerOptions compilerOptions() {
- return ProcessingEnvironmentCompilerOptions.create(processingEnvironment);
- }
-
- @Provides
- Optional<DaggerStatisticsRecorder> daggerStatisticsRecorder() {
- return Optional.empty();
+ @ProcessorClassLoader
+ static ClassLoader processorClassloader(ProcessingEnvironment processingEnvironment) {
+ return BindingGraphPlugin.class.getClassLoader();
}
}
diff --git a/java/dagger/internal/codegen/ProcessingOptions.java b/java/dagger/internal/codegen/ProcessingOptions.java
deleted file mode 100644
index 105452a..0000000
--- a/java/dagger/internal/codegen/ProcessingOptions.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static java.lang.annotation.RetentionPolicy.RUNTIME;
-
-import java.lang.annotation.Retention;
-import javax.inject.Qualifier;
-
-/**
- * A qualifier for the {@link javax.annotation.processing.ProcessingEnvironment#getOptions()
- * processing options} passed to the current invocation of {@code javac}.
- */
-@Retention(RUNTIME)
-@Qualifier
-@interface ProcessingOptions {}
diff --git a/java/dagger/internal/codegen/ProcessingRoundCacheModule.java b/java/dagger/internal/codegen/ProcessingRoundCacheModule.java
index b56cc30..2373cd2 100644
--- a/java/dagger/internal/codegen/ProcessingRoundCacheModule.java
+++ b/java/dagger/internal/codegen/ProcessingRoundCacheModule.java
@@ -18,6 +18,14 @@
import dagger.Binds;
import dagger.Module;
+import dagger.internal.codegen.base.ClearableCache;
+import dagger.internal.codegen.binding.BindingGraphFactory;
+import dagger.internal.codegen.binding.ModuleDescriptor;
+import dagger.internal.codegen.kotlin.KotlinMetadataFactory;
+import dagger.internal.codegen.validation.AnyBindingMethodValidator;
+import dagger.internal.codegen.validation.ComponentCreatorValidator;
+import dagger.internal.codegen.validation.ComponentValidator;
+import dagger.internal.codegen.validation.InjectValidator;
import dagger.multibindings.IntoSet;
/**
@@ -28,6 +36,14 @@
interface ProcessingRoundCacheModule {
@Binds
@IntoSet
+ ClearableCache anyBindingMethodValidator(AnyBindingMethodValidator cache);
+
+ @Binds
+ @IntoSet
+ ClearableCache injectValidator(InjectValidator cache);
+
+ @Binds
+ @IntoSet
ClearableCache moduleDescriptorFactory(ModuleDescriptor.Factory cache);
@Binds
@@ -36,5 +52,13 @@
@Binds
@IntoSet
- ClearableCache componentImplementationFactory(ComponentImplementationFactory cache);
+ ClearableCache componentValidator(ComponentValidator cache);
+
+ @Binds
+ @IntoSet
+ ClearableCache componentCreatorValidator(ComponentCreatorValidator cache);
+
+ @Binds
+ @IntoSet
+ ClearableCache kotlinMetadata(KotlinMetadataFactory cache);
}
diff --git a/java/dagger/internal/codegen/ProducerCreationExpression.java b/java/dagger/internal/codegen/ProducerCreationExpression.java
deleted file mode 100644
index 1dd7a1c..0000000
--- a/java/dagger/internal/codegen/ProducerCreationExpression.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static dagger.internal.codegen.SourceFiles.generatedClassNameForBinding;
-
-import com.squareup.javapoet.CodeBlock;
-import dagger.internal.codegen.FrameworkFieldInitializer.FrameworkInstanceCreationExpression;
-
-/**
- * A {@link dagger.producers.Producer} creation expression for a {@link
- * dagger.producers.Produces @Produces}-annotated module method.
- */
-// TODO(dpb): Resolve with InjectionOrProvisionProviderCreationExpression.
-final class ProducerCreationExpression implements FrameworkInstanceCreationExpression {
-
- private final ComponentBindingExpressions componentBindingExpressions;
- private final ContributionBinding binding;
-
- ProducerCreationExpression(
- ContributionBinding binding, ComponentBindingExpressions componentBindingExpressions) {
- this.binding = checkNotNull(binding);
- this.componentBindingExpressions = checkNotNull(componentBindingExpressions);
- }
-
- @Override
- public CodeBlock creationExpression() {
- return CodeBlock.of(
- "$T.create($L)",
- generatedClassNameForBinding(binding),
- componentBindingExpressions.getCreateMethodArgumentsCodeBlock(binding));
- }
-}
diff --git a/java/dagger/internal/codegen/ProducerEntryPointView.java b/java/dagger/internal/codegen/ProducerEntryPointView.java
deleted file mode 100644
index 87b5a4a..0000000
--- a/java/dagger/internal/codegen/ProducerEntryPointView.java
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.ComponentImplementation.FieldSpecKind.FRAMEWORK_FIELD;
-import static javax.lang.model.element.Modifier.PRIVATE;
-
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.FieldSpec;
-import com.squareup.javapoet.TypeName;
-import dagger.internal.codegen.ComponentDescriptor.ComponentMethodDescriptor;
-import dagger.internal.codegen.javapoet.Expression;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.RequestKind;
-import dagger.producers.Producer;
-import dagger.producers.internal.CancellationListener;
-import dagger.producers.internal.Producers;
-import java.util.Optional;
-import javax.lang.model.type.TypeMirror;
-
-/**
- * A factory of {@linkplain Producers#entryPointViewOf(Producer, CancellationListener) entry point
- * views} of {@link Producer}s.
- */
-final class ProducerEntryPointView {
- private final DaggerTypes types;
-
- ProducerEntryPointView(DaggerTypes types) {
- this.types = types;
- }
-
- /**
- * Returns an expression for an {@linkplain Producers#entryPointViewOf(Producer,
- * CancellationListener) entry point view} of a producer if the component method returns a {@link
- * Producer} or {@link com.google.common.util.concurrent.ListenableFuture}.
- *
- * <p>This is intended to be a replacement implementation for {@link
- * BindingExpression#getDependencyExpressionForComponentMethod(ComponentMethodDescriptor,
- * ComponentImplementation)}, and in cases where {@link Optional#empty()} is returned, callers
- * should call {@code super.getDependencyExpressionForComponentMethod()}.
- */
- Optional<Expression> getProducerEntryPointField(
- BindingExpression producerExpression,
- ComponentMethodDescriptor componentMethod,
- ComponentImplementation component) {
- if (component.componentDescriptor().isProduction()
- && (componentMethod.dependencyRequest().get().kind().equals(RequestKind.FUTURE)
- || componentMethod.dependencyRequest().get().kind().equals(RequestKind.PRODUCER))) {
- return Optional.of(
- Expression.create(
- fieldType(componentMethod),
- "$N",
- createField(producerExpression, componentMethod, component)));
- } else {
- // If the component isn't a production component, it won't implement CancellationListener and
- // as such we can't create an entry point. But this binding must also just be a Producer from
- // Provider anyway in that case, so there shouldn't be an issue.
- // TODO(b/116855531): Is it really intended that a non-production component can have Producer
- // entry points?
- return Optional.empty();
- }
- }
-
- private FieldSpec createField(
- BindingExpression producerExpression,
- ComponentMethodDescriptor componentMethod,
- ComponentImplementation component) {
- // TODO(cgdecker): Use a FrameworkFieldInitializer for this?
- // Though I don't think we need the once-only behavior of that, since I think
- // getComponentMethodImplementation will only be called once anyway
- String methodName = componentMethod.methodElement().getSimpleName().toString();
- FieldSpec field =
- FieldSpec.builder(
- TypeName.get(fieldType(componentMethod)),
- component.getUniqueFieldName(methodName + "EntryPoint"),
- PRIVATE)
- .build();
- component.addField(FRAMEWORK_FIELD, field);
-
- CodeBlock fieldInitialization =
- CodeBlock.of(
- "this.$N = $T.entryPointViewOf($L, this);",
- field,
- Producers.class,
- producerExpression.getDependencyExpression(component.name()).codeBlock());
- component.addInitialization(fieldInitialization);
-
- return field;
- }
-
- // TODO(cgdecker): Can we use producerExpression.getDependencyExpression().type() instead of
- // needing to (re)compute this?
- private TypeMirror fieldType(ComponentMethodDescriptor componentMethod) {
- return types.wrapType(componentMethod.dependencyRequest().get().key().type(), Producer.class);
- }
-}
diff --git a/java/dagger/internal/codegen/ProducerFactoryGenerator.java b/java/dagger/internal/codegen/ProducerFactoryGenerator.java
deleted file mode 100644
index 3f2bef4..0000000
--- a/java/dagger/internal/codegen/ProducerFactoryGenerator.java
+++ /dev/null
@@ -1,553 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Verify.verifyNotNull;
-import static com.squareup.javapoet.ClassName.OBJECT;
-import static com.squareup.javapoet.MethodSpec.constructorBuilder;
-import static com.squareup.javapoet.MethodSpec.methodBuilder;
-import static com.squareup.javapoet.TypeSpec.classBuilder;
-import static dagger.internal.codegen.DaggerStreams.toImmutableList;
-import static dagger.internal.codegen.GwtCompatibility.gwtIncompatibleAnnotation;
-import static dagger.internal.codegen.SourceFiles.bindingTypeElementTypeVariableNames;
-import static dagger.internal.codegen.SourceFiles.generateBindingFieldsForDependencies;
-import static dagger.internal.codegen.SourceFiles.generatedClassNameForBinding;
-import static dagger.internal.codegen.SourceFiles.parameterizedGeneratedTypeNameForBinding;
-import static dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression.UNCHECKED;
-import static dagger.internal.codegen.javapoet.CodeBlocks.makeParametersCodeBlock;
-import static dagger.internal.codegen.javapoet.CodeBlocks.toParametersCodeBlock;
-import static dagger.internal.codegen.javapoet.TypeNames.FUTURES;
-import static dagger.internal.codegen.javapoet.TypeNames.PRODUCERS;
-import static dagger.internal.codegen.javapoet.TypeNames.PRODUCER_TOKEN;
-import static dagger.internal.codegen.javapoet.TypeNames.VOID_CLASS;
-import static dagger.internal.codegen.javapoet.TypeNames.listOf;
-import static dagger.internal.codegen.javapoet.TypeNames.listenableFutureOf;
-import static dagger.internal.codegen.javapoet.TypeNames.producedOf;
-import static java.util.stream.Collectors.joining;
-import static javax.lang.model.element.Modifier.FINAL;
-import static javax.lang.model.element.Modifier.PRIVATE;
-import static javax.lang.model.element.Modifier.PROTECTED;
-import static javax.lang.model.element.Modifier.PUBLIC;
-import static javax.lang.model.element.Modifier.STATIC;
-
-import com.google.common.collect.FluentIterable;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Iterables;
-import com.squareup.javapoet.AnnotationSpec;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.FieldSpec;
-import com.squareup.javapoet.MethodSpec;
-import com.squareup.javapoet.ParameterizedTypeName;
-import com.squareup.javapoet.TypeName;
-import com.squareup.javapoet.TypeSpec;
-import dagger.internal.codegen.javapoet.AnnotationSpecs;
-import dagger.internal.codegen.javapoet.TypeNames;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.model.DependencyRequest;
-import dagger.model.Key;
-import dagger.model.RequestKind;
-import dagger.producers.Producer;
-import dagger.producers.internal.AbstractProducesMethodProducer;
-import dagger.producers.internal.Producers;
-import java.util.Map;
-import java.util.Optional;
-import javax.annotation.processing.Filer;
-import javax.inject.Inject;
-import javax.lang.model.SourceVersion;
-import javax.lang.model.element.Element;
-import javax.lang.model.type.TypeMirror;
-
-/**
- * Generates {@link Producer} implementations from {@link ProductionBinding} instances.
- */
-final class ProducerFactoryGenerator extends SourceFileGenerator<ProductionBinding> {
- private final CompilerOptions compilerOptions;
- private final KeyFactory keyFactory;
-
- @Inject
- ProducerFactoryGenerator(
- Filer filer,
- DaggerElements elements,
- SourceVersion sourceVersion,
- CompilerOptions compilerOptions,
- KeyFactory keyFactory) {
- super(filer, elements, sourceVersion);
- this.compilerOptions = compilerOptions;
- this.keyFactory = keyFactory;
- }
-
- @Override
- ClassName nameGeneratedType(ProductionBinding binding) {
- return generatedClassNameForBinding(binding);
- }
-
- @Override
- Element originatingElement(ProductionBinding binding) {
- // we only create factories for bindings that have a binding element
- return binding.bindingElement().get();
- }
-
- @Override
- Optional<TypeSpec.Builder> write(ClassName generatedTypeName, ProductionBinding binding) {
- // We don't want to write out resolved bindings -- we want to write out the generic version.
- checkArgument(!binding.unresolved().isPresent());
- checkArgument(binding.bindingElement().isPresent());
-
- TypeName providedTypeName = TypeName.get(binding.contributedType());
- TypeName futureTypeName = listenableFutureOf(providedTypeName);
-
- TypeSpec.Builder factoryBuilder =
- classBuilder(generatedTypeName)
- .addAnnotation(
- // TODO(beder): examine if we can remove this or prevent subtypes of Future from
- // being produced
- AnnotationSpec.builder(SuppressWarnings.class)
- .addMember("value", "$S", "FutureReturnValueIgnored")
- .build())
- .addModifiers(PUBLIC, FINAL)
- .addTypeVariables(bindingTypeElementTypeVariableNames(binding));
-
- UniqueNameSet uniqueFieldNames = new UniqueNameSet();
- ImmutableMap.Builder<Key, FieldSpec> fieldsBuilder = ImmutableMap.builder();
-
- MethodSpec.Builder constructorBuilder = constructorBuilder().addModifiers(PRIVATE);
-
- Optional<FieldSpec> moduleField =
- binding.requiresModuleInstance()
- ? Optional.of(
- addFieldAndConstructorParameter(
- factoryBuilder,
- constructorBuilder,
- uniqueFieldNames.getUniqueName("module"),
- TypeName.get(binding.bindingTypeElement().get().asType())))
- : Optional.empty();
-
- String[] executorParameterName = new String[1];
- String[] monitorParameterName = new String[1];
- Map<Key, FrameworkField> bindingFieldsForDependencies =
- generateBindingFieldsForDependencies(binding);
- bindingFieldsForDependencies.forEach(
- (key, bindingField) -> {
- String fieldName = uniqueFieldNames.getUniqueName(bindingField.name());
- if (key.equals(keyFactory.forProductionImplementationExecutor())) {
- executorParameterName[0] = fieldName;
- constructorBuilder.addParameter(bindingField.type(), executorParameterName[0]);
- } else if (key.equals(keyFactory.forProductionComponentMonitor())) {
- monitorParameterName[0] = fieldName;
- constructorBuilder.addParameter(bindingField.type(), monitorParameterName[0]);
- } else {
- FieldSpec field =
- addFieldAndConstructorParameter(
- factoryBuilder, constructorBuilder, fieldName, bindingField.type());
- fieldsBuilder.put(key, field);
- }
- });
- ImmutableMap<Key, FieldSpec> fields = fieldsBuilder.build();
-
- constructorBuilder.addStatement(
- "super($N, $L, $N)",
- verifyNotNull(monitorParameterName[0]),
- producerTokenConstruction(generatedTypeName, binding),
- verifyNotNull(executorParameterName[0]));
-
- if (binding.requiresModuleInstance()) {
- assignField(constructorBuilder, moduleField.get(), null);
- }
-
- fields.forEach(
- (key, field) -> {
- ParameterizedTypeName type = bindingFieldsForDependencies.get(key).type();
- assignField(constructorBuilder, field, type);
- });
-
- MethodSpec.Builder collectDependenciesBuilder =
- methodBuilder("collectDependencies")
- .addAnnotation(Override.class)
- .addModifiers(PROTECTED);
-
- ImmutableList<DependencyRequest> asyncDependencies = asyncDependencies(binding);
- for (DependencyRequest dependency : asyncDependencies) {
- TypeName futureType = listenableFutureOf(asyncDependencyType(dependency));
- CodeBlock futureAccess = CodeBlock.of("$N.get()", fields.get(dependency.key()));
- collectDependenciesBuilder.addStatement(
- "$T $L = $L",
- futureType,
- dependencyFutureName(dependency),
- dependency.kind().equals(RequestKind.PRODUCED)
- ? CodeBlock.of("$T.createFutureProduced($L)", PRODUCERS, futureAccess)
- : futureAccess);
- }
- FutureTransform futureTransform = FutureTransform.create(fields, binding, asyncDependencies);
-
- collectDependenciesBuilder
- .returns(listenableFutureOf(futureTransform.applyArgType()))
- .addStatement("return $L", futureTransform.futureCodeBlock());
-
- MethodSpec.Builder callProducesMethod =
- methodBuilder("callProducesMethod")
- .returns(futureTypeName)
- .addAnnotation(Override.class)
- .addModifiers(PUBLIC)
- .addParameter(futureTransform.applyArgType(), futureTransform.applyArgName())
- .addExceptions(getThrownTypeNames(binding.thrownTypes()))
- .addCode(
- getInvocationCodeBlock(
- binding, providedTypeName, futureTransform.parameterCodeBlocks()));
- if (futureTransform.hasUncheckedCast()) {
- callProducesMethod.addAnnotation(AnnotationSpecs.suppressWarnings(UNCHECKED));
- }
-
- MethodSpec constructor = constructorBuilder.build();
- factoryBuilder
- .superclass(
- ParameterizedTypeName.get(
- ClassName.get(AbstractProducesMethodProducer.class),
- futureTransform.applyArgType(),
- providedTypeName))
- .addMethod(constructor)
- .addMethod(staticFactoryMethod(binding, constructor))
- .addMethod(collectDependenciesBuilder.build())
- .addMethod(callProducesMethod.build());
-
- gwtIncompatibleAnnotation(binding).ifPresent(factoryBuilder::addAnnotation);
-
- // TODO(gak): write a sensible toString
- return Optional.of(factoryBuilder);
- }
-
- private MethodSpec staticFactoryMethod(ProductionBinding binding, MethodSpec constructor) {
- return MethodSpec.methodBuilder("create")
- .addModifiers(PUBLIC, STATIC)
- .returns(parameterizedGeneratedTypeNameForBinding(binding))
- .addTypeVariables(bindingTypeElementTypeVariableNames(binding))
- .addParameters(constructor.parameters)
- .addStatement(
- "return new $T($L)",
- parameterizedGeneratedTypeNameForBinding(binding),
- constructor.parameters.stream()
- .map(p -> CodeBlock.of("$N", p.name))
- .collect(toParametersCodeBlock()))
- .build();
- }
-
- // TODO(ronshapiro): consolidate versions of these
- private static FieldSpec addFieldAndConstructorParameter(
- TypeSpec.Builder typeBuilder,
- MethodSpec.Builder constructorBuilder,
- String variableName,
- TypeName variableType) {
- FieldSpec field = FieldSpec.builder(variableType, variableName, PRIVATE, FINAL).build();
- typeBuilder.addField(field);
- constructorBuilder.addParameter(field.type, field.name);
- return field;
- }
-
- private static void assignField(
- MethodSpec.Builder constructorBuilder, FieldSpec field, ParameterizedTypeName type) {
- if (type != null && type.rawType.equals(TypeNames.PRODUCER)) {
- constructorBuilder.addStatement(
- "this.$1N = $2T.nonCancellationPropagatingViewOf($1N)", field, Producers.class);
- } else {
- constructorBuilder.addStatement("this.$1N = $1N", field);
- }
- }
-
- /** Returns a list of dependencies that are generated asynchronously. */
- private static ImmutableList<DependencyRequest> asyncDependencies(Binding binding) {
- final ImmutableMap<DependencyRequest, FrameworkDependency> frameworkDependencies =
- binding.dependenciesToFrameworkDependenciesMap();
- return FluentIterable.from(binding.dependencies())
- .filter(
- dependency ->
- isAsyncDependency(dependency)
- && frameworkDependencies
- .get(dependency)
- .frameworkClass()
- .equals(Producer.class))
- .toList();
- }
-
- private CodeBlock producerTokenConstruction(
- ClassName generatedTypeName, ProductionBinding binding) {
- CodeBlock producerTokenArgs =
- compilerOptions.writeProducerNameInToken()
- ? CodeBlock.of(
- "$S",
- String.format(
- "%s#%s",
- ClassName.get(binding.bindingTypeElement().get()),
- binding.bindingElement().get().getSimpleName()))
- : CodeBlock.of("$T.class", generatedTypeName);
- return CodeBlock.of("$T.create($L)", PRODUCER_TOKEN, producerTokenArgs);
- }
-
- /** Returns a name of the variable representing this dependency's future. */
- private static String dependencyFutureName(DependencyRequest dependency) {
- return dependency.requestElement().get().getSimpleName() + "Future";
- }
-
- /** Represents the transformation of an input future by a producer method. */
- abstract static class FutureTransform {
- protected final ImmutableMap<Key, FieldSpec> fields;
- protected final ProductionBinding binding;
-
- FutureTransform(ImmutableMap<Key, FieldSpec> fields, ProductionBinding binding) {
- this.fields = fields;
- this.binding = binding;
- }
-
- /** The code block representing the future that should be transformed. */
- abstract CodeBlock futureCodeBlock();
-
- /** The type of the argument to the apply method. */
- abstract TypeName applyArgType();
-
- /** The name of the argument to the apply method */
- abstract String applyArgName();
-
- /** The code blocks to be passed to the produces method itself. */
- abstract ImmutableList<CodeBlock> parameterCodeBlocks();
-
- /** Whether the transform method has an unchecked cast. */
- boolean hasUncheckedCast() {
- return false;
- }
-
- CodeBlock frameworkTypeUsageStatement(DependencyRequest dependency) {
- return SourceFiles.frameworkTypeUsageStatement(
- CodeBlock.of("$N", fields.get(dependency.key())), dependency.kind());
- }
-
- static FutureTransform create(
- ImmutableMap<Key, FieldSpec> fields,
- ProductionBinding binding,
- ImmutableList<DependencyRequest> asyncDependencies) {
- if (asyncDependencies.isEmpty()) {
- return new NoArgFutureTransform(fields, binding);
- } else if (asyncDependencies.size() == 1) {
- return new SingleArgFutureTransform(
- fields, binding, Iterables.getOnlyElement(asyncDependencies));
- } else {
- return new MultiArgFutureTransform(fields, binding, asyncDependencies);
- }
- }
- }
-
- static final class NoArgFutureTransform extends FutureTransform {
- NoArgFutureTransform(ImmutableMap<Key, FieldSpec> fields, ProductionBinding binding) {
- super(fields, binding);
- }
-
- @Override
- CodeBlock futureCodeBlock() {
- return CodeBlock.of("$T.<$T>immediateFuture(null)", FUTURES, VOID_CLASS);
- }
-
- @Override
- TypeName applyArgType() {
- return VOID_CLASS;
- }
-
- @Override
- String applyArgName() {
- return "ignoredVoidArg";
- }
-
- @Override
- ImmutableList<CodeBlock> parameterCodeBlocks() {
- return binding.explicitDependencies().stream()
- .map(this::frameworkTypeUsageStatement)
- .collect(toImmutableList());
- }
- }
-
- static final class SingleArgFutureTransform extends FutureTransform {
- private final DependencyRequest asyncDependency;
-
- SingleArgFutureTransform(
- ImmutableMap<Key, FieldSpec> fields,
- ProductionBinding binding,
- DependencyRequest asyncDependency) {
- super(fields, binding);
- this.asyncDependency = asyncDependency;
- }
-
- @Override
- CodeBlock futureCodeBlock() {
- return CodeBlock.of("$L", dependencyFutureName(asyncDependency));
- }
-
- @Override
- TypeName applyArgType() {
- return asyncDependencyType(asyncDependency);
- }
-
- @Override
- String applyArgName() {
- String argName = asyncDependency.requestElement().get().getSimpleName().toString();
- if (argName.equals("module")) {
- return "moduleArg";
- }
- return argName;
- }
-
- @Override
- ImmutableList<CodeBlock> parameterCodeBlocks() {
- ImmutableList.Builder<CodeBlock> parameterCodeBlocks = ImmutableList.builder();
- for (DependencyRequest dependency : binding.explicitDependencies()) {
- // We really want to compare instances here, because asyncDependency is an element in the
- // set binding.dependencies().
- if (dependency == asyncDependency) {
- parameterCodeBlocks.add(CodeBlock.of("$L", applyArgName()));
- } else {
- parameterCodeBlocks.add(frameworkTypeUsageStatement(dependency));
- }
- }
- return parameterCodeBlocks.build();
- }
- }
-
- static final class MultiArgFutureTransform extends FutureTransform {
- private final ImmutableList<DependencyRequest> asyncDependencies;
-
- MultiArgFutureTransform(
- ImmutableMap<Key, FieldSpec> fields,
- ProductionBinding binding,
- ImmutableList<DependencyRequest> asyncDependencies) {
- super(fields, binding);
- this.asyncDependencies = asyncDependencies;
- }
-
- @Override
- CodeBlock futureCodeBlock() {
- return CodeBlock.of(
- "$T.<$T>allAsList($L)",
- FUTURES,
- OBJECT,
- asyncDependencies
- .stream()
- .map(ProducerFactoryGenerator::dependencyFutureName)
- .collect(joining(", ")));
- }
-
- @Override
- TypeName applyArgType() {
- return listOf(OBJECT);
- }
-
- @Override
- String applyArgName() {
- return "args";
- }
-
- @Override
- ImmutableList<CodeBlock> parameterCodeBlocks() {
- int argIndex = 0;
- ImmutableList.Builder<CodeBlock> codeBlocks = ImmutableList.builder();
- for (DependencyRequest dependency : binding.explicitDependencies()) {
- if (isAsyncDependency(dependency)) {
- codeBlocks.add(
- CodeBlock.of(
- "($T) $L.get($L)", asyncDependencyType(dependency), applyArgName(), argIndex));
- argIndex++;
- } else {
- codeBlocks.add(frameworkTypeUsageStatement(dependency));
- }
- }
- return codeBlocks.build();
- }
-
- @Override
- boolean hasUncheckedCast() {
- return true;
- }
- }
-
- private static boolean isAsyncDependency(DependencyRequest dependency) {
- switch (dependency.kind()) {
- case INSTANCE:
- case PRODUCED:
- return true;
- default:
- return false;
- }
- }
-
- private static TypeName asyncDependencyType(DependencyRequest dependency) {
- TypeName keyName = TypeName.get(dependency.key().type());
- switch (dependency.kind()) {
- case INSTANCE:
- return keyName;
- case PRODUCED:
- return producedOf(keyName);
- default:
- throw new AssertionError();
- }
- }
-
- /**
- * Creates a code block for the invocation of the producer method from the module, which should be
- * used entirely within a method body.
- *
- * @param binding The binding to generate the invocation code block for.
- * @param providedTypeName The type name that should be provided by this producer.
- * @param parameterCodeBlocks The code blocks for all the parameters to the producer method.
- */
- private CodeBlock getInvocationCodeBlock(
- ProductionBinding binding,
- TypeName providedTypeName,
- ImmutableList<CodeBlock> parameterCodeBlocks) {
- CodeBlock moduleCodeBlock =
- CodeBlock.of(
- "$L.$L($L)",
- binding.requiresModuleInstance()
- ? "module"
- : CodeBlock.of("$T", ClassName.get(binding.bindingTypeElement().get())),
- binding.bindingElement().get().getSimpleName(),
- makeParametersCodeBlock(parameterCodeBlocks));
-
- final CodeBlock returnCodeBlock;
- switch (binding.productionKind().get()) {
- case IMMEDIATE:
- returnCodeBlock =
- CodeBlock.of("$T.<$T>immediateFuture($L)", FUTURES, providedTypeName, moduleCodeBlock);
- break;
- case FUTURE:
- returnCodeBlock = moduleCodeBlock;
- break;
- case SET_OF_FUTURE:
- returnCodeBlock = CodeBlock.of("$T.allAsSet($L)", PRODUCERS, moduleCodeBlock);
- break;
- default:
- throw new AssertionError();
- }
- return CodeBlock.of("return $L;", returnCodeBlock);
- }
-
- /**
- * Converts the list of thrown types into type names.
- *
- * @param thrownTypes the list of thrown types.
- */
- private FluentIterable<? extends TypeName> getThrownTypeNames(
- Iterable<? extends TypeMirror> thrownTypes) {
- return FluentIterable.from(thrownTypes).transform(TypeName::get);
- }
-}
diff --git a/java/dagger/internal/codegen/ProducerFromProviderCreationExpression.java b/java/dagger/internal/codegen/ProducerFromProviderCreationExpression.java
deleted file mode 100644
index aca9756..0000000
--- a/java/dagger/internal/codegen/ProducerFromProviderCreationExpression.java
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static dagger.internal.codegen.BindingRequest.bindingRequest;
-
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import dagger.internal.codegen.FrameworkFieldInitializer.FrameworkInstanceCreationExpression;
-import dagger.internal.codegen.javapoet.TypeNames;
-import dagger.model.RequestKind;
-import dagger.producers.Producer;
-import java.util.Optional;
-
-/** An {@link Producer} creation expression for provision bindings. */
-final class ProducerFromProviderCreationExpression implements FrameworkInstanceCreationExpression {
- private final ContributionBinding binding;
- private final ComponentImplementation componentImplementation;
- private final ComponentBindingExpressions componentBindingExpressions;
-
- ProducerFromProviderCreationExpression(
- ContributionBinding binding,
- ComponentImplementation componentImplementation,
- ComponentBindingExpressions componentBindingExpressions) {
- this.binding = checkNotNull(binding);
- this.componentImplementation = checkNotNull(componentImplementation);
- this.componentBindingExpressions = checkNotNull(componentBindingExpressions);
- }
-
- @Override
- public CodeBlock creationExpression() {
- return FrameworkType.PROVIDER.to(
- RequestKind.PRODUCER,
- componentBindingExpressions
- .getDependencyExpression(
- bindingRequest(binding.key(), FrameworkType.PROVIDER),
- componentImplementation.name())
- .codeBlock());
- }
-
- @Override
- public Optional<ClassName> alternativeFrameworkClass() {
- return Optional.of(TypeNames.PRODUCER);
- }
-
- // TODO(ronshapiro): should this have a simple factory if the delegate expression is simple?
-}
diff --git a/java/dagger/internal/codegen/ProducerNodeInstanceBindingExpression.java b/java/dagger/internal/codegen/ProducerNodeInstanceBindingExpression.java
deleted file mode 100644
index 18818d5..0000000
--- a/java/dagger/internal/codegen/ProducerNodeInstanceBindingExpression.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.squareup.javapoet.ClassName;
-import dagger.internal.codegen.ComponentDescriptor.ComponentMethodDescriptor;
-import dagger.internal.codegen.javapoet.Expression;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.Key;
-
-/** Binding expression for producer node instances. */
-final class ProducerNodeInstanceBindingExpression extends FrameworkInstanceBindingExpression {
- /** The component defining this binding. */
- private final ComponentImplementation componentImplementation;
- private final Key key;
- private final ProducerEntryPointView producerEntryPointView;
-
- ProducerNodeInstanceBindingExpression(
- ResolvedBindings resolvedBindings,
- FrameworkInstanceSupplier frameworkInstanceSupplier,
- DaggerTypes types,
- DaggerElements elements,
- ComponentImplementation componentImplementation) {
- super(resolvedBindings, frameworkInstanceSupplier, types, elements);
- this.componentImplementation = checkNotNull(componentImplementation);
- this.key = resolvedBindings.key();
- this.producerEntryPointView = new ProducerEntryPointView(types);
- }
-
- @Override
- protected FrameworkType frameworkType() {
- return FrameworkType.PRODUCER_NODE;
- }
-
- @Override
- Expression getDependencyExpression(ClassName requestingClass) {
- Expression result = super.getDependencyExpression(requestingClass);
- componentImplementation.addCancellableProducerKey(key);
- return result;
- }
-
- @Override
- Expression getDependencyExpressionForComponentMethod(
- ComponentMethodDescriptor componentMethod, ComponentImplementation component) {
- return producerEntryPointView
- .getProducerEntryPointField(this, componentMethod, component)
- .orElseGet(
- () -> super.getDependencyExpressionForComponentMethod(componentMethod, component));
- }
-}
diff --git a/java/dagger/internal/codegen/ProducesMethodValidator.java b/java/dagger/internal/codegen/ProducesMethodValidator.java
deleted file mode 100644
index bf45948..0000000
--- a/java/dagger/internal/codegen/ProducesMethodValidator.java
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static dagger.internal.codegen.BindingElementValidator.AllowsMultibindings.ALLOWS_MULTIBINDINGS;
-import static dagger.internal.codegen.BindingElementValidator.AllowsScoping.NO_SCOPING;
-import static dagger.internal.codegen.BindingMethodValidator.Abstractness.MUST_BE_CONCRETE;
-import static dagger.internal.codegen.BindingMethodValidator.ExceptionSuperclass.EXCEPTION;
-
-import com.google.auto.common.MoreTypes;
-import com.google.common.util.concurrent.ListenableFuture;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.multibindings.ElementsIntoSet;
-import dagger.producers.ProducerModule;
-import dagger.producers.Produces;
-import java.util.Optional;
-import java.util.Set;
-import javax.inject.Inject;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.TypeMirror;
-
-/** A validator for {@link Produces} methods. */
-final class ProducesMethodValidator extends BindingMethodValidator {
-
- @Inject
- ProducesMethodValidator(
- DaggerElements elements,
- DaggerTypes types,
- DependencyRequestValidator dependencyRequestValidator) {
- super(
- elements,
- types,
- dependencyRequestValidator,
- Produces.class,
- ProducerModule.class,
- MUST_BE_CONCRETE,
- EXCEPTION,
- ALLOWS_MULTIBINDINGS,
- NO_SCOPING);
- }
-
- @Override
- protected String elementsIntoSetNotASetMessage() {
- return "@Produces methods of type set values must return a Set or ListenableFuture of Set";
- }
-
- @Override
- protected String badTypeMessage() {
- return "@Produces methods can return only a primitive, an array, a type variable, "
- + "a declared type, or a ListenableFuture of one of those types";
- }
-
- @Override
- protected ElementValidator elementValidator(ExecutableElement element) {
- return new Validator(element);
- }
-
- private class Validator extends MethodValidator {
- Validator(ExecutableElement element) {
- super(element);
- }
-
- @Override
- protected void checkAdditionalMethodProperties() {
- checkNullable();
- }
-
- /** Adds a warning if a {@link Produces @Produces} method is declared nullable. */
- // TODO(beder): Properly handle nullable with producer methods.
- private void checkNullable() {
- if (ConfigurationAnnotations.getNullableType(element).isPresent()) {
- report.addWarning("@Nullable on @Produces methods does not do anything");
- }
- }
-
- /**
- * {@inheritDoc}
- *
- * <p>Allows {@code keyType} to be a {@link ListenableFuture} of an otherwise-valid key type.
- */
- @Override
- protected void checkKeyType(TypeMirror keyType) {
- Optional<TypeMirror> typeToCheck = unwrapListenableFuture(keyType);
- if (typeToCheck.isPresent()) {
- super.checkKeyType(typeToCheck.get());
- }
- }
-
- /**
- * {@inheritDoc}
- *
- * <p>Allows an {@link ElementsIntoSet @ElementsIntoSet} or {@code SET_VALUES} method to return
- * a {@link ListenableFuture} of a {@link Set} as well.
- */
- @Override
- protected void checkSetValuesType() {
- Optional<TypeMirror> typeToCheck = unwrapListenableFuture(element.getReturnType());
- if (typeToCheck.isPresent()) {
- checkSetValuesType(typeToCheck.get());
- }
- }
-
- private Optional<TypeMirror> unwrapListenableFuture(TypeMirror type) {
- if (MoreTypes.isType(type) && MoreTypes.isTypeOf(ListenableFuture.class, type)) {
- DeclaredType declaredType = MoreTypes.asDeclared(type);
- if (declaredType.getTypeArguments().isEmpty()) {
- report.addError("@Produces methods cannot return a raw ListenableFuture");
- return Optional.empty();
- } else {
- return Optional.of((TypeMirror) getOnlyElement(declaredType.getTypeArguments()));
- }
- }
- return Optional.of(type);
- }
- }
-}
diff --git a/java/dagger/internal/codegen/ProductionBinding.java b/java/dagger/internal/codegen/ProductionBinding.java
deleted file mode 100644
index a22f21c..0000000
--- a/java/dagger/internal/codegen/ProductionBinding.java
+++ /dev/null
@@ -1,146 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.internal.codegen.langmodel.DaggerTypes.isFutureType;
-
-import com.google.auto.value.AutoValue;
-import com.google.auto.value.extension.memoized.Memoized;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-import com.google.errorprone.annotations.CanIgnoreReturnValue;
-import dagger.model.DependencyRequest;
-import dagger.model.Key;
-import java.util.Optional;
-import java.util.stream.Stream;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.type.TypeMirror;
-
-/**
- * A value object representing the mechanism by which a {@link Key} can be produced.
- */
-@AutoValue
-abstract class ProductionBinding extends ContributionBinding {
-
- @Override
- public BindingType bindingType() {
- return BindingType.PRODUCTION;
- }
-
- @Override
- abstract Optional<ProductionBinding> unresolved();
-
- @Override
- ImmutableSet<DependencyRequest> implicitDependencies() {
- return Stream.of(executorRequest(), monitorRequest())
- .filter(Optional::isPresent)
- .map(Optional::get)
- .collect(toImmutableSet());
- }
-
- /** What kind of object a {@code @Produces}-annotated method returns. */
- enum ProductionKind {
- /** A value. */
- IMMEDIATE,
- /** A {@code ListenableFuture<T>}. */
- FUTURE,
- /** A {@code Set<ListenableFuture<T>>}. */
- SET_OF_FUTURE;
-
- /** Returns the kind of object a {@code @Produces}-annotated method returns. */
- static ProductionKind fromProducesMethod(ExecutableElement producesMethod) {
- if (isFutureType(producesMethod.getReturnType())) {
- return FUTURE;
- } else if (ContributionType.fromBindingElement(producesMethod)
- .equals(ContributionType.SET_VALUES)
- && isFutureType(SetType.from(producesMethod.getReturnType()).elementType())) {
- return SET_OF_FUTURE;
- } else {
- return IMMEDIATE;
- }
- }
- }
-
- /**
- * Returns the kind of object the produces method returns. All production bindings from
- * {@code @Produces} methods will have a production kind, but synthetic production bindings may
- * not.
- */
- abstract Optional<ProductionKind> productionKind();
-
- /** Returns the list of types in the throws clause of the method. */
- abstract ImmutableList<? extends TypeMirror> thrownTypes();
-
- /**
- * If this production requires an executor, this will be the corresponding request. All
- * production bindings from {@code @Produces} methods will have an executor request, but
- * synthetic production bindings may not.
- */
- abstract Optional<DependencyRequest> executorRequest();
-
- /** If this production requires a monitor, this will be the corresponding request. All
- * production bindings from {@code @Produces} methods will have a monitor request, but synthetic
- * production bindings may not.
- */
- abstract Optional<DependencyRequest> monitorRequest();
-
- // Profiling determined that this method is called enough times that memoizing it had a measurable
- // performance improvement for large components.
- @Memoized
- @Override
- boolean requiresModuleInstance() {
- return super.requiresModuleInstance();
- }
-
- static Builder builder() {
- return new AutoValue_ProductionBinding.Builder()
- .explicitDependencies(ImmutableList.<DependencyRequest>of())
- .thrownTypes(ImmutableList.<TypeMirror>of());
- }
-
- @Memoized
- @Override
- public abstract int hashCode();
-
- // TODO(ronshapiro,dpb): simplify the equality semantics
- @Override
- public abstract boolean equals(Object obj);
-
- @AutoValue.Builder
- @CanIgnoreReturnValue
- abstract static class Builder extends ContributionBinding.Builder<ProductionBinding, Builder> {
-
- @Override
- Builder dependencies(Iterable<DependencyRequest> dependencies) {
- return explicitDependencies(dependencies);
- }
-
- abstract Builder explicitDependencies(Iterable<DependencyRequest> dependencies);
-
- abstract Builder productionKind(ProductionKind productionKind);
-
- @Override
- abstract Builder unresolved(ProductionBinding unresolved);
-
- abstract Builder thrownTypes(Iterable<? extends TypeMirror> thrownTypes);
-
- abstract Builder executorRequest(DependencyRequest executorRequest);
-
- abstract Builder monitorRequest(DependencyRequest monitorRequest);
- }
-}
diff --git a/java/dagger/internal/codegen/ProviderInstanceBindingExpression.java b/java/dagger/internal/codegen/ProviderInstanceBindingExpression.java
deleted file mode 100644
index 60166de..0000000
--- a/java/dagger/internal/codegen/ProviderInstanceBindingExpression.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-
-/** Binding expression for provider instances. */
-final class ProviderInstanceBindingExpression extends FrameworkInstanceBindingExpression {
-
- ProviderInstanceBindingExpression(
- ResolvedBindings resolvedBindings,
- FrameworkInstanceSupplier frameworkInstanceSupplier,
- DaggerTypes types,
- DaggerElements elements) {
- super(
- resolvedBindings,
- frameworkInstanceSupplier,
- types,
- elements);
- }
-
- @Override
- protected FrameworkType frameworkType() {
- return FrameworkType.PROVIDER;
- }
-}
diff --git a/java/dagger/internal/codegen/ProvidesMethodValidator.java b/java/dagger/internal/codegen/ProvidesMethodValidator.java
deleted file mode 100644
index 01e71ae..0000000
--- a/java/dagger/internal/codegen/ProvidesMethodValidator.java
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.BindingElementValidator.AllowsMultibindings.ALLOWS_MULTIBINDINGS;
-import static dagger.internal.codegen.BindingElementValidator.AllowsScoping.ALLOWS_SCOPING;
-import static dagger.internal.codegen.BindingMethodValidator.Abstractness.MUST_BE_CONCRETE;
-import static dagger.internal.codegen.BindingMethodValidator.ExceptionSuperclass.RUNTIME_EXCEPTION;
-
-import com.google.common.collect.ImmutableSet;
-import dagger.Module;
-import dagger.Provides;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.producers.ProducerModule;
-import javax.inject.Inject;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.VariableElement;
-
-/** A validator for {@link Provides} methods. */
-final class ProvidesMethodValidator extends BindingMethodValidator {
-
- private final DependencyRequestValidator dependencyRequestValidator;
-
- @Inject
- ProvidesMethodValidator(
- DaggerElements elements,
- DaggerTypes types,
- DependencyRequestValidator dependencyRequestValidator) {
- super(
- elements,
- types,
- Provides.class,
- ImmutableSet.of(Module.class, ProducerModule.class),
- dependencyRequestValidator,
- MUST_BE_CONCRETE,
- RUNTIME_EXCEPTION,
- ALLOWS_MULTIBINDINGS,
- ALLOWS_SCOPING);
- this.dependencyRequestValidator = dependencyRequestValidator;
- }
-
- @Override
- protected ElementValidator elementValidator(ExecutableElement element) {
- return new Validator(element);
- }
-
- private class Validator extends MethodValidator {
- Validator(ExecutableElement element) {
- super(element);
- }
-
- @Override
- protected void checkAdditionalMethodProperties() {
- }
-
- /** Adds an error if a {@link Provides @Provides} method depends on a producer type. */
- @Override
- protected void checkParameter(VariableElement parameter) {
- super.checkParameter(parameter);
- dependencyRequestValidator.checkNotProducer(report, parameter);
- }
- }
-}
diff --git a/java/dagger/internal/codegen/ProvisionBinding.java b/java/dagger/internal/codegen/ProvisionBinding.java
deleted file mode 100644
index 306cb13..0000000
--- a/java/dagger/internal/codegen/ProvisionBinding.java
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.model.BindingKind.COMPONENT_PROVISION;
-import static dagger.model.BindingKind.PROVISION;
-
-import com.google.auto.value.AutoValue;
-import com.google.auto.value.extension.memoized.Memoized;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableSortedSet;
-import com.google.errorprone.annotations.CanIgnoreReturnValue;
-import dagger.internal.codegen.MembersInjectionBinding.InjectionSite;
-import dagger.model.BindingKind;
-import dagger.model.DependencyRequest;
-import dagger.model.Key;
-import dagger.model.Scope;
-import java.util.Optional;
-
-/**
- * A value object representing the mechanism by which a {@link Key} can be provided.
- */
-@AutoValue
-abstract class ProvisionBinding extends ContributionBinding {
-
- @Override
- @Memoized
- ImmutableSet<DependencyRequest> explicitDependencies() {
- return ImmutableSet.<DependencyRequest>builder()
- .addAll(provisionDependencies())
- .addAll(membersInjectionDependencies())
- .build();
- }
-
- /**
- * Dependencies necessary to invoke an {@code @Inject} constructor or {@code @Provides} method.
- */
- abstract ImmutableSet<DependencyRequest> provisionDependencies();
-
- @Memoized
- ImmutableSet<DependencyRequest> membersInjectionDependencies() {
- return injectionSites()
- .stream()
- .flatMap(i -> i.dependencies().stream())
- .collect(toImmutableSet());
- }
-
- /**
- * {@link InjectionSite}s for all {@code @Inject} members if {@link #kind()} is {@link
- * BindingKind#INJECTION}, otherwise empty.
- */
- abstract ImmutableSortedSet<InjectionSite> injectionSites();
-
- @Override
- public BindingType bindingType() {
- return BindingType.PROVISION;
- }
-
- @Override
- abstract Optional<ProvisionBinding> unresolved();
-
- // TODO(ronshapiro): we should be able to remove this, but AutoValue barks on the Builder's scope
- // method, saying that the method doesn't correspond to a property of ProvisionBinding
- @Override
- public abstract Optional<Scope> scope();
-
- static Builder builder() {
- return new AutoValue_ProvisionBinding.Builder()
- .provisionDependencies(ImmutableSet.of())
- .injectionSites(ImmutableSortedSet.of());
- }
-
- abstract Builder toBuilder();
-
- private static final ImmutableSet<BindingKind> KINDS_TO_CHECK_FOR_NULL =
- ImmutableSet.of(PROVISION, COMPONENT_PROVISION);
-
- boolean shouldCheckForNull(CompilerOptions compilerOptions) {
- return KINDS_TO_CHECK_FOR_NULL.contains(kind())
- && !contributedPrimitiveType().isPresent()
- && !nullableType().isPresent()
- && compilerOptions.doCheckForNulls();
- }
-
- // Profiling determined that this method is called enough times that memoizing it had a measurable
- // performance improvement for large components.
- @Memoized
- @Override
- boolean requiresModuleInstance() {
- return super.requiresModuleInstance();
- }
-
- @Memoized
- @Override
- public abstract int hashCode();
-
- // TODO(ronshapiro,dpb): simplify the equality semantics
- @Override
- public abstract boolean equals(Object obj);
-
- @AutoValue.Builder
- @CanIgnoreReturnValue
- abstract static class Builder extends ContributionBinding.Builder<ProvisionBinding, Builder> {
-
- @Override
- Builder dependencies(Iterable<DependencyRequest> dependencies) {
- return provisionDependencies(dependencies);
- }
-
- abstract Builder provisionDependencies(Iterable<DependencyRequest> provisionDependencies);
-
- abstract Builder injectionSites(ImmutableSortedSet<InjectionSite> injectionSites);
-
- @Override
- abstract Builder unresolved(ProvisionBinding unresolved);
-
- abstract Builder scope(Optional<Scope> scope);
- }
-
-}
diff --git a/java/dagger/internal/codegen/ProvisionDependencyOnProducerBindingValidator.java b/java/dagger/internal/codegen/ProvisionDependencyOnProducerBindingValidator.java
deleted file mode 100644
index 2fb1a0e..0000000
--- a/java/dagger/internal/codegen/ProvisionDependencyOnProducerBindingValidator.java
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Verify.verify;
-import static dagger.internal.codegen.DaggerStreams.instancesOf;
-import static dagger.internal.codegen.RequestKinds.canBeSatisfiedByProductionBinding;
-import static javax.tools.Diagnostic.Kind.ERROR;
-
-import dagger.model.BindingGraph;
-import dagger.model.BindingGraph.DependencyEdge;
-import dagger.model.BindingGraph.Node;
-import dagger.spi.BindingGraphPlugin;
-import dagger.spi.DiagnosticReporter;
-import java.util.stream.Stream;
-import javax.inject.Inject;
-
-/**
- * Reports an error for each provision-only dependency request that is satisfied by a production
- * binding.
- */
-// TODO(b/29509141): Clarify the error.
-final class ProvisionDependencyOnProducerBindingValidator implements BindingGraphPlugin {
-
- @Inject
- ProvisionDependencyOnProducerBindingValidator() {}
-
- @Override
- public String pluginName() {
- return "Dagger/ProviderDependsOnProducer";
- }
-
- @Override
- public void visitGraph(BindingGraph bindingGraph, DiagnosticReporter diagnosticReporter) {
- provisionDependenciesOnProductionBindings(bindingGraph)
- .forEach(
- provisionDependent ->
- diagnosticReporter.reportDependency(
- ERROR,
- provisionDependent,
- provisionDependent.isEntryPoint()
- ? entryPointErrorMessage(provisionDependent)
- : dependencyErrorMessage(provisionDependent, bindingGraph)));
- }
-
- private Stream<DependencyEdge> provisionDependenciesOnProductionBindings(
- BindingGraph bindingGraph) {
- return bindingGraph.bindings().stream()
- .filter(binding -> binding.isProduction())
- .flatMap(binding -> incomingDependencies(binding, bindingGraph))
- .filter(edge -> !dependencyCanUseProduction(edge, bindingGraph));
- }
-
- /** Returns the dependencies on {@code binding}. */
- // TODO(dpb): Move to BindingGraph.
- private Stream<DependencyEdge> incomingDependencies(
- dagger.model.Binding binding, BindingGraph bindingGraph) {
- return bindingGraph.network().inEdges(binding).stream()
- .flatMap(instancesOf(DependencyEdge.class));
- }
-
- // TODO(ronshapiro): merge with MissingBindingValidator.dependencyCanUseProduction
- private boolean dependencyCanUseProduction(DependencyEdge edge, BindingGraph bindingGraph) {
- return edge.isEntryPoint()
- ? canBeSatisfiedByProductionBinding(edge.dependencyRequest().kind())
- : bindingRequestingDependency(edge, bindingGraph).isProduction();
- }
-
- /**
- * Returns the binding that requests a dependency.
- *
- * @throws IllegalArgumentException if {@code dependency} is an {@linkplain
- * DependencyEdge#isEntryPoint() entry point}.
- */
- // TODO(dpb): Move to BindingGraph.
- private dagger.model.Binding bindingRequestingDependency(
- DependencyEdge dependency, BindingGraph bindingGraph) {
- checkArgument(!dependency.isEntryPoint());
- Node source = bindingGraph.network().incidentNodes(dependency).source();
- verify(
- source instanceof dagger.model.Binding,
- "expected source of %s to be a binding, but was: %s",
- dependency,
- source);
- return (dagger.model.Binding) source;
- }
-
- private String entryPointErrorMessage(DependencyEdge entryPoint) {
- return String.format(
- "%s is a provision entry-point, which cannot depend on a production.",
- entryPoint.dependencyRequest().key());
- }
-
- private String dependencyErrorMessage(
- DependencyEdge dependencyOnProduction, BindingGraph bindingGraph) {
- return String.format(
- "%s is a provision, which cannot depend on a production.",
- bindingRequestingDependency(dependencyOnProduction, bindingGraph).key());
- }
-}
diff --git a/java/dagger/internal/codegen/PrunedConcreteMethodBindingExpression.java b/java/dagger/internal/codegen/PrunedConcreteMethodBindingExpression.java
deleted file mode 100644
index 6eb92ac..0000000
--- a/java/dagger/internal/codegen/PrunedConcreteMethodBindingExpression.java
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import dagger.internal.MissingBindingFactory;
-import dagger.internal.codegen.ModifiableBindingMethods.ModifiableBindingMethod;
-import dagger.internal.codegen.javapoet.Expression;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.producers.internal.MissingBindingProducer;
-import java.util.Optional;
-
-/**
- * A {@link BindingExpression} that implements a method that encapsulates a binding that is not part
- * of the binding graph when generating a final concrete implementation of a subcomponent. The
- * implementation throws an exception. It is assumed that a binding may remain missing in a valid
- * binding graph, because it's possible for there to be dependencies that are passively pruned when
- * a non-leaf binding is re-defined (such as when {@code @Provides} bindings override
- * {@code @Inject} bindings).
- *
- * <p>This method should never be invoked. If it is the exception indicates an issue within Dagger
- * itself.
- */
-final class PrunedConcreteMethodBindingExpression extends BindingExpression {
- private static final CodeBlock METHOD_IMPLEMENTATION =
- CodeBlock.of(
- "throw new $T($S);",
- UnsupportedOperationException.class,
- "This binding is not part of the final binding graph. The key was requested by a binding "
- + "that was believed to possibly be part of the graph, but is no longer requested. "
- + "If this exception is thrown, it is the result of a Dagger bug.");
-
- PrunedConcreteMethodBindingExpression() {}
-
- @Override
- CodeBlock getModifiableBindingMethodImplementation(
- ModifiableBindingMethod modifiableBindingMethod,
- ComponentImplementation component,
- DaggerTypes types) {
- Optional<FrameworkType> frameworkType = modifiableBindingMethod.request().frameworkType();
- if (frameworkType.isPresent()) {
- // If we make initializations replaceable, we can do away with these classes and this logic
- // since the pruned framework instances will no longer be initialized
- switch (frameworkType.get()) {
- case PROVIDER:
- return missingFrameworkInstance(MissingBindingFactory.class);
- case PRODUCER_NODE:
- return missingFrameworkInstance(MissingBindingProducer.class);
- }
- throw new AssertionError(frameworkType);
- }
- return METHOD_IMPLEMENTATION;
- }
-
- private static CodeBlock missingFrameworkInstance(Class<?> factoryClass) {
- return CodeBlock.builder().addStatement("return $T.create()", factoryClass).build();
- }
-
- @Override
- final Expression getDependencyExpression(ClassName requestingClass) {
- throw new UnsupportedOperationException(
- "Requesting a dependency expression for a pruned binding.");
- }
-}
diff --git a/java/dagger/internal/codegen/RequestKinds.java b/java/dagger/internal/codegen/RequestKinds.java
deleted file mode 100644
index aa17f5e..0000000
--- a/java/dagger/internal/codegen/RequestKinds.java
+++ /dev/null
@@ -1,203 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreTypes.asDeclared;
-import static com.google.auto.common.MoreTypes.isType;
-import static com.google.auto.common.MoreTypes.isTypeOf;
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static dagger.internal.codegen.javapoet.TypeNames.lazyOf;
-import static dagger.internal.codegen.javapoet.TypeNames.listenableFutureOf;
-import static dagger.internal.codegen.javapoet.TypeNames.producedOf;
-import static dagger.internal.codegen.javapoet.TypeNames.producerOf;
-import static dagger.internal.codegen.javapoet.TypeNames.providerOf;
-import static dagger.internal.codegen.langmodel.DaggerTypes.checkTypePresent;
-import static dagger.model.RequestKind.INSTANCE;
-import static dagger.model.RequestKind.LAZY;
-import static dagger.model.RequestKind.PRODUCED;
-import static dagger.model.RequestKind.PRODUCER;
-import static dagger.model.RequestKind.PROVIDER;
-import static dagger.model.RequestKind.PROVIDER_OF_LAZY;
-
-import com.google.auto.common.MoreTypes;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.util.concurrent.ListenableFuture;
-import com.squareup.javapoet.TypeName;
-import dagger.Lazy;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.RequestKind;
-import dagger.producers.Produced;
-import dagger.producers.Producer;
-import javax.inject.Provider;
-import javax.lang.model.type.TypeMirror;
-
-/** Utility methods for {@link RequestKind}s. */
-final class RequestKinds {
- /** Returns the type of a request of this kind for a key with a given type. */
- static TypeMirror requestType(RequestKind requestKind, TypeMirror type, DaggerTypes types) {
- switch (requestKind) {
- case INSTANCE:
- return type;
-
- case PROVIDER_OF_LAZY:
- return types.wrapType(requestType(LAZY, type, types), Provider.class);
-
- case FUTURE:
- return types.wrapType(type, ListenableFuture.class);
-
- default:
- return types.wrapType(type, frameworkClass(requestKind));
- }
- }
-
- /** Returns the type of a request of this kind for a key with a given type. */
- static TypeName requestTypeName(RequestKind requestKind, TypeName keyType) {
- switch (requestKind) {
- case INSTANCE:
- return keyType;
-
- case PROVIDER:
- return providerOf(keyType);
-
- case LAZY:
- return lazyOf(keyType);
-
- case PROVIDER_OF_LAZY:
- return providerOf(lazyOf(keyType));
-
- case PRODUCER:
- return producerOf(keyType);
-
- case PRODUCED:
- return producedOf(keyType);
-
- case FUTURE:
- return listenableFutureOf(keyType);
-
- default:
- throw new AssertionError(requestKind);
- }
- }
-
- private static final ImmutableMap<RequestKind, Class<?>> FRAMEWORK_CLASSES =
- ImmutableMap.of(
- PROVIDER, Provider.class,
- LAZY, Lazy.class,
- PRODUCER, Producer.class,
- PRODUCED, Produced.class);
-
- /** Returns the {@link RequestKind} that matches the wrapping types (if any) of {@code type}. */
- static RequestKind getRequestKind(TypeMirror type) {
- checkTypePresent(type);
- for (RequestKind kind : FRAMEWORK_CLASSES.keySet()) {
- if (matchesKind(kind, type)) {
- if (kind.equals(PROVIDER) && matchesKind(LAZY, extractKeyType(kind, type))) {
- return PROVIDER_OF_LAZY;
- }
- return kind;
- }
- }
- return INSTANCE;
- }
-
- /**
- * Returns {@code true} if {@code type} is a parameterized type of {@code kind}'s {@link
- * #frameworkClass(RequestKind) framework class}.
- */
- private static boolean matchesKind(RequestKind kind, TypeMirror type) {
- return isType(type)
- && isTypeOf(frameworkClass(kind), type)
- && !asDeclared(type).getTypeArguments().isEmpty();
- }
-
- /**
- * Unwraps the framework class(es) of {@code requestKind} from {@code type}. If {@code
- * requestKind} is {@link RequestKind#INSTANCE}, this acts as an identity function.
- *
- * @throws TypeNotPresentException if {@code type} is an {@link javax.lang.model.type.ErrorType},
- * which may mean that the type will be generated in a later round of processing
- * @throws IllegalArgumentException if {@code type} is not wrapped with {@code requestKind}'s
- * framework class(es).
- */
- static TypeMirror extractKeyType(RequestKind requestKind, TypeMirror type) {
- checkTypePresent(type);
- switch (requestKind) {
- case INSTANCE:
- return type;
- case PROVIDER_OF_LAZY:
- return extractKeyType(LAZY, extractKeyType(PROVIDER, type));
- default:
- checkArgument(isType(type) && isTypeOf(frameworkClass(requestKind), type));
- return getOnlyElement(MoreTypes.asDeclared(type).getTypeArguments());
- }
- }
-
- /**
- * A dagger- or {@code javax.inject}-defined class for {@code requestKind} that that can wrap
- * another type but share the same {@link dagger.model.Key}.
- *
- * <p>For example, {@code Provider<String>} and {@code Lazy<String>} can both be requested if a
- * key exists for {@code String}; they all share the same key.
- *
- * <p>This concept is not well defined and should probably be removed and inlined into the cases
- * that need it. For example, {@link RequestKind#PROVIDER_OF_LAZY} has <em>2</em> wrapping
- * classes, and {@link RequestKind#FUTURE} is wrapped with a {@link ListenableFuture}, but for
- * historical/implementation reasons has not had an associated framework class.
- */
- static Class<?> frameworkClass(RequestKind requestKind) {
- Class<?> result = FRAMEWORK_CLASSES.get(requestKind);
- checkArgument(result != null, "no framework class for %s", requestKind);
- return result;
- }
-
- /**
- * Returns {@code true} if requests for {@code requestKind} can be satisfied by a production
- * binding.
- */
- static boolean canBeSatisfiedByProductionBinding(RequestKind requestKind) {
- switch (requestKind) {
- case INSTANCE:
- case PROVIDER:
- case LAZY:
- case PROVIDER_OF_LAZY:
- case MEMBERS_INJECTION:
- return false;
- case PRODUCER:
- case PRODUCED:
- case FUTURE:
- return true;
- }
- throw new AssertionError();
- }
-
- /**
- * Returns true if {@code requestKind} is always derived from a {@link RequestKind#PROVIDER}
- * instance.
- */
- static boolean isDerivedFromProvider(RequestKind requestKind) {
- switch (requestKind) {
- case LAZY:
- case PROVIDER_OF_LAZY:
- return true;
- default:
- return false;
- }
- }
-
- private RequestKinds() {}
-}
diff --git a/java/dagger/internal/codegen/ResolvedBindings.java b/java/dagger/internal/codegen/ResolvedBindings.java
deleted file mode 100644
index 814995a..0000000
--- a/java/dagger/internal/codegen/ResolvedBindings.java
+++ /dev/null
@@ -1,264 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkState;
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-
-import com.google.auto.value.AutoValue;
-import com.google.auto.value.extension.memoized.Memoized;
-import com.google.common.collect.ImmutableCollection;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableSetMultimap;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.Multimap;
-import dagger.internal.codegen.ContributionType.HasContributionType;
-import dagger.model.Key;
-import dagger.model.Scope;
-import java.util.Optional;
-import javax.lang.model.element.TypeElement;
-
-/**
- * The collection of bindings that have been resolved for a key. For valid graphs, contains exactly
- * one binding.
- *
- * <p>Separate {@link ResolvedBindings} instances should be used if a {@link
- * MembersInjectionBinding} and a {@link ProvisionBinding} for the same key exist in the same
- * component. (This will only happen if a type has an {@code @Inject} constructor and members, the
- * component has a members injection method, and the type is also requested normally.)
- */
-@AutoValue
-abstract class ResolvedBindings implements HasContributionType {
- /**
- * The binding key for which the {@link #bindings()} have been resolved.
- */
- abstract Key key();
-
- /**
- * The {@link ContributionBinding}s for {@link #key()} indexed by the component that owns the
- * binding. Each key in the multimap is a part of the same component ancestry.
- */
- abstract ImmutableSetMultimap<TypeElement, ContributionBinding> allContributionBindings();
-
- /**
- * The {@link MembersInjectionBinding}s for {@link #key()} indexed by the component that owns the
- * binding. Each key in the map is a part of the same component ancestry.
- */
- abstract ImmutableMap<TypeElement, MembersInjectionBinding> allMembersInjectionBindings();
-
- /** The multibinding declarations for {@link #key()}. */
- abstract ImmutableSet<MultibindingDeclaration> multibindingDeclarations();
-
- /** The subcomponent declarations for {@link #key()}. */
- abstract ImmutableSet<SubcomponentDeclaration> subcomponentDeclarations();
-
- /**
- * The optional binding declarations for {@link #key()}.
- */
- abstract ImmutableSet<OptionalBindingDeclaration> optionalBindingDeclarations();
-
- // Computing the hash code is an expensive operation.
- @Memoized
- @Override
- public abstract int hashCode();
-
- // Suppresses ErrorProne warning that hashCode was overridden w/o equals
- @Override
- public abstract boolean equals(Object other);
-
- /** All bindings for {@link #key()}, indexed by the component that owns the binding. */
- final ImmutableSetMultimap<TypeElement, ? extends Binding> allBindings() {
- return !allMembersInjectionBindings().isEmpty()
- ? allMembersInjectionBindings().asMultimap()
- : allContributionBindings();
- }
-
- /** All bindings for {@link #key()}, regardless of which component owns them. */
- final ImmutableCollection<? extends Binding> bindings() {
- return allBindings().values();
- }
-
- /**
- * Returns the single binding.
- *
- * @throws IllegalStateException if there is not exactly one element in {@link #bindings()}, which
- * will never happen for contributions in valid graphs
- */
- final Binding binding() {
- return getOnlyElement(bindings());
- }
-
- /**
- * {@code true} if there are no {@link #bindings()}, {@link #multibindingDeclarations()}, {@link
- * #optionalBindingDeclarations()}, or {@link #subcomponentDeclarations()}.
- */
- final boolean isEmpty() {
- return allMembersInjectionBindings().isEmpty()
- && allContributionBindings().isEmpty()
- && multibindingDeclarations().isEmpty()
- && optionalBindingDeclarations().isEmpty()
- && subcomponentDeclarations().isEmpty();
- }
-
- /** All bindings for {@link #key()} that are owned by a component. */
- ImmutableSet<? extends Binding> bindingsOwnedBy(ComponentDescriptor component) {
- return allBindings().get(component.typeElement());
- }
-
- /**
- * All contribution bindings, regardless of owning component. Empty if this is a members-injection
- * binding.
- */
- @Memoized
- ImmutableSet<ContributionBinding> contributionBindings() {
- // TODO(ronshapiro): consider optimizing ImmutableSet.copyOf(Collection) for small immutable
- // collections so that it doesn't need to call toArray(). Even though this method is memoized,
- // toArray() can take ~150ms for large components, and there are surely other places in the
- // processor that can benefit from this.
- return ImmutableSet.copyOf(allContributionBindings().values());
- }
-
- /** The component that owns {@code binding}. */
- final TypeElement owningComponent(ContributionBinding binding) {
- checkArgument(
- contributionBindings().contains(binding),
- "binding is not resolved for %s: %s",
- key(),
- binding);
- return getOnlyElement(allContributionBindings().inverse().get(binding));
- }
-
- /**
- * The members-injection binding, regardless of owning component. Absent if these are contribution
- * bindings, or if there is no members-injection binding because the type fails validation.
- */
- final Optional<MembersInjectionBinding> membersInjectionBinding() {
- return allMembersInjectionBindings().isEmpty()
- ? Optional.empty()
- : Optional.of(Iterables.getOnlyElement(allMembersInjectionBindings().values()));
- }
-
- /** Creates a {@link ResolvedBindings} for contribution bindings. */
- static ResolvedBindings forContributionBindings(
- Key key,
- Multimap<TypeElement, ContributionBinding> contributionBindings,
- Iterable<MultibindingDeclaration> multibindings,
- Iterable<SubcomponentDeclaration> subcomponentDeclarations,
- Iterable<OptionalBindingDeclaration> optionalBindingDeclarations) {
- return new AutoValue_ResolvedBindings(
- key,
- ImmutableSetMultimap.copyOf(contributionBindings),
- ImmutableMap.of(),
- ImmutableSet.copyOf(multibindings),
- ImmutableSet.copyOf(subcomponentDeclarations),
- ImmutableSet.copyOf(optionalBindingDeclarations));
- }
-
- /**
- * Creates a {@link ResolvedBindings} for members injection bindings.
- */
- static ResolvedBindings forMembersInjectionBinding(
- Key key,
- ComponentDescriptor owningComponent,
- MembersInjectionBinding ownedMembersInjectionBinding) {
- return new AutoValue_ResolvedBindings(
- key,
- ImmutableSetMultimap.of(),
- ImmutableMap.of(owningComponent.typeElement(), ownedMembersInjectionBinding),
- ImmutableSet.of(),
- ImmutableSet.of(),
- ImmutableSet.of());
- }
-
- /**
- * Creates a {@link ResolvedBindings} appropriate for when there are no bindings for the key.
- */
- static ResolvedBindings noBindings(Key key) {
- return new AutoValue_ResolvedBindings(
- key,
- ImmutableSetMultimap.of(),
- ImmutableMap.of(),
- ImmutableSet.of(),
- ImmutableSet.of(),
- ImmutableSet.of());
- }
-
- /**
- * {@code true} if this is a multibinding contribution.
- */
- boolean isMultibindingContribution() {
- return contributionBindings().size() == 1
- && contributionBinding().contributionType().isMultibinding();
- }
-
- /**
- * Returns the single contribution binding.
- *
- * @throws IllegalStateException if there is not exactly one element in
- * {@link #contributionBindings()}, which will never happen for contributions in valid graphs
- */
- ContributionBinding contributionBinding() {
- return getOnlyElement(contributionBindings());
- }
-
- /**
- * The binding type for these bindings. If there are {@link #multibindingDeclarations()} or {@link
- * #subcomponentDeclarations()} but no {@link #bindings()}, returns {@link BindingType#PROVISION}.
- *
- * @throws IllegalStateException if {@link #isEmpty()} or the binding types conflict
- */
- final BindingType bindingType() {
- checkState(!isEmpty(), "empty bindings for %s", key());
- if (allBindings().isEmpty()
- && (!multibindingDeclarations().isEmpty() || !subcomponentDeclarations().isEmpty())) {
- // Only multibinding declarations, so assume provision.
- return BindingType.PROVISION;
- }
- ImmutableSet<BindingType> bindingTypes = bindingTypes();
- checkState(bindingTypes.size() == 1, "conflicting binding types: %s", bindings());
- return getOnlyElement(bindingTypes);
- }
-
- /** The binding types for {@link #bindings()}. */
- @Memoized
- ImmutableSet<BindingType> bindingTypes() {
- return bindings().stream().map(Binding::bindingType).collect(toImmutableSet());
- }
-
- /**
- * The contribution type for these bindings.
- *
- * @throws IllegalStateException if there is not exactly one element in {@link
- * #contributionBindings()}, which will never happen for contributions in valid graphs
- */
- @Override
- public ContributionType contributionType() {
- return contributionBinding().contributionType();
- }
-
- /**
- * The scope associated with the single binding.
- *
- * @throws IllegalStateException if {@link #bindings()} does not have exactly one element
- */
- Optional<Scope> scope() {
- return binding().scope();
- }
-}
diff --git a/java/dagger/internal/codegen/Scopes.java b/java/dagger/internal/codegen/Scopes.java
deleted file mode 100644
index 252f712..0000000
--- a/java/dagger/internal/codegen/Scopes.java
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.internal.codegen.DiagnosticFormatting.stripCommonTypePrefixes;
-
-import com.google.auto.common.AnnotationMirrors;
-import com.google.common.collect.ImmutableSet;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.model.Scope;
-import dagger.producers.ProductionScope;
-import java.lang.annotation.Annotation;
-import java.util.Optional;
-import javax.inject.Singleton;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.TypeElement;
-
-/** Common names and convenience methods for {@link Scope}s. */
-final class Scopes {
- /**
- * Creates a {@link Scope} object from the {@link javax.inject.Scope}-annotated annotation type.
- */
- static Scope scope(TypeElement scopeType) {
- return Scope.scope(SimpleAnnotationMirror.of(scopeType));
- }
-
- /** Returns a representation for {@link ProductionScope @ProductionScope} scope. */
- static Scope productionScope(DaggerElements elements) {
- return scope(elements, ProductionScope.class);
- }
-
- /** Returns a representation for {@link Singleton @Singleton} scope. */
- static Scope singletonScope(DaggerElements elements) {
- return scope(elements, Singleton.class);
- }
-
- private static Scope scope(
- DaggerElements elements, Class<? extends Annotation> scopeAnnotationClass) {
- return scope(elements.getTypeElement(scopeAnnotationClass));
- }
-
- /**
- * Returns at most one associated scoped annotation from the source code element, throwing an
- * exception if there are more than one.
- */
- static Optional<Scope> uniqueScopeOf(Element element) {
- // TODO(ronshapiro): Use MoreCollectors.toOptional() once we can use guava-jre
- return Optional.ofNullable(getOnlyElement(scopesOf(element), null));
- }
-
- /**
- * Returns the readable source representation (name with @ prefix) of the scope's annotation type.
- *
- * <p>It's readable source because it has had common package prefixes removed, e.g.
- * {@code @javax.inject.Singleton} is returned as {@code @Singleton}.
- */
- static String getReadableSource(Scope scope) {
- return stripCommonTypePrefixes(scope.toString());
- }
-
- /** Returns all of the associated scopes for a source code element. */
- static ImmutableSet<Scope> scopesOf(Element element) {
- return AnnotationMirrors.getAnnotatedAnnotations(element, javax.inject.Scope.class)
- .stream()
- .map(Scope::scope)
- .collect(toImmutableSet());
- }
-}
diff --git a/java/dagger/internal/codegen/SetBindingExpression.java b/java/dagger/internal/codegen/SetBindingExpression.java
deleted file mode 100644
index 5efb85f..0000000
--- a/java/dagger/internal/codegen/SetBindingExpression.java
+++ /dev/null
@@ -1,183 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static dagger.internal.codegen.BindingRequest.bindingRequest;
-import static dagger.internal.codegen.javapoet.CodeBlocks.toParametersCodeBlock;
-import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
-import static javax.lang.model.util.ElementFilter.methodsIn;
-
-import com.google.common.collect.ImmutableSet;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import dagger.internal.SetBuilder;
-import dagger.internal.codegen.javapoet.Expression;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.DependencyRequest;
-import java.util.Collections;
-import java.util.Optional;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.TypeMirror;
-
-/** A binding expression for multibound sets. */
-final class SetBindingExpression extends MultibindingExpression {
- private final ProvisionBinding binding;
- private final BindingGraph graph;
- private final ComponentBindingExpressions componentBindingExpressions;
- private final DaggerTypes types;
- private final DaggerElements elements;
-
- SetBindingExpression(
- ResolvedBindings resolvedBindings,
- ComponentImplementation componentImplementation,
- BindingGraph graph,
- ComponentBindingExpressions componentBindingExpressions,
- DaggerTypes types,
- DaggerElements elements) {
- super(resolvedBindings, componentImplementation);
- this.binding = (ProvisionBinding) resolvedBindings.contributionBinding();
- this.graph = graph;
- this.componentBindingExpressions = componentBindingExpressions;
- this.types = types;
- this.elements = elements;
- }
-
- @Override
- protected Expression buildDependencyExpression(ClassName requestingClass) {
- Optional<CodeBlock> superMethodCall = superMethodCall();
- // TODO(ronshapiro): We should also make an ImmutableSet version of SetFactory
- boolean isImmutableSetAvailable = isImmutableSetAvailable();
- // TODO(ronshapiro, gak): Use Sets.immutableEnumSet() if it's available?
- if (isImmutableSetAvailable
- && binding.dependencies().stream().allMatch(this::isSingleValue)
- && !superMethodCall.isPresent()) {
- return Expression.create(
- immutableSetType(),
- CodeBlock.builder()
- .add("$T.", ImmutableSet.class)
- .add(maybeTypeParameter(requestingClass))
- .add(
- "of($L)",
- binding
- .dependencies()
- .stream()
- .map(dependency -> getContributionExpression(dependency, requestingClass))
- .collect(toParametersCodeBlock()))
- .build());
- }
- switch (binding.dependencies().size()) {
- case 0:
- return collectionsStaticFactoryInvocation(requestingClass, CodeBlock.of("emptySet()"));
- case 1:
- {
- DependencyRequest dependency = getOnlyElement(binding.dependencies());
- CodeBlock contributionExpression = getContributionExpression(dependency, requestingClass);
- if (isSingleValue(dependency)) {
- return collectionsStaticFactoryInvocation(
- requestingClass, CodeBlock.of("singleton($L)", contributionExpression));
- } else if (isImmutableSetAvailable) {
- return Expression.create(
- immutableSetType(),
- CodeBlock.builder()
- .add("$T.", ImmutableSet.class)
- .add(maybeTypeParameter(requestingClass))
- .add("copyOf($L)", contributionExpression)
- .build());
- }
- }
- // fall through
- default:
- CodeBlock.Builder instantiation = CodeBlock.builder();
- instantiation
- .add("$T.", isImmutableSetAvailable ? ImmutableSet.class : SetBuilder.class)
- .add(maybeTypeParameter(requestingClass));
- if (isImmutableSetBuilderWithExpectedSizeAvailable()) {
- instantiation.add("builderWithExpectedSize($L)", binding.dependencies().size());
- } else if (isImmutableSetAvailable) {
- instantiation.add("builder()");
- } else {
- instantiation.add("newSetBuilder($L)", binding.dependencies().size());
- }
- for (DependencyRequest dependency : getNewContributions(binding.dependencies())) {
- String builderMethod = isSingleValue(dependency) ? "add" : "addAll";
- instantiation.add(
- ".$L($L)", builderMethod, getContributionExpression(dependency, requestingClass));
- }
- if (superMethodCall.isPresent()) {
- instantiation.add(CodeBlock.of(".addAll($L)", superMethodCall.get()));
- }
- instantiation.add(".build()");
- return Expression.create(
- isImmutableSetAvailable ? immutableSetType() : binding.key().type(),
- instantiation.build());
- }
- }
-
- private DeclaredType immutableSetType() {
- return types.getDeclaredType(
- elements.getTypeElement(ImmutableSet.class), SetType.from(binding.key()).elementType());
- }
-
- private CodeBlock getContributionExpression(
- DependencyRequest dependency, ClassName requestingClass) {
- return componentBindingExpressions
- .getDependencyExpression(bindingRequest(dependency), requestingClass)
- .codeBlock();
- }
-
- private Expression collectionsStaticFactoryInvocation(
- ClassName requestingClass, CodeBlock methodInvocation) {
- return Expression.create(
- binding.key().type(),
- CodeBlock.builder()
- .add("$T.", Collections.class)
- .add(maybeTypeParameter(requestingClass))
- .add(methodInvocation)
- .build());
- }
-
- private CodeBlock maybeTypeParameter(ClassName requestingClass) {
- TypeMirror elementType = SetType.from(binding.key()).elementType();
- return isTypeAccessibleFrom(elementType, requestingClass.packageName())
- ? CodeBlock.of("<$T>", elementType)
- : CodeBlock.of("");
- }
-
- private boolean isSingleValue(DependencyRequest dependency) {
- return graph
- .contributionBindings()
- .get(dependency.key())
- .contributionBinding()
- .contributionType()
- .equals(ContributionType.SET);
- }
-
- private boolean isImmutableSetBuilderWithExpectedSizeAvailable() {
- if (isImmutableSetAvailable()) {
- return methodsIn(elements.getTypeElement(ImmutableSet.class).getEnclosedElements())
- .stream()
- .anyMatch(method -> method.getSimpleName().contentEquals("builderWithExpectedSize"));
- }
- return false;
- }
-
- private boolean isImmutableSetAvailable() {
- return elements.getTypeElement(ImmutableSet.class) != null;
- }
-}
diff --git a/java/dagger/internal/codegen/SetFactoryCreationExpression.java b/java/dagger/internal/codegen/SetFactoryCreationExpression.java
deleted file mode 100644
index 9712091..0000000
--- a/java/dagger/internal/codegen/SetFactoryCreationExpression.java
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static dagger.internal.codegen.SourceFiles.setFactoryClassName;
-
-import com.squareup.javapoet.CodeBlock;
-import dagger.model.DependencyRequest;
-import dagger.producers.Produced;
-import java.util.Optional;
-
-/** A factory creation expression for a multibound set. */
-final class SetFactoryCreationExpression extends MultibindingFactoryCreationExpression {
-
- private final ComponentImplementation componentImplementation;
- private final BindingGraph graph;
- private final ContributionBinding binding;
-
- SetFactoryCreationExpression(
- ContributionBinding binding,
- ComponentImplementation componentImplementation,
- ComponentBindingExpressions componentBindingExpressions,
- BindingGraph graph) {
- super(binding, componentImplementation, componentBindingExpressions);
- this.binding = checkNotNull(binding);
- this.componentImplementation = checkNotNull(componentImplementation);
- this.graph = checkNotNull(graph);
- }
-
- @Override
- public CodeBlock creationExpression() {
- CodeBlock.Builder builder = CodeBlock.builder().add("$T.", setFactoryClassName(binding));
- if (!useRawType()) {
- SetType setType = SetType.from(binding.key());
- builder.add(
- "<$T>",
- setType.elementsAreTypeOf(Produced.class)
- ? setType.unwrappedElementType(Produced.class)
- : setType.elementType());
- }
-
- int individualProviders = 0;
- int setProviders = 0;
- CodeBlock.Builder builderMethodCalls = CodeBlock.builder();
- String methodNameSuffix =
- binding.bindingType().equals(BindingType.PROVISION) ? "Provider" : "Producer";
-
- Optional<CodeBlock> superContributions = superContributions();
- if (superContributions.isPresent()) {
- // TODO(b/117833324): consider decomposing the Provider<Set<Provider>> and adding the
- // individual contributions separately from the collection contributions. Though this may
- // actually not be doable/desirable if the super provider instance is a DelegateFactory or
- // another internal type that is not SetFactory
- builderMethodCalls.add(".addCollection$N($L)", methodNameSuffix, superContributions.get());
- setProviders++;
- }
-
- for (DependencyRequest dependency : dependenciesToImplement()) {
- ContributionType contributionType =
- graph.contributionBindings().get(dependency.key()).contributionType();
- String methodNamePrefix;
- switch (contributionType) {
- case SET:
- individualProviders++;
- methodNamePrefix = "add";
- break;
- case SET_VALUES:
- setProviders++;
- methodNamePrefix = "addCollection";
- break;
- default:
- throw new AssertionError(dependency + " is not a set multibinding");
- }
-
- builderMethodCalls.add(
- ".$N$N($L)",
- methodNamePrefix,
- methodNameSuffix,
- multibindingDependencyExpression(dependency));
- }
- builder.add("builder($L, $L)", individualProviders, setProviders);
- builder.add(builderMethodCalls.build());
-
- componentImplementation.registerImplementedMultibinding(binding, bindingRequest());
-
- return builder.add(".build()").build();
- }
-}
diff --git a/java/dagger/internal/codegen/SetType.java b/java/dagger/internal/codegen/SetType.java
deleted file mode 100644
index e4fa584..0000000
--- a/java/dagger/internal/codegen/SetType.java
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkArgument;
-
-import com.google.auto.common.MoreTypes;
-import com.google.auto.value.AutoValue;
-import com.google.common.base.Equivalence;
-import dagger.model.Key;
-import java.util.Set;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.TypeMirror;
-
-/**
- * Information about a {@link Set} {@link TypeMirror}.
- */
-@AutoValue
-abstract class SetType {
- /**
- * The set type itself, wrapped using {@link MoreTypes#equivalence()}. Use
- * {@link #declaredSetType()} instead.
- */
- protected abstract Equivalence.Wrapper<DeclaredType> wrappedDeclaredSetType();
-
- /**
- * The set type itself.
- */
- DeclaredType declaredSetType() {
- return wrappedDeclaredSetType().get();
- }
-
- /**
- * {@code true} if the set type is the raw {@link Set} type.
- */
- boolean isRawType() {
- return declaredSetType().getTypeArguments().isEmpty();
- }
-
- /**
- * The element type.
- */
- TypeMirror elementType() {
- return declaredSetType().getTypeArguments().get(0);
- }
-
- /**
- * {@code true} if {@link #elementType()} is a {@code clazz}.
- */
- boolean elementsAreTypeOf(Class<?> clazz) {
- return MoreTypes.isType(elementType()) && MoreTypes.isTypeOf(clazz, elementType());
- }
-
- /**
- * {@code T} if {@link #elementType()} is a {@code WrappingClass<T>}.
- *
- * @throws IllegalStateException if {@link #elementType()} is not a {@code WrappingClass<T>}
- * @throws IllegalArgumentException if {@code wrappingClass} does not have exactly one type
- * parameter
- */
- TypeMirror unwrappedElementType(Class<?> wrappingClass) {
- checkArgument(
- wrappingClass.getTypeParameters().length == 1,
- "%s must have exactly one type parameter",
- wrappingClass);
- checkArgument(
- elementsAreTypeOf(wrappingClass),
- "expected elements to be %s, but this type is %s",
- wrappingClass,
- declaredSetType());
- return MoreTypes.asDeclared(elementType()).getTypeArguments().get(0);
- }
-
- /**
- * {@code true} if {@code type} is a {@link Set} type.
- */
- static boolean isSet(TypeMirror type) {
- return MoreTypes.isType(type) && MoreTypes.isTypeOf(Set.class, type);
- }
-
- /**
- * {@code true} if {@code key.type()} is a {@link Set} type.
- */
- static boolean isSet(Key key) {
- return isSet(key.type());
- }
-
- /**
- * Returns a {@link SetType} for {@code type}.
- *
- * @throws IllegalArgumentException if {@code type} is not a {@link Set} type
- */
- static SetType from(TypeMirror type) {
- checkArgument(isSet(type), "%s must be a Set", type);
- return new AutoValue_SetType(MoreTypes.equivalence().wrap(MoreTypes.asDeclared(type)));
- }
-
- /**
- * Returns a {@link SetType} for {@code key}'s {@link Key#type() type}.
- *
- * @throws IllegalArgumentException if {@code key.type()} is not a {@link Set} type
- */
- static SetType from(Key key) {
- return from (key.type());
- }
-}
diff --git a/java/dagger/internal/codegen/SimpleAnnotationMirror.java b/java/dagger/internal/codegen/SimpleAnnotationMirror.java
deleted file mode 100644
index 505c8ea..0000000
--- a/java/dagger/internal/codegen/SimpleAnnotationMirror.java
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static javax.lang.model.util.ElementFilter.methodsIn;
-
-import com.google.auto.common.MoreTypes;
-import com.google.common.base.Functions;
-import com.google.common.base.Joiner;
-import com.google.common.collect.FluentIterable;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Maps;
-import java.util.Map;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.AnnotationValue;
-import javax.lang.model.element.ElementKind;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.DeclaredType;
-
-/** A representation of an annotation. */
-final class SimpleAnnotationMirror implements AnnotationMirror {
- private final TypeElement annotationType;
- private final ImmutableMap<String, ? extends AnnotationValue> namedValues;
- private final ImmutableMap<ExecutableElement, ? extends AnnotationValue> elementValues;
-
- private SimpleAnnotationMirror(
- TypeElement annotationType, Map<String, ? extends AnnotationValue> namedValues) {
- checkArgument(
- annotationType.getKind().equals(ElementKind.ANNOTATION_TYPE),
- "annotationType must be an annotation: %s",
- annotationType);
- checkArgument(
- FluentIterable.from(methodsIn(annotationType.getEnclosedElements()))
- .transform(element -> element.getSimpleName().toString())
- .toSet()
- .equals(namedValues.keySet()),
- "namedValues must have values for exactly the members in %s: %s",
- annotationType,
- namedValues);
- this.annotationType = annotationType;
- this.namedValues = ImmutableMap.copyOf(namedValues);
- this.elementValues =
- Maps.toMap(
- methodsIn(annotationType.getEnclosedElements()),
- Functions.compose(
- Functions.forMap(namedValues), element -> element.getSimpleName().toString()));
- }
-
- @Override
- public DeclaredType getAnnotationType() {
- return MoreTypes.asDeclared(annotationType.asType());
- }
-
- @Override
- public Map<ExecutableElement, ? extends AnnotationValue> getElementValues() {
- return elementValues;
- }
-
- @Override
- public String toString() {
- StringBuilder builder = new StringBuilder("@").append(annotationType.getQualifiedName());
- if (!namedValues.isEmpty()) {
- builder
- .append('(')
- .append(Joiner.on(", ").withKeyValueSeparator(" = ").join(namedValues))
- .append(')');
- }
- return builder.toString();
- }
-
- /**
- * An object representing an annotation instance.
- *
- * @param annotationType must be an annotation type with no members
- */
- static AnnotationMirror of(TypeElement annotationType) {
- return of(annotationType, ImmutableMap.<String, AnnotationValue>of());
- }
-
- /**
- * An object representing an annotation instance.
- *
- * @param annotationType must be an annotation type
- * @param namedValues a value for every annotation member, including those with defaults, indexed
- * by simple name
- */
- static AnnotationMirror of(
- TypeElement annotationType, Map<String, ? extends AnnotationValue> namedValues) {
- return new SimpleAnnotationMirror(annotationType, namedValues);
- }
-}
diff --git a/java/dagger/internal/codegen/SimpleInvocationBindingExpression.java b/java/dagger/internal/codegen/SimpleInvocationBindingExpression.java
deleted file mode 100644
index 909d7ae..0000000
--- a/java/dagger/internal/codegen/SimpleInvocationBindingExpression.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/** A simple binding expression for instance requests. Does not scope. */
-abstract class SimpleInvocationBindingExpression extends BindingExpression {
- // TODO(dpb): Take ContributionBinding instead of ResolvedBindings.
- private final ResolvedBindings resolvedBindings;
-
- SimpleInvocationBindingExpression(ResolvedBindings resolvedBindings) {
- this.resolvedBindings = checkNotNull(resolvedBindings);
- }
-
- @Override
- boolean requiresMethodEncapsulation() {
- return !resolvedBindings.contributionBinding().dependencies().isEmpty();
- }
-}
diff --git a/java/dagger/internal/codegen/SimpleMethodBindingExpression.java b/java/dagger/internal/codegen/SimpleMethodBindingExpression.java
deleted file mode 100644
index 805ac7b..0000000
--- a/java/dagger/internal/codegen/SimpleMethodBindingExpression.java
+++ /dev/null
@@ -1,191 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreElements.asExecutable;
-import static com.google.common.base.Preconditions.checkArgument;
-import static dagger.internal.codegen.InjectionMethods.ProvisionMethod.requiresInjectionMethod;
-import static dagger.internal.codegen.javapoet.CodeBlocks.toParametersCodeBlock;
-import static dagger.internal.codegen.javapoet.TypeNames.rawTypeName;
-import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
-
-import com.google.auto.common.MoreTypes;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Maps;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.MethodSpec;
-import com.squareup.javapoet.TypeName;
-import dagger.internal.codegen.InjectionMethods.ProvisionMethod;
-import dagger.internal.codegen.javapoet.Expression;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.DependencyRequest;
-import java.util.Optional;
-import java.util.function.Function;
-import javax.lang.model.SourceVersion;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.TypeMirror;
-
-/**
- * A binding expression that invokes methods or constructors directly (without attempting to scope)
- * {@link dagger.model.RequestKind#INSTANCE} requests.
- */
-final class SimpleMethodBindingExpression extends SimpleInvocationBindingExpression {
- private final CompilerOptions compilerOptions;
- private final ProvisionBinding provisionBinding;
- private final ComponentBindingExpressions componentBindingExpressions;
- private final MembersInjectionMethods membersInjectionMethods;
- private final ComponentRequirementExpressions componentRequirementExpressions;
- private final DaggerTypes types;
- private final DaggerElements elements;
- private final SourceVersion sourceVersion;
-
- SimpleMethodBindingExpression(
- ResolvedBindings resolvedBindings,
- CompilerOptions compilerOptions,
- ComponentBindingExpressions componentBindingExpressions,
- MembersInjectionMethods membersInjectionMethods,
- ComponentRequirementExpressions componentRequirementExpressions,
- DaggerTypes types,
- DaggerElements elements,
- SourceVersion sourceVersion) {
- super(resolvedBindings);
- this.compilerOptions = compilerOptions;
- this.provisionBinding = (ProvisionBinding) resolvedBindings.contributionBinding();
- checkArgument(
- provisionBinding.implicitDependencies().isEmpty(),
- "framework deps are not currently supported");
- checkArgument(provisionBinding.bindingElement().isPresent());
- this.componentBindingExpressions = componentBindingExpressions;
- this.membersInjectionMethods = membersInjectionMethods;
- this.componentRequirementExpressions = componentRequirementExpressions;
- this.types = types;
- this.elements = elements;
- this.sourceVersion = sourceVersion;
- }
-
- @Override
- Expression getDependencyExpression(ClassName requestingClass) {
- ImmutableMap<DependencyRequest, Expression> arguments =
- ImmutableMap.copyOf(
- Maps.asMap(
- provisionBinding.dependencies(),
- request -> dependencyArgument(request, requestingClass)));
- Function<DependencyRequest, CodeBlock> argumentsFunction =
- request -> arguments.get(request).codeBlock();
- return requiresInjectionMethod(
- provisionBinding,
- arguments.values().asList(),
- compilerOptions,
- requestingClass.packageName(),
- types)
- ? invokeInjectionMethod(argumentsFunction, requestingClass)
- : invokeMethod(argumentsFunction, requestingClass);
- }
-
- private Expression invokeMethod(
- Function<DependencyRequest, CodeBlock> argumentsFunction,
- ClassName requestingClass) {
- // TODO(dpb): align this with the contents of InlineMethods.create
- CodeBlock arguments =
- provisionBinding.dependencies().stream()
- .map(argumentsFunction)
- .collect(toParametersCodeBlock());
- ExecutableElement method = asExecutable(provisionBinding.bindingElement().get());
- CodeBlock invocation;
- switch (method.getKind()) {
- case CONSTRUCTOR:
- invocation = CodeBlock.of("new $T($L)", constructorTypeName(requestingClass), arguments);
- break;
- case METHOD:
- CodeBlock module =
- moduleReference(requestingClass)
- .orElse(CodeBlock.of("$T", provisionBinding.bindingTypeElement().get()));
- invocation = CodeBlock.of("$L.$L($L)", module, method.getSimpleName(), arguments);
- break;
- default:
- throw new IllegalStateException();
- }
-
- return Expression.create(simpleMethodReturnType(), invocation);
- }
-
- private TypeName constructorTypeName(ClassName requestingClass) {
- DeclaredType type = MoreTypes.asDeclared(provisionBinding.key().type());
- TypeName typeName = TypeName.get(type);
- if (type.getTypeArguments()
- .stream()
- .allMatch(t -> isTypeAccessibleFrom(t, requestingClass.packageName()))) {
- return typeName;
- }
- return rawTypeName(typeName);
- }
-
- private Expression invokeInjectionMethod(
- Function<DependencyRequest, CodeBlock> argumentsFunction, ClassName requestingClass) {
- return injectMembers(
- ProvisionMethod.invoke(
- provisionBinding,
- argumentsFunction,
- requestingClass,
- moduleReference(requestingClass),
- compilerOptions,
- elements));
- }
-
- private Expression dependencyArgument(DependencyRequest dependency, ClassName requestingClass) {
- return componentBindingExpressions.getDependencyArgumentExpression(dependency, requestingClass);
- }
-
- private Expression injectMembers(CodeBlock instance) {
- if (provisionBinding.injectionSites().isEmpty()) {
- return Expression.create(simpleMethodReturnType(), instance);
- }
- if (sourceVersion.compareTo(SourceVersion.RELEASE_7) <= 0) {
- // Java 7 type inference can't figure out that instance in
- // injectParameterized(Parameterized_Factory.newParameterized()) is Parameterized<T> and not
- // Parameterized<Object>
- if (!MoreTypes.asDeclared(provisionBinding.key().type()).getTypeArguments().isEmpty()) {
- TypeName keyType = TypeName.get(provisionBinding.key().type());
- instance = CodeBlock.of("($T) ($T) $L", keyType, rawTypeName(keyType), instance);
- }
- }
- MethodSpec membersInjectionMethod = membersInjectionMethods.getOrCreate(provisionBinding.key());
- TypeMirror returnType =
- membersInjectionMethod.returnType.equals(TypeName.OBJECT)
- ? elements.getTypeElement(Object.class).asType()
- : provisionBinding.key().type();
- return Expression.create(returnType, CodeBlock.of("$N($L)", membersInjectionMethod, instance));
- }
-
- private Optional<CodeBlock> moduleReference(ClassName requestingClass) {
- return provisionBinding.requiresModuleInstance()
- ? provisionBinding
- .contributingModule()
- .map(Element::asType)
- .map(ComponentRequirement::forModule)
- .map(module -> componentRequirementExpressions.getExpression(module, requestingClass))
- : Optional.empty();
- }
-
- private TypeMirror simpleMethodReturnType() {
- return provisionBinding.contributedPrimitiveType().orElse(provisionBinding.key().type());
- }
-}
diff --git a/java/dagger/internal/codegen/SimpleTypeAnnotationValue.java b/java/dagger/internal/codegen/SimpleTypeAnnotationValue.java
deleted file mode 100644
index 7f043db..0000000
--- a/java/dagger/internal/codegen/SimpleTypeAnnotationValue.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import javax.lang.model.element.AnnotationValue;
-import javax.lang.model.element.AnnotationValueVisitor;
-import javax.lang.model.type.TypeMirror;
-
-/** An {@link AnnotationValue} that contains a {@link TypeMirror}. */
-final class SimpleTypeAnnotationValue implements AnnotationValue {
- private final TypeMirror value;
-
- SimpleTypeAnnotationValue(TypeMirror value) {
- this.value = value;
- }
-
- @Override
- public TypeMirror getValue() {
- return value;
- }
-
- @Override
- public String toString() {
- return value + ".class";
- }
-
- @Override
- public <R, P> R accept(AnnotationValueVisitor<R, P> visitor, P parameter) {
- return visitor.visitType(getValue(), parameter);
- }
-}
diff --git a/java/dagger/internal/codegen/SourceFileGenerationException.java b/java/dagger/internal/codegen/SourceFileGenerationException.java
deleted file mode 100644
index 07c1c68..0000000
--- a/java/dagger/internal/codegen/SourceFileGenerationException.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static javax.tools.Diagnostic.Kind.ERROR;
-
-import com.squareup.javapoet.ClassName;
-import java.util.Optional;
-import javax.annotation.processing.Messager;
-import javax.lang.model.element.Element;
-
-/**
- * An exception thrown to indicate that a source file could not be generated.
- *
- * <p>This exception <b>should not</b> be used to report detectable, logical errors as it may mask
- * other errors that might have been caught upon further processing. Use a {@link ValidationReport}
- * for that.
- */
-final class SourceFileGenerationException extends Exception {
- private final Element associatedElement;
-
- SourceFileGenerationException(
- Optional<ClassName> generatedClassName, Throwable cause, Element associatedElement) {
- super(createMessage(generatedClassName, cause.getMessage()), cause);
- this.associatedElement = checkNotNull(associatedElement);
- }
-
- private static String createMessage(Optional<ClassName> generatedClassName, String message) {
- return String.format("Could not generate %s: %s.",
- generatedClassName.isPresent()
- ? generatedClassName.get()
- : "unknown file",
- message);
- }
-
- void printMessageTo(Messager messager) {
- messager.printMessage(ERROR, getMessage(), associatedElement);
- }
-}
diff --git a/java/dagger/internal/codegen/SourceFileGenerator.java b/java/dagger/internal/codegen/SourceFileGenerator.java
deleted file mode 100644
index 7dddc2f..0000000
--- a/java/dagger/internal/codegen/SourceFileGenerator.java
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.GeneratedAnnotations.generatedAnnotation;
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.base.Throwables;
-import com.squareup.javapoet.AnnotationSpec;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.JavaFile;
-import com.squareup.javapoet.TypeSpec;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import java.util.Optional;
-import javax.annotation.processing.Filer;
-import javax.annotation.processing.Messager;
-import javax.lang.model.SourceVersion;
-import javax.lang.model.element.Element;
-
-/**
- * A template class that provides a framework for properly handling IO while generating source files
- * from an annotation processor. Particularly, it makes a best effort to ensure that files that
- * fail to write successfully are deleted.
- *
- * @param <T> The input type from which source is to be generated.
- */
-abstract class SourceFileGenerator<T> {
- private static final String GENERATED_COMMENTS = "https://dagger.dev";
-
- private final Filer filer;
- private final DaggerElements elements;
- private final SourceVersion sourceVersion;
-
- SourceFileGenerator(Filer filer, DaggerElements elements, SourceVersion sourceVersion) {
- this.filer = checkNotNull(filer);
- this.elements = checkNotNull(elements);
- this.sourceVersion = checkNotNull(sourceVersion);
- }
-
- SourceFileGenerator(SourceFileGenerator<T> delegate) {
- this(delegate.filer, delegate.elements, delegate.sourceVersion);
- }
-
- /**
- * Generates a source file to be compiled for {@code T}. Writes any generation exception to {@code
- * messager} and does not throw.
- */
- void generate(T input, Messager messager) {
- try {
- generate(input);
- } catch (SourceFileGenerationException e) {
- e.printMessageTo(messager);
- }
- }
-
- /** Generates a source file to be compiled for {@code T}. */
- void generate(T input) throws SourceFileGenerationException {
- ClassName generatedTypeName = nameGeneratedType(input);
- Optional<TypeSpec.Builder> type = write(generatedTypeName, input);
- if (!type.isPresent()) {
- return;
- }
- try {
- buildJavaFile(generatedTypeName, input, type.get()).writeTo(filer);
- } catch (Exception e) {
- // if the code above threw a SFGE, use that
- Throwables.propagateIfPossible(e, SourceFileGenerationException.class);
- // otherwise, throw a new one
- throw new SourceFileGenerationException(
- Optional.empty(), e, originatingElement(input));
- }
- }
-
- private JavaFile buildJavaFile(
- ClassName generatedTypeName, T input, TypeSpec.Builder typeSpecBuilder) {
- typeSpecBuilder.addOriginatingElement(originatingElement(input));
- Optional<AnnotationSpec> generatedAnnotation =
- generatedAnnotation(elements, sourceVersion)
- .map(
- annotation ->
- AnnotationSpec.builder(ClassName.get(annotation))
- .addMember("value", "$S", "dagger.internal.codegen.ComponentProcessor")
- .addMember("comments", "$S", GENERATED_COMMENTS)
- .build());
- generatedAnnotation.ifPresent(typeSpecBuilder::addAnnotation);
- JavaFile.Builder javaFileBuilder =
- JavaFile.builder(generatedTypeName.packageName(), typeSpecBuilder.build())
- .skipJavaLangImports(true);
- if (!generatedAnnotation.isPresent()) {
- javaFileBuilder.addFileComment("Generated by Dagger ($L).", GENERATED_COMMENTS);
- }
- return javaFileBuilder.build();
- }
-
- /**
- * Implementations should return the {@link ClassName} for the top-level type to be generated.
- */
- abstract ClassName nameGeneratedType(T input);
-
- /** Returns the originating element of the generating type. */
- abstract Element originatingElement(T input);
-
- /**
- * Returns a {@link TypeSpec.Builder type} to be generated for {@code T}, or {@link
- * Optional#empty()} if no file should be generated.
- */
- // TODO(ronshapiro): write() makes more sense in JavaWriter where all writers are mutable.
- // consider renaming to something like typeBuilder() which conveys the mutability of the result
- abstract Optional<TypeSpec.Builder> write(ClassName generatedTypeName, T input);
-}
diff --git a/java/dagger/internal/codegen/SourceFileGeneratorsModule.java b/java/dagger/internal/codegen/SourceFileGeneratorsModule.java
index c32262a..426afae 100644
--- a/java/dagger/internal/codegen/SourceFileGeneratorsModule.java
+++ b/java/dagger/internal/codegen/SourceFileGeneratorsModule.java
@@ -18,48 +18,49 @@
import dagger.Module;
import dagger.Provides;
-import dagger.internal.codegen.SourceFileGeneratorsModule.ComponentModule;
-import dagger.internal.codegen.SourceFileGeneratorsModule.MembersInjectionModule;
-import dagger.internal.codegen.SourceFileGeneratorsModule.ProductionModule;
-import dagger.internal.codegen.SourceFileGeneratorsModule.ProvisionModule;
+import dagger.internal.codegen.base.SourceFileGenerator;
+import dagger.internal.codegen.binding.MembersInjectionBinding;
+import dagger.internal.codegen.binding.ProductionBinding;
+import dagger.internal.codegen.binding.ProvisionBinding;
+import dagger.internal.codegen.compileroption.CompilerOptions;
+import dagger.internal.codegen.writing.FactoryGenerator;
+import dagger.internal.codegen.writing.HjarSourceFileGenerator;
+import dagger.internal.codegen.writing.MembersInjectorGenerator;
+import dagger.internal.codegen.writing.ModuleGenerator;
+import dagger.internal.codegen.writing.ModuleProxies.ModuleConstructorProxyGenerator;
+import dagger.internal.codegen.writing.ProducerFactoryGenerator;
import javax.lang.model.element.TypeElement;
-@Module(
- includes = {
- ProvisionModule.class,
- ProductionModule.class,
- MembersInjectionModule.class,
- ComponentModule.class
- })
-interface SourceFileGeneratorsModule {
- @Module
- abstract class GeneratorModule<T, G extends SourceFileGenerator<T>> {
- @Provides
- SourceFileGenerator<T> generator(G generator, CompilerOptions compilerOptions) {
- return compilerOptions.headerCompilation()
- ? HjarSourceFileGenerator.wrap(generator)
- : generator;
- }
+@Module
+abstract class SourceFileGeneratorsModule {
+
+ @Provides
+ static SourceFileGenerator<ProvisionBinding> factoryGenerator(
+ FactoryGenerator generator, CompilerOptions compilerOptions) {
+ return hjarWrapper(generator, compilerOptions);
}
- @Module
- class ProvisionModule extends GeneratorModule<ProvisionBinding, FactoryGenerator> {}
+ @Provides
+ static SourceFileGenerator<ProductionBinding> producerFactoryGenerator(
+ ProducerFactoryGenerator generator, CompilerOptions compilerOptions) {
+ return hjarWrapper(generator, compilerOptions);
+ }
- @Module
- class ProductionModule extends GeneratorModule<ProductionBinding, ProducerFactoryGenerator> {}
+ @Provides
+ static SourceFileGenerator<MembersInjectionBinding> membersInjectorGenerator(
+ MembersInjectorGenerator generator, CompilerOptions compilerOptions) {
+ return hjarWrapper(generator, compilerOptions);
+ }
- @Module
- class MembersInjectionModule
- extends GeneratorModule<MembersInjectionBinding, MembersInjectorGenerator> {}
-
- @Module
- class ComponentModule extends GeneratorModule<BindingGraph, ComponentGenerator> {}
-
- // the abstract module is not available because we're using a qualifier
@Provides
@ModuleGenerator
- static SourceFileGenerator<TypeElement> generator(
+ static SourceFileGenerator<TypeElement> moduleConstructorProxyGenerator(
ModuleConstructorProxyGenerator generator, CompilerOptions compilerOptions) {
+ return hjarWrapper(generator, compilerOptions);
+ }
+
+ private static <T> SourceFileGenerator<T> hjarWrapper(
+ SourceFileGenerator<T> generator, CompilerOptions compilerOptions) {
return compilerOptions.headerCompilation()
? HjarSourceFileGenerator.wrap(generator)
: generator;
diff --git a/java/dagger/internal/codegen/SourceFiles.java b/java/dagger/internal/codegen/SourceFiles.java
deleted file mode 100644
index fd93d0d..0000000
--- a/java/dagger/internal/codegen/SourceFiles.java
+++ /dev/null
@@ -1,348 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.CaseFormat.LOWER_CAMEL;
-import static com.google.common.base.CaseFormat.UPPER_CAMEL;
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkState;
-import static com.google.common.base.Verify.verify;
-import static dagger.internal.codegen.DaggerStreams.toImmutableList;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.internal.codegen.Optionals.optionalComparator;
-import static dagger.internal.codegen.javapoet.TypeNames.DOUBLE_CHECK;
-import static dagger.internal.codegen.javapoet.TypeNames.MAP_FACTORY;
-import static dagger.internal.codegen.javapoet.TypeNames.MAP_OF_PRODUCED_PRODUCER;
-import static dagger.internal.codegen.javapoet.TypeNames.MAP_OF_PRODUCER_PRODUCER;
-import static dagger.internal.codegen.javapoet.TypeNames.MAP_PRODUCER;
-import static dagger.internal.codegen.javapoet.TypeNames.MAP_PROVIDER_FACTORY;
-import static dagger.internal.codegen.javapoet.TypeNames.PROVIDER_OF_LAZY;
-import static dagger.internal.codegen.javapoet.TypeNames.SET_FACTORY;
-import static dagger.internal.codegen.javapoet.TypeNames.SET_OF_PRODUCED_PRODUCER;
-import static dagger.internal.codegen.javapoet.TypeNames.SET_PRODUCER;
-import static dagger.model.BindingKind.INJECTION;
-import static dagger.model.BindingKind.MULTIBOUND_MAP;
-import static dagger.model.BindingKind.MULTIBOUND_SET;
-import static java.util.Comparator.comparing;
-import static javax.lang.model.SourceVersion.isName;
-
-import com.google.auto.common.MoreElements;
-import com.google.common.base.CaseFormat;
-import com.google.common.base.Joiner;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.Maps;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.FieldSpec;
-import com.squareup.javapoet.ParameterizedTypeName;
-import com.squareup.javapoet.TypeName;
-import com.squareup.javapoet.TypeVariableName;
-import dagger.internal.SetFactory;
-import dagger.model.DependencyRequest;
-import dagger.model.Key;
-import dagger.model.RequestKind;
-import dagger.producers.Produced;
-import dagger.producers.Producer;
-import dagger.producers.internal.SetOfProducedProducer;
-import dagger.producers.internal.SetProducer;
-import java.util.Comparator;
-import java.util.Iterator;
-import java.util.List;
-import javax.inject.Provider;
-import javax.lang.model.SourceVersion;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ElementKind;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.element.TypeParameterElement;
-
-/**
- * Utilities for generating files.
- */
-class SourceFiles {
-
- private static final Joiner CLASS_FILE_NAME_JOINER = Joiner.on('_');
-
- /**
- * Sorts {@link DependencyRequest} instances in an order likely to reflect their logical
- * importance.
- */
- static final Comparator<DependencyRequest> DEPENDENCY_ORDERING =
- // put fields before parameters
- comparing(
- (DependencyRequest request) -> request.requestElement().map(Element::getKind),
- optionalComparator())
- // order by dependency kind
- .thenComparing(DependencyRequest::kind)
- // then sort by name
- .thenComparing(
- request ->
- request.requestElement().map(element -> element.getSimpleName().toString()),
- optionalComparator());
-
- /**
- * Generates names and keys for the factory class fields needed to hold the framework classes for
- * all of the dependencies of {@code binding}. It is responsible for choosing a name that
- *
- * <ul>
- * <li>represents all of the dependency requests for this key
- * <li>is <i>probably</i> associated with the type being bound
- * <li>is unique within the class
- * </ul>
- *
- * @param binding must be an unresolved binding (type parameters must match its type element's)
- */
- static ImmutableMap<Key, FrameworkField> generateBindingFieldsForDependencies(
- Binding binding) {
- checkArgument(!binding.unresolved().isPresent(), "binding must be unresolved: %s", binding);
-
- ImmutableMap.Builder<Key, FrameworkField> bindingFields = ImmutableMap.builder();
- for (Binding.DependencyAssociation dependencyAssociation : binding.dependencyAssociations()) {
- FrameworkDependency frameworkDependency = dependencyAssociation.frameworkDependency();
- bindingFields.put(
- frameworkDependency.key(),
- FrameworkField.create(
- ClassName.get(frameworkDependency.frameworkClass()),
- TypeName.get(frameworkDependency.key().type()),
- fieldNameForDependency(dependencyAssociation.dependencyRequests())));
- }
- return bindingFields.build();
- }
-
- private static String fieldNameForDependency(ImmutableSet<DependencyRequest> dependencyRequests) {
- // collect together all of the names that we would want to call the provider
- ImmutableSet<String> dependencyNames =
- dependencyRequests.stream().map(DependencyVariableNamer::name).collect(toImmutableSet());
-
- if (dependencyNames.size() == 1) {
- // if there's only one name, great! use it!
- return Iterables.getOnlyElement(dependencyNames);
- } else {
- // in the event that a field is being used for a bunch of deps with different names,
- // add all the names together with "And"s in the middle. E.g.: stringAndS
- Iterator<String> namesIterator = dependencyNames.iterator();
- String first = namesIterator.next();
- StringBuilder compositeNameBuilder = new StringBuilder(first);
- while (namesIterator.hasNext()) {
- compositeNameBuilder
- .append("And")
- .append(CaseFormat.LOWER_CAMEL.to(UPPER_CAMEL, namesIterator.next()));
- }
- return compositeNameBuilder.toString();
- }
- }
-
- static CodeBlock frameworkTypeUsageStatement(
- CodeBlock frameworkTypeMemberSelect, RequestKind dependencyKind) {
- switch (dependencyKind) {
- case LAZY:
- return CodeBlock.of("$T.lazy($L)", DOUBLE_CHECK, frameworkTypeMemberSelect);
- case INSTANCE:
- case FUTURE:
- return CodeBlock.of("$L.get()", frameworkTypeMemberSelect);
- case PROVIDER:
- case PRODUCER:
- return frameworkTypeMemberSelect;
- case PROVIDER_OF_LAZY:
- return CodeBlock.of("$T.create($L)", PROVIDER_OF_LAZY, frameworkTypeMemberSelect);
- default: // including PRODUCED
- throw new AssertionError(dependencyKind);
- }
- }
-
- /**
- * Returns a mapping of {@link DependencyRequest}s to {@link CodeBlock}s that {@linkplain
- * #frameworkTypeUsageStatement(CodeBlock, RequestKind) use them}.
- */
- static ImmutableMap<DependencyRequest, CodeBlock> frameworkFieldUsages(
- ImmutableSet<DependencyRequest> dependencies, ImmutableMap<Key, FieldSpec> fields) {
- return Maps.toMap(
- dependencies,
- dep ->
- frameworkTypeUsageStatement(CodeBlock.of("$N", fields.get(dep.key())), dep.kind()));
- }
-
- /**
- * Returns the generated factory or members injector name for a binding.
- */
- static ClassName generatedClassNameForBinding(Binding binding) {
- switch (binding.bindingType()) {
- case PROVISION:
- case PRODUCTION:
- ContributionBinding contribution = (ContributionBinding) binding;
- switch (contribution.kind()) {
- case INJECTION:
- case PROVISION:
- case PRODUCTION:
- return elementBasedClassName(
- MoreElements.asExecutable(binding.bindingElement().get()), "Factory");
-
- default:
- throw new AssertionError();
- }
-
- case MEMBERS_INJECTION:
- return membersInjectorNameForType(
- ((MembersInjectionBinding) binding).membersInjectedType());
- }
- throw new AssertionError();
- }
-
- /**
- * Calculates an appropriate {@link ClassName} for a generated class that is based on {@code
- * element}, appending {@code suffix} at the end.
- *
- * <p>This will always return a {@linkplain ClassName#topLevelClassName() top level class name},
- * even if {@code element}'s enclosing class is a nested type.
- */
- static ClassName elementBasedClassName(ExecutableElement element, String suffix) {
- ClassName enclosingClassName =
- ClassName.get(MoreElements.asType(element.getEnclosingElement()));
- String methodName =
- element.getKind().equals(ElementKind.CONSTRUCTOR)
- ? ""
- : LOWER_CAMEL.to(UPPER_CAMEL, element.getSimpleName().toString());
- return ClassName.get(
- enclosingClassName.packageName(),
- classFileName(enclosingClassName) + "_" + methodName + suffix);
- }
-
- static TypeName parameterizedGeneratedTypeNameForBinding(Binding binding) {
- ClassName className = generatedClassNameForBinding(binding);
- ImmutableList<TypeVariableName> typeParameters = bindingTypeElementTypeVariableNames(binding);
- return typeParameters.isEmpty()
- ? className
- : ParameterizedTypeName.get(className, Iterables.toArray(typeParameters, TypeName.class));
- }
-
- static ClassName membersInjectorNameForType(TypeElement typeElement) {
- return siblingClassName(typeElement, "_MembersInjector");
- }
-
- static String classFileName(ClassName className) {
- return CLASS_FILE_NAME_JOINER.join(className.simpleNames());
- }
-
- static ClassName generatedMonitoringModuleName(
- TypeElement componentElement) {
- return siblingClassName(componentElement, "_MonitoringModule");
- }
-
- // TODO(ronshapiro): when JavaPoet migration is complete, replace the duplicated code
- // which could use this.
- private static ClassName siblingClassName(TypeElement typeElement, String suffix) {
- ClassName className = ClassName.get(typeElement);
- return className.topLevelClassName().peerClass(classFileName(className) + suffix);
- }
-
- /**
- * The {@link java.util.Set} factory class name appropriate for set bindings.
- *
- * <ul>
- * <li>{@link SetFactory} for provision bindings.
- * <li>{@link SetProducer} for production bindings for {@code Set<T>}.
- * <li>{@link SetOfProducedProducer} for production bindings for {@code Set<Produced<T>>}.
- * </ul>
- */
- static ClassName setFactoryClassName(ContributionBinding binding) {
- checkArgument(binding.kind().equals(MULTIBOUND_SET));
- if (binding.bindingType().equals(BindingType.PROVISION)) {
- return SET_FACTORY;
- } else {
- SetType setType = SetType.from(binding.key());
- return setType.elementsAreTypeOf(Produced.class) ? SET_OF_PRODUCED_PRODUCER : SET_PRODUCER;
- }
- }
-
- /** The {@link java.util.Map} factory class name appropriate for map bindings. */
- static ClassName mapFactoryClassName(ContributionBinding binding) {
- checkState(binding.kind().equals(MULTIBOUND_MAP), binding.kind());
- MapType mapType = MapType.from(binding.key());
- switch (binding.bindingType()) {
- case PROVISION:
- return mapType.valuesAreTypeOf(Provider.class) ? MAP_PROVIDER_FACTORY : MAP_FACTORY;
- case PRODUCTION:
- return mapType.valuesAreFrameworkType()
- ? mapType.valuesAreTypeOf(Producer.class)
- ? MAP_OF_PRODUCER_PRODUCER
- : MAP_OF_PRODUCED_PRODUCER
- : MAP_PRODUCER;
- default:
- throw new IllegalArgumentException(binding.bindingType().toString());
- }
- }
-
- static ImmutableList<TypeVariableName> bindingTypeElementTypeVariableNames(Binding binding) {
- if (binding instanceof ContributionBinding) {
- ContributionBinding contributionBinding = (ContributionBinding) binding;
- if (!contributionBinding.kind().equals(INJECTION)
- && !contributionBinding.requiresModuleInstance()) {
- return ImmutableList.of();
- }
- }
- List<? extends TypeParameterElement> typeParameters =
- binding.bindingTypeElement().get().getTypeParameters();
- return typeParameters.stream().map(TypeVariableName::get).collect(toImmutableList());
- }
-
- /**
- * Returns a name to be used for variables of the given {@linkplain TypeElement type}. Prefer
- * semantically meaningful variable names, but if none can be derived, this will produce something
- * readable.
- */
- // TODO(gak): maybe this should be a function of TypeMirrors instead of Elements?
- static String simpleVariableName(TypeElement typeElement) {
- String candidateName = UPPER_CAMEL.to(LOWER_CAMEL, typeElement.getSimpleName().toString());
- String variableName = protectAgainstKeywords(candidateName);
- verify(isName(variableName), "'%s' was expected to be a valid variable name");
- return variableName;
- }
-
- static String protectAgainstKeywords(String candidateName) {
- switch (candidateName) {
- case "package":
- return "pkg";
- case "boolean":
- return "b";
- case "double":
- return "d";
- case "byte":
- return "b";
- case "int":
- return "i";
- case "short":
- return "s";
- case "char":
- return "c";
- case "void":
- return "v";
- case "class":
- return "clazz";
- case "float":
- return "f";
- case "long":
- return "l";
- default:
- return SourceVersion.isKeyword(candidateName) ? candidateName + '_' : candidateName;
- }
- }
-
- private SourceFiles() {}
-}
diff --git a/java/dagger/internal/codegen/SpiModule.java b/java/dagger/internal/codegen/SpiModule.java
index a8f13e1..a4f537b 100644
--- a/java/dagger/internal/codegen/SpiModule.java
+++ b/java/dagger/internal/codegen/SpiModule.java
@@ -24,6 +24,7 @@
import com.google.common.collect.ImmutableSet;
import dagger.Module;
import dagger.Provides;
+import dagger.internal.codegen.validation.BindingGraphValidator;
import dagger.spi.BindingGraphPlugin;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
@@ -40,16 +41,21 @@
@Provides
@Singleton
static ImmutableSet<BindingGraphPlugin> externalPlugins(
- @TestingPlugins Optional<ImmutableSet<BindingGraphPlugin>> testingPlugins) {
+ @TestingPlugins Optional<ImmutableSet<BindingGraphPlugin>> testingPlugins,
+ @ProcessorClassLoader ClassLoader processorClassLoader) {
return testingPlugins.orElseGet(
() ->
ImmutableSet.copyOf(
- ServiceLoader.load(
- BindingGraphPlugin.class, BindingGraphValidator.class.getClassLoader())));
+ ServiceLoader.load(BindingGraphPlugin.class, processorClassLoader)));
}
@Qualifier
@Retention(RUNTIME)
@Target({FIELD, PARAMETER, METHOD})
@interface TestingPlugins {}
+
+ @Qualifier
+ @Retention(RUNTIME)
+ @Target({PARAMETER, METHOD})
+ @interface ProcessorClassLoader {}
}
diff --git a/java/dagger/internal/codegen/SubcomponentCreatorBindingEdgeImpl.java b/java/dagger/internal/codegen/SubcomponentCreatorBindingEdgeImpl.java
deleted file mode 100644
index c97024e..0000000
--- a/java/dagger/internal/codegen/SubcomponentCreatorBindingEdgeImpl.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static dagger.internal.codegen.DaggerStreams.presentValues;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static java.util.stream.Collectors.joining;
-
-import com.google.common.collect.ImmutableSet;
-import dagger.model.BindingGraph.SubcomponentCreatorBindingEdge;
-import javax.lang.model.element.TypeElement;
-
-/** An implementation of {@link SubcomponentCreatorBindingEdge}. */
-final class SubcomponentCreatorBindingEdgeImpl implements SubcomponentCreatorBindingEdge {
-
- private final ImmutableSet<SubcomponentDeclaration> subcomponentDeclarations;
-
- SubcomponentCreatorBindingEdgeImpl(
- ImmutableSet<SubcomponentDeclaration> subcomponentDeclarations) {
- this.subcomponentDeclarations = subcomponentDeclarations;
- }
-
- @Override
- public ImmutableSet<TypeElement> declaringModules() {
- return subcomponentDeclarations.stream()
- .map(SubcomponentDeclaration::contributingModule)
- .flatMap(presentValues())
- .collect(toImmutableSet());
- }
-
- @Override
- public String toString() {
- return "subcomponent declared by "
- + (subcomponentDeclarations.size() == 1
- ? getOnlyElement(declaringModules()).getQualifiedName()
- : declaringModules().stream()
- .map(TypeElement::getQualifiedName)
- .collect(joining(", ", "{", "}")));
- }
-}
diff --git a/java/dagger/internal/codegen/SubcomponentCreatorBindingExpression.java b/java/dagger/internal/codegen/SubcomponentCreatorBindingExpression.java
deleted file mode 100644
index b415d3f..0000000
--- a/java/dagger/internal/codegen/SubcomponentCreatorBindingExpression.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import com.squareup.javapoet.ClassName;
-import dagger.internal.codegen.javapoet.Expression;
-import javax.lang.model.type.TypeMirror;
-
-/** A binding expression for a subcomponent creator that just invokes the constructor. */
-final class SubcomponentCreatorBindingExpression extends SimpleInvocationBindingExpression {
- private final TypeMirror creatorType;
- private final String creatorImplementationName;
-
- SubcomponentCreatorBindingExpression(
- ResolvedBindings resolvedBindings, String creatorImplementationName) {
- super(resolvedBindings);
- this.creatorType = resolvedBindings.key().type();
- this.creatorImplementationName = creatorImplementationName;
- }
-
- @Override
- Expression getDependencyExpression(ClassName requestingClass) {
- return Expression.create(creatorType, "new $L()", creatorImplementationName);
- }
-}
diff --git a/java/dagger/internal/codegen/SubcomponentDeclaration.java b/java/dagger/internal/codegen/SubcomponentDeclaration.java
deleted file mode 100644
index 5677857..0000000
--- a/java/dagger/internal/codegen/SubcomponentDeclaration.java
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.AnnotationMirrors.getAnnotationElementAndValue;
-import static dagger.internal.codegen.ConfigurationAnnotations.getSubcomponentCreator;
-
-import com.google.auto.value.AutoValue;
-import com.google.auto.value.extension.memoized.Memoized;
-import com.google.common.collect.ImmutableSet;
-import dagger.model.Key;
-import java.util.Optional;
-import javax.inject.Inject;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.TypeElement;
-
-/**
- * A declaration for a subcomponent that is included in a module via {@link
- * dagger.Module#subcomponents()}.
- */
-@AutoValue
-abstract class SubcomponentDeclaration extends BindingDeclaration {
- /**
- * Key for the {@link dagger.Subcomponent.Builder} or {@link
- * dagger.producers.ProductionSubcomponent.Builder} of {@link #subcomponentType()}.
- */
- @Override
- public abstract Key key();
-
- /**
- * The type element that defines the {@link dagger.Subcomponent} or {@link
- * dagger.producers.ProductionSubcomponent} for this declaration.
- */
- abstract TypeElement subcomponentType();
-
- /** The module annotation. */
- abstract ModuleAnnotation moduleAnnotation();
-
- @Memoized
- @Override
- public abstract int hashCode();
-
- @Override
- public abstract boolean equals(Object obj);
-
- static class Factory {
- private final KeyFactory keyFactory;
-
- @Inject
- Factory(KeyFactory keyFactory) {
- this.keyFactory = keyFactory;
- }
-
- ImmutableSet<SubcomponentDeclaration> forModule(TypeElement module) {
- ImmutableSet.Builder<SubcomponentDeclaration> declarations = ImmutableSet.builder();
- ModuleAnnotation moduleAnnotation = ModuleAnnotation.moduleAnnotation(module).get();
- Element subcomponentAttribute =
- getAnnotationElementAndValue(moduleAnnotation.annotation(), "subcomponents").getKey();
- for (TypeElement subcomponent : moduleAnnotation.subcomponents()) {
- declarations.add(
- new AutoValue_SubcomponentDeclaration(
- Optional.of(subcomponentAttribute),
- Optional.of(module),
- keyFactory.forSubcomponentCreator(
- getSubcomponentCreator(subcomponent).get().asType()),
- subcomponent,
- moduleAnnotation));
- }
- return declarations.build();
- }
- }
-}
diff --git a/java/dagger/internal/codegen/SubcomponentFactoryMethodValidator.java b/java/dagger/internal/codegen/SubcomponentFactoryMethodValidator.java
deleted file mode 100644
index 0c6a006..0000000
--- a/java/dagger/internal/codegen/SubcomponentFactoryMethodValidator.java
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.auto.common.MoreTypes.asDeclared;
-import static com.google.auto.common.MoreTypes.asExecutable;
-import static com.google.auto.common.MoreTypes.asTypeElements;
-import static com.google.common.collect.Sets.union;
-import static dagger.internal.codegen.DaggerStreams.instancesOf;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.internal.codegen.Util.componentCanMakeNewInstances;
-import static javax.tools.Diagnostic.Kind.ERROR;
-
-import com.google.common.base.Joiner;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Sets;
-import com.google.common.collect.Sets.SetView;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.BindingGraph;
-import dagger.model.BindingGraph.ChildFactoryMethodEdge;
-import dagger.model.BindingGraph.ComponentNode;
-import dagger.spi.BindingGraphPlugin;
-import dagger.spi.DiagnosticReporter;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Set;
-import java.util.function.Function;
-import javax.inject.Inject;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.ExecutableType;
-
-/** Reports an error if a subcomponent factory method is missing required modules. */
-final class SubcomponentFactoryMethodValidator implements BindingGraphPlugin {
-
- private final DaggerTypes types;
- private final Map<ComponentNode, Set<TypeElement>> inheritedModulesCache = new HashMap<>();
-
- @Inject
- SubcomponentFactoryMethodValidator(DaggerTypes types) {
- this.types = types;
- }
-
- @Override
- public String pluginName() {
- return "Dagger/SubcomponentFactoryMethodMissingModule";
- }
-
- @Override
- public void visitGraph(BindingGraph bindingGraph, DiagnosticReporter diagnosticReporter) {
- if (!bindingGraph.rootComponentNode().isRealComponent()
- || bindingGraph.rootComponentNode().isSubcomponent()) {
- // We don't know all the modules that might be owned by the child until we know the real root
- // component, which we don't if the root component node is really a module or a subcomponent.
- return;
- }
- bindingGraph.network().edges().stream()
- .flatMap(instancesOf(ChildFactoryMethodEdge.class))
- .forEach(
- edge -> {
- ImmutableSet<TypeElement> missingModules = findMissingModules(edge, bindingGraph);
- if (!missingModules.isEmpty()) {
- reportMissingModuleParameters(
- edge, missingModules, bindingGraph, diagnosticReporter);
- }
- });
- }
-
- private ImmutableSet<TypeElement> findMissingModules(
- ChildFactoryMethodEdge edge, BindingGraph graph) {
- ImmutableSet<TypeElement> factoryMethodParameters =
- subgraphFactoryMethodParameters(edge, graph);
- ComponentNode child = (ComponentNode) graph.network().incidentNodes(edge).target();
- SetView<TypeElement> modulesOwnedByChild = ownedModules(child, graph);
- return graph.bindings().stream()
- // bindings owned by child
- .filter(binding -> binding.componentPath().equals(child.componentPath()))
- // that require a module instance
- .filter(binding -> binding.requiresModuleInstance())
- .map(binding -> binding.contributingModule().get())
- .distinct()
- // module owned by child
- .filter(module -> modulesOwnedByChild.contains(module))
- // module not in the method parameters
- .filter(module -> !factoryMethodParameters.contains(module))
- // module doesn't have an accessible no-arg constructor
- .filter(moduleType -> !componentCanMakeNewInstances(moduleType))
- .collect(toImmutableSet());
- }
-
- private ImmutableSet<TypeElement> subgraphFactoryMethodParameters(
- ChildFactoryMethodEdge edge, BindingGraph bindingGraph) {
- ComponentNode parent = (ComponentNode) bindingGraph.network().incidentNodes(edge).source();
- DeclaredType parentType = asDeclared(parent.componentPath().currentComponent().asType());
- ExecutableType factoryMethodType =
- asExecutable(types.asMemberOf(parentType, edge.factoryMethod()));
- return asTypeElements(factoryMethodType.getParameterTypes());
- }
-
- private SetView<TypeElement> ownedModules(ComponentNode component, BindingGraph graph) {
- return Sets.difference(
- ((ComponentNodeImpl) component).componentDescriptor().moduleTypes(),
- inheritedModules(component, graph));
- }
-
- private Set<TypeElement> inheritedModules(ComponentNode component, BindingGraph graph) {
- return Util.reentrantComputeIfAbsent(
- inheritedModulesCache, component, uncachedInheritedModules(graph));
- }
-
- private Function<ComponentNode, Set<TypeElement>> uncachedInheritedModules(BindingGraph graph) {
- return componentNode ->
- componentNode.componentPath().atRoot()
- ? ImmutableSet.of()
- : graph
- .componentNode(componentNode.componentPath().parent())
- .map(parent -> union(ownedModules(parent, graph), inheritedModules(parent, graph)))
- .get();
- }
-
- private void reportMissingModuleParameters(
- ChildFactoryMethodEdge edge,
- ImmutableSet<TypeElement> missingModules,
- BindingGraph graph,
- DiagnosticReporter diagnosticReporter) {
- diagnosticReporter.reportSubcomponentFactoryMethod(
- ERROR,
- edge,
- "%s requires modules which have no visible default constructors. "
- + "Add the following modules as parameters to this method: %s",
- graph
- .network()
- .incidentNodes(edge)
- .target()
- .componentPath()
- .currentComponent()
- .getQualifiedName(),
- Joiner.on(", ").join(missingModules));
- }
-}
diff --git a/java/dagger/internal/codegen/SubcomponentNames.java b/java/dagger/internal/codegen/SubcomponentNames.java
deleted file mode 100644
index f2ffd83..0000000
--- a/java/dagger/internal/codegen/SubcomponentNames.java
+++ /dev/null
@@ -1,182 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static dagger.internal.codegen.DaggerStreams.toImmutableMap;
-import static java.lang.Character.isUpperCase;
-import static java.lang.String.format;
-
-import com.google.common.base.CharMatcher;
-import com.google.common.base.Splitter;
-import com.google.common.collect.ImmutableBiMap;
-import com.google.common.collect.ImmutableListMultimap;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Multimaps;
-import dagger.model.Key;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.LinkedHashMap;
-import java.util.Map;
-import javax.lang.model.element.Name;
-import javax.lang.model.element.TypeElement;
-
-/**
- * Holds the unique simple names for all subcomponents, keyed by their {@link ComponentDescriptor}
- * and {@link Key} of the subcomponent builder.
- */
-final class SubcomponentNames {
- private static final Splitter QUALIFIED_NAME_SPLITTER = Splitter.on('.');
-
- private final ImmutableMap<ComponentDescriptor, String> namesByDescriptor;
- private final ImmutableMap<Key, ComponentDescriptor> descriptorsByCreatorKey;
-
- SubcomponentNames(BindingGraph graph, KeyFactory keyFactory) {
- this.namesByDescriptor = namesByDescriptor(graph);
- this.descriptorsByCreatorKey = descriptorsByCreatorKey(keyFactory, namesByDescriptor.keySet());
- }
-
- /** Returns the simple component name for the given {@link ComponentDescriptor}. */
- String get(ComponentDescriptor componentDescriptor) {
- return namesByDescriptor.get(componentDescriptor);
- }
-
- /**
- * Returns the simple name for the subcomponent creator implementation with the given {@link Key}.
- */
- String getCreatorName(Key key) {
- return getCreatorName(descriptorsByCreatorKey.get(key));
- }
-
- /**
- * Returns the simple name for the subcomponent creator implementation for the given {@link
- * ComponentDescriptor}.
- */
- String getCreatorName(ComponentDescriptor componentDescriptor) {
- checkArgument(componentDescriptor.creatorDescriptor().isPresent());
- ComponentCreatorDescriptor creatorDescriptor = componentDescriptor.creatorDescriptor().get();
- return get(componentDescriptor) + creatorDescriptor.kind().typeName();
- }
-
- private static ImmutableMap<ComponentDescriptor, String> namesByDescriptor(BindingGraph graph) {
- ImmutableListMultimap<String, ComponentDescriptor> componentDescriptorsBySimpleName =
- Multimaps.index(
- graph.componentDescriptors(),
- componentDescriptor -> componentDescriptor.typeElement().getSimpleName().toString());
- ImmutableMap<ComponentDescriptor, Namer> componentNamers =
- qualifiedNames(graph.componentDescriptors());
- Map<ComponentDescriptor, String> subcomponentImplSimpleNames = new LinkedHashMap<>();
- componentDescriptorsBySimpleName
- .asMap()
- .values()
- .forEach(
- components ->
- subcomponentImplSimpleNames.putAll(
- disambiguateConflictingSimpleNames(components, componentNamers)));
- subcomponentImplSimpleNames.remove(graph.componentDescriptor());
- return ImmutableMap.copyOf(subcomponentImplSimpleNames);
- }
-
- private static ImmutableMap<Key, ComponentDescriptor> descriptorsByCreatorKey(
- KeyFactory keyFactory, ImmutableSet<ComponentDescriptor> subcomponents) {
- return subcomponents.stream()
- .filter(subcomponent -> subcomponent.creatorDescriptor().isPresent())
- .collect(
- toImmutableMap(
- subcomponent ->
- keyFactory.forSubcomponentCreator(
- subcomponent.creatorDescriptor().get().typeElement().asType()),
- subcomponent -> subcomponent));
- }
-
- private static ImmutableBiMap<ComponentDescriptor, String> disambiguateConflictingSimpleNames(
- Collection<ComponentDescriptor> components,
- ImmutableMap<ComponentDescriptor, Namer> componentNamers) {
- Map<String, ComponentDescriptor> generatedSimpleNames = new LinkedHashMap<>();
-
- // Let's see if we can get away with using simpleName() everywhere.
- for (ComponentDescriptor component : components) {
- Namer namer = componentNamers.get(component);
- if (generatedSimpleNames.containsKey(namer.simpleName())) {
- break;
- }
- generatedSimpleNames.put(namer.simpleName(), component);
- }
-
- if (generatedSimpleNames.size() != components.size()) {
- // Simple approach didn't work out, let's use more complicated names.
- // We keep them small to fix https://github.com/google/dagger/issues/421.
- generatedSimpleNames.clear();
- UniqueNameSet nameSet = new UniqueNameSet();
- for (ComponentDescriptor component : components) {
- Namer namer = componentNamers.get(component);
- String simpleName = namer.simpleName();
- String basePrefix = namer.uniquingPrefix();
- generatedSimpleNames.put(
- format("%s_%s", nameSet.getUniqueName(basePrefix), simpleName), component);
- }
- }
- return ImmutableBiMap.copyOf(generatedSimpleNames).inverse();
- }
-
- private static ImmutableMap<ComponentDescriptor, Namer> qualifiedNames(
- Iterable<ComponentDescriptor> componentDescriptors) {
- ImmutableMap.Builder<ComponentDescriptor, Namer> builder = ImmutableMap.builder();
- for (ComponentDescriptor component : componentDescriptors) {
- builder.put(component, new Namer(component.typeElement()));
- }
- return builder.build();
- }
-
- private static final class Namer {
- final TypeElement typeElement;
-
- Namer(TypeElement typeElement) {
- this.typeElement = typeElement;
- }
-
- String simpleName() {
- return typeElement.getSimpleName().toString();
- }
-
- /** Returns a prefix that could make {@link #simpleName()} more unique. */
- String uniquingPrefix() {
- String containerName = typeElement.getEnclosingElement().getSimpleName().toString();
-
- // If parent element looks like a class, use its initials as a prefix.
- if (!containerName.isEmpty() && isUpperCase(containerName.charAt(0))) {
- return CharMatcher.javaLowerCase().removeFrom(containerName);
- }
-
- // Not in a normally named class. Prefix with the initials of the elements leading here.
- Name qualifiedName = typeElement.getQualifiedName();
- Iterator<String> pieces = QUALIFIED_NAME_SPLITTER.split(qualifiedName).iterator();
- StringBuilder b = new StringBuilder();
-
- while (pieces.hasNext()) {
- String next = pieces.next();
- if (pieces.hasNext()) {
- b.append(next.charAt(0));
- }
- }
-
- // Note that a top level class in the root package will be prefixed "$_".
- return b.length() > 0 ? b.toString() : "$";
- }
- }
-}
diff --git a/java/dagger/internal/codegen/SwitchingProviders.java b/java/dagger/internal/codegen/SwitchingProviders.java
deleted file mode 100644
index 29633d9..0000000
--- a/java/dagger/internal/codegen/SwitchingProviders.java
+++ /dev/null
@@ -1,227 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.collect.Iterables.getLast;
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static com.squareup.javapoet.MethodSpec.methodBuilder;
-import static com.squareup.javapoet.TypeSpec.classBuilder;
-import static dagger.internal.codegen.DaggerStreams.toImmutableList;
-import static dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression.UNCHECKED;
-import static dagger.internal.codegen.javapoet.AnnotationSpecs.suppressWarnings;
-import static dagger.internal.codegen.javapoet.TypeNames.providerOf;
-import static javax.lang.model.element.Modifier.PRIVATE;
-import static javax.lang.model.element.Modifier.PUBLIC;
-
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Lists;
-import com.squareup.javapoet.ClassName;
-import com.squareup.javapoet.CodeBlock;
-import com.squareup.javapoet.MethodSpec;
-import com.squareup.javapoet.TypeSpec;
-import com.squareup.javapoet.TypeVariableName;
-import dagger.internal.codegen.javapoet.CodeBlocks;
-import dagger.internal.codegen.javapoet.Expression;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.model.Key;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.Map;
-import java.util.TreeMap;
-
-/**
- * Keeps track of all provider expression requests for a component.
- *
- * <p>The provider expression request will be satisfied by a single generated {@code Provider} inner
- * class that can provide instances for all types by switching on an id.
- */
-// TODO(ronshapiro): either merge this with InnerSwitchingProviders, or repurpose this for
-// SwitchingProducers
-abstract class SwitchingProviders {
- /**
- * Defines the {@linkplain Expression expressions} for a switch case in a {@code SwitchProvider}
- * for a particular binding.
- */
- // TODO(user): Consider handling SwitchingProviders with dependency arguments in this class,
- // then we wouldn't need the getProviderExpression method.
- // TODO(user): Consider making this an abstract class with equals/hashCode defined by the key
- // and then using this class directly in Map types instead of Key.
- interface SwitchCase {
- /** Returns the {@link Key} for this switch case. */
- Key key();
-
- /** Returns the {@link Expression} that returns the provided instance for this case. */
- Expression getReturnExpression(ClassName switchingProviderClass);
-
- /**
- * Returns the {@link Expression} that returns the {@code SwitchProvider} instance for this
- * case.
- */
- Expression getProviderExpression(ClassName switchingProviderClass, int switchId);
- }
-
- /**
- * Each switch size is fixed at 100 cases each and put in its own method. This is to limit the
- * size of the methods so that we don't reach the "huge" method size limit for Android that will
- * prevent it from being AOT compiled in some versions of Android (b/77652521). This generally
- * starts to happen around 1500 cases, but we are choosing 100 to be safe.
- */
- // TODO(user): Include a proguard_spec in the Dagger library to prevent inlining these methods?
- // TODO(ronshapiro): Consider making this configurable via a flag.
- private static final int MAX_CASES_PER_SWITCH = 100;
-
- private static final long MAX_CASES_PER_CLASS = MAX_CASES_PER_SWITCH * MAX_CASES_PER_SWITCH;
- private static final TypeVariableName T = TypeVariableName.get("T");
-
- /**
- * Maps a {@link Key} to an instance of a {@link SwitchingProviderBuilder}. Each group of {@code
- * MAX_CASES_PER_CLASS} keys will share the same instance.
- */
- private final Map<Key, SwitchingProviderBuilder> switchingProviderBuilders =
- new LinkedHashMap<>();
-
- private final ComponentImplementation componentImplementation;
- private final ClassName owningComponent;
- private final DaggerTypes types;
- private final UniqueNameSet switchingProviderNames = new UniqueNameSet();
-
- SwitchingProviders(ComponentImplementation componentImplementation, DaggerTypes types) {
- this.componentImplementation = checkNotNull(componentImplementation);
- this.types = checkNotNull(types);
- this.owningComponent = checkNotNull(componentImplementation).name();
- }
-
- /** Returns the {@link TypeSpec} for a {@code SwitchingProvider} based on the given builder. */
- protected abstract TypeSpec createSwitchingProviderType(TypeSpec.Builder builder);
-
- /**
- * Returns the {@link Expression} that returns the {@code SwitchProvider} instance for the case.
- */
- protected final Expression getProviderExpression(SwitchCase switchCase) {
- return switchingProviderBuilders
- .computeIfAbsent(switchCase.key(), key -> getSwitchingProviderBuilder())
- .getProviderExpression(switchCase);
- }
-
- private SwitchingProviderBuilder getSwitchingProviderBuilder() {
- if (switchingProviderBuilders.size() % MAX_CASES_PER_CLASS == 0) {
- String name = switchingProviderNames.getUniqueName("SwitchingProvider");
- SwitchingProviderBuilder switchingProviderBuilder =
- new SwitchingProviderBuilder(owningComponent.nestedClass(name));
- componentImplementation.addSwitchingProvider(switchingProviderBuilder::build);
- return switchingProviderBuilder;
- }
- return getLast(switchingProviderBuilders.values());
- }
-
- // TODO(user): Consider just merging this class with SwitchingProviders.
- private final class SwitchingProviderBuilder {
- // Keep the switch cases ordered by switch id. The switch Ids are assigned in pre-order
- // traversal, but the switch cases are assigned in post-order traversal of the binding graph.
- private final Map<Integer, CodeBlock> switchCases = new TreeMap<>();
- private final Map<Key, Integer> switchIds = new HashMap<>();
- private final ClassName switchingProviderType;
-
- SwitchingProviderBuilder(ClassName switchingProviderType) {
- this.switchingProviderType = checkNotNull(switchingProviderType);
- }
-
- Expression getProviderExpression(SwitchCase switchCase) {
- Key key = switchCase.key();
- if (!switchIds.containsKey(key)) {
- int switchId = switchIds.size();
- switchIds.put(key, switchId);
- switchCases.put(switchId, createSwitchCaseCodeBlock(switchCase));
- }
- return switchCase.getProviderExpression(switchingProviderType, switchIds.get(key));
- }
-
- private CodeBlock createSwitchCaseCodeBlock(SwitchCase switchCase) {
- CodeBlock instanceCodeBlock =
- switchCase.getReturnExpression(switchingProviderType).box(types).codeBlock();
-
- return CodeBlock.builder()
- // TODO(user): Is there something else more useful than the key?
- .add("case $L: // $L \n", switchIds.get(switchCase.key()), switchCase.key())
- .addStatement("return ($T) $L", T, instanceCodeBlock)
- .build();
- }
-
- private TypeSpec build() {
- return createSwitchingProviderType(
- classBuilder(switchingProviderType)
- .addTypeVariable(T)
- .addSuperinterface(providerOf(T))
- .addMethods(getMethods()));
- }
-
- private ImmutableList<MethodSpec> getMethods() {
- ImmutableList<CodeBlock> switchCodeBlockPartitions = switchCodeBlockPartitions();
- if (switchCodeBlockPartitions.size() == 1) {
- // There are less than MAX_CASES_PER_SWITCH cases, so no need for extra get methods.
- return ImmutableList.of(
- methodBuilder("get")
- .addModifiers(PUBLIC)
- .addAnnotation(suppressWarnings(UNCHECKED))
- .addAnnotation(Override.class)
- .returns(T)
- .addCode(getOnlyElement(switchCodeBlockPartitions))
- .build());
- }
-
- // This is the main public "get" method that will route to private getter methods.
- MethodSpec.Builder routerMethod =
- methodBuilder("get")
- .addModifiers(PUBLIC)
- .addAnnotation(Override.class)
- .returns(T)
- .beginControlFlow("switch (id / $L)", MAX_CASES_PER_SWITCH);
-
- ImmutableList.Builder<MethodSpec> getMethods = ImmutableList.builder();
- for (int i = 0; i < switchCodeBlockPartitions.size(); i++) {
- MethodSpec method =
- methodBuilder("get" + i)
- .addModifiers(PRIVATE)
- .addAnnotation(suppressWarnings(UNCHECKED))
- .returns(T)
- .addCode(switchCodeBlockPartitions.get(i))
- .build();
- getMethods.add(method);
- routerMethod.addStatement("case $L: return $N()", i, method);
- }
-
- routerMethod.addStatement("default: throw new $T(id)", AssertionError.class).endControlFlow();
-
- return getMethods.add(routerMethod.build()).build();
- }
-
- private ImmutableList<CodeBlock> switchCodeBlockPartitions() {
- return Lists.partition(ImmutableList.copyOf(switchCases.values()), MAX_CASES_PER_SWITCH)
- .stream()
- .map(
- partitionCases ->
- CodeBlock.builder()
- .beginControlFlow("switch (id)")
- .add(CodeBlocks.concat(partitionCases))
- .addStatement("default: throw new $T(id)", AssertionError.class)
- .endControlFlow()
- .build())
- .collect(toImmutableList());
- }
- }
-}
diff --git a/java/dagger/internal/codegen/SystemComponentsModule.java b/java/dagger/internal/codegen/SystemComponentsModule.java
deleted file mode 100644
index 3f59b24..0000000
--- a/java/dagger/internal/codegen/SystemComponentsModule.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import com.google.common.base.Ticker;
-import dagger.Module;
-import dagger.Provides;
-
-/** Module to provide system-level dependencies (such as time-related objects). */
-@Module
-interface SystemComponentsModule {
-
- @Provides
- static Ticker ticker() {
- return Ticker.systemTicker();
- }
-}
diff --git a/java/dagger/internal/codegen/TopLevel.java b/java/dagger/internal/codegen/TopLevel.java
deleted file mode 100644
index 4f456f2..0000000
--- a/java/dagger/internal/codegen/TopLevel.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static java.lang.annotation.RetentionPolicy.RUNTIME;
-
-import java.lang.annotation.Retention;
-import javax.inject.Qualifier;
-
-/**
- * A {@link Qualifier} for bindings that are associated with the top level component implementation.
- */
-@Retention(RUNTIME)
-@Qualifier
-@interface TopLevel {}
diff --git a/java/dagger/internal/codegen/TopLevelImplementationComponent.java b/java/dagger/internal/codegen/TopLevelImplementationComponent.java
deleted file mode 100644
index 306c05d..0000000
--- a/java/dagger/internal/codegen/TopLevelImplementationComponent.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import dagger.BindsInstance;
-import dagger.Module;
-import dagger.Subcomponent;
-
-/**
- * A shared subcomponent for a top-level {@link ComponentImplementation} and any nested child
- * implementations.
- */
-@PerGeneratedFile
-@Subcomponent
-interface TopLevelImplementationComponent {
- CurrentImplementationSubcomponent.Builder currentImplementationSubcomponentBuilder();
-
- @Subcomponent.Builder
- interface Builder {
- @BindsInstance
- Builder topLevelComponent(@TopLevel ComponentImplementation topLevelImplementation);
- TopLevelImplementationComponent build();
- }
-
- @Module(subcomponents = TopLevelImplementationComponent.class)
- interface InstallationModule {}
-}
diff --git a/java/dagger/internal/codegen/TypeCheckingProcessingStep.java b/java/dagger/internal/codegen/TypeCheckingProcessingStep.java
deleted file mode 100644
index 00769b2..0000000
--- a/java/dagger/internal/codegen/TypeCheckingProcessingStep.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.auto.common.BasicAnnotationProcessor.ProcessingStep;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableSetMultimap;
-import com.google.common.collect.SetMultimap;
-import java.lang.annotation.Annotation;
-import java.util.function.Function;
-import javax.lang.model.element.Element;
-
-/**
- * A {@link ProcessingStep} that processes one element at a time and defers any for which {@link
- * TypeNotPresentException} is thrown.
- */
-// TODO(dpb): Contribute to auto-common.
-abstract class TypeCheckingProcessingStep<E extends Element> implements ProcessingStep {
- private final Function<Element, E> downcaster;
-
- TypeCheckingProcessingStep(Function<Element, E> downcaster) {
- this.downcaster = checkNotNull(downcaster);
- }
-
- @Override
- public ImmutableSet<Element> process(
- SetMultimap<Class<? extends Annotation>, Element> elementsByAnnotation) {
- ImmutableSet.Builder<Element> deferredElements = ImmutableSet.builder();
- ImmutableSetMultimap.copyOf(elementsByAnnotation)
- .inverse()
- .asMap()
- .forEach(
- (element, annotations) -> {
- try {
- process(downcaster.apply(element), ImmutableSet.copyOf(annotations));
- } catch (TypeNotPresentException e) {
- deferredElements.add(element);
- }
- });
- return deferredElements.build();
- }
-
- /**
- * Processes one element. If this method throws {@link TypeNotPresentException}, the element will
- * be deferred until the next round of processing.
- *
- * @param annotations the subset of {@link ProcessingStep#annotations()} that annotate {@code
- * element}
- */
- protected abstract void process(E element, ImmutableSet<Class<? extends Annotation>> annotations);
-}
diff --git a/java/dagger/internal/codegen/TypeProtoConverter.java b/java/dagger/internal/codegen/TypeProtoConverter.java
deleted file mode 100644
index c703bd8..0000000
--- a/java/dagger/internal/codegen/TypeProtoConverter.java
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- * Copyright (C) 2019 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static javax.lang.model.util.ElementFilter.typesIn;
-
-import com.google.auto.common.MoreTypes;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.internal.codegen.serialization.TypeProto;
-import dagger.internal.codegen.serialization.TypeProto.PrimitiveKind;
-import javax.inject.Inject;
-import javax.lang.model.element.TypeElement;
-import javax.lang.model.type.DeclaredType;
-import javax.lang.model.type.TypeKind;
-import javax.lang.model.type.TypeMirror;
-import javax.lang.model.type.WildcardType;
-
-/** Converts {@link TypeMirror}s to {@link TypeProto}s and vice-versa. */
-final class TypeProtoConverter {
- // TODO(ronshapiro): if DaggerTypes and DaggerElements become public, move this file to
- // dagger.internal.codegen.serialization
- private final DaggerTypes types;
- private final DaggerElements elements;
-
- @Inject
- TypeProtoConverter(DaggerTypes types, DaggerElements elements) {
- this.types = types;
- this.elements = elements;
- }
-
- /** Translates a {@link TypeMirror} to a proto representation. */
- static TypeProto toProto(TypeMirror type) {
- TypeProto.Builder builder = TypeProto.newBuilder();
- int arrayDimensions = 0;
- while (type.getKind().equals(TypeKind.ARRAY)) {
- type = MoreTypes.asArray(type).getComponentType();
- arrayDimensions++;
- }
- builder.setArrayDimensions(arrayDimensions);
- if (type.getKind().isPrimitive()) {
- builder.setPrimitiveKind(PrimitiveKind.valueOf(type.getKind().name()));
- } else if (type.getKind().equals(TypeKind.WILDCARD)) {
- WildcardType wildcardType = MoreTypes.asWildcard(type);
- TypeProto.Wildcard.Builder wildcardBuilder = TypeProto.Wildcard.newBuilder();
- if (wildcardType.getExtendsBound() != null) {
- wildcardBuilder.setExtendsBound(toProto(wildcardType.getExtendsBound()));
- } else if (wildcardType.getSuperBound() != null) {
- wildcardBuilder.setSuperBound(toProto(wildcardType.getSuperBound()));
- }
- builder.setWildcard(wildcardBuilder);
- } else {
- TypeElement typeElement = MoreTypes.asTypeElement(type);
- DeclaredType declaredType = MoreTypes.asDeclared(type);
- TypeMirror enclosingType = declaredType.getEnclosingType();
- if (enclosingType.getKind().equals(TypeKind.NONE)) {
- builder.setQualifiedName(typeElement.getQualifiedName().toString());
- } else {
- builder
- .setEnclosingType(toProto(enclosingType))
- .setSimpleName(typeElement.getSimpleName().toString());
- }
- declaredType.getTypeArguments().stream()
- .map(TypeProtoConverter::toProto)
- .forEachOrdered(builder::addTypeArguments);
- }
- return builder.build();
- }
-
- /** Creates an {@link TypeMirror} from its proto representation. */
- TypeMirror fromProto(TypeProto type) {
- if (type.hasWildcard()) {
- return wildcardType(type.getWildcard());
- }
-
- TypeMirror[] typeArguments =
- type.getTypeArgumentsList().stream().map(this::fromProto).toArray(TypeMirror[]::new);
- TypeMirror typeMirror;
- if (!type.getPrimitiveKind().equals(PrimitiveKind.UNKNOWN)) {
- typeMirror = types.getPrimitiveType(TypeKind.valueOf(type.getPrimitiveKind().name()));
- } else if (type.hasEnclosingType()) {
- DeclaredType enclosingType = MoreTypes.asDeclared(fromProto(type.getEnclosingType()));
- TypeElement typeElement =
- typesIn(enclosingType.asElement().getEnclosedElements()).stream()
- .filter(inner -> inner.getSimpleName().contentEquals(type.getSimpleName()))
- .findFirst()
- .get();
- typeMirror = types.getDeclaredType(enclosingType, typeElement, typeArguments);
- } else {
- typeMirror =
- types.getDeclaredType(elements.getTypeElement(type.getQualifiedName()), typeArguments);
- }
- for (int i = 0; i < type.getArrayDimensions(); i++) {
- typeMirror = types.getArrayType(typeMirror);
- }
- return typeMirror;
- }
-
- private TypeMirror wildcardType(TypeProto.Wildcard wildcard) {
- if (wildcard.hasExtendsBound()) {
- return types.getWildcardType(fromProto(wildcard.getExtendsBound()), null);
- } else if (wildcard.hasSuperBound()) {
- return types.getWildcardType(null, fromProto(wildcard.getSuperBound()));
- } else {
- return types.getWildcardType(null, null);
- }
- }
-}
diff --git a/java/dagger/internal/codegen/UniqueNameSet.java b/java/dagger/internal/codegen/UniqueNameSet.java
deleted file mode 100644
index 11c48b3..0000000
--- a/java/dagger/internal/codegen/UniqueNameSet.java
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import java.util.HashSet;
-import java.util.Set;
-
-/** A collector for names to be used in the same namespace that should not conflict. */
-final class UniqueNameSet {
- private final Set<String> uniqueNames = new HashSet<>();
-
- /**
- * Generates a unique name using {@code base}. If {@code base} has not yet been added, it will be
- * returned as-is. If your {@code base} is healthy, this will always return {@code base}.
- */
- String getUniqueName(CharSequence base) {
- String name = base.toString();
- for (int differentiator = 2; !uniqueNames.add(name); differentiator++) {
- name = base.toString() + differentiator;
- }
- return name;
- }
-
- /**
- * Adds {@code name} without any modification to the name set. Has no effect if {@code name} is
- * already present in the set.
- */
- void claim(CharSequence name) {
- uniqueNames.add(name.toString());
- }
-}
diff --git a/java/dagger/internal/codegen/UnwrappedMapKeyGenerator.java b/java/dagger/internal/codegen/UnwrappedMapKeyGenerator.java
deleted file mode 100644
index 2b7b02c..0000000
--- a/java/dagger/internal/codegen/UnwrappedMapKeyGenerator.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright (C) 2016 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import dagger.MapKey;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import java.util.Set;
-import javax.annotation.processing.Filer;
-import javax.inject.Inject;
-import javax.lang.model.SourceVersion;
-import javax.lang.model.element.TypeElement;
-
-/**
- * Generates classes that create annotation instances for an unwrapped {@link MapKey} annotation
- * type whose nested value is an annotation. The generated class will have a private empty
- * constructor and a static method that creates each annotation type that is nested in the top-level
- * annotation type.
- *
- * <p>So for an example {@link MapKey} annotation:
- *
- * <pre>
- * {@literal @MapKey}(unwrapValue = true)
- * {@literal @interface} Foo {
- * Bar bar();
- * }
- *
- * {@literal @interface} Bar {
- * {@literal Class<?> baz();}
- * }
- * </pre>
- *
- * the generated class will look like:
- *
- * <pre>
- * public final class FooCreator {
- * private FooCreator() {}
- *
- * public static Bar createBar({@literal Class<?> baz}) { … }
- * }
- * </pre>
- */
-final class UnwrappedMapKeyGenerator extends AnnotationCreatorGenerator {
-
- @Inject
- UnwrappedMapKeyGenerator(Filer filer, DaggerElements elements, SourceVersion sourceVersion) {
- super(filer, elements, sourceVersion);
- }
-
- @Override
- protected Set<TypeElement> annotationsToCreate(TypeElement annotationElement) {
- Set<TypeElement> nestedAnnotationElements = super.annotationsToCreate(annotationElement);
- nestedAnnotationElements.remove(annotationElement);
- return nestedAnnotationElements;
- }
-}
diff --git a/java/dagger/internal/codegen/Util.java b/java/dagger/internal/codegen/Util.java
deleted file mode 100644
index 1869b7c..0000000
--- a/java/dagger/internal/codegen/Util.java
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * Copyright (C) 2013 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static javax.lang.model.element.ElementKind.CONSTRUCTOR;
-import static javax.lang.model.element.Modifier.ABSTRACT;
-import static javax.lang.model.element.Modifier.PRIVATE;
-import static javax.lang.model.element.Modifier.STATIC;
-
-import java.util.Map;
-import java.util.function.Function;
-import javax.lang.model.element.Element;
-import javax.lang.model.element.ExecutableElement;
-import javax.lang.model.element.TypeElement;
-
-/**
- * Utilities for handling types in annotation processors
- */
-final class Util {
- /**
- * Returns true if and only if a component can instantiate new instances (typically of a module)
- * rather than requiring that they be passed.
- */
- static boolean componentCanMakeNewInstances(TypeElement typeElement) {
- switch (typeElement.getKind()) {
- case CLASS:
- break;
- case ENUM:
- case ANNOTATION_TYPE:
- case INTERFACE:
- return false;
- default:
- throw new AssertionError("TypeElement cannot have kind: " + typeElement.getKind());
- }
-
- if (typeElement.getModifiers().contains(ABSTRACT)) {
- return false;
- }
-
- if (requiresEnclosingInstance(typeElement)) {
- return false;
- }
-
- for (Element enclosed : typeElement.getEnclosedElements()) {
- if (enclosed.getKind().equals(CONSTRUCTOR)
- && ((ExecutableElement) enclosed).getParameters().isEmpty()
- && !enclosed.getModifiers().contains(PRIVATE)) {
- return true;
- }
- }
-
- // TODO(gak): still need checks for visibility
-
- return false;
- }
-
- private static boolean requiresEnclosingInstance(TypeElement typeElement) {
- switch (typeElement.getNestingKind()) {
- case TOP_LEVEL:
- return false;
- case MEMBER:
- return !typeElement.getModifiers().contains(STATIC);
- case ANONYMOUS:
- case LOCAL:
- return true;
- }
- throw new AssertionError(
- "TypeElement cannot have nesting kind: " + typeElement.getNestingKind());
- }
-
- /**
- * A version of {@link Map#computeIfAbsent(Object, Function)} that allows {@code mappingFunction}
- * to update {@code map}.
- */
- static <K, V> V reentrantComputeIfAbsent(
- Map<K, V> map, K key, Function<? super K, ? extends V> mappingFunction) {
- V value = map.get(key);
- if (value == null) {
- value = mappingFunction.apply(key);
- if (value != null) {
- map.put(key, value);
- }
- }
- return value;
- }
-
- private Util() {}
-}
diff --git a/java/dagger/internal/codegen/Validation.java b/java/dagger/internal/codegen/Validation.java
deleted file mode 100644
index f6a4b3f..0000000
--- a/java/dagger/internal/codegen/Validation.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import javax.inject.Qualifier;
-
-/**
- * Qualifier annotation for the {@link dagger.spi.BindingGraphPlugin}s that are used to implement
- * core Dagger validation.
- */
-@Documented
-@Retention(RetentionPolicy.RUNTIME)
-@Qualifier
-@interface Validation {}
diff --git a/java/dagger/internal/codegen/ValidationReport.java b/java/dagger/internal/codegen/ValidationReport.java
deleted file mode 100644
index d7c3252..0000000
--- a/java/dagger/internal/codegen/ValidationReport.java
+++ /dev/null
@@ -1,288 +0,0 @@
-/*
- * Copyright (C) 2014 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.internal.codegen.ElementFormatter.elementToString;
-import static javax.tools.Diagnostic.Kind.ERROR;
-import static javax.tools.Diagnostic.Kind.NOTE;
-import static javax.tools.Diagnostic.Kind.WARNING;
-
-import com.google.auto.value.AutoValue;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.graph.Traverser;
-import com.google.errorprone.annotations.CanIgnoreReturnValue;
-import com.google.errorprone.annotations.CheckReturnValue;
-import java.util.Optional;
-import javax.annotation.processing.Messager;
-import javax.lang.model.element.AnnotationMirror;
-import javax.lang.model.element.AnnotationValue;
-import javax.lang.model.element.Element;
-import javax.tools.Diagnostic;
-import javax.tools.Diagnostic.Kind;
-
-/** A collection of issues to report for source code. */
-@AutoValue
-abstract class ValidationReport<T extends Element> {
-
- /**
- * The subject of the report. Should be an element within a compilation unit being processed by
- * this compilation task.
- */
- abstract T subject();
-
- /** The items to report for the {@linkplain #subject() subject}. */
- abstract ImmutableSet<Item> items();
-
- /** Returns the {@link #items()} from this report and all transitive subreports. */
- ImmutableSet<Item> allItems() {
- return allReports()
- .stream()
- .flatMap(report -> report.items().stream())
- .collect(toImmutableSet());
- }
-
- /** Other reports associated with this one. */
- abstract ImmutableSet<ValidationReport<?>> subreports();
-
- private static final Traverser<ValidationReport<?>> SUBREPORTS =
- Traverser.forTree(ValidationReport::subreports);
-
- /** Returns this report and all transitive subreports. */
- ImmutableSet<ValidationReport<?>> allReports() {
- return ImmutableSet.copyOf(SUBREPORTS.depthFirstPreOrder(this));
- }
-
- /**
- * {@code true} if {@link #isClean()} should return {@code false} even if there are no error items
- * in this report.
- */
- abstract boolean markedDirty();
-
- /**
- * Returns {@code true} if there are no errors in this report or any subreports and {@link
- * #markedDirty()} is {@code false}.
- */
- boolean isClean() {
- if (markedDirty()) {
- return false;
- }
- for (Item item : items()) {
- switch (item.kind()) {
- case ERROR:
- return false;
- default:
- break;
- }
- }
- for (ValidationReport<?> subreport : subreports()) {
- if (!subreport.isClean()) {
- return false;
- }
- }
- return true;
- }
-
- /**
- * Prints all {@linkplain #items() messages} to {@code messager} (and recurs for subreports). If a
- * message's {@linkplain Item#element() element} is contained within the report's {@linkplain
- * #subject() subject}, associates the message with the message's element. Otherwise, since
- * {@link Diagnostic} reporting is expected to be associated with elements that are currently
- * being compiled, associates the message with the subject itself and prepends a reference to the
- * item's element.
- */
- void printMessagesTo(Messager messager) {
- for (Item item : items()) {
- if (isEnclosedIn(subject(), item.element())) {
- if (item.annotation().isPresent()) {
- if (item.annotationValue().isPresent()) {
- messager.printMessage(
- item.kind(),
- item.message(),
- item.element(),
- item.annotation().get(),
- item.annotationValue().get());
- } else {
- messager.printMessage(
- item.kind(), item.message(), item.element(), item.annotation().get());
- }
- } else {
- messager.printMessage(item.kind(), item.message(), item.element());
- }
- } else {
- String message = String.format("[%s] %s", elementToString(item.element()), item.message());
- messager.printMessage(item.kind(), message, subject());
- }
- }
- for (ValidationReport<?> subreport : subreports()) {
- subreport.printMessagesTo(messager);
- }
- }
-
- private static boolean isEnclosedIn(Element parent, Element child) {
- Element current = child;
- while (current != null) {
- if (current.equals(parent)) {
- return true;
- }
- current = current.getEnclosingElement();
- }
- return false;
- }
-
- @AutoValue
- static abstract class Item {
- abstract String message();
- abstract Kind kind();
- abstract Element element();
- abstract Optional<AnnotationMirror> annotation();
- abstract Optional<AnnotationValue> annotationValue();
- }
-
- static <T extends Element> Builder<T> about(T subject) {
- return new Builder<>(subject);
- }
-
- @CanIgnoreReturnValue
- static final class Builder<T extends Element> {
- private final T subject;
- private final ImmutableSet.Builder<Item> items = ImmutableSet.builder();
- private final ImmutableSet.Builder<ValidationReport<?>> subreports = ImmutableSet.builder();
- private boolean markedDirty;
-
- private Builder(T subject) {
- this.subject = subject;
- }
-
- @CheckReturnValue
- T getSubject() {
- return subject;
- }
-
- Builder<T> addItems(Iterable<Item> newItems) {
- items.addAll(newItems);
- return this;
- }
-
- Builder<T> addError(String message) {
- return addError(message, subject);
- }
-
- Builder<T> addError(String message, Element element) {
- return addItem(message, ERROR, element);
- }
-
- Builder<T> addError(String message, Element element, AnnotationMirror annotation) {
- return addItem(message, ERROR, element, annotation);
- }
-
- Builder<T> addError(
- String message,
- Element element,
- AnnotationMirror annotation,
- AnnotationValue annotationValue) {
- return addItem(message, ERROR, element, annotation, annotationValue);
- }
-
- Builder<T> addWarning(String message) {
- return addWarning(message, subject);
- }
-
- Builder<T> addWarning(String message, Element element) {
- return addItem(message, WARNING, element);
- }
-
- Builder<T> addWarning(String message, Element element, AnnotationMirror annotation) {
- return addItem(message, WARNING, element, annotation);
- }
-
- Builder<T> addWarning(
- String message,
- Element element,
- AnnotationMirror annotation,
- AnnotationValue annotationValue) {
- return addItem(message, WARNING, element, annotation, annotationValue);
- }
-
- Builder<T> addNote(String message) {
- return addNote(message, subject);
- }
-
- Builder<T> addNote(String message, Element element) {
- return addItem(message, NOTE, element);
- }
-
- Builder<T> addNote(String message, Element element, AnnotationMirror annotation) {
- return addItem(message, NOTE, element, annotation);
- }
-
- Builder<T> addNote(
- String message,
- Element element,
- AnnotationMirror annotation,
- AnnotationValue annotationValue) {
- return addItem(message, NOTE, element, annotation, annotationValue);
- }
-
- Builder<T> addItem(String message, Kind kind, Element element) {
- return addItem(message, kind, element, Optional.empty(), Optional.empty());
- }
-
- Builder<T> addItem(String message, Kind kind, Element element, AnnotationMirror annotation) {
- return addItem(message, kind, element, Optional.of(annotation), Optional.empty());
- }
-
- Builder<T> addItem(
- String message,
- Kind kind,
- Element element,
- AnnotationMirror annotation,
- AnnotationValue annotationValue) {
- return addItem(message, kind, element, Optional.of(annotation), Optional.of(annotationValue));
- }
-
- private Builder<T> addItem(
- String message,
- Kind kind,
- Element element,
- Optional<AnnotationMirror> annotation,
- Optional<AnnotationValue> annotationValue) {
- items.add(
- new AutoValue_ValidationReport_Item(message, kind, element, annotation, annotationValue));
- return this;
- }
-
- /**
- * If called, then {@link #isClean()} will return {@code false} even if there are no error items
- * in the report.
- */
- void markDirty() {
- this.markedDirty = true;
- }
-
- Builder<T> addSubreport(ValidationReport<?> subreport) {
- subreports.add(subreport);
- return this;
- }
-
- @CheckReturnValue
- ValidationReport<T> build() {
- return new AutoValue_ValidationReport<>(
- subject, items.build(), subreports.build(), markedDirty);
- }
- }
-}
diff --git a/java/dagger/internal/codegen/ValidationType.java b/java/dagger/internal/codegen/ValidationType.java
deleted file mode 100644
index 5d19dc1..0000000
--- a/java/dagger/internal/codegen/ValidationType.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright (C) 2015 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import java.util.Optional;
-import javax.tools.Diagnostic;
-
-/**
- * Allows options to control how component process validates things such as scope cycles
- * or nullability.
- */
-enum ValidationType {
- ERROR,
- WARNING,
- NONE;
-
- Optional<Diagnostic.Kind> diagnosticKind() {
- switch (this) {
- case ERROR:
- return Optional.of(Diagnostic.Kind.ERROR);
- case WARNING:
- return Optional.of(Diagnostic.Kind.WARNING);
- default:
- return Optional.empty();
- }
- }
-}
diff --git a/java/dagger/internal/codegen/base/BUILD b/java/dagger/internal/codegen/base/BUILD
new file mode 100644
index 0000000..0bcbb12
--- /dev/null
+++ b/java/dagger/internal/codegen/base/BUILD
@@ -0,0 +1,66 @@
+# Copyright (C) 2019 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Sources related to compiler options.
+
+load("@rules_java//java:defs.bzl", "java_library")
+
+package(default_visibility = ["//:src"])
+
+SHARED_SOURCES = [
+ "ClearableCache.java",
+ "MoreAnnotationMirrors.java",
+ "MoreAnnotationValues.java",
+]
+
+java_library(
+ name = "base",
+ srcs = glob(
+ ["*.java"],
+ exclude = SHARED_SOURCES,
+ ),
+ plugins = ["//java/dagger/internal/codegen/bootstrap"],
+ tags = ["maven:merged"],
+ exports = [":shared"],
+ deps = [
+ ":shared",
+ "//java/dagger:core",
+ "//java/dagger/internal/codegen/extension",
+ "//java/dagger/internal/codegen/javapoet",
+ "//java/dagger/internal/codegen/langmodel",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/internal/guava:concurrent",
+ "//java/dagger/producers",
+ "//java/dagger/spi",
+ "@google_bazel_common//third_party/java/auto:value",
+ "@google_bazel_common//third_party/java/javapoet",
+ "@google_bazel_common//third_party/java/jsr330_inject",
+ "@maven//:com_google_auto_auto_common",
+ ],
+)
+
+# TODO(bcorso): Remove this target but first remove spi and producers from :base
+java_library(
+ name = "shared",
+ srcs = SHARED_SOURCES,
+ tags = ["maven:merged"],
+ deps = [
+ "//java/dagger/internal/codegen/extension",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "@maven//:com_google_auto_auto_common",
+ ],
+)
diff --git a/java/dagger/internal/codegen/base/ClearableCache.java b/java/dagger/internal/codegen/base/ClearableCache.java
new file mode 100644
index 0000000..61e9482
--- /dev/null
+++ b/java/dagger/internal/codegen/base/ClearableCache.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.base;
+
+/** A cache of objects that can be cleared. */
+public interface ClearableCache {
+ /** Releases cached references. */
+ void clearCache();
+}
diff --git a/java/dagger/internal/codegen/base/ComponentAnnotation.java b/java/dagger/internal/codegen/base/ComponentAnnotation.java
new file mode 100644
index 0000000..c9b3580
--- /dev/null
+++ b/java/dagger/internal/codegen/base/ComponentAnnotation.java
@@ -0,0 +1,326 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.base;
+
+import static com.google.auto.common.AnnotationMirrors.getAnnotationValue;
+import static com.google.auto.common.MoreElements.asType;
+import static com.google.auto.common.MoreTypes.asTypeElements;
+import static com.google.auto.common.MoreTypes.isTypeOf;
+import static dagger.internal.codegen.base.MoreAnnotationValues.asAnnotationValues;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
+import static dagger.internal.codegen.javapoet.TypeNames.PRODUCER_MODULE;
+import static dagger.internal.codegen.langmodel.DaggerElements.getAnyAnnotation;
+
+import com.google.auto.value.AutoValue;
+import com.google.auto.value.extension.memoized.Memoized;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.squareup.javapoet.ClassName;
+import dagger.Component;
+import dagger.Subcomponent;
+import dagger.producers.ProductionComponent;
+import dagger.producers.ProductionSubcomponent;
+import java.lang.annotation.Annotation;
+import java.util.Collection;
+import java.util.Optional;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeMirror;
+
+/**
+ * A {@code @Component}, {@code @Subcomponent}, {@code @ProductionComponent}, or
+ * {@code @ProductionSubcomponent} annotation, or a {@code @Module} or {@code @ProducerModule}
+ * annotation that is being treated as a component annotation when validating full binding graphs
+ * for modules.
+ */
+public abstract class ComponentAnnotation {
+ /** The root component annotation types. */
+ private static final ImmutableSet<Class<? extends Annotation>> ROOT_COMPONENT_ANNOTATIONS =
+ ImmutableSet.of(Component.class, ProductionComponent.class);
+
+ /** The subcomponent annotation types. */
+ private static final ImmutableSet<Class<? extends Annotation>> SUBCOMPONENT_ANNOTATIONS =
+ ImmutableSet.of(Subcomponent.class, ProductionSubcomponent.class);
+
+ /** All component annotation types. */
+ private static final ImmutableSet<Class<? extends Annotation>> ALL_COMPONENT_ANNOTATIONS =
+ ImmutableSet.<Class<? extends Annotation>>builder()
+ .addAll(ROOT_COMPONENT_ANNOTATIONS)
+ .addAll(SUBCOMPONENT_ANNOTATIONS)
+ .build();
+
+ /** The annotation itself. */
+ public abstract AnnotationMirror annotation();
+
+ /** The simple name of the annotation type. */
+ public String simpleName() {
+ return MoreAnnotationMirrors.simpleName(annotation()).toString();
+ }
+
+ /**
+ * Returns {@code true} if the annotation is a {@code @Subcomponent} or
+ * {@code @ProductionSubcomponent}.
+ */
+ public abstract boolean isSubcomponent();
+
+ /**
+ * Returns {@code true} if the annotation is a {@code @ProductionComponent},
+ * {@code @ProductionSubcomponent}, or {@code @ProducerModule}.
+ */
+ public abstract boolean isProduction();
+
+ /**
+ * Returns {@code true} if the annotation is a real component annotation and not a module
+ * annotation.
+ */
+ public abstract boolean isRealComponent();
+
+ /** The values listed as {@code dependencies}. */
+ public abstract ImmutableList<AnnotationValue> dependencyValues();
+
+ /** The types listed as {@code dependencies}. */
+ public ImmutableList<TypeMirror> dependencyTypes() {
+ return dependencyValues().stream().map(MoreAnnotationValues::asType).collect(toImmutableList());
+ }
+
+ /**
+ * The types listed as {@code dependencies}.
+ *
+ * @throws IllegalArgumentException if any of {@link #dependencyTypes()} are error types
+ */
+ public ImmutableList<TypeElement> dependencies() {
+ return asTypeElements(dependencyTypes()).asList();
+ }
+
+ /** The values listed as {@code modules}. */
+ public abstract ImmutableList<AnnotationValue> moduleValues();
+
+ /** The types listed as {@code modules}. */
+ public ImmutableList<TypeMirror> moduleTypes() {
+ return moduleValues().stream().map(MoreAnnotationValues::asType).collect(toImmutableList());
+ }
+
+ /**
+ * The types listed as {@code modules}.
+ *
+ * @throws IllegalArgumentException if any of {@link #moduleTypes()} are error types
+ */
+ public ImmutableSet<TypeElement> modules() {
+ return asTypeElements(moduleTypes());
+ }
+
+ protected final ImmutableList<AnnotationValue> getAnnotationValues(String parameterName) {
+ return asAnnotationValues(getAnnotationValue(annotation(), parameterName));
+ }
+
+ /**
+ * Returns an object representing a root component annotation, not a subcomponent annotation, if
+ * one is present on {@code typeElement}.
+ */
+ public static Optional<ComponentAnnotation> rootComponentAnnotation(TypeElement typeElement) {
+ return anyComponentAnnotation(typeElement, ROOT_COMPONENT_ANNOTATIONS);
+ }
+
+ /**
+ * Returns an object representing a subcomponent annotation, if one is present on {@code
+ * typeElement}.
+ */
+ public static Optional<ComponentAnnotation> subcomponentAnnotation(TypeElement typeElement) {
+ return anyComponentAnnotation(typeElement, SUBCOMPONENT_ANNOTATIONS);
+ }
+
+ /**
+ * Returns an object representing a root component or subcomponent annotation, if one is present
+ * on {@code typeElement}.
+ */
+ public static Optional<ComponentAnnotation> anyComponentAnnotation(TypeElement typeElement) {
+ return anyComponentAnnotation(typeElement, ALL_COMPONENT_ANNOTATIONS);
+ }
+
+ private static Optional<ComponentAnnotation> anyComponentAnnotation(
+ TypeElement typeElement, Collection<Class<? extends Annotation>> annotations) {
+ return getAnyAnnotation(typeElement, annotations).map(ComponentAnnotation::componentAnnotation);
+ }
+
+ /** Returns {@code true} if the argument is a component annotation. */
+ public static boolean isComponentAnnotation(AnnotationMirror annotation) {
+ return ALL_COMPONENT_ANNOTATIONS.stream()
+ .anyMatch(annotationClass -> isTypeOf(annotationClass, annotation.getAnnotationType()));
+ }
+
+ /** Creates an object representing a component or subcomponent annotation. */
+ public static ComponentAnnotation componentAnnotation(AnnotationMirror annotation) {
+ RealComponentAnnotation.Builder annotationBuilder =
+ RealComponentAnnotation.builder().annotation(annotation);
+
+ if (isTypeOf(Component.class, annotation.getAnnotationType())) {
+ return annotationBuilder.isProduction(false).isSubcomponent(false).build();
+ }
+ if (isTypeOf(Subcomponent.class, annotation.getAnnotationType())) {
+ return annotationBuilder.isProduction(false).isSubcomponent(true).build();
+ }
+ if (isTypeOf(ProductionComponent.class, annotation.getAnnotationType())) {
+ return annotationBuilder.isProduction(true).isSubcomponent(false).build();
+ }
+ if (isTypeOf(ProductionSubcomponent.class, annotation.getAnnotationType())) {
+ return annotationBuilder.isProduction(true).isSubcomponent(true).build();
+ }
+ throw new IllegalArgumentException(
+ annotation
+ + " must be a Component, Subcomponent, ProductionComponent, "
+ + "or ProductionSubcomponent annotation");
+ }
+
+ /** Creates a fictional component annotation representing a module. */
+ public static ComponentAnnotation fromModuleAnnotation(ModuleAnnotation moduleAnnotation) {
+ return new AutoValue_ComponentAnnotation_FictionalComponentAnnotation(moduleAnnotation);
+ }
+
+ /** The root component annotation types. */
+ public static ImmutableSet<Class<? extends Annotation>> rootComponentAnnotations() {
+ return ROOT_COMPONENT_ANNOTATIONS;
+ }
+
+ /** The subcomponent annotation types. */
+ public static ImmutableSet<Class<? extends Annotation>> subcomponentAnnotations() {
+ return SUBCOMPONENT_ANNOTATIONS;
+ }
+
+ /** All component annotation types. */
+ public static ImmutableSet<Class<? extends Annotation>> allComponentAnnotations() {
+ return ALL_COMPONENT_ANNOTATIONS;
+ }
+
+ /**
+ * An actual component annotation.
+ *
+ * @see FictionalComponentAnnotation
+ */
+ @AutoValue
+ abstract static class RealComponentAnnotation extends ComponentAnnotation {
+
+ @Override
+ @Memoized
+ public ImmutableList<AnnotationValue> dependencyValues() {
+ return isSubcomponent() ? ImmutableList.of() : getAnnotationValues("dependencies");
+ }
+
+ @Override
+ @Memoized
+ public ImmutableList<TypeMirror> dependencyTypes() {
+ return super.dependencyTypes();
+ }
+
+ @Override
+ @Memoized
+ public ImmutableList<TypeElement> dependencies() {
+ return super.dependencies();
+ }
+
+ @Override
+ public boolean isRealComponent() {
+ return true;
+ }
+
+ @Override
+ @Memoized
+ public ImmutableList<AnnotationValue> moduleValues() {
+ return getAnnotationValues("modules");
+ }
+
+ @Override
+ @Memoized
+ public ImmutableList<TypeMirror> moduleTypes() {
+ return super.moduleTypes();
+ }
+
+ @Override
+ @Memoized
+ public ImmutableSet<TypeElement> modules() {
+ return super.modules();
+ }
+
+ static Builder builder() {
+ return new AutoValue_ComponentAnnotation_RealComponentAnnotation.Builder();
+ }
+
+ @AutoValue.Builder
+ interface Builder {
+ Builder annotation(AnnotationMirror annotation);
+
+ Builder isSubcomponent(boolean isSubcomponent);
+
+ Builder isProduction(boolean isProduction);
+
+ RealComponentAnnotation build();
+ }
+ }
+
+ /**
+ * A fictional component annotation used to represent modules or other collections of bindings as
+ * a component.
+ */
+ @AutoValue
+ abstract static class FictionalComponentAnnotation extends ComponentAnnotation {
+
+ @Override
+ public AnnotationMirror annotation() {
+ return moduleAnnotation().annotation();
+ }
+
+ @Override
+ public boolean isSubcomponent() {
+ return false;
+ }
+
+ @Override
+ public boolean isProduction() {
+ return ClassName.get(asType(moduleAnnotation().annotation().getAnnotationType().asElement()))
+ .equals(PRODUCER_MODULE);
+ }
+
+ @Override
+ public boolean isRealComponent() {
+ return false;
+ }
+
+ @Override
+ public ImmutableList<AnnotationValue> dependencyValues() {
+ return ImmutableList.of();
+ }
+
+ @Override
+ public ImmutableList<AnnotationValue> moduleValues() {
+ return moduleAnnotation().includesAsAnnotationValues();
+ }
+
+ @Override
+ @Memoized
+ public ImmutableList<TypeMirror> moduleTypes() {
+ return super.moduleTypes();
+ }
+
+ @Override
+ @Memoized
+ public ImmutableSet<TypeElement> modules() {
+ return super.modules();
+ }
+
+ public abstract ModuleAnnotation moduleAnnotation();
+ }
+}
diff --git a/java/dagger/internal/codegen/base/ContributionType.java b/java/dagger/internal/codegen/base/ContributionType.java
new file mode 100644
index 0000000..c046daa
--- /dev/null
+++ b/java/dagger/internal/codegen/base/ContributionType.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.base;
+
+import static com.google.auto.common.MoreElements.isAnnotationPresent;
+
+import dagger.multibindings.ElementsIntoSet;
+import dagger.multibindings.IntoMap;
+import dagger.multibindings.IntoSet;
+import javax.lang.model.element.Element;
+
+/** Whether a binding or declaration is for a unique contribution or a map or set multibinding. */
+public enum ContributionType {
+ /** Represents map bindings. */
+ MAP,
+ /** Represents set bindings. */
+ SET,
+ /** Represents set values bindings. */
+ SET_VALUES,
+ /** Represents a valid non-collection binding. */
+ UNIQUE,
+ ;
+
+ /** An object that is associated with a {@link ContributionType}. */
+ public interface HasContributionType {
+
+ /** The contribution type of this object. */
+ ContributionType contributionType();
+ }
+
+ /** {@code true} if this is for a multibinding. */
+ public boolean isMultibinding() {
+ return !this.equals(UNIQUE);
+ }
+
+ /**
+ * The contribution type from a binding element's annotations. Presumes a well-formed binding
+ * element (at most one of @IntoSet, @IntoMap, @ElementsIntoSet and @Provides.type). {@link
+ * dagger.internal.codegen.validation.BindingMethodValidator} and {@link
+ * dagger.internal.codegen.validation.BindsInstanceProcessingStep} validate correctness on their
+ * own.
+ */
+ public static ContributionType fromBindingElement(Element element) {
+ // TODO(bcorso): Replace these class references with ClassName.
+ if (isAnnotationPresent(element, IntoMap.class)) {
+ return ContributionType.MAP;
+ } else if (isAnnotationPresent(element, IntoSet.class)) {
+ return ContributionType.SET;
+ } else if (isAnnotationPresent(element, ElementsIntoSet.class)) {
+ return ContributionType.SET_VALUES;
+ }
+ return ContributionType.UNIQUE;
+ }
+}
diff --git a/java/dagger/internal/codegen/base/DiagnosticFormatting.java b/java/dagger/internal/codegen/base/DiagnosticFormatting.java
new file mode 100644
index 0000000..93e445c
--- /dev/null
+++ b/java/dagger/internal/codegen/base/DiagnosticFormatting.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.base;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Utility methods for formatting diagnostics to the {@link javax.annotation.processing.Messager}.
+ */
+public final class DiagnosticFormatting {
+
+ /**
+ * A regular expression to match a small list of specific packages deemed to be unhelpful to
+ * display in fully qualified types in error messages.
+ *
+ * <p>Note: This should never be applied to messages themselves.
+ */
+ private static final Pattern COMMON_PACKAGE_PATTERN =
+ Pattern.compile(
+ "(?:^|[^.a-z_])" // What we want to match on but not capture.
+ + "((?:" // Start a group with a non-capturing or part
+ + "java[.]lang"
+ + "|java[.]util"
+ + "|javax[.]inject"
+ + "|dagger"
+ + "|dagger[.]multibindings"
+ + "|com[.]google[.]common[.]base"
+ + "|com[.]google[.]common[.]collect"
+ + ")[.])" // Always end with a literal .
+ + "[A-Z]"); // What we want to match on but not capture.
+
+ /**
+ * A method to strip out common packages and a few rare type prefixes from types' string
+ * representation before being used in error messages.
+ *
+ * <p>This type assumes a String value that is a valid fully qualified (and possibly
+ * parameterized) type, and should NOT be used with arbitrary text, especially prose error
+ * messages.
+ *
+ * <p>TODO(user): Tighten these to take type representations (mirrors and elements) to avoid
+ * accidental mis-use by running errors through this method.
+ */
+ public static String stripCommonTypePrefixes(String type) {
+ // Do regex magic to remove common packages we care to shorten.
+ Matcher matcher = COMMON_PACKAGE_PATTERN.matcher(type);
+ StringBuilder result = new StringBuilder();
+ int index = 0;
+ while (matcher.find()) {
+ result.append(type.subSequence(index, matcher.start(1)));
+ index = matcher.end(1); // Skip the matched pattern content.
+ }
+ result.append(type.subSequence(index, type.length()));
+ return result.toString();
+ }
+
+ private DiagnosticFormatting() {}
+}
diff --git a/java/dagger/internal/codegen/base/ElementFormatter.java b/java/dagger/internal/codegen/base/ElementFormatter.java
new file mode 100644
index 0000000..f85fbfd
--- /dev/null
+++ b/java/dagger/internal/codegen/base/ElementFormatter.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2013 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.base;
+
+import static com.google.auto.common.MoreElements.asExecutable;
+import static java.util.stream.Collectors.joining;
+
+import javax.inject.Inject;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementVisitor;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.util.ElementKindVisitor8;
+
+/**
+ * Formats elements into a useful string representation.
+ *
+ * <p>Elements directly enclosed by a type are preceded by the enclosing type's qualified name.
+ *
+ * <p>Parameters are given with their enclosing executable, with other parameters elided.
+ */
+public final class ElementFormatter extends Formatter<Element> {
+ @Inject
+ ElementFormatter() {}
+
+ @Override
+ public String format(Element element) {
+ return elementToString(element);
+ }
+
+ /**
+ * Returns a useful string form for an element.
+ *
+ * <p>Elements directly enclosed by a type are preceded by the enclosing type's qualified name.
+ *
+ * <p>Parameters are given with their enclosing executable, with other parameters elided.
+ */
+ public static String elementToString(Element element) {
+ return element.accept(ELEMENT_TO_STRING, null);
+ }
+
+ private static final ElementVisitor<String, Void> ELEMENT_TO_STRING =
+ new ElementKindVisitor8<String, Void>() {
+ @Override
+ public String visitExecutable(ExecutableElement executableElement, Void aVoid) {
+ return enclosingTypeAndMemberName(executableElement)
+ .append(
+ executableElement.getParameters().stream()
+ .map(parameter -> parameter.asType().toString())
+ .collect(joining(", ", "(", ")")))
+ .toString();
+ }
+
+ @Override
+ public String visitVariableAsParameter(VariableElement parameter, Void aVoid) {
+ ExecutableElement methodOrConstructor = asExecutable(parameter.getEnclosingElement());
+ return enclosingTypeAndMemberName(methodOrConstructor)
+ .append('(')
+ .append(
+ formatArgumentInList(
+ methodOrConstructor.getParameters().indexOf(parameter),
+ methodOrConstructor.getParameters().size(),
+ parameter.getSimpleName()))
+ .append(')')
+ .toString();
+ }
+
+ @Override
+ public String visitVariableAsField(VariableElement field, Void aVoid) {
+ return enclosingTypeAndMemberName(field).toString();
+ }
+
+ @Override
+ public String visitType(TypeElement type, Void aVoid) {
+ return type.getQualifiedName().toString();
+ }
+
+ @Override
+ protected String defaultAction(Element element, Void aVoid) {
+ throw new UnsupportedOperationException(
+ "Can't determine string for " + element.getKind() + " element " + element);
+ }
+
+ private StringBuilder enclosingTypeAndMemberName(Element element) {
+ StringBuilder name = new StringBuilder(element.getEnclosingElement().accept(this, null));
+ if (!element.getSimpleName().contentEquals("<init>")) {
+ name.append('.').append(element.getSimpleName());
+ }
+ return name;
+ }
+ };
+}
diff --git a/java/dagger/internal/codegen/base/Formatter.java b/java/dagger/internal/codegen/base/Formatter.java
new file mode 100644
index 0000000..c5e2357
--- /dev/null
+++ b/java/dagger/internal/codegen/base/Formatter.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.base;
+
+import static com.google.common.base.Preconditions.checkElementIndex;
+
+import com.google.common.base.Function;
+import com.google.common.collect.Iterables;
+
+/**
+ * A formatter which transforms an instance of a particular type into a string
+ * representation.
+ *
+ * @param <T> the type of the object to be transformed.
+ */
+public abstract class Formatter<T> implements Function<T, String> {
+
+ public static final String INDENT = " ";
+ public static final String DOUBLE_INDENT = INDENT + INDENT;
+ private static final int LIST_LIMIT = 10;
+
+ /**
+ * Performs the transformation of an object into a string representation.
+ */
+ public abstract String format(T object);
+
+ /**
+ * Performs the transformation of an object into a string representation in conformity with the
+ * {@link Function}{@code <T, String>} contract, delegating to {@link #format(Object)}.
+ *
+ * @deprecated Call {@link #format(Object)} instead. This method exists to make formatters easy to
+ * use when functions are required, but shouldn't be called directly.
+ */
+ @SuppressWarnings("javadoc")
+ @Deprecated
+ @Override
+ public final String apply(T object) {
+ return format(object);
+ }
+
+ /** Formats {@code items}, one per line. Stops after {@value #LIST_LIMIT} items. */
+ public void formatIndentedList(
+ StringBuilder builder, Iterable<? extends T> items, int indentLevel) {
+ for (T item : Iterables.limit(items, LIST_LIMIT)) {
+ String formatted = format(item);
+ if (formatted.isEmpty()) {
+ continue;
+ }
+ builder.append('\n');
+ appendIndent(builder, indentLevel);
+ builder.append(formatted);
+ }
+ int numberOfOtherItems = Iterables.size(items) - LIST_LIMIT;
+ if (numberOfOtherItems > 0) {
+ builder.append('\n');
+ appendIndent(builder, indentLevel);
+ builder.append("and ").append(numberOfOtherItems).append(" other");
+ }
+ if (numberOfOtherItems > 1) {
+ builder.append('s');
+ }
+ }
+
+ private void appendIndent(StringBuilder builder, int indentLevel) {
+ for (int i = 0; i < indentLevel; i++) {
+ builder.append(INDENT);
+ }
+ }
+
+ public static String formatArgumentInList(int index, int size, CharSequence name) {
+ checkElementIndex(index, size);
+ StringBuilder builder = new StringBuilder();
+ if (index > 0) {
+ builder.append("…, ");
+ }
+ builder.append(name);
+ if (index < size - 1) {
+ builder.append(", …");
+ }
+ return builder.toString();
+ }
+}
diff --git a/java/dagger/internal/codegen/base/FrameworkTypes.java b/java/dagger/internal/codegen/base/FrameworkTypes.java
new file mode 100644
index 0000000..4cd54a3
--- /dev/null
+++ b/java/dagger/internal/codegen/base/FrameworkTypes.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.base;
+
+import static com.google.auto.common.MoreTypes.isType;
+
+import com.google.auto.common.MoreTypes;
+import com.google.common.collect.ImmutableSet;
+import dagger.Lazy;
+import dagger.MembersInjector;
+import dagger.producers.Produced;
+import dagger.producers.Producer;
+import java.util.Set;
+import javax.inject.Provider;
+import javax.lang.model.type.TypeMirror;
+
+/**
+ * A collection of utility methods for dealing with Dagger framework types. A framework type is any
+ * type that the framework itself defines.
+ */
+public final class FrameworkTypes {
+ private static final ImmutableSet<Class<?>> PROVISION_TYPES =
+ ImmutableSet.of(Provider.class, Lazy.class, MembersInjector.class);
+
+ // NOTE(beder): ListenableFuture is not considered a producer framework type because it is not
+ // defined by the framework, so we can't treat it specially in ordinary Dagger.
+ private static final ImmutableSet<Class<?>> PRODUCTION_TYPES =
+ ImmutableSet.of(Produced.class, Producer.class);
+
+ /** Returns true if the type represents a producer-related framework type. */
+ public static boolean isProducerType(TypeMirror type) {
+ return isType(type) && typeIsOneOf(PRODUCTION_TYPES, type);
+ }
+
+ /** Returns true if the type represents a framework type. */
+ public static boolean isFrameworkType(TypeMirror type) {
+ return isType(type)
+ && (typeIsOneOf(PROVISION_TYPES, type)
+ || typeIsOneOf(PRODUCTION_TYPES, type));
+ }
+
+ private static boolean typeIsOneOf(Set<Class<?>> classes, TypeMirror type) {
+ for (Class<?> clazz : classes) {
+ if (MoreTypes.isTypeOf(clazz, type)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private FrameworkTypes() {}
+}
diff --git a/java/dagger/internal/codegen/base/Keys.java b/java/dagger/internal/codegen/base/Keys.java
new file mode 100644
index 0000000..a25f996
--- /dev/null
+++ b/java/dagger/internal/codegen/base/Keys.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.base;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.MoreTypes;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.Key;
+import java.util.Optional;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.SimpleTypeVisitor6;
+
+/** Utility methods related to {@link Key}s. */
+public final class Keys {
+ public static boolean isValidMembersInjectionKey(Key key) {
+ return !key.qualifier().isPresent()
+ && !key.multibindingContributionIdentifier().isPresent()
+ && key.type().getKind().equals(TypeKind.DECLARED);
+ }
+
+ /**
+ * Returns {@code true} if this is valid as an implicit key (that is, if it's valid for a
+ * just-in-time binding by discovering an {@code @Inject} constructor).
+ */
+ public static boolean isValidImplicitProvisionKey(Key key, DaggerTypes types) {
+ return isValidImplicitProvisionKey(key.qualifier(), key.type(), types);
+ }
+
+ /**
+ * Returns {@code true} if a key with {@code qualifier} and {@code type} is valid as an implicit
+ * key (that is, if it's valid for a just-in-time binding by discovering an {@code @Inject}
+ * constructor).
+ */
+ public static boolean isValidImplicitProvisionKey(
+ Optional<? extends AnnotationMirror> qualifier, TypeMirror type, final DaggerTypes types) {
+ // Qualifiers disqualify implicit provisioning.
+ if (qualifier.isPresent()) {
+ return false;
+ }
+
+ return type.accept(
+ new SimpleTypeVisitor6<Boolean, Void>(false) {
+ @Override
+ public Boolean visitDeclared(DeclaredType type, Void ignored) {
+ // Non-classes or abstract classes aren't allowed.
+ TypeElement element = MoreElements.asType(type.asElement());
+ if (!element.getKind().equals(ElementKind.CLASS)
+ || element.getModifiers().contains(Modifier.ABSTRACT)) {
+ return false;
+ }
+
+ // If the key has type arguments, validate that each type argument is declared.
+ // Otherwise the type argument may be a wildcard (or other type), and we can't
+ // resolve that to actual types.
+ for (TypeMirror arg : type.getTypeArguments()) {
+ if (arg.getKind() != TypeKind.DECLARED) {
+ return false;
+ }
+ }
+
+ // Also validate that the key is not the erasure of a generic type.
+ // If it is, that means the user referred to Foo<T> as just 'Foo',
+ // which we don't allow. (This is a judgement call -- we *could*
+ // allow it and instantiate the type bounds... but we don't.)
+ return MoreTypes.asDeclared(element.asType()).getTypeArguments().isEmpty()
+ || !types.isSameType(types.erasure(element.asType()), type);
+ }
+ },
+ null);
+ }
+}
diff --git a/java/dagger/internal/codegen/base/MapKeyAccessibility.java b/java/dagger/internal/codegen/base/MapKeyAccessibility.java
new file mode 100644
index 0000000..93c265a
--- /dev/null
+++ b/java/dagger/internal/codegen/base/MapKeyAccessibility.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.base;
+
+import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
+
+import dagger.internal.codegen.langmodel.Accessibility;
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Predicate;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.SimpleAnnotationValueVisitor8;
+
+/** Utility class for checking the visibility of an annotation. */
+public final class MapKeyAccessibility extends SimpleAnnotationValueVisitor8<Boolean, Void> {
+ private final Predicate<TypeMirror> accessibilityChecker;
+
+ private MapKeyAccessibility(Predicate<TypeMirror> accessibilityChecker) {
+ this.accessibilityChecker = accessibilityChecker;
+ }
+
+ @Override
+ public Boolean visitAnnotation(AnnotationMirror annotation, Void aVoid) {
+ // The annotation type is not checked, as the generated code will refer to the @AutoAnnotation
+ // generated type which is always public
+ return visitValues(annotation.getElementValues().values());
+ }
+
+ @Override
+ public Boolean visitArray(List<? extends AnnotationValue> values, Void aVoid) {
+ return visitValues(values);
+ }
+
+ private boolean visitValues(Collection<? extends AnnotationValue> values) {
+ return values.stream().allMatch(value -> value.accept(this, null));
+ }
+
+ @Override
+ public Boolean visitEnumConstant(VariableElement enumConstant, Void aVoid) {
+ return accessibilityChecker.test(enumConstant.getEnclosingElement().asType());
+ }
+
+ @Override
+ public Boolean visitType(TypeMirror type, Void aVoid) {
+ return accessibilityChecker.test(type);
+ }
+
+ @Override
+ protected Boolean defaultAction(Object o, Void aVoid) {
+ return true;
+ }
+
+ public static boolean isMapKeyAccessibleFrom(
+ AnnotationMirror annotation, String accessingPackage) {
+ return new MapKeyAccessibility(type -> isTypeAccessibleFrom(type, accessingPackage))
+ .visitAnnotation(annotation, null);
+ }
+
+ public static boolean isMapKeyPubliclyAccessible(AnnotationMirror annotation) {
+ return new MapKeyAccessibility(Accessibility::isTypePubliclyAccessible)
+ .visitAnnotation(annotation, null);
+ }
+}
diff --git a/java/dagger/internal/codegen/base/MapType.java b/java/dagger/internal/codegen/base/MapType.java
new file mode 100644
index 0000000..4e2307a
--- /dev/null
+++ b/java/dagger/internal/codegen/base/MapType.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.base;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.auto.common.MoreTypes;
+import com.google.auto.value.AutoValue;
+import com.google.common.base.Equivalence;
+import dagger.model.Key;
+import java.util.Map;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeMirror;
+
+/**
+ * Information about a {@link Map} {@link TypeMirror}.
+ */
+@AutoValue
+public abstract class MapType {
+ /**
+ * The map type itself, wrapped using {@link MoreTypes#equivalence()}. Use
+ * {@link #declaredMapType()} instead.
+ */
+ protected abstract Equivalence.Wrapper<DeclaredType> wrappedDeclaredMapType();
+
+ /**
+ * The map type itself.
+ */
+ private DeclaredType declaredMapType() {
+ return wrappedDeclaredMapType().get();
+ }
+
+ /**
+ * {@code true} if the map type is the raw {@link Map} type.
+ */
+ public boolean isRawType() {
+ return declaredMapType().getTypeArguments().isEmpty();
+ }
+
+ /**
+ * The map key type.
+ *
+ * @throws IllegalStateException if {@link #isRawType()} is true.
+ */
+ public TypeMirror keyType() {
+ checkState(!isRawType());
+ return declaredMapType().getTypeArguments().get(0);
+ }
+
+ /**
+ * The map value type.
+ *
+ * @throws IllegalStateException if {@link #isRawType()} is true.
+ */
+ public TypeMirror valueType() {
+ checkState(!isRawType());
+ return declaredMapType().getTypeArguments().get(1);
+ }
+
+ /**
+ * {@code true} if {@link #valueType()} is a {@code clazz}.
+ *
+ * @throws IllegalStateException if {@link #isRawType()} is true.
+ */
+ public boolean valuesAreTypeOf(Class<?> clazz) {
+ return MoreTypes.isType(valueType()) && MoreTypes.isTypeOf(clazz, valueType());
+ }
+
+ /**
+ * Returns {@code true} if the {@linkplain #valueType() value type} of the {@link Map} is a
+ * {@linkplain FrameworkTypes#isFrameworkType(TypeMirror) framework type}.
+ */
+ public boolean valuesAreFrameworkType() {
+ return FrameworkTypes.isFrameworkType(valueType());
+ }
+
+ /**
+ * {@code V} if {@link #valueType()} is a framework type like {@code Provider<V>} or {@code
+ * Producer<V>}.
+ *
+ * @throws IllegalStateException if {@link #isRawType()} is true or {@link #valueType()} is not a
+ * framework type
+ */
+ public TypeMirror unwrappedFrameworkValueType() {
+ checkState(
+ valuesAreFrameworkType(), "called unwrappedFrameworkValueType() on %s", declaredMapType());
+ return uncheckedUnwrappedValueType();
+ }
+
+ /**
+ * {@code V} if {@link #valueType()} is a {@code WrappingClass<V>}.
+ *
+ * @throws IllegalStateException if {@link #isRawType()} is true or {@link #valueType()} is not a
+ * {@code WrappingClass<V>}
+ * @throws IllegalArgumentException if {@code wrappingClass} does not have exactly one type
+ * parameter
+ */
+ public TypeMirror unwrappedValueType(Class<?> wrappingClass) {
+ checkArgument(
+ wrappingClass.getTypeParameters().length == 1,
+ "%s must have exactly one type parameter",
+ wrappingClass);
+ checkState(valuesAreTypeOf(wrappingClass), "expected values to be %s: %s", wrappingClass, this);
+ return uncheckedUnwrappedValueType();
+ }
+
+ private TypeMirror uncheckedUnwrappedValueType() {
+ return MoreTypes.asDeclared(valueType()).getTypeArguments().get(0);
+ }
+
+ /**
+ * {@code true} if {@code type} is a {@link Map} type.
+ */
+ public static boolean isMap(TypeMirror type) {
+ return MoreTypes.isType(type) && MoreTypes.isTypeOf(Map.class, type);
+ }
+
+ /**
+ * {@code true} if {@code key.type()} is a {@link Map} type.
+ */
+ public static boolean isMap(Key key) {
+ return isMap(key.type());
+ }
+
+ /**
+ * Returns a {@link MapType} for {@code type}.
+ *
+ * @throws IllegalArgumentException if {@code type} is not a {@link Map} type
+ */
+ public static MapType from(TypeMirror type) {
+ checkArgument(isMap(type), "%s is not a Map", type);
+ return new AutoValue_MapType(MoreTypes.equivalence().wrap(MoreTypes.asDeclared(type)));
+ }
+
+ /**
+ * Returns a {@link MapType} for {@code key}'s {@link Key#type() type}.
+ *
+ * @throws IllegalArgumentException if {@code key.type()} is not a {@link Map} type
+ */
+ public static MapType from(Key key) {
+ return from(key.type());
+ }
+}
diff --git a/java/dagger/internal/codegen/base/ModuleAnnotation.java b/java/dagger/internal/codegen/base/ModuleAnnotation.java
new file mode 100644
index 0000000..1688736
--- /dev/null
+++ b/java/dagger/internal/codegen/base/ModuleAnnotation.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.base;
+
+import static com.google.auto.common.AnnotationMirrors.getAnnotationValue;
+import static com.google.auto.common.MoreTypes.asTypeElement;
+import static com.google.common.base.Preconditions.checkArgument;
+import static dagger.internal.codegen.base.MoreAnnotationValues.asAnnotationValues;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
+import static dagger.internal.codegen.langmodel.DaggerElements.getAnyAnnotation;
+
+import com.google.auto.common.MoreTypes;
+import com.google.auto.value.AutoValue;
+import com.google.auto.value.extension.memoized.Memoized;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import dagger.Module;
+import dagger.producers.ProducerModule;
+import java.lang.annotation.Annotation;
+import java.util.Optional;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
+import javax.lang.model.element.TypeElement;
+
+/** A {@code @Module} or {@code @ProducerModule} annotation. */
+@AutoValue
+public abstract class ModuleAnnotation {
+ private static final ImmutableSet<Class<? extends Annotation>> MODULE_ANNOTATIONS =
+ ImmutableSet.of(Module.class, ProducerModule.class);
+
+ /** The annotation itself. */
+ // This does not use AnnotationMirrors.equivalence() because we want the actual annotation
+ // instance.
+ public abstract AnnotationMirror annotation();
+
+ /** The simple name of the annotation. */
+ public String annotationName() {
+ return annotation().getAnnotationType().asElement().getSimpleName().toString();
+ }
+
+ /**
+ * The types specified in the {@code includes} attribute.
+ *
+ * @throws IllegalArgumentException if any of the values are error types
+ */
+ @Memoized
+ public ImmutableList<TypeElement> includes() {
+ return includesAsAnnotationValues().stream()
+ .map(MoreAnnotationValues::asType)
+ .map(MoreTypes::asTypeElement)
+ .collect(toImmutableList());
+ }
+
+ /** The values specified in the {@code includes} attribute. */
+ @Memoized
+ public ImmutableList<AnnotationValue> includesAsAnnotationValues() {
+ return asAnnotationValues(getAnnotationValue(annotation(), "includes"));
+ }
+
+ /**
+ * The types specified in the {@code subcomponents} attribute.
+ *
+ * @throws IllegalArgumentException if any of the values are error types
+ */
+ @Memoized
+ public ImmutableList<TypeElement> subcomponents() {
+ return subcomponentsAsAnnotationValues().stream()
+ .map(MoreAnnotationValues::asType)
+ .map(MoreTypes::asTypeElement)
+ .collect(toImmutableList());
+ }
+
+ /** The values specified in the {@code subcomponents} attribute. */
+ @Memoized
+ public ImmutableList<AnnotationValue> subcomponentsAsAnnotationValues() {
+ return asAnnotationValues(getAnnotationValue(annotation(), "subcomponents"));
+ }
+
+ /** Returns {@code true} if the argument is a {@code @Module} or {@code @ProducerModule}. */
+ public static boolean isModuleAnnotation(AnnotationMirror annotation) {
+ return MODULE_ANNOTATIONS.stream()
+ .map(Class::getCanonicalName)
+ .anyMatch(asTypeElement(annotation.getAnnotationType()).getQualifiedName()::contentEquals);
+ }
+
+ /** The module annotation types. */
+ public static ImmutableSet<Class<? extends Annotation>> moduleAnnotations() {
+ return MODULE_ANNOTATIONS;
+ }
+
+ /**
+ * Creates an object that represents a {@code @Module} or {@code @ProducerModule}.
+ *
+ * @throws IllegalArgumentException if {@link #isModuleAnnotation(AnnotationMirror)} returns
+ * {@code false}
+ */
+ public static ModuleAnnotation moduleAnnotation(AnnotationMirror annotation) {
+ checkArgument(
+ isModuleAnnotation(annotation),
+ "%s is not a Module or ProducerModule annotation",
+ annotation);
+ return new AutoValue_ModuleAnnotation(annotation);
+ }
+
+ /**
+ * Returns an object representing the {@code @Module} or {@code @ProducerModule} annotation if one
+ * annotates {@code typeElement}.
+ */
+ public static Optional<ModuleAnnotation> moduleAnnotation(TypeElement typeElement) {
+ return getAnyAnnotation(typeElement, Module.class, ProducerModule.class)
+ .map(ModuleAnnotation::moduleAnnotation);
+ }
+}
diff --git a/java/dagger/internal/codegen/base/MoreAnnotationMirrors.java b/java/dagger/internal/codegen/base/MoreAnnotationMirrors.java
new file mode 100644
index 0000000..234ecc1
--- /dev/null
+++ b/java/dagger/internal/codegen/base/MoreAnnotationMirrors.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.base;
+
+import static com.google.auto.common.AnnotationMirrors.getAnnotationValue;
+import static dagger.internal.codegen.base.MoreAnnotationValues.asAnnotationValues;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
+
+import com.google.auto.common.AnnotationMirrors;
+import com.google.common.base.Equivalence;
+import com.google.common.collect.ImmutableList;
+import java.util.Optional;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Name;
+import javax.lang.model.type.TypeMirror;
+
+/**
+ * A utility class for working with {@link AnnotationMirror} instances, similar to {@link
+ * AnnotationMirrors}.
+ */
+public final class MoreAnnotationMirrors {
+
+ private MoreAnnotationMirrors() {}
+
+ /**
+ * Wraps an {@link Optional} of a type in an {@code Optional} of a {@link Equivalence.Wrapper} for
+ * that type.
+ */
+ public static Optional<Equivalence.Wrapper<AnnotationMirror>> wrapOptionalInEquivalence(
+ Optional<AnnotationMirror> optional) {
+ return optional.map(AnnotationMirrors.equivalence()::wrap);
+ }
+
+ /**
+ * Unwraps an {@link Optional} of a {@link Equivalence.Wrapper} into an {@code Optional} of the
+ * underlying type.
+ */
+ public static Optional<AnnotationMirror> unwrapOptionalEquivalence(
+ Optional<Equivalence.Wrapper<AnnotationMirror>> wrappedOptional) {
+ return wrappedOptional.map(Equivalence.Wrapper::get);
+ }
+
+ public static Name simpleName(AnnotationMirror annotationMirror) {
+ return annotationMirror.getAnnotationType().asElement().getSimpleName();
+ }
+
+ /**
+ * Returns the list of types that is the value named {@code name} from {@code annotationMirror}.
+ *
+ * @throws IllegalArgumentException unless that member represents an array of types
+ */
+ public static ImmutableList<TypeMirror> getTypeListValue(
+ AnnotationMirror annotationMirror, String name) {
+ return asAnnotationValues(getAnnotationValue(annotationMirror, name))
+ .stream()
+ .map(MoreAnnotationValues::asType)
+ .collect(toImmutableList());
+ }
+}
diff --git a/java/dagger/internal/codegen/base/MoreAnnotationValues.java b/java/dagger/internal/codegen/base/MoreAnnotationValues.java
new file mode 100644
index 0000000..1ee50da
--- /dev/null
+++ b/java/dagger/internal/codegen/base/MoreAnnotationValues.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) 2013 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.base;
+
+import static com.google.auto.common.AnnotationMirrors.getAnnotationValue;
+import static com.google.auto.common.AnnotationMirrors.getAnnotationValuesWithDefaults;
+
+import com.google.common.collect.ImmutableList;
+import java.util.List;
+import java.util.Optional;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
+import javax.lang.model.element.AnnotationValueVisitor;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.SimpleAnnotationValueVisitor8;
+
+/** Utility methods for working with {@link AnnotationValue} instances. */
+public final class MoreAnnotationValues {
+ /**
+ * Returns the list of values represented by an array annotation value.
+ *
+ * @throws IllegalArgumentException unless {@code annotationValue} represents an array
+ */
+ public static ImmutableList<AnnotationValue> asAnnotationValues(AnnotationValue annotationValue) {
+ return annotationValue.accept(AS_ANNOTATION_VALUES, null);
+ }
+
+ private static final AnnotationValueVisitor<ImmutableList<AnnotationValue>, String>
+ AS_ANNOTATION_VALUES =
+ new SimpleAnnotationValueVisitor8<ImmutableList<AnnotationValue>, String>() {
+ @Override
+ public ImmutableList<AnnotationValue> visitArray(
+ List<? extends AnnotationValue> vals, String elementName) {
+ return ImmutableList.copyOf(vals);
+ }
+
+ @Override
+ protected ImmutableList<AnnotationValue> defaultAction(Object o, String elementName) {
+ throw new IllegalArgumentException(elementName + " is not an array: " + o);
+ }
+ };
+
+ /**
+ * Returns the type represented by an annotation value.
+ *
+ * @throws IllegalArgumentException unless {@code annotationValue} represents a single type
+ */
+ public static TypeMirror asType(AnnotationValue annotationValue) {
+ return AS_TYPE.visit(annotationValue);
+ }
+
+ private static final AnnotationValueVisitor<TypeMirror, Void> AS_TYPE =
+ new SimpleAnnotationValueVisitor8<TypeMirror, Void>() {
+ @Override
+ public TypeMirror visitType(TypeMirror t, Void p) {
+ return t;
+ }
+
+ @Override
+ protected TypeMirror defaultAction(Object o, Void p) {
+ throw new TypeNotPresentException(o.toString(), null);
+ }
+ };
+
+ /** Returns the int value of an annotation */
+ public static int getIntValue(AnnotationMirror annotation, String valueName) {
+ return (int) getAnnotationValue(annotation, valueName).getValue();
+ }
+
+ /** Returns an optional int value of an annotation if the value name is present */
+ public static Optional<Integer> getOptionalIntValue(
+ AnnotationMirror annotation, String valueName) {
+ return isValuePresent(annotation, valueName)
+ ? Optional.of(getIntValue(annotation, valueName))
+ : Optional.empty();
+ }
+
+ /** Returns the String value of an annotation */
+ public static String getStringValue(AnnotationMirror annotation, String valueName) {
+ return (String) getAnnotationValue(annotation, valueName).getValue();
+ }
+
+ /** Returns an optional String value of an annotation if the value name is present */
+ public static Optional<String> getOptionalStringValue(
+ AnnotationMirror annotation, String valueName) {
+ return isValuePresent(annotation, valueName)
+ ? Optional.of(getStringValue(annotation, valueName))
+ : Optional.empty();
+ }
+
+ /** Returns the int array value of an annotation */
+ public static int[] getIntArrayValue(AnnotationMirror annotation, String valueName) {
+ return asAnnotationValues(getAnnotationValue(annotation, valueName)).stream()
+ .mapToInt(it -> (int) it.getValue())
+ .toArray();
+ }
+
+ /** Returns the String array value of an annotation */
+ public static String[] getStringArrayValue(AnnotationMirror annotation, String valueName) {
+ return asAnnotationValues(getAnnotationValue(annotation, valueName)).stream()
+ .map(it -> (String) it.getValue())
+ .toArray(String[]::new);
+ }
+
+ private static boolean isValuePresent(AnnotationMirror annotation, String valueName) {
+ return getAnnotationValuesWithDefaults(annotation).keySet().stream()
+ .anyMatch(member -> member.getSimpleName().contentEquals(valueName));
+ }
+
+ private MoreAnnotationValues() {}
+}
diff --git a/java/dagger/internal/codegen/base/MultibindingAnnotations.java b/java/dagger/internal/codegen/base/MultibindingAnnotations.java
new file mode 100644
index 0000000..424f92a
--- /dev/null
+++ b/java/dagger/internal/codegen/base/MultibindingAnnotations.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.base;
+
+import static dagger.internal.codegen.langmodel.DaggerElements.getAllAnnotations;
+
+import com.google.common.collect.ImmutableSet;
+import dagger.multibindings.ElementsIntoSet;
+import dagger.multibindings.IntoMap;
+import dagger.multibindings.IntoSet;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Element;
+
+/**
+ * Utility methods related to processing {@link IntoSet}, {@link ElementsIntoSet}, and {@link
+ * IntoMap}.
+ */
+public final class MultibindingAnnotations {
+ public static ImmutableSet<AnnotationMirror> forElement(Element method) {
+ return getAllAnnotations(method, IntoSet.class, ElementsIntoSet.class, IntoMap.class);
+ }
+}
diff --git a/java/dagger/internal/codegen/base/OptionalType.java b/java/dagger/internal/codegen/base/OptionalType.java
new file mode 100644
index 0000000..1505682
--- /dev/null
+++ b/java/dagger/internal/codegen/base/OptionalType.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.base;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.MoreTypes;
+import com.google.auto.value.AutoValue;
+import com.google.common.base.Equivalence;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.ParameterizedTypeName;
+import com.squareup.javapoet.TypeName;
+import dagger.model.Key;
+import java.util.Optional;
+import javax.lang.model.element.Name;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.type.TypeVisitor;
+import javax.lang.model.util.SimpleTypeVisitor8;
+
+/**
+ * Information about an {@code Optional} {@link TypeMirror}.
+ *
+ * <p>{@link com.google.common.base.Optional} and {@link java.util.Optional} are supported.
+ */
+@AutoValue
+public abstract class OptionalType {
+
+ /** A variant of {@code Optional}. */
+ public enum OptionalKind {
+ /** {@link com.google.common.base.Optional}. */
+ GUAVA_OPTIONAL(com.google.common.base.Optional.class, "absent"),
+
+ /** {@link java.util.Optional}. */
+ JDK_OPTIONAL(java.util.Optional.class, "empty"),
+ ;
+
+ private final Class<?> clazz;
+ private final String absentFactoryMethodName;
+
+ OptionalKind(Class<?> clazz, String absentFactoryMethodName) {
+ this.clazz = clazz;
+ this.absentFactoryMethodName = absentFactoryMethodName;
+ }
+
+ /** Returns {@code valueType} wrapped in the correct class. */
+ public ParameterizedTypeName of(TypeName valueType) {
+ return ParameterizedTypeName.get(ClassName.get(clazz), valueType);
+ }
+
+ /** Returns an expression for the absent/empty value. */
+ public CodeBlock absentValueExpression() {
+ return CodeBlock.of("$T.$L()", clazz, absentFactoryMethodName);
+ }
+
+ /**
+ * Returns an expression for the absent/empty value, parameterized with {@link #valueType()}.
+ */
+ public CodeBlock parameterizedAbsentValueExpression(OptionalType optionalType) {
+ return CodeBlock.of("$T.<$T>$L()", clazz, optionalType.valueType(), absentFactoryMethodName);
+ }
+
+ /** Returns an expression for the present {@code value}. */
+ public CodeBlock presentExpression(CodeBlock value) {
+ return CodeBlock.of("$T.of($L)", clazz, value);
+ }
+
+ /**
+ * Returns an expression for the present {@code value}, returning {@code Optional<Object>} no
+ * matter what type the value is.
+ */
+ public CodeBlock presentObjectExpression(CodeBlock value) {
+ return CodeBlock.of("$T.<$T>of($L)", clazz, Object.class, value);
+ }
+ }
+
+ private static final TypeVisitor<Optional<OptionalKind>, Void> OPTIONAL_KIND =
+ new SimpleTypeVisitor8<Optional<OptionalKind>, Void>(Optional.empty()) {
+ @Override
+ public Optional<OptionalKind> visitDeclared(DeclaredType t, Void p) {
+ for (OptionalKind optionalKind : OptionalKind.values()) {
+ Name qualifiedName = MoreElements.asType(t.asElement()).getQualifiedName();
+ if (qualifiedName.contentEquals(optionalKind.clazz.getCanonicalName())) {
+ return Optional.of(optionalKind);
+ }
+ }
+ return Optional.empty();
+ }
+ };
+
+ /**
+ * The optional type itself, wrapped using {@link MoreTypes#equivalence()}.
+ *
+ * @deprecated Use {@link #declaredOptionalType()} instead.
+ */
+ @Deprecated
+ protected abstract Equivalence.Wrapper<DeclaredType> wrappedDeclaredOptionalType();
+
+ /** The optional type itself. */
+ @SuppressWarnings("deprecation")
+ private DeclaredType declaredOptionalType() {
+ return wrappedDeclaredOptionalType().get();
+ }
+
+ /** Which {@code Optional} type is used. */
+ public OptionalKind kind() {
+ return declaredOptionalType().accept(OPTIONAL_KIND, null).get();
+ }
+
+ /** The value type. */
+ public TypeMirror valueType() {
+ return declaredOptionalType().getTypeArguments().get(0);
+ }
+
+ /** Returns {@code true} if {@code type} is an {@code Optional} type. */
+ private static boolean isOptional(TypeMirror type) {
+ return type.accept(OPTIONAL_KIND, null).isPresent();
+ }
+
+ /** Returns {@code true} if {@code key.type()} is an {@code Optional} type. */
+ public static boolean isOptional(Key key) {
+ return isOptional(key.type());
+ }
+
+ /**
+ * Returns a {@link OptionalType} for {@code type}.
+ *
+ * @throws IllegalArgumentException if {@code type} is not an {@code Optional} type
+ */
+ public static OptionalType from(TypeMirror type) {
+ checkArgument(isOptional(type), "%s must be an Optional", type);
+ return new AutoValue_OptionalType(MoreTypes.equivalence().wrap(MoreTypes.asDeclared(type)));
+ }
+
+ /**
+ * Returns a {@link OptionalType} for {@code key}'s {@link Key#type() type}.
+ *
+ * @throws IllegalArgumentException if {@code key.type()} is not an {@code Optional} type
+ */
+ public static OptionalType from(Key key) {
+ return from(key.type());
+ }
+}
diff --git a/java/dagger/internal/codegen/base/RequestKinds.java b/java/dagger/internal/codegen/base/RequestKinds.java
new file mode 100644
index 0000000..95d5ef4
--- /dev/null
+++ b/java/dagger/internal/codegen/base/RequestKinds.java
@@ -0,0 +1,189 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.base;
+
+import static com.google.auto.common.MoreTypes.asDeclared;
+import static com.google.auto.common.MoreTypes.isType;
+import static com.google.auto.common.MoreTypes.isTypeOf;
+import static com.google.common.base.Preconditions.checkArgument;
+import static dagger.internal.codegen.javapoet.TypeNames.lazyOf;
+import static dagger.internal.codegen.javapoet.TypeNames.listenableFutureOf;
+import static dagger.internal.codegen.javapoet.TypeNames.producedOf;
+import static dagger.internal.codegen.javapoet.TypeNames.producerOf;
+import static dagger.internal.codegen.javapoet.TypeNames.providerOf;
+import static dagger.internal.codegen.langmodel.DaggerTypes.checkTypePresent;
+import static dagger.model.RequestKind.LAZY;
+import static dagger.model.RequestKind.PRODUCED;
+import static dagger.model.RequestKind.PRODUCER;
+import static dagger.model.RequestKind.PROVIDER;
+import static dagger.model.RequestKind.PROVIDER_OF_LAZY;
+import static javax.lang.model.type.TypeKind.DECLARED;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.squareup.javapoet.TypeName;
+import dagger.Lazy;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.RequestKind;
+import dagger.producers.Produced;
+import dagger.producers.Producer;
+import javax.inject.Provider;
+import javax.lang.model.type.TypeMirror;
+
+/** Utility methods for {@link RequestKind}s. */
+public final class RequestKinds {
+
+ /** Returns the type of a request of this kind for a key with a given type. */
+ public static TypeMirror requestType(
+ RequestKind requestKind, TypeMirror type, DaggerTypes types) {
+ switch (requestKind) {
+ case INSTANCE:
+ return type;
+
+ case PROVIDER_OF_LAZY:
+ return types.wrapType(requestType(LAZY, type, types), Provider.class);
+
+ case FUTURE:
+ return types.wrapType(type, ListenableFuture.class);
+
+ default:
+ return types.wrapType(type, frameworkClass(requestKind));
+ }
+ }
+
+ /** Returns the type of a request of this kind for a key with a given type. */
+ public static TypeName requestTypeName(RequestKind requestKind, TypeName keyType) {
+ switch (requestKind) {
+ case INSTANCE:
+ return keyType;
+
+ case PROVIDER:
+ return providerOf(keyType);
+
+ case LAZY:
+ return lazyOf(keyType);
+
+ case PROVIDER_OF_LAZY:
+ return providerOf(lazyOf(keyType));
+
+ case PRODUCER:
+ return producerOf(keyType);
+
+ case PRODUCED:
+ return producedOf(keyType);
+
+ case FUTURE:
+ return listenableFutureOf(keyType);
+
+ default:
+ throw new AssertionError(requestKind);
+ }
+ }
+
+ private static final ImmutableMap<RequestKind, Class<?>> FRAMEWORK_CLASSES =
+ ImmutableMap.of(
+ PROVIDER, Provider.class,
+ LAZY, Lazy.class,
+ PRODUCER, Producer.class,
+ PRODUCED, Produced.class);
+
+ /** Returns the {@link RequestKind} that matches the wrapping types (if any) of {@code type}. */
+ public static RequestKind getRequestKind(TypeMirror type) {
+ checkTypePresent(type);
+ if (!isType(type) // TODO(b/147320669): isType check can be removed once this bug is fixed.
+ || !type.getKind().equals(DECLARED)
+ || asDeclared(type).getTypeArguments().isEmpty()) {
+ // If the type is not a declared type (i.e. class or interface) with type arguments, then we
+ // know it can't be a parameterized type of one of the framework classes, so return INSTANCE.
+ return RequestKind.INSTANCE;
+ }
+ for (RequestKind kind : FRAMEWORK_CLASSES.keySet()) {
+ if (isTypeOf(frameworkClass(kind), type)) {
+ if (kind.equals(PROVIDER) && getRequestKind(DaggerTypes.unwrapType(type)).equals(LAZY)) {
+ return PROVIDER_OF_LAZY;
+ }
+ return kind;
+ }
+ }
+ return RequestKind.INSTANCE;
+ }
+
+ /**
+ * Unwraps the framework class(es) of {@code requestKind} from {@code type}. If {@code
+ * requestKind} is {@link RequestKind#INSTANCE}, this acts as an identity function.
+ *
+ * @throws TypeNotPresentException if {@code type} is an {@link javax.lang.model.type.ErrorType},
+ * which may mean that the type will be generated in a later round of processing
+ * @throws IllegalArgumentException if {@code type} is not wrapped with {@code requestKind}'s
+ * framework class(es).
+ */
+ public static TypeMirror extractKeyType(TypeMirror type) {
+ return extractKeyType(getRequestKind(type), type);
+ }
+
+ private static TypeMirror extractKeyType(RequestKind requestKind, TypeMirror type) {
+ switch (requestKind) {
+ case INSTANCE:
+ return type;
+ case PROVIDER_OF_LAZY:
+ return extractKeyType(LAZY, extractKeyType(PROVIDER, type));
+ default:
+ checkArgument(isType(type));
+ return DaggerTypes.unwrapType(type);
+ }
+ }
+
+ /**
+ * A dagger- or {@code javax.inject}-defined class for {@code requestKind} that that can wrap
+ * another type but share the same {@link dagger.model.Key}.
+ *
+ * <p>For example, {@code Provider<String>} and {@code Lazy<String>} can both be requested if a
+ * key exists for {@code String}; they all share the same key.
+ *
+ * <p>This concept is not well defined and should probably be removed and inlined into the cases
+ * that need it. For example, {@link RequestKind#PROVIDER_OF_LAZY} has <em>2</em> wrapping
+ * classes, and {@link RequestKind#FUTURE} is wrapped with a {@link ListenableFuture}, but for
+ * historical/implementation reasons has not had an associated framework class.
+ */
+ public static Class<?> frameworkClass(RequestKind requestKind) {
+ Class<?> result = FRAMEWORK_CLASSES.get(requestKind);
+ checkArgument(result != null, "no framework class for %s", requestKind);
+ return result;
+ }
+
+ /**
+ * Returns {@code true} if requests for {@code requestKind} can be satisfied by a production
+ * binding.
+ */
+ public static boolean canBeSatisfiedByProductionBinding(RequestKind requestKind) {
+ switch (requestKind) {
+ case INSTANCE:
+ case PROVIDER:
+ case LAZY:
+ case PROVIDER_OF_LAZY:
+ case MEMBERS_INJECTION:
+ return false;
+ case PRODUCER:
+ case PRODUCED:
+ case FUTURE:
+ return true;
+ }
+ throw new AssertionError();
+ }
+
+ private RequestKinds() {}
+}
diff --git a/java/dagger/internal/codegen/base/Scopes.java b/java/dagger/internal/codegen/base/Scopes.java
new file mode 100644
index 0000000..f2c39ce
--- /dev/null
+++ b/java/dagger/internal/codegen/base/Scopes.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.base;
+
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static dagger.internal.codegen.base.DiagnosticFormatting.stripCommonTypePrefixes;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+
+import com.google.auto.common.AnnotationMirrors;
+import com.google.common.collect.ImmutableSet;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.model.Scope;
+import dagger.producers.ProductionScope;
+import java.lang.annotation.Annotation;
+import java.util.Optional;
+import javax.inject.Singleton;
+import javax.lang.model.element.Element;
+
+/** Common names and convenience methods for {@link Scope}s. */
+public final class Scopes {
+
+ /** Returns a representation for {@link ProductionScope @ProductionScope} scope. */
+ public static Scope productionScope(DaggerElements elements) {
+ return scope(elements, ProductionScope.class);
+ }
+
+ /** Returns a representation for {@link Singleton @Singleton} scope. */
+ public static Scope singletonScope(DaggerElements elements) {
+ return scope(elements, Singleton.class);
+ }
+
+ /**
+ * Creates a {@link Scope} object from the {@link javax.inject.Scope}-annotated annotation type.
+ */
+ private static Scope scope(
+ DaggerElements elements, Class<? extends Annotation> scopeAnnotationClass) {
+ return Scope.scope(SimpleAnnotationMirror.of(elements.getTypeElement(scopeAnnotationClass)));
+ }
+
+ /**
+ * Returns at most one associated scoped annotation from the source code element, throwing an
+ * exception if there are more than one.
+ */
+ public static Optional<Scope> uniqueScopeOf(Element element) {
+ // TODO(ronshapiro): Use MoreCollectors.toOptional() once we can use guava-jre
+ return Optional.ofNullable(getOnlyElement(scopesOf(element), null));
+ }
+
+ /**
+ * Returns the readable source representation (name with @ prefix) of the scope's annotation type.
+ *
+ * <p>It's readable source because it has had common package prefixes removed, e.g.
+ * {@code @javax.inject.Singleton} is returned as {@code @Singleton}.
+ */
+ public static String getReadableSource(Scope scope) {
+ return stripCommonTypePrefixes(scope.toString());
+ }
+
+ /** Returns all of the associated scopes for a source code element. */
+ public static ImmutableSet<Scope> scopesOf(Element element) {
+ return AnnotationMirrors.getAnnotatedAnnotations(element, javax.inject.Scope.class)
+ .stream()
+ .map(Scope::scope)
+ .collect(toImmutableSet());
+ }
+}
diff --git a/java/dagger/internal/codegen/base/SetType.java b/java/dagger/internal/codegen/base/SetType.java
new file mode 100644
index 0000000..a75a6d3
--- /dev/null
+++ b/java/dagger/internal/codegen/base/SetType.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.base;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import com.google.auto.common.MoreTypes;
+import com.google.auto.value.AutoValue;
+import com.google.common.base.Equivalence;
+import dagger.model.Key;
+import java.util.Set;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeMirror;
+
+/**
+ * Information about a {@link Set} {@link TypeMirror}.
+ */
+@AutoValue
+public abstract class SetType {
+ /**
+ * The set type itself, wrapped using {@link MoreTypes#equivalence()}. Use
+ * {@link #declaredSetType()} instead.
+ */
+ protected abstract Equivalence.Wrapper<DeclaredType> wrappedDeclaredSetType();
+
+ /**
+ * The set type itself.
+ */
+ private DeclaredType declaredSetType() {
+ return wrappedDeclaredSetType().get();
+ }
+
+ /**
+ * {@code true} if the set type is the raw {@link Set} type.
+ */
+ public boolean isRawType() {
+ return declaredSetType().getTypeArguments().isEmpty();
+ }
+
+ /**
+ * The element type.
+ */
+ public TypeMirror elementType() {
+ return declaredSetType().getTypeArguments().get(0);
+ }
+
+ /**
+ * {@code true} if {@link #elementType()} is a {@code clazz}.
+ */
+ public boolean elementsAreTypeOf(Class<?> clazz) {
+ return MoreTypes.isType(elementType()) && MoreTypes.isTypeOf(clazz, elementType());
+ }
+
+ /**
+ * {@code T} if {@link #elementType()} is a {@code WrappingClass<T>}.
+ *
+ * @throws IllegalStateException if {@link #elementType()} is not a {@code WrappingClass<T>}
+ * @throws IllegalArgumentException if {@code wrappingClass} does not have exactly one type
+ * parameter
+ */
+ public TypeMirror unwrappedElementType(Class<?> wrappingClass) {
+ checkArgument(
+ wrappingClass.getTypeParameters().length == 1,
+ "%s must have exactly one type parameter",
+ wrappingClass);
+ checkArgument(
+ elementsAreTypeOf(wrappingClass),
+ "expected elements to be %s, but this type is %s",
+ wrappingClass,
+ declaredSetType());
+ return MoreTypes.asDeclared(elementType()).getTypeArguments().get(0);
+ }
+
+ /**
+ * {@code true} if {@code type} is a {@link Set} type.
+ */
+ public static boolean isSet(TypeMirror type) {
+ return MoreTypes.isType(type) && MoreTypes.isTypeOf(Set.class, type);
+ }
+
+ /**
+ * {@code true} if {@code key.type()} is a {@link Set} type.
+ */
+ public static boolean isSet(Key key) {
+ return isSet(key.type());
+ }
+
+ /**
+ * Returns a {@link SetType} for {@code type}.
+ *
+ * @throws IllegalArgumentException if {@code type} is not a {@link Set} type
+ */
+ public static SetType from(TypeMirror type) {
+ checkArgument(isSet(type), "%s must be a Set", type);
+ return new AutoValue_SetType(MoreTypes.equivalence().wrap(MoreTypes.asDeclared(type)));
+ }
+
+ /**
+ * Returns a {@link SetType} for {@code key}'s {@link Key#type() type}.
+ *
+ * @throws IllegalArgumentException if {@code key.type()} is not a {@link Set} type
+ */
+ public static SetType from(Key key) {
+ return from (key.type());
+ }
+}
diff --git a/java/dagger/internal/codegen/base/SimpleAnnotationMirror.java b/java/dagger/internal/codegen/base/SimpleAnnotationMirror.java
new file mode 100644
index 0000000..9690691
--- /dev/null
+++ b/java/dagger/internal/codegen/base/SimpleAnnotationMirror.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.base;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static javax.lang.model.util.ElementFilter.methodsIn;
+
+import com.google.auto.common.MoreTypes;
+import com.google.common.base.Functions;
+import com.google.common.base.Joiner;
+import com.google.common.collect.FluentIterable;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Maps;
+import java.util.Map;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.DeclaredType;
+
+/** A representation of an annotation. */
+public final class SimpleAnnotationMirror implements AnnotationMirror {
+ private final TypeElement annotationType;
+ private final ImmutableMap<String, ? extends AnnotationValue> namedValues;
+ private final ImmutableMap<ExecutableElement, ? extends AnnotationValue> elementValues;
+
+ private SimpleAnnotationMirror(
+ TypeElement annotationType, Map<String, ? extends AnnotationValue> namedValues) {
+ checkArgument(
+ annotationType.getKind().equals(ElementKind.ANNOTATION_TYPE),
+ "annotationType must be an annotation: %s",
+ annotationType);
+ checkArgument(
+ FluentIterable.from(methodsIn(annotationType.getEnclosedElements()))
+ .transform(element -> element.getSimpleName().toString())
+ .toSet()
+ .equals(namedValues.keySet()),
+ "namedValues must have values for exactly the members in %s: %s",
+ annotationType,
+ namedValues);
+ this.annotationType = annotationType;
+ this.namedValues = ImmutableMap.copyOf(namedValues);
+ this.elementValues =
+ Maps.toMap(
+ methodsIn(annotationType.getEnclosedElements()),
+ Functions.compose(
+ Functions.forMap(namedValues), element -> element.getSimpleName().toString()));
+ }
+
+ @Override
+ public DeclaredType getAnnotationType() {
+ return MoreTypes.asDeclared(annotationType.asType());
+ }
+
+ @Override
+ public Map<ExecutableElement, ? extends AnnotationValue> getElementValues() {
+ return elementValues;
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder builder = new StringBuilder("@").append(annotationType.getQualifiedName());
+ if (!namedValues.isEmpty()) {
+ builder
+ .append('(')
+ .append(Joiner.on(", ").withKeyValueSeparator(" = ").join(namedValues))
+ .append(')');
+ }
+ return builder.toString();
+ }
+
+ /**
+ * An object representing an annotation instance.
+ *
+ * @param annotationType must be an annotation type with no members
+ */
+ public static AnnotationMirror of(TypeElement annotationType) {
+ return of(annotationType, ImmutableMap.<String, AnnotationValue>of());
+ }
+
+ /**
+ * An object representing an annotation instance.
+ *
+ * @param annotationType must be an annotation type
+ * @param namedValues a value for every annotation member, including those with defaults, indexed
+ * by simple name
+ */
+ private static AnnotationMirror of(
+ TypeElement annotationType, Map<String, ? extends AnnotationValue> namedValues) {
+ return new SimpleAnnotationMirror(annotationType, namedValues);
+ }
+}
diff --git a/java/dagger/internal/codegen/base/SimpleTypeAnnotationValue.java b/java/dagger/internal/codegen/base/SimpleTypeAnnotationValue.java
new file mode 100644
index 0000000..d595bcb
--- /dev/null
+++ b/java/dagger/internal/codegen/base/SimpleTypeAnnotationValue.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.base;
+
+import javax.lang.model.element.AnnotationValue;
+import javax.lang.model.element.AnnotationValueVisitor;
+import javax.lang.model.type.TypeMirror;
+
+/** An {@link AnnotationValue} that contains a {@link TypeMirror}. */
+final class SimpleTypeAnnotationValue implements AnnotationValue {
+ private final TypeMirror value;
+
+ SimpleTypeAnnotationValue(TypeMirror value) {
+ this.value = value;
+ }
+
+ @Override
+ public TypeMirror getValue() {
+ return value;
+ }
+
+ @Override
+ public String toString() {
+ return value + ".class";
+ }
+
+ @Override
+ public <R, P> R accept(AnnotationValueVisitor<R, P> visitor, P parameter) {
+ return visitor.visitType(getValue(), parameter);
+ }
+}
diff --git a/java/dagger/internal/codegen/base/SourceFileGenerationException.java b/java/dagger/internal/codegen/base/SourceFileGenerationException.java
new file mode 100644
index 0000000..5553dd8
--- /dev/null
+++ b/java/dagger/internal/codegen/base/SourceFileGenerationException.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.base;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static javax.tools.Diagnostic.Kind.ERROR;
+
+import com.squareup.javapoet.ClassName;
+import java.util.Optional;
+import javax.annotation.processing.Messager;
+import javax.lang.model.element.Element;
+
+/**
+ * An exception thrown to indicate that a source file could not be generated.
+ *
+ * <p>This exception <b>should not</b> be used to report detectable, logical errors as it may mask
+ * other errors that might have been caught upon further processing. Use a {@link ValidationReport}
+ * for that.
+ */
+public final class SourceFileGenerationException extends Exception {
+ private final Element associatedElement;
+
+ SourceFileGenerationException(
+ Optional<ClassName> generatedClassName, Throwable cause, Element associatedElement) {
+ super(createMessage(generatedClassName, cause.getMessage()), cause);
+ this.associatedElement = checkNotNull(associatedElement);
+ }
+
+ private static String createMessage(Optional<ClassName> generatedClassName, String message) {
+ return String.format("Could not generate %s: %s.",
+ generatedClassName.isPresent()
+ ? generatedClassName.get()
+ : "unknown file",
+ message);
+ }
+
+ public void printMessageTo(Messager messager) {
+ messager.printMessage(ERROR, getMessage(), associatedElement);
+ }
+}
diff --git a/java/dagger/internal/codegen/base/SourceFileGenerator.java b/java/dagger/internal/codegen/base/SourceFileGenerator.java
new file mode 100644
index 0000000..02348a4
--- /dev/null
+++ b/java/dagger/internal/codegen/base/SourceFileGenerator.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.base;
+
+import static com.google.auto.common.GeneratedAnnotations.generatedAnnotation;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression.RAWTYPES;
+import static dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression.UNCHECKED;
+
+import com.google.common.base.Throwables;
+import com.google.common.collect.ImmutableSet;
+import com.squareup.javapoet.AnnotationSpec;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.TypeSpec;
+import dagger.internal.codegen.javapoet.AnnotationSpecs;
+import dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import java.util.Optional;
+import javax.annotation.processing.Filer;
+import javax.annotation.processing.Messager;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Element;
+
+/**
+ * A template class that provides a framework for properly handling IO while generating source files
+ * from an annotation processor. Particularly, it makes a best effort to ensure that files that fail
+ * to write successfully are deleted.
+ *
+ * @param <T> The input type from which source is to be generated.
+ */
+public abstract class SourceFileGenerator<T> {
+ private static final String GENERATED_COMMENTS = "https://dagger.dev";
+
+ private final Filer filer;
+ private final DaggerElements elements;
+ private final SourceVersion sourceVersion;
+
+ public SourceFileGenerator(Filer filer, DaggerElements elements, SourceVersion sourceVersion) {
+ this.filer = checkNotNull(filer);
+ this.elements = checkNotNull(elements);
+ this.sourceVersion = checkNotNull(sourceVersion);
+ }
+
+ public SourceFileGenerator(SourceFileGenerator<T> delegate) {
+ this(delegate.filer, delegate.elements, delegate.sourceVersion);
+ }
+
+ /**
+ * Generates a source file to be compiled for {@code T}. Writes any generation exception to {@code
+ * messager} and does not throw.
+ */
+ public void generate(T input, Messager messager) {
+ try {
+ generate(input);
+ } catch (SourceFileGenerationException e) {
+ e.printMessageTo(messager);
+ }
+ }
+
+ /** Generates a source file to be compiled for {@code T}. */
+ public void generate(T input) throws SourceFileGenerationException {
+ Optional<TypeSpec.Builder> type = write(input);
+ if (!type.isPresent()) {
+ return;
+ }
+ try {
+ buildJavaFile(input, type.get()).writeTo(filer);
+ } catch (Exception e) {
+ // if the code above threw a SFGE, use that
+ Throwables.propagateIfPossible(e, SourceFileGenerationException.class);
+ // otherwise, throw a new one
+ throw new SourceFileGenerationException(Optional.empty(), e, originatingElement(input));
+ }
+ }
+
+ private JavaFile buildJavaFile(T input, TypeSpec.Builder typeSpecBuilder) {
+ typeSpecBuilder.addOriginatingElement(originatingElement(input));
+ Optional<AnnotationSpec> generatedAnnotation =
+ generatedAnnotation(elements, sourceVersion)
+ .map(
+ annotation ->
+ AnnotationSpec.builder(ClassName.get(annotation))
+ .addMember("value", "$S", "dagger.internal.codegen.ComponentProcessor")
+ .addMember("comments", "$S", GENERATED_COMMENTS)
+ .build());
+ generatedAnnotation.ifPresent(typeSpecBuilder::addAnnotation);
+
+ // TODO(b/134590785): remove this and only suppress annotations locally, if necessary
+ typeSpecBuilder.addAnnotation(
+ AnnotationSpecs.suppressWarnings(
+ ImmutableSet.<Suppression>builder()
+ .addAll(warningSuppressions())
+ .add(UNCHECKED, RAWTYPES)
+ .build()));
+
+ JavaFile.Builder javaFileBuilder =
+ JavaFile.builder(nameGeneratedType(input).packageName(), typeSpecBuilder.build())
+ .skipJavaLangImports(true);
+ if (!generatedAnnotation.isPresent()) {
+ javaFileBuilder.addFileComment("Generated by Dagger ($L).", GENERATED_COMMENTS);
+ }
+ return javaFileBuilder.build();
+ }
+
+ /** Implementations should return the {@link ClassName} for the top-level type to be generated. */
+ public abstract ClassName nameGeneratedType(T input);
+
+ /** Returns the originating element of the generating type. */
+ public abstract Element originatingElement(T input);
+
+ /**
+ * Returns a {@link TypeSpec.Builder type} to be generated for {@code T}, or {@link
+ * Optional#empty()} if no file should be generated.
+ */
+ // TODO(ronshapiro): write() makes more sense in JavaWriter where all writers are mutable.
+ // consider renaming to something like typeBuilder() which conveys the mutability of the result
+ public abstract Optional<TypeSpec.Builder> write(T input);
+
+ /** Returns {@link Suppression}s that are applied to files generated by this generator. */
+ // TODO(b/134590785): When suppressions are removed locally, remove this and inline the usages
+ protected ImmutableSet<Suppression> warningSuppressions() {
+ return ImmutableSet.of();
+ }
+}
diff --git a/java/dagger/internal/codegen/base/UniqueNameSet.java b/java/dagger/internal/codegen/base/UniqueNameSet.java
new file mode 100644
index 0000000..c1ffe47
--- /dev/null
+++ b/java/dagger/internal/codegen/base/UniqueNameSet.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.base;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/** A collector for names to be used in the same namespace that should not conflict. */
+public final class UniqueNameSet {
+ private final Set<String> uniqueNames = new HashSet<>();
+
+ /**
+ * Generates a unique name using {@code base}. If {@code base} has not yet been added, it will be
+ * returned as-is. If your {@code base} is healthy, this will always return {@code base}.
+ */
+ public String getUniqueName(CharSequence base) {
+ String name = base.toString();
+ for (int differentiator = 2; !uniqueNames.add(name); differentiator++) {
+ name = base.toString() + differentiator;
+ }
+ return name;
+ }
+
+ /**
+ * Adds {@code name} without any modification to the name set. Has no effect if {@code name} is
+ * already present in the set.
+ */
+ public void claim(CharSequence name) {
+ uniqueNames.add(name.toString());
+ }
+}
diff --git a/java/dagger/internal/codegen/base/Util.java b/java/dagger/internal/codegen/base/Util.java
new file mode 100644
index 0000000..e92b8ab
--- /dev/null
+++ b/java/dagger/internal/codegen/base/Util.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2013 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.base;
+
+import java.util.Map;
+import java.util.function.Function;
+
+/** General utilities for the annotation processor. */
+public final class Util {
+
+ /**
+ * A version of {@link Map#computeIfAbsent(Object, Function)} that allows {@code mappingFunction}
+ * to update {@code map}.
+ */
+ public static <K, V> V reentrantComputeIfAbsent(
+ Map<K, V> map, K key, Function<? super K, ? extends V> mappingFunction) {
+ V value = map.get(key);
+ if (value == null) {
+ value = mappingFunction.apply(key);
+ if (value != null) {
+ map.put(key, value);
+ }
+ }
+ return value;
+ }
+
+ private Util() {}
+}
diff --git a/java/dagger/internal/codegen/binding/AnnotationExpression.java b/java/dagger/internal/codegen/binding/AnnotationExpression.java
new file mode 100644
index 0000000..de0aea5
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/AnnotationExpression.java
@@ -0,0 +1,208 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.auto.common.AnnotationMirrors.getAnnotationValuesWithDefaults;
+import static dagger.internal.codegen.binding.SourceFiles.classFileName;
+import static dagger.internal.codegen.javapoet.CodeBlocks.makeParametersCodeBlock;
+import static java.util.stream.Collectors.toList;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.MoreTypes;
+import com.google.common.collect.ImmutableList;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.TypeName;
+import java.util.List;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.ArrayType;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.SimpleAnnotationValueVisitor6;
+import javax.lang.model.util.SimpleTypeVisitor6;
+
+/**
+ * Returns an expression creating an instance of the visited annotation type. Its parameter must be
+ * a class as generated by {@link dagger.internal.codegen.writing.AnnotationCreatorGenerator}.
+ *
+ * <p>Note that {@link AnnotationValue#toString()} is the source-code representation of the value
+ * <em>when used in an annotation</em>, which is not always the same as the representation needed
+ * when creating the value in a method body.
+ *
+ * <p>For example, inside an annotation, a nested array of {@code int}s is simply {@code {1, 2, 3}},
+ * but in code it would have to be {@code new int[] {1, 2, 3}}.
+ */
+public class AnnotationExpression
+ extends SimpleAnnotationValueVisitor6<CodeBlock, AnnotationValue> {
+
+ private final AnnotationMirror annotation;
+ private final ClassName creatorClass;
+
+ AnnotationExpression(AnnotationMirror annotation) {
+ this.annotation = annotation;
+ this.creatorClass =
+ getAnnotationCreatorClassName(
+ MoreTypes.asTypeElement(annotation.getAnnotationType()));
+ }
+
+ /**
+ * Returns an expression that calls static methods on the annotation's creator class to create an
+ * annotation instance equivalent the annotation passed to the constructor.
+ */
+ CodeBlock getAnnotationInstanceExpression() {
+ return getAnnotationInstanceExpression(annotation);
+ }
+
+ private CodeBlock getAnnotationInstanceExpression(AnnotationMirror annotation) {
+ return CodeBlock.of(
+ "$T.$L($L)",
+ creatorClass,
+ createMethodName(
+ MoreElements.asType(annotation.getAnnotationType().asElement())),
+ makeParametersCodeBlock(
+ getAnnotationValuesWithDefaults(annotation)
+ .entrySet()
+ .stream()
+ .map(entry -> getValueExpression(entry.getKey().getReturnType(), entry.getValue()))
+ .collect(toList())));
+ }
+
+ /**
+ * Returns the name of the generated class that contains the static {@code create} methods for an
+ * annotation type.
+ */
+ public static ClassName getAnnotationCreatorClassName(TypeElement annotationType) {
+ ClassName annotationTypeName = ClassName.get(annotationType);
+ return annotationTypeName
+ .topLevelClassName()
+ .peerClass(classFileName(annotationTypeName) + "Creator");
+ }
+
+ public static String createMethodName(TypeElement annotationType) {
+ return "create" + annotationType.getSimpleName();
+ }
+
+ /**
+ * Returns an expression that evaluates to a {@code value} of a given type on an {@code
+ * annotation}.
+ */
+ CodeBlock getValueExpression(TypeMirror valueType, AnnotationValue value) {
+ return ARRAY_LITERAL_PREFIX.visit(valueType, this.visit(value, value));
+ }
+
+ @Override
+ public CodeBlock visitEnumConstant(VariableElement c, AnnotationValue p) {
+ return CodeBlock.of("$T.$L", c.getEnclosingElement(), c.getSimpleName());
+ }
+
+ @Override
+ public CodeBlock visitAnnotation(AnnotationMirror a, AnnotationValue p) {
+ return getAnnotationInstanceExpression(a);
+ }
+
+ @Override
+ public CodeBlock visitType(TypeMirror t, AnnotationValue p) {
+ return CodeBlock.of("$T.class", t);
+ }
+
+ @Override
+ public CodeBlock visitString(String s, AnnotationValue p) {
+ return CodeBlock.of("$S", s);
+ }
+
+ @Override
+ public CodeBlock visitByte(byte b, AnnotationValue p) {
+ return CodeBlock.of("(byte) $L", b);
+ }
+
+ @Override
+ public CodeBlock visitChar(char c, AnnotationValue p) {
+ return CodeBlock.of("$L", p);
+ }
+
+ @Override
+ public CodeBlock visitDouble(double d, AnnotationValue p) {
+ return CodeBlock.of("$LD", d);
+ }
+
+ @Override
+ public CodeBlock visitFloat(float f, AnnotationValue p) {
+ return CodeBlock.of("$LF", f);
+ }
+
+ @Override
+ public CodeBlock visitLong(long i, AnnotationValue p) {
+ return CodeBlock.of("$LL", i);
+ }
+
+ @Override
+ public CodeBlock visitShort(short s, AnnotationValue p) {
+ return CodeBlock.of("(short) $L", s);
+ }
+
+ @Override
+ protected CodeBlock defaultAction(Object o, AnnotationValue p) {
+ return CodeBlock.of("$L", o);
+ }
+
+ @Override
+ public CodeBlock visitArray(List<? extends AnnotationValue> values, AnnotationValue p) {
+ ImmutableList.Builder<CodeBlock> codeBlocks = ImmutableList.builder();
+ for (AnnotationValue value : values) {
+ codeBlocks.add(this.visit(value, p));
+ }
+ return CodeBlock.of("{$L}", makeParametersCodeBlock(codeBlocks.build()));
+ }
+
+ /**
+ * If the visited type is an array, prefixes the parameter code block with {@code new T[]}, where
+ * {@code T} is the raw array component type.
+ */
+ private static final SimpleTypeVisitor6<CodeBlock, CodeBlock> ARRAY_LITERAL_PREFIX =
+ new SimpleTypeVisitor6<CodeBlock, CodeBlock>() {
+
+ @Override
+ public CodeBlock visitArray(ArrayType t, CodeBlock p) {
+ return CodeBlock.of("new $T[] $L", RAW_TYPE_NAME.visit(t.getComponentType()), p);
+ }
+
+ @Override
+ protected CodeBlock defaultAction(TypeMirror e, CodeBlock p) {
+ return p;
+ }
+ };
+
+ /**
+ * If the visited type is an array, returns the name of its raw component type; otherwise returns
+ * the name of the type itself.
+ */
+ private static final SimpleTypeVisitor6<TypeName, Void> RAW_TYPE_NAME =
+ new SimpleTypeVisitor6<TypeName, Void>() {
+ @Override
+ public TypeName visitDeclared(DeclaredType t, Void p) {
+ return ClassName.get(MoreTypes.asTypeElement(t));
+ }
+
+ @Override
+ protected TypeName defaultAction(TypeMirror e, Void p) {
+ return TypeName.get(e);
+ }
+ };
+}
diff --git a/java/dagger/internal/codegen/binding/AssistedInjectionAnnotations.java b/java/dagger/internal/codegen/binding/AssistedInjectionAnnotations.java
new file mode 100644
index 0000000..8d6ee5d
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/AssistedInjectionAnnotations.java
@@ -0,0 +1,299 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.auto.common.MoreElements.asExecutable;
+import static com.google.auto.common.MoreElements.isAnnotationPresent;
+import static com.google.auto.common.MoreTypes.asDeclared;
+import static com.google.auto.common.MoreTypes.asExecutable;
+import static com.google.auto.common.MoreTypes.asTypeElement;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static dagger.internal.codegen.base.MoreAnnotationValues.getStringValue;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static dagger.internal.codegen.langmodel.DaggerElements.getAnnotationMirror;
+import static javax.lang.model.element.Modifier.ABSTRACT;
+import static javax.lang.model.util.ElementFilter.constructorsIn;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.MoreTypes;
+import com.google.auto.value.AutoValue;
+import com.google.auto.value.extension.memoized.Memoized;
+import com.google.common.base.Equivalence;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.squareup.javapoet.ParameterSpec;
+import com.squareup.javapoet.TypeName;
+import dagger.assisted.Assisted;
+import dagger.assisted.AssistedFactory;
+import dagger.assisted.AssistedInject;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.BindingKind;
+import java.util.List;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.ExecutableType;
+import javax.lang.model.type.TypeMirror;
+
+/** Assisted injection utility methods. */
+public final class AssistedInjectionAnnotations {
+ /** Returns the factory method for the given factory {@link TypeElement}. */
+ public static ExecutableElement assistedFactoryMethod(
+ TypeElement factory, DaggerElements elements, DaggerTypes types) {
+ return getOnlyElement(assistedFactoryMethods(factory, elements, types));
+ }
+
+ /** Returns the list of abstract factory methods for the given factory {@link TypeElement}. */
+ public static ImmutableSet<ExecutableElement> assistedFactoryMethods(
+ TypeElement factory, DaggerElements elements, DaggerTypes types) {
+ return MoreElements.getLocalAndInheritedMethods(factory, types, elements).stream()
+ .filter(method -> method.getModifiers().contains(ABSTRACT))
+ .filter(method -> !method.isDefault())
+ .collect(toImmutableSet());
+ }
+
+ /** Returns {@code true} if the element uses assisted injection. */
+ public static boolean isAssistedInjectionType(TypeElement typeElement) {
+ ImmutableSet<ExecutableElement> injectConstructors = assistedInjectedConstructors(typeElement);
+ return !injectConstructors.isEmpty()
+ && isAnnotationPresent(getOnlyElement(injectConstructors), AssistedInject.class);
+ }
+
+ /** Returns {@code true} if this binding is an assisted factory. */
+ public static boolean isAssistedFactoryType(Element element) {
+ return isAnnotationPresent(element, AssistedFactory.class);
+ }
+
+ /**
+ * Returns the list of assisted parameters as {@link ParameterSpec}s.
+ *
+ * <p>The type of each parameter will be the resolved type given by the binding key, and the name
+ * of each parameter will be the name given in the {@link
+ * dagger.assisted.AssistedInject}-annotated constructor.
+ */
+ public static ImmutableList<ParameterSpec> assistedParameterSpecs(
+ Binding binding, DaggerTypes types) {
+ checkArgument(binding.kind() == BindingKind.ASSISTED_INJECTION);
+ ExecutableElement constructor = asExecutable(binding.bindingElement().get());
+ ExecutableType constructorType =
+ asExecutable(types.asMemberOf(asDeclared(binding.key().type()), constructor));
+ return assistedParameterSpecs(constructor.getParameters(), constructorType.getParameterTypes());
+ }
+
+ private static ImmutableList<ParameterSpec> assistedParameterSpecs(
+ List<? extends VariableElement> paramElements, List<? extends TypeMirror> paramTypes) {
+ ImmutableList.Builder<ParameterSpec> assistedParameterSpecs = ImmutableList.builder();
+ for (int i = 0; i < paramElements.size(); i++) {
+ VariableElement paramElement = paramElements.get(i);
+ TypeMirror paramType = paramTypes.get(i);
+ if (isAssistedParameter(paramElement)) {
+ assistedParameterSpecs.add(
+ ParameterSpec.builder(TypeName.get(paramType), paramElement.getSimpleName().toString())
+ .build());
+ }
+ }
+ return assistedParameterSpecs.build();
+ }
+
+ /**
+ * Returns the list of assisted factory parameters as {@link ParameterSpec}s.
+ *
+ * <p>The type of each parameter will be the resolved type given by the binding key, and the name
+ * of each parameter will be the name given in the {@link
+ * dagger.assisted.AssistedInject}-annotated constructor.
+ */
+ public static ImmutableList<ParameterSpec> assistedFactoryParameterSpecs(
+ Binding binding, DaggerElements elements, DaggerTypes types) {
+ checkArgument(binding.kind() == BindingKind.ASSISTED_FACTORY);
+
+ AssistedFactoryMetadata metadata =
+ AssistedFactoryMetadata.create(binding.bindingElement().get().asType(), elements, types);
+ ExecutableType factoryMethodType =
+ asExecutable(types.asMemberOf(asDeclared(binding.key().type()), metadata.factoryMethod()));
+ return assistedParameterSpecs(
+ // Use the order of the parameters from the @AssistedFactory method but use the parameter
+ // names of the @AssistedInject constructor.
+ metadata.assistedFactoryAssistedParameters().stream()
+ .map(metadata.assistedInjectAssistedParametersMap()::get)
+ .collect(toImmutableList()),
+ factoryMethodType.getParameterTypes());
+ }
+
+ /** Returns the constructors in {@code type} that are annotated with {@link AssistedInject}. */
+ public static ImmutableSet<ExecutableElement> assistedInjectedConstructors(TypeElement type) {
+ return constructorsIn(type.getEnclosedElements()).stream()
+ .filter(constructor -> isAnnotationPresent(constructor, AssistedInject.class))
+ .collect(toImmutableSet());
+ }
+
+ public static ImmutableList<VariableElement> assistedParameters(Binding binding) {
+ return binding.kind() == BindingKind.ASSISTED_INJECTION
+ ? assistedParameters(asExecutable(binding.bindingElement().get()))
+ : ImmutableList.of();
+ }
+
+ private static ImmutableList<VariableElement> assistedParameters(ExecutableElement constructor) {
+ return constructor.getParameters().stream()
+ .filter(AssistedInjectionAnnotations::isAssistedParameter)
+ .collect(toImmutableList());
+ }
+
+ /** Returns {@code true} if this binding is uses assisted injection. */
+ public static boolean isAssistedParameter(VariableElement param) {
+ return isAnnotationPresent(MoreElements.asVariable(param), Assisted.class);
+ }
+
+ /** Metadata about an {@link dagger.assisted.AssistedFactory} annotated type. */
+ @AutoValue
+ public abstract static class AssistedFactoryMetadata {
+ public static AssistedFactoryMetadata create(
+ TypeMirror factory, DaggerElements elements, DaggerTypes types) {
+ DeclaredType factoryType = asDeclared(factory);
+ TypeElement factoryElement = asTypeElement(factoryType);
+ ExecutableElement factoryMethod = assistedFactoryMethod(factoryElement, elements, types);
+ ExecutableType factoryMethodType = asExecutable(types.asMemberOf(factoryType, factoryMethod));
+ DeclaredType assistedInjectType = asDeclared(factoryMethodType.getReturnType());
+ return new AutoValue_AssistedInjectionAnnotations_AssistedFactoryMetadata(
+ factoryElement,
+ factoryType,
+ factoryMethod,
+ factoryMethodType,
+ asTypeElement(assistedInjectType),
+ assistedInjectType,
+ AssistedInjectionAnnotations.assistedInjectAssistedParameters(assistedInjectType, types),
+ AssistedInjectionAnnotations.assistedFactoryAssistedParameters(
+ factoryMethod, factoryMethodType));
+ }
+
+ public abstract TypeElement factory();
+
+ public abstract DeclaredType factoryType();
+
+ public abstract ExecutableElement factoryMethod();
+
+ public abstract ExecutableType factoryMethodType();
+
+ public abstract TypeElement assistedInjectElement();
+
+ public abstract DeclaredType assistedInjectType();
+
+ public abstract ImmutableList<AssistedParameter> assistedInjectAssistedParameters();
+
+ public abstract ImmutableList<AssistedParameter> assistedFactoryAssistedParameters();
+
+ @Memoized
+ public ImmutableMap<AssistedParameter, VariableElement> assistedInjectAssistedParametersMap() {
+ ImmutableMap.Builder<AssistedParameter, VariableElement> builder = ImmutableMap.builder();
+ for (AssistedParameter assistedParameter : assistedInjectAssistedParameters()) {
+ builder.put(assistedParameter, assistedParameter.variableElement);
+ }
+ return builder.build();
+ }
+
+ @Memoized
+ public ImmutableMap<AssistedParameter, VariableElement> assistedFactoryAssistedParametersMap() {
+ ImmutableMap.Builder<AssistedParameter, VariableElement> builder = ImmutableMap.builder();
+ for (AssistedParameter assistedParameter : assistedFactoryAssistedParameters()) {
+ builder.put(assistedParameter, assistedParameter.variableElement);
+ }
+ return builder.build();
+ }
+ }
+
+ /**
+ * Metadata about an {@link Assisted} annotated parameter.
+ *
+ * <p>This parameter can represent an {@link Assisted} annotated parameter from an {@link
+ * AssistedInject} constructor or an {@link AssistedFactory} method.
+ */
+ @AutoValue
+ public abstract static class AssistedParameter {
+ public static AssistedParameter create(VariableElement parameter, TypeMirror parameterType) {
+ AssistedParameter assistedParameter =
+ new AutoValue_AssistedInjectionAnnotations_AssistedParameter(
+ getAnnotationMirror(parameter, Assisted.class)
+ .map(assisted -> getStringValue(assisted, "value"))
+ .orElse(""),
+ MoreTypes.equivalence().wrap(parameterType));
+ assistedParameter.variableElement = parameter;
+ return assistedParameter;
+ }
+
+ private VariableElement variableElement;
+
+ /** Returns the string qualifier from the {@link Assisted#value()}. */
+ public abstract String qualifier();
+
+ /** Returns the wrapper for the type annotated with {@link Assisted}. */
+ public abstract Equivalence.Wrapper<TypeMirror> wrappedType();
+
+ /** Returns the type annotated with {@link Assisted}. */
+ public final TypeMirror type() {
+ return wrappedType().get();
+ }
+
+ public final VariableElement variableElement() {
+ return variableElement;
+ }
+
+ @Override
+ public final String toString() {
+ return qualifier().isEmpty()
+ ? String.format("@Assisted %s", type())
+ : String.format("@Assisted(\"%s\") %s", qualifier(), type());
+ }
+ }
+
+ public static ImmutableList<AssistedParameter> assistedInjectAssistedParameters(
+ DeclaredType assistedInjectType, DaggerTypes types) {
+ // We keep track of the constructor both as an ExecutableElement to access @Assisted
+ // parameters and as an ExecutableType to access the resolved parameter types.
+ ExecutableElement assistedInjectConstructor =
+ getOnlyElement(assistedInjectedConstructors(asTypeElement(assistedInjectType)));
+ ExecutableType assistedInjectConstructorType =
+ asExecutable(types.asMemberOf(assistedInjectType, assistedInjectConstructor));
+
+ ImmutableList.Builder<AssistedParameter> builder = ImmutableList.builder();
+ for (int i = 0; i < assistedInjectConstructor.getParameters().size(); i++) {
+ VariableElement parameter = assistedInjectConstructor.getParameters().get(i);
+ TypeMirror parameterType = assistedInjectConstructorType.getParameterTypes().get(i);
+ if (isAnnotationPresent(parameter, Assisted.class)) {
+ builder.add(AssistedParameter.create(parameter, parameterType));
+ }
+ }
+ return builder.build();
+ }
+
+ public static ImmutableList<AssistedParameter> assistedFactoryAssistedParameters(
+ ExecutableElement factoryMethod, ExecutableType factoryMethodType) {
+ ImmutableList.Builder<AssistedParameter> builder = ImmutableList.builder();
+ for (int i = 0; i < factoryMethod.getParameters().size(); i++) {
+ VariableElement parameter = factoryMethod.getParameters().get(i);
+ TypeMirror parameterType = factoryMethodType.getParameterTypes().get(i);
+ builder.add(AssistedParameter.create(parameter, parameterType));
+ }
+ return builder.build();
+ }
+
+ private AssistedInjectionAnnotations() {}
+}
diff --git a/java/dagger/internal/codegen/binding/BUILD b/java/dagger/internal/codegen/binding/BUILD
new file mode 100644
index 0000000..ff8db8f
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/BUILD
@@ -0,0 +1,47 @@
+# Copyright (C) 2017 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# JavaPoet extensions for use in Dagger
+
+load("@rules_java//java:defs.bzl", "java_library")
+
+package(default_visibility = ["//:src"])
+
+java_library(
+ name = "binding",
+ srcs = glob(["*.java"]),
+ plugins = ["//java/dagger/internal/codegen/bootstrap"],
+ tags = ["maven:merged"],
+ deps = [
+ "//java/dagger:core",
+ "//java/dagger/internal/codegen/base",
+ "//java/dagger/internal/codegen/compileroption",
+ "//java/dagger/internal/codegen/extension",
+ "//java/dagger/internal/codegen/javapoet",
+ "//java/dagger/internal/codegen/kotlin",
+ "//java/dagger/internal/codegen/langmodel",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/internal/guava:concurrent",
+ "//java/dagger/internal/guava:graph",
+ "//java/dagger/model:internal-proxies",
+ "//java/dagger/producers",
+ "//java/dagger/spi",
+ "@google_bazel_common//third_party/java/auto:value",
+ "@google_bazel_common//third_party/java/error_prone:annotations",
+ "@google_bazel_common//third_party/java/javapoet",
+ "@maven//:com_google_auto_auto_common",
+ ],
+)
diff --git a/java/dagger/internal/codegen/binding/Binding.java b/java/dagger/internal/codegen/binding/Binding.java
new file mode 100644
index 0000000..0d4eef6
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/Binding.java
@@ -0,0 +1,165 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.common.base.Suppliers.memoize;
+import static javax.lang.model.element.Modifier.ABSTRACT;
+import static javax.lang.model.element.Modifier.STATIC;
+
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.BindingKind;
+import dagger.model.DependencyRequest;
+import dagger.model.Scope;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.TypeParameterElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.SimpleTypeVisitor6;
+
+/**
+ * An abstract type for classes representing a Dagger binding. Particularly, contains the {@link
+ * Element} that generated the binding and the {@link DependencyRequest} instances that are required
+ * to satisfy the binding, but leaves the specifics of the <i>mechanism</i> of the binding to the
+ * subtypes.
+ */
+public abstract class Binding extends BindingDeclaration {
+
+ /**
+ * Returns {@code true} if using this binding requires an instance of the {@link
+ * #contributingModule()}.
+ */
+ public boolean requiresModuleInstance() {
+ if (!bindingElement().isPresent() || !contributingModule().isPresent()) {
+ return false;
+ }
+ Set<Modifier> modifiers = bindingElement().get().getModifiers();
+ return !modifiers.contains(ABSTRACT) && !modifiers.contains(STATIC);
+ }
+
+ /**
+ * Returns {@code true} if this binding may provide {@code null} instead of an instance of {@link
+ * #key()}. Nullable bindings cannot be requested from {@linkplain DependencyRequest#isNullable()
+ * non-nullable dependency requests}.
+ */
+ public abstract boolean isNullable();
+
+ /** The kind of binding this instance represents. */
+ public abstract BindingKind kind();
+
+ /** The {@link BindingType} of this binding. */
+ public abstract BindingType bindingType();
+
+ /** The {@link FrameworkType} of this binding. */
+ public final FrameworkType frameworkType() {
+ return FrameworkType.forBindingType(bindingType());
+ }
+
+ /**
+ * The explicit set of {@link DependencyRequest dependencies} required to satisfy this binding as
+ * defined by the user-defined injection sites.
+ */
+ public abstract ImmutableSet<DependencyRequest> explicitDependencies();
+
+ /**
+ * The set of {@link DependencyRequest dependencies} that are added by the framework rather than a
+ * user-defined injection site. This returns an unmodifiable set.
+ */
+ public ImmutableSet<DependencyRequest> implicitDependencies() {
+ return ImmutableSet.of();
+ }
+
+ private final Supplier<ImmutableSet<DependencyRequest>> dependencies =
+ memoize(
+ () -> {
+ ImmutableSet<DependencyRequest> implicitDependencies = implicitDependencies();
+ return ImmutableSet.copyOf(
+ implicitDependencies.isEmpty()
+ ? explicitDependencies()
+ : Sets.union(implicitDependencies, explicitDependencies()));
+ });
+
+ /**
+ * The set of {@link DependencyRequest dependencies} required to satisfy this binding. This is the
+ * union of {@link #explicitDependencies()} and {@link #implicitDependencies()}. This returns an
+ * unmodifiable set.
+ */
+ public final ImmutableSet<DependencyRequest> dependencies() {
+ return dependencies.get();
+ }
+
+ /**
+ * If this binding's key's type parameters are different from those of the {@link
+ * #bindingTypeElement()}, this is the binding for the {@link #bindingTypeElement()}'s unresolved
+ * type.
+ */
+ public abstract Optional<? extends Binding> unresolved();
+
+ public Optional<Scope> scope() {
+ return Optional.empty();
+ }
+
+ // TODO(sameb): Remove the TypeElement parameter and pull it from the TypeMirror.
+ static boolean hasNonDefaultTypeParameters(
+ TypeElement element, TypeMirror type, DaggerTypes types) {
+ // If the element has no type parameters, nothing can be wrong.
+ if (element.getTypeParameters().isEmpty()) {
+ return false;
+ }
+
+ List<TypeMirror> defaultTypes = Lists.newArrayList();
+ for (TypeParameterElement parameter : element.getTypeParameters()) {
+ defaultTypes.add(parameter.asType());
+ }
+
+ List<TypeMirror> actualTypes =
+ type.accept(
+ new SimpleTypeVisitor6<List<TypeMirror>, Void>() {
+ @Override
+ protected List<TypeMirror> defaultAction(TypeMirror e, Void p) {
+ return ImmutableList.of();
+ }
+
+ @Override
+ public List<TypeMirror> visitDeclared(DeclaredType t, Void p) {
+ return ImmutableList.<TypeMirror>copyOf(t.getTypeArguments());
+ }
+ },
+ null);
+
+ // The actual type parameter size can be different if the user is using a raw type.
+ if (defaultTypes.size() != actualTypes.size()) {
+ return true;
+ }
+
+ for (int i = 0; i < defaultTypes.size(); i++) {
+ if (!types.isSameType(defaultTypes.get(i), actualTypes.get(i))) {
+ return true;
+ }
+ }
+ return false;
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/BindingDeclaration.java b/java/dagger/internal/codegen/binding/BindingDeclaration.java
new file mode 100644
index 0000000..712260f
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/BindingDeclaration.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static dagger.internal.codegen.extension.Optionals.emptiesLast;
+import static java.util.Comparator.comparing;
+
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.model.BindingKind;
+import dagger.model.Key;
+import java.util.Comparator;
+import java.util.Optional;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+
+/** An object that declares or specifies a binding. */
+public abstract class BindingDeclaration {
+ /**
+ * A comparator that compares binding declarations with elements.
+ *
+ * <p>Compares, in order:
+ *
+ * <ol>
+ * <li>Contributing module or enclosing type name
+ * <li>Binding element's simple name
+ * <li>Binding element's type
+ * </ol>
+ *
+ * Any binding declarations without elements are last.
+ */
+ public static final Comparator<BindingDeclaration> COMPARATOR =
+ comparing(
+ (BindingDeclaration declaration) ->
+ declaration.contributingModule().isPresent()
+ ? declaration.contributingModule()
+ : declaration.bindingTypeElement(),
+ emptiesLast(comparing((TypeElement type) -> type.getQualifiedName().toString())))
+ .thenComparing(
+ (BindingDeclaration declaration) -> declaration.bindingElement(),
+ emptiesLast(
+ comparing((Element element) -> element.getSimpleName().toString())
+ .thenComparing((Element element) -> element.asType().toString())));
+
+ /** The {@link Key} of this declaration. */
+ public abstract Key key();
+
+ /**
+ * The {@link Element} that declares this binding. Absent for {@linkplain BindingKind binding
+ * kinds} that are not always declared by exactly one element.
+ *
+ * <p>For example, consider {@link BindingKind#MULTIBOUND_SET}. A component with many
+ * {@code @IntoSet} bindings for the same key will have a synthetic binding that depends on all
+ * contributions, but with no identifiying binding element. A {@code @Multibinds} method will also
+ * contribute a synthetic binding, but since multiple {@code @Multibinds} methods can coexist in
+ * the same component (and contribute to one single binding), it has no binding element.
+ */
+ public abstract Optional<Element> bindingElement();
+
+ /**
+ * The type enclosing the {@link #bindingElement()}, or {@link Optional#empty()} if {@link
+ * #bindingElement()} is empty.
+ */
+ public final Optional<TypeElement> bindingTypeElement() {
+ return bindingElement().map(DaggerElements::closestEnclosingTypeElement);
+ }
+
+ /**
+ * The installed module class that contributed the {@link #bindingElement()}. May be a subclass of
+ * the class that contains {@link #bindingElement()}. Absent if {@link #bindingElement()} is
+ * empty.
+ */
+ public abstract Optional<TypeElement> contributingModule();
+}
diff --git a/java/dagger/internal/codegen/binding/BindingDeclarationFormatter.java b/java/dagger/internal/codegen/binding/BindingDeclarationFormatter.java
new file mode 100644
index 0000000..8476497
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/BindingDeclarationFormatter.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.common.collect.Sets.immutableEnumSet;
+import static dagger.internal.codegen.base.DiagnosticFormatting.stripCommonTypePrefixes;
+import static dagger.internal.codegen.base.ElementFormatter.elementToString;
+import static javax.lang.model.element.ElementKind.PARAMETER;
+import static javax.lang.model.type.TypeKind.DECLARED;
+import static javax.lang.model.type.TypeKind.EXECUTABLE;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.MoreTypes;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import dagger.internal.codegen.base.Formatter;
+import javax.inject.Inject;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeKind;
+
+/**
+ * Formats a {@link BindingDeclaration} into a {@link String} suitable for use in error messages.
+ */
+public final class BindingDeclarationFormatter extends Formatter<BindingDeclaration> {
+ private static final ImmutableSet<TypeKind> FORMATTABLE_ELEMENT_TYPE_KINDS =
+ immutableEnumSet(EXECUTABLE, DECLARED);
+
+ private final MethodSignatureFormatter methodSignatureFormatter;
+
+ @Inject
+ BindingDeclarationFormatter(MethodSignatureFormatter methodSignatureFormatter) {
+ this.methodSignatureFormatter = methodSignatureFormatter;
+ }
+
+ /**
+ * Returns {@code true} for declarations that this formatter can format. Specifically bindings
+ * from subcomponent declarations or those with {@linkplain BindingDeclaration#bindingElement()
+ * binding elements} that are methods, constructors, or types.
+ */
+ public boolean canFormat(BindingDeclaration bindingDeclaration) {
+ if (bindingDeclaration instanceof SubcomponentDeclaration) {
+ return true;
+ }
+ if (bindingDeclaration.bindingElement().isPresent()) {
+ Element bindingElement = bindingDeclaration.bindingElement().get();
+ return bindingElement.getKind().equals(PARAMETER)
+ || FORMATTABLE_ELEMENT_TYPE_KINDS.contains(bindingElement.asType().getKind());
+ }
+ // TODO(dpb): validate whether what this is doing is correct
+ return false;
+ }
+
+ @Override
+ public String format(BindingDeclaration bindingDeclaration) {
+ if (bindingDeclaration instanceof SubcomponentDeclaration) {
+ return formatSubcomponentDeclaration((SubcomponentDeclaration) bindingDeclaration);
+ }
+
+ if (bindingDeclaration.bindingElement().isPresent()) {
+ Element bindingElement = bindingDeclaration.bindingElement().get();
+ if (bindingElement.getKind().equals(PARAMETER)) {
+ return elementToString(bindingElement);
+ }
+
+ switch (bindingElement.asType().getKind()) {
+ case EXECUTABLE:
+ return methodSignatureFormatter.format(
+ MoreElements.asExecutable(bindingElement),
+ bindingDeclaration
+ .contributingModule()
+ .map(module -> MoreTypes.asDeclared(module.asType())));
+
+ case DECLARED:
+ return stripCommonTypePrefixes(bindingElement.asType().toString());
+
+ default:
+ throw new IllegalArgumentException(
+ "Formatting unsupported for element: " + bindingElement);
+ }
+ }
+
+ return String.format(
+ "Dagger-generated binding for %s",
+ stripCommonTypePrefixes(bindingDeclaration.key().toString()));
+ }
+
+ private String formatSubcomponentDeclaration(SubcomponentDeclaration subcomponentDeclaration) {
+ ImmutableList<TypeElement> moduleSubcomponents =
+ subcomponentDeclaration.moduleAnnotation().subcomponents();
+ int index = moduleSubcomponents.indexOf(subcomponentDeclaration.subcomponentType());
+ StringBuilder annotationValue = new StringBuilder();
+ if (moduleSubcomponents.size() != 1) {
+ annotationValue.append("{");
+ }
+ annotationValue.append(
+ formatArgumentInList(
+ index,
+ moduleSubcomponents.size(),
+ subcomponentDeclaration.subcomponentType().getQualifiedName() + ".class"));
+ if (moduleSubcomponents.size() != 1) {
+ annotationValue.append("}");
+ }
+
+ return String.format(
+ "@%s(subcomponents = %s) for %s",
+ subcomponentDeclaration.moduleAnnotation().annotationName(),
+ annotationValue,
+ subcomponentDeclaration.contributingModule().get());
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/BindingFactory.java b/java/dagger/internal/codegen/binding/BindingFactory.java
new file mode 100644
index 0000000..6f2fc80
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/BindingFactory.java
@@ -0,0 +1,578 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.auto.common.MoreElements.isAnnotationPresent;
+import static com.google.auto.common.MoreTypes.asDeclared;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static dagger.internal.codegen.base.MoreAnnotationMirrors.wrapOptionalInEquivalence;
+import static dagger.internal.codegen.base.Scopes.uniqueScopeOf;
+import static dagger.internal.codegen.binding.Binding.hasNonDefaultTypeParameters;
+import static dagger.internal.codegen.binding.ComponentDescriptor.isComponentProductionMethod;
+import static dagger.internal.codegen.binding.ConfigurationAnnotations.getNullableType;
+import static dagger.internal.codegen.binding.ContributionBinding.bindingKindForMultibindingKey;
+import static dagger.internal.codegen.binding.MapKeys.getMapKey;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static dagger.model.BindingKind.ASSISTED_FACTORY;
+import static dagger.model.BindingKind.ASSISTED_INJECTION;
+import static dagger.model.BindingKind.BOUND_INSTANCE;
+import static dagger.model.BindingKind.COMPONENT;
+import static dagger.model.BindingKind.COMPONENT_DEPENDENCY;
+import static dagger.model.BindingKind.COMPONENT_PRODUCTION;
+import static dagger.model.BindingKind.COMPONENT_PROVISION;
+import static dagger.model.BindingKind.DELEGATE;
+import static dagger.model.BindingKind.INJECTION;
+import static dagger.model.BindingKind.MEMBERS_INJECTOR;
+import static dagger.model.BindingKind.OPTIONAL;
+import static dagger.model.BindingKind.PRODUCTION;
+import static dagger.model.BindingKind.PROVISION;
+import static dagger.model.BindingKind.SUBCOMPONENT_CREATOR;
+import static javax.lang.model.element.ElementKind.CONSTRUCTOR;
+import static javax.lang.model.element.ElementKind.METHOD;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.MoreTypes;
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSortedSet;
+import com.google.common.collect.Iterables;
+import dagger.Module;
+import dagger.assisted.AssistedInject;
+import dagger.internal.codegen.base.ContributionType;
+import dagger.internal.codegen.base.MapType;
+import dagger.internal.codegen.base.SetType;
+import dagger.internal.codegen.binding.MembersInjectionBinding.InjectionSite;
+import dagger.internal.codegen.binding.ProductionBinding.ProductionKind;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.DependencyRequest;
+import dagger.model.Key;
+import dagger.model.RequestKind;
+import dagger.producers.Produced;
+import dagger.producers.Producer;
+import java.util.Optional;
+import java.util.function.BiFunction;
+import javax.inject.Inject;
+import javax.inject.Provider;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.ExecutableType;
+import javax.lang.model.type.TypeMirror;
+
+/** A factory for {@link Binding} objects. */
+public final class BindingFactory {
+ private final DaggerTypes types;
+ private final KeyFactory keyFactory;
+ private final DependencyRequestFactory dependencyRequestFactory;
+ private final InjectionSiteFactory injectionSiteFactory;
+ private final DaggerElements elements;
+ private final InjectionAnnotations injectionAnnotations;
+ private final KotlinMetadataUtil metadataUtil;
+
+ @Inject
+ BindingFactory(
+ DaggerTypes types,
+ DaggerElements elements,
+ KeyFactory keyFactory,
+ DependencyRequestFactory dependencyRequestFactory,
+ InjectionSiteFactory injectionSiteFactory,
+ InjectionAnnotations injectionAnnotations,
+ KotlinMetadataUtil metadataUtil) {
+ this.types = types;
+ this.elements = elements;
+ this.keyFactory = keyFactory;
+ this.dependencyRequestFactory = dependencyRequestFactory;
+ this.injectionSiteFactory = injectionSiteFactory;
+ this.injectionAnnotations = injectionAnnotations;
+ this.metadataUtil = metadataUtil;
+ }
+
+ /**
+ * Returns an {@link dagger.model.BindingKind#INJECTION} binding.
+ *
+ * @param constructorElement the {@code @Inject}-annotated constructor
+ * @param resolvedType the parameterized type if the constructor is for a generic class and the
+ * binding should be for the parameterized type
+ */
+ // TODO(dpb): See if we can just pass the parameterized type and not also the constructor.
+ public ProvisionBinding injectionBinding(
+ ExecutableElement constructorElement, Optional<TypeMirror> resolvedType) {
+ checkArgument(constructorElement.getKind().equals(CONSTRUCTOR));
+ checkArgument(
+ isAnnotationPresent(constructorElement, Inject.class)
+ || isAnnotationPresent(constructorElement, AssistedInject.class));
+ checkArgument(!injectionAnnotations.getQualifier(constructorElement).isPresent());
+
+ ExecutableType constructorType = MoreTypes.asExecutable(constructorElement.asType());
+ DeclaredType constructedType =
+ MoreTypes.asDeclared(constructorElement.getEnclosingElement().asType());
+ // If the class this is constructing has some type arguments, resolve everything.
+ if (!constructedType.getTypeArguments().isEmpty() && resolvedType.isPresent()) {
+ DeclaredType resolved = MoreTypes.asDeclared(resolvedType.get());
+ // Validate that we're resolving from the correct type.
+ checkState(
+ types.isSameType(types.erasure(resolved), types.erasure(constructedType)),
+ "erased expected type: %s, erased actual type: %s",
+ types.erasure(resolved),
+ types.erasure(constructedType));
+ constructorType = MoreTypes.asExecutable(types.asMemberOf(resolved, constructorElement));
+ constructedType = resolved;
+ }
+
+ // Collect all dependency requests within the provision method.
+ // Note: we filter out @Assisted parameters since these aren't considered dependency requests.
+ ImmutableSet.Builder<DependencyRequest> provisionDependencies = ImmutableSet.builder();
+ for (int i = 0; i < constructorElement.getParameters().size(); i++) {
+ VariableElement parameter = constructorElement.getParameters().get(i);
+ TypeMirror parameterType = constructorType.getParameterTypes().get(i);
+ if (!AssistedInjectionAnnotations.isAssistedParameter(parameter)) {
+ provisionDependencies.add(
+ dependencyRequestFactory.forRequiredResolvedVariable(parameter, parameterType));
+ }
+ }
+
+ Key key = keyFactory.forInjectConstructorWithResolvedType(constructedType);
+ ProvisionBinding.Builder builder =
+ ProvisionBinding.builder()
+ .contributionType(ContributionType.UNIQUE)
+ .bindingElement(constructorElement)
+ .key(key)
+ .provisionDependencies(provisionDependencies.build())
+ .injectionSites(injectionSiteFactory.getInjectionSites(constructedType))
+ .kind(
+ isAnnotationPresent(constructorElement, AssistedInject.class)
+ ? ASSISTED_INJECTION
+ : INJECTION)
+ .scope(uniqueScopeOf(constructorElement.getEnclosingElement()));
+
+ TypeElement bindingTypeElement = MoreElements.asType(constructorElement.getEnclosingElement());
+ if (hasNonDefaultTypeParameters(bindingTypeElement, key.type(), types)) {
+ builder.unresolved(injectionBinding(constructorElement, Optional.empty()));
+ }
+ return builder.build();
+ }
+
+ public ProvisionBinding assistedFactoryBinding(
+ TypeElement factory, Optional<TypeMirror> resolvedType) {
+
+ // If the class this is constructing has some type arguments, resolve everything.
+ DeclaredType factoryType = MoreTypes.asDeclared(factory.asType());
+ if (!factoryType.getTypeArguments().isEmpty() && resolvedType.isPresent()) {
+ DeclaredType resolved = MoreTypes.asDeclared(resolvedType.get());
+ // Validate that we're resolving from the correct type by checking that the erasure of the
+ // resolvedType is the same as the erasure of the factoryType.
+ checkState(
+ types.isSameType(types.erasure(resolved), types.erasure(factoryType)),
+ "erased expected type: %s, erased actual type: %s",
+ types.erasure(resolved),
+ types.erasure(factoryType));
+ factoryType = resolved;
+ }
+
+ ExecutableElement factoryMethod =
+ AssistedInjectionAnnotations.assistedFactoryMethod(factory, elements, types);
+ ExecutableType factoryMethodType =
+ MoreTypes.asExecutable(types.asMemberOf(factoryType, factoryMethod));
+ return ProvisionBinding.builder()
+ .contributionType(ContributionType.UNIQUE)
+ .key(Key.builder(factoryType).build())
+ .bindingElement(factory)
+ .provisionDependencies(
+ ImmutableSet.of(
+ DependencyRequest.builder()
+ .key(Key.builder(factoryMethodType.getReturnType()).build())
+ .kind(RequestKind.PROVIDER)
+ .build()))
+ .kind(ASSISTED_FACTORY)
+ .build();
+ }
+
+ /**
+ * Returns a {@link dagger.model.BindingKind#PROVISION} binding for a {@code @Provides}-annotated
+ * method.
+ *
+ * @param contributedBy the installed module that declares or inherits the method
+ */
+ public ProvisionBinding providesMethodBinding(
+ ExecutableElement providesMethod, TypeElement contributedBy) {
+ return setMethodBindingProperties(
+ ProvisionBinding.builder(),
+ providesMethod,
+ contributedBy,
+ keyFactory.forProvidesMethod(providesMethod, contributedBy),
+ this::providesMethodBinding)
+ .kind(PROVISION)
+ .scope(uniqueScopeOf(providesMethod))
+ .nullableType(getNullableType(providesMethod))
+ .build();
+ }
+
+ /**
+ * Returns a {@link dagger.model.BindingKind#PRODUCTION} binding for a {@code @Produces}-annotated
+ * method.
+ *
+ * @param contributedBy the installed module that declares or inherits the method
+ */
+ public ProductionBinding producesMethodBinding(
+ ExecutableElement producesMethod, TypeElement contributedBy) {
+ // TODO(beder): Add nullability checking with Java 8.
+ ProductionBinding.Builder builder =
+ setMethodBindingProperties(
+ ProductionBinding.builder(),
+ producesMethod,
+ contributedBy,
+ keyFactory.forProducesMethod(producesMethod, contributedBy),
+ this::producesMethodBinding)
+ .kind(PRODUCTION)
+ .productionKind(ProductionKind.fromProducesMethod(producesMethod))
+ .thrownTypes(producesMethod.getThrownTypes())
+ .executorRequest(dependencyRequestFactory.forProductionImplementationExecutor())
+ .monitorRequest(dependencyRequestFactory.forProductionComponentMonitor());
+ return builder.build();
+ }
+
+ private <C extends ContributionBinding, B extends ContributionBinding.Builder<C, B>>
+ B setMethodBindingProperties(
+ B builder,
+ ExecutableElement method,
+ TypeElement contributedBy,
+ Key key,
+ BiFunction<ExecutableElement, TypeElement, C> create) {
+ checkArgument(method.getKind().equals(METHOD));
+ ExecutableType methodType =
+ MoreTypes.asExecutable(
+ types.asMemberOf(MoreTypes.asDeclared(contributedBy.asType()), method));
+ if (!types.isSameType(methodType, method.asType())) {
+ builder.unresolved(create.apply(method, MoreElements.asType(method.getEnclosingElement())));
+ }
+ boolean isKotlinObject =
+ metadataUtil.isObjectClass(contributedBy)
+ || metadataUtil.isCompanionObjectClass(contributedBy);
+ return builder
+ .contributionType(ContributionType.fromBindingElement(method))
+ .bindingElement(method)
+ .contributingModule(contributedBy)
+ .isContributingModuleKotlinObject(isKotlinObject)
+ .key(key)
+ .dependencies(
+ dependencyRequestFactory.forRequiredResolvedVariables(
+ method.getParameters(), methodType.getParameterTypes()))
+ .wrappedMapKeyAnnotation(wrapOptionalInEquivalence(getMapKey(method)));
+ }
+
+ /**
+ * Returns a {@link dagger.model.BindingKind#MULTIBOUND_MAP} or {@link
+ * dagger.model.BindingKind#MULTIBOUND_SET} binding given a set of multibinding contribution
+ * bindings.
+ *
+ * @param key a key that may be satisfied by a multibinding
+ */
+ public ContributionBinding syntheticMultibinding(
+ Key key, Iterable<ContributionBinding> multibindingContributions) {
+ ContributionBinding.Builder<?, ?> builder =
+ multibindingRequiresProduction(key, multibindingContributions)
+ ? ProductionBinding.builder()
+ : ProvisionBinding.builder();
+ return builder
+ .contributionType(ContributionType.UNIQUE)
+ .key(key)
+ .dependencies(
+ dependencyRequestFactory.forMultibindingContributions(key, multibindingContributions))
+ .kind(bindingKindForMultibindingKey(key))
+ .build();
+ }
+
+ private boolean multibindingRequiresProduction(
+ Key key, Iterable<ContributionBinding> multibindingContributions) {
+ if (MapType.isMap(key)) {
+ MapType mapType = MapType.from(key);
+ if (mapType.valuesAreTypeOf(Producer.class) || mapType.valuesAreTypeOf(Produced.class)) {
+ return true;
+ }
+ } else if (SetType.isSet(key) && SetType.from(key).elementsAreTypeOf(Produced.class)) {
+ return true;
+ }
+ return Iterables.any(
+ multibindingContributions, binding -> binding.bindingType().equals(BindingType.PRODUCTION));
+ }
+
+ /** Returns a {@link dagger.model.BindingKind#COMPONENT} binding for the component. */
+ public ProvisionBinding componentBinding(TypeElement componentDefinitionType) {
+ checkNotNull(componentDefinitionType);
+ return ProvisionBinding.builder()
+ .contributionType(ContributionType.UNIQUE)
+ .bindingElement(componentDefinitionType)
+ .key(keyFactory.forType(componentDefinitionType.asType()))
+ .kind(COMPONENT)
+ .build();
+ }
+
+ /**
+ * Returns a {@link dagger.model.BindingKind#COMPONENT_DEPENDENCY} binding for a component's
+ * dependency.
+ */
+ public ProvisionBinding componentDependencyBinding(ComponentRequirement dependency) {
+ checkNotNull(dependency);
+ return ProvisionBinding.builder()
+ .contributionType(ContributionType.UNIQUE)
+ .bindingElement(dependency.typeElement())
+ .key(keyFactory.forType(dependency.type()))
+ .kind(COMPONENT_DEPENDENCY)
+ .build();
+ }
+
+ /**
+ * Returns a {@link dagger.model.BindingKind#COMPONENT_PROVISION} or {@link
+ * dagger.model.BindingKind#COMPONENT_PRODUCTION} binding for a method on a component's
+ * dependency.
+ *
+ * @param componentDescriptor the component with the dependency, not the dependency that has the
+ * method
+ */
+ public ContributionBinding componentDependencyMethodBinding(
+ ComponentDescriptor componentDescriptor, ExecutableElement dependencyMethod) {
+ checkArgument(dependencyMethod.getKind().equals(METHOD));
+ checkArgument(dependencyMethod.getParameters().isEmpty());
+ ContributionBinding.Builder<?, ?> builder;
+ if (componentDescriptor.isProduction()
+ && isComponentProductionMethod(elements, dependencyMethod)) {
+ builder =
+ ProductionBinding.builder()
+ .key(keyFactory.forProductionComponentMethod(dependencyMethod))
+ .kind(COMPONENT_PRODUCTION)
+ .thrownTypes(dependencyMethod.getThrownTypes());
+ } else {
+ builder =
+ ProvisionBinding.builder()
+ .key(keyFactory.forComponentMethod(dependencyMethod))
+ .nullableType(getNullableType(dependencyMethod))
+ .kind(COMPONENT_PROVISION)
+ .scope(uniqueScopeOf(dependencyMethod));
+ }
+ return builder
+ .contributionType(ContributionType.UNIQUE)
+ .bindingElement(dependencyMethod)
+ .build();
+ }
+
+ /**
+ * Returns a {@link dagger.model.BindingKind#BOUND_INSTANCE} binding for a
+ * {@code @BindsInstance}-annotated builder setter method or factory method parameter.
+ */
+ ProvisionBinding boundInstanceBinding(ComponentRequirement requirement, Element element) {
+ checkArgument(element instanceof VariableElement || element instanceof ExecutableElement);
+ VariableElement parameterElement =
+ element instanceof VariableElement
+ ? MoreElements.asVariable(element)
+ : getOnlyElement(MoreElements.asExecutable(element).getParameters());
+ return ProvisionBinding.builder()
+ .contributionType(ContributionType.UNIQUE)
+ .bindingElement(element)
+ .key(requirement.key().get())
+ .nullableType(getNullableType(parameterElement))
+ .kind(BOUND_INSTANCE)
+ .build();
+ }
+
+ /**
+ * Returns a {@link dagger.model.BindingKind#SUBCOMPONENT_CREATOR} binding declared by a component
+ * method that returns a subcomponent builder. Use {{@link
+ * #subcomponentCreatorBinding(ImmutableSet)}} for bindings declared using {@link
+ * Module#subcomponents()}.
+ *
+ * @param component the component that declares or inherits the method
+ */
+ ProvisionBinding subcomponentCreatorBinding(
+ ExecutableElement subcomponentCreatorMethod, TypeElement component) {
+ checkArgument(subcomponentCreatorMethod.getKind().equals(METHOD));
+ checkArgument(subcomponentCreatorMethod.getParameters().isEmpty());
+ Key key =
+ keyFactory.forSubcomponentCreatorMethod(
+ subcomponentCreatorMethod, asDeclared(component.asType()));
+ return ProvisionBinding.builder()
+ .contributionType(ContributionType.UNIQUE)
+ .bindingElement(subcomponentCreatorMethod)
+ .key(key)
+ .kind(SUBCOMPONENT_CREATOR)
+ .build();
+ }
+
+ /**
+ * Returns a {@link dagger.model.BindingKind#SUBCOMPONENT_CREATOR} binding declared using {@link
+ * Module#subcomponents()}.
+ */
+ ProvisionBinding subcomponentCreatorBinding(
+ ImmutableSet<SubcomponentDeclaration> subcomponentDeclarations) {
+ SubcomponentDeclaration subcomponentDeclaration = subcomponentDeclarations.iterator().next();
+ return ProvisionBinding.builder()
+ .contributionType(ContributionType.UNIQUE)
+ .key(subcomponentDeclaration.key())
+ .kind(SUBCOMPONENT_CREATOR)
+ .build();
+ }
+
+ /**
+ * Returns a {@link dagger.model.BindingKind#DELEGATE} binding.
+ *
+ * @param delegateDeclaration the {@code @Binds}-annotated declaration
+ * @param actualBinding the binding that satisfies the {@code @Binds} declaration
+ */
+ ContributionBinding delegateBinding(
+ DelegateDeclaration delegateDeclaration, ContributionBinding actualBinding) {
+ switch (actualBinding.bindingType()) {
+ case PRODUCTION:
+ return buildDelegateBinding(
+ ProductionBinding.builder().nullableType(actualBinding.nullableType()),
+ delegateDeclaration,
+ Producer.class);
+
+ case PROVISION:
+ return buildDelegateBinding(
+ ProvisionBinding.builder()
+ .scope(uniqueScopeOf(delegateDeclaration.bindingElement().get()))
+ .nullableType(actualBinding.nullableType()),
+ delegateDeclaration,
+ Provider.class);
+
+ case MEMBERS_INJECTION: // fall-through to throw
+ }
+ throw new AssertionError("bindingType: " + actualBinding);
+ }
+
+ /**
+ * Returns a {@link dagger.model.BindingKind#DELEGATE} binding used when there is no binding that
+ * satisfies the {@code @Binds} declaration.
+ */
+ public ContributionBinding unresolvedDelegateBinding(DelegateDeclaration delegateDeclaration) {
+ return buildDelegateBinding(
+ ProvisionBinding.builder().scope(uniqueScopeOf(delegateDeclaration.bindingElement().get())),
+ delegateDeclaration,
+ Provider.class);
+ }
+
+ private ContributionBinding buildDelegateBinding(
+ ContributionBinding.Builder<?, ?> builder,
+ DelegateDeclaration delegateDeclaration,
+ Class<?> frameworkType) {
+ boolean isKotlinObject =
+ metadataUtil.isObjectClass(delegateDeclaration.contributingModule().get())
+ || metadataUtil.isCompanionObjectClass(delegateDeclaration.contributingModule().get());
+ return builder
+ .contributionType(delegateDeclaration.contributionType())
+ .bindingElement(delegateDeclaration.bindingElement().get())
+ .contributingModule(delegateDeclaration.contributingModule().get())
+ .isContributingModuleKotlinObject(isKotlinObject)
+ .key(keyFactory.forDelegateBinding(delegateDeclaration, frameworkType))
+ .dependencies(delegateDeclaration.delegateRequest())
+ .wrappedMapKeyAnnotation(delegateDeclaration.wrappedMapKey())
+ .kind(DELEGATE)
+ .build();
+ }
+
+ /**
+ * Returns an {@link dagger.model.BindingKind#OPTIONAL} binding for {@code key}.
+ *
+ * @param requestKind the kind of request for the optional binding
+ * @param underlyingKeyBindings the possibly empty set of bindings that exist in the component for
+ * the underlying (non-optional) key
+ */
+ ContributionBinding syntheticOptionalBinding(
+ Key key,
+ RequestKind requestKind,
+ ImmutableCollection<? extends Binding> underlyingKeyBindings) {
+ if (underlyingKeyBindings.isEmpty()) {
+ return ProvisionBinding.builder()
+ .contributionType(ContributionType.UNIQUE)
+ .key(key)
+ .kind(OPTIONAL)
+ .build();
+ }
+
+ boolean requiresProduction =
+ underlyingKeyBindings.stream()
+ .anyMatch(binding -> binding.bindingType() == BindingType.PRODUCTION)
+ || requestKind.equals(RequestKind.PRODUCER) // handles producerFromProvider cases
+ || requestKind.equals(RequestKind.PRODUCED); // handles producerFromProvider cases
+
+ return (requiresProduction ? ProductionBinding.builder() : ProvisionBinding.builder())
+ .contributionType(ContributionType.UNIQUE)
+ .key(key)
+ .kind(OPTIONAL)
+ .dependencies(dependencyRequestFactory.forSyntheticPresentOptionalBinding(key, requestKind))
+ .build();
+ }
+
+ /** Returns a {@link dagger.model.BindingKind#MEMBERS_INJECTOR} binding. */
+ public ProvisionBinding membersInjectorBinding(
+ Key key, MembersInjectionBinding membersInjectionBinding) {
+ return ProvisionBinding.builder()
+ .key(key)
+ .contributionType(ContributionType.UNIQUE)
+ .kind(MEMBERS_INJECTOR)
+ .bindingElement(MoreTypes.asTypeElement(membersInjectionBinding.key().type()))
+ .provisionDependencies(membersInjectionBinding.dependencies())
+ .injectionSites(membersInjectionBinding.injectionSites())
+ .build();
+ }
+
+ /**
+ * Returns a {@link dagger.model.BindingKind#MEMBERS_INJECTION} binding.
+ *
+ * @param resolvedType if {@code declaredType} is a generic class and {@code resolvedType} is a
+ * parameterization of that type, the returned binding will be for the resolved type
+ */
+ // TODO(dpb): See if we can just pass one nongeneric/parameterized type.
+ public MembersInjectionBinding membersInjectionBinding(
+ DeclaredType declaredType, Optional<TypeMirror> resolvedType) {
+ // If the class this is injecting has some type arguments, resolve everything.
+ if (!declaredType.getTypeArguments().isEmpty() && resolvedType.isPresent()) {
+ DeclaredType resolved = asDeclared(resolvedType.get());
+ // Validate that we're resolving from the correct type.
+ checkState(
+ types.isSameType(types.erasure(resolved), types.erasure(declaredType)),
+ "erased expected type: %s, erased actual type: %s",
+ types.erasure(resolved),
+ types.erasure(declaredType));
+ declaredType = resolved;
+ }
+ ImmutableSortedSet<InjectionSite> injectionSites =
+ injectionSiteFactory.getInjectionSites(declaredType);
+ ImmutableSet<DependencyRequest> dependencies =
+ injectionSites.stream()
+ .flatMap(injectionSite -> injectionSite.dependencies().stream())
+ .collect(toImmutableSet());
+
+ Key key = keyFactory.forMembersInjectedType(declaredType);
+ TypeElement typeElement = MoreElements.asType(declaredType.asElement());
+ return new AutoValue_MembersInjectionBinding(
+ key,
+ dependencies,
+ typeElement,
+ hasNonDefaultTypeParameters(typeElement, key.type(), types)
+ ? Optional.of(
+ membersInjectionBinding(asDeclared(typeElement.asType()), Optional.empty()))
+ : Optional.empty(),
+ injectionSites);
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/BindingGraph.java b/java/dagger/internal/codegen/binding/BindingGraph.java
new file mode 100644
index 0000000..4936a05
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/BindingGraph.java
@@ -0,0 +1,347 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static dagger.internal.codegen.extension.DaggerCollectors.toOptional;
+import static dagger.internal.codegen.extension.DaggerStreams.presentValues;
+import static dagger.internal.codegen.extension.DaggerStreams.stream;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableMap;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+
+import com.google.auto.value.AutoValue;
+import com.google.auto.value.extension.memoized.Memoized;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSetMultimap;
+import com.google.common.collect.Sets;
+import com.google.common.graph.Graphs;
+import com.google.common.graph.ImmutableNetwork;
+import com.google.common.graph.Traverser;
+import dagger.model.BindingGraph.ChildFactoryMethodEdge;
+import dagger.model.BindingGraph.ComponentNode;
+import dagger.model.BindingGraph.Edge;
+import dagger.model.BindingGraph.Node;
+import dagger.model.ComponentPath;
+import dagger.model.Key;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+
+/**
+ * A graph that represents a single component or subcomponent within a fully validated top-level
+ * binding graph.
+ */
+@AutoValue
+public abstract class BindingGraph {
+
+ @AutoValue
+ abstract static class TopLevelBindingGraph extends dagger.model.BindingGraph {
+ static TopLevelBindingGraph create(
+ ImmutableNetwork<Node, Edge> network, boolean isFullBindingGraph) {
+ TopLevelBindingGraph topLevelBindingGraph =
+ new AutoValue_BindingGraph_TopLevelBindingGraph(network, isFullBindingGraph);
+
+ ImmutableMap<ComponentPath, ComponentNode> componentNodes =
+ topLevelBindingGraph.componentNodes().stream()
+ .collect(
+ toImmutableMap(ComponentNode::componentPath, componentNode -> componentNode));
+
+ ImmutableSetMultimap.Builder<ComponentNode, ComponentNode> subcomponentNodesBuilder =
+ ImmutableSetMultimap.builder();
+ topLevelBindingGraph.componentNodes().stream()
+ .filter(componentNode -> !componentNode.componentPath().atRoot())
+ .forEach(
+ componentNode ->
+ subcomponentNodesBuilder.put(
+ componentNodes.get(componentNode.componentPath().parent()), componentNode));
+
+ // Set these fields directly on the instance rather than passing these in as input to the
+ // AutoValue to prevent exposing this data outside of the class.
+ topLevelBindingGraph.componentNodes = componentNodes;
+ topLevelBindingGraph.subcomponentNodes = subcomponentNodesBuilder.build();
+ return topLevelBindingGraph;
+ }
+
+ private ImmutableMap<ComponentPath, ComponentNode> componentNodes;
+ private ImmutableSetMultimap<ComponentNode, ComponentNode> subcomponentNodes;
+
+ TopLevelBindingGraph() {}
+
+ // This overrides dagger.model.BindingGraph with a more efficient implementation.
+ @Override
+ public Optional<ComponentNode> componentNode(ComponentPath componentPath) {
+ return componentNodes.containsKey(componentPath)
+ ? Optional.of(componentNodes.get(componentPath))
+ : Optional.empty();
+ }
+
+ /** Returns the set of subcomponent nodes of the given component node. */
+ ImmutableSet<ComponentNode> subcomponentNodes(ComponentNode componentNode) {
+ return subcomponentNodes.get(componentNode);
+ }
+
+ @Override
+ @Memoized
+ public ImmutableSetMultimap<Class<? extends Node>, ? extends Node> nodesByClass() {
+ return super.nodesByClass();
+ }
+ }
+
+ static BindingGraph create(
+ ComponentNode componentNode, TopLevelBindingGraph topLevelBindingGraph) {
+ return create(Optional.empty(), componentNode, topLevelBindingGraph);
+ }
+
+ private static BindingGraph create(
+ Optional<BindingGraph> parent,
+ ComponentNode componentNode,
+ TopLevelBindingGraph topLevelBindingGraph) {
+ ImmutableSet<BindingNode> reachableBindingNodes =
+ Graphs.reachableNodes(topLevelBindingGraph.network().asGraph(), componentNode).stream()
+ .filter(node -> isSubpath(componentNode.componentPath(), node.componentPath()))
+ .filter(node -> node instanceof BindingNode)
+ .map(node -> (BindingNode) node)
+ .collect(toImmutableSet());
+
+ // Construct the maps of the ContributionBindings and MembersInjectionBindings.
+ Map<Key, BindingNode> contributionBindings = new HashMap<>();
+ Map<Key, BindingNode> membersInjectionBindings = new HashMap<>();
+ for (BindingNode bindingNode : reachableBindingNodes) {
+ Map<Key, BindingNode> bindingsMap;
+ if (bindingNode.delegate() instanceof ContributionBinding) {
+ bindingsMap = contributionBindings;
+ } else if (bindingNode.delegate() instanceof MembersInjectionBinding) {
+ bindingsMap = membersInjectionBindings;
+ } else {
+ throw new AssertionError("Unexpected binding node type: " + bindingNode.delegate());
+ }
+
+ // TODO(bcorso): Mapping binding nodes by key is flawed since bindings that depend on local
+ // multibindings can have multiple nodes (one in each component). In this case, we choose the
+ // node in the child-most component since this is likely the node that users of this
+ // BindingGraph will want (and to remain consisted with LegacyBindingGraph). However, ideally
+ // we would avoid this ambiguity by getting dependencies directly from the top-level network.
+ // In particular, rather than using a Binding's list of DependencyRequests (which only
+ // contains the key) we would use the top-level network to find the DependencyEdges for a
+ // particular BindingNode.
+ Key key = bindingNode.key();
+ if (!bindingsMap.containsKey(key)
+ // Always choose the child-most binding node.
+ || bindingNode.componentPath().components().size()
+ > bindingsMap.get(key).componentPath().components().size()) {
+ bindingsMap.put(key, bindingNode);
+ }
+ }
+
+ BindingGraph bindingGraph = new AutoValue_BindingGraph(componentNode, topLevelBindingGraph);
+
+ ImmutableSet<ModuleDescriptor> modules =
+ ((ComponentNodeImpl) componentNode).componentDescriptor().modules();
+
+ ImmutableSet<ModuleDescriptor> inheritedModules =
+ parent.isPresent()
+ ? Sets.union(parent.get().ownedModules, parent.get().inheritedModules).immutableCopy()
+ : ImmutableSet.of();
+
+ // Set these fields directly on the instance rather than passing these in as input to the
+ // AutoValue to prevent exposing this data outside of the class.
+ bindingGraph.inheritedModules = inheritedModules;
+ bindingGraph.ownedModules = Sets.difference(modules, inheritedModules).immutableCopy();
+ bindingGraph.contributionBindings = ImmutableMap.copyOf(contributionBindings);
+ bindingGraph.membersInjectionBindings = ImmutableMap.copyOf(membersInjectionBindings);
+ bindingGraph.bindingModules =
+ contributionBindings.values().stream()
+ .map(BindingNode::contributingModule)
+ .flatMap(presentValues())
+ .collect(toImmutableSet());
+
+ return bindingGraph;
+ }
+
+ private ImmutableMap<Key, BindingNode> contributionBindings;
+ private ImmutableMap<Key, BindingNode> membersInjectionBindings;
+ private ImmutableSet<ModuleDescriptor> inheritedModules;
+ private ImmutableSet<ModuleDescriptor> ownedModules;
+ private ImmutableSet<TypeElement> bindingModules;
+
+ BindingGraph() {}
+
+ /** Returns the {@link ComponentNode} for this graph. */
+ public abstract ComponentNode componentNode();
+
+ /** Returns the {@link ComponentPath} for this graph. */
+ public final ComponentPath componentPath() {
+ return componentNode().componentPath();
+ }
+
+ /** Returns the {@link TopLevelBindingGraph} from which this graph is contained. */
+ public abstract TopLevelBindingGraph topLevelBindingGraph();
+
+ /** Returns the {@link ComponentDescriptor} for this graph */
+ public final ComponentDescriptor componentDescriptor() {
+ return ((ComponentNodeImpl) componentNode()).componentDescriptor();
+ }
+
+ /** Returns the {@link ContributionBinding} for the given {@link Key}. */
+ public final ContributionBinding contributionBinding(Key key) {
+ return (ContributionBinding) contributionBindings.get(key).delegate();
+ }
+
+ /**
+ * Returns the {@link MembersInjectionBinding} for the given {@link Key} or {@link
+ * Optional#empty()} if one does not exist.
+ */
+ public final Optional<MembersInjectionBinding> membersInjectionBinding(Key key) {
+ return membersInjectionBindings.containsKey(key)
+ ? Optional.of((MembersInjectionBinding) membersInjectionBindings.get(key).delegate())
+ : Optional.empty();
+ }
+
+ /** Returns the {@link TypeElement} for the component this graph represents. */
+ public final TypeElement componentTypeElement() {
+ return componentPath().currentComponent();
+ }
+
+ /**
+ * Returns the set of modules that are owned by this graph regardless of whether or not any of
+ * their bindings are used in this graph. For graphs representing top-level {@link
+ * dagger.Component components}, this set will be the same as {@linkplain
+ * ComponentDescriptor#modules() the component's transitive modules}. For {@linkplain Subcomponent
+ * subcomponents}, this set will be the transitive modules that are not owned by any of their
+ * ancestors.
+ */
+ public final ImmutableSet<TypeElement> ownedModuleTypes() {
+ return ownedModules.stream().map(ModuleDescriptor::moduleElement).collect(toImmutableSet());
+ }
+
+ /**
+ * Returns the factory method for this subcomponent, if it exists.
+ *
+ * <p>This factory method is the one defined in the parent component's interface.
+ *
+ * <p>In the example below, the {@link BindingGraph#factoryMethod} for {@code ChildComponent}
+ * would return the {@link ExecutableElement}: {@code childComponent(ChildModule1)} .
+ *
+ * <pre><code>
+ * {@literal @Component}
+ * interface ParentComponent {
+ * ChildComponent childComponent(ChildModule1 childModule);
+ * }
+ * </code></pre>
+ */
+ // TODO(b/73294201): Consider returning the resolved ExecutableType for the factory method.
+ public final Optional<ExecutableElement> factoryMethod() {
+ return topLevelBindingGraph().network().inEdges(componentNode()).stream()
+ .filter(edge -> edge instanceof ChildFactoryMethodEdge)
+ .map(edge -> ((ChildFactoryMethodEdge) edge).factoryMethod())
+ .collect(toOptional());
+ }
+
+ /**
+ * Returns a map between the {@linkplain ComponentRequirement component requirement} and the
+ * corresponding {@link VariableElement} for each module parameter in the {@linkplain
+ * BindingGraph#factoryMethod factory method}.
+ */
+ // TODO(dpb): Consider disallowing modules if none of their bindings are used.
+ public final ImmutableMap<ComponentRequirement, VariableElement> factoryMethodParameters() {
+ return factoryMethod().get().getParameters().stream()
+ .collect(
+ toImmutableMap(
+ parameter -> ComponentRequirement.forModule(parameter.asType()),
+ parameter -> parameter));
+ }
+
+ /**
+ * The types for which the component needs instances.
+ *
+ * <ul>
+ * <li>component dependencies
+ * <li>owned modules with concrete instance bindings that are used in the graph
+ * <li>bound instances
+ * </ul>
+ */
+ @Memoized
+ public ImmutableSet<ComponentRequirement> componentRequirements() {
+ ImmutableSet<TypeElement> requiredModules =
+ stream(Traverser.forTree(BindingGraph::subgraphs).depthFirstPostOrder(this))
+ .flatMap(graph -> graph.bindingModules.stream())
+ .filter(ownedModuleTypes()::contains)
+ .collect(toImmutableSet());
+ ImmutableSet.Builder<ComponentRequirement> requirements = ImmutableSet.builder();
+ componentDescriptor().requirements().stream()
+ .filter(
+ requirement ->
+ !requirement.kind().isModule()
+ || requiredModules.contains(requirement.typeElement()))
+ .forEach(requirements::add);
+ if (factoryMethod().isPresent()) {
+ requirements.addAll(factoryMethodParameters().keySet());
+ }
+ return requirements.build();
+ }
+
+ /** Returns all {@link ComponentDescriptor}s in the {@link TopLevelBindingGraph}. */
+ public final ImmutableSet<ComponentDescriptor> componentDescriptors() {
+ return topLevelBindingGraph().componentNodes().stream()
+ .map(componentNode -> ((ComponentNodeImpl) componentNode).componentDescriptor())
+ .collect(toImmutableSet());
+ }
+
+ @Memoized
+ public ImmutableList<BindingGraph> subgraphs() {
+ return topLevelBindingGraph().subcomponentNodes(componentNode()).stream()
+ .map(subcomponent -> create(Optional.of(this), subcomponent, topLevelBindingGraph()))
+ .collect(toImmutableList());
+ }
+
+ public final ImmutableSet<BindingNode> bindingNodes(Key key) {
+ ImmutableSet.Builder<BindingNode> builder = ImmutableSet.builder();
+ if (contributionBindings.containsKey(key)) {
+ builder.add(contributionBindings.get(key));
+ }
+ if (membersInjectionBindings.containsKey(key)) {
+ builder.add(membersInjectionBindings.get(key));
+ }
+ return builder.build();
+ }
+
+ @Memoized
+ public ImmutableSet<BindingNode> bindingNodes() {
+ return ImmutableSet.<BindingNode>builder()
+ .addAll(contributionBindings.values())
+ .addAll(membersInjectionBindings.values())
+ .build();
+ }
+
+ // TODO(bcorso): Move this to ComponentPath
+ private static boolean isSubpath(ComponentPath path, ComponentPath subpath) {
+ if (path.components().size() < subpath.components().size()) {
+ return false;
+ }
+ for (int i = 0; i < subpath.components().size(); i++) {
+ if (!path.components().get(i).equals(subpath.components().get(i))) {
+ return false;
+ }
+ }
+ return true;
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/BindingGraphConverter.java b/java/dagger/internal/codegen/binding/BindingGraphConverter.java
new file mode 100644
index 0000000..b882b37
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/BindingGraphConverter.java
@@ -0,0 +1,397 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.auto.common.MoreTypes.asTypeElement;
+import static com.google.common.base.Verify.verify;
+import static dagger.internal.codegen.binding.BindingRequest.bindingRequest;
+import static dagger.internal.codegen.extension.DaggerGraphs.unreachableNodes;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
+import static dagger.model.BindingKind.SUBCOMPONENT_CREATOR;
+
+import com.google.auto.value.AutoValue;
+import com.google.auto.value.extension.memoized.Memoized;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Iterators;
+import com.google.common.graph.ImmutableNetwork;
+import com.google.common.graph.MutableNetwork;
+import com.google.common.graph.Network;
+import com.google.common.graph.NetworkBuilder;
+import dagger.internal.codegen.binding.BindingGraph.TopLevelBindingGraph;
+import dagger.internal.codegen.binding.ComponentDescriptor.ComponentMethodDescriptor;
+import dagger.model.BindingGraph.ComponentNode;
+import dagger.model.BindingGraph.DependencyEdge;
+import dagger.model.BindingGraph.Edge;
+import dagger.model.BindingGraph.MissingBinding;
+import dagger.model.BindingGraph.Node;
+import dagger.model.ComponentPath;
+import dagger.model.DependencyRequest;
+import dagger.model.Key;
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import javax.inject.Inject;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeMirror;
+
+/** Converts {@link BindingGraph}s to {@link dagger.model.BindingGraph}s. */
+final class BindingGraphConverter {
+ private final BindingDeclarationFormatter bindingDeclarationFormatter;
+
+ @Inject
+ BindingGraphConverter(BindingDeclarationFormatter bindingDeclarationFormatter) {
+ this.bindingDeclarationFormatter = bindingDeclarationFormatter;
+ }
+
+ /**
+ * Creates the external {@link dagger.model.BindingGraph} representing the given internal {@link
+ * BindingGraph}.
+ */
+ BindingGraph convert(LegacyBindingGraph legacyBindingGraph, boolean isFullBindingGraph) {
+ MutableNetwork<Node, Edge> network = asNetwork(legacyBindingGraph);
+ ComponentNode rootNode = rootComponentNode(network);
+
+ // When bindings are copied down into child graphs because they transitively depend on local
+ // multibindings or optional bindings, the parent-owned binding is still there. If that
+ // parent-owned binding is not reachable from its component, it doesn't need to be in the graph
+ // because it will never be used. So remove all nodes that are not reachable from the root
+ // component—unless we're converting a full binding graph.
+ if (!isFullBindingGraph) {
+ unreachableNodes(network.asGraph(), rootNode).forEach(network::removeNode);
+ }
+
+ TopLevelBindingGraph topLevelBindingGraph =
+ TopLevelBindingGraph.create(ImmutableNetwork.copyOf(network), isFullBindingGraph);
+ return BindingGraph.create(rootNode, topLevelBindingGraph);
+ }
+
+ private MutableNetwork<Node, Edge> asNetwork(LegacyBindingGraph graph) {
+ Converter converter = new Converter(bindingDeclarationFormatter);
+ converter.visitRootComponent(graph);
+ return converter.network;
+ }
+
+ // TODO(dpb): Example of BindingGraph logic applied to derived networks.
+ private ComponentNode rootComponentNode(Network<Node, Edge> network) {
+ return (ComponentNode)
+ Iterables.find(
+ network.nodes(),
+ node -> node instanceof ComponentNode && node.componentPath().atRoot());
+ }
+
+ /**
+ * Used as a cache key to make sure resolved bindings are cached per component path.
+ * This is required so that binding nodes are not reused across different branches of the
+ * graph since the ResolvedBindings class only contains the component and not the path.
+ */
+ @AutoValue
+ abstract static class ResolvedBindingsWithPath {
+ abstract ResolvedBindings resolvedBindings();
+ abstract ComponentPath componentPath();
+
+ static ResolvedBindingsWithPath create(
+ ResolvedBindings resolvedBindings, ComponentPath componentPath) {
+ return new AutoValue_BindingGraphConverter_ResolvedBindingsWithPath(
+ resolvedBindings, componentPath);
+ }
+ }
+
+ private static final class Converter {
+ /** The path from the root graph to the currently visited graph. */
+ private final Deque<LegacyBindingGraph> bindingGraphPath = new ArrayDeque<>();
+
+ /** The {@link ComponentPath} for each component in {@link #bindingGraphPath}. */
+ private final Deque<ComponentPath> componentPaths = new ArrayDeque<>();
+
+ private final BindingDeclarationFormatter bindingDeclarationFormatter;
+ private final MutableNetwork<Node, Edge> network =
+ NetworkBuilder.directed().allowsParallelEdges(true).allowsSelfLoops(true).build();
+ private final Set<BindingNode> bindings = new HashSet<>();
+
+ private final Map<ResolvedBindingsWithPath, ImmutableSet<BindingNode>> resolvedBindingsMap =
+ new HashMap<>();
+
+ /** Constructs a converter for a root (component, not subcomponent) binding graph. */
+ private Converter(BindingDeclarationFormatter bindingDeclarationFormatter) {
+ this.bindingDeclarationFormatter = bindingDeclarationFormatter;
+ }
+
+ private void visitRootComponent(LegacyBindingGraph graph) {
+ visitComponent(graph, null);
+ }
+
+ /**
+ * Called once for each component in a component hierarchy.
+ *
+ * <p>This implementation does the following:
+ *
+ * <ol>
+ * <li>If this component is installed in its parent by a subcomponent factory method, calls
+ * {@link #visitSubcomponentFactoryMethod(ComponentNode, ComponentNode,
+ * ExecutableElement)}.
+ * <li>For each entry point in the component, calls {@link #visitEntryPoint(ComponentNode,
+ * DependencyRequest)}.
+ * <li>For each child component, calls {@link #visitComponent(LegacyBindingGraph,
+ * ComponentNode)}, updating the traversal state.
+ * </ol>
+ *
+ * @param graph the currently visited graph
+ */
+ private void visitComponent(LegacyBindingGraph graph, ComponentNode parentComponent) {
+ bindingGraphPath.addLast(graph);
+ ComponentPath graphPath =
+ ComponentPath.create(
+ bindingGraphPath.stream()
+ .map(LegacyBindingGraph::componentDescriptor)
+ .map(ComponentDescriptor::typeElement)
+ .collect(toImmutableList()));
+ componentPaths.addLast(graphPath);
+ ComponentNode currentComponent =
+ ComponentNodeImpl.create(componentPath(), graph.componentDescriptor());
+
+ network.addNode(currentComponent);
+
+ for (ComponentMethodDescriptor entryPointMethod :
+ graph.componentDescriptor().entryPointMethods()) {
+ visitEntryPoint(currentComponent, entryPointMethod.dependencyRequest().get());
+ }
+
+ for (ResolvedBindings resolvedBindings : graph.resolvedBindings()) {
+ for (BindingNode binding : bindingNodes(resolvedBindings)) {
+ if (bindings.add(binding)) {
+ network.addNode(binding);
+ for (DependencyRequest dependencyRequest : binding.dependencies()) {
+ addDependencyEdges(binding, dependencyRequest);
+ }
+ }
+ if (binding.kind().equals(SUBCOMPONENT_CREATOR)
+ && binding.componentPath().equals(currentComponent.componentPath())) {
+ network.addEdge(
+ binding,
+ subcomponentNode(binding.key().type(), graph),
+ new SubcomponentCreatorBindingEdgeImpl(
+ resolvedBindings.subcomponentDeclarations()));
+ }
+ }
+ }
+
+ if (bindingGraphPath.size() > 1) {
+ LegacyBindingGraph parent = Iterators.get(bindingGraphPath.descendingIterator(), 1);
+ parent
+ .componentDescriptor()
+ .getFactoryMethodForChildComponent(graph.componentDescriptor())
+ .ifPresent(
+ childFactoryMethod ->
+ visitSubcomponentFactoryMethod(
+ parentComponent, currentComponent, childFactoryMethod.methodElement()));
+ }
+
+ for (LegacyBindingGraph child : graph.subgraphs()) {
+ visitComponent(child, currentComponent);
+ }
+
+ verify(bindingGraphPath.removeLast().equals(graph));
+ verify(componentPaths.removeLast().equals(graphPath));
+ }
+
+ /**
+ * Called once for each entry point in a component.
+ *
+ * @param componentNode the component that contains the entry point
+ * @param entryPoint the entry point to visit
+ */
+ private void visitEntryPoint(ComponentNode componentNode, DependencyRequest entryPoint) {
+ addDependencyEdges(componentNode, entryPoint);
+ }
+
+ /**
+ * Called if this component was installed in its parent by a subcomponent factory method.
+ *
+ * @param parentComponent the parent graph
+ * @param currentComponent the currently visited graph
+ * @param factoryMethod the factory method in the parent component that declares that the
+ * current component is a child
+ */
+ private void visitSubcomponentFactoryMethod(
+ ComponentNode parentComponent,
+ ComponentNode currentComponent,
+ ExecutableElement factoryMethod) {
+ network.addEdge(
+ parentComponent,
+ currentComponent,
+ new ChildFactoryMethodEdgeImpl(factoryMethod));
+ }
+
+ /**
+ * Returns an immutable snapshot of the path from the root component to the currently visited
+ * component.
+ */
+ private ComponentPath componentPath() {
+ return componentPaths.getLast();
+ }
+
+ /**
+ * Returns the subpath from the root component to the matching {@code ancestor} of the current
+ * component.
+ */
+ private ComponentPath pathFromRootToAncestor(TypeElement ancestor) {
+ for (ComponentPath componentPath : componentPaths) {
+ if (componentPath.currentComponent().equals(ancestor)) {
+ return componentPath;
+ }
+ }
+ throw new IllegalArgumentException(
+ String.format(
+ "%s is not in the current path: %s", ancestor.getQualifiedName(), componentPath()));
+ }
+
+ /**
+ * Returns the LegacyBindingGraph for {@code ancestor}, where {@code ancestor} is in the
+ * component path of the current traversal.
+ */
+ private LegacyBindingGraph graphForAncestor(TypeElement ancestor) {
+ for (LegacyBindingGraph graph : bindingGraphPath) {
+ if (graph.componentDescriptor().typeElement().equals(ancestor)) {
+ return graph;
+ }
+ }
+ throw new IllegalArgumentException(
+ String.format(
+ "%s is not in the current path: %s", ancestor.getQualifiedName(), componentPath()));
+ }
+
+ /**
+ * Adds a {@link dagger.model.BindingGraph.DependencyEdge} from a node to the binding(s) that
+ * satisfy a dependency request.
+ */
+ private void addDependencyEdges(Node source, DependencyRequest dependencyRequest) {
+ ResolvedBindings dependencies = resolvedDependencies(source, dependencyRequest);
+ if (dependencies.isEmpty()) {
+ addDependencyEdge(source, dependencyRequest, missingBindingNode(dependencies));
+ } else {
+ for (BindingNode dependency : bindingNodes(dependencies)) {
+ addDependencyEdge(source, dependencyRequest, dependency);
+ }
+ }
+ }
+
+ private void addDependencyEdge(
+ Node source, DependencyRequest dependencyRequest, Node dependency) {
+ network.addNode(dependency);
+ if (!hasDependencyEdge(source, dependency, dependencyRequest)) {
+ network.addEdge(
+ source,
+ dependency,
+ new DependencyEdgeImpl(dependencyRequest, source instanceof ComponentNode));
+ }
+ }
+
+ private boolean hasDependencyEdge(
+ Node source, Node dependency, DependencyRequest dependencyRequest) {
+ // An iterative approach is used instead of a Stream because this method is called in a hot
+ // loop, and the Stream calculates the size of network.edgesConnecting(), which is slow. This
+ // seems to be because caculating the edges connecting two nodes in a Network that supports
+ // parallel edges is must check the equality of many nodes, and BindingNode's equality
+ // semantics drag in the equality of many other expensive objects
+ for (Edge edge : network.edgesConnecting(source, dependency)) {
+ if (edge instanceof DependencyEdge) {
+ if (((DependencyEdge) edge).dependencyRequest().equals(dependencyRequest)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ private ResolvedBindings resolvedDependencies(
+ Node source, DependencyRequest dependencyRequest) {
+ return graphForAncestor(source.componentPath().currentComponent())
+ .resolvedBindings(bindingRequest(dependencyRequest));
+ }
+
+ private ImmutableSet<BindingNode> bindingNodes(ResolvedBindings resolvedBindings) {
+ ResolvedBindingsWithPath resolvedBindingsWithPath =
+ ResolvedBindingsWithPath.create(resolvedBindings, componentPath());
+ return resolvedBindingsMap.computeIfAbsent(
+ resolvedBindingsWithPath, this::uncachedBindingNodes);
+ }
+
+ private ImmutableSet<BindingNode> uncachedBindingNodes(
+ ResolvedBindingsWithPath resolvedBindingsWithPath) {
+ ImmutableSet.Builder<BindingNode> bindingNodes = ImmutableSet.builder();
+ resolvedBindingsWithPath.resolvedBindings()
+ .allBindings()
+ .asMap()
+ .forEach(
+ (component, bindings) -> {
+ for (Binding binding : bindings) {
+ bindingNodes.add(
+ bindingNode(resolvedBindingsWithPath.resolvedBindings(), binding, component));
+ }
+ });
+ return bindingNodes.build();
+ }
+
+ private BindingNode bindingNode(
+ ResolvedBindings resolvedBindings, Binding binding, TypeElement owningComponent) {
+ return BindingNode.create(
+ pathFromRootToAncestor(owningComponent),
+ binding,
+ resolvedBindings.multibindingDeclarations(),
+ resolvedBindings.optionalBindingDeclarations(),
+ resolvedBindings.subcomponentDeclarations(),
+ bindingDeclarationFormatter);
+ }
+
+ private MissingBinding missingBindingNode(ResolvedBindings dependencies) {
+ // Put all missing binding nodes in the root component. This simplifies the binding graph
+ // and produces better error messages for users since all dependents point to the same node.
+ return MissingBindingImpl.create(
+ ComponentPath.create(ImmutableList.of(componentPath().rootComponent())),
+ dependencies.key());
+ }
+
+ private ComponentNode subcomponentNode(
+ TypeMirror subcomponentBuilderType, LegacyBindingGraph graph) {
+ TypeElement subcomponentBuilderElement = asTypeElement(subcomponentBuilderType);
+ ComponentDescriptor subcomponent =
+ graph.componentDescriptor().getChildComponentWithBuilderType(subcomponentBuilderElement);
+ return ComponentNodeImpl.create(
+ componentPath().childPath(subcomponent.typeElement()), subcomponent);
+ }
+ }
+
+ @AutoValue
+ abstract static class MissingBindingImpl extends MissingBinding {
+ static MissingBinding create(ComponentPath component, Key key) {
+ return new AutoValue_BindingGraphConverter_MissingBindingImpl(component, key);
+ }
+
+ @Memoized
+ @Override
+ public abstract int hashCode();
+
+ @Override
+ public abstract boolean equals(Object o);
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/BindingGraphFactory.java b/java/dagger/internal/codegen/binding/BindingGraphFactory.java
new file mode 100644
index 0000000..2c15e26
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/BindingGraphFactory.java
@@ -0,0 +1,980 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.auto.common.MoreTypes.asTypeElement;
+import static com.google.auto.common.MoreTypes.isType;
+import static com.google.auto.common.MoreTypes.isTypeOf;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static dagger.internal.codegen.base.RequestKinds.getRequestKind;
+import static dagger.internal.codegen.base.Util.reentrantComputeIfAbsent;
+import static dagger.internal.codegen.binding.AssistedInjectionAnnotations.isAssistedFactoryType;
+import static dagger.internal.codegen.binding.ComponentDescriptor.isComponentContributionMethod;
+import static dagger.internal.codegen.binding.SourceFiles.generatedMonitoringModuleName;
+import static dagger.model.BindingKind.ASSISTED_INJECTION;
+import static dagger.model.BindingKind.DELEGATE;
+import static dagger.model.BindingKind.INJECTION;
+import static dagger.model.BindingKind.OPTIONAL;
+import static dagger.model.BindingKind.SUBCOMPONENT_CREATOR;
+import static dagger.model.RequestKind.MEMBERS_INJECTION;
+import static java.util.function.Predicate.isEqual;
+import static javax.lang.model.util.ElementFilter.methodsIn;
+
+import com.google.auto.common.MoreTypes;
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSetMultimap;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Multimaps;
+import dagger.MembersInjector;
+import dagger.Reusable;
+import dagger.internal.codegen.base.ClearableCache;
+import dagger.internal.codegen.base.ContributionType;
+import dagger.internal.codegen.base.MapType;
+import dagger.internal.codegen.base.OptionalType;
+import dagger.internal.codegen.compileroption.CompilerOptions;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.model.DependencyRequest;
+import dagger.model.Key;
+import dagger.model.Scope;
+import dagger.producers.Produced;
+import dagger.producers.Producer;
+import dagger.producers.internal.ProductionExecutorModule;
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Queue;
+import java.util.Set;
+import javax.inject.Inject;
+import javax.inject.Provider;
+import javax.inject.Singleton;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeKind;
+
+/** A factory for {@link BindingGraph} objects. */
+@Singleton
+public final class BindingGraphFactory implements ClearableCache {
+
+ private final DaggerElements elements;
+ private final InjectBindingRegistry injectBindingRegistry;
+ private final KeyFactory keyFactory;
+ private final BindingFactory bindingFactory;
+ private final ModuleDescriptor.Factory moduleDescriptorFactory;
+ private final BindingGraphConverter bindingGraphConverter;
+ private final Map<Key, ImmutableSet<Key>> keysMatchingRequestCache = new HashMap<>();
+ private final CompilerOptions compilerOptions;
+
+ @Inject
+ BindingGraphFactory(
+ DaggerElements elements,
+ InjectBindingRegistry injectBindingRegistry,
+ KeyFactory keyFactory,
+ BindingFactory bindingFactory,
+ ModuleDescriptor.Factory moduleDescriptorFactory,
+ BindingGraphConverter bindingGraphConverter,
+ CompilerOptions compilerOptions) {
+ this.elements = elements;
+ this.injectBindingRegistry = injectBindingRegistry;
+ this.keyFactory = keyFactory;
+ this.bindingFactory = bindingFactory;
+ this.moduleDescriptorFactory = moduleDescriptorFactory;
+ this.bindingGraphConverter = bindingGraphConverter;
+ this.compilerOptions = compilerOptions;
+ }
+
+ /**
+ * Creates a binding graph for a component.
+ *
+ * @param createFullBindingGraph if {@code true}, the binding graph will include all bindings;
+ * otherwise it will include only bindings reachable from at least one entry point
+ */
+ public BindingGraph create(
+ ComponentDescriptor componentDescriptor, boolean createFullBindingGraph) {
+ return bindingGraphConverter.convert(
+ createLegacyBindingGraph(Optional.empty(), componentDescriptor, createFullBindingGraph),
+ createFullBindingGraph);
+ }
+
+ private LegacyBindingGraph createLegacyBindingGraph(
+ Optional<Resolver> parentResolver,
+ ComponentDescriptor componentDescriptor,
+ boolean createFullBindingGraph) {
+ ImmutableSet.Builder<ContributionBinding> explicitBindingsBuilder = ImmutableSet.builder();
+ ImmutableSet.Builder<DelegateDeclaration> delegatesBuilder = ImmutableSet.builder();
+ ImmutableSet.Builder<OptionalBindingDeclaration> optionalsBuilder = ImmutableSet.builder();
+
+ if (componentDescriptor.isRealComponent()) {
+ // binding for the component itself
+ explicitBindingsBuilder.add(
+ bindingFactory.componentBinding(componentDescriptor.typeElement()));
+ }
+
+ // Collect Component dependencies.
+ for (ComponentRequirement dependency : componentDescriptor.dependencies()) {
+ explicitBindingsBuilder.add(bindingFactory.componentDependencyBinding(dependency));
+ List<ExecutableElement> dependencyMethods =
+ methodsIn(elements.getAllMembers(dependency.typeElement()));
+
+ // Within a component dependency, we want to allow the same method to appear multiple
+ // times assuming it is the exact same method. We do this by tracking a set of bindings
+ // we've already added with the binding element removed since that is the only thing
+ // allowed to differ.
+ HashMultimap<String, ContributionBinding> dedupeBindings = HashMultimap.create();
+ for (ExecutableElement method : dependencyMethods) {
+ // MembersInjection methods aren't "provided" explicitly, so ignore them.
+ if (isComponentContributionMethod(elements, method)) {
+ ContributionBinding binding = bindingFactory.componentDependencyMethodBinding(
+ componentDescriptor, method);
+ if (dedupeBindings.put(
+ method.getSimpleName().toString(),
+ // Remove the binding element since we know that will be different, but everything
+ // else we want to be the same to consider it a duplicate.
+ binding.toBuilder().clearBindingElement().build())) {
+ explicitBindingsBuilder.add(binding);
+ }
+ }
+ }
+ }
+
+ // Collect bindings on the creator.
+ componentDescriptor
+ .creatorDescriptor()
+ .ifPresent(
+ creatorDescriptor ->
+ creatorDescriptor.boundInstanceRequirements().stream()
+ .map(
+ requirement ->
+ bindingFactory.boundInstanceBinding(
+ requirement, creatorDescriptor.elementForRequirement(requirement)))
+ .forEach(explicitBindingsBuilder::add));
+
+ componentDescriptor
+ .childComponentsDeclaredByBuilderEntryPoints()
+ .forEach(
+ (builderEntryPoint, childComponent) -> {
+ if (!componentDescriptor
+ .childComponentsDeclaredByModules()
+ .contains(childComponent)) {
+ explicitBindingsBuilder.add(
+ bindingFactory.subcomponentCreatorBinding(
+ builderEntryPoint.methodElement(), componentDescriptor.typeElement()));
+ }
+ });
+
+ ImmutableSet.Builder<MultibindingDeclaration> multibindingDeclarations = ImmutableSet.builder();
+ ImmutableSet.Builder<SubcomponentDeclaration> subcomponentDeclarations = ImmutableSet.builder();
+
+ // Collect transitive module bindings and multibinding declarations.
+ for (ModuleDescriptor moduleDescriptor : modules(componentDescriptor, parentResolver)) {
+ explicitBindingsBuilder.addAll(moduleDescriptor.bindings());
+ multibindingDeclarations.addAll(moduleDescriptor.multibindingDeclarations());
+ subcomponentDeclarations.addAll(moduleDescriptor.subcomponentDeclarations());
+ delegatesBuilder.addAll(moduleDescriptor.delegateDeclarations());
+ optionalsBuilder.addAll(moduleDescriptor.optionalDeclarations());
+ }
+
+ final Resolver requestResolver =
+ new Resolver(
+ parentResolver,
+ componentDescriptor,
+ indexBindingDeclarationsByKey(explicitBindingsBuilder.build()),
+ indexBindingDeclarationsByKey(multibindingDeclarations.build()),
+ indexBindingDeclarationsByKey(subcomponentDeclarations.build()),
+ indexBindingDeclarationsByKey(delegatesBuilder.build()),
+ indexBindingDeclarationsByKey(optionalsBuilder.build()));
+
+ componentDescriptor.entryPointMethods().stream()
+ .map(method -> method.dependencyRequest().get())
+ .forEach(
+ entryPoint -> {
+ if (entryPoint.kind().equals(MEMBERS_INJECTION)) {
+ requestResolver.resolveMembersInjection(entryPoint.key());
+ } else {
+ requestResolver.resolve(entryPoint.key());
+ }
+ });
+
+ if (createFullBindingGraph) {
+ // Resolve the keys for all bindings in all modules, stripping any multibinding contribution
+ // identifier so that the multibinding itself is resolved.
+ modules(componentDescriptor, parentResolver).stream()
+ .flatMap(module -> module.allBindingKeys().stream())
+ .map(key -> key.toBuilder().multibindingContributionIdentifier(Optional.empty()).build())
+ .forEach(requestResolver::resolve);
+ }
+
+ // Resolve all bindings for subcomponents, creating subgraphs for all subcomponents that have
+ // been detected during binding resolution. If a binding for a subcomponent is never resolved,
+ // no BindingGraph will be created for it and no implementation will be generated. This is
+ // done in a queue since resolving one subcomponent might resolve a key for a subcomponent
+ // from a parent graph. This is done until no more new subcomponents are resolved.
+ Set<ComponentDescriptor> resolvedSubcomponents = new HashSet<>();
+ ImmutableList.Builder<LegacyBindingGraph> subgraphs = ImmutableList.builder();
+ for (ComponentDescriptor subcomponent :
+ Iterables.consumingIterable(requestResolver.subcomponentsToResolve)) {
+ if (resolvedSubcomponents.add(subcomponent)) {
+ subgraphs.add(
+ createLegacyBindingGraph(
+ Optional.of(requestResolver), subcomponent, createFullBindingGraph));
+ }
+ }
+
+ return new LegacyBindingGraph(
+ componentDescriptor,
+ ImmutableMap.copyOf(requestResolver.getResolvedContributionBindings()),
+ ImmutableMap.copyOf(requestResolver.getResolvedMembersInjectionBindings()),
+ ImmutableList.copyOf(subgraphs.build()));
+ }
+
+ /**
+ * Returns all the modules that should be installed in the component. For production components
+ * and production subcomponents that have a parent that is not a production component or
+ * subcomponent, also includes the production monitoring module for the component and the
+ * production executor module.
+ */
+ private ImmutableSet<ModuleDescriptor> modules(
+ ComponentDescriptor componentDescriptor, Optional<Resolver> parentResolver) {
+ return shouldIncludeImplicitProductionModules(componentDescriptor, parentResolver)
+ ? new ImmutableSet.Builder<ModuleDescriptor>()
+ .addAll(componentDescriptor.modules())
+ .add(descriptorForMonitoringModule(componentDescriptor.typeElement()))
+ .add(descriptorForProductionExecutorModule())
+ .build()
+ : componentDescriptor.modules();
+ }
+
+ private boolean shouldIncludeImplicitProductionModules(
+ ComponentDescriptor component, Optional<Resolver> parentResolver) {
+ return component.isProduction()
+ && ((!component.isSubcomponent() && component.isRealComponent())
+ || (parentResolver.isPresent()
+ && !parentResolver.get().componentDescriptor.isProduction()));
+ }
+
+ /**
+ * Returns a descriptor for a generated module that handles monitoring for production components.
+ * This module is generated in the {@link
+ * dagger.internal.codegen.validation.MonitoringModuleProcessingStep}.
+ *
+ * @throws TypeNotPresentException if the module has not been generated yet. This will cause the
+ * processor to retry in a later processing round.
+ */
+ private ModuleDescriptor descriptorForMonitoringModule(TypeElement componentDefinitionType) {
+ return moduleDescriptorFactory.create(
+ elements.checkTypePresent(
+ generatedMonitoringModuleName(componentDefinitionType).toString()));
+ }
+
+ /** Returns a descriptor {@link ProductionExecutorModule}. */
+ private ModuleDescriptor descriptorForProductionExecutorModule() {
+ return moduleDescriptorFactory.create(elements.getTypeElement(ProductionExecutorModule.class));
+ }
+
+ /** Indexes {@code bindingDeclarations} by {@link BindingDeclaration#key()}. */
+ private static <T extends BindingDeclaration>
+ ImmutableSetMultimap<Key, T> indexBindingDeclarationsByKey(Iterable<T> declarations) {
+ return ImmutableSetMultimap.copyOf(Multimaps.index(declarations, BindingDeclaration::key));
+ }
+
+ @Override
+ public void clearCache() {
+ keysMatchingRequestCache.clear();
+ }
+
+ private final class Resolver {
+ final Optional<Resolver> parentResolver;
+ final ComponentDescriptor componentDescriptor;
+ final ImmutableSetMultimap<Key, ContributionBinding> explicitBindings;
+ final ImmutableSet<ContributionBinding> explicitBindingsSet;
+ final ImmutableSetMultimap<Key, ContributionBinding> explicitMultibindings;
+ final ImmutableSetMultimap<Key, MultibindingDeclaration> multibindingDeclarations;
+ final ImmutableSetMultimap<Key, SubcomponentDeclaration> subcomponentDeclarations;
+ final ImmutableSetMultimap<Key, DelegateDeclaration> delegateDeclarations;
+ final ImmutableSetMultimap<Key, OptionalBindingDeclaration> optionalBindingDeclarations;
+ final ImmutableSetMultimap<Key, DelegateDeclaration> delegateMultibindingDeclarations;
+ final Map<Key, ResolvedBindings> resolvedContributionBindings = new LinkedHashMap<>();
+ final Map<Key, ResolvedBindings> resolvedMembersInjectionBindings = new LinkedHashMap<>();
+ final Deque<Key> cycleStack = new ArrayDeque<>();
+ final Map<Key, Boolean> keyDependsOnLocalBindingsCache = new HashMap<>();
+ final Map<Binding, Boolean> bindingDependsOnLocalBindingsCache = new HashMap<>();
+ final Queue<ComponentDescriptor> subcomponentsToResolve = new ArrayDeque<>();
+
+ Resolver(
+ Optional<Resolver> parentResolver,
+ ComponentDescriptor componentDescriptor,
+ ImmutableSetMultimap<Key, ContributionBinding> explicitBindings,
+ ImmutableSetMultimap<Key, MultibindingDeclaration> multibindingDeclarations,
+ ImmutableSetMultimap<Key, SubcomponentDeclaration> subcomponentDeclarations,
+ ImmutableSetMultimap<Key, DelegateDeclaration> delegateDeclarations,
+ ImmutableSetMultimap<Key, OptionalBindingDeclaration> optionalBindingDeclarations) {
+ this.parentResolver = parentResolver;
+ this.componentDescriptor = checkNotNull(componentDescriptor);
+ this.explicitBindings = checkNotNull(explicitBindings);
+ this.explicitBindingsSet = ImmutableSet.copyOf(explicitBindings.values());
+ this.multibindingDeclarations = checkNotNull(multibindingDeclarations);
+ this.subcomponentDeclarations = checkNotNull(subcomponentDeclarations);
+ this.delegateDeclarations = checkNotNull(delegateDeclarations);
+ this.optionalBindingDeclarations = checkNotNull(optionalBindingDeclarations);
+ this.explicitMultibindings = multibindingContributionsByMultibindingKey(explicitBindingsSet);
+ this.delegateMultibindingDeclarations =
+ multibindingContributionsByMultibindingKey(delegateDeclarations.values());
+ subcomponentsToResolve.addAll(
+ componentDescriptor.childComponentsDeclaredByFactoryMethods().values());
+ subcomponentsToResolve.addAll(
+ componentDescriptor.childComponentsDeclaredByBuilderEntryPoints().values());
+ }
+
+ /**
+ * Returns the resolved contribution bindings for the given {@link Key}:
+ *
+ * <ul>
+ * <li>All explicit bindings for:
+ * <ul>
+ * <li>the requested key
+ * <li>{@code Set<T>} if the requested key's type is {@code Set<Produced<T>>}
+ * <li>{@code Map<K, Provider<V>>} if the requested key's type is {@code Map<K,
+ * Producer<V>>}.
+ * </ul>
+ * <li>An implicit {@link Inject @Inject}-annotated constructor binding if there is one and
+ * there are no explicit bindings or synthetic bindings.
+ * </ul>
+ */
+ ResolvedBindings lookUpBindings(Key requestKey) {
+ Set<ContributionBinding> bindings = new LinkedHashSet<>();
+ Set<ContributionBinding> multibindingContributions = new LinkedHashSet<>();
+ Set<MultibindingDeclaration> multibindingDeclarations = new LinkedHashSet<>();
+ Set<OptionalBindingDeclaration> optionalBindingDeclarations = new LinkedHashSet<>();
+ Set<SubcomponentDeclaration> subcomponentDeclarations = new LinkedHashSet<>();
+
+ // Gather all bindings, multibindings, optional, and subcomponent declarations/contributions.
+ ImmutableSet<Key> keysMatchingRequest = keysMatchingRequest(requestKey);
+ for (Resolver resolver : getResolverLineage()) {
+ bindings.addAll(resolver.getLocalExplicitBindings(requestKey));
+
+ for (Key key : keysMatchingRequest) {
+ multibindingContributions.addAll(resolver.getLocalExplicitMultibindings(key));
+ multibindingDeclarations.addAll(resolver.multibindingDeclarations.get(key));
+ subcomponentDeclarations.addAll(resolver.subcomponentDeclarations.get(key));
+ // The optional binding declarations are keyed by the unwrapped type.
+ keyFactory.unwrapOptional(key)
+ .map(resolver.optionalBindingDeclarations::get)
+ .ifPresent(optionalBindingDeclarations::addAll);
+ }
+ }
+
+ // Add synthetic multibinding
+ if (!multibindingContributions.isEmpty() || !multibindingDeclarations.isEmpty()) {
+ bindings.add(bindingFactory.syntheticMultibinding(requestKey, multibindingContributions));
+ }
+
+ // Add synthetic optional binding
+ if (!optionalBindingDeclarations.isEmpty()) {
+ bindings.add(
+ bindingFactory.syntheticOptionalBinding(
+ requestKey,
+ getRequestKind(OptionalType.from(requestKey).valueType()),
+ lookUpBindings(keyFactory.unwrapOptional(requestKey).get()).bindings()));
+ }
+
+ // Add subcomponent creator binding
+ if (!subcomponentDeclarations.isEmpty()) {
+ ProvisionBinding binding =
+ bindingFactory.subcomponentCreatorBinding(
+ ImmutableSet.copyOf(subcomponentDeclarations));
+ bindings.add(binding);
+ addSubcomponentToOwningResolver(binding);
+ }
+
+ // Add members injector binding
+ if (isType(requestKey.type()) && isTypeOf(MembersInjector.class, requestKey.type())) {
+ injectBindingRegistry
+ .getOrFindMembersInjectorProvisionBinding(requestKey)
+ .ifPresent(bindings::add);
+ }
+
+ // Add Assisted Factory binding
+ if (isType(requestKey.type())
+ && requestKey.type().getKind() == TypeKind.DECLARED
+ && isAssistedFactoryType(asTypeElement(requestKey.type()))) {
+ bindings.add(
+ bindingFactory.assistedFactoryBinding(
+ asTypeElement(requestKey.type()), Optional.of(requestKey.type())));
+ }
+
+ // If there are no bindings, add the implicit @Inject-constructed binding if there is one.
+ if (bindings.isEmpty()) {
+ injectBindingRegistry
+ .getOrFindProvisionBinding(requestKey)
+ .filter(this::isCorrectlyScopedInSubcomponent)
+ .ifPresent(bindings::add);
+ }
+
+ return ResolvedBindings.forContributionBindings(
+ requestKey,
+ Multimaps.index(bindings, binding -> getOwningComponent(requestKey, binding)),
+ multibindingDeclarations,
+ subcomponentDeclarations,
+ optionalBindingDeclarations);
+ }
+
+ /**
+ * Returns true if this binding graph resolution is for a subcomponent and the {@code @Inject}
+ * binding's scope correctly matches one of the components in the current component ancestry.
+ * If not, it means the binding is not owned by any of the currently known components, and will
+ * be owned by a future ancestor (or, if never owned, will result in an incompatibly scoped
+ * binding error at the root component).
+ */
+ private boolean isCorrectlyScopedInSubcomponent(ProvisionBinding binding) {
+ checkArgument(binding.kind() == INJECTION || binding.kind() == ASSISTED_INJECTION);
+ if (!rootComponent().isSubcomponent()
+ || !binding.scope().isPresent()
+ || binding.scope().get().isReusable()) {
+ return true;
+ }
+
+ Resolver owningResolver = getOwningResolver(binding).orElse(this);
+ ComponentDescriptor owningComponent = owningResolver.componentDescriptor;
+ return owningComponent.scopes().contains(binding.scope().get());
+ }
+
+ private ComponentDescriptor rootComponent() {
+ return parentResolver.map(Resolver::rootComponent).orElse(componentDescriptor);
+ }
+
+ /** Returns the resolved members injection bindings for the given {@link Key}. */
+ ResolvedBindings lookUpMembersInjectionBinding(Key requestKey) {
+ // no explicit deps for members injection, so just look it up
+ Optional<MembersInjectionBinding> binding =
+ injectBindingRegistry.getOrFindMembersInjectionBinding(requestKey);
+ return binding.isPresent()
+ ? ResolvedBindings.forMembersInjectionBinding(
+ requestKey, componentDescriptor, binding.get())
+ : ResolvedBindings.noBindings(requestKey);
+ }
+
+ /**
+ * When a binding is resolved for a {@link SubcomponentDeclaration}, adds corresponding {@link
+ * ComponentDescriptor subcomponent} to a queue in the owning component's resolver. The queue
+ * will be used to detect which subcomponents need to be resolved.
+ */
+ private void addSubcomponentToOwningResolver(ProvisionBinding subcomponentCreatorBinding) {
+ checkArgument(subcomponentCreatorBinding.kind().equals(SUBCOMPONENT_CREATOR));
+ Resolver owningResolver = getOwningResolver(subcomponentCreatorBinding).get();
+
+ TypeElement builderType = MoreTypes.asTypeElement(subcomponentCreatorBinding.key().type());
+ owningResolver.subcomponentsToResolve.add(
+ owningResolver.componentDescriptor.getChildComponentWithBuilderType(builderType));
+ }
+
+ /**
+ * Profiling has determined that computing the keys matching {@code requestKey} has measurable
+ * performance impact. It is called repeatedly (at least 3 times per key resolved per {@link
+ * BindingGraph}. {@code javac}'s name-checking performance seems suboptimal (converting byte
+ * strings to Strings repeatedly), and the matching keys creations relies on that. This also
+ * ensures that the resulting keys have their hash codes cached on successive calls to this
+ * method.
+ *
+ * <p>This caching may become obsolete if:
+ *
+ * <ul>
+ * <li>We decide to intern all {@link Key} instances
+ * <li>We fix javac's name-checking peformance (though we may want to keep this for older
+ * javac users)
+ * </ul>
+ */
+ private ImmutableSet<Key> keysMatchingRequest(Key requestKey) {
+ return keysMatchingRequestCache.computeIfAbsent(
+ requestKey, this::keysMatchingRequestUncached);
+ }
+
+ private ImmutableSet<Key> keysMatchingRequestUncached(Key requestKey) {
+ ImmutableSet.Builder<Key> keys = ImmutableSet.builder();
+ keys.add(requestKey);
+ keyFactory.unwrapSetKey(requestKey, Produced.class).ifPresent(keys::add);
+ keyFactory.rewrapMapKey(requestKey, Producer.class, Provider.class).ifPresent(keys::add);
+ keyFactory.rewrapMapKey(requestKey, Provider.class, Producer.class).ifPresent(keys::add);
+ keys.addAll(keyFactory.implicitFrameworkMapKeys(requestKey));
+ return keys.build();
+ }
+
+ private ImmutableSet<ContributionBinding> createDelegateBindings(
+ ImmutableSet<DelegateDeclaration> delegateDeclarations) {
+ ImmutableSet.Builder<ContributionBinding> builder = ImmutableSet.builder();
+ for (DelegateDeclaration delegateDeclaration : delegateDeclarations) {
+ builder.add(createDelegateBinding(delegateDeclaration));
+ }
+ return builder.build();
+ }
+
+ /**
+ * Creates one (and only one) delegate binding for a delegate declaration, based on the resolved
+ * bindings of the right-hand-side of a {@link dagger.Binds} method. If there are duplicate
+ * bindings for the dependency key, there should still be only one binding for the delegate key.
+ */
+ private ContributionBinding createDelegateBinding(DelegateDeclaration delegateDeclaration) {
+ Key delegateKey = delegateDeclaration.delegateRequest().key();
+ if (cycleStack.contains(delegateKey)) {
+ return bindingFactory.unresolvedDelegateBinding(delegateDeclaration);
+ }
+
+ ResolvedBindings resolvedDelegate;
+ try {
+ cycleStack.push(delegateKey);
+ resolvedDelegate = lookUpBindings(delegateKey);
+ } finally {
+ cycleStack.pop();
+ }
+ if (resolvedDelegate.contributionBindings().isEmpty()) {
+ // This is guaranteed to result in a missing binding error, so it doesn't matter if the
+ // binding is a Provision or Production, except if it is a @IntoMap method, in which
+ // case the key will be of type Map<K, Provider<V>>, which will be "upgraded" into a
+ // Map<K, Producer<V>> if it's requested in a ProductionComponent. This may result in a
+ // strange error, that the RHS needs to be provided with an @Inject or @Provides
+ // annotated method, but a user should be able to figure out if a @Produces annotation
+ // is needed.
+ // TODO(gak): revisit how we model missing delegates if/when we clean up how we model
+ // binding declarations
+ return bindingFactory.unresolvedDelegateBinding(delegateDeclaration);
+ }
+ // It doesn't matter which of these is selected, since they will later on produce a
+ // duplicate binding error.
+ ContributionBinding explicitDelegate =
+ resolvedDelegate.contributionBindings().iterator().next();
+ return bindingFactory.delegateBinding(delegateDeclaration, explicitDelegate);
+ }
+
+ /**
+ * Returns the component that should contain the framework field for {@code binding}.
+ *
+ * <p>If {@code binding} is either not bound in an ancestor component or depends transitively on
+ * bindings in this component, returns this component.
+ *
+ * <p>Otherwise, resolves {@code request} in this component's parent in order to resolve any
+ * multibinding contributions in the parent, and returns the parent-resolved {@link
+ * ResolvedBindings#owningComponent(ContributionBinding)}.
+ */
+ private TypeElement getOwningComponent(Key requestKey, ContributionBinding binding) {
+ if (isResolvedInParent(requestKey, binding)
+ && !new LocalDependencyChecker().dependsOnLocalBindings(binding)) {
+ ResolvedBindings parentResolvedBindings =
+ parentResolver.get().resolvedContributionBindings.get(requestKey);
+ return parentResolvedBindings.owningComponent(binding);
+ } else {
+ return componentDescriptor.typeElement();
+ }
+ }
+
+ /**
+ * Returns {@code true} if {@code binding} is owned by an ancestor. If so, {@linkplain #resolve
+ * resolves} the {@link Key} in this component's parent. Don't resolve directly in the owning
+ * component in case it depends on multibindings in any of its descendants.
+ */
+ private boolean isResolvedInParent(Key requestKey, ContributionBinding binding) {
+ Optional<Resolver> owningResolver = getOwningResolver(binding);
+ if (owningResolver.isPresent() && !owningResolver.get().equals(this)) {
+ parentResolver.get().resolve(requestKey);
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ private Optional<Resolver> getOwningResolver(ContributionBinding binding) {
+ // TODO(ronshapiro): extract the different pieces of this method into their own methods
+ if ((binding.scope().isPresent() && binding.scope().get().isProductionScope())
+ || binding.bindingType().equals(BindingType.PRODUCTION)) {
+ for (Resolver requestResolver : getResolverLineage()) {
+ // Resolve @Inject @ProductionScope bindings at the highest production component.
+ if (binding.kind().equals(INJECTION)
+ && requestResolver.componentDescriptor.isProduction()) {
+ return Optional.of(requestResolver);
+ }
+
+ // Resolve explicit @Produces and @ProductionScope bindings at the highest component that
+ // installs the binding.
+ if (requestResolver.containsExplicitBinding(binding)) {
+ return Optional.of(requestResolver);
+ }
+ }
+ }
+
+ if (binding.scope().isPresent() && binding.scope().get().isReusable()) {
+ for (Resolver requestResolver : getResolverLineage().reverse()) {
+ // If a @Reusable binding was resolved in an ancestor, use that component.
+ ResolvedBindings resolvedBindings =
+ requestResolver.resolvedContributionBindings.get(binding.key());
+ if (resolvedBindings != null
+ && resolvedBindings.contributionBindings().contains(binding)) {
+ return Optional.of(requestResolver);
+ }
+ }
+ // If a @Reusable binding was not resolved in any ancestor, resolve it here.
+ return Optional.empty();
+ }
+
+ for (Resolver requestResolver : getResolverLineage().reverse()) {
+ if (requestResolver.containsExplicitBinding(binding)) {
+ return Optional.of(requestResolver);
+ }
+ }
+
+ // look for scope separately. we do this for the case where @Singleton can appear twice
+ // in the † compatibility mode
+ Optional<Scope> bindingScope = binding.scope();
+ if (bindingScope.isPresent()) {
+ for (Resolver requestResolver : getResolverLineage().reverse()) {
+ if (requestResolver.componentDescriptor.scopes().contains(bindingScope.get())) {
+ return Optional.of(requestResolver);
+ }
+ }
+ }
+ return Optional.empty();
+ }
+
+ private boolean containsExplicitBinding(ContributionBinding binding) {
+ return explicitBindingsSet.contains(binding)
+ || resolverContainsDelegateDeclarationForBinding(binding)
+ || subcomponentDeclarations.containsKey(binding.key());
+ }
+
+ /** Returns true if {@code binding} was installed in a module in this resolver's component. */
+ private boolean resolverContainsDelegateDeclarationForBinding(ContributionBinding binding) {
+ if (!binding.kind().equals(DELEGATE)) {
+ return false;
+ }
+
+ // Map multibinding key values are wrapped with a framework type. This needs to be undone
+ // to look it up in the delegate declarations map.
+ // TODO(erichang): See if we can standardize the way map keys are used in these data
+ // structures, either always wrapped or unwrapped to be consistent and less errorprone.
+ Key bindingKey = binding.key();
+ if (compilerOptions.strictMultibindingValidation()
+ && binding.contributionType().equals(ContributionType.MAP)) {
+ bindingKey = keyFactory.unwrapMapValueType(bindingKey);
+ }
+
+ return delegateDeclarations.get(bindingKey).stream()
+ .anyMatch(
+ declaration ->
+ declaration.contributingModule().equals(binding.contributingModule())
+ && declaration.bindingElement().equals(binding.bindingElement()));
+ }
+
+ /** Returns the resolver lineage from parent to child. */
+ private ImmutableList<Resolver> getResolverLineage() {
+ ImmutableList.Builder<Resolver> resolverList = ImmutableList.builder();
+ for (Optional<Resolver> currentResolver = Optional.of(this);
+ currentResolver.isPresent();
+ currentResolver = currentResolver.get().parentResolver) {
+ resolverList.add(currentResolver.get());
+ }
+ return resolverList.build().reverse();
+ }
+
+ /**
+ * Returns the explicit {@link ContributionBinding}s that match the {@code key} from this
+ * resolver.
+ */
+ private ImmutableSet<ContributionBinding> getLocalExplicitBindings(Key key) {
+ return new ImmutableSet.Builder<ContributionBinding>()
+ .addAll(explicitBindings.get(key))
+ // @Binds @IntoMap declarations have key Map<K, V>, unlike @Provides @IntoMap or @Produces
+ // @IntoMap, which have Map<K, Provider/Producer<V>> keys. So unwrap the key's type's
+ // value type if it's a Map<K, Provider/Producer<V>> before looking in
+ // delegateDeclarations. createDelegateBindings() will create bindings with the properly
+ // wrapped key type.
+ .addAll(
+ createDelegateBindings(delegateDeclarations.get(keyFactory.unwrapMapValueType(key))))
+ .build();
+ }
+
+ /**
+ * Returns the explicit multibinding contributions that contribute to the map or set requested
+ * by {@code key} from this resolver.
+ */
+ private ImmutableSet<ContributionBinding> getLocalExplicitMultibindings(Key key) {
+ ImmutableSet.Builder<ContributionBinding> multibindings = ImmutableSet.builder();
+ multibindings.addAll(explicitMultibindings.get(key));
+ if (!MapType.isMap(key)
+ || MapType.from(key).isRawType()
+ || MapType.from(key).valuesAreFrameworkType()) {
+ // @Binds @IntoMap declarations have key Map<K, V>, unlike @Provides @IntoMap or @Produces
+ // @IntoMap, which have Map<K, Provider/Producer<V>> keys. So unwrap the key's type's
+ // value type if it's a Map<K, Provider/Producer<V>> before looking in
+ // delegateMultibindingDeclarations. createDelegateBindings() will create bindings with the
+ // properly wrapped key type.
+ multibindings.addAll(
+ createDelegateBindings(
+ delegateMultibindingDeclarations.get(keyFactory.unwrapMapValueType(key))));
+ }
+ return multibindings.build();
+ }
+
+ /**
+ * Returns the {@link OptionalBindingDeclaration}s that match the {@code key} from this and all
+ * ancestor resolvers.
+ */
+ private ImmutableSet<OptionalBindingDeclaration> getOptionalBindingDeclarations(Key key) {
+ Optional<Key> unwrapped = keyFactory.unwrapOptional(key);
+ if (!unwrapped.isPresent()) {
+ return ImmutableSet.of();
+ }
+ ImmutableSet.Builder<OptionalBindingDeclaration> declarations = ImmutableSet.builder();
+ for (Resolver resolver : getResolverLineage()) {
+ declarations.addAll(resolver.optionalBindingDeclarations.get(unwrapped.get()));
+ }
+ return declarations.build();
+ }
+
+ /**
+ * Returns the {@link ResolvedBindings} for {@code key} that was resolved in this resolver or an
+ * ancestor resolver. Only checks for {@link ContributionBinding}s as {@link
+ * MembersInjectionBinding}s are not inherited.
+ */
+ private Optional<ResolvedBindings> getPreviouslyResolvedBindings(Key key) {
+ Optional<ResolvedBindings> result =
+ Optional.ofNullable(resolvedContributionBindings.get(key));
+ if (result.isPresent()) {
+ return result;
+ } else if (parentResolver.isPresent()) {
+ return parentResolver.get().getPreviouslyResolvedBindings(key);
+ } else {
+ return Optional.empty();
+ }
+ }
+
+ private void resolveMembersInjection(Key key) {
+ ResolvedBindings bindings = lookUpMembersInjectionBinding(key);
+ resolveDependencies(bindings);
+ resolvedMembersInjectionBindings.put(key, bindings);
+ }
+
+ void resolve(Key key) {
+ // If we find a cycle, stop resolving. The original request will add it with all of the
+ // other resolved deps.
+ if (cycleStack.contains(key)) {
+ return;
+ }
+
+ // If the binding was previously resolved in this (sub)component, don't resolve it again.
+ if (resolvedContributionBindings.containsKey(key)) {
+ return;
+ }
+
+ /*
+ * If the binding was previously resolved in an ancestor component, then we may be able to
+ * avoid resolving it here and just depend on the ancestor component resolution.
+ *
+ * 1. If it depends transitively on multibinding contributions or optional bindings with
+ * bindings from this subcomponent, then we have to resolve it in this subcomponent so
+ * that it sees the local bindings.
+ *
+ * 2. If there are any explicit bindings in this component, they may conflict with those in
+ * the ancestor component, so resolve them here so that conflicts can be caught.
+ */
+ if (getPreviouslyResolvedBindings(key).isPresent()) {
+ /* Resolve in the parent in case there are multibinding contributions or conflicts in some
+ * component between this one and the previously-resolved one. */
+ parentResolver.get().resolve(key);
+ if (!new LocalDependencyChecker().dependsOnLocalBindings(key)
+ && getLocalExplicitBindings(key).isEmpty()) {
+ /* Cache the inherited parent component's bindings in case resolving at the parent found
+ * bindings in some component between this one and the previously-resolved one. */
+ resolvedContributionBindings.put(key, getPreviouslyResolvedBindings(key).get());
+ return;
+ }
+ }
+
+ cycleStack.push(key);
+ try {
+ ResolvedBindings bindings = lookUpBindings(key);
+ resolvedContributionBindings.put(key, bindings);
+ resolveDependencies(bindings);
+ } finally {
+ cycleStack.pop();
+ }
+ }
+
+ /**
+ * {@link #resolve(Key) Resolves} each of the dependencies of the bindings owned by this
+ * component.
+ */
+ private void resolveDependencies(ResolvedBindings resolvedBindings) {
+ for (Binding binding : resolvedBindings.bindingsOwnedBy(componentDescriptor)) {
+ for (DependencyRequest dependency : binding.dependencies()) {
+ resolve(dependency.key());
+ }
+ }
+ }
+
+ /**
+ * Returns all of the {@link ResolvedBindings} for {@link ContributionBinding}s from this and
+ * all ancestor resolvers, indexed by {@link ResolvedBindings#key()}.
+ */
+ Map<Key, ResolvedBindings> getResolvedContributionBindings() {
+ Map<Key, ResolvedBindings> bindings = new LinkedHashMap<>();
+ parentResolver.ifPresent(parent -> bindings.putAll(parent.getResolvedContributionBindings()));
+ bindings.putAll(resolvedContributionBindings);
+ return bindings;
+ }
+
+ /**
+ * Returns all of the {@link ResolvedBindings} for {@link MembersInjectionBinding} from this
+ * resolvers, indexed by {@link ResolvedBindings#key()}.
+ */
+ ImmutableMap<Key, ResolvedBindings> getResolvedMembersInjectionBindings() {
+ return ImmutableMap.copyOf(resolvedMembersInjectionBindings);
+ }
+
+ private final class LocalDependencyChecker {
+ private final Set<Object> cycleChecker = new HashSet<>();
+
+ /**
+ * Returns {@code true} if any of the bindings resolved for {@code key} are multibindings with
+ * contributions declared within this component's modules or optional bindings with present
+ * values declared within this component's modules, or if any of its unscoped dependencies
+ * depend on such bindings.
+ *
+ * <p>We don't care about scoped dependencies because they will never depend on bindings from
+ * subcomponents.
+ *
+ * @throws IllegalArgumentException if {@link #getPreviouslyResolvedBindings(Key)} is empty
+ */
+ private boolean dependsOnLocalBindings(Key key) {
+ // Don't recur infinitely if there are valid cycles in the dependency graph.
+ // http://b/23032377
+ if (!cycleChecker.add(key)) {
+ return false;
+ }
+ return reentrantComputeIfAbsent(
+ keyDependsOnLocalBindingsCache, key, this::dependsOnLocalBindingsUncached);
+ }
+
+ /**
+ * Returns {@code true} if {@code binding} is unscoped (or has {@link Reusable @Reusable}
+ * scope) and depends on multibindings with contributions declared within this component's
+ * modules, or if any of its unscoped or {@link Reusable @Reusable} scoped dependencies depend
+ * on such local multibindings.
+ *
+ * <p>We don't care about non-reusable scoped dependencies because they will never depend on
+ * multibindings with contributions from subcomponents.
+ */
+ private boolean dependsOnLocalBindings(Binding binding) {
+ if (!cycleChecker.add(binding)) {
+ return false;
+ }
+ return reentrantComputeIfAbsent(
+ bindingDependsOnLocalBindingsCache, binding, this::dependsOnLocalBindingsUncached);
+ }
+
+ private boolean dependsOnLocalBindingsUncached(Key key) {
+ checkArgument(
+ getPreviouslyResolvedBindings(key).isPresent(),
+ "no previously resolved bindings in %s for %s",
+ Resolver.this,
+ key);
+ ResolvedBindings previouslyResolvedBindings = getPreviouslyResolvedBindings(key).get();
+ if (hasLocalMultibindingContributions(key)
+ || hasLocalOptionalBindingContribution(previouslyResolvedBindings)) {
+ return true;
+ }
+
+ for (Binding binding : previouslyResolvedBindings.bindings()) {
+ if (dependsOnLocalBindings(binding)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private boolean dependsOnLocalBindingsUncached(Binding binding) {
+ if ((!binding.scope().isPresent() || binding.scope().get().isReusable())
+ // TODO(beder): Figure out what happens with production subcomponents.
+ && !binding.bindingType().equals(BindingType.PRODUCTION)) {
+ for (DependencyRequest dependency : binding.dependencies()) {
+ if (dependsOnLocalBindings(dependency.key())) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Returns {@code true} if there is at least one multibinding contribution declared within
+ * this component's modules that matches the key.
+ */
+ private boolean hasLocalMultibindingContributions(Key requestKey) {
+ return keysMatchingRequest(requestKey)
+ .stream()
+ .anyMatch(key -> !getLocalExplicitMultibindings(key).isEmpty());
+ }
+
+ /**
+ * Returns {@code true} if there is a contribution in this component for an {@code
+ * Optional<Foo>} key that has not been contributed in a parent.
+ */
+ private boolean hasLocalOptionalBindingContribution(ResolvedBindings resolvedBindings) {
+ if (resolvedBindings
+ .contributionBindings()
+ .stream()
+ .map(ContributionBinding::kind)
+ .anyMatch(isEqual(OPTIONAL))) {
+ return !getLocalExplicitBindings(keyFactory.unwrapOptional(resolvedBindings.key()).get())
+ .isEmpty();
+ } else {
+ // If a parent contributes a @Provides Optional<Foo> binding and a child has a
+ // @BindsOptionalOf Foo method, the two should conflict, even if there is no binding for
+ // Foo on its own
+ return !getOptionalBindingDeclarations(resolvedBindings.key()).isEmpty();
+ }
+ }
+ }
+ }
+
+ /**
+ * A multimap of those {@code declarations} that are multibinding contribution declarations,
+ * indexed by the key of the set or map to which they contribute.
+ */
+ static <T extends BindingDeclaration>
+ ImmutableSetMultimap<Key, T> multibindingContributionsByMultibindingKey(
+ Iterable<T> declarations) {
+ ImmutableSetMultimap.Builder<Key, T> builder = ImmutableSetMultimap.builder();
+ for (T declaration : declarations) {
+ if (declaration.key().multibindingContributionIdentifier().isPresent()) {
+ builder.put(
+ declaration
+ .key()
+ .toBuilder()
+ .multibindingContributionIdentifier(Optional.empty())
+ .build(),
+ declaration);
+ }
+ }
+ return builder.build();
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/BindingNode.java b/java/dagger/internal/codegen/binding/BindingNode.java
new file mode 100644
index 0000000..78d440d
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/BindingNode.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static dagger.internal.codegen.binding.BindingType.PRODUCTION;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import dagger.BindsOptionalOf;
+import dagger.Module;
+import dagger.model.BindingKind;
+import dagger.model.ComponentPath;
+import dagger.model.DependencyRequest;
+import dagger.model.Key;
+import dagger.model.Scope;
+import dagger.multibindings.Multibinds;
+import java.util.Optional;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+
+/**
+ * An implementation of {@link dagger.model.Binding} that also exposes {@link BindingDeclaration}s
+ * associated with the binding.
+ */
+// TODO(dpb): Consider a supertype of dagger.model.Binding that
+// dagger.internal.codegen.binding.Binding
+// could also implement.
+@AutoValue
+public abstract class BindingNode implements dagger.model.Binding {
+ public static BindingNode create(
+ ComponentPath component,
+ Binding delegate,
+ ImmutableSet<MultibindingDeclaration> multibindingDeclarations,
+ ImmutableSet<OptionalBindingDeclaration> optionalBindingDeclarations,
+ ImmutableSet<SubcomponentDeclaration> subcomponentDeclarations,
+ BindingDeclarationFormatter bindingDeclarationFormatter) {
+ BindingNode node =
+ new AutoValue_BindingNode(
+ component,
+ delegate,
+ multibindingDeclarations,
+ optionalBindingDeclarations,
+ subcomponentDeclarations);
+ node.bindingDeclarationFormatter = checkNotNull(bindingDeclarationFormatter);
+ return node;
+ }
+
+ private BindingDeclarationFormatter bindingDeclarationFormatter;
+
+ public abstract Binding delegate();
+
+ public abstract ImmutableSet<MultibindingDeclaration> multibindingDeclarations();
+
+ public abstract ImmutableSet<OptionalBindingDeclaration> optionalBindingDeclarations();
+
+ public abstract ImmutableSet<SubcomponentDeclaration> subcomponentDeclarations();
+
+ /**
+ * The {@link Element}s (other than the binding's {@link #bindingElement()}) that are associated
+ * with the binding.
+ *
+ * <ul>
+ * <li>{@linkplain BindsOptionalOf optional binding} declarations
+ * <li>{@linkplain Module#subcomponents() module subcomponent} declarations
+ * <li>{@linkplain Multibinds multibinding} declarations
+ * </ul>
+ */
+ public final Iterable<BindingDeclaration> associatedDeclarations() {
+ return Iterables.concat(
+ multibindingDeclarations(), optionalBindingDeclarations(), subcomponentDeclarations());
+ }
+
+ @Override
+ public Key key() {
+ return delegate().key();
+ }
+
+ @Override
+ public ImmutableSet<DependencyRequest> dependencies() {
+ return delegate().dependencies();
+ }
+
+ @Override
+ public Optional<Element> bindingElement() {
+ return delegate().bindingElement();
+ }
+
+ @Override
+ public Optional<TypeElement> contributingModule() {
+ return delegate().contributingModule();
+ }
+
+ @Override
+ public boolean requiresModuleInstance() {
+ return delegate().requiresModuleInstance();
+ }
+
+ @Override
+ public Optional<Scope> scope() {
+ return delegate().scope();
+ }
+
+ @Override
+ public boolean isNullable() {
+ return delegate().isNullable();
+ }
+
+ @Override
+ public boolean isProduction() {
+ return delegate().bindingType().equals(PRODUCTION);
+ }
+
+ @Override
+ public BindingKind kind() {
+ return delegate().kind();
+ }
+
+ @Override
+ public final String toString() {
+ return bindingDeclarationFormatter.format(delegate());
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/BindingRequest.java b/java/dagger/internal/codegen/binding/BindingRequest.java
new file mode 100644
index 0000000..d61d9cf
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/BindingRequest.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static dagger.internal.codegen.base.RequestKinds.requestType;
+
+import com.google.auto.value.AutoValue;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.DependencyRequest;
+import dagger.model.Key;
+import dagger.model.RequestKind;
+import java.util.Optional;
+import javax.lang.model.type.TypeMirror;
+
+/**
+ * A request for a binding, which may be in the form of a request for a dependency to pass to a
+ * constructor or module method ({@link RequestKind}) or an internal request for a framework
+ * instance ({@link FrameworkType}).
+ */
+@AutoValue
+public abstract class BindingRequest {
+ /** Creates a {@link BindingRequest} for the given {@link DependencyRequest}. */
+ public static BindingRequest bindingRequest(DependencyRequest dependencyRequest) {
+ return bindingRequest(dependencyRequest.key(), dependencyRequest.kind());
+ }
+
+ /**
+ * Creates a {@link BindingRequest} for a normal dependency request for the given {@link Key} and
+ * {@link RequestKind}.
+ */
+ public static BindingRequest bindingRequest(Key key, RequestKind requestKind) {
+ // When there's a request that has a 1:1 mapping to a FrameworkType, the request should be
+ // associated with that FrameworkType as well, because we want to ensure that if a request
+ // comes in for that as a dependency first and as a framework instance later, they resolve to
+ // the same binding expression.
+ // TODO(cgdecker): Instead of doing this, make ComponentBindingExpressions create a
+ // BindingExpression for the RequestKind that simply delegates to the BindingExpression for the
+ // FrameworkType. Then there are separate BindingExpressions, but we don't end up doing weird
+ // things like creating two fields when there should only be one.
+ return new AutoValue_BindingRequest(
+ key, Optional.of(requestKind), FrameworkType.forRequestKind(requestKind));
+ }
+
+ /**
+ * Creates a {@link BindingRequest} for a request for a framework instance for the given {@link
+ * Key} with the given {@link FrameworkType}.
+ */
+ public static BindingRequest bindingRequest(Key key, FrameworkType frameworkType) {
+ return new AutoValue_BindingRequest(
+ key, frameworkType.requestKind(), Optional.of(frameworkType));
+ }
+
+ /** Returns the {@link Key} for the requested binding. */
+ public abstract Key key();
+
+ /** Returns the request kind associated with this request, if any. */
+ public abstract Optional<RequestKind> requestKind();
+
+ /** Returns the framework type associated with this request, if any. */
+ public abstract Optional<FrameworkType> frameworkType();
+
+ /** Returns whether this request is of the given kind. */
+ public final boolean isRequestKind(RequestKind requestKind) {
+ return requestKind.equals(requestKind().orElse(null));
+ }
+
+ public final TypeMirror requestedType(TypeMirror contributedType, DaggerTypes types) {
+ if (requestKind().isPresent()) {
+ return requestType(requestKind().get(), contributedType, types);
+ }
+ return types.wrapType(contributedType, frameworkType().get().frameworkClass());
+ }
+
+ /** Returns a name that can be used for the kind of request this is. */
+ public final String kindName() {
+ Object requestKindObject =
+ requestKind().isPresent()
+ ? requestKind().get()
+ : frameworkType().get().frameworkClass().getSimpleName();
+ return requestKindObject.toString();
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/BindingType.java b/java/dagger/internal/codegen/binding/BindingType.java
new file mode 100644
index 0000000..7f5ea54
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/BindingType.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import dagger.MembersInjector;
+
+/** Whether a binding or declaration is for provision, production, or a {@link MembersInjector}. */
+public enum BindingType {
+ /** A binding with this type is a {@link ProvisionBinding}. */
+ PROVISION,
+
+ /** A binding with this type is a {@link MembersInjectionBinding}. */
+ MEMBERS_INJECTION,
+
+ /** A binding with this type is a {@link ProductionBinding}. */
+ PRODUCTION,
+}
diff --git a/java/dagger/internal/codegen/binding/BindsTypeChecker.java b/java/dagger/internal/codegen/binding/BindsTypeChecker.java
new file mode 100644
index 0000000..f3e0a1b
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/BindsTypeChecker.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.common.collect.Iterables.getOnlyElement;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.MoreTypes;
+import com.google.common.collect.ImmutableList;
+import dagger.internal.codegen.base.ContributionType;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import java.util.Map;
+import java.util.Set;
+import javax.inject.Inject;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeMirror;
+
+/**
+ * Checks the assignability of one type to another, given a {@link ContributionType} context. This
+ * is used by {@link dagger.internal.codegen.validation.BindsMethodValidator} to validate that the
+ * right-hand- side of a {@link dagger.Binds} method is valid, as well as in {@link
+ * dagger.internal.codegen.writing.DelegateBindingExpression} when the right-hand-side in generated
+ * code might be an erased type due to accessibility.
+ */
+public final class BindsTypeChecker {
+ private final DaggerTypes types;
+ private final DaggerElements elements;
+
+ // TODO(bcorso): Make this pkg-private. Used by DelegateBindingExpression.
+ @Inject
+ public BindsTypeChecker(DaggerTypes types, DaggerElements elements) {
+ this.types = types;
+ this.elements = elements;
+ }
+
+ /**
+ * Checks the assignability of {@code rightHandSide} to {@code leftHandSide} given a {@link
+ * ContributionType} context.
+ */
+ public boolean isAssignable(
+ TypeMirror rightHandSide, TypeMirror leftHandSide, ContributionType contributionType) {
+ return types.isAssignable(rightHandSide, desiredAssignableType(leftHandSide, contributionType));
+ }
+
+ private TypeMirror desiredAssignableType(
+ TypeMirror leftHandSide, ContributionType contributionType) {
+ switch (contributionType) {
+ case UNIQUE:
+ return leftHandSide;
+ case SET:
+ DeclaredType parameterizedSetType = types.getDeclaredType(setElement(), leftHandSide);
+ return methodParameterType(parameterizedSetType, "add");
+ case SET_VALUES:
+ return methodParameterType(MoreTypes.asDeclared(leftHandSide), "addAll");
+ case MAP:
+ DeclaredType parameterizedMapType =
+ types.getDeclaredType(mapElement(), unboundedWildcard(), leftHandSide);
+ return methodParameterTypes(parameterizedMapType, "put").get(1);
+ }
+ throw new AssertionError("Unknown contribution type: " + contributionType);
+ }
+
+ private ImmutableList<TypeMirror> methodParameterTypes(DeclaredType type, String methodName) {
+ ImmutableList.Builder<ExecutableElement> methodsForName = ImmutableList.builder();
+ for (ExecutableElement method :
+ // type.asElement().getEnclosedElements() is not used because some non-standard JDKs (e.g.
+ // J2CL) don't redefine Set.add() (whose only purpose of being redefined in the standard JDK
+ // is documentation, and J2CL's implementation doesn't declare docs for JDK types).
+ // MoreElements.getLocalAndInheritedMethods ensures that the method will always be present.
+ MoreElements.getLocalAndInheritedMethods(MoreTypes.asTypeElement(type), types, elements)) {
+ if (method.getSimpleName().contentEquals(methodName)) {
+ methodsForName.add(method);
+ }
+ }
+ ExecutableElement method = getOnlyElement(methodsForName.build());
+ return ImmutableList.copyOf(
+ MoreTypes.asExecutable(types.asMemberOf(type, method)).getParameterTypes());
+ }
+
+ private TypeMirror methodParameterType(DeclaredType type, String methodName) {
+ return getOnlyElement(methodParameterTypes(type, methodName));
+ }
+
+ private TypeElement setElement() {
+ return elements.getTypeElement(Set.class);
+ }
+
+ private TypeElement mapElement() {
+ return elements.getTypeElement(Map.class);
+ }
+
+ private TypeMirror unboundedWildcard() {
+ return types.getWildcardType(null, null);
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/ChildFactoryMethodEdgeImpl.java b/java/dagger/internal/codegen/binding/ChildFactoryMethodEdgeImpl.java
new file mode 100644
index 0000000..c056588
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/ChildFactoryMethodEdgeImpl.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static dagger.internal.codegen.base.ElementFormatter.elementToString;
+
+import dagger.model.BindingGraph.ChildFactoryMethodEdge;
+import javax.lang.model.element.ExecutableElement;
+
+/** An implementation of {@link ChildFactoryMethodEdge}. */
+public final class ChildFactoryMethodEdgeImpl implements ChildFactoryMethodEdge {
+
+ private final ExecutableElement factoryMethod;
+
+ ChildFactoryMethodEdgeImpl(ExecutableElement factoryMethod) {
+ this.factoryMethod = factoryMethod;
+ }
+
+ @Override
+ public ExecutableElement factoryMethod() {
+ return factoryMethod;
+ }
+
+ @Override
+ public String toString() {
+ return elementToString(factoryMethod);
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/ComponentCreatorAnnotation.java b/java/dagger/internal/codegen/binding/ComponentCreatorAnnotation.java
new file mode 100644
index 0000000..6297188
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/ComponentCreatorAnnotation.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.auto.common.MoreElements.isAnnotationPresent;
+import static com.google.common.base.Ascii.toUpperCase;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static dagger.internal.codegen.extension.DaggerStreams.valuesOf;
+import static java.util.stream.Collectors.mapping;
+
+import com.google.common.collect.ImmutableSet;
+import dagger.Component;
+import dagger.Subcomponent;
+import dagger.internal.codegen.base.ComponentAnnotation;
+import dagger.producers.ProductionComponent;
+import dagger.producers.ProductionSubcomponent;
+import java.lang.annotation.Annotation;
+import java.util.stream.Collector;
+import java.util.stream.Stream;
+import javax.lang.model.element.TypeElement;
+
+/** Simple representation of a component creator annotation type. */
+public enum ComponentCreatorAnnotation {
+ COMPONENT_BUILDER(Component.Builder.class),
+ COMPONENT_FACTORY(Component.Factory.class),
+ SUBCOMPONENT_BUILDER(Subcomponent.Builder.class),
+ SUBCOMPONENT_FACTORY(Subcomponent.Factory.class),
+ PRODUCTION_COMPONENT_BUILDER(ProductionComponent.Builder.class),
+ PRODUCTION_COMPONENT_FACTORY(ProductionComponent.Factory.class),
+ PRODUCTION_SUBCOMPONENT_BUILDER(ProductionSubcomponent.Builder.class),
+ PRODUCTION_SUBCOMPONENT_FACTORY(ProductionSubcomponent.Factory.class),
+ ;
+
+ private final Class<? extends Annotation> annotation;
+ private final ComponentCreatorKind creatorKind;
+ private final Class<? extends Annotation> componentAnnotation;
+
+ @SuppressWarnings("unchecked") // Builder/factory annotations live within their parent annotation.
+ ComponentCreatorAnnotation(Class<? extends Annotation> annotation) {
+ this.annotation = annotation;
+ this.creatorKind = ComponentCreatorKind.valueOf(toUpperCase(annotation.getSimpleName()));
+ this.componentAnnotation = (Class<? extends Annotation>) annotation.getEnclosingClass();
+ }
+
+ /** The actual annotation type. */
+ public Class<? extends Annotation> annotation() {
+ return annotation;
+ }
+
+ /** The component annotation type that encloses this creator annotation type. */
+ public final Class<? extends Annotation> componentAnnotation() {
+ return componentAnnotation;
+ }
+
+ /** Returns {@code true} if the creator annotation is for a subcomponent. */
+ public final boolean isSubcomponentCreatorAnnotation() {
+ return componentAnnotation().getSimpleName().endsWith("Subcomponent");
+ }
+
+ /**
+ * Returns {@code true} if the creator annotation is for a production component or subcomponent.
+ */
+ public final boolean isProductionCreatorAnnotation() {
+ return componentAnnotation().getSimpleName().startsWith("Production");
+ }
+
+ /** The creator kind the annotation is associated with. */
+ // TODO(dpb): Remove ComponentCreatorKind.
+ public ComponentCreatorKind creatorKind() {
+ return creatorKind;
+ }
+
+ @Override
+ public final String toString() {
+ return annotation().getName();
+ }
+
+ /** Returns all component creator annotations. */
+ public static ImmutableSet<Class<? extends Annotation>> allCreatorAnnotations() {
+ return stream().collect(toAnnotationClasses());
+ }
+
+ /** Returns all root component creator annotations. */
+ public static ImmutableSet<Class<? extends Annotation>> rootComponentCreatorAnnotations() {
+ return stream()
+ .filter(
+ componentCreatorAnnotation ->
+ !componentCreatorAnnotation.isSubcomponentCreatorAnnotation())
+ .collect(toAnnotationClasses());
+ }
+
+ /** Returns all subcomponent creator annotations. */
+ public static ImmutableSet<Class<? extends Annotation>> subcomponentCreatorAnnotations() {
+ return stream()
+ .filter(
+ componentCreatorAnnotation ->
+ componentCreatorAnnotation.isSubcomponentCreatorAnnotation())
+ .collect(toAnnotationClasses());
+ }
+
+ /** Returns all production component creator annotations. */
+ public static ImmutableSet<Class<? extends Annotation>> productionCreatorAnnotations() {
+ return stream()
+ .filter(
+ componentCreatorAnnotation ->
+ componentCreatorAnnotation.isProductionCreatorAnnotation())
+ .collect(toAnnotationClasses());
+ }
+
+ /** Returns the legal creator annotations for the given {@code componentAnnotation}. */
+ public static ImmutableSet<Class<? extends Annotation>> creatorAnnotationsFor(
+ ComponentAnnotation componentAnnotation) {
+ return stream()
+ .filter(
+ creatorAnnotation ->
+ creatorAnnotation
+ .componentAnnotation()
+ .getSimpleName()
+ .equals(componentAnnotation.simpleName()))
+ .collect(toAnnotationClasses());
+ }
+
+ /** Returns all creator annotations present on the given {@code type}. */
+ public static ImmutableSet<ComponentCreatorAnnotation> getCreatorAnnotations(TypeElement type) {
+ return stream()
+ .filter(cca -> isAnnotationPresent(type, cca.annotation()))
+ .collect(toImmutableSet());
+ }
+
+ private static Stream<ComponentCreatorAnnotation> stream() {
+ return valuesOf(ComponentCreatorAnnotation.class);
+ }
+
+ private static Collector<ComponentCreatorAnnotation, ?, ImmutableSet<Class<? extends Annotation>>>
+ toAnnotationClasses() {
+ return mapping(ComponentCreatorAnnotation::annotation, toImmutableSet());
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/ComponentCreatorDescriptor.java b/java/dagger/internal/codegen/binding/ComponentCreatorDescriptor.java
new file mode 100644
index 0000000..5ea30ed
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/ComponentCreatorDescriptor.java
@@ -0,0 +1,223 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.auto.common.MoreElements.isAnnotationPresent;
+import static com.google.auto.common.MoreTypes.asTypeElement;
+import static com.google.common.base.Verify.verify;
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static dagger.internal.codegen.base.ModuleAnnotation.moduleAnnotation;
+import static dagger.internal.codegen.binding.ComponentCreatorAnnotation.getCreatorAnnotations;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+
+import com.google.auto.common.MoreTypes;
+import com.google.auto.value.AutoValue;
+import com.google.auto.value.extension.memoized.Memoized;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSetMultimap;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multimap;
+import dagger.BindsInstance;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.DependencyRequest;
+import java.util.List;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.ExecutableType;
+import javax.lang.model.type.TypeMirror;
+
+/**
+ * A descriptor for a component <i>creator</i> type: that is, a type annotated with
+ * {@code @Component.Builder} (or one of the corresponding production or subcomponent versions).
+ */
+@AutoValue
+public abstract class ComponentCreatorDescriptor {
+
+ /** Returns the annotation marking this creator. */
+ public abstract ComponentCreatorAnnotation annotation();
+
+ /** The kind of this creator. */
+ public final ComponentCreatorKind kind() {
+ return annotation().creatorKind();
+ }
+
+ /** The annotated creator type. */
+ public abstract TypeElement typeElement();
+
+ /** The method that creates and returns a component instance. */
+ public abstract ExecutableElement factoryMethod();
+
+ /**
+ * Multimap of component requirements to setter methods that set that requirement.
+ *
+ * <p>In a valid creator, there will be exactly one element per component requirement, so this
+ * method should only be called when validating the descriptor.
+ */
+ abstract ImmutableSetMultimap<ComponentRequirement, ExecutableElement> unvalidatedSetterMethods();
+
+ /**
+ * Multimap of component requirements to factory method parameters that set that requirement.
+ *
+ * <p>In a valid creator, there will be exactly one element per component requirement, so this
+ * method should only be called when validating the descriptor.
+ */
+ abstract ImmutableSetMultimap<ComponentRequirement, VariableElement>
+ unvalidatedFactoryParameters();
+
+ /**
+ * Multimap of component requirements to elements (methods or parameters) that set that
+ * requirement.
+ *
+ * <p>In a valid creator, there will be exactly one element per component requirement, so this
+ * method should only be called when validating the descriptor.
+ */
+ public final ImmutableSetMultimap<ComponentRequirement, Element>
+ unvalidatedRequirementElements() {
+ // ComponentCreatorValidator ensures that there are either setter methods or factory method
+ // parameters, but not both, so we can cheat a little here since we know that only one of
+ // the two multimaps will be non-empty.
+ return ImmutableSetMultimap.copyOf( // no actual copy
+ unvalidatedSetterMethods().isEmpty()
+ ? unvalidatedFactoryParameters()
+ : unvalidatedSetterMethods());
+ }
+
+ /**
+ * Map of component requirements to elements (setter methods or factory method parameters) that
+ * set them.
+ */
+ @Memoized
+ ImmutableMap<ComponentRequirement, Element> requirementElements() {
+ return flatten(unvalidatedRequirementElements());
+ }
+
+ /** Map of component requirements to setter methods for those requirements. */
+ @Memoized
+ public ImmutableMap<ComponentRequirement, ExecutableElement> setterMethods() {
+ return flatten(unvalidatedSetterMethods());
+ }
+
+ /** Map of component requirements to factory method parameters for those requirements. */
+ @Memoized
+ public ImmutableMap<ComponentRequirement, VariableElement> factoryParameters() {
+ return flatten(unvalidatedFactoryParameters());
+ }
+
+ private static <K, V> ImmutableMap<K, V> flatten(Multimap<K, V> multimap) {
+ return ImmutableMap.copyOf(
+ Maps.transformValues(multimap.asMap(), values -> getOnlyElement(values)));
+ }
+
+ /** Returns the set of component requirements this creator allows the user to set. */
+ public final ImmutableSet<ComponentRequirement> userSettableRequirements() {
+ // Note: they should have been validated at the point this is used, so this set is valid.
+ return unvalidatedRequirementElements().keySet();
+ }
+
+ /** Returns the set of requirements for modules and component dependencies for this creator. */
+ public final ImmutableSet<ComponentRequirement> moduleAndDependencyRequirements() {
+ return userSettableRequirements().stream()
+ .filter(requirement -> !requirement.isBoundInstance())
+ .collect(toImmutableSet());
+ }
+
+ /** Returns the set of bound instance requirements for this creator. */
+ final ImmutableSet<ComponentRequirement> boundInstanceRequirements() {
+ return userSettableRequirements().stream()
+ .filter(ComponentRequirement::isBoundInstance)
+ .collect(toImmutableSet());
+ }
+
+ /** Returns the element in this creator that sets the given {@code requirement}. */
+ final Element elementForRequirement(ComponentRequirement requirement) {
+ return requirementElements().get(requirement);
+ }
+
+ /** Creates a new {@link ComponentCreatorDescriptor} for the given creator {@code type}. */
+ public static ComponentCreatorDescriptor create(
+ DeclaredType type,
+ DaggerElements elements,
+ DaggerTypes types,
+ DependencyRequestFactory dependencyRequestFactory) {
+ TypeElement typeElement = asTypeElement(type);
+ TypeMirror componentType = typeElement.getEnclosingElement().asType();
+
+ ImmutableSetMultimap.Builder<ComponentRequirement, ExecutableElement> setterMethods =
+ ImmutableSetMultimap.builder();
+
+ ExecutableElement factoryMethod = null;
+ for (ExecutableElement method : elements.getUnimplementedMethods(typeElement)) {
+ ExecutableType resolvedMethodType = MoreTypes.asExecutable(types.asMemberOf(type, method));
+
+ if (types.isSubtype(componentType, resolvedMethodType.getReturnType())) {
+ factoryMethod = method;
+ } else {
+ VariableElement parameter = getOnlyElement(method.getParameters());
+ TypeMirror parameterType = getOnlyElement(resolvedMethodType.getParameterTypes());
+ setterMethods.put(
+ requirement(method, parameter, parameterType, dependencyRequestFactory, method),
+ method);
+ }
+ }
+ verify(factoryMethod != null); // validation should have ensured this.
+
+ ImmutableSetMultimap.Builder<ComponentRequirement, VariableElement> factoryParameters =
+ ImmutableSetMultimap.builder();
+
+ ExecutableType resolvedFactoryMethodType =
+ MoreTypes.asExecutable(types.asMemberOf(type, factoryMethod));
+ List<? extends VariableElement> parameters = factoryMethod.getParameters();
+ List<? extends TypeMirror> parameterTypes = resolvedFactoryMethodType.getParameterTypes();
+ for (int i = 0; i < parameters.size(); i++) {
+ VariableElement parameter = parameters.get(i);
+ TypeMirror parameterType = parameterTypes.get(i);
+ factoryParameters.put(
+ requirement(factoryMethod, parameter, parameterType, dependencyRequestFactory, parameter),
+ parameter);
+ }
+
+ // Validation should have ensured exactly one creator annotation is present on the type.
+ ComponentCreatorAnnotation annotation = getOnlyElement(getCreatorAnnotations(typeElement));
+ return new AutoValue_ComponentCreatorDescriptor(
+ annotation, typeElement, factoryMethod, setterMethods.build(), factoryParameters.build());
+ }
+
+ private static ComponentRequirement requirement(
+ ExecutableElement method,
+ VariableElement parameter,
+ TypeMirror type,
+ DependencyRequestFactory dependencyRequestFactory,
+ Element elementForVariableName) {
+ if (isAnnotationPresent(method, BindsInstance.class)
+ || isAnnotationPresent(parameter, BindsInstance.class)) {
+ DependencyRequest request =
+ dependencyRequestFactory.forRequiredResolvedVariable(parameter, type);
+ String variableName = elementForVariableName.getSimpleName().toString();
+ return ComponentRequirement.forBoundInstance(
+ request.key(), request.isNullable(), variableName);
+ }
+
+ return moduleAnnotation(asTypeElement(type)).isPresent()
+ ? ComponentRequirement.forModule(type)
+ : ComponentRequirement.forDependency(type);
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/ComponentCreatorKind.java b/java/dagger/internal/codegen/binding/ComponentCreatorKind.java
new file mode 100644
index 0000000..b2581d6
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/ComponentCreatorKind.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.common.base.CaseFormat.UPPER_CAMEL;
+import static com.google.common.base.CaseFormat.UPPER_UNDERSCORE;
+
+import com.google.common.base.Ascii;
+
+/** Enumeration of the different kinds of component creators. */
+public enum ComponentCreatorKind {
+ /** {@code @Component.Builder} or one of its subcomponent/production variants. */
+ BUILDER,
+
+ /** {@code @Component.Factory} or one of its subcomponent/production variants. */
+ FACTORY,
+ ;
+
+ /** Name to use as (or as part of) a type name for a creator of this kind. */
+ public String typeName() {
+ return UPPER_UNDERSCORE.to(UPPER_CAMEL, name());
+ }
+
+ /** Name to use for a component's static method returning a creator of this kind. */
+ public String methodName() {
+ return Ascii.toLowerCase(name());
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/ComponentDescriptor.java b/java/dagger/internal/codegen/binding/ComponentDescriptor.java
new file mode 100644
index 0000000..a7e4cc4
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/ComponentDescriptor.java
@@ -0,0 +1,376 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableMap;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static dagger.internal.codegen.langmodel.DaggerTypes.isFutureType;
+import static javax.lang.model.element.Modifier.ABSTRACT;
+import static javax.lang.model.type.TypeKind.VOID;
+
+import com.google.auto.value.AutoValue;
+import com.google.auto.value.extension.memoized.Memoized;
+import com.google.common.base.Supplier;
+import com.google.common.base.Suppliers;
+import com.google.common.collect.ImmutableBiMap;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Maps;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.errorprone.annotations.CheckReturnValue;
+import dagger.Component;
+import dagger.Module;
+import dagger.Subcomponent;
+import dagger.internal.codegen.base.ComponentAnnotation;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.DependencyRequest;
+import dagger.model.Scope;
+import dagger.producers.CancellationPolicy;
+import dagger.producers.ProductionComponent;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.stream.Stream;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeMirror;
+
+/**
+ * A component declaration.
+ *
+ * <p>Represents one type annotated with {@code @Component}, {@code Subcomponent},
+ * {@code @ProductionComponent}, or {@code @ProductionSubcomponent}.
+ *
+ * <p>When validating bindings installed in modules, a {@link ComponentDescriptor} can also
+ * represent a synthetic component for the module, where there is an entry point for each binding in
+ * the module.
+ */
+@AutoValue
+public abstract class ComponentDescriptor {
+ /** The annotation that specifies that {@link #typeElement()} is a component. */
+ public abstract ComponentAnnotation annotation();
+
+ /** Returns {@code true} if this is a subcomponent. */
+ public final boolean isSubcomponent() {
+ return annotation().isSubcomponent();
+ }
+
+ /**
+ * Returns {@code true} if this is a production component or subcomponent, or a
+ * {@code @ProducerModule} when doing module binding validation.
+ */
+ public final boolean isProduction() {
+ return annotation().isProduction();
+ }
+
+ /**
+ * Returns {@code true} if this is a real component, and not a fictional one used to validate
+ * module bindings.
+ */
+ public final boolean isRealComponent() {
+ return annotation().isRealComponent();
+ }
+
+ /**
+ * The element that defines the component. This is the element to which the {@link #annotation()}
+ * was applied.
+ */
+ public abstract TypeElement typeElement();
+
+ /**
+ * The set of component dependencies listed in {@link Component#dependencies} or {@link
+ * ProductionComponent#dependencies()}.
+ */
+ public abstract ImmutableSet<ComponentRequirement> dependencies();
+
+ /** The non-abstract {@link #modules()} and the {@link #dependencies()}. */
+ public final ImmutableSet<ComponentRequirement> dependenciesAndConcreteModules() {
+ return Stream.concat(
+ moduleTypes().stream()
+ .filter(dep -> !dep.getModifiers().contains(ABSTRACT))
+ .map(module -> ComponentRequirement.forModule(module.asType())),
+ dependencies().stream())
+ .collect(toImmutableSet());
+ }
+
+ /**
+ * The {@link ModuleDescriptor modules} declared in {@link Component#modules()} and reachable by
+ * traversing {@link Module#includes()}.
+ */
+ public abstract ImmutableSet<ModuleDescriptor> modules();
+
+ /** The types of the {@link #modules()}. */
+ public final ImmutableSet<TypeElement> moduleTypes() {
+ return modules().stream().map(ModuleDescriptor::moduleElement).collect(toImmutableSet());
+ }
+
+ /**
+ * The types for which the component will need instances if all of its bindings are used. For the
+ * types the component will need in a given binding graph, use {@link
+ * BindingGraph#componentRequirements()}.
+ *
+ * <ul>
+ * <li>{@linkplain #modules()} modules} with concrete instance bindings
+ * <li>Bound instances
+ * <li>{@linkplain #dependencies() dependencies}
+ * </ul>
+ */
+ @Memoized
+ ImmutableSet<ComponentRequirement> requirements() {
+ ImmutableSet.Builder<ComponentRequirement> requirements = ImmutableSet.builder();
+ modules().stream()
+ .filter(
+ module ->
+ module.bindings().stream().anyMatch(ContributionBinding::requiresModuleInstance))
+ .map(module -> ComponentRequirement.forModule(module.moduleElement().asType()))
+ .forEach(requirements::add);
+ requirements.addAll(dependencies());
+ requirements.addAll(
+ creatorDescriptor()
+ .map(ComponentCreatorDescriptor::boundInstanceRequirements)
+ .orElse(ImmutableSet.of()));
+ return requirements.build();
+ }
+
+ /**
+ * This component's {@linkplain #dependencies() dependencies} keyed by each provision or
+ * production method defined by that dependency. Note that the dependencies' types are not simply
+ * the enclosing type of the method; a method may be declared by a supertype of the actual
+ * dependency.
+ */
+ public abstract ImmutableMap<ExecutableElement, ComponentRequirement>
+ dependenciesByDependencyMethod();
+
+ /** The {@linkplain #dependencies() component dependency} that defines a method. */
+ public final ComponentRequirement getDependencyThatDefinesMethod(Element method) {
+ checkArgument(
+ method instanceof ExecutableElement, "method must be an executable element: %s", method);
+ return checkNotNull(
+ dependenciesByDependencyMethod().get(method), "no dependency implements %s", method);
+ }
+
+ /** The scopes of the component. */
+ public abstract ImmutableSet<Scope> scopes();
+
+ /**
+ * All {@link Subcomponent}s which are direct children of this component. This includes
+ * subcomponents installed from {@link Module#subcomponents()} as well as subcomponent {@linkplain
+ * #childComponentsDeclaredByFactoryMethods() factory methods} and {@linkplain
+ * #childComponentsDeclaredByBuilderEntryPoints() builder methods}.
+ */
+ public final ImmutableSet<ComponentDescriptor> childComponents() {
+ return ImmutableSet.<ComponentDescriptor>builder()
+ .addAll(childComponentsDeclaredByFactoryMethods().values())
+ .addAll(childComponentsDeclaredByBuilderEntryPoints().values())
+ .addAll(childComponentsDeclaredByModules())
+ .build();
+ }
+
+ /**
+ * All {@linkplain Subcomponent direct child} components that are declared by a {@linkplain
+ * Module#subcomponents() module's subcomponents}.
+ */
+ abstract ImmutableSet<ComponentDescriptor> childComponentsDeclaredByModules();
+
+ /**
+ * All {@linkplain Subcomponent direct child} components that are declared by a subcomponent
+ * factory method.
+ */
+ public abstract ImmutableBiMap<ComponentMethodDescriptor, ComponentDescriptor>
+ childComponentsDeclaredByFactoryMethods();
+
+ /** Returns a map of {@link #childComponents()} indexed by {@link #typeElement()}. */
+ @Memoized
+ public ImmutableMap<TypeElement, ComponentDescriptor> childComponentsByElement() {
+ return Maps.uniqueIndex(childComponents(), ComponentDescriptor::typeElement);
+ }
+
+ /** Returns the factory method that declares a child component. */
+ final Optional<ComponentMethodDescriptor> getFactoryMethodForChildComponent(
+ ComponentDescriptor childComponent) {
+ return Optional.ofNullable(
+ childComponentsDeclaredByFactoryMethods().inverse().get(childComponent));
+ }
+
+ /**
+ * All {@linkplain Subcomponent direct child} components that are declared by a subcomponent
+ * builder method.
+ */
+ abstract ImmutableBiMap<ComponentMethodDescriptor, ComponentDescriptor>
+ childComponentsDeclaredByBuilderEntryPoints();
+
+ private final Supplier<ImmutableMap<TypeElement, ComponentDescriptor>>
+ childComponentsByBuilderType =
+ Suppliers.memoize(
+ () ->
+ childComponents().stream()
+ .filter(child -> child.creatorDescriptor().isPresent())
+ .collect(
+ toImmutableMap(
+ child -> child.creatorDescriptor().get().typeElement(),
+ child -> child)));
+
+ /** Returns the child component with the given builder type. */
+ final ComponentDescriptor getChildComponentWithBuilderType(TypeElement builderType) {
+ return checkNotNull(
+ childComponentsByBuilderType.get().get(builderType),
+ "no child component found for builder type %s",
+ builderType.getQualifiedName());
+ }
+
+ public abstract ImmutableSet<ComponentMethodDescriptor> componentMethods();
+
+ /** Returns the first component method associated with this binding request, if one exists. */
+ public Optional<ComponentMethodDescriptor> firstMatchingComponentMethod(BindingRequest request) {
+ return componentMethods().stream()
+ .filter(method -> doesComponentMethodMatch(method, request))
+ .findFirst();
+ }
+
+ /** Returns true if the component method matches the binding request. */
+ private static boolean doesComponentMethodMatch(
+ ComponentMethodDescriptor componentMethod, BindingRequest request) {
+ return componentMethod
+ .dependencyRequest()
+ .map(BindingRequest::bindingRequest)
+ .filter(request::equals)
+ .isPresent();
+ }
+
+ /** The entry point methods on the component type. Each has a {@link DependencyRequest}. */
+ public final ImmutableSet<ComponentMethodDescriptor> entryPointMethods() {
+ return componentMethods()
+ .stream()
+ .filter(method -> method.dependencyRequest().isPresent())
+ .collect(toImmutableSet());
+ }
+
+ // TODO(gak): Consider making this non-optional and revising the
+ // interaction between the spec & generation
+ /** Returns a descriptor for the creator type for this component type, if the user defined one. */
+ public abstract Optional<ComponentCreatorDescriptor> creatorDescriptor();
+
+ /**
+ * Returns {@code true} for components that have a creator, either because the user {@linkplain
+ * #creatorDescriptor() specified one} or because it's a top-level component with an implicit
+ * builder.
+ */
+ public final boolean hasCreator() {
+ return !isSubcomponent() || creatorDescriptor().isPresent();
+ }
+
+ /**
+ * Returns the {@link CancellationPolicy} for this component, or an empty optional if either the
+ * component is not a production component or no {@code CancellationPolicy} annotation is present.
+ */
+ public final Optional<CancellationPolicy> cancellationPolicy() {
+ return isProduction()
+ ? Optional.ofNullable(typeElement().getAnnotation(CancellationPolicy.class))
+ : Optional.empty();
+ }
+
+ @Memoized
+ @Override
+ public int hashCode() {
+ // TODO(b/122962745): Only use typeElement().hashCode()
+ return Objects.hash(typeElement(), annotation());
+ }
+
+ // TODO(ronshapiro): simplify the equality semantics
+ @Override
+ public abstract boolean equals(Object obj);
+
+ /** A component method. */
+ @AutoValue
+ public abstract static class ComponentMethodDescriptor {
+ /** The method itself. Note that this may be declared on a supertype of the component. */
+ public abstract ExecutableElement methodElement();
+
+ /**
+ * The dependency request for production, provision, and subcomponent creator methods. Absent
+ * for subcomponent factory methods.
+ */
+ public abstract Optional<DependencyRequest> dependencyRequest();
+
+ /** The subcomponent for subcomponent factory methods and subcomponent creator methods. */
+ public abstract Optional<ComponentDescriptor> subcomponent();
+
+ /**
+ * Returns the return type of {@link #methodElement()} as resolved in the {@link
+ * ComponentDescriptor#typeElement() component type}. If there are no type variables in the
+ * return type, this is the equivalent of {@code methodElement().getReturnType()}.
+ */
+ public TypeMirror resolvedReturnType(DaggerTypes types) {
+ checkState(dependencyRequest().isPresent());
+
+ TypeMirror returnType = methodElement().getReturnType();
+ if (returnType.getKind().isPrimitive() || returnType.getKind().equals(VOID)) {
+ return returnType;
+ }
+ return BindingRequest.bindingRequest(dependencyRequest().get())
+ .requestedType(dependencyRequest().get().key().type(), types);
+ }
+
+ /** A {@link ComponentMethodDescriptor}builder for a method. */
+ public static Builder builder(ExecutableElement method) {
+ return new AutoValue_ComponentDescriptor_ComponentMethodDescriptor.Builder()
+ .methodElement(method);
+ }
+
+ /** A builder of {@link ComponentMethodDescriptor}s. */
+ @AutoValue.Builder
+ @CanIgnoreReturnValue
+ public interface Builder {
+ /** @see ComponentMethodDescriptor#methodElement() */
+ Builder methodElement(ExecutableElement methodElement);
+
+ /** @see ComponentMethodDescriptor#dependencyRequest() */
+ Builder dependencyRequest(DependencyRequest dependencyRequest);
+
+ /** @see ComponentMethodDescriptor#subcomponent() */
+ Builder subcomponent(ComponentDescriptor subcomponent);
+
+ /** Builds the descriptor. */
+ @CheckReturnValue
+ ComponentMethodDescriptor build();
+ }
+ }
+
+ /** No-argument methods defined on {@link Object} that are ignored for contribution. */
+ private static final ImmutableSet<String> NON_CONTRIBUTING_OBJECT_METHOD_NAMES =
+ ImmutableSet.of("toString", "hashCode", "clone", "getClass");
+
+ /**
+ * Returns {@code true} if a method could be a component entry point but not a members-injection
+ * method.
+ */
+ static boolean isComponentContributionMethod(DaggerElements elements, ExecutableElement method) {
+ return method.getParameters().isEmpty()
+ && !method.getReturnType().getKind().equals(VOID)
+ && !elements.getTypeElement(Object.class).equals(method.getEnclosingElement())
+ && !NON_CONTRIBUTING_OBJECT_METHOD_NAMES.contains(method.getSimpleName().toString());
+ }
+
+ /** Returns {@code true} if a method could be a component production entry point. */
+ static boolean isComponentProductionMethod(DaggerElements elements, ExecutableElement method) {
+ return isComponentContributionMethod(elements, method) && isFutureType(method.getReturnType());
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/ComponentDescriptorFactory.java b/java/dagger/internal/codegen/binding/ComponentDescriptorFactory.java
new file mode 100644
index 0000000..f13aa50
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/ComponentDescriptorFactory.java
@@ -0,0 +1,273 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.auto.common.MoreElements.asType;
+import static com.google.auto.common.MoreTypes.asTypeElement;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static dagger.internal.codegen.base.ComponentAnnotation.subcomponentAnnotation;
+import static dagger.internal.codegen.base.Scopes.productionScope;
+import static dagger.internal.codegen.base.Scopes.scopesOf;
+import static dagger.internal.codegen.binding.ComponentCreatorAnnotation.creatorAnnotationsFor;
+import static dagger.internal.codegen.binding.ComponentDescriptor.isComponentContributionMethod;
+import static dagger.internal.codegen.binding.ConfigurationAnnotations.enclosedAnnotatedTypes;
+import static dagger.internal.codegen.binding.ConfigurationAnnotations.isSubcomponentCreator;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static javax.lang.model.type.TypeKind.DECLARED;
+import static javax.lang.model.type.TypeKind.VOID;
+import static javax.lang.model.util.ElementFilter.methodsIn;
+
+import com.google.auto.common.MoreTypes;
+import com.google.common.collect.ImmutableBiMap;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import dagger.internal.codegen.base.ComponentAnnotation;
+import dagger.internal.codegen.base.ModuleAnnotation;
+import dagger.internal.codegen.binding.ComponentDescriptor.ComponentMethodDescriptor;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.Scope;
+import java.util.Optional;
+import java.util.function.Function;
+import javax.inject.Inject;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.ExecutableType;
+import javax.lang.model.type.TypeMirror;
+
+/** A factory for {@link ComponentDescriptor}s. */
+public final class ComponentDescriptorFactory {
+ private final DaggerElements elements;
+ private final DaggerTypes types;
+ private final DependencyRequestFactory dependencyRequestFactory;
+ private final ModuleDescriptor.Factory moduleDescriptorFactory;
+ private final InjectionAnnotations injectionAnnotations;
+
+ @Inject
+ ComponentDescriptorFactory(
+ DaggerElements elements,
+ DaggerTypes types,
+ DependencyRequestFactory dependencyRequestFactory,
+ ModuleDescriptor.Factory moduleDescriptorFactory,
+ InjectionAnnotations injectionAnnotations) {
+ this.elements = elements;
+ this.types = types;
+ this.dependencyRequestFactory = dependencyRequestFactory;
+ this.moduleDescriptorFactory = moduleDescriptorFactory;
+ this.injectionAnnotations = injectionAnnotations;
+ }
+
+ /** Returns a descriptor for a root component type. */
+ public ComponentDescriptor rootComponentDescriptor(TypeElement typeElement) {
+ return create(
+ typeElement,
+ checkAnnotation(
+ typeElement,
+ ComponentAnnotation::rootComponentAnnotation,
+ "must have a component annotation"));
+ }
+
+ /** Returns a descriptor for a subcomponent type. */
+ public ComponentDescriptor subcomponentDescriptor(TypeElement typeElement) {
+ return create(
+ typeElement,
+ checkAnnotation(
+ typeElement,
+ ComponentAnnotation::subcomponentAnnotation,
+ "must have a subcomponent annotation"));
+ }
+
+ /**
+ * Returns a descriptor for a fictional component based on a module type in order to validate its
+ * bindings.
+ */
+ public ComponentDescriptor moduleComponentDescriptor(TypeElement typeElement) {
+ return create(
+ typeElement,
+ ComponentAnnotation.fromModuleAnnotation(
+ checkAnnotation(
+ typeElement, ModuleAnnotation::moduleAnnotation, "must have a module annotation")));
+ }
+
+ private static <A> A checkAnnotation(
+ TypeElement typeElement,
+ Function<TypeElement, Optional<A>> annotationFunction,
+ String message) {
+ return annotationFunction
+ .apply(typeElement)
+ .orElseThrow(() -> new IllegalArgumentException(typeElement + " " + message));
+ }
+
+ private ComponentDescriptor create(
+ TypeElement typeElement, ComponentAnnotation componentAnnotation) {
+ ImmutableSet<ComponentRequirement> componentDependencies =
+ componentAnnotation.dependencyTypes().stream()
+ .map(ComponentRequirement::forDependency)
+ .collect(toImmutableSet());
+
+ ImmutableMap.Builder<ExecutableElement, ComponentRequirement> dependenciesByDependencyMethod =
+ ImmutableMap.builder();
+
+ for (ComponentRequirement componentDependency : componentDependencies) {
+ for (ExecutableElement dependencyMethod :
+ methodsIn(elements.getAllMembers(componentDependency.typeElement()))) {
+ if (isComponentContributionMethod(elements, dependencyMethod)) {
+ dependenciesByDependencyMethod.put(dependencyMethod, componentDependency);
+ }
+ }
+ }
+
+ // Start with the component's modules. For fictional components built from a module, start with
+ // that module.
+ ImmutableSet<TypeElement> modules =
+ componentAnnotation.isRealComponent()
+ ? componentAnnotation.modules()
+ : ImmutableSet.of(typeElement);
+
+ ImmutableSet<ModuleDescriptor> transitiveModules =
+ moduleDescriptorFactory.transitiveModules(modules);
+
+ ImmutableSet.Builder<ComponentDescriptor> subcomponentsFromModules = ImmutableSet.builder();
+ for (ModuleDescriptor module : transitiveModules) {
+ for (SubcomponentDeclaration subcomponentDeclaration : module.subcomponentDeclarations()) {
+ TypeElement subcomponent = subcomponentDeclaration.subcomponentType();
+ subcomponentsFromModules.add(subcomponentDescriptor(subcomponent));
+ }
+ }
+
+ ImmutableSet.Builder<ComponentMethodDescriptor> componentMethodsBuilder =
+ ImmutableSet.builder();
+ ImmutableBiMap.Builder<ComponentMethodDescriptor, ComponentDescriptor>
+ subcomponentsByFactoryMethod = ImmutableBiMap.builder();
+ ImmutableBiMap.Builder<ComponentMethodDescriptor, ComponentDescriptor>
+ subcomponentsByBuilderMethod = ImmutableBiMap.builder();
+ if (componentAnnotation.isRealComponent()) {
+ ImmutableSet<ExecutableElement> unimplementedMethods =
+ elements.getUnimplementedMethods(typeElement);
+ for (ExecutableElement componentMethod : unimplementedMethods) {
+ ComponentMethodDescriptor componentMethodDescriptor =
+ getDescriptorForComponentMethod(typeElement, componentAnnotation, componentMethod);
+ componentMethodsBuilder.add(componentMethodDescriptor);
+ componentMethodDescriptor
+ .subcomponent()
+ .ifPresent(
+ subcomponent -> {
+ // If the dependency request is present, that means the method returns the
+ // subcomponent factory.
+ if (componentMethodDescriptor.dependencyRequest().isPresent()) {
+ subcomponentsByBuilderMethod.put(componentMethodDescriptor, subcomponent);
+ } else {
+ subcomponentsByFactoryMethod.put(componentMethodDescriptor, subcomponent);
+ }
+ });
+ }
+ }
+
+ // Validation should have ensured that this set will have at most one element.
+ ImmutableSet<DeclaredType> enclosedCreators =
+ creatorAnnotationsFor(componentAnnotation).stream()
+ .flatMap(
+ creatorAnnotation ->
+ enclosedAnnotatedTypes(typeElement, creatorAnnotation).stream())
+ .collect(toImmutableSet());
+ Optional<ComponentCreatorDescriptor> creatorDescriptor =
+ enclosedCreators.isEmpty()
+ ? Optional.empty()
+ : Optional.of(
+ ComponentCreatorDescriptor.create(
+ getOnlyElement(enclosedCreators), elements, types, dependencyRequestFactory));
+
+ ImmutableSet<Scope> scopes = scopesOf(typeElement);
+ if (componentAnnotation.isProduction()) {
+ scopes = ImmutableSet.<Scope>builder().addAll(scopes).add(productionScope(elements)).build();
+ }
+
+ return new AutoValue_ComponentDescriptor(
+ componentAnnotation,
+ typeElement,
+ componentDependencies,
+ transitiveModules,
+ dependenciesByDependencyMethod.build(),
+ scopes,
+ subcomponentsFromModules.build(),
+ subcomponentsByFactoryMethod.build(),
+ subcomponentsByBuilderMethod.build(),
+ componentMethodsBuilder.build(),
+ creatorDescriptor);
+ }
+
+ private ComponentMethodDescriptor getDescriptorForComponentMethod(
+ TypeElement componentElement,
+ ComponentAnnotation componentAnnotation,
+ ExecutableElement componentMethod) {
+ ComponentMethodDescriptor.Builder descriptor =
+ ComponentMethodDescriptor.builder(componentMethod);
+
+ ExecutableType resolvedComponentMethod =
+ MoreTypes.asExecutable(
+ types.asMemberOf(MoreTypes.asDeclared(componentElement.asType()), componentMethod));
+ TypeMirror returnType = resolvedComponentMethod.getReturnType();
+ if (returnType.getKind().equals(DECLARED)
+ && !injectionAnnotations.getQualifier(componentMethod).isPresent()) {
+ TypeElement returnTypeElement = asTypeElement(returnType);
+ if (subcomponentAnnotation(returnTypeElement).isPresent()) {
+ // It's a subcomponent factory method. There is no dependency request, and there could be
+ // any number of parameters. Just return the descriptor.
+ return descriptor.subcomponent(subcomponentDescriptor(returnTypeElement)).build();
+ }
+ if (isSubcomponentCreator(returnTypeElement)) {
+ descriptor.subcomponent(
+ subcomponentDescriptor(asType(returnTypeElement.getEnclosingElement())));
+ }
+ }
+
+ switch (componentMethod.getParameters().size()) {
+ case 0:
+ checkArgument(
+ !returnType.getKind().equals(VOID),
+ "component method cannot be void: %s",
+ componentMethod);
+ descriptor.dependencyRequest(
+ componentAnnotation.isProduction()
+ ? dependencyRequestFactory.forComponentProductionMethod(
+ componentMethod, resolvedComponentMethod)
+ : dependencyRequestFactory.forComponentProvisionMethod(
+ componentMethod, resolvedComponentMethod));
+ break;
+
+ case 1:
+ checkArgument(
+ returnType.getKind().equals(VOID)
+ || MoreTypes.equivalence()
+ .equivalent(returnType, resolvedComponentMethod.getParameterTypes().get(0)),
+ "members injection method must return void or parameter type: %s",
+ componentMethod);
+ descriptor.dependencyRequest(
+ dependencyRequestFactory.forComponentMembersInjectionMethod(
+ componentMethod, resolvedComponentMethod));
+ break;
+
+ default:
+ throw new IllegalArgumentException(
+ "component method has too many parameters: " + componentMethod);
+ }
+
+ return descriptor.build();
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/ComponentKind.java b/java/dagger/internal/codegen/binding/ComponentKind.java
new file mode 100644
index 0000000..1cb3d7c
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/ComponentKind.java
@@ -0,0 +1,171 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.auto.common.MoreElements.isAnnotationPresent;
+import static com.google.common.collect.Sets.immutableEnumSet;
+import static dagger.internal.codegen.extension.DaggerStreams.stream;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static dagger.internal.codegen.extension.DaggerStreams.valuesOf;
+import static java.util.EnumSet.allOf;
+
+import com.google.common.collect.ImmutableSet;
+import dagger.Component;
+import dagger.Module;
+import dagger.Subcomponent;
+import dagger.producers.ProducerModule;
+import dagger.producers.ProductionComponent;
+import dagger.producers.ProductionSubcomponent;
+import java.lang.annotation.Annotation;
+import java.util.Optional;
+import javax.lang.model.element.TypeElement;
+
+/** Enumeration of the different kinds of components. */
+public enum ComponentKind {
+ /** {@code @Component} */
+ COMPONENT(Component.class, true, false),
+
+ /** {@code @Subcomponent} */
+ SUBCOMPONENT(Subcomponent.class, false, false),
+
+ /** {@code @ProductionComponent} */
+ PRODUCTION_COMPONENT(ProductionComponent.class, true, true),
+
+ /** {@code @ProductionSubcomponent} */
+ PRODUCTION_SUBCOMPONENT(ProductionSubcomponent.class, false, true),
+
+ /**
+ * Kind for a descriptor that was generated from a {@link Module} instead of a component type in
+ * order to validate the module's bindings.
+ */
+ MODULE(Module.class, true, false),
+
+ /**
+ * Kind for a descriptor was generated from a {@link ProducerModule} instead of a component type
+ * in order to validate the module's bindings.
+ */
+ PRODUCER_MODULE(ProducerModule.class, true, true),
+ ;
+
+ private static final ImmutableSet<ComponentKind> ROOT_COMPONENT_KINDS =
+ valuesOf(ComponentKind.class)
+ .filter(kind -> !kind.isForModuleValidation())
+ .filter(kind -> kind.isRoot())
+ .collect(toImmutableSet());
+
+ private static final ImmutableSet<ComponentKind> SUBCOMPONENT_KINDS =
+ valuesOf(ComponentKind.class)
+ .filter(kind -> !kind.isForModuleValidation())
+ .filter(kind -> !kind.isRoot())
+ .collect(toImmutableSet());
+
+ /** Returns the set of kinds for root components. */
+ public static ImmutableSet<ComponentKind> rootComponentKinds() {
+ return ROOT_COMPONENT_KINDS;
+ }
+
+ /** Returns the set of kinds for subcomponents. */
+ public static ImmutableSet<ComponentKind> subcomponentKinds() {
+ return SUBCOMPONENT_KINDS;
+ }
+
+ /** Returns the annotations for components of the given kinds. */
+ public static ImmutableSet<Class<? extends Annotation>> annotationsFor(
+ Iterable<ComponentKind> kinds) {
+ return stream(kinds).map(ComponentKind::annotation).collect(toImmutableSet());
+ }
+
+ /** Returns the set of component kinds the given {@code element} has annotations for. */
+ public static ImmutableSet<ComponentKind> getComponentKinds(TypeElement element) {
+ return valuesOf(ComponentKind.class)
+ .filter(kind -> isAnnotationPresent(element, kind.annotation()))
+ .collect(toImmutableSet());
+ }
+
+ /**
+ * Returns the kind of an annotated element if it is annotated with one of the {@linkplain
+ * #annotation() annotations}.
+ *
+ * @throws IllegalArgumentException if the element is annotated with more than one of the
+ * annotations
+ */
+ public static Optional<ComponentKind> forAnnotatedElement(TypeElement element) {
+ ImmutableSet<ComponentKind> kinds = getComponentKinds(element);
+ if (kinds.size() > 1) {
+ throw new IllegalArgumentException(
+ element + " cannot be annotated with more than one of " + annotationsFor(kinds));
+ }
+ return kinds.stream().findAny();
+ }
+
+ private final Class<? extends Annotation> annotation;
+ private final boolean isRoot;
+ private final boolean production;
+
+ ComponentKind(
+ Class<? extends Annotation> annotation,
+ boolean isRoot,
+ boolean production) {
+ this.annotation = annotation;
+ this.isRoot = isRoot;
+ this.production = production;
+ }
+
+ /** Returns the annotation that marks a component of this kind. */
+ public Class<? extends Annotation> annotation() {
+ return annotation;
+ }
+
+ /** Returns the kinds of modules that can be used with a component of this kind. */
+ public ImmutableSet<ModuleKind> legalModuleKinds() {
+ return isProducer()
+ ? immutableEnumSet(allOf(ModuleKind.class))
+ : immutableEnumSet(ModuleKind.MODULE);
+ }
+
+ /** Returns the kinds of subcomponents a component of this kind can have. */
+ public ImmutableSet<ComponentKind> legalSubcomponentKinds() {
+ return isProducer()
+ ? immutableEnumSet(PRODUCTION_SUBCOMPONENT)
+ : immutableEnumSet(SUBCOMPONENT, PRODUCTION_SUBCOMPONENT);
+ }
+
+ /**
+ * Returns {@code true} if the descriptor is for a root component (not a subcomponent) or is for
+ * {@linkplain #isForModuleValidation() module-validation}.
+ */
+ public boolean isRoot() {
+ return isRoot;
+ }
+
+ /** Returns true if this is a production component. */
+ public boolean isProducer() {
+ return production;
+ }
+
+ /** Returns {@code true} if the descriptor is for a module in order to validate its bindings. */
+ public boolean isForModuleValidation() {
+ switch (this) {
+ case MODULE:
+ case PRODUCER_MODULE:
+ return true;
+ default:
+ // fall through
+ }
+ return false;
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/ComponentNodeImpl.java b/java/dagger/internal/codegen/binding/ComponentNodeImpl.java
new file mode 100644
index 0000000..0947c25
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/ComponentNodeImpl.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.collect.ImmutableSet;
+import dagger.model.BindingGraph.ComponentNode;
+import dagger.model.ComponentPath;
+import dagger.model.DependencyRequest;
+import dagger.model.Scope;
+
+/** An implementation of {@link ComponentNode} that also exposes the {@link ComponentDescriptor}. */
+@AutoValue
+public abstract class ComponentNodeImpl implements ComponentNode {
+ public static ComponentNode create(
+ ComponentPath componentPath, ComponentDescriptor componentDescriptor) {
+ return new AutoValue_ComponentNodeImpl(componentPath, componentDescriptor);
+ }
+
+ @Override
+ public final boolean isSubcomponent() {
+ return componentDescriptor().isSubcomponent();
+ }
+
+ @Override
+ public boolean isRealComponent() {
+ return componentDescriptor().isRealComponent();
+ }
+
+ @Override
+ public final ImmutableSet<DependencyRequest> entryPoints() {
+ return componentDescriptor().entryPointMethods().stream()
+ .map(method -> method.dependencyRequest().get())
+ .collect(toImmutableSet());
+ }
+
+ @Override
+ public ImmutableSet<Scope> scopes() {
+ return componentDescriptor().scopes();
+ }
+
+ public abstract ComponentDescriptor componentDescriptor();
+
+ @Override
+ public final String toString() {
+ return componentPath().toString();
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/ComponentRequirement.java b/java/dagger/internal/codegen/binding/ComponentRequirement.java
new file mode 100644
index 0000000..fa24b56
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/ComponentRequirement.java
@@ -0,0 +1,301 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.auto.common.MoreElements.getLocalAndInheritedMethods;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static dagger.internal.codegen.binding.SourceFiles.simpleVariableName;
+import static dagger.internal.codegen.langmodel.DaggerElements.isAnyAnnotationPresent;
+import static javax.lang.model.element.ElementKind.CONSTRUCTOR;
+import static javax.lang.model.element.Modifier.ABSTRACT;
+import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.STATIC;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.MoreTypes;
+import com.google.auto.value.AutoValue;
+import com.google.common.base.Equivalence;
+import com.google.common.collect.ImmutableSet;
+import com.squareup.javapoet.ParameterSpec;
+import com.squareup.javapoet.TypeName;
+import dagger.Binds;
+import dagger.BindsOptionalOf;
+import dagger.Provides;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.BindingKind;
+import dagger.model.Key;
+import dagger.multibindings.Multibinds;
+import dagger.producers.Produces;
+import java.util.Optional;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeMirror;
+
+/** A type that a component needs an instance of. */
+@AutoValue
+public abstract class ComponentRequirement {
+ /** The kind of the {@link ComponentRequirement}. */
+ public enum Kind {
+ /** A type listed in the component's {@code dependencies} attribute. */
+ DEPENDENCY,
+
+ /** A type listed in the component or subcomponent's {@code modules} attribute. */
+ MODULE,
+
+ /**
+ * An object that is passed to a builder's {@link dagger.BindsInstance @BindsInstance} method.
+ */
+ BOUND_INSTANCE,
+ ;
+
+ public boolean isBoundInstance() {
+ return equals(BOUND_INSTANCE);
+ }
+
+ public boolean isModule() {
+ return equals(MODULE);
+ }
+ }
+
+ /** The kind of requirement. */
+ public abstract Kind kind();
+
+ /** Returns true if this is a {@link Kind#BOUND_INSTANCE} requirement. */
+ // TODO(ronshapiro): consider removing this and inlining the usages
+ final boolean isBoundInstance() {
+ return kind().isBoundInstance();
+ }
+
+ /**
+ * The type of the instance the component must have, wrapped so that requirements can be used as
+ * value types.
+ */
+ public abstract Equivalence.Wrapper<TypeMirror> wrappedType();
+
+ /** The type of the instance the component must have. */
+ public TypeMirror type() {
+ return wrappedType().get();
+ }
+
+ /** The element associated with the type of this requirement. */
+ public TypeElement typeElement() {
+ return MoreTypes.asTypeElement(type());
+ }
+
+ /** The action a component builder should take if it {@code null} is passed. */
+ public enum NullPolicy {
+ /** Make a new instance. */
+ NEW,
+ /** Throw an exception. */
+ THROW,
+ /** Allow use of null values. */
+ ALLOW,
+ }
+
+ /**
+ * An override for the requirement's null policy. If set, this is used as the null policy instead
+ * of the default behavior in {@link #nullPolicy}.
+ *
+ * <p>Some implementations' null policy can be determined upon construction (e.g., for binding
+ * instances), but others' require Elements and Types, which must wait until {@link #nullPolicy}
+ * is called.
+ */
+ abstract Optional<NullPolicy> overrideNullPolicy();
+
+ /** The requirement's null policy. */
+ public NullPolicy nullPolicy(
+ DaggerElements elements, DaggerTypes types, KotlinMetadataUtil metadataUtil) {
+ if (overrideNullPolicy().isPresent()) {
+ return overrideNullPolicy().get();
+ }
+ switch (kind()) {
+ case MODULE:
+ return componentCanMakeNewInstances(typeElement(), metadataUtil)
+ ? NullPolicy.NEW
+ : requiresAPassedInstance(elements, types, metadataUtil)
+ ? NullPolicy.THROW
+ : NullPolicy.ALLOW;
+ case DEPENDENCY:
+ case BOUND_INSTANCE:
+ return NullPolicy.THROW;
+ }
+ throw new AssertionError();
+ }
+
+ /**
+ * Returns true if the passed {@link ComponentRequirement} requires a passed instance in order to
+ * be used within a component.
+ */
+ public boolean requiresAPassedInstance(
+ DaggerElements elements, DaggerTypes types, KotlinMetadataUtil metadataUtil) {
+ if (!kind().isModule()) {
+ // Bound instances and dependencies always require the user to provide an instance.
+ return true;
+ }
+ return requiresModuleInstance(elements, types, metadataUtil)
+ && !componentCanMakeNewInstances(typeElement(), metadataUtil);
+ }
+
+ /**
+ * Returns {@code true} if an instance is needed for this (module) requirement.
+ *
+ * <p>An instance is only needed if there is a binding method on the module that is neither {@code
+ * abstract} nor {@code static}; if all bindings are one of those, then there should be no
+ * possible dependency on instance state in the module's bindings.
+ *
+ * <p>Alternatively, if the module is a Kotlin Object then the binding methods are considered
+ * {@code static}, requiring no module instance.
+ */
+ private boolean requiresModuleInstance(
+ DaggerElements elements, DaggerTypes types, KotlinMetadataUtil metadataUtil) {
+ boolean isKotlinObject =
+ metadataUtil.isObjectClass(typeElement())
+ || metadataUtil.isCompanionObjectClass(typeElement());
+ if (isKotlinObject) {
+ return false;
+ }
+
+ ImmutableSet<ExecutableElement> methods =
+ getLocalAndInheritedMethods(typeElement(), types, elements);
+ return methods.stream()
+ .filter(this::isBindingMethod)
+ .map(ExecutableElement::getModifiers)
+ .anyMatch(modifiers -> !modifiers.contains(ABSTRACT) && !modifiers.contains(STATIC));
+ }
+
+ private boolean isBindingMethod(ExecutableElement method) {
+ // TODO(cgdecker): At the very least, we should have utility methods to consolidate this stuff
+ // in one place; listing individual annotations all over the place is brittle.
+ return isAnyAnnotationPresent(
+ method,
+ Provides.class,
+ Produces.class,
+ // TODO(ronshapiro): it would be cool to have internal meta-annotations that could describe
+ // these, like @AbstractBindingMethod
+ Binds.class,
+ Multibinds.class,
+ BindsOptionalOf.class);
+ }
+
+ /** The key for this requirement, if one is available. */
+ public abstract Optional<Key> key();
+
+ /** Returns the name for this requirement that could be used as a variable. */
+ public abstract String variableName();
+
+ /** Returns a parameter spec for this requirement. */
+ public ParameterSpec toParameterSpec() {
+ return ParameterSpec.builder(TypeName.get(type()), variableName()).build();
+ }
+
+ public static ComponentRequirement forDependency(TypeMirror type) {
+ return new AutoValue_ComponentRequirement(
+ Kind.DEPENDENCY,
+ MoreTypes.equivalence().wrap(checkNotNull(type)),
+ Optional.empty(),
+ Optional.empty(),
+ simpleVariableName(MoreTypes.asTypeElement(type)));
+ }
+
+ public static ComponentRequirement forModule(TypeMirror type) {
+ return new AutoValue_ComponentRequirement(
+ Kind.MODULE,
+ MoreTypes.equivalence().wrap(checkNotNull(type)),
+ Optional.empty(),
+ Optional.empty(),
+ simpleVariableName(MoreTypes.asTypeElement(type)));
+ }
+
+ static ComponentRequirement forBoundInstance(Key key, boolean nullable, String variableName) {
+ return new AutoValue_ComponentRequirement(
+ Kind.BOUND_INSTANCE,
+ MoreTypes.equivalence().wrap(key.type()),
+ nullable ? Optional.of(NullPolicy.ALLOW) : Optional.empty(),
+ Optional.of(key),
+ variableName);
+ }
+
+ public static ComponentRequirement forBoundInstance(ContributionBinding binding) {
+ checkArgument(binding.kind().equals(BindingKind.BOUND_INSTANCE));
+ return forBoundInstance(
+ binding.key(),
+ binding.nullableType().isPresent(),
+ binding.bindingElement().get().getSimpleName().toString());
+ }
+
+ /**
+ * Returns true if and only if a component can instantiate new instances (typically of a module)
+ * rather than requiring that they be passed.
+ */
+ // TODO(bcorso): Should this method throw if its called knowing that an instance is not needed?
+ public static boolean componentCanMakeNewInstances(
+ TypeElement typeElement, KotlinMetadataUtil metadataUtil) {
+ switch (typeElement.getKind()) {
+ case CLASS:
+ break;
+ case ENUM:
+ case ANNOTATION_TYPE:
+ case INTERFACE:
+ return false;
+ default:
+ throw new AssertionError("TypeElement cannot have kind: " + typeElement.getKind());
+ }
+
+ if (typeElement.getModifiers().contains(ABSTRACT)) {
+ return false;
+ }
+
+ if (requiresEnclosingInstance(typeElement)) {
+ return false;
+ }
+
+ if (metadataUtil.isObjectClass(typeElement)
+ || metadataUtil.isCompanionObjectClass(typeElement)) {
+ return false;
+ }
+
+ for (Element enclosed : typeElement.getEnclosedElements()) {
+ if (enclosed.getKind().equals(CONSTRUCTOR)
+ && MoreElements.asExecutable(enclosed).getParameters().isEmpty()
+ && !enclosed.getModifiers().contains(PRIVATE)) {
+ return true;
+ }
+ }
+
+ // TODO(gak): still need checks for visibility
+
+ return false;
+ }
+
+ private static boolean requiresEnclosingInstance(TypeElement typeElement) {
+ switch (typeElement.getNestingKind()) {
+ case TOP_LEVEL:
+ return false;
+ case MEMBER:
+ return !typeElement.getModifiers().contains(STATIC);
+ case ANONYMOUS:
+ case LOCAL:
+ return true;
+ }
+ throw new AssertionError(
+ "TypeElement cannot have nesting kind: " + typeElement.getNestingKind());
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/ConfigurationAnnotations.java b/java/dagger/internal/codegen/binding/ConfigurationAnnotations.java
new file mode 100644
index 0000000..539a66a
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/ConfigurationAnnotations.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.collect.Iterables.consumingIterable;
+import static dagger.internal.codegen.base.ComponentAnnotation.subcomponentAnnotation;
+import static dagger.internal.codegen.base.ModuleAnnotation.moduleAnnotation;
+import static dagger.internal.codegen.base.MoreAnnotationMirrors.getTypeListValue;
+import static dagger.internal.codegen.binding.ComponentCreatorAnnotation.subcomponentCreatorAnnotations;
+import static dagger.internal.codegen.langmodel.DaggerElements.isAnyAnnotationPresent;
+import static javax.lang.model.util.ElementFilter.typesIn;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.MoreTypes;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Sets;
+import dagger.Component;
+import dagger.Module;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import java.lang.annotation.Annotation;
+import java.util.ArrayDeque;
+import java.util.List;
+import java.util.Optional;
+import java.util.Queue;
+import java.util.Set;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeMirror;
+
+/**
+ * Utility methods related to dagger configuration annotations (e.g.: {@link Component} and {@link
+ * Module}).
+ */
+public final class ConfigurationAnnotations {
+
+ public static Optional<TypeElement> getSubcomponentCreator(TypeElement subcomponent) {
+ checkArgument(subcomponentAnnotation(subcomponent).isPresent());
+ for (TypeElement nestedType : typesIn(subcomponent.getEnclosedElements())) {
+ if (isSubcomponentCreator(nestedType)) {
+ return Optional.of(nestedType);
+ }
+ }
+ return Optional.empty();
+ }
+
+ static boolean isSubcomponentCreator(Element element) {
+ return isAnyAnnotationPresent(element, subcomponentCreatorAnnotations());
+ }
+
+ // Dagger 1 support.
+ public static ImmutableList<TypeMirror> getModuleInjects(AnnotationMirror moduleAnnotation) {
+ checkNotNull(moduleAnnotation);
+ return getTypeListValue(moduleAnnotation, "injects");
+ }
+
+ /** Returns the first type that specifies this' nullability, or empty if none. */
+ public static Optional<DeclaredType> getNullableType(Element element) {
+ List<? extends AnnotationMirror> mirrors = element.getAnnotationMirrors();
+ for (AnnotationMirror mirror : mirrors) {
+ if (mirror.getAnnotationType().asElement().getSimpleName().contentEquals("Nullable")) {
+ return Optional.of(mirror.getAnnotationType());
+ }
+ }
+ return Optional.empty();
+ }
+
+ /**
+ * Returns the full set of modules transitively {@linkplain Module#includes included} from the
+ * given seed modules. If a module is malformed and a type listed in {@link Module#includes} is
+ * not annotated with {@link Module}, it is ignored.
+ *
+ * @deprecated Use {@link ComponentDescriptor#modules()}.
+ */
+ @Deprecated
+ public static ImmutableSet<TypeElement> getTransitiveModules(
+ DaggerTypes types, DaggerElements elements, Iterable<TypeElement> seedModules) {
+ TypeMirror objectType = elements.getTypeElement(Object.class).asType();
+ Queue<TypeElement> moduleQueue = new ArrayDeque<>();
+ Iterables.addAll(moduleQueue, seedModules);
+ Set<TypeElement> moduleElements = Sets.newLinkedHashSet();
+ for (TypeElement moduleElement : consumingIterable(moduleQueue)) {
+ moduleAnnotation(moduleElement)
+ .ifPresent(
+ moduleAnnotation -> {
+ ImmutableSet.Builder<TypeElement> moduleDependenciesBuilder =
+ ImmutableSet.builder();
+ moduleDependenciesBuilder.addAll(moduleAnnotation.includes());
+ // We don't recur on the parent class because we don't want the parent class as a
+ // root that the component depends on, and also because we want the dependencies
+ // rooted against this element, not the parent.
+ addIncludesFromSuperclasses(
+ types, moduleElement, moduleDependenciesBuilder, objectType);
+ ImmutableSet<TypeElement> moduleDependencies = moduleDependenciesBuilder.build();
+ moduleElements.add(moduleElement);
+ for (TypeElement dependencyType : moduleDependencies) {
+ if (!moduleElements.contains(dependencyType)) {
+ moduleQueue.add(dependencyType);
+ }
+ }
+ });
+ }
+ return ImmutableSet.copyOf(moduleElements);
+ }
+
+ /** Returns the enclosed types annotated with the given annotation. */
+ public static ImmutableList<DeclaredType> enclosedAnnotatedTypes(
+ TypeElement typeElement, Class<? extends Annotation> annotation) {
+ final ImmutableList.Builder<DeclaredType> builders = ImmutableList.builder();
+ for (TypeElement element : typesIn(typeElement.getEnclosedElements())) {
+ if (MoreElements.isAnnotationPresent(element, annotation)) {
+ builders.add(MoreTypes.asDeclared(element.asType()));
+ }
+ }
+ return builders.build();
+ }
+
+ /** Traverses includes from superclasses and adds them into the builder. */
+ private static void addIncludesFromSuperclasses(
+ DaggerTypes types,
+ TypeElement element,
+ ImmutableSet.Builder<TypeElement> builder,
+ TypeMirror objectType) {
+ // Also add the superclass to the queue, in case any @Module definitions were on that.
+ TypeMirror superclass = element.getSuperclass();
+ while (!types.isSameType(objectType, superclass)
+ && superclass.getKind().equals(TypeKind.DECLARED)) {
+ element = MoreElements.asType(types.asElement(superclass));
+ moduleAnnotation(element)
+ .ifPresent(moduleAnnotation -> builder.addAll(moduleAnnotation.includes()));
+ superclass = element.getSuperclass();
+ }
+ }
+
+ private ConfigurationAnnotations() {}
+}
diff --git a/java/dagger/internal/codegen/binding/ContributionBinding.java b/java/dagger/internal/codegen/binding/ContributionBinding.java
new file mode 100644
index 0000000..1942e8c
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/ContributionBinding.java
@@ -0,0 +1,207 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static dagger.internal.codegen.base.MoreAnnotationMirrors.unwrapOptionalEquivalence;
+import static dagger.internal.codegen.binding.ContributionBinding.FactoryCreationStrategy.CLASS_CONSTRUCTOR;
+import static dagger.internal.codegen.binding.ContributionBinding.FactoryCreationStrategy.DELEGATE;
+import static dagger.internal.codegen.binding.ContributionBinding.FactoryCreationStrategy.SINGLETON_INSTANCE;
+import static java.util.Arrays.asList;
+
+import com.google.auto.common.MoreElements;
+import com.google.common.base.Equivalence;
+import com.google.common.base.Preconditions;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.errorprone.annotations.CheckReturnValue;
+import dagger.internal.codegen.base.ContributionType;
+import dagger.internal.codegen.base.ContributionType.HasContributionType;
+import dagger.internal.codegen.base.MapType;
+import dagger.internal.codegen.base.SetType;
+import dagger.model.BindingKind;
+import dagger.model.DependencyRequest;
+import dagger.model.Key;
+import java.util.Optional;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeMirror;
+
+/**
+ * An abstract class for a value object representing the mechanism by which a {@link Key} can be
+ * contributed to a dependency graph.
+ */
+public abstract class ContributionBinding extends Binding implements HasContributionType {
+
+ /** Returns the type that specifies this' nullability, absent if not nullable. */
+ public abstract Optional<DeclaredType> nullableType();
+
+ public abstract Optional<Equivalence.Wrapper<AnnotationMirror>> wrappedMapKeyAnnotation();
+
+ public final Optional<AnnotationMirror> mapKeyAnnotation() {
+ return unwrapOptionalEquivalence(wrappedMapKeyAnnotation());
+ }
+
+ /** If {@link #bindingElement()} is a method that returns a primitive type, returns that type. */
+ public final Optional<TypeMirror> contributedPrimitiveType() {
+ return bindingElement()
+ .filter(bindingElement -> bindingElement instanceof ExecutableElement)
+ .map(bindingElement -> MoreElements.asExecutable(bindingElement).getReturnType())
+ .filter(type -> type.getKind().isPrimitive());
+ }
+
+ @Override
+ public boolean requiresModuleInstance() {
+ return !isContributingModuleKotlinObject().orElse(false) && super.requiresModuleInstance();
+ }
+
+ @Override
+ public final boolean isNullable() {
+ return nullableType().isPresent();
+ }
+
+ /**
+ * Returns {@code true} if the contributing module is a Kotlin object. Note that a companion
+ * object is also considered a Kotlin object.
+ */
+ abstract Optional<Boolean> isContributingModuleKotlinObject();
+
+ /** The strategy for getting an instance of a factory for a {@link ContributionBinding}. */
+ public enum FactoryCreationStrategy {
+ /** The factory class is a single instance. */
+ SINGLETON_INSTANCE,
+ /** The factory must be created by calling the constructor. */
+ CLASS_CONSTRUCTOR,
+ /** The factory is simply delegated to another. */
+ DELEGATE,
+ }
+
+ /**
+ * Returns the {@link FactoryCreationStrategy} appropriate for a binding.
+ *
+ * <p>Delegate bindings use the {@link FactoryCreationStrategy#DELEGATE} strategy.
+ *
+ * <p>Bindings without dependencies that don't require a module instance use the {@link
+ * FactoryCreationStrategy#SINGLETON_INSTANCE} strategy.
+ *
+ * <p>All other bindings use the {@link FactoryCreationStrategy#CLASS_CONSTRUCTOR} strategy.
+ */
+ public final FactoryCreationStrategy factoryCreationStrategy() {
+ switch (kind()) {
+ case DELEGATE:
+ return DELEGATE;
+ case PROVISION:
+ return dependencies().isEmpty() && !requiresModuleInstance()
+ ? SINGLETON_INSTANCE
+ : CLASS_CONSTRUCTOR;
+ case INJECTION:
+ case MULTIBOUND_SET:
+ case MULTIBOUND_MAP:
+ return dependencies().isEmpty() ? SINGLETON_INSTANCE : CLASS_CONSTRUCTOR;
+ default:
+ return CLASS_CONSTRUCTOR;
+ }
+ }
+
+ /**
+ * The {@link TypeMirror type} for the {@code Factory<T>} or {@code Producer<T>} which is created
+ * for this binding. Uses the binding's key, V in the case of {@code Map<K, FrameworkClass<V>>>},
+ * and E {@code Set<E>} for {@link dagger.multibindings.IntoSet @IntoSet} methods.
+ */
+ public final TypeMirror contributedType() {
+ switch (contributionType()) {
+ case MAP:
+ return MapType.from(key()).unwrappedFrameworkValueType();
+ case SET:
+ return SetType.from(key()).elementType();
+ case SET_VALUES:
+ case UNIQUE:
+ return key().type();
+ }
+ throw new AssertionError();
+ }
+
+ /**
+ * Returns {@link BindingKind#MULTIBOUND_SET} or {@link
+ * BindingKind#MULTIBOUND_MAP} if the key is a set or map.
+ *
+ * @throws IllegalArgumentException if {@code key} is neither a set nor a map
+ */
+ static BindingKind bindingKindForMultibindingKey(Key key) {
+ if (SetType.isSet(key)) {
+ return BindingKind.MULTIBOUND_SET;
+ } else if (MapType.isMap(key)) {
+ return BindingKind.MULTIBOUND_MAP;
+ } else {
+ throw new IllegalArgumentException(String.format("key is not for a set or map: %s", key));
+ }
+ }
+
+ public abstract Builder<?, ?> toBuilder();
+
+ /**
+ * Base builder for {@link com.google.auto.value.AutoValue @AutoValue} subclasses of {@link
+ * ContributionBinding}.
+ */
+ @CanIgnoreReturnValue
+ public abstract static class Builder<C extends ContributionBinding, B extends Builder<C, B>> {
+ public abstract B dependencies(Iterable<DependencyRequest> dependencies);
+
+ public B dependencies(DependencyRequest... dependencies) {
+ return dependencies(asList(dependencies));
+ }
+
+ public abstract B unresolved(C unresolved);
+
+ public abstract B contributionType(ContributionType contributionType);
+
+ public abstract B bindingElement(Element bindingElement);
+
+ abstract B bindingElement(Optional<Element> bindingElement);
+
+ public final B clearBindingElement() {
+ return bindingElement(Optional.empty());
+ };
+
+ abstract B contributingModule(TypeElement contributingModule);
+
+ abstract B isContributingModuleKotlinObject(boolean isModuleKotlinObject);
+
+ public abstract B key(Key key);
+
+ public abstract B nullableType(Optional<DeclaredType> nullableType);
+
+ abstract B wrappedMapKeyAnnotation(
+ Optional<Equivalence.Wrapper<AnnotationMirror>> wrappedMapKeyAnnotation);
+
+ public abstract B kind(BindingKind kind);
+
+ @CheckReturnValue
+ abstract C autoBuild();
+
+ @CheckReturnValue
+ public C build() {
+ C binding = autoBuild();
+ Preconditions.checkState(
+ binding.contributingModule().isPresent()
+ == binding.isContributingModuleKotlinObject().isPresent(),
+ "The contributionModule and isModuleKotlinObject must both be set together.");
+ return binding;
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/DelegateDeclaration.java b/java/dagger/internal/codegen/binding/DelegateDeclaration.java
new file mode 100644
index 0000000..b6c3c38
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/DelegateDeclaration.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static dagger.internal.codegen.base.MoreAnnotationMirrors.wrapOptionalInEquivalence;
+import static dagger.internal.codegen.binding.MapKeys.getMapKey;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.MoreTypes;
+import com.google.auto.value.AutoValue;
+import com.google.auto.value.extension.memoized.Memoized;
+import com.google.common.base.Equivalence;
+import com.google.common.collect.Iterables;
+import dagger.Binds;
+import dagger.internal.codegen.base.ContributionType;
+import dagger.internal.codegen.base.ContributionType.HasContributionType;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.DependencyRequest;
+import java.util.Optional;
+import javax.inject.Inject;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.ExecutableType;
+
+/** The declaration for a delegate binding established by a {@link Binds} method. */
+@AutoValue
+public abstract class DelegateDeclaration extends BindingDeclaration
+ implements HasContributionType {
+ abstract DependencyRequest delegateRequest();
+
+ abstract Optional<Equivalence.Wrapper<AnnotationMirror>> wrappedMapKey();
+
+ @Memoized
+ @Override
+ public abstract int hashCode();
+
+ @Override
+ public abstract boolean equals(Object obj);
+
+ /** A {@link DelegateDeclaration} factory. */
+ public static final class Factory {
+ private final DaggerTypes types;
+ private final KeyFactory keyFactory;
+ private final DependencyRequestFactory dependencyRequestFactory;
+
+ @Inject
+ Factory(
+ DaggerTypes types,
+ KeyFactory keyFactory,
+ DependencyRequestFactory dependencyRequestFactory) {
+ this.types = types;
+ this.keyFactory = keyFactory;
+ this.dependencyRequestFactory = dependencyRequestFactory;
+ }
+
+ public DelegateDeclaration create(
+ ExecutableElement bindsMethod, TypeElement contributingModule) {
+ checkArgument(MoreElements.isAnnotationPresent(bindsMethod, Binds.class));
+ ExecutableType resolvedMethod =
+ MoreTypes.asExecutable(
+ types.asMemberOf(MoreTypes.asDeclared(contributingModule.asType()), bindsMethod));
+ DependencyRequest delegateRequest =
+ dependencyRequestFactory.forRequiredResolvedVariable(
+ Iterables.getOnlyElement(bindsMethod.getParameters()),
+ Iterables.getOnlyElement(resolvedMethod.getParameterTypes()));
+ return new AutoValue_DelegateDeclaration(
+ ContributionType.fromBindingElement(bindsMethod),
+ keyFactory.forBindsMethod(bindsMethod, contributingModule),
+ Optional.<Element>of(bindsMethod),
+ Optional.of(contributingModule),
+ delegateRequest,
+ wrapOptionalInEquivalence(getMapKey(bindsMethod)));
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/DependencyEdgeImpl.java b/java/dagger/internal/codegen/binding/DependencyEdgeImpl.java
new file mode 100644
index 0000000..f11517e
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/DependencyEdgeImpl.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import dagger.internal.codegen.base.ElementFormatter;
+import dagger.model.BindingGraph.DependencyEdge;
+import dagger.model.DependencyRequest;
+
+/** An implementation of {@link DependencyEdge}. */
+final class DependencyEdgeImpl implements DependencyEdge {
+
+ private final DependencyRequest dependencyRequest;
+ private final boolean entryPoint;
+
+ DependencyEdgeImpl(DependencyRequest dependencyRequest, boolean entryPoint) {
+ this.dependencyRequest = dependencyRequest;
+ this.entryPoint = entryPoint;
+ }
+
+ @Override
+ public DependencyRequest dependencyRequest() {
+ return dependencyRequest;
+ }
+
+ @Override
+ public boolean isEntryPoint() {
+ return entryPoint;
+ }
+
+ @Override
+ public String toString() {
+ String string =
+ dependencyRequest
+ .requestElement()
+ .map(ElementFormatter::elementToString)
+ .orElseGet(
+ () ->
+ "synthetic request for "
+ + dependencyRequest.kind().format(dependencyRequest.key()));
+ return entryPoint ? string + " (entry point)" : string;
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/DependencyRequestFactory.java b/java/dagger/internal/codegen/binding/DependencyRequestFactory.java
new file mode 100644
index 0000000..707de4c
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/DependencyRequestFactory.java
@@ -0,0 +1,241 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.auto.common.MoreTypes.isTypeOf;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static dagger.internal.codegen.base.RequestKinds.extractKeyType;
+import static dagger.internal.codegen.base.RequestKinds.frameworkClass;
+import static dagger.internal.codegen.base.RequestKinds.getRequestKind;
+import static dagger.internal.codegen.binding.ConfigurationAnnotations.getNullableType;
+import static dagger.internal.codegen.langmodel.DaggerTypes.unwrapType;
+import static dagger.model.RequestKind.FUTURE;
+import static dagger.model.RequestKind.INSTANCE;
+import static dagger.model.RequestKind.MEMBERS_INJECTION;
+import static dagger.model.RequestKind.PRODUCER;
+import static dagger.model.RequestKind.PROVIDER;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.util.concurrent.ListenableFuture;
+import dagger.Lazy;
+import dagger.internal.codegen.base.MapType;
+import dagger.internal.codegen.base.OptionalType;
+import dagger.model.DependencyRequest;
+import dagger.model.Key;
+import dagger.model.RequestKind;
+import java.util.List;
+import java.util.Optional;
+import javax.inject.Inject;
+import javax.inject.Provider;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.ExecutableType;
+import javax.lang.model.type.TypeMirror;
+
+/**
+ * Factory for {@link DependencyRequest}s.
+ *
+ * <p>Any factory method may throw {@link TypeNotPresentException} if a type is not available, which
+ * may mean that the type will be generated in a later round of processing.
+ */
+public final class DependencyRequestFactory {
+ private final KeyFactory keyFactory;
+ private final InjectionAnnotations injectionAnnotations;
+
+ @Inject
+ DependencyRequestFactory(KeyFactory keyFactory, InjectionAnnotations injectionAnnotations) {
+ this.keyFactory = keyFactory;
+ this.injectionAnnotations = injectionAnnotations;
+ }
+
+ ImmutableSet<DependencyRequest> forRequiredResolvedVariables(
+ List<? extends VariableElement> variables, List<? extends TypeMirror> resolvedTypes) {
+ checkState(resolvedTypes.size() == variables.size());
+ ImmutableSet.Builder<DependencyRequest> builder = ImmutableSet.builder();
+ for (int i = 0; i < variables.size(); i++) {
+ builder.add(forRequiredResolvedVariable(variables.get(i), resolvedTypes.get(i)));
+ }
+ return builder.build();
+ }
+
+ /**
+ * Creates synthetic dependency requests for each individual multibinding contribution in {@code
+ * multibindingContributions}.
+ */
+ ImmutableSet<DependencyRequest> forMultibindingContributions(
+ Key multibindingKey, Iterable<ContributionBinding> multibindingContributions) {
+ ImmutableSet.Builder<DependencyRequest> requests = ImmutableSet.builder();
+ for (ContributionBinding multibindingContribution : multibindingContributions) {
+ requests.add(forMultibindingContribution(multibindingKey, multibindingContribution));
+ }
+ return requests.build();
+ }
+
+ /** Creates a synthetic dependency request for one individual {@code multibindingContribution}. */
+ private DependencyRequest forMultibindingContribution(
+ Key multibindingKey, ContributionBinding multibindingContribution) {
+ checkArgument(
+ multibindingContribution.key().multibindingContributionIdentifier().isPresent(),
+ "multibindingContribution's key must have a multibinding contribution identifier: %s",
+ multibindingContribution);
+ return DependencyRequest.builder()
+ .kind(multibindingContributionRequestKind(multibindingKey, multibindingContribution))
+ .key(multibindingContribution.key())
+ .build();
+ }
+
+ // TODO(b/28555349): support PROVIDER_OF_LAZY here too
+ private static final ImmutableSet<RequestKind> WRAPPING_MAP_VALUE_FRAMEWORK_TYPES =
+ ImmutableSet.of(PROVIDER, PRODUCER);
+
+ private RequestKind multibindingContributionRequestKind(
+ Key multibindingKey, ContributionBinding multibindingContribution) {
+ switch (multibindingContribution.contributionType()) {
+ case MAP:
+ MapType mapType = MapType.from(multibindingKey);
+ for (RequestKind kind : WRAPPING_MAP_VALUE_FRAMEWORK_TYPES) {
+ if (mapType.valuesAreTypeOf(frameworkClass(kind))) {
+ return kind;
+ }
+ }
+ // fall through
+ case SET:
+ case SET_VALUES:
+ return INSTANCE;
+ case UNIQUE:
+ throw new IllegalArgumentException(
+ "multibindingContribution must be a multibinding: " + multibindingContribution);
+ }
+ throw new AssertionError(multibindingContribution.toString());
+ }
+
+ DependencyRequest forRequiredResolvedVariable(
+ VariableElement variableElement, TypeMirror resolvedType) {
+ checkNotNull(variableElement);
+ checkNotNull(resolvedType);
+ // Ban @Assisted parameters, they are not considered dependency requests.
+ checkArgument(!AssistedInjectionAnnotations.isAssistedParameter(variableElement));
+ Optional<AnnotationMirror> qualifier = injectionAnnotations.getQualifier(variableElement);
+ return newDependencyRequest(variableElement, resolvedType, qualifier);
+ }
+
+ public DependencyRequest forComponentProvisionMethod(
+ ExecutableElement provisionMethod, ExecutableType provisionMethodType) {
+ checkNotNull(provisionMethod);
+ checkNotNull(provisionMethodType);
+ checkArgument(
+ provisionMethod.getParameters().isEmpty(),
+ "Component provision methods must be empty: %s",
+ provisionMethod);
+ Optional<AnnotationMirror> qualifier = injectionAnnotations.getQualifier(provisionMethod);
+ return newDependencyRequest(provisionMethod, provisionMethodType.getReturnType(), qualifier);
+ }
+
+ public DependencyRequest forComponentProductionMethod(
+ ExecutableElement productionMethod, ExecutableType productionMethodType) {
+ checkNotNull(productionMethod);
+ checkNotNull(productionMethodType);
+ checkArgument(
+ productionMethod.getParameters().isEmpty(),
+ "Component production methods must be empty: %s",
+ productionMethod);
+ TypeMirror type = productionMethodType.getReturnType();
+ Optional<AnnotationMirror> qualifier = injectionAnnotations.getQualifier(productionMethod);
+ // Only a component production method can be a request for a ListenableFuture, so we
+ // special-case it here.
+ if (isTypeOf(ListenableFuture.class, type)) {
+ return DependencyRequest.builder()
+ .kind(FUTURE)
+ .key(keyFactory.forQualifiedType(qualifier, unwrapType(type)))
+ .requestElement(productionMethod)
+ .build();
+ } else {
+ return newDependencyRequest(productionMethod, type, qualifier);
+ }
+ }
+
+ DependencyRequest forComponentMembersInjectionMethod(
+ ExecutableElement membersInjectionMethod, ExecutableType membersInjectionMethodType) {
+ checkNotNull(membersInjectionMethod);
+ checkNotNull(membersInjectionMethodType);
+ Optional<AnnotationMirror> qualifier =
+ injectionAnnotations.getQualifier(membersInjectionMethod);
+ checkArgument(!qualifier.isPresent());
+ TypeMirror membersInjectedType = getOnlyElement(membersInjectionMethodType.getParameterTypes());
+ return DependencyRequest.builder()
+ .kind(MEMBERS_INJECTION)
+ .key(keyFactory.forMembersInjectedType(membersInjectedType))
+ .requestElement(membersInjectionMethod)
+ .build();
+ }
+
+ DependencyRequest forProductionImplementationExecutor() {
+ return DependencyRequest.builder()
+ .kind(PROVIDER)
+ .key(keyFactory.forProductionImplementationExecutor())
+ .build();
+ }
+
+ DependencyRequest forProductionComponentMonitor() {
+ return DependencyRequest.builder()
+ .kind(PROVIDER)
+ .key(keyFactory.forProductionComponentMonitor())
+ .build();
+ }
+
+ /**
+ * Returns a synthetic request for the present value of an optional binding generated from a
+ * {@link dagger.BindsOptionalOf} declaration.
+ */
+ DependencyRequest forSyntheticPresentOptionalBinding(Key requestKey, RequestKind kind) {
+ Optional<Key> key = keyFactory.unwrapOptional(requestKey);
+ checkArgument(key.isPresent(), "not a request for optional: %s", requestKey);
+ return DependencyRequest.builder()
+ .kind(kind)
+ .key(key.get())
+ .isNullable(
+ allowsNull(getRequestKind(OptionalType.from(requestKey).valueType()), Optional.empty()))
+ .build();
+ }
+
+ private DependencyRequest newDependencyRequest(
+ Element requestElement, TypeMirror type, Optional<AnnotationMirror> qualifier) {
+ RequestKind requestKind = getRequestKind(type);
+ return DependencyRequest.builder()
+ .kind(requestKind)
+ .key(keyFactory.forQualifiedType(qualifier, extractKeyType(type)))
+ .requestElement(requestElement)
+ .isNullable(allowsNull(requestKind, getNullableType(requestElement)))
+ .build();
+ }
+
+ /**
+ * Returns {@code true} if a given request element allows null values. {@link
+ * RequestKind#INSTANCE} requests must be annotated with {@code @Nullable} in order to allow null
+ * values. All other request kinds implicitly allow null values because they are are wrapped
+ * inside {@link Provider}, {@link Lazy}, etc.
+ */
+ private boolean allowsNull(RequestKind kind, Optional<DeclaredType> nullableType) {
+ return nullableType.isPresent() || !kind.equals(INSTANCE);
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/DependencyRequestFormatter.java b/java/dagger/internal/codegen/binding/DependencyRequestFormatter.java
new file mode 100644
index 0000000..888dec2
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/DependencyRequestFormatter.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static dagger.internal.codegen.base.ElementFormatter.elementToString;
+import static dagger.internal.codegen.base.RequestKinds.requestType;
+
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import dagger.Provides;
+import dagger.internal.codegen.base.Formatter;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.DependencyRequest;
+import dagger.producers.Produces;
+import java.util.Optional;
+import javax.inject.Inject;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementVisitor;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.ElementKindVisitor8;
+
+/**
+ * Formats a {@link DependencyRequest} into a {@link String} suitable for an error message listing a
+ * chain of dependencies.
+ *
+ * <dl>
+ * <dt>For component provision methods
+ * <dd>{@code @Qualifier SomeType is provided at\n ComponentType.method()}
+ * <dt>For component injection methods
+ * <dd>{@code SomeType is injected at\n ComponentType.method(foo)}
+ * <dt>For parameters to {@link Provides @Provides}, {@link Produces @Produces}, or {@link
+ * Inject @Inject} methods:
+ * <dd>{@code @Qualified ResolvedType is injected at\n EnclosingType.method([…, ]param[, …])}
+ * <dt>For parameters to {@link Inject @Inject} constructors:
+ * <dd>{@code @Qualified ResolvedType is injected at\n EnclosingType([…, ]param[, …])}
+ * <dt>For {@link Inject @Inject} fields:
+ * <dd>{@code @Qualified ResolvedType is injected at\n EnclosingType.field}
+ * </dl>
+ */
+public final class DependencyRequestFormatter extends Formatter<DependencyRequest> {
+
+ private final DaggerTypes types;
+
+ @Inject
+ DependencyRequestFormatter(DaggerTypes types) {
+ this.types = types;
+ }
+
+ @Override
+ public String format(DependencyRequest request) {
+ return request
+ .requestElement()
+ .map(element -> element.accept(formatVisitor, request))
+ .orElse("");
+ }
+
+ /**
+ * Appends a newline and the formatted dependency request unless {@link
+ * #format(DependencyRequest)} returns the empty string.
+ */
+ @CanIgnoreReturnValue
+ public StringBuilder appendFormatLine(
+ StringBuilder builder, DependencyRequest dependencyRequest) {
+ String formatted = format(dependencyRequest);
+ if (!formatted.isEmpty()) {
+ builder.append('\n').append(formatted);
+ }
+ return builder;
+ }
+
+ private final ElementVisitor<String, DependencyRequest> formatVisitor =
+ new ElementKindVisitor8<String, DependencyRequest>() {
+
+ @Override
+ public String visitExecutableAsMethod(ExecutableElement method, DependencyRequest request) {
+ return INDENT
+ + request.key()
+ + " is "
+ + componentMethodRequestVerb(request)
+ + " at\n"
+ + DOUBLE_INDENT
+ + elementToString(method);
+ }
+
+ @Override
+ public String visitVariable(VariableElement variable, DependencyRequest request) {
+ TypeMirror requestedType = requestType(request.kind(), request.key().type(), types);
+ return INDENT
+ + formatQualifier(request.key().qualifier())
+ + requestedType
+ + " is injected at\n"
+ + DOUBLE_INDENT
+ + elementToString(variable);
+ }
+
+ @Override
+ public String visitType(TypeElement e, DependencyRequest request) {
+ return ""; // types by themselves provide no useful information.
+ }
+
+ @Override
+ protected String defaultAction(Element element, DependencyRequest request) {
+ throw new IllegalStateException(
+ "Invalid request " + element.getKind() + " element " + element);
+ }
+ };
+
+ private String formatQualifier(Optional<AnnotationMirror> maybeQualifier) {
+ return maybeQualifier.map(qualifier -> qualifier + " ").orElse("");
+ }
+
+ /**
+ * Returns the verb for a component method dependency request. Returns "produced", "provided", or
+ * "injected", depending on the kind of request.
+ */
+ private String componentMethodRequestVerb(DependencyRequest request) {
+ switch (request.kind()) {
+ case FUTURE:
+ case PRODUCER:
+ case INSTANCE:
+ case LAZY:
+ case PROVIDER:
+ case PROVIDER_OF_LAZY:
+ return "requested";
+
+ case MEMBERS_INJECTION:
+ return "injected";
+
+ case PRODUCED:
+ break;
+ }
+ throw new AssertionError("illegal request kind for method: " + request);
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/DependencyVariableNamer.java b/java/dagger/internal/codegen/binding/DependencyVariableNamer.java
new file mode 100644
index 0000000..e01d22e
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/DependencyVariableNamer.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static dagger.internal.codegen.binding.SourceFiles.simpleVariableName;
+
+import com.google.auto.common.MoreTypes;
+import com.google.common.base.Ascii;
+import com.google.common.base.CaseFormat;
+import dagger.Lazy;
+import dagger.model.DependencyRequest;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import javax.inject.Provider;
+
+/**
+ * Picks a reasonable name for what we think is being provided from the variable name associated
+ * with the {@link DependencyRequest}. I.e. strips out words like "lazy" and "provider" if we
+ * believe that those refer to {@link Lazy} and {@link Provider} rather than the type being
+ * provided.
+ */
+//TODO(gak): develop the heuristics to get better names
+final class DependencyVariableNamer {
+ private static final Pattern LAZY_PROVIDER_PATTERN = Pattern.compile("lazy(\\w+)Provider");
+
+ static String name(DependencyRequest dependency) {
+ if (!dependency.requestElement().isPresent()) {
+ return simpleVariableName(MoreTypes.asTypeElement(dependency.key().type()));
+ }
+
+ String variableName = dependency.requestElement().get().getSimpleName().toString();
+ if (Ascii.isUpperCase(variableName.charAt(0))) {
+ variableName = toLowerCamel(variableName);
+ }
+ switch (dependency.kind()) {
+ case INSTANCE:
+ return variableName;
+ case LAZY:
+ return variableName.startsWith("lazy") && !variableName.equals("lazy")
+ ? toLowerCamel(variableName.substring(4))
+ : variableName;
+ case PROVIDER_OF_LAZY:
+ Matcher matcher = LAZY_PROVIDER_PATTERN.matcher(variableName);
+ if (matcher.matches()) {
+ return toLowerCamel(matcher.group(1));
+ }
+ // fall through
+ case PROVIDER:
+ return variableName.endsWith("Provider") && !variableName.equals("Provider")
+ ? variableName.substring(0, variableName.length() - 8)
+ : variableName;
+ case PRODUCED:
+ return variableName.startsWith("produced") && !variableName.equals("produced")
+ ? toLowerCamel(variableName.substring(8))
+ : variableName;
+ case PRODUCER:
+ return variableName.endsWith("Producer") && !variableName.equals("Producer")
+ ? variableName.substring(0, variableName.length() - 8)
+ : variableName;
+ default:
+ throw new AssertionError();
+ }
+ }
+
+ private static String toLowerCamel(String name) {
+ return CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL, name);
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/ErrorMessages.java b/java/dagger/internal/codegen/binding/ErrorMessages.java
new file mode 100644
index 0000000..8962ade
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/ErrorMessages.java
@@ -0,0 +1,358 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import com.google.common.base.Joiner;
+import com.google.common.collect.ImmutableMap;
+import dagger.internal.codegen.base.ComponentAnnotation;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.function.UnaryOperator;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeMirror;
+
+/** The collection of error messages to be reported back to users. */
+public final class ErrorMessages {
+
+ private static final UnaryOperator<String> PRODUCTION =
+ s ->
+ s.replace("component", "production component")
+ .replace("Component", "ProductionComponent");
+
+ private static final UnaryOperator<String> SUBCOMPONENT =
+ s -> s.replace("component", "subcomponent").replace("Component", "Subcomponent");
+
+ private static final UnaryOperator<String> FACTORY = s -> s.replace("Builder", "Factory");
+
+ private static final ImmutableMap<ComponentKind, Function<String, String>>
+ COMPONENT_TRANSFORMATIONS =
+ ImmutableMap.of(
+ ComponentKind.COMPONENT, UnaryOperator.identity(),
+ ComponentKind.SUBCOMPONENT, SUBCOMPONENT,
+ ComponentKind.PRODUCTION_COMPONENT, PRODUCTION,
+ ComponentKind.PRODUCTION_SUBCOMPONENT, PRODUCTION.andThen(SUBCOMPONENT));
+
+ public static ComponentMessages componentMessagesFor(ComponentKind componentKind) {
+ return new ComponentMessages(COMPONENT_TRANSFORMATIONS.get(componentKind));
+ }
+
+ public static ComponentMessages componentMessagesFor(ComponentAnnotation componentAnnotation) {
+ return new ComponentMessages(
+ transformation(componentAnnotation.isProduction(), componentAnnotation.isSubcomponent()));
+ }
+
+ public static ComponentCreatorMessages creatorMessagesFor(
+ ComponentCreatorAnnotation creatorAnnotation) {
+ Function<String, String> transformation =
+ transformation(
+ creatorAnnotation.isProductionCreatorAnnotation(),
+ creatorAnnotation.isSubcomponentCreatorAnnotation());
+ switch (creatorAnnotation.creatorKind()) {
+ case BUILDER:
+ return new BuilderMessages(transformation);
+ case FACTORY:
+ return new FactoryMessages(transformation);
+ }
+ throw new AssertionError(creatorAnnotation);
+ }
+
+ private static Function<String, String> transformation(
+ boolean isProduction, boolean isSubcomponent) {
+ Function<String, String> transformation = isProduction ? PRODUCTION : UnaryOperator.identity();
+ return isSubcomponent ? transformation.andThen(SUBCOMPONENT) : transformation;
+ }
+
+ private abstract static class Messages {
+ private final Function<String, String> transformation;
+
+ Messages(Function<String, String> transformation) {
+ this.transformation = transformation;
+ }
+
+ protected final String process(String s) {
+ return transformation.apply(s);
+ }
+ }
+
+ /** Errors for components. */
+ public static final class ComponentMessages extends Messages {
+ ComponentMessages(Function<String, String> transformation) {
+ super(transformation);
+ }
+
+ public final String moreThanOne() {
+ return process("@Component has more than one @Component.Builder or @Component.Factory: %s");
+ }
+ }
+
+ /** Errors for component creators. */
+ public abstract static class ComponentCreatorMessages extends Messages {
+ ComponentCreatorMessages(Function<String, String> transformation) {
+ super(transformation);
+ }
+
+ public static String builderMethodRequiresNoArgs() {
+ return "Methods returning a @Component.Builder must have no arguments";
+ }
+
+ public static String moreThanOneRefToSubcomponent() {
+ return "Only one method can create a given subcomponent. %s is created by: %s";
+ }
+
+ public final String invalidConstructor() {
+ return process("@Component.Builder classes must have exactly one constructor,"
+ + " and it must not be private or have any parameters");
+ }
+
+ public final String generics() {
+ return process("@Component.Builder types must not have any generic types");
+ }
+
+ public final String mustBeInComponent() {
+ return process("@Component.Builder types must be nested within a @Component");
+ }
+
+ public final String mustBeClassOrInterface() {
+ return process("@Component.Builder types must be abstract classes or interfaces");
+ }
+
+ public final String isPrivate() {
+ return process("@Component.Builder types must not be private");
+ }
+
+ public final String mustBeStatic() {
+ return process("@Component.Builder types must be static");
+ }
+
+ public final String mustBeAbstract() {
+ return process("@Component.Builder types must be abstract");
+ }
+
+ public abstract String missingFactoryMethod();
+
+ public abstract String multipleSettersForModuleOrDependencyType();
+
+ public abstract String extraSetters();
+
+ public abstract String missingSetters();
+
+ public abstract String twoFactoryMethods();
+
+ public abstract String inheritedTwoFactoryMethods();
+
+ public abstract String factoryMethodMustReturnComponentType();
+
+ public final String inheritedFactoryMethodMustReturnComponentType() {
+ return factoryMethodMustReturnComponentType() + ". Inherited method: %s";
+ }
+
+ public abstract String factoryMethodMayNotBeAnnotatedWithBindsInstance();
+
+ public final String inheritedFactoryMethodMayNotBeAnnotatedWithBindsInstance() {
+ return factoryMethodMayNotBeAnnotatedWithBindsInstance() + ". Inherited method: %s";
+ }
+
+ public final String setterMethodsMustTakeOneArg() {
+ return process("@Component.Builder methods must not have more than one argument");
+ }
+
+ public final String inheritedSetterMethodsMustTakeOneArg() {
+ return setterMethodsMustTakeOneArg() + ". Inherited method: %s";
+ }
+
+ public final String setterMethodsMustReturnVoidOrBuilder() {
+ return process("@Component.Builder setter methods must return void, the builder,"
+ + " or a supertype of the builder");
+ }
+
+ public final String inheritedSetterMethodsMustReturnVoidOrBuilder() {
+ return setterMethodsMustReturnVoidOrBuilder() + ". Inherited method: %s";
+ }
+
+ public final String methodsMayNotHaveTypeParameters() {
+ return process("@Component.Builder methods must not have type parameters");
+ }
+
+ public final String inheritedMethodsMayNotHaveTypeParameters() {
+ return methodsMayNotHaveTypeParameters() + ". Inherited method: %s";
+ }
+
+ public abstract String nonBindsInstanceParametersMayNotBePrimitives();
+
+ public final String inheritedNonBindsInstanceParametersMayNotBePrimitives() {
+ return nonBindsInstanceParametersMayNotBePrimitives() + ". Inherited method: %s";
+ }
+
+ public final String factoryMethodReturnsSupertypeWithMissingMethods(
+ TypeElement component,
+ TypeElement componentBuilder,
+ TypeMirror returnType,
+ ExecutableElement buildMethod,
+ Set<ExecutableElement> additionalMethods) {
+ return String.format(
+ "%1$s.%2$s() returns %3$s, but %4$s declares additional component method(s): %5$s. In "
+ + "order to provide type-safe access to these methods, override %2$s() to return "
+ + "%4$s",
+ componentBuilder.getQualifiedName(),
+ buildMethod.getSimpleName(),
+ returnType,
+ component.getQualifiedName(),
+ Joiner.on(", ").join(additionalMethods));
+ }
+
+ public final String bindsInstanceNotAllowedOnBothSetterMethodAndParameter() {
+ return process("@Component.Builder setter methods may not have @BindsInstance on both the "
+ + "method and its parameter; choose one or the other");
+ }
+
+ public final String inheritedBindsInstanceNotAllowedOnBothSetterMethodAndParameter() {
+ return bindsInstanceNotAllowedOnBothSetterMethodAndParameter() + ". Inherited method: %s";
+ }
+ }
+
+ private static final class BuilderMessages extends ComponentCreatorMessages {
+ BuilderMessages(Function<String, String> transformation) {
+ super(transformation);
+ }
+
+ @Override
+ public String missingFactoryMethod() {
+ return process(
+ "@Component.Builder types must have exactly one no-args method that "
+ + " returns the @Component type");
+ }
+
+ @Override
+ public String multipleSettersForModuleOrDependencyType() {
+ return process(
+ "@Component.Builder types must not have more than one setter method per module or "
+ + "dependency, but %s is set by %s");
+ }
+
+ @Override
+ public String extraSetters() {
+ return process(
+ "@Component.Builder has setters for modules or components that aren't required: %s");
+ }
+
+ @Override
+ public String missingSetters() {
+ return process(
+ "@Component.Builder is missing setters for required modules or components: %s");
+ }
+
+ @Override
+ public String twoFactoryMethods() {
+ return process(
+ "@Component.Builder types must have exactly one zero-arg method, and that"
+ + " method must return the @Component type. Already found: %s");
+ }
+
+ @Override
+ public String inheritedTwoFactoryMethods() {
+ return process(
+ "@Component.Builder types must have exactly one zero-arg method, and that"
+ + " method must return the @Component type. Found %s and %s");
+ }
+
+ @Override
+ public String factoryMethodMustReturnComponentType() {
+ return process(
+ "@Component.Builder methods that have no arguments must return the @Component type or a "
+ + "supertype of the @Component");
+ }
+
+ @Override
+ public String factoryMethodMayNotBeAnnotatedWithBindsInstance() {
+ return process(
+ "@Component.Builder no-arg build methods may not be annotated with @BindsInstance");
+ }
+
+ @Override
+ public String nonBindsInstanceParametersMayNotBePrimitives() {
+ return process(
+ "@Component.Builder methods that are not annotated with @BindsInstance "
+ + "must take either a module or a component dependency, not a primitive");
+ }
+ }
+
+ private static final class FactoryMessages extends ComponentCreatorMessages {
+ FactoryMessages(Function<String, String> transformation) {
+ super(transformation.andThen(FACTORY));
+ }
+
+ @Override
+ public String missingFactoryMethod() {
+ return process(
+ "@Component.Factory types must have exactly one method that "
+ + "returns the @Component type");
+ }
+
+ @Override
+ public String multipleSettersForModuleOrDependencyType() {
+ return process(
+ "@Component.Factory methods must not have more than one parameter per module or "
+ + "dependency, but %s is set by %s");
+ }
+
+ @Override
+ public String extraSetters() {
+ return process(
+ "@Component.Factory method has parameters for modules or components that aren't "
+ + "required: %s");
+ }
+
+ @Override
+ public String missingSetters() {
+ return process(
+ "@Component.Factory method is missing parameters for required modules or components: %s");
+ }
+
+ @Override
+ public String twoFactoryMethods() {
+ return process(
+ "@Component.Factory types must have exactly one abstract method. Already found: %s");
+ }
+
+ @Override
+ public String inheritedTwoFactoryMethods() {
+ return twoFactoryMethods();
+ }
+
+ @Override
+ public String factoryMethodMustReturnComponentType() {
+ return process(
+ "@Component.Factory abstract methods must return the @Component type or a "
+ + "supertype of the @Component");
+ }
+
+ @Override
+ public String factoryMethodMayNotBeAnnotatedWithBindsInstance() {
+ return process("@Component.Factory method may not be annotated with @BindsInstance");
+ }
+
+ @Override
+ public String nonBindsInstanceParametersMayNotBePrimitives() {
+ return process(
+ "@Component.Factory method parameters that are not annotated with @BindsInstance "
+ + "must be either a module or a component dependency, not a primitive");
+ }
+ }
+
+ private ErrorMessages() {}
+}
diff --git a/java/dagger/internal/codegen/binding/FrameworkField.java b/java/dagger/internal/codegen/binding/FrameworkField.java
new file mode 100644
index 0000000..3b0b73f
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/FrameworkField.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static dagger.model.BindingKind.MEMBERS_INJECTOR;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.base.CaseFormat;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.ParameterizedTypeName;
+import com.squareup.javapoet.TypeName;
+import java.util.Optional;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementVisitor;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.ElementKindVisitor8;
+
+/**
+ * A value object that represents a field in the generated Component class.
+ *
+ * <p>Examples:
+ *
+ * <ul>
+ * <li>{@code Provider<String>}
+ * <li>{@code Producer<Widget>}
+ * <li>{@code Provider<Map<SomeMapKey, MapValue>>}.
+ * </ul>
+ */
+@AutoValue
+public abstract class FrameworkField {
+
+ /**
+ * Creates a framework field.
+ *
+ * @param frameworkClassName the name of the framework class (e.g., {@link javax.inject.Provider})
+ * @param valueTypeName the name of the type parameter of the framework class (e.g., {@code Foo}
+ * for {@code Provider<Foo>}
+ * @param fieldName the name of the field
+ */
+ public static FrameworkField create(
+ ClassName frameworkClassName, TypeName valueTypeName, String fieldName) {
+ String suffix = frameworkClassName.simpleName();
+ return new AutoValue_FrameworkField(
+ ParameterizedTypeName.get(frameworkClassName, valueTypeName),
+ fieldName.endsWith(suffix) ? fieldName : fieldName + suffix);
+ }
+
+ /**
+ * A framework field for a {@link ContributionBinding}.
+ *
+ * @param frameworkClass if present, the field will use this framework class instead of the normal
+ * one for the binding's type.
+ */
+ public static FrameworkField forBinding(
+ ContributionBinding binding, Optional<ClassName> frameworkClass) {
+ return create(
+ frameworkClass.orElse(
+ ClassName.get(
+ FrameworkType.forBindingType(binding.bindingType()).frameworkClass())),
+ TypeName.get(fieldValueType(binding)),
+ frameworkFieldName(binding));
+ }
+
+ private static TypeMirror fieldValueType(ContributionBinding binding) {
+ return binding.contributionType().isMultibinding()
+ ? binding.contributedType()
+ : binding.key().type();
+ }
+
+ private static String frameworkFieldName(ContributionBinding binding) {
+ if (binding.bindingElement().isPresent()) {
+ String name = BINDING_ELEMENT_NAME.visit(binding.bindingElement().get(), binding);
+ return binding.kind().equals(MEMBERS_INJECTOR) ? name + "MembersInjector" : name;
+ }
+ return KeyVariableNamer.name(binding.key());
+ }
+
+ private static final ElementVisitor<String, Binding> BINDING_ELEMENT_NAME =
+ new ElementKindVisitor8<String, Binding>() {
+
+ @Override
+ protected String defaultAction(Element e, Binding p) {
+ throw new IllegalArgumentException("Unexpected binding " + p);
+ }
+
+ @Override
+ public String visitExecutableAsConstructor(ExecutableElement e, Binding p) {
+ return visit(e.getEnclosingElement(), p);
+ }
+
+ @Override
+ public String visitExecutableAsMethod(ExecutableElement e, Binding p) {
+ return e.getSimpleName().toString();
+ }
+
+ @Override
+ public String visitType(TypeElement e, Binding p) {
+ return CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL, e.getSimpleName().toString());
+ }
+
+ @Override
+ public String visitVariableAsParameter(VariableElement e, Binding p) {
+ return e.getSimpleName().toString();
+ }
+ };
+
+ public abstract ParameterizedTypeName type();
+
+ public abstract String name();
+}
diff --git a/java/dagger/internal/codegen/binding/FrameworkType.java b/java/dagger/internal/codegen/binding/FrameworkType.java
new file mode 100644
index 0000000..6b160b6
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/FrameworkType.java
@@ -0,0 +1,223 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.common.base.CaseFormat.UPPER_CAMEL;
+import static com.google.common.base.CaseFormat.UPPER_UNDERSCORE;
+import static dagger.model.RequestKind.INSTANCE;
+
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.ParameterizedTypeName;
+import com.squareup.javapoet.TypeName;
+import dagger.Lazy;
+import dagger.internal.DoubleCheck;
+import dagger.internal.ProviderOfLazy;
+import dagger.internal.codegen.base.RequestKinds;
+import dagger.internal.codegen.javapoet.Expression;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.DependencyRequest;
+import dagger.model.RequestKind;
+import dagger.producers.Produced;
+import dagger.producers.Producer;
+import dagger.producers.internal.Producers;
+import java.util.Optional;
+import javax.inject.Provider;
+import javax.lang.model.type.TypeMirror;
+
+/** One of the core types initialized as fields in a generated component. */
+public enum FrameworkType {
+ /** A {@link Provider}. */
+ PROVIDER {
+ @Override
+ public Class<?> frameworkClass() {
+ return Provider.class;
+ }
+
+ @Override
+ public Optional<RequestKind> requestKind() {
+ return Optional.of(RequestKind.PROVIDER);
+ }
+
+ @Override
+ public CodeBlock to(RequestKind requestKind, CodeBlock from) {
+ switch (requestKind) {
+ case INSTANCE:
+ return CodeBlock.of("$L.get()", from);
+
+ case LAZY:
+ return CodeBlock.of("$T.lazy($L)", DoubleCheck.class, from);
+
+ case PROVIDER:
+ return from;
+
+ case PROVIDER_OF_LAZY:
+ return CodeBlock.of("$T.create($L)", ProviderOfLazy.class, from);
+
+ case PRODUCER:
+ return CodeBlock.of("$T.producerFromProvider($L)", Producers.class, from);
+
+ case FUTURE:
+ return CodeBlock.of("$T.immediateFuture($L)", Futures.class, to(INSTANCE, from));
+
+ case PRODUCED:
+ return CodeBlock.of("$T.successful($L)", Produced.class, to(INSTANCE, from));
+
+ default:
+ throw new IllegalArgumentException(
+ String.format("Cannot request a %s from a %s", requestKind, this));
+ }
+ }
+
+ @Override
+ public Expression to(RequestKind requestKind, Expression from, DaggerTypes types) {
+ CodeBlock codeBlock = to(requestKind, from.codeBlock());
+ switch (requestKind) {
+ case INSTANCE:
+ return Expression.create(types.unwrapTypeOrObject(from.type()), codeBlock);
+
+ case PROVIDER:
+ return from;
+
+ case PROVIDER_OF_LAZY:
+ TypeMirror lazyType = types.rewrapType(from.type(), Lazy.class);
+ return Expression.create(types.wrapType(lazyType, Provider.class), codeBlock);
+
+ case FUTURE:
+ return Expression.create(
+ types.rewrapType(from.type(), ListenableFuture.class), codeBlock);
+
+ default:
+ return Expression.create(
+ types.rewrapType(from.type(), RequestKinds.frameworkClass(requestKind)), codeBlock);
+ }
+ }
+ },
+
+ /** A {@link Producer}. */
+ PRODUCER_NODE {
+ @Override
+ public Class<?> frameworkClass() {
+ // TODO(cgdecker): Replace this with new class for representing internal producer nodes.
+ // Currently the new class is CancellableProducer, but it may be changed to ProducerNode and
+ // made to not implement Producer.
+ return Producer.class;
+ }
+
+ @Override
+ public Optional<RequestKind> requestKind() {
+ return Optional.empty();
+ }
+
+ @Override
+ public CodeBlock to(RequestKind requestKind, CodeBlock from) {
+ switch (requestKind) {
+ case FUTURE:
+ return CodeBlock.of("$L.get()", from);
+
+ case PRODUCER:
+ return from;
+
+ default:
+ throw new IllegalArgumentException(
+ String.format("Cannot request a %s from a %s", requestKind, this));
+ }
+ }
+
+ @Override
+ public Expression to(RequestKind requestKind, Expression from, DaggerTypes types) {
+ switch (requestKind) {
+ case FUTURE:
+ return Expression.create(
+ types.rewrapType(from.type(), ListenableFuture.class),
+ to(requestKind, from.codeBlock()));
+
+ case PRODUCER:
+ return Expression.create(from.type(), to(requestKind, from.codeBlock()));
+
+ default:
+ throw new IllegalArgumentException(
+ String.format("Cannot request a %s from a %s", requestKind, this));
+ }
+ }
+ },
+ ;
+
+ /** Returns the framework type appropriate for fields for a given binding type. */
+ public static FrameworkType forBindingType(BindingType bindingType) {
+ switch (bindingType) {
+ case PROVISION:
+ return PROVIDER;
+ case PRODUCTION:
+ return PRODUCER_NODE;
+ case MEMBERS_INJECTION:
+ }
+ throw new AssertionError(bindingType);
+ }
+
+ /** Returns the framework type that exactly matches the given request kind, if one exists. */
+ public static Optional<FrameworkType> forRequestKind(RequestKind requestKind) {
+ switch (requestKind) {
+ case PROVIDER:
+ return Optional.of(FrameworkType.PROVIDER);
+ default:
+ return Optional.empty();
+ }
+ }
+
+ /** The class of fields of this type. */
+ public abstract Class<?> frameworkClass();
+
+ /** Returns the {@link #frameworkClass()} parameterized with a type. */
+ public ParameterizedTypeName frameworkClassOf(TypeName valueType) {
+ return ParameterizedTypeName.get(ClassName.get(frameworkClass()), valueType);
+ }
+
+ /** The request kind that an instance of this framework type can satisfy directly, if any. */
+ public abstract Optional<RequestKind> requestKind();
+
+ /**
+ * Returns a {@link CodeBlock} that evaluates to a requested object given an expression that
+ * evaluates to an instance of this framework type.
+ *
+ * @param requestKind the kind of {@link DependencyRequest} that the returned expression can
+ * satisfy
+ * @param from a {@link CodeBlock} that evaluates to an instance of this framework type
+ * @throws IllegalArgumentException if a valid expression cannot be generated for {@code
+ * requestKind}
+ */
+ public abstract CodeBlock to(RequestKind requestKind, CodeBlock from);
+
+ /**
+ * Returns an {@link Expression} that evaluates to a requested object given an expression that
+ * evaluates to an instance of this framework type.
+ *
+ * @param requestKind the kind of {@link DependencyRequest} that the returned expression can
+ * satisfy
+ * @param from an expression that evaluates to an instance of this framework type
+ * @throws IllegalArgumentException if a valid expression cannot be generated for {@code
+ * requestKind}
+ */
+ public abstract Expression to(RequestKind requestKind, Expression from, DaggerTypes types);
+
+ @Override
+ public String toString() {
+ return UPPER_UNDERSCORE.to(UPPER_CAMEL, super.toString());
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/FrameworkTypeMapper.java b/java/dagger/internal/codegen/binding/FrameworkTypeMapper.java
new file mode 100644
index 0000000..85463af
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/FrameworkTypeMapper.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static dagger.internal.codegen.binding.BindingType.PRODUCTION;
+
+import dagger.model.RequestKind;
+import dagger.producers.Producer;
+import javax.inject.Provider;
+
+/**
+ * A mapper for associating a {@link RequestKind} to a {@link FrameworkType}, dependent on the type
+ * of code to be generated (e.g., for {@link Provider} or {@link Producer}).
+ */
+public enum FrameworkTypeMapper {
+ FOR_PROVIDER() {
+ @Override
+ public FrameworkType getFrameworkType(RequestKind requestKind) {
+ switch (requestKind) {
+ case INSTANCE:
+ case PROVIDER:
+ case PROVIDER_OF_LAZY:
+ case LAZY:
+ return FrameworkType.PROVIDER;
+ case PRODUCED:
+ case PRODUCER:
+ throw new IllegalArgumentException(requestKind.toString());
+ default:
+ throw new AssertionError(requestKind);
+ }
+ }
+ },
+ FOR_PRODUCER() {
+ @Override
+ public FrameworkType getFrameworkType(RequestKind requestKind) {
+ switch (requestKind) {
+ case INSTANCE:
+ case PRODUCED:
+ case PRODUCER:
+ return FrameworkType.PRODUCER_NODE;
+ case PROVIDER:
+ case PROVIDER_OF_LAZY:
+ case LAZY:
+ return FrameworkType.PROVIDER;
+ default:
+ throw new AssertionError(requestKind);
+ }
+ }
+ };
+
+ public static FrameworkTypeMapper forBindingType(BindingType bindingType) {
+ return bindingType.equals(PRODUCTION) ? FOR_PRODUCER : FOR_PROVIDER;
+ }
+
+ public abstract FrameworkType getFrameworkType(RequestKind requestKind);
+}
diff --git a/java/dagger/internal/codegen/binding/InjectBindingRegistry.java b/java/dagger/internal/codegen/binding/InjectBindingRegistry.java
new file mode 100644
index 0000000..5203130
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/InjectBindingRegistry.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import dagger.Component;
+import dagger.Provides;
+import dagger.internal.codegen.base.SourceFileGenerationException;
+import dagger.internal.codegen.base.SourceFileGenerator;
+import dagger.model.Key;
+import java.util.Optional;
+import javax.inject.Inject;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+
+/**
+ * Maintains the collection of provision bindings from {@link Inject} constructors and members
+ * injection bindings from {@link Inject} fields and methods known to the annotation processor. Note
+ * that this registry <b>does not</b> handle any explicit bindings (those from {@link Provides}
+ * methods, {@link Component} dependencies, etc.).
+ */
+public interface InjectBindingRegistry {
+ /**
+ * Returns a {@link ProvisionBinding} for {@code key}. If none has been registered yet, registers
+ * one.
+ */
+ Optional<ProvisionBinding> getOrFindProvisionBinding(Key key);
+
+ /**
+ * Returns a {@link MembersInjectionBinding} for {@code key}. If none has been registered yet,
+ * registers one, along with all necessary members injection bindings for superclasses.
+ */
+ Optional<MembersInjectionBinding> getOrFindMembersInjectionBinding(Key key);
+
+ /**
+ * Returns a {@link ProvisionBinding} for a {@link dagger.MembersInjector} of {@code key}. If none
+ * has been registered yet, registers one.
+ */
+ Optional<ProvisionBinding> getOrFindMembersInjectorProvisionBinding(Key key);
+
+ @CanIgnoreReturnValue
+ Optional<ProvisionBinding> tryRegisterConstructor(ExecutableElement constructorElement);
+
+ @CanIgnoreReturnValue
+ Optional<MembersInjectionBinding> tryRegisterMembersInjectedType(TypeElement typeElement);
+
+ /**
+ * This method ensures that sources for all registered {@link Binding bindings} (either explicitly
+ * or implicitly via {@link #getOrFindMembersInjectionBinding} or {@link
+ * #getOrFindProvisionBinding}) are generated.
+ */
+ void generateSourcesForRequiredBindings(
+ SourceFileGenerator<ProvisionBinding> factoryGenerator,
+ SourceFileGenerator<MembersInjectionBinding> membersInjectorGenerator)
+ throws SourceFileGenerationException;
+}
diff --git a/java/dagger/internal/codegen/binding/InjectionAnnotations.java b/java/dagger/internal/codegen/binding/InjectionAnnotations.java
new file mode 100644
index 0000000..748755e
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/InjectionAnnotations.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.auto.common.MoreElements.asType;
+import static com.google.auto.common.MoreElements.asVariable;
+import static com.google.auto.common.MoreElements.isAnnotationPresent;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static dagger.internal.codegen.base.MoreAnnotationValues.getStringValue;
+import static dagger.internal.codegen.binding.SourceFiles.memberInjectedFieldSignatureForVariable;
+import static dagger.internal.codegen.binding.SourceFiles.membersInjectorNameForType;
+import static dagger.internal.codegen.langmodel.DaggerElements.getAnnotationMirror;
+import static javax.lang.model.element.Modifier.STATIC;
+import static javax.lang.model.util.ElementFilter.constructorsIn;
+
+import com.google.auto.common.AnnotationMirrors;
+import com.google.auto.common.SuperficialValidation;
+import com.google.common.base.Equivalence;
+import com.google.common.base.Equivalence.Wrapper;
+import com.google.common.collect.FluentIterable;
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableSet;
+import dagger.internal.InjectedFieldSignature;
+import dagger.internal.codegen.extension.DaggerCollectors;
+import dagger.internal.codegen.extension.DaggerStreams;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import java.util.Optional;
+import java.util.stream.Stream;
+import javax.inject.Inject;
+import javax.inject.Qualifier;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.util.ElementFilter;
+
+/** Utilities relating to annotations defined in the {@code javax.inject} package. */
+public final class InjectionAnnotations {
+
+ private static final Equivalence<AnnotationMirror> EQUIVALENCE = AnnotationMirrors.equivalence();
+
+ private final DaggerElements elements;
+ private final KotlinMetadataUtil kotlinMetadataUtil;
+
+ @Inject
+ InjectionAnnotations(DaggerElements elements, KotlinMetadataUtil kotlinMetadataUtil) {
+ this.elements = elements;
+ this.kotlinMetadataUtil = kotlinMetadataUtil;
+ }
+
+ public Optional<AnnotationMirror> getQualifier(Element e) {
+ if (!SuperficialValidation.validateElement(e)) {
+ throw new TypeNotPresentException(e.toString(), null);
+ }
+ checkNotNull(e);
+ ImmutableCollection<? extends AnnotationMirror> qualifierAnnotations = getQualifiers(e);
+ switch (qualifierAnnotations.size()) {
+ case 0:
+ return Optional.empty();
+ case 1:
+ return Optional.<AnnotationMirror>of(qualifierAnnotations.iterator().next());
+ default:
+ throw new IllegalArgumentException(
+ e + " was annotated with more than one @Qualifier annotation");
+ }
+ }
+
+ public ImmutableCollection<? extends AnnotationMirror> getQualifiers(Element element) {
+ ImmutableSet<? extends AnnotationMirror> qualifiers =
+ AnnotationMirrors.getAnnotatedAnnotations(element, Qualifier.class);
+ if (element.getKind() == ElementKind.FIELD
+ // static injected fields are not supported, no need to get qualifier from kotlin metadata
+ && !element.getModifiers().contains(STATIC)
+ && isAnnotationPresent(element, Inject.class)
+ && kotlinMetadataUtil.hasMetadata(element)) {
+ return Stream.concat(
+ qualifiers.stream(), getQualifiersForKotlinProperty(asVariable(element)).stream())
+ .map(EQUIVALENCE::wrap) // Wrap in equivalence to deduplicate
+ .distinct()
+ .map(Wrapper::get)
+ .collect(DaggerStreams.toImmutableList());
+ } else {
+ return qualifiers.asList();
+ }
+ }
+
+ /** Returns the constructors in {@code type} that are annotated with {@link Inject}. */
+ public static ImmutableSet<ExecutableElement> injectedConstructors(TypeElement type) {
+ return FluentIterable.from(constructorsIn(type.getEnclosedElements()))
+ .filter(constructor -> isAnnotationPresent(constructor, Inject.class))
+ .toSet();
+ }
+
+ /**
+ * Gets the qualifiers annotation of a Kotlin Property. Finding these annotations involve finding
+ * the synthetic method for annotations as described by the Kotlin metadata or finding the
+ * corresponding MembersInjector method for the field, which also contains the qualifier
+ * annotation.
+ */
+ private ImmutableCollection<? extends AnnotationMirror> getQualifiersForKotlinProperty(
+ VariableElement fieldElement) {
+ // TODO(bcorso): Consider moving this to KotlinMetadataUtil
+ if (kotlinMetadataUtil.isMissingSyntheticPropertyForAnnotations(fieldElement)) {
+ // If we detect that the synthetic method for annotations is missing, possibly due to the
+ // element being from a compiled class, then find the MembersInjector that was generated
+ // for the enclosing class and extract the qualifier information from it.
+ TypeElement membersInjector =
+ elements.getTypeElement(
+ membersInjectorNameForType(asType(fieldElement.getEnclosingElement())));
+ if (membersInjector != null) {
+ String memberInjectedFieldSignature = memberInjectedFieldSignatureForVariable(fieldElement);
+ // TODO(danysantiago): We have to iterate over all the injection methods for every qualifier
+ // look up. Making this N^2 when looking through all the injected fields. :(
+ return ElementFilter.methodsIn(membersInjector.getEnclosedElements()).stream()
+ .filter(
+ method ->
+ getAnnotationMirror(method, InjectedFieldSignature.class)
+ .map(annotation -> getStringValue(annotation, "value"))
+ .map(memberInjectedFieldSignature::equals)
+ // If a method is not an @InjectedFieldSignature method then filter it out
+ .orElse(false))
+ .collect(DaggerCollectors.toOptional())
+ .map(this::getQualifiers)
+ .orElseThrow(
+ () ->
+ new IllegalStateException(
+ String.format(
+ "No matching InjectedFieldSignature for %1$s. This likely means that "
+ + "%1$s was compiled with an older, incompatible version of "
+ + "Dagger. Please update all Dagger dependencies to the same "
+ + "version.",
+ memberInjectedFieldSignature)));
+ } else {
+ throw new IllegalStateException(
+ "No MembersInjector found for " + fieldElement.getEnclosingElement());
+ }
+ } else {
+ return kotlinMetadataUtil.getSyntheticPropertyAnnotations(fieldElement, Qualifier.class);
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/InjectionSiteFactory.java b/java/dagger/internal/codegen/binding/InjectionSiteFactory.java
new file mode 100644
index 0000000..7a6f8d2
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/InjectionSiteFactory.java
@@ -0,0 +1,146 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.auto.common.MoreElements.isAnnotationPresent;
+import static dagger.internal.codegen.langmodel.DaggerElements.DECLARATION_ORDER;
+import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.STATIC;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.MoreTypes;
+import com.google.common.collect.ImmutableSortedSet;
+import com.google.common.collect.LinkedHashMultimap;
+import com.google.common.collect.SetMultimap;
+import dagger.internal.codegen.binding.MembersInjectionBinding.InjectionSite;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import javax.inject.Inject;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.ExecutableType;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.ElementKindVisitor8;
+
+/** A factory for {@link Binding} objects. */
+final class InjectionSiteFactory {
+
+ private final DaggerTypes types;
+ private final DaggerElements elements;
+ private final DependencyRequestFactory dependencyRequestFactory;
+
+ @Inject
+ InjectionSiteFactory(
+ DaggerTypes types,
+ DaggerElements elements,
+ DependencyRequestFactory dependencyRequestFactory) {
+ this.types = types;
+ this.elements = elements;
+ this.dependencyRequestFactory = dependencyRequestFactory;
+ }
+
+ /** Returns the injection sites for a type. */
+ ImmutableSortedSet<InjectionSite> getInjectionSites(DeclaredType declaredType) {
+ Set<InjectionSite> injectionSites = new HashSet<>();
+ List<TypeElement> ancestors = new ArrayList<>();
+ InjectionSiteVisitor injectionSiteVisitor = new InjectionSiteVisitor();
+ for (Optional<DeclaredType> currentType = Optional.of(declaredType);
+ currentType.isPresent();
+ currentType = types.nonObjectSuperclass(currentType.get())) {
+ DeclaredType type = currentType.get();
+ ancestors.add(MoreElements.asType(type.asElement()));
+ for (Element enclosedElement : type.asElement().getEnclosedElements()) {
+ injectionSiteVisitor.visit(enclosedElement, type).ifPresent(injectionSites::add);
+ }
+ }
+ return ImmutableSortedSet.copyOf(
+ // supertypes before subtypes
+ Comparator.comparing(
+ (InjectionSite injectionSite) ->
+ ancestors.indexOf(injectionSite.element().getEnclosingElement()))
+ .reversed()
+ // fields before methods
+ .thenComparing(injectionSite -> injectionSite.element().getKind())
+ // then sort by whichever element comes first in the parent
+ // this isn't necessary, but makes the processor nice and predictable
+ .thenComparing(InjectionSite::element, DECLARATION_ORDER),
+ injectionSites);
+ }
+
+ private final class InjectionSiteVisitor
+ extends ElementKindVisitor8<Optional<InjectionSite>, DeclaredType> {
+ private final SetMultimap<String, ExecutableElement> subclassMethodMap =
+ LinkedHashMultimap.create();
+
+ InjectionSiteVisitor() {
+ super(Optional.empty());
+ }
+
+ @Override
+ public Optional<InjectionSite> visitExecutableAsMethod(
+ ExecutableElement method, DeclaredType type) {
+ subclassMethodMap.put(method.getSimpleName().toString(), method);
+ if (!shouldBeInjected(method)) {
+ return Optional.empty();
+ }
+ // This visitor assumes that subclass methods are visited before superclass methods, so we can
+ // skip any overridden method that has already been visited. To decrease the number of methods
+ // that are checked, we store the already injected methods in a SetMultimap and only check the
+ // methods with the same name.
+ String methodName = method.getSimpleName().toString();
+ TypeElement enclosingType = MoreElements.asType(method.getEnclosingElement());
+ for (ExecutableElement subclassMethod : subclassMethodMap.get(methodName)) {
+ if (method != subclassMethod && elements.overrides(subclassMethod, method, enclosingType)) {
+ return Optional.empty();
+ }
+ }
+ ExecutableType resolved = MoreTypes.asExecutable(types.asMemberOf(type, method));
+ return Optional.of(
+ InjectionSite.method(
+ method,
+ dependencyRequestFactory.forRequiredResolvedVariables(
+ method.getParameters(), resolved.getParameterTypes())));
+ }
+
+ @Override
+ public Optional<InjectionSite> visitVariableAsField(
+ VariableElement field, DeclaredType type) {
+ if (!shouldBeInjected(field)) {
+ return Optional.empty();
+ }
+ TypeMirror resolved = types.asMemberOf(type, field);
+ return Optional.of(
+ InjectionSite.field(
+ field, dependencyRequestFactory.forRequiredResolvedVariable(field, resolved)));
+ }
+
+ private boolean shouldBeInjected(Element injectionSite) {
+ return isAnnotationPresent(injectionSite, Inject.class)
+ && !injectionSite.getModifiers().contains(PRIVATE)
+ && !injectionSite.getModifiers().contains(STATIC);
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/KeyFactory.java b/java/dagger/internal/codegen/binding/KeyFactory.java
new file mode 100644
index 0000000..d923666
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/KeyFactory.java
@@ -0,0 +1,434 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.auto.common.MoreElements.isAnnotationPresent;
+import static com.google.auto.common.MoreTypes.asExecutable;
+import static com.google.auto.common.MoreTypes.isType;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static dagger.internal.codegen.base.RequestKinds.extractKeyType;
+import static dagger.internal.codegen.binding.MapKeys.getMapKey;
+import static dagger.internal.codegen.binding.MapKeys.mapKeyType;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static dagger.internal.codegen.extension.Optionals.firstPresent;
+import static dagger.internal.codegen.langmodel.DaggerTypes.isFutureType;
+import static dagger.internal.codegen.langmodel.DaggerTypes.unwrapType;
+import static java.util.Arrays.asList;
+import static javax.lang.model.element.ElementKind.METHOD;
+
+import com.google.auto.common.MoreTypes;
+import com.google.common.collect.ImmutableSet;
+import dagger.Binds;
+import dagger.BindsOptionalOf;
+import dagger.internal.codegen.base.ContributionType;
+import dagger.internal.codegen.base.FrameworkTypes;
+import dagger.internal.codegen.base.MapType;
+import dagger.internal.codegen.base.OptionalType;
+import dagger.internal.codegen.base.RequestKinds;
+import dagger.internal.codegen.base.SetType;
+import dagger.internal.codegen.base.SimpleAnnotationMirror;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.Key;
+import dagger.model.Key.MultibindingContributionIdentifier;
+import dagger.model.RequestKind;
+import dagger.multibindings.Multibinds;
+import dagger.producers.Produced;
+import dagger.producers.Producer;
+import dagger.producers.Production;
+import dagger.producers.internal.ProductionImplementation;
+import dagger.producers.monitoring.ProductionComponentMonitor;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.Executor;
+import java.util.stream.Stream;
+import javax.inject.Inject;
+import javax.inject.Provider;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.ExecutableType;
+import javax.lang.model.type.PrimitiveType;
+import javax.lang.model.type.TypeMirror;
+
+/** A factory for {@link Key}s. */
+public final class KeyFactory {
+ private final DaggerTypes types;
+ private final DaggerElements elements;
+ private final InjectionAnnotations injectionAnnotations;
+
+ @Inject
+ KeyFactory(
+ DaggerTypes types, DaggerElements elements, InjectionAnnotations injectionAnnotations) {
+ this.types = checkNotNull(types);
+ this.elements = checkNotNull(elements);
+ this.injectionAnnotations = injectionAnnotations;
+ }
+
+ private TypeMirror boxPrimitives(TypeMirror type) {
+ return type.getKind().isPrimitive() ? types.boxedClass((PrimitiveType) type).asType() : type;
+ }
+
+ private DeclaredType setOf(TypeMirror elementType) {
+ return types.getDeclaredType(elements.getTypeElement(Set.class), boxPrimitives(elementType));
+ }
+
+ private DeclaredType mapOf(TypeMirror keyType, TypeMirror valueType) {
+ return types.getDeclaredType(
+ elements.getTypeElement(Map.class), boxPrimitives(keyType), boxPrimitives(valueType));
+ }
+
+ /** Returns {@code Map<KeyType, FrameworkType<ValueType>>}. */
+ private TypeMirror mapOfFrameworkType(
+ TypeMirror keyType, TypeElement frameworkType, TypeMirror valueType) {
+ return mapOf(keyType, types.getDeclaredType(frameworkType, boxPrimitives(valueType)));
+ }
+
+ Key forComponentMethod(ExecutableElement componentMethod) {
+ checkArgument(componentMethod.getKind().equals(METHOD));
+ return forMethod(componentMethod, componentMethod.getReturnType());
+ }
+
+ Key forProductionComponentMethod(ExecutableElement componentMethod) {
+ checkArgument(componentMethod.getKind().equals(METHOD));
+ TypeMirror returnType = componentMethod.getReturnType();
+ TypeMirror keyType =
+ isFutureType(returnType)
+ ? getOnlyElement(MoreTypes.asDeclared(returnType).getTypeArguments())
+ : returnType;
+ return forMethod(componentMethod, keyType);
+ }
+
+ Key forSubcomponentCreatorMethod(
+ ExecutableElement subcomponentCreatorMethod, DeclaredType declaredContainer) {
+ checkArgument(subcomponentCreatorMethod.getKind().equals(METHOD));
+ ExecutableType resolvedMethod =
+ asExecutable(types.asMemberOf(declaredContainer, subcomponentCreatorMethod));
+ return Key.builder(resolvedMethod.getReturnType()).build();
+ }
+
+ public Key forSubcomponentCreator(TypeMirror creatorType) {
+ return Key.builder(creatorType).build();
+ }
+
+ public Key forProvidesMethod(ExecutableElement method, TypeElement contributingModule) {
+ return forBindingMethod(
+ method, contributingModule, Optional.of(elements.getTypeElement(Provider.class)));
+ }
+
+ public Key forProducesMethod(ExecutableElement method, TypeElement contributingModule) {
+ return forBindingMethod(
+ method, contributingModule, Optional.of(elements.getTypeElement(Producer.class)));
+ }
+
+ /** Returns the key bound by a {@link Binds} method. */
+ Key forBindsMethod(ExecutableElement method, TypeElement contributingModule) {
+ checkArgument(isAnnotationPresent(method, Binds.class));
+ return forBindingMethod(method, contributingModule, Optional.empty());
+ }
+
+ /** Returns the base key bound by a {@link BindsOptionalOf} method. */
+ Key forBindsOptionalOfMethod(ExecutableElement method, TypeElement contributingModule) {
+ checkArgument(isAnnotationPresent(method, BindsOptionalOf.class));
+ return forBindingMethod(method, contributingModule, Optional.empty());
+ }
+
+ private Key forBindingMethod(
+ ExecutableElement method,
+ TypeElement contributingModule,
+ Optional<TypeElement> frameworkType) {
+ checkArgument(method.getKind().equals(METHOD));
+ ExecutableType methodType =
+ MoreTypes.asExecutable(
+ types.asMemberOf(MoreTypes.asDeclared(contributingModule.asType()), method));
+ ContributionType contributionType = ContributionType.fromBindingElement(method);
+ TypeMirror returnType = methodType.getReturnType();
+ if (frameworkType.isPresent()
+ && frameworkType.get().equals(elements.getTypeElement(Producer.class))
+ && isType(returnType)) {
+ if (isFutureType(methodType.getReturnType())) {
+ returnType = getOnlyElement(MoreTypes.asDeclared(returnType).getTypeArguments());
+ } else if (contributionType.equals(ContributionType.SET_VALUES)
+ && SetType.isSet(returnType)) {
+ SetType setType = SetType.from(returnType);
+ if (isFutureType(setType.elementType())) {
+ returnType =
+ types.getDeclaredType(
+ elements.getTypeElement(Set.class), unwrapType(setType.elementType()));
+ }
+ }
+ }
+ TypeMirror keyType = bindingMethodKeyType(returnType, method, contributionType, frameworkType);
+ Key key = forMethod(method, keyType);
+ return contributionType.equals(ContributionType.UNIQUE)
+ ? key
+ : key.toBuilder()
+ .multibindingContributionIdentifier(
+ new MultibindingContributionIdentifier(method, contributingModule))
+ .build();
+ }
+
+ /**
+ * Returns the key for a {@link Multibinds @Multibinds} method.
+ *
+ * <p>The key's type is either {@code Set<T>} or {@code Map<K, Provider<V>>}. The latter works
+ * even for maps used by {@code Producer}s.
+ */
+ Key forMultibindsMethod(ExecutableType executableType, ExecutableElement method) {
+ checkArgument(method.getKind().equals(METHOD), "%s must be a method", method);
+ TypeMirror returnType = executableType.getReturnType();
+ TypeMirror keyType =
+ MapType.isMap(returnType)
+ ? mapOfFrameworkType(
+ MapType.from(returnType).keyType(),
+ elements.getTypeElement(Provider.class),
+ MapType.from(returnType).valueType())
+ : returnType;
+ return forMethod(method, keyType);
+ }
+
+ private TypeMirror bindingMethodKeyType(
+ TypeMirror returnType,
+ ExecutableElement method,
+ ContributionType contributionType,
+ Optional<TypeElement> frameworkType) {
+ switch (contributionType) {
+ case UNIQUE:
+ return returnType;
+ case SET:
+ return setOf(returnType);
+ case MAP:
+ TypeMirror mapKeyType = mapKeyType(getMapKey(method).get(), types);
+ return frameworkType.isPresent()
+ ? mapOfFrameworkType(mapKeyType, frameworkType.get(), returnType)
+ : mapOf(mapKeyType, returnType);
+ case SET_VALUES:
+ // TODO(gak): do we want to allow people to use "covariant return" here?
+ checkArgument(SetType.isSet(returnType));
+ return returnType;
+ }
+ throw new AssertionError();
+ }
+
+ /**
+ * Returns the key for a binding associated with a {@link DelegateDeclaration}.
+ *
+ * <p>If {@code delegateDeclaration} is {@code @IntoMap}, transforms the {@code Map<K, V>} key
+ * from {@link DelegateDeclaration#key()} to {@code Map<K, FrameworkType<V>>}. If {@code
+ * delegateDeclaration} is not a map contribution, its key is returned.
+ */
+ Key forDelegateBinding(DelegateDeclaration delegateDeclaration, Class<?> frameworkType) {
+ return delegateDeclaration.contributionType().equals(ContributionType.MAP)
+ ? wrapMapValue(delegateDeclaration.key(), frameworkType)
+ : delegateDeclaration.key();
+ }
+
+ private Key forMethod(ExecutableElement method, TypeMirror keyType) {
+ return forQualifiedType(injectionAnnotations.getQualifier(method), keyType);
+ }
+
+ public Key forInjectConstructorWithResolvedType(TypeMirror type) {
+ return Key.builder(type).build();
+ }
+
+ // TODO(ronshapiro): Remove these conveniences which are simple wrappers around Key.Builder
+ Key forType(TypeMirror type) {
+ return Key.builder(type).build();
+ }
+
+ public Key forMembersInjectedType(TypeMirror type) {
+ return Key.builder(type).build();
+ }
+
+ Key forQualifiedType(Optional<AnnotationMirror> qualifier, TypeMirror type) {
+ return Key.builder(boxPrimitives(type)).qualifier(qualifier).build();
+ }
+
+ public Key forProductionExecutor() {
+ return Key.builder(elements.getTypeElement(Executor.class).asType())
+ .qualifier(SimpleAnnotationMirror.of(elements.getTypeElement(Production.class)))
+ .build();
+ }
+
+ public Key forProductionImplementationExecutor() {
+ return Key.builder(elements.getTypeElement(Executor.class).asType())
+ .qualifier(SimpleAnnotationMirror.of(elements.getTypeElement(ProductionImplementation.class)))
+ .build();
+ }
+
+ public Key forProductionComponentMonitor() {
+ return Key.builder(elements.getTypeElement(ProductionComponentMonitor.class).asType()).build();
+ }
+
+ /**
+ * If {@code requestKey} is for a {@code Map<K, V>} or {@code Map<K, Produced<V>>}, returns keys
+ * for {@code Map<K, Provider<V>>} and {@code Map<K, Producer<V>>} (if Dagger-Producers is on
+ * the classpath).
+ */
+ ImmutableSet<Key> implicitFrameworkMapKeys(Key requestKey) {
+ return Stream.of(implicitMapProviderKeyFrom(requestKey), implicitMapProducerKeyFrom(requestKey))
+ .filter(Optional::isPresent)
+ .map(Optional::get)
+ .collect(toImmutableSet());
+ }
+
+ /**
+ * Optionally extract a {@link Key} for the underlying provision binding(s) if such a valid key
+ * can be inferred from the given key. Specifically, if the key represents a {@link Map}{@code
+ * <K, V>} or {@code Map<K, Producer<V>>}, a key of {@code Map<K, Provider<V>>} will be
+ * returned.
+ */
+ Optional<Key> implicitMapProviderKeyFrom(Key possibleMapKey) {
+ return firstPresent(
+ rewrapMapKey(possibleMapKey, Produced.class, Provider.class),
+ wrapMapKey(possibleMapKey, Provider.class));
+ }
+
+ /**
+ * Optionally extract a {@link Key} for the underlying production binding(s) if such a
+ * valid key can be inferred from the given key. Specifically, if the key represents a
+ * {@link Map}{@code <K, V>} or {@code Map<K, Produced<V>>}, a key of
+ * {@code Map<K, Producer<V>>} will be returned.
+ */
+ Optional<Key> implicitMapProducerKeyFrom(Key possibleMapKey) {
+ return firstPresent(
+ rewrapMapKey(possibleMapKey, Produced.class, Producer.class),
+ wrapMapKey(possibleMapKey, Producer.class));
+ }
+
+ /**
+ * If {@code key}'s type is {@code Map<K, Provider<V>>}, {@code Map<K, Producer<V>>}, or {@code
+ * Map<K, Produced<V>>}, returns a key with the same qualifier and {@link
+ * Key#multibindingContributionIdentifier()} whose type is simply {@code Map<K, V>}.
+ *
+ * <p>Otherwise, returns {@code key}.
+ */
+ public Key unwrapMapValueType(Key key) {
+ if (MapType.isMap(key)) {
+ MapType mapType = MapType.from(key);
+ if (!mapType.isRawType()) {
+ for (Class<?> frameworkClass : asList(Provider.class, Producer.class, Produced.class)) {
+ if (mapType.valuesAreTypeOf(frameworkClass)) {
+ return key.toBuilder()
+ .type(mapOf(mapType.keyType(), mapType.unwrappedValueType(frameworkClass)))
+ .build();
+ }
+ }
+ }
+ }
+ return key;
+ }
+
+ /**
+ * Converts a {@link Key} of type {@code Map<K, V>} to {@code Map<K, Provider<V>>}.
+ */
+ private Key wrapMapValue(Key key, Class<?> newWrappingClass) {
+ checkArgument(
+ FrameworkTypes.isFrameworkType(elements.getTypeElement(newWrappingClass).asType()));
+ return wrapMapKey(key, newWrappingClass).get();
+ }
+
+ /**
+ * If {@code key}'s type is {@code Map<K, CurrentWrappingClass<Bar>>}, returns a key with type
+ * {@code Map<K, NewWrappingClass<Bar>>} with the same qualifier. Otherwise returns {@link
+ * Optional#empty()}.
+ *
+ * <p>Returns {@link Optional#empty()} if {@code newWrappingClass} is not in the classpath.
+ *
+ * @throws IllegalArgumentException if {@code newWrappingClass} is the same as {@code
+ * currentWrappingClass}
+ */
+ public Optional<Key> rewrapMapKey(
+ Key possibleMapKey, Class<?> currentWrappingClass, Class<?> newWrappingClass) {
+ checkArgument(!currentWrappingClass.equals(newWrappingClass));
+ if (MapType.isMap(possibleMapKey)) {
+ MapType mapType = MapType.from(possibleMapKey);
+ if (!mapType.isRawType() && mapType.valuesAreTypeOf(currentWrappingClass)) {
+ TypeElement wrappingElement = elements.getTypeElement(newWrappingClass);
+ if (wrappingElement == null) {
+ // This target might not be compiled with Producers, so wrappingClass might not have an
+ // associated element.
+ return Optional.empty();
+ }
+ DeclaredType wrappedValueType =
+ types.getDeclaredType(
+ wrappingElement, mapType.unwrappedValueType(currentWrappingClass));
+ return Optional.of(
+ possibleMapKey.toBuilder().type(mapOf(mapType.keyType(), wrappedValueType)).build());
+ }
+ }
+ return Optional.empty();
+ }
+
+ /**
+ * If {@code key}'s type is {@code Map<K, Foo>} and {@code Foo} is not {@code WrappingClass
+ * <Bar>}, returns a key with type {@code Map<K, WrappingClass<Foo>>} with the same qualifier.
+ * Otherwise returns {@link Optional#empty()}.
+ *
+ * <p>Returns {@link Optional#empty()} if {@code WrappingClass} is not in the classpath.
+ */
+ private Optional<Key> wrapMapKey(Key possibleMapKey, Class<?> wrappingClass) {
+ if (MapType.isMap(possibleMapKey)) {
+ MapType mapType = MapType.from(possibleMapKey);
+ if (!mapType.isRawType() && !mapType.valuesAreTypeOf(wrappingClass)) {
+ TypeElement wrappingElement = elements.getTypeElement(wrappingClass);
+ if (wrappingElement == null) {
+ // This target might not be compiled with Producers, so wrappingClass might not have an
+ // associated element.
+ return Optional.empty();
+ }
+ DeclaredType wrappedValueType = types.getDeclaredType(wrappingElement, mapType.valueType());
+ return Optional.of(
+ possibleMapKey.toBuilder().type(mapOf(mapType.keyType(), wrappedValueType)).build());
+ }
+ }
+ return Optional.empty();
+ }
+
+ /**
+ * If {@code key}'s type is {@code Set<WrappingClass<Bar>>}, returns a key with type {@code Set
+ * <Bar>} with the same qualifier. Otherwise returns {@link Optional#empty()}.
+ */
+ Optional<Key> unwrapSetKey(Key key, Class<?> wrappingClass) {
+ if (SetType.isSet(key)) {
+ SetType setType = SetType.from(key);
+ if (!setType.isRawType() && setType.elementsAreTypeOf(wrappingClass)) {
+ return Optional.of(
+ key.toBuilder().type(setOf(setType.unwrappedElementType(wrappingClass))).build());
+ }
+ }
+ return Optional.empty();
+ }
+
+ /**
+ * If {@code key}'s type is {@code Optional<T>} for some {@code T}, returns a key with the same
+ * qualifier whose type is {@linkplain RequestKinds#extractKeyType(RequestKind, TypeMirror)}
+ * extracted} from {@code T}.
+ */
+ Optional<Key> unwrapOptional(Key key) {
+ if (!OptionalType.isOptional(key)) {
+ return Optional.empty();
+ }
+
+ TypeMirror optionalValueType = OptionalType.from(key).valueType();
+ return Optional.of(key.toBuilder().type(extractKeyType(optionalValueType)).build());
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/KeyVariableNamer.java b/java/dagger/internal/codegen/binding/KeyVariableNamer.java
new file mode 100644
index 0000000..9ac0efa
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/KeyVariableNamer.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.common.base.CaseFormat.LOWER_CAMEL;
+import static com.google.common.base.CaseFormat.UPPER_CAMEL;
+import static dagger.internal.codegen.binding.SourceFiles.protectAgainstKeywords;
+
+import com.google.auto.common.MoreTypes;
+import com.google.common.collect.ImmutableSet;
+import dagger.model.DependencyRequest;
+import dagger.model.Key;
+import java.util.Iterator;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.ArrayType;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.PrimitiveType;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.type.TypeVisitor;
+import javax.lang.model.util.SimpleTypeVisitor8;
+
+/**
+ * Suggests a variable name for a type based on a {@link Key}. Prefer {@link
+ * DependencyVariableNamer} for cases where a specific {@link DependencyRequest} is present.
+ */
+public final class KeyVariableNamer {
+ /** Simple names that are very common. Inspired by https://errorprone.info/bugpattern/BadImport */
+ private static final ImmutableSet<String> VERY_SIMPLE_NAMES =
+ ImmutableSet.of(
+ "Builder",
+ "Factory",
+ "Component",
+ "Subcomponent",
+ "Injector");
+
+ private static final TypeVisitor<Void, StringBuilder> TYPE_NAMER =
+ new SimpleTypeVisitor8<Void, StringBuilder>() {
+ @Override
+ public Void visitDeclared(DeclaredType declaredType, StringBuilder builder) {
+ TypeElement element = MoreTypes.asTypeElement(declaredType);
+ if (element.getNestingKind().isNested()
+ && VERY_SIMPLE_NAMES.contains(element.getSimpleName().toString())) {
+ builder.append(element.getEnclosingElement().getSimpleName());
+ }
+
+ builder.append(element.getSimpleName());
+ Iterator<? extends TypeMirror> argumentIterator =
+ declaredType.getTypeArguments().iterator();
+ if (argumentIterator.hasNext()) {
+ builder.append("Of");
+ TypeMirror first = argumentIterator.next();
+ first.accept(this, builder);
+ while (argumentIterator.hasNext()) {
+ builder.append("And");
+ argumentIterator.next().accept(this, builder);
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public Void visitPrimitive(PrimitiveType type, StringBuilder builder) {
+ builder.append(LOWER_CAMEL.to(UPPER_CAMEL, type.toString()));
+ return null;
+ }
+
+ @Override
+ public Void visitArray(ArrayType type, StringBuilder builder) {
+ type.getComponentType().accept(this, builder);
+ builder.append("Array");
+ return null;
+ }
+ };
+
+ private KeyVariableNamer() {}
+
+ public static String name(Key key) {
+ if (key.multibindingContributionIdentifier().isPresent()) {
+ return key.multibindingContributionIdentifier().get().bindingElement();
+ }
+
+ StringBuilder builder = new StringBuilder();
+
+ if (key.qualifier().isPresent()) {
+ // TODO(gak): Use a better name for fields with qualifiers with members.
+ builder.append(key.qualifier().get().getAnnotationType().asElement().getSimpleName());
+ }
+
+ key.type().accept(TYPE_NAMER, builder);
+
+ return protectAgainstKeywords(UPPER_CAMEL.to(LOWER_CAMEL, builder.toString()));
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/LegacyBindingGraph.java b/java/dagger/internal/codegen/binding/LegacyBindingGraph.java
new file mode 100644
index 0000000..7c00401
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/LegacyBindingGraph.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multimaps;
+import dagger.model.Key;
+import dagger.model.RequestKind;
+import java.util.Collection;
+import java.util.Map;
+import javax.lang.model.element.TypeElement;
+
+// TODO(bcorso): Remove the LegacyBindingGraph after we've migrated to the new BindingGraph.
+/** The canonical representation of a full-resolved graph. */
+final class LegacyBindingGraph {
+ private final ComponentDescriptor componentDescriptor;
+ private final ImmutableMap<Key, ResolvedBindings> contributionBindings;
+ private final ImmutableMap<Key, ResolvedBindings> membersInjectionBindings;
+ private final ImmutableList<LegacyBindingGraph> subgraphs;
+
+ LegacyBindingGraph(
+ ComponentDescriptor componentDescriptor,
+ ImmutableMap<Key, ResolvedBindings> contributionBindings,
+ ImmutableMap<Key, ResolvedBindings> membersInjectionBindings,
+ ImmutableList<LegacyBindingGraph> subgraphs) {
+ this.componentDescriptor = componentDescriptor;
+ this.contributionBindings = contributionBindings;
+ this.membersInjectionBindings = membersInjectionBindings;
+ this.subgraphs = checkForDuplicates(subgraphs);
+ }
+
+ ComponentDescriptor componentDescriptor() {
+ return componentDescriptor;
+ }
+
+ ResolvedBindings resolvedBindings(BindingRequest request) {
+ return request.isRequestKind(RequestKind.MEMBERS_INJECTION)
+ ? membersInjectionBindings.get(request.key())
+ : contributionBindings.get(request.key());
+ }
+
+ Iterable<ResolvedBindings> resolvedBindings() {
+ // Don't return an immutable collection - this is only ever used for looping over all bindings
+ // in the graph. Copying is wasteful, especially if is a hashing collection, since the values
+ // should all, by definition, be distinct.
+ return Iterables.concat(membersInjectionBindings.values(), contributionBindings.values());
+ }
+
+ ImmutableList<LegacyBindingGraph> subgraphs() {
+ return subgraphs;
+ }
+
+ private static ImmutableList<LegacyBindingGraph> checkForDuplicates(
+ ImmutableList<LegacyBindingGraph> graphs) {
+ Map<TypeElement, Collection<LegacyBindingGraph>> duplicateGraphs =
+ Maps.filterValues(
+ Multimaps.index(graphs, graph -> graph.componentDescriptor().typeElement()).asMap(),
+ overlapping -> overlapping.size() > 1);
+ if (!duplicateGraphs.isEmpty()) {
+ throw new IllegalArgumentException("Expected no duplicates: " + duplicateGraphs);
+ }
+ return graphs;
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/MapKeys.java b/java/dagger/internal/codegen/binding/MapKeys.java
new file mode 100644
index 0000000..ec7d79d
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/MapKeys.java
@@ -0,0 +1,222 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.auto.common.AnnotationMirrors.getAnnotatedAnnotations;
+import static com.google.auto.common.AnnotationMirrors.getAnnotationValuesWithDefaults;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static com.squareup.javapoet.MethodSpec.methodBuilder;
+import static dagger.internal.codegen.base.MapKeyAccessibility.isMapKeyPubliclyAccessible;
+import static dagger.internal.codegen.binding.SourceFiles.elementBasedClassName;
+import static javax.lang.model.element.Modifier.PUBLIC;
+import static javax.lang.model.element.Modifier.STATIC;
+import static javax.lang.model.util.ElementFilter.methodsIn;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.MoreTypes;
+import com.google.common.collect.ImmutableSet;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.TypeName;
+import dagger.MapKey;
+import dagger.internal.codegen.base.MapKeyAccessibility;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import java.util.NoSuchElementException;
+import java.util.Optional;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.ArrayType;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.PrimitiveType;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.SimpleTypeVisitor6;
+
+/** Methods for extracting {@link MapKey} annotations and key code blocks from binding elements. */
+public final class MapKeys {
+
+ /**
+ * If {@code bindingElement} is annotated with a {@link MapKey} annotation, returns it.
+ *
+ * @throws IllegalArgumentException if the element is annotated with more than one {@code MapKey}
+ * annotation
+ */
+ static Optional<AnnotationMirror> getMapKey(Element bindingElement) {
+ ImmutableSet<? extends AnnotationMirror> mapKeys = getMapKeys(bindingElement);
+ return mapKeys.isEmpty()
+ ? Optional.empty()
+ : Optional.<AnnotationMirror>of(getOnlyElement(mapKeys));
+ }
+
+ /** Returns all of the {@link MapKey} annotations that annotate {@code bindingElement}. */
+ public static ImmutableSet<? extends AnnotationMirror> getMapKeys(Element bindingElement) {
+ return getAnnotatedAnnotations(bindingElement, MapKey.class);
+ }
+
+ /**
+ * Returns the annotation value if {@code mapKey}'s type is annotated with
+ * {@link MapKey @MapKey(unwrapValue = true)}.
+ *
+ * @throws IllegalArgumentException if {@code mapKey}'s type is not annotated with
+ * {@link MapKey @MapKey} at all.
+ */
+ static Optional<? extends AnnotationValue> unwrapValue(AnnotationMirror mapKey) {
+ MapKey mapKeyAnnotation = mapKey.getAnnotationType().asElement().getAnnotation(MapKey.class);
+ checkArgument(
+ mapKeyAnnotation != null, "%s is not annotated with @MapKey", mapKey.getAnnotationType());
+ return mapKeyAnnotation.unwrapValue()
+ ? Optional.of(getOnlyElement(getAnnotationValuesWithDefaults(mapKey).values()))
+ : Optional.empty();
+ }
+
+ static TypeMirror mapKeyType(AnnotationMirror mapKeyAnnotation, DaggerTypes types) {
+ return unwrapValue(mapKeyAnnotation).isPresent()
+ ? getUnwrappedMapKeyType(mapKeyAnnotation.getAnnotationType(), types)
+ : mapKeyAnnotation.getAnnotationType();
+ }
+
+ /**
+ * Returns the map key type for an unwrapped {@link MapKey} annotation type. If the single member
+ * type is primitive, returns the boxed type.
+ *
+ * @throws IllegalArgumentException if {@code mapKeyAnnotationType} is not an annotation type or
+ * has more than one member, or if its single member is an array
+ * @throws NoSuchElementException if the annotation has no members
+ */
+ public static DeclaredType getUnwrappedMapKeyType(
+ final DeclaredType mapKeyAnnotationType, final DaggerTypes types) {
+ checkArgument(
+ MoreTypes.asTypeElement(mapKeyAnnotationType).getKind() == ElementKind.ANNOTATION_TYPE,
+ "%s is not an annotation type",
+ mapKeyAnnotationType);
+
+ final ExecutableElement onlyElement =
+ getOnlyElement(methodsIn(mapKeyAnnotationType.asElement().getEnclosedElements()));
+
+ SimpleTypeVisitor6<DeclaredType, Void> keyTypeElementVisitor =
+ new SimpleTypeVisitor6<DeclaredType, Void>() {
+
+ @Override
+ public DeclaredType visitArray(ArrayType t, Void p) {
+ throw new IllegalArgumentException(
+ mapKeyAnnotationType + "." + onlyElement.getSimpleName() + " cannot be an array");
+ }
+
+ @Override
+ public DeclaredType visitPrimitive(PrimitiveType t, Void p) {
+ return MoreTypes.asDeclared(types.boxedClass(t).asType());
+ }
+
+ @Override
+ public DeclaredType visitDeclared(DeclaredType t, Void p) {
+ return t;
+ }
+ };
+ return keyTypeElementVisitor.visit(onlyElement.getReturnType());
+ }
+
+ /**
+ * Returns a code block for {@code binding}'s {@link ContributionBinding#mapKeyAnnotation() map
+ * key}. If for whatever reason the map key is not accessible from within {@code requestingClass}
+ * (i.e. it has a package-private {@code enum} from a different package), this will return an
+ * invocation of a proxy-method giving it access.
+ *
+ * @throws IllegalStateException if {@code binding} is not a {@link dagger.multibindings.IntoMap
+ * map} contribution.
+ */
+ public static CodeBlock getMapKeyExpression(
+ ContributionBinding binding, ClassName requestingClass, DaggerElements elements) {
+ AnnotationMirror mapKeyAnnotation = binding.mapKeyAnnotation().get();
+ return MapKeyAccessibility.isMapKeyAccessibleFrom(
+ mapKeyAnnotation, requestingClass.packageName())
+ ? directMapKeyExpression(mapKeyAnnotation, elements)
+ : CodeBlock.of("$T.create()", mapKeyProxyClassName(binding));
+ }
+
+ /**
+ * Returns a code block for the map key annotation {@code mapKey}.
+ *
+ * <p>This method assumes the map key will be accessible in the context that the returned {@link
+ * CodeBlock} is used. Use {@link #getMapKeyExpression(ContributionBinding, ClassName,
+ * DaggerElements)} when that assumption is not guaranteed.
+ *
+ * @throws IllegalArgumentException if the element is annotated with more than one {@code MapKey}
+ * annotation
+ * @throws IllegalStateException if {@code bindingElement} is not annotated with a {@code MapKey}
+ * annotation
+ */
+ private static CodeBlock directMapKeyExpression(
+ AnnotationMirror mapKey, DaggerElements elements) {
+ Optional<? extends AnnotationValue> unwrappedValue = unwrapValue(mapKey);
+ AnnotationExpression annotationExpression = new AnnotationExpression(mapKey);
+
+ if (MoreTypes.asTypeElement(mapKey.getAnnotationType())
+ .getQualifiedName()
+ .contentEquals("dagger.android.AndroidInjectionKey")) {
+ TypeElement unwrappedType =
+ elements.checkTypePresent((String) unwrappedValue.get().getValue());
+ return CodeBlock.of(
+ "$T.of($S)",
+ ClassName.get("dagger.android.internal", "AndroidInjectionKeys"),
+ ClassName.get(unwrappedType).reflectionName());
+ }
+
+ if (unwrappedValue.isPresent()) {
+ TypeMirror unwrappedValueType =
+ getOnlyElement(getAnnotationValuesWithDefaults(mapKey).keySet()).getReturnType();
+ return annotationExpression.getValueExpression(unwrappedValueType, unwrappedValue.get());
+ } else {
+ return annotationExpression.getAnnotationInstanceExpression();
+ }
+ }
+
+ /**
+ * Returns the {@link ClassName} in which {@link #mapKeyFactoryMethod(ContributionBinding,
+ * DaggerTypes, DaggerElements)} is generated.
+ */
+ public static ClassName mapKeyProxyClassName(ContributionBinding binding) {
+ return elementBasedClassName(
+ MoreElements.asExecutable(binding.bindingElement().get()), "MapKey");
+ }
+
+ /**
+ * A {@code static create()} method to be added to {@link
+ * #mapKeyProxyClassName(ContributionBinding)} when the {@code @MapKey} annotation is not publicly
+ * accessible.
+ */
+ public static Optional<MethodSpec> mapKeyFactoryMethod(
+ ContributionBinding binding, DaggerTypes types, DaggerElements elements) {
+ return binding
+ .mapKeyAnnotation()
+ .filter(mapKey -> !isMapKeyPubliclyAccessible(mapKey))
+ .map(
+ mapKey ->
+ methodBuilder("create")
+ .addModifiers(PUBLIC, STATIC)
+ .returns(TypeName.get(mapKeyType(mapKey, types)))
+ .addStatement("return $L", directMapKeyExpression(mapKey, elements))
+ .build());
+ }
+
+ private MapKeys() {}
+}
diff --git a/java/dagger/internal/codegen/binding/MembersInjectionBinding.java b/java/dagger/internal/codegen/binding/MembersInjectionBinding.java
new file mode 100644
index 0000000..3dd1016
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/MembersInjectionBinding.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.auto.common.MoreElements.isAnnotationPresent;
+import static java.util.stream.Collectors.toList;
+
+import com.google.auto.value.AutoValue;
+import com.google.auto.value.extension.memoized.Memoized;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSortedSet;
+import dagger.model.BindingKind;
+import dagger.model.DependencyRequest;
+import java.util.Optional;
+import javax.inject.Inject;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+
+/** Represents the full members injection of a particular type. */
+@AutoValue
+public abstract class MembersInjectionBinding extends Binding {
+ @Override
+ public final Optional<Element> bindingElement() {
+ return Optional.of(membersInjectedType());
+ }
+
+ public abstract TypeElement membersInjectedType();
+
+ @Override
+ public abstract Optional<MembersInjectionBinding> unresolved();
+
+ @Override
+ public Optional<TypeElement> contributingModule() {
+ return Optional.empty();
+ }
+
+ /** The set of individual sites where {@link Inject} is applied. */
+ public abstract ImmutableSortedSet<InjectionSite> injectionSites();
+
+ @Override
+ public BindingType bindingType() {
+ return BindingType.MEMBERS_INJECTION;
+ }
+
+ @Override
+ public BindingKind kind() {
+ return BindingKind.MEMBERS_INJECTION;
+ }
+
+ @Override
+ public boolean isNullable() {
+ return false;
+ }
+
+ /**
+ * Returns {@code true} if any of this binding's injection sites are directly on the bound type.
+ */
+ public boolean hasLocalInjectionSites() {
+ return injectionSites()
+ .stream()
+ .anyMatch(
+ injectionSite ->
+ injectionSite.element().getEnclosingElement().equals(membersInjectedType()));
+ }
+
+ @Override
+ public boolean requiresModuleInstance() {
+ return false;
+ }
+
+ @Memoized
+ @Override
+ public abstract int hashCode();
+
+ // TODO(ronshapiro,dpb): simplify the equality semantics
+ @Override
+ public abstract boolean equals(Object obj);
+
+ /** Metadata about a field or method injection site. */
+ @AutoValue
+ public abstract static class InjectionSite {
+ /** The type of injection site. */
+ public enum Kind {
+ FIELD,
+ METHOD,
+ }
+
+ public abstract Kind kind();
+
+ public abstract Element element();
+
+ public abstract ImmutableSet<DependencyRequest> dependencies();
+
+ /**
+ * Returns the index of {@link #element()} in its parents {@code @Inject} members that have the
+ * same simple name. This method filters out private elements so that the results will be
+ * consistent independent of whether the build system uses header jars or not.
+ */
+ @Memoized
+ public int indexAmongAtInjectMembersWithSameSimpleName() {
+ return element()
+ .getEnclosingElement()
+ .getEnclosedElements()
+ .stream()
+ .filter(element -> isAnnotationPresent(element, Inject.class))
+ .filter(element -> !element.getModifiers().contains(Modifier.PRIVATE))
+ .filter(element -> element.getSimpleName().equals(this.element().getSimpleName()))
+ .collect(toList())
+ .indexOf(element());
+ }
+
+ public static InjectionSite field(VariableElement element, DependencyRequest dependency) {
+ return new AutoValue_MembersInjectionBinding_InjectionSite(
+ Kind.FIELD, element, ImmutableSet.of(dependency));
+ }
+
+ public static InjectionSite method(
+ ExecutableElement element, Iterable<DependencyRequest> dependencies) {
+ return new AutoValue_MembersInjectionBinding_InjectionSite(
+ Kind.METHOD, element, ImmutableSet.copyOf(dependencies));
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/MethodSignatureFormatter.java b/java/dagger/internal/codegen/binding/MethodSignatureFormatter.java
new file mode 100644
index 0000000..97c680f
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/MethodSignatureFormatter.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.common.base.Preconditions.checkState;
+import static dagger.internal.codegen.base.DiagnosticFormatting.stripCommonTypePrefixes;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.MoreTypes;
+import dagger.internal.codegen.base.Formatter;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Optional;
+import javax.inject.Inject;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.ExecutableType;
+import javax.lang.model.type.TypeMirror;
+
+/** Formats the signature of an {@link ExecutableElement} suitable for use in error messages. */
+public final class MethodSignatureFormatter extends Formatter<ExecutableElement> {
+ private final DaggerTypes types;
+ private final InjectionAnnotations injectionAnnotations;
+
+ @Inject
+ public MethodSignatureFormatter(DaggerTypes types, InjectionAnnotations injectionAnnotations) {
+ this.types = types;
+ this.injectionAnnotations = injectionAnnotations;
+ }
+
+ /**
+ * A formatter that uses the type where the method is declared for the annotations and name of the
+ * method, but the method's resolved type as a member of {@code declaredType} for the key.
+ */
+ public Formatter<ExecutableElement> typedFormatter(DeclaredType declaredType) {
+ return new Formatter<ExecutableElement>() {
+ @Override
+ public String format(ExecutableElement method) {
+ return MethodSignatureFormatter.this.format(
+ method,
+ MoreTypes.asExecutable(types.asMemberOf(declaredType, method)),
+ MoreElements.asType(method.getEnclosingElement()));
+ }
+ };
+ }
+
+ @Override
+ public String format(ExecutableElement method) {
+ return format(method, Optional.empty());
+ }
+
+ /**
+ * Formats an ExecutableElement as if it were contained within the container, if the container is
+ * present.
+ */
+ public String format(ExecutableElement method, Optional<DeclaredType> container) {
+ TypeElement type = MoreElements.asType(method.getEnclosingElement());
+ ExecutableType executableType = MoreTypes.asExecutable(method.asType());
+ if (container.isPresent()) {
+ executableType = MoreTypes.asExecutable(types.asMemberOf(container.get(), method));
+ type = MoreElements.asType(container.get().asElement());
+ }
+ return format(method, executableType, type);
+ }
+
+ private String format(
+ ExecutableElement method, ExecutableType methodType, TypeElement declaringType) {
+ StringBuilder builder = new StringBuilder();
+ // TODO(user): AnnotationMirror formatter.
+ List<? extends AnnotationMirror> annotations = method.getAnnotationMirrors();
+ if (!annotations.isEmpty()) {
+ Iterator<? extends AnnotationMirror> annotationIterator = annotations.iterator();
+ for (int i = 0; annotationIterator.hasNext(); i++) {
+ if (i > 0) {
+ builder.append(' ');
+ }
+ builder.append(formatAnnotation(annotationIterator.next()));
+ }
+ builder.append(' ');
+ }
+ if (method.getSimpleName().contentEquals("<init>")) {
+ builder.append(declaringType.getQualifiedName());
+ } else {
+ builder
+ .append(nameOfType(methodType.getReturnType()))
+ .append(' ')
+ .append(declaringType.getQualifiedName())
+ .append('.')
+ .append(method.getSimpleName());
+ }
+ builder.append('(');
+ checkState(method.getParameters().size() == methodType.getParameterTypes().size());
+ Iterator<? extends VariableElement> parameters = method.getParameters().iterator();
+ Iterator<? extends TypeMirror> parameterTypes = methodType.getParameterTypes().iterator();
+ for (int i = 0; parameters.hasNext(); i++) {
+ if (i > 0) {
+ builder.append(", ");
+ }
+ appendParameter(builder, parameters.next(), parameterTypes.next());
+ }
+ builder.append(')');
+ return builder.toString();
+ }
+
+ private void appendParameter(StringBuilder builder, VariableElement parameter, TypeMirror type) {
+ injectionAnnotations
+ .getQualifier(parameter)
+ .ifPresent(
+ qualifier -> {
+ builder.append(formatAnnotation(qualifier)).append(' ');
+ });
+ builder.append(nameOfType(type));
+ }
+
+ private static String nameOfType(TypeMirror type) {
+ return stripCommonTypePrefixes(type.toString());
+ }
+
+ private static String formatAnnotation(AnnotationMirror annotation) {
+ return stripCommonTypePrefixes(annotation.toString());
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/ModuleDescriptor.java b/java/dagger/internal/codegen/binding/ModuleDescriptor.java
new file mode 100644
index 0000000..c471f94
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/ModuleDescriptor.java
@@ -0,0 +1,267 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.auto.common.MoreElements.asExecutable;
+import static com.google.auto.common.MoreElements.getPackage;
+import static com.google.auto.common.MoreElements.isAnnotationPresent;
+import static com.google.common.base.CaseFormat.LOWER_CAMEL;
+import static com.google.common.base.CaseFormat.UPPER_CAMEL;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Verify.verify;
+import static com.google.common.collect.Iterables.transform;
+import static dagger.internal.codegen.base.ModuleAnnotation.moduleAnnotation;
+import static dagger.internal.codegen.base.Util.reentrantComputeIfAbsent;
+import static dagger.internal.codegen.binding.SourceFiles.classFileName;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static dagger.internal.codegen.langmodel.DaggerElements.getMethodDescriptor;
+import static dagger.internal.codegen.langmodel.DaggerElements.isAnnotationPresent;
+import static javax.lang.model.type.TypeKind.DECLARED;
+import static javax.lang.model.type.TypeKind.NONE;
+import static javax.lang.model.util.ElementFilter.methodsIn;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.MoreTypes;
+import com.google.auto.value.AutoValue;
+import com.google.auto.value.extension.memoized.Memoized;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.graph.Traverser;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.squareup.javapoet.ClassName;
+import dagger.Binds;
+import dagger.BindsOptionalOf;
+import dagger.Module;
+import dagger.Provides;
+import dagger.internal.codegen.base.ClearableCache;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.model.Key;
+import dagger.multibindings.Multibinds;
+import dagger.producers.Produces;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeMirror;
+
+/** Contains metadata that describes a module. */
+@AutoValue
+public abstract class ModuleDescriptor {
+
+ public abstract TypeElement moduleElement();
+
+ abstract ImmutableSet<TypeElement> includedModules();
+
+ public abstract ImmutableSet<ContributionBinding> bindings();
+
+ /** The multibinding declarations contained in this module. */
+ abstract ImmutableSet<MultibindingDeclaration> multibindingDeclarations();
+
+ /** The {@link Module#subcomponents() subcomponent declarations} contained in this module. */
+ abstract ImmutableSet<SubcomponentDeclaration> subcomponentDeclarations();
+
+ /** The {@link Binds} method declarations that define delegate bindings. */
+ abstract ImmutableSet<DelegateDeclaration> delegateDeclarations();
+
+ /** The {@link BindsOptionalOf} method declarations that define optional bindings. */
+ abstract ImmutableSet<OptionalBindingDeclaration> optionalDeclarations();
+
+ /** The kind of the module. */
+ public abstract ModuleKind kind();
+
+ /** Returns all of the bindings declared in this module. */
+ @Memoized
+ public ImmutableSet<BindingDeclaration> allBindingDeclarations() {
+ return ImmutableSet.<BindingDeclaration>builder()
+ .addAll(bindings())
+ .addAll(delegateDeclarations())
+ .addAll(multibindingDeclarations())
+ .addAll(optionalDeclarations())
+ .addAll(subcomponentDeclarations())
+ .build();
+ }
+
+ /** Returns the keys of all bindings declared by this module. */
+ ImmutableSet<Key> allBindingKeys() {
+ return allBindingDeclarations().stream().map(BindingDeclaration::key).collect(toImmutableSet());
+ }
+
+ /** A {@link ModuleDescriptor} factory. */
+ @Singleton
+ public static final class Factory implements ClearableCache {
+ private final DaggerElements elements;
+ private final KotlinMetadataUtil metadataUtil;
+ private final BindingFactory bindingFactory;
+ private final MultibindingDeclaration.Factory multibindingDeclarationFactory;
+ private final DelegateDeclaration.Factory bindingDelegateDeclarationFactory;
+ private final SubcomponentDeclaration.Factory subcomponentDeclarationFactory;
+ private final OptionalBindingDeclaration.Factory optionalBindingDeclarationFactory;
+ private final Map<TypeElement, ModuleDescriptor> cache = new HashMap<>();
+
+ @Inject
+ Factory(
+ DaggerElements elements,
+ KotlinMetadataUtil metadataUtil,
+ BindingFactory bindingFactory,
+ MultibindingDeclaration.Factory multibindingDeclarationFactory,
+ DelegateDeclaration.Factory bindingDelegateDeclarationFactory,
+ SubcomponentDeclaration.Factory subcomponentDeclarationFactory,
+ OptionalBindingDeclaration.Factory optionalBindingDeclarationFactory) {
+ this.elements = elements;
+ this.metadataUtil = metadataUtil;
+ this.bindingFactory = bindingFactory;
+ this.multibindingDeclarationFactory = multibindingDeclarationFactory;
+ this.bindingDelegateDeclarationFactory = bindingDelegateDeclarationFactory;
+ this.subcomponentDeclarationFactory = subcomponentDeclarationFactory;
+ this.optionalBindingDeclarationFactory = optionalBindingDeclarationFactory;
+ }
+
+ public ModuleDescriptor create(TypeElement moduleElement) {
+ return reentrantComputeIfAbsent(cache, moduleElement, this::createUncached);
+ }
+
+ public ModuleDescriptor createUncached(TypeElement moduleElement) {
+ ImmutableSet.Builder<ContributionBinding> bindings = ImmutableSet.builder();
+ ImmutableSet.Builder<DelegateDeclaration> delegates = ImmutableSet.builder();
+ ImmutableSet.Builder<MultibindingDeclaration> multibindingDeclarations =
+ ImmutableSet.builder();
+ ImmutableSet.Builder<OptionalBindingDeclaration> optionalDeclarations =
+ ImmutableSet.builder();
+
+ for (ExecutableElement moduleMethod : methodsIn(elements.getAllMembers(moduleElement))) {
+ if (isAnnotationPresent(moduleMethod, Provides.class)) {
+ bindings.add(bindingFactory.providesMethodBinding(moduleMethod, moduleElement));
+ }
+ if (isAnnotationPresent(moduleMethod, Produces.class)) {
+ bindings.add(bindingFactory.producesMethodBinding(moduleMethod, moduleElement));
+ }
+ if (isAnnotationPresent(moduleMethod, Binds.class)) {
+ delegates.add(bindingDelegateDeclarationFactory.create(moduleMethod, moduleElement));
+ }
+ if (isAnnotationPresent(moduleMethod, Multibinds.class)) {
+ multibindingDeclarations.add(
+ multibindingDeclarationFactory.forMultibindsMethod(moduleMethod, moduleElement));
+ }
+ if (isAnnotationPresent(moduleMethod, BindsOptionalOf.class)) {
+ optionalDeclarations.add(
+ optionalBindingDeclarationFactory.forMethod(moduleMethod, moduleElement));
+ }
+ }
+
+ if (metadataUtil.hasEnclosedCompanionObject(moduleElement)) {
+ collectCompanionModuleBindings(moduleElement, bindings);
+ }
+
+ return new AutoValue_ModuleDescriptor(
+ moduleElement,
+ ImmutableSet.copyOf(collectIncludedModules(new LinkedHashSet<>(), moduleElement)),
+ bindings.build(),
+ multibindingDeclarations.build(),
+ subcomponentDeclarationFactory.forModule(moduleElement),
+ delegates.build(),
+ optionalDeclarations.build(),
+ ModuleKind.forAnnotatedElement(moduleElement).get());
+ }
+
+ private void collectCompanionModuleBindings(
+ TypeElement moduleElement, ImmutableSet.Builder<ContributionBinding> bindings) {
+ checkArgument(metadataUtil.hasEnclosedCompanionObject(moduleElement));
+ TypeElement companionModule = metadataUtil.getEnclosedCompanionObject(moduleElement);
+ ImmutableSet<String> bindingElementDescriptors =
+ bindings.build().stream()
+ .map(binding -> getMethodDescriptor(asExecutable(binding.bindingElement().get())))
+ .collect(toImmutableSet());
+ methodsIn(elements.getAllMembers(companionModule)).stream()
+ // Binding methods in companion objects with @JvmStatic are mirrored in the enclosing
+ // class, therefore we should ignore it or else it'll be a duplicate binding.
+ .filter(method -> !KotlinMetadataUtil.isJvmStaticPresent(method))
+ // Fallback strategy for de-duping contributing bindings in the companion module with
+ // @JvmStatic by comparing descriptors. Contributing bindings are the only valid bindings
+ // a companion module can declare. See: https://youtrack.jetbrains.com/issue/KT-35104
+ // TODO(danysantiago): Checks qualifiers too.
+ .filter(method -> !bindingElementDescriptors.contains(getMethodDescriptor(method)))
+ .forEach(
+ method -> {
+ if (isAnnotationPresent(method, Provides.class)) {
+ bindings.add(bindingFactory.providesMethodBinding(method, companionModule));
+ }
+ if (isAnnotationPresent(method, Produces.class)) {
+ bindings.add(bindingFactory.producesMethodBinding(method, companionModule));
+ }
+ });
+ }
+
+ /** Returns all the modules transitively included by given modules, including the arguments. */
+ ImmutableSet<ModuleDescriptor> transitiveModules(Iterable<TypeElement> modules) {
+ return ImmutableSet.copyOf(
+ Traverser.forGraph(
+ (ModuleDescriptor module) -> transform(module.includedModules(), this::create))
+ .depthFirstPreOrder(transform(modules, this::create)));
+ }
+
+ @CanIgnoreReturnValue
+ private Set<TypeElement> collectIncludedModules(
+ Set<TypeElement> includedModules, TypeElement moduleElement) {
+ TypeMirror superclass = moduleElement.getSuperclass();
+ if (!superclass.getKind().equals(NONE)) {
+ verify(superclass.getKind().equals(DECLARED));
+ TypeElement superclassElement = MoreTypes.asTypeElement(superclass);
+ if (!superclassElement.getQualifiedName().contentEquals(Object.class.getCanonicalName())) {
+ collectIncludedModules(includedModules, superclassElement);
+ }
+ }
+ moduleAnnotation(moduleElement)
+ .ifPresent(
+ moduleAnnotation -> {
+ includedModules.addAll(moduleAnnotation.includes());
+ includedModules.addAll(implicitlyIncludedModules(moduleElement));
+ });
+ return includedModules;
+ }
+
+ // @ContributesAndroidInjector generates a module that is implicitly included in the enclosing
+ // module
+ private ImmutableSet<TypeElement> implicitlyIncludedModules(TypeElement moduleElement) {
+ TypeElement contributesAndroidInjector =
+ elements.getTypeElement("dagger.android.ContributesAndroidInjector");
+ if (contributesAndroidInjector == null) {
+ return ImmutableSet.of();
+ }
+ return methodsIn(moduleElement.getEnclosedElements()).stream()
+ .filter(method -> isAnnotationPresent(method, contributesAndroidInjector.asType()))
+ .map(method -> elements.checkTypePresent(implicitlyIncludedModuleName(method)))
+ .collect(toImmutableSet());
+ }
+
+ private String implicitlyIncludedModuleName(ExecutableElement method) {
+ return getPackage(method).getQualifiedName()
+ + "."
+ + classFileName(ClassName.get(MoreElements.asType(method.getEnclosingElement())))
+ + "_"
+ + LOWER_CAMEL.to(UPPER_CAMEL, method.getSimpleName().toString());
+ }
+
+ @Override
+ public void clearCache() {
+ cache.clear();
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/ModuleKind.java b/java/dagger/internal/codegen/binding/ModuleKind.java
new file mode 100644
index 0000000..6b52f04
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/ModuleKind.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.auto.common.MoreElements.asType;
+import static com.google.common.base.Preconditions.checkArgument;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static dagger.internal.codegen.langmodel.DaggerElements.getAnnotationMirror;
+
+import com.google.auto.common.MoreElements;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import dagger.Module;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.producers.ProducerModule;
+import java.lang.annotation.Annotation;
+import java.util.EnumSet;
+import java.util.Optional;
+import java.util.Set;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.TypeElement;
+
+/** Enumeration of the kinds of modules. */
+public enum ModuleKind {
+ /** {@code @Module} */
+ MODULE(Module.class),
+
+ /** {@code @ProducerModule} */
+ PRODUCER_MODULE(ProducerModule.class);
+
+ /** Returns the annotations for modules of the given kinds. */
+ public static ImmutableSet<Class<? extends Annotation>> annotationsFor(Set<ModuleKind> kinds) {
+ return kinds.stream().map(ModuleKind::annotation).collect(toImmutableSet());
+ }
+
+ /**
+ * Returns the kind of an annotated element if it is annotated with one of the module {@linkplain
+ * #annotation() annotations}.
+ *
+ * @throws IllegalArgumentException if the element is annotated with more than one of the module
+ * annotations
+ */
+ public static Optional<ModuleKind> forAnnotatedElement(TypeElement element) {
+ Set<ModuleKind> kinds = EnumSet.noneOf(ModuleKind.class);
+ for (ModuleKind kind : values()) {
+ if (MoreElements.isAnnotationPresent(element, kind.annotation())) {
+ kinds.add(kind);
+ }
+ }
+
+ if (kinds.size() > 1) {
+ throw new IllegalArgumentException(
+ element + " cannot be annotated with more than one of " + annotationsFor(kinds));
+ }
+ return kinds.stream().findAny();
+ }
+
+ public static void checkIsModule(TypeElement moduleElement, KotlinMetadataUtil metadataUtil) {
+ // If the type element is a Kotlin companion object, then assert it is a module if its enclosing
+ // type is a module.
+ if (metadataUtil.isCompanionObjectClass(moduleElement)) {
+ checkArgument(forAnnotatedElement(asType(moduleElement.getEnclosingElement())).isPresent());
+ } else {
+ checkArgument(forAnnotatedElement(moduleElement).isPresent());
+ }
+ }
+
+ private final Class<? extends Annotation> moduleAnnotation;
+
+ ModuleKind(Class<? extends Annotation> moduleAnnotation) {
+ this.moduleAnnotation = moduleAnnotation;
+ }
+
+ /**
+ * Returns the annotation mirror for this module kind on the given type.
+ *
+ * @throws IllegalArgumentException if the annotation is not present on the type
+ */
+ public AnnotationMirror getModuleAnnotation(TypeElement element) {
+ Optional<AnnotationMirror> result = getAnnotationMirror(element, moduleAnnotation);
+ checkArgument(
+ result.isPresent(), "annotation %s is not present on type %s", moduleAnnotation, element);
+ return result.get();
+ }
+
+ /** Returns the annotation that marks a module of this kind. */
+ public Class<? extends Annotation> annotation() {
+ return moduleAnnotation;
+ }
+
+ /** Returns the kinds of modules that a module of this kind is allowed to include. */
+ public ImmutableSet<ModuleKind> legalIncludedModuleKinds() {
+ switch (this) {
+ case MODULE:
+ return Sets.immutableEnumSet(MODULE);
+ case PRODUCER_MODULE:
+ return Sets.immutableEnumSet(MODULE, PRODUCER_MODULE);
+ }
+ throw new AssertionError(this);
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/MultibindingDeclaration.java b/java/dagger/internal/codegen/binding/MultibindingDeclaration.java
new file mode 100644
index 0000000..f1d3f8d
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/MultibindingDeclaration.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.auto.common.MoreElements.isAnnotationPresent;
+import static com.google.common.base.Preconditions.checkArgument;
+
+import com.google.auto.common.MoreTypes;
+import com.google.auto.value.AutoValue;
+import com.google.auto.value.extension.memoized.Memoized;
+import dagger.internal.codegen.base.ContributionType;
+import dagger.internal.codegen.base.ContributionType.HasContributionType;
+import dagger.internal.codegen.base.MapType;
+import dagger.internal.codegen.base.SetType;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.Key;
+import dagger.multibindings.Multibinds;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import javax.inject.Inject;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.ExecutableType;
+import javax.lang.model.type.TypeMirror;
+
+/**
+ * A declaration that a multibinding with a certain key is available to be injected in a component
+ * even if the component has no multibindings for that key. Identified by a map- or set-returning
+ * method annotated with {@link Multibinds @Multibinds}.
+ */
+@AutoValue
+public abstract class MultibindingDeclaration extends BindingDeclaration
+ implements HasContributionType {
+
+ /**
+ * The map or set key whose availability is declared. For maps, this will be {@code Map<K,
+ * Provider<V>>}. For sets, this will be {@code Set<T>}.
+ */
+ @Override
+ public abstract Key key();
+
+ /**
+ * {@link ContributionType#SET} if the declared type is a {@link Set}, or
+ * {@link ContributionType#MAP} if it is a {@link Map}.
+ */
+ @Override
+ public abstract ContributionType contributionType();
+
+ @Memoized
+ @Override
+ public abstract int hashCode();
+
+ @Override
+ public abstract boolean equals(Object obj);
+
+ /** A factory for {@link MultibindingDeclaration}s. */
+ public static final class Factory {
+ private final DaggerTypes types;
+ private final KeyFactory keyFactory;
+
+ @Inject
+ Factory(DaggerTypes types, KeyFactory keyFactory) {
+ this.types = types;
+ this.keyFactory = keyFactory;
+ }
+
+ /** A multibinding declaration for a {@link Multibinds @Multibinds} method. */
+ MultibindingDeclaration forMultibindsMethod(
+ ExecutableElement moduleMethod, TypeElement moduleElement) {
+ checkArgument(isAnnotationPresent(moduleMethod, Multibinds.class));
+ return forDeclaredMethod(
+ moduleMethod,
+ MoreTypes.asExecutable(
+ types.asMemberOf(MoreTypes.asDeclared(moduleElement.asType()), moduleMethod)),
+ moduleElement);
+ }
+
+ private MultibindingDeclaration forDeclaredMethod(
+ ExecutableElement method,
+ ExecutableType methodType,
+ TypeElement contributingType) {
+ TypeMirror returnType = methodType.getReturnType();
+ checkArgument(
+ SetType.isSet(returnType) || MapType.isMap(returnType),
+ "%s must return a set or map",
+ method);
+ return new AutoValue_MultibindingDeclaration(
+ Optional.<Element>of(method),
+ Optional.of(contributingType),
+ keyFactory.forMultibindsMethod(methodType, method),
+ contributionType(returnType));
+ }
+
+ private ContributionType contributionType(TypeMirror returnType) {
+ if (MapType.isMap(returnType)) {
+ return ContributionType.MAP;
+ } else if (SetType.isSet(returnType)) {
+ return ContributionType.SET;
+ } else {
+ throw new IllegalArgumentException("Must be Map or Set: " + returnType);
+ }
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/OptionalBindingDeclaration.java b/java/dagger/internal/codegen/binding/OptionalBindingDeclaration.java
new file mode 100644
index 0000000..d7ba7bc
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/OptionalBindingDeclaration.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.auto.common.MoreElements.isAnnotationPresent;
+import static com.google.common.base.Preconditions.checkArgument;
+
+import com.google.auto.value.AutoValue;
+import com.google.auto.value.extension.memoized.Memoized;
+import dagger.BindsOptionalOf;
+import dagger.model.Key;
+import java.util.Optional;
+import javax.inject.Inject;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+
+/** A {@link BindsOptionalOf} declaration. */
+@AutoValue
+abstract class OptionalBindingDeclaration extends BindingDeclaration {
+
+ /**
+ * {@inheritDoc}
+ *
+ * <p>The key's type is the method's return type, even though the synthetic bindings will be for
+ * {@code Optional} of derived types.
+ */
+ @Override
+ public abstract Key key();
+
+ @Memoized
+ @Override
+ public abstract int hashCode();
+
+ @Override
+ public abstract boolean equals(Object obj);
+
+ static class Factory {
+ private final KeyFactory keyFactory;
+
+ @Inject
+ Factory(KeyFactory keyFactory) {
+ this.keyFactory = keyFactory;
+ }
+
+ OptionalBindingDeclaration forMethod(ExecutableElement method, TypeElement contributingModule) {
+ checkArgument(isAnnotationPresent(method, BindsOptionalOf.class));
+ return new AutoValue_OptionalBindingDeclaration(
+ Optional.<Element>of(method),
+ Optional.of(contributingModule),
+ keyFactory.forBindsOptionalOfMethod(method, contributingModule));
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/ProductionBinding.java b/java/dagger/internal/codegen/binding/ProductionBinding.java
new file mode 100644
index 0000000..ad85a68
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/ProductionBinding.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static dagger.internal.codegen.langmodel.DaggerTypes.isFutureType;
+
+import com.google.auto.value.AutoValue;
+import com.google.auto.value.extension.memoized.Memoized;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import dagger.internal.codegen.base.ContributionType;
+import dagger.internal.codegen.base.SetType;
+import dagger.model.DependencyRequest;
+import dagger.model.Key;
+import java.util.Optional;
+import java.util.stream.Stream;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.type.TypeMirror;
+
+/** A value object representing the mechanism by which a {@link Key} can be produced. */
+@AutoValue
+public abstract class ProductionBinding extends ContributionBinding {
+
+ @Override
+ public BindingType bindingType() {
+ return BindingType.PRODUCTION;
+ }
+
+ @Override
+ public abstract Optional<ProductionBinding> unresolved();
+
+ @Override
+ public ImmutableSet<DependencyRequest> implicitDependencies() {
+ return Stream.of(executorRequest(), monitorRequest())
+ .filter(Optional::isPresent)
+ .map(Optional::get)
+ .collect(toImmutableSet());
+ }
+
+ /** What kind of object a {@code @Produces}-annotated method returns. */
+ public enum ProductionKind {
+ /** A value. */
+ IMMEDIATE,
+ /** A {@code ListenableFuture<T>}. */
+ FUTURE,
+ /** A {@code Set<ListenableFuture<T>>}. */
+ SET_OF_FUTURE;
+
+ /** Returns the kind of object a {@code @Produces}-annotated method returns. */
+ public static ProductionKind fromProducesMethod(ExecutableElement producesMethod) {
+ if (isFutureType(producesMethod.getReturnType())) {
+ return FUTURE;
+ } else if (ContributionType.fromBindingElement(producesMethod)
+ .equals(ContributionType.SET_VALUES)
+ && isFutureType(SetType.from(producesMethod.getReturnType()).elementType())) {
+ return SET_OF_FUTURE;
+ } else {
+ return IMMEDIATE;
+ }
+ }
+ }
+
+ /**
+ * Returns the kind of object the produces method returns. All production bindings from
+ * {@code @Produces} methods will have a production kind, but synthetic production bindings may
+ * not.
+ */
+ public abstract Optional<ProductionKind> productionKind();
+
+ /** Returns the list of types in the throws clause of the method. */
+ public abstract ImmutableList<? extends TypeMirror> thrownTypes();
+
+ /**
+ * If this production requires an executor, this will be the corresponding request. All
+ * production bindings from {@code @Produces} methods will have an executor request, but
+ * synthetic production bindings may not.
+ */
+ abstract Optional<DependencyRequest> executorRequest();
+
+ /** If this production requires a monitor, this will be the corresponding request. All
+ * production bindings from {@code @Produces} methods will have a monitor request, but synthetic
+ * production bindings may not.
+ */
+ abstract Optional<DependencyRequest> monitorRequest();
+
+ // Profiling determined that this method is called enough times that memoizing it had a measurable
+ // performance improvement for large components.
+ @Memoized
+ @Override
+ public boolean requiresModuleInstance() {
+ return super.requiresModuleInstance();
+ }
+
+ public static Builder builder() {
+ return new AutoValue_ProductionBinding.Builder()
+ .explicitDependencies(ImmutableList.<DependencyRequest>of())
+ .thrownTypes(ImmutableList.<TypeMirror>of());
+ }
+
+ @Override
+ public abstract Builder toBuilder();
+
+ @Memoized
+ @Override
+ public abstract int hashCode();
+
+ // TODO(ronshapiro,dpb): simplify the equality semantics
+ @Override
+ public abstract boolean equals(Object obj);
+
+ /** A {@link ProductionBinding} builder. */
+ @AutoValue.Builder
+ @CanIgnoreReturnValue
+ public abstract static class Builder
+ extends ContributionBinding.Builder<ProductionBinding, Builder> {
+
+ @Override
+ public Builder dependencies(Iterable<DependencyRequest> dependencies) {
+ return explicitDependencies(dependencies);
+ }
+
+ abstract Builder explicitDependencies(Iterable<DependencyRequest> dependencies);
+
+ abstract Builder productionKind(ProductionKind productionKind);
+
+ @Override
+ public abstract Builder unresolved(ProductionBinding unresolved);
+
+ abstract Builder thrownTypes(Iterable<? extends TypeMirror> thrownTypes);
+
+ abstract Builder executorRequest(DependencyRequest executorRequest);
+
+ abstract Builder monitorRequest(DependencyRequest monitorRequest);
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/ProvisionBinding.java b/java/dagger/internal/codegen/binding/ProvisionBinding.java
new file mode 100644
index 0000000..c917dd6
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/ProvisionBinding.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static dagger.model.BindingKind.COMPONENT_PROVISION;
+import static dagger.model.BindingKind.PROVISION;
+
+import com.google.auto.value.AutoValue;
+import com.google.auto.value.extension.memoized.Memoized;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSortedSet;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import dagger.internal.codegen.binding.MembersInjectionBinding.InjectionSite;
+import dagger.internal.codegen.compileroption.CompilerOptions;
+import dagger.model.BindingKind;
+import dagger.model.DependencyRequest;
+import dagger.model.Key;
+import dagger.model.Scope;
+import java.util.Optional;
+
+/** A value object representing the mechanism by which a {@link Key} can be provided. */
+@AutoValue
+public abstract class ProvisionBinding extends ContributionBinding {
+
+ @Override
+ @Memoized
+ public ImmutableSet<DependencyRequest> explicitDependencies() {
+ return ImmutableSet.<DependencyRequest>builder()
+ .addAll(provisionDependencies())
+ .addAll(membersInjectionDependencies())
+ .build();
+ }
+
+ /**
+ * Dependencies necessary to invoke an {@code @Inject} constructor or {@code @Provides} method.
+ */
+ public abstract ImmutableSet<DependencyRequest> provisionDependencies();
+
+ @Memoized
+ ImmutableSet<DependencyRequest> membersInjectionDependencies() {
+ return injectionSites()
+ .stream()
+ .flatMap(i -> i.dependencies().stream())
+ .collect(toImmutableSet());
+ }
+
+ /**
+ * {@link InjectionSite}s for all {@code @Inject} members if {@link #kind()} is {@link
+ * BindingKind#INJECTION}, otherwise empty.
+ */
+ public abstract ImmutableSortedSet<InjectionSite> injectionSites();
+
+ @Override
+ public BindingType bindingType() {
+ return BindingType.PROVISION;
+ }
+
+ @Override
+ public abstract Optional<ProvisionBinding> unresolved();
+
+ // TODO(ronshapiro): we should be able to remove this, but AutoValue barks on the Builder's scope
+ // method, saying that the method doesn't correspond to a property of ProvisionBinding
+ @Override
+ public abstract Optional<Scope> scope();
+
+ public static Builder builder() {
+ return new AutoValue_ProvisionBinding.Builder()
+ .provisionDependencies(ImmutableSet.of())
+ .injectionSites(ImmutableSortedSet.of());
+ }
+
+ @Override
+ public abstract Builder toBuilder();
+
+ private static final ImmutableSet<BindingKind> KINDS_TO_CHECK_FOR_NULL =
+ ImmutableSet.of(PROVISION, COMPONENT_PROVISION);
+
+ public boolean shouldCheckForNull(CompilerOptions compilerOptions) {
+ return KINDS_TO_CHECK_FOR_NULL.contains(kind())
+ && !contributedPrimitiveType().isPresent()
+ && !nullableType().isPresent()
+ && compilerOptions.doCheckForNulls();
+ }
+
+ // Profiling determined that this method is called enough times that memoizing it had a measurable
+ // performance improvement for large components.
+ @Memoized
+ @Override
+ public boolean requiresModuleInstance() {
+ return super.requiresModuleInstance();
+ }
+
+ @Memoized
+ @Override
+ public abstract int hashCode();
+
+ // TODO(ronshapiro,dpb): simplify the equality semantics
+ @Override
+ public abstract boolean equals(Object obj);
+
+ /** A {@link ProvisionBinding} builder. */
+ @AutoValue.Builder
+ @CanIgnoreReturnValue
+ public abstract static class Builder
+ extends ContributionBinding.Builder<ProvisionBinding, Builder> {
+
+ @Override
+ public Builder dependencies(Iterable<DependencyRequest> dependencies) {
+ return provisionDependencies(dependencies);
+ }
+
+ abstract Builder provisionDependencies(Iterable<DependencyRequest> provisionDependencies);
+
+ public abstract Builder injectionSites(ImmutableSortedSet<InjectionSite> injectionSites);
+
+ @Override
+ public abstract Builder unresolved(ProvisionBinding unresolved);
+
+ public abstract Builder scope(Optional<Scope> scope);
+ }
+
+}
diff --git a/java/dagger/internal/codegen/binding/ResolvedBindings.java b/java/dagger/internal/codegen/binding/ResolvedBindings.java
new file mode 100644
index 0000000..74301fe
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/ResolvedBindings.java
@@ -0,0 +1,172 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.collect.Iterables.getOnlyElement;
+
+import com.google.auto.value.AutoValue;
+import com.google.auto.value.extension.memoized.Memoized;
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSetMultimap;
+import com.google.common.collect.Multimap;
+import dagger.model.Key;
+import javax.lang.model.element.TypeElement;
+
+/**
+ * The collection of bindings that have been resolved for a key. For valid graphs, contains exactly
+ * one binding.
+ *
+ * <p>Separate {@link ResolvedBindings} instances should be used if a {@link
+ * MembersInjectionBinding} and a {@link ProvisionBinding} for the same key exist in the same
+ * component. (This will only happen if a type has an {@code @Inject} constructor and members, the
+ * component has a members injection method, and the type is also requested normally.)
+ */
+@AutoValue
+abstract class ResolvedBindings {
+ /** The binding key for which the {@link #bindings()} have been resolved. */
+ abstract Key key();
+
+ /**
+ * The {@link ContributionBinding}s for {@link #key()} indexed by the component that owns the
+ * binding. Each key in the multimap is a part of the same component ancestry.
+ */
+ abstract ImmutableSetMultimap<TypeElement, ContributionBinding> allContributionBindings();
+
+ /**
+ * The {@link MembersInjectionBinding}s for {@link #key()} indexed by the component that owns the
+ * binding. Each key in the map is a part of the same component ancestry.
+ */
+ abstract ImmutableMap<TypeElement, MembersInjectionBinding> allMembersInjectionBindings();
+
+ /** The multibinding declarations for {@link #key()}. */
+ abstract ImmutableSet<MultibindingDeclaration> multibindingDeclarations();
+
+ /** The subcomponent declarations for {@link #key()}. */
+ abstract ImmutableSet<SubcomponentDeclaration> subcomponentDeclarations();
+
+ /** The optional binding declarations for {@link #key()}. */
+ abstract ImmutableSet<OptionalBindingDeclaration> optionalBindingDeclarations();
+
+ // Computing the hash code is an expensive operation.
+ @Memoized
+ @Override
+ public abstract int hashCode();
+
+ // Suppresses ErrorProne warning that hashCode was overridden w/o equals
+ @Override
+ public abstract boolean equals(Object other);
+
+ /** All bindings for {@link #key()}, indexed by the component that owns the binding. */
+ final ImmutableSetMultimap<TypeElement, ? extends Binding> allBindings() {
+ return !allMembersInjectionBindings().isEmpty()
+ ? allMembersInjectionBindings().asMultimap()
+ : allContributionBindings();
+ }
+
+ /** All bindings for {@link #key()}, regardless of which component owns them. */
+ final ImmutableCollection<? extends Binding> bindings() {
+ return allBindings().values();
+ }
+
+ /**
+ * {@code true} if there are no {@link #bindings()}, {@link #multibindingDeclarations()}, {@link
+ * #optionalBindingDeclarations()}, or {@link #subcomponentDeclarations()}.
+ */
+ final boolean isEmpty() {
+ return allMembersInjectionBindings().isEmpty()
+ && allContributionBindings().isEmpty()
+ && multibindingDeclarations().isEmpty()
+ && optionalBindingDeclarations().isEmpty()
+ && subcomponentDeclarations().isEmpty();
+ }
+
+ /** All bindings for {@link #key()} that are owned by a component. */
+ ImmutableSet<? extends Binding> bindingsOwnedBy(ComponentDescriptor component) {
+ return allBindings().get(component.typeElement());
+ }
+
+ /**
+ * All contribution bindings, regardless of owning component. Empty if this is a members-injection
+ * binding.
+ */
+ @Memoized
+ ImmutableSet<ContributionBinding> contributionBindings() {
+ // TODO(ronshapiro): consider optimizing ImmutableSet.copyOf(Collection) for small immutable
+ // collections so that it doesn't need to call toArray(). Even though this method is memoized,
+ // toArray() can take ~150ms for large components, and there are surely other places in the
+ // processor that can benefit from this.
+ return ImmutableSet.copyOf(allContributionBindings().values());
+ }
+
+ /** The component that owns {@code binding}. */
+ final TypeElement owningComponent(ContributionBinding binding) {
+ checkArgument(
+ contributionBindings().contains(binding),
+ "binding is not resolved for %s: %s",
+ key(),
+ binding);
+ return getOnlyElement(allContributionBindings().inverse().get(binding));
+ }
+
+ /** Creates a {@link ResolvedBindings} for contribution bindings. */
+ static ResolvedBindings forContributionBindings(
+ Key key,
+ Multimap<TypeElement, ContributionBinding> contributionBindings,
+ Iterable<MultibindingDeclaration> multibindings,
+ Iterable<SubcomponentDeclaration> subcomponentDeclarations,
+ Iterable<OptionalBindingDeclaration> optionalBindingDeclarations) {
+ return new AutoValue_ResolvedBindings(
+ key,
+ ImmutableSetMultimap.copyOf(contributionBindings),
+ ImmutableMap.of(),
+ ImmutableSet.copyOf(multibindings),
+ ImmutableSet.copyOf(subcomponentDeclarations),
+ ImmutableSet.copyOf(optionalBindingDeclarations));
+ }
+
+ /**
+ * Creates a {@link ResolvedBindings} for members injection bindings.
+ */
+ static ResolvedBindings forMembersInjectionBinding(
+ Key key,
+ ComponentDescriptor owningComponent,
+ MembersInjectionBinding ownedMembersInjectionBinding) {
+ return new AutoValue_ResolvedBindings(
+ key,
+ ImmutableSetMultimap.of(),
+ ImmutableMap.of(owningComponent.typeElement(), ownedMembersInjectionBinding),
+ ImmutableSet.of(),
+ ImmutableSet.of(),
+ ImmutableSet.of());
+ }
+
+ /**
+ * Creates a {@link ResolvedBindings} appropriate for when there are no bindings for the key.
+ */
+ static ResolvedBindings noBindings(Key key) {
+ return new AutoValue_ResolvedBindings(
+ key,
+ ImmutableSetMultimap.of(),
+ ImmutableMap.of(),
+ ImmutableSet.of(),
+ ImmutableSet.of(),
+ ImmutableSet.of());
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/SourceFiles.java b/java/dagger/internal/codegen/binding/SourceFiles.java
new file mode 100644
index 0000000..3b6d9d9
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/SourceFiles.java
@@ -0,0 +1,311 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.common.base.CaseFormat.LOWER_CAMEL;
+import static com.google.common.base.CaseFormat.UPPER_CAMEL;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.base.Verify.verify;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
+import static dagger.internal.codegen.javapoet.TypeNames.DOUBLE_CHECK;
+import static dagger.internal.codegen.javapoet.TypeNames.MAP_FACTORY;
+import static dagger.internal.codegen.javapoet.TypeNames.MAP_OF_PRODUCED_PRODUCER;
+import static dagger.internal.codegen.javapoet.TypeNames.MAP_OF_PRODUCER_PRODUCER;
+import static dagger.internal.codegen.javapoet.TypeNames.MAP_PRODUCER;
+import static dagger.internal.codegen.javapoet.TypeNames.MAP_PROVIDER_FACTORY;
+import static dagger.internal.codegen.javapoet.TypeNames.PROVIDER_OF_LAZY;
+import static dagger.internal.codegen.javapoet.TypeNames.SET_FACTORY;
+import static dagger.internal.codegen.javapoet.TypeNames.SET_OF_PRODUCED_PRODUCER;
+import static dagger.internal.codegen.javapoet.TypeNames.SET_PRODUCER;
+import static dagger.model.BindingKind.ASSISTED_INJECTION;
+import static dagger.model.BindingKind.INJECTION;
+import static dagger.model.BindingKind.MULTIBOUND_MAP;
+import static dagger.model.BindingKind.MULTIBOUND_SET;
+import static javax.lang.model.SourceVersion.isName;
+
+import com.google.auto.common.MoreElements;
+import com.google.common.base.Joiner;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Maps;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.ParameterizedTypeName;
+import com.squareup.javapoet.TypeName;
+import com.squareup.javapoet.TypeVariableName;
+import dagger.internal.SetFactory;
+import dagger.internal.codegen.base.MapType;
+import dagger.internal.codegen.base.SetType;
+import dagger.model.DependencyRequest;
+import dagger.model.RequestKind;
+import dagger.producers.Produced;
+import dagger.producers.Producer;
+import dagger.producers.internal.SetOfProducedProducer;
+import dagger.producers.internal.SetProducer;
+import java.util.List;
+import javax.inject.Provider;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.TypeParameterElement;
+import javax.lang.model.element.VariableElement;
+
+/** Utilities for generating files. */
+public class SourceFiles {
+
+ private static final Joiner CLASS_FILE_NAME_JOINER = Joiner.on('_');
+
+ /**
+ * Generates names and keys for the factory class fields needed to hold the framework classes for
+ * all of the dependencies of {@code binding}. It is responsible for choosing a name that
+ *
+ * <ul>
+ * <li>represents all of the dependency requests for this key
+ * <li>is <i>probably</i> associated with the type being bound
+ * <li>is unique within the class
+ * </ul>
+ *
+ * @param binding must be an unresolved binding (type parameters must match its type element's)
+ */
+ public static ImmutableMap<DependencyRequest, FrameworkField>
+ generateBindingFieldsForDependencies(Binding binding) {
+ checkArgument(!binding.unresolved().isPresent(), "binding must be unresolved: %s", binding);
+
+ FrameworkTypeMapper frameworkTypeMapper =
+ FrameworkTypeMapper.forBindingType(binding.bindingType());
+
+ return Maps.toMap(
+ binding.dependencies(),
+ dependency ->
+ FrameworkField.create(
+ ClassName.get(
+ frameworkTypeMapper.getFrameworkType(dependency.kind()).frameworkClass()),
+ TypeName.get(dependency.key().type()),
+ DependencyVariableNamer.name(dependency)));
+ }
+
+ public static CodeBlock frameworkTypeUsageStatement(
+ CodeBlock frameworkTypeMemberSelect, RequestKind dependencyKind) {
+ switch (dependencyKind) {
+ case LAZY:
+ return CodeBlock.of("$T.lazy($L)", DOUBLE_CHECK, frameworkTypeMemberSelect);
+ case INSTANCE:
+ case FUTURE:
+ return CodeBlock.of("$L.get()", frameworkTypeMemberSelect);
+ case PROVIDER:
+ case PRODUCER:
+ return frameworkTypeMemberSelect;
+ case PROVIDER_OF_LAZY:
+ return CodeBlock.of("$T.create($L)", PROVIDER_OF_LAZY, frameworkTypeMemberSelect);
+ default: // including PRODUCED
+ throw new AssertionError(dependencyKind);
+ }
+ }
+
+ /**
+ * Returns a mapping of {@link DependencyRequest}s to {@link CodeBlock}s that {@linkplain
+ * #frameworkTypeUsageStatement(CodeBlock, RequestKind) use them}.
+ */
+ public static ImmutableMap<DependencyRequest, CodeBlock> frameworkFieldUsages(
+ ImmutableSet<DependencyRequest> dependencies,
+ ImmutableMap<DependencyRequest, FieldSpec> fields) {
+ return Maps.toMap(
+ dependencies,
+ dep -> frameworkTypeUsageStatement(CodeBlock.of("$N", fields.get(dep)), dep.kind()));
+ }
+
+ /** Returns the generated factory or members injector name for a binding. */
+ public static ClassName generatedClassNameForBinding(Binding binding) {
+ switch (binding.bindingType()) {
+ case PROVISION:
+ case PRODUCTION:
+ ContributionBinding contribution = (ContributionBinding) binding;
+ switch (contribution.kind()) {
+ case ASSISTED_INJECTION:
+ case INJECTION:
+ case PROVISION:
+ case PRODUCTION:
+ return elementBasedClassName(
+ MoreElements.asExecutable(binding.bindingElement().get()), "Factory");
+
+ case ASSISTED_FACTORY:
+ return siblingClassName(MoreElements.asType(binding.bindingElement().get()), "_Impl");
+
+ default:
+ throw new AssertionError();
+ }
+
+ case MEMBERS_INJECTION:
+ return membersInjectorNameForType(
+ ((MembersInjectionBinding) binding).membersInjectedType());
+ }
+ throw new AssertionError();
+ }
+
+ /**
+ * Calculates an appropriate {@link ClassName} for a generated class that is based on {@code
+ * element}, appending {@code suffix} at the end.
+ *
+ * <p>This will always return a {@linkplain ClassName#topLevelClassName() top level class name},
+ * even if {@code element}'s enclosing class is a nested type.
+ */
+ public static ClassName elementBasedClassName(ExecutableElement element, String suffix) {
+ ClassName enclosingClassName =
+ ClassName.get(MoreElements.asType(element.getEnclosingElement()));
+ String methodName =
+ element.getKind().equals(ElementKind.CONSTRUCTOR)
+ ? ""
+ : LOWER_CAMEL.to(UPPER_CAMEL, element.getSimpleName().toString());
+ return ClassName.get(
+ enclosingClassName.packageName(),
+ classFileName(enclosingClassName) + "_" + methodName + suffix);
+ }
+
+ public static TypeName parameterizedGeneratedTypeNameForBinding(Binding binding) {
+ ClassName className = generatedClassNameForBinding(binding);
+ ImmutableList<TypeVariableName> typeParameters = bindingTypeElementTypeVariableNames(binding);
+ return typeParameters.isEmpty()
+ ? className
+ : ParameterizedTypeName.get(className, Iterables.toArray(typeParameters, TypeName.class));
+ }
+
+ public static ClassName membersInjectorNameForType(TypeElement typeElement) {
+ return siblingClassName(typeElement, "_MembersInjector");
+ }
+
+ public static String memberInjectedFieldSignatureForVariable(VariableElement variableElement) {
+ return MoreElements.asType(variableElement.getEnclosingElement()).getQualifiedName()
+ + "."
+ + variableElement.getSimpleName();
+ }
+
+ public static String classFileName(ClassName className) {
+ return CLASS_FILE_NAME_JOINER.join(className.simpleNames());
+ }
+
+ public static ClassName generatedMonitoringModuleName(TypeElement componentElement) {
+ return siblingClassName(componentElement, "_MonitoringModule");
+ }
+
+ // TODO(ronshapiro): when JavaPoet migration is complete, replace the duplicated code
+ // which could use this.
+ private static ClassName siblingClassName(TypeElement typeElement, String suffix) {
+ ClassName className = ClassName.get(typeElement);
+ return className.topLevelClassName().peerClass(classFileName(className) + suffix);
+ }
+
+ /**
+ * The {@link java.util.Set} factory class name appropriate for set bindings.
+ *
+ * <ul>
+ * <li>{@link SetFactory} for provision bindings.
+ * <li>{@link SetProducer} for production bindings for {@code Set<T>}.
+ * <li>{@link SetOfProducedProducer} for production bindings for {@code Set<Produced<T>>}.
+ * </ul>
+ */
+ public static ClassName setFactoryClassName(ContributionBinding binding) {
+ checkArgument(binding.kind().equals(MULTIBOUND_SET));
+ if (binding.bindingType().equals(BindingType.PROVISION)) {
+ return SET_FACTORY;
+ } else {
+ SetType setType = SetType.from(binding.key());
+ return setType.elementsAreTypeOf(Produced.class) ? SET_OF_PRODUCED_PRODUCER : SET_PRODUCER;
+ }
+ }
+
+ /** The {@link java.util.Map} factory class name appropriate for map bindings. */
+ public static ClassName mapFactoryClassName(ContributionBinding binding) {
+ checkState(binding.kind().equals(MULTIBOUND_MAP), binding.kind());
+ MapType mapType = MapType.from(binding.key());
+ switch (binding.bindingType()) {
+ case PROVISION:
+ return mapType.valuesAreTypeOf(Provider.class) ? MAP_PROVIDER_FACTORY : MAP_FACTORY;
+ case PRODUCTION:
+ return mapType.valuesAreFrameworkType()
+ ? mapType.valuesAreTypeOf(Producer.class)
+ ? MAP_OF_PRODUCER_PRODUCER
+ : MAP_OF_PRODUCED_PRODUCER
+ : MAP_PRODUCER;
+ default:
+ throw new IllegalArgumentException(binding.bindingType().toString());
+ }
+ }
+
+ public static ImmutableList<TypeVariableName> bindingTypeElementTypeVariableNames(
+ Binding binding) {
+ if (binding instanceof ContributionBinding) {
+ ContributionBinding contributionBinding = (ContributionBinding) binding;
+ if (!(contributionBinding.kind() == INJECTION
+ || contributionBinding.kind() == ASSISTED_INJECTION)
+ && !contributionBinding.requiresModuleInstance()) {
+ return ImmutableList.of();
+ }
+ }
+ List<? extends TypeParameterElement> typeParameters =
+ binding.bindingTypeElement().get().getTypeParameters();
+ return typeParameters.stream().map(TypeVariableName::get).collect(toImmutableList());
+ }
+
+ /**
+ * Returns a name to be used for variables of the given {@linkplain TypeElement type}. Prefer
+ * semantically meaningful variable names, but if none can be derived, this will produce something
+ * readable.
+ */
+ // TODO(gak): maybe this should be a function of TypeMirrors instead of Elements?
+ public static String simpleVariableName(TypeElement typeElement) {
+ String candidateName = UPPER_CAMEL.to(LOWER_CAMEL, typeElement.getSimpleName().toString());
+ String variableName = protectAgainstKeywords(candidateName);
+ verify(isName(variableName), "'%s' was expected to be a valid variable name");
+ return variableName;
+ }
+
+ public static String protectAgainstKeywords(String candidateName) {
+ switch (candidateName) {
+ case "package":
+ return "pkg";
+ case "boolean":
+ return "b";
+ case "double":
+ return "d";
+ case "byte":
+ return "b";
+ case "int":
+ return "i";
+ case "short":
+ return "s";
+ case "char":
+ return "c";
+ case "void":
+ return "v";
+ case "class":
+ return "clazz";
+ case "float":
+ return "f";
+ case "long":
+ return "l";
+ default:
+ return SourceVersion.isKeyword(candidateName) ? candidateName + '_' : candidateName;
+ }
+ }
+
+ private SourceFiles() {}
+}
diff --git a/java/dagger/internal/codegen/binding/SubcomponentCreatorBindingEdgeImpl.java b/java/dagger/internal/codegen/binding/SubcomponentCreatorBindingEdgeImpl.java
new file mode 100644
index 0000000..93e79b5
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/SubcomponentCreatorBindingEdgeImpl.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static dagger.internal.codegen.extension.DaggerStreams.presentValues;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static java.util.stream.Collectors.joining;
+
+import com.google.common.collect.ImmutableSet;
+import dagger.model.BindingGraph.SubcomponentCreatorBindingEdge;
+import javax.lang.model.element.TypeElement;
+
+/** An implementation of {@link SubcomponentCreatorBindingEdge}. */
+public final class SubcomponentCreatorBindingEdgeImpl implements SubcomponentCreatorBindingEdge {
+
+ private final ImmutableSet<SubcomponentDeclaration> subcomponentDeclarations;
+
+ SubcomponentCreatorBindingEdgeImpl(
+ ImmutableSet<SubcomponentDeclaration> subcomponentDeclarations) {
+ this.subcomponentDeclarations = subcomponentDeclarations;
+ }
+
+ @Override
+ public ImmutableSet<TypeElement> declaringModules() {
+ return subcomponentDeclarations.stream()
+ .map(SubcomponentDeclaration::contributingModule)
+ .flatMap(presentValues())
+ .collect(toImmutableSet());
+ }
+
+ @Override
+ public String toString() {
+ return "subcomponent declared by "
+ + (subcomponentDeclarations.size() == 1
+ ? getOnlyElement(declaringModules()).getQualifiedName()
+ : declaringModules().stream()
+ .map(TypeElement::getQualifiedName)
+ .collect(joining(", ", "{", "}")));
+ }
+}
diff --git a/java/dagger/internal/codegen/binding/SubcomponentDeclaration.java b/java/dagger/internal/codegen/binding/SubcomponentDeclaration.java
new file mode 100644
index 0000000..4f1f3ef
--- /dev/null
+++ b/java/dagger/internal/codegen/binding/SubcomponentDeclaration.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.binding;
+
+import static com.google.auto.common.AnnotationMirrors.getAnnotationElementAndValue;
+import static dagger.internal.codegen.binding.ConfigurationAnnotations.getSubcomponentCreator;
+
+import com.google.auto.value.AutoValue;
+import com.google.auto.value.extension.memoized.Memoized;
+import com.google.common.collect.ImmutableSet;
+import dagger.internal.codegen.base.ModuleAnnotation;
+import dagger.model.Key;
+import java.util.Optional;
+import javax.inject.Inject;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+
+/**
+ * A declaration for a subcomponent that is included in a module via {@link
+ * dagger.Module#subcomponents()}.
+ */
+@AutoValue
+public abstract class SubcomponentDeclaration extends BindingDeclaration {
+ /**
+ * Key for the {@link dagger.Subcomponent.Builder} or {@link
+ * dagger.producers.ProductionSubcomponent.Builder} of {@link #subcomponentType()}.
+ */
+ @Override
+ public abstract Key key();
+
+ /**
+ * The type element that defines the {@link dagger.Subcomponent} or {@link
+ * dagger.producers.ProductionSubcomponent} for this declaration.
+ */
+ abstract TypeElement subcomponentType();
+
+ /** The module annotation. */
+ public abstract ModuleAnnotation moduleAnnotation();
+
+ @Memoized
+ @Override
+ public abstract int hashCode();
+
+ @Override
+ public abstract boolean equals(Object obj);
+
+ /** A {@link SubcomponentDeclaration} factory. */
+ public static class Factory {
+ private final KeyFactory keyFactory;
+
+ @Inject
+ Factory(KeyFactory keyFactory) {
+ this.keyFactory = keyFactory;
+ }
+
+ ImmutableSet<SubcomponentDeclaration> forModule(TypeElement module) {
+ ImmutableSet.Builder<SubcomponentDeclaration> declarations = ImmutableSet.builder();
+ ModuleAnnotation moduleAnnotation = ModuleAnnotation.moduleAnnotation(module).get();
+ Element subcomponentAttribute =
+ getAnnotationElementAndValue(moduleAnnotation.annotation(), "subcomponents").getKey();
+ for (TypeElement subcomponent : moduleAnnotation.subcomponents()) {
+ declarations.add(
+ new AutoValue_SubcomponentDeclaration(
+ Optional.of(subcomponentAttribute),
+ Optional.of(module),
+ keyFactory.forSubcomponentCreator(
+ getSubcomponentCreator(subcomponent).get().asType()),
+ subcomponent,
+ moduleAnnotation));
+ }
+ return declarations.build();
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/bindinggraphvalidation/BUILD b/java/dagger/internal/codegen/bindinggraphvalidation/BUILD
new file mode 100644
index 0000000..da35b51
--- /dev/null
+++ b/java/dagger/internal/codegen/bindinggraphvalidation/BUILD
@@ -0,0 +1,45 @@
+# Copyright (C) 2019 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Classes related to BindingGraph validation.
+
+load("@rules_java//java:defs.bzl", "java_library")
+
+package(default_visibility = ["//:src"])
+
+java_library(
+ name = "bindinggraphvalidation",
+ srcs = glob(["*.java"]),
+ plugins = ["//java/dagger/internal/codegen/bootstrap"],
+ tags = ["maven:merged"],
+ deps = [
+ "//java/dagger:core",
+ "//java/dagger/internal/codegen/base",
+ "//java/dagger/internal/codegen/binding",
+ "//java/dagger/internal/codegen/compileroption",
+ "//java/dagger/internal/codegen/extension",
+ "//java/dagger/internal/codegen/kotlin",
+ "//java/dagger/internal/codegen/langmodel",
+ "//java/dagger/internal/codegen/validation",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/internal/guava:graph",
+ "//java/dagger/producers",
+ "//java/dagger/spi",
+ "@google_bazel_common//third_party/java/auto:value",
+ "@google_bazel_common//third_party/java/jsr330_inject",
+ "@maven//:com_google_auto_auto_common",
+ ],
+)
diff --git a/java/dagger/internal/codegen/bindinggraphvalidation/BindingGraphValidationModule.java b/java/dagger/internal/codegen/bindinggraphvalidation/BindingGraphValidationModule.java
new file mode 100644
index 0000000..a1f1848
--- /dev/null
+++ b/java/dagger/internal/codegen/bindinggraphvalidation/BindingGraphValidationModule.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.bindinggraphvalidation;
+
+import com.google.common.collect.ImmutableSet;
+import dagger.Module;
+import dagger.Provides;
+import dagger.internal.codegen.compileroption.CompilerOptions;
+import dagger.internal.codegen.validation.CompositeBindingGraphPlugin;
+import dagger.internal.codegen.validation.Validation;
+import dagger.spi.BindingGraphPlugin;
+
+/** Binds the set of {@link BindingGraphPlugin}s used to implement Dagger validation. */
+@Module
+public interface BindingGraphValidationModule {
+
+ @Provides
+ @Validation
+ static ImmutableSet<BindingGraphPlugin> providePlugins(
+ CompositeBindingGraphPlugin.Factory factory,
+ CompilerOptions compilerOptions,
+ DependencyCycleValidator validation1,
+ DependsOnProductionExecutorValidator validation2,
+ DuplicateBindingsValidator validation3,
+ IncompatiblyScopedBindingsValidator validation4,
+ InjectBindingValidator validation5,
+ MapMultibindingValidator validation6,
+ MissingBindingValidator validation7,
+ NullableBindingValidator validation8,
+ ProvisionDependencyOnProducerBindingValidator validation9,
+ SubcomponentFactoryMethodValidator validation10) {
+ ImmutableSet<BindingGraphPlugin> plugins = ImmutableSet.of(
+ validation1,
+ validation2,
+ validation3,
+ validation4,
+ validation5,
+ validation6,
+ validation7,
+ validation8,
+ validation9,
+ validation10);
+ if (compilerOptions.experimentalDaggerErrorMessages()) {
+ return ImmutableSet.of(factory.create(plugins, "Dagger/Validation"));
+ } else {
+ return plugins;
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/bindinggraphvalidation/DependencyCycleValidator.java b/java/dagger/internal/codegen/bindinggraphvalidation/DependencyCycleValidator.java
new file mode 100644
index 0000000..bc89ebb
--- /dev/null
+++ b/java/dagger/internal/codegen/bindinggraphvalidation/DependencyCycleValidator.java
@@ -0,0 +1,329 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.bindinggraphvalidation;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.collect.Iterables.getLast;
+import static com.google.common.collect.Iterables.limit;
+import static com.google.common.collect.Iterables.skip;
+import static com.google.common.collect.Sets.newHashSetWithExpectedSize;
+import static dagger.internal.codegen.base.RequestKinds.extractKeyType;
+import static dagger.internal.codegen.base.RequestKinds.getRequestKind;
+import static dagger.internal.codegen.extension.DaggerGraphs.shortestPath;
+import static dagger.internal.codegen.extension.DaggerStreams.instancesOf;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static javax.tools.Diagnostic.Kind.ERROR;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.common.graph.EndpointPair;
+import com.google.common.graph.Graphs;
+import com.google.common.graph.ImmutableNetwork;
+import com.google.common.graph.MutableNetwork;
+import com.google.common.graph.NetworkBuilder;
+import dagger.internal.codegen.base.MapType;
+import dagger.internal.codegen.base.OptionalType;
+import dagger.internal.codegen.binding.DependencyRequestFormatter;
+import dagger.model.BindingGraph;
+import dagger.model.BindingGraph.ComponentNode;
+import dagger.model.BindingGraph.DependencyEdge;
+import dagger.model.BindingGraph.Node;
+import dagger.model.BindingKind;
+import dagger.model.DependencyRequest;
+import dagger.model.RequestKind;
+import dagger.spi.BindingGraphPlugin;
+import dagger.spi.DiagnosticReporter;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Stream;
+import javax.inject.Inject;
+import javax.inject.Provider;
+import javax.lang.model.type.TypeMirror;
+
+/** Reports errors for dependency cycles. */
+final class DependencyCycleValidator implements BindingGraphPlugin {
+
+ private final DependencyRequestFormatter dependencyRequestFormatter;
+
+ @Inject
+ DependencyCycleValidator(DependencyRequestFormatter dependencyRequestFormatter) {
+ this.dependencyRequestFormatter = dependencyRequestFormatter;
+ }
+
+ @Override
+ public String pluginName() {
+ return "Dagger/DependencyCycle";
+ }
+
+ @Override
+ public void visitGraph(BindingGraph bindingGraph, DiagnosticReporter diagnosticReporter) {
+ ImmutableNetwork<Node, DependencyEdge> dependencyGraph =
+ nonCycleBreakingDependencyGraph(bindingGraph);
+ // First check the graph for a cycle. If there is one, then we'll do more work to report where.
+ if (!Graphs.hasCycle(dependencyGraph)) {
+ return;
+ }
+ // Check each endpoint pair only once, no matter how many parallel edges connect them.
+ Set<EndpointPair<Node>> dependencyEndpointPairs = dependencyGraph.asGraph().edges();
+ Set<EndpointPair<Node>> visited = newHashSetWithExpectedSize(dependencyEndpointPairs.size());
+ for (EndpointPair<Node> endpointPair : dependencyEndpointPairs) {
+ cycleContainingEndpointPair(endpointPair, dependencyGraph, visited)
+ .ifPresent(cycle -> reportCycle(cycle, bindingGraph, diagnosticReporter));
+ }
+ }
+
+ private Optional<Cycle<Node>> cycleContainingEndpointPair(
+ EndpointPair<Node> endpoints,
+ ImmutableNetwork<Node, DependencyEdge> dependencyGraph,
+ Set<EndpointPair<Node>> visited) {
+ if (!visited.add(endpoints)) {
+ // don't recheck endpoints we already know are part of a cycle
+ return Optional.empty();
+ }
+
+ // If there's a path from the target back to the source, there's a cycle.
+ ImmutableList<Node> cycleNodes =
+ shortestPath(dependencyGraph, endpoints.target(), endpoints.source());
+ if (cycleNodes.isEmpty()) {
+ return Optional.empty();
+ }
+
+ Cycle<Node> cycle = Cycle.fromPath(cycleNodes);
+ visited.addAll(cycle.endpointPairs()); // no need to check any edge in this cycle again
+ return Optional.of(cycle);
+ }
+
+ /**
+ * Reports a dependency cycle at the dependency into the cycle that is closest to an entry point.
+ *
+ * <p>For cycles found in reachable binding graphs, looks for the shortest path from the component
+ * that contains the cycle (all bindings in a cycle must be in the same component; see below) to
+ * some binding in the cycle. Then looks for the last dependency in that path that is not in the
+ * cycle; that is the dependency that will be reported, so that the dependency trace will end just
+ * before the cycle.
+ *
+ * <p>For cycles found during full binding graph validation, just reports the component that
+ * contains the cycle.
+ *
+ * <p>Proof (by counterexample) that all bindings in a cycle must be in the same component: Assume
+ * one binding in the cycle is in a parent component. Bindings cannot depend on bindings in child
+ * components, so that binding cannot depend on the next binding in the cycle.
+ */
+ private void reportCycle(
+ Cycle<Node> cycle, BindingGraph bindingGraph, DiagnosticReporter diagnosticReporter) {
+ if (bindingGraph.isFullBindingGraph()) {
+ diagnosticReporter.reportComponent(
+ ERROR,
+ bindingGraph.componentNode(cycle.nodes().asList().get(0).componentPath()).get(),
+ errorMessage(cycle, bindingGraph));
+ return;
+ }
+
+ ImmutableList<Node> path = shortestPathToCycleFromAnEntryPoint(cycle, bindingGraph);
+ Node cycleStartNode = path.get(path.size() - 1);
+ Node previousNode = path.get(path.size() - 2);
+ DependencyEdge dependencyToReport =
+ chooseDependencyEdgeConnecting(previousNode, cycleStartNode, bindingGraph);
+ diagnosticReporter.reportDependency(
+ ERROR, dependencyToReport, errorMessage(cycle.shift(cycleStartNode), bindingGraph));
+ }
+
+ private ImmutableList<Node> shortestPathToCycleFromAnEntryPoint(
+ Cycle<Node> cycle, BindingGraph bindingGraph) {
+ Node someCycleNode = cycle.nodes().asList().get(0);
+ ComponentNode componentContainingCycle =
+ bindingGraph.componentNode(someCycleNode.componentPath()).get();
+ ImmutableList<Node> pathToCycle =
+ shortestPath(bindingGraph.network(), componentContainingCycle, someCycleNode);
+ return subpathToCycle(pathToCycle, cycle);
+ }
+
+ /**
+ * Returns the subpath from the head of {@code path} to the first node in {@code path} that's in
+ * the cycle.
+ */
+ private ImmutableList<Node> subpathToCycle(ImmutableList<Node> path, Cycle<Node> cycle) {
+ ImmutableList.Builder<Node> subpath = ImmutableList.builder();
+ for (Node node : path) {
+ subpath.add(node);
+ if (cycle.nodes().contains(node)) {
+ return subpath.build();
+ }
+ }
+ throw new IllegalArgumentException(
+ "path " + path + " doesn't contain any nodes in cycle " + cycle);
+ }
+
+ private String errorMessage(Cycle<Node> cycle, BindingGraph graph) {
+ StringBuilder message = new StringBuilder("Found a dependency cycle:");
+ ImmutableList<DependencyRequest> cycleRequests =
+ cycle.endpointPairs().stream()
+ // TODO(dpb): Would be nice to take the dependency graph here.
+ .map(endpointPair -> nonCycleBreakingEdge(endpointPair, graph))
+ .map(DependencyEdge::dependencyRequest)
+ .collect(toImmutableList())
+ .reverse();
+ dependencyRequestFormatter.formatIndentedList(message, cycleRequests, 0);
+ return message.toString();
+ }
+
+ /**
+ * Returns one of the edges between two nodes that doesn't {@linkplain
+ * #breaksCycle(DependencyEdge, BindingGraph) break} a cycle.
+ */
+ private DependencyEdge nonCycleBreakingEdge(EndpointPair<Node> endpointPair, BindingGraph graph) {
+ return graph.network().edgesConnecting(endpointPair.source(), endpointPair.target()).stream()
+ .flatMap(instancesOf(DependencyEdge.class))
+ .filter(edge -> !breaksCycle(edge, graph))
+ .findFirst()
+ .get();
+ }
+
+ private boolean breaksCycle(DependencyEdge edge, BindingGraph graph) {
+ // Map<K, V> multibindings depend on Map<K, Provider<V>> entries, but those don't break any
+ // cycles, so ignore them.
+ if (edge.dependencyRequest().key().multibindingContributionIdentifier().isPresent()) {
+ return false;
+ }
+ if (breaksCycle(edge.dependencyRequest().key().type(), edge.dependencyRequest().kind())) {
+ return true;
+ }
+ Node target = graph.network().incidentNodes(edge).target();
+ if (target instanceof dagger.model.Binding
+ && ((dagger.model.Binding) target).kind().equals(BindingKind.OPTIONAL)) {
+ /* For @BindsOptionalOf bindings, unwrap the type inside the Optional. If the unwrapped type
+ * breaks the cycle, so does the optional binding. */
+ TypeMirror optionalValueType = OptionalType.from(edge.dependencyRequest().key()).valueType();
+ RequestKind requestKind = getRequestKind(optionalValueType);
+ return breaksCycle(extractKeyType(optionalValueType), requestKind);
+ }
+ return false;
+ }
+
+ private boolean breaksCycle(TypeMirror requestedType, RequestKind requestKind) {
+ switch (requestKind) {
+ case PROVIDER:
+ case LAZY:
+ case PROVIDER_OF_LAZY:
+ return true;
+
+ case INSTANCE:
+ if (MapType.isMap(requestedType)) {
+ MapType mapType = MapType.from(requestedType);
+ return !mapType.isRawType() && mapType.valuesAreTypeOf(Provider.class);
+ }
+ // fall through
+
+ default:
+ return false;
+ }
+ }
+
+ private DependencyEdge chooseDependencyEdgeConnecting(
+ Node source, Node target, BindingGraph bindingGraph) {
+ return bindingGraph.network().edgesConnecting(source, target).stream()
+ .flatMap(instancesOf(DependencyEdge.class))
+ .findFirst()
+ .get();
+ }
+
+ /** Returns the subgraph containing only {@link DependencyEdge}s that would not break a cycle. */
+ // TODO(dpb): Return a network containing only Binding nodes.
+ private ImmutableNetwork<Node, DependencyEdge> nonCycleBreakingDependencyGraph(
+ BindingGraph bindingGraph) {
+ MutableNetwork<Node, DependencyEdge> dependencyNetwork =
+ NetworkBuilder.from(bindingGraph.network())
+ .expectedNodeCount(bindingGraph.network().nodes().size())
+ .expectedEdgeCount(bindingGraph.dependencyEdges().size())
+ .build();
+ bindingGraph.dependencyEdges().stream()
+ .filter(edge -> !breaksCycle(edge, bindingGraph))
+ .forEach(
+ edge -> {
+ EndpointPair<Node> endpoints = bindingGraph.network().incidentNodes(edge);
+ dependencyNetwork.addEdge(endpoints.source(), endpoints.target(), edge);
+ });
+ return ImmutableNetwork.copyOf(dependencyNetwork);
+ }
+
+ /**
+ * An ordered set of endpoint pairs representing the edges in the cycle. The target of each pair
+ * is the source of the next pair. The target of the last pair is the source of the first pair.
+ */
+ @AutoValue
+ abstract static class Cycle<N> {
+ /**
+ * The ordered set of endpoint pairs representing the edges in the cycle. The target of each
+ * pair is the source of the next pair. The target of the last pair is the source of the first
+ * pair.
+ */
+ abstract ImmutableSet<EndpointPair<N>> endpointPairs();
+
+ /** Returns the nodes that participate in the cycle. */
+ ImmutableSet<N> nodes() {
+ return endpointPairs().stream()
+ .flatMap(pair -> Stream.of(pair.source(), pair.target()))
+ .collect(toImmutableSet());
+ }
+
+ /** Returns the number of edges in the cycle. */
+ int size() {
+ return endpointPairs().size();
+ }
+
+ /**
+ * Shifts this cycle so that it starts with a specific node.
+ *
+ * @return a cycle equivalent to this one but whose first pair starts with {@code startNode}
+ */
+ Cycle<N> shift(N startNode) {
+ int startIndex = Iterables.indexOf(endpointPairs(), pair -> pair.source().equals(startNode));
+ checkArgument(
+ startIndex >= 0, "startNode (%s) is not part of this cycle: %s", startNode, this);
+ if (startIndex == 0) {
+ return this;
+ }
+ ImmutableSet.Builder<EndpointPair<N>> shifted = ImmutableSet.builder();
+ shifted.addAll(skip(endpointPairs(), startIndex));
+ shifted.addAll(limit(endpointPairs(), size() - startIndex));
+ return new AutoValue_DependencyCycleValidator_Cycle<>(shifted.build());
+ }
+
+ @Override
+ public final String toString() {
+ return endpointPairs().toString();
+ }
+
+ /**
+ * Creates a {@link Cycle} from a nonempty list of nodes, assuming there is an edge between each
+ * pair of nodes as well as an edge from the last node to the first.
+ */
+ static <N> Cycle<N> fromPath(List<N> nodes) {
+ checkArgument(!nodes.isEmpty());
+ ImmutableSet.Builder<EndpointPair<N>> cycle = ImmutableSet.builder();
+ cycle.add(EndpointPair.ordered(getLast(nodes), nodes.get(0)));
+ for (int i = 0; i < nodes.size() - 1; i++) {
+ cycle.add(EndpointPair.ordered(nodes.get(i), nodes.get(i + 1)));
+ }
+ return new AutoValue_DependencyCycleValidator_Cycle<>(cycle.build());
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/bindinggraphvalidation/DependsOnProductionExecutorValidator.java b/java/dagger/internal/codegen/bindinggraphvalidation/DependsOnProductionExecutorValidator.java
new file mode 100644
index 0000000..08e2c3e
--- /dev/null
+++ b/java/dagger/internal/codegen/bindinggraphvalidation/DependsOnProductionExecutorValidator.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.bindinggraphvalidation;
+
+import static dagger.internal.codegen.extension.DaggerStreams.instancesOf;
+import static javax.tools.Diagnostic.Kind.ERROR;
+
+import dagger.internal.codegen.binding.KeyFactory;
+import dagger.internal.codegen.compileroption.CompilerOptions;
+import dagger.model.BindingGraph;
+import dagger.model.BindingGraph.MaybeBinding;
+import dagger.model.Key;
+import dagger.spi.BindingGraphPlugin;
+import dagger.spi.DiagnosticReporter;
+import javax.inject.Inject;
+
+/**
+ * Reports an error on all bindings that depend explicitly on the {@code @Production Executor} key.
+ */
+// TODO(dpb,beder): Validate this during @Inject/@Provides/@Produces validation.
+final class DependsOnProductionExecutorValidator implements BindingGraphPlugin {
+ private final CompilerOptions compilerOptions;
+ private final KeyFactory keyFactory;
+
+ @Inject
+ DependsOnProductionExecutorValidator(CompilerOptions compilerOptions, KeyFactory keyFactory) {
+ this.compilerOptions = compilerOptions;
+ this.keyFactory = keyFactory;
+ }
+
+ @Override
+ public String pluginName() {
+ return "Dagger/DependsOnProductionExecutor";
+ }
+
+ @Override
+ public void visitGraph(BindingGraph bindingGraph, DiagnosticReporter diagnosticReporter) {
+ if (!compilerOptions.usesProducers()) {
+ return;
+ }
+
+ Key productionImplementationExecutorKey = keyFactory.forProductionImplementationExecutor();
+ Key productionExecutorKey = keyFactory.forProductionExecutor();
+
+ bindingGraph.network().nodes().stream()
+ .flatMap(instancesOf(MaybeBinding.class))
+ .filter(node -> node.key().equals(productionExecutorKey))
+ .flatMap(productionExecutor -> bindingGraph.requestingBindings(productionExecutor).stream())
+ .filter(binding -> !binding.key().equals(productionImplementationExecutorKey))
+ .forEach(binding -> reportError(diagnosticReporter, binding));
+ }
+
+ private void reportError(DiagnosticReporter diagnosticReporter, dagger.model.Binding binding) {
+ diagnosticReporter.reportBinding(
+ ERROR, binding, "%s may not depend on the production executor", binding.key());
+ }
+}
diff --git a/java/dagger/internal/codegen/bindinggraphvalidation/DuplicateBindingsValidator.java b/java/dagger/internal/codegen/bindinggraphvalidation/DuplicateBindingsValidator.java
new file mode 100644
index 0000000..5c4da51
--- /dev/null
+++ b/java/dagger/internal/codegen/bindinggraphvalidation/DuplicateBindingsValidator.java
@@ -0,0 +1,345 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.bindinggraphvalidation;
+
+import static com.google.common.base.Verify.verify;
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static dagger.internal.codegen.base.Formatter.INDENT;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSetMultimap;
+import static dagger.model.BindingKind.INJECTION;
+import static dagger.model.BindingKind.MEMBERS_INJECTION;
+import static java.util.Comparator.comparing;
+import static javax.tools.Diagnostic.Kind.ERROR;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableListMultimap;
+import com.google.common.collect.ImmutableMultiset;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSetMultimap;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Multimaps;
+import com.google.common.collect.Sets;
+import dagger.internal.codegen.base.Formatter;
+import dagger.internal.codegen.binding.BindingDeclaration;
+import dagger.internal.codegen.binding.BindingDeclarationFormatter;
+import dagger.internal.codegen.binding.BindingNode;
+import dagger.internal.codegen.binding.MultibindingDeclaration;
+import dagger.internal.codegen.compileroption.CompilerOptions;
+import dagger.model.Binding;
+import dagger.model.BindingGraph;
+import dagger.model.BindingGraph.ComponentNode;
+import dagger.model.BindingKind;
+import dagger.model.ComponentPath;
+import dagger.model.Key;
+import dagger.spi.BindingGraphPlugin;
+import dagger.spi.DiagnosticReporter;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Predicate;
+import javax.inject.Inject;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import javax.tools.Diagnostic.Kind;
+
+/** Reports errors for conflicting bindings with the same key. */
+final class DuplicateBindingsValidator implements BindingGraphPlugin {
+
+ private static final Comparator<Binding> BY_LENGTH_OF_COMPONENT_PATH =
+ comparing(binding -> binding.componentPath().components().size());
+
+ private final BindingDeclarationFormatter bindingDeclarationFormatter;
+ private final CompilerOptions compilerOptions;
+
+ @Inject
+ DuplicateBindingsValidator(
+ BindingDeclarationFormatter bindingDeclarationFormatter, CompilerOptions compilerOptions) {
+ this.bindingDeclarationFormatter = bindingDeclarationFormatter;
+ this.compilerOptions = compilerOptions;
+ }
+
+ @Override
+ public String pluginName() {
+ return "Dagger/DuplicateBindings";
+ }
+
+ @Override
+ public void visitGraph(BindingGraph bindingGraph, DiagnosticReporter diagnosticReporter) {
+ // If two unrelated subcomponents have the same duplicate bindings only because they install the
+ // same two modules, then fixing the error in one subcomponent will uncover the second
+ // subcomponent to fix.
+ // TODO(ronshapiro): Explore ways to address such underreporting without overreporting.
+ Set<ImmutableSet<BindingElement>> reportedDuplicateBindingSets = new HashSet<>();
+ duplicateBindingSets(bindingGraph)
+ .forEach(
+ duplicateBindings -> {
+ // Only report each set of duplicate bindings once, ignoring the installed component.
+ if (reportedDuplicateBindingSets.add(duplicateBindings.keySet())) {
+ reportDuplicateBindings(duplicateBindings, bindingGraph, diagnosticReporter);
+ }
+ });
+ }
+
+ /**
+ * Returns sets of duplicate bindings. Bindings are duplicates if they bind the same key and are
+ * visible from the same component. Two bindings that differ only in the component that owns them
+ * are not considered to be duplicates, because that means the same binding was "copied" down to a
+ * descendant component because it depends on local multibindings or optional bindings. Hence each
+ * "set" is represented as a multimap from binding element (ignoring component path) to binding.
+ */
+ private ImmutableSet<ImmutableSetMultimap<BindingElement, Binding>> duplicateBindingSets(
+ BindingGraph bindingGraph) {
+ return groupBindingsByKey(bindingGraph).stream()
+ .flatMap(bindings -> mutuallyVisibleSubsets(bindings).stream())
+ .map(BindingElement::index)
+ .filter(duplicates -> duplicates.keySet().size() > 1)
+ .collect(toImmutableSet());
+ }
+
+ private static ImmutableSet<ImmutableSet<Binding>> groupBindingsByKey(BindingGraph bindingGraph) {
+ return valueSetsForEachKey(
+ bindingGraph.bindings().stream()
+ .filter(binding -> !binding.kind().equals(MEMBERS_INJECTION))
+ .collect(toImmutableSetMultimap(Binding::key, binding -> binding)));
+ }
+
+ /**
+ * Returns the subsets of the input set that contain bindings that are all visible from the same
+ * component. A binding is visible from its component and all its descendants.
+ */
+ private static ImmutableSet<ImmutableSet<Binding>> mutuallyVisibleSubsets(
+ Set<Binding> duplicateBindings) {
+ ImmutableListMultimap<ComponentPath, Binding> bindingsByComponentPath =
+ Multimaps.index(duplicateBindings, Binding::componentPath);
+ ImmutableSetMultimap.Builder<ComponentPath, Binding> mutuallyVisibleBindings =
+ ImmutableSetMultimap.builder();
+ bindingsByComponentPath
+ .asMap()
+ .forEach(
+ (componentPath, bindings) -> {
+ mutuallyVisibleBindings.putAll(componentPath, bindings);
+ for (ComponentPath ancestor = componentPath; !ancestor.atRoot(); ) {
+ ancestor = ancestor.parent();
+ ImmutableList<Binding> bindingsInAncestor = bindingsByComponentPath.get(ancestor);
+ mutuallyVisibleBindings.putAll(componentPath, bindingsInAncestor);
+ }
+ });
+ return valueSetsForEachKey(mutuallyVisibleBindings.build());
+ }
+
+ private void reportDuplicateBindings(
+ ImmutableSetMultimap<BindingElement, Binding> duplicateBindings,
+ BindingGraph bindingGraph,
+ DiagnosticReporter diagnosticReporter) {
+ if (explicitBindingConfictsWithInject(duplicateBindings.keySet())) {
+ compilerOptions
+ .explicitBindingConflictsWithInjectValidationType()
+ .diagnosticKind()
+ .ifPresent(
+ diagnosticKind ->
+ reportExplicitBindingConflictsWithInject(
+ duplicateBindings,
+ diagnosticReporter,
+ diagnosticKind,
+ bindingGraph.rootComponentNode()));
+ return;
+ }
+ ImmutableSet<Binding> bindings = ImmutableSet.copyOf(duplicateBindings.values());
+ Binding oneBinding = bindings.asList().get(0);
+ String message = bindings.stream().anyMatch(binding -> binding.kind().isMultibinding())
+ ? incompatibleBindingsMessage(oneBinding, bindings, bindingGraph)
+ : duplicateBindingMessage(oneBinding, bindings, bindingGraph);
+ if (compilerOptions.experimentalDaggerErrorMessages()) {
+ diagnosticReporter.reportComponent(
+ ERROR,
+ bindingGraph.rootComponentNode(),
+ message);
+ } else {
+ diagnosticReporter.reportBinding(
+ ERROR,
+ oneBinding,
+ message);
+ }
+ }
+
+ /**
+ * Returns {@code true} if the bindings contain one {@code @Inject} binding and one that isn't.
+ */
+ private static boolean explicitBindingConfictsWithInject(
+ ImmutableSet<BindingElement> duplicateBindings) {
+ ImmutableMultiset<BindingKind> bindingKinds =
+ Multimaps.index(duplicateBindings, BindingElement::bindingKind).keys();
+ return bindingKinds.count(INJECTION) == 1 && bindingKinds.size() == 2;
+ }
+
+ private void reportExplicitBindingConflictsWithInject(
+ ImmutableSetMultimap<BindingElement, Binding> duplicateBindings,
+ DiagnosticReporter diagnosticReporter,
+ Kind diagnosticKind,
+ ComponentNode rootComponent) {
+ Binding injectBinding =
+ rootmostBindingWithKind(k -> k.equals(INJECTION), duplicateBindings.values());
+ Binding explicitBinding =
+ rootmostBindingWithKind(k -> !k.equals(INJECTION), duplicateBindings.values());
+ StringBuilder message =
+ new StringBuilder()
+ .append(explicitBinding.key())
+ .append(" is bound multiple times:")
+ .append(formatWithComponentPath(injectBinding))
+ .append(formatWithComponentPath(explicitBinding))
+ .append(
+ "\nThis condition was never validated before, and will soon be an error. "
+ + "See https://dagger.dev/conflicting-inject.");
+
+ if (compilerOptions.experimentalDaggerErrorMessages()) {
+ diagnosticReporter.reportComponent(diagnosticKind, rootComponent, message.toString());
+ } else {
+ diagnosticReporter.reportBinding(diagnosticKind, explicitBinding, message.toString());
+ }
+ }
+
+ private String formatWithComponentPath(Binding binding) {
+ return String.format(
+ "\n%s%s [%s]",
+ Formatter.INDENT,
+ bindingDeclarationFormatter.format(((BindingNode) binding).delegate()),
+ binding.componentPath());
+ }
+
+ private String duplicateBindingMessage(
+ Binding oneBinding, ImmutableSet<Binding> duplicateBindings, BindingGraph graph) {
+ StringBuilder message =
+ new StringBuilder().append(oneBinding.key()).append(" is bound multiple times:");
+ formatDeclarations(message, 1, declarations(graph, duplicateBindings));
+ if (compilerOptions.experimentalDaggerErrorMessages()) {
+ message.append(String.format("\n%sin component: [%s]", INDENT, oneBinding.componentPath()));
+ }
+ return message.toString();
+ }
+
+ private String incompatibleBindingsMessage(
+ Binding oneBinding, ImmutableSet<Binding> duplicateBindings, BindingGraph graph) {
+ Key key = oneBinding.key();
+ ImmutableSet<dagger.model.Binding> multibindings =
+ duplicateBindings.stream()
+ .filter(binding -> binding.kind().isMultibinding())
+ .collect(toImmutableSet());
+ verify(
+ multibindings.size() == 1, "expected only one multibinding for %s: %s", key, multibindings);
+ StringBuilder message = new StringBuilder();
+ java.util.Formatter messageFormatter = new java.util.Formatter(message);
+ messageFormatter.format("%s has incompatible bindings or declarations:\n", key);
+ message.append(INDENT);
+ dagger.model.Binding multibinding = getOnlyElement(multibindings);
+ messageFormatter.format("%s bindings and declarations:", multibindingTypeString(multibinding));
+ formatDeclarations(message, 2, declarations(graph, multibindings));
+
+ Set<dagger.model.Binding> uniqueBindings =
+ Sets.filter(duplicateBindings, binding -> !binding.equals(multibinding));
+ message.append('\n').append(INDENT).append("Unique bindings and declarations:");
+ formatDeclarations(
+ message,
+ 2,
+ Sets.filter(
+ declarations(graph, uniqueBindings),
+ declaration -> !(declaration instanceof MultibindingDeclaration)));
+ if (compilerOptions.experimentalDaggerErrorMessages()) {
+ message.append(String.format("\n%sin component: [%s]", INDENT, oneBinding.componentPath()));
+ }
+ return message.toString();
+ }
+
+ private void formatDeclarations(
+ StringBuilder builder,
+ int indentLevel,
+ Iterable<? extends BindingDeclaration> bindingDeclarations) {
+ bindingDeclarationFormatter.formatIndentedList(
+ builder, ImmutableList.copyOf(bindingDeclarations), indentLevel);
+ }
+
+ private ImmutableSet<BindingDeclaration> declarations(
+ BindingGraph graph, Set<dagger.model.Binding> bindings) {
+ return bindings.stream()
+ .flatMap(binding -> declarations(graph, binding).stream())
+ .distinct()
+ .sorted(BindingDeclaration.COMPARATOR)
+ .collect(toImmutableSet());
+ }
+
+ private ImmutableSet<BindingDeclaration> declarations(
+ BindingGraph graph, dagger.model.Binding binding) {
+ ImmutableSet.Builder<BindingDeclaration> declarations = ImmutableSet.builder();
+ BindingNode bindingNode = (BindingNode) binding;
+ bindingNode.associatedDeclarations().forEach(declarations::add);
+ if (bindingDeclarationFormatter.canFormat(bindingNode.delegate())) {
+ declarations.add(bindingNode.delegate());
+ } else {
+ graph.requestedBindings(binding).stream()
+ .flatMap(requestedBinding -> declarations(graph, requestedBinding).stream())
+ .forEach(declarations::add);
+ }
+ return declarations.build();
+ }
+
+ private String multibindingTypeString(dagger.model.Binding multibinding) {
+ switch (multibinding.kind()) {
+ case MULTIBOUND_MAP:
+ return "Map";
+ case MULTIBOUND_SET:
+ return "Set";
+ default:
+ throw new AssertionError(multibinding);
+ }
+ }
+
+ private static <E> ImmutableSet<ImmutableSet<E>> valueSetsForEachKey(Multimap<?, E> multimap) {
+ return multimap.asMap().values().stream().map(ImmutableSet::copyOf).collect(toImmutableSet());
+ }
+
+ /** Returns the binding of the given kind that is closest to the root component. */
+ private static Binding rootmostBindingWithKind(
+ Predicate<BindingKind> bindingKindPredicate, ImmutableCollection<Binding> bindings) {
+ return bindings.stream()
+ .filter(b -> bindingKindPredicate.test(b.kind()))
+ .min(BY_LENGTH_OF_COMPONENT_PATH)
+ .get();
+ }
+
+ /** The identifying information about a binding, excluding its {@link Binding#componentPath()}. */
+ @AutoValue
+ abstract static class BindingElement {
+
+ abstract BindingKind bindingKind();
+
+ abstract Optional<Element> bindingElement();
+
+ abstract Optional<TypeElement> contributingModule();
+
+ static ImmutableSetMultimap<BindingElement, Binding> index(Set<Binding> bindings) {
+ return bindings.stream().collect(toImmutableSetMultimap(BindingElement::forBinding, b -> b));
+ }
+
+ private static BindingElement forBinding(Binding binding) {
+ return new AutoValue_DuplicateBindingsValidator_BindingElement(
+ binding.kind(), binding.bindingElement(), binding.contributingModule());
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/bindinggraphvalidation/IncompatiblyScopedBindingsValidator.java b/java/dagger/internal/codegen/bindinggraphvalidation/IncompatiblyScopedBindingsValidator.java
new file mode 100644
index 0000000..a01dbaf
--- /dev/null
+++ b/java/dagger/internal/codegen/bindinggraphvalidation/IncompatiblyScopedBindingsValidator.java
@@ -0,0 +1,145 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.bindinggraphvalidation;
+
+import static dagger.internal.codegen.base.Formatter.INDENT;
+import static dagger.internal.codegen.base.Scopes.getReadableSource;
+import static dagger.internal.codegen.langmodel.DaggerElements.closestEnclosingTypeElement;
+import static dagger.model.BindingKind.INJECTION;
+import static java.util.stream.Collectors.joining;
+import static javax.tools.Diagnostic.Kind.ERROR;
+
+import com.google.auto.common.MoreElements;
+import com.google.common.collect.ImmutableSetMultimap;
+import com.google.common.collect.Multimaps;
+import dagger.internal.codegen.base.Scopes;
+import dagger.internal.codegen.binding.MethodSignatureFormatter;
+import dagger.internal.codegen.compileroption.CompilerOptions;
+import dagger.model.Binding;
+import dagger.model.BindingGraph;
+import dagger.model.BindingGraph.ComponentNode;
+import dagger.spi.BindingGraphPlugin;
+import dagger.spi.DiagnosticReporter;
+import java.util.Optional;
+import java.util.Set;
+import javax.inject.Inject;
+import javax.tools.Diagnostic;
+
+/**
+ * Reports an error for any component that uses bindings with scopes that are not assigned to the
+ * component.
+ */
+final class IncompatiblyScopedBindingsValidator implements BindingGraphPlugin {
+
+ private final MethodSignatureFormatter methodSignatureFormatter;
+ private final CompilerOptions compilerOptions;
+
+ @Inject
+ IncompatiblyScopedBindingsValidator(
+ MethodSignatureFormatter methodSignatureFormatter, CompilerOptions compilerOptions) {
+ this.methodSignatureFormatter = methodSignatureFormatter;
+ this.compilerOptions = compilerOptions;
+ }
+
+ @Override
+ public String pluginName() {
+ return "Dagger/IncompatiblyScopedBindings";
+ }
+
+ @Override
+ public void visitGraph(BindingGraph bindingGraph, DiagnosticReporter diagnosticReporter) {
+ ImmutableSetMultimap.Builder<ComponentNode, dagger.model.Binding> incompatibleBindings =
+ ImmutableSetMultimap.builder();
+ for (dagger.model.Binding binding : bindingGraph.bindings()) {
+ binding
+ .scope()
+ .filter(scope -> !scope.isReusable())
+ .ifPresent(
+ scope -> {
+ ComponentNode componentNode =
+ bindingGraph.componentNode(binding.componentPath()).get();
+ if (!componentNode.scopes().contains(scope)) {
+ // @Inject bindings in module or subcomponent binding graphs will appear at the
+ // properly scoped ancestor component, so ignore them here.
+ if (binding.kind().equals(INJECTION)
+ && (bindingGraph.rootComponentNode().isSubcomponent()
+ || !bindingGraph.rootComponentNode().isRealComponent())) {
+ return;
+ }
+ incompatibleBindings.put(componentNode, binding);
+ }
+ });
+ }
+ Multimaps.asMap(incompatibleBindings.build())
+ .forEach((componentNode, bindings) -> report(componentNode, bindings, diagnosticReporter));
+ }
+
+ private void report(
+ ComponentNode componentNode,
+ Set<Binding> bindings,
+ DiagnosticReporter diagnosticReporter) {
+ Diagnostic.Kind diagnosticKind = ERROR;
+ StringBuilder message =
+ new StringBuilder(componentNode.componentPath().currentComponent().getQualifiedName());
+
+ if (!componentNode.isRealComponent()) {
+ // If the "component" is really a module, it will have no scopes attached. We want to report
+ // if there is more than one scope in that component.
+ if (bindings.stream().map(Binding::scope).map(Optional::get).distinct().count() <= 1) {
+ return;
+ }
+ message.append(" contains bindings with different scopes:");
+ diagnosticKind = compilerOptions.moduleHasDifferentScopesDiagnosticKind();
+ } else if (componentNode.scopes().isEmpty()) {
+ message.append(" (unscoped) may not reference scoped bindings:");
+ } else {
+ message
+ .append(" scoped with ")
+ .append(
+ componentNode.scopes().stream().map(Scopes::getReadableSource).collect(joining(" ")))
+ .append(" may not reference bindings with different scopes:");
+ }
+
+ // TODO(ronshapiro): Should we group by scope?
+ for (Binding binding : bindings) {
+ message.append('\n').append(INDENT);
+
+ // TODO(dpb): Use BindingDeclarationFormatter.
+ // But that doesn't print scopes for @Inject-constructed types.
+ switch (binding.kind()) {
+ case DELEGATE:
+ case PROVISION:
+ message.append(
+ methodSignatureFormatter.format(
+ MoreElements.asExecutable(binding.bindingElement().get())));
+ break;
+
+ case INJECTION:
+ message
+ .append(getReadableSource(binding.scope().get()))
+ .append(" class ")
+ .append(
+ closestEnclosingTypeElement(binding.bindingElement().get()).getQualifiedName());
+ break;
+
+ default:
+ throw new AssertionError(binding);
+ }
+ }
+ diagnosticReporter.reportComponent(diagnosticKind, componentNode, message.toString());
+ }
+}
diff --git a/java/dagger/internal/codegen/bindinggraphvalidation/InjectBindingValidator.java b/java/dagger/internal/codegen/bindinggraphvalidation/InjectBindingValidator.java
new file mode 100644
index 0000000..fe1c3e0
--- /dev/null
+++ b/java/dagger/internal/codegen/bindinggraphvalidation/InjectBindingValidator.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.bindinggraphvalidation;
+
+import static dagger.model.BindingKind.INJECTION;
+
+import com.google.auto.common.MoreTypes;
+import dagger.internal.codegen.validation.InjectValidator;
+import dagger.internal.codegen.validation.ValidationReport;
+import dagger.internal.codegen.validation.ValidationReport.Item;
+import dagger.model.BindingGraph;
+import dagger.spi.BindingGraphPlugin;
+import dagger.spi.DiagnosticReporter;
+import javax.inject.Inject;
+import javax.lang.model.element.TypeElement;
+
+/** Validates bindings from {@code @Inject}-annotated constructors. */
+final class InjectBindingValidator implements BindingGraphPlugin {
+
+ private final InjectValidator injectValidator;
+
+ @Inject
+ InjectBindingValidator(InjectValidator injectValidator) {
+ this.injectValidator = injectValidator.whenGeneratingCode();
+ }
+
+ @Override
+ public String pluginName() {
+ return "Dagger/InjectBinding";
+ }
+
+ @Override
+ public void visitGraph(BindingGraph bindingGraph, DiagnosticReporter diagnosticReporter) {
+ bindingGraph.bindings().stream()
+ .filter(binding -> binding.kind().equals(INJECTION)) // TODO(dpb): Move to BindingGraph
+ .forEach(binding -> validateInjectionBinding(binding, diagnosticReporter));
+ }
+
+ private void validateInjectionBinding(
+ dagger.model.Binding node, DiagnosticReporter diagnosticReporter) {
+ ValidationReport<TypeElement> typeReport =
+ injectValidator.validateType(MoreTypes.asTypeElement(node.key().type()));
+ for (Item item : typeReport.allItems()) {
+ diagnosticReporter.reportBinding(item.kind(), node, item.message());
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/bindinggraphvalidation/MapMultibindingValidator.java b/java/dagger/internal/codegen/bindinggraphvalidation/MapMultibindingValidator.java
new file mode 100644
index 0000000..481c6d8
--- /dev/null
+++ b/java/dagger/internal/codegen/bindinggraphvalidation/MapMultibindingValidator.java
@@ -0,0 +1,211 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.bindinggraphvalidation;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.collect.Multimaps.filterKeys;
+import static dagger.internal.codegen.base.Formatter.INDENT;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSetMultimap;
+import static dagger.model.BindingKind.MULTIBOUND_MAP;
+import static javax.tools.Diagnostic.Kind.ERROR;
+
+import com.google.auto.common.MoreTypes;
+import com.google.common.base.Equivalence;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSetMultimap;
+import com.google.common.collect.Multimaps;
+import com.google.common.collect.SetMultimap;
+import dagger.internal.codegen.base.MapType;
+import dagger.internal.codegen.binding.BindingDeclaration;
+import dagger.internal.codegen.binding.BindingDeclarationFormatter;
+import dagger.internal.codegen.binding.BindingNode;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.binding.KeyFactory;
+import dagger.model.BindingGraph;
+import dagger.model.Key;
+import dagger.producers.Producer;
+import dagger.spi.BindingGraphPlugin;
+import dagger.spi.DiagnosticReporter;
+import java.util.Set;
+import javax.inject.Inject;
+import javax.inject.Provider;
+import javax.lang.model.type.DeclaredType;
+
+/**
+ * Reports an error for any map binding with either more than one contribution with the same map key
+ * or contributions with inconsistent map key annotation types.
+ */
+final class MapMultibindingValidator implements BindingGraphPlugin {
+
+ private final BindingDeclarationFormatter bindingDeclarationFormatter;
+ private final KeyFactory keyFactory;
+
+ @Inject
+ MapMultibindingValidator(
+ BindingDeclarationFormatter bindingDeclarationFormatter, KeyFactory keyFactory) {
+ this.bindingDeclarationFormatter = bindingDeclarationFormatter;
+ this.keyFactory = keyFactory;
+ }
+
+ @Override
+ public String pluginName() {
+ return "Dagger/MapKeys";
+ }
+
+ @Override
+ public void visitGraph(BindingGraph bindingGraph, DiagnosticReporter diagnosticReporter) {
+ mapMultibindings(bindingGraph)
+ .forEach(
+ binding -> {
+ ImmutableSet<ContributionBinding> contributions =
+ mapBindingContributions(binding, bindingGraph);
+ checkForDuplicateMapKeys(binding, contributions, diagnosticReporter);
+ checkForInconsistentMapKeyAnnotationTypes(binding, contributions, diagnosticReporter);
+ });
+ }
+
+ /**
+ * Returns the map multibindings in the binding graph. If a graph contains bindings for more than
+ * one of the following for the same {@code K} and {@code V}, then only the first one found will
+ * be returned so we don't report the same map contribution problem more than once.
+ *
+ * <ol>
+ * <li>{@code Map<K, V>}
+ * <li>{@code Map<K, Provider<V>>}
+ * <li>{@code Map<K, Producer<V>>}
+ * </ol>
+ */
+ private ImmutableSet<dagger.model.Binding> mapMultibindings(BindingGraph bindingGraph) {
+ ImmutableSetMultimap<Key, dagger.model.Binding> mapMultibindings =
+ bindingGraph.bindings().stream()
+ .filter(node -> node.kind().equals(MULTIBOUND_MAP))
+ .collect(toImmutableSetMultimap(dagger.model.Binding::key, node -> node));
+
+ // Mutlbindings for Map<K, V>
+ SetMultimap<Key, dagger.model.Binding> plainValueMapMultibindings =
+ filterKeys(mapMultibindings, key -> !MapType.from(key).valuesAreFrameworkType());
+
+ // Multibindings for Map<K, Provider<V>> where Map<K, V> isn't in plainValueMapMultibindings
+ SetMultimap<Key, dagger.model.Binding> providerValueMapMultibindings =
+ filterKeys(
+ mapMultibindings,
+ key ->
+ MapType.from(key).valuesAreTypeOf(Provider.class)
+ && !plainValueMapMultibindings.containsKey(keyFactory.unwrapMapValueType(key)));
+
+ // Multibindings for Map<K, Producer<V>> where Map<K, V> isn't in plainValueMapMultibindings and
+ // Map<K, Provider<V>> isn't in providerValueMapMultibindings
+ SetMultimap<Key, dagger.model.Binding> producerValueMapMultibindings =
+ filterKeys(
+ mapMultibindings,
+ key ->
+ MapType.from(key).valuesAreTypeOf(Producer.class)
+ && !plainValueMapMultibindings.containsKey(keyFactory.unwrapMapValueType(key))
+ && !providerValueMapMultibindings.containsKey(
+ keyFactory.rewrapMapKey(key, Producer.class, Provider.class).get()));
+
+ return new ImmutableSet.Builder<dagger.model.Binding>()
+ .addAll(plainValueMapMultibindings.values())
+ .addAll(providerValueMapMultibindings.values())
+ .addAll(producerValueMapMultibindings.values())
+ .build();
+ }
+
+ private ImmutableSet<ContributionBinding> mapBindingContributions(
+ dagger.model.Binding binding, BindingGraph bindingGraph) {
+ checkArgument(binding.kind().equals(MULTIBOUND_MAP));
+ return bindingGraph.requestedBindings(binding).stream()
+ .map(b -> (BindingNode) b)
+ .map(b -> (ContributionBinding) b.delegate())
+ .collect(toImmutableSet());
+ }
+
+ private void checkForDuplicateMapKeys(
+ dagger.model.Binding multiboundMapBinding,
+ ImmutableSet<ContributionBinding> contributions,
+ DiagnosticReporter diagnosticReporter) {
+ ImmutableSetMultimap<?, ContributionBinding> contributionsByMapKey =
+ ImmutableSetMultimap.copyOf(
+ Multimaps.index(contributions, ContributionBinding::wrappedMapKeyAnnotation));
+
+ for (Set<ContributionBinding> contributionsForOneMapKey :
+ Multimaps.asMap(contributionsByMapKey).values()) {
+ if (contributionsForOneMapKey.size() > 1) {
+ diagnosticReporter.reportBinding(
+ ERROR,
+ multiboundMapBinding,
+ duplicateMapKeyErrorMessage(contributionsForOneMapKey, multiboundMapBinding.key()));
+ }
+ }
+ }
+
+ private void checkForInconsistentMapKeyAnnotationTypes(
+ dagger.model.Binding multiboundMapBinding,
+ ImmutableSet<ContributionBinding> contributions,
+ DiagnosticReporter diagnosticReporter) {
+ ImmutableSetMultimap<Equivalence.Wrapper<DeclaredType>, ContributionBinding>
+ contributionsByMapKeyAnnotationType = indexByMapKeyAnnotationType(contributions);
+
+ if (contributionsByMapKeyAnnotationType.keySet().size() > 1) {
+ diagnosticReporter.reportBinding(
+ ERROR,
+ multiboundMapBinding,
+ inconsistentMapKeyAnnotationTypesErrorMessage(
+ contributionsByMapKeyAnnotationType, multiboundMapBinding.key()));
+ }
+ }
+
+ private static ImmutableSetMultimap<Equivalence.Wrapper<DeclaredType>, ContributionBinding>
+ indexByMapKeyAnnotationType(ImmutableSet<ContributionBinding> contributions) {
+ return ImmutableSetMultimap.copyOf(
+ Multimaps.index(
+ contributions,
+ mapBinding ->
+ MoreTypes.equivalence()
+ .wrap(mapBinding.mapKeyAnnotation().get().getAnnotationType())));
+ }
+
+ private String inconsistentMapKeyAnnotationTypesErrorMessage(
+ ImmutableSetMultimap<Equivalence.Wrapper<DeclaredType>, ContributionBinding>
+ contributionsByMapKeyAnnotationType,
+ Key mapBindingKey) {
+ StringBuilder message =
+ new StringBuilder(mapBindingKey.toString())
+ .append(" uses more than one @MapKey annotation type");
+ Multimaps.asMap(contributionsByMapKeyAnnotationType)
+ .forEach(
+ (annotationType, contributions) -> {
+ message.append('\n').append(INDENT).append(annotationType.get()).append(':');
+ bindingDeclarationFormatter.formatIndentedList(message, contributions, 2);
+ });
+ return message.toString();
+ }
+
+ private String duplicateMapKeyErrorMessage(
+ Set<ContributionBinding> contributionsForOneMapKey, Key mapBindingKey) {
+ StringBuilder message =
+ new StringBuilder("The same map key is bound more than once for ").append(mapBindingKey);
+
+ bindingDeclarationFormatter.formatIndentedList(
+ message,
+ ImmutableList.sortedCopyOf(BindingDeclaration.COMPARATOR, contributionsForOneMapKey),
+ 1);
+ return message.toString();
+ }
+}
diff --git a/java/dagger/internal/codegen/bindinggraphvalidation/MissingBindingValidator.java b/java/dagger/internal/codegen/bindinggraphvalidation/MissingBindingValidator.java
new file mode 100644
index 0000000..7334cd9
--- /dev/null
+++ b/java/dagger/internal/codegen/bindinggraphvalidation/MissingBindingValidator.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.bindinggraphvalidation;
+
+import static com.google.common.base.Verify.verify;
+import static dagger.internal.codegen.base.Keys.isValidImplicitProvisionKey;
+import static dagger.internal.codegen.base.Keys.isValidMembersInjectionKey;
+import static dagger.internal.codegen.base.RequestKinds.canBeSatisfiedByProductionBinding;
+import static dagger.internal.codegen.extension.DaggerStreams.instancesOf;
+import static javax.tools.Diagnostic.Kind.ERROR;
+
+import dagger.internal.codegen.binding.InjectBindingRegistry;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.BindingGraph;
+import dagger.model.BindingGraph.ComponentNode;
+import dagger.model.BindingGraph.DependencyEdge;
+import dagger.model.BindingGraph.MissingBinding;
+import dagger.model.BindingGraph.Node;
+import dagger.model.Key;
+import dagger.spi.BindingGraphPlugin;
+import dagger.spi.DiagnosticReporter;
+import javax.inject.Inject;
+import javax.lang.model.type.TypeKind;
+
+/** Reports errors for missing bindings. */
+final class MissingBindingValidator implements BindingGraphPlugin {
+
+ private final DaggerTypes types;
+ private final InjectBindingRegistry injectBindingRegistry;
+
+ @Inject
+ MissingBindingValidator(
+ DaggerTypes types, InjectBindingRegistry injectBindingRegistry) {
+ this.types = types;
+ this.injectBindingRegistry = injectBindingRegistry;
+ }
+
+ @Override
+ public String pluginName() {
+ return "Dagger/MissingBinding";
+ }
+
+ @Override
+ public void visitGraph(BindingGraph graph, DiagnosticReporter diagnosticReporter) {
+ // Don't report missing bindings when validating a full binding graph or a graph built from a
+ // subcomponent.
+ if (graph.isFullBindingGraph() || graph.rootComponentNode().isSubcomponent()) {
+ return;
+ }
+ graph
+ .missingBindings()
+ .forEach(missingBinding -> reportMissingBinding(missingBinding, graph, diagnosticReporter));
+ }
+
+ private void reportMissingBinding(
+ MissingBinding missingBinding, BindingGraph graph, DiagnosticReporter diagnosticReporter) {
+ diagnosticReporter.reportBinding(
+ ERROR, missingBinding, missingBindingErrorMessage(missingBinding, graph));
+ }
+
+ private String missingBindingErrorMessage(MissingBinding missingBinding, BindingGraph graph) {
+ Key key = missingBinding.key();
+ StringBuilder errorMessage = new StringBuilder();
+ // Wildcards should have already been checked by DependencyRequestValidator.
+ verify(!key.type().getKind().equals(TypeKind.WILDCARD), "unexpected wildcard request: %s", key);
+ // TODO(ronshapiro): replace "provided" with "satisfied"?
+ errorMessage.append(key).append(" cannot be provided without ");
+ if (isValidImplicitProvisionKey(key, types)) {
+ errorMessage.append("an @Inject constructor or ");
+ }
+ errorMessage.append("an @Provides-"); // TODO(dpb): s/an/a
+ if (allIncomingDependenciesCanUseProduction(missingBinding, graph)) {
+ errorMessage.append(" or @Produces-");
+ }
+ errorMessage.append("annotated method.");
+ if (isValidMembersInjectionKey(key) && typeHasInjectionSites(key)) {
+ errorMessage.append(
+ " This type supports members injection but cannot be implicitly provided.");
+ }
+ graph.bindings(key).stream()
+ .map(binding -> binding.componentPath().currentComponent())
+ .distinct()
+ .forEach(
+ component ->
+ errorMessage
+ .append("\nA binding with matching key exists in component: ")
+ .append(component.getQualifiedName()));
+ return errorMessage.toString();
+ }
+
+ private boolean allIncomingDependenciesCanUseProduction(
+ MissingBinding missingBinding, BindingGraph graph) {
+ return graph.network().inEdges(missingBinding).stream()
+ .flatMap(instancesOf(DependencyEdge.class))
+ .allMatch(edge -> dependencyCanBeProduction(edge, graph));
+ }
+
+ // TODO(ronshapiro): merge with
+ // ProvisionDependencyOnProduerBindingValidator.dependencyCanUseProduction
+ private boolean dependencyCanBeProduction(DependencyEdge edge, BindingGraph graph) {
+ Node source = graph.network().incidentNodes(edge).source();
+ if (source instanceof ComponentNode) {
+ return canBeSatisfiedByProductionBinding(edge.dependencyRequest().kind());
+ }
+ if (source instanceof dagger.model.Binding) {
+ return ((dagger.model.Binding) source).isProduction();
+ }
+ throw new IllegalArgumentException(
+ "expected a dagger.model.Binding or ComponentNode: " + source);
+ }
+
+ private boolean typeHasInjectionSites(Key key) {
+ return injectBindingRegistry
+ .getOrFindMembersInjectionBinding(key)
+ .map(binding -> !binding.injectionSites().isEmpty())
+ .orElse(false);
+ }
+}
diff --git a/java/dagger/internal/codegen/bindinggraphvalidation/NullableBindingValidator.java b/java/dagger/internal/codegen/bindinggraphvalidation/NullableBindingValidator.java
new file mode 100644
index 0000000..9800b15
--- /dev/null
+++ b/java/dagger/internal/codegen/bindinggraphvalidation/NullableBindingValidator.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.bindinggraphvalidation;
+
+import static dagger.internal.codegen.extension.DaggerStreams.instancesOf;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import dagger.internal.codegen.compileroption.CompilerOptions;
+import dagger.model.BindingGraph;
+import dagger.model.BindingGraph.DependencyEdge;
+import dagger.spi.BindingGraphPlugin;
+import dagger.spi.DiagnosticReporter;
+import javax.inject.Inject;
+
+/**
+ * Reports errors or warnings (depending on the {@code -Adagger.nullableValidation} value) for each
+ * non-nullable dependency request that is satisfied by a nullable binding.
+ */
+final class NullableBindingValidator implements BindingGraphPlugin {
+
+ private final CompilerOptions compilerOptions;
+
+ @Inject
+ NullableBindingValidator(CompilerOptions compilerOptions) {
+ this.compilerOptions = compilerOptions;
+ }
+
+ @Override
+ public void visitGraph(BindingGraph bindingGraph, DiagnosticReporter diagnosticReporter) {
+ for (dagger.model.Binding binding : nullableBindings(bindingGraph)) {
+ for (DependencyEdge dependencyEdge : nonNullableDependencies(bindingGraph, binding)) {
+ diagnosticReporter.reportDependency(
+ compilerOptions.nullableValidationKind(),
+ dependencyEdge,
+ nullableToNonNullable(
+ binding.key().toString(),
+ binding.toString())); // binding.toString() will include the @Nullable
+ }
+ }
+ }
+
+ @Override
+ public String pluginName() {
+ return "Dagger/Nullable";
+ }
+
+ private ImmutableList<dagger.model.Binding> nullableBindings(BindingGraph bindingGraph) {
+ return bindingGraph.bindings().stream()
+ .filter(binding -> binding.isNullable())
+ .collect(toImmutableList());
+ }
+
+ private ImmutableSet<DependencyEdge> nonNullableDependencies(
+ BindingGraph bindingGraph, dagger.model.Binding binding) {
+ return bindingGraph.network().inEdges(binding).stream()
+ .flatMap(instancesOf(DependencyEdge.class))
+ .filter(edge -> !edge.dependencyRequest().isNullable())
+ .collect(toImmutableSet());
+ }
+
+ @VisibleForTesting
+ static String nullableToNonNullable(String key, String binding) {
+ return String.format("%s is not nullable, but is being provided by %s", key, binding);
+ }
+}
diff --git a/java/dagger/internal/codegen/bindinggraphvalidation/ProvisionDependencyOnProducerBindingValidator.java b/java/dagger/internal/codegen/bindinggraphvalidation/ProvisionDependencyOnProducerBindingValidator.java
new file mode 100644
index 0000000..7d742f9
--- /dev/null
+++ b/java/dagger/internal/codegen/bindinggraphvalidation/ProvisionDependencyOnProducerBindingValidator.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.bindinggraphvalidation;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Verify.verify;
+import static dagger.internal.codegen.base.RequestKinds.canBeSatisfiedByProductionBinding;
+import static dagger.internal.codegen.extension.DaggerStreams.instancesOf;
+import static javax.tools.Diagnostic.Kind.ERROR;
+
+import dagger.model.BindingGraph;
+import dagger.model.BindingGraph.DependencyEdge;
+import dagger.model.BindingGraph.Node;
+import dagger.spi.BindingGraphPlugin;
+import dagger.spi.DiagnosticReporter;
+import java.util.stream.Stream;
+import javax.inject.Inject;
+
+/**
+ * Reports an error for each provision-only dependency request that is satisfied by a production
+ * binding.
+ */
+// TODO(b/29509141): Clarify the error.
+final class ProvisionDependencyOnProducerBindingValidator implements BindingGraphPlugin {
+
+ @Inject
+ ProvisionDependencyOnProducerBindingValidator() {}
+
+ @Override
+ public String pluginName() {
+ return "Dagger/ProviderDependsOnProducer";
+ }
+
+ @Override
+ public void visitGraph(BindingGraph bindingGraph, DiagnosticReporter diagnosticReporter) {
+ provisionDependenciesOnProductionBindings(bindingGraph)
+ .forEach(
+ provisionDependent ->
+ diagnosticReporter.reportDependency(
+ ERROR,
+ provisionDependent,
+ provisionDependent.isEntryPoint()
+ ? entryPointErrorMessage(provisionDependent)
+ : dependencyErrorMessage(provisionDependent, bindingGraph)));
+ }
+
+ private Stream<DependencyEdge> provisionDependenciesOnProductionBindings(
+ BindingGraph bindingGraph) {
+ return bindingGraph.bindings().stream()
+ .filter(binding -> binding.isProduction())
+ .flatMap(binding -> incomingDependencies(binding, bindingGraph))
+ .filter(edge -> !dependencyCanUseProduction(edge, bindingGraph));
+ }
+
+ /** Returns the dependencies on {@code binding}. */
+ // TODO(dpb): Move to BindingGraph.
+ private Stream<DependencyEdge> incomingDependencies(
+ dagger.model.Binding binding, BindingGraph bindingGraph) {
+ return bindingGraph.network().inEdges(binding).stream()
+ .flatMap(instancesOf(DependencyEdge.class));
+ }
+
+ // TODO(ronshapiro): merge with MissingBindingValidator.dependencyCanUseProduction
+ private boolean dependencyCanUseProduction(DependencyEdge edge, BindingGraph bindingGraph) {
+ return edge.isEntryPoint()
+ ? canBeSatisfiedByProductionBinding(edge.dependencyRequest().kind())
+ : bindingRequestingDependency(edge, bindingGraph).isProduction();
+ }
+
+ /**
+ * Returns the binding that requests a dependency.
+ *
+ * @throws IllegalArgumentException if {@code dependency} is an {@linkplain
+ * DependencyEdge#isEntryPoint() entry point}.
+ */
+ // TODO(dpb): Move to BindingGraph.
+ private dagger.model.Binding bindingRequestingDependency(
+ DependencyEdge dependency, BindingGraph bindingGraph) {
+ checkArgument(!dependency.isEntryPoint());
+ Node source = bindingGraph.network().incidentNodes(dependency).source();
+ verify(
+ source instanceof dagger.model.Binding,
+ "expected source of %s to be a binding, but was: %s",
+ dependency,
+ source);
+ return (dagger.model.Binding) source;
+ }
+
+ private String entryPointErrorMessage(DependencyEdge entryPoint) {
+ return String.format(
+ "%s is a provision entry-point, which cannot depend on a production.",
+ entryPoint.dependencyRequest().key());
+ }
+
+ private String dependencyErrorMessage(
+ DependencyEdge dependencyOnProduction, BindingGraph bindingGraph) {
+ return String.format(
+ "%s is a provision, which cannot depend on a production.",
+ bindingRequestingDependency(dependencyOnProduction, bindingGraph).key());
+ }
+}
diff --git a/java/dagger/internal/codegen/bindinggraphvalidation/SubcomponentFactoryMethodValidator.java b/java/dagger/internal/codegen/bindinggraphvalidation/SubcomponentFactoryMethodValidator.java
new file mode 100644
index 0000000..bf83a69
--- /dev/null
+++ b/java/dagger/internal/codegen/bindinggraphvalidation/SubcomponentFactoryMethodValidator.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.bindinggraphvalidation;
+
+import static com.google.auto.common.MoreTypes.asDeclared;
+import static com.google.auto.common.MoreTypes.asExecutable;
+import static com.google.auto.common.MoreTypes.asTypeElements;
+import static com.google.common.collect.Sets.union;
+import static dagger.internal.codegen.binding.ComponentRequirement.componentCanMakeNewInstances;
+import static dagger.internal.codegen.extension.DaggerStreams.instancesOf;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static javax.tools.Diagnostic.Kind.ERROR;
+
+import com.google.common.base.Joiner;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import com.google.common.collect.Sets.SetView;
+import dagger.internal.codegen.base.Util;
+import dagger.internal.codegen.binding.ComponentNodeImpl;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.BindingGraph;
+import dagger.model.BindingGraph.ChildFactoryMethodEdge;
+import dagger.model.BindingGraph.ComponentNode;
+import dagger.spi.BindingGraphPlugin;
+import dagger.spi.DiagnosticReporter;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
+import javax.inject.Inject;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.ExecutableType;
+
+/** Reports an error if a subcomponent factory method is missing required modules. */
+final class SubcomponentFactoryMethodValidator implements BindingGraphPlugin {
+
+ private final DaggerTypes types;
+ private final KotlinMetadataUtil metadataUtil;
+ private final Map<ComponentNode, Set<TypeElement>> inheritedModulesCache = new HashMap<>();
+
+ @Inject
+ SubcomponentFactoryMethodValidator(DaggerTypes types, KotlinMetadataUtil metadataUtil) {
+ this.types = types;
+ this.metadataUtil = metadataUtil;
+ }
+
+ @Override
+ public String pluginName() {
+ return "Dagger/SubcomponentFactoryMethodMissingModule";
+ }
+
+ @Override
+ public void visitGraph(BindingGraph bindingGraph, DiagnosticReporter diagnosticReporter) {
+ if (!bindingGraph.rootComponentNode().isRealComponent()
+ || bindingGraph.rootComponentNode().isSubcomponent()) {
+ // We don't know all the modules that might be owned by the child until we know the real root
+ // component, which we don't if the root component node is really a module or a subcomponent.
+ return;
+ }
+ bindingGraph.network().edges().stream()
+ .flatMap(instancesOf(ChildFactoryMethodEdge.class))
+ .forEach(
+ edge -> {
+ ImmutableSet<TypeElement> missingModules = findMissingModules(edge, bindingGraph);
+ if (!missingModules.isEmpty()) {
+ reportMissingModuleParameters(
+ edge, missingModules, bindingGraph, diagnosticReporter);
+ }
+ });
+ }
+
+ private ImmutableSet<TypeElement> findMissingModules(
+ ChildFactoryMethodEdge edge, BindingGraph graph) {
+ ImmutableSet<TypeElement> factoryMethodParameters =
+ subgraphFactoryMethodParameters(edge, graph);
+ ComponentNode child = (ComponentNode) graph.network().incidentNodes(edge).target();
+ SetView<TypeElement> modulesOwnedByChild = ownedModules(child, graph);
+ return graph.bindings().stream()
+ // bindings owned by child
+ .filter(binding -> binding.componentPath().equals(child.componentPath()))
+ // that require a module instance
+ .filter(binding -> binding.requiresModuleInstance())
+ .map(binding -> binding.contributingModule().get())
+ .distinct()
+ // module owned by child
+ .filter(module -> modulesOwnedByChild.contains(module))
+ // module not in the method parameters
+ .filter(module -> !factoryMethodParameters.contains(module))
+ // module doesn't have an accessible no-arg constructor
+ .filter(moduleType -> !componentCanMakeNewInstances(moduleType, metadataUtil))
+ .collect(toImmutableSet());
+ }
+
+ private ImmutableSet<TypeElement> subgraphFactoryMethodParameters(
+ ChildFactoryMethodEdge edge, BindingGraph bindingGraph) {
+ ComponentNode parent = (ComponentNode) bindingGraph.network().incidentNodes(edge).source();
+ DeclaredType parentType = asDeclared(parent.componentPath().currentComponent().asType());
+ ExecutableType factoryMethodType =
+ asExecutable(types.asMemberOf(parentType, edge.factoryMethod()));
+ return asTypeElements(factoryMethodType.getParameterTypes());
+ }
+
+ private SetView<TypeElement> ownedModules(ComponentNode component, BindingGraph graph) {
+ return Sets.difference(
+ ((ComponentNodeImpl) component).componentDescriptor().moduleTypes(),
+ inheritedModules(component, graph));
+ }
+
+ private Set<TypeElement> inheritedModules(ComponentNode component, BindingGraph graph) {
+ return Util.reentrantComputeIfAbsent(
+ inheritedModulesCache, component, uncachedInheritedModules(graph));
+ }
+
+ private Function<ComponentNode, Set<TypeElement>> uncachedInheritedModules(BindingGraph graph) {
+ return componentNode ->
+ componentNode.componentPath().atRoot()
+ ? ImmutableSet.of()
+ : graph
+ .componentNode(componentNode.componentPath().parent())
+ .map(parent -> union(ownedModules(parent, graph), inheritedModules(parent, graph)))
+ .get();
+ }
+
+ private void reportMissingModuleParameters(
+ ChildFactoryMethodEdge edge,
+ ImmutableSet<TypeElement> missingModules,
+ BindingGraph graph,
+ DiagnosticReporter diagnosticReporter) {
+ diagnosticReporter.reportSubcomponentFactoryMethod(
+ ERROR,
+ edge,
+ "%s requires modules which have no visible default constructors. "
+ + "Add the following modules as parameters to this method: %s",
+ graph
+ .network()
+ .incidentNodes(edge)
+ .target()
+ .componentPath()
+ .currentComponent()
+ .getQualifiedName(),
+ Joiner.on(", ").join(missingModules));
+ }
+}
diff --git a/java/dagger/internal/codegen/bootstrap/BUILD b/java/dagger/internal/codegen/bootstrap/BUILD
new file mode 100644
index 0000000..2527d3c
--- /dev/null
+++ b/java/dagger/internal/codegen/bootstrap/BUILD
@@ -0,0 +1,33 @@
+# Copyright (C) 2019 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Bootstrap libraries for building Dagger with Dagger.
+
+load("@rules_java//java:defs.bzl", "java_import", "java_plugin")
+
+package(default_visibility = ["//:src"])
+
+java_plugin(
+ name = "bootstrap",
+ generates_api = 1,
+ processor_class = "dagger.internal.codegen.ComponentProcessor",
+ deps = [":bootstrap_compiler"],
+)
+
+java_import(
+ name = "bootstrap_compiler",
+ jars = ["bootstrap_compiler_deploy.jar"],
+ visibility = ["//visibility:private"],
+)
diff --git a/java/dagger/internal/codegen/bootstrap/bootstrap_compiler_deploy.jar b/java/dagger/internal/codegen/bootstrap/bootstrap_compiler_deploy.jar
new file mode 100644
index 0000000..b69dc65
--- /dev/null
+++ b/java/dagger/internal/codegen/bootstrap/bootstrap_compiler_deploy.jar
Binary files differ
diff --git a/java/dagger/internal/codegen/bootstrap_compiler_deploy.jar b/java/dagger/internal/codegen/bootstrap_compiler_deploy.jar
deleted file mode 100644
index ad9761d..0000000
--- a/java/dagger/internal/codegen/bootstrap_compiler_deploy.jar
+++ /dev/null
Binary files differ
diff --git a/java/dagger/internal/codegen/compileroption/BUILD b/java/dagger/internal/codegen/compileroption/BUILD
new file mode 100644
index 0000000..ef39b34
--- /dev/null
+++ b/java/dagger/internal/codegen/compileroption/BUILD
@@ -0,0 +1,38 @@
+# Copyright (C) 2019 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Sources related to compiler options.
+
+load("@rules_java//java:defs.bzl", "java_library")
+
+package(default_visibility = ["//:src"])
+
+java_library(
+ name = "compileroption",
+ srcs = glob(["*.java"]),
+ plugins = ["//java/dagger/internal/codegen/bootstrap"],
+ tags = ["maven:merged"],
+ deps = [
+ "//java/dagger:core",
+ "//java/dagger/internal/codegen/extension",
+ "//java/dagger/internal/codegen/langmodel",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/producers",
+ "@google_bazel_common//third_party/java/google_java_format",
+ "@google_bazel_common//third_party/java/jsr330_inject",
+ "@maven//:com_google_auto_auto_common",
+ ],
+)
diff --git a/java/dagger/internal/codegen/compileroption/CompilerOptions.java b/java/dagger/internal/codegen/compileroption/CompilerOptions.java
new file mode 100644
index 0000000..a0d1cda
--- /dev/null
+++ b/java/dagger/internal/codegen/compileroption/CompilerOptions.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.compileroption;
+
+import javax.lang.model.element.TypeElement;
+import javax.tools.Diagnostic;
+
+/** A collection of options that dictate how the compiler will run. */
+public abstract class CompilerOptions {
+ public abstract boolean usesProducers();
+
+ /**
+ * Returns true if the fast initialization flag, {@code fastInit}, is enabled.
+ *
+ * <p>If enabled, the generated code will attempt to optimize for fast component initialization.
+ * This is done by reducing the number of factory classes loaded during initialization and the
+ * number of eagerly initialized fields at the cost of potential memory leaks and higher
+ * per-provision instantiation time.
+ */
+ public abstract boolean fastInit(TypeElement element);
+
+ public abstract boolean formatGeneratedSource();
+
+ public abstract boolean writeProducerNameInToken();
+
+ public abstract Diagnostic.Kind nullableValidationKind();
+
+ public final boolean doCheckForNulls() {
+ return nullableValidationKind().equals(Diagnostic.Kind.ERROR);
+ }
+
+ public abstract Diagnostic.Kind privateMemberValidationKind();
+
+ public abstract Diagnostic.Kind staticMemberValidationKind();
+
+ /**
+ * If {@code true}, Dagger will generate factories and components even if some members-injected
+ * types have {@code private} or {@code static} {@code @Inject}-annotated members.
+ *
+ * <p>This should only ever be enabled by the TCK tests. Disabling this validation could lead to
+ * generating code that does not compile.
+ */
+ public abstract boolean ignorePrivateAndStaticInjectionForComponent();
+
+ public abstract ValidationType scopeCycleValidationType();
+
+ /**
+ * If {@code true}, Dagger will validate all transitive component dependencies of a component.
+ * Otherwise, Dagger will only validate the direct component dependencies.
+ *
+ * <p>Note: this is different from scopeCycleValidationType, which lets you silence errors of
+ * transitive component dependencies, but still requires the full transitive dependencies in the
+ * classpath.
+ *
+ * <p>The main motivation for this flag is to prevent requiring the transitive component
+ * dependencies in the classpath to speed up builds. See
+ * https://github.com/google/dagger/issues/970.
+ */
+ public abstract boolean validateTransitiveComponentDependencies();
+
+ public abstract boolean warnIfInjectionFactoryNotGeneratedUpstream();
+
+ public abstract boolean headerCompilation();
+
+ public abstract ValidationType fullBindingGraphValidationType();
+
+ /**
+ * If {@code true}, each plugin will visit the full binding graph for the given element.
+ *
+ * @throws IllegalArgumentException if {@code element} is not a module or (sub)component
+ */
+ public abstract boolean pluginsVisitFullBindingGraphs(TypeElement element);
+
+ public abstract Diagnostic.Kind moduleHasDifferentScopesDiagnosticKind();
+
+ public abstract ValidationType explicitBindingConflictsWithInjectValidationType();
+
+ public abstract boolean experimentalDaggerErrorMessages();
+
+ /** Returns the number of bindings allowed per shard. */
+ public int keysPerComponentShard(TypeElement component) {
+ return 3500;
+ }
+
+ /**
+ * This option enables a fix to an issue where Dagger previously would erroneously allow
+ * multibinding contributions in a component to have dependencies on child components. This will
+ * eventually become the default and enforced.
+ */
+ public abstract boolean strictMultibindingValidation();
+}
diff --git a/java/dagger/internal/codegen/compileroption/FeatureStatus.java b/java/dagger/internal/codegen/compileroption/FeatureStatus.java
new file mode 100644
index 0000000..d989679
--- /dev/null
+++ b/java/dagger/internal/codegen/compileroption/FeatureStatus.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.compileroption;
+
+/** Allows options to control how features in component processing are enabled. */
+public enum FeatureStatus {
+ ENABLED,
+ DISABLED;
+}
diff --git a/java/dagger/internal/codegen/compileroption/JavacPluginCompilerOptions.java b/java/dagger/internal/codegen/compileroption/JavacPluginCompilerOptions.java
new file mode 100644
index 0000000..a86cc1b
--- /dev/null
+++ b/java/dagger/internal/codegen/compileroption/JavacPluginCompilerOptions.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.compileroption;
+
+import static dagger.internal.codegen.compileroption.ValidationType.NONE;
+import static javax.tools.Diagnostic.Kind.NOTE;
+
+import javax.inject.Inject;
+import javax.lang.model.element.TypeElement;
+import javax.tools.Diagnostic;
+
+/** {@link CompilerOptions} for Javac plugins (e.g. for Dagger statistics or Kythe). */
+public final class JavacPluginCompilerOptions extends CompilerOptions {
+
+ @Inject
+ JavacPluginCompilerOptions() {}
+
+ @Override
+ public boolean usesProducers() {
+ return true;
+ }
+
+ @Override
+ public boolean fastInit(TypeElement element) {
+ return false;
+ }
+
+ @Override
+ public boolean formatGeneratedSource() {
+ return false;
+ }
+
+ @Override
+ public boolean writeProducerNameInToken() {
+ return true;
+ }
+
+ @Override
+ public Diagnostic.Kind nullableValidationKind() {
+ return NOTE;
+ }
+
+ @Override
+ public Diagnostic.Kind privateMemberValidationKind() {
+ return NOTE;
+ }
+
+ @Override
+ public Diagnostic.Kind staticMemberValidationKind() {
+ return NOTE;
+ }
+
+ @Override
+ public boolean ignorePrivateAndStaticInjectionForComponent() {
+ return false;
+ }
+
+ @Override
+ public ValidationType scopeCycleValidationType() {
+ return NONE;
+ }
+
+ @Override
+ public boolean validateTransitiveComponentDependencies() {
+ return true;
+ }
+
+ @Override
+ public boolean warnIfInjectionFactoryNotGeneratedUpstream() {
+ return false;
+ }
+
+ @Override
+ public boolean headerCompilation() {
+ return false;
+ }
+
+ @Override
+ public ValidationType fullBindingGraphValidationType() {
+ return NONE;
+ }
+
+ @Override
+ public boolean pluginsVisitFullBindingGraphs(TypeElement element) {
+ return false;
+ }
+
+ @Override
+ public Diagnostic.Kind moduleHasDifferentScopesDiagnosticKind() {
+ return NOTE;
+ }
+
+ @Override
+ public ValidationType explicitBindingConflictsWithInjectValidationType() {
+ return NONE;
+ }
+
+ @Override
+ public boolean experimentalDaggerErrorMessages() {
+ return false;
+ }
+
+ @Override
+ public boolean strictMultibindingValidation() {
+ return false;
+ }
+}
diff --git a/java/dagger/internal/codegen/compileroption/ProcessingEnvironmentCompilerOptions.java b/java/dagger/internal/codegen/compileroption/ProcessingEnvironmentCompilerOptions.java
new file mode 100644
index 0000000..06d15a2
--- /dev/null
+++ b/java/dagger/internal/codegen/compileroption/ProcessingEnvironmentCompilerOptions.java
@@ -0,0 +1,520 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.compileroption;
+
+import static com.google.common.base.CaseFormat.LOWER_CAMEL;
+import static com.google.common.base.CaseFormat.UPPER_UNDERSCORE;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.collect.Sets.immutableEnumSet;
+import static dagger.internal.codegen.compileroption.FeatureStatus.DISABLED;
+import static dagger.internal.codegen.compileroption.FeatureStatus.ENABLED;
+import static dagger.internal.codegen.compileroption.ProcessingEnvironmentCompilerOptions.Feature.EXPERIMENTAL_AHEAD_OF_TIME_SUBCOMPONENTS;
+import static dagger.internal.codegen.compileroption.ProcessingEnvironmentCompilerOptions.Feature.EXPERIMENTAL_ANDROID_MODE;
+import static dagger.internal.codegen.compileroption.ProcessingEnvironmentCompilerOptions.Feature.EXPERIMENTAL_DAGGER_ERROR_MESSAGES;
+import static dagger.internal.codegen.compileroption.ProcessingEnvironmentCompilerOptions.Feature.FAST_INIT;
+import static dagger.internal.codegen.compileroption.ProcessingEnvironmentCompilerOptions.Feature.FLOATING_BINDS_METHODS;
+import static dagger.internal.codegen.compileroption.ProcessingEnvironmentCompilerOptions.Feature.FORMAT_GENERATED_SOURCE;
+import static dagger.internal.codegen.compileroption.ProcessingEnvironmentCompilerOptions.Feature.IGNORE_PRIVATE_AND_STATIC_INJECTION_FOR_COMPONENT;
+import static dagger.internal.codegen.compileroption.ProcessingEnvironmentCompilerOptions.Feature.PLUGINS_VISIT_FULL_BINDING_GRAPHS;
+import static dagger.internal.codegen.compileroption.ProcessingEnvironmentCompilerOptions.Feature.STRICT_MULTIBINDING_VALIDATION;
+import static dagger.internal.codegen.compileroption.ProcessingEnvironmentCompilerOptions.Feature.VALIDATE_TRANSITIVE_COMPONENT_DEPENDENCIES;
+import static dagger.internal.codegen.compileroption.ProcessingEnvironmentCompilerOptions.Feature.WARN_IF_INJECTION_FACTORY_NOT_GENERATED_UPSTREAM;
+import static dagger.internal.codegen.compileroption.ProcessingEnvironmentCompilerOptions.Feature.WRITE_PRODUCER_NAME_IN_TOKEN;
+import static dagger.internal.codegen.compileroption.ProcessingEnvironmentCompilerOptions.KeyOnlyOption.HEADER_COMPILATION;
+import static dagger.internal.codegen.compileroption.ProcessingEnvironmentCompilerOptions.KeyOnlyOption.USE_GRADLE_INCREMENTAL_PROCESSING;
+import static dagger.internal.codegen.compileroption.ProcessingEnvironmentCompilerOptions.Validation.DISABLE_INTER_COMPONENT_SCOPE_VALIDATION;
+import static dagger.internal.codegen.compileroption.ProcessingEnvironmentCompilerOptions.Validation.EXPLICIT_BINDING_CONFLICTS_WITH_INJECT;
+import static dagger.internal.codegen.compileroption.ProcessingEnvironmentCompilerOptions.Validation.FULL_BINDING_GRAPH_VALIDATION;
+import static dagger.internal.codegen.compileroption.ProcessingEnvironmentCompilerOptions.Validation.MODULE_HAS_DIFFERENT_SCOPES_VALIDATION;
+import static dagger.internal.codegen.compileroption.ProcessingEnvironmentCompilerOptions.Validation.NULLABLE_VALIDATION;
+import static dagger.internal.codegen.compileroption.ProcessingEnvironmentCompilerOptions.Validation.PRIVATE_MEMBER_VALIDATION;
+import static dagger.internal.codegen.compileroption.ProcessingEnvironmentCompilerOptions.Validation.STATIC_MEMBER_VALIDATION;
+import static dagger.internal.codegen.compileroption.ValidationType.ERROR;
+import static dagger.internal.codegen.compileroption.ValidationType.NONE;
+import static dagger.internal.codegen.compileroption.ValidationType.WARNING;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static java.util.stream.Collectors.joining;
+import static java.util.stream.Stream.concat;
+
+import com.google.auto.common.MoreElements;
+import com.google.common.base.Ascii;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.producers.Produces;
+import java.util.Arrays;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Stream;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.inject.Inject;
+import javax.lang.model.element.TypeElement;
+import javax.tools.Diagnostic;
+
+/** {@link CompilerOptions} for the given {@link ProcessingEnvironment}. */
+public final class ProcessingEnvironmentCompilerOptions extends CompilerOptions {
+ // EnumOption<T> doesn't support integer inputs so just doing this as a 1-off for now.
+ private static final String KEYS_PER_COMPONENT_SHARD = "dagger.keysPerComponentShard";
+
+ private final ProcessingEnvironment processingEnvironment;
+ private final DaggerElements daggerElements;
+ private final Map<EnumOption<?>, Object> enumOptions = new HashMap<>();
+ private final Map<EnumOption<?>, ImmutableMap<String, ? extends Enum<?>>> allCommandLineOptions =
+ new HashMap<>();
+
+ @Inject
+ ProcessingEnvironmentCompilerOptions(
+ ProcessingEnvironment processingEnvironment, DaggerElements daggerElements) {
+ this.processingEnvironment = processingEnvironment;
+ this.daggerElements = daggerElements;
+ checkValid();
+ }
+
+ @Override
+ public boolean usesProducers() {
+ return processingEnvironment.getElementUtils().getTypeElement(Produces.class.getCanonicalName())
+ != null;
+ }
+
+ @Override
+ public boolean headerCompilation() {
+ return isEnabled(HEADER_COMPILATION);
+ }
+
+ @Override
+ public boolean fastInit(TypeElement component) {
+ return isEnabled(FAST_INIT);
+ }
+
+ @Override
+ public boolean formatGeneratedSource() {
+ return isEnabled(FORMAT_GENERATED_SOURCE);
+ }
+
+ @Override
+ public boolean writeProducerNameInToken() {
+ return isEnabled(WRITE_PRODUCER_NAME_IN_TOKEN);
+ }
+
+ @Override
+ public Diagnostic.Kind nullableValidationKind() {
+ return diagnosticKind(NULLABLE_VALIDATION);
+ }
+
+ @Override
+ public Diagnostic.Kind privateMemberValidationKind() {
+ return diagnosticKind(PRIVATE_MEMBER_VALIDATION);
+ }
+
+ @Override
+ public Diagnostic.Kind staticMemberValidationKind() {
+ return diagnosticKind(STATIC_MEMBER_VALIDATION);
+ }
+
+ @Override
+ public boolean ignorePrivateAndStaticInjectionForComponent() {
+ return isEnabled(IGNORE_PRIVATE_AND_STATIC_INJECTION_FOR_COMPONENT);
+ }
+
+ @Override
+ public ValidationType scopeCycleValidationType() {
+ return parseOption(DISABLE_INTER_COMPONENT_SCOPE_VALIDATION);
+ }
+
+ @Override
+ public boolean validateTransitiveComponentDependencies() {
+ return isEnabled(VALIDATE_TRANSITIVE_COMPONENT_DEPENDENCIES);
+ }
+
+ @Override
+ public boolean warnIfInjectionFactoryNotGeneratedUpstream() {
+ return isEnabled(WARN_IF_INJECTION_FACTORY_NOT_GENERATED_UPSTREAM);
+ }
+
+ @Override
+ public ValidationType fullBindingGraphValidationType() {
+ return parseOption(FULL_BINDING_GRAPH_VALIDATION);
+ }
+
+ @Override
+ public boolean pluginsVisitFullBindingGraphs(TypeElement component) {
+ return isEnabled(PLUGINS_VISIT_FULL_BINDING_GRAPHS);
+ }
+
+ @Override
+ public Diagnostic.Kind moduleHasDifferentScopesDiagnosticKind() {
+ return diagnosticKind(MODULE_HAS_DIFFERENT_SCOPES_VALIDATION);
+ }
+
+ @Override
+ public ValidationType explicitBindingConflictsWithInjectValidationType() {
+ return parseOption(EXPLICIT_BINDING_CONFLICTS_WITH_INJECT);
+ }
+
+ @Override
+ public boolean experimentalDaggerErrorMessages() {
+ return isEnabled(EXPERIMENTAL_DAGGER_ERROR_MESSAGES);
+ }
+
+ @Override
+ public boolean strictMultibindingValidation() {
+ return isEnabled(STRICT_MULTIBINDING_VALIDATION);
+ }
+
+ @Override
+ public int keysPerComponentShard(TypeElement component) {
+ if (processingEnvironment.getOptions().containsKey(KEYS_PER_COMPONENT_SHARD)) {
+ checkArgument(
+ "dagger.internal.codegen".contentEquals(
+ MoreElements.getPackage(component).getQualifiedName()),
+ "Cannot set %s. It is only meant for internal testing.", KEYS_PER_COMPONENT_SHARD);
+ return Integer.parseInt(
+ processingEnvironment.getOptions().get(KEYS_PER_COMPONENT_SHARD));
+ }
+ return super.keysPerComponentShard(component);
+ }
+
+ private boolean isEnabled(KeyOnlyOption keyOnlyOption) {
+ return processingEnvironment.getOptions().containsKey(keyOnlyOption.toString());
+ }
+
+ private boolean isEnabled(Feature feature) {
+ return parseOption(feature).equals(ENABLED);
+ }
+
+ private Diagnostic.Kind diagnosticKind(Validation validation) {
+ return parseOption(validation).diagnosticKind().get();
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ private ProcessingEnvironmentCompilerOptions checkValid() {
+ for (KeyOnlyOption keyOnlyOption : KeyOnlyOption.values()) {
+ isEnabled(keyOnlyOption);
+ }
+ for (Feature feature : Feature.values()) {
+ parseOption(feature);
+ }
+ for (Validation validation : Validation.values()) {
+ parseOption(validation);
+ }
+ noLongerRecognized(EXPERIMENTAL_ANDROID_MODE);
+ noLongerRecognized(FLOATING_BINDS_METHODS);
+ noLongerRecognized(EXPERIMENTAL_AHEAD_OF_TIME_SUBCOMPONENTS);
+ noLongerRecognized(USE_GRADLE_INCREMENTAL_PROCESSING);
+ return this;
+ }
+
+ private void noLongerRecognized(CommandLineOption commandLineOption) {
+ if (processingEnvironment.getOptions().containsKey(commandLineOption.toString())) {
+ processingEnvironment
+ .getMessager()
+ .printMessage(
+ Diagnostic.Kind.WARNING, commandLineOption + " is no longer recognized by Dagger");
+ }
+ }
+
+ private interface CommandLineOption {
+ /** The key of the option (appears after "-A"). */
+ @Override
+ String toString();
+
+ /**
+ * Returns all aliases besides {@link #toString()}, such as old names for an option, in order of
+ * precedence.
+ */
+ default ImmutableList<String> aliases() {
+ return ImmutableList.of();
+ }
+
+ /** All the command-line names for this option, in order of precedence. */
+ default Stream<String> allNames() {
+ return concat(Stream.of(toString()), aliases().stream());
+ }
+ }
+
+ /** An option that can be set on the command line. */
+ private interface EnumOption<E extends Enum<E>> extends CommandLineOption {
+ /** The default value for this option. */
+ E defaultValue();
+
+ /** The valid values for this option. */
+ Set<E> validValues();
+ }
+
+ enum KeyOnlyOption implements CommandLineOption {
+ HEADER_COMPILATION {
+ @Override
+ public String toString() {
+ return "experimental_turbine_hjar";
+ }
+ },
+
+ USE_GRADLE_INCREMENTAL_PROCESSING {
+ @Override
+ public String toString() {
+ return "dagger.gradle.incremental";
+ }
+ },
+ }
+
+ /**
+ * A feature that can be enabled or disabled on the command line by setting {@code -Akey=ENABLED}
+ * or {@code -Akey=DISABLED}.
+ */
+ enum Feature implements EnumOption<FeatureStatus> {
+ FAST_INIT,
+
+ EXPERIMENTAL_ANDROID_MODE,
+
+ FORMAT_GENERATED_SOURCE,
+
+ WRITE_PRODUCER_NAME_IN_TOKEN,
+
+ WARN_IF_INJECTION_FACTORY_NOT_GENERATED_UPSTREAM,
+
+ IGNORE_PRIVATE_AND_STATIC_INJECTION_FOR_COMPONENT,
+
+ EXPERIMENTAL_AHEAD_OF_TIME_SUBCOMPONENTS,
+
+ FORCE_USE_SERIALIZED_COMPONENT_IMPLEMENTATIONS,
+
+ EMIT_MODIFIABLE_METADATA_ANNOTATIONS(ENABLED),
+
+ PLUGINS_VISIT_FULL_BINDING_GRAPHS,
+
+ FLOATING_BINDS_METHODS,
+
+ EXPERIMENTAL_DAGGER_ERROR_MESSAGES,
+
+ STRICT_MULTIBINDING_VALIDATION,
+
+ VALIDATE_TRANSITIVE_COMPONENT_DEPENDENCIES(ENABLED)
+ ;
+
+ final FeatureStatus defaultValue;
+
+ Feature() {
+ this(DISABLED);
+ }
+
+ Feature(FeatureStatus defaultValue) {
+ this.defaultValue = defaultValue;
+ }
+
+ @Override
+ public FeatureStatus defaultValue() {
+ return defaultValue;
+ }
+
+ @Override
+ public Set<FeatureStatus> validValues() {
+ return EnumSet.allOf(FeatureStatus.class);
+ }
+
+ @Override
+ public String toString() {
+ return optionName(this);
+ }
+ }
+
+ /** The diagnostic kind or validation type for a kind of validation. */
+ enum Validation implements EnumOption<ValidationType> {
+ DISABLE_INTER_COMPONENT_SCOPE_VALIDATION(),
+
+ NULLABLE_VALIDATION(ERROR, WARNING),
+
+ PRIVATE_MEMBER_VALIDATION(ERROR, WARNING),
+
+ STATIC_MEMBER_VALIDATION(ERROR, WARNING),
+
+ /** Whether to validate full binding graphs for components, subcomponents, and modules. */
+ FULL_BINDING_GRAPH_VALIDATION(NONE, ERROR, WARNING) {
+ @Override
+ public ImmutableList<String> aliases() {
+ return ImmutableList.of("dagger.moduleBindingValidation");
+ }
+ },
+
+ /**
+ * How to report conflicting scoped bindings when validating partial binding graphs associated
+ * with modules.
+ */
+ MODULE_HAS_DIFFERENT_SCOPES_VALIDATION(ERROR, WARNING),
+
+ /**
+ * How to report that an explicit binding in a subcomponent conflicts with an {@code @Inject}
+ * constructor used in an ancestor component.
+ */
+ EXPLICIT_BINDING_CONFLICTS_WITH_INJECT(WARNING, ERROR, NONE),
+ ;
+
+ final ValidationType defaultType;
+ final ImmutableSet<ValidationType> validTypes;
+
+ Validation() {
+ this(ERROR, WARNING, NONE);
+ }
+
+ Validation(ValidationType defaultType, ValidationType... moreValidTypes) {
+ this.defaultType = defaultType;
+ this.validTypes = immutableEnumSet(defaultType, moreValidTypes);
+ }
+
+ @Override
+ public ValidationType defaultValue() {
+ return defaultType;
+ }
+
+ @Override
+ public Set<ValidationType> validValues() {
+ return validTypes;
+ }
+
+ @Override
+ public String toString() {
+ return optionName(this);
+ }
+ }
+
+ private static String optionName(Enum<? extends EnumOption<?>> option) {
+ return "dagger." + UPPER_UNDERSCORE.to(LOWER_CAMEL, option.name());
+ }
+
+ /** The supported command-line options. */
+ public static ImmutableSet<String> supportedOptions() {
+ // need explicit type parameter to avoid a runtime stream error
+ return ImmutableSet.<String>builder()
+ .addAll(
+ Stream.<CommandLineOption[]>of(
+ KeyOnlyOption.values(), Feature.values(), Validation.values())
+ .flatMap(Arrays::stream)
+ .flatMap(CommandLineOption::allNames)
+ .collect(toImmutableSet()))
+ .add(KEYS_PER_COMPONENT_SHARD)
+ .build();
+ }
+
+ /**
+ * Returns the value for the option as set on the command line by any name, or the default value
+ * if not set.
+ *
+ * <p>If more than one name is used to set the value, but all names specify the same value,
+ * reports a warning and returns that value.
+ *
+ * <p>If more than one name is used to set the value, and not all names specify the same value,
+ * reports an error and returns the default value.
+ */
+ private <T extends Enum<T>> T parseOption(EnumOption<T> option) {
+ @SuppressWarnings("unchecked") // we only put covariant values into the map
+ T value = (T) enumOptions.computeIfAbsent(option, this::parseOptionUncached);
+ return value;
+ }
+
+ private boolean isSetOnCommandLine(Feature feature) {
+ return getUsedNames(feature).count() > 0;
+ }
+
+ private <T extends Enum<T>> T parseOptionUncached(EnumOption<T> option) {
+ ImmutableMap<String, T> values = parseOptionWithAllNames(option);
+
+ // If no value is specified, return the default value.
+ if (values.isEmpty()) {
+ return option.defaultValue();
+ }
+
+ // If all names have the same value, return that.
+ if (values.asMultimap().inverse().keySet().size() == 1) {
+ // Warn if an option was set with more than one name. That would be an error if the values
+ // differed.
+ if (values.size() > 1) {
+ reportUseOfDifferentNamesForOption(Diagnostic.Kind.WARNING, option, values.keySet());
+ }
+ return values.values().asList().get(0);
+ }
+
+ // If different names have different values, report an error and return the default
+ // value.
+ reportUseOfDifferentNamesForOption(Diagnostic.Kind.ERROR, option, values.keySet());
+ return option.defaultValue();
+ }
+
+ private void reportUseOfDifferentNamesForOption(
+ Diagnostic.Kind diagnosticKind, EnumOption<?> option, ImmutableSet<String> usedNames) {
+ processingEnvironment
+ .getMessager()
+ .printMessage(
+ diagnosticKind,
+ String.format(
+ "Only one of the equivalent options (%s) should be used; prefer -A%s",
+ usedNames.stream().map(name -> "-A" + name).collect(joining(", ")), option));
+ }
+
+ private <T extends Enum<T>> ImmutableMap<String, T> parseOptionWithAllNames(
+ EnumOption<T> option) {
+ @SuppressWarnings("unchecked") // map is covariant
+ ImmutableMap<String, T> aliasValues =
+ (ImmutableMap<String, T>)
+ allCommandLineOptions.computeIfAbsent(option, this::parseOptionWithAllNamesUncached);
+ return aliasValues;
+ }
+
+ private <T extends Enum<T>> ImmutableMap<String, T> parseOptionWithAllNamesUncached(
+ EnumOption<T> option) {
+ ImmutableMap.Builder<String, T> values = ImmutableMap.builder();
+ getUsedNames(option)
+ .forEach(
+ name -> parseOptionWithName(option, name).ifPresent(value -> values.put(name, value)));
+ return values.build();
+ }
+
+ private <T extends Enum<T>> Optional<T> parseOptionWithName(EnumOption<T> option, String key) {
+ checkArgument(processingEnvironment.getOptions().containsKey(key), "key %s not found", key);
+ String stringValue = processingEnvironment.getOptions().get(key);
+ if (stringValue == null) {
+ processingEnvironment
+ .getMessager()
+ .printMessage(Diagnostic.Kind.ERROR, "Processor option -A" + key + " needs a value");
+ } else {
+ try {
+ T value =
+ Enum.valueOf(option.defaultValue().getDeclaringClass(), Ascii.toUpperCase(stringValue));
+ if (option.validValues().contains(value)) {
+ return Optional.of(value);
+ }
+ } catch (IllegalArgumentException e) {
+ // handled below
+ }
+ processingEnvironment
+ .getMessager()
+ .printMessage(
+ Diagnostic.Kind.ERROR,
+ String.format(
+ "Processor option -A%s may only have the values %s "
+ + "(case insensitive), found: %s",
+ key, option.validValues(), stringValue));
+ }
+ return Optional.empty();
+ }
+
+ private Stream<String> getUsedNames(CommandLineOption option) {
+ return option.allNames().filter(name -> processingEnvironment.getOptions().containsKey(name));
+ }
+}
diff --git a/java/dagger/internal/codegen/compileroption/ProcessingOptions.java b/java/dagger/internal/codegen/compileroption/ProcessingOptions.java
new file mode 100644
index 0000000..39c4728
--- /dev/null
+++ b/java/dagger/internal/codegen/compileroption/ProcessingOptions.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.compileroption;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Retention;
+import javax.inject.Qualifier;
+
+/**
+ * A qualifier for the {@link javax.annotation.processing.ProcessingEnvironment#getOptions()
+ * processing options} passed to the current invocation of {@code javac}.
+ */
+@Retention(RUNTIME)
+@Qualifier
+public @interface ProcessingOptions {}
diff --git a/java/dagger/internal/codegen/compileroption/ValidationType.java b/java/dagger/internal/codegen/compileroption/ValidationType.java
new file mode 100644
index 0000000..d7be4ca
--- /dev/null
+++ b/java/dagger/internal/codegen/compileroption/ValidationType.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.compileroption;
+
+import java.util.Optional;
+import javax.tools.Diagnostic;
+
+/**
+ * Allows options to control how component process validates things such as scope cycles or
+ * nullability.
+ */
+public enum ValidationType {
+ ERROR,
+ WARNING,
+ NONE;
+
+ public Optional<Diagnostic.Kind> diagnosticKind() {
+ switch (this) {
+ case ERROR:
+ return Optional.of(Diagnostic.Kind.ERROR);
+ case WARNING:
+ return Optional.of(Diagnostic.Kind.WARNING);
+ default:
+ return Optional.empty();
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/componentgenerator/BUILD b/java/dagger/internal/codegen/componentgenerator/BUILD
new file mode 100644
index 0000000..d898d4d
--- /dev/null
+++ b/java/dagger/internal/codegen/componentgenerator/BUILD
@@ -0,0 +1,43 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# A JSR-330 compliant dependency injection system for android and java
+
+package(default_visibility = ["//:src"])
+
+java_library(
+ name = "componentgenerator",
+ srcs = glob(["*.java"]),
+ plugins = ["//java/dagger/internal/codegen/bootstrap"],
+ deps = [
+ "//java/dagger:core",
+ "//java/dagger/internal/codegen/base",
+ "//java/dagger/internal/codegen/binding",
+ "//java/dagger/internal/codegen/compileroption",
+ "//java/dagger/internal/codegen/extension",
+ "//java/dagger/internal/codegen/javapoet",
+ "//java/dagger/internal/codegen/kotlin",
+ "//java/dagger/internal/codegen/langmodel",
+ "//java/dagger/internal/codegen/writing",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/producers",
+ "//java/dagger/spi",
+ "@google_bazel_common//third_party/java/auto:value",
+ "@google_bazel_common//third_party/java/javapoet",
+ "@google_bazel_common//third_party/java/jsr330_inject",
+ "@maven//:com_google_auto_auto_common",
+ ],
+)
diff --git a/java/dagger/internal/codegen/componentgenerator/ComponentCreatorImplementationFactory.java b/java/dagger/internal/codegen/componentgenerator/ComponentCreatorImplementationFactory.java
new file mode 100644
index 0000000..e1b35da
--- /dev/null
+++ b/java/dagger/internal/codegen/componentgenerator/ComponentCreatorImplementationFactory.java
@@ -0,0 +1,542 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.componentgenerator;
+
+import static com.google.auto.common.MoreTypes.asDeclared;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static com.squareup.javapoet.MethodSpec.constructorBuilder;
+import static com.squareup.javapoet.MethodSpec.methodBuilder;
+import static com.squareup.javapoet.TypeSpec.classBuilder;
+import static dagger.internal.codegen.binding.SourceFiles.simpleVariableName;
+import static dagger.internal.codegen.javapoet.CodeBlocks.toParametersCodeBlock;
+import static dagger.internal.codegen.javapoet.TypeSpecs.addSupertype;
+import static dagger.internal.codegen.langmodel.Accessibility.isElementAccessibleFrom;
+import static javax.lang.model.element.Modifier.FINAL;
+import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.PUBLIC;
+import static javax.lang.model.element.Modifier.STATIC;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterSpec;
+import com.squareup.javapoet.TypeName;
+import com.squareup.javapoet.TypeSpec;
+import dagger.internal.Preconditions;
+import dagger.internal.codegen.base.UniqueNameSet;
+import dagger.internal.codegen.binding.ComponentCreatorDescriptor;
+import dagger.internal.codegen.binding.ComponentDescriptor;
+import dagger.internal.codegen.binding.ComponentRequirement;
+import dagger.internal.codegen.binding.ComponentRequirement.NullPolicy;
+import dagger.internal.codegen.javapoet.TypeNames;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.internal.codegen.writing.ComponentCreatorImplementation;
+import dagger.internal.codegen.writing.ComponentImplementation;
+import dagger.internal.codegen.writing.ModuleProxies;
+import java.util.Optional;
+import java.util.Set;
+import javax.inject.Inject;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeKind;
+
+/** Factory for creating {@link ComponentCreatorImplementation} instances. */
+final class ComponentCreatorImplementationFactory {
+
+ private final ComponentImplementation componentImplementation;
+ private final DaggerElements elements;
+ private final DaggerTypes types;
+ private final KotlinMetadataUtil metadataUtil;
+ private final ModuleProxies moduleProxies;
+
+ @Inject
+ ComponentCreatorImplementationFactory(
+ ComponentImplementation componentImplementation,
+ DaggerElements elements,
+ DaggerTypes types,
+ KotlinMetadataUtil metadataUtil,
+ ModuleProxies moduleProxies) {
+ this.componentImplementation = componentImplementation;
+ this.elements = elements;
+ this.types = types;
+ this.metadataUtil = metadataUtil;
+ this.moduleProxies = moduleProxies;
+ }
+
+ /** Returns a new creator implementation for the given component, if necessary. */
+ Optional<ComponentCreatorImplementation> create() {
+ if (!componentImplementation.componentDescriptor().hasCreator()) {
+ return Optional.empty();
+ }
+
+ Optional<ComponentCreatorDescriptor> creatorDescriptor =
+ componentImplementation.componentDescriptor().creatorDescriptor();
+
+ Builder builder =
+ creatorDescriptor.isPresent()
+ ? new BuilderForCreatorDescriptor(componentImplementation, creatorDescriptor.get())
+ : new BuilderForGeneratedRootComponentBuilder(componentImplementation);
+ return Optional.of(builder.build());
+ }
+
+ /** Base class for building a creator implementation. */
+ private abstract class Builder {
+ final ComponentImplementation componentImplementation;
+ final ClassName className;
+ final TypeSpec.Builder classBuilder;
+
+ private ImmutableMap<ComponentRequirement, FieldSpec> fields;
+
+ Builder(ComponentImplementation componentImplementation) {
+ this.componentImplementation = componentImplementation;
+ this.className = componentImplementation.getCreatorName();
+ this.classBuilder = classBuilder(className);
+ }
+
+ /** Builds the {@link ComponentCreatorImplementation}. */
+ ComponentCreatorImplementation build() {
+ setModifiers();
+ setSupertype();
+ this.fields = addFields();
+ addConstructor();
+ addSetterMethods();
+ addFactoryMethod();
+ return ComponentCreatorImplementation.create(classBuilder.build(), className, fields);
+ }
+
+ /** Returns the descriptor for the component. */
+ final ComponentDescriptor componentDescriptor() {
+ return componentImplementation.componentDescriptor();
+ }
+
+ /**
+ * The set of requirements that must be passed to the component's constructor in the order
+ * they must be passed.
+ */
+ final ImmutableSet<ComponentRequirement> componentConstructorRequirements() {
+ return componentImplementation.graph().componentRequirements();
+ }
+
+ /** Returns the requirements that have setter methods on the creator type. */
+ abstract ImmutableSet<ComponentRequirement> setterMethods();
+
+ /**
+ * Returns the component requirements that have factory method parameters, mapped to the name
+ * for that parameter.
+ */
+ abstract ImmutableMap<ComponentRequirement, String> factoryMethodParameters();
+
+ /**
+ * The {@link ComponentRequirement}s that this creator allows users to set. Values are a status
+ * for each requirement indicating what's needed for that requirement in the implementation
+ * class currently being generated.
+ */
+ abstract ImmutableMap<ComponentRequirement, RequirementStatus> userSettableRequirements();
+
+ /**
+ * Component requirements that are both settable by the creator and needed to construct the
+ * component.
+ */
+ private Set<ComponentRequirement> neededUserSettableRequirements() {
+ return Sets.intersection(
+ userSettableRequirements().keySet(), componentConstructorRequirements());
+ }
+
+ private void setModifiers() {
+ visibility().ifPresent(classBuilder::addModifiers);
+ if (!componentImplementation.isNested()) {
+ classBuilder.addModifiers(STATIC);
+ }
+ classBuilder.addModifiers(FINAL);
+ }
+
+ /** Returns the visibility modifier the generated class should have, if any. */
+ protected abstract Optional<Modifier> visibility();
+
+ /** Sets the superclass being extended or interface being implemented for this creator. */
+ protected abstract void setSupertype();
+
+ /** Adds a constructor for the creator type, if needed. */
+ protected abstract void addConstructor();
+
+ private ImmutableMap<ComponentRequirement, FieldSpec> addFields() {
+ // Fields in an abstract creator class need to be visible from subclasses.
+ UniqueNameSet fieldNames = new UniqueNameSet();
+ ImmutableMap<ComponentRequirement, FieldSpec> result =
+ Maps.toMap(
+ Sets.intersection(neededUserSettableRequirements(), setterMethods()),
+ requirement ->
+ FieldSpec.builder(
+ TypeName.get(requirement.type()),
+ fieldNames.getUniqueName(requirement.variableName()),
+ PRIVATE)
+ .build());
+ classBuilder.addFields(result.values());
+ return result;
+ }
+
+ private void addSetterMethods() {
+ Maps.filterKeys(userSettableRequirements(), setterMethods()::contains)
+ .forEach(
+ (requirement, status) ->
+ createSetterMethod(requirement, status).ifPresent(classBuilder::addMethod));
+ }
+
+ /** Creates a new setter method builder, with no method body, for the given requirement. */
+ protected abstract MethodSpec.Builder setterMethodBuilder(ComponentRequirement requirement);
+
+ private Optional<MethodSpec> createSetterMethod(
+ ComponentRequirement requirement, RequirementStatus status) {
+ switch (status) {
+ case NEEDED:
+ return Optional.of(normalSetterMethod(requirement));
+ case UNNEEDED:
+ // TODO(bcorso): Don't generate noop setters for any unneeded requirements.
+ // However, since this is a breaking change we can at least avoid trying
+ // to generate noop setters for impossible cases like when the requirement type
+ // is in another package. This avoids unnecessary breakages in Dagger's generated
+ // due to the noop setters.
+ if (isElementAccessibleFrom(requirement.typeElement(), className.packageName())) {
+ return Optional.of(noopSetterMethod(requirement));
+ } else {
+ return Optional.empty();
+ }
+ case UNSETTABLE_REPEATED_MODULE:
+ return Optional.of(repeatedModuleSetterMethod(requirement));
+ }
+ throw new AssertionError();
+ }
+
+ private MethodSpec normalSetterMethod(ComponentRequirement requirement) {
+ MethodSpec.Builder method = setterMethodBuilder(requirement);
+ ParameterSpec parameter = parameter(method.build());
+ method.addStatement(
+ "this.$N = $L",
+ fields.get(requirement),
+ requirement.nullPolicy(elements, types, metadataUtil).equals(NullPolicy.ALLOW)
+ ? CodeBlock.of("$N", parameter)
+ : CodeBlock.of("$T.checkNotNull($N)", Preconditions.class, parameter));
+ return maybeReturnThis(method);
+ }
+
+ private MethodSpec noopSetterMethod(ComponentRequirement requirement) {
+ MethodSpec.Builder method = setterMethodBuilder(requirement);
+ ParameterSpec parameter = parameter(method.build());
+ method
+ .addAnnotation(Deprecated.class)
+ .addJavadoc(
+ "@deprecated This module is declared, but an instance is not used in the component. "
+ + "This method is a no-op. For more, see https://dagger.dev/unused-modules.\n")
+ .addStatement("$T.checkNotNull($N)", Preconditions.class, parameter);
+ return maybeReturnThis(method);
+ }
+
+ private MethodSpec repeatedModuleSetterMethod(ComponentRequirement requirement) {
+ return setterMethodBuilder(requirement)
+ .addStatement(
+ "throw new $T($T.format($S, $T.class.getCanonicalName()))",
+ UnsupportedOperationException.class,
+ String.class,
+ "%s cannot be set because it is inherited from the enclosing component",
+ TypeNames.rawTypeName(TypeName.get(requirement.type())))
+ .build();
+ }
+
+ private ParameterSpec parameter(MethodSpec method) {
+ return getOnlyElement(method.parameters);
+ }
+
+ private MethodSpec maybeReturnThis(MethodSpec.Builder method) {
+ MethodSpec built = method.build();
+ return built.returnType.equals(TypeName.VOID)
+ ? built
+ : method.addStatement("return this").build();
+ }
+
+ private void addFactoryMethod() {
+ classBuilder.addMethod(factoryMethod());
+ }
+
+ MethodSpec factoryMethod() {
+ MethodSpec.Builder factoryMethod = factoryMethodBuilder();
+ factoryMethod
+ .returns(ClassName.get(componentDescriptor().typeElement()))
+ .addModifiers(PUBLIC);
+
+ ImmutableMap<ComponentRequirement, String> factoryMethodParameters =
+ factoryMethodParameters();
+ userSettableRequirements()
+ .keySet()
+ .forEach(
+ requirement -> {
+ if (fields.containsKey(requirement)) {
+ FieldSpec field = fields.get(requirement);
+ addNullHandlingForField(requirement, field, factoryMethod);
+ } else if (factoryMethodParameters.containsKey(requirement)) {
+ String parameterName = factoryMethodParameters.get(requirement);
+ addNullHandlingForParameter(requirement, parameterName, factoryMethod);
+ }
+ });
+ factoryMethod.addStatement(
+ "return new $T($L)",
+ componentImplementation.name(),
+ componentConstructorArgs(factoryMethodParameters));
+ return factoryMethod.build();
+ }
+
+ private void addNullHandlingForField(
+ ComponentRequirement requirement, FieldSpec field, MethodSpec.Builder factoryMethod) {
+ switch (requirement.nullPolicy(elements, types, metadataUtil)) {
+ case NEW:
+ checkState(requirement.kind().isModule());
+ factoryMethod
+ .beginControlFlow("if ($N == null)", field)
+ .addStatement("this.$N = $L", field, newModuleInstance(requirement))
+ .endControlFlow();
+ break;
+ case THROW:
+ // TODO(cgdecker,ronshapiro): ideally this should use the key instead of a class for
+ // @BindsInstance requirements, but that's not easily proguardable.
+ factoryMethod.addStatement(
+ "$T.checkBuilderRequirement($N, $T.class)",
+ Preconditions.class,
+ field,
+ TypeNames.rawTypeName(field.type));
+ break;
+ case ALLOW:
+ break;
+ }
+ }
+
+ private void addNullHandlingForParameter(
+ ComponentRequirement requirement, String parameter, MethodSpec.Builder factoryMethod) {
+ if (!requirement.nullPolicy(elements, types, metadataUtil).equals(NullPolicy.ALLOW)) {
+ // Factory method parameters are always required unless they are a nullable
+ // binds-instance (i.e. ALLOW)
+ factoryMethod.addStatement("$T.checkNotNull($L)", Preconditions.class, parameter);
+ }
+ }
+
+ /** Returns a builder for the creator's factory method. */
+ protected abstract MethodSpec.Builder factoryMethodBuilder();
+
+ private CodeBlock componentConstructorArgs(
+ ImmutableMap<ComponentRequirement, String> factoryMethodParameters) {
+ return componentConstructorRequirements().stream()
+ .map(
+ requirement -> {
+ if (fields.containsKey(requirement)) {
+ return CodeBlock.of("$N", fields.get(requirement));
+ } else if (factoryMethodParameters.containsKey(requirement)) {
+ return CodeBlock.of("$L", factoryMethodParameters.get(requirement));
+ } else {
+ return newModuleInstance(requirement);
+ }
+ })
+ .collect(toParametersCodeBlock());
+ }
+
+ private CodeBlock newModuleInstance(ComponentRequirement requirement) {
+ checkArgument(requirement.kind().isModule()); // this should be guaranteed to be true here
+ return moduleProxies.newModuleInstance(requirement.typeElement(), className);
+ }
+ }
+
+ /** Builder for a creator type defined by a {@code ComponentCreatorDescriptor}. */
+ private final class BuilderForCreatorDescriptor extends Builder {
+ final ComponentCreatorDescriptor creatorDescriptor;
+
+ BuilderForCreatorDescriptor(
+ ComponentImplementation componentImplementation,
+ ComponentCreatorDescriptor creatorDescriptor) {
+ super(componentImplementation);
+ this.creatorDescriptor = creatorDescriptor;
+ }
+
+ @Override
+ protected ImmutableMap<ComponentRequirement, RequirementStatus> userSettableRequirements() {
+ return Maps.toMap(creatorDescriptor.userSettableRequirements(), this::requirementStatus);
+ }
+
+ @Override
+ protected Optional<Modifier> visibility() {
+ return Optional.of(PRIVATE);
+ }
+
+ @Override
+ protected void setSupertype() {
+ addSupertype(classBuilder, creatorDescriptor.typeElement());
+ }
+
+ @Override
+ protected void addConstructor() {
+ // Just use the implicit no-arg public constructor.
+ }
+
+ @Override
+ protected ImmutableSet<ComponentRequirement> setterMethods() {
+ return ImmutableSet.copyOf(creatorDescriptor.setterMethods().keySet());
+ }
+
+ @Override
+ protected ImmutableMap<ComponentRequirement, String> factoryMethodParameters() {
+ return ImmutableMap.copyOf(
+ Maps.transformValues(
+ creatorDescriptor.factoryParameters(),
+ element -> element.getSimpleName().toString()));
+ }
+
+ private DeclaredType creatorType() {
+ return asDeclared(creatorDescriptor.typeElement().asType());
+ }
+
+ @Override
+ protected MethodSpec.Builder factoryMethodBuilder() {
+ return MethodSpec.overriding(creatorDescriptor.factoryMethod(), creatorType(), types);
+ }
+
+ private RequirementStatus requirementStatus(ComponentRequirement requirement) {
+ if (isRepeatedModule(requirement)) {
+ return RequirementStatus.UNSETTABLE_REPEATED_MODULE;
+ }
+
+ return componentConstructorRequirements().contains(requirement)
+ ? RequirementStatus.NEEDED
+ : RequirementStatus.UNNEEDED;
+ }
+
+ /**
+ * Returns whether the given requirement is for a repeat of a module inherited from an ancestor
+ * component. This creator is not allowed to set such a module.
+ */
+ final boolean isRepeatedModule(ComponentRequirement requirement) {
+ return !componentConstructorRequirements().contains(requirement)
+ && !isOwnedModule(requirement);
+ }
+
+ /**
+ * Returns whether the given {@code requirement} is for a module type owned by the component.
+ */
+ private boolean isOwnedModule(ComponentRequirement requirement) {
+ return componentImplementation.graph().ownedModuleTypes().contains(requirement.typeElement());
+ }
+
+ @Override
+ protected MethodSpec.Builder setterMethodBuilder(ComponentRequirement requirement) {
+ ExecutableElement supertypeMethod = creatorDescriptor.setterMethods().get(requirement);
+ MethodSpec.Builder method = MethodSpec.overriding(supertypeMethod, creatorType(), types);
+ if (!supertypeMethod.getReturnType().getKind().equals(TypeKind.VOID)) {
+ // Take advantage of covariant returns so that we don't have to worry about type variables
+ method.returns(className);
+ }
+ return method;
+ }
+ }
+
+ /**
+ * Builder for a component builder class that is automatically generated for a root component that
+ * does not have its own user-defined creator type (i.e. a {@code ComponentCreatorDescriptor}).
+ */
+ private final class BuilderForGeneratedRootComponentBuilder extends Builder {
+ BuilderForGeneratedRootComponentBuilder(ComponentImplementation componentImplementation) {
+ super(componentImplementation);
+ }
+
+ @Override
+ protected ImmutableMap<ComponentRequirement, RequirementStatus> userSettableRequirements() {
+ return Maps.toMap(
+ setterMethods(),
+ requirement ->
+ componentConstructorRequirements().contains(requirement)
+ ? RequirementStatus.NEEDED
+ : RequirementStatus.UNNEEDED);
+ }
+
+ @Override
+ protected Optional<Modifier> visibility() {
+ return componentImplementation
+ .componentDescriptor()
+ .typeElement()
+ .getModifiers()
+ .contains(PUBLIC) ? Optional.of(PUBLIC) : Optional.empty();
+ }
+
+ @Override
+ protected void setSupertype() {
+ // There's never a supertype for a root component auto-generated builder type.
+ }
+
+ @Override
+ protected void addConstructor() {
+ classBuilder.addMethod(constructorBuilder().addModifiers(PRIVATE).build());
+ }
+
+ @Override
+ protected ImmutableSet<ComponentRequirement> setterMethods() {
+ return componentDescriptor().dependenciesAndConcreteModules();
+ }
+
+ @Override
+ protected ImmutableMap<ComponentRequirement, String> factoryMethodParameters() {
+ return ImmutableMap.of();
+ }
+
+ @Override
+ protected MethodSpec.Builder factoryMethodBuilder() {
+ return methodBuilder("build");
+ }
+
+ @Override
+ protected MethodSpec.Builder setterMethodBuilder(ComponentRequirement requirement) {
+ String name = simpleVariableName(requirement.typeElement());
+ return methodBuilder(name)
+ .addModifiers(PUBLIC)
+ .addParameter(TypeName.get(requirement.type()), name)
+ .returns(className);
+ }
+ }
+
+ /** Enumeration of statuses a component requirement may have in a creator. */
+ enum RequirementStatus {
+ /** An instance is needed to create the component. */
+ NEEDED,
+
+ /**
+ * An instance is not needed to create the component, but the requirement is for a module owned
+ * by the component. Setting the requirement is a no-op and any setter method should be marked
+ * deprecated on the generated type as a warning to the user.
+ */
+ UNNEEDED,
+
+ /**
+ * The requirement may not be set in this creator because the module it is for is already
+ * inherited from an ancestor component. Any setter method for it should throw an exception.
+ */
+ UNSETTABLE_REPEATED_MODULE,
+ ;
+ }
+}
diff --git a/java/dagger/internal/codegen/componentgenerator/ComponentGenerator.java b/java/dagger/internal/codegen/componentgenerator/ComponentGenerator.java
new file mode 100644
index 0000000..e04ee14
--- /dev/null
+++ b/java/dagger/internal/codegen/componentgenerator/ComponentGenerator.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.componentgenerator;
+
+import static com.google.common.base.Verify.verify;
+import static dagger.internal.codegen.binding.SourceFiles.classFileName;
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.TypeSpec;
+import dagger.Component;
+import dagger.internal.codegen.base.SourceFileGenerator;
+import dagger.internal.codegen.binding.BindingGraph;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.writing.ComponentImplementation;
+import java.util.Optional;
+import javax.annotation.processing.Filer;
+import javax.inject.Inject;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+
+/** Generates the implementation of the abstract types annotated with {@link Component}. */
+final class ComponentGenerator extends SourceFileGenerator<BindingGraph> {
+ private final ComponentImplementationFactory componentImplementationFactory;
+
+ @Inject
+ ComponentGenerator(
+ Filer filer,
+ DaggerElements elements,
+ SourceVersion sourceVersion,
+ ComponentImplementationFactory componentImplementationFactory) {
+ super(filer, elements, sourceVersion);
+ this.componentImplementationFactory = componentImplementationFactory;
+ }
+
+ @Override
+ public ClassName nameGeneratedType(BindingGraph input) {
+ return componentName(input.componentTypeElement());
+ }
+
+ static ClassName componentName(TypeElement componentDefinitionType) {
+ ClassName componentName = ClassName.get(componentDefinitionType);
+ return ClassName.get(componentName.packageName(), "Dagger" + classFileName(componentName));
+ }
+
+ @Override
+ public Element originatingElement(BindingGraph input) {
+ return input.componentTypeElement();
+ }
+
+ @Override
+ public Optional<TypeSpec.Builder> write(BindingGraph bindingGraph) {
+ ComponentImplementation componentImplementation =
+ componentImplementationFactory.createComponentImplementation(bindingGraph);
+ verify(componentImplementation.name().equals(nameGeneratedType(bindingGraph)));
+ return Optional.of(componentImplementation.generate());
+ }
+}
diff --git a/java/dagger/internal/codegen/componentgenerator/ComponentGeneratorModule.java b/java/dagger/internal/codegen/componentgenerator/ComponentGeneratorModule.java
new file mode 100644
index 0000000..84179d6
--- /dev/null
+++ b/java/dagger/internal/codegen/componentgenerator/ComponentGeneratorModule.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.componentgenerator;
+
+import dagger.Binds;
+import dagger.Module;
+import dagger.internal.codegen.base.ClearableCache;
+import dagger.internal.codegen.base.SourceFileGenerator;
+import dagger.internal.codegen.binding.BindingGraph;
+import dagger.internal.codegen.binding.ComponentDescriptor;
+import dagger.multibindings.IntoSet;
+
+/** Provides bindings needed to generated the component. */
+@Module(subcomponents = TopLevelImplementationComponent.class)
+public interface ComponentGeneratorModule {
+
+ @Binds
+ abstract SourceFileGenerator<BindingGraph> componentGenerator(ComponentGenerator generator);
+
+ // The HjarSourceFileGenerator wrapper first generates the entire TypeSpec before stripping out
+ // things that aren't needed for the hjar. However, this can be really expensive for the component
+ // because it is usually the most expensive file to generate, and most of its content is not
+ // needed in the hjar. Thus, instead of wrapping the ComponentGenerator in HjarSourceFileGenerator
+ // we provide a completely separate processing step, ComponentHjarProcessingStep, and generator,
+ // ComponentHjarGenerator, for when generating hjars for components, which can avoid generating
+ // the parts of the component that would have been stripped out by the HjarSourceFileGenerator.
+ @Binds
+ abstract SourceFileGenerator<ComponentDescriptor> componentHjarGenerator(
+ ComponentHjarGenerator hjarGenerator);
+
+ @Binds
+ @IntoSet
+ ClearableCache componentImplementationFactory(ComponentImplementationFactory cache);
+}
diff --git a/java/dagger/internal/codegen/componentgenerator/ComponentHjarGenerator.java b/java/dagger/internal/codegen/componentgenerator/ComponentHjarGenerator.java
new file mode 100644
index 0000000..b386a4f
--- /dev/null
+++ b/java/dagger/internal/codegen/componentgenerator/ComponentHjarGenerator.java
@@ -0,0 +1,269 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.componentgenerator;
+
+import static com.google.auto.common.MoreElements.isAnnotationPresent;
+import static com.google.common.base.CaseFormat.LOWER_CAMEL;
+import static com.google.common.base.CaseFormat.UPPER_CAMEL;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.squareup.javapoet.MethodSpec.constructorBuilder;
+import static dagger.internal.codegen.binding.ComponentCreatorKind.BUILDER;
+import static dagger.internal.codegen.componentgenerator.ComponentGenerator.componentName;
+import static dagger.internal.codegen.javapoet.TypeSpecs.addSupertype;
+import static dagger.internal.codegen.langmodel.Accessibility.isElementAccessibleFrom;
+import static javax.lang.model.element.Modifier.ABSTRACT;
+import static javax.lang.model.element.Modifier.FINAL;
+import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.PUBLIC;
+import static javax.lang.model.element.Modifier.STATIC;
+
+import com.google.auto.common.MoreTypes;
+import com.google.common.base.Ascii;
+import com.google.common.collect.Sets;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.TypeName;
+import com.squareup.javapoet.TypeSpec;
+import dagger.BindsInstance;
+import dagger.internal.codegen.base.SourceFileGenerator;
+import dagger.internal.codegen.binding.ComponentCreatorDescriptor;
+import dagger.internal.codegen.binding.ComponentCreatorKind;
+import dagger.internal.codegen.binding.ComponentDescriptor;
+import dagger.internal.codegen.binding.ComponentRequirement;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.producers.internal.CancellationListener;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Stream;
+import javax.annotation.processing.Filer;
+import javax.inject.Inject;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.DeclaredType;
+
+/**
+ * A component generator that emits only API, without any actual implementation.
+ *
+ * <p>When compiling a header jar (hjar), Bazel needs to run annotation processors that generate
+ * API, like Dagger, to see what code they might output. Full binding graph analysis is costly and
+ * unnecessary from the perspective of the header compiler; it's sole goal is to pass along a
+ * slimmed down version of what will be the jar for a particular compilation, whether or not that
+ * compilation succeeds. If it does not, the compilation pipeline will fail, even if header
+ * compilation succeeded.
+ *
+ * <p>The components emitted by this processing step include all of the API elements exposed by the
+ * normal step. Method bodies are omitted as Turbine ignores them entirely.
+ */
+final class ComponentHjarGenerator extends SourceFileGenerator<ComponentDescriptor> {
+ private final DaggerElements elements;
+ private final DaggerTypes types;
+ private final KotlinMetadataUtil metadataUtil;
+
+ @Inject
+ ComponentHjarGenerator(
+ Filer filer,
+ DaggerElements elements,
+ DaggerTypes types,
+ SourceVersion sourceVersion,
+ KotlinMetadataUtil metadataUtil) {
+ super(filer, elements, sourceVersion);
+ this.elements = elements;
+ this.types = types;
+ this.metadataUtil = metadataUtil;
+ }
+
+ @Override
+ public ClassName nameGeneratedType(ComponentDescriptor input) {
+ return componentName(input.typeElement());
+ }
+
+ @Override
+ public Element originatingElement(ComponentDescriptor input) {
+ return input.typeElement();
+ }
+
+ @Override
+ public Optional<TypeSpec.Builder> write(ComponentDescriptor componentDescriptor) {
+ ClassName generatedTypeName = nameGeneratedType(componentDescriptor);
+ TypeSpec.Builder generatedComponent =
+ TypeSpec.classBuilder(generatedTypeName)
+ .addModifiers(FINAL)
+ .addMethod(privateConstructor());
+ if (componentDescriptor.typeElement().getModifiers().contains(PUBLIC)) {
+ generatedComponent.addModifiers(PUBLIC);
+ }
+
+ TypeElement componentElement = componentDescriptor.typeElement();
+ addSupertype(generatedComponent, componentElement);
+
+ TypeName builderMethodReturnType;
+ ComponentCreatorKind creatorKind;
+ boolean noArgFactoryMethod;
+ if (componentDescriptor.creatorDescriptor().isPresent()) {
+ ComponentCreatorDescriptor creatorDescriptor = componentDescriptor.creatorDescriptor().get();
+ builderMethodReturnType = ClassName.get(creatorDescriptor.typeElement());
+ creatorKind = creatorDescriptor.kind();
+ noArgFactoryMethod = creatorDescriptor.factoryParameters().isEmpty();
+ } else {
+ TypeSpec.Builder builder =
+ TypeSpec.classBuilder("Builder")
+ .addModifiers(STATIC, FINAL)
+ .addMethod(privateConstructor());
+ if (componentDescriptor.typeElement().getModifiers().contains(PUBLIC)) {
+ builder.addModifiers(PUBLIC);
+ }
+
+ ClassName builderClassName = generatedTypeName.nestedClass("Builder");
+ builderMethodReturnType = builderClassName;
+ creatorKind = BUILDER;
+ noArgFactoryMethod = true;
+ componentRequirements(componentDescriptor)
+ .map(requirement -> builderSetterMethod(requirement.typeElement(), builderClassName))
+ .forEach(builder::addMethod);
+ builder.addMethod(builderBuildMethod(componentDescriptor));
+ generatedComponent.addType(builder.build());
+ }
+
+ generatedComponent.addMethod(staticCreatorMethod(builderMethodReturnType, creatorKind));
+
+ if (noArgFactoryMethod
+ && !hasBindsInstanceMethods(componentDescriptor)
+ && componentRequirements(componentDescriptor)
+ .noneMatch(
+ requirement ->
+ requirement.requiresAPassedInstance(elements, types, metadataUtil))) {
+ generatedComponent.addMethod(createMethod(componentDescriptor));
+ }
+
+ DeclaredType componentType = MoreTypes.asDeclared(componentElement.asType());
+ // TODO(ronshapiro): unify with ComponentImplementationBuilder
+ Set<MethodSignature> methodSignatures =
+ Sets.newHashSetWithExpectedSize(componentDescriptor.componentMethods().size());
+ componentDescriptor.componentMethods().stream()
+ .filter(
+ method -> {
+ return methodSignatures.add(
+ MethodSignature.forComponentMethod(method, componentType, types));
+ })
+ .forEach(
+ method ->
+ generatedComponent.addMethod(
+ emptyComponentMethod(componentElement, method.methodElement())));
+
+ if (componentDescriptor.isProduction()) {
+ generatedComponent
+ .addSuperinterface(ClassName.get(CancellationListener.class))
+ .addMethod(onProducerFutureCancelledMethod());
+ }
+
+ return Optional.of(generatedComponent);
+ }
+
+ private MethodSpec emptyComponentMethod(TypeElement typeElement, ExecutableElement baseMethod) {
+ return MethodSpec.overriding(baseMethod, MoreTypes.asDeclared(typeElement.asType()), types)
+ .build();
+ }
+
+ private static MethodSpec privateConstructor() {
+ return constructorBuilder().addModifiers(PRIVATE).build();
+ }
+
+ /**
+ * Returns the {@link ComponentRequirement}s for a component that does not have a {@link
+ * ComponentDescriptor#creatorDescriptor()}.
+ */
+ private static Stream<ComponentRequirement> componentRequirements(ComponentDescriptor component) {
+ // TODO(b/152802759): See if you can merge logics that normal component processing and hjar
+ // component processing use. So that there would't be a duplicated logic (like the lines below)
+ // everytime we modify the generated code for the component.
+ checkArgument(!component.isSubcomponent());
+ return Stream.concat(
+ component.dependencies().stream(),
+ component.modules().stream()
+ .filter(
+ module ->
+ !module.moduleElement().getModifiers().contains(ABSTRACT)
+ && isElementAccessibleFrom(
+ module.moduleElement(),
+ ClassName.get(component.typeElement()).packageName()))
+ .map(module -> ComponentRequirement.forModule(module.moduleElement().asType())));
+ }
+
+ private boolean hasBindsInstanceMethods(ComponentDescriptor componentDescriptor) {
+ return componentDescriptor.creatorDescriptor().isPresent()
+ && elements
+ .getUnimplementedMethods(componentDescriptor.creatorDescriptor().get().typeElement())
+ .stream()
+ .anyMatch(method -> isBindsInstance(method));
+ }
+
+ private static boolean isBindsInstance(ExecutableElement method) {
+ if (isAnnotationPresent(method, BindsInstance.class)) {
+ return true;
+ }
+
+ if (method.getParameters().size() == 1) {
+ return isAnnotationPresent(method.getParameters().get(0), BindsInstance.class);
+ }
+
+ return false;
+ }
+
+ private static MethodSpec builderSetterMethod(
+ TypeElement componentRequirement, ClassName builderClass) {
+ String simpleName =
+ UPPER_CAMEL.to(LOWER_CAMEL, componentRequirement.getSimpleName().toString());
+ return MethodSpec.methodBuilder(simpleName)
+ .addModifiers(PUBLIC)
+ .addParameter(ClassName.get(componentRequirement), simpleName)
+ .returns(builderClass)
+ .build();
+ }
+
+ private static MethodSpec builderBuildMethod(ComponentDescriptor component) {
+ return MethodSpec.methodBuilder("build")
+ .addModifiers(PUBLIC)
+ .returns(ClassName.get(component.typeElement()))
+ .build();
+ }
+
+ private static MethodSpec staticCreatorMethod(
+ TypeName creatorMethodReturnType, ComponentCreatorKind creatorKind) {
+ return MethodSpec.methodBuilder(Ascii.toLowerCase(creatorKind.typeName()))
+ .addModifiers(PUBLIC, STATIC)
+ .returns(creatorMethodReturnType)
+ .build();
+ }
+
+ private static MethodSpec createMethod(ComponentDescriptor componentDescriptor) {
+ return MethodSpec.methodBuilder("create")
+ .addModifiers(PUBLIC, STATIC)
+ .returns(ClassName.get(componentDescriptor.typeElement()))
+ .build();
+ }
+
+ private static MethodSpec onProducerFutureCancelledMethod() {
+ return MethodSpec.methodBuilder("onProducerFutureCancelled")
+ .addModifiers(PUBLIC)
+ .addParameter(TypeName.BOOLEAN, "mayInterruptIfRunning")
+ .build();
+ }
+}
diff --git a/java/dagger/internal/codegen/componentgenerator/ComponentImplementationBuilder.java b/java/dagger/internal/codegen/componentgenerator/ComponentImplementationBuilder.java
new file mode 100644
index 0000000..04cb80f
--- /dev/null
+++ b/java/dagger/internal/codegen/componentgenerator/ComponentImplementationBuilder.java
@@ -0,0 +1,524 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.componentgenerator;
+
+import static com.google.auto.common.MoreElements.getLocalAndInheritedMethods;
+import static com.google.auto.common.MoreTypes.asDeclared;
+import static com.google.common.base.Preconditions.checkState;
+import static com.squareup.javapoet.MethodSpec.constructorBuilder;
+import static com.squareup.javapoet.MethodSpec.methodBuilder;
+import static dagger.internal.codegen.binding.BindingRequest.bindingRequest;
+import static dagger.internal.codegen.binding.ComponentCreatorKind.BUILDER;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
+import static dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression.UNCHECKED;
+import static dagger.internal.codegen.javapoet.CodeBlocks.parameterNames;
+import static dagger.internal.codegen.writing.ComponentImplementation.MethodSpecKind.BUILDER_METHOD;
+import static dagger.internal.codegen.writing.ComponentImplementation.MethodSpecKind.CANCELLATION_LISTENER_METHOD;
+import static dagger.internal.codegen.writing.ComponentImplementation.MethodSpecKind.COMPONENT_METHOD;
+import static dagger.internal.codegen.writing.ComponentImplementation.MethodSpecKind.CONSTRUCTOR;
+import static dagger.internal.codegen.writing.ComponentImplementation.MethodSpecKind.INITIALIZE_METHOD;
+import static dagger.internal.codegen.writing.ComponentImplementation.TypeSpecKind.COMPONENT_CREATOR;
+import static dagger.internal.codegen.writing.ComponentImplementation.TypeSpecKind.SUBCOMPONENT;
+import static dagger.producers.CancellationPolicy.Propagation.PROPAGATE;
+import static javax.lang.model.element.Modifier.FINAL;
+import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.PUBLIC;
+import static javax.lang.model.element.Modifier.STATIC;
+
+import com.google.auto.common.MoreTypes;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableListMultimap;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multimaps;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterSpec;
+import com.squareup.javapoet.TypeSpec;
+import dagger.internal.Preconditions;
+import dagger.internal.codegen.binding.BindingGraph;
+import dagger.internal.codegen.binding.ComponentCreatorDescriptor;
+import dagger.internal.codegen.binding.ComponentCreatorKind;
+import dagger.internal.codegen.binding.ComponentDescriptor.ComponentMethodDescriptor;
+import dagger.internal.codegen.binding.ComponentRequirement;
+import dagger.internal.codegen.binding.FrameworkType;
+import dagger.internal.codegen.javapoet.AnnotationSpecs;
+import dagger.internal.codegen.javapoet.CodeBlocks;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.internal.codegen.writing.ComponentBindingExpressions;
+import dagger.internal.codegen.writing.ComponentCreatorImplementation;
+import dagger.internal.codegen.writing.ComponentImplementation;
+import dagger.internal.codegen.writing.ComponentRequirementExpressions;
+import dagger.internal.codegen.writing.ParentComponent;
+import dagger.model.Key;
+import dagger.producers.internal.CancellationListener;
+import dagger.producers.internal.Producers;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+import javax.inject.Inject;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.type.DeclaredType;
+
+/** A builder of {@link ComponentImplementation}s. */
+// This only needs to be public because it's referenced in an entry point.
+public final class ComponentImplementationBuilder {
+ private static final String MAY_INTERRUPT_IF_RUNNING = "mayInterruptIfRunning";
+
+ /**
+ * How many statements per {@code initialize()} or {@code onProducerFutureCancelled()} method
+ * before they get partitioned.
+ */
+ private static final int STATEMENTS_PER_METHOD = 100;
+
+ private static final String CANCELLATION_LISTENER_METHOD_NAME = "onProducerFutureCancelled";
+
+ private final Optional<ComponentImplementationBuilder> parent;
+ private final BindingGraph graph;
+ private final ComponentBindingExpressions bindingExpressions;
+ private final ComponentRequirementExpressions componentRequirementExpressions;
+ private final ComponentImplementation componentImplementation;
+ private final ComponentCreatorImplementationFactory componentCreatorImplementationFactory;
+ private final TopLevelImplementationComponent topLevelImplementationComponent;
+ private final DaggerTypes types;
+ private final DaggerElements elements;
+ private final KotlinMetadataUtil metadataUtil;
+ private boolean done;
+
+ @Inject
+ ComponentImplementationBuilder(
+ @ParentComponent Optional<ComponentImplementationBuilder> parent,
+ BindingGraph graph,
+ ComponentBindingExpressions bindingExpressions,
+ ComponentRequirementExpressions componentRequirementExpressions,
+ ComponentImplementation componentImplementation,
+ ComponentCreatorImplementationFactory componentCreatorImplementationFactory,
+ TopLevelImplementationComponent topLevelImplementationComponent,
+ DaggerTypes types,
+ DaggerElements elements,
+ KotlinMetadataUtil metadataUtil) {
+ this.parent = parent;
+ this.graph = graph;
+ this.bindingExpressions = bindingExpressions;
+ this.componentRequirementExpressions = componentRequirementExpressions;
+ this.componentImplementation = componentImplementation;
+ this.componentCreatorImplementationFactory = componentCreatorImplementationFactory;
+ this.types = types;
+ this.elements = elements;
+ this.topLevelImplementationComponent = topLevelImplementationComponent;
+ this.metadataUtil = metadataUtil;
+ }
+
+ /**
+ * Returns a {@link ComponentImplementation} for this component. This is only intended to be
+ * called once (and will throw on successive invocations). If the component must be regenerated,
+ * use a new instance.
+ */
+ ComponentImplementation build() {
+ checkState(
+ !done,
+ "ComponentImplementationBuilder has already built the ComponentImplementation for [%s].",
+ componentImplementation.name());
+ setSupertype();
+
+ componentCreatorImplementationFactory.create()
+ .map(ComponentCreatorImplementation::spec)
+ .ifPresent(this::addCreatorClass);
+
+ getLocalAndInheritedMethods(graph.componentTypeElement(), types, elements)
+ .forEach(method -> componentImplementation.claimMethodName(method.getSimpleName()));
+
+ addFactoryMethods();
+ addInterfaceMethods();
+ addChildComponents();
+
+ addConstructorAndInitializationMethods();
+
+ if (graph.componentDescriptor().isProduction()) {
+ addCancellationListenerImplementation();
+ }
+
+ done = true;
+ return componentImplementation;
+ }
+
+ /** Set the supertype for this generated class. */
+ private void setSupertype() {
+ componentImplementation.addSupertype(graph.componentTypeElement());
+ }
+
+ private void addCreatorClass(TypeSpec creator) {
+ if (parent.isPresent()) {
+ // In an inner implementation of a subcomponent the creator is a peer class.
+ parent.get().componentImplementation.addType(SUBCOMPONENT, creator);
+ } else {
+ componentImplementation.addType(COMPONENT_CREATOR, creator);
+ }
+ }
+
+ private void addFactoryMethods() {
+ if (parent.isPresent()) {
+ graph.factoryMethod().ifPresent(this::createSubcomponentFactoryMethod);
+ } else {
+ createRootComponentFactoryMethod();
+ }
+ }
+
+ private void addInterfaceMethods() {
+ // Each component method may have been declared by several supertypes. We want to implement
+ // only one method for each distinct signature.
+ ImmutableListMultimap<MethodSignature, ComponentMethodDescriptor> componentMethodsBySignature =
+ Multimaps.index(graph.componentDescriptor().entryPointMethods(), this::getMethodSignature);
+ for (List<ComponentMethodDescriptor> methodsWithSameSignature :
+ Multimaps.asMap(componentMethodsBySignature).values()) {
+ ComponentMethodDescriptor anyOneMethod = methodsWithSameSignature.stream().findAny().get();
+ MethodSpec methodSpec = bindingExpressions.getComponentMethod(anyOneMethod);
+
+ componentImplementation.addMethod(COMPONENT_METHOD, methodSpec);
+ }
+ }
+
+ private void addCancellationListenerImplementation() {
+ componentImplementation.addSupertype(elements.getTypeElement(CancellationListener.class));
+ componentImplementation.claimMethodName(CANCELLATION_LISTENER_METHOD_NAME);
+
+ ImmutableList<ParameterSpec> parameters =
+ ImmutableList.of(ParameterSpec.builder(boolean.class, MAY_INTERRUPT_IF_RUNNING).build());
+
+ MethodSpec.Builder methodBuilder =
+ methodBuilder(CANCELLATION_LISTENER_METHOD_NAME)
+ .addModifiers(PUBLIC)
+ .addAnnotation(Override.class)
+ .addParameters(parameters);
+
+ ImmutableList<CodeBlock> cancellationStatements = cancellationStatements();
+
+ if (cancellationStatements.size() < STATEMENTS_PER_METHOD) {
+ methodBuilder.addCode(CodeBlocks.concat(cancellationStatements)).build();
+ } else {
+ ImmutableList<MethodSpec> cancelProducersMethods =
+ createPartitionedMethods(
+ "cancelProducers",
+ parameters,
+ cancellationStatements,
+ methodName -> methodBuilder(methodName).addModifiers(PRIVATE));
+ for (MethodSpec cancelProducersMethod : cancelProducersMethods) {
+ methodBuilder.addStatement("$N($L)", cancelProducersMethod, MAY_INTERRUPT_IF_RUNNING);
+ componentImplementation.addMethod(CANCELLATION_LISTENER_METHOD, cancelProducersMethod);
+ }
+ }
+
+ cancelParentStatement().ifPresent(methodBuilder::addCode);
+
+ componentImplementation.addMethod(CANCELLATION_LISTENER_METHOD, methodBuilder.build());
+ }
+
+ private ImmutableList<CodeBlock> cancellationStatements() {
+ // Reversing should order cancellations starting from entry points and going down to leaves
+ // rather than the other way around. This shouldn't really matter but seems *slightly*
+ // preferable because:
+ // When a future that another future depends on is cancelled, that cancellation will propagate
+ // up the future graph toward the entry point. Cancelling in reverse order should ensure that
+ // everything that depends on a particular node has already been cancelled when that node is
+ // cancelled, so there's no need to propagate. Otherwise, when we cancel a leaf node, it might
+ // propagate through most of the graph, making most of the cancel calls that follow in the
+ // onProducerFutureCancelled method do nothing.
+ ImmutableList<Key> cancellationKeys =
+ componentImplementation.getCancellableProducerKeys().reverse();
+
+ ImmutableList.Builder<CodeBlock> cancellationStatements = ImmutableList.builder();
+ for (Key cancellationKey : cancellationKeys) {
+ cancellationStatements.add(
+ CodeBlock.of(
+ "$T.cancel($L, $N);",
+ Producers.class,
+ bindingExpressions
+ .getDependencyExpression(
+ bindingRequest(cancellationKey, FrameworkType.PRODUCER_NODE),
+ componentImplementation.name())
+ .codeBlock(),
+ MAY_INTERRUPT_IF_RUNNING));
+ }
+ return cancellationStatements.build();
+ }
+
+ private Optional<CodeBlock> cancelParentStatement() {
+ if (!shouldPropagateCancellationToParent()) {
+ return Optional.empty();
+ }
+ return Optional.of(
+ CodeBlock.builder()
+ .addStatement(
+ "$T.this.$N($N)",
+ parent.get().componentImplementation.name(),
+ CANCELLATION_LISTENER_METHOD_NAME,
+ MAY_INTERRUPT_IF_RUNNING)
+ .build());
+ }
+
+ private boolean shouldPropagateCancellationToParent() {
+ return parent.isPresent()
+ && parent
+ .get()
+ .componentImplementation
+ .componentDescriptor()
+ .cancellationPolicy()
+ .map(policy -> policy.fromSubcomponents().equals(PROPAGATE))
+ .orElse(false);
+ }
+
+ private MethodSignature getMethodSignature(ComponentMethodDescriptor method) {
+ return MethodSignature.forComponentMethod(
+ method, MoreTypes.asDeclared(graph.componentTypeElement().asType()), types);
+ }
+
+ private void addChildComponents() {
+ for (BindingGraph subgraph : graph.subgraphs()) {
+ componentImplementation.addType(SUBCOMPONENT, childComponent(subgraph));
+ }
+ }
+
+ private TypeSpec childComponent(BindingGraph childGraph) {
+ return topLevelImplementationComponent
+ .currentImplementationSubcomponentBuilder()
+ .componentImplementation(subcomponent(childGraph))
+ .bindingGraph(childGraph)
+ .parentBuilder(Optional.of(this))
+ .parentBindingExpressions(Optional.of(bindingExpressions))
+ .parentRequirementExpressions(Optional.of(componentRequirementExpressions))
+ .build()
+ .componentImplementationBuilder()
+ .build()
+ .generate()
+ .build();
+ }
+
+ /** Creates an inner subcomponent implementation. */
+ private ComponentImplementation subcomponent(BindingGraph childGraph) {
+ return componentImplementation.childComponentImplementation(childGraph);
+ }
+
+ /** Creates and adds the constructor and methods needed for initializing the component. */
+ private void addConstructorAndInitializationMethods() {
+ MethodSpec.Builder constructor = constructorBuilder().addModifiers(PRIVATE);
+ implementInitializationMethod(constructor, initializationParameters());
+ componentImplementation.addMethod(CONSTRUCTOR, constructor.build());
+ }
+
+ /** Adds parameters and code to the given {@code initializationMethod}. */
+ private void implementInitializationMethod(
+ MethodSpec.Builder initializationMethod,
+ ImmutableMap<ComponentRequirement, ParameterSpec> initializationParameters) {
+ initializationMethod.addParameters(initializationParameters.values());
+ initializationMethod.addCode(
+ CodeBlocks.concat(componentImplementation.getComponentRequirementInitializations()));
+ addInitializeMethods(initializationMethod, initializationParameters.values().asList());
+ }
+
+ /**
+ * Adds any necessary {@code initialize} methods to the component and adds calls to them to the
+ * given {@code callingMethod}.
+ */
+ private void addInitializeMethods(
+ MethodSpec.Builder callingMethod, ImmutableList<ParameterSpec> parameters) {
+ // TODO(cgdecker): It's not the case that each initialize() method has need for all of the
+ // given parameters. In some cases, those parameters may have already been assigned to fields
+ // which could be referenced instead. In other cases, an initialize method may just not need
+ // some of the parameters because the set of initializations in that partition does not
+ // include any reference to them. Right now, the Dagger code has no way of getting that
+ // information because, among other things, componentImplementation.getImplementations() just
+ // returns a bunch of CodeBlocks with no semantic information. Additionally, we may not know
+ // yet whether a field will end up needing to be created for a specific requirement, and we
+ // don't want to create a field that ends up only being used during initialization.
+ CodeBlock args = parameterNames(parameters);
+ ImmutableList<MethodSpec> methods =
+ createPartitionedMethods(
+ "initialize",
+ makeFinal(parameters),
+ componentImplementation.getInitializations(),
+ methodName ->
+ methodBuilder(methodName)
+ .addModifiers(PRIVATE)
+ /* TODO(gak): Strictly speaking, we only need the suppression here if we are
+ * also initializing a raw field in this method, but the structure of this
+ * code makes it awkward to pass that bit through. This will be cleaned up
+ * when we no longer separate fields and initialization as we do now. */
+ .addAnnotation(AnnotationSpecs.suppressWarnings(UNCHECKED)));
+ for (MethodSpec method : methods) {
+ callingMethod.addStatement("$N($L)", method, args);
+ componentImplementation.addMethod(INITIALIZE_METHOD, method);
+ }
+ }
+
+ /**
+ * Creates one or more methods, all taking the given {@code parameters}, which partition the given
+ * list of {@code statements} among themselves such that no method has more than {@code
+ * STATEMENTS_PER_METHOD} statements in it and such that the returned methods, if called in order,
+ * will execute the {@code statements} in the given order.
+ */
+ private ImmutableList<MethodSpec> createPartitionedMethods(
+ String methodName,
+ Iterable<ParameterSpec> parameters,
+ List<CodeBlock> statements,
+ Function<String, MethodSpec.Builder> methodBuilderCreator) {
+ return Lists.partition(statements, STATEMENTS_PER_METHOD).stream()
+ .map(
+ partition ->
+ methodBuilderCreator
+ .apply(componentImplementation.getUniqueMethodName(methodName))
+ .addParameters(parameters)
+ .addCode(CodeBlocks.concat(partition))
+ .build())
+ .collect(toImmutableList());
+ }
+
+ /** Returns the given parameters with a final modifier added. */
+ private final ImmutableList<ParameterSpec> makeFinal(Collection<ParameterSpec> parameters) {
+ return parameters.stream()
+ .map(param -> param.toBuilder().addModifiers(FINAL).build())
+ .collect(toImmutableList());
+ }
+
+ /**
+ * Returns the parameters for the constructor as a map from the requirement the parameter fulfills
+ * to the spec for the parameter.
+ */
+ private final ImmutableMap<ComponentRequirement, ParameterSpec> initializationParameters() {
+ Map<ComponentRequirement, ParameterSpec> parameters;
+ if (componentImplementation.componentDescriptor().hasCreator()) {
+ parameters = Maps.toMap(graph.componentRequirements(), ComponentRequirement::toParameterSpec);
+ } else if (graph.factoryMethod().isPresent()) {
+ parameters = getFactoryMethodParameters(graph);
+ } else {
+ throw new AssertionError(
+ "Expected either a component creator or factory method but found neither.");
+ }
+
+ return renameParameters(parameters);
+ }
+
+ /**
+ * Renames the given parameters to guarantee their names do not conflict with fields in the
+ * component to ensure that a parameter is never referenced where a reference to a field was
+ * intended.
+ */
+ // TODO(cgdecker): This is a bit kludgy; it would be preferable to either qualify the field
+ // references with "this." or "super." when needed to disambiguate between field and parameter,
+ // but that would require more context than is currently available when the code referencing a
+ // field is generated.
+ private ImmutableMap<ComponentRequirement, ParameterSpec> renameParameters(
+ Map<ComponentRequirement, ParameterSpec> parameters) {
+ return ImmutableMap.copyOf(
+ Maps.transformEntries(
+ parameters,
+ (requirement, parameter) ->
+ renameParameter(
+ parameter,
+ componentImplementation.getParameterName(requirement, parameter.name))));
+ }
+
+ private ParameterSpec renameParameter(ParameterSpec parameter, String newName) {
+ return ParameterSpec.builder(parameter.type, newName)
+ .addAnnotations(parameter.annotations)
+ .addModifiers(parameter.modifiers)
+ .build();
+ }
+
+ private void createRootComponentFactoryMethod() {
+ checkState(!parent.isPresent());
+ // Top-level components have a static method that returns a builder or factory for the
+ // component. If the user defined a @Component.Builder or @Component.Factory, an
+ // implementation of their type is returned. Otherwise, an autogenerated Builder type is
+ // returned.
+ // TODO(cgdecker): Replace this abomination with a small class?
+ // Better yet, change things so that an autogenerated builder type has a descriptor of sorts
+ // just like a user-defined creator type.
+ ComponentCreatorKind creatorKind;
+ ClassName creatorType;
+ String factoryMethodName;
+ boolean noArgFactoryMethod;
+ Optional<ComponentCreatorDescriptor> creatorDescriptor =
+ graph.componentDescriptor().creatorDescriptor();
+ if (creatorDescriptor.isPresent()) {
+ ComponentCreatorDescriptor descriptor = creatorDescriptor.get();
+ creatorKind = descriptor.kind();
+ creatorType = ClassName.get(descriptor.typeElement());
+ factoryMethodName = descriptor.factoryMethod().getSimpleName().toString();
+ noArgFactoryMethod = descriptor.factoryParameters().isEmpty();
+ } else {
+ creatorKind = BUILDER;
+ creatorType = componentImplementation.getCreatorName();
+ factoryMethodName = "build";
+ noArgFactoryMethod = true;
+ }
+
+ MethodSpec creatorFactoryMethod =
+ methodBuilder(creatorKind.methodName())
+ .addModifiers(PUBLIC, STATIC)
+ .returns(creatorType)
+ .addStatement("return new $T()", componentImplementation.getCreatorName())
+ .build();
+ componentImplementation.addMethod(BUILDER_METHOD, creatorFactoryMethod);
+ if (noArgFactoryMethod && canInstantiateAllRequirements()) {
+ componentImplementation.addMethod(
+ BUILDER_METHOD,
+ methodBuilder("create")
+ .returns(ClassName.get(graph.componentTypeElement()))
+ .addModifiers(PUBLIC, STATIC)
+ .addStatement("return new $L().$L()", creatorKind.typeName(), factoryMethodName)
+ .build());
+ }
+ }
+
+ /** {@code true} if all of the graph's required dependencies can be automatically constructed */
+ private boolean canInstantiateAllRequirements() {
+ return !Iterables.any(
+ graph.componentRequirements(),
+ dependency -> dependency.requiresAPassedInstance(elements, types, metadataUtil));
+ }
+
+ 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 DeclaredType parentType() {
+ return asDeclared(parent.get().graph.componentTypeElement().asType());
+ }
+ /**
+ * Returns the map of {@link ComponentRequirement}s to {@link ParameterSpec}s for the given
+ * graph's factory method.
+ */
+ private static Map<ComponentRequirement, ParameterSpec> getFactoryMethodParameters(
+ BindingGraph graph) {
+ return Maps.transformValues(graph.factoryMethodParameters(), ParameterSpec::get);
+ }
+}
diff --git a/java/dagger/internal/codegen/componentgenerator/ComponentImplementationFactory.java b/java/dagger/internal/codegen/componentgenerator/ComponentImplementationFactory.java
new file mode 100644
index 0000000..fdfcc9d
--- /dev/null
+++ b/java/dagger/internal/codegen/componentgenerator/ComponentImplementationFactory.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.componentgenerator;
+
+import static dagger.internal.codegen.base.Util.reentrantComputeIfAbsent;
+import static dagger.internal.codegen.componentgenerator.ComponentGenerator.componentName;
+
+import dagger.internal.codegen.base.ClearableCache;
+import dagger.internal.codegen.binding.BindingGraph;
+import dagger.internal.codegen.binding.KeyFactory;
+import dagger.internal.codegen.compileroption.CompilerOptions;
+import dagger.internal.codegen.writing.ComponentImplementation;
+import dagger.internal.codegen.writing.SubcomponentNames;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import javax.lang.model.element.TypeElement;
+
+/** Factory for {@link ComponentImplementation}s. */
+@Singleton
+final class ComponentImplementationFactory implements ClearableCache {
+ private final Map<TypeElement, ComponentImplementation> topLevelComponentCache = new HashMap<>();
+ private final KeyFactory keyFactory;
+ private final CompilerOptions compilerOptions;
+ private final TopLevelImplementationComponent.Builder topLevelImplementationComponentBuilder;
+
+ @Inject
+ ComponentImplementationFactory(
+ KeyFactory keyFactory,
+ CompilerOptions compilerOptions,
+ TopLevelImplementationComponent.Builder topLevelImplementationComponentBuilder) {
+ this.keyFactory = keyFactory;
+ this.compilerOptions = compilerOptions;
+ this.topLevelImplementationComponentBuilder = topLevelImplementationComponentBuilder;
+ }
+
+ /**
+ * Returns a top-level (non-nested) component implementation for a binding graph.
+ */
+ ComponentImplementation createComponentImplementation(BindingGraph bindingGraph) {
+ return reentrantComputeIfAbsent(
+ topLevelComponentCache,
+ bindingGraph.componentTypeElement(),
+ component -> createComponentImplementationUncached(bindingGraph));
+ }
+
+ private ComponentImplementation createComponentImplementationUncached(BindingGraph bindingGraph) {
+ ComponentImplementation componentImplementation =
+ ComponentImplementation.topLevelComponentImplementation(
+ bindingGraph,
+ componentName(bindingGraph.componentTypeElement()),
+ new SubcomponentNames(bindingGraph, keyFactory),
+ compilerOptions);
+
+ // TODO(dpb): explore using optional bindings for the "parent" bindings
+ return topLevelImplementationComponentBuilder
+ .topLevelComponent(componentImplementation)
+ .build()
+ .currentImplementationSubcomponentBuilder()
+ .componentImplementation(componentImplementation)
+ .bindingGraph(bindingGraph)
+ .parentBuilder(Optional.empty())
+ .parentBindingExpressions(Optional.empty())
+ .parentRequirementExpressions(Optional.empty())
+ .build()
+ .componentImplementationBuilder()
+ .build();
+ }
+
+ @Override
+ public void clearCache() {
+ topLevelComponentCache.clear();
+ }
+}
diff --git a/java/dagger/internal/codegen/componentgenerator/CurrentImplementationSubcomponent.java b/java/dagger/internal/codegen/componentgenerator/CurrentImplementationSubcomponent.java
new file mode 100644
index 0000000..5584372
--- /dev/null
+++ b/java/dagger/internal/codegen/componentgenerator/CurrentImplementationSubcomponent.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.componentgenerator;
+
+import dagger.BindsInstance;
+import dagger.Subcomponent;
+import dagger.internal.codegen.binding.BindingGraph;
+import dagger.internal.codegen.writing.ComponentBindingExpressions;
+import dagger.internal.codegen.writing.ComponentImplementation;
+import dagger.internal.codegen.writing.ComponentRequirementExpressions;
+import dagger.internal.codegen.writing.ParentComponent;
+import dagger.internal.codegen.writing.PerComponentImplementation;
+import java.util.Optional;
+
+/**
+ * A subcomponent that injects all objects that are responsible for creating a single {@link
+ * ComponentImplementation} instance. Each child {@link ComponentImplementation} will have its own
+ * instance of {@link CurrentImplementationSubcomponent}.
+ */
+@Subcomponent
+@PerComponentImplementation
+// This only needs to be public because the type is referenced by generated component.
+public interface CurrentImplementationSubcomponent {
+ ComponentImplementationBuilder componentImplementationBuilder();
+
+ /** Returns the builder for {@link CurrentImplementationSubcomponent}. */
+ @Subcomponent.Builder
+ interface Builder {
+ @BindsInstance
+ Builder componentImplementation(ComponentImplementation componentImplementation);
+
+ @BindsInstance
+ Builder bindingGraph(BindingGraph bindingGraph);
+
+ @BindsInstance
+ Builder parentBuilder(@ParentComponent Optional<ComponentImplementationBuilder> parentBuilder);
+
+ @BindsInstance
+ Builder parentBindingExpressions(
+ @ParentComponent Optional<ComponentBindingExpressions> parentBindingExpressions);
+
+ @BindsInstance
+ Builder parentRequirementExpressions(
+ @ParentComponent Optional<ComponentRequirementExpressions> parentRequirementExpressions);
+
+ CurrentImplementationSubcomponent build();
+ }
+}
diff --git a/java/dagger/internal/codegen/componentgenerator/MethodSignature.java b/java/dagger/internal/codegen/componentgenerator/MethodSignature.java
new file mode 100644
index 0000000..99b05a4
--- /dev/null
+++ b/java/dagger/internal/codegen/componentgenerator/MethodSignature.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.componentgenerator;
+
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
+
+import com.google.auto.common.MoreTypes;
+import com.google.auto.value.AutoValue;
+import com.google.common.base.Equivalence;
+import com.google.common.collect.ImmutableList;
+import dagger.internal.codegen.binding.ComponentDescriptor.ComponentMethodDescriptor;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import java.util.List;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.ExecutableType;
+import javax.lang.model.type.TypeMirror;
+
+/** A class that defines proper {@code equals} and {@code hashcode} for a method signature. */
+@AutoValue
+abstract class MethodSignature {
+
+ abstract String name();
+
+ abstract ImmutableList<? extends Equivalence.Wrapper<? extends TypeMirror>> parameterTypes();
+
+ abstract ImmutableList<? extends Equivalence.Wrapper<? extends TypeMirror>> thrownTypes();
+
+ static MethodSignature forComponentMethod(
+ ComponentMethodDescriptor componentMethod, DeclaredType componentType, DaggerTypes types) {
+ ExecutableType methodType =
+ MoreTypes.asExecutable(types.asMemberOf(componentType, componentMethod.methodElement()));
+ return new AutoValue_MethodSignature(
+ componentMethod.methodElement().getSimpleName().toString(),
+ wrapInEquivalence(methodType.getParameterTypes()),
+ wrapInEquivalence(methodType.getThrownTypes()));
+ }
+
+ private static ImmutableList<? extends Equivalence.Wrapper<? extends TypeMirror>>
+ wrapInEquivalence(List<? extends TypeMirror> types) {
+ return types.stream().map(MoreTypes.equivalence()::wrap).collect(toImmutableList());
+ }
+}
diff --git a/java/dagger/internal/codegen/componentgenerator/TopLevelImplementationComponent.java b/java/dagger/internal/codegen/componentgenerator/TopLevelImplementationComponent.java
new file mode 100644
index 0000000..7919e47
--- /dev/null
+++ b/java/dagger/internal/codegen/componentgenerator/TopLevelImplementationComponent.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.componentgenerator;
+
+import dagger.BindsInstance;
+import dagger.Subcomponent;
+import dagger.internal.codegen.writing.ComponentImplementation;
+import dagger.internal.codegen.writing.PerGeneratedFile;
+import dagger.internal.codegen.writing.TopLevel;
+
+/**
+ * A shared subcomponent for a top-level {@link ComponentImplementation} and any nested child
+ * implementations.
+ */
+@PerGeneratedFile
+@Subcomponent
+// This only needs to be public because the type is referenced by generated component.
+public interface TopLevelImplementationComponent {
+ CurrentImplementationSubcomponent.Builder currentImplementationSubcomponentBuilder();
+
+ /** Returns the builder for {@link TopLevelImplementationComponent}. */
+ @Subcomponent.Builder
+ interface Builder {
+ @BindsInstance
+ Builder topLevelComponent(@TopLevel ComponentImplementation topLevelImplementation);
+ TopLevelImplementationComponent build();
+ }
+}
diff --git a/java/dagger/internal/codegen/dagger_statistics.proto b/java/dagger/internal/codegen/dagger_statistics.proto
deleted file mode 100644
index 273e472..0000000
--- a/java/dagger/internal/codegen/dagger_statistics.proto
+++ /dev/null
@@ -1,25 +0,0 @@
-syntax = "proto2";
-
-package dagger.internal.codegen.proto;
-option java_package = "dagger.internal.codegen.proto";
-
-import "google/protobuf/duration.proto";
-
-message DaggerBuildStatistics {
- optional google.protobuf.Duration total_processing_time = 1;
- repeated DaggerRound rounds = 2;
-}
-
-// Duration of each Dagger ProcessingStep for a single annotation processing
-// round.
-message DaggerRound {
- optional google.protobuf.Duration map_key_step_time = 1;
- optional google.protobuf.Duration inject_step_time = 2;
- optional google.protobuf.Duration monitoring_module_step_time = 3;
- optional google.protobuf.Duration multibinding_annotations_step_time = 4;
- optional google.protobuf.Duration binds_instance_step_time = 5;
- optional google.protobuf.Duration module_step_time = 6;
- optional google.protobuf.Duration component_step_time = 7;
- optional google.protobuf.Duration component_hjar_step_time = 8;
- optional google.protobuf.Duration binding_method_step_time = 9;
-}
diff --git a/java/dagger/internal/codegen/extension/BUILD b/java/dagger/internal/codegen/extension/BUILD
new file mode 100644
index 0000000..468a685
--- /dev/null
+++ b/java/dagger/internal/codegen/extension/BUILD
@@ -0,0 +1,33 @@
+# Copyright (C) 2019 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Extra features for the JDK and Guava. This code is merged into both
+# the dagger-compiler and dagger-spi artifacts that are sent to Maven
+
+load("@rules_java//java:defs.bzl", "java_library")
+
+package(default_visibility = ["//:src"])
+
+java_library(
+ name = "extension",
+ srcs = glob(["*.java"]),
+ tags = ["maven:merged"],
+ deps = [
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/internal/guava:graph",
+ "@google_bazel_common//third_party/java/jsr305_annotations",
+ ],
+)
diff --git a/java/dagger/internal/codegen/extension/DaggerCollectors.java b/java/dagger/internal/codegen/extension/DaggerCollectors.java
new file mode 100644
index 0000000..7b01676
--- /dev/null
+++ b/java/dagger/internal/codegen/extension/DaggerCollectors.java
@@ -0,0 +1,155 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.extension;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.Optional;
+import java.util.stream.Collector;
+import javax.annotation.Nullable;
+
+/**
+ * A copy of {@link com.google.common.collect.MoreCollectors} to avoid issues with the '-android'
+ * variant of Guava. See b/68008628
+ */
+public final class DaggerCollectors {
+
+ private static final Collector<Object, ?, Optional<Object>> TO_OPTIONAL =
+ Collector.of(
+ ToOptionalState::new,
+ ToOptionalState::add,
+ ToOptionalState::combine,
+ ToOptionalState::getOptional,
+ Collector.Characteristics.UNORDERED);
+
+ /**
+ * A collector that converts a stream of zero or one elements to an {@code Optional}. The returned
+ * collector throws an {@code IllegalArgumentException} if the stream consists of two or more
+ * elements, and a {@code NullPointerException} if the stream consists of exactly one element,
+ * which is null.
+ */
+ @SuppressWarnings("unchecked")
+ public static <T> Collector<T, ?, Optional<T>> toOptional() {
+ return (Collector) TO_OPTIONAL;
+ }
+
+ private static final Object NULL_PLACEHOLDER = new Object();
+
+ private static final Collector<Object, ?, Object> ONLY_ELEMENT =
+ Collector.of(
+ ToOptionalState::new,
+ (state, o) -> state.add((o == null) ? NULL_PLACEHOLDER : o),
+ ToOptionalState::combine,
+ state -> {
+ Object result = state.getElement();
+ return (result == NULL_PLACEHOLDER) ? null : result;
+ },
+ Collector.Characteristics.UNORDERED);
+
+ /**
+ * A collector that takes a stream containing exactly one element and returns that element. The
+ * returned collector throws an {@code IllegalArgumentException} if the stream consists of two or
+ * more elements, and a {@code NoSuchElementException} if the stream is empty.
+ */
+ @SuppressWarnings("unchecked")
+ public static <T> Collector<T, ?, T> onlyElement() {
+ return (Collector) ONLY_ELEMENT;
+ }
+
+ private static final class ToOptionalState {
+ static final int MAX_EXTRAS = 4;
+
+ @Nullable Object element;
+ @Nullable List<Object> extras;
+
+ ToOptionalState() {
+ element = null;
+ extras = null;
+ }
+
+ IllegalArgumentException multiples(boolean overflow) {
+ StringBuilder sb =
+ new StringBuilder().append("expected one element but was: <").append(element);
+ for (Object o : extras) {
+ sb.append(", ").append(o);
+ }
+ if (overflow) {
+ sb.append(", ...");
+ }
+ sb.append('>');
+ throw new IllegalArgumentException(sb.toString());
+ }
+
+ void add(Object o) {
+ checkNotNull(o);
+ if (element == null) {
+ this.element = o;
+ } else if (extras == null) {
+ extras = new ArrayList<>(MAX_EXTRAS);
+ extras.add(o);
+ } else if (extras.size() < MAX_EXTRAS) {
+ extras.add(o);
+ } else {
+ throw multiples(true);
+ }
+ }
+
+ ToOptionalState combine(ToOptionalState other) {
+ if (element == null) {
+ return other;
+ } else if (other.element == null) {
+ return this;
+ } else {
+ if (extras == null) {
+ extras = new ArrayList<>();
+ }
+ extras.add(other.element);
+ if (other.extras != null) {
+ this.extras.addAll(other.extras);
+ }
+ if (extras.size() > MAX_EXTRAS) {
+ extras.subList(MAX_EXTRAS, extras.size()).clear();
+ throw multiples(true);
+ }
+ return this;
+ }
+ }
+
+ Optional<Object> getOptional() {
+ if (extras == null) {
+ return Optional.ofNullable(element);
+ } else {
+ throw multiples(false);
+ }
+ }
+
+ Object getElement() {
+ if (element == null) {
+ throw new NoSuchElementException();
+ } else if (extras == null) {
+ return element;
+ } else {
+ throw multiples(false);
+ }
+ }
+ }
+
+ private DaggerCollectors() {}
+}
diff --git a/java/dagger/internal/codegen/extension/DaggerGraphs.java b/java/dagger/internal/codegen/extension/DaggerGraphs.java
new file mode 100644
index 0000000..587445b
--- /dev/null
+++ b/java/dagger/internal/codegen/extension/DaggerGraphs.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.extension;
+
+import static com.google.common.collect.Sets.difference;
+import static com.google.common.graph.Graphs.reachableNodes;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.graph.Graph;
+import com.google.common.graph.SuccessorsFunction;
+import java.util.ArrayDeque;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Queue;
+import java.util.Set;
+
+/** Utility methods for {@link com.google.common.graph} types. */
+public final class DaggerGraphs {
+ /**
+ * Returns a shortest path from {@code nodeU} to {@code nodeV} in {@code graph} as a list of the
+ * nodes visited in sequence, including both {@code nodeU} and {@code nodeV}. (Note that there may
+ * be many possible shortest paths.)
+ *
+ * <p>If {@code nodeV} is not {@link
+ * com.google.common.graph.Graphs#reachableNodes(com.google.common.graph.Graph, Object) reachable}
+ * from {@code nodeU}, the list returned is empty.
+ *
+ * @throws IllegalArgumentException if {@code nodeU} or {@code nodeV} is not present in {@code
+ * graph}
+ */
+ public static <N> ImmutableList<N> shortestPath(SuccessorsFunction<N> graph, N nodeU, N nodeV) {
+ if (nodeU.equals(nodeV)) {
+ return ImmutableList.of(nodeU);
+ }
+ Set<N> successors = ImmutableSet.copyOf(graph.successors(nodeU));
+ if (successors.contains(nodeV)) {
+ return ImmutableList.of(nodeU, nodeV);
+ }
+
+ Map<N, N> visitedNodeToPathPredecessor = new HashMap<>(); // encodes shortest path tree
+ for (N node : successors) {
+ visitedNodeToPathPredecessor.put(node, nodeU);
+ }
+ Queue<N> currentNodes = new ArrayDeque<N>(successors);
+ Queue<N> nextNodes = new ArrayDeque<N>();
+
+ // Perform a breadth-first traversal starting with the successors of nodeU.
+ while (!currentNodes.isEmpty()) {
+ while (!currentNodes.isEmpty()) {
+ N currentNode = currentNodes.remove();
+ for (N nextNode : graph.successors(currentNode)) {
+ if (visitedNodeToPathPredecessor.containsKey(nextNode)) {
+ continue; // we already have a shortest path to nextNode
+ }
+ visitedNodeToPathPredecessor.put(nextNode, currentNode);
+ if (nextNode.equals(nodeV)) {
+ ImmutableList.Builder<N> builder = ImmutableList.builder();
+ N node = nodeV;
+ builder.add(node);
+ while (!node.equals(nodeU)) {
+ node = visitedNodeToPathPredecessor.get(node);
+ builder.add(node);
+ }
+ return builder.build().reverse();
+ }
+ nextNodes.add(nextNode);
+ }
+ }
+ Queue<N> emptyQueue = currentNodes;
+ currentNodes = nextNodes;
+ nextNodes = emptyQueue; // reusing empty queue faster than allocating new one
+ }
+
+ return ImmutableList.of();
+ }
+
+ /** Returns the nodes in a graph that are not reachable from a node. */
+ public static <N> ImmutableSet<N> unreachableNodes(Graph<N> graph, N node) {
+ return ImmutableSet.copyOf(difference(graph.nodes(), reachableNodes(graph, node)));
+ }
+
+ private DaggerGraphs() {}
+}
diff --git a/java/dagger/internal/codegen/extension/DaggerStreams.java b/java/dagger/internal/codegen/extension/DaggerStreams.java
new file mode 100644
index 0000000..136280d
--- /dev/null
+++ b/java/dagger/internal/codegen/extension/DaggerStreams.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (C) 2013 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.extension;
+
+import static java.util.stream.Collectors.collectingAndThen;
+import static java.util.stream.Collectors.toList;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSetMultimap;
+import com.google.common.collect.Maps;
+import java.util.Collection;
+import java.util.EnumSet;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.stream.Collector;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+/** Utilities for streams. */
+public final class DaggerStreams {
+
+ /**
+ * Returns a {@link Collector} that accumulates the input elements into a new {@link
+ * ImmutableList}, in encounter order.
+ */
+ // TODO(b/68008628): Use ImmutableList.toImmutableList().
+ public static <T> Collector<T, ?, ImmutableList<T>> toImmutableList() {
+ return collectingAndThen(toList(), ImmutableList::copyOf);
+ }
+
+ /**
+ * Returns a {@link Collector} that accumulates the input elements into a new {@link
+ * ImmutableSet}, in encounter order.
+ */
+ // TODO(b/68008628): Use ImmutableSet.toImmutableSet().
+ public static <T> Collector<T, ?, ImmutableSet<T>> toImmutableSet() {
+ return collectingAndThen(toList(), ImmutableSet::copyOf);
+ }
+
+ /**
+ * Returns a {@link Collector} that accumulates elements into an {@code ImmutableMap} whose keys
+ * and values are the result of applying the provided mapping functions to the input elements.
+ * Entries appear in the result {@code ImmutableMap} in encounter order.
+ */
+ // TODO(b/68008628): Use ImmutableMap.toImmutableMap().
+ public static <T, K, V> Collector<T, ?, ImmutableMap<K, V>> toImmutableMap(
+ Function<? super T, K> keyMapper, Function<? super T, V> valueMapper) {
+ return Collectors.mapping(
+ value -> Maps.immutableEntry(keyMapper.apply(value), valueMapper.apply(value)),
+ Collector.of(
+ ImmutableMap::builder,
+ (ImmutableMap.Builder<K, V> builder, Map.Entry<K, V> entry) -> builder.put(entry),
+ (left, right) -> left.putAll(right.build()),
+ ImmutableMap.Builder::build));
+ }
+
+ /**
+ * Returns a {@link Collector} that accumulates elements into an {@code ImmutableSetMultimap}
+ * whose keys and values are the result of applying the provided mapping functions to the input
+ * elements. Entries appear in the result {@code ImmutableSetMultimap} in encounter order.
+ */
+ // TODO(b/68008628): Use ImmutableSetMultimap.toImmutableSetMultimap().
+ public static <T, K, V> Collector<T, ?, ImmutableSetMultimap<K, V>> toImmutableSetMultimap(
+ Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper) {
+ return Collectors.mapping(
+ value -> Maps.immutableEntry(keyMapper.apply(value), valueMapper.apply(value)),
+ Collector.of(
+ ImmutableSetMultimap::builder,
+ (ImmutableSetMultimap.Builder<K, V> builder, Map.Entry<K, V> entry) ->
+ builder.put(entry),
+ (left, right) -> left.putAll(right.build()),
+ ImmutableSetMultimap.Builder::build));
+ }
+
+ /**
+ * Returns a function from {@link Object} to {@code Stream<T>}, which returns a stream containing
+ * its input if its input is an instance of {@code T}.
+ *
+ * <p>Use as an argument to {@link Stream#flatMap(Function)}:
+ *
+ * <pre>{@code Stream<Bar>} barStream = fooStream.flatMap(instancesOf(Bar.class));</pre>
+ */
+ public static <T> Function<Object, Stream<T>> instancesOf(Class<T> to) {
+ return f -> to.isInstance(f) ? Stream.of(to.cast(f)) : Stream.empty();
+ }
+
+ /** Returns a stream of all values of the given {@code enumType}. */
+ public static <E extends Enum<E>> Stream<E> valuesOf(Class<E> enumType) {
+ return EnumSet.allOf(enumType).stream();
+ }
+
+ /**
+ * A function that you can use to extract the present values from a stream of {@link Optional}s.
+ *
+ * <pre>{@code
+ * Set<Foo> foos =
+ * optionalFoos()
+ * .flatMap(DaggerStreams.presentValues())
+ * .collect(toSet());
+ * }</pre>
+ */
+ public static <T> Function<Optional<T>, Stream<T>> presentValues() {
+ return optional -> optional.map(Stream::of).orElse(Stream.empty());
+ }
+
+ /**
+ * Returns a sequential {@link Stream} of the contents of {@code iterable}, delegating to {@link
+ * Collection#stream} if possible.
+ */
+ public static <T> Stream<T> stream(Iterable<T> iterable) {
+ return (iterable instanceof Collection)
+ ? ((Collection<T>) iterable).stream()
+ : StreamSupport.stream(iterable.spliterator(), false);
+ }
+
+ private DaggerStreams() {}
+}
diff --git a/java/dagger/internal/codegen/extension/Optionals.java b/java/dagger/internal/codegen/extension/Optionals.java
new file mode 100644
index 0000000..57494a2
--- /dev/null
+++ b/java/dagger/internal/codegen/extension/Optionals.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.extension;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.collect.Lists.asList;
+
+import java.util.Comparator;
+import java.util.Optional;
+import java.util.function.Function;
+
+/** Utilities for {@link Optional}s. */
+public final class Optionals {
+ /**
+ * A {@link Comparator} that puts empty {@link Optional}s before present ones, and compares
+ * present {@link Optional}s by their values.
+ */
+ public static <C extends Comparable<C>> Comparator<Optional<C>> optionalComparator() {
+ return Comparator.comparing((Optional<C> optional) -> optional.isPresent())
+ .thenComparing(Optional::get);
+ }
+
+ public static <T> Comparator<Optional<T>> emptiesLast(Comparator<? super T> valueComparator) {
+ checkNotNull(valueComparator);
+ return Comparator.comparing(o -> o.orElse(null), Comparator.nullsLast(valueComparator));
+ }
+
+ /** Returns the first argument that is present, or empty if none are. */
+ @SafeVarargs
+ public static <T> Optional<T> firstPresent(
+ Optional<T> first, Optional<T> second, Optional<T>... rest) {
+ return asList(first, second, rest).stream()
+ .filter(Optional::isPresent)
+ .findFirst()
+ .orElse(Optional.empty());
+ }
+
+ /**
+ * Walks a chain of present optionals as defined by successive calls to {@code nextFunction},
+ * returning the value of the final optional that is present. The first optional in the chain is
+ * the result of {@code nextFunction(start)}.
+ */
+ public static <T> T rootmostValue(T start, Function<T, Optional<T>> nextFunction) {
+ T current = start;
+ for (Optional<T> next = nextFunction.apply(start);
+ next.isPresent();
+ next = nextFunction.apply(current)) {
+ current = next.get();
+ }
+ return current;
+ }
+
+ private Optionals() {}
+}
diff --git a/java/dagger/internal/codegen/javac/BUILD b/java/dagger/internal/codegen/javac/BUILD
new file mode 100644
index 0000000..b8cb37c
--- /dev/null
+++ b/java/dagger/internal/codegen/javac/BUILD
@@ -0,0 +1,44 @@
+# Copyright (C) 2017 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# A library for javac the javac plugin module.
+
+load("@rules_java//java:defs.bzl", "java_library")
+
+package(default_visibility = ["//:src"])
+
+java_library(
+ name = "javac",
+ srcs = glob(["*.java"]),
+ plugins = ["//java/dagger/internal/codegen:component-codegen"],
+ exports = [
+ ":javac-import",
+ ],
+ deps = [
+ ":javac-import",
+ "//java/dagger:core",
+ "//java/dagger/internal/codegen/binding",
+ "//java/dagger/internal/codegen/compileroption",
+ "//java/dagger/internal/codegen/langmodel",
+ ],
+)
+
+load("@rules_java//java:defs.bzl", "java_import")
+
+# Replacement for @bazel_tools//third_party/java/jdk/langtools:javac, which seems to have gone away?
+java_import(
+ name = "javac-import",
+ jars = ["@bazel_tools//third_party/java/jdk/langtools:javac_jar"],
+)
diff --git a/java/dagger/internal/codegen/javac/JavacPluginModule.java b/java/dagger/internal/codegen/javac/JavacPluginModule.java
new file mode 100644
index 0000000..214191a
--- /dev/null
+++ b/java/dagger/internal/codegen/javac/JavacPluginModule.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.javac;
+
+import com.sun.tools.javac.model.JavacElements;
+import com.sun.tools.javac.model.JavacTypes;
+import com.sun.tools.javac.util.Context;
+import dagger.Binds;
+import dagger.Module;
+import dagger.Provides;
+import dagger.internal.codegen.binding.BindingGraphFactory;
+import dagger.internal.codegen.binding.ComponentDescriptorFactory;
+import dagger.internal.codegen.compileroption.CompilerOptions;
+import dagger.internal.codegen.compileroption.JavacPluginCompilerOptions;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import javax.annotation.processing.Messager;
+import javax.inject.Inject;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
+import javax.lang.model.element.Element;
+import javax.lang.model.util.Types;
+import javax.tools.Diagnostic;
+
+/**
+ * A module that provides a {@link BindingGraphFactory} and {@link ComponentDescriptorFactory} for
+ * use in {@code javac} plugins. Requires a binding for the {@code javac} {@link Context}.
+ */
+@Module
+public abstract class JavacPluginModule {
+ @Binds
+ abstract CompilerOptions compilerOptions(JavacPluginCompilerOptions compilerOptions);
+
+ @Binds
+ abstract Messager messager(NullMessager nullMessager);
+
+ static final class NullMessager implements Messager {
+
+ @Inject
+ NullMessager() {}
+
+ @Override
+ public void printMessage(Diagnostic.Kind kind, CharSequence charSequence) {}
+
+ @Override
+ public void printMessage(Diagnostic.Kind kind, CharSequence charSequence, Element element) {}
+
+ @Override
+ public void printMessage(
+ Diagnostic.Kind kind,
+ CharSequence charSequence,
+ Element element,
+ AnnotationMirror annotationMirror) {}
+
+ @Override
+ public void printMessage(
+ Diagnostic.Kind kind,
+ CharSequence charSequence,
+ Element element,
+ AnnotationMirror annotationMirror,
+ AnnotationValue annotationValue) {}
+ }
+
+ @Provides
+ static DaggerElements daggerElements(Context javaContext) {
+ return new DaggerElements(
+ JavacElements.instance(javaContext), JavacTypes.instance(javaContext));
+ }
+
+ @Provides
+ static DaggerTypes daggerTypes(Context javaContext, DaggerElements elements) {
+ return new DaggerTypes(JavacTypes.instance(javaContext), elements);
+ }
+
+ @Binds abstract Types types(DaggerTypes daggerTypes);
+
+ private JavacPluginModule() {}
+}
diff --git a/java/dagger/internal/codegen/javapoet/AnnotationSpecs.java b/java/dagger/internal/codegen/javapoet/AnnotationSpecs.java
index cc0d7de..b66d266 100644
--- a/java/dagger/internal/codegen/javapoet/AnnotationSpecs.java
+++ b/java/dagger/internal/codegen/javapoet/AnnotationSpecs.java
@@ -16,34 +16,38 @@
package dagger.internal.codegen.javapoet;
-import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkArgument;
-import com.google.common.base.Ascii;
-import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Lists;
import com.squareup.javapoet.AnnotationSpec;
-import java.util.Arrays;
/** Static factories to create {@link AnnotationSpec}s. */
public final class AnnotationSpecs {
/** Values for an {@link SuppressWarnings} annotation. */
public enum Suppression {
- RAWTYPES,
- UNCHECKED,
+ RAWTYPES("rawtypes"),
+ UNCHECKED("unchecked"),
+ FUTURE_RETURN_VALUE_IGNORED("FutureReturnValueIgnored"),
;
- @Override
- public String toString() {
- return Ascii.toLowerCase(name());
+ private final String value;
+
+ Suppression(String value) {
+ this.value = value;
}
}
/** Creates an {@link AnnotationSpec} for {@link SuppressWarnings}. */
public static AnnotationSpec suppressWarnings(Suppression first, Suppression... rest) {
- checkNotNull(first);
- Arrays.stream(rest).forEach(Preconditions::checkNotNull);
+ return suppressWarnings(ImmutableSet.copyOf(Lists.asList(first, rest)));
+ }
+
+ /** Creates an {@link AnnotationSpec} for {@link SuppressWarnings}. */
+ public static AnnotationSpec suppressWarnings(ImmutableSet<Suppression> suppressions) {
+ checkArgument(!suppressions.isEmpty());
AnnotationSpec.Builder builder = AnnotationSpec.builder(SuppressWarnings.class);
- Lists.asList(first, rest).forEach(suppression -> builder.addMember("value", "$S", suppression));
+ suppressions.forEach(suppression -> builder.addMember("value", "$S", suppression.value));
return builder.build();
}
diff --git a/java/dagger/internal/codegen/javapoet/BUILD b/java/dagger/internal/codegen/javapoet/BUILD
index f829d49..ddb9f88 100644
--- a/java/dagger/internal/codegen/javapoet/BUILD
+++ b/java/dagger/internal/codegen/javapoet/BUILD
@@ -15,20 +15,22 @@
# Description:
# JavaPoet extensions for use in Dagger
+load("@rules_java//java:defs.bzl", "java_library")
+
package(default_visibility = ["//:src"])
java_library(
name = "javapoet",
srcs = glob(["*.java"]),
- plugins = ["//java/dagger/internal/codegen:bootstrap_compiler_plugin"],
+ plugins = ["//java/dagger/internal/codegen/bootstrap"],
tags = ["maven:merged"],
deps = [
"//java/dagger:core",
"//java/dagger/internal/codegen/langmodel",
+ "//java/dagger/internal/guava:collect",
"//java/dagger/producers",
- "@google_bazel_common//third_party/java/auto:common",
"@google_bazel_common//third_party/java/error_prone:annotations",
- "@google_bazel_common//third_party/java/guava",
"@google_bazel_common//third_party/java/javapoet",
+ "@maven//:com_google_auto_auto_common",
],
)
diff --git a/java/dagger/internal/codegen/javapoet/TypeNames.java b/java/dagger/internal/codegen/javapoet/TypeNames.java
index 9301dbc..71f03f0 100644
--- a/java/dagger/internal/codegen/javapoet/TypeNames.java
+++ b/java/dagger/internal/codegen/javapoet/TypeNames.java
@@ -25,6 +25,7 @@
import dagger.MembersInjector;
import dagger.internal.DoubleCheck;
import dagger.internal.Factory;
+import dagger.internal.InjectedFieldSignature;
import dagger.internal.InstanceFactory;
import dagger.internal.MapFactory;
import dagger.internal.MapProviderFactory;
@@ -34,6 +35,7 @@
import dagger.internal.SingleCheck;
import dagger.producers.Produced;
import dagger.producers.Producer;
+import dagger.producers.ProducerModule;
import dagger.producers.internal.AbstractProducer;
import dagger.producers.internal.DependencyMethodProducer;
import dagger.producers.internal.MapOfProducedProducer;
@@ -57,6 +59,8 @@
public static final ClassName DOUBLE_CHECK = ClassName.get(DoubleCheck.class);
public static final ClassName FACTORY = ClassName.get(Factory.class);
public static final ClassName FUTURES = ClassName.get(Futures.class);
+ public static final ClassName INJECTED_FIELD_SIGNATURE =
+ ClassName.get(InjectedFieldSignature.class);
public static final ClassName INSTANCE_FACTORY = ClassName.get(InstanceFactory.class);
public static final ClassName LAZY = ClassName.get(Lazy.class);
public static final ClassName LIST = ClassName.get(List.class);
@@ -74,6 +78,7 @@
public static final ClassName PRODUCED = ClassName.get(Produced.class);
public static final ClassName PRODUCER = ClassName.get(Producer.class);
public static final ClassName PRODUCERS = ClassName.get(Producers.class);
+ public static final ClassName PRODUCER_MODULE = ClassName.get(ProducerModule.class);
public static final ClassName PRODUCTION_COMPONENT_MONITOR_FACTORY =
ClassName.get(ProductionComponentMonitor.Factory.class);
public static final ClassName PROVIDER = ClassName.get(Provider.class);
diff --git a/java/dagger/internal/codegen/kotlin/BUILD b/java/dagger/internal/codegen/kotlin/BUILD
new file mode 100644
index 0000000..d1c5458
--- /dev/null
+++ b/java/dagger/internal/codegen/kotlin/BUILD
@@ -0,0 +1,41 @@
+# Copyright (C) 2019 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Sources related to Kotlin metadata.
+
+load("@rules_java//java:defs.bzl", "java_library")
+
+package(default_visibility = ["//:src"])
+
+java_library(
+ name = "kotlin",
+ srcs = glob(["*.java"]),
+ plugins = ["//java/dagger/internal/codegen/bootstrap"],
+ tags = ["maven:merged"],
+ deps = [
+ "//java/dagger:core",
+ "//java/dagger/internal/codegen/base:shared",
+ "//java/dagger/internal/codegen/extension",
+ "//java/dagger/internal/codegen/langmodel",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "@google_bazel_common//third_party/java/auto:value",
+ "@google_bazel_common//third_party/java/jsr305_annotations",
+ "@google_bazel_common//third_party/java/jsr330_inject",
+ "@maven//:com_google_auto_auto_common",
+ "@maven//:org_jetbrains_kotlin_kotlin_stdlib",
+ "@maven//:org_jetbrains_kotlinx_kotlinx_metadata_jvm",
+ ],
+)
diff --git a/java/dagger/internal/codegen/kotlin/KotlinMetadata.java b/java/dagger/internal/codegen/kotlin/KotlinMetadata.java
new file mode 100644
index 0000000..296da44
--- /dev/null
+++ b/java/dagger/internal/codegen/kotlin/KotlinMetadata.java
@@ -0,0 +1,472 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.kotlin;
+
+import static dagger.internal.codegen.base.MoreAnnotationValues.getIntArrayValue;
+import static dagger.internal.codegen.base.MoreAnnotationValues.getIntValue;
+import static dagger.internal.codegen.base.MoreAnnotationValues.getOptionalIntValue;
+import static dagger.internal.codegen.base.MoreAnnotationValues.getOptionalStringValue;
+import static dagger.internal.codegen.base.MoreAnnotationValues.getStringArrayValue;
+import static dagger.internal.codegen.base.MoreAnnotationValues.getStringValue;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableMap;
+import static dagger.internal.codegen.langmodel.DaggerElements.getAnnotationMirror;
+import static dagger.internal.codegen.langmodel.DaggerElements.getFieldDescriptor;
+import static dagger.internal.codegen.langmodel.DaggerElements.getMethodDescriptor;
+import static kotlinx.metadata.Flag.ValueParameter.DECLARES_DEFAULT_VALUE;
+
+import com.google.auto.value.AutoValue;
+import com.google.auto.value.extension.memoized.Memoized;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import dagger.internal.codegen.extension.DaggerCollectors;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+import javax.annotation.Nullable;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.util.ElementFilter;
+import kotlin.Metadata;
+import kotlinx.metadata.Flag;
+import kotlinx.metadata.KmClassVisitor;
+import kotlinx.metadata.KmConstructorExtensionVisitor;
+import kotlinx.metadata.KmConstructorVisitor;
+import kotlinx.metadata.KmExtensionType;
+import kotlinx.metadata.KmFunctionExtensionVisitor;
+import kotlinx.metadata.KmFunctionVisitor;
+import kotlinx.metadata.KmPropertyExtensionVisitor;
+import kotlinx.metadata.KmPropertyVisitor;
+import kotlinx.metadata.KmValueParameterVisitor;
+import kotlinx.metadata.jvm.JvmConstructorExtensionVisitor;
+import kotlinx.metadata.jvm.JvmFieldSignature;
+import kotlinx.metadata.jvm.JvmFunctionExtensionVisitor;
+import kotlinx.metadata.jvm.JvmMethodSignature;
+import kotlinx.metadata.jvm.JvmPropertyExtensionVisitor;
+import kotlinx.metadata.jvm.KotlinClassHeader;
+import kotlinx.metadata.jvm.KotlinClassMetadata;
+
+/** Data class of a TypeElement and its Kotlin metadata. */
+@AutoValue
+abstract class KotlinMetadata {
+ // Kotlin suffix for fields that are for a delegated property.
+ // See:
+ // https://github.com/JetBrains/kotlin/blob/master/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/JvmAbi.kt#L32
+ private static final String DELEGATED_PROPERTY_NAME_SUFFIX = "$delegate";
+
+ // Map that associates field elements with its Kotlin synthetic method for annotations.
+ private final Map<VariableElement, Optional<MethodForAnnotations>>
+ elementFieldAnnotationMethodMap = new HashMap<>();
+
+ // Map that associates field elements with its Kotlin getter method.
+ private final Map<VariableElement, Optional<ExecutableElement>> elementFieldGetterMethodMap =
+ new HashMap<>();
+
+ abstract TypeElement typeElement();
+
+ abstract ClassMetadata classMetadata();
+
+ @Memoized
+ ImmutableMap<String, ExecutableElement> methodDescriptors() {
+ return ElementFilter.methodsIn(typeElement().getEnclosedElements()).stream()
+ .collect(toImmutableMap(DaggerElements::getMethodDescriptor, Function.identity()));
+ }
+
+ /** Returns true if any constructor of the defined a default parameter. */
+ @Memoized
+ boolean containsConstructorWithDefaultParam() {
+ return classMetadata().constructors().stream()
+ .flatMap(constructor -> constructor.parameters().stream())
+ .anyMatch(parameter -> parameter.flags(DECLARES_DEFAULT_VALUE));
+ }
+
+ /** Gets the synthetic method for annotations of a given field element. */
+ Optional<ExecutableElement> getSyntheticAnnotationMethod(VariableElement fieldElement) {
+ return getAnnotationMethod(fieldElement)
+ .map(
+ methodForAnnotations -> {
+ if (methodForAnnotations == MethodForAnnotations.MISSING) {
+ throw new IllegalStateException(
+ "Method for annotations is missing for " + fieldElement);
+ }
+ return methodForAnnotations.method();
+ });
+ }
+
+ /**
+ * Returns true if the synthetic method for annotations is missing. This can occur when inspecting
+ * the Kotlin metadata of a property from another compilation unit.
+ */
+ boolean isMissingSyntheticAnnotationMethod(VariableElement fieldElement) {
+ return getAnnotationMethod(fieldElement)
+ .map(methodForAnnotations -> methodForAnnotations == MethodForAnnotations.MISSING)
+ // This can be missing if there was no property annotation at all (e.g. no annotations or
+ // the qualifier is already properly attached to the field). For these cases, it isn't
+ // considered missing since there was no method to look for in the first place.
+ .orElse(false);
+ }
+
+ private Optional<MethodForAnnotations> getAnnotationMethod(VariableElement fieldElement) {
+ return elementFieldAnnotationMethodMap.computeIfAbsent(
+ fieldElement, this::getAnnotationMethodUncached);
+ }
+
+ private Optional<MethodForAnnotations> getAnnotationMethodUncached(VariableElement fieldElement) {
+ return findProperty(fieldElement)
+ .methodForAnnotationsSignature()
+ .map(
+ signature ->
+ Optional.ofNullable(methodDescriptors().get(signature))
+ .map(MethodForAnnotations::create)
+ // The method may be missing across different compilations.
+ // See https://youtrack.jetbrains.com/issue/KT-34684
+ .orElse(MethodForAnnotations.MISSING));
+ }
+
+ /** Gets the getter method of a given field element corresponding to a property. */
+ Optional<ExecutableElement> getPropertyGetter(VariableElement fieldElement) {
+ return elementFieldGetterMethodMap.computeIfAbsent(
+ fieldElement, this::getPropertyGetterUncached);
+ }
+
+ private Optional<ExecutableElement> getPropertyGetterUncached(VariableElement fieldElement) {
+ return findProperty(fieldElement)
+ .getterSignature()
+ .flatMap(signature -> Optional.ofNullable(methodDescriptors().get(signature)));
+ }
+
+ private PropertyMetadata findProperty(VariableElement field) {
+ String fieldDescriptor = getFieldDescriptor(field);
+ if (classMetadata().propertiesByFieldSignature().containsKey(fieldDescriptor)) {
+ return classMetadata().propertiesByFieldSignature().get(fieldDescriptor);
+ } else {
+ // Fallback to finding property by name, see: https://youtrack.jetbrains.com/issue/KT-35124
+ final String propertyName = getPropertyNameFromField(field);
+ return classMetadata().propertiesByFieldSignature().values().stream()
+ .filter(property -> propertyName.contentEquals(property.name()))
+ .collect(DaggerCollectors.onlyElement());
+ }
+ }
+
+ private static String getPropertyNameFromField(VariableElement field) {
+ String name = field.getSimpleName().toString();
+ if (name.endsWith(DELEGATED_PROPERTY_NAME_SUFFIX)) {
+ return name.substring(0, name.length() - DELEGATED_PROPERTY_NAME_SUFFIX.length());
+ } else {
+ return name;
+ }
+ }
+
+ FunctionMetadata getFunctionMetadata(ExecutableElement method) {
+ return classMetadata().functionsBySignature().get(getMethodDescriptor(method));
+ }
+
+ /** Parse Kotlin class metadata from a given type element * */
+ static KotlinMetadata from(TypeElement typeElement) {
+ return new AutoValue_KotlinMetadata(
+ typeElement, ClassVisitor.createClassMetadata(metadataOf(typeElement)));
+ }
+
+ private static KotlinClassMetadata.Class metadataOf(TypeElement typeElement) {
+ Optional<AnnotationMirror> metadataAnnotation =
+ getAnnotationMirror(typeElement, Metadata.class);
+ Preconditions.checkState(metadataAnnotation.isPresent());
+ KotlinClassHeader header =
+ new KotlinClassHeader(
+ getIntValue(metadataAnnotation.get(), "k"),
+ getIntArrayValue(metadataAnnotation.get(), "mv"),
+ getIntArrayValue(metadataAnnotation.get(), "bv"),
+ getStringArrayValue(metadataAnnotation.get(), "d1"),
+ getStringArrayValue(metadataAnnotation.get(), "d2"),
+ getStringValue(metadataAnnotation.get(), "xs"),
+ getOptionalStringValue(metadataAnnotation.get(), "pn").orElse(null),
+ getOptionalIntValue(metadataAnnotation.get(), "xi").orElse(null));
+ KotlinClassMetadata metadata = KotlinClassMetadata.read(header);
+ if (metadata == null) {
+ // Should only happen on Kotlin < 1.0 (i.e. metadata version < 1.1)
+ throw new IllegalStateException(
+ "Unsupported metadata version. Check that your Kotlin version is >= 1.0");
+ }
+ if (metadata instanceof KotlinClassMetadata.Class) {
+ // TODO(danysantiago): If when we need other types of metadata then move to right method.
+ return (KotlinClassMetadata.Class) metadata;
+ } else {
+ throw new IllegalStateException("Unsupported metadata type: " + metadata);
+ }
+ }
+
+ private static final class ClassVisitor extends KmClassVisitor {
+ static ClassMetadata createClassMetadata(KotlinClassMetadata.Class data) {
+ ClassVisitor visitor = new ClassVisitor();
+ data.accept(visitor);
+ return visitor.classMetadata.build();
+ }
+
+ private final ClassMetadata.Builder classMetadata = ClassMetadata.builder();
+
+ @Override
+ public void visit(int flags, String name) {
+ classMetadata.flags(flags).name(name);
+ }
+
+ @Override
+ public KmConstructorVisitor visitConstructor(int flags) {
+ return new KmConstructorVisitor() {
+ private final FunctionMetadata.Builder constructor =
+ FunctionMetadata.builder(flags, "<init>");
+
+ @Override
+ public KmValueParameterVisitor visitValueParameter(int flags, String name) {
+ constructor.addParameter(ValueParameterMetadata.create(flags, name));
+ return super.visitValueParameter(flags, name);
+ }
+
+ @Override
+ public KmConstructorExtensionVisitor visitExtensions(KmExtensionType kmExtensionType) {
+ return kmExtensionType.equals(JvmConstructorExtensionVisitor.TYPE)
+ ? new JvmConstructorExtensionVisitor() {
+ @Override
+ public void visit(JvmMethodSignature jvmMethodSignature) {
+ constructor.signature(jvmMethodSignature.asString());
+ }
+ }
+ : null;
+ }
+
+ @Override
+ public void visitEnd() {
+ classMetadata.addConstructor(constructor.build());
+ }
+ };
+ }
+
+ @Override
+ public KmFunctionVisitor visitFunction(int flags, String name) {
+ return new KmFunctionVisitor() {
+ private final FunctionMetadata.Builder function = FunctionMetadata.builder(flags, name);
+
+ @Override
+ public KmValueParameterVisitor visitValueParameter(int flags, String name) {
+ function.addParameter(ValueParameterMetadata.create(flags, name));
+ return super.visitValueParameter(flags, name);
+ }
+
+ @Override
+ public KmFunctionExtensionVisitor visitExtensions(KmExtensionType kmExtensionType) {
+ return kmExtensionType.equals(JvmFunctionExtensionVisitor.TYPE)
+ ? new JvmFunctionExtensionVisitor() {
+ @Override
+ public void visit(JvmMethodSignature jvmMethodSignature) {
+ function.signature(jvmMethodSignature.asString());
+ }
+ }
+ : null;
+ }
+
+ @Override
+ public void visitEnd() {
+ classMetadata.addFunction(function.build());
+ }
+ };
+ }
+
+ @Override
+ public void visitCompanionObject(String companionObjectName) {
+ classMetadata.companionObjectName(companionObjectName);
+ }
+
+ @Override
+ public KmPropertyVisitor visitProperty(
+ int flags, String name, int getterFlags, int setterFlags) {
+ return new KmPropertyVisitor() {
+ private final PropertyMetadata.Builder property = PropertyMetadata.builder(flags, name);
+
+ @Override
+ public KmPropertyExtensionVisitor visitExtensions(KmExtensionType kmExtensionType) {
+ if (!kmExtensionType.equals(JvmPropertyExtensionVisitor.TYPE)) {
+ return null;
+ }
+
+ return new JvmPropertyExtensionVisitor() {
+ @Override
+ public void visit(
+ int jvmFlags,
+ @Nullable JvmFieldSignature jvmFieldSignature,
+ @Nullable JvmMethodSignature jvmGetterSignature,
+ @Nullable JvmMethodSignature jvmSetterSignature) {
+ property.fieldSignature(
+ Optional.ofNullable(jvmFieldSignature).map(JvmFieldSignature::asString));
+ property.getterSignature(
+ Optional.ofNullable(jvmGetterSignature).map(JvmMethodSignature::asString));
+ }
+
+ @Override
+ public void visitSyntheticMethodForAnnotations(
+ @Nullable JvmMethodSignature methodSignature) {
+ property.methodForAnnotationsSignature(
+ Optional.ofNullable(methodSignature).map(JvmMethodSignature::asString));
+ }
+ };
+ }
+
+ @Override
+ public void visitEnd() {
+ classMetadata.addProperty(property.build());
+ }
+ };
+ }
+ }
+
+ @AutoValue
+ abstract static class ClassMetadata extends BaseMetadata {
+ abstract Optional<String> companionObjectName();
+
+ abstract ImmutableSet<FunctionMetadata> constructors();
+
+ abstract ImmutableMap<String, FunctionMetadata> functionsBySignature();
+
+ abstract ImmutableMap<String, PropertyMetadata> propertiesByFieldSignature();
+
+ static Builder builder() {
+ return new AutoValue_KotlinMetadata_ClassMetadata.Builder();
+ }
+
+ @AutoValue.Builder
+ abstract static class Builder implements BaseMetadata.Builder<Builder> {
+ abstract Builder companionObjectName(String companionObjectName);
+
+ abstract ImmutableSet.Builder<FunctionMetadata> constructorsBuilder();
+
+ abstract ImmutableMap.Builder<String, FunctionMetadata> functionsBySignatureBuilder();
+
+ abstract ImmutableMap.Builder<String, PropertyMetadata> propertiesByFieldSignatureBuilder();
+
+ Builder addConstructor(FunctionMetadata constructor) {
+ constructorsBuilder().add(constructor);
+ return this;
+ }
+
+ Builder addFunction(FunctionMetadata function) {
+ functionsBySignatureBuilder().put(function.signature(), function);
+ return this;
+ }
+
+ Builder addProperty(PropertyMetadata property) {
+ if (property.fieldSignature().isPresent()) {
+ propertiesByFieldSignatureBuilder().put(property.fieldSignature().get(), property);
+ }
+ return this;
+ }
+
+ abstract ClassMetadata build();
+ }
+ }
+
+ @AutoValue
+ abstract static class FunctionMetadata extends BaseMetadata {
+ abstract String signature();
+
+ abstract ImmutableList<ValueParameterMetadata> parameters();
+
+ static Builder builder(int flags, String name) {
+ return new AutoValue_KotlinMetadata_FunctionMetadata.Builder().flags(flags).name(name);
+ }
+
+ @AutoValue.Builder
+ abstract static class Builder implements BaseMetadata.Builder<Builder> {
+ abstract Builder signature(String signature);
+
+ abstract ImmutableList.Builder<ValueParameterMetadata> parametersBuilder();
+
+ Builder addParameter(ValueParameterMetadata parameter) {
+ parametersBuilder().add(parameter);
+ return this;
+ }
+
+ abstract FunctionMetadata build();
+ }
+ }
+
+ @AutoValue
+ abstract static class PropertyMetadata extends BaseMetadata {
+ /** Returns the JVM field descriptor of the backing field of this property. */
+ abstract Optional<String> fieldSignature();
+
+ abstract Optional<String> getterSignature();
+
+ /** Returns JVM method descriptor of the synthetic method for property annotations. */
+ abstract Optional<String> methodForAnnotationsSignature();
+
+ static Builder builder(int flags, String name) {
+ return new AutoValue_KotlinMetadata_PropertyMetadata.Builder().flags(flags).name(name);
+ }
+
+ @AutoValue.Builder
+ interface Builder extends BaseMetadata.Builder<Builder> {
+ Builder fieldSignature(Optional<String> signature);
+
+ Builder getterSignature(Optional<String> signature);
+
+ Builder methodForAnnotationsSignature(Optional<String> signature);
+
+ PropertyMetadata build();
+ }
+ }
+
+ @AutoValue
+ abstract static class ValueParameterMetadata extends BaseMetadata {
+ private static ValueParameterMetadata create(int flags, String name) {
+ return new AutoValue_KotlinMetadata_ValueParameterMetadata(flags, name);
+ }
+ }
+
+ abstract static class BaseMetadata {
+ /** Returns the Kotlin metadata flags for this property. */
+ abstract int flags();
+
+ /** returns {@code true} if the given flag (e.g. {@link Flag.IS_PRIVATE}) applies. */
+ boolean flags(Flag flag) {
+ return flag.invoke(flags());
+ }
+
+ /** Returns the simple name of this property. */
+ abstract String name();
+
+ interface Builder<BuilderT> {
+ BuilderT flags(int flags);
+
+ BuilderT name(String name);
+ }
+ }
+
+ @AutoValue
+ abstract static class MethodForAnnotations {
+ static MethodForAnnotations create(ExecutableElement method) {
+ return new AutoValue_KotlinMetadata_MethodForAnnotations(method);
+ }
+
+ static final MethodForAnnotations MISSING = MethodForAnnotations.create(null);
+
+ @Nullable
+ abstract ExecutableElement method();
+ }
+}
diff --git a/java/dagger/internal/codegen/kotlin/KotlinMetadataFactory.java b/java/dagger/internal/codegen/kotlin/KotlinMetadataFactory.java
new file mode 100644
index 0000000..1515469
--- /dev/null
+++ b/java/dagger/internal/codegen/kotlin/KotlinMetadataFactory.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.kotlin;
+
+import static com.google.auto.common.MoreElements.isAnnotationPresent;
+import static dagger.internal.codegen.langmodel.DaggerElements.closestEnclosingTypeElement;
+
+import dagger.internal.codegen.base.ClearableCache;
+import java.util.HashMap;
+import java.util.Map;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import kotlin.Metadata;
+
+/**
+ * Factory creating Kotlin metadata data objects.
+ *
+ * <p>The metadata is cache since it can be expensive to parse the information stored in a proto
+ * binary string format in the metadata annotation values.
+ */
+@Singleton
+public final class KotlinMetadataFactory implements ClearableCache {
+ private final Map<TypeElement, KotlinMetadata> metadataCache = new HashMap<>();
+
+ @Inject
+ KotlinMetadataFactory() {}
+
+ /**
+ * Parses and returns the {@link KotlinMetadata} out of a given element.
+ *
+ * @throws IllegalStateException if the element has no metadata or is not enclosed in a type
+ * element with metadata. To check if an element has metadata use {@link
+ * KotlinMetadataUtil#hasMetadata(Element)}
+ */
+ public KotlinMetadata create(Element element) {
+ TypeElement enclosingElement = closestEnclosingTypeElement(element);
+ if (!isAnnotationPresent(enclosingElement, Metadata.class)) {
+ throw new IllegalStateException("Missing @Metadata for: " + enclosingElement);
+ }
+ return metadataCache.computeIfAbsent(enclosingElement, KotlinMetadata::from);
+ }
+
+ @Override
+ public void clearCache() {
+ metadataCache.clear();
+ }
+}
diff --git a/java/dagger/internal/codegen/kotlin/KotlinMetadataUtil.java b/java/dagger/internal/codegen/kotlin/KotlinMetadataUtil.java
new file mode 100644
index 0000000..76d28f0
--- /dev/null
+++ b/java/dagger/internal/codegen/kotlin/KotlinMetadataUtil.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.kotlin;
+
+import static com.google.auto.common.AnnotationMirrors.getAnnotatedAnnotations;
+import static com.google.auto.common.MoreElements.isAnnotationPresent;
+import static dagger.internal.codegen.langmodel.DaggerElements.closestEnclosingTypeElement;
+import static kotlinx.metadata.Flag.Class.IS_COMPANION_OBJECT;
+import static kotlinx.metadata.Flag.Class.IS_DATA;
+import static kotlinx.metadata.Flag.Class.IS_OBJECT;
+import static kotlinx.metadata.Flag.IS_PRIVATE;
+
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableList;
+import dagger.internal.codegen.extension.DaggerCollectors;
+import java.lang.annotation.Annotation;
+import java.util.Optional;
+import javax.inject.Inject;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.util.ElementFilter;
+import kotlin.Metadata;
+import kotlin.jvm.JvmStatic;
+import kotlinx.metadata.Flag;
+
+/** Utility class for interacting with Kotlin Metadata. */
+public final class KotlinMetadataUtil {
+
+ private final KotlinMetadataFactory metadataFactory;
+
+ @Inject
+ KotlinMetadataUtil(KotlinMetadataFactory metadataFactory) {
+ this.metadataFactory = metadataFactory;
+ }
+
+ /**
+ * Returns {@code true} if this element has the Kotlin Metadata annotation or if it is enclosed in
+ * an element that does.
+ */
+ public boolean hasMetadata(Element element) {
+ return isAnnotationPresent(closestEnclosingTypeElement(element), Metadata.class);
+ }
+
+ /**
+ * Returns the synthetic annotations of a Kotlin property.
+ *
+ * <p>Note that this method only looks for additional annotations in the synthetic property
+ * method, if any, of a Kotlin property and not for annotations in its backing field.
+ */
+ public ImmutableCollection<? extends AnnotationMirror> getSyntheticPropertyAnnotations(
+ VariableElement fieldElement, Class<? extends Annotation> annotationType) {
+ return metadataFactory
+ .create(fieldElement)
+ .getSyntheticAnnotationMethod(fieldElement)
+ .map(methodElement -> getAnnotatedAnnotations(methodElement, annotationType).asList())
+ .orElse(ImmutableList.of());
+ }
+
+ /**
+ * Returns {@code true} if the synthetic method for annotations is missing. This can occur when
+ * the Kotlin metadata of the property reports that it contains a synthetic method for annotations
+ * but such method is not found since it is synthetic and ignored by the processor.
+ */
+ public boolean isMissingSyntheticPropertyForAnnotations(VariableElement fieldElement) {
+ return metadataFactory.create(fieldElement).isMissingSyntheticAnnotationMethod(fieldElement);
+ }
+
+ /** Returns {@code true} if this type element is a Kotlin Object. */
+ public boolean isObjectClass(TypeElement typeElement) {
+ return hasMetadata(typeElement)
+ && metadataFactory.create(typeElement).classMetadata().flags(IS_OBJECT);
+ }
+
+ /** Returns {@code true} if this type element is a Kotlin data class. */
+ public boolean isDataClass(TypeElement typeElement) {
+ return hasMetadata(typeElement)
+ && metadataFactory.create(typeElement).classMetadata().flags(IS_DATA);
+ }
+
+ /* Returns {@code true} if this type element is a Kotlin Companion Object. */
+ public boolean isCompanionObjectClass(TypeElement typeElement) {
+ return hasMetadata(typeElement)
+ && metadataFactory.create(typeElement).classMetadata().flags(IS_COMPANION_OBJECT);
+ }
+
+ /* Returns {@code true} if this type element has a Kotlin Companion Object. */
+ public boolean hasEnclosedCompanionObject(TypeElement typeElement) {
+ return hasMetadata(typeElement)
+ && metadataFactory.create(typeElement).classMetadata().companionObjectName().isPresent();
+ }
+
+ /* Returns the Companion Object element enclosed by the given type element. */
+ public TypeElement getEnclosedCompanionObject(TypeElement typeElement) {
+ return metadataFactory
+ .create(typeElement)
+ .classMetadata()
+ .companionObjectName()
+ .map(
+ companionObjectName ->
+ ElementFilter.typesIn(typeElement.getEnclosedElements()).stream()
+ .filter(
+ innerType -> innerType.getSimpleName().contentEquals(companionObjectName))
+ .collect(DaggerCollectors.onlyElement()))
+ .get();
+ }
+
+ /**
+ * Returns {@code true} if the given type element was declared <code>private</code> in its Kotlin
+ * source.
+ */
+ public boolean isVisibilityPrivate(TypeElement typeElement) {
+ return hasMetadata(typeElement)
+ && metadataFactory.create(typeElement).classMetadata().flags(IS_PRIVATE);
+ }
+
+ /**
+ * Returns {@code true} if the given executable element was declared {@code internal} in its
+ * Kotlin source.
+ */
+ public boolean isVisibilityInternal(ExecutableElement method) {
+ return hasMetadata(method)
+ && metadataFactory.create(method).getFunctionMetadata(method).flags(Flag.IS_INTERNAL);
+ }
+
+ public Optional<ExecutableElement> getPropertyGetter(VariableElement fieldElement) {
+ return metadataFactory.create(fieldElement).getPropertyGetter(fieldElement);
+ }
+
+ public boolean containsConstructorWithDefaultParam(TypeElement typeElement) {
+ return hasMetadata(typeElement)
+ && metadataFactory.create(typeElement).containsConstructorWithDefaultParam();
+ }
+
+ /**
+ * Returns {@code true} if the <code>@JvmStatic</code> annotation is present in the given element.
+ */
+ public static boolean isJvmStaticPresent(ExecutableElement element) {
+ return isAnnotationPresent(element, JvmStatic.class);
+ }
+}
diff --git a/java/dagger/internal/codegen/kythe/BUILD b/java/dagger/internal/codegen/kythe/BUILD
new file mode 100644
index 0000000..9e8dea1
--- /dev/null
+++ b/java/dagger/internal/codegen/kythe/BUILD
@@ -0,0 +1,51 @@
+# Copyright (C) 2017 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# A library for the kythe plugin.
+
+load("@rules_java//java:defs.bzl", "java_library")
+
+package(default_visibility = ["//:src"])
+
+java_library(
+ name = "kythe",
+ srcs = glob(["*.java"]),
+ plugins = ["//java/dagger/internal/codegen:component-codegen"],
+ deps = [
+ ":kythe_plugin",
+ "//java/dagger:core",
+ "//java/dagger/internal/codegen/binding",
+ "//java/dagger/internal/codegen/javac",
+ "//java/dagger/internal/codegen/langmodel",
+ "//java/dagger/internal/codegen/validation",
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/producers",
+ "//java/dagger/spi",
+ "@google_bazel_common//third_party/java/auto:service",
+ "@maven//:com_google_auto_auto_common",
+ ],
+)
+
+load("@rules_java//java:defs.bzl", "java_import")
+
+# A _deploy.jar consisting of the java_librarys in https://github.com/kythe/kythe needed to build a
+# Kythe plugin
+# TODO(ronshapiro): replace this with a http_archive of the next release in
+# https://github.com/kythe/kythe/releases
+java_import(
+ name = "kythe_plugin",
+ jars = ["kythe_plugin_deploy.jar"],
+ neverlink = 1,
+)
diff --git a/java/dagger/internal/codegen/kythe/DaggerKythePlugin.java b/java/dagger/internal/codegen/kythe/DaggerKythePlugin.java
new file mode 100644
index 0000000..4c6f85e
--- /dev/null
+++ b/java/dagger/internal/codegen/kythe/DaggerKythePlugin.java
@@ -0,0 +1,197 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// This must be in the dagger.internal.codegen package since Dagger doesn't expose its APIs publicly
+// https://github.com/google/dagger/issues/773 could present an opportunity to put this somewhere in
+// the regular kythe/java tree.
+package dagger.internal.codegen.kythe;
+
+import static dagger.internal.codegen.langmodel.DaggerElements.isAnyAnnotationPresent;
+
+import com.google.auto.service.AutoService;
+import com.google.common.collect.Iterables;
+import com.google.devtools.kythe.analyzers.base.EntrySet;
+import com.google.devtools.kythe.analyzers.base.FactEmitter;
+import com.google.devtools.kythe.analyzers.base.KytheEntrySets;
+import com.google.devtools.kythe.analyzers.java.Plugin;
+import com.google.devtools.kythe.proto.Storage.VName;
+import com.sun.tools.javac.code.Symbol;
+import com.sun.tools.javac.tree.JCTree.JCClassDecl;
+import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;
+import com.sun.tools.javac.util.Context;
+import dagger.BindsInstance;
+import dagger.Component;
+import dagger.internal.codegen.binding.Binding;
+import dagger.internal.codegen.binding.BindingDeclaration;
+import dagger.internal.codegen.binding.BindingGraphFactory;
+import dagger.internal.codegen.binding.BindingNode;
+import dagger.internal.codegen.binding.ComponentDescriptorFactory;
+import dagger.internal.codegen.binding.ModuleDescriptor;
+import dagger.internal.codegen.javac.JavacPluginModule;
+import dagger.internal.codegen.validation.InjectBindingRegistryModule;
+import dagger.model.BindingGraph;
+import dagger.model.BindingGraph.DependencyEdge;
+import dagger.model.BindingGraph.Edge;
+import dagger.model.BindingGraph.Node;
+import dagger.model.DependencyRequest;
+import dagger.producers.ProductionComponent;
+import java.util.Optional;
+import java.util.logging.Logger;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import javax.lang.model.element.Element;
+
+/**
+ * A plugin which emits nodes and edges for <a href="https://github.com/google/dagger">Dagger</a>
+ * specific code.
+ */
+@AutoService(Plugin.class)
+public class DaggerKythePlugin extends Plugin.Scanner<Void, Void> {
+ // TODO(ronshapiro): use flogger
+ private static final Logger logger = Logger.getLogger(DaggerKythePlugin.class.getCanonicalName());
+ private FactEmitter emitter;
+ @Inject ComponentDescriptorFactory componentDescriptorFactory;
+ @Inject BindingGraphFactory bindingGraphFactory;
+
+ @Override
+ public Void visitClassDef(JCClassDecl tree, Void p) {
+ if (tree.sym != null
+ && isAnyAnnotationPresent(tree.sym, Component.class, ProductionComponent.class)) {
+ addNodesForGraph(
+ bindingGraphFactory.create(
+ componentDescriptorFactory.rootComponentDescriptor(tree.sym), false));
+ }
+ return super.visitClassDef(tree, p);
+ }
+
+ private void addNodesForGraph(dagger.internal.codegen.binding.BindingGraph graph) {
+ addDependencyEdges(graph.topLevelBindingGraph());
+
+ // TODO(bcorso): Convert these to use the new BindingGraph
+ addModuleEdges(graph);
+ addChildComponentEdges(graph);
+ }
+
+ private void addDependencyEdges(BindingGraph graph) {
+ for (DependencyEdge dependencyEdge : graph.dependencyEdges()) {
+ DependencyRequest dependency = dependencyEdge.dependencyRequest();
+ Node node = graph.network().incidentNodes(dependencyEdge).target();
+ addEdgesForDependencyRequest(dependency, (BindingNode) node, graph);
+ }
+ }
+
+ /**
+ * Add {@code /inject/satisfiedby} edges from {@code dependency}'s {@link
+ * DependencyRequest#requestElement()} to any {@link BindingDeclaration#bindingElement() binding
+ * elements} that satisfy the request.
+ *
+ * <p>This collapses requests for synthetic bindings so that a request for a multibound key
+ * points to all of the contributions for the multibound object. It does so by recursively calling
+ * this method, with each dependency's key as the {@code targetKey}.
+ */
+ private void addEdgesForDependencyRequest(
+ DependencyRequest dependency, BindingNode bindingNode, BindingGraph graph) {
+ if (!dependency.requestElement().isPresent()) {
+ return;
+ }
+ Binding binding = bindingNode.delegate();
+ if (binding.bindingElement().isPresent()) {
+ addDependencyEdge(dependency, binding);
+ } else {
+ for (Edge outEdge : graph.network().outEdges(bindingNode)) {
+ if (outEdge instanceof DependencyEdge) {
+ Node outNode = graph.network().incidentNodes(outEdge).target();
+ addEdgesForDependencyRequest(dependency, (BindingNode) outNode, graph);
+ }
+ }
+ }
+ for (BindingDeclaration bindingDeclaration :
+ Iterables.concat(
+ bindingNode.multibindingDeclarations(),
+ bindingNode.optionalBindingDeclarations())) {
+ addDependencyEdge(dependency, bindingDeclaration);
+ }
+ }
+
+ private void addDependencyEdge(
+ DependencyRequest dependency, BindingDeclaration bindingDeclaration) {
+ Element requestElement = dependency.requestElement().get();
+ Element bindingElement = bindingDeclaration.bindingElement().get();
+ Optional<VName> requestElementNode = jvmNode(requestElement, "request element");
+ Optional<VName> bindingElementNode = jvmNode(bindingElement, "binding element");
+ emitEdge(requestElementNode, "/inject/satisfiedby", bindingElementNode);
+ // TODO(ronshapiro): emit facts about the component that satisfies the edge
+ }
+
+ private void addModuleEdges(dagger.internal.codegen.binding.BindingGraph graph) {
+ Optional<VName> componentNode = jvmNode(graph.componentTypeElement(), "component");
+ for (ModuleDescriptor module : graph.componentDescriptor().modules()) {
+ Optional<VName> moduleNode = jvmNode(module.moduleElement(), "module");
+ emitEdge(componentNode, "/inject/installsmodule", moduleNode);
+ }
+ graph.subgraphs().forEach(this::addModuleEdges);
+ }
+
+ private void addChildComponentEdges(dagger.internal.codegen.binding.BindingGraph graph) {
+ Optional<VName> componentNode = jvmNode(graph.componentTypeElement(), "component");
+ for (dagger.internal.codegen.binding.BindingGraph subgraph : graph.subgraphs()) {
+ Optional<VName> subcomponentNode =
+ jvmNode(subgraph.componentTypeElement(), "child component");
+ emitEdge(componentNode, "/inject/childcomponent", subcomponentNode);
+ }
+ graph.subgraphs().forEach(this::addChildComponentEdges);
+ }
+
+ private Optional<VName> jvmNode(Element element, String name) {
+ Optional<VName> jvmNode = kytheGraph.getJvmNode((Symbol) element).map(KytheNode::getVName);
+ if (!jvmNode.isPresent()) {
+ logger.warning(String.format("Missing JVM node for %s: %s", name, element));
+ }
+ return jvmNode;
+ }
+
+ private void emitEdge(Optional<VName> source, String edgeName, Optional<VName> target) {
+ source.ifPresent(
+ s -> target.ifPresent(t -> new EntrySet.Builder(s, edgeName, t).build().emit(emitter)));
+ }
+
+ @Override
+ public void run(
+ JCCompilationUnit compilationUnit, KytheEntrySets entrySets, KytheGraph kytheGraph) {
+ if (bindingGraphFactory == null) {
+ emitter = entrySets.getEmitter();
+ DaggerDaggerKythePlugin_PluginComponent.builder()
+ .context(kytheGraph.getJavaContext())
+ .build()
+ .inject(this);
+ }
+ super.run(compilationUnit, entrySets, kytheGraph);
+ }
+
+ @Singleton
+ @Component(modules = {InjectBindingRegistryModule.class, JavacPluginModule.class})
+ interface PluginComponent {
+ void inject(DaggerKythePlugin plugin);
+
+ @Component.Builder
+ interface Builder {
+ @BindsInstance
+ Builder context(Context context);
+
+ PluginComponent build();
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/kythe_plugin_deploy.jar b/java/dagger/internal/codegen/kythe/kythe_plugin_deploy.jar
similarity index 100%
rename from java/dagger/internal/codegen/kythe_plugin_deploy.jar
rename to java/dagger/internal/codegen/kythe/kythe_plugin_deploy.jar
Binary files differ
diff --git a/java/dagger/internal/codegen/langmodel/BUILD b/java/dagger/internal/codegen/langmodel/BUILD
index 16fa5d8..670f4aa 100644
--- a/java/dagger/internal/codegen/langmodel/BUILD
+++ b/java/dagger/internal/codegen/langmodel/BUILD
@@ -15,17 +15,22 @@
# Description:
# Dagger-specific extensions to the javax.lang.model APIs
+load("@rules_java//java:defs.bzl", "java_library")
+
package(default_visibility = ["//:src"])
java_library(
name = "langmodel",
srcs = glob(["*.java"]),
- plugins = ["//java/dagger/internal/codegen:bootstrap_compiler_plugin"],
+ plugins = ["//java/dagger/internal/codegen/bootstrap"],
tags = ["maven:merged"],
deps = [
"//java/dagger:core",
- "@google_bazel_common//third_party/java/auto:common",
- "@google_bazel_common//third_party/java/guava",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/internal/guava:concurrent",
+ "//java/dagger/internal/guava:graph",
"@google_bazel_common//third_party/java/javapoet",
+ "@maven//:com_google_auto_auto_common",
],
)
diff --git a/java/dagger/internal/codegen/langmodel/DaggerElements.java b/java/dagger/internal/codegen/langmodel/DaggerElements.java
index 873ad3d..12cec31 100644
--- a/java/dagger/internal/codegen/langmodel/DaggerElements.java
+++ b/java/dagger/internal/codegen/langmodel/DaggerElements.java
@@ -28,6 +28,7 @@
import com.google.auto.common.MoreElements;
import com.google.auto.common.MoreTypes;
import com.google.common.collect.FluentIterable;
+import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import com.google.common.graph.Traverser;
@@ -42,6 +43,7 @@
import java.util.Optional;
import java.util.Set;
import java.util.function.Predicate;
+import java.util.stream.Collectors;
import javax.annotation.processing.ProcessingEnvironment;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.element.AnnotationValue;
@@ -51,8 +53,22 @@
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.Name;
import javax.lang.model.element.PackageElement;
+import javax.lang.model.element.QualifiedNameable;
import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.ArrayType;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.ErrorType;
+import javax.lang.model.type.ExecutableType;
+import javax.lang.model.type.IntersectionType;
+import javax.lang.model.type.NoType;
+import javax.lang.model.type.NullType;
+import javax.lang.model.type.PrimitiveType;
import javax.lang.model.type.TypeMirror;
+import javax.lang.model.type.TypeVariable;
+import javax.lang.model.type.UnionType;
+import javax.lang.model.type.WildcardType;
+import javax.lang.model.util.AbstractTypeVisitor8;
import javax.lang.model.util.Elements;
import javax.lang.model.util.SimpleElementVisitor8;
import javax.lang.model.util.Types;
@@ -231,6 +247,161 @@
}
/**
+ * Returns the field descriptor of the given {@code element}.
+ *
+ * <p>This is useful for matching Kotlin Metadata JVM Signatures with elements from the AST.
+ *
+ * <p>For reference, see the <a
+ * href="https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.3.2">JVM
+ * specification, section 4.3.2</a>.
+ */
+ public static String getFieldDescriptor(VariableElement element) {
+ return element.getSimpleName() + ":" + getDescriptor(element.asType());
+ }
+
+ /**
+ * Returns the method descriptor of the given {@code element}.
+ *
+ * <p>This is useful for matching Kotlin Metadata JVM Signatures with elements from the AST.
+ *
+ * <p>For reference, see the <a
+ * href="https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.3.3">JVM
+ * specification, section 4.3.3</a>.
+ */
+ public static String getMethodDescriptor(ExecutableElement element) {
+ return element.getSimpleName() + getDescriptor(element.asType());
+ }
+
+ private static String getDescriptor(TypeMirror t) {
+ return t.accept(JVM_DESCRIPTOR_TYPE_VISITOR, null);
+ }
+
+ private static final AbstractTypeVisitor8<String, Void> JVM_DESCRIPTOR_TYPE_VISITOR =
+ new AbstractTypeVisitor8<String, Void>() {
+
+ @Override
+ public String visitArray(ArrayType arrayType, Void v) {
+ return "[" + getDescriptor(arrayType.getComponentType());
+ }
+
+ @Override
+ public String visitDeclared(DeclaredType declaredType, Void v) {
+ return "L" + getInternalName(declaredType.asElement()) + ";";
+ }
+
+ @Override
+ public String visitError(ErrorType errorType, Void v) {
+ // For descriptor generating purposes we don't need a fully modeled type since we are
+ // only interested in obtaining the class name in its "internal form".
+ return visitDeclared(errorType, v);
+ }
+
+ @Override
+ public String visitExecutable(ExecutableType executableType, Void v) {
+ String parameterDescriptors =
+ executableType.getParameterTypes().stream()
+ .map(DaggerElements::getDescriptor)
+ .collect(Collectors.joining());
+ String returnDescriptor = getDescriptor(executableType.getReturnType());
+ return "(" + parameterDescriptors + ")" + returnDescriptor;
+ }
+
+ @Override
+ public String visitIntersection(IntersectionType intersectionType, Void v) {
+ // For a type variable with multiple bounds: "the erasure of a type variable is determined
+ // by the first type in its bound" - JVM Spec Sec 4.4
+ return getDescriptor(intersectionType.getBounds().get(0));
+ }
+
+ @Override
+ public String visitNoType(NoType noType, Void v) {
+ return "V";
+ }
+
+ @Override
+ public String visitNull(NullType nullType, Void v) {
+ return visitUnknown(nullType, null);
+ }
+
+ @Override
+ public String visitPrimitive(PrimitiveType primitiveType, Void v) {
+ switch (primitiveType.getKind()) {
+ case BOOLEAN:
+ return "Z";
+ case BYTE:
+ return "B";
+ case SHORT:
+ return "S";
+ case INT:
+ return "I";
+ case LONG:
+ return "J";
+ case CHAR:
+ return "C";
+ case FLOAT:
+ return "F";
+ case DOUBLE:
+ return "D";
+ default:
+ throw new IllegalArgumentException("Unknown primitive type.");
+ }
+ }
+
+ @Override
+ public String visitTypeVariable(TypeVariable typeVariable, Void v) {
+ // The erasure of a type variable is the erasure of its leftmost bound. - JVM Spec Sec 4.6
+ return getDescriptor(typeVariable.getUpperBound());
+ }
+
+ @Override
+ public String visitUnion(UnionType unionType, Void v) {
+ return visitUnknown(unionType, null);
+ }
+
+ @Override
+ public String visitUnknown(TypeMirror typeMirror, Void v) {
+ throw new IllegalArgumentException("Unsupported type: " + typeMirror);
+ }
+
+ @Override
+ public String visitWildcard(WildcardType wildcardType, Void v) {
+ return "";
+ }
+
+ /**
+ * Returns the name of this element in its "internal form".
+ *
+ * <p>For reference, see the <a
+ * href="https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.2">JVM
+ * specification, section 4.2</a>.
+ */
+ private String getInternalName(Element element) {
+ try {
+ TypeElement typeElement = MoreElements.asType(element);
+ switch (typeElement.getNestingKind()) {
+ case TOP_LEVEL:
+ return typeElement.getQualifiedName().toString().replace('.', '/');
+ case MEMBER:
+ return getInternalName(typeElement.getEnclosingElement())
+ + "$"
+ + typeElement.getSimpleName();
+ default:
+ throw new IllegalArgumentException("Unsupported nesting kind.");
+ }
+ } catch (IllegalArgumentException e) {
+ // Not a TypeElement, try something else...
+ }
+
+ if (element instanceof QualifiedNameable) {
+ QualifiedNameable qualifiedNameElement = (QualifiedNameable) element;
+ return qualifiedNameElement.getQualifiedName().toString().replace('.', '/');
+ }
+
+ return element.getSimpleName().toString();
+ }
+ };
+
+ /**
* Invokes {@link Elements#getTypeElement(CharSequence)}, throwing {@link TypeNotPresentException}
* if it is not accessible in the current compilation.
*/
@@ -253,6 +424,14 @@
return elements.getElementValuesWithDefaults(a);
}
+ /** Returns a map of annotation values keyed by attribute name. */
+ public Map<String, ? extends AnnotationValue> getElementValuesWithDefaultsByName(
+ AnnotationMirror a) {
+ ImmutableMap.Builder<String, AnnotationValue> builder = ImmutableMap.builder();
+ getElementValuesWithDefaults(a).forEach((k, v) -> builder.put(k.getSimpleName().toString(), v));
+ return builder.build();
+ }
+
@Override
public String getDocComment(Element e) {
return elements.getDocComment(e);
diff --git a/java/dagger/internal/codegen/langmodel/DaggerTypes.java b/java/dagger/internal/codegen/langmodel/DaggerTypes.java
index e588fbd..fb291db 100644
--- a/java/dagger/internal/codegen/langmodel/DaggerTypes.java
+++ b/java/dagger/internal/codegen/langmodel/DaggerTypes.java
@@ -83,7 +83,7 @@
* @throws IllegalArgumentException if {@code type} is not a declared type or has zero or more
* than one type arguments.
*/
- public TypeMirror unwrapType(TypeMirror type) {
+ public static TypeMirror unwrapType(TypeMirror type) {
TypeMirror unwrapped = unwrapTypeOrDefault(type, null);
checkArgument(unwrapped != null, "%s is a raw type", type);
return unwrapped;
@@ -101,7 +101,7 @@
return unwrapTypeOrDefault(type, elements.getTypeElement(Object.class).asType());
}
- private TypeMirror unwrapTypeOrDefault(TypeMirror type, TypeMirror defaultType) {
+ private static TypeMirror unwrapTypeOrDefault(TypeMirror type, TypeMirror defaultType) {
DeclaredType declaredType = MoreTypes.asDeclared(type);
TypeElement typeElement = MoreElements.asType(declaredType.asElement());
checkArgument(
diff --git a/java/dagger/internal/codegen/package-info.java b/java/dagger/internal/codegen/package-info.java
index c8cc404..4c478d6 100644
--- a/java/dagger/internal/codegen/package-info.java
+++ b/java/dagger/internal/codegen/package-info.java
@@ -14,6 +14,7 @@
* limitations under the License.
*/
+/** Apply {@link CheckReturnValue} by default to every method in this package. */
@CheckReturnValue
package dagger.internal.codegen;
diff --git a/java/dagger/internal/codegen/serialization/BUILD b/java/dagger/internal/codegen/serialization/BUILD
deleted file mode 100644
index 2bc02b4..0000000
--- a/java/dagger/internal/codegen/serialization/BUILD
+++ /dev/null
@@ -1,41 +0,0 @@
-# Copyright (C) 2019 The Dagger Authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# Description:
-# Serialized forms of types used in the Dagger processor.
-
-package(default_visibility = ["//:src"])
-
-proto_library(
- name = "serialization_proto",
- srcs = ["serialization.proto"],
- visibility = ["//visibility:private"],
-)
-
-java_proto_library(
- name = "serialization_java_proto",
- visibility = ["//visibility:private"],
- deps = [":serialization_proto"],
-)
-
-java_library(
- name = "serialization",
- srcs = glob(["*.java"]),
- exports = [":serialization_java_proto"],
- deps = [
- "@google_bazel_common//third_party/java/guava",
- "@google_bazel_common//third_party/java/javapoet",
- "@google_bazel_common//third_party/java/protobuf",
- ],
-)
diff --git a/java/dagger/internal/codegen/serialization/ProtoSerialization.java b/java/dagger/internal/codegen/serialization/ProtoSerialization.java
deleted file mode 100644
index 1449e9d..0000000
--- a/java/dagger/internal/codegen/serialization/ProtoSerialization.java
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * Copyright (C) 2019 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen.serialization;
-
-import static com.google.common.io.BaseEncoding.base64;
-
-import com.google.common.io.BaseEncoding;
-import com.google.protobuf.InvalidProtocolBufferException;
-import com.google.protobuf.Message;
-import com.squareup.javapoet.CodeBlock;
-import javax.lang.model.element.AnnotationValue;
-import javax.lang.model.element.AnnotationValueVisitor;
-import javax.lang.model.util.SimpleAnnotationValueVisitor8;
-
-/**
- * Serializes and deserializes {@link Message}s using {@link BaseEncoding#base64()} for use in
- * annotation values.
- */
-public final class ProtoSerialization {
- /** Returns a {@link CodeBlock} of {@code message} serialized as a String. */
- public static CodeBlock toAnnotationValue(Message message) {
- return CodeBlock.of("$S", base64().encode(message.toByteArray()));
- }
-
- /**
- * Returns a {@link Message T} from the deserialized the String {@code value}.
- *
- * @throws IllegalArgumentException if {@code value} represents an {@link AnnotationValue} who's
- * type is not {@link String}
- */
- public static <T extends Message> T fromAnnotationValue(
- AnnotationValue value, T defaultInstance) {
- byte[] bytes = base64().decode(value.accept(STRING_VALUE, null));
- Message message;
- try {
- message = defaultInstance.getParserForType().parseFrom(bytes);
- } catch (InvalidProtocolBufferException e) {
- throw new InconsistentSerializedProtoException(e);
- }
- @SuppressWarnings("unchecked") // guaranteed by proto API
- T t = (T) message;
- return t;
- }
-
- private static final AnnotationValueVisitor<String, Void> STRING_VALUE =
- new SimpleAnnotationValueVisitor8<String, Void>() {
- @Override
- public String visitString(String s, Void ignored) {
- return s;
- }
-
- @Override
- protected String defaultAction(Object o, Void ignored) {
- throw new IllegalArgumentException(o + " is not a String");
- }
- };
-
- /**
- * An exception thrown when the proto that's serialized in a compiled subcomponent implementation
- * is from a different version than the current compiler's.
- */
- public static final class InconsistentSerializedProtoException extends RuntimeException {
- InconsistentSerializedProtoException(Throwable cause) {
- super(cause);
- }
- }
-}
diff --git a/java/dagger/internal/codegen/serialization/serialization.proto b/java/dagger/internal/codegen/serialization/serialization.proto
deleted file mode 100644
index e6c9577..0000000
--- a/java/dagger/internal/codegen/serialization/serialization.proto
+++ /dev/null
@@ -1,167 +0,0 @@
-/*
- * Copyright (C) 2019 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// Serialized forms of types used in the Dagger processor. The wire format of
-// these types is not guaranteed to remain compatible over time; serialization
-// is only expected to function correctly within an individual version of the
-// Dagger processor.
-
-syntax = "proto3";
-
-package dagger.internal.codegen.serialization;
-option java_package = "dagger.internal.codegen.serialization";
-option java_multiple_files = true;
-
-// TODO(ronshapiro): consider exposing some of these in
-// dagger.model.serialization
-
-// Serialized form of `dagger.internal.codegen.BindingRequest`
-message BindingRequestProto {
- KeyProto key = 1;
- RequestKindWrapper.RequestKind request_kind = 2;
- FrameworkTypeWrapper.FrameworkType framework_type = 3;
-}
-
-message RequestKindWrapper {
- // Serialized form of `dagger.model.RequestKind`
- enum RequestKind {
- UNKNOWN = 0;
- INSTANCE = 1;
- PROVIDER = 2;
- LAZY = 3;
- PROVIDER_OF_LAZY = 4;
- MEMBERS_INJECTION = 5;
- PRODUCER = 6;
- PRODUCED = 7;
- FUTURE = 8;
- }
-}
-
-message FrameworkTypeWrapper {
- // Serialized form of `dagger.internal.codegen.FrameworkType`
- enum FrameworkType {
- UNKNOWN = 0;
- PROVIDER = 1;
- PRODUCER_NODE = 2;
- }
-}
-
-// Serialized form of `dagger.model.Key`
-message KeyProto {
- TypeProto type = 1;
- AnnotationProto qualifier = 2;
- MultibindingContributionIdentifier multibinding_contribution_identifier =
- 3;
-
- // Serialized form of `dagger.model.Key.MultibindingContributionIdentifier`
- message MultibindingContributionIdentifier {
- string module = 1;
- string binding_element = 2;
- }
-}
-
-// Serialized form of `javax.lang.model.type.TypeMirror`
-message TypeProto {
- PrimitiveKind primitive_kind = 1;
-
- // The qualified name of the type. Absent if this is an inner type.
- string qualified_name = 2;
-
- // The enclosing type if this is an inner type, otherwise absent.
- TypeProto enclosing_type = 3;
-
- // Simple name of the type if this is an inner type, otherwise absent.
- string simple_name = 4;
-
- repeated TypeProto type_arguments = 5;
-
- message Wildcard {
- TypeProto extends_bound = 1;
- TypeProto super_bound = 2;
- }
- Wildcard wildcard = 6;
-
- int32 array_dimensions = 7;
-
- // Kinds of primitive types
- enum PrimitiveKind {
- UNKNOWN = 0;
- BOOLEAN = 1;
- BYTE = 2;
- SHORT = 3;
- CHAR = 4;
- INT = 5;
- FLOAT = 6;
- LONG = 7;
- DOUBLE = 8;
- }
-}
-
-// Serialized form of `javax.lang.model.element.AnnotationMirror`
-message AnnotationProto {
- TypeProto annotation_type = 1;
- map<string, AnnotationValueProto> values = 2;
-}
-
-// Serialized form of `javax.lang.model.element.AnnotationValue`
-message AnnotationValueProto {
- Kind kind = 1;
- bool boolean_value = 2;
- int32 int_value = 3;
- int64 long_value = 4;
- float float_value = 5;
- double double_value = 6;
- string string_value = 7;
- TypeProto class_literal = 8;
- TypeProto enum_type = 9;
- string enum_name = 10;
- AnnotationProto nested_annotation = 11;
-
- repeated AnnotationValueProto array_values = 12;
-
- // The type of annotation value
- enum Kind {
- UNKNOWN = 0;
- BOOLEAN = 1;
- BYTE = 2;
- SHORT = 3;
- CHAR = 4;
- INT = 5;
- FLOAT = 6;
- LONG = 7;
- DOUBLE = 8;
- STRING = 9;
- CLASS_LITERAL = 10;
- ENUM = 11;
- ANNOTATION = 12;
- ARRAY = 13;
- }
-}
-
-// Serialized form of `dagger.internal.codegen.ComponentRequirement`
-message ComponentRequirementProto {
- oneof requirement {
- TypeProto dependency = 1;
- TypeProto module = 2;
- BoundInstanceRequirement bound_instance = 3;
- }
-
- message BoundInstanceRequirement {
- KeyProto key = 1;
- bool nullable = 2;
- string variable_name = 3;
- }
-}
diff --git a/java/dagger/internal/codegen/validation/AnyBindingMethodValidator.java b/java/dagger/internal/codegen/validation/AnyBindingMethodValidator.java
new file mode 100644
index 0000000..140afd2
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/AnyBindingMethodValidator.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static com.google.auto.common.MoreElements.isAnnotationPresent;
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static dagger.internal.codegen.base.Util.reentrantComputeIfAbsent;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static dagger.internal.codegen.langmodel.DaggerElements.isAnyAnnotationPresent;
+import static java.util.stream.Collectors.joining;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import dagger.internal.codegen.base.ClearableCache;
+import java.lang.annotation.Annotation;
+import java.util.HashMap;
+import java.util.Map;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import javax.lang.model.element.ExecutableElement;
+
+/** Validates any binding method. */
+@Singleton
+public final class AnyBindingMethodValidator implements ClearableCache {
+ private final ImmutableMap<Class<? extends Annotation>, BindingMethodValidator> validators;
+ private final Map<ExecutableElement, ValidationReport<ExecutableElement>> reports =
+ new HashMap<>();
+
+ @Inject
+ AnyBindingMethodValidator(
+ ImmutableMap<Class<? extends Annotation>, BindingMethodValidator> validators) {
+ this.validators = validators;
+ }
+
+ @Override
+ public void clearCache() {
+ reports.clear();
+ }
+
+ /** Returns the binding method annotations considered by this validator. */
+ ImmutableSet<Class<? extends Annotation>> methodAnnotations() {
+ return validators.keySet();
+ }
+
+ /**
+ * Returns {@code true} if {@code method} is annotated with at least one of {@link
+ * #methodAnnotations()}.
+ */
+ boolean isBindingMethod(ExecutableElement method) {
+ return isAnyAnnotationPresent(method, methodAnnotations());
+ }
+
+ /**
+ * Returns a validation report for a method.
+ *
+ * <ul>
+ * <li>Reports an error if {@code method} is annotated with more than one {@linkplain
+ * #methodAnnotations() binding method annotation}.
+ * <li>Validates {@code method} with the {@link BindingMethodValidator} for the single
+ * {@linkplain #methodAnnotations() binding method annotation}.
+ * </ul>
+ *
+ * @throws IllegalArgumentException if {@code method} is not annotated by any {@linkplain
+ * #methodAnnotations() binding method annotation}
+ */
+ ValidationReport<ExecutableElement> validate(ExecutableElement method) {
+ return reentrantComputeIfAbsent(reports, method, this::validateUncached);
+ }
+
+ /**
+ * Returns {@code true} if {@code method} was already {@linkplain #validate(ExecutableElement)
+ * validated}.
+ */
+ boolean wasAlreadyValidated(ExecutableElement method) {
+ return reports.containsKey(method);
+ }
+
+ private ValidationReport<ExecutableElement> validateUncached(ExecutableElement method) {
+ ValidationReport.Builder<ExecutableElement> report = ValidationReport.about(method);
+ ImmutableSet<? extends Class<? extends Annotation>> bindingMethodAnnotations =
+ methodAnnotations()
+ .stream()
+ .filter(annotation -> isAnnotationPresent(method, annotation))
+ .collect(toImmutableSet());
+ switch (bindingMethodAnnotations.size()) {
+ case 0:
+ throw new IllegalArgumentException(
+ String.format("%s has no binding method annotation", method));
+
+ case 1:
+ report.addSubreport(
+ validators.get(getOnlyElement(bindingMethodAnnotations)).validate(method));
+ break;
+
+ default:
+ report.addError(
+ String.format(
+ "%s is annotated with more than one of (%s)",
+ method.getSimpleName(),
+ methodAnnotations().stream().map(Class::getCanonicalName).collect(joining(", "))),
+ method);
+ break;
+ }
+ return report.build();
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/BUILD b/java/dagger/internal/codegen/validation/BUILD
new file mode 100644
index 0000000..602157b
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/BUILD
@@ -0,0 +1,50 @@
+# Copyright (C) 2019 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Code related to validating the user-written Dagger code
+
+load("@rules_java//java:defs.bzl", "java_library")
+
+package(default_visibility = ["//:src"])
+
+java_library(
+ name = "validation",
+ srcs = glob(["*.java"]),
+ plugins = ["//java/dagger/internal/codegen/bootstrap"],
+ tags = ["maven:merged"],
+ deps = [
+ "//java/dagger:core",
+ "//java/dagger/internal/codegen/base",
+ "//java/dagger/internal/codegen/binding",
+ "//java/dagger/internal/codegen/compileroption",
+ "//java/dagger/internal/codegen/extension",
+ "//java/dagger/internal/codegen/javapoet",
+ "//java/dagger/internal/codegen/kotlin",
+ "//java/dagger/internal/codegen/langmodel",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:cache",
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/internal/guava:concurrent",
+ "//java/dagger/internal/guava:graph",
+ "//java/dagger/producers",
+ "//java/dagger/spi",
+ "@google_bazel_common//third_party/java/auto:value",
+ "@google_bazel_common//third_party/java/checker_framework_annotations",
+ "@google_bazel_common//third_party/java/error_prone:annotations",
+ "@google_bazel_common//third_party/java/javapoet",
+ "@google_bazel_common//third_party/java/jsr330_inject",
+ "@maven//:com_google_auto_auto_common",
+ ],
+)
diff --git a/java/dagger/internal/codegen/validation/BindingElementValidator.java b/java/dagger/internal/codegen/validation/BindingElementValidator.java
new file mode 100644
index 0000000..4557745
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/BindingElementValidator.java
@@ -0,0 +1,408 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static com.google.auto.common.MoreTypes.asTypeElement;
+import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.base.Verify.verifyNotNull;
+import static dagger.internal.codegen.base.Scopes.scopesOf;
+import static dagger.internal.codegen.base.Util.reentrantComputeIfAbsent;
+import static dagger.internal.codegen.binding.AssistedInjectionAnnotations.isAssistedFactoryType;
+import static dagger.internal.codegen.binding.AssistedInjectionAnnotations.isAssistedInjectionType;
+import static dagger.internal.codegen.binding.MapKeys.getMapKeys;
+import static dagger.internal.codegen.langmodel.DaggerElements.getAnnotationMirror;
+import static javax.lang.model.type.TypeKind.ARRAY;
+import static javax.lang.model.type.TypeKind.DECLARED;
+import static javax.lang.model.type.TypeKind.TYPEVAR;
+import static javax.lang.model.type.TypeKind.VOID;
+
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableSet;
+import com.google.errorprone.annotations.FormatMethod;
+import dagger.MapKey;
+import dagger.Provides;
+import dagger.internal.codegen.base.ContributionType;
+import dagger.internal.codegen.base.FrameworkTypes;
+import dagger.internal.codegen.base.MultibindingAnnotations;
+import dagger.internal.codegen.base.SetType;
+import dagger.internal.codegen.binding.InjectionAnnotations;
+import dagger.model.Key;
+import dagger.model.Scope;
+import dagger.multibindings.ElementsIntoSet;
+import dagger.multibindings.IntoMap;
+import dagger.producers.Produces;
+import java.lang.annotation.Annotation;
+import java.util.Formatter;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import javax.inject.Qualifier;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeMirror;
+
+/** A validator for elements that represent binding declarations. */
+public abstract class BindingElementValidator<E extends Element> {
+ private final Class<? extends Annotation> bindingAnnotation;
+ private final AllowsMultibindings allowsMultibindings;
+ private final AllowsScoping allowsScoping;
+ private final Map<E, ValidationReport<E>> cache = new HashMap<>();
+ private final InjectionAnnotations injectionAnnotations;
+
+ /**
+ * Creates a validator object.
+ *
+ * @param bindingAnnotation the annotation on an element that identifies it as a binding element
+ */
+ protected BindingElementValidator(
+ Class<? extends Annotation> bindingAnnotation,
+ AllowsMultibindings allowsMultibindings,
+ AllowsScoping allowsScoping,
+ InjectionAnnotations injectionAnnotations) {
+ this.bindingAnnotation = bindingAnnotation;
+ this.allowsMultibindings = allowsMultibindings;
+ this.allowsScoping = allowsScoping;
+ this.injectionAnnotations = injectionAnnotations;
+ }
+
+ /** Returns a {@link ValidationReport} for {@code element}. */
+ final ValidationReport<E> validate(E element) {
+ return reentrantComputeIfAbsent(cache, element, this::validateUncached);
+ }
+
+ private ValidationReport<E> validateUncached(E element) {
+ return elementValidator(element).validate();
+ }
+
+ /**
+ * Returns an error message of the form "<{@link #bindingElements()}> <i>rule</i>", where
+ * <i>rule</i> comes from calling {@link String#format(String, Object...)} on {@code ruleFormat}
+ * and the other arguments.
+ */
+ @FormatMethod
+ protected final String bindingElements(String ruleFormat, Object... args) {
+ return new Formatter().format("%s ", bindingElements()).format(ruleFormat, args).toString();
+ }
+
+ /**
+ * The kind of elements that this validator validates. Should be plural. Used for error reporting.
+ */
+ protected abstract String bindingElements();
+
+ /** The verb describing the {@link ElementValidator#bindingElementType()} in error messages. */
+ // TODO(ronshapiro,dpb): improve the name of this method and it's documentation.
+ protected abstract String bindingElementTypeVerb();
+
+ /** The error message when a binding element has a bad type. */
+ protected String badTypeMessage() {
+ return bindingElements(
+ "must %s a primitive, an array, a type variable, or a declared type",
+ bindingElementTypeVerb());
+ }
+
+ /**
+ * The error message when a the type for a binding element with {@link
+ * ElementsIntoSet @ElementsIntoSet} or {@code SET_VALUES} is a not set type.
+ */
+ protected String elementsIntoSetNotASetMessage() {
+ return bindingElements(
+ "annotated with @ElementsIntoSet must %s a Set", bindingElementTypeVerb());
+ }
+
+ /**
+ * The error message when a the type for a binding element with {@link
+ * ElementsIntoSet @ElementsIntoSet} or {@code SET_VALUES} is a raw set.
+ */
+ protected String elementsIntoSetRawSetMessage() {
+ return bindingElements(
+ "annotated with @ElementsIntoSet cannot %s a raw Set", bindingElementTypeVerb());
+ }
+
+ /*** Returns an {@link ElementValidator} for validating the given {@code element}. */
+ protected abstract ElementValidator elementValidator(E element);
+
+ /** Validator for a single binding element. */
+ protected abstract class ElementValidator {
+ protected final E element;
+ protected final ValidationReport.Builder<E> report;
+
+ protected ElementValidator(E element) {
+ this.element = element;
+ this.report = ValidationReport.about(element);
+ }
+
+ /** Checks the element for validity. */
+ private ValidationReport<E> validate() {
+ checkType();
+ checkQualifiers();
+ checkMapKeys();
+ checkMultibindings();
+ checkScopes();
+ checkAdditionalProperties();
+ return report.build();
+ }
+
+ /** Check any additional properties of the element. Does nothing by default. */
+ protected void checkAdditionalProperties() {}
+
+ /**
+ * The type declared by this binding element. This may differ from a binding's {@link
+ * Key#type()}, for example in multibindings. An {@link Optional#empty()} return value indicates
+ * that the contributed type is ambiguous or missing, i.e. a {@code @BindsInstance} method with
+ * zero or many parameters.
+ */
+ // TODO(dpb): should this be an ImmutableList<TypeMirror>, with this class checking the size?
+ protected abstract Optional<TypeMirror> bindingElementType();
+
+ /**
+ * Adds an error if the {@link #bindingElementType() binding element type} is not appropriate.
+ *
+ * <p>Adds an error if the type is not a primitive, array, declared type, or type variable.
+ *
+ * <p>If the binding is not a multibinding contribution, adds an error if the type is a
+ * framework type.
+ *
+ * <p>If the element has {@link ElementsIntoSet @ElementsIntoSet} or {@code SET_VALUES}, adds an
+ * error if the type is not a {@code Set<T>} for some {@code T}
+ */
+ protected void checkType() {
+ switch (ContributionType.fromBindingElement(element)) {
+ case UNIQUE:
+ /* Validate that a unique binding is not attempting to bind a framework type. This
+ * validation is only appropriate for unique bindings because multibindings may collect
+ * framework types. E.g. Set<Provider<Foo>> is perfectly reasonable. */
+ checkFrameworkType();
+ // fall through
+
+ case SET:
+ case MAP:
+ bindingElementType().ifPresent(type -> checkKeyType(type));
+ break;
+
+ case SET_VALUES:
+ checkSetValuesType();
+ }
+ }
+
+ /**
+ * Adds an error if {@code keyType} is not a primitive, declared type, array, or type variable.
+ */
+ protected void checkKeyType(TypeMirror keyType) {
+ TypeKind kind = keyType.getKind();
+ if (kind.equals(VOID)) {
+ report.addError(bindingElements("must %s a value (not void)", bindingElementTypeVerb()));
+ } else if (kind == DECLARED) {
+ checkNotAssistedInject(keyType);
+ } else if (!(kind.isPrimitive() || kind.equals(ARRAY) || kind.equals(TYPEVAR))) {
+ report.addError(badTypeMessage());
+ }
+ }
+
+ /** Adds errors for a method return type. */
+ private void checkNotAssistedInject(TypeMirror keyType) {
+ checkState(keyType.getKind() == TypeKind.DECLARED);
+ TypeElement keyElement = asTypeElement(keyType);
+ if (isAssistedInjectionType(keyElement)) {
+ report.addError("Dagger does not support providing @AssistedInject types.", keyElement);
+ }
+ if (isAssistedFactoryType(keyElement)) {
+ report.addError("Dagger does not support providing @AssistedFactory types.", keyElement);
+ }
+ }
+
+ /**
+ * Adds an error if the type for an element with {@link ElementsIntoSet @ElementsIntoSet} or
+ * {@code SET_VALUES} is not a a {@code Set<T>} for a reasonable {@code T}.
+ */
+ // TODO(gak): should we allow "covariant return" for set values?
+ protected void checkSetValuesType() {
+ bindingElementType().ifPresent(keyType -> checkSetValuesType(keyType));
+ }
+
+ /** Adds an error if {@code type} is not a {@code Set<T>} for a reasonable {@code T}. */
+ protected final void checkSetValuesType(TypeMirror type) {
+ if (!SetType.isSet(type)) {
+ report.addError(elementsIntoSetNotASetMessage());
+ } else {
+ SetType setType = SetType.from(type);
+ if (setType.isRawType()) {
+ report.addError(elementsIntoSetRawSetMessage());
+ } else {
+ checkKeyType(setType.elementType());
+ }
+ }
+ }
+
+ /**
+ * Adds an error if the element has more than one {@linkplain Qualifier qualifier} annotation.
+ */
+ private void checkQualifiers() {
+ ImmutableCollection<? extends AnnotationMirror> qualifiers =
+ injectionAnnotations.getQualifiers(element);
+ if (qualifiers.size() > 1) {
+ for (AnnotationMirror qualifier : qualifiers) {
+ report.addError(
+ bindingElements("may not use more than one @Qualifier"),
+ element,
+ qualifier);
+ }
+ }
+ }
+
+ /**
+ * Adds an error if an {@link IntoMap @IntoMap} element doesn't have exactly one {@link
+ * MapKey @MapKey} annotation, or if an element that is {@link IntoMap @IntoMap} has any.
+ */
+ private void checkMapKeys() {
+ if (!allowsMultibindings.allowsMultibindings()) {
+ return;
+ }
+ ImmutableSet<? extends AnnotationMirror> mapKeys = getMapKeys(element);
+ if (ContributionType.fromBindingElement(element).equals(ContributionType.MAP)) {
+ switch (mapKeys.size()) {
+ case 0:
+ report.addError(bindingElements("of type map must declare a map key"));
+ break;
+ case 1:
+ break;
+ default:
+ report.addError(bindingElements("may not have more than one map key"));
+ break;
+ }
+ } else if (!mapKeys.isEmpty()) {
+ report.addError(bindingElements("of non map type cannot declare a map key"));
+ }
+ }
+
+ /**
+ * Adds errors if:
+ *
+ * <ul>
+ * <li>the element doesn't allow {@linkplain MultibindingAnnotations multibinding annotations}
+ * and has any
+ * <li>the element does allow them but has more than one
+ * <li>the element has a multibinding annotation and its {@link Provides} or {@link Produces}
+ * annotation has a {@code type} parameter.
+ * </ul>
+ */
+ private void checkMultibindings() {
+ ImmutableSet<AnnotationMirror> multibindingAnnotations =
+ MultibindingAnnotations.forElement(element);
+
+ switch (allowsMultibindings) {
+ case NO_MULTIBINDINGS:
+ for (AnnotationMirror annotation : multibindingAnnotations) {
+ report.addError(
+ bindingElements("cannot have multibinding annotations"),
+ element,
+ annotation);
+ }
+ break;
+
+ case ALLOWS_MULTIBINDINGS:
+ if (multibindingAnnotations.size() > 1) {
+ for (AnnotationMirror annotation : multibindingAnnotations) {
+ report.addError(
+ bindingElements("cannot have more than one multibinding annotation"),
+ element,
+ annotation);
+ }
+ }
+ break;
+ }
+
+ // TODO(ronshapiro): move this into ProvidesMethodValidator
+ if (bindingAnnotation.equals(Provides.class)) {
+ AnnotationMirror bindingAnnotationMirror =
+ getAnnotationMirror(element, bindingAnnotation).get();
+ boolean usesProvidesType = false;
+ for (ExecutableElement member : bindingAnnotationMirror.getElementValues().keySet()) {
+ usesProvidesType |= member.getSimpleName().contentEquals("type");
+ }
+ if (usesProvidesType && !multibindingAnnotations.isEmpty()) {
+ report.addError(
+ "@Provides.type cannot be used with multibinding annotations", element);
+ }
+ }
+ }
+
+ /**
+ * Adds an error if the element has a scope but doesn't allow scoping, or if it has more than
+ * one {@linkplain Scope scope} annotation.
+ */
+ private void checkScopes() {
+ ImmutableSet<Scope> scopes = scopesOf(element);
+ String error = null;
+ switch (allowsScoping) {
+ case ALLOWS_SCOPING:
+ if (scopes.size() <= 1) {
+ return;
+ }
+ error = bindingElements("cannot use more than one @Scope");
+ break;
+ case NO_SCOPING:
+ error = bindingElements("cannot be scoped");
+ break;
+ }
+ verifyNotNull(error);
+ for (Scope scope : scopes) {
+ report.addError(error, element, scope.scopeAnnotation());
+ }
+ }
+
+ /**
+ * Adds an error if the {@link #bindingElementType() type} is a {@linkplain FrameworkTypes
+ * framework type}.
+ */
+ private void checkFrameworkType() {
+ if (bindingElementType().filter(FrameworkTypes::isFrameworkType).isPresent()) {
+ report.addError(bindingElements("must not %s framework types", bindingElementTypeVerb()));
+ }
+ }
+ }
+
+ /** Whether to check multibinding annotations. */
+ enum AllowsMultibindings {
+ /**
+ * This element disallows multibinding annotations, so don't bother checking for their validity.
+ * {@link MultibindingAnnotationsProcessingStep} will add errors if the element has any
+ * multibinding annotations.
+ */
+ NO_MULTIBINDINGS,
+
+ /** This element allows multibinding annotations, so validate them. */
+ ALLOWS_MULTIBINDINGS,
+ ;
+
+ private boolean allowsMultibindings() {
+ return this == ALLOWS_MULTIBINDINGS;
+ }
+ }
+
+ /** How to check scoping annotations. */
+ enum AllowsScoping {
+ /** This element disallows scoping, so check that no scope annotations are present. */
+ NO_SCOPING,
+
+ /** This element allows scoping, so validate that there's at most one scope annotation. */
+ ALLOWS_SCOPING,
+ ;
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/BindingGraphPlugins.java b/java/dagger/internal/codegen/validation/BindingGraphPlugins.java
new file mode 100644
index 0000000..16ef78f
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/BindingGraphPlugins.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import dagger.internal.codegen.compileroption.ProcessingOptions;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.spi.BindingGraphPlugin;
+import java.util.Map;
+import java.util.Set;
+import javax.annotation.processing.Filer;
+import javax.inject.Inject;
+
+/** Initializes {@link BindingGraphPlugin}s. */
+public final class BindingGraphPlugins {
+ private final ImmutableSet<BindingGraphPlugin> plugins;
+ private final Filer filer;
+ private final DaggerTypes types;
+ private final DaggerElements elements;
+ private final Map<String, String> processingOptions;
+
+ @Inject
+ BindingGraphPlugins(
+ @Validation ImmutableSet<BindingGraphPlugin> validationPlugins,
+ ImmutableSet<BindingGraphPlugin> externalPlugins,
+ Filer filer,
+ DaggerTypes types,
+ DaggerElements elements,
+ @ProcessingOptions Map<String, String> processingOptions) {
+ this.plugins = Sets.union(validationPlugins, externalPlugins).immutableCopy();
+ this.filer = filer;
+ this.types = types;
+ this.elements = elements;
+ this.processingOptions = processingOptions;
+ }
+
+ /** Returns {@link BindingGraphPlugin#supportedOptions()} from all the plugins. */
+ public ImmutableSet<String> allSupportedOptions() {
+ return plugins.stream()
+ .flatMap(plugin -> plugin.supportedOptions().stream())
+ .collect(toImmutableSet());
+ }
+
+ /** Initializes the plugins. */
+ // TODO(ronshapiro): Should we validate the uniqueness of plugin names?
+ public void initializePlugins() {
+ plugins.forEach(this::initializePlugin);
+ }
+
+ private void initializePlugin(BindingGraphPlugin plugin) {
+ plugin.initFiler(filer);
+ plugin.initTypes(types);
+ plugin.initElements(elements);
+ Set<String> supportedOptions = plugin.supportedOptions();
+ if (!supportedOptions.isEmpty()) {
+ plugin.initOptions(Maps.filterKeys(processingOptions, supportedOptions::contains));
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/BindingGraphValidator.java b/java/dagger/internal/codegen/validation/BindingGraphValidator.java
new file mode 100644
index 0000000..99e86e7
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/BindingGraphValidator.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static javax.tools.Diagnostic.Kind.ERROR;
+
+import com.google.common.collect.ImmutableSet;
+import dagger.internal.codegen.compileroption.CompilerOptions;
+import dagger.internal.codegen.compileroption.ValidationType;
+import dagger.internal.codegen.validation.DiagnosticReporterFactory.DiagnosticReporterImpl;
+import dagger.model.BindingGraph;
+import dagger.spi.BindingGraphPlugin;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import javax.lang.model.element.TypeElement;
+
+/** Validates a {@link BindingGraph}. */
+@Singleton
+public final class BindingGraphValidator {
+ private final ImmutableSet<BindingGraphPlugin> validationPlugins;
+ private final ImmutableSet<BindingGraphPlugin> externalPlugins;
+ private final DiagnosticReporterFactory diagnosticReporterFactory;
+ private final CompilerOptions compilerOptions;
+
+ @Inject
+ BindingGraphValidator(
+ @Validation ImmutableSet<BindingGraphPlugin> validationPlugins,
+ ImmutableSet<BindingGraphPlugin> externalPlugins,
+ DiagnosticReporterFactory diagnosticReporterFactory,
+ CompilerOptions compilerOptions) {
+ this.validationPlugins = validationPlugins;
+ this.externalPlugins = externalPlugins;
+ this.diagnosticReporterFactory = checkNotNull(diagnosticReporterFactory);
+ this.compilerOptions = compilerOptions;
+ }
+
+ /** Returns {@code true} if validation or analysis is required on the full binding graph. */
+ public boolean shouldDoFullBindingGraphValidation(TypeElement component) {
+ return requiresFullBindingGraphValidation()
+ || compilerOptions.pluginsVisitFullBindingGraphs(component);
+ }
+
+ private boolean requiresFullBindingGraphValidation() {
+ return !compilerOptions.fullBindingGraphValidationType().equals(ValidationType.NONE);
+ }
+
+ /** Returns {@code true} if no errors are reported for {@code graph}. */
+ public boolean isValid(BindingGraph graph) {
+ return validate(graph) && visitPlugins(graph);
+ }
+
+ /** Returns {@code true} if validation plugins report no errors. */
+ private boolean validate(BindingGraph graph) {
+ if (graph.isFullBindingGraph() && !requiresFullBindingGraphValidation()) {
+ return true;
+ }
+
+ boolean errorsAsWarnings =
+ graph.isFullBindingGraph()
+ && compilerOptions.fullBindingGraphValidationType().equals(ValidationType.WARNING);
+
+ return runPlugins(validationPlugins, graph, errorsAsWarnings);
+ }
+
+ /** Returns {@code true} if external plugins report no errors. */
+ private boolean visitPlugins(BindingGraph graph) {
+ TypeElement component = graph.rootComponentNode().componentPath().currentComponent();
+ if (graph.isFullBindingGraph()
+ // TODO(b/135938915): Consider not visiting plugins if only
+ // fullBindingGraphValidation is enabled.
+ && !requiresFullBindingGraphValidation()
+ && !compilerOptions.pluginsVisitFullBindingGraphs(component)) {
+ return true;
+ }
+ return runPlugins(externalPlugins, graph, /*errorsAsWarnings=*/ false);
+ }
+
+ /** Returns {@code false} if any of the plugins reported an error. */
+ private boolean runPlugins(
+ ImmutableSet<BindingGraphPlugin> plugins, BindingGraph graph, boolean errorsAsWarnings) {
+ boolean isClean = true;
+ for (BindingGraphPlugin plugin : plugins) {
+ DiagnosticReporterImpl reporter =
+ diagnosticReporterFactory.reporter(graph, plugin, errorsAsWarnings);
+ plugin.visitGraph(graph, reporter);
+ if (reporter.reportedDiagnosticKinds().contains(ERROR)) {
+ isClean = false;
+ }
+ }
+ return isClean;
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/BindingMethodProcessingStep.java b/java/dagger/internal/codegen/validation/BindingMethodProcessingStep.java
new file mode 100644
index 0000000..10aec06
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/BindingMethodProcessingStep.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import com.google.auto.common.MoreElements;
+import com.google.common.collect.ImmutableSet;
+import java.lang.annotation.Annotation;
+import java.util.Set;
+import javax.annotation.processing.Messager;
+import javax.inject.Inject;
+import javax.lang.model.element.ExecutableElement;
+
+/** A step that validates all binding methods that were not validated while processing modules. */
+public final class BindingMethodProcessingStep
+ extends TypeCheckingProcessingStep<ExecutableElement> {
+
+ private final Messager messager;
+ private final AnyBindingMethodValidator anyBindingMethodValidator;
+
+ @Inject
+ BindingMethodProcessingStep(
+ Messager messager, AnyBindingMethodValidator anyBindingMethodValidator) {
+ super(MoreElements::asExecutable);
+ this.messager = messager;
+ this.anyBindingMethodValidator = anyBindingMethodValidator;
+ }
+
+ @Override
+ public Set<? extends Class<? extends Annotation>> annotations() {
+ return anyBindingMethodValidator.methodAnnotations();
+ }
+
+ @Override
+ protected void process(
+ ExecutableElement method, ImmutableSet<Class<? extends Annotation>> annotations) {
+ checkArgument(
+ anyBindingMethodValidator.isBindingMethod(method),
+ "%s is not annotated with any of %s",
+ method,
+ annotations());
+ if (!anyBindingMethodValidator.wasAlreadyValidated(method)) {
+ anyBindingMethodValidator.validate(method).printMessagesTo(messager);
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/BindingMethodValidator.java b/java/dagger/internal/codegen/validation/BindingMethodValidator.java
new file mode 100644
index 0000000..81349b9
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/BindingMethodValidator.java
@@ -0,0 +1,319 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static com.google.auto.common.MoreElements.asType;
+import static dagger.internal.codegen.langmodel.DaggerElements.isAnyAnnotationPresent;
+import static java.util.stream.Collectors.joining;
+import static javax.lang.model.element.Modifier.ABSTRACT;
+import static javax.lang.model.element.Modifier.PRIVATE;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.errorprone.annotations.FormatMethod;
+import dagger.internal.codegen.binding.InjectionAnnotations;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import java.lang.annotation.Annotation;
+import java.util.Optional;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.TypeMirror;
+
+/** A validator for methods that represent binding declarations. */
+abstract class BindingMethodValidator extends BindingElementValidator<ExecutableElement> {
+
+ private final DaggerElements elements;
+ private final DaggerTypes types;
+ private final KotlinMetadataUtil metadataUtil;
+ private final DependencyRequestValidator dependencyRequestValidator;
+ private final Class<? extends Annotation> methodAnnotation;
+ private final ImmutableSet<? extends Class<? extends Annotation>> enclosingElementAnnotations;
+ private final Abstractness abstractness;
+ private final ExceptionSuperclass exceptionSuperclass;
+
+ /**
+ * Creates a validator object.
+ *
+ * @param methodAnnotation the annotation on a method that identifies it as a binding method
+ * @param enclosingElementAnnotation the method must be declared in a class or interface annotated
+ * with this annotation
+ */
+ protected BindingMethodValidator(
+ DaggerElements elements,
+ DaggerTypes types,
+ KotlinMetadataUtil metadataUtil,
+ DependencyRequestValidator dependencyRequestValidator,
+ Class<? extends Annotation> methodAnnotation,
+ Class<? extends Annotation> enclosingElementAnnotation,
+ Abstractness abstractness,
+ ExceptionSuperclass exceptionSuperclass,
+ AllowsMultibindings allowsMultibindings,
+ AllowsScoping allowsScoping,
+ InjectionAnnotations injectionAnnotations) {
+ this(
+ elements,
+ types,
+ metadataUtil,
+ methodAnnotation,
+ ImmutableSet.of(enclosingElementAnnotation),
+ dependencyRequestValidator,
+ abstractness,
+ exceptionSuperclass,
+ allowsMultibindings,
+ allowsScoping,
+ injectionAnnotations);
+ }
+
+ /**
+ * Creates a validator object.
+ *
+ * @param methodAnnotation the annotation on a method that identifies it as a binding method
+ * @param enclosingElementAnnotations the method must be declared in a class or interface
+ * annotated with one of these annotations
+ */
+ protected BindingMethodValidator(
+ DaggerElements elements,
+ DaggerTypes types,
+ KotlinMetadataUtil metadataUtil,
+ Class<? extends Annotation> methodAnnotation,
+ Iterable<? extends Class<? extends Annotation>> enclosingElementAnnotations,
+ DependencyRequestValidator dependencyRequestValidator,
+ Abstractness abstractness,
+ ExceptionSuperclass exceptionSuperclass,
+ AllowsMultibindings allowsMultibindings,
+ AllowsScoping allowsScoping,
+ InjectionAnnotations injectionAnnotations) {
+ super(methodAnnotation, allowsMultibindings, allowsScoping, injectionAnnotations);
+ this.elements = elements;
+ this.types = types;
+ this.metadataUtil = metadataUtil;
+ this.methodAnnotation = methodAnnotation;
+ this.enclosingElementAnnotations = ImmutableSet.copyOf(enclosingElementAnnotations);
+ this.dependencyRequestValidator = dependencyRequestValidator;
+ this.abstractness = abstractness;
+ this.exceptionSuperclass = exceptionSuperclass;
+ }
+
+ /** The annotation that identifies binding methods validated by this object. */
+ final Class<? extends Annotation> methodAnnotation() {
+ return methodAnnotation;
+ }
+
+ /**
+ * Returns an error message of the form "@<i>annotation</i> methods <i>rule</i>", where
+ * <i>rule</i> comes from calling {@link String#format(String, Object...)} on {@code ruleFormat}
+ * and the other arguments.
+ */
+ @FormatMethod
+ protected final String bindingMethods(String ruleFormat, Object... args) {
+ return bindingElements(ruleFormat, args);
+ }
+
+ @Override
+ protected final String bindingElements() {
+ return String.format("@%s methods", methodAnnotation.getSimpleName());
+ }
+
+ @Override
+ protected final String bindingElementTypeVerb() {
+ return "return";
+ }
+
+ /** Abstract validator for individual binding method elements. */
+ protected abstract class MethodValidator extends ElementValidator {
+ protected MethodValidator(ExecutableElement element) {
+ super(element);
+ }
+
+ @Override
+ protected final Optional<TypeMirror> bindingElementType() {
+ return Optional.of(element.getReturnType());
+ }
+
+ @Override
+ protected final void checkAdditionalProperties() {
+ checkEnclosingElement();
+ checkTypeParameters();
+ checkNotPrivate();
+ checkAbstractness();
+ checkThrows();
+ checkParameters();
+ checkAdditionalMethodProperties();
+ }
+
+ /** Checks additional properties of the binding method. */
+ protected void checkAdditionalMethodProperties() {}
+
+ /**
+ * Adds an error if the method is not declared in a class or interface annotated with one of the
+ * {@link #enclosingElementAnnotations}.
+ */
+ private void checkEnclosingElement() {
+ TypeElement enclosingElement = asType(element.getEnclosingElement());
+ if (metadataUtil.isCompanionObjectClass(enclosingElement)) {
+ // Binding method is in companion object, use companion object's enclosing class instead.
+ enclosingElement = asType(enclosingElement.getEnclosingElement());
+ }
+ if (!isAnyAnnotationPresent(enclosingElement, enclosingElementAnnotations)) {
+ report.addError(
+ bindingMethods(
+ "can only be present within a @%s",
+ enclosingElementAnnotations.stream()
+ .map(Class::getSimpleName)
+ .collect(joining(" or @"))));
+ }
+ }
+
+ /** Adds an error if the method is generic. */
+ private void checkTypeParameters() {
+ if (!element.getTypeParameters().isEmpty()) {
+ report.addError(bindingMethods("may not have type parameters"));
+ }
+ }
+
+ /** Adds an error if the method is private. */
+ private void checkNotPrivate() {
+ if (element.getModifiers().contains(PRIVATE)) {
+ report.addError(bindingMethods("cannot be private"));
+ }
+ }
+
+ /** Adds an error if the method is abstract but must not be, or is not and must be. */
+ private void checkAbstractness() {
+ boolean isAbstract = element.getModifiers().contains(ABSTRACT);
+ switch (abstractness) {
+ case MUST_BE_ABSTRACT:
+ if (!isAbstract) {
+ report.addError(bindingMethods("must be abstract"));
+ }
+ break;
+
+ case MUST_BE_CONCRETE:
+ if (isAbstract) {
+ report.addError(bindingMethods("cannot be abstract"));
+ }
+ }
+ }
+
+ /**
+ * Adds an error if the method declares throws anything but an {@link Error} or an appropriate
+ * subtype of {@link Exception}.
+ */
+ private void checkThrows() {
+ exceptionSuperclass.checkThrows(BindingMethodValidator.this, element, report);
+ }
+
+ /** Adds errors for the method parameters. */
+ protected void checkParameters() {
+ for (VariableElement parameter : element.getParameters()) {
+ checkParameter(parameter);
+ }
+ }
+
+ /**
+ * Adds errors for a method parameter. This implementation reports an error if the parameter has
+ * more than one qualifier.
+ */
+ protected void checkParameter(VariableElement parameter) {
+ dependencyRequestValidator.validateDependencyRequest(report, parameter, parameter.asType());
+ }
+ }
+
+ /** An abstract/concrete restriction on methods. */
+ protected enum Abstractness {
+ MUST_BE_ABSTRACT,
+ MUST_BE_CONCRETE
+ }
+
+ /**
+ * The exception class that all {@code throws}-declared throwables must extend, other than {@link
+ * Error}.
+ */
+ protected enum ExceptionSuperclass {
+ /** Methods may not declare any throwable types. */
+ NO_EXCEPTIONS {
+ @Override
+ protected String errorMessage(BindingMethodValidator validator) {
+ return validator.bindingMethods("may not throw");
+ }
+
+ @Override
+ protected void checkThrows(
+ BindingMethodValidator validator,
+ ExecutableElement element,
+ ValidationReport.Builder<ExecutableElement> report) {
+ if (!element.getThrownTypes().isEmpty()) {
+ report.addError(validator.bindingMethods("may not throw"));
+ return;
+ }
+ }
+ },
+
+ /** Methods may throw checked or unchecked exceptions or errors. */
+ EXCEPTION(Exception.class) {
+ @Override
+ protected String errorMessage(BindingMethodValidator validator) {
+ return validator.bindingMethods(
+ "may only throw unchecked exceptions or exceptions subclassing Exception");
+ }
+ },
+
+ /** Methods may throw unchecked exceptions or errors. */
+ RUNTIME_EXCEPTION(RuntimeException.class) {
+ @Override
+ protected String errorMessage(BindingMethodValidator validator) {
+ return validator.bindingMethods("may only throw unchecked exceptions");
+ }
+ },
+ ;
+
+ private final Class<? extends Exception> superclass;
+
+ ExceptionSuperclass() {
+ this(null);
+ }
+
+ ExceptionSuperclass(Class<? extends Exception> superclass) {
+ this.superclass = superclass;
+ }
+
+ /**
+ * Adds an error if the method declares throws anything but an {@link Error} or an appropriate
+ * subtype of {@link Exception}.
+ *
+ * <p>This method is overridden in {@link #NO_EXCEPTIONS}.
+ */
+ protected void checkThrows(
+ BindingMethodValidator validator,
+ ExecutableElement element,
+ ValidationReport.Builder<ExecutableElement> report) {
+ TypeMirror exceptionSupertype = validator.elements.getTypeElement(superclass).asType();
+ TypeMirror errorType = validator.elements.getTypeElement(Error.class).asType();
+ for (TypeMirror thrownType : element.getThrownTypes()) {
+ if (!validator.types.isSubtype(thrownType, exceptionSupertype)
+ && !validator.types.isSubtype(thrownType, errorType)) {
+ report.addError(errorMessage(validator));
+ break;
+ }
+ }
+ }
+
+ protected abstract String errorMessage(BindingMethodValidator validator);
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/BindingMethodValidatorsModule.java b/java/dagger/internal/codegen/validation/BindingMethodValidatorsModule.java
new file mode 100644
index 0000000..08afbc8
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/BindingMethodValidatorsModule.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static com.google.common.collect.Maps.uniqueIndex;
+
+import com.google.common.collect.ImmutableMap;
+import dagger.Binds;
+import dagger.Module;
+import dagger.Provides;
+import dagger.multibindings.IntoSet;
+import java.lang.annotation.Annotation;
+import java.util.Set;
+
+/**
+ * Binds each {@link BindingMethodValidator} into a map, keyed by {@link
+ * BindingMethodValidator#methodAnnotation()}.
+ */
+@Module
+public interface BindingMethodValidatorsModule {
+ @Provides
+ static ImmutableMap<Class<? extends Annotation>, BindingMethodValidator> indexValidators(
+ Set<BindingMethodValidator> validators) {
+ return uniqueIndex(validators, BindingMethodValidator::methodAnnotation);
+ }
+
+ @Binds
+ @IntoSet
+ BindingMethodValidator provides(ProvidesMethodValidator validator);
+
+ @Binds
+ @IntoSet
+ BindingMethodValidator produces(ProducesMethodValidator validator);
+
+ @Binds
+ @IntoSet
+ BindingMethodValidator binds(BindsMethodValidator validator);
+
+ @Binds
+ @IntoSet
+ BindingMethodValidator multibinds(MultibindsMethodValidator validator);
+
+ @Binds
+ @IntoSet
+ BindingMethodValidator bindsOptionalOf(BindsOptionalOfMethodValidator validator);
+}
diff --git a/java/dagger/internal/codegen/validation/BindsInstanceElementValidator.java b/java/dagger/internal/codegen/validation/BindsInstanceElementValidator.java
new file mode 100644
index 0000000..283af7d
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/BindsInstanceElementValidator.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import dagger.BindsInstance;
+import dagger.internal.codegen.binding.InjectionAnnotations;
+import javax.lang.model.element.Element;
+
+abstract class BindsInstanceElementValidator<E extends Element> extends BindingElementValidator<E> {
+ BindsInstanceElementValidator(InjectionAnnotations injectionAnnotations) {
+ super(
+ BindsInstance.class,
+ AllowsMultibindings.NO_MULTIBINDINGS,
+ AllowsScoping.NO_SCOPING,
+ injectionAnnotations);
+ }
+
+ @Override
+ protected final String bindingElements() {
+ // Even though @BindsInstance may be placed on methods, the subject of errors is the
+ // parameter
+ return "@BindsInstance parameters";
+ }
+
+ @Override
+ protected final String bindingElementTypeVerb() {
+ return "be";
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/BindsInstanceMethodValidator.java b/java/dagger/internal/codegen/validation/BindsInstanceMethodValidator.java
new file mode 100644
index 0000000..6d144bd
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/BindsInstanceMethodValidator.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static dagger.internal.codegen.base.ComponentAnnotation.anyComponentAnnotation;
+import static dagger.internal.codegen.base.ModuleAnnotation.moduleAnnotation;
+import static javax.lang.model.element.Modifier.ABSTRACT;
+
+import com.google.auto.common.MoreElements;
+import dagger.internal.codegen.base.ModuleAnnotation;
+import dagger.internal.codegen.binding.InjectionAnnotations;
+import java.util.List;
+import java.util.Optional;
+import javax.inject.Inject;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.TypeMirror;
+
+final class BindsInstanceMethodValidator extends BindsInstanceElementValidator<ExecutableElement> {
+ @Inject
+ BindsInstanceMethodValidator(InjectionAnnotations injectionAnnotations) {
+ super(injectionAnnotations);
+ }
+
+ @Override
+ protected ElementValidator elementValidator(ExecutableElement element) {
+ return new Validator(element);
+ }
+
+ private class Validator extends ElementValidator {
+ Validator(ExecutableElement element) {
+ super(element);
+ }
+
+ @Override
+ protected void checkAdditionalProperties() {
+ if (!element.getModifiers().contains(ABSTRACT)) {
+ report.addError("@BindsInstance methods must be abstract");
+ }
+ if (element.getParameters().size() != 1) {
+ report.addError(
+ "@BindsInstance methods should have exactly one parameter for the bound type");
+ }
+ TypeElement enclosingType = MoreElements.asType(element.getEnclosingElement());
+ moduleAnnotation(enclosingType)
+ .ifPresent(moduleAnnotation -> report.addError(didYouMeanBinds(moduleAnnotation)));
+ anyComponentAnnotation(enclosingType)
+ .ifPresent(
+ componentAnnotation ->
+ report.addError(
+ String.format(
+ "@BindsInstance methods should not be included in @%1$ss. "
+ + "Did you mean to put it in a @%1$s.Builder?",
+ componentAnnotation.simpleName())));
+ }
+
+ @Override
+ protected Optional<TypeMirror> bindingElementType() {
+ List<? extends VariableElement> parameters =
+ MoreElements.asExecutable(element).getParameters();
+ return parameters.size() == 1
+ ? Optional.of(getOnlyElement(parameters).asType())
+ : Optional.empty();
+ }
+ }
+
+ private static String didYouMeanBinds(ModuleAnnotation moduleAnnotation) {
+ return String.format(
+ "@BindsInstance methods should not be included in @%ss. Did you mean @Binds?",
+ moduleAnnotation.annotationName());
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/BindsInstanceParameterValidator.java b/java/dagger/internal/codegen/validation/BindsInstanceParameterValidator.java
new file mode 100644
index 0000000..24d65a9
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/BindsInstanceParameterValidator.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static javax.lang.model.element.ElementKind.METHOD;
+import static javax.lang.model.element.Modifier.ABSTRACT;
+import static javax.lang.model.type.TypeKind.DECLARED;
+import static javax.lang.model.type.TypeKind.TYPEVAR;
+
+import com.google.auto.common.MoreElements;
+import dagger.internal.codegen.binding.InjectionAnnotations;
+import java.util.Optional;
+import javax.inject.Inject;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeMirror;
+
+final class BindsInstanceParameterValidator extends BindsInstanceElementValidator<VariableElement> {
+ @Inject
+ BindsInstanceParameterValidator(InjectionAnnotations injectionAnnotations) {
+ super(injectionAnnotations);
+ }
+
+ @Override
+ protected ElementValidator elementValidator(VariableElement element) {
+ return new Validator(element);
+ }
+
+ private class Validator extends ElementValidator {
+ Validator(VariableElement element) {
+ super(element);
+ }
+
+ @Override
+ protected void checkAdditionalProperties() {
+ Element enclosing = element.getEnclosingElement();
+ if (!enclosing.getKind().equals(METHOD)) {
+ report.addError(
+ "@BindsInstance should only be applied to methods or parameters of methods");
+ return;
+ }
+
+ ExecutableElement method = MoreElements.asExecutable(enclosing);
+ if (!method.getModifiers().contains(ABSTRACT)) {
+ report.addError("@BindsInstance parameters may only be used in abstract methods");
+ }
+
+ TypeKind returnKind = method.getReturnType().getKind();
+ if (!(returnKind.equals(DECLARED) || returnKind.equals(TYPEVAR))) {
+ report.addError(
+ "@BindsInstance parameters may not be used in methods with a void, array or primitive "
+ + "return type");
+ }
+ }
+
+ @Override
+ protected Optional<TypeMirror> bindingElementType() {
+ return Optional.of(element.asType());
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/BindsInstanceProcessingStep.java b/java/dagger/internal/codegen/validation/BindsInstanceProcessingStep.java
new file mode 100644
index 0000000..0e79b91
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/BindsInstanceProcessingStep.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import com.google.auto.common.MoreElements;
+import com.google.common.collect.ImmutableSet;
+import dagger.BindsInstance;
+import java.lang.annotation.Annotation;
+import java.util.Set;
+import javax.annotation.processing.Messager;
+import javax.inject.Inject;
+import javax.lang.model.element.Element;
+
+/**
+ * Processing step that validates that the {@code BindsInstance} annotation is applied to the
+ * correct elements.
+ */
+public final class BindsInstanceProcessingStep extends TypeCheckingProcessingStep<Element> {
+ private final BindsInstanceMethodValidator methodValidator;
+ private final BindsInstanceParameterValidator parameterValidator;
+ private final Messager messager;
+
+ @Inject
+ BindsInstanceProcessingStep(
+ BindsInstanceMethodValidator methodValidator,
+ BindsInstanceParameterValidator parameterValidator,
+ Messager messager) {
+ super(element -> element);
+ this.methodValidator = methodValidator;
+ this.parameterValidator = parameterValidator;
+ this.messager = messager;
+ }
+
+ @Override
+ public Set<? extends Class<? extends Annotation>> annotations() {
+ return ImmutableSet.of(BindsInstance.class);
+ }
+
+ @Override
+ protected void process(Element element, ImmutableSet<Class<? extends Annotation>> annotations) {
+ switch (element.getKind()) {
+ case PARAMETER:
+ parameterValidator.validate(MoreElements.asVariable(element)).printMessagesTo(messager);
+ break;
+ case METHOD:
+ methodValidator.validate(MoreElements.asExecutable(element)).printMessagesTo(messager);
+ break;
+ default:
+ throw new AssertionError(element);
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/BindsMethodValidator.java b/java/dagger/internal/codegen/validation/BindsMethodValidator.java
new file mode 100644
index 0000000..6d2dd18
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/BindsMethodValidator.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static dagger.internal.codegen.validation.BindingElementValidator.AllowsMultibindings.ALLOWS_MULTIBINDINGS;
+import static dagger.internal.codegen.validation.BindingElementValidator.AllowsScoping.ALLOWS_SCOPING;
+import static dagger.internal.codegen.validation.BindingMethodValidator.Abstractness.MUST_BE_ABSTRACT;
+import static dagger.internal.codegen.validation.BindingMethodValidator.ExceptionSuperclass.NO_EXCEPTIONS;
+import static dagger.internal.codegen.validation.TypeHierarchyValidator.validateTypeHierarchy;
+
+import com.google.auto.common.MoreTypes;
+import com.google.common.collect.ImmutableSet;
+import dagger.Binds;
+import dagger.Module;
+import dagger.internal.codegen.base.ContributionType;
+import dagger.internal.codegen.base.SetType;
+import dagger.internal.codegen.binding.BindsTypeChecker;
+import dagger.internal.codegen.binding.InjectionAnnotations;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.producers.ProducerModule;
+import javax.inject.Inject;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.TypeMirror;
+
+/** A validator for {@link Binds} methods. */
+final class BindsMethodValidator extends BindingMethodValidator {
+ private final DaggerTypes types;
+ private final BindsTypeChecker bindsTypeChecker;
+
+ @Inject
+ BindsMethodValidator(
+ DaggerElements elements,
+ DaggerTypes types,
+ KotlinMetadataUtil kotlinMetadataUtil,
+ BindsTypeChecker bindsTypeChecker,
+ DependencyRequestValidator dependencyRequestValidator,
+ InjectionAnnotations injectionAnnotations) {
+ super(
+ elements,
+ types,
+ kotlinMetadataUtil,
+ Binds.class,
+ ImmutableSet.of(Module.class, ProducerModule.class),
+ dependencyRequestValidator,
+ MUST_BE_ABSTRACT,
+ NO_EXCEPTIONS,
+ ALLOWS_MULTIBINDINGS,
+ ALLOWS_SCOPING,
+ injectionAnnotations);
+ this.types = types;
+ this.bindsTypeChecker = bindsTypeChecker;
+ }
+
+ @Override
+ protected ElementValidator elementValidator(ExecutableElement element) {
+ return new Validator(element);
+ }
+
+ private class Validator extends MethodValidator {
+ Validator(ExecutableElement element) {
+ super(element);
+ }
+
+ @Override
+ protected void checkParameters() {
+ if (element.getParameters().size() != 1) {
+ report.addError(
+ bindingMethods(
+ "must have exactly one parameter, whose type is assignable to the return type"));
+ } else {
+ super.checkParameters();
+ }
+ }
+
+ @Override
+ protected void checkParameter(VariableElement parameter) {
+ super.checkParameter(parameter);
+ TypeMirror leftHandSide = boxIfNecessary(element.getReturnType());
+ TypeMirror rightHandSide = parameter.asType();
+ ContributionType contributionType = ContributionType.fromBindingElement(element);
+ if (contributionType.equals(ContributionType.SET_VALUES) && !SetType.isSet(leftHandSide)) {
+ report.addError(
+ "@Binds @ElementsIntoSet methods must return a Set and take a Set parameter");
+ }
+
+ if (!bindsTypeChecker.isAssignable(rightHandSide, leftHandSide, contributionType)) {
+ // Validate the type hierarchy of both sides to make sure they're both valid.
+ // If one of the types isn't valid it means we need to delay validation to the next round.
+ // Note: BasicAnnotationProcessor only performs superficial validation on the referenced
+ // types within the module. Thus, we're guaranteed that the types in the @Binds method are
+ // valid, but it says nothing about their supertypes, which are needed for isAssignable.
+ validateTypeHierarchy(leftHandSide, types);
+ validateTypeHierarchy(rightHandSide, types);
+ // TODO(ronshapiro): clarify this error message for @ElementsIntoSet cases, where the
+ // right-hand-side might not be assignable to the left-hand-side, but still compatible with
+ // Set.addAll(Collection<? extends E>)
+ report.addError("@Binds methods' parameter type must be assignable to the return type");
+ }
+ }
+
+ private TypeMirror boxIfNecessary(TypeMirror maybePrimitive) {
+ if (maybePrimitive.getKind().isPrimitive()) {
+ return types.boxedClass(MoreTypes.asPrimitiveType(maybePrimitive)).asType();
+ }
+ return maybePrimitive;
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/BindsOptionalOfMethodValidator.java b/java/dagger/internal/codegen/validation/BindsOptionalOfMethodValidator.java
new file mode 100644
index 0000000..cb776e1
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/BindsOptionalOfMethodValidator.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static com.google.auto.common.MoreTypes.asTypeElement;
+import static dagger.internal.codegen.base.Keys.isValidImplicitProvisionKey;
+import static dagger.internal.codegen.binding.InjectionAnnotations.injectedConstructors;
+import static dagger.internal.codegen.validation.BindingElementValidator.AllowsMultibindings.NO_MULTIBINDINGS;
+import static dagger.internal.codegen.validation.BindingElementValidator.AllowsScoping.NO_SCOPING;
+import static dagger.internal.codegen.validation.BindingMethodValidator.Abstractness.MUST_BE_ABSTRACT;
+import static dagger.internal.codegen.validation.BindingMethodValidator.ExceptionSuperclass.NO_EXCEPTIONS;
+
+import com.google.common.collect.ImmutableSet;
+import dagger.BindsOptionalOf;
+import dagger.Module;
+import dagger.internal.codegen.binding.InjectionAnnotations;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.producers.ProducerModule;
+import javax.inject.Inject;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.type.TypeMirror;
+
+/** A validator for {@link BindsOptionalOf} methods. */
+final class BindsOptionalOfMethodValidator extends BindingMethodValidator {
+
+ private final DaggerTypes types;
+ private final InjectionAnnotations injectionAnnotations;
+
+ @Inject
+ BindsOptionalOfMethodValidator(
+ DaggerElements elements,
+ DaggerTypes types,
+ KotlinMetadataUtil kotlinMetadataUtil,
+ DependencyRequestValidator dependencyRequestValidator,
+ InjectionAnnotations injectionAnnotations) {
+ super(
+ elements,
+ types,
+ kotlinMetadataUtil,
+ BindsOptionalOf.class,
+ ImmutableSet.of(Module.class, ProducerModule.class),
+ dependencyRequestValidator,
+ MUST_BE_ABSTRACT,
+ NO_EXCEPTIONS,
+ NO_MULTIBINDINGS,
+ NO_SCOPING,
+ injectionAnnotations);
+ this.types = types;
+ this.injectionAnnotations = injectionAnnotations;
+ }
+
+
+ @Override
+ protected ElementValidator elementValidator(ExecutableElement element) {
+ return new Validator(element);
+ }
+
+ private class Validator extends MethodValidator {
+ Validator(ExecutableElement element) {
+ super(element);
+ }
+
+ @Override
+ protected void checkKeyType(TypeMirror keyType) {
+ super.checkKeyType(keyType);
+ if (isValidImplicitProvisionKey(
+ injectionAnnotations.getQualifiers(element).stream().findFirst(), keyType, types)
+ && !injectedConstructors(asTypeElement(keyType)).isEmpty()) {
+ report.addError(
+ "@BindsOptionalOf methods cannot return unqualified types that have an @Inject-"
+ + "annotated constructor because those are always present");
+ }
+ }
+
+ @Override
+ protected void checkParameters() {
+ if (!element.getParameters().isEmpty()) {
+ report.addError("@BindsOptionalOf methods cannot have parameters");
+ }
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/ComponentCreatorValidator.java b/java/dagger/internal/codegen/validation/ComponentCreatorValidator.java
new file mode 100644
index 0000000..a6d9a3f
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/ComponentCreatorValidator.java
@@ -0,0 +1,408 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static com.google.auto.common.MoreElements.isAnnotationPresent;
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static dagger.internal.codegen.base.Util.reentrantComputeIfAbsent;
+import static dagger.internal.codegen.binding.ComponentCreatorAnnotation.getCreatorAnnotations;
+import static javax.lang.model.element.Modifier.ABSTRACT;
+import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.STATIC;
+import static javax.lang.model.util.ElementFilter.methodsIn;
+
+import com.google.auto.common.MoreElements;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ObjectArrays;
+import dagger.BindsInstance;
+import dagger.internal.codegen.base.ClearableCache;
+import dagger.internal.codegen.binding.ComponentCreatorAnnotation;
+import dagger.internal.codegen.binding.ErrorMessages;
+import dagger.internal.codegen.binding.ErrorMessages.ComponentCreatorMessages;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.ElementFilter;
+
+/** Validates types annotated with component creator annotations. */
+@Singleton
+public final class ComponentCreatorValidator implements ClearableCache {
+
+ private final DaggerElements elements;
+ private final DaggerTypes types;
+ private final Map<TypeElement, ValidationReport<TypeElement>> reports = new HashMap<>();
+
+ @Inject
+ ComponentCreatorValidator(DaggerElements elements, DaggerTypes types) {
+ this.elements = elements;
+ this.types = types;
+ }
+
+ @Override
+ public void clearCache() {
+ reports.clear();
+ }
+
+ /** Validates that the given {@code type} is potentially a valid component creator type. */
+ public ValidationReport<TypeElement> validate(TypeElement type) {
+ return reentrantComputeIfAbsent(reports, type, this::validateUncached);
+ }
+
+ private ValidationReport<TypeElement> validateUncached(TypeElement type) {
+ ValidationReport.Builder<TypeElement> report = ValidationReport.about(type);
+
+ ImmutableSet<ComponentCreatorAnnotation> creatorAnnotations = getCreatorAnnotations(type);
+ if (!validateOnlyOneCreatorAnnotation(creatorAnnotations, report)) {
+ return report.build();
+ }
+
+ // Note: there's more validation in ComponentDescriptorValidator:
+ // - to make sure the setter methods/factory parameters mirror the deps
+ // - to make sure each type or key is set by only one method or parameter
+ ElementValidator validator =
+ new ElementValidator(type, report, getOnlyElement(creatorAnnotations));
+ return validator.validate();
+ }
+
+ private boolean validateOnlyOneCreatorAnnotation(
+ ImmutableSet<ComponentCreatorAnnotation> creatorAnnotations,
+ ValidationReport.Builder<?> report) {
+ // creatorAnnotations should never be empty because this should only ever be called for
+ // types that have been found to have some creator annotation
+ if (creatorAnnotations.size() > 1) {
+ String error =
+ "May not have more than one component Factory or Builder annotation on a type"
+ + ": found "
+ + creatorAnnotations;
+ report.addError(error);
+ return false;
+ }
+
+ return true;
+ }
+
+ /**
+ * Validator for a single {@link TypeElement} that is annotated with a {@code Builder} or {@code
+ * Factory} annotation.
+ */
+ private final class ElementValidator {
+ private final TypeElement type;
+ private final Element component;
+ private final ValidationReport.Builder<TypeElement> report;
+ private final ComponentCreatorAnnotation annotation;
+ private final ComponentCreatorMessages messages;
+
+ private ElementValidator(
+ TypeElement type,
+ ValidationReport.Builder<TypeElement> report,
+ ComponentCreatorAnnotation annotation) {
+ this.type = type;
+ this.component = type.getEnclosingElement();
+ this.report = report;
+ this.annotation = annotation;
+ this.messages = ErrorMessages.creatorMessagesFor(annotation);
+ }
+
+ /** Validates the creator type. */
+ final ValidationReport<TypeElement> validate() {
+ if (!isAnnotationPresent(component, annotation.componentAnnotation())) {
+ report.addError(messages.mustBeInComponent());
+ }
+
+ // If the type isn't a class or interface, don't validate anything else since the rest of the
+ // messages will be bogus.
+ if (!validateIsClassOrInterface()) {
+ return report.build();
+ }
+
+ validateTypeRequirements();
+ switch (annotation.creatorKind()) {
+ case FACTORY:
+ validateFactory();
+ break;
+ case BUILDER:
+ validateBuilder();
+ }
+
+ return report.build();
+ }
+
+ /** Validates that the type is a class or interface type and returns true if it is. */
+ private boolean validateIsClassOrInterface() {
+ switch (type.getKind()) {
+ case CLASS:
+ validateConstructor();
+ return true;
+ case INTERFACE:
+ return true;
+ default:
+ report.addError(messages.mustBeClassOrInterface());
+ }
+ return false;
+ }
+
+ private void validateConstructor() {
+ List<? extends Element> allElements = type.getEnclosedElements();
+ List<ExecutableElement> constructors = ElementFilter.constructorsIn(allElements);
+
+ boolean valid = true;
+ if (constructors.size() != 1) {
+ valid = false;
+ } else {
+ ExecutableElement constructor = getOnlyElement(constructors);
+ valid =
+ constructor.getParameters().isEmpty() && !constructor.getModifiers().contains(PRIVATE);
+ }
+
+ if (!valid) {
+ report.addError(messages.invalidConstructor());
+ }
+ }
+
+ /** Validates basic requirements about the type that are common to both creator kinds. */
+ private void validateTypeRequirements() {
+ if (!type.getTypeParameters().isEmpty()) {
+ report.addError(messages.generics());
+ }
+
+ Set<Modifier> modifiers = type.getModifiers();
+ if (modifiers.contains(PRIVATE)) {
+ report.addError(messages.isPrivate());
+ }
+ if (!modifiers.contains(STATIC)) {
+ report.addError(messages.mustBeStatic());
+ }
+ // Note: Must be abstract, so no need to check for final.
+ if (!modifiers.contains(ABSTRACT)) {
+ report.addError(messages.mustBeAbstract());
+ }
+ }
+
+ private void validateBuilder() {
+ ExecutableElement buildMethod = null;
+ for (ExecutableElement method : elements.getUnimplementedMethods(type)) {
+ switch (method.getParameters().size()) {
+ case 0: // If this is potentially a build() method, validate it returns the correct type.
+ if (validateFactoryMethodReturnType(method)) {
+ if (buildMethod != null) {
+ // If we found more than one build-like method, fail.
+ error(
+ method,
+ messages.twoFactoryMethods(),
+ messages.inheritedTwoFactoryMethods(),
+ buildMethod);
+ }
+ }
+ // We set the buildMethod regardless of the return type to reduce error spam.
+ buildMethod = method;
+ break;
+
+ case 1: // If this correctly had one parameter, make sure the return types are valid.
+ validateSetterMethod(method);
+ break;
+
+ default: // more than one parameter
+ error(
+ method,
+ messages.setterMethodsMustTakeOneArg(),
+ messages.inheritedSetterMethodsMustTakeOneArg());
+ break;
+ }
+ }
+
+ if (buildMethod == null) {
+ report.addError(messages.missingFactoryMethod());
+ } else {
+ validateNotGeneric(buildMethod);
+ }
+ }
+
+ private void validateSetterMethod(ExecutableElement method) {
+ TypeMirror returnType = types.resolveExecutableType(method, type.asType()).getReturnType();
+ if (returnType.getKind() != TypeKind.VOID && !types.isSubtype(type.asType(), returnType)) {
+ error(
+ method,
+ messages.setterMethodsMustReturnVoidOrBuilder(),
+ messages.inheritedSetterMethodsMustReturnVoidOrBuilder());
+ }
+
+ validateNotGeneric(method);
+
+ VariableElement parameter = method.getParameters().get(0);
+
+ boolean methodIsBindsInstance = isAnnotationPresent(method, BindsInstance.class);
+ boolean parameterIsBindsInstance = isAnnotationPresent(parameter, BindsInstance.class);
+ boolean bindsInstance = methodIsBindsInstance || parameterIsBindsInstance;
+
+ if (methodIsBindsInstance && parameterIsBindsInstance) {
+ error(
+ method,
+ messages.bindsInstanceNotAllowedOnBothSetterMethodAndParameter(),
+ messages.inheritedBindsInstanceNotAllowedOnBothSetterMethodAndParameter());
+ }
+
+ if (!bindsInstance && parameter.asType().getKind().isPrimitive()) {
+ error(
+ method,
+ messages.nonBindsInstanceParametersMayNotBePrimitives(),
+ messages.inheritedNonBindsInstanceParametersMayNotBePrimitives());
+ }
+ }
+
+ private void validateFactory() {
+ ImmutableList<ExecutableElement> abstractMethods =
+ elements.getUnimplementedMethods(type).asList();
+ switch (abstractMethods.size()) {
+ case 0:
+ report.addError(messages.missingFactoryMethod());
+ return;
+ case 1:
+ break; // good
+ default:
+ error(
+ abstractMethods.get(1),
+ messages.twoFactoryMethods(),
+ messages.inheritedTwoFactoryMethods(),
+ abstractMethods.get(0));
+ return;
+ }
+
+ validateFactoryMethod(getOnlyElement(abstractMethods));
+ }
+
+ /** Validates that the given {@code method} is a valid component factory method. */
+ private void validateFactoryMethod(ExecutableElement method) {
+ validateNotGeneric(method);
+
+ if (!validateFactoryMethodReturnType(method)) {
+ // If we can't determine that the single method is a valid factory method, don't bother
+ // validating its parameters.
+ return;
+ }
+
+ for (VariableElement parameter : method.getParameters()) {
+ if (!isAnnotationPresent(parameter, BindsInstance.class)
+ && parameter.asType().getKind().isPrimitive()) {
+ error(
+ method,
+ messages.nonBindsInstanceParametersMayNotBePrimitives(),
+ messages.inheritedNonBindsInstanceParametersMayNotBePrimitives());
+ }
+ }
+ }
+
+ /**
+ * Validates that the factory method that actually returns a new component instance. Returns
+ * true if the return type was valid.
+ */
+ private boolean validateFactoryMethodReturnType(ExecutableElement method) {
+ TypeMirror returnType = types.resolveExecutableType(method, type.asType()).getReturnType();
+
+ if (!types.isSubtype(component.asType(), returnType)) {
+ error(
+ method,
+ messages.factoryMethodMustReturnComponentType(),
+ messages.inheritedFactoryMethodMustReturnComponentType());
+ return false;
+ }
+
+ if (isAnnotationPresent(method, BindsInstance.class)) {
+ error(
+ method,
+ messages.factoryMethodMayNotBeAnnotatedWithBindsInstance(),
+ messages.inheritedFactoryMethodMayNotBeAnnotatedWithBindsInstance());
+ return false;
+ }
+
+ TypeElement componentType = MoreElements.asType(component);
+ if (!types.isSameType(componentType.asType(), returnType)) {
+ ImmutableSet<ExecutableElement> methodsOnlyInComponent =
+ methodsOnlyInComponent(componentType);
+ if (!methodsOnlyInComponent.isEmpty()) {
+ report.addWarning(
+ messages.factoryMethodReturnsSupertypeWithMissingMethods(
+ componentType, type, returnType, method, methodsOnlyInComponent),
+ method);
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Generates one of two error messages. If the method is enclosed in the subject, we target the
+ * error to the method itself. Otherwise we target the error to the subject and list the method
+ * as an argument. (Otherwise we have no way of knowing if the method is being compiled in this
+ * pass too, so javac might not be able to pinpoint it's line of code.)
+ */
+ /*
+ * For Component.Builder, the prototypical example would be if someone had:
+ * libfoo: interface SharedBuilder { void badSetter(A a, B b); }
+ * libbar: BarComponent { BarBuilder extends SharedBuilder } }
+ * ... the compiler only validates BarBuilder when compiling libbar, but it fails because
+ * of libfoo's SharedBuilder (which could have been compiled in a previous pass).
+ * So we can't point to SharedBuilder#badSetter as the subject of the BarBuilder validation
+ * failure.
+ *
+ * This check is a little more strict than necessary -- ideally we'd check if method's enclosing
+ * class was included in this compile run. But that's hard, and this is close enough.
+ */
+ private void error(
+ ExecutableElement method,
+ String enclosedError,
+ String inheritedError,
+ Object... extraArgs) {
+ if (method.getEnclosingElement().equals(type)) {
+ report.addError(String.format(enclosedError, extraArgs), method);
+ } else {
+ report.addError(String.format(inheritedError, ObjectArrays.concat(extraArgs, method)));
+ }
+ }
+
+ /** Validates that the given {@code method} is not generic. * */
+ private void validateNotGeneric(ExecutableElement method) {
+ if (!method.getTypeParameters().isEmpty()) {
+ error(
+ method,
+ messages.methodsMayNotHaveTypeParameters(),
+ messages.inheritedMethodsMayNotHaveTypeParameters());
+ }
+ }
+
+ /**
+ * Returns all methods defind in {@code componentType} which are not inherited from a supertype.
+ */
+ private ImmutableSet<ExecutableElement> methodsOnlyInComponent(TypeElement componentType) {
+ // TODO(ronshapiro): Ideally this shouldn't return methods which are redeclared from a
+ // supertype, but do not change the return type. We don't have a good/simple way of checking
+ // that, and it doesn't seem likely, so the warning won't be too bad.
+ return ImmutableSet.copyOf(methodsIn(componentType.getEnclosedElements()));
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/ComponentDescriptorValidator.java b/java/dagger/internal/codegen/validation/ComponentDescriptorValidator.java
new file mode 100644
index 0000000..aa20232
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/ComponentDescriptorValidator.java
@@ -0,0 +1,493 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static com.google.auto.common.MoreTypes.asDeclared;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Predicates.in;
+import static com.google.common.collect.Collections2.transform;
+import static dagger.internal.codegen.base.ComponentAnnotation.rootComponentAnnotation;
+import static dagger.internal.codegen.base.DiagnosticFormatting.stripCommonTypePrefixes;
+import static dagger.internal.codegen.base.Formatter.INDENT;
+import static dagger.internal.codegen.base.Scopes.getReadableSource;
+import static dagger.internal.codegen.base.Scopes.scopesOf;
+import static dagger.internal.codegen.base.Scopes.singletonScope;
+import static dagger.internal.codegen.base.Util.reentrantComputeIfAbsent;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSetMultimap;
+import static java.util.stream.Collectors.joining;
+import static java.util.stream.Collectors.toList;
+import static javax.tools.Diagnostic.Kind.ERROR;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.MoreTypes;
+import com.google.common.base.Equivalence.Wrapper;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSetMultimap;
+import com.google.common.collect.Multimaps;
+import com.google.common.collect.Sets;
+import dagger.internal.codegen.binding.ComponentCreatorDescriptor;
+import dagger.internal.codegen.binding.ComponentDescriptor;
+import dagger.internal.codegen.binding.ComponentRequirement;
+import dagger.internal.codegen.binding.ComponentRequirement.NullPolicy;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.binding.ErrorMessages;
+import dagger.internal.codegen.binding.ErrorMessages.ComponentCreatorMessages;
+import dagger.internal.codegen.binding.MethodSignatureFormatter;
+import dagger.internal.codegen.binding.ModuleDescriptor;
+import dagger.internal.codegen.compileroption.CompilerOptions;
+import dagger.internal.codegen.compileroption.ValidationType;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.Scope;
+import java.util.ArrayDeque;
+import java.util.Collection;
+import java.util.Deque;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Optional;
+import java.util.Set;
+import java.util.StringJoiner;
+import javax.inject.Inject;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.ExecutableType;
+import javax.lang.model.type.TypeMirror;
+import javax.tools.Diagnostic;
+
+/**
+ * Reports errors in the component hierarchy.
+ *
+ * <ul>
+ * <li>Validates scope hierarchy of component dependencies and subcomponents.
+ * <li>Reports errors if there are component dependency cycles.
+ * <li>Reports errors if any abstract modules have non-abstract instance binding methods.
+ * <li>Validates component creator types.
+ * </ul>
+ */
+// TODO(dpb): Combine with ComponentHierarchyValidator.
+public final class ComponentDescriptorValidator {
+
+ private final DaggerElements elements;
+ private final DaggerTypes types;
+ private final CompilerOptions compilerOptions;
+ private final MethodSignatureFormatter methodSignatureFormatter;
+ private final ComponentHierarchyValidator componentHierarchyValidator;
+ private final KotlinMetadataUtil metadataUtil;
+
+ @Inject
+ ComponentDescriptorValidator(
+ DaggerElements elements,
+ DaggerTypes types,
+ CompilerOptions compilerOptions,
+ MethodSignatureFormatter methodSignatureFormatter,
+ ComponentHierarchyValidator componentHierarchyValidator,
+ KotlinMetadataUtil metadataUtil) {
+ this.elements = elements;
+ this.types = types;
+ this.compilerOptions = compilerOptions;
+ this.methodSignatureFormatter = methodSignatureFormatter;
+ this.componentHierarchyValidator = componentHierarchyValidator;
+ this.metadataUtil = metadataUtil;
+ }
+
+ public ValidationReport<TypeElement> validate(ComponentDescriptor component) {
+ ComponentValidation validation = new ComponentValidation(component);
+ validation.visitComponent(component);
+ validation.report(component).addSubreport(componentHierarchyValidator.validate(component));
+ return validation.buildReport();
+ }
+
+ private final class ComponentValidation {
+ final ComponentDescriptor rootComponent;
+ final Map<ComponentDescriptor, ValidationReport.Builder<TypeElement>> reports =
+ new LinkedHashMap<>();
+
+ ComponentValidation(ComponentDescriptor rootComponent) {
+ this.rootComponent = checkNotNull(rootComponent);
+ }
+
+ /** Returns a report that contains all validation messages found during traversal. */
+ ValidationReport<TypeElement> buildReport() {
+ ValidationReport.Builder<TypeElement> report =
+ ValidationReport.about(rootComponent.typeElement());
+ reports.values().forEach(subreport -> report.addSubreport(subreport.build()));
+ return report.build();
+ }
+
+ /** Returns the report builder for a (sub)component. */
+ private ValidationReport.Builder<TypeElement> report(ComponentDescriptor component) {
+ return reentrantComputeIfAbsent(
+ reports, component, descriptor -> ValidationReport.about(descriptor.typeElement()));
+ }
+
+ private void reportComponentItem(
+ Diagnostic.Kind kind, ComponentDescriptor component, String message) {
+ report(component)
+ .addItem(message, kind, component.typeElement(), component.annotation().annotation());
+ }
+
+ private void reportComponentError(ComponentDescriptor component, String error) {
+ reportComponentItem(ERROR, component, error);
+ }
+
+ void visitComponent(ComponentDescriptor component) {
+ validateDependencyScopes(component);
+ validateComponentDependencyHierarchy(component);
+ validateModules(component);
+ validateCreators(component);
+ component.childComponents().forEach(this::visitComponent);
+ }
+
+ /** Validates that component dependencies do not form a cycle. */
+ private void validateComponentDependencyHierarchy(ComponentDescriptor component) {
+ validateComponentDependencyHierarchy(component, component.typeElement(), new ArrayDeque<>());
+ }
+
+ /** Recursive method to validate that component dependencies do not form a cycle. */
+ private void validateComponentDependencyHierarchy(
+ ComponentDescriptor component, TypeElement dependency, Deque<TypeElement> dependencyStack) {
+ if (dependencyStack.contains(dependency)) {
+ // Current component has already appeared in the component chain.
+ StringBuilder message = new StringBuilder();
+ message.append(component.typeElement().getQualifiedName());
+ message.append(" contains a cycle in its component dependencies:\n");
+ dependencyStack.push(dependency);
+ appendIndentedComponentsList(message, dependencyStack);
+ dependencyStack.pop();
+ reportComponentItem(
+ compilerOptions.scopeCycleValidationType().diagnosticKind().get(),
+ component,
+ message.toString());
+ } else if (compilerOptions.validateTransitiveComponentDependencies()
+ // Always validate direct component dependencies referenced by this component regardless
+ // of the flag value
+ || dependencyStack.isEmpty()) {
+ rootComponentAnnotation(dependency)
+ .ifPresent(
+ componentAnnotation -> {
+ dependencyStack.push(dependency);
+
+ for (TypeElement nextDependency : componentAnnotation.dependencies()) {
+ validateComponentDependencyHierarchy(
+ component, nextDependency, dependencyStack);
+ }
+
+ dependencyStack.pop();
+ });
+ }
+ }
+
+ /**
+ * Validates that among the dependencies there are no cycles within the scoping chain, and that
+ * singleton components have no scoped dependencies.
+ */
+ private void validateDependencyScopes(ComponentDescriptor component) {
+ ImmutableSet<Scope> scopes = component.scopes();
+ ImmutableSet<TypeElement> scopedDependencies =
+ scopedTypesIn(
+ component
+ .dependencies()
+ .stream()
+ .map(ComponentRequirement::typeElement)
+ .collect(toImmutableSet()));
+ if (!scopes.isEmpty()) {
+ Scope singletonScope = singletonScope(elements);
+ // Dagger 1.x scope compatibility requires this be suppress-able.
+ if (compilerOptions.scopeCycleValidationType().diagnosticKind().isPresent()
+ && scopes.contains(singletonScope)) {
+ // Singleton is a special-case representing the longest lifetime, and therefore
+ // @Singleton components may not depend on scoped components
+ if (!scopedDependencies.isEmpty()) {
+ StringBuilder message =
+ new StringBuilder(
+ "This @Singleton component cannot depend on scoped components:\n");
+ appendIndentedComponentsList(message, scopedDependencies);
+ reportComponentItem(
+ compilerOptions.scopeCycleValidationType().diagnosticKind().get(),
+ component,
+ message.toString());
+ }
+ } else {
+ // Dagger 1.x scope compatibility requires this be suppress-able.
+ if (!compilerOptions.scopeCycleValidationType().equals(ValidationType.NONE)) {
+ validateDependencyScopeHierarchy(
+ component, component.typeElement(), new ArrayDeque<>(), new ArrayDeque<>());
+ }
+ }
+ } else {
+ // Scopeless components may not depend on scoped components.
+ if (!scopedDependencies.isEmpty()) {
+ StringBuilder message =
+ new StringBuilder(component.typeElement().getQualifiedName())
+ .append(" (unscoped) cannot depend on scoped components:\n");
+ appendIndentedComponentsList(message, scopedDependencies);
+ reportComponentError(component, message.toString());
+ }
+ }
+ }
+
+ private void validateModules(ComponentDescriptor component) {
+ for (ModuleDescriptor module : component.modules()) {
+ if (module.moduleElement().getModifiers().contains(Modifier.ABSTRACT)) {
+ for (ContributionBinding binding : module.bindings()) {
+ if (binding.requiresModuleInstance()) {
+ report(component).addError(abstractModuleHasInstanceBindingMethodsError(module));
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ private String abstractModuleHasInstanceBindingMethodsError(ModuleDescriptor module) {
+ String methodAnnotations;
+ switch (module.kind()) {
+ case MODULE:
+ methodAnnotations = "@Provides";
+ break;
+ case PRODUCER_MODULE:
+ methodAnnotations = "@Provides or @Produces";
+ break;
+ default:
+ throw new AssertionError(module.kind());
+ }
+ return String.format(
+ "%s is abstract and has instance %s methods. Consider making the methods static or "
+ + "including a non-abstract subclass of the module instead.",
+ module.moduleElement(), methodAnnotations);
+ }
+
+ private void validateCreators(ComponentDescriptor component) {
+ if (!component.creatorDescriptor().isPresent()) {
+ // If no builder, nothing to validate.
+ return;
+ }
+
+ ComponentCreatorDescriptor creator = component.creatorDescriptor().get();
+ ComponentCreatorMessages messages = ErrorMessages.creatorMessagesFor(creator.annotation());
+
+ // Requirements for modules and dependencies that the creator can set
+ Set<ComponentRequirement> creatorModuleAndDependencyRequirements =
+ creator.moduleAndDependencyRequirements();
+ // Modules and dependencies the component requires
+ Set<ComponentRequirement> componentModuleAndDependencyRequirements =
+ component.dependenciesAndConcreteModules();
+
+ // Requirements that the creator can set that don't match any requirements that the component
+ // actually has.
+ Set<ComponentRequirement> inapplicableRequirementsOnCreator =
+ Sets.difference(
+ creatorModuleAndDependencyRequirements, componentModuleAndDependencyRequirements);
+
+ DeclaredType container = asDeclared(creator.typeElement().asType());
+ if (!inapplicableRequirementsOnCreator.isEmpty()) {
+ Collection<Element> excessElements =
+ Multimaps.filterKeys(
+ creator.unvalidatedRequirementElements(), in(inapplicableRequirementsOnCreator))
+ .values();
+ String formatted =
+ excessElements.stream()
+ .map(element -> formatElement(element, container))
+ .collect(joining(", ", "[", "]"));
+ report(component)
+ .addError(String.format(messages.extraSetters(), formatted), creator.typeElement());
+ }
+
+ // Component requirements that the creator must be able to set
+ Set<ComponentRequirement> mustBePassed =
+ Sets.filter(
+ componentModuleAndDependencyRequirements,
+ input -> input.nullPolicy(elements, types, metadataUtil).equals(NullPolicy.THROW));
+ // Component requirements that the creator must be able to set, but can't
+ Set<ComponentRequirement> missingRequirements =
+ Sets.difference(mustBePassed, creatorModuleAndDependencyRequirements);
+
+ if (!missingRequirements.isEmpty()) {
+ report(component)
+ .addError(
+ String.format(
+ messages.missingSetters(),
+ missingRequirements.stream().map(ComponentRequirement::type).collect(toList())),
+ creator.typeElement());
+ }
+
+ // Validate that declared creator requirements (modules, dependencies) have unique types.
+ ImmutableSetMultimap<Wrapper<TypeMirror>, Element> declaredRequirementsByType =
+ Multimaps.filterKeys(
+ creator.unvalidatedRequirementElements(),
+ creatorModuleAndDependencyRequirements::contains)
+ .entries().stream()
+ .collect(
+ toImmutableSetMultimap(entry -> entry.getKey().wrappedType(), Entry::getValue));
+ declaredRequirementsByType
+ .asMap()
+ .forEach(
+ (typeWrapper, elementsForType) -> {
+ if (elementsForType.size() > 1) {
+ TypeMirror type = typeWrapper.get();
+ // TODO(cgdecker): Attach this error message to the factory method rather than
+ // the component type if the elements are factory method parameters AND the
+ // factory method is defined by the factory type itself and not by a supertype.
+ report(component)
+ .addError(
+ String.format(
+ messages.multipleSettersForModuleOrDependencyType(),
+ type,
+ transform(
+ elementsForType, element -> formatElement(element, container))),
+ creator.typeElement());
+ }
+ });
+
+ // TODO(cgdecker): Duplicate binding validation should handle the case of multiple elements
+ // that set the same bound-instance Key, but validating that here would make it fail faster
+ // for subcomponents.
+ }
+
+ private String formatElement(Element element, DeclaredType container) {
+ // TODO(cgdecker): Extract some or all of this to another class?
+ // But note that it does different formatting for parameters than
+ // DaggerElements.elementToString(Element).
+ switch (element.getKind()) {
+ case METHOD:
+ return methodSignatureFormatter.format(
+ MoreElements.asExecutable(element), Optional.of(container));
+ case PARAMETER:
+ return formatParameter(MoreElements.asVariable(element), container);
+ default:
+ // This method shouldn't be called with any other type of element.
+ throw new AssertionError();
+ }
+ }
+
+ private String formatParameter(VariableElement parameter, DeclaredType container) {
+ // TODO(cgdecker): Possibly leave the type (and annotations?) off of the parameters here and
+ // just use their names, since the type will be redundant in the context of the error message.
+ StringJoiner joiner = new StringJoiner(" ");
+ parameter.getAnnotationMirrors().stream().map(Object::toString).forEach(joiner::add);
+ TypeMirror parameterType = resolveParameterType(parameter, container);
+ return joiner
+ .add(stripCommonTypePrefixes(parameterType.toString()))
+ .add(parameter.getSimpleName())
+ .toString();
+ }
+
+ private TypeMirror resolveParameterType(VariableElement parameter, DeclaredType container) {
+ ExecutableElement method =
+ MoreElements.asExecutable(parameter.getEnclosingElement());
+ int parameterIndex = method.getParameters().indexOf(parameter);
+
+ ExecutableType methodType = MoreTypes.asExecutable(types.asMemberOf(container, method));
+ return methodType.getParameterTypes().get(parameterIndex);
+ }
+
+ /**
+ * Validates that scopes do not participate in a scoping cycle - that is to say, scoped
+ * components are in a hierarchical relationship terminating with Singleton.
+ *
+ * <p>As a side-effect, this means scoped components cannot have a dependency cycle between
+ * themselves, since a component's presence within its own dependency path implies a cyclical
+ * relationship between scopes. However, cycles in component dependencies are explicitly checked
+ * in {@link #validateComponentDependencyHierarchy(ComponentDescriptor)}.
+ */
+ private void validateDependencyScopeHierarchy(
+ ComponentDescriptor component,
+ TypeElement dependency,
+ Deque<ImmutableSet<Scope>> scopeStack,
+ Deque<TypeElement> scopedDependencyStack) {
+ ImmutableSet<Scope> scopes = scopesOf(dependency);
+ if (stackOverlaps(scopeStack, scopes)) {
+ scopedDependencyStack.push(dependency);
+ // Current scope has already appeared in the component chain.
+ StringBuilder message = new StringBuilder();
+ message.append(component.typeElement().getQualifiedName());
+ message.append(" depends on scoped components in a non-hierarchical scope ordering:\n");
+ appendIndentedComponentsList(message, scopedDependencyStack);
+ if (compilerOptions.scopeCycleValidationType().diagnosticKind().isPresent()) {
+ reportComponentItem(
+ compilerOptions.scopeCycleValidationType().diagnosticKind().get(),
+ component,
+ message.toString());
+ }
+ scopedDependencyStack.pop();
+ } else if (compilerOptions.validateTransitiveComponentDependencies()
+ // Always validate direct component dependencies referenced by this component regardless
+ // of the flag value
+ || scopedDependencyStack.isEmpty()) {
+ // TODO(beder): transitively check scopes of production components too.
+ rootComponentAnnotation(dependency)
+ .filter(componentAnnotation -> !componentAnnotation.isProduction())
+ .ifPresent(
+ componentAnnotation -> {
+ ImmutableSet<TypeElement> scopedDependencies =
+ scopedTypesIn(componentAnnotation.dependencies());
+ if (!scopedDependencies.isEmpty()) {
+ // empty can be ignored (base-case)
+ scopeStack.push(scopes);
+ scopedDependencyStack.push(dependency);
+ for (TypeElement scopedDependency : scopedDependencies) {
+ validateDependencyScopeHierarchy(
+ component,
+ scopedDependency,
+ scopeStack,
+ scopedDependencyStack);
+ }
+ scopedDependencyStack.pop();
+ scopeStack.pop();
+ }
+ }); // else: we skip component dependencies which are not components
+ }
+ }
+
+ private <T> boolean stackOverlaps(Deque<ImmutableSet<T>> stack, ImmutableSet<T> set) {
+ for (ImmutableSet<T> entry : stack) {
+ if (!Sets.intersection(entry, set).isEmpty()) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /** Appends and formats a list of indented component types (with their scope annotations). */
+ private void appendIndentedComponentsList(StringBuilder message, Iterable<TypeElement> types) {
+ for (TypeElement scopedComponent : types) {
+ message.append(INDENT);
+ for (Scope scope : scopesOf(scopedComponent)) {
+ message.append(getReadableSource(scope)).append(' ');
+ }
+ message
+ .append(stripCommonTypePrefixes(scopedComponent.getQualifiedName().toString()))
+ .append('\n');
+ }
+ }
+
+ /**
+ * Returns a set of type elements containing only those found in the input set that have a
+ * scoping annotation.
+ */
+ private ImmutableSet<TypeElement> scopedTypesIn(Collection<TypeElement> types) {
+ return types.stream().filter(type -> !scopesOf(type).isEmpty()).collect(toImmutableSet());
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/ComponentHierarchyValidator.java b/java/dagger/internal/codegen/validation/ComponentHierarchyValidator.java
new file mode 100644
index 0000000..1861636
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/ComponentHierarchyValidator.java
@@ -0,0 +1,273 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static com.google.common.base.Functions.constant;
+import static com.google.common.base.Predicates.and;
+import static com.google.common.base.Predicates.in;
+import static com.google.common.base.Predicates.not;
+import static dagger.internal.codegen.base.Scopes.getReadableSource;
+import static dagger.internal.codegen.base.Scopes.uniqueScopeOf;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+
+import com.google.auto.common.MoreTypes;
+import com.google.common.base.Joiner;
+import com.google.common.base.Predicate;
+import com.google.common.collect.FluentIterable;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSetMultimap;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.LinkedHashMultimap;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multimaps;
+import com.google.common.collect.SetMultimap;
+import com.google.common.collect.Sets;
+import dagger.internal.codegen.binding.ComponentDescriptor;
+import dagger.internal.codegen.binding.ComponentDescriptor.ComponentMethodDescriptor;
+import dagger.internal.codegen.binding.ModuleDescriptor;
+import dagger.internal.codegen.binding.ModuleKind;
+import dagger.internal.codegen.compileroption.CompilerOptions;
+import dagger.model.Scope;
+import java.util.Collection;
+import java.util.Formatter;
+import java.util.Map;
+import javax.inject.Inject;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+
+/** Validates the relationships between parent components and subcomponents. */
+final class ComponentHierarchyValidator {
+ private static final Joiner COMMA_SEPARATED_JOINER = Joiner.on(", ");
+ private final CompilerOptions compilerOptions;
+
+ @Inject
+ ComponentHierarchyValidator(CompilerOptions compilerOptions) {
+ this.compilerOptions = compilerOptions;
+ }
+
+ ValidationReport<TypeElement> validate(ComponentDescriptor componentDescriptor) {
+ ValidationReport.Builder<TypeElement> report =
+ ValidationReport.about(componentDescriptor.typeElement());
+ validateSubcomponentMethods(
+ report,
+ componentDescriptor,
+ Maps.toMap(componentDescriptor.moduleTypes(), constant(componentDescriptor.typeElement())));
+ validateRepeatedScopedDeclarations(report, componentDescriptor, LinkedHashMultimap.create());
+
+ if (compilerOptions.scopeCycleValidationType().diagnosticKind().isPresent()) {
+ validateScopeHierarchy(
+ report, componentDescriptor, LinkedHashMultimap.<ComponentDescriptor, Scope>create());
+ }
+ validateProductionModuleUniqueness(report, componentDescriptor, LinkedHashMultimap.create());
+ return report.build();
+ }
+
+ private void validateSubcomponentMethods(
+ ValidationReport.Builder<?> report,
+ ComponentDescriptor componentDescriptor,
+ ImmutableMap<TypeElement, TypeElement> existingModuleToOwners) {
+ componentDescriptor
+ .childComponentsDeclaredByFactoryMethods()
+ .forEach(
+ (method, childComponent) -> {
+ if (childComponent.hasCreator()) {
+ report.addError(
+ "Components may not have factory methods for subcomponents that define a "
+ + "builder.",
+ method.methodElement());
+ } else {
+ validateFactoryMethodParameters(report, method, existingModuleToOwners);
+ }
+
+ validateSubcomponentMethods(
+ report,
+ childComponent,
+ new ImmutableMap.Builder<TypeElement, TypeElement>()
+ .putAll(existingModuleToOwners)
+ .putAll(
+ Maps.toMap(
+ Sets.difference(
+ childComponent.moduleTypes(), existingModuleToOwners.keySet()),
+ constant(childComponent.typeElement())))
+ .build());
+ });
+ }
+
+ private void validateFactoryMethodParameters(
+ ValidationReport.Builder<?> report,
+ ComponentMethodDescriptor subcomponentMethodDescriptor,
+ ImmutableMap<TypeElement, TypeElement> existingModuleToOwners) {
+ for (VariableElement factoryMethodParameter :
+ subcomponentMethodDescriptor.methodElement().getParameters()) {
+ TypeElement moduleType = MoreTypes.asTypeElement(factoryMethodParameter.asType());
+ TypeElement originatingComponent = existingModuleToOwners.get(moduleType);
+ if (originatingComponent != null) {
+ /* Factory method tries to pass a module that is already present in the parent.
+ * This is an error. */
+ report.addError(
+ String.format(
+ "%s is present in %s. A subcomponent cannot use an instance of a "
+ + "module that differs from its parent.",
+ moduleType.getSimpleName(), originatingComponent.getQualifiedName()),
+ factoryMethodParameter);
+ }
+ }
+ }
+
+ /**
+ * Checks that components do not have any scopes that are also applied on any of their ancestors.
+ */
+ private void validateScopeHierarchy(
+ ValidationReport.Builder<TypeElement> report,
+ ComponentDescriptor subject,
+ SetMultimap<ComponentDescriptor, Scope> scopesByComponent) {
+ scopesByComponent.putAll(subject, subject.scopes());
+
+ for (ComponentDescriptor childComponent : subject.childComponents()) {
+ validateScopeHierarchy(report, childComponent, scopesByComponent);
+ }
+
+ scopesByComponent.removeAll(subject);
+
+ Predicate<Scope> subjectScopes =
+ subject.isProduction()
+ // TODO(beder): validate that @ProductionScope is only applied on production components
+ ? and(in(subject.scopes()), not(Scope::isProductionScope))
+ : in(subject.scopes());
+ SetMultimap<ComponentDescriptor, Scope> overlappingScopes =
+ Multimaps.filterValues(scopesByComponent, subjectScopes);
+ if (!overlappingScopes.isEmpty()) {
+ StringBuilder error =
+ new StringBuilder()
+ .append(subject.typeElement().getQualifiedName())
+ .append(" has conflicting scopes:");
+ for (Map.Entry<ComponentDescriptor, Scope> entry : overlappingScopes.entries()) {
+ Scope scope = entry.getValue();
+ error
+ .append("\n ")
+ .append(entry.getKey().typeElement().getQualifiedName())
+ .append(" also has ")
+ .append(getReadableSource(scope));
+ }
+ report.addItem(
+ error.toString(),
+ compilerOptions.scopeCycleValidationType().diagnosticKind().get(),
+ subject.typeElement());
+ }
+ }
+
+ private void validateProductionModuleUniqueness(
+ ValidationReport.Builder<TypeElement> report,
+ ComponentDescriptor componentDescriptor,
+ SetMultimap<ComponentDescriptor, ModuleDescriptor> producerModulesByComponent) {
+ ImmutableSet<ModuleDescriptor> producerModules =
+ componentDescriptor.modules().stream()
+ .filter(module -> module.kind().equals(ModuleKind.PRODUCER_MODULE))
+ .collect(toImmutableSet());
+
+ producerModulesByComponent.putAll(componentDescriptor, producerModules);
+ for (ComponentDescriptor childComponent : componentDescriptor.childComponents()) {
+ validateProductionModuleUniqueness(report, childComponent, producerModulesByComponent);
+ }
+ producerModulesByComponent.removeAll(componentDescriptor);
+
+
+ SetMultimap<ComponentDescriptor, ModuleDescriptor> repeatedModules =
+ Multimaps.filterValues(producerModulesByComponent, producerModules::contains);
+ if (repeatedModules.isEmpty()) {
+ return;
+ }
+
+ StringBuilder error = new StringBuilder();
+ Formatter formatter = new Formatter(error);
+
+ formatter.format("%s repeats @ProducerModules:", componentDescriptor.typeElement());
+
+ for (Map.Entry<ComponentDescriptor, Collection<ModuleDescriptor>> entry :
+ repeatedModules.asMap().entrySet()) {
+ formatter.format("\n %s also installs: ", entry.getKey().typeElement());
+ COMMA_SEPARATED_JOINER
+ .appendTo(error, Iterables.transform(entry.getValue(), m -> m.moduleElement()));
+ }
+
+ report.addError(error.toString());
+ }
+
+ private void validateRepeatedScopedDeclarations(
+ ValidationReport.Builder<TypeElement> report,
+ ComponentDescriptor component,
+ // TODO(ronshapiro): optimize ModuleDescriptor.hashCode()/equals. Otherwise this could be
+ // quite costly
+ SetMultimap<ComponentDescriptor, ModuleDescriptor> modulesWithScopes) {
+ ImmutableSet<ModuleDescriptor> modules =
+ component.modules().stream().filter(this::hasScopedDeclarations).collect(toImmutableSet());
+ modulesWithScopes.putAll(component, modules);
+ for (ComponentDescriptor childComponent : component.childComponents()) {
+ validateRepeatedScopedDeclarations(report, childComponent, modulesWithScopes);
+ }
+ modulesWithScopes.removeAll(component);
+
+ SetMultimap<ComponentDescriptor, ModuleDescriptor> repeatedModules =
+ Multimaps.filterValues(modulesWithScopes, modules::contains);
+ if (repeatedModules.isEmpty()) {
+ return;
+ }
+
+ report.addError(
+ repeatedModulesWithScopeError(component, ImmutableSetMultimap.copyOf(repeatedModules)));
+ }
+
+ private boolean hasScopedDeclarations(ModuleDescriptor module) {
+ return !moduleScopes(module).isEmpty();
+ }
+
+ private String repeatedModulesWithScopeError(
+ ComponentDescriptor component,
+ ImmutableSetMultimap<ComponentDescriptor, ModuleDescriptor> repeatedModules) {
+ StringBuilder error =
+ new StringBuilder()
+ .append(component.typeElement().getQualifiedName())
+ .append(" repeats modules with scoped bindings or declarations:");
+
+ repeatedModules
+ .asMap()
+ .forEach(
+ (conflictingComponent, conflictingModules) -> {
+ error
+ .append("\n - ")
+ .append(conflictingComponent.typeElement().getQualifiedName())
+ .append(" also includes:");
+ for (ModuleDescriptor conflictingModule : conflictingModules) {
+ error
+ .append("\n - ")
+ .append(conflictingModule.moduleElement().getQualifiedName())
+ .append(" with scopes: ")
+ .append(COMMA_SEPARATED_JOINER.join(moduleScopes(conflictingModule)));
+ }
+ });
+ return error.toString();
+ }
+
+ private ImmutableSet<Scope> moduleScopes(ModuleDescriptor module) {
+ return FluentIterable.concat(module.allBindingDeclarations())
+ .transform(declaration -> uniqueScopeOf(declaration.bindingElement().get()))
+ .filter(scope -> scope.isPresent() && !scope.get().isReusable())
+ .transform(scope -> scope.get())
+ .toSet();
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/ComponentValidator.java b/java/dagger/internal/codegen/validation/ComponentValidator.java
new file mode 100644
index 0000000..b3322e5
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/ComponentValidator.java
@@ -0,0 +1,558 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static com.google.auto.common.MoreElements.asType;
+import static com.google.auto.common.MoreElements.getLocalAndInheritedMethods;
+import static com.google.auto.common.MoreElements.isAnnotationPresent;
+import static com.google.auto.common.MoreTypes.asDeclared;
+import static com.google.auto.common.MoreTypes.asExecutable;
+import static com.google.auto.common.MoreTypes.asTypeElement;
+import static com.google.common.base.Verify.verify;
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static com.google.common.collect.Multimaps.asMap;
+import static com.google.common.collect.Sets.intersection;
+import static dagger.internal.codegen.base.ComponentAnnotation.anyComponentAnnotation;
+import static dagger.internal.codegen.base.ModuleAnnotation.moduleAnnotation;
+import static dagger.internal.codegen.base.Util.reentrantComputeIfAbsent;
+import static dagger.internal.codegen.binding.ComponentCreatorAnnotation.creatorAnnotationsFor;
+import static dagger.internal.codegen.binding.ComponentCreatorAnnotation.productionCreatorAnnotations;
+import static dagger.internal.codegen.binding.ComponentCreatorAnnotation.subcomponentCreatorAnnotations;
+import static dagger.internal.codegen.binding.ComponentKind.annotationsFor;
+import static dagger.internal.codegen.binding.ConfigurationAnnotations.enclosedAnnotatedTypes;
+import static dagger.internal.codegen.binding.ConfigurationAnnotations.getTransitiveModules;
+import static dagger.internal.codegen.binding.ErrorMessages.ComponentCreatorMessages.builderMethodRequiresNoArgs;
+import static dagger.internal.codegen.binding.ErrorMessages.ComponentCreatorMessages.moreThanOneRefToSubcomponent;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static dagger.internal.codegen.langmodel.DaggerElements.getAnnotationMirror;
+import static dagger.internal.codegen.langmodel.DaggerElements.getAnyAnnotation;
+import static java.util.Comparator.comparing;
+import static javax.lang.model.element.ElementKind.CLASS;
+import static javax.lang.model.element.ElementKind.INTERFACE;
+import static javax.lang.model.element.Modifier.ABSTRACT;
+import static javax.lang.model.type.TypeKind.VOID;
+import static javax.lang.model.util.ElementFilter.methodsIn;
+
+import com.google.auto.common.MoreTypes;
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.LinkedHashMultimap;
+import com.google.common.collect.Maps;
+import com.google.common.collect.SetMultimap;
+import com.google.common.collect.Sets;
+import dagger.Component;
+import dagger.Reusable;
+import dagger.internal.codegen.base.ClearableCache;
+import dagger.internal.codegen.base.ComponentAnnotation;
+import dagger.internal.codegen.binding.ComponentKind;
+import dagger.internal.codegen.binding.DependencyRequestFactory;
+import dagger.internal.codegen.binding.ErrorMessages;
+import dagger.internal.codegen.binding.MethodSignatureFormatter;
+import dagger.internal.codegen.binding.ModuleKind;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.DependencyRequest;
+import dagger.model.Key;
+import dagger.producers.CancellationPolicy;
+import dagger.producers.ProductionComponent;
+import java.lang.annotation.Annotation;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.ExecutableType;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.type.TypeVisitor;
+import javax.lang.model.util.SimpleTypeVisitor8;
+
+/**
+ * Performs superficial validation of the contract of the {@link Component} and {@link
+ * ProductionComponent} annotations.
+ */
+@Singleton
+public final class ComponentValidator implements ClearableCache {
+ private final DaggerElements elements;
+ private final DaggerTypes types;
+ private final ModuleValidator moduleValidator;
+ private final ComponentCreatorValidator creatorValidator;
+ private final DependencyRequestValidator dependencyRequestValidator;
+ private final MembersInjectionValidator membersInjectionValidator;
+ private final MethodSignatureFormatter methodSignatureFormatter;
+ private final DependencyRequestFactory dependencyRequestFactory;
+ private final Map<TypeElement, ValidationReport<TypeElement>> reports = new HashMap<>();
+
+ @Inject
+ ComponentValidator(
+ DaggerElements elements,
+ DaggerTypes types,
+ ModuleValidator moduleValidator,
+ ComponentCreatorValidator creatorValidator,
+ DependencyRequestValidator dependencyRequestValidator,
+ MembersInjectionValidator membersInjectionValidator,
+ MethodSignatureFormatter methodSignatureFormatter,
+ DependencyRequestFactory dependencyRequestFactory) {
+ this.elements = elements;
+ this.types = types;
+ this.moduleValidator = moduleValidator;
+ this.creatorValidator = creatorValidator;
+ this.dependencyRequestValidator = dependencyRequestValidator;
+ this.membersInjectionValidator = membersInjectionValidator;
+ this.methodSignatureFormatter = methodSignatureFormatter;
+ this.dependencyRequestFactory = dependencyRequestFactory;
+ }
+
+ @Override
+ public void clearCache() {
+ reports.clear();
+ }
+
+ /** Validates the given component. */
+ public ValidationReport<TypeElement> validate(TypeElement component) {
+ return reentrantComputeIfAbsent(reports, component, this::validateUncached);
+ }
+
+ private ValidationReport<TypeElement> validateUncached(TypeElement component) {
+ return new ElementValidator(component).validateElement();
+ }
+
+ private class ElementValidator {
+ private final TypeElement component;
+ private final ValidationReport.Builder<TypeElement> report;
+ private final ImmutableSet<ComponentKind> componentKinds;
+
+ // Populated by ComponentMethodValidators
+ private final SetMultimap<Element, ExecutableElement> referencedSubcomponents =
+ LinkedHashMultimap.create();
+
+ ElementValidator(TypeElement component) {
+ this.component = component;
+ this.report = ValidationReport.about(component);
+ this.componentKinds = ComponentKind.getComponentKinds(component);
+ }
+
+ private ComponentKind componentKind() {
+ return getOnlyElement(componentKinds);
+ }
+
+ private ComponentAnnotation componentAnnotation() {
+ return anyComponentAnnotation(component).get();
+ }
+
+ private DeclaredType componentType() {
+ return asDeclared(component.asType());
+ }
+
+ ValidationReport<TypeElement> validateElement() {
+ if (componentKinds.size() > 1) {
+ return moreThanOneComponentAnnotation();
+ }
+
+ validateUseOfCancellationPolicy();
+ validateIsAbstractType();
+ validateCreators();
+ validateNoReusableAnnotation();
+ validateComponentMethods();
+ validateNoConflictingEntryPoints();
+ validateSubcomponentReferences();
+ validateComponentDependencies();
+ validateReferencedModules();
+ validateSubcomponents();
+
+ return report.build();
+ }
+
+ private ValidationReport<TypeElement> moreThanOneComponentAnnotation() {
+ String error =
+ "Components may not be annotated with more than one component annotation: found "
+ + annotationsFor(componentKinds);
+ report.addError(error, component);
+ return report.build();
+ }
+
+ private void validateUseOfCancellationPolicy() {
+ if (isAnnotationPresent(component, CancellationPolicy.class)
+ && !componentKind().isProducer()) {
+ report.addError(
+ "@CancellationPolicy may only be applied to production components and subcomponents",
+ component);
+ }
+ }
+
+ private void validateIsAbstractType() {
+ if (!component.getKind().equals(INTERFACE)
+ && !(component.getKind().equals(CLASS) && component.getModifiers().contains(ABSTRACT))) {
+ report.addError(
+ String.format(
+ "@%s may only be applied to an interface or abstract class",
+ componentKind().annotation().getSimpleName()),
+ component);
+ }
+ }
+
+ private void validateCreators() {
+ ImmutableList<DeclaredType> creators =
+ creatorAnnotationsFor(componentAnnotation()).stream()
+ .flatMap(annotation -> enclosedAnnotatedTypes(component, annotation).stream())
+ .collect(toImmutableList());
+ creators.forEach(
+ creator -> report.addSubreport(creatorValidator.validate(asTypeElement(creator))));
+ if (creators.size() > 1) {
+ report.addError(
+ String.format(
+ ErrorMessages.componentMessagesFor(componentKind()).moreThanOne(), creators),
+ component);
+ }
+ }
+
+ private void validateNoReusableAnnotation() {
+ Optional<AnnotationMirror> reusableAnnotation =
+ getAnnotationMirror(component, Reusable.class);
+ if (reusableAnnotation.isPresent()) {
+ report.addError(
+ "@Reusable cannot be applied to components or subcomponents",
+ component,
+ reusableAnnotation.get());
+ }
+ }
+
+ private void validateComponentMethods() {
+ getLocalAndInheritedMethods(component, types, elements).stream()
+ .filter(method -> method.getModifiers().contains(ABSTRACT))
+ .map(ComponentMethodValidator::new)
+ .forEachOrdered(ComponentMethodValidator::validateMethod);
+ }
+
+ private class ComponentMethodValidator {
+ private final ExecutableElement method;
+ private final ExecutableType resolvedMethod;
+ private final List<? extends TypeMirror> parameterTypes;
+ private final List<? extends VariableElement> parameters;
+ private final TypeMirror returnType;
+
+ ComponentMethodValidator(ExecutableElement method) {
+ this.method = method;
+ this.resolvedMethod = asExecutable(types.asMemberOf(componentType(), method));
+ this.parameterTypes = resolvedMethod.getParameterTypes();
+ this.parameters = method.getParameters();
+ this.returnType = resolvedMethod.getReturnType();
+ }
+
+ void validateMethod() {
+ validateNoTypeVariables();
+
+ // abstract methods are ones we have to implement, so they each need to be validated
+ // first, check the return type. if it's a subcomponent, validate that method as
+ // such.
+ Optional<AnnotationMirror> subcomponentAnnotation = subcomponentAnnotation();
+ if (subcomponentAnnotation.isPresent()) {
+ validateSubcomponentFactoryMethod(subcomponentAnnotation.get());
+ } else if (subcomponentCreatorAnnotation().isPresent()) {
+ validateSubcomponentCreatorMethod();
+ } else {
+ // if it's not a subcomponent...
+ switch (parameters.size()) {
+ case 0:
+ validateProvisionMethod();
+ break;
+ case 1:
+ validateMembersInjectionMethod();
+ break;
+ default:
+ reportInvalidMethod();
+ break;
+ }
+ }
+ }
+
+ private void validateNoTypeVariables() {
+ if (!resolvedMethod.getTypeVariables().isEmpty()) {
+ report.addError("Component methods cannot have type variables", method);
+ }
+ }
+
+ private Optional<AnnotationMirror> subcomponentAnnotation() {
+ return checkForAnnotations(
+ returnType,
+ componentKind().legalSubcomponentKinds().stream()
+ .map(ComponentKind::annotation)
+ .collect(toImmutableSet()));
+ }
+
+ private Optional<AnnotationMirror> subcomponentCreatorAnnotation() {
+ return checkForAnnotations(
+ returnType,
+ componentAnnotation().isProduction()
+ ? intersection(subcomponentCreatorAnnotations(), productionCreatorAnnotations())
+ : subcomponentCreatorAnnotations());
+ }
+
+ private void validateSubcomponentFactoryMethod(AnnotationMirror subcomponentAnnotation) {
+ referencedSubcomponents.put(MoreTypes.asElement(returnType), method);
+
+ ComponentKind subcomponentKind =
+ ComponentKind.forAnnotatedElement(MoreTypes.asTypeElement(returnType)).get();
+ ImmutableSet<TypeElement> moduleTypes =
+ ComponentAnnotation.componentAnnotation(subcomponentAnnotation).modules();
+
+ // TODO(gak): This logic maybe/probably shouldn't live here as it requires us to traverse
+ // subcomponents and their modules separately from how it is done in ComponentDescriptor and
+ // ModuleDescriptor
+ @SuppressWarnings("deprecation")
+ ImmutableSet<TypeElement> transitiveModules =
+ getTransitiveModules(types, elements, moduleTypes);
+
+ Set<TypeElement> variableTypes = Sets.newHashSet();
+
+ for (int i = 0; i < parameterTypes.size(); i++) {
+ VariableElement parameter = parameters.get(i);
+ TypeMirror parameterType = parameterTypes.get(i);
+ Optional<TypeElement> moduleType =
+ parameterType.accept(
+ new SimpleTypeVisitor8<Optional<TypeElement>, Void>() {
+ @Override
+ protected Optional<TypeElement> defaultAction(TypeMirror e, Void p) {
+ return Optional.empty();
+ }
+
+ @Override
+ public Optional<TypeElement> visitDeclared(DeclaredType t, Void p) {
+ for (ModuleKind moduleKind : subcomponentKind.legalModuleKinds()) {
+ if (isAnnotationPresent(t.asElement(), moduleKind.annotation())) {
+ return Optional.of(MoreTypes.asTypeElement(t));
+ }
+ }
+ return Optional.empty();
+ }
+ },
+ null);
+ if (moduleType.isPresent()) {
+ if (variableTypes.contains(moduleType.get())) {
+ report.addError(
+ String.format(
+ "A module may only occur once an an argument in a Subcomponent factory "
+ + "method, but %s was already passed.",
+ moduleType.get().getQualifiedName()),
+ parameter);
+ }
+ if (!transitiveModules.contains(moduleType.get())) {
+ report.addError(
+ String.format(
+ "%s is present as an argument to the %s factory method, but is not one of the"
+ + " modules used to implement the subcomponent.",
+ moduleType.get().getQualifiedName(),
+ MoreTypes.asTypeElement(returnType).getQualifiedName()),
+ method);
+ }
+ variableTypes.add(moduleType.get());
+ } else {
+ report.addError(
+ String.format(
+ "Subcomponent factory methods may only accept modules, but %s is not.",
+ parameterType),
+ parameter);
+ }
+ }
+ }
+
+ private void validateSubcomponentCreatorMethod() {
+ referencedSubcomponents.put(MoreTypes.asElement(returnType).getEnclosingElement(), method);
+
+ if (!parameters.isEmpty()) {
+ report.addError(builderMethodRequiresNoArgs(), method);
+ }
+
+ TypeElement creatorElement = MoreTypes.asTypeElement(returnType);
+ // TODO(sameb): The creator validator right now assumes the element is being compiled
+ // in this pass, which isn't true here. We should change error messages to spit out
+ // this method as the subject and add the original subject to the message output.
+ report.addSubreport(creatorValidator.validate(creatorElement));
+ }
+
+ private void validateProvisionMethod() {
+ dependencyRequestValidator.validateDependencyRequest(report, method, returnType);
+ }
+
+ private void validateMembersInjectionMethod() {
+ TypeMirror parameterType = getOnlyElement(parameterTypes);
+ report.addSubreport(
+ membersInjectionValidator.validateMembersInjectionMethod(method, parameterType));
+ if (!(returnType.getKind().equals(VOID) || types.isSameType(returnType, parameterType))) {
+ report.addError(
+ "Members injection methods may only return the injected type or void.", method);
+ }
+ }
+
+ private void reportInvalidMethod() {
+ report.addError(
+ "This method isn't a valid provision method, members injection method or "
+ + "subcomponent factory method. Dagger cannot implement this method",
+ method);
+ }
+ }
+
+ private void validateNoConflictingEntryPoints() {
+ // Collect entry point methods that are not overridden by others. If the "same" method is
+ // inherited from more than one supertype, each will be in the multimap.
+ SetMultimap<String, ExecutableElement> entryPointMethods = HashMultimap.create();
+
+ methodsIn(elements.getAllMembers(component)).stream()
+ .filter(
+ method ->
+ isEntryPoint(method, asExecutable(types.asMemberOf(componentType(), method))))
+ .forEach(
+ method ->
+ addMethodUnlessOverridden(
+ method, entryPointMethods.get(method.getSimpleName().toString())));
+
+ for (Set<ExecutableElement> methods : asMap(entryPointMethods).values()) {
+ if (distinctKeys(methods).size() > 1) {
+ reportConflictingEntryPoints(methods);
+ }
+ }
+ }
+
+ private void reportConflictingEntryPoints(Collection<ExecutableElement> methods) {
+ verify(
+ methods.stream().map(ExecutableElement::getEnclosingElement).distinct().count()
+ == methods.size(),
+ "expected each method to be declared on a different type: %s",
+ methods);
+ StringBuilder message = new StringBuilder("conflicting entry point declarations:");
+ methodSignatureFormatter
+ .typedFormatter(componentType())
+ .formatIndentedList(
+ message,
+ ImmutableList.sortedCopyOf(
+ comparing(
+ method -> asType(method.getEnclosingElement()).getQualifiedName().toString()),
+ methods),
+ 1);
+ report.addError(message.toString());
+ }
+
+ private void validateSubcomponentReferences() {
+ Maps.filterValues(referencedSubcomponents.asMap(), methods -> methods.size() > 1)
+ .forEach(
+ (subcomponent, methods) ->
+ report.addError(
+ String.format(moreThanOneRefToSubcomponent(), subcomponent, methods),
+ component));
+ }
+
+ private void validateComponentDependencies() {
+ for (TypeMirror type : componentAnnotation().dependencyTypes()) {
+ type.accept(CHECK_DEPENDENCY_TYPES, report);
+ }
+ }
+
+ private void validateReferencedModules() {
+ report.addSubreport(
+ moduleValidator.validateReferencedModules(
+ component,
+ componentAnnotation().annotation(),
+ componentKind().legalModuleKinds(),
+ new HashSet<>()));
+ }
+
+ private void validateSubcomponents() {
+ // Make sure we validate any subcomponents we're referencing.
+ for (Element subcomponent : referencedSubcomponents.keySet()) {
+ ValidationReport<TypeElement> subreport = validate(asType(subcomponent));
+ report.addSubreport(subreport);
+ }
+ }
+
+ private ImmutableSet<Key> distinctKeys(Set<ExecutableElement> methods) {
+ return methods.stream()
+ .map(this::dependencyRequest)
+ .map(DependencyRequest::key)
+ .collect(toImmutableSet());
+ }
+
+ private DependencyRequest dependencyRequest(ExecutableElement method) {
+ ExecutableType methodType = asExecutable(types.asMemberOf(componentType(), method));
+ return ComponentKind.forAnnotatedElement(component).get().isProducer()
+ ? dependencyRequestFactory.forComponentProductionMethod(method, methodType)
+ : dependencyRequestFactory.forComponentProvisionMethod(method, methodType);
+ }
+ }
+
+ private static boolean isEntryPoint(ExecutableElement method, ExecutableType methodType) {
+ return method.getModifiers().contains(ABSTRACT)
+ && method.getParameters().isEmpty()
+ && !methodType.getReturnType().getKind().equals(VOID)
+ && methodType.getTypeVariables().isEmpty();
+ }
+
+ private void addMethodUnlessOverridden(ExecutableElement method, Set<ExecutableElement> methods) {
+ if (methods.stream().noneMatch(existingMethod -> overridesAsDeclared(existingMethod, method))) {
+ methods.removeIf(existingMethod -> overridesAsDeclared(method, existingMethod));
+ methods.add(method);
+ }
+ }
+
+ /**
+ * Returns {@code true} if {@code overrider} overrides {@code overridden} considered from within
+ * the type that declares {@code overrider}.
+ */
+ // TODO(dpb): Does this break for ECJ?
+ private boolean overridesAsDeclared(ExecutableElement overrider, ExecutableElement overridden) {
+ return elements.overrides(overrider, overridden, asType(overrider.getEnclosingElement()));
+ }
+
+ private static final TypeVisitor<Void, ValidationReport.Builder<?>> CHECK_DEPENDENCY_TYPES =
+ new SimpleTypeVisitor8<Void, ValidationReport.Builder<?>>() {
+ @Override
+ protected Void defaultAction(TypeMirror type, ValidationReport.Builder<?> report) {
+ report.addError(type + " is not a valid component dependency type");
+ return null;
+ }
+
+ @Override
+ public Void visitDeclared(DeclaredType type, ValidationReport.Builder<?> report) {
+ if (moduleAnnotation(MoreTypes.asTypeElement(type)).isPresent()) {
+ report.addError(type + " is a module, which cannot be a component dependency");
+ }
+ return null;
+ }
+ };
+
+ private static Optional<AnnotationMirror> checkForAnnotations(
+ TypeMirror type, final Set<? extends Class<? extends Annotation>> annotations) {
+ return type.accept(
+ new SimpleTypeVisitor8<Optional<AnnotationMirror>, Void>(Optional.empty()) {
+ @Override
+ public Optional<AnnotationMirror> visitDeclared(DeclaredType t, Void p) {
+ return getAnyAnnotation(t.asElement(), annotations);
+ }
+ },
+ null);
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/CompositeBindingGraphPlugin.java b/java/dagger/internal/codegen/validation/CompositeBindingGraphPlugin.java
new file mode 100644
index 0000000..a9c650a
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/CompositeBindingGraphPlugin.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.collect.Lists.asList;
+import static dagger.internal.codegen.base.ElementFormatter.elementToString;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static dagger.internal.codegen.langmodel.DaggerElements.elementEncloses;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.errorprone.annotations.FormatMethod;
+import dagger.model.BindingGraph;
+import dagger.model.BindingGraph.ChildFactoryMethodEdge;
+import dagger.model.BindingGraph.ComponentNode;
+import dagger.model.BindingGraph.DependencyEdge;
+import dagger.model.BindingGraph.MaybeBinding;
+import dagger.spi.BindingGraphPlugin;
+import dagger.spi.DiagnosticReporter;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import javax.annotation.processing.Filer;
+import javax.inject.Inject;
+import javax.lang.model.util.Elements; // ALLOW_TYPES_ELEMENTS because of interface dependencies
+import javax.lang.model.util.Types; // ALLOW_TYPES_ELEMENTS because of interface dependencies
+import javax.tools.Diagnostic;
+
+/**
+ * Combines many {@link BindingGraphPlugin} implementations. This helps reduce spam by combining
+ * all of the messages that are reported on the root component.
+ */
+public final class CompositeBindingGraphPlugin implements BindingGraphPlugin {
+
+ private final ImmutableSet<BindingGraphPlugin> plugins;
+ private final String pluginName;
+ private final DiagnosticMessageGenerator.Factory messageGeneratorFactory;
+
+ /** Factory class for {@link CompositeBindingGraphPlugin}. */
+ public static final class Factory {
+ private final DiagnosticMessageGenerator.Factory messageGeneratorFactory;
+
+ @Inject Factory(DiagnosticMessageGenerator.Factory messageGeneratorFactory) {
+ this.messageGeneratorFactory = messageGeneratorFactory;
+ }
+
+ public CompositeBindingGraphPlugin create(
+ ImmutableSet<BindingGraphPlugin> plugins, String pluginName) {
+ return new CompositeBindingGraphPlugin(plugins, pluginName, messageGeneratorFactory);
+ }
+ }
+
+ private CompositeBindingGraphPlugin(
+ ImmutableSet<BindingGraphPlugin> plugins,
+ String pluginName,
+ DiagnosticMessageGenerator.Factory messageGeneratorFactory) {
+ this.plugins = plugins;
+ this.pluginName = pluginName;
+ this.messageGeneratorFactory = messageGeneratorFactory;
+ }
+
+ @Override
+ public void visitGraph(BindingGraph bindingGraph, DiagnosticReporter diagnosticReporter) {
+ AggregatingDiagnosticReporter aggregatingDiagnosticReporter = new AggregatingDiagnosticReporter(
+ bindingGraph, diagnosticReporter, messageGeneratorFactory.create(bindingGraph));
+ plugins.forEach(plugin -> {
+ aggregatingDiagnosticReporter.setCurrentPlugin(plugin.pluginName());
+ plugin.visitGraph(bindingGraph, aggregatingDiagnosticReporter);
+ });
+ aggregatingDiagnosticReporter.report();
+ }
+
+ @Override
+ public void initFiler(Filer filer) {
+ plugins.forEach(plugin -> plugin.initFiler(filer));
+ }
+
+ @Override
+ public void initTypes(Types types) {
+ plugins.forEach(plugin -> plugin.initTypes(types));
+ }
+
+ @Override
+ public void initElements(Elements elements) {
+ plugins.forEach(plugin -> plugin.initElements(elements));
+ }
+
+ @Override
+ public void initOptions(Map<String, String> options) {
+ plugins.forEach(plugin -> plugin.initOptions(options));
+ }
+
+ @Override
+ public Set<String> supportedOptions() {
+ return plugins.stream().flatMap(
+ plugin -> plugin.supportedOptions().stream()).collect(toImmutableSet());
+ }
+
+ @Override
+ public String pluginName() {
+ return pluginName;
+ }
+
+ // TODO(erichang): This kind of breaks some of the encapsulation by relying on or repeating
+ // logic within DiagnosticReporterImpl. Hopefully if the experiment for aggregated messages
+ // goes well though this can be merged with that implementation.
+ private static final class AggregatingDiagnosticReporter implements DiagnosticReporter {
+ private final DiagnosticReporter delegate;
+ private final BindingGraph graph;
+ // Initialize with a new line so the first message appears below the reported component
+ private final StringBuilder messageBuilder = new StringBuilder("\n");
+ private final DiagnosticMessageGenerator messageGenerator;
+ private Optional<Diagnostic.Kind> mergedDiagnosticKind = Optional.empty();
+ private String currentPluginName = null;
+
+ AggregatingDiagnosticReporter(
+ BindingGraph graph,
+ DiagnosticReporter delegate,
+ DiagnosticMessageGenerator messageGenerator) {
+ this.graph = graph;
+ this.delegate = delegate;
+ this.messageGenerator = messageGenerator;
+ }
+
+ /** Sets the currently running aggregated plugin. Used to add a diagnostic prefix. */
+ void setCurrentPlugin(String pluginName) {
+ currentPluginName = pluginName;
+ }
+
+ /** Reports all of the stored diagnostics. */
+ void report() {
+ if (mergedDiagnosticKind.isPresent()) {
+ delegate.reportComponent(
+ mergedDiagnosticKind.get(),
+ graph.rootComponentNode(),
+ PackageNameCompressor.compressPackagesInMessage(messageBuilder.toString()));
+ }
+ }
+
+ @Override
+ public void reportComponent(Diagnostic.Kind diagnosticKind, ComponentNode componentNode,
+ String message) {
+ addMessage(diagnosticKind, message);
+ messageGenerator.appendComponentPathUnlessAtRoot(messageBuilder, componentNode);
+ }
+
+ @Override
+ @FormatMethod
+ public void reportComponent(
+ Diagnostic.Kind diagnosticKind,
+ ComponentNode componentNode,
+ String messageFormat,
+ Object firstArg,
+ Object... moreArgs) {
+ reportComponent(
+ diagnosticKind, componentNode, formatMessage(messageFormat, firstArg, moreArgs));
+ }
+
+ @Override
+ public void reportBinding(Diagnostic.Kind diagnosticKind, MaybeBinding binding,
+ String message) {
+ addMessage(diagnosticKind,
+ String.format("%s%s", message, messageGenerator.getMessage(binding)));
+ }
+
+ @Override
+ @FormatMethod
+ public void reportBinding(
+ Diagnostic.Kind diagnosticKind,
+ MaybeBinding binding,
+ String messageFormat,
+ Object firstArg,
+ Object... moreArgs) {
+ reportBinding(diagnosticKind, binding, formatMessage(messageFormat, firstArg, moreArgs));
+ }
+
+ @Override
+ public void reportDependency(
+ Diagnostic.Kind diagnosticKind, DependencyEdge dependencyEdge, String message) {
+ addMessage(diagnosticKind,
+ String.format("%s%s", message, messageGenerator.getMessage(dependencyEdge)));
+ }
+
+ @Override
+ @FormatMethod
+ public void reportDependency(
+ Diagnostic.Kind diagnosticKind,
+ DependencyEdge dependencyEdge,
+ String messageFormat,
+ Object firstArg,
+ Object... moreArgs) {
+ reportDependency(
+ diagnosticKind, dependencyEdge, formatMessage(messageFormat, firstArg, moreArgs));
+ }
+
+ @Override
+ public void reportSubcomponentFactoryMethod(
+ Diagnostic.Kind diagnosticKind,
+ ChildFactoryMethodEdge childFactoryMethodEdge,
+ String message) {
+ // TODO(erichang): This repeats some of the logic in DiagnosticReporterImpl. Remove when
+ // merged.
+ if (elementEncloses(
+ graph.rootComponentNode().componentPath().currentComponent(),
+ childFactoryMethodEdge.factoryMethod())) {
+ // Let this pass through since it is not an error reported on the root component
+ delegate.reportSubcomponentFactoryMethod(diagnosticKind, childFactoryMethodEdge, message);
+ } else {
+ addMessage(
+ diagnosticKind,
+ String.format(
+ "[%s] %s", elementToString(childFactoryMethodEdge.factoryMethod()), message));
+ }
+ }
+
+ @Override
+ @FormatMethod
+ public void reportSubcomponentFactoryMethod(
+ Diagnostic.Kind diagnosticKind,
+ ChildFactoryMethodEdge childFactoryMethodEdge,
+ String messageFormat,
+ Object firstArg,
+ Object... moreArgs) {
+ reportSubcomponentFactoryMethod(
+ diagnosticKind, childFactoryMethodEdge, formatMessage(messageFormat, firstArg, moreArgs));
+ }
+
+ /** Adds a message to the stored aggregated message. */
+ private void addMessage(Diagnostic.Kind diagnosticKind, String message) {
+ checkNotNull(diagnosticKind);
+ checkNotNull(message);
+ checkState(currentPluginName != null);
+
+ // Add a separator if this isn't the first message
+ if (mergedDiagnosticKind.isPresent()) {
+ messageBuilder.append("\n\n");
+ }
+
+ mergeDiagnosticKind(diagnosticKind);
+ // Adds brackets as well as special color strings to make the string red and bold.
+ messageBuilder.append(String.format("\033[1;31m[%s]\033[0m ", currentPluginName));
+ messageBuilder.append(message);
+ }
+
+ private static String formatMessage(String messageFormat, Object firstArg, Object[] moreArgs) {
+ return String.format(messageFormat, asList(firstArg, moreArgs).toArray());
+ }
+
+ private void mergeDiagnosticKind(Diagnostic.Kind diagnosticKind) {
+ checkArgument(diagnosticKind != Diagnostic.Kind.MANDATORY_WARNING,
+ "Dagger plugins should not be issuing mandatory warnings");
+ if (!mergedDiagnosticKind.isPresent()) {
+ mergedDiagnosticKind = Optional.of(diagnosticKind);
+ return;
+ }
+ Diagnostic.Kind current = mergedDiagnosticKind.get();
+ if (current == Diagnostic.Kind.ERROR || diagnosticKind == Diagnostic.Kind.ERROR) {
+ mergedDiagnosticKind = Optional.of(Diagnostic.Kind.ERROR);
+ } else if (current == Diagnostic.Kind.WARNING || diagnosticKind == Diagnostic.Kind.WARNING) {
+ mergedDiagnosticKind = Optional.of(Diagnostic.Kind.WARNING);
+ } else if (current == Diagnostic.Kind.NOTE || diagnosticKind == Diagnostic.Kind.NOTE) {
+ mergedDiagnosticKind = Optional.of(Diagnostic.Kind.NOTE);
+ } else {
+ mergedDiagnosticKind = Optional.of(Diagnostic.Kind.OTHER);
+ }
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/DependencyRequestValidator.java b/java/dagger/internal/codegen/validation/DependencyRequestValidator.java
new file mode 100644
index 0000000..68c9604
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/DependencyRequestValidator.java
@@ -0,0 +1,173 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static com.google.auto.common.MoreElements.asType;
+import static com.google.auto.common.MoreElements.asVariable;
+import static com.google.auto.common.MoreTypes.asTypeElement;
+import static dagger.internal.codegen.base.RequestKinds.extractKeyType;
+import static dagger.internal.codegen.binding.AssistedInjectionAnnotations.isAssistedFactoryType;
+import static dagger.internal.codegen.binding.AssistedInjectionAnnotations.isAssistedInjectionType;
+import static dagger.internal.codegen.binding.SourceFiles.membersInjectorNameForType;
+import static javax.lang.model.element.Modifier.STATIC;
+import static javax.lang.model.type.TypeKind.WILDCARD;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.MoreTypes;
+import com.google.common.collect.ImmutableCollection;
+import dagger.MembersInjector;
+import dagger.assisted.Assisted;
+import dagger.internal.codegen.base.FrameworkTypes;
+import dagger.internal.codegen.base.RequestKinds;
+import dagger.internal.codegen.binding.InjectionAnnotations;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.model.RequestKind;
+import java.util.Optional;
+import javax.inject.Inject;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeMirror;
+
+/** Validation for dependency requests. */
+final class DependencyRequestValidator {
+ private final MembersInjectionValidator membersInjectionValidator;
+ private final InjectionAnnotations injectionAnnotations;
+ private final KotlinMetadataUtil metadataUtil;
+ private final DaggerElements elements;
+
+ @Inject
+ DependencyRequestValidator(
+ MembersInjectionValidator membersInjectionValidator,
+ InjectionAnnotations injectionAnnotations,
+ KotlinMetadataUtil metadataUtil,
+ DaggerElements elements) {
+ this.membersInjectionValidator = membersInjectionValidator;
+ this.injectionAnnotations = injectionAnnotations;
+ this.metadataUtil = metadataUtil;
+ this.elements = elements;
+ }
+
+ /**
+ * Adds an error if the given dependency request has more than one qualifier annotation or is a
+ * non-instance request with a wildcard type.
+ */
+ void validateDependencyRequest(
+ ValidationReport.Builder<?> report, Element requestElement, TypeMirror requestType) {
+ if (MoreElements.isAnnotationPresent(requestElement, Assisted.class)) {
+ // Don't validate assisted parameters. These are not dependency requests.
+ return;
+ }
+ checkQualifiers(report, requestElement);
+ checkType(report, requestElement, requestType);
+ }
+
+ private void checkQualifiers(ValidationReport.Builder<?> report, Element requestElement) {
+ if (requestElement.getKind() == ElementKind.FIELD
+ // static injected fields are not supported, no need to get qualifier from kotlin metadata
+ && !requestElement.getModifiers().contains(STATIC)
+ && metadataUtil.hasMetadata(requestElement)
+ && metadataUtil.isMissingSyntheticPropertyForAnnotations(asVariable(requestElement))) {
+ Optional<TypeElement> membersInjector =
+ Optional.ofNullable(
+ elements.getTypeElement(
+ membersInjectorNameForType(asType(requestElement.getEnclosingElement()))));
+ if (!membersInjector.isPresent()) {
+ report.addError(
+ "Unable to read annotations on an injected Kotlin property. The Dagger compiler must"
+ + " also be applied to any project containing @Inject properties.",
+ requestElement);
+ return; // finish checking qualifiers since current information is unreliable.
+ }
+ }
+
+ ImmutableCollection<? extends AnnotationMirror> qualifiers =
+ injectionAnnotations.getQualifiers(requestElement);
+ if (qualifiers.size() > 1) {
+ for (AnnotationMirror qualifier : qualifiers) {
+ report.addError(
+ "A single dependency request may not use more than one @Qualifier",
+ requestElement,
+ qualifier);
+ }
+ }
+ }
+
+ private void checkType(
+ ValidationReport.Builder<?> report, Element requestElement, TypeMirror requestType) {
+ TypeMirror keyType = extractKeyType(requestType);
+ RequestKind requestKind = RequestKinds.getRequestKind(requestType);
+ if (keyType.getKind() == TypeKind.DECLARED) {
+ TypeElement typeElement = asTypeElement(keyType);
+ if (isAssistedInjectionType(typeElement)) {
+ report.addError(
+ "Dagger does not support injecting @AssistedInject type, "
+ + requestType
+ + ". Did you mean to inject its assisted factory type instead?",
+ requestElement);
+ }
+ if (requestKind != RequestKind.INSTANCE && isAssistedFactoryType(typeElement)) {
+ report.addError(
+ "Dagger does not support injecting Provider<T>, Lazy<T>, Producer<T>, "
+ + "or Produced<T> when T is an @AssistedFactory-annotated type such as "
+ + keyType,
+ requestElement);
+ }
+ }
+ if (keyType.getKind().equals(WILDCARD)) {
+ // TODO(ronshapiro): Explore creating this message using RequestKinds.
+ report.addError(
+ "Dagger does not support injecting Provider<T>, Lazy<T>, Producer<T>, "
+ + "or Produced<T> when T is a wildcard type such as "
+ + keyType,
+ requestElement);
+ }
+ if (MoreTypes.isType(keyType) && MoreTypes.isTypeOf(MembersInjector.class, keyType)) {
+ DeclaredType membersInjectorType = MoreTypes.asDeclared(keyType);
+ if (membersInjectorType.getTypeArguments().isEmpty()) {
+ report.addError("Cannot inject a raw MembersInjector", requestElement);
+ } else {
+ report.addSubreport(
+ membersInjectionValidator.validateMembersInjectionRequest(
+ requestElement, membersInjectorType.getTypeArguments().get(0)));
+ }
+ }
+ }
+
+ /**
+ * Adds an error if the given dependency request is for a {@link dagger.producers.Producer} or
+ * {@link dagger.producers.Produced}.
+ *
+ * <p>Only call this when processing a provision binding.
+ */
+ // TODO(dpb): Should we disallow Producer entry points in non-production components?
+ void checkNotProducer(ValidationReport.Builder<?> report, VariableElement requestElement) {
+ TypeMirror requestType = requestElement.asType();
+ if (FrameworkTypes.isProducerType(requestType)) {
+ report.addError(
+ String.format(
+ "%s may only be injected in @Produces methods",
+ MoreTypes.asTypeElement(requestType).getSimpleName()),
+ requestElement);
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/DiagnosticMessageGenerator.java b/java/dagger/internal/codegen/validation/DiagnosticMessageGenerator.java
new file mode 100644
index 0000000..7d7b9e3
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/DiagnosticMessageGenerator.java
@@ -0,0 +1,389 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static com.google.common.base.Predicates.equalTo;
+import static com.google.common.base.Verify.verify;
+import static com.google.common.collect.Iterables.filter;
+import static com.google.common.collect.Iterables.getLast;
+import static com.google.common.collect.Iterables.indexOf;
+import static com.google.common.collect.Iterables.transform;
+import static dagger.internal.codegen.base.ElementFormatter.elementToString;
+import static dagger.internal.codegen.extension.DaggerGraphs.shortestPath;
+import static dagger.internal.codegen.extension.DaggerStreams.instancesOf;
+import static dagger.internal.codegen.extension.DaggerStreams.presentValues;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static dagger.internal.codegen.langmodel.DaggerElements.DECLARATION_ORDER;
+import static dagger.internal.codegen.langmodel.DaggerElements.closestEnclosingTypeElement;
+import static java.util.Collections.min;
+import static java.util.Comparator.comparing;
+import static java.util.Comparator.comparingInt;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.MoreTypes;
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+import com.google.common.collect.HashBasedTable;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Table;
+import dagger.internal.codegen.base.ElementFormatter;
+import dagger.internal.codegen.base.Formatter;
+import dagger.internal.codegen.binding.DependencyRequestFormatter;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.BindingGraph;
+import dagger.model.BindingGraph.DependencyEdge;
+import dagger.model.BindingGraph.Edge;
+import dagger.model.BindingGraph.MaybeBinding;
+import dagger.model.BindingGraph.Node;
+import dagger.model.ComponentPath;
+import java.util.Comparator;
+import java.util.Set;
+import java.util.function.Function;
+import javax.inject.Inject;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+
+/** Helper class for generating diagnostic messages. */
+public final class DiagnosticMessageGenerator {
+
+ /** Injectable factory for {@code DiagnosticMessageGenerator}. */
+ public static final class Factory {
+ private final DaggerTypes types;
+ private final DependencyRequestFormatter dependencyRequestFormatter;
+ private final ElementFormatter elementFormatter;
+
+ @Inject
+ Factory(
+ DaggerTypes types,
+ DependencyRequestFormatter dependencyRequestFormatter,
+ ElementFormatter elementFormatter) {
+ this.types = types;
+ this.dependencyRequestFormatter = dependencyRequestFormatter;
+ this.elementFormatter = elementFormatter;
+ }
+
+ /** Creates a {@code DiagnosticMessageGenerator} for the given binding graph. */
+ public DiagnosticMessageGenerator create(BindingGraph graph) {
+ return new DiagnosticMessageGenerator(
+ graph, types, dependencyRequestFormatter, elementFormatter);
+ }
+ }
+
+ private final BindingGraph graph;
+ private final DependencyRequestFormatter dependencyRequestFormatter;
+ private final ElementFormatter elementFormatter;
+
+ /** A cached function from type to all of its supertypes in breadth-first order. */
+ private final Function<TypeElement, Iterable<TypeElement>> supertypes;
+
+ /** The shortest path (value) from an entry point (column) to a binding (row). */
+ private final Table<MaybeBinding, DependencyEdge, ImmutableList<Node>> shortestPaths =
+ HashBasedTable.create();
+
+ private static <K, V> Function<K, V> memoize(Function<K, V> uncached) {
+ // If Android Guava is on the processor path, then c.g.c.b.Function (which LoadingCache
+ // implements) does not extend j.u.f.Function.
+ // TODO(erichang): Fix current breakages and try to remove this to enforce not having this on
+ // processor path.
+
+ // First, explicitly convert uncached to c.g.c.b.Function because CacheLoader.from() expects
+ // one.
+ com.google.common.base.Function<K, V> uncachedAsBaseFunction = uncached::apply;
+
+ LoadingCache<K, V> cache =
+ CacheBuilder.newBuilder().build(CacheLoader.from(uncachedAsBaseFunction));
+
+ // Second, explicitly convert LoadingCache to j.u.f.Function.
+ @SuppressWarnings("deprecation") // uncachedAsBaseFunction throws only unchecked exceptions
+ Function<K, V> memoized = cache::apply;
+
+ return memoized;
+ }
+
+ private DiagnosticMessageGenerator(
+ BindingGraph graph,
+ DaggerTypes types,
+ DependencyRequestFormatter dependencyRequestFormatter,
+ ElementFormatter elementFormatter) {
+ this.graph = graph;
+ this.dependencyRequestFormatter = dependencyRequestFormatter;
+ this.elementFormatter = elementFormatter;
+ supertypes =
+ memoize(
+ component -> transform(types.supertypes(component.asType()), MoreTypes::asTypeElement));
+ }
+
+ public String getMessage(MaybeBinding binding) {
+ ImmutableSet<DependencyEdge> entryPoints = graph.entryPointEdgesDependingOnBinding(binding);
+ ImmutableSet<DependencyEdge> requests = requests(binding);
+ ImmutableList<DependencyEdge> dependencyTrace = dependencyTrace(binding, entryPoints);
+
+ return getMessageInternal(dependencyTrace, requests, entryPoints);
+ }
+
+ public String getMessage(DependencyEdge dependencyEdge) {
+ ImmutableSet<DependencyEdge> requests = ImmutableSet.of(dependencyEdge);
+
+ ImmutableSet<DependencyEdge> entryPoints;
+ ImmutableList<DependencyEdge> dependencyTrace;
+ if (dependencyEdge.isEntryPoint()) {
+ entryPoints = ImmutableSet.of(dependencyEdge);
+ dependencyTrace = ImmutableList.of(dependencyEdge);
+ } else {
+ // It's not an entry point, so it's part of a binding
+ dagger.model.Binding binding = (dagger.model.Binding) source(dependencyEdge);
+ entryPoints = graph.entryPointEdgesDependingOnBinding(binding);
+ dependencyTrace =
+ ImmutableList.<DependencyEdge>builder()
+ .add(dependencyEdge)
+ .addAll(dependencyTrace(binding, entryPoints))
+ .build();
+ }
+
+ return getMessageInternal(dependencyTrace, requests, entryPoints);
+ }
+
+ private String getMessageInternal(
+ ImmutableList<DependencyEdge> dependencyTrace,
+ ImmutableSet<DependencyEdge> requests,
+ ImmutableSet<DependencyEdge> entryPoints) {
+ StringBuilder message =
+ graph.isFullBindingGraph()
+ ? new StringBuilder()
+ : new StringBuilder(dependencyTrace.size() * 100 /* a guess heuristic */);
+
+ // Print the dependency trace unless it's a full binding graph
+ if (!graph.isFullBindingGraph()) {
+ dependencyTrace.forEach(
+ edge -> dependencyRequestFormatter.appendFormatLine(message, edge.dependencyRequest()));
+ if (!dependencyTrace.isEmpty()) {
+ appendComponentPathUnlessAtRoot(message, source(getLast(dependencyTrace)));
+ }
+ }
+
+ // Print any dependency requests that aren't shown as part of the dependency trace.
+ ImmutableSet<Element> requestsToPrint =
+ requests.stream()
+ // if printing entry points, skip entry points and the traced request
+ .filter(
+ request ->
+ graph.isFullBindingGraph()
+ || (!request.isEntryPoint() && !isTracedRequest(dependencyTrace, request)))
+ .map(request -> request.dependencyRequest().requestElement())
+ .flatMap(presentValues())
+ .collect(toImmutableSet());
+ if (!requestsToPrint.isEmpty()) {
+ message
+ .append("\nIt is")
+ .append(graph.isFullBindingGraph() ? " " : " also ")
+ .append("requested at:");
+ elementFormatter.formatIndentedList(message, requestsToPrint, 1);
+ }
+
+ // Print the remaining entry points, showing which component they're in, unless it's a full
+ // binding graph
+ if (!graph.isFullBindingGraph() && entryPoints.size() > 1) {
+ message.append("\nThe following other entry points also depend on it:");
+ entryPointFormatter.formatIndentedList(
+ message,
+ entryPoints.stream()
+ .filter(entryPoint -> !entryPoint.equals(getLast(dependencyTrace)))
+ .sorted(
+ // 1. List entry points in components closest to the root first.
+ // 2. List entry points declared in a component before those in a supertype.
+ // 3. List entry points in declaration order in their declaring type.
+ rootComponentFirst()
+ .thenComparing(nearestComponentSupertypeFirst())
+ .thenComparing(requestElementDeclarationOrder()))
+ .collect(toImmutableList()),
+ 1);
+ }
+ return message.toString();
+ }
+
+ public void appendComponentPathUnlessAtRoot(StringBuilder message, Node node) {
+ if (!node.componentPath().equals(graph.rootComponentNode().componentPath())) {
+ message.append(String.format(" [%s]", node.componentPath()));
+ }
+ }
+
+ private final Formatter<DependencyEdge> entryPointFormatter =
+ new Formatter<DependencyEdge>() {
+ @Override
+ public String format(DependencyEdge object) {
+ Element requestElement = object.dependencyRequest().requestElement().get();
+ StringBuilder element = new StringBuilder(elementToString(requestElement));
+
+ // For entry points declared in subcomponents or supertypes of the root component,
+ // append the component path to make clear to the user which component it's in.
+ ComponentPath componentPath = source(object).componentPath();
+ if (!componentPath.atRoot()
+ || !requestElement.getEnclosingElement().equals(componentPath.rootComponent())) {
+ element.append(String.format(" [%s]", componentPath));
+ }
+ return element.toString();
+ }
+ };
+
+ private static boolean isTracedRequest(
+ ImmutableList<DependencyEdge> dependencyTrace, DependencyEdge request) {
+ return !dependencyTrace.isEmpty() && request.equals(dependencyTrace.get(0));
+ }
+
+ /**
+ * Returns the dependency trace from one of the {@code entryPoints} to {@code binding} to {@code
+ * message} as a list <i>ending with</i> the entry point.
+ */
+ // TODO(ronshapiro): Adding a DependencyPath type to dagger.model could be useful, i.e.
+ // bindingGraph.shortestPathFromEntryPoint(DependencyEdge, MaybeBindingNode)
+ ImmutableList<DependencyEdge> dependencyTrace(
+ MaybeBinding binding, ImmutableSet<DependencyEdge> entryPoints) {
+ // Module binding graphs may have bindings unreachable from any entry points. If there are
+ // no entry points for this DiagnosticInfo, don't try to print a dependency trace.
+ if (entryPoints.isEmpty()) {
+ return ImmutableList.of();
+ }
+ // Show the full dependency trace for one entry point.
+ DependencyEdge entryPointForTrace =
+ min(
+ entryPoints,
+ // prefer entry points in components closest to the root
+ rootComponentFirst()
+ // then prefer entry points with a short dependency path to the error
+ .thenComparing(shortestDependencyPathFirst(binding))
+ // then prefer entry points declared in the component to those declared in a
+ // supertype
+ .thenComparing(nearestComponentSupertypeFirst())
+ // finally prefer entry points declared first in their enclosing type
+ .thenComparing(requestElementDeclarationOrder()));
+
+ ImmutableList<Node> shortestBindingPath =
+ shortestPathFromEntryPoint(entryPointForTrace, binding);
+ verify(
+ !shortestBindingPath.isEmpty(),
+ "no dependency path from %s to %s in %s",
+ entryPointForTrace,
+ binding,
+ graph);
+
+ ImmutableList.Builder<DependencyEdge> dependencyTrace = ImmutableList.builder();
+ dependencyTrace.add(entryPointForTrace);
+ for (int i = 0; i < shortestBindingPath.size() - 1; i++) {
+ Set<Edge> dependenciesBetween =
+ graph
+ .network()
+ .edgesConnecting(shortestBindingPath.get(i), shortestBindingPath.get(i + 1));
+ // If a binding requests a key more than once, any of them should be fine to get to the
+ // shortest path
+ dependencyTrace.add((DependencyEdge) Iterables.get(dependenciesBetween, 0));
+ }
+ return dependencyTrace.build().reverse();
+ }
+
+ /** Returns all the nonsynthetic dependency requests for a binding. */
+ ImmutableSet<DependencyEdge> requests(MaybeBinding binding) {
+ return graph.network().inEdges(binding).stream()
+ .flatMap(instancesOf(DependencyEdge.class))
+ .filter(edge -> edge.dependencyRequest().requestElement().isPresent())
+ .sorted(requestEnclosingTypeName().thenComparing(requestElementDeclarationOrder()))
+ .collect(toImmutableSet());
+ }
+
+ /**
+ * Returns a comparator that sorts entry points in components whose paths from the root are
+ * shorter first.
+ */
+ Comparator<DependencyEdge> rootComponentFirst() {
+ return comparingInt(entryPoint -> source(entryPoint).componentPath().components().size());
+ }
+
+ /**
+ * Returns a comparator that puts entry points whose shortest dependency path to {@code binding}
+ * is shortest first.
+ */
+ Comparator<DependencyEdge> shortestDependencyPathFirst(MaybeBinding binding) {
+ return comparing(entryPoint -> shortestPathFromEntryPoint(entryPoint, binding).size());
+ }
+
+ ImmutableList<Node> shortestPathFromEntryPoint(DependencyEdge entryPoint, MaybeBinding binding) {
+ return shortestPaths
+ .row(binding)
+ .computeIfAbsent(
+ entryPoint,
+ ep ->
+ shortestPath(
+ node ->
+ filter(graph.network().successors(node), MaybeBinding.class::isInstance),
+ graph.network().incidentNodes(ep).target(),
+ binding));
+ }
+
+ /**
+ * Returns a comparator that sorts entry points in by the distance of the type that declares them
+ * from the type of the component that contains them.
+ *
+ * <p>For instance, an entry point declared directly in the component type would sort before one
+ * declared in a direct supertype, which would sort before one declared in a supertype of a
+ * supertype.
+ */
+ Comparator<DependencyEdge> nearestComponentSupertypeFirst() {
+ return comparingInt(
+ entryPoint ->
+ indexOf(
+ supertypes.apply(componentContainingEntryPoint(entryPoint)),
+ equalTo(typeDeclaringEntryPoint(entryPoint))));
+ }
+
+ TypeElement componentContainingEntryPoint(DependencyEdge entryPoint) {
+ return source(entryPoint).componentPath().currentComponent();
+ }
+
+ TypeElement typeDeclaringEntryPoint(DependencyEdge entryPoint) {
+ return MoreElements.asType(
+ entryPoint.dependencyRequest().requestElement().get().getEnclosingElement());
+ }
+
+ /**
+ * Returns a comparator that sorts dependency edges lexicographically by the qualified name of the
+ * type that contains them. Only appropriate for edges with request elements.
+ */
+ Comparator<DependencyEdge> requestEnclosingTypeName() {
+ return comparing(
+ edge ->
+ closestEnclosingTypeElement(edge.dependencyRequest().requestElement().get())
+ .getQualifiedName()
+ .toString());
+ }
+
+ /**
+ * Returns a comparator that sorts edges in the order in which their request elements were
+ * declared in their declaring type.
+ *
+ * <p>Only useful to compare edges whose request elements were declared in the same type.
+ */
+ Comparator<DependencyEdge> requestElementDeclarationOrder() {
+ return comparing(edge -> edge.dependencyRequest().requestElement().get(), DECLARATION_ORDER);
+ }
+
+ private Node source(Edge edge) {
+ return graph.network().incidentNodes(edge).source();
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/DiagnosticReporterFactory.java b/java/dagger/internal/codegen/validation/DiagnosticReporterFactory.java
new file mode 100644
index 0000000..35ae7c7
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/DiagnosticReporterFactory.java
@@ -0,0 +1,191 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static com.google.common.collect.Lists.asList;
+import static dagger.internal.codegen.base.ElementFormatter.elementToString;
+import static dagger.internal.codegen.langmodel.DaggerElements.elementEncloses;
+import static javax.tools.Diagnostic.Kind.ERROR;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.errorprone.annotations.FormatMethod;
+import dagger.model.BindingGraph;
+import dagger.model.BindingGraph.ChildFactoryMethodEdge;
+import dagger.model.BindingGraph.ComponentNode;
+import dagger.model.BindingGraph.DependencyEdge;
+import dagger.model.BindingGraph.MaybeBinding;
+import dagger.spi.BindingGraphPlugin;
+import dagger.spi.DiagnosticReporter;
+import javax.annotation.processing.Messager;
+import javax.inject.Inject;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import javax.tools.Diagnostic;
+import org.checkerframework.checker.nullness.compatqual.NullableDecl;
+
+/** A factory for {@link DiagnosticReporter}s. */
+// TODO(ronshapiro): If multiple plugins print errors on the same node/edge, should we condense the
+// messages and only print the dependency trace once?
+final class DiagnosticReporterFactory {
+ private final Messager messager;
+ private final DiagnosticMessageGenerator.Factory diagnosticMessageGeneratorFactory;
+
+ @Inject
+ DiagnosticReporterFactory(
+ Messager messager, DiagnosticMessageGenerator.Factory diagnosticMessageGeneratorFactory) {
+ this.messager = messager;
+ this.diagnosticMessageGeneratorFactory = diagnosticMessageGeneratorFactory;
+ }
+
+ /** Creates a reporter for a binding graph and a plugin. */
+ DiagnosticReporterImpl reporter(
+ BindingGraph graph, BindingGraphPlugin plugin, boolean reportErrorsAsWarnings) {
+ return new DiagnosticReporterImpl(graph, plugin.pluginName(), reportErrorsAsWarnings);
+ }
+
+ /**
+ * A {@link DiagnosticReporter} that keeps track of which {@linkplain Diagnostic.Kind kinds} of
+ * diagnostics were reported.
+ */
+ final class DiagnosticReporterImpl implements DiagnosticReporter {
+ private final String plugin;
+ private final TypeElement rootComponent;
+ private final boolean reportErrorsAsWarnings;
+ private final ImmutableSet.Builder<Diagnostic.Kind> reportedDiagnosticKinds =
+ ImmutableSet.builder();
+ private final DiagnosticMessageGenerator diagnosticMessageGenerator;
+
+ DiagnosticReporterImpl(BindingGraph graph, String plugin, boolean reportErrorsAsWarnings) {
+ this.plugin = plugin;
+ this.reportErrorsAsWarnings = reportErrorsAsWarnings;
+ this.rootComponent = graph.rootComponentNode().componentPath().currentComponent();
+ this.diagnosticMessageGenerator = diagnosticMessageGeneratorFactory.create(graph);
+ }
+
+ /** Returns which {@linkplain Diagnostic.Kind kinds} of diagnostics were reported. */
+ ImmutableSet<Diagnostic.Kind> reportedDiagnosticKinds() {
+ return reportedDiagnosticKinds.build();
+ }
+
+ @Override
+ public void reportComponent(
+ Diagnostic.Kind diagnosticKind, ComponentNode componentNode, String messageFormat) {
+ StringBuilder message = new StringBuilder(messageFormat);
+ diagnosticMessageGenerator.appendComponentPathUnlessAtRoot(message, componentNode);
+ // TODO(dpb): Report at the component node component.
+ printMessage(diagnosticKind, message, rootComponent);
+ }
+
+ @Override
+ @FormatMethod
+ public void reportComponent(
+ Diagnostic.Kind diagnosticKind,
+ ComponentNode componentNode,
+ String messageFormat,
+ Object firstArg,
+ Object... moreArgs) {
+ reportComponent(
+ diagnosticKind, componentNode, formatMessage(messageFormat, firstArg, moreArgs));
+ }
+
+ // TODO(ronshapiro): should this also include the binding element?
+ @Override
+ public void reportBinding(
+ Diagnostic.Kind diagnosticKind, MaybeBinding binding, String message) {
+ printMessage(
+ diagnosticKind, message + diagnosticMessageGenerator.getMessage(binding), rootComponent);
+ }
+
+ @Override
+ public void reportBinding(
+ Diagnostic.Kind diagnosticKind,
+ MaybeBinding binding,
+ String messageFormat,
+ Object firstArg,
+ Object... moreArgs) {
+ reportBinding(diagnosticKind, binding, formatMessage(messageFormat, firstArg, moreArgs));
+ }
+
+ @Override
+ public void reportDependency(
+ Diagnostic.Kind diagnosticKind, DependencyEdge dependencyEdge, String message) {
+ printMessage(
+ diagnosticKind,
+ message + diagnosticMessageGenerator.getMessage(dependencyEdge),
+ rootComponent);
+ }
+
+ @Override
+ public void reportDependency(
+ Diagnostic.Kind diagnosticKind,
+ DependencyEdge dependencyEdge,
+ String messageFormat,
+ Object firstArg,
+ Object... moreArgs) {
+ reportDependency(
+ diagnosticKind, dependencyEdge, formatMessage(messageFormat, firstArg, moreArgs));
+ }
+
+ @Override
+ public void reportSubcomponentFactoryMethod(
+ Diagnostic.Kind diagnosticKind,
+ ChildFactoryMethodEdge childFactoryMethodEdge,
+ String message) {
+ printMessage(diagnosticKind, message, childFactoryMethodEdge.factoryMethod());
+ }
+
+ @Override
+ public void reportSubcomponentFactoryMethod(
+ Diagnostic.Kind diagnosticKind,
+ ChildFactoryMethodEdge childFactoryMethodEdge,
+ String messageFormat,
+ Object firstArg,
+ Object... moreArgs) {
+ reportSubcomponentFactoryMethod(
+ diagnosticKind, childFactoryMethodEdge, formatMessage(messageFormat, firstArg, moreArgs));
+ }
+
+ private String formatMessage(String messageFormat, Object firstArg, Object[] moreArgs) {
+ return String.format(messageFormat, asList(firstArg, moreArgs).toArray());
+ }
+
+ void printMessage(
+ Diagnostic.Kind diagnosticKind,
+ CharSequence message,
+ @NullableDecl Element elementToReport) {
+ if (diagnosticKind.equals(ERROR) && reportErrorsAsWarnings) {
+ diagnosticKind = Diagnostic.Kind.WARNING;
+ }
+ reportedDiagnosticKinds.add(diagnosticKind);
+ StringBuilder fullMessage = new StringBuilder();
+ appendBracketPrefix(fullMessage, plugin);
+
+ // TODO(ronshapiro): should we create a HashSet out of elementEncloses() so we don't
+ // need to do an O(n) contains() each time?
+ if (elementToReport != null && !elementEncloses(rootComponent, elementToReport)) {
+ appendBracketPrefix(fullMessage, elementToString(elementToReport));
+ elementToReport = rootComponent;
+ }
+
+ messager.printMessage(diagnosticKind, fullMessage.append(message), elementToReport);
+ }
+
+ private void appendBracketPrefix(StringBuilder message, String prefix) {
+ message.append(String.format("[%s] ", prefix));
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/InjectBindingRegistryImpl.java b/java/dagger/internal/codegen/validation/InjectBindingRegistryImpl.java
new file mode 100644
index 0000000..06f68f6
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/InjectBindingRegistryImpl.java
@@ -0,0 +1,359 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static dagger.internal.codegen.base.Keys.isValidImplicitProvisionKey;
+import static dagger.internal.codegen.base.Keys.isValidMembersInjectionKey;
+import static dagger.internal.codegen.binding.AssistedInjectionAnnotations.assistedInjectedConstructors;
+import static dagger.internal.codegen.binding.InjectionAnnotations.injectedConstructors;
+import static dagger.internal.codegen.binding.SourceFiles.generatedClassNameForBinding;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.MoreTypes;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import dagger.Component;
+import dagger.MembersInjector;
+import dagger.Provides;
+import dagger.internal.codegen.base.SourceFileGenerationException;
+import dagger.internal.codegen.base.SourceFileGenerator;
+import dagger.internal.codegen.binding.Binding;
+import dagger.internal.codegen.binding.BindingFactory;
+import dagger.internal.codegen.binding.InjectBindingRegistry;
+import dagger.internal.codegen.binding.KeyFactory;
+import dagger.internal.codegen.binding.MembersInjectionBinding;
+import dagger.internal.codegen.binding.ProvisionBinding;
+import dagger.internal.codegen.compileroption.CompilerOptions;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.Key;
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import javax.annotation.processing.Messager;
+import javax.inject.Inject;
+import javax.inject.Provider;
+import javax.inject.Singleton;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeMirror;
+import javax.tools.Diagnostic.Kind;
+
+/**
+ * Maintains the collection of provision bindings from {@link Inject} constructors and members
+ * injection bindings from {@link Inject} fields and methods known to the annotation processor.
+ * Note that this registry <b>does not</b> handle any explicit bindings (those from {@link Provides}
+ * methods, {@link Component} dependencies, etc.).
+ */
+@Singleton
+final class InjectBindingRegistryImpl implements InjectBindingRegistry {
+ private final DaggerElements elements;
+ private final DaggerTypes types;
+ private final Messager messager;
+ private final InjectValidator injectValidator;
+ private final InjectValidator injectValidatorWhenGeneratingCode;
+ private final KeyFactory keyFactory;
+ private final BindingFactory bindingFactory;
+ private final CompilerOptions compilerOptions;
+
+ final class BindingsCollection<B extends Binding> {
+ private final Class<?> factoryClass;
+ private final Map<Key, B> bindingsByKey = Maps.newLinkedHashMap();
+ private final Deque<B> bindingsRequiringGeneration = new ArrayDeque<>();
+ private final Set<Key> materializedBindingKeys = Sets.newLinkedHashSet();
+
+ BindingsCollection(Class<?> factoryClass) {
+ this.factoryClass = factoryClass;
+ }
+
+ void generateBindings(SourceFileGenerator<B> generator) throws SourceFileGenerationException {
+ for (B binding = bindingsRequiringGeneration.poll();
+ binding != null;
+ binding = bindingsRequiringGeneration.poll()) {
+ checkState(!binding.unresolved().isPresent());
+ if (injectValidatorWhenGeneratingCode.isValidType(binding.key().type())) {
+ generator.generate(binding);
+ }
+ materializedBindingKeys.add(binding.key());
+ }
+ // Because Elements instantiated across processing rounds are not guaranteed to be equals() to
+ // the logically same element, clear the cache after generating
+ bindingsByKey.clear();
+ }
+
+ /** Returns a previously cached binding. */
+ B getBinding(Key key) {
+ return bindingsByKey.get(key);
+ }
+
+ /** Caches the binding and generates it if it needs generation. */
+ void tryRegisterBinding(B binding, boolean warnIfNotAlreadyGenerated) {
+ tryToCacheBinding(binding);
+ tryToGenerateBinding(binding, warnIfNotAlreadyGenerated);
+ }
+
+ /**
+ * Tries to generate a binding, not generating if it already is generated. For resolved
+ * bindings, this will try to generate the unresolved version of the binding.
+ */
+ void tryToGenerateBinding(B binding, boolean warnIfNotAlreadyGenerated) {
+ if (shouldGenerateBinding(binding)) {
+ bindingsRequiringGeneration.offer(binding);
+ if (compilerOptions.warnIfInjectionFactoryNotGeneratedUpstream()
+ && warnIfNotAlreadyGenerated) {
+ messager.printMessage(
+ Kind.NOTE,
+ String.format(
+ "Generating a %s for %s. "
+ + "Prefer to run the dagger processor over that class instead.",
+ factoryClass.getSimpleName(),
+ types.erasure(binding.key().type()))); // erasure to strip <T> from msgs.
+ }
+ }
+ }
+
+ /** Returns true if the binding needs to be generated. */
+ private boolean shouldGenerateBinding(B binding) {
+ return !binding.unresolved().isPresent()
+ && !materializedBindingKeys.contains(binding.key())
+ && !bindingsRequiringGeneration.contains(binding)
+ && elements.getTypeElement(generatedClassNameForBinding(binding)) == null;
+ }
+
+ /** Caches the binding for future lookups by key. */
+ private void tryToCacheBinding(B binding) {
+ // We only cache resolved bindings or unresolved bindings w/o type arguments.
+ // Unresolved bindings w/ type arguments aren't valid for the object graph.
+ if (binding.unresolved().isPresent()
+ || binding.bindingTypeElement().get().getTypeParameters().isEmpty()) {
+ Key key = binding.key();
+ Binding previousValue = bindingsByKey.put(key, binding);
+ checkState(previousValue == null || binding.equals(previousValue),
+ "couldn't register %s. %s was already registered for %s",
+ binding, previousValue, key);
+ }
+ }
+ }
+
+ private final BindingsCollection<ProvisionBinding> provisionBindings =
+ new BindingsCollection<>(Provider.class);
+ private final BindingsCollection<MembersInjectionBinding> membersInjectionBindings =
+ new BindingsCollection<>(MembersInjector.class);
+
+ @Inject
+ InjectBindingRegistryImpl(
+ DaggerElements elements,
+ DaggerTypes types,
+ Messager messager,
+ InjectValidator injectValidator,
+ KeyFactory keyFactory,
+ BindingFactory bindingFactory,
+ CompilerOptions compilerOptions) {
+ this.elements = elements;
+ this.types = types;
+ this.messager = messager;
+ this.injectValidator = injectValidator;
+ this.injectValidatorWhenGeneratingCode = injectValidator.whenGeneratingCode();
+ this.keyFactory = keyFactory;
+ this.bindingFactory = bindingFactory;
+ this.compilerOptions = compilerOptions;
+ }
+
+
+ // TODO(dpb): make the SourceFileGenerators fields so they don't have to be passed in
+ @Override
+ public void generateSourcesForRequiredBindings(
+ SourceFileGenerator<ProvisionBinding> factoryGenerator,
+ SourceFileGenerator<MembersInjectionBinding> membersInjectorGenerator)
+ throws SourceFileGenerationException {
+ provisionBindings.generateBindings(factoryGenerator);
+ membersInjectionBindings.generateBindings(membersInjectorGenerator);
+ }
+
+ /**
+ * Registers the binding for generation and later lookup. If the binding is resolved, we also
+ * attempt to register an unresolved version of it.
+ */
+ private void registerBinding(ProvisionBinding binding, boolean warnIfNotAlreadyGenerated) {
+ provisionBindings.tryRegisterBinding(binding, warnIfNotAlreadyGenerated);
+ if (binding.unresolved().isPresent()) {
+ provisionBindings.tryToGenerateBinding(binding.unresolved().get(), warnIfNotAlreadyGenerated);
+ }
+ }
+
+ /**
+ * Registers the binding for generation and later lookup. If the binding is resolved, we also
+ * attempt to register an unresolved version of it.
+ */
+ private void registerBinding(MembersInjectionBinding binding, boolean warnIfNotAlreadyGenerated) {
+ /*
+ * We generate MembersInjector classes for types with @Inject constructors only if they have any
+ * injection sites.
+ *
+ * We generate MembersInjector classes for types without @Inject constructors only if they have
+ * local (non-inherited) injection sites.
+ *
+ * Warn only when registering bindings post-hoc for those types.
+ */
+ if (warnIfNotAlreadyGenerated) {
+ boolean hasInjectConstructor =
+ !(injectedConstructors(binding.membersInjectedType()).isEmpty()
+ && assistedInjectedConstructors(binding.membersInjectedType()).isEmpty());
+ warnIfNotAlreadyGenerated =
+ hasInjectConstructor
+ ? !binding.injectionSites().isEmpty()
+ : binding.hasLocalInjectionSites();
+ }
+
+ membersInjectionBindings.tryRegisterBinding(binding, warnIfNotAlreadyGenerated);
+ if (binding.unresolved().isPresent()) {
+ membersInjectionBindings.tryToGenerateBinding(
+ binding.unresolved().get(), warnIfNotAlreadyGenerated);
+ }
+ }
+
+ @Override
+ public Optional<ProvisionBinding> tryRegisterConstructor(ExecutableElement constructorElement) {
+ return tryRegisterConstructor(constructorElement, Optional.empty(), false);
+ }
+
+ @CanIgnoreReturnValue
+ private Optional<ProvisionBinding> tryRegisterConstructor(
+ ExecutableElement constructorElement,
+ Optional<TypeMirror> resolvedType,
+ boolean warnIfNotAlreadyGenerated) {
+ TypeElement typeElement = MoreElements.asType(constructorElement.getEnclosingElement());
+ DeclaredType type = MoreTypes.asDeclared(typeElement.asType());
+ Key key = keyFactory.forInjectConstructorWithResolvedType(type);
+ ProvisionBinding cachedBinding = provisionBindings.getBinding(key);
+ if (cachedBinding != null) {
+ return Optional.of(cachedBinding);
+ }
+
+ ValidationReport<TypeElement> report = injectValidator.validateConstructor(constructorElement);
+ report.printMessagesTo(messager);
+ if (report.isClean()) {
+ ProvisionBinding binding = bindingFactory.injectionBinding(constructorElement, resolvedType);
+ registerBinding(binding, warnIfNotAlreadyGenerated);
+ if (!binding.injectionSites().isEmpty()) {
+ tryRegisterMembersInjectedType(typeElement, resolvedType, warnIfNotAlreadyGenerated);
+ }
+ return Optional.of(binding);
+ }
+ return Optional.empty();
+ }
+
+ @Override
+ public Optional<MembersInjectionBinding> tryRegisterMembersInjectedType(TypeElement typeElement) {
+ return tryRegisterMembersInjectedType(typeElement, Optional.empty(), false);
+ }
+
+ @CanIgnoreReturnValue
+ private Optional<MembersInjectionBinding> tryRegisterMembersInjectedType(
+ TypeElement typeElement,
+ Optional<TypeMirror> resolvedType,
+ boolean warnIfNotAlreadyGenerated) {
+ DeclaredType type = MoreTypes.asDeclared(typeElement.asType());
+ Key key = keyFactory.forInjectConstructorWithResolvedType(type);
+ MembersInjectionBinding cachedBinding = membersInjectionBindings.getBinding(key);
+ if (cachedBinding != null) {
+ return Optional.of(cachedBinding);
+ }
+
+ ValidationReport<TypeElement> report =
+ injectValidator.validateMembersInjectionType(typeElement);
+ report.printMessagesTo(messager);
+ if (report.isClean()) {
+ MembersInjectionBinding binding = bindingFactory.membersInjectionBinding(type, resolvedType);
+ registerBinding(binding, warnIfNotAlreadyGenerated);
+ for (Optional<DeclaredType> supertype = types.nonObjectSuperclass(type);
+ supertype.isPresent();
+ supertype = types.nonObjectSuperclass(supertype.get())) {
+ getOrFindMembersInjectionBinding(keyFactory.forMembersInjectedType(supertype.get()));
+ }
+ return Optional.of(binding);
+ }
+ return Optional.empty();
+ }
+
+ @CanIgnoreReturnValue
+ @Override
+ public Optional<ProvisionBinding> getOrFindProvisionBinding(Key key) {
+ checkNotNull(key);
+ if (!isValidImplicitProvisionKey(key, types)) {
+ return Optional.empty();
+ }
+ ProvisionBinding binding = provisionBindings.getBinding(key);
+ if (binding != null) {
+ return Optional.of(binding);
+ }
+
+ // ok, let's see if we can find an @Inject constructor
+ TypeElement element = MoreElements.asType(types.asElement(key.type()));
+ ImmutableSet<ExecutableElement> injectConstructors =
+ ImmutableSet.<ExecutableElement>builder()
+ .addAll(injectedConstructors(element))
+ .addAll(assistedInjectedConstructors(element))
+ .build();
+ switch (injectConstructors.size()) {
+ case 0:
+ // No constructor found.
+ return Optional.empty();
+ case 1:
+ return tryRegisterConstructor(
+ Iterables.getOnlyElement(injectConstructors), Optional.of(key.type()), true);
+ default:
+ throw new IllegalStateException("Found multiple @Inject constructors: "
+ + injectConstructors);
+ }
+ }
+
+ @CanIgnoreReturnValue
+ @Override
+ public Optional<MembersInjectionBinding> getOrFindMembersInjectionBinding(Key key) {
+ checkNotNull(key);
+ // TODO(gak): is checking the kind enough?
+ checkArgument(isValidMembersInjectionKey(key));
+ MembersInjectionBinding binding = membersInjectionBindings.getBinding(key);
+ if (binding != null) {
+ return Optional.of(binding);
+ }
+ Optional<MembersInjectionBinding> newBinding =
+ tryRegisterMembersInjectedType(
+ MoreTypes.asTypeElement(key.type()), Optional.of(key.type()), true);
+ return newBinding;
+ }
+
+ @Override
+ public Optional<ProvisionBinding> getOrFindMembersInjectorProvisionBinding(Key key) {
+ if (!isValidMembersInjectionKey(key)) {
+ return Optional.empty();
+ }
+ Key membersInjectionKey = keyFactory.forMembersInjectedType(types.unwrapType(key.type()));
+ return getOrFindMembersInjectionBinding(membersInjectionKey)
+ .map(binding -> bindingFactory.membersInjectorBinding(key, binding));
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/InjectBindingRegistryModule.java b/java/dagger/internal/codegen/validation/InjectBindingRegistryModule.java
new file mode 100644
index 0000000..3a164ca
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/InjectBindingRegistryModule.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import dagger.Binds;
+import dagger.Module;
+import dagger.internal.codegen.binding.InjectBindingRegistry;
+
+/** Binds the {@link InjectBindingRegistry} implementation. */
+@Module
+public interface InjectBindingRegistryModule {
+ @Binds InjectBindingRegistry injectBindingRegistry(InjectBindingRegistryImpl impl);
+}
diff --git a/java/dagger/internal/codegen/validation/InjectValidator.java b/java/dagger/internal/codegen/validation/InjectValidator.java
new file mode 100644
index 0000000..240f9d0
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/InjectValidator.java
@@ -0,0 +1,420 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static com.google.auto.common.MoreElements.asType;
+import static com.google.auto.common.MoreElements.isAnnotationPresent;
+import static dagger.internal.codegen.base.Scopes.scopesOf;
+import static dagger.internal.codegen.base.Util.reentrantComputeIfAbsent;
+import static dagger.internal.codegen.binding.AssistedInjectionAnnotations.assistedInjectedConstructors;
+import static dagger.internal.codegen.binding.InjectionAnnotations.injectedConstructors;
+import static javax.lang.model.element.Modifier.ABSTRACT;
+import static javax.lang.model.element.Modifier.FINAL;
+import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.STATIC;
+import static javax.lang.model.type.TypeKind.DECLARED;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.MoreTypes;
+import com.google.common.collect.ImmutableSet;
+import dagger.assisted.AssistedInject;
+import dagger.internal.codegen.base.ClearableCache;
+import dagger.internal.codegen.binding.InjectionAnnotations;
+import dagger.internal.codegen.compileroption.CompilerOptions;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.internal.codegen.langmodel.Accessibility;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.Scope;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.ElementFilter;
+import javax.tools.Diagnostic;
+import javax.tools.Diagnostic.Kind;
+
+/**
+ * A {@linkplain ValidationReport validator} for {@link Inject}-annotated elements and the types
+ * that contain them.
+ */
+@Singleton
+public final class InjectValidator implements ClearableCache {
+ private final DaggerTypes types;
+ private final DaggerElements elements;
+ private final CompilerOptions compilerOptions;
+ private final DependencyRequestValidator dependencyRequestValidator;
+ private final Optional<Diagnostic.Kind> privateAndStaticInjectionDiagnosticKind;
+ private final InjectionAnnotations injectionAnnotations;
+ private final KotlinMetadataUtil metadataUtil;
+ private final Map<ExecutableElement, ValidationReport<TypeElement>> reports = new HashMap<>();
+
+ @Inject
+ InjectValidator(
+ DaggerTypes types,
+ DaggerElements elements,
+ DependencyRequestValidator dependencyRequestValidator,
+ CompilerOptions compilerOptions,
+ InjectionAnnotations injectionAnnotations,
+ KotlinMetadataUtil metadataUtil) {
+ this(
+ types,
+ elements,
+ compilerOptions,
+ dependencyRequestValidator,
+ Optional.empty(),
+ injectionAnnotations,
+ metadataUtil);
+ }
+
+ private InjectValidator(
+ DaggerTypes types,
+ DaggerElements elements,
+ CompilerOptions compilerOptions,
+ DependencyRequestValidator dependencyRequestValidator,
+ Optional<Kind> privateAndStaticInjectionDiagnosticKind,
+ InjectionAnnotations injectionAnnotations,
+ KotlinMetadataUtil metadataUtil) {
+ this.types = types;
+ this.elements = elements;
+ this.compilerOptions = compilerOptions;
+ this.dependencyRequestValidator = dependencyRequestValidator;
+ this.privateAndStaticInjectionDiagnosticKind = privateAndStaticInjectionDiagnosticKind;
+ this.injectionAnnotations = injectionAnnotations;
+ this.metadataUtil = metadataUtil;
+ }
+
+ @Override
+ public void clearCache() {
+ reports.clear();
+ }
+
+ /**
+ * Returns a new validator that performs the same validation as this one, but is strict about
+ * rejecting optionally-specified JSR 330 behavior that Dagger doesn't support (unless {@code
+ * -Adagger.ignorePrivateAndStaticInjectionForComponent=enabled} was set in the javac options).
+ */
+ public InjectValidator whenGeneratingCode() {
+ return compilerOptions.ignorePrivateAndStaticInjectionForComponent()
+ ? this
+ : new InjectValidator(
+ types,
+ elements,
+ compilerOptions,
+ dependencyRequestValidator,
+ Optional.of(Diagnostic.Kind.ERROR),
+ injectionAnnotations,
+ metadataUtil);
+ }
+
+ public ValidationReport<TypeElement> validateConstructor(ExecutableElement constructorElement) {
+ return reentrantComputeIfAbsent(reports, constructorElement, this::validateConstructorUncached);
+ }
+
+ private ValidationReport<TypeElement> validateConstructorUncached(
+ ExecutableElement constructorElement) {
+ ValidationReport.Builder<TypeElement> builder =
+ ValidationReport.about(asType(constructorElement.getEnclosingElement()));
+
+ if (isAnnotationPresent(constructorElement, Inject.class)
+ && isAnnotationPresent(constructorElement, AssistedInject.class)) {
+ builder.addError("Constructors cannot be annotated with both @Inject and @AssistedInject");
+ }
+
+ Class<?> injectAnnotation =
+ isAnnotationPresent(constructorElement, Inject.class) ? Inject.class : AssistedInject.class;
+
+ if (constructorElement.getModifiers().contains(PRIVATE)) {
+ builder.addError(
+ "Dagger does not support injection into private constructors", constructorElement);
+ }
+
+ for (AnnotationMirror qualifier : injectionAnnotations.getQualifiers(constructorElement)) {
+ builder.addError(
+ String.format(
+ "@Qualifier annotations are not allowed on @%s constructors",
+ injectAnnotation.getSimpleName()),
+ constructorElement,
+ qualifier);
+ }
+
+ String scopeErrorMsg =
+ String.format(
+ "@Scope annotations are not allowed on @%s constructors",
+ injectAnnotation.getSimpleName());
+
+ if (injectAnnotation == Inject.class) {
+ scopeErrorMsg += "; annotate the class instead";
+ }
+
+ for (Scope scope : scopesOf(constructorElement)) {
+ builder.addError(scopeErrorMsg, constructorElement, scope.scopeAnnotation());
+ }
+
+ for (VariableElement parameter : constructorElement.getParameters()) {
+ validateDependencyRequest(builder, parameter);
+ }
+
+ if (throwsCheckedExceptions(constructorElement)) {
+ builder.addItem(
+ String.format(
+ "Dagger does not support checked exceptions on @%s constructors",
+ injectAnnotation.getSimpleName()),
+ privateMemberDiagnosticKind(),
+ constructorElement);
+ }
+
+ checkInjectIntoPrivateClass(constructorElement, builder);
+
+ TypeElement enclosingElement =
+ MoreElements.asType(constructorElement.getEnclosingElement());
+
+ Set<Modifier> typeModifiers = enclosingElement.getModifiers();
+ if (typeModifiers.contains(ABSTRACT)) {
+ builder.addError(
+ String.format(
+ "@%s is nonsense on the constructor of an abstract class",
+ injectAnnotation.getSimpleName()),
+ constructorElement);
+ }
+
+ if (enclosingElement.getNestingKind().isNested()
+ && !typeModifiers.contains(STATIC)) {
+ builder.addError(
+ String.format(
+ "@%s constructors are invalid on inner classes. "
+ + "Did you mean to make the class static?",
+ injectAnnotation.getSimpleName()),
+ constructorElement);
+ }
+
+ // This is computationally expensive, but probably preferable to a giant index
+ ImmutableSet<ExecutableElement> injectConstructors =
+ ImmutableSet.<ExecutableElement>builder()
+ .addAll(injectedConstructors(enclosingElement))
+ .addAll(assistedInjectedConstructors(enclosingElement))
+ .build();
+
+ if (injectConstructors.size() > 1) {
+ builder.addError("Types may only contain one injected constructor", constructorElement);
+ }
+
+ ImmutableSet<Scope> scopes = scopesOf(enclosingElement);
+ if (injectAnnotation == AssistedInject.class) {
+ for (Scope scope : scopes) {
+ builder.addError(
+ "A type with an @AssistedInject-annotated constructor cannot be scoped",
+ enclosingElement,
+ scope.scopeAnnotation());
+ }
+ } else if (scopes.size() > 1) {
+ for (Scope scope : scopes) {
+ builder.addError(
+ "A single binding may not declare more than one @Scope",
+ enclosingElement,
+ scope.scopeAnnotation());
+ }
+ }
+
+ return builder.build();
+ }
+
+ private ValidationReport<VariableElement> validateField(VariableElement fieldElement) {
+ ValidationReport.Builder<VariableElement> builder = ValidationReport.about(fieldElement);
+ Set<Modifier> modifiers = fieldElement.getModifiers();
+ if (modifiers.contains(FINAL)) {
+ builder.addError("@Inject fields may not be final", fieldElement);
+ }
+
+ if (modifiers.contains(PRIVATE)) {
+ builder.addItem(
+ "Dagger does not support injection into private fields",
+ privateMemberDiagnosticKind(),
+ fieldElement);
+ }
+
+ if (modifiers.contains(STATIC)) {
+ builder.addItem(
+ "Dagger does not support injection into static fields",
+ staticMemberDiagnosticKind(),
+ fieldElement);
+ }
+
+ validateDependencyRequest(builder, fieldElement);
+
+ return builder.build();
+ }
+
+ private ValidationReport<ExecutableElement> validateMethod(ExecutableElement methodElement) {
+ ValidationReport.Builder<ExecutableElement> builder = ValidationReport.about(methodElement);
+ Set<Modifier> modifiers = methodElement.getModifiers();
+ if (modifiers.contains(ABSTRACT)) {
+ builder.addError("Methods with @Inject may not be abstract", methodElement);
+ }
+
+ if (modifiers.contains(PRIVATE)) {
+ builder.addItem(
+ "Dagger does not support injection into private methods",
+ privateMemberDiagnosticKind(),
+ methodElement);
+ }
+
+ if (modifiers.contains(STATIC)) {
+ builder.addItem(
+ "Dagger does not support injection into static methods",
+ staticMemberDiagnosticKind(),
+ methodElement);
+ }
+
+ if (!methodElement.getTypeParameters().isEmpty()) {
+ builder.addError("Methods with @Inject may not declare type parameters", methodElement);
+ }
+
+ if (!methodElement.getThrownTypes().isEmpty()) {
+ builder.addError("Methods with @Inject may not throw checked exceptions. "
+ + "Please wrap your exceptions in a RuntimeException instead.", methodElement);
+ }
+
+ for (VariableElement parameter : methodElement.getParameters()) {
+ validateDependencyRequest(builder, parameter);
+ }
+
+ return builder.build();
+ }
+
+ private void validateDependencyRequest(
+ ValidationReport.Builder<?> builder, VariableElement parameter) {
+ dependencyRequestValidator.validateDependencyRequest(builder, parameter, parameter.asType());
+ dependencyRequestValidator.checkNotProducer(builder, parameter);
+ }
+
+ public ValidationReport<TypeElement> validateMembersInjectionType(TypeElement typeElement) {
+ // TODO(beder): This element might not be currently compiled, so this error message could be
+ // left in limbo. Find an appropriate way to display the error message in that case.
+ ValidationReport.Builder<TypeElement> builder = ValidationReport.about(typeElement);
+ boolean hasInjectedMembers = false;
+ for (VariableElement element : ElementFilter.fieldsIn(typeElement.getEnclosedElements())) {
+ if (MoreElements.isAnnotationPresent(element, Inject.class)) {
+ hasInjectedMembers = true;
+ ValidationReport<VariableElement> report = validateField(element);
+ if (!report.isClean()) {
+ builder.addSubreport(report);
+ }
+ }
+ }
+ for (ExecutableElement element : ElementFilter.methodsIn(typeElement.getEnclosedElements())) {
+ if (MoreElements.isAnnotationPresent(element, Inject.class)) {
+ hasInjectedMembers = true;
+ ValidationReport<ExecutableElement> report = validateMethod(element);
+ if (!report.isClean()) {
+ builder.addSubreport(report);
+ }
+ }
+ }
+
+ if (hasInjectedMembers) {
+ checkInjectIntoPrivateClass(typeElement, builder);
+ checkInjectIntoKotlinObject(typeElement, builder);
+ }
+ TypeMirror superclass = typeElement.getSuperclass();
+ if (!superclass.getKind().equals(TypeKind.NONE)) {
+ ValidationReport<TypeElement> report = validateType(MoreTypes.asTypeElement(superclass));
+ if (!report.isClean()) {
+ builder.addSubreport(report);
+ }
+ }
+ return builder.build();
+ }
+
+ public ValidationReport<TypeElement> validateType(TypeElement typeElement) {
+ ValidationReport.Builder<TypeElement> builder = ValidationReport.about(typeElement);
+ ValidationReport<TypeElement> membersInjectionReport =
+ validateMembersInjectionType(typeElement);
+ if (!membersInjectionReport.isClean()) {
+ builder.addSubreport(membersInjectionReport);
+ }
+ for (ExecutableElement element :
+ ElementFilter.constructorsIn(typeElement.getEnclosedElements())) {
+ if (isAnnotationPresent(element, Inject.class)
+ || isAnnotationPresent(element, AssistedInject.class)) {
+ ValidationReport<TypeElement> report = validateConstructor(element);
+ if (!report.isClean()) {
+ builder.addSubreport(report);
+ }
+ }
+ }
+ return builder.build();
+ }
+
+ public boolean isValidType(TypeMirror type) {
+ if (!type.getKind().equals(DECLARED)) {
+ return true;
+ }
+ return validateType(MoreTypes.asTypeElement(type)).isClean();
+ }
+
+ /** Returns true if the given method element declares a checked exception. */
+ private boolean throwsCheckedExceptions(ExecutableElement methodElement) {
+ TypeMirror runtimeExceptionType = elements.getTypeElement(RuntimeException.class).asType();
+ TypeMirror errorType = elements.getTypeElement(Error.class).asType();
+ for (TypeMirror thrownType : methodElement.getThrownTypes()) {
+ if (!types.isSubtype(thrownType, runtimeExceptionType)
+ && !types.isSubtype(thrownType, errorType)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private void checkInjectIntoPrivateClass(
+ Element element, ValidationReport.Builder<TypeElement> builder) {
+ if (!Accessibility.isElementAccessibleFromOwnPackage(
+ DaggerElements.closestEnclosingTypeElement(element))) {
+ builder.addItem(
+ "Dagger does not support injection into private classes",
+ privateMemberDiagnosticKind(),
+ element);
+ }
+ }
+
+ private void checkInjectIntoKotlinObject(
+ TypeElement element, ValidationReport.Builder<TypeElement> builder) {
+ if (metadataUtil.isObjectClass(element) || metadataUtil.isCompanionObjectClass(element)) {
+ builder.addError("Dagger does not support injection into Kotlin objects", element);
+ }
+ }
+
+ private Diagnostic.Kind privateMemberDiagnosticKind() {
+ return privateAndStaticInjectionDiagnosticKind.orElse(
+ compilerOptions.privateMemberValidationKind());
+ }
+
+ private Diagnostic.Kind staticMemberDiagnosticKind() {
+ return privateAndStaticInjectionDiagnosticKind.orElse(
+ compilerOptions.staticMemberValidationKind());
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/MapKeyValidator.java b/java/dagger/internal/codegen/validation/MapKeyValidator.java
new file mode 100644
index 0000000..6aa5147
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/MapKeyValidator.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static javax.lang.model.util.ElementFilter.methodsIn;
+
+import dagger.MapKey;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import java.util.List;
+import javax.inject.Inject;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeKind;
+
+/**
+ * A validator for {@link MapKey} annotations.
+ */
+// TODO(dpb,gak): Should unwrapped MapKeys be required to have their single member be named "value"?
+public final class MapKeyValidator {
+ private final DaggerElements elements;
+
+ @Inject
+ MapKeyValidator(DaggerElements elements) {
+ this.elements = elements;
+ }
+
+ public ValidationReport<Element> validate(Element element) {
+ ValidationReport.Builder<Element> builder = ValidationReport.about(element);
+ List<ExecutableElement> members = methodsIn(((TypeElement) element).getEnclosedElements());
+ if (members.isEmpty()) {
+ builder.addError("Map key annotations must have members", element);
+ } else if (element.getAnnotation(MapKey.class).unwrapValue()) {
+ if (members.size() > 1) {
+ builder.addError(
+ "Map key annotations with unwrapped values must have exactly one member", element);
+ } else if (members.get(0).getReturnType().getKind() == TypeKind.ARRAY) {
+ builder.addError("Map key annotations with unwrapped values cannot use arrays", element);
+ }
+ } else if (autoAnnotationIsMissing()) {
+ builder.addError(
+ "@AutoAnnotation is a necessary dependency if @MapKey(unwrapValue = false). Add a "
+ + "dependency on com.google.auto.value:auto-value:<current version>");
+ }
+ return builder.build();
+ }
+
+ private boolean autoAnnotationIsMissing() {
+ return elements.getTypeElement("com.google.auto.value.AutoAnnotation") == null;
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/MembersInjectionValidator.java b/java/dagger/internal/codegen/validation/MembersInjectionValidator.java
new file mode 100644
index 0000000..afa6270
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/MembersInjectionValidator.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import com.google.auto.common.MoreElements;
+import dagger.internal.codegen.binding.InjectionAnnotations;
+import javax.inject.Inject;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.type.ArrayType;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.PrimitiveType;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.type.TypeVisitor;
+import javax.lang.model.util.SimpleTypeVisitor8;
+
+/**
+ * Validates members injection requests (members injection methods on components and requests for
+ * {@code MembersInjector<Foo>}).
+ */
+final class MembersInjectionValidator {
+ private final InjectionAnnotations injectionAnnotations;
+
+ @Inject
+ MembersInjectionValidator(InjectionAnnotations injectionAnnotations) {
+ this.injectionAnnotations = injectionAnnotations;
+ }
+
+ /** Reports errors if a request for a {@code MembersInjector<Foo>}) is invalid. */
+ ValidationReport<Element> validateMembersInjectionRequest(
+ Element requestElement, TypeMirror membersInjectedType) {
+ ValidationReport.Builder<Element> report = ValidationReport.about(requestElement);
+ checkQualifiers(report, requestElement);
+ membersInjectedType.accept(VALIDATE_MEMBERS_INJECTED_TYPE, report);
+ return report.build();
+ }
+
+ /**
+ * Reports errors if a members injection method on a component is invalid.
+ *
+ * @throws IllegalArgumentException if the method doesn't have exactly one parameter
+ */
+ ValidationReport<ExecutableElement> validateMembersInjectionMethod(
+ ExecutableElement method, TypeMirror membersInjectedType) {
+ checkArgument(
+ method.getParameters().size() == 1, "expected a method with one parameter: %s", method);
+
+ ValidationReport.Builder<ExecutableElement> report = ValidationReport.about(method);
+ checkQualifiers(report, method);
+ checkQualifiers(report, method.getParameters().get(0));
+ membersInjectedType.accept(VALIDATE_MEMBERS_INJECTED_TYPE, report);
+ return report.build();
+ }
+
+ private void checkQualifiers(ValidationReport.Builder<?> report, Element element) {
+ for (AnnotationMirror qualifier : injectionAnnotations.getQualifiers(element)) {
+ report.addError("Cannot inject members into qualified types", element, qualifier);
+ break; // just report on the first qualifier, in case there is more than one
+ }
+ }
+
+ private static final TypeVisitor<Void, ValidationReport.Builder<?>>
+ VALIDATE_MEMBERS_INJECTED_TYPE =
+ new SimpleTypeVisitor8<Void, ValidationReport.Builder<?>>() {
+ // Only declared types can be members-injected.
+ @Override
+ protected Void defaultAction(TypeMirror type, ValidationReport.Builder<?> report) {
+ report.addError("Cannot inject members into " + type);
+ return null;
+ }
+
+ @Override
+ public Void visitDeclared(DeclaredType type, ValidationReport.Builder<?> report) {
+ if (type.getTypeArguments().isEmpty()) {
+ // If the type is the erasure of a generic type, that means the user referred to
+ // Foo<T> as just 'Foo', which we don't allow. (This is a judgement call; we
+ // *could* allow it and instantiate the type bounds, but we don't.)
+ if (!MoreElements.asType(type.asElement()).getTypeParameters().isEmpty()) {
+ report.addError("Cannot inject members into raw type " + type);
+ }
+ } else {
+ // If the type has arguments, validate that each type argument is declared.
+ // Otherwise the type argument may be a wildcard (or other type), and we can't
+ // resolve that to actual types. For array type arguments, validate the type of the
+ // array.
+ for (TypeMirror arg : type.getTypeArguments()) {
+ if (!arg.accept(DECLARED_OR_ARRAY, null)) {
+ report.addError(
+ "Cannot inject members into types with unbounded type arguments: " + type);
+ }
+ }
+ }
+ return null;
+ }
+ };
+
+ // TODO(dpb): Can this be inverted so it explicitly rejects wildcards or type variables?
+ // This logic is hard to describe.
+ private static final TypeVisitor<Boolean, Void> DECLARED_OR_ARRAY =
+ new SimpleTypeVisitor8<Boolean, Void>(false) {
+ @Override
+ public Boolean visitArray(ArrayType arrayType, Void p) {
+ return arrayType
+ .getComponentType()
+ .accept(
+ new SimpleTypeVisitor8<Boolean, Void>(false) {
+ @Override
+ public Boolean visitDeclared(DeclaredType declaredType, Void p) {
+ for (TypeMirror arg : declaredType.getTypeArguments()) {
+ if (!arg.accept(this, null)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ @Override
+ public Boolean visitArray(ArrayType arrayType, Void p) {
+ return arrayType.getComponentType().accept(this, null);
+ }
+
+ @Override
+ public Boolean visitPrimitive(PrimitiveType primitiveType, Void p) {
+ return true;
+ }
+ },
+ null);
+ }
+
+ @Override
+ public Boolean visitDeclared(DeclaredType t, Void p) {
+ return true;
+ }
+ };
+}
diff --git a/java/dagger/internal/codegen/validation/ModuleValidator.java b/java/dagger/internal/codegen/validation/ModuleValidator.java
new file mode 100644
index 0000000..02ac06a
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/ModuleValidator.java
@@ -0,0 +1,712 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static com.google.auto.common.AnnotationMirrors.getAnnotatedAnnotations;
+import static com.google.auto.common.MoreElements.isAnnotationPresent;
+import static com.google.auto.common.MoreTypes.asTypeElement;
+import static com.google.auto.common.Visibility.PRIVATE;
+import static com.google.auto.common.Visibility.PUBLIC;
+import static com.google.auto.common.Visibility.effectiveVisibilityOfElement;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static dagger.internal.codegen.base.ComponentAnnotation.componentAnnotation;
+import static dagger.internal.codegen.base.ComponentAnnotation.isComponentAnnotation;
+import static dagger.internal.codegen.base.ComponentAnnotation.subcomponentAnnotation;
+import static dagger.internal.codegen.base.ModuleAnnotation.isModuleAnnotation;
+import static dagger.internal.codegen.base.ModuleAnnotation.moduleAnnotation;
+import static dagger.internal.codegen.base.MoreAnnotationMirrors.simpleName;
+import static dagger.internal.codegen.base.MoreAnnotationValues.asType;
+import static dagger.internal.codegen.base.Util.reentrantComputeIfAbsent;
+import static dagger.internal.codegen.binding.ComponentCreatorAnnotation.getCreatorAnnotations;
+import static dagger.internal.codegen.binding.ConfigurationAnnotations.getSubcomponentCreator;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static dagger.internal.codegen.langmodel.DaggerElements.getAnnotationMirror;
+import static dagger.internal.codegen.langmodel.DaggerElements.isAnyAnnotationPresent;
+import static java.util.stream.Collectors.joining;
+import static javax.lang.model.element.Modifier.ABSTRACT;
+import static javax.lang.model.element.Modifier.STATIC;
+import static javax.lang.model.util.ElementFilter.methodsIn;
+
+import com.google.auto.common.MoreElements;
+import com.google.auto.common.MoreTypes;
+import com.google.auto.common.Visibility;
+import com.google.common.base.Joiner;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableListMultimap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ListMultimap;
+import com.google.common.collect.MultimapBuilder;
+import com.google.common.collect.Multimaps;
+import com.google.common.collect.Sets;
+import com.google.errorprone.annotations.FormatMethod;
+import dagger.Module;
+import dagger.Subcomponent;
+import dagger.internal.codegen.base.ModuleAnnotation;
+import dagger.internal.codegen.binding.BindingGraphFactory;
+import dagger.internal.codegen.binding.ComponentCreatorAnnotation;
+import dagger.internal.codegen.binding.ComponentDescriptorFactory;
+import dagger.internal.codegen.binding.MethodSignatureFormatter;
+import dagger.internal.codegen.binding.ModuleKind;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.BindingGraph;
+import dagger.producers.ProducerModule;
+import dagger.producers.ProductionSubcomponent;
+import java.lang.annotation.Annotation;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Optional;
+import java.util.Set;
+import javax.inject.Inject;
+import javax.inject.Scope;
+import javax.inject.Singleton;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.Name;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.SimpleAnnotationValueVisitor8;
+import javax.lang.model.util.SimpleTypeVisitor8;
+
+/** A {@linkplain ValidationReport validator} for {@link Module}s or {@link ProducerModule}s. */
+@Singleton
+public final class ModuleValidator {
+ private static final ImmutableSet<Class<? extends Annotation>> SUBCOMPONENT_TYPES =
+ ImmutableSet.of(Subcomponent.class, ProductionSubcomponent.class);
+ private static final ImmutableSet<Class<? extends Annotation>> SUBCOMPONENT_CREATOR_TYPES =
+ ImmutableSet.of(
+ Subcomponent.Builder.class,
+ Subcomponent.Factory.class,
+ ProductionSubcomponent.Builder.class,
+ ProductionSubcomponent.Factory.class);
+ private static final Optional<Class<?>> ANDROID_PROCESSOR;
+ private static final String CONTRIBUTES_ANDROID_INJECTOR_NAME =
+ "dagger.android.ContributesAndroidInjector";
+ private static final String ANDROID_PROCESSOR_NAME = "dagger.android.processor.AndroidProcessor";
+
+ static {
+ Class<?> clazz;
+ try {
+ clazz = Class.forName(ANDROID_PROCESSOR_NAME, false, ModuleValidator.class.getClassLoader());
+ } catch (ClassNotFoundException ignored) {
+ clazz = null;
+ }
+ ANDROID_PROCESSOR = Optional.ofNullable(clazz);
+ }
+
+ private final DaggerTypes types;
+ private final DaggerElements elements;
+ private final AnyBindingMethodValidator anyBindingMethodValidator;
+ private final MethodSignatureFormatter methodSignatureFormatter;
+ private final ComponentDescriptorFactory componentDescriptorFactory;
+ private final BindingGraphFactory bindingGraphFactory;
+ private final BindingGraphValidator bindingGraphValidator;
+ private final KotlinMetadataUtil metadataUtil;
+ private final Map<TypeElement, ValidationReport<TypeElement>> cache = new HashMap<>();
+ private final Set<TypeElement> knownModules = new HashSet<>();
+
+ @Inject
+ ModuleValidator(
+ DaggerTypes types,
+ DaggerElements elements,
+ AnyBindingMethodValidator anyBindingMethodValidator,
+ MethodSignatureFormatter methodSignatureFormatter,
+ ComponentDescriptorFactory componentDescriptorFactory,
+ BindingGraphFactory bindingGraphFactory,
+ BindingGraphValidator bindingGraphValidator,
+ KotlinMetadataUtil metadataUtil) {
+ this.types = types;
+ this.elements = elements;
+ this.anyBindingMethodValidator = anyBindingMethodValidator;
+ this.methodSignatureFormatter = methodSignatureFormatter;
+ this.componentDescriptorFactory = componentDescriptorFactory;
+ this.bindingGraphFactory = bindingGraphFactory;
+ this.bindingGraphValidator = bindingGraphValidator;
+ this.metadataUtil = metadataUtil;
+ }
+
+ /**
+ * Adds {@code modules} to the set of module types that will be validated during this compilation
+ * step. If a component or module includes a module that is not in this set, that included module
+ * is assumed to be valid because it was processed in a previous compilation step. If it were
+ * invalid, that previous compilation step would have failed and blocked this one.
+ *
+ * <p>This logic depends on this method being called before {@linkplain #validate(TypeElement)
+ * validating} any module or {@linkplain #validateReferencedModules(TypeElement, AnnotationMirror,
+ * ImmutableSet, Set) component}.
+ */
+ public void addKnownModules(Collection<TypeElement> modules) {
+ knownModules.addAll(modules);
+ }
+
+ /** Returns a validation report for a module type. */
+ public ValidationReport<TypeElement> validate(TypeElement module) {
+ return validate(module, new HashSet<>());
+ }
+
+ private ValidationReport<TypeElement> validate(
+ TypeElement module, Set<TypeElement> visitedModules) {
+ if (visitedModules.add(module)) {
+ return reentrantComputeIfAbsent(cache, module, m -> validateUncached(module, visitedModules));
+ }
+ return ValidationReport.about(module).build();
+ }
+
+ private ValidationReport<TypeElement> validateUncached(
+ TypeElement module, Set<TypeElement> visitedModules) {
+ ValidationReport.Builder<TypeElement> builder = ValidationReport.about(module);
+ ModuleKind moduleKind = ModuleKind.forAnnotatedElement(module).get();
+ TypeElement contributesAndroidInjectorElement =
+ elements.getTypeElement(CONTRIBUTES_ANDROID_INJECTOR_NAME);
+ TypeMirror contributesAndroidInjector =
+ contributesAndroidInjectorElement != null
+ ? contributesAndroidInjectorElement.asType()
+ : null;
+ List<ExecutableElement> moduleMethods = methodsIn(module.getEnclosedElements());
+ List<ExecutableElement> bindingMethods = new ArrayList<>();
+ for (ExecutableElement moduleMethod : moduleMethods) {
+ if (anyBindingMethodValidator.isBindingMethod(moduleMethod)) {
+ builder.addSubreport(anyBindingMethodValidator.validate(moduleMethod));
+ bindingMethods.add(moduleMethod);
+ }
+
+ for (AnnotationMirror annotation : moduleMethod.getAnnotationMirrors()) {
+ if (!ANDROID_PROCESSOR.isPresent()
+ && MoreTypes.equivalence()
+ .equivalent(contributesAndroidInjector, annotation.getAnnotationType())) {
+ builder.addSubreport(
+ ValidationReport.about(moduleMethod)
+ .addError(
+ String.format(
+ "@%s was used, but %s was not found on the processor path",
+ CONTRIBUTES_ANDROID_INJECTOR_NAME, ANDROID_PROCESSOR_NAME))
+ .build());
+ break;
+ }
+ }
+ }
+
+ if (bindingMethods.stream()
+ .map(ModuleMethodKind::ofMethod)
+ .collect(toImmutableSet())
+ .containsAll(
+ EnumSet.of(ModuleMethodKind.ABSTRACT_DECLARATION, ModuleMethodKind.INSTANCE_BINDING))) {
+ builder.addError(
+ String.format(
+ "A @%s may not contain both non-static and abstract binding methods",
+ moduleKind.annotation().getSimpleName()));
+ }
+
+ validateModuleVisibility(module, moduleKind, builder);
+
+ ImmutableListMultimap<Name, ExecutableElement> bindingMethodsByName =
+ Multimaps.index(bindingMethods, ExecutableElement::getSimpleName);
+
+ validateMethodsWithSameName(builder, bindingMethodsByName);
+ if (module.getKind() != ElementKind.INTERFACE) {
+ validateBindingMethodOverrides(
+ module,
+ builder,
+ Multimaps.index(moduleMethods, ExecutableElement::getSimpleName),
+ bindingMethodsByName);
+ }
+ validateModifiers(module, builder);
+ validateReferencedModules(module, moduleKind, visitedModules, builder);
+ validateReferencedSubcomponents(module, moduleKind, builder);
+ validateNoScopeAnnotationsOnModuleElement(module, moduleKind, builder);
+ validateSelfCycles(module, builder);
+ if (metadataUtil.hasEnclosedCompanionObject(module)) {
+ validateCompanionModule(module, builder);
+ }
+
+ if (builder.build().isClean()
+ && bindingGraphValidator.shouldDoFullBindingGraphValidation(module)) {
+ validateModuleBindings(module, builder);
+ }
+
+ return builder.build();
+ }
+
+ private void validateReferencedSubcomponents(
+ final TypeElement subject,
+ ModuleKind moduleKind,
+ final ValidationReport.Builder<TypeElement> builder) {
+ // TODO(ronshapiro): use validateTypesAreDeclared when it is checked in
+ ModuleAnnotation moduleAnnotation = moduleAnnotation(moduleKind.getModuleAnnotation(subject));
+ for (AnnotationValue subcomponentAttribute :
+ moduleAnnotation.subcomponentsAsAnnotationValues()) {
+ asType(subcomponentAttribute)
+ .accept(
+ new SimpleTypeVisitor8<Void, Void>() {
+ @Override
+ protected Void defaultAction(TypeMirror e, Void aVoid) {
+ builder.addError(
+ e + " is not a valid subcomponent type",
+ subject,
+ moduleAnnotation.annotation(),
+ subcomponentAttribute);
+ return null;
+ }
+
+ @Override
+ public Void visitDeclared(DeclaredType declaredType, Void aVoid) {
+ TypeElement attributeType = asTypeElement(declaredType);
+ if (isAnyAnnotationPresent(attributeType, SUBCOMPONENT_TYPES)) {
+ validateSubcomponentHasBuilder(
+ attributeType, moduleAnnotation.annotation(), builder);
+ } else {
+ builder.addError(
+ isAnyAnnotationPresent(attributeType, SUBCOMPONENT_CREATOR_TYPES)
+ ? moduleSubcomponentsIncludesCreator(attributeType)
+ : moduleSubcomponentsIncludesNonSubcomponent(attributeType),
+ subject,
+ moduleAnnotation.annotation(),
+ subcomponentAttribute);
+ }
+
+ return null;
+ }
+ },
+ null);
+ }
+ }
+
+ private static String moduleSubcomponentsIncludesNonSubcomponent(TypeElement notSubcomponent) {
+ return notSubcomponent.getQualifiedName()
+ + " is not a @Subcomponent or @ProductionSubcomponent";
+ }
+
+ private static String moduleSubcomponentsIncludesCreator(
+ TypeElement moduleSubcomponentsAttribute) {
+ TypeElement subcomponentType =
+ MoreElements.asType(moduleSubcomponentsAttribute.getEnclosingElement());
+ ComponentCreatorAnnotation creatorAnnotation =
+ getOnlyElement(getCreatorAnnotations(moduleSubcomponentsAttribute));
+ return String.format(
+ "%s is a @%s.%s. Did you mean to use %s?",
+ moduleSubcomponentsAttribute.getQualifiedName(),
+ subcomponentAnnotation(subcomponentType).get().simpleName(),
+ creatorAnnotation.creatorKind().typeName(),
+ subcomponentType.getQualifiedName());
+ }
+
+ private static void validateSubcomponentHasBuilder(
+ TypeElement subcomponentAttribute,
+ AnnotationMirror moduleAnnotation,
+ ValidationReport.Builder<TypeElement> builder) {
+ if (getSubcomponentCreator(subcomponentAttribute).isPresent()) {
+ return;
+ }
+ builder.addError(
+ moduleSubcomponentsDoesntHaveCreator(subcomponentAttribute, moduleAnnotation),
+ builder.getSubject(),
+ moduleAnnotation);
+ }
+
+ private static String moduleSubcomponentsDoesntHaveCreator(
+ TypeElement subcomponent, AnnotationMirror moduleAnnotation) {
+ return String.format(
+ "%1$s doesn't have a @%2$s.Builder or @%2$s.Factory, which is required when used with "
+ + "@%3$s.subcomponents",
+ subcomponent.getQualifiedName(),
+ subcomponentAnnotation(subcomponent).get().simpleName(),
+ simpleName(moduleAnnotation));
+ }
+
+ enum ModuleMethodKind {
+ ABSTRACT_DECLARATION,
+ INSTANCE_BINDING,
+ STATIC_BINDING,
+ ;
+
+ static ModuleMethodKind ofMethod(ExecutableElement moduleMethod) {
+ if (moduleMethod.getModifiers().contains(STATIC)) {
+ return STATIC_BINDING;
+ } else if (moduleMethod.getModifiers().contains(ABSTRACT)) {
+ return ABSTRACT_DECLARATION;
+ } else {
+ return INSTANCE_BINDING;
+ }
+ }
+ }
+
+ private void validateModifiers(
+ TypeElement subject, ValidationReport.Builder<TypeElement> builder) {
+ // This coupled with the check for abstract modules in ComponentValidator guarantees that
+ // only modules without type parameters are referenced from @Component(modules={...}).
+ if (!subject.getTypeParameters().isEmpty() && !subject.getModifiers().contains(ABSTRACT)) {
+ builder.addError("Modules with type parameters must be abstract", subject);
+ }
+ }
+
+ private void validateMethodsWithSameName(
+ ValidationReport.Builder<TypeElement> builder,
+ ListMultimap<Name, ExecutableElement> bindingMethodsByName) {
+ for (Entry<Name, Collection<ExecutableElement>> entry :
+ bindingMethodsByName.asMap().entrySet()) {
+ if (entry.getValue().size() > 1) {
+ for (ExecutableElement offendingMethod : entry.getValue()) {
+ builder.addError(
+ String.format(
+ "Cannot have more than one binding method with the same name in a single module"),
+ offendingMethod);
+ }
+ }
+ }
+ }
+
+ private void validateReferencedModules(
+ TypeElement subject,
+ ModuleKind moduleKind,
+ Set<TypeElement> visitedModules,
+ ValidationReport.Builder<TypeElement> builder) {
+ // Validate that all the modules we include are valid for inclusion.
+ AnnotationMirror mirror = moduleKind.getModuleAnnotation(subject);
+ builder.addSubreport(
+ validateReferencedModules(
+ subject, mirror, moduleKind.legalIncludedModuleKinds(), visitedModules));
+ }
+
+ /**
+ * Validates modules included in a given module or installed in a given component.
+ *
+ * <p>Checks that the referenced modules are non-generic types annotated with {@code @Module} or
+ * {@code @ProducerModule}.
+ *
+ * <p>If the referenced module is in the {@linkplain #addKnownModules(Collection) known modules
+ * set} and has errors, reports an error at that module's inclusion.
+ *
+ * @param annotatedType the annotated module or component
+ * @param annotation the annotation specifying the referenced modules ({@code @Component},
+ * {@code @ProductionComponent}, {@code @Subcomponent}, {@code @ProductionSubcomponent},
+ * {@code @Module}, or {@code @ProducerModule})
+ * @param validModuleKinds the module kinds that the annotated type is permitted to include
+ */
+ ValidationReport<TypeElement> validateReferencedModules(
+ TypeElement annotatedType,
+ AnnotationMirror annotation,
+ ImmutableSet<ModuleKind> validModuleKinds,
+ Set<TypeElement> visitedModules) {
+ ValidationReport.Builder<TypeElement> subreport = ValidationReport.about(annotatedType);
+ ImmutableSet<? extends Class<? extends Annotation>> validModuleAnnotations =
+ validModuleKinds.stream().map(ModuleKind::annotation).collect(toImmutableSet());
+
+ for (AnnotationValue includedModule : getModules(annotation)) {
+ asType(includedModule)
+ .accept(
+ new SimpleTypeVisitor8<Void, Void>() {
+ @Override
+ protected Void defaultAction(TypeMirror mirror, Void p) {
+ reportError("%s is not a valid module type.", mirror);
+ return null;
+ }
+
+ @Override
+ public Void visitDeclared(DeclaredType t, Void p) {
+ TypeElement module = MoreElements.asType(t.asElement());
+ if (!t.getTypeArguments().isEmpty()) {
+ reportError(
+ "%s is listed as a module, but has type parameters",
+ module.getQualifiedName());
+ }
+ if (!isAnyAnnotationPresent(module, validModuleAnnotations)) {
+ reportError(
+ "%s is listed as a module, but is not annotated with %s",
+ module.getQualifiedName(),
+ (validModuleAnnotations.size() > 1 ? "one of " : "")
+ + validModuleAnnotations.stream()
+ .map(otherClass -> "@" + otherClass.getSimpleName())
+ .collect(joining(", ")));
+ } else if (knownModules.contains(module)
+ && !validate(module, visitedModules).isClean()) {
+ reportError("%s has errors", module.getQualifiedName());
+ }
+ if (metadataUtil.isCompanionObjectClass(module)) {
+ reportError(
+ "%s is listed as a module, but it is a companion object class. "
+ + "Add @Module to the enclosing class and reference that instead.",
+ module.getQualifiedName());
+ }
+ return null;
+ }
+
+ @FormatMethod
+ private void reportError(String format, Object... args) {
+ subreport.addError(
+ String.format(format, args), annotatedType, annotation, includedModule);
+ }
+ },
+ null);
+ }
+ return subreport.build();
+ }
+
+ private static ImmutableList<AnnotationValue> getModules(AnnotationMirror annotation) {
+ if (isModuleAnnotation(annotation)) {
+ return moduleAnnotation(annotation).includesAsAnnotationValues();
+ }
+ if (isComponentAnnotation(annotation)) {
+ return componentAnnotation(annotation).moduleValues();
+ }
+ throw new IllegalArgumentException(String.format("unsupported annotation: %s", annotation));
+ }
+
+ private void validateBindingMethodOverrides(
+ TypeElement subject,
+ ValidationReport.Builder<TypeElement> builder,
+ ImmutableListMultimap<Name, ExecutableElement> moduleMethodsByName,
+ ImmutableListMultimap<Name, ExecutableElement> bindingMethodsByName) {
+ // For every binding method, confirm it overrides nothing *and* nothing overrides it.
+ // Consider the following hierarchy:
+ // class Parent {
+ // @Provides Foo a() {}
+ // @Provides Foo b() {}
+ // Foo c() {}
+ // }
+ // class Child extends Parent {
+ // @Provides Foo a() {}
+ // Foo b() {}
+ // @Provides Foo c() {}
+ // }
+ // In each of those cases, we want to fail. "a" is clear, "b" because Child is overriding
+ // a binding method in Parent, and "c" because Child is defining a binding method that overrides
+ // Parent.
+ TypeElement currentClass = subject;
+ TypeMirror objectType = elements.getTypeElement(Object.class).asType();
+ // We keep track of methods that failed so we don't spam with multiple failures.
+ Set<ExecutableElement> failedMethods = Sets.newHashSet();
+ ListMultimap<Name, ExecutableElement> allMethodsByName =
+ MultimapBuilder.hashKeys().arrayListValues().build(moduleMethodsByName);
+
+ while (!types.isSameType(currentClass.getSuperclass(), objectType)) {
+ currentClass = MoreElements.asType(types.asElement(currentClass.getSuperclass()));
+ List<ExecutableElement> superclassMethods = methodsIn(currentClass.getEnclosedElements());
+ for (ExecutableElement superclassMethod : superclassMethods) {
+ Name name = superclassMethod.getSimpleName();
+ // For each method in the superclass, confirm our binding methods don't override it
+ for (ExecutableElement bindingMethod : bindingMethodsByName.get(name)) {
+ if (failedMethods.add(bindingMethod)
+ && elements.overrides(bindingMethod, superclassMethod, subject)) {
+ builder.addError(
+ String.format(
+ "Binding methods may not override another method. Overrides: %s",
+ methodSignatureFormatter.format(superclassMethod)),
+ bindingMethod);
+ }
+ }
+ // For each binding method in superclass, confirm our methods don't override it.
+ if (anyBindingMethodValidator.isBindingMethod(superclassMethod)) {
+ for (ExecutableElement method : allMethodsByName.get(name)) {
+ if (failedMethods.add(method)
+ && elements.overrides(method, superclassMethod, subject)) {
+ builder.addError(
+ String.format(
+ "Binding methods may not be overridden in modules. Overrides: %s",
+ methodSignatureFormatter.format(superclassMethod)),
+ method);
+ }
+ }
+ }
+ allMethodsByName.put(superclassMethod.getSimpleName(), superclassMethod);
+ }
+ }
+ }
+
+ private void validateModuleVisibility(
+ final TypeElement moduleElement,
+ ModuleKind moduleKind,
+ final ValidationReport.Builder<?> reportBuilder) {
+ ModuleAnnotation moduleAnnotation =
+ moduleAnnotation(getAnnotationMirror(moduleElement, moduleKind.annotation()).get());
+ Visibility moduleVisibility = Visibility.ofElement(moduleElement);
+ Visibility moduleEffectiveVisibility = effectiveVisibilityOfElement(moduleElement);
+ if (moduleVisibility.equals(PRIVATE)) {
+ reportBuilder.addError("Modules cannot be private.", moduleElement);
+ } else if (moduleEffectiveVisibility.equals(PRIVATE)) {
+ reportBuilder.addError("Modules cannot be enclosed in private types.", moduleElement);
+ }
+
+ switch (moduleElement.getNestingKind()) {
+ case ANONYMOUS:
+ throw new IllegalStateException("Can't apply @Module to an anonymous class");
+ case LOCAL:
+ throw new IllegalStateException("Local classes shouldn't show up in the processor");
+ case MEMBER:
+ case TOP_LEVEL:
+ if (moduleEffectiveVisibility.equals(PUBLIC)) {
+ ImmutableSet<TypeElement> invalidVisibilityIncludes =
+ getModuleIncludesWithInvalidVisibility(moduleAnnotation);
+ if (!invalidVisibilityIncludes.isEmpty()) {
+ reportBuilder.addError(
+ String.format(
+ "This module is public, but it includes non-public (or effectively non-public) "
+ + "modules (%s) that have non-static, non-abstract binding methods. Either "
+ + "reduce the visibility of this module, make the included modules "
+ + "public, or make all of the binding methods on the included modules "
+ + "abstract or static.",
+ formatListForErrorMessage(invalidVisibilityIncludes.asList())),
+ moduleElement);
+ }
+ }
+ }
+ }
+
+ private ImmutableSet<TypeElement> getModuleIncludesWithInvalidVisibility(
+ ModuleAnnotation moduleAnnotation) {
+ return moduleAnnotation.includes().stream()
+ .filter(include -> !effectiveVisibilityOfElement(include).equals(PUBLIC))
+ .filter(this::requiresModuleInstance)
+ .collect(toImmutableSet());
+ }
+
+ /**
+ * Returns {@code true} if a module instance is needed for any of the binding methods on the given
+ * {@code module}. This is the case when the module has any binding methods that are neither
+ * {@code abstract} nor {@code static}. Alternatively, if the module is a Kotlin Object then the
+ * binding methods are considered {@code static}, requiring no module instance.
+ */
+ private boolean requiresModuleInstance(TypeElement module) {
+ // Note elements.getAllMembers(module) rather than module.getEnclosedElements() here: we need to
+ // include binding methods declared in supertypes because unlike most other validations being
+ // done in this class, which assume that supertype binding methods will be validated in a
+ // separate call to the validator since the supertype itself must be a @Module, we need to look
+ // at all the binding methods in the module's type hierarchy here.
+ boolean isKotlinObject =
+ metadataUtil.isObjectClass(module) || metadataUtil.isCompanionObjectClass(module);
+ if (isKotlinObject) {
+ return false;
+ }
+ return methodsIn(elements.getAllMembers(module)).stream()
+ .filter(anyBindingMethodValidator::isBindingMethod)
+ .map(ExecutableElement::getModifiers)
+ .anyMatch(modifiers -> !modifiers.contains(ABSTRACT) && !modifiers.contains(STATIC));
+ }
+
+ private void validateNoScopeAnnotationsOnModuleElement(
+ TypeElement module, ModuleKind moduleKind, ValidationReport.Builder<TypeElement> report) {
+ for (AnnotationMirror scope : getAnnotatedAnnotations(module, Scope.class)) {
+ report.addError(
+ String.format(
+ "@%ss cannot be scoped. Did you mean to scope a method instead?",
+ moduleKind.annotation().getSimpleName()),
+ module,
+ scope);
+ }
+ }
+
+ private void validateSelfCycles(
+ TypeElement module, ValidationReport.Builder<TypeElement> builder) {
+ ModuleAnnotation moduleAnnotation = moduleAnnotation(module).get();
+ moduleAnnotation
+ .includesAsAnnotationValues()
+ .forEach(
+ value ->
+ value.accept(
+ new SimpleAnnotationValueVisitor8<Void, Void>() {
+ @Override
+ public Void visitType(TypeMirror includedModule, Void aVoid) {
+ if (MoreTypes.equivalence().equivalent(module.asType(), includedModule)) {
+ String moduleKind = moduleAnnotation.annotationName();
+ builder.addError(
+ String.format("@%s cannot include themselves.", moduleKind),
+ module,
+ moduleAnnotation.annotation(),
+ value);
+ }
+ return null;
+ }
+ },
+ null));
+ }
+
+ private void validateCompanionModule(
+ TypeElement module, ValidationReport.Builder<TypeElement> builder) {
+ checkArgument(metadataUtil.hasEnclosedCompanionObject(module));
+ TypeElement companionModule = metadataUtil.getEnclosedCompanionObject(module);
+ List<ExecutableElement> companionModuleMethods =
+ methodsIn(companionModule.getEnclosedElements());
+ List<ExecutableElement> companionBindingMethods = new ArrayList<>();
+ for (ExecutableElement companionModuleMethod : companionModuleMethods) {
+ if (anyBindingMethodValidator.isBindingMethod(companionModuleMethod)) {
+ builder.addSubreport(anyBindingMethodValidator.validate(companionModuleMethod));
+ companionBindingMethods.add(companionModuleMethod);
+ }
+
+ // On normal modules only overriding other binding methods is disallowed, but for companion
+ // objects we are prohibiting any override. For this can rely on checking the @Override
+ // annotation since the Kotlin compiler will always produce them for overriding methods.
+ if (isAnnotationPresent(companionModuleMethod, Override.class)) {
+ builder.addError(
+ "Binding method in companion object may not override another method.",
+ companionModuleMethod);
+ }
+
+ // TODO(danysantiago): Be strict about the usage of @JvmStatic, i.e. tell user to remove it.
+ }
+
+ ImmutableListMultimap<Name, ExecutableElement> bindingMethodsByName =
+ Multimaps.index(companionBindingMethods, ExecutableElement::getSimpleName);
+ validateMethodsWithSameName(builder, bindingMethodsByName);
+
+ // If there are provision methods, then check the visibility. Companion objects are composed by
+ // an inner class and a static field, it is not enough to check the visibility on the type
+ // element or the field, therefore we check the metadata.
+ if (!companionBindingMethods.isEmpty() && metadataUtil.isVisibilityPrivate(companionModule)) {
+ builder.addError(
+ "A Companion Module with binding methods cannot be private.", companionModule);
+ }
+ }
+
+ private void validateModuleBindings(
+ TypeElement module, ValidationReport.Builder<TypeElement> report) {
+ BindingGraph bindingGraph =
+ bindingGraphFactory.create(
+ componentDescriptorFactory.moduleComponentDescriptor(module), true)
+ .topLevelBindingGraph();
+ if (!bindingGraphValidator.isValid(bindingGraph)) {
+ // Since the validator uses a DiagnosticReporter to report errors, the ValdiationReport won't
+ // have any Items for them. We have to tell the ValidationReport that some errors were
+ // reported for the subject.
+ report.markDirty();
+ }
+ }
+
+ private static String formatListForErrorMessage(List<?> things) {
+ switch (things.size()) {
+ case 0:
+ return "";
+ case 1:
+ return things.get(0).toString();
+ default:
+ StringBuilder output = new StringBuilder();
+ Joiner.on(", ").appendTo(output, things.subList(0, things.size() - 1));
+ output.append(" and ").append(things.get(things.size() - 1));
+ return output.toString();
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/MonitoringModuleGenerator.java b/java/dagger/internal/codegen/validation/MonitoringModuleGenerator.java
new file mode 100644
index 0000000..2c72e5f
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/MonitoringModuleGenerator.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static com.squareup.javapoet.MethodSpec.constructorBuilder;
+import static com.squareup.javapoet.MethodSpec.methodBuilder;
+import static com.squareup.javapoet.TypeSpec.classBuilder;
+import static dagger.internal.codegen.javapoet.TypeNames.PRODUCTION_COMPONENT_MONITOR_FACTORY;
+import static dagger.internal.codegen.javapoet.TypeNames.providerOf;
+import static dagger.internal.codegen.javapoet.TypeNames.setOf;
+import static javax.lang.model.element.Modifier.ABSTRACT;
+import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.STATIC;
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.TypeSpec;
+import dagger.Module;
+import dagger.Provides;
+import dagger.internal.codegen.base.SourceFileGenerator;
+import dagger.internal.codegen.binding.SourceFiles;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.multibindings.Multibinds;
+import dagger.producers.ProductionScope;
+import dagger.producers.monitoring.ProductionComponentMonitor;
+import dagger.producers.monitoring.internal.Monitors;
+import java.util.Optional;
+import javax.annotation.processing.Filer;
+import javax.inject.Inject;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+
+/** Generates a monitoring module for use with production components. */
+final class MonitoringModuleGenerator extends SourceFileGenerator<TypeElement> {
+
+ @Inject
+ MonitoringModuleGenerator(Filer filer, DaggerElements elements, SourceVersion sourceVersion) {
+ super(filer, elements, sourceVersion);
+ }
+
+ @Override
+ public ClassName nameGeneratedType(TypeElement componentElement) {
+ return SourceFiles.generatedMonitoringModuleName(componentElement);
+ }
+
+ @Override
+ public Element originatingElement(TypeElement componentElement) {
+ return componentElement;
+ }
+
+ @Override
+ public Optional<TypeSpec.Builder> write(TypeElement componentElement) {
+ return Optional.of(
+ classBuilder(nameGeneratedType(componentElement))
+ .addAnnotation(Module.class)
+ .addModifiers(ABSTRACT)
+ .addMethod(privateConstructor())
+ .addMethod(setOfFactories())
+ .addMethod(monitor(componentElement)));
+ }
+
+ private MethodSpec privateConstructor() {
+ return constructorBuilder().addModifiers(PRIVATE).build();
+ }
+
+ private MethodSpec setOfFactories() {
+ return methodBuilder("setOfFactories")
+ .addAnnotation(Multibinds.class)
+ .addModifiers(ABSTRACT)
+ .returns(setOf(PRODUCTION_COMPONENT_MONITOR_FACTORY))
+ .build();
+ }
+
+ private MethodSpec monitor(TypeElement componentElement) {
+ return methodBuilder("monitor")
+ .returns(ProductionComponentMonitor.class)
+ .addModifiers(STATIC)
+ .addAnnotation(Provides.class)
+ .addAnnotation(ProductionScope.class)
+ .addParameter(providerOf(ClassName.get(componentElement.asType())), "component")
+ .addParameter(
+ providerOf(setOf(PRODUCTION_COMPONENT_MONITOR_FACTORY)), "factories")
+ .addStatement(
+ "return $T.createMonitorForComponent(component, factories)", Monitors.class)
+ .build();
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/MonitoringModuleProcessingStep.java b/java/dagger/internal/codegen/validation/MonitoringModuleProcessingStep.java
new file mode 100644
index 0000000..5d4c64e
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/MonitoringModuleProcessingStep.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import com.google.auto.common.MoreElements;
+import com.google.common.collect.ImmutableSet;
+import dagger.producers.ProductionComponent;
+import dagger.producers.ProductionSubcomponent;
+import java.lang.annotation.Annotation;
+import java.util.Set;
+import javax.annotation.processing.Messager;
+import javax.inject.Inject;
+import javax.lang.model.element.TypeElement;
+
+/**
+ * A processing step that is responsible for generating a special module for a {@link
+ * ProductionComponent} or {@link ProductionSubcomponent}.
+ */
+public final class MonitoringModuleProcessingStep extends TypeCheckingProcessingStep<TypeElement> {
+ private final Messager messager;
+ private final MonitoringModuleGenerator monitoringModuleGenerator;
+
+ @Inject
+ MonitoringModuleProcessingStep(
+ Messager messager, MonitoringModuleGenerator monitoringModuleGenerator) {
+ super(MoreElements::asType);
+ this.messager = messager;
+ this.monitoringModuleGenerator = monitoringModuleGenerator;
+ }
+
+ @Override
+ public Set<? extends Class<? extends Annotation>> annotations() {
+ return ImmutableSet.of(ProductionComponent.class, ProductionSubcomponent.class);
+ }
+
+ @Override
+ protected void process(
+ TypeElement element, ImmutableSet<Class<? extends Annotation>> annotations) {
+ monitoringModuleGenerator.generate(MoreElements.asType(element), messager);
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/MultibindingAnnotationsProcessingStep.java b/java/dagger/internal/codegen/validation/MultibindingAnnotationsProcessingStep.java
new file mode 100644
index 0000000..fd75eac
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/MultibindingAnnotationsProcessingStep.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static dagger.internal.codegen.langmodel.DaggerElements.getAnnotationMirror;
+import static javax.tools.Diagnostic.Kind.ERROR;
+
+import com.google.auto.common.MoreElements;
+import com.google.common.collect.ImmutableSet;
+import dagger.multibindings.ElementsIntoSet;
+import dagger.multibindings.IntoMap;
+import dagger.multibindings.IntoSet;
+import java.lang.annotation.Annotation;
+import java.util.Set;
+import javax.annotation.processing.Messager;
+import javax.inject.Inject;
+import javax.lang.model.element.ExecutableElement;
+
+/**
+ * Processing step that verifies that {@link IntoSet}, {@link ElementsIntoSet} and {@link IntoMap}
+ * are not present on non-binding methods.
+ */
+public final class MultibindingAnnotationsProcessingStep
+ extends TypeCheckingProcessingStep<ExecutableElement> {
+ private final AnyBindingMethodValidator anyBindingMethodValidator;
+ private final Messager messager;
+
+ @Inject
+ MultibindingAnnotationsProcessingStep(
+ AnyBindingMethodValidator anyBindingMethodValidator, Messager messager) {
+ super(MoreElements::asExecutable);
+ this.anyBindingMethodValidator = anyBindingMethodValidator;
+ this.messager = messager;
+ }
+
+ @Override
+ public Set<? extends Class<? extends Annotation>> annotations() {
+ return ImmutableSet.of(IntoSet.class, ElementsIntoSet.class, IntoMap.class);
+ }
+
+ @Override
+ protected void process(
+ ExecutableElement method, ImmutableSet<Class<? extends Annotation>> annotations) {
+ if (!anyBindingMethodValidator.isBindingMethod(method)) {
+ annotations.forEach(
+ annotation ->
+ messager.printMessage(
+ ERROR,
+ "Multibinding annotations may only be on @Provides, @Produces, or @Binds methods",
+ method,
+ getAnnotationMirror(method, annotation).get()));
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/MultibindsMethodValidator.java b/java/dagger/internal/codegen/validation/MultibindsMethodValidator.java
new file mode 100644
index 0000000..8829667
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/MultibindsMethodValidator.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static dagger.internal.codegen.base.FrameworkTypes.isFrameworkType;
+import static dagger.internal.codegen.validation.BindingElementValidator.AllowsMultibindings.NO_MULTIBINDINGS;
+import static dagger.internal.codegen.validation.BindingElementValidator.AllowsScoping.NO_SCOPING;
+import static dagger.internal.codegen.validation.BindingMethodValidator.Abstractness.MUST_BE_ABSTRACT;
+import static dagger.internal.codegen.validation.BindingMethodValidator.ExceptionSuperclass.NO_EXCEPTIONS;
+
+import com.google.auto.common.MoreTypes;
+import com.google.common.collect.ImmutableSet;
+import dagger.Module;
+import dagger.internal.codegen.base.MapType;
+import dagger.internal.codegen.base.SetType;
+import dagger.internal.codegen.binding.InjectionAnnotations;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.multibindings.Multibinds;
+import dagger.producers.ProducerModule;
+import javax.inject.Inject;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.type.TypeMirror;
+
+/** A validator for {@link Multibinds} methods. */
+class MultibindsMethodValidator extends BindingMethodValidator {
+
+ /** Creates a validator for {@link Multibinds @Multibinds} methods. */
+ @Inject
+ MultibindsMethodValidator(
+ DaggerElements elements,
+ DaggerTypes types,
+ KotlinMetadataUtil kotlinMetadataUtil,
+ DependencyRequestValidator dependencyRequestValidator,
+ InjectionAnnotations injectionAnnotations) {
+ super(
+ elements,
+ types,
+ kotlinMetadataUtil,
+ Multibinds.class,
+ ImmutableSet.of(Module.class, ProducerModule.class),
+ dependencyRequestValidator,
+ MUST_BE_ABSTRACT,
+ NO_EXCEPTIONS,
+ NO_MULTIBINDINGS,
+ NO_SCOPING,
+ injectionAnnotations);
+ }
+
+ @Override
+ protected ElementValidator elementValidator(ExecutableElement element) {
+ return new Validator(element);
+ }
+
+ private class Validator extends MethodValidator {
+ Validator(ExecutableElement element) {
+ super(element);
+ }
+
+ @Override
+ protected void checkParameters() {
+ if (!element.getParameters().isEmpty()) {
+ report.addError(bindingMethods("cannot have parameters"));
+ }
+ }
+
+ /** Adds an error unless the method returns a {@code Map<K, V>} or {@code Set<T>}. */
+ @Override
+ protected void checkType() {
+ if (!isPlainMap(element.getReturnType())
+ && !isPlainSet(element.getReturnType())) {
+ report.addError(bindingMethods("must return Map<K, V> or Set<T>"));
+ }
+ }
+
+ private boolean isPlainMap(TypeMirror returnType) {
+ if (!MapType.isMap(returnType)) {
+ return false;
+ }
+ MapType mapType = MapType.from(returnType);
+ return !mapType.isRawType()
+ && MoreTypes.isType(mapType.valueType()) // No wildcards.
+ && !isFrameworkType(mapType.valueType());
+ }
+
+ private boolean isPlainSet(TypeMirror returnType) {
+ if (!SetType.isSet(returnType)) {
+ return false;
+ }
+ SetType setType = SetType.from(returnType);
+ return !setType.isRawType()
+ && MoreTypes.isType(setType.elementType()) // No wildcards.
+ && !isFrameworkType(setType.elementType());
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/PackageNameCompressor.java b/java/dagger/internal/codegen/validation/PackageNameCompressor.java
new file mode 100644
index 0000000..6b7c720
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/PackageNameCompressor.java
@@ -0,0 +1,181 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static java.util.Comparator.comparing;
+
+import com.google.common.base.Joiner;
+import com.google.common.base.Splitter;
+import com.google.common.base.Strings;
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Munges an error message to remove/shorten package names and adds a legend at the end.
+ */
+final class PackageNameCompressor {
+
+ static final String LEGEND_HEADER =
+ "\n\n======================\nFull classname legend:\n======================\n";
+ static final String LEGEND_FOOTER =
+ "========================\nEnd of classname legend:\n========================\n";
+
+ private static final ImmutableSet<String> PACKAGES_SKIPPED_IN_LEGEND = ImmutableSet.of(
+ "java.lang.",
+ "java.util.");
+
+ private static final Splitter PACKAGE_SPLITTER = Splitter.on('.');
+
+ private static final Joiner PACKAGE_JOINER = Joiner.on('.');
+
+ // TODO(erichang): Consider validating this regex by also passing in all of the known types from
+ // keys, module names, component names, etc and checking against that list. This may have some
+ // extra complications with taking apart types like List<Foo> to get the inner class names.
+ private static final Pattern CLASSNAME_PATTERN =
+ // Match lowercase package names with trailing dots. Start with a non-word character so we
+ // don't match substrings in like Bar.Foo and match the ar.Foo. Start a group to not include
+ // the non-word character.
+ Pattern.compile("[\\W](([a-z_0-9]++[.])++"
+ // Then match a name starting with an uppercase letter. This is the outer class name.
+ + "[A-Z][\\w$]++)");
+
+ /**
+ * Compresses an error message by stripping the packages out of class names and adding them
+ * to a legend at the bottom of the error.
+ */
+ static String compressPackagesInMessage(String input) {
+ Matcher matcher = CLASSNAME_PATTERN.matcher(input);
+
+ Set<String> names = new HashSet<>();
+ // Find all classnames in the error. Note that if our regex isn't complete, it just means the
+ // classname is left in the full form, which is a fine fallback.
+ while (matcher.find()) {
+ String name = matcher.group(1);
+ names.add(name);
+ }
+ // Now dedupe any conflicts. Use a TreeMap since we're going to need the legend sorted anyway.
+ // This map is from short name to full name.
+ Map<String, String> replacementMap = shortenNames(names);
+
+ // If we have nothing to replace, just return the original.
+ if (replacementMap.isEmpty()) {
+ return input;
+ }
+
+ // Find the longest key for building the legend
+ int longestKey = replacementMap.keySet().stream().max(comparing(String::length)).get().length();
+
+ String replacedString = input;
+ StringBuilder legendBuilder = new StringBuilder();
+ for (Map.Entry<String, String> entry : replacementMap.entrySet()) {
+ String shortName = entry.getKey();
+ String fullName = entry.getValue();
+ // Do the replacements in the message
+ replacedString = replacedString.replace(fullName, shortName);
+
+ // Skip certain prefixes. We need to check the shortName for a . though in case
+ // there was some type of conflict like java.util.concurrent.Future and
+ // java.util.foo.Future that got shortened to concurrent.Future and foo.Future.
+ // In those cases we do not want to skip the legend. We only skip if the class
+ // is directly in that package.
+ String prefix = fullName.substring(0, fullName.length() - shortName.length());
+ if (PACKAGES_SKIPPED_IN_LEGEND.contains(prefix) && !shortName.contains(".")) {
+ continue;
+ }
+
+ // Add to the legend
+ legendBuilder
+ .append(shortName)
+ .append(": ")
+ // Add enough spaces to adjust the columns
+ .append(Strings.repeat(" ", longestKey - shortName.length()))
+ .append(fullName)
+ .append("\n");
+ }
+
+ return legendBuilder.length() == 0 ? replacedString
+ : replacedString + LEGEND_HEADER + legendBuilder + LEGEND_FOOTER;
+ }
+
+ /**
+ * Returns a map from short name to full name after resolving conflicts. This resolves conflicts
+ * by adding on segments of the package name until they are unique. For example, com.foo.Baz and
+ * com.bar.Baz will conflict on Baz and then resolve with foo.Baz and bar.Baz as replacements.
+ */
+ private static Map<String, String> shortenNames(Collection<String> names) {
+ HashMultimap<String, List<String>> shortNameToPartsMap = HashMultimap.create();
+ for (String name : names) {
+ List<String> parts = new ArrayList<>(PACKAGE_SPLITTER.splitToList(name));
+ // Start with the just the class name as the simple name
+ String className = parts.remove(parts.size() - 1);
+ shortNameToPartsMap.put(className, parts);
+ }
+
+ // Iterate through looking for conflicts adding the next part of the package until there are no
+ // more conflicts
+ while (true) {
+ // Save the keys with conflicts to avoid concurrent modification issues
+ List<String> conflictingShortNames = new ArrayList<>();
+ for (Map.Entry<String, Collection<List<String>>> entry
+ : shortNameToPartsMap.asMap().entrySet()) {
+ if (entry.getValue().size() > 1) {
+ conflictingShortNames.add(entry.getKey());
+ }
+ }
+
+ if (conflictingShortNames.isEmpty()) {
+ break;
+ }
+
+ // For all conflicts, add in the next part of the package
+ for (String conflictingShortName : conflictingShortNames) {
+ Set<List<String>> partsCollection = shortNameToPartsMap.removeAll(conflictingShortName);
+ for (List<String> parts : partsCollection) {
+ String newShortName = parts.remove(parts.size() - 1) + "." + conflictingShortName;
+ // If we've removed the last part of the package, then just skip it entirely because
+ // now we're not shortening it at all.
+ if (!parts.isEmpty()) {
+ shortNameToPartsMap.put(newShortName, parts);
+ }
+ }
+ }
+ }
+
+ // Turn the multimap into a regular map now that conflicts have been resolved. Use a TreeMap
+ // since we're going to need the legend sorted anyway. This map is from short name to full name.
+ Map<String, String> replacementMap = new TreeMap<>();
+ for (Map.Entry<String, Collection<List<String>>> entry
+ : shortNameToPartsMap.asMap().entrySet()) {
+ replacementMap.put(
+ entry.getKey(),
+ PACKAGE_JOINER.join(Iterables.getOnlyElement(entry.getValue())) + "." + entry.getKey());
+ }
+ return replacementMap;
+ }
+
+ private PackageNameCompressor() {}
+}
diff --git a/java/dagger/internal/codegen/validation/ProducesMethodValidator.java b/java/dagger/internal/codegen/validation/ProducesMethodValidator.java
new file mode 100644
index 0000000..1606ebe
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/ProducesMethodValidator.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static dagger.internal.codegen.validation.BindingElementValidator.AllowsMultibindings.ALLOWS_MULTIBINDINGS;
+import static dagger.internal.codegen.validation.BindingElementValidator.AllowsScoping.NO_SCOPING;
+import static dagger.internal.codegen.validation.BindingMethodValidator.Abstractness.MUST_BE_CONCRETE;
+import static dagger.internal.codegen.validation.BindingMethodValidator.ExceptionSuperclass.EXCEPTION;
+
+import com.google.auto.common.MoreTypes;
+import com.google.common.util.concurrent.ListenableFuture;
+import dagger.internal.codegen.binding.ConfigurationAnnotations;
+import dagger.internal.codegen.binding.InjectionAnnotations;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.multibindings.ElementsIntoSet;
+import dagger.producers.ProducerModule;
+import dagger.producers.Produces;
+import java.util.Optional;
+import java.util.Set;
+import javax.inject.Inject;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeMirror;
+
+/** A validator for {@link Produces} methods. */
+final class ProducesMethodValidator extends BindingMethodValidator {
+
+ @Inject
+ ProducesMethodValidator(
+ DaggerElements elements,
+ DaggerTypes types,
+ KotlinMetadataUtil kotlinMetadataUtil,
+ DependencyRequestValidator dependencyRequestValidator,
+ InjectionAnnotations injectionAnnotations) {
+ super(
+ elements,
+ types,
+ kotlinMetadataUtil,
+ dependencyRequestValidator,
+ Produces.class,
+ ProducerModule.class,
+ MUST_BE_CONCRETE,
+ EXCEPTION,
+ ALLOWS_MULTIBINDINGS,
+ NO_SCOPING,
+ injectionAnnotations);
+ }
+
+ @Override
+ protected String elementsIntoSetNotASetMessage() {
+ return "@Produces methods of type set values must return a Set or ListenableFuture of Set";
+ }
+
+ @Override
+ protected String badTypeMessage() {
+ return "@Produces methods can return only a primitive, an array, a type variable, "
+ + "a declared type, or a ListenableFuture of one of those types";
+ }
+
+ @Override
+ protected ElementValidator elementValidator(ExecutableElement element) {
+ return new Validator(element);
+ }
+
+ private class Validator extends MethodValidator {
+ Validator(ExecutableElement element) {
+ super(element);
+ }
+
+ @Override
+ protected void checkAdditionalMethodProperties() {
+ checkNullable();
+ }
+
+ /** Adds a warning if a {@link Produces @Produces} method is declared nullable. */
+ // TODO(beder): Properly handle nullable with producer methods.
+ private void checkNullable() {
+ if (ConfigurationAnnotations.getNullableType(element).isPresent()) {
+ report.addWarning("@Nullable on @Produces methods does not do anything");
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * <p>Allows {@code keyType} to be a {@link ListenableFuture} of an otherwise-valid key type.
+ */
+ @Override
+ protected void checkKeyType(TypeMirror keyType) {
+ Optional<TypeMirror> typeToCheck = unwrapListenableFuture(keyType);
+ if (typeToCheck.isPresent()) {
+ super.checkKeyType(typeToCheck.get());
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * <p>Allows an {@link ElementsIntoSet @ElementsIntoSet} or {@code SET_VALUES} method to return
+ * a {@link ListenableFuture} of a {@link Set} as well.
+ */
+ @Override
+ protected void checkSetValuesType() {
+ Optional<TypeMirror> typeToCheck = unwrapListenableFuture(element.getReturnType());
+ if (typeToCheck.isPresent()) {
+ checkSetValuesType(typeToCheck.get());
+ }
+ }
+
+ private Optional<TypeMirror> unwrapListenableFuture(TypeMirror type) {
+ if (MoreTypes.isType(type) && MoreTypes.isTypeOf(ListenableFuture.class, type)) {
+ DeclaredType declaredType = MoreTypes.asDeclared(type);
+ if (declaredType.getTypeArguments().isEmpty()) {
+ report.addError("@Produces methods cannot return a raw ListenableFuture");
+ return Optional.empty();
+ } else {
+ return Optional.of((TypeMirror) getOnlyElement(declaredType.getTypeArguments()));
+ }
+ }
+ return Optional.of(type);
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/ProvidesMethodValidator.java b/java/dagger/internal/codegen/validation/ProvidesMethodValidator.java
new file mode 100644
index 0000000..6b4f303
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/ProvidesMethodValidator.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static dagger.internal.codegen.validation.BindingElementValidator.AllowsMultibindings.ALLOWS_MULTIBINDINGS;
+import static dagger.internal.codegen.validation.BindingElementValidator.AllowsScoping.ALLOWS_SCOPING;
+import static dagger.internal.codegen.validation.BindingMethodValidator.Abstractness.MUST_BE_CONCRETE;
+import static dagger.internal.codegen.validation.BindingMethodValidator.ExceptionSuperclass.RUNTIME_EXCEPTION;
+
+import com.google.common.collect.ImmutableSet;
+import dagger.Module;
+import dagger.Provides;
+import dagger.internal.codegen.binding.InjectionAnnotations;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.producers.ProducerModule;
+import javax.inject.Inject;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.VariableElement;
+
+/** A validator for {@link Provides} methods. */
+final class ProvidesMethodValidator extends BindingMethodValidator {
+
+ private final DependencyRequestValidator dependencyRequestValidator;
+
+ @Inject
+ ProvidesMethodValidator(
+ DaggerElements elements,
+ DaggerTypes types,
+ KotlinMetadataUtil kotlinMetadataUtil,
+ DependencyRequestValidator dependencyRequestValidator,
+ InjectionAnnotations injectionAnnotations) {
+ super(
+ elements,
+ types,
+ kotlinMetadataUtil,
+ Provides.class,
+ ImmutableSet.of(Module.class, ProducerModule.class),
+ dependencyRequestValidator,
+ MUST_BE_CONCRETE,
+ RUNTIME_EXCEPTION,
+ ALLOWS_MULTIBINDINGS,
+ ALLOWS_SCOPING,
+ injectionAnnotations);
+ this.dependencyRequestValidator = dependencyRequestValidator;
+ }
+
+ @Override
+ protected ElementValidator elementValidator(ExecutableElement element) {
+ return new Validator(element);
+ }
+
+ private class Validator extends MethodValidator {
+ Validator(ExecutableElement element) {
+ super(element);
+ }
+
+ @Override
+ protected void checkAdditionalMethodProperties() {
+ }
+
+ /** Adds an error if a {@link Provides @Provides} method depends on a producer type. */
+ @Override
+ protected void checkParameter(VariableElement parameter) {
+ super.checkParameter(parameter);
+ dependencyRequestValidator.checkNotProducer(report, parameter);
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/TypeCheckingProcessingStep.java b/java/dagger/internal/codegen/validation/TypeCheckingProcessingStep.java
new file mode 100644
index 0000000..57867f1
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/TypeCheckingProcessingStep.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.auto.common.BasicAnnotationProcessor.ProcessingStep;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSetMultimap;
+import com.google.common.collect.SetMultimap;
+import java.lang.annotation.Annotation;
+import java.util.function.Function;
+import javax.lang.model.element.Element;
+
+/**
+ * A {@link ProcessingStep} that processes one element at a time and defers any for which {@link
+ * TypeNotPresentException} is thrown.
+ */
+// TODO(dpb): Contribute to auto-common.
+public abstract class TypeCheckingProcessingStep<E extends Element> implements ProcessingStep {
+ private final Function<Element, E> downcaster;
+
+ protected TypeCheckingProcessingStep(Function<Element, E> downcaster) {
+ this.downcaster = checkNotNull(downcaster);
+ }
+
+ @Override
+ public ImmutableSet<Element> process(
+ SetMultimap<Class<? extends Annotation>, Element> elementsByAnnotation) {
+ ImmutableSet.Builder<Element> deferredElements = ImmutableSet.builder();
+ ImmutableSetMultimap.copyOf(elementsByAnnotation)
+ .inverse()
+ .asMap()
+ .forEach(
+ (element, annotations) -> {
+ try {
+ process(downcaster.apply(element), ImmutableSet.copyOf(annotations));
+ } catch (TypeNotPresentException e) {
+ deferredElements.add(element);
+ }
+ });
+ return deferredElements.build();
+ }
+
+ /**
+ * Processes one element. If this method throws {@link TypeNotPresentException}, the element will
+ * be deferred until the next round of processing.
+ *
+ * @param annotations the subset of {@link ProcessingStep#annotations()} that annotate {@code
+ * element}
+ */
+ protected abstract void process(E element, ImmutableSet<Class<? extends Annotation>> annotations);
+}
diff --git a/java/dagger/internal/codegen/validation/TypeHierarchyValidator.java b/java/dagger/internal/codegen/validation/TypeHierarchyValidator.java
new file mode 100644
index 0000000..5fa0270
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/TypeHierarchyValidator.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import com.google.auto.common.MoreTypes;
+import com.google.auto.common.SuperficialValidation;
+import com.google.common.base.Equivalence;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import java.util.ArrayDeque;
+import java.util.HashSet;
+import java.util.Queue;
+import java.util.Set;
+import javax.lang.model.type.TypeMirror;
+
+/** Utility methods for validating the type hierarchy of a given type. */
+final class TypeHierarchyValidator {
+ private TypeHierarchyValidator() {}
+
+ /**
+ * Validate the type hierarchy of the given type including all super classes, interfaces, and
+ * type parameters.
+ *
+ * @throws TypeNotPresentException if an type in the hierarchy is not valid.
+ */
+ public static void validateTypeHierarchy(TypeMirror type, DaggerTypes types) {
+ Queue<TypeMirror> queue = new ArrayDeque<>();
+ Set<Equivalence.Wrapper<TypeMirror>> queued = new HashSet<>();
+ queue.add(type);
+ queued.add(MoreTypes.equivalence().wrap(type));
+ while (!queue.isEmpty()) {
+ TypeMirror currType = queue.remove();
+ if (!SuperficialValidation.validateType(currType)) {
+ throw new TypeNotPresentException(currType.toString(), null);
+ }
+ for (TypeMirror superType : types.directSupertypes(currType)) {
+ if (queued.add(MoreTypes.equivalence().wrap(superType))) {
+ queue.add(superType);
+ }
+ }
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/validation/Validation.java b/java/dagger/internal/codegen/validation/Validation.java
new file mode 100644
index 0000000..620b0f0
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/Validation.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import javax.inject.Qualifier;
+
+/**
+ * Qualifier annotation for the {@link dagger.spi.BindingGraphPlugin}s that are used to implement
+ * core Dagger validation.
+ */
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Qualifier
+public @interface Validation {}
diff --git a/java/dagger/internal/codegen/validation/ValidationReport.java b/java/dagger/internal/codegen/validation/ValidationReport.java
new file mode 100644
index 0000000..7f37375
--- /dev/null
+++ b/java/dagger/internal/codegen/validation/ValidationReport.java
@@ -0,0 +1,285 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.validation;
+
+import static dagger.internal.codegen.base.ElementFormatter.elementToString;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static javax.tools.Diagnostic.Kind.ERROR;
+import static javax.tools.Diagnostic.Kind.NOTE;
+import static javax.tools.Diagnostic.Kind.WARNING;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.graph.Traverser;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.errorprone.annotations.CheckReturnValue;
+import java.util.Optional;
+import javax.annotation.processing.Messager;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
+import javax.lang.model.element.Element;
+import javax.tools.Diagnostic;
+import javax.tools.Diagnostic.Kind;
+
+/** A collection of issues to report for source code. */
+public final class ValidationReport<T extends Element> {
+ private static final Traverser<ValidationReport<?>> SUBREPORTS =
+ Traverser.forTree(report -> report.subreports);
+
+ private final T subject;
+ private final ImmutableSet<Item> items;
+ private final ImmutableSet<ValidationReport<?>> subreports;
+ private final boolean markedDirty;
+ private boolean hasPrintedErrors;
+
+ private ValidationReport(
+ T subject,
+ ImmutableSet<Item> items,
+ ImmutableSet<ValidationReport<?>> subreports,
+ boolean markedDirty) {
+ this.subject = subject;
+ this.items = items;
+ this.subreports = subreports;
+ this.markedDirty = markedDirty;
+ }
+
+ /** Returns the items from this report and all transitive subreports. */
+ public ImmutableSet<Item> allItems() {
+ return ImmutableSet.copyOf(SUBREPORTS.depthFirstPreOrder(this))
+ .stream()
+ .flatMap(report -> report.items.stream())
+ .collect(toImmutableSet());
+ }
+
+ /**
+ * Returns {@code true} if there are no errors in this report or any subreports and markedDirty is
+ * {@code false}.
+ */
+ public boolean isClean() {
+ if (markedDirty) {
+ return false;
+ }
+ for (Item item : items) {
+ switch (item.kind()) {
+ case ERROR:
+ return false;
+ default:
+ break;
+ }
+ }
+ for (ValidationReport<?> subreport : subreports) {
+ if (!subreport.isClean()) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Prints all messages to {@code messager} (and recurs for subreports). If a
+ * message's {@linkplain Item#element() element} is contained within the report's subject,
+ * associates the message with the message's element. Otherwise, since {@link Diagnostic}
+ * reporting is expected to be associated with elements that are currently being compiled,
+ * associates the message with the subject itself and prepends a reference to the item's element.
+ */
+ public void printMessagesTo(Messager messager) {
+ if (hasPrintedErrors) {
+ // Avoid printing the errors from this validation report more than once.
+ return;
+ }
+ hasPrintedErrors = true;
+ for (Item item : items) {
+ if (isEnclosedIn(subject, item.element())) {
+ if (item.annotation().isPresent()) {
+ if (item.annotationValue().isPresent()) {
+ messager.printMessage(
+ item.kind(),
+ item.message(),
+ item.element(),
+ item.annotation().get(),
+ item.annotationValue().get());
+ } else {
+ messager.printMessage(
+ item.kind(), item.message(), item.element(), item.annotation().get());
+ }
+ } else {
+ messager.printMessage(item.kind(), item.message(), item.element());
+ }
+ } else {
+ String message = String.format("[%s] %s", elementToString(item.element()), item.message());
+ messager.printMessage(item.kind(), message, subject);
+ }
+ }
+ for (ValidationReport<?> subreport : subreports) {
+ subreport.printMessagesTo(messager);
+ }
+ }
+
+ private static boolean isEnclosedIn(Element parent, Element child) {
+ Element current = child;
+ while (current != null) {
+ if (current.equals(parent)) {
+ return true;
+ }
+ current = current.getEnclosingElement();
+ }
+ return false;
+ }
+
+ /** Metadata about a {@link ValidationReport} item. */
+ @AutoValue
+ public abstract static class Item {
+ public abstract String message();
+ public abstract Kind kind();
+ public abstract Element element();
+ public abstract Optional<AnnotationMirror> annotation();
+ abstract Optional<AnnotationValue> annotationValue();
+ }
+
+ public static <T extends Element> Builder<T> about(T subject) {
+ return new Builder<>(subject);
+ }
+
+ /** A {@link ValidationReport} builder. */
+ @CanIgnoreReturnValue
+ public static final class Builder<T extends Element> {
+ private final T subject;
+ private final ImmutableSet.Builder<Item> items = ImmutableSet.builder();
+ private final ImmutableSet.Builder<ValidationReport<?>> subreports = ImmutableSet.builder();
+ private boolean markedDirty;
+
+ private Builder(T subject) {
+ this.subject = subject;
+ }
+
+ @CheckReturnValue
+ T getSubject() {
+ return subject;
+ }
+
+ Builder<T> addItems(Iterable<Item> newItems) {
+ items.addAll(newItems);
+ return this;
+ }
+
+ public Builder<T> addError(String message) {
+ return addError(message, subject);
+ }
+
+ public Builder<T> addError(String message, Element element) {
+ return addItem(message, ERROR, element);
+ }
+
+ public Builder<T> addError(String message, Element element, AnnotationMirror annotation) {
+ return addItem(message, ERROR, element, annotation);
+ }
+
+ public Builder<T> addError(
+ String message,
+ Element element,
+ AnnotationMirror annotation,
+ AnnotationValue annotationValue) {
+ return addItem(message, ERROR, element, annotation, annotationValue);
+ }
+
+ Builder<T> addWarning(String message) {
+ return addWarning(message, subject);
+ }
+
+ Builder<T> addWarning(String message, Element element) {
+ return addItem(message, WARNING, element);
+ }
+
+ Builder<T> addWarning(String message, Element element, AnnotationMirror annotation) {
+ return addItem(message, WARNING, element, annotation);
+ }
+
+ Builder<T> addWarning(
+ String message,
+ Element element,
+ AnnotationMirror annotation,
+ AnnotationValue annotationValue) {
+ return addItem(message, WARNING, element, annotation, annotationValue);
+ }
+
+ Builder<T> addNote(String message) {
+ return addNote(message, subject);
+ }
+
+ Builder<T> addNote(String message, Element element) {
+ return addItem(message, NOTE, element);
+ }
+
+ Builder<T> addNote(String message, Element element, AnnotationMirror annotation) {
+ return addItem(message, NOTE, element, annotation);
+ }
+
+ Builder<T> addNote(
+ String message,
+ Element element,
+ AnnotationMirror annotation,
+ AnnotationValue annotationValue) {
+ return addItem(message, NOTE, element, annotation, annotationValue);
+ }
+
+ Builder<T> addItem(String message, Kind kind, Element element) {
+ return addItem(message, kind, element, Optional.empty(), Optional.empty());
+ }
+
+ Builder<T> addItem(String message, Kind kind, Element element, AnnotationMirror annotation) {
+ return addItem(message, kind, element, Optional.of(annotation), Optional.empty());
+ }
+
+ Builder<T> addItem(
+ String message,
+ Kind kind,
+ Element element,
+ AnnotationMirror annotation,
+ AnnotationValue annotationValue) {
+ return addItem(message, kind, element, Optional.of(annotation), Optional.of(annotationValue));
+ }
+
+ private Builder<T> addItem(
+ String message,
+ Kind kind,
+ Element element,
+ Optional<AnnotationMirror> annotation,
+ Optional<AnnotationValue> annotationValue) {
+ items.add(
+ new AutoValue_ValidationReport_Item(message, kind, element, annotation, annotationValue));
+ return this;
+ }
+
+ /**
+ * If called, then {@link #isClean()} will return {@code false} even if there are no error items
+ * in the report.
+ */
+ void markDirty() {
+ this.markedDirty = true;
+ }
+
+ public Builder<T> addSubreport(ValidationReport<?> subreport) {
+ subreports.add(subreport);
+ return this;
+ }
+
+ @CheckReturnValue
+ public ValidationReport<T> build() {
+ return new ValidationReport<>(subject, items.build(), subreports.build(), markedDirty);
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/AnnotationCreatorGenerator.java b/java/dagger/internal/codegen/writing/AnnotationCreatorGenerator.java
new file mode 100644
index 0000000..96e6340
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/AnnotationCreatorGenerator.java
@@ -0,0 +1,169 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.squareup.javapoet.MethodSpec.constructorBuilder;
+import static com.squareup.javapoet.MethodSpec.methodBuilder;
+import static com.squareup.javapoet.TypeSpec.classBuilder;
+import static dagger.internal.codegen.binding.AnnotationExpression.createMethodName;
+import static dagger.internal.codegen.binding.AnnotationExpression.getAnnotationCreatorClassName;
+import static dagger.internal.codegen.javapoet.CodeBlocks.makeParametersCodeBlock;
+import static javax.lang.model.element.Modifier.FINAL;
+import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.PUBLIC;
+import static javax.lang.model.element.Modifier.STATIC;
+import static javax.lang.model.util.ElementFilter.methodsIn;
+
+import com.google.auto.common.MoreTypes;
+import com.google.common.collect.ImmutableList;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.TypeName;
+import com.squareup.javapoet.TypeSpec;
+import dagger.internal.codegen.base.SourceFileGenerator;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import java.util.LinkedHashSet;
+import java.util.Optional;
+import java.util.Set;
+import javax.annotation.processing.Filer;
+import javax.inject.Inject;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.util.SimpleTypeVisitor6;
+
+/**
+ * Generates classes that create annotation instances for an annotation type. The generated class
+ * will have a private empty constructor, a static method that creates the annotation type itself,
+ * and a static method that creates each annotation type that is nested in the top-level annotation
+ * type.
+ *
+ * <p>So for an example annotation:
+ *
+ * <pre>
+ * {@literal @interface} Foo {
+ * String s();
+ * int i();
+ * Bar bar(); // an annotation defined elsewhere
+ * }
+ * </pre>
+ *
+ * the generated class will look like:
+ *
+ * <pre>
+ * public final class FooCreator {
+ * private FooCreator() {}
+ *
+ * public static Foo createFoo(String s, int i, Bar bar) { … }
+ * public static Bar createBar(…) { … }
+ * }
+ * </pre>
+ */
+public class AnnotationCreatorGenerator extends SourceFileGenerator<TypeElement> {
+ private static final ClassName AUTO_ANNOTATION =
+ ClassName.get("com.google.auto.value", "AutoAnnotation");
+
+ @Inject
+ AnnotationCreatorGenerator(Filer filer, DaggerElements elements, SourceVersion sourceVersion) {
+ super(filer, elements, sourceVersion);
+ }
+
+ @Override
+ public ClassName nameGeneratedType(TypeElement annotationType) {
+ return getAnnotationCreatorClassName(annotationType);
+ }
+
+ @Override
+ public Element originatingElement(TypeElement annotationType) {
+ return annotationType;
+ }
+
+ @Override
+ public Optional<TypeSpec.Builder> write(TypeElement annotationType) {
+ ClassName generatedTypeName = nameGeneratedType(annotationType);
+ TypeSpec.Builder annotationCreatorBuilder =
+ classBuilder(generatedTypeName)
+ .addModifiers(PUBLIC, FINAL)
+ .addMethod(constructorBuilder().addModifiers(PRIVATE).build());
+
+ for (TypeElement annotationElement : annotationsToCreate(annotationType)) {
+ annotationCreatorBuilder.addMethod(buildCreateMethod(generatedTypeName, annotationElement));
+ }
+
+ return Optional.of(annotationCreatorBuilder);
+ }
+
+ private MethodSpec buildCreateMethod(ClassName generatedTypeName, TypeElement annotationElement) {
+ String createMethodName = createMethodName(annotationElement);
+ MethodSpec.Builder createMethod =
+ methodBuilder(createMethodName)
+ .addAnnotation(AUTO_ANNOTATION)
+ .addModifiers(PUBLIC, STATIC)
+ .returns(TypeName.get(annotationElement.asType()));
+
+ ImmutableList.Builder<CodeBlock> parameters = ImmutableList.builder();
+ for (ExecutableElement annotationMember : methodsIn(annotationElement.getEnclosedElements())) {
+ String parameterName = annotationMember.getSimpleName().toString();
+ TypeName parameterType = TypeName.get(annotationMember.getReturnType());
+ createMethod.addParameter(parameterType, parameterName);
+ parameters.add(CodeBlock.of("$L", parameterName));
+ }
+
+ ClassName autoAnnotationClass =
+ generatedTypeName.peerClass(
+ "AutoAnnotation_" + generatedTypeName.simpleName() + "_" + createMethodName);
+ createMethod.addStatement(
+ "return new $T($L)", autoAnnotationClass, makeParametersCodeBlock(parameters.build()));
+ return createMethod.build();
+ }
+
+ /**
+ * Returns the annotation types for which {@code @AutoAnnotation static Foo createFoo(…)} methods
+ * should be written.
+ */
+ protected Set<TypeElement> annotationsToCreate(TypeElement annotationElement) {
+ return nestedAnnotationElements(annotationElement, new LinkedHashSet<>());
+ }
+
+ @CanIgnoreReturnValue
+ private static Set<TypeElement> nestedAnnotationElements(
+ TypeElement annotationElement, Set<TypeElement> annotationElements) {
+ if (annotationElements.add(annotationElement)) {
+ for (ExecutableElement method : methodsIn(annotationElement.getEnclosedElements())) {
+ TRAVERSE_NESTED_ANNOTATIONS.visit(method.getReturnType(), annotationElements);
+ }
+ }
+ return annotationElements;
+ }
+
+ private static final SimpleTypeVisitor6<Void, Set<TypeElement>> TRAVERSE_NESTED_ANNOTATIONS =
+ new SimpleTypeVisitor6<Void, Set<TypeElement>>() {
+ @Override
+ public Void visitDeclared(DeclaredType t, Set<TypeElement> p) {
+ TypeElement typeElement = MoreTypes.asTypeElement(t);
+ if (typeElement.getKind() == ElementKind.ANNOTATION_TYPE) {
+ nestedAnnotationElements(typeElement, p);
+ }
+ return null;
+ }
+ };
+}
diff --git a/java/dagger/internal/codegen/writing/AnonymousProviderCreationExpression.java b/java/dagger/internal/codegen/writing/AnonymousProviderCreationExpression.java
new file mode 100644
index 0000000..b1237ca
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/AnonymousProviderCreationExpression.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static dagger.internal.codegen.binding.BindingRequest.bindingRequest;
+import static dagger.internal.codegen.javapoet.CodeBlocks.anonymousProvider;
+import static dagger.model.RequestKind.INSTANCE;
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import dagger.internal.codegen.binding.BindingRequest;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.javapoet.Expression;
+import dagger.internal.codegen.writing.FrameworkFieldInitializer.FrameworkInstanceCreationExpression;
+
+/**
+ * A {@link javax.inject.Provider} creation expression for an anonymous inner class whose
+ * {@code get()} method returns the expression for an instance binding request for its key.
+ */
+final class AnonymousProviderCreationExpression
+ implements FrameworkInstanceCreationExpression {
+ private final ContributionBinding binding;
+ private final ComponentBindingExpressions componentBindingExpressions;
+ private final ClassName requestingClass;
+
+ AnonymousProviderCreationExpression(
+ ContributionBinding binding,
+ ComponentBindingExpressions componentBindingExpressions,
+ ClassName requestingClass) {
+ this.binding = binding;
+ this.componentBindingExpressions = componentBindingExpressions;
+ this.requestingClass = requestingClass;
+ }
+
+ @Override
+ public CodeBlock creationExpression() {
+ BindingRequest instanceExpressionRequest = bindingRequest(binding.key(), INSTANCE);
+ Expression instanceExpression =
+ componentBindingExpressions.getDependencyExpression(
+ instanceExpressionRequest,
+ // Not a real class name, but the actual requestingClass is an inner class within the
+ // given class, not that class itself.
+ requestingClass.nestedClass("Anonymous"));
+ return anonymousProvider(instanceExpression);
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/AssistedFactoryBindingExpression.java b/java/dagger/internal/codegen/writing/AssistedFactoryBindingExpression.java
new file mode 100644
index 0000000..d0c481c
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/AssistedFactoryBindingExpression.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.auto.common.MoreElements.asType;
+import static com.google.auto.common.MoreTypes.asDeclared;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static dagger.internal.codegen.binding.AssistedInjectionAnnotations.assistedFactoryMethod;
+import static dagger.internal.codegen.binding.AssistedInjectionAnnotations.assistedFactoryParameterSpecs;
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.TypeName;
+import com.squareup.javapoet.TypeSpec;
+import dagger.internal.codegen.binding.BindingRequest;
+import dagger.internal.codegen.binding.ProvisionBinding;
+import dagger.internal.codegen.javapoet.Expression;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.DependencyRequest;
+import dagger.model.RequestKind;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.DeclaredType;
+
+/**
+ * A {@link dagger.internal.codegen.writing.BindingExpression} for {@link
+ * dagger.assisted.AssistedFactory} methods.
+ */
+final class AssistedFactoryBindingExpression extends SimpleInvocationBindingExpression {
+ private final ProvisionBinding binding;
+ private final ComponentBindingExpressions componentBindingExpressions;
+ private final DaggerElements elements;
+ private final DaggerTypes types;
+
+ AssistedFactoryBindingExpression(
+ ProvisionBinding binding,
+ ComponentBindingExpressions componentBindingExpressions,
+ DaggerTypes types,
+ DaggerElements elements) {
+ super(binding);
+ this.binding = checkNotNull(binding);
+ this.componentBindingExpressions = checkNotNull(componentBindingExpressions);
+ this.elements = checkNotNull(elements);
+ this.types = checkNotNull(types);
+ }
+
+ @Override
+ Expression getDependencyExpression(ClassName requestingClass) {
+ // An assisted factory binding should have a single request for an assisted injection type.
+ DependencyRequest assistedInjectionRequest = getOnlyElement(binding.provisionDependencies());
+ Expression assistedInjectionExpression =
+ componentBindingExpressions.getDependencyExpression(
+ BindingRequest.bindingRequest(assistedInjectionRequest.key(), RequestKind.INSTANCE),
+ // This is kind of gross because the anonymous class doesn't really have a name we can
+ // reference. The requesting class name is really only needed to determine if we need to
+ // append "OwningClass.this." to the method call or not.
+ // TODO(bcorso): We should probably use a non-anonymous class here instead so that we
+ // actually have a proper class name.
+ requestingClass.peerClass(""));
+ return Expression.create(
+ assistedInjectionExpression.type(),
+ CodeBlock.of("$L", anonymousfactoryImpl(assistedInjectionExpression)));
+ }
+
+ private TypeSpec anonymousfactoryImpl(Expression assistedInjectionExpression) {
+ TypeElement factory = asType(binding.bindingElement().get());
+ DeclaredType factoryType = asDeclared(binding.key().type());
+ ExecutableElement factoryMethod = assistedFactoryMethod(factory, elements, types);
+
+ // We can't use MethodSpec.overriding directly because we need to control the parameter names.
+ MethodSpec factoryOverride = MethodSpec.overriding(factoryMethod, factoryType, types).build();
+ TypeSpec.Builder builder =
+ TypeSpec.anonymousClassBuilder("")
+ .addMethod(
+ MethodSpec.methodBuilder(factoryMethod.getSimpleName().toString())
+ .addModifiers(factoryOverride.modifiers)
+ .addTypeVariables(factoryOverride.typeVariables)
+ .returns(factoryOverride.returnType)
+ .addAnnotations(factoryOverride.annotations)
+ .addExceptions(factoryOverride.exceptions)
+ .addParameters(assistedFactoryParameterSpecs(binding, elements, types))
+ .addStatement("return $L", assistedInjectionExpression.codeBlock())
+ .build());
+
+ if (factory.getKind() == ElementKind.INTERFACE) {
+ builder.addSuperinterface(TypeName.get(factoryType));
+ } else {
+ builder.superclass(TypeName.get(factoryType));
+ }
+
+ return builder.build();
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/BUILD b/java/dagger/internal/codegen/writing/BUILD
new file mode 100644
index 0000000..dcb88b3
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/BUILD
@@ -0,0 +1,47 @@
+# Copyright (C) 2019 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Classes that assemble the model of the generated code and write to the Filer
+
+load("@rules_java//java:defs.bzl", "java_library")
+
+package(default_visibility = ["//:src"])
+
+java_library(
+ name = "writing",
+ srcs = glob(["*.java"]),
+ plugins = ["//java/dagger/internal/codegen/bootstrap"],
+ tags = ["maven:merged"],
+ deps = [
+ "//java/dagger:core",
+ "//java/dagger/internal/codegen/base",
+ "//java/dagger/internal/codegen/binding",
+ "//java/dagger/internal/codegen/compileroption",
+ "//java/dagger/internal/codegen/extension",
+ "//java/dagger/internal/codegen/javapoet",
+ "//java/dagger/internal/codegen/kotlin",
+ "//java/dagger/internal/codegen/langmodel",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/internal/guava:concurrent",
+ "//java/dagger/producers",
+ "//java/dagger/spi",
+ "@google_bazel_common//third_party/java/auto:value",
+ "@google_bazel_common//third_party/java/error_prone:annotations",
+ "@google_bazel_common//third_party/java/javapoet",
+ "@google_bazel_common//third_party/java/jsr330_inject",
+ "@maven//:com_google_auto_auto_common",
+ ],
+)
diff --git a/java/dagger/internal/codegen/writing/BindingExpression.java b/java/dagger/internal/codegen/writing/BindingExpression.java
new file mode 100644
index 0000000..bd45f60
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/BindingExpression.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import dagger.internal.codegen.binding.ComponentDescriptor.ComponentMethodDescriptor;
+import dagger.internal.codegen.javapoet.Expression;
+
+/** A factory of code expressions used to access a single request for a binding in a component. */
+// TODO(bcorso): Rename this to RequestExpression?
+abstract class BindingExpression {
+
+ /**
+ * Returns an expression that evaluates to the value of a request based on the given requesting
+ * class.
+ *
+ * @param requestingClass the class that will contain the expression
+ */
+ abstract Expression getDependencyExpression(ClassName requestingClass);
+
+ /**
+ * Equivalent to {@link #getDependencyExpression} that is used only when the request is for an
+ * implementation of a component method. By default, just delegates to {@link
+ * #getDependencyExpression}.
+ */
+ Expression getDependencyExpressionForComponentMethod(
+ ComponentMethodDescriptor componentMethod, ComponentImplementation component) {
+ return getDependencyExpression(component.name());
+ }
+
+ /** Returns {@code true} if this binding expression should be encapsulated in a method. */
+ boolean requiresMethodEncapsulation() {
+ return false;
+ }
+
+ /**
+ * Returns an expression for the implementation of a component method with the given request.
+ *
+ * @param component the component that will contain the implemented method
+ */
+ CodeBlock getComponentMethodImplementation(
+ ComponentMethodDescriptor componentMethod, ComponentImplementation component) {
+ // By default, just delegate to #getDependencyExpression().
+ return CodeBlock.of(
+ "return $L;",
+ getDependencyExpressionForComponentMethod(componentMethod, component).codeBlock());
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/ComponentBindingExpressions.java b/java/dagger/internal/codegen/writing/ComponentBindingExpressions.java
new file mode 100644
index 0000000..5f1f0bd
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/ComponentBindingExpressions.java
@@ -0,0 +1,721 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Verify.verify;
+import static dagger.internal.codegen.binding.BindingRequest.bindingRequest;
+import static dagger.internal.codegen.extension.DaggerCollectors.toOptional;
+import static dagger.internal.codegen.javapoet.CodeBlocks.makeParametersCodeBlock;
+import static dagger.internal.codegen.javapoet.TypeNames.DOUBLE_CHECK;
+import static dagger.internal.codegen.javapoet.TypeNames.SINGLE_CHECK;
+import static dagger.internal.codegen.langmodel.Accessibility.isRawTypeAccessible;
+import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
+import static dagger.internal.codegen.writing.DelegateBindingExpression.isBindsScopeStrongerThanDependencyScope;
+import static dagger.internal.codegen.writing.MemberSelect.staticFactoryCreation;
+import static dagger.model.BindingKind.DELEGATE;
+import static dagger.model.BindingKind.MULTIBOUND_MAP;
+import static dagger.model.BindingKind.MULTIBOUND_SET;
+
+import com.google.auto.common.MoreTypes;
+import com.google.common.collect.ImmutableList;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.MethodSpec;
+import dagger.internal.codegen.binding.Binding;
+import dagger.internal.codegen.binding.BindingGraph;
+import dagger.internal.codegen.binding.BindingNode;
+import dagger.internal.codegen.binding.BindingRequest;
+import dagger.internal.codegen.binding.BindingType;
+import dagger.internal.codegen.binding.ComponentDescriptor.ComponentMethodDescriptor;
+import dagger.internal.codegen.binding.ComponentRequirement;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.binding.FrameworkType;
+import dagger.internal.codegen.binding.FrameworkTypeMapper;
+import dagger.internal.codegen.binding.MembersInjectionBinding;
+import dagger.internal.codegen.binding.ProvisionBinding;
+import dagger.internal.codegen.compileroption.CompilerOptions;
+import dagger.internal.codegen.javapoet.Expression;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.internal.codegen.writing.FrameworkFieldInitializer.FrameworkInstanceCreationExpression;
+import dagger.internal.codegen.writing.MethodBindingExpression.MethodImplementationStrategy;
+import dagger.model.BindingKind;
+import dagger.model.DependencyRequest;
+import dagger.model.Key;
+import dagger.model.RequestKind;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import javax.inject.Inject;
+import javax.inject.Provider;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.type.TypeMirror;
+
+/** A central repository of code expressions used to access any binding available to a component. */
+@PerComponentImplementation
+public final class ComponentBindingExpressions {
+ // TODO(dpb,ronshapiro): refactor this and ComponentRequirementExpressions into a
+ // HierarchicalComponentMap<K, V>, or perhaps this use a flattened ImmutableMap, built from its
+ // parents? If so, maybe make BindingExpression.Factory create it.
+
+ private final Optional<ComponentBindingExpressions> parent;
+ private final BindingGraph graph;
+ private final ComponentImplementation componentImplementation;
+ private final ComponentImplementation topLevelComponentImplementation;
+ private final ComponentRequirementExpressions componentRequirementExpressions;
+ private final OptionalFactories optionalFactories;
+ private final DaggerTypes types;
+ private final DaggerElements elements;
+ private final SourceVersion sourceVersion;
+ private final CompilerOptions compilerOptions;
+ private final MembersInjectionMethods membersInjectionMethods;
+ private final InnerSwitchingProviders innerSwitchingProviders;
+ private final Map<BindingRequest, BindingExpression> expressions = new HashMap<>();
+ private final KotlinMetadataUtil metadataUtil;
+
+ @Inject
+ ComponentBindingExpressions(
+ @ParentComponent Optional<ComponentBindingExpressions> parent,
+ BindingGraph graph,
+ ComponentImplementation componentImplementation,
+ @TopLevel ComponentImplementation topLevelComponentImplementation,
+ ComponentRequirementExpressions componentRequirementExpressions,
+ OptionalFactories optionalFactories,
+ DaggerTypes types,
+ DaggerElements elements,
+ SourceVersion sourceVersion,
+ CompilerOptions compilerOptions,
+ KotlinMetadataUtil metadataUtil) {
+ this.parent = parent;
+ this.graph = graph;
+ this.componentImplementation = componentImplementation;
+ this.topLevelComponentImplementation = topLevelComponentImplementation;
+ this.componentRequirementExpressions = checkNotNull(componentRequirementExpressions);
+ this.optionalFactories = checkNotNull(optionalFactories);
+ this.types = checkNotNull(types);
+ this.elements = checkNotNull(elements);
+ this.sourceVersion = checkNotNull(sourceVersion);
+ this.compilerOptions = checkNotNull(compilerOptions);
+ this.membersInjectionMethods =
+ new MembersInjectionMethods(
+ componentImplementation, this, graph, elements, types, metadataUtil);
+ this.innerSwitchingProviders =
+ new InnerSwitchingProviders(componentImplementation, this, types);
+ this.metadataUtil = metadataUtil;
+ }
+
+ /**
+ * Returns an expression that evaluates to the value of a binding request for a binding owned by
+ * this component or an ancestor.
+ *
+ * @param requestingClass the class that will contain the expression
+ * @throws IllegalStateException if there is no binding expression that satisfies the request
+ */
+ public Expression getDependencyExpression(BindingRequest request, ClassName requestingClass) {
+ return getBindingExpression(request).getDependencyExpression(requestingClass);
+ }
+
+ /**
+ * Equivalent to {@link #getDependencyExpression(BindingRequest, ClassName)} that is used only
+ * when the request is for implementation of a component method.
+ *
+ * @throws IllegalStateException if there is no binding expression that satisfies the request
+ */
+ Expression getDependencyExpressionForComponentMethod(
+ BindingRequest request,
+ ComponentMethodDescriptor componentMethod,
+ ComponentImplementation componentImplementation) {
+ return getBindingExpression(request)
+ .getDependencyExpressionForComponentMethod(componentMethod, componentImplementation);
+ }
+
+ /**
+ * Returns the {@link CodeBlock} for the method arguments used with the factory {@code create()}
+ * method for the given {@link ContributionBinding binding}.
+ */
+ CodeBlock getCreateMethodArgumentsCodeBlock(ContributionBinding binding) {
+ return makeParametersCodeBlock(getCreateMethodArgumentsCodeBlocks(binding));
+ }
+
+ private ImmutableList<CodeBlock> getCreateMethodArgumentsCodeBlocks(ContributionBinding binding) {
+ ImmutableList.Builder<CodeBlock> arguments = ImmutableList.builder();
+
+ if (binding.requiresModuleInstance()) {
+ arguments.add(
+ componentRequirementExpressions.getExpressionDuringInitialization(
+ ComponentRequirement.forModule(binding.contributingModule().get().asType()),
+ componentImplementation.name()));
+ }
+
+ binding.dependencies().stream()
+ .map(dependency -> frameworkRequest(binding, dependency))
+ .map(request -> getDependencyExpression(request, componentImplementation.name()))
+ .map(Expression::codeBlock)
+ .forEach(arguments::add);
+
+ return arguments.build();
+ }
+
+ private static BindingRequest frameworkRequest(
+ ContributionBinding binding, DependencyRequest dependency) {
+ // TODO(bcorso): See if we can get rid of FrameworkTypeMatcher
+ FrameworkType frameworkType =
+ FrameworkTypeMapper.forBindingType(binding.bindingType())
+ .getFrameworkType(dependency.kind());
+ return BindingRequest.bindingRequest(dependency.key(), frameworkType);
+ }
+
+ /**
+ * Returns an expression that evaluates to the value of a dependency request, for passing to a
+ * binding method, an {@code @Inject}-annotated constructor or member, or a proxy for one.
+ *
+ * <p>If the method is a generated static {@link InjectionMethods injection method}, each
+ * parameter will be {@link Object} if the dependency's raw type is inaccessible. If that is the
+ * case for this dependency, the returned expression will use a cast to evaluate to the raw type.
+ *
+ * @param requestingClass the class that will contain the expression
+ */
+ Expression getDependencyArgumentExpression(
+ DependencyRequest dependencyRequest, ClassName requestingClass) {
+
+ TypeMirror dependencyType = dependencyRequest.key().type();
+ BindingRequest bindingRequest = bindingRequest(dependencyRequest);
+ Expression dependencyExpression = getDependencyExpression(bindingRequest, requestingClass);
+
+ if (dependencyRequest.kind().equals(RequestKind.INSTANCE)
+ && !isTypeAccessibleFrom(dependencyType, requestingClass.packageName())
+ && isRawTypeAccessible(dependencyType, requestingClass.packageName())) {
+ return dependencyExpression.castTo(types.erasure(dependencyType));
+ }
+
+ return dependencyExpression;
+ }
+
+ /** Returns the implementation of a component method. */
+ public MethodSpec getComponentMethod(ComponentMethodDescriptor componentMethod) {
+ checkArgument(componentMethod.dependencyRequest().isPresent());
+ BindingRequest request = bindingRequest(componentMethod.dependencyRequest().get());
+ MethodSpec.Builder method =
+ MethodSpec.overriding(
+ componentMethod.methodElement(),
+ MoreTypes.asDeclared(graph.componentTypeElement().asType()),
+ types);
+ // Even though this is not used if the method is abstract, we need to invoke the binding
+ // expression in order for the side of effect of the method being added to the
+ // ComponentImplementation
+ CodeBlock methodBody =
+ getBindingExpression(request)
+ .getComponentMethodImplementation(componentMethod, componentImplementation);
+
+ return method.addCode(methodBody).build();
+ }
+
+ /** Returns the {@link BindingExpression} for the given {@link BindingRequest}. */
+ BindingExpression getBindingExpression(BindingRequest request) {
+ if (expressions.containsKey(request)) {
+ return expressions.get(request);
+ }
+
+ Optional<Binding> optionalBinding =
+ graph.bindingNodes(request.key()).stream()
+ // Filter out nodes we don't own.
+ .filter(bindingNode -> bindingNode.componentPath().equals(graph.componentPath()))
+ // Filter out nodes that don't match the request kind
+ .filter(
+ bindingNode ->
+ // The binding used for the binding expression depends on the request:
+ // 1. MembersInjectionBinding: satisfies MEMBERS_INJECTION requests
+ // 2. ContributionBindings: satisfies all other requests.
+ request.isRequestKind(RequestKind.MEMBERS_INJECTION)
+ ? bindingNode.delegate().bindingType() == BindingType.MEMBERS_INJECTION
+ : bindingNode.delegate().bindingType() == BindingType.PROVISION
+ || bindingNode.delegate().bindingType() == BindingType.PRODUCTION)
+ .map(BindingNode::delegate)
+ // We expect at most one binding to match since this graph is already validated.
+ .collect(toOptional());
+
+ if (optionalBinding.isPresent()) {
+ BindingExpression expression = createBindingExpression(optionalBinding.get(), request);
+ expressions.put(request, expression);
+ return expression;
+ }
+
+ checkArgument(parent.isPresent(), "no expression found for %s", request);
+ return parent.get().getBindingExpression(request);
+ }
+
+ /** Creates a binding expression. */
+ private BindingExpression createBindingExpression(Binding binding, BindingRequest request) {
+ switch (binding.bindingType()) {
+ case MEMBERS_INJECTION:
+ checkArgument(request.isRequestKind(RequestKind.MEMBERS_INJECTION));
+ return new MembersInjectionBindingExpression(
+ (MembersInjectionBinding) binding, membersInjectionMethods);
+
+ case PROVISION:
+ return provisionBindingExpression((ContributionBinding) binding, request);
+
+ case PRODUCTION:
+ return productionBindingExpression((ContributionBinding) binding, request);
+ }
+ throw new AssertionError(binding);
+ }
+
+ /**
+ * Returns a binding expression that uses a {@link javax.inject.Provider} for provision bindings
+ * or a {@link dagger.producers.Producer} for production bindings.
+ */
+ private BindingExpression frameworkInstanceBindingExpression(ContributionBinding binding) {
+ // TODO(bcorso): Consider merging the static factory creation logic into CreationExpressions?
+ Optional<MemberSelect> staticMethod =
+ useStaticFactoryCreation(binding) ? staticFactoryCreation(binding) : Optional.empty();
+ FrameworkInstanceSupplier frameworkInstanceSupplier =
+ staticMethod.isPresent()
+ ? staticMethod::get
+ : new FrameworkFieldInitializer(
+ componentImplementation,
+ binding,
+ binding.scope().isPresent()
+ ? scope(binding, frameworkInstanceCreationExpression(binding))
+ : frameworkInstanceCreationExpression(binding));
+
+ switch (binding.bindingType()) {
+ case PROVISION:
+ return new ProviderInstanceBindingExpression(
+ binding, frameworkInstanceSupplier, types, elements);
+ case PRODUCTION:
+ return new ProducerNodeInstanceBindingExpression(
+ binding, frameworkInstanceSupplier, types, elements, componentImplementation);
+ default:
+ throw new AssertionError("invalid binding type: " + binding.bindingType());
+ }
+ }
+
+ private FrameworkInstanceCreationExpression scope(
+ ContributionBinding binding, FrameworkInstanceCreationExpression unscoped) {
+ return () ->
+ CodeBlock.of(
+ "$T.provider($L)",
+ binding.scope().get().isReusable() ? SINGLE_CHECK : DOUBLE_CHECK,
+ unscoped.creationExpression());
+ }
+
+ /**
+ * Returns a creation expression for a {@link javax.inject.Provider} for provision bindings or a
+ * {@link dagger.producers.Producer} for production bindings.
+ */
+ private FrameworkInstanceCreationExpression frameworkInstanceCreationExpression(
+ ContributionBinding binding) {
+ switch (binding.kind()) {
+ case COMPONENT:
+ // The cast can be removed when we drop java 7 source support
+ return new InstanceFactoryCreationExpression(
+ () -> CodeBlock.of("($T) this", binding.key().type()));
+
+ case BOUND_INSTANCE:
+ return instanceFactoryCreationExpression(
+ binding, ComponentRequirement.forBoundInstance(binding));
+
+ case COMPONENT_DEPENDENCY:
+ return instanceFactoryCreationExpression(
+ binding, ComponentRequirement.forDependency(binding.key().type()));
+
+ case COMPONENT_PROVISION:
+ return new DependencyMethodProviderCreationExpression(
+ binding,
+ componentImplementation,
+ componentRequirementExpressions,
+ compilerOptions,
+ graph);
+
+ case SUBCOMPONENT_CREATOR:
+ return new AnonymousProviderCreationExpression(
+ binding, this, componentImplementation.name());
+
+ case ASSISTED_FACTORY:
+ case ASSISTED_INJECTION:
+ case INJECTION:
+ case PROVISION:
+ return new InjectionOrProvisionProviderCreationExpression(binding, this);
+
+ case COMPONENT_PRODUCTION:
+ return new DependencyMethodProducerCreationExpression(
+ binding, componentImplementation, componentRequirementExpressions, graph);
+
+ case PRODUCTION:
+ return new ProducerCreationExpression(binding, this);
+
+ case MULTIBOUND_SET:
+ return new SetFactoryCreationExpression(binding, componentImplementation, this, graph);
+
+ case MULTIBOUND_MAP:
+ return new MapFactoryCreationExpression(
+ binding, componentImplementation, this, graph, elements);
+
+ case DELEGATE:
+ return new DelegatingFrameworkInstanceCreationExpression(
+ binding, componentImplementation, this);
+
+ case OPTIONAL:
+ return new OptionalFactoryInstanceCreationExpression(
+ optionalFactories, binding, componentImplementation, this);
+
+ case MEMBERS_INJECTOR:
+ return new MembersInjectorProviderCreationExpression((ProvisionBinding) binding, this);
+
+ default:
+ throw new AssertionError(binding);
+ }
+ }
+
+ private InstanceFactoryCreationExpression instanceFactoryCreationExpression(
+ ContributionBinding binding, ComponentRequirement componentRequirement) {
+ return new InstanceFactoryCreationExpression(
+ binding.nullableType().isPresent(),
+ () ->
+ componentRequirementExpressions.getExpressionDuringInitialization(
+ componentRequirement, componentImplementation.name()));
+ }
+
+ /** Returns a binding expression for a provision binding. */
+ private BindingExpression provisionBindingExpression(
+ ContributionBinding binding, BindingRequest request) {
+ if (!request.requestKind().isPresent()) {
+ verify(
+ request.frameworkType().get().equals(FrameworkType.PRODUCER_NODE),
+ "expected a PRODUCER_NODE: %s",
+ request);
+ return producerFromProviderBindingExpression(binding);
+ }
+ RequestKind requestKind = request.requestKind().get();
+ Key key = request.key();
+ switch (requestKind) {
+ case INSTANCE:
+ return instanceBindingExpression(binding);
+
+ case PROVIDER:
+ return providerBindingExpression(binding);
+
+ case LAZY:
+ case PRODUCED:
+ case PROVIDER_OF_LAZY:
+ return new DerivedFromFrameworkInstanceBindingExpression(
+ key, FrameworkType.PROVIDER, requestKind, this, types);
+
+ case PRODUCER:
+ return producerFromProviderBindingExpression(binding);
+
+ case FUTURE:
+ return new ImmediateFutureBindingExpression(key, this, types, sourceVersion);
+
+ case MEMBERS_INJECTION:
+ throw new IllegalArgumentException();
+ }
+
+ throw new AssertionError();
+ }
+
+ /** Returns a binding expression for a production binding. */
+ private BindingExpression productionBindingExpression(
+ ContributionBinding binding, BindingRequest request) {
+ if (request.frameworkType().isPresent()) {
+ return frameworkInstanceBindingExpression(binding);
+ } else {
+ // If no FrameworkType is present, a RequestKind is guaranteed to be present.
+ RequestKind requestKind = request.requestKind().get();
+ return new DerivedFromFrameworkInstanceBindingExpression(
+ request.key(), FrameworkType.PRODUCER_NODE, requestKind, this, types);
+ }
+ }
+
+ /**
+ * Returns a binding expression for {@link RequestKind#PROVIDER} requests.
+ *
+ * <p>{@code @Binds} bindings that don't {@linkplain #needsCaching(ContributionBinding) need to be
+ * cached} can use a {@link DelegateBindingExpression}.
+ *
+ * <p>In fastInit mode, use an {@link InnerSwitchingProviders inner switching provider} unless
+ * that provider's case statement will simply call {@code get()} on another {@link Provider} (in
+ * which case, just use that Provider directly).
+ *
+ * <p>Otherwise, return a {@link FrameworkInstanceBindingExpression}.
+ */
+ private BindingExpression providerBindingExpression(ContributionBinding binding) {
+ if (binding.kind().equals(DELEGATE) && !needsCaching(binding)) {
+ return new DelegateBindingExpression(binding, RequestKind.PROVIDER, this, types, elements);
+ } else if (compilerOptions.fastInit(
+ topLevelComponentImplementation.componentDescriptor().typeElement())
+ && frameworkInstanceCreationExpression(binding).useInnerSwitchingProvider()
+ && !(instanceBindingExpression(binding)
+ instanceof DerivedFromFrameworkInstanceBindingExpression)) {
+ return wrapInMethod(
+ binding,
+ bindingRequest(binding.key(), RequestKind.PROVIDER),
+ innerSwitchingProviders.newBindingExpression(binding));
+ }
+ return frameworkInstanceBindingExpression(binding);
+ }
+
+ /**
+ * Returns a binding expression that uses a {@link dagger.producers.Producer} field for a
+ * provision binding.
+ */
+ private FrameworkInstanceBindingExpression producerFromProviderBindingExpression(
+ ContributionBinding binding) {
+ checkArgument(binding.bindingType().equals(BindingType.PROVISION));
+ return new ProducerNodeInstanceBindingExpression(
+ binding,
+ new FrameworkFieldInitializer(
+ componentImplementation,
+ binding,
+ new ProducerFromProviderCreationExpression(binding, componentImplementation, this)),
+ types,
+ elements,
+ componentImplementation);
+ }
+
+ /**
+ * Returns a binding expression for {@link RequestKind#INSTANCE} requests.
+ *
+ * <p>If there is a direct expression (not calling {@link Provider#get()}) we can use for an
+ * instance of this binding, return it, wrapped in a method if the binding {@linkplain
+ * #needsCaching(ContributionBinding) needs to be cached} or the expression has dependencies.
+ *
+ * <p>In fastInit mode, we can use direct expressions unless the binding needs to be cached.
+ */
+ private BindingExpression instanceBindingExpression(ContributionBinding binding) {
+ Optional<BindingExpression> maybeDirectInstanceExpression =
+ unscopedDirectInstanceExpression(binding);
+ if (canUseDirectInstanceExpression(binding) && maybeDirectInstanceExpression.isPresent()) {
+ BindingExpression directInstanceExpression = maybeDirectInstanceExpression.get();
+ return directInstanceExpression.requiresMethodEncapsulation() || needsCaching(binding)
+ ? wrapInMethod(
+ binding,
+ bindingRequest(binding.key(), RequestKind.INSTANCE),
+ directInstanceExpression)
+ : directInstanceExpression;
+ }
+ return new DerivedFromFrameworkInstanceBindingExpression(
+ binding.key(), FrameworkType.PROVIDER, RequestKind.INSTANCE, this, types);
+ }
+
+ /**
+ * Returns an unscoped binding expression for an {@link RequestKind#INSTANCE} that does not call
+ * {@code get()} on its provider, if there is one.
+ */
+ private Optional<BindingExpression> unscopedDirectInstanceExpression(
+ ContributionBinding binding) {
+ switch (binding.kind()) {
+ case DELEGATE:
+ return Optional.of(
+ new DelegateBindingExpression(binding, RequestKind.INSTANCE, this, types, elements));
+
+ case COMPONENT:
+ return Optional.of(
+ new ComponentInstanceBindingExpression(binding, componentImplementation.name()));
+
+ case COMPONENT_DEPENDENCY:
+ return Optional.of(
+ new ComponentRequirementBindingExpression(
+ binding,
+ ComponentRequirement.forDependency(binding.key().type()),
+ componentRequirementExpressions));
+
+ case COMPONENT_PROVISION:
+ return Optional.of(
+ new ComponentProvisionBindingExpression(
+ (ProvisionBinding) binding,
+ graph,
+ componentRequirementExpressions,
+ compilerOptions));
+
+ case SUBCOMPONENT_CREATOR:
+ return Optional.of(
+ new SubcomponentCreatorBindingExpression(
+ binding, componentImplementation.getSubcomponentCreatorSimpleName(binding.key())));
+
+ case MULTIBOUND_SET:
+ return Optional.of(
+ new SetBindingExpression((ProvisionBinding) binding, graph, this, types, elements));
+
+ case MULTIBOUND_MAP:
+ return Optional.of(
+ new MapBindingExpression((ProvisionBinding) binding, graph, this, types, elements));
+
+ case OPTIONAL:
+ return Optional.of(
+ new OptionalBindingExpression((ProvisionBinding) binding, this, types, sourceVersion));
+
+ case BOUND_INSTANCE:
+ return Optional.of(
+ new ComponentRequirementBindingExpression(
+ binding,
+ ComponentRequirement.forBoundInstance(binding),
+ componentRequirementExpressions));
+
+ case ASSISTED_FACTORY:
+ return Optional.of(
+ new AssistedFactoryBindingExpression(
+ (ProvisionBinding) binding, this, types, elements));
+
+ case ASSISTED_INJECTION:
+ case INJECTION:
+ case PROVISION:
+ return Optional.of(
+ new SimpleMethodBindingExpression(
+ (ProvisionBinding) binding,
+ compilerOptions,
+ this,
+ membersInjectionMethods,
+ componentRequirementExpressions,
+ elements,
+ sourceVersion,
+ metadataUtil));
+
+ case MEMBERS_INJECTOR:
+ return Optional.empty();
+
+ case MEMBERS_INJECTION:
+ case COMPONENT_PRODUCTION:
+ case PRODUCTION:
+ throw new IllegalArgumentException(binding.kind().toString());
+ default:
+ throw new AssertionError("Unexpected binding kind: " + binding.kind());
+ }
+ }
+
+ /**
+ * Returns {@code true} if the binding should use the static factory creation strategy.
+ *
+ * <p>In default mode, we always use the static factory creation strategy. In fastInit mode, we
+ * prefer to use a SwitchingProvider instead of static factories in order to reduce class loading;
+ * however, we allow static factories that can reused across multiple bindings, e.g. {@code
+ * MapFactory} or {@code SetFactory}.
+ */
+ private boolean useStaticFactoryCreation(ContributionBinding binding) {
+ return !compilerOptions.fastInit(
+ topLevelComponentImplementation.componentDescriptor().typeElement())
+ || binding.kind().equals(MULTIBOUND_MAP)
+ || binding.kind().equals(MULTIBOUND_SET);
+ }
+
+ /**
+ * Returns {@code true} if we can use a direct (not {@code Provider.get()}) expression for this
+ * binding. If the binding doesn't {@linkplain #needsCaching(ContributionBinding) need to be
+ * cached} and the binding is not an {@link BindingKind.ASSISTED_FACTORY}, we can.
+ *
+ * <p>In fastInit mode, we can use a direct expression even if the binding {@linkplain
+ * #needsCaching(ContributionBinding) needs to be cached}.
+ */
+ private boolean canUseDirectInstanceExpression(ContributionBinding binding) {
+ return (!needsCaching(binding) && binding.kind() != BindingKind.ASSISTED_FACTORY)
+ || compilerOptions.fastInit(
+ topLevelComponentImplementation.componentDescriptor().typeElement());
+ }
+
+ /**
+ * Returns a binding expression that uses a given one as the body of a method that users call. If
+ * a component provision method matches it, it will be the method implemented. If it does not
+ * match a component provision method and the binding is modifiable, then a new public modifiable
+ * binding method will be written. If the binding doesn't match a component method and is not
+ * modifiable, then a new private method will be written.
+ */
+ BindingExpression wrapInMethod(
+ ContributionBinding binding, BindingRequest request, BindingExpression bindingExpression) {
+ // If we've already wrapped the expression, then use the delegate.
+ if (bindingExpression instanceof MethodBindingExpression) {
+ return bindingExpression;
+ }
+
+ MethodImplementationStrategy methodImplementationStrategy =
+ methodImplementationStrategy(binding, request);
+ Optional<ComponentMethodDescriptor> matchingComponentMethod =
+ graph.componentDescriptor().firstMatchingComponentMethod(request);
+
+ ComponentImplementation shard = componentImplementation.shardImplementation(binding.key());
+
+ // Consider the case of a request from a component method like:
+ //
+ // DaggerMyComponent extends MyComponent {
+ // @Overrides
+ // Foo getFoo() {
+ // <FOO_BINDING_REQUEST>
+ // }
+ // }
+ //
+ // Normally, in this case we would return a ComponentMethodBindingExpression rather than a
+ // PrivateMethodBindingExpression so that #getFoo() can inline the implementation rather than
+ // create an unnecessary private method and return that. However, with sharding we don't want to
+ // inline the implementation because that would defeat some of the class pool savings if those
+ // fields had to communicate across shards. Thus, when a key belongs to a separate shard use a
+ // PrivateMethodBindingExpression and put the private method in the shard.
+ if (matchingComponentMethod.isPresent() && componentImplementation == shard) {
+ ComponentMethodDescriptor componentMethod = matchingComponentMethod.get();
+ return new ComponentMethodBindingExpression(
+ request,
+ binding,
+ methodImplementationStrategy,
+ bindingExpression,
+ componentImplementation,
+ componentMethod,
+ types);
+ } else {
+ return new PrivateMethodBindingExpression(
+ request,
+ binding,
+ methodImplementationStrategy,
+ bindingExpression,
+ shard,
+ types,
+ compilerOptions);
+ }
+ }
+
+ private MethodImplementationStrategy methodImplementationStrategy(
+ ContributionBinding binding, BindingRequest request) {
+ if (compilerOptions.fastInit(
+ topLevelComponentImplementation.componentDescriptor().typeElement())) {
+ if (request.isRequestKind(RequestKind.PROVIDER)) {
+ return MethodImplementationStrategy.SINGLE_CHECK;
+ } else if (request.isRequestKind(RequestKind.INSTANCE) && needsCaching(binding)) {
+ return binding.scope().get().isReusable()
+ ? MethodImplementationStrategy.SINGLE_CHECK
+ : MethodImplementationStrategy.DOUBLE_CHECK;
+ }
+ }
+ return MethodImplementationStrategy.SIMPLE;
+ }
+
+ /**
+ * Returns {@code true} if the component needs to make sure the provided value is cached.
+ *
+ * <p>The component needs to cache the value for scoped bindings except for {@code @Binds}
+ * bindings whose scope is no stronger than their delegate's.
+ */
+ private boolean needsCaching(ContributionBinding binding) {
+ if (!binding.scope().isPresent()) {
+ return false;
+ }
+ if (binding.kind().equals(DELEGATE)) {
+ return isBindsScopeStrongerThanDependencyScope(binding, graph);
+ }
+ return true;
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/ComponentCreatorImplementation.java b/java/dagger/internal/codegen/writing/ComponentCreatorImplementation.java
new file mode 100644
index 0000000..f9d218b
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/ComponentCreatorImplementation.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.collect.ImmutableMap;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.TypeSpec;
+import dagger.internal.codegen.binding.ComponentRequirement;
+
+/** The implementation of a component creator type. */
+@AutoValue
+public abstract class ComponentCreatorImplementation {
+
+ /** Creates a new {@link ComponentCreatorImplementation}. */
+ public static ComponentCreatorImplementation create(
+ TypeSpec spec, ClassName name, ImmutableMap<ComponentRequirement, FieldSpec> fields) {
+ return new AutoValue_ComponentCreatorImplementation(spec, name, fields);
+ }
+
+ /** The type spec for the creator implementation. */
+ public abstract TypeSpec spec();
+
+ /** The name of the creator implementation class. */
+ public abstract ClassName name();
+
+ /** All fields that are present in this implementation. */
+ abstract ImmutableMap<ComponentRequirement, FieldSpec> fields();
+}
diff --git a/java/dagger/internal/codegen/writing/ComponentImplementation.java b/java/dagger/internal/codegen/writing/ComponentImplementation.java
new file mode 100644
index 0000000..ef69124
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/ComponentImplementation.java
@@ -0,0 +1,432 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.CaseFormat.LOWER_CAMEL;
+import static com.google.common.base.CaseFormat.UPPER_CAMEL;
+import static com.google.common.base.CaseFormat.UPPER_UNDERSCORE;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkState;
+import static com.squareup.javapoet.TypeSpec.classBuilder;
+import static dagger.internal.codegen.binding.ComponentCreatorKind.BUILDER;
+import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
+import static javax.lang.model.element.Modifier.FINAL;
+import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.PUBLIC;
+
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ListMultimap;
+import com.google.common.collect.MultimapBuilder;
+import com.squareup.javapoet.AnnotationSpec;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.TypeSpec;
+import dagger.internal.codegen.base.UniqueNameSet;
+import dagger.internal.codegen.binding.BindingGraph;
+import dagger.internal.codegen.binding.BindingRequest;
+import dagger.internal.codegen.binding.ComponentCreatorDescriptor;
+import dagger.internal.codegen.binding.ComponentCreatorKind;
+import dagger.internal.codegen.binding.ComponentDescriptor;
+import dagger.internal.codegen.binding.ComponentRequirement;
+import dagger.internal.codegen.binding.KeyVariableNamer;
+import dagger.internal.codegen.compileroption.CompilerOptions;
+import dagger.internal.codegen.javapoet.TypeSpecs;
+import dagger.model.Key;
+import dagger.model.RequestKind;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeMirror;
+
+/** The implementation of a component type. */
+public final class ComponentImplementation {
+ /** A type of field that this component can contain. */
+ public enum FieldSpecKind {
+ /** A field for a component shard. */
+ COMPONENT_SHARD,
+
+ /** A field required by the component, e.g. module instances. */
+ COMPONENT_REQUIREMENT_FIELD,
+
+ /**
+ * A field for the lock and cached value for {@linkplain PrivateMethodBindingExpression
+ * private-method scoped bindings}.
+ */
+ PRIVATE_METHOD_SCOPED_FIELD,
+
+ /** A framework field for type T, e.g. {@code Provider<T>}. */
+ FRAMEWORK_FIELD,
+
+ /** A static field that always returns an absent {@code Optional} value for the binding. */
+ ABSENT_OPTIONAL_FIELD
+ }
+
+ /** A type of method that this component can contain. */
+ // TODO(bcorso, dpb): Change the oder to constructor, initialize, component, then private
+ // (including MIM and AOM—why treat those separately?).
+ public enum MethodSpecKind {
+ /** The component constructor. */
+ CONSTRUCTOR,
+
+ /** A builder method for the component. (Only used by the root component.) */
+ BUILDER_METHOD,
+
+ /** A private method that wraps dependency expressions. */
+ PRIVATE_METHOD,
+
+ /** An initialization method that initializes component requirements and framework types. */
+ INITIALIZE_METHOD,
+
+ /** An implementation of a component interface method. */
+ COMPONENT_METHOD,
+
+ /** A private method that encapsulates members injection logic for a binding. */
+ MEMBERS_INJECTION_METHOD,
+
+ /** A static method that always returns an absent {@code Optional} value for the binding. */
+ ABSENT_OPTIONAL_METHOD,
+
+ /**
+ * The {@link dagger.producers.internal.CancellationListener#onProducerFutureCancelled(boolean)}
+ * method for a production component.
+ */
+ CANCELLATION_LISTENER_METHOD,
+ ;
+ }
+
+ /** A type of nested class that this component can contain. */
+ public enum TypeSpecKind {
+ /** A factory class for a present optional binding. */
+ PRESENT_FACTORY,
+
+ /** A class for the component creator (only used by the root component.) */
+ COMPONENT_CREATOR,
+
+ /** A provider class for a component provision. */
+ COMPONENT_PROVISION_FACTORY,
+
+ /** A class for the subcomponent or subcomponent builder. */
+ SUBCOMPONENT
+ }
+
+ private ComponentImplementation currentShard = this;
+ private final Map<Key, ComponentImplementation> shardsByKey = new HashMap<>();
+ private final Optional<ComponentImplementation> shardOwner;
+ private final BindingGraph graph;
+ private final ClassName name;
+ private final TypeSpec.Builder component;
+ private final SubcomponentNames subcomponentNames;
+ private final CompilerOptions compilerOptions;
+ private final CodeBlock externalReferenceBlock;
+ private final UniqueNameSet componentFieldNames = new UniqueNameSet();
+ private final UniqueNameSet componentMethodNames = new UniqueNameSet();
+ private final List<CodeBlock> initializations = new ArrayList<>();
+ private final List<CodeBlock> componentRequirementInitializations = new ArrayList<>();
+ private final Map<ComponentRequirement, String> componentRequirementParameterNames =
+ new HashMap<>();
+ private final Set<Key> cancellableProducerKeys = new LinkedHashSet<>();
+ private final ListMultimap<FieldSpecKind, FieldSpec> fieldSpecsMap =
+ MultimapBuilder.enumKeys(FieldSpecKind.class).arrayListValues().build();
+ private final ListMultimap<MethodSpecKind, MethodSpec> methodSpecsMap =
+ MultimapBuilder.enumKeys(MethodSpecKind.class).arrayListValues().build();
+ private final ListMultimap<TypeSpecKind, TypeSpec> typeSpecsMap =
+ MultimapBuilder.enumKeys(TypeSpecKind.class).arrayListValues().build();
+ private final List<Supplier<TypeSpec>> typeSuppliers = new ArrayList<>();
+
+ private ComponentImplementation(
+ BindingGraph graph,
+ ClassName name,
+ SubcomponentNames subcomponentNames,
+ CompilerOptions compilerOptions) {
+ this.graph = graph;
+ this.name = name;
+ this.component = classBuilder(name);
+ this.subcomponentNames = subcomponentNames;
+ this.shardOwner = Optional.empty();
+ this.externalReferenceBlock = CodeBlock.of("$T.this", name);
+ this.compilerOptions = compilerOptions;
+ }
+
+ private ComponentImplementation(ComponentImplementation shardOwner, ClassName shardName) {
+ this.graph = shardOwner.graph;
+ this.name = shardName;
+ this.component = classBuilder(shardName);
+ this.subcomponentNames = shardOwner.subcomponentNames;
+ this.compilerOptions = shardOwner.compilerOptions;
+ this.shardOwner = Optional.of(shardOwner);
+ String fieldName = UPPER_CAMEL.to(LOWER_CAMEL, name.simpleName());
+ String uniqueFieldName = shardOwner.getUniqueFieldName(fieldName);
+ this.externalReferenceBlock = CodeBlock.of("$T.this.$N", shardOwner.name, uniqueFieldName);
+ shardOwner.addTypeSupplier(() -> generate().build());
+ shardOwner.addField(
+ FieldSpecKind.COMPONENT_SHARD,
+ FieldSpec.builder(name, uniqueFieldName, PRIVATE, FINAL)
+ .initializer("new $T()", name)
+ .build());
+ }
+
+ /** Returns a component implementation for a top-level component. */
+ public static ComponentImplementation topLevelComponentImplementation(
+ BindingGraph graph,
+ ClassName name,
+ SubcomponentNames subcomponentNames,
+ CompilerOptions compilerOptions) {
+ return new ComponentImplementation(graph, name, subcomponentNames, compilerOptions);
+ }
+
+ /** Returns a component implementation that is a child of the current implementation. */
+ public ComponentImplementation childComponentImplementation(BindingGraph graph) {
+ checkState(!shardOwner.isPresent(), "Shards cannot create child components.");
+ ClassName childName = getSubcomponentName(graph.componentDescriptor());
+ return new ComponentImplementation(graph, childName, subcomponentNames, compilerOptions);
+ }
+
+ /** Returns a component implementation that is a shard of the current implementation. */
+ public ComponentImplementation shardImplementation(Key key) {
+ checkState(!shardOwner.isPresent(), "Shards cannot create other shards.");
+ if (!shardsByKey.containsKey(key)) {
+ int keysPerShard = compilerOptions.keysPerComponentShard(graph.componentTypeElement());
+ if (!shardsByKey.isEmpty() && shardsByKey.size() % keysPerShard == 0) {
+ ClassName shardName = name.nestedClass("Shard" + shardsByKey.size() / keysPerShard);
+ currentShard = new ComponentImplementation(this, shardName);
+ }
+ shardsByKey.put(key, currentShard);
+ }
+ return shardsByKey.get(key);
+ }
+
+ /** Returns a reference to this compenent when called from a class nested in this component. */
+ public CodeBlock externalReferenceBlock() {
+ return externalReferenceBlock;
+ }
+
+ // TODO(ronshapiro): see if we can remove this method and instead inject it in the objects that
+ // need it.
+ /** Returns the binding graph for the component being generated. */
+ public BindingGraph graph() {
+ return graph;
+ }
+
+ /** Returns the descriptor for the component being generated. */
+ public ComponentDescriptor componentDescriptor() {
+ return graph.componentDescriptor();
+ }
+
+ /** Returns the name of the component. */
+ public ClassName name() {
+ return name;
+ }
+
+ /** Returns whether or not the implementation is nested within another class. */
+ public boolean isNested() {
+ return name.enclosingClassName() != null;
+ }
+
+ /**
+ * Returns the kind of this component's creator.
+ *
+ * @throws IllegalStateException if the component has no creator
+ */
+ private ComponentCreatorKind creatorKind() {
+ checkState(componentDescriptor().hasCreator());
+ return componentDescriptor()
+ .creatorDescriptor()
+ .map(ComponentCreatorDescriptor::kind)
+ .orElse(BUILDER);
+ }
+
+ /**
+ * Returns the name of the creator class for this component. It will be a sibling of this
+ * generated class unless this is a top-level component, in which case it will be nested.
+ */
+ public ClassName getCreatorName() {
+ return isNested()
+ ? name.peerClass(subcomponentNames.getCreatorName(componentDescriptor()))
+ : name.nestedClass(creatorKind().typeName());
+ }
+
+ /** Returns the name of the nested implementation class for a child component. */
+ private ClassName getSubcomponentName(ComponentDescriptor childDescriptor) {
+ checkArgument(
+ componentDescriptor().childComponents().contains(childDescriptor),
+ "%s is not a child component of %s",
+ childDescriptor.typeElement(),
+ componentDescriptor().typeElement());
+ return name.nestedClass(subcomponentNames.get(childDescriptor) + "Impl");
+ }
+
+ /**
+ * Returns the simple name of the creator implementation class for the given subcomponent creator
+ * {@link Key}.
+ */
+ String getSubcomponentCreatorSimpleName(Key key) {
+ return subcomponentNames.getCreatorName(key);
+ }
+
+ /** Returns {@code true} if {@code type} is accessible from the generated component. */
+ boolean isTypeAccessible(TypeMirror type) {
+ return isTypeAccessibleFrom(type, name.packageName());
+ }
+
+ /** Adds the given super type to the component. */
+ public void addSupertype(TypeElement supertype) {
+ TypeSpecs.addSupertype(component, supertype);
+ }
+
+ // TODO(dpb): Consider taking FieldSpec, and returning identical FieldSpec with unique name?
+ /** Adds the given field to the component. */
+ public void addField(FieldSpecKind fieldKind, FieldSpec fieldSpec) {
+ fieldSpecsMap.put(fieldKind, fieldSpec);
+ }
+
+ // TODO(dpb): Consider taking MethodSpec, and returning identical MethodSpec with unique name?
+ /** Adds the given method to the component. */
+ public void addMethod(MethodSpecKind methodKind, MethodSpec methodSpec) {
+ methodSpecsMap.put(methodKind, methodSpec);
+ }
+
+ /** Adds the given annotation to the component. */
+ public void addAnnotation(AnnotationSpec annotation) {
+ component.addAnnotation(annotation);
+ }
+
+ /** Adds the given type to the component. */
+ public void addType(TypeSpecKind typeKind, TypeSpec typeSpec) {
+ typeSpecsMap.put(typeKind, typeSpec);
+ }
+
+ /** Adds a {@link Supplier} for the SwitchingProvider for the component. */
+ void addTypeSupplier(Supplier<TypeSpec> typeSpecSupplier) {
+ typeSuppliers.add(typeSpecSupplier);
+ }
+
+ /** Adds the given code block to the initialize methods of the component. */
+ void addInitialization(CodeBlock codeBlock) {
+ initializations.add(codeBlock);
+ }
+
+ /** Adds the given code block that initializes a {@link ComponentRequirement}. */
+ void addComponentRequirementInitialization(CodeBlock codeBlock) {
+ componentRequirementInitializations.add(codeBlock);
+ }
+
+ /**
+ * Marks the given key of a producer as one that should have a cancellation statement in the
+ * cancellation listener method of the component.
+ */
+ void addCancellableProducerKey(Key key) {
+ cancellableProducerKeys.add(key);
+ }
+
+ /** Returns a new, unique field name for the component based on the given name. */
+ String getUniqueFieldName(String name) {
+ return componentFieldNames.getUniqueName(name);
+ }
+
+ /** Returns a new, unique method name for the component based on the given name. */
+ public String getUniqueMethodName(String name) {
+ return componentMethodNames.getUniqueName(name);
+ }
+
+ /** Returns a new, unique method name for a getter method for the given request. */
+ String getUniqueMethodName(BindingRequest request) {
+ return uniqueMethodName(request, KeyVariableNamer.name(request.key()));
+ }
+
+ private String uniqueMethodName(BindingRequest request, String bindingName) {
+ // This name is intentionally made to match the name for fields in fastInit
+ // in order to reduce the constant pool size. b/162004246
+ String baseMethodName = bindingName
+ + (request.isRequestKind(RequestKind.INSTANCE)
+ ? ""
+ : UPPER_UNDERSCORE.to(UPPER_CAMEL, request.kindName()));
+ return getUniqueMethodName(baseMethodName);
+ }
+
+ /**
+ * Gets the parameter name to use for the given requirement for this component, starting with the
+ * given base name if no parameter name has already been selected for the requirement.
+ */
+ public String getParameterName(ComponentRequirement requirement, String baseName) {
+ return componentRequirementParameterNames.computeIfAbsent(
+ requirement, r -> getUniqueFieldName(baseName));
+ }
+
+ /** Claims a new method name for the component. Does nothing if method name already exists. */
+ public void claimMethodName(CharSequence name) {
+ componentMethodNames.claim(name);
+ }
+
+ /** Returns the list of {@link CodeBlock}s that need to go in the initialize method. */
+ public ImmutableList<CodeBlock> getInitializations() {
+ return ImmutableList.copyOf(initializations);
+ }
+
+ /**
+ * Returns a list of {@link CodeBlock}s for initializing {@link ComponentRequirement}s.
+ *
+ * <p>These initializations are kept separate from {@link #getInitializations()} because they must
+ * be executed before the initializations of any framework instance initializations in a
+ * superclass implementation that may depend on the instances. We cannot use the same strategy
+ * that we use for framework instances (i.e. wrap in a {@link dagger.internal.DelegateFactory} or
+ * {@link dagger.producers.internal.DelegateProducer} since the types of these initialized fields
+ * have no interface type that we can write a proxy for.
+ */
+ // TODO(cgdecker): can these be inlined with getInitializations() now that we've turned down
+ // ahead-of-time subcomponents?
+ public ImmutableList<CodeBlock> getComponentRequirementInitializations() {
+ return ImmutableList.copyOf(componentRequirementInitializations);
+ }
+
+ /**
+ * Returns the list of producer {@link Key}s that need cancellation statements in the cancellation
+ * listener method.
+ */
+ public ImmutableList<Key> getCancellableProducerKeys() {
+ return ImmutableList.copyOf(cancellableProducerKeys);
+ }
+
+ /** Generates the component and returns the resulting {@link TypeSpec.Builder}. */
+ public TypeSpec.Builder generate() {
+ modifiers().forEach(component::addModifiers);
+ fieldSpecsMap.asMap().values().forEach(component::addFields);
+ methodSpecsMap.asMap().values().forEach(component::addMethods);
+ typeSpecsMap.asMap().values().forEach(component::addTypes);
+ typeSuppliers.stream().map(Supplier::get).forEach(component::addType);
+ return component;
+ }
+
+ private ImmutableSet<Modifier> modifiers() {
+ if (isNested()) {
+ return ImmutableSet.of(PRIVATE, FINAL);
+ }
+ return graph.componentTypeElement().getModifiers().contains(PUBLIC)
+ // TODO(ronshapiro): perhaps all generated components should be non-public?
+ ? ImmutableSet.of(PUBLIC, FINAL)
+ : ImmutableSet.of(FINAL);
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/ComponentInstanceBindingExpression.java b/java/dagger/internal/codegen/writing/ComponentInstanceBindingExpression.java
new file mode 100644
index 0000000..9fa10c6
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/ComponentInstanceBindingExpression.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.javapoet.Expression;
+
+/** A binding expression for the instance of the component itself, i.e. {@code this}. */
+final class ComponentInstanceBindingExpression extends SimpleInvocationBindingExpression {
+ private final ClassName componentName;
+ private final ContributionBinding binding;
+
+ ComponentInstanceBindingExpression(ContributionBinding binding, ClassName componentName) {
+ super(binding);
+ this.binding = binding;
+ this.componentName = componentName;
+ }
+
+ @Override
+ Expression getDependencyExpression(ClassName requestingClass) {
+ return Expression.create(
+ binding.key().type(),
+ componentName.equals(requestingClass)
+ ? CodeBlock.of("this")
+ : CodeBlock.of("$T.this", componentName));
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/ComponentMethodBindingExpression.java b/java/dagger/internal/codegen/writing/ComponentMethodBindingExpression.java
new file mode 100644
index 0000000..7fa9aa3
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/ComponentMethodBindingExpression.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import dagger.internal.codegen.binding.BindingRequest;
+import dagger.internal.codegen.binding.ComponentDescriptor.ComponentMethodDescriptor;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.javapoet.Expression;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import javax.lang.model.type.TypeMirror;
+
+/**
+ * A binding expression that implements and uses a component method.
+ *
+ * <p>Dependents of this binding expression will just call the component method.
+ */
+final class ComponentMethodBindingExpression extends MethodBindingExpression {
+ private final ComponentImplementation componentImplementation;
+ private final ComponentMethodDescriptor componentMethod;
+
+ ComponentMethodBindingExpression(
+ BindingRequest request,
+ ContributionBinding binding,
+ MethodImplementationStrategy methodImplementationStrategy,
+ BindingExpression wrappedBindingExpression,
+ ComponentImplementation componentImplementation,
+ ComponentMethodDescriptor componentMethod,
+ DaggerTypes types) {
+ super(
+ request,
+ binding,
+ methodImplementationStrategy,
+ wrappedBindingExpression,
+ componentImplementation,
+ types);
+ this.componentImplementation = checkNotNull(componentImplementation);
+ this.componentMethod = checkNotNull(componentMethod);
+ }
+
+ @Override
+ protected CodeBlock getComponentMethodImplementation(
+ ComponentMethodDescriptor componentMethod, ComponentImplementation component) {
+ // There could be several methods on the component for the same request key and kind.
+ // Only one should use the BindingMethodImplementation; the others can delegate that one. So
+ // use methodImplementation.body() only if componentMethod equals the method for this instance.
+
+ // Separately, the method might be defined on a supertype that is also a supertype of some
+ // parent component. In that case, the same ComponentMethodDescriptor will be used to add a CMBE
+ // for the parent and the child. Only the parent's should use the BindingMethodImplementation;
+ // the child's can delegate to the parent. So use methodImplementation.body() only if
+ // componentName equals the component for this instance.
+ return componentMethod.equals(this.componentMethod) && component.equals(componentImplementation)
+ ? methodBodyForComponentMethod(componentMethod)
+ : super.getComponentMethodImplementation(componentMethod, component);
+ }
+
+ @Override
+ Expression getDependencyExpression(ClassName requestingClass) {
+ // If a component method returns a primitive, update the expression's type which might be boxed.
+ Expression expression = super.getDependencyExpression(requestingClass);
+ TypeMirror methodReturnType = componentMethod.methodElement().getReturnType();
+ return methodReturnType.getKind().isPrimitive()
+ ? Expression.create(methodReturnType, expression.codeBlock())
+ : expression;
+ }
+
+ @Override
+ protected void addMethod() {}
+
+ @Override
+ protected String methodName() {
+ return componentMethod.methodElement().getSimpleName().toString();
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/ComponentProvisionBindingExpression.java b/java/dagger/internal/codegen/writing/ComponentProvisionBindingExpression.java
new file mode 100644
index 0000000..53914b6
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/ComponentProvisionBindingExpression.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import dagger.internal.Preconditions;
+import dagger.internal.codegen.binding.BindingGraph;
+import dagger.internal.codegen.binding.ComponentRequirement;
+import dagger.internal.codegen.binding.ProvisionBinding;
+import dagger.internal.codegen.compileroption.CompilerOptions;
+import dagger.internal.codegen.javapoet.Expression;
+
+/** A binding expression for component provision methods. */
+final class ComponentProvisionBindingExpression extends SimpleInvocationBindingExpression {
+ private final ProvisionBinding binding;
+ private final BindingGraph bindingGraph;
+ private final ComponentRequirementExpressions componentRequirementExpressions;
+ private final CompilerOptions compilerOptions;
+
+ ComponentProvisionBindingExpression(
+ ProvisionBinding binding,
+ BindingGraph bindingGraph,
+ ComponentRequirementExpressions componentRequirementExpressions,
+ CompilerOptions compilerOptions) {
+ super(binding);
+ this.binding = binding;
+ this.bindingGraph = checkNotNull(bindingGraph);
+ this.componentRequirementExpressions = checkNotNull(componentRequirementExpressions);
+ this.compilerOptions = checkNotNull(compilerOptions);
+ }
+
+ @Override
+ Expression getDependencyExpression(ClassName requestingClass) {
+ CodeBlock invocation =
+ CodeBlock.of(
+ "$L.$L()",
+ componentRequirementExpressions.getExpression(componentRequirement(), requestingClass),
+ binding.bindingElement().get().getSimpleName());
+ return Expression.create(
+ binding.contributedPrimitiveType().orElse(binding.key().type()),
+ maybeCheckForNull(binding, compilerOptions, invocation));
+ }
+
+ private ComponentRequirement componentRequirement() {
+ return bindingGraph
+ .componentDescriptor()
+ .getDependencyThatDefinesMethod(binding.bindingElement().get());
+ }
+
+ static CodeBlock maybeCheckForNull(
+ ProvisionBinding binding, CompilerOptions compilerOptions, CodeBlock invocation) {
+ return binding.shouldCheckForNull(compilerOptions)
+ ? CodeBlock.of("$T.checkNotNullFromComponent($L)", Preconditions.class, invocation)
+ : invocation;
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/ComponentRequirementBindingExpression.java b/java/dagger/internal/codegen/writing/ComponentRequirementBindingExpression.java
new file mode 100644
index 0000000..299f279
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/ComponentRequirementBindingExpression.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import com.squareup.javapoet.ClassName;
+import dagger.internal.codegen.binding.ComponentRequirement;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.javapoet.Expression;
+
+/**
+ * A binding expression for instances bound with {@link dagger.BindsInstance} and instances of
+ * {@linkplain dagger.Component#dependencies() component} and {@linkplain
+ * dagger.producers.ProductionComponent#dependencies() production component dependencies}.
+ */
+final class ComponentRequirementBindingExpression extends SimpleInvocationBindingExpression {
+ private final ComponentRequirement componentRequirement;
+ private final ComponentRequirementExpressions componentRequirementExpressions;
+
+ ComponentRequirementBindingExpression(
+ ContributionBinding binding,
+ ComponentRequirement componentRequirement,
+ ComponentRequirementExpressions componentRequirementExpressions) {
+ super(binding);
+ this.componentRequirement = componentRequirement;
+ this.componentRequirementExpressions = componentRequirementExpressions;
+ }
+
+ @Override
+ Expression getDependencyExpression(ClassName requestingClass) {
+ return Expression.create(
+ componentRequirement.type(),
+ componentRequirementExpressions.getExpression(componentRequirement, requestingClass));
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/ComponentRequirementExpression.java b/java/dagger/internal/codegen/writing/ComponentRequirementExpression.java
new file mode 100644
index 0000000..13008b8
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/ComponentRequirementExpression.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import dagger.internal.codegen.binding.ComponentRequirement;
+
+/**
+ * A factory for expressions of {@link ComponentRequirement}s in the generated component. This is
+ * <em>not</em> a {@link BindingExpression}, since {@link ComponentRequirement}s do not have a
+ * {@link dagger.model.Key}. See {@link ComponentRequirementBindingExpression} for binding
+ * expressions that are themselves a component requirement.
+ */
+interface ComponentRequirementExpression {
+ /**
+ * Returns an expression for the {@link ComponentRequirement} to be used when implementing a
+ * component method. This may add a field or method to the component in order to reference the
+ * component requirement outside of the {@code initialize()} methods.
+ */
+ CodeBlock getExpression(ClassName requestingClass);
+
+ /**
+ * Returns an expression for the {@link ComponentRequirement} to be used only within {@code
+ * initialize()} methods, where the constructor parameters are available.
+ *
+ * <p>When accessing this expression from a subcomponent, this may cause a field to be initialized
+ * or a method to be added in the component that owns this {@link ComponentRequirement}.
+ */
+ default CodeBlock getExpressionDuringInitialization(ClassName requestingClass) {
+ return getExpression(requestingClass);
+ }
+
+ /**
+ * Returns the expression for the {@link ComponentRequirement} to be used when reimplementing a
+ * modifiable module method.
+ */
+ default CodeBlock getModifiableModuleMethodExpression(ClassName requestingClass) {
+ return CodeBlock.of("return $L", getExpression(requestingClass));
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/ComponentRequirementExpressions.java b/java/dagger/internal/codegen/writing/ComponentRequirementExpressions.java
new file mode 100644
index 0000000..653a7a2
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/ComponentRequirementExpressions.java
@@ -0,0 +1,233 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Suppliers.memoize;
+import static dagger.internal.codegen.writing.ComponentImplementation.FieldSpecKind.COMPONENT_REQUIREMENT_FIELD;
+import static javax.lang.model.element.Modifier.FINAL;
+import static javax.lang.model.element.Modifier.PRIVATE;
+
+import com.google.common.base.Supplier;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.TypeName;
+import dagger.internal.codegen.binding.BindingGraph;
+import dagger.internal.codegen.binding.ComponentRequirement;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import javax.inject.Inject;
+import javax.lang.model.element.TypeElement;
+
+/**
+ * A central repository of expressions used to access any {@link ComponentRequirement} available to
+ * a component.
+ */
+@PerComponentImplementation
+public final class ComponentRequirementExpressions {
+
+ // TODO(dpb,ronshapiro): refactor this and ComponentBindingExpressions into a
+ // HierarchicalComponentMap<K, V>, or perhaps this use a flattened ImmutableMap, built from its
+ // parents? If so, maybe make ComponentRequirementExpression.Factory create it.
+
+ private final Optional<ComponentRequirementExpressions> parent;
+ private final Map<ComponentRequirement, ComponentRequirementExpression>
+ componentRequirementExpressions = new HashMap<>();
+ private final BindingGraph graph;
+ private final ComponentImplementation componentImplementation;
+ private final ModuleProxies moduleProxies;
+
+ // TODO(ronshapiro): give ComponentImplementation a graph() method
+ @Inject
+ ComponentRequirementExpressions(
+ @ParentComponent Optional<ComponentRequirementExpressions> parent,
+ BindingGraph graph,
+ ComponentImplementation componentImplementation,
+ DaggerElements elements,
+ ModuleProxies moduleProxies) {
+ this.parent = parent;
+ this.graph = graph;
+ this.componentImplementation = componentImplementation;
+ this.moduleProxies = moduleProxies;
+ }
+
+ /**
+ * Returns an expression for the {@code componentRequirement} to be used when implementing a
+ * component method. This may add a field or method to the component in order to reference the
+ * component requirement outside of the {@code initialize()} methods.
+ */
+ CodeBlock getExpression(ComponentRequirement componentRequirement, ClassName requestingClass) {
+ return getExpression(componentRequirement).getExpression(requestingClass);
+ }
+
+ /**
+ * Returns an expression for the {@code componentRequirement} to be used only within {@code
+ * initialize()} methods, where the component constructor parameters are available.
+ *
+ * <p>When accessing this expression from a subcomponent, this may cause a field to be initialized
+ * or a method to be added in the component that owns this {@link ComponentRequirement}.
+ */
+ CodeBlock getExpressionDuringInitialization(
+ ComponentRequirement componentRequirement, ClassName requestingClass) {
+ return getExpression(componentRequirement).getExpressionDuringInitialization(requestingClass);
+ }
+
+ ComponentRequirementExpression getExpression(ComponentRequirement componentRequirement) {
+ if (graph.componentRequirements().contains(componentRequirement)) {
+ return componentRequirementExpressions.computeIfAbsent(
+ componentRequirement, this::createField);
+ }
+ if (parent.isPresent()) {
+ return parent.get().getExpression(componentRequirement);
+ }
+
+ throw new IllegalStateException(
+ "no component requirement expression found for " + componentRequirement);
+ }
+
+ /** Returns a field for a {@link ComponentRequirement}. */
+ private ComponentRequirementExpression createField(ComponentRequirement requirement) {
+ if (componentImplementation.componentDescriptor().hasCreator()) {
+ return new ComponentParameterField(requirement, componentImplementation, Optional.empty());
+ } else if (graph.factoryMethod().isPresent()
+ && graph.factoryMethodParameters().containsKey(requirement)) {
+ String parameterName =
+ graph.factoryMethodParameters().get(requirement).getSimpleName().toString();
+ return new ComponentParameterField(
+ requirement, componentImplementation, Optional.of(parameterName));
+ } else if (requirement.kind().isModule()) {
+ return new InstantiableModuleField(requirement, componentImplementation);
+ } else {
+ throw new AssertionError(
+ String.format("Can't create %s in %s", requirement, componentImplementation.name()));
+ }
+ }
+
+ private abstract static class AbstractField implements ComponentRequirementExpression {
+ final ComponentRequirement componentRequirement;
+ final ComponentImplementation componentImplementation;
+ final String fieldName;
+ private final Supplier<MemberSelect> field = memoize(this::addField);
+
+ private AbstractField(
+ ComponentRequirement componentRequirement,
+ ComponentImplementation componentImplementation) {
+ this.componentRequirement = checkNotNull(componentRequirement);
+ this.componentImplementation = checkNotNull(componentImplementation);
+ // Note: The field name is being claimed eagerly here even though we don't know at this point
+ // whether or not the requirement will even need a field. This is done because:
+ // A) ComponentParameterField wants to ensure that it doesn't give the parameter the same name
+ // as any field in the component, which requires that it claim a "field name" for itself
+ // when naming the parameter.
+ // B) The parameter name may be needed before the field name is.
+ // C) We want to prefer giving the best name to the field rather than the parameter given its
+ // wider scope.
+ this.fieldName =
+ componentImplementation.getUniqueFieldName(componentRequirement.variableName());
+ }
+
+ @Override
+ public CodeBlock getExpression(ClassName requestingClass) {
+ return field.get().getExpressionFor(requestingClass);
+ }
+
+ private MemberSelect addField() {
+ FieldSpec field = createField();
+ componentImplementation.addField(COMPONENT_REQUIREMENT_FIELD, field);
+ componentImplementation.addComponentRequirementInitialization(fieldInitialization(field));
+ return MemberSelect.localField(componentImplementation.name(), fieldName);
+ }
+
+ private FieldSpec createField() {
+ return FieldSpec.builder(TypeName.get(componentRequirement.type()), fieldName, PRIVATE, FINAL)
+ .build();
+ }
+
+ /** Returns the {@link CodeBlock} that initializes the component field during construction. */
+ abstract CodeBlock fieldInitialization(FieldSpec componentField);
+ }
+
+ /**
+ * A {@link ComponentRequirementExpression} for {@link ComponentRequirement}s that can be
+ * instantiated by the component (i.e. a static class with a no-arg constructor).
+ */
+ private final class InstantiableModuleField extends AbstractField {
+ private final TypeElement moduleElement;
+
+ private InstantiableModuleField(
+ ComponentRequirement module, ComponentImplementation componentImplementation) {
+ super(module, componentImplementation);
+ checkArgument(module.kind().isModule());
+ this.moduleElement = module.typeElement();
+ }
+
+ @Override
+ CodeBlock fieldInitialization(FieldSpec componentField) {
+ return CodeBlock.of(
+ "this.$N = $L;",
+ componentField,
+ moduleProxies.newModuleInstance(moduleElement, componentImplementation.name()));
+ }
+ }
+
+ /**
+ * A {@link ComponentRequirementExpression} for {@link ComponentRequirement}s that are passed in
+ * as parameters to the component's constructor.
+ */
+ private static final class ComponentParameterField extends AbstractField {
+ private final String parameterName;
+
+ private ComponentParameterField(
+ ComponentRequirement componentRequirement,
+ ComponentImplementation componentImplementation,
+ Optional<String> name) {
+ super(componentRequirement, componentImplementation);
+ // Get the name that the component implementation will use for its parameter for the
+ // requirement. If the given name is different than the name of the field created for the
+ // requirement (as may be the case when the parameter name is derived from a user-written
+ // factory method parameter), just use that as the base name for the parameter. Otherwise,
+ // append "Param" to the end of the name to differentiate.
+ // In either case, componentImplementation.getParameterName() will ensure that the final name
+ // that is used is not the same name as any field in the component even if there's something
+ // weird where the component actually has fields named, say, "foo" and "fooParam".
+ String baseName = name.filter(n -> !n.equals(fieldName)).orElse(fieldName + "Param");
+ this.parameterName = componentImplementation.getParameterName(componentRequirement, baseName);
+ }
+
+ @Override
+ public CodeBlock getExpressionDuringInitialization(ClassName requestingClass) {
+ if (componentImplementation.name().equals(requestingClass)) {
+ return CodeBlock.of("$L", parameterName);
+ } else {
+ // requesting this component requirement during initialization of a child component requires
+ // it to be accessed from a field and not the parameter (since it is no longer available)
+ return getExpression(requestingClass);
+ }
+ }
+
+ @Override
+ CodeBlock fieldInitialization(FieldSpec componentField) {
+ // Don't checkNotNull here because the parameter may be nullable; if it isn't, the caller
+ // should handle checking that before passing the parameter.
+ return CodeBlock.of("this.$N = $L;", componentField, parameterName);
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/DelegateBindingExpression.java b/java/dagger/internal/codegen/writing/DelegateBindingExpression.java
new file mode 100644
index 0000000..3361132
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/DelegateBindingExpression.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static dagger.internal.codegen.base.RequestKinds.requestType;
+import static dagger.internal.codegen.binding.BindingRequest.bindingRequest;
+import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
+import static dagger.model.BindingKind.DELEGATE;
+
+import com.squareup.javapoet.ClassName;
+import dagger.internal.codegen.binding.Binding;
+import dagger.internal.codegen.binding.BindingGraph;
+import dagger.internal.codegen.binding.BindsTypeChecker;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.javapoet.Expression;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.RequestKind;
+import javax.lang.model.type.TypeMirror;
+
+/** A {@link dagger.internal.codegen.writing.BindingExpression} for {@code @Binds} methods. */
+final class DelegateBindingExpression extends BindingExpression {
+ private final ContributionBinding binding;
+ private final RequestKind requestKind;
+ private final ComponentBindingExpressions componentBindingExpressions;
+ private final DaggerTypes types;
+ private final BindsTypeChecker bindsTypeChecker;
+
+ DelegateBindingExpression(
+ ContributionBinding binding,
+ RequestKind requestKind,
+ ComponentBindingExpressions componentBindingExpressions,
+ DaggerTypes types,
+ DaggerElements elements) {
+ this.binding = checkNotNull(binding);
+ this.requestKind = checkNotNull(requestKind);
+ this.componentBindingExpressions = checkNotNull(componentBindingExpressions);
+ this.types = checkNotNull(types);
+ this.bindsTypeChecker = new BindsTypeChecker(types, elements);
+ }
+
+ /**
+ * Returns {@code true} if the {@code @Binds} binding's scope is stronger than the scope of the
+ * binding it depends on.
+ */
+ static boolean isBindsScopeStrongerThanDependencyScope(
+ ContributionBinding bindsBinding, BindingGraph graph) {
+ checkArgument(bindsBinding.kind().equals(DELEGATE));
+ Binding dependencyBinding =
+ graph.contributionBinding(getOnlyElement(bindsBinding.dependencies()).key());
+ ScopeKind bindsScope = ScopeKind.get(bindsBinding);
+ ScopeKind dependencyScope = ScopeKind.get(dependencyBinding);
+ return bindsScope.isStrongerScopeThan(dependencyScope);
+ }
+
+ @Override
+ Expression getDependencyExpression(ClassName requestingClass) {
+ Expression delegateExpression =
+ componentBindingExpressions.getDependencyExpression(
+ bindingRequest(getOnlyElement(binding.dependencies()).key(), requestKind),
+ requestingClass);
+
+ TypeMirror contributedType = binding.contributedType();
+ switch (requestKind) {
+ case INSTANCE:
+ return instanceRequiresCast(delegateExpression, requestingClass)
+ ? delegateExpression.castTo(contributedType)
+ : delegateExpression;
+ default:
+ return castToRawTypeIfNecessary(
+ delegateExpression, requestType(requestKind, contributedType, types));
+ }
+ }
+
+ private boolean instanceRequiresCast(Expression delegateExpression, ClassName requestingClass) {
+ // delegateExpression.type() could be Object if expression is satisfied with a raw
+ // Provider's get() method.
+ return !bindsTypeChecker.isAssignable(
+ delegateExpression.type(), binding.contributedType(), binding.contributionType())
+ && isTypeAccessibleFrom(binding.contributedType(), requestingClass.packageName());
+ }
+
+ /**
+ * If {@code delegateExpression} can be assigned to {@code desiredType} safely, then {@code
+ * delegateExpression} is returned unchanged. If the {@code delegateExpression} is already a raw
+ * type, returns {@code delegateExpression} as well, as casting would have no effect. Otherwise,
+ * returns a {@link Expression#castTo(TypeMirror) casted} version of {@code delegateExpression}
+ * to the raw type of {@code desiredType}.
+ */
+ // TODO(ronshapiro): this probably can be generalized for usage in InjectionMethods
+ private Expression castToRawTypeIfNecessary(
+ Expression delegateExpression, TypeMirror desiredType) {
+ if (types.isAssignable(delegateExpression.type(), desiredType)) {
+ return delegateExpression;
+ }
+ return delegateExpression.castTo(types.erasure(desiredType));
+ }
+
+ private enum ScopeKind {
+ UNSCOPED,
+ SINGLE_CHECK,
+ DOUBLE_CHECK,
+ ;
+
+ static ScopeKind get(Binding binding) {
+ return binding
+ .scope()
+ .map(scope -> scope.isReusable() ? SINGLE_CHECK : DOUBLE_CHECK)
+ .orElse(UNSCOPED);
+ }
+
+ boolean isStrongerScopeThan(ScopeKind other) {
+ return this.ordinal() > other.ordinal();
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/DelegatingFrameworkInstanceCreationExpression.java b/java/dagger/internal/codegen/writing/DelegatingFrameworkInstanceCreationExpression.java
new file mode 100644
index 0000000..a7f9556
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/DelegatingFrameworkInstanceCreationExpression.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static dagger.internal.codegen.binding.BindingRequest.bindingRequest;
+
+import com.squareup.javapoet.CodeBlock;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.javapoet.CodeBlocks;
+import dagger.internal.codegen.writing.FrameworkFieldInitializer.FrameworkInstanceCreationExpression;
+import dagger.model.DependencyRequest;
+
+/** A framework instance creation expression for a {@link dagger.Binds @Binds} binding. */
+final class DelegatingFrameworkInstanceCreationExpression
+ implements FrameworkInstanceCreationExpression {
+
+ private final ContributionBinding binding;
+ private final ComponentImplementation componentImplementation;
+ private final ComponentBindingExpressions componentBindingExpressions;
+
+ DelegatingFrameworkInstanceCreationExpression(
+ ContributionBinding binding,
+ ComponentImplementation componentImplementation,
+ ComponentBindingExpressions componentBindingExpressions) {
+ this.binding = checkNotNull(binding);
+ this.componentImplementation = checkNotNull(componentImplementation);
+ this.componentBindingExpressions = checkNotNull(componentBindingExpressions);
+ }
+
+ @Override
+ public CodeBlock creationExpression() {
+ DependencyRequest dependency = getOnlyElement(binding.dependencies());
+ return CodeBlocks.cast(
+ componentBindingExpressions
+ .getDependencyExpression(
+ bindingRequest(dependency.key(), binding.frameworkType()),
+ componentImplementation.name())
+ .codeBlock(),
+ binding.frameworkType().frameworkClass());
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/DependencyMethodProducerCreationExpression.java b/java/dagger/internal/codegen/writing/DependencyMethodProducerCreationExpression.java
new file mode 100644
index 0000000..5ac1e8f
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/DependencyMethodProducerCreationExpression.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.squareup.javapoet.MethodSpec.methodBuilder;
+import static com.squareup.javapoet.TypeSpec.anonymousClassBuilder;
+import static dagger.internal.codegen.javapoet.TypeNames.dependencyMethodProducerOf;
+import static dagger.internal.codegen.javapoet.TypeNames.listenableFutureOf;
+import static javax.lang.model.element.Modifier.FINAL;
+import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.PUBLIC;
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.TypeName;
+import dagger.internal.codegen.binding.BindingGraph;
+import dagger.internal.codegen.binding.ComponentRequirement;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.writing.FrameworkFieldInitializer.FrameworkInstanceCreationExpression;
+
+/**
+ * A {@link dagger.producers.Producer} creation expression for a production method on a production
+ * component's {@linkplain dagger.producers.ProductionComponent#dependencies()} dependency} that
+ * returns a {@link com.google.common.util.concurrent.ListenableFuture}.
+ */
+// TODO(dpb): Resolve with DependencyMethodProviderCreationExpression.
+final class DependencyMethodProducerCreationExpression
+ implements FrameworkInstanceCreationExpression {
+ private final ContributionBinding binding;
+ private final ComponentImplementation componentImplementation;
+ private final ComponentRequirementExpressions componentRequirementExpressions;
+ private final BindingGraph graph;
+
+ DependencyMethodProducerCreationExpression(
+ ContributionBinding binding,
+ ComponentImplementation componentImplementation,
+ ComponentRequirementExpressions componentRequirementExpressions,
+ BindingGraph graph) {
+ this.binding = checkNotNull(binding);
+ this.componentImplementation = checkNotNull(componentImplementation);
+ this.componentRequirementExpressions = checkNotNull(componentRequirementExpressions);
+ this.graph = checkNotNull(graph);
+ }
+
+ @Override
+ public CodeBlock creationExpression() {
+ ComponentRequirement dependency =
+ graph.componentDescriptor().getDependencyThatDefinesMethod(binding.bindingElement().get());
+ FieldSpec dependencyField =
+ FieldSpec.builder(
+ ClassName.get(dependency.typeElement()), dependency.variableName(), PRIVATE, FINAL)
+ .initializer(
+ componentRequirementExpressions.getExpressionDuringInitialization(
+ dependency,
+ // This isn't a real class name, but we want the requesting class for the
+ // expression to *not* be the same class as the component implementation,
+ // because it isn't... it's an anonymous inner class.
+ // TODO(cgdecker): If we didn't use an anonymous inner class here but instead
+ // generated a named nested class as with
+ // DependencyMethodProviderCreationExpression, we wouldn't need to deal with
+ // this and might be able to avoid potentially creating an extra field in the
+ // component?
+ componentImplementation.name().nestedClass("Anonymous")))
+ .build();
+ // TODO(b/70395982): Explore using a private static type instead of an anonymous class.
+ TypeName keyType = TypeName.get(binding.key().type());
+ return CodeBlock.of(
+ "$L",
+ anonymousClassBuilder("")
+ .superclass(dependencyMethodProducerOf(keyType))
+ .addField(dependencyField)
+ .addMethod(
+ methodBuilder("callDependencyMethod")
+ .addAnnotation(Override.class)
+ .addModifiers(PUBLIC)
+ .returns(listenableFutureOf(keyType))
+ .addStatement(
+ "return $N.$L()",
+ dependencyField,
+ binding.bindingElement().get().getSimpleName())
+ .build())
+ .build());
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/DependencyMethodProviderCreationExpression.java b/java/dagger/internal/codegen/writing/DependencyMethodProviderCreationExpression.java
new file mode 100644
index 0000000..5a40c02
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/DependencyMethodProviderCreationExpression.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.squareup.javapoet.MethodSpec.constructorBuilder;
+import static com.squareup.javapoet.MethodSpec.methodBuilder;
+import static com.squareup.javapoet.TypeSpec.classBuilder;
+import static dagger.internal.codegen.javapoet.TypeNames.providerOf;
+import static dagger.internal.codegen.writing.ComponentImplementation.TypeSpecKind.COMPONENT_PROVISION_FACTORY;
+import static javax.lang.model.element.Modifier.FINAL;
+import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.PUBLIC;
+import static javax.lang.model.element.Modifier.STATIC;
+
+import com.google.auto.common.MoreTypes;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.TypeName;
+import dagger.internal.codegen.binding.BindingGraph;
+import dagger.internal.codegen.binding.ComponentRequirement;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.binding.ProvisionBinding;
+import dagger.internal.codegen.compileroption.CompilerOptions;
+import dagger.internal.codegen.writing.FrameworkFieldInitializer.FrameworkInstanceCreationExpression;
+import javax.lang.model.element.Element;
+
+/**
+ * A {@link javax.inject.Provider} creation expression for a provision method on a component's
+ * {@linkplain dagger.Component#dependencies()} dependency}.
+ */
+// TODO(dpb): Resolve with DependencyMethodProducerCreationExpression.
+final class DependencyMethodProviderCreationExpression
+ implements FrameworkInstanceCreationExpression {
+
+ private final ComponentImplementation componentImplementation;
+ private final ComponentRequirementExpressions componentRequirementExpressions;
+ private final CompilerOptions compilerOptions;
+ private final BindingGraph graph;
+ private final ContributionBinding binding;
+
+ DependencyMethodProviderCreationExpression(
+ ContributionBinding binding,
+ ComponentImplementation componentImplementation,
+ ComponentRequirementExpressions componentRequirementExpressions,
+ CompilerOptions compilerOptions,
+ BindingGraph graph) {
+ this.binding = checkNotNull(binding);
+ this.componentImplementation = checkNotNull(componentImplementation);
+ this.componentRequirementExpressions = checkNotNull(componentRequirementExpressions);
+ this.compilerOptions = checkNotNull(compilerOptions);
+ this.graph = checkNotNull(graph);
+ }
+
+ @Override
+ public CodeBlock creationExpression() {
+ // TODO(sameb): The Provider.get() throws a very vague NPE. The stack trace doesn't
+ // help to figure out what the method or return type is. If we include a string
+ // of the return type or method name in the error message, that can defeat obfuscation.
+ // We can easily include the raw type (no generics) + annotation type (no values),
+ // using .class & String.format -- but that wouldn't be the whole story.
+ // What should we do?
+ CodeBlock invocation =
+ ComponentProvisionBindingExpression.maybeCheckForNull(
+ (ProvisionBinding) binding,
+ compilerOptions,
+ CodeBlock.of(
+ "$N.$N()", dependency().variableName(), provisionMethod().getSimpleName()));
+ ClassName dependencyClassName = ClassName.get(dependency().typeElement());
+ TypeName keyType = TypeName.get(binding.key().type());
+ MethodSpec.Builder getMethod =
+ methodBuilder("get")
+ .addAnnotation(Override.class)
+ .addModifiers(PUBLIC)
+ .returns(keyType)
+ .addStatement("return $L", invocation);
+ if (binding.nullableType().isPresent()) {
+ getMethod.addAnnotation(ClassName.get(MoreTypes.asTypeElement(binding.nullableType().get())));
+ }
+ componentImplementation.addType(
+ COMPONENT_PROVISION_FACTORY,
+ classBuilder(factoryClassName())
+ .addSuperinterface(providerOf(keyType))
+ .addModifiers(PRIVATE, STATIC)
+ .addField(dependencyClassName, dependency().variableName(), PRIVATE, FINAL)
+ .addMethod(
+ constructorBuilder()
+ .addParameter(dependencyClassName, dependency().variableName())
+ .addStatement("this.$1L = $1L", dependency().variableName())
+ .build())
+ .addMethod(getMethod.build())
+ .build());
+ return CodeBlock.of(
+ "new $T($L)",
+ factoryClassName(),
+ componentRequirementExpressions.getExpressionDuringInitialization(
+ dependency(), componentImplementation.name()));
+ }
+
+ private ClassName factoryClassName() {
+ String factoryName =
+ ClassName.get(dependency().typeElement()).toString().replace('.', '_')
+ + "_"
+ + binding.bindingElement().get().getSimpleName();
+ return componentImplementation.name().nestedClass(factoryName);
+ }
+
+ private ComponentRequirement dependency() {
+ return graph.componentDescriptor().getDependencyThatDefinesMethod(provisionMethod());
+ }
+
+ private Element provisionMethod() {
+ return binding.bindingElement().get();
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/DerivedFromFrameworkInstanceBindingExpression.java b/java/dagger/internal/codegen/writing/DerivedFromFrameworkInstanceBindingExpression.java
new file mode 100644
index 0000000..6e5dca8
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/DerivedFromFrameworkInstanceBindingExpression.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static dagger.internal.codegen.binding.BindingRequest.bindingRequest;
+
+import com.squareup.javapoet.ClassName;
+import dagger.internal.codegen.binding.BindingRequest;
+import dagger.internal.codegen.binding.ComponentDescriptor.ComponentMethodDescriptor;
+import dagger.internal.codegen.binding.FrameworkType;
+import dagger.internal.codegen.javapoet.Expression;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.Key;
+import dagger.model.RequestKind;
+
+/** A binding expression that depends on a framework instance. */
+final class DerivedFromFrameworkInstanceBindingExpression extends BindingExpression {
+
+ private final BindingRequest frameworkRequest;
+ private final RequestKind requestKind;
+ private final FrameworkType frameworkType;
+ private final ComponentBindingExpressions componentBindingExpressions;
+ private final DaggerTypes types;
+
+ DerivedFromFrameworkInstanceBindingExpression(
+ Key key,
+ FrameworkType frameworkType,
+ RequestKind requestKind,
+ ComponentBindingExpressions componentBindingExpressions,
+ DaggerTypes types) {
+ this.frameworkRequest = bindingRequest(key, frameworkType);
+ this.requestKind = checkNotNull(requestKind);
+ this.frameworkType = checkNotNull(frameworkType);
+ this.componentBindingExpressions = checkNotNull(componentBindingExpressions);
+ this.types = checkNotNull(types);
+ }
+
+ @Override
+ Expression getDependencyExpression(ClassName requestingClass) {
+ return frameworkType.to(
+ requestKind,
+ componentBindingExpressions.getDependencyExpression(frameworkRequest, requestingClass),
+ types);
+ }
+
+ @Override
+ Expression getDependencyExpressionForComponentMethod(
+ ComponentMethodDescriptor componentMethod, ComponentImplementation component) {
+ Expression frameworkInstance =
+ componentBindingExpressions.getDependencyExpressionForComponentMethod(
+ frameworkRequest, componentMethod, component);
+ return frameworkType.to(requestKind, frameworkInstance, types);
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/FactoryGenerator.java b/java/dagger/internal/codegen/writing/FactoryGenerator.java
new file mode 100644
index 0000000..70edd1a
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/FactoryGenerator.java
@@ -0,0 +1,294 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.collect.Maps.transformValues;
+import static com.squareup.javapoet.MethodSpec.constructorBuilder;
+import static com.squareup.javapoet.MethodSpec.methodBuilder;
+import static com.squareup.javapoet.TypeSpec.classBuilder;
+import static dagger.internal.codegen.binding.AssistedInjectionAnnotations.assistedParameters;
+import static dagger.internal.codegen.binding.ContributionBinding.FactoryCreationStrategy.DELEGATE;
+import static dagger.internal.codegen.binding.ContributionBinding.FactoryCreationStrategy.SINGLETON_INSTANCE;
+import static dagger.internal.codegen.binding.SourceFiles.bindingTypeElementTypeVariableNames;
+import static dagger.internal.codegen.binding.SourceFiles.frameworkFieldUsages;
+import static dagger.internal.codegen.binding.SourceFiles.frameworkTypeUsageStatement;
+import static dagger.internal.codegen.binding.SourceFiles.generateBindingFieldsForDependencies;
+import static dagger.internal.codegen.binding.SourceFiles.generatedClassNameForBinding;
+import static dagger.internal.codegen.binding.SourceFiles.parameterizedGeneratedTypeNameForBinding;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
+import static dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression.RAWTYPES;
+import static dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression.UNCHECKED;
+import static dagger.internal.codegen.javapoet.AnnotationSpecs.suppressWarnings;
+import static dagger.internal.codegen.javapoet.CodeBlocks.makeParametersCodeBlock;
+import static dagger.internal.codegen.javapoet.TypeNames.factoryOf;
+import static dagger.internal.codegen.writing.GwtCompatibility.gwtIncompatibleAnnotation;
+import static dagger.model.BindingKind.PROVISION;
+import static javax.lang.model.element.Modifier.FINAL;
+import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.PUBLIC;
+import static javax.lang.model.element.Modifier.STATIC;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Lists;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterSpec;
+import com.squareup.javapoet.TypeName;
+import com.squareup.javapoet.TypeSpec;
+import dagger.internal.Factory;
+import dagger.internal.codegen.base.SourceFileGenerator;
+import dagger.internal.codegen.base.UniqueNameSet;
+import dagger.internal.codegen.binding.ProvisionBinding;
+import dagger.internal.codegen.compileroption.CompilerOptions;
+import dagger.internal.codegen.javapoet.CodeBlocks;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.internal.codegen.writing.InjectionMethods.InjectionSiteMethod;
+import dagger.internal.codegen.writing.InjectionMethods.ProvisionMethod;
+import dagger.model.BindingKind;
+import dagger.model.DependencyRequest;
+import java.util.List;
+import java.util.Optional;
+import javax.annotation.processing.Filer;
+import javax.inject.Inject;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Element;
+
+/**
+ * Generates {@link Factory} implementations from {@link ProvisionBinding} instances for {@link
+ * Inject} constructors.
+ */
+public final class FactoryGenerator extends SourceFileGenerator<ProvisionBinding> {
+ private final DaggerTypes types;
+ private final CompilerOptions compilerOptions;
+ private final KotlinMetadataUtil metadataUtil;
+
+ @Inject
+ FactoryGenerator(
+ Filer filer,
+ SourceVersion sourceVersion,
+ DaggerTypes types,
+ DaggerElements elements,
+ CompilerOptions compilerOptions,
+ KotlinMetadataUtil metadataUtil) {
+ super(filer, elements, sourceVersion);
+ this.types = types;
+ this.compilerOptions = compilerOptions;
+ this.metadataUtil = metadataUtil;
+ }
+
+ @Override
+ public ClassName nameGeneratedType(ProvisionBinding binding) {
+ return generatedClassNameForBinding(binding);
+ }
+
+ @Override
+ public Element originatingElement(ProvisionBinding binding) {
+ // we only create factories for bindings that have a binding element
+ return binding.bindingElement().get();
+ }
+
+ @Override
+ public Optional<TypeSpec.Builder> write(ProvisionBinding binding) {
+ // We don't want to write out resolved bindings -- we want to write out the generic version.
+ checkArgument(!binding.unresolved().isPresent());
+ checkArgument(binding.bindingElement().isPresent());
+
+ if (binding.factoryCreationStrategy().equals(DELEGATE)) {
+ return Optional.empty();
+ }
+
+ return Optional.of(factoryBuilder(binding));
+ }
+
+ private TypeSpec.Builder factoryBuilder(ProvisionBinding binding) {
+ TypeSpec.Builder factoryBuilder =
+ classBuilder(nameGeneratedType(binding))
+ .addModifiers(PUBLIC, FINAL)
+ .addTypeVariables(bindingTypeElementTypeVariableNames(binding));
+
+ factoryTypeName(binding).ifPresent(factoryBuilder::addSuperinterface);
+ addConstructorAndFields(binding, factoryBuilder);
+ factoryBuilder.addMethod(getMethod(binding));
+ addCreateMethod(binding, factoryBuilder);
+
+ factoryBuilder.addMethod(ProvisionMethod.create(binding, compilerOptions, metadataUtil));
+ gwtIncompatibleAnnotation(binding).ifPresent(factoryBuilder::addAnnotation);
+
+ return factoryBuilder;
+ }
+
+ private void addConstructorAndFields(ProvisionBinding binding, TypeSpec.Builder factoryBuilder) {
+ if (binding.factoryCreationStrategy().equals(SINGLETON_INSTANCE)) {
+ return;
+ }
+ // TODO(bcorso): Make the constructor private?
+ MethodSpec.Builder constructor = constructorBuilder().addModifiers(PUBLIC);
+ constructorParams(binding).forEach(
+ param -> {
+ constructor.addParameter(param).addStatement("this.$1N = $1N", param);
+ factoryBuilder.addField(
+ FieldSpec.builder(param.type, param.name, PRIVATE, FINAL).build());
+ });
+ factoryBuilder.addMethod(constructor.build());
+ }
+
+ private ImmutableList<ParameterSpec> constructorParams(ProvisionBinding binding) {
+ ImmutableList.Builder<ParameterSpec> params = ImmutableList.builder();
+ moduleParameter(binding).ifPresent(params::add);
+ frameworkFields(binding).values().forEach(field -> params.add(toParameter(field)));
+ return params.build();
+ }
+
+ private Optional<ParameterSpec> moduleParameter(ProvisionBinding binding) {
+ if (binding.requiresModuleInstance()) {
+ // TODO(bcorso, dpb): Should this use contributingModule()?
+ TypeName type = TypeName.get(binding.bindingTypeElement().get().asType());
+ return Optional.of(ParameterSpec.builder(type, "module").build());
+ }
+ return Optional.empty();
+ }
+
+ private ImmutableMap<DependencyRequest, FieldSpec> frameworkFields(ProvisionBinding binding) {
+ UniqueNameSet uniqueFieldNames = new UniqueNameSet();
+ // TODO(bcorso, dpb): Add a test for the case when a Factory parameter is named "module".
+ moduleParameter(binding).ifPresent(module -> uniqueFieldNames.claim(module.name));
+ return ImmutableMap.copyOf(
+ transformValues(
+ generateBindingFieldsForDependencies(binding),
+ field ->
+ FieldSpec.builder(
+ field.type(), uniqueFieldNames.getUniqueName(field.name()), PRIVATE, FINAL)
+ .build()));
+ }
+
+ private void addCreateMethod(ProvisionBinding binding, TypeSpec.Builder factoryBuilder) {
+ // If constructing a factory for @Inject or @Provides bindings, we use a static create method
+ // so that generated components can avoid having to refer to the generic types
+ // of the factory. (Otherwise they may have visibility problems referring to the types.)
+ MethodSpec.Builder createMethodBuilder =
+ methodBuilder("create")
+ .addModifiers(PUBLIC, STATIC)
+ .returns(parameterizedGeneratedTypeNameForBinding(binding))
+ .addTypeVariables(bindingTypeElementTypeVariableNames(binding));
+
+ switch (binding.factoryCreationStrategy()) {
+ case SINGLETON_INSTANCE:
+ FieldSpec.Builder instanceFieldBuilder =
+ FieldSpec.builder(nameGeneratedType(binding), "INSTANCE", PRIVATE, STATIC, FINAL)
+ .initializer("new $T()", nameGeneratedType(binding));
+
+ if (!bindingTypeElementTypeVariableNames(binding).isEmpty()) {
+ // If the factory has type parameters, ignore them in the field declaration & initializer
+ instanceFieldBuilder.addAnnotation(suppressWarnings(RAWTYPES));
+ createMethodBuilder.addAnnotation(suppressWarnings(UNCHECKED));
+ }
+
+ ClassName instanceHolderName = nameGeneratedType(binding).nestedClass("InstanceHolder");
+ createMethodBuilder.addStatement("return $T.INSTANCE", instanceHolderName);
+ factoryBuilder.addType(
+ TypeSpec.classBuilder(instanceHolderName)
+ .addModifiers(PRIVATE, STATIC, FINAL)
+ .addField(instanceFieldBuilder.build())
+ .build());
+ break;
+ case CLASS_CONSTRUCTOR:
+ List<ParameterSpec> params = constructorParams(binding);
+ createMethodBuilder.addParameters(params);
+ createMethodBuilder.addStatement(
+ "return new $T($L)",
+ parameterizedGeneratedTypeNameForBinding(binding),
+ makeParametersCodeBlock(Lists.transform(params, input -> CodeBlock.of("$N", input))));
+ break;
+ default:
+ throw new AssertionError();
+ }
+ factoryBuilder.addMethod(createMethodBuilder.build());
+ }
+
+ private MethodSpec getMethod(ProvisionBinding binding) {
+ TypeName providedTypeName = providedTypeName(binding);
+ MethodSpec.Builder getMethod =
+ methodBuilder("get")
+ .addModifiers(PUBLIC)
+ .returns(providedTypeName)
+ .addParameters(
+ // The 'get' method for an assisted injection type takes in the assisted parameters.
+ assistedParameters(binding).stream()
+ .map(ParameterSpec::get)
+ .collect(toImmutableList()));
+
+ if (factoryTypeName(binding).isPresent()) {
+ getMethod.addAnnotation(Override.class);
+ }
+
+ ImmutableMap<DependencyRequest, FieldSpec> frameworkFields = frameworkFields(binding);
+ CodeBlock invokeNewInstance =
+ ProvisionMethod.invoke(
+ binding,
+ request ->
+ frameworkTypeUsageStatement(
+ CodeBlock.of("$N", frameworkFields.get(request)), request.kind()),
+ nameGeneratedType(binding),
+ moduleParameter(binding).map(module -> CodeBlock.of("$N", module)),
+ compilerOptions,
+ metadataUtil);
+
+ if (binding.kind().equals(PROVISION)) {
+ binding
+ .nullableType()
+ .ifPresent(nullableType -> CodeBlocks.addAnnotation(getMethod, nullableType));
+ getMethod.addStatement("return $L", invokeNewInstance);
+ } else if (!binding.injectionSites().isEmpty()) {
+ CodeBlock instance = CodeBlock.of("instance");
+ getMethod
+ .addStatement("$T $L = $L", providedTypeName, instance, invokeNewInstance)
+ .addCode(
+ InjectionSiteMethod.invokeAll(
+ binding.injectionSites(),
+ nameGeneratedType(binding),
+ instance,
+ binding.key().type(),
+ frameworkFieldUsages(binding.dependencies(), frameworkFields)::get,
+ types,
+ metadataUtil))
+ .addStatement("return $L", instance);
+ } else {
+ getMethod.addStatement("return $L", invokeNewInstance);
+ }
+ return getMethod.build();
+ }
+
+ private static TypeName providedTypeName(ProvisionBinding binding) {
+ return TypeName.get(binding.contributedType());
+ }
+
+ private static Optional<TypeName> factoryTypeName(ProvisionBinding binding) {
+ return binding.kind() == BindingKind.ASSISTED_INJECTION
+ ? Optional.empty()
+ : Optional.of(factoryOf(providedTypeName(binding)));
+ }
+
+ private static ParameterSpec toParameter(FieldSpec field) {
+ return ParameterSpec.builder(field.type, field.name).build();
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/FrameworkFieldInitializer.java b/java/dagger/internal/codegen/writing/FrameworkFieldInitializer.java
new file mode 100644
index 0000000..c17ff8e
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/FrameworkFieldInitializer.java
@@ -0,0 +1,210 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static dagger.internal.codegen.binding.SourceFiles.generatedClassNameForBinding;
+import static dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression.RAWTYPES;
+import static dagger.internal.codegen.writing.ComponentImplementation.FieldSpecKind.FRAMEWORK_FIELD;
+import static javax.lang.model.element.Modifier.PRIVATE;
+
+import com.google.auto.common.MoreTypes;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.ParameterizedTypeName;
+import com.squareup.javapoet.TypeName;
+import dagger.internal.DelegateFactory;
+import dagger.internal.codegen.binding.BindingType;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.binding.FrameworkField;
+import dagger.internal.codegen.javapoet.AnnotationSpecs;
+import dagger.internal.codegen.javapoet.TypeNames;
+import dagger.model.BindingKind;
+import dagger.producers.internal.DelegateProducer;
+import java.util.Optional;
+
+/**
+ * An object that can initialize a framework-type component field for a binding. An instance should
+ * be created for each field.
+ */
+class FrameworkFieldInitializer implements FrameworkInstanceSupplier {
+
+ /**
+ * An object that can determine the expression to use to assign to the component field for a
+ * binding.
+ */
+ interface FrameworkInstanceCreationExpression {
+ /** Returns the expression to use to assign to the component field for the binding. */
+ CodeBlock creationExpression();
+
+ /**
+ * Returns the framework class to use for the field, if different from the one implied by the
+ * binding. This implementation returns {@link Optional#empty()}.
+ */
+ default Optional<ClassName> alternativeFrameworkClass() {
+ return Optional.empty();
+ }
+
+ /**
+ * Returns {@code true} if instead of using {@link #creationExpression()} to create a framework
+ * instance, a case in {@link InnerSwitchingProviders} should be created for this binding.
+ */
+ // TODO(ronshapiro): perhaps this isn't the right approach. Instead of saying "Use
+ // SetFactory.EMPTY because you will only get 1 class for all types of bindings that use
+ // SetFactory", maybe we should still use an inner switching provider but the same switching
+ // provider index for all cases.
+ default boolean useInnerSwitchingProvider() {
+ return true;
+ }
+ }
+
+ private final ComponentImplementation componentImplementation;
+ private final ContributionBinding binding;
+ private final FrameworkInstanceCreationExpression frameworkInstanceCreationExpression;
+ private FieldSpec fieldSpec;
+ private InitializationState fieldInitializationState = InitializationState.UNINITIALIZED;
+
+ FrameworkFieldInitializer(
+ ComponentImplementation componentImplementation,
+ ContributionBinding binding,
+ FrameworkInstanceCreationExpression frameworkInstanceCreationExpression) {
+ this.componentImplementation = checkNotNull(componentImplementation);
+ this.binding = checkNotNull(binding);
+ this.frameworkInstanceCreationExpression = checkNotNull(frameworkInstanceCreationExpression);
+ }
+
+ /**
+ * Returns the {@link MemberSelect} for the framework field, and adds the field and its
+ * initialization code to the component if it's needed and not already added.
+ */
+ @Override
+ public final MemberSelect memberSelect() {
+ initializeField();
+ return MemberSelect.localField(componentImplementation.name(), checkNotNull(fieldSpec).name);
+ }
+
+ /** Adds the field and its initialization code to the component. */
+ private void initializeField() {
+ switch (fieldInitializationState) {
+ case UNINITIALIZED:
+ // Change our state in case we are recursively invoked via initializeBindingExpression
+ fieldInitializationState = InitializationState.INITIALIZING;
+ CodeBlock.Builder codeBuilder = CodeBlock.builder();
+ CodeBlock fieldInitialization = frameworkInstanceCreationExpression.creationExpression();
+ CodeBlock initCode = CodeBlock.of("this.$N = $L;", getOrCreateField(), fieldInitialization);
+
+ if (fieldInitializationState == InitializationState.DELEGATED) {
+ codeBuilder.add(
+ "$T.setDelegate($N, $L);", delegateType(), fieldSpec, fieldInitialization);
+ } else {
+ codeBuilder.add(initCode);
+ }
+ componentImplementation.addInitialization(codeBuilder.build());
+
+ fieldInitializationState = InitializationState.INITIALIZED;
+ break;
+
+ case INITIALIZING:
+ // We were recursively invoked, so create a delegate factory instead
+ fieldInitializationState = InitializationState.DELEGATED;
+ componentImplementation.addInitialization(
+ CodeBlock.of("this.$N = new $T<>();", getOrCreateField(), delegateType()));
+ break;
+
+ case DELEGATED:
+ case INITIALIZED:
+ break;
+ }
+ }
+
+ /**
+ * Adds a field representing the resolved bindings, optionally forcing it to use a particular
+ * binding type (instead of the type the resolved bindings would typically use).
+ */
+ private FieldSpec getOrCreateField() {
+ if (fieldSpec != null) {
+ return fieldSpec;
+ }
+ boolean useRawType = !componentImplementation.isTypeAccessible(binding.key().type());
+ FrameworkField contributionBindingField =
+ FrameworkField.forBinding(
+ binding, frameworkInstanceCreationExpression.alternativeFrameworkClass());
+
+ TypeName fieldType =
+ useRawType ? contributionBindingField.type().rawType : contributionBindingField.type();
+
+ if (binding.kind() == BindingKind.ASSISTED_INJECTION) {
+ // An assisted injection factory doesn't extend Provider, so we reference the generated
+ // factory type directly (i.e. Foo_Factory<T> instead of Provider<Foo<T>>).
+ TypeName[] typeParameters =
+ MoreTypes.asDeclared(binding.key().type()).getTypeArguments().stream()
+ .map(TypeName::get)
+ .toArray(TypeName[]::new);
+ fieldType =
+ typeParameters.length == 0
+ ? generatedClassNameForBinding(binding)
+ : ParameterizedTypeName.get(generatedClassNameForBinding(binding), typeParameters);
+ }
+
+ FieldSpec.Builder contributionField =
+ FieldSpec.builder(
+ fieldType, componentImplementation.getUniqueFieldName(contributionBindingField.name()));
+ contributionField.addModifiers(PRIVATE);
+ if (useRawType) {
+ contributionField.addAnnotation(AnnotationSpecs.suppressWarnings(RAWTYPES));
+ }
+
+ fieldSpec = contributionField.build();
+ componentImplementation.addField(FRAMEWORK_FIELD, fieldSpec);
+
+ return fieldSpec;
+ }
+
+ private Class<?> delegateType() {
+ return isProvider() ? DelegateFactory.class : DelegateProducer.class;
+ }
+
+ private boolean isProvider() {
+ return binding.bindingType().equals(BindingType.PROVISION)
+ && frameworkInstanceCreationExpression
+ .alternativeFrameworkClass()
+ .map(TypeNames.PROVIDER::equals)
+ .orElse(true);
+ }
+
+ /** Initialization state for a factory field. */
+ private enum InitializationState {
+ /** The field is {@code null}. */
+ UNINITIALIZED,
+
+ /**
+ * The field's dependencies are being set up. If the field is needed in this state, use a {@link
+ * DelegateFactory}.
+ */
+ INITIALIZING,
+
+ /**
+ * The field's dependencies are being set up, but the field can be used because it has already
+ * been set to a {@link DelegateFactory}.
+ */
+ DELEGATED,
+
+ /** The field is set to an undelegated factory. */
+ INITIALIZED;
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/FrameworkInstanceBindingExpression.java b/java/dagger/internal/codegen/writing/FrameworkInstanceBindingExpression.java
new file mode 100644
index 0000000..56a6ef3
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/FrameworkInstanceBindingExpression.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.FieldSpec;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.binding.FrameworkType;
+import dagger.internal.codegen.javapoet.Expression;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeMirror;
+
+/** A binding expression that uses a {@link FrameworkType} field. */
+abstract class FrameworkInstanceBindingExpression extends BindingExpression {
+ private final ContributionBinding binding;
+ private final FrameworkInstanceSupplier frameworkInstanceSupplier;
+ private final DaggerTypes types;
+ private final DaggerElements elements;
+
+ FrameworkInstanceBindingExpression(
+ ContributionBinding binding,
+ FrameworkInstanceSupplier frameworkInstanceSupplier,
+ DaggerTypes types,
+ DaggerElements elements) {
+ this.binding = checkNotNull(binding);
+ this.frameworkInstanceSupplier = checkNotNull(frameworkInstanceSupplier);
+ this.types = checkNotNull(types);
+ this.elements = checkNotNull(elements);
+ }
+
+ /**
+ * The expression for the framework instance for this binding. The field will be {@link
+ * ComponentImplementation#addInitialization(CodeBlock) initialized} and {@link
+ * ComponentImplementation#addField(ComponentImplementation.FieldSpecKind, FieldSpec) added} to
+ * the component the first time this method is invoked.
+ */
+ @Override
+ Expression getDependencyExpression(ClassName requestingClass) {
+ MemberSelect memberSelect = frameworkInstanceSupplier.memberSelect();
+ TypeMirror expressionType =
+ isTypeAccessibleFrom(binding.contributedType(), requestingClass.packageName())
+ || isInlinedFactoryCreation(memberSelect)
+ ? types.wrapType(binding.contributedType(), frameworkType().frameworkClass())
+ : rawFrameworkType();
+ return Expression.create(expressionType, memberSelect.getExpressionFor(requestingClass));
+ }
+
+ /** Returns the framework type for the binding. */
+ protected abstract FrameworkType frameworkType();
+
+ /**
+ * Returns {@code true} if a factory is created inline each time it is requested. For example, in
+ * the initialization {@code this.fooProvider = Foo_Factory.create(Bar_Factory.create());}, {@code
+ * Bar_Factory} is considered to be inline.
+ *
+ * <p>This is used in {@link #getDependencyExpression(ClassName)} when determining the type of a
+ * factory. Normally if the {@link ContributionBinding#contributedType()} is not accessible from
+ * the component, the type of the expression will be a raw {@link javax.inject.Provider}. However,
+ * if the factory is created inline, even if contributed type is not accessible, javac will still
+ * be able to determine the type that is returned from the {@code Foo_Factory.create()} method.
+ */
+ private static boolean isInlinedFactoryCreation(MemberSelect memberSelect) {
+ return memberSelect.staticMember();
+ }
+
+ private DeclaredType rawFrameworkType() {
+ return types.getDeclaredType(elements.getTypeElement(frameworkType().frameworkClass()));
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/FrameworkInstanceSupplier.java b/java/dagger/internal/codegen/writing/FrameworkInstanceSupplier.java
new file mode 100644
index 0000000..cc0e136
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/FrameworkInstanceSupplier.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+/** An object that supplies a {@link MemberSelect} for a framework instance. */
+interface FrameworkInstanceSupplier {
+ /** Returns a {@link MemberSelect}, with possible side effects on the first call. */
+ MemberSelect memberSelect();
+}
diff --git a/java/dagger/internal/codegen/writing/GwtCompatibility.java b/java/dagger/internal/codegen/writing/GwtCompatibility.java
new file mode 100644
index 0000000..2df6a99
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/GwtCompatibility.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import com.squareup.javapoet.AnnotationSpec;
+import dagger.internal.codegen.binding.Binding;
+import java.util.Optional;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.Name;
+
+final class GwtCompatibility {
+
+ /**
+ * Returns a {@code @GwtIncompatible} annotation that is applied to {@code binding}'s {@link
+ * Binding#bindingElement()} or any enclosing type.
+ */
+ static Optional<AnnotationSpec> gwtIncompatibleAnnotation(Binding binding) {
+ checkArgument(binding.bindingElement().isPresent());
+ Element element = binding.bindingElement().get();
+ while (element != null) {
+ Optional<AnnotationSpec> gwtIncompatible =
+ element
+ .getAnnotationMirrors()
+ .stream()
+ .filter(annotation -> isGwtIncompatible(annotation))
+ .map(AnnotationSpec::get)
+ .findFirst();
+ if (gwtIncompatible.isPresent()) {
+ return gwtIncompatible;
+ }
+ element = element.getEnclosingElement();
+ }
+ return Optional.empty();
+ }
+
+ private static boolean isGwtIncompatible(AnnotationMirror annotation) {
+ Name simpleName = annotation.getAnnotationType().asElement().getSimpleName();
+ return simpleName.contentEquals("GwtIncompatible");
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/HjarSourceFileGenerator.java b/java/dagger/internal/codegen/writing/HjarSourceFileGenerator.java
new file mode 100644
index 0000000..5a4b6f1
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/HjarSourceFileGenerator.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.squareup.javapoet.MethodSpec.constructorBuilder;
+import static com.squareup.javapoet.MethodSpec.methodBuilder;
+import static com.squareup.javapoet.TypeSpec.classBuilder;
+import static javax.lang.model.element.Modifier.PRIVATE;
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.TypeSpec;
+import dagger.internal.codegen.base.SourceFileGenerator;
+import java.util.Optional;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.Modifier;
+
+/**
+ * A source file generator that only writes the relevant code necessary for Bazel to create a
+ * correct header (ABI) jar.
+ */
+public final class HjarSourceFileGenerator<T> extends SourceFileGenerator<T> {
+ private final SourceFileGenerator<T> delegate;
+
+ private HjarSourceFileGenerator(SourceFileGenerator<T> delegate) {
+ super(delegate);
+ this.delegate = delegate;
+ }
+
+ public static <T> SourceFileGenerator<T> wrap(SourceFileGenerator<T> delegate) {
+ return new HjarSourceFileGenerator<>(delegate);
+ }
+
+ @Override
+ public ClassName nameGeneratedType(T input) {
+ return delegate.nameGeneratedType(input);
+ }
+
+ @Override
+ public Element originatingElement(T input) {
+ return delegate.originatingElement(input);
+ }
+
+ @Override
+ public Optional<TypeSpec.Builder> write(T input) {
+ return delegate.write(input).map(completeType -> skeletonType(completeType.build()));
+ }
+
+ private TypeSpec.Builder skeletonType(TypeSpec completeType) {
+ TypeSpec.Builder skeleton =
+ classBuilder(completeType.name)
+ .addSuperinterfaces(completeType.superinterfaces)
+ .addTypeVariables(completeType.typeVariables)
+ .addModifiers(completeType.modifiers.toArray(new Modifier[0]))
+ .addAnnotations(completeType.annotations);
+
+ if (!completeType.superclass.equals(ClassName.OBJECT)) {
+ skeleton.superclass(completeType.superclass);
+ }
+
+ completeType.methodSpecs.stream()
+ .filter(method -> !method.modifiers.contains(PRIVATE) || method.isConstructor())
+ .map(this::skeletonMethod)
+ .forEach(skeleton::addMethod);
+
+ completeType.fieldSpecs.stream()
+ .filter(field -> !field.modifiers.contains(PRIVATE))
+ .map(this::skeletonField)
+ .forEach(skeleton::addField);
+
+ completeType.typeSpecs.stream()
+ .map(type -> skeletonType(type).build())
+ .forEach(skeleton::addType);
+
+ return skeleton;
+ }
+
+ private MethodSpec skeletonMethod(MethodSpec completeMethod) {
+ MethodSpec.Builder skeleton =
+ completeMethod.isConstructor()
+ ? constructorBuilder()
+ : methodBuilder(completeMethod.name).returns(completeMethod.returnType);
+
+ if (completeMethod.isConstructor()) {
+ // Code in Turbine must (for technical reasons in javac) have a valid super() call for
+ // constructors, otherwise javac will bark, and Turbine has no way to avoid this. So we retain
+ // constructor method bodies if they do exist
+ skeleton.addCode(completeMethod.code);
+ }
+
+ return skeleton
+ .addModifiers(completeMethod.modifiers)
+ .addTypeVariables(completeMethod.typeVariables)
+ .addParameters(completeMethod.parameters)
+ .addExceptions(completeMethod.exceptions)
+ .varargs(completeMethod.varargs)
+ .addAnnotations(completeMethod.annotations)
+ .build();
+ }
+
+ private FieldSpec skeletonField(FieldSpec completeField) {
+ return FieldSpec.builder(
+ completeField.type,
+ completeField.name,
+ completeField.modifiers.toArray(new Modifier[0]))
+ .addAnnotations(completeField.annotations)
+ .build();
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/ImmediateFutureBindingExpression.java b/java/dagger/internal/codegen/writing/ImmediateFutureBindingExpression.java
new file mode 100644
index 0000000..dcd02fa
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/ImmediateFutureBindingExpression.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static dagger.internal.codegen.binding.BindingRequest.bindingRequest;
+
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import dagger.internal.codegen.javapoet.Expression;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.Key;
+import dagger.model.RequestKind;
+import javax.lang.model.SourceVersion;
+
+final class ImmediateFutureBindingExpression extends BindingExpression {
+ private final Key key;
+ private final ComponentBindingExpressions componentBindingExpressions;
+ private final DaggerTypes types;
+ private final SourceVersion sourceVersion;
+
+ ImmediateFutureBindingExpression(
+ Key key,
+ ComponentBindingExpressions componentBindingExpressions,
+ DaggerTypes types,
+ SourceVersion sourceVersion) {
+ this.key = key;
+ this.componentBindingExpressions = checkNotNull(componentBindingExpressions);
+ this.types = checkNotNull(types);
+ this.sourceVersion = checkNotNull(sourceVersion);
+ }
+
+ @Override
+ Expression getDependencyExpression(ClassName requestingClass) {
+ return Expression.create(
+ types.wrapType(key.type(), ListenableFuture.class),
+ CodeBlock.of("$T.immediateFuture($L)", Futures.class, instanceExpression(requestingClass)));
+ }
+
+ private CodeBlock instanceExpression(ClassName requestingClass) {
+ Expression expression =
+ componentBindingExpressions.getDependencyExpression(
+ bindingRequest(key, RequestKind.INSTANCE), requestingClass);
+ if (sourceVersion.compareTo(SourceVersion.RELEASE_7) <= 0) {
+ // Java 7 type inference is not as strong as in Java 8, and therefore some generated code must
+ // cast.
+ //
+ // For example, javac7 cannot detect that Futures.immediateFuture(ImmutableSet.of("T"))
+ // can safely be assigned to ListenableFuture<Set<T>>.
+ if (!types.isSameType(expression.type(), key.type())) {
+ return CodeBlock.of(
+ "($T) $L", types.accessibleType(key.type(), requestingClass), expression.codeBlock());
+ }
+ }
+ return expression.codeBlock();
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/InaccessibleMapKeyProxyGenerator.java b/java/dagger/internal/codegen/writing/InaccessibleMapKeyProxyGenerator.java
new file mode 100644
index 0000000..d527359
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/InaccessibleMapKeyProxyGenerator.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.squareup.javapoet.MethodSpec.constructorBuilder;
+import static com.squareup.javapoet.TypeSpec.classBuilder;
+import static javax.lang.model.element.Modifier.FINAL;
+import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.PUBLIC;
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.TypeSpec;
+import dagger.internal.codegen.base.SourceFileGenerator;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.binding.MapKeys;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import java.util.Optional;
+import javax.annotation.processing.Filer;
+import javax.inject.Inject;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Element;
+
+/**
+ * Generates a class that exposes a non-{@code public} {@link
+ * ContributionBinding#mapKeyAnnotation()} @MapKey} annotation.
+ */
+public final class InaccessibleMapKeyProxyGenerator
+ extends SourceFileGenerator<ContributionBinding> {
+ private final DaggerTypes types;
+ private final DaggerElements elements;
+
+ @Inject
+ InaccessibleMapKeyProxyGenerator(
+ Filer filer, DaggerTypes types, DaggerElements elements, SourceVersion sourceVersion) {
+ super(filer, elements, sourceVersion);
+ this.types = types;
+ this.elements = elements;
+ }
+
+ @Override
+ public ClassName nameGeneratedType(ContributionBinding binding) {
+ return MapKeys.mapKeyProxyClassName(binding);
+ }
+
+ @Override
+ public Element originatingElement(ContributionBinding binding) {
+ // a map key is only ever present on bindings that have a binding element
+ return binding.bindingElement().get();
+ }
+
+ @Override
+ public Optional<TypeSpec.Builder> write(ContributionBinding binding) {
+ return MapKeys.mapKeyFactoryMethod(binding, types, elements)
+ .map(
+ method ->
+ classBuilder(nameGeneratedType(binding))
+ .addModifiers(PUBLIC, FINAL)
+ .addMethod(constructorBuilder().addModifiers(PRIVATE).build())
+ .addMethod(method));
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/InjectionMethods.java b/java/dagger/internal/codegen/writing/InjectionMethods.java
new file mode 100644
index 0000000..7cebc10
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/InjectionMethods.java
@@ -0,0 +1,571 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.auto.common.MoreElements.asExecutable;
+import static com.google.auto.common.MoreElements.asType;
+import static com.google.auto.common.MoreElements.asVariable;
+import static com.google.common.base.CaseFormat.LOWER_CAMEL;
+import static com.google.common.base.CaseFormat.UPPER_CAMEL;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.squareup.javapoet.MethodSpec.methodBuilder;
+import static dagger.internal.codegen.base.RequestKinds.requestTypeName;
+import static dagger.internal.codegen.binding.ConfigurationAnnotations.getNullableType;
+import static dagger.internal.codegen.binding.SourceFiles.generatedClassNameForBinding;
+import static dagger.internal.codegen.binding.SourceFiles.memberInjectedFieldSignatureForVariable;
+import static dagger.internal.codegen.binding.SourceFiles.membersInjectorNameForType;
+import static dagger.internal.codegen.binding.SourceFiles.protectAgainstKeywords;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableMap;
+import static dagger.internal.codegen.javapoet.CodeBlocks.makeParametersCodeBlock;
+import static dagger.internal.codegen.javapoet.CodeBlocks.toConcatenatedCodeBlock;
+import static dagger.internal.codegen.javapoet.CodeBlocks.toParametersCodeBlock;
+import static dagger.internal.codegen.javapoet.TypeNames.rawTypeName;
+import static dagger.internal.codegen.langmodel.Accessibility.isElementAccessibleFrom;
+import static dagger.internal.codegen.langmodel.Accessibility.isRawTypeAccessible;
+import static dagger.internal.codegen.langmodel.Accessibility.isRawTypePubliclyAccessible;
+import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
+import static java.util.stream.Collectors.toList;
+import static javax.lang.model.element.Modifier.PUBLIC;
+import static javax.lang.model.element.Modifier.STATIC;
+import static javax.lang.model.type.TypeKind.VOID;
+
+import com.google.auto.common.MoreElements;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.squareup.javapoet.AnnotationSpec;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterSpec;
+import com.squareup.javapoet.TypeName;
+import com.squareup.javapoet.TypeVariableName;
+import dagger.internal.Preconditions;
+import dagger.internal.codegen.base.UniqueNameSet;
+import dagger.internal.codegen.binding.AssistedInjectionAnnotations;
+import dagger.internal.codegen.binding.MembersInjectionBinding.InjectionSite;
+import dagger.internal.codegen.binding.ProvisionBinding;
+import dagger.internal.codegen.compileroption.CompilerOptions;
+import dagger.internal.codegen.extension.DaggerCollectors;
+import dagger.internal.codegen.javapoet.CodeBlocks;
+import dagger.internal.codegen.javapoet.TypeNames;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.DependencyRequest;
+import dagger.model.RequestKind;
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Function;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.Parameterizable;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeMirror;
+
+/** Convenience methods for creating and invoking {@link InjectionMethod}s. */
+final class InjectionMethods {
+
+ /**
+ * A method that returns an object from a {@code @Provides} method or an {@code @Inject}ed
+ * constructor. Its parameters match the dependency requests for constructor and members
+ * injection.
+ *
+ * <p>For {@code @Provides} methods named "foo", the method name is "proxyFoo". For example:
+ *
+ * <pre><code>
+ * abstract class FooModule {
+ * {@literal @Provides} static Foo provideFoo(Bar bar, Baz baz) { … }
+ * }
+ *
+ * public static proxyProvideFoo(Bar bar, Baz baz) { … }
+ * </code></pre>
+ *
+ * <p>For {@code @Inject}ed constructors, the method name is "newFoo". For example:
+ *
+ * <pre><code>
+ * class Foo {
+ * {@literal @Inject} Foo(Bar bar) {}
+ * }
+ *
+ * public static Foo newFoo(Bar bar) { … }
+ * </code></pre>
+ */
+ static final class ProvisionMethod {
+ // These names are already defined in factories and shouldn't be used for the proxy method name.
+ private static final ImmutableSet<String> BANNED_PROXY_NAMES = ImmutableSet.of("get", "create");
+
+ /**
+ * Returns a method that invokes the binding's {@linkplain ProvisionBinding#bindingElement()
+ * constructor} and injects the instance's members.
+ */
+ static MethodSpec create(
+ ProvisionBinding binding,
+ CompilerOptions compilerOptions,
+ KotlinMetadataUtil metadataUtil) {
+ ExecutableElement element = asExecutable(binding.bindingElement().get());
+ switch (element.getKind()) {
+ case CONSTRUCTOR:
+ return constructorProxy(element);
+ case METHOD:
+ return methodProxy(
+ element,
+ methodName(element),
+ InstanceCastPolicy.IGNORE,
+ CheckNotNullPolicy.get(binding, compilerOptions),
+ metadataUtil);
+ default:
+ throw new AssertionError(element);
+ }
+ }
+
+ /**
+ * Invokes the injection method for {@code binding}, with the dependencies transformed with the
+ * {@code dependencyUsage} function.
+ */
+ static CodeBlock invoke(
+ ProvisionBinding binding,
+ Function<DependencyRequest, CodeBlock> dependencyUsage,
+ ClassName requestingClass,
+ Optional<CodeBlock> moduleReference,
+ CompilerOptions compilerOptions,
+ KotlinMetadataUtil metadataUtil) {
+ ImmutableList.Builder<CodeBlock> arguments = ImmutableList.builder();
+ moduleReference.ifPresent(arguments::add);
+ invokeArguments(binding, dependencyUsage, requestingClass).forEach(arguments::add);
+
+ ClassName enclosingClass = generatedClassNameForBinding(binding);
+ MethodSpec methodSpec = create(binding, compilerOptions, metadataUtil);
+ return invokeMethod(methodSpec, arguments.build(), enclosingClass, requestingClass);
+ }
+
+ static ImmutableList<CodeBlock> invokeArguments(
+ ProvisionBinding binding,
+ Function<DependencyRequest, CodeBlock> dependencyUsage,
+ ClassName requestingClass) {
+ ImmutableMap<VariableElement, DependencyRequest> dependencyRequestMap =
+ binding.provisionDependencies().stream()
+ .collect(
+ toImmutableMap(
+ request -> MoreElements.asVariable(request.requestElement().get()),
+ request -> request));
+
+ ImmutableList.Builder<CodeBlock> arguments = ImmutableList.builder();
+ for (VariableElement parameter :
+ asExecutable(binding.bindingElement().get()).getParameters()) {
+ if (AssistedInjectionAnnotations.isAssistedParameter(parameter)) {
+ arguments.add(CodeBlock.of("$L", parameter.getSimpleName()));
+ } else if (dependencyRequestMap.containsKey(parameter)) {
+ DependencyRequest request = dependencyRequestMap.get(parameter);
+ arguments.add(
+ injectionMethodArgument(request, dependencyUsage.apply(request), requestingClass));
+ } else {
+ throw new AssertionError("Unexpected parameter: " + parameter);
+ }
+ }
+
+ return arguments.build();
+ }
+
+ private static MethodSpec constructorProxy(ExecutableElement constructor) {
+ TypeElement enclosingType = MoreElements.asType(constructor.getEnclosingElement());
+ MethodSpec.Builder builder =
+ methodBuilder(methodName(constructor))
+ .addModifiers(PUBLIC, STATIC)
+ .varargs(constructor.isVarArgs())
+ .returns(TypeName.get(enclosingType.asType()));
+
+ copyTypeParameters(builder, enclosingType);
+ copyThrows(builder, constructor);
+
+ CodeBlock arguments =
+ copyParameters(builder, new UniqueNameSet(), constructor.getParameters());
+ return builder.addStatement("return new $T($L)", enclosingType, arguments).build();
+ }
+
+ /**
+ * Returns {@code true} if injecting an instance of {@code binding} from {@code callingPackage}
+ * requires the use of an injection method.
+ */
+ static boolean requiresInjectionMethod(
+ ProvisionBinding binding, CompilerOptions compilerOptions, ClassName requestingClass) {
+ ExecutableElement method = MoreElements.asExecutable(binding.bindingElement().get());
+ return !binding.injectionSites().isEmpty()
+ || binding.shouldCheckForNull(compilerOptions)
+ || !isElementAccessibleFrom(method, requestingClass.packageName())
+ // This check should be removable once we drop support for -source 7
+ || method.getParameters().stream()
+ .map(VariableElement::asType)
+ .anyMatch(type -> !isRawTypeAccessible(type, requestingClass.packageName()));
+ }
+
+ /**
+ * Returns the name of the {@code static} method that wraps {@code method}. For methods that are
+ * associated with {@code @Inject} constructors, the method will also inject all {@link
+ * InjectionSite}s.
+ */
+ private static String methodName(ExecutableElement method) {
+ switch (method.getKind()) {
+ case CONSTRUCTOR:
+ return "newInstance";
+ case METHOD:
+ String methodName = method.getSimpleName().toString();
+ return BANNED_PROXY_NAMES.contains(methodName)
+ ? "proxy" + LOWER_CAMEL.to(UPPER_CAMEL, methodName)
+ : methodName;
+ default:
+ throw new AssertionError(method);
+ }
+ }
+ }
+
+ /**
+ * A static method that injects one member of an instance of a type. Its first parameter is an
+ * instance of the type to be injected. The remaining parameters match the dependency requests for
+ * the injection site.
+ *
+ * <p>Example:
+ *
+ * <pre><code>
+ * class Foo {
+ * {@literal @Inject} Bar bar;
+ * {@literal @Inject} void setThings(Baz baz, Qux qux) {}
+ * }
+ *
+ * public static injectBar(Foo instance, Bar bar) { … }
+ * public static injectSetThings(Foo instance, Baz baz, Qux qux) { … }
+ * </code></pre>
+ */
+ static final class InjectionSiteMethod {
+ /**
+ * When a type has an inaccessible member from a supertype (e.g. an @Inject field in a parent
+ * that's in a different package), a method in the supertype's package must be generated to give
+ * the subclass's members injector a way to inject it. Each potentially inaccessible member
+ * receives its own method, as the subclass may need to inject them in a different order from
+ * the parent class.
+ */
+ static MethodSpec create(InjectionSite injectionSite, KotlinMetadataUtil metadataUtil) {
+ String methodName = methodName(injectionSite);
+ switch (injectionSite.kind()) {
+ case METHOD:
+ return methodProxy(
+ asExecutable(injectionSite.element()),
+ methodName,
+ InstanceCastPolicy.CAST_IF_NOT_PUBLIC,
+ CheckNotNullPolicy.IGNORE,
+ metadataUtil);
+ case FIELD:
+ Optional<AnnotationMirror> qualifier =
+ injectionSite.dependencies().stream()
+ // methods for fields have a single dependency request
+ .collect(DaggerCollectors.onlyElement())
+ .key()
+ .qualifier();
+ return fieldProxy(asVariable(injectionSite.element()), methodName, qualifier);
+ }
+ throw new AssertionError(injectionSite);
+ }
+
+ /**
+ * Invokes each of the injection methods for {@code injectionSites}, with the dependencies
+ * transformed using the {@code dependencyUsage} function.
+ *
+ * @param instanceType the type of the {@code instance} parameter
+ */
+ static CodeBlock invokeAll(
+ ImmutableSet<InjectionSite> injectionSites,
+ ClassName generatedTypeName,
+ CodeBlock instanceCodeBlock,
+ TypeMirror instanceType,
+ Function<DependencyRequest, CodeBlock> dependencyUsage,
+ DaggerTypes types,
+ KotlinMetadataUtil metadataUtil) {
+ return injectionSites.stream()
+ .map(
+ injectionSite -> {
+ TypeMirror injectSiteType =
+ types.erasure(injectionSite.element().getEnclosingElement().asType());
+
+ // If instance has been declared as Object because it is not accessible from the
+ // component, but the injectionSite is in a supertype of instanceType that is
+ // publicly accessible, the InjectionSiteMethod will request the actual type and not
+ // Object as the first parameter. If so, cast to the supertype which is accessible
+ // from within generatedTypeName
+ CodeBlock maybeCastedInstance =
+ !types.isSubtype(instanceType, injectSiteType)
+ && isTypeAccessibleFrom(injectSiteType, generatedTypeName.packageName())
+ ? CodeBlock.of("($T) $L", injectSiteType, instanceCodeBlock)
+ : instanceCodeBlock;
+ return CodeBlock.of(
+ "$L;",
+ invoke(
+ injectionSite,
+ generatedTypeName,
+ maybeCastedInstance,
+ dependencyUsage,
+ metadataUtil));
+ })
+ .collect(toConcatenatedCodeBlock());
+ }
+
+ /**
+ * Invokes the injection method for {@code injectionSite}, with the dependencies transformed
+ * using the {@code dependencyUsage} function.
+ */
+ private static CodeBlock invoke(
+ InjectionSite injectionSite,
+ ClassName generatedTypeName,
+ CodeBlock instanceCodeBlock,
+ Function<DependencyRequest, CodeBlock> dependencyUsage,
+ KotlinMetadataUtil metadataUtil) {
+ ImmutableList.Builder<CodeBlock> arguments = ImmutableList.builder();
+ arguments.add(instanceCodeBlock);
+ if (!injectionSite.dependencies().isEmpty()) {
+ arguments.addAll(
+ injectionSite.dependencies().stream().map(dependencyUsage).collect(toList()));
+ }
+
+ ClassName enclosingClass =
+ membersInjectorNameForType(asType(injectionSite.element().getEnclosingElement()));
+ MethodSpec methodSpec = create(injectionSite, metadataUtil);
+ return invokeMethod(methodSpec, arguments.build(), enclosingClass, generatedTypeName);
+ }
+
+ /*
+ * TODO(ronshapiro): this isn't perfect, as collisions could still exist. Some examples:
+ *
+ * - @Inject void members() {} will generate a method that conflicts with the instance
+ * method `injectMembers(T)`
+ * - Adding the index could conflict with another member:
+ * @Inject void a(Object o) {}
+ * @Inject void a(String s) {}
+ * @Inject void a1(String s) {}
+ *
+ * Here, Method a(String) will add the suffix "1", which will conflict with the method
+ * generated for a1(String)
+ * - Members named "members" or "methods" could also conflict with the {@code static} injection
+ * method.
+ */
+ private static String methodName(InjectionSite injectionSite) {
+ int index = injectionSite.indexAmongAtInjectMembersWithSameSimpleName();
+ String indexString = index == 0 ? "" : String.valueOf(index + 1);
+ return "inject"
+ + LOWER_CAMEL.to(UPPER_CAMEL, injectionSite.element().getSimpleName().toString())
+ + indexString;
+ }
+ }
+
+ private static CodeBlock injectionMethodArgument(
+ DependencyRequest dependency, CodeBlock argument, ClassName generatedTypeName) {
+ TypeMirror keyType = dependency.key().type();
+ CodeBlock.Builder codeBlock = CodeBlock.builder();
+ if (!isRawTypeAccessible(keyType, generatedTypeName.packageName())
+ && isTypeAccessibleFrom(keyType, generatedTypeName.packageName())) {
+ if (!dependency.kind().equals(RequestKind.INSTANCE)) {
+ TypeName usageTypeName = accessibleType(dependency);
+ codeBlock.add("($T) ($T)", usageTypeName, rawTypeName(usageTypeName));
+ } else if (dependency.requestElement().get().asType().getKind().equals(TypeKind.TYPEVAR)) {
+ codeBlock.add("($T)", keyType);
+ }
+ }
+ return codeBlock.add(argument).build();
+ }
+
+ /**
+ * Returns the parameter type for {@code dependency}. If the raw type is not accessible, returns
+ * {@link Object}.
+ */
+ private static TypeName accessibleType(DependencyRequest dependency) {
+ TypeName typeName = requestTypeName(dependency.kind(), accessibleType(dependency.key().type()));
+ return dependency
+ .requestElement()
+ .map(element -> element.asType().getKind().isPrimitive())
+ .orElse(false)
+ ? typeName.unbox()
+ : typeName;
+ }
+
+ /**
+ * Returns the accessible type for {@code type}. If the raw type is not accessible, returns {@link
+ * Object}.
+ */
+ private static TypeName accessibleType(TypeMirror type) {
+ return isRawTypePubliclyAccessible(type) ? TypeName.get(type) : TypeName.OBJECT;
+ }
+
+ private enum InstanceCastPolicy {
+ CAST_IF_NOT_PUBLIC, IGNORE;
+
+ boolean useObjectType(TypeMirror instanceType) {
+ return this == CAST_IF_NOT_PUBLIC && !isRawTypePubliclyAccessible(instanceType);
+ }
+ }
+
+ private enum CheckNotNullPolicy {
+ IGNORE, CHECK_FOR_NULL;
+
+ CodeBlock checkForNull(CodeBlock maybeNull) {
+ return this.equals(IGNORE)
+ ? maybeNull
+ : CodeBlock.of("$T.checkNotNullFromProvides($L)", Preconditions.class, maybeNull);
+ }
+
+ static CheckNotNullPolicy get(ProvisionBinding binding, CompilerOptions compilerOptions) {
+ return binding.shouldCheckForNull(compilerOptions) ? CHECK_FOR_NULL : IGNORE;
+ }
+ }
+
+ private static MethodSpec methodProxy(
+ ExecutableElement method,
+ String methodName,
+ InstanceCastPolicy instanceCastPolicy,
+ CheckNotNullPolicy checkNotNullPolicy,
+ KotlinMetadataUtil metadataUtil) {
+ MethodSpec.Builder builder =
+ methodBuilder(methodName).addModifiers(PUBLIC, STATIC).varargs(method.isVarArgs());
+
+ TypeElement enclosingType = asType(method.getEnclosingElement());
+ boolean isMethodInKotlinObject = metadataUtil.isObjectClass(enclosingType);
+ boolean isMethodInKotlinCompanionObject = metadataUtil.isCompanionObjectClass(enclosingType);
+ UniqueNameSet parameterNameSet = new UniqueNameSet();
+ CodeBlock instance;
+ if (isMethodInKotlinCompanionObject || method.getModifiers().contains(STATIC)) {
+ instance = CodeBlock.of("$T", rawTypeName(TypeName.get(enclosingType.asType())));
+ } else if (isMethodInKotlinObject) {
+ // Call through the singleton instance.
+ // See: https://kotlinlang.org/docs/reference/java-to-kotlin-interop.html#static-methods
+ instance = CodeBlock.of("$T.INSTANCE", rawTypeName(TypeName.get(enclosingType.asType())));
+ } else {
+ copyTypeParameters(builder, enclosingType);
+ boolean useObject = instanceCastPolicy.useObjectType(enclosingType.asType());
+ instance = copyInstance(builder, parameterNameSet, enclosingType.asType(), useObject);
+ }
+ CodeBlock arguments = copyParameters(builder, parameterNameSet, method.getParameters());
+ CodeBlock invocation =
+ checkNotNullPolicy.checkForNull(
+ CodeBlock.of("$L.$L($L)", instance, method.getSimpleName(), arguments));
+
+ copyTypeParameters(builder, method);
+ copyThrows(builder, method);
+
+ if (method.getReturnType().getKind().equals(VOID)) {
+ return builder.addStatement("$L", invocation).build();
+ } else {
+ getNullableType(method)
+ .ifPresent(annotation -> CodeBlocks.addAnnotation(builder, annotation));
+ return builder
+ .returns(TypeName.get(method.getReturnType()))
+ .addStatement("return $L", invocation).build();
+ }
+ }
+
+ private static MethodSpec fieldProxy(
+ VariableElement field, String methodName, Optional<AnnotationMirror> qualifierAnnotation) {
+ MethodSpec.Builder builder =
+ methodBuilder(methodName)
+ .addModifiers(PUBLIC, STATIC)
+ .addAnnotation(
+ AnnotationSpec.builder(TypeNames.INJECTED_FIELD_SIGNATURE)
+ .addMember("value", "$S", memberInjectedFieldSignatureForVariable(field))
+ .build());
+
+ qualifierAnnotation.map(AnnotationSpec::get).ifPresent(builder::addAnnotation);
+
+ TypeElement enclosingType = asType(field.getEnclosingElement());
+ copyTypeParameters(builder, enclosingType);
+
+ boolean useObject = !isRawTypePubliclyAccessible(enclosingType.asType());
+ UniqueNameSet parameterNameSet = new UniqueNameSet();
+ CodeBlock instance = copyInstance(builder, parameterNameSet, enclosingType.asType(), useObject);
+ CodeBlock argument = copyParameters(builder, parameterNameSet, ImmutableList.of(field));
+ return builder.addStatement("$L.$L = $L", instance, field.getSimpleName(), argument).build();
+ }
+
+ private static CodeBlock invokeMethod(
+ MethodSpec methodSpec,
+ ImmutableList<CodeBlock> parameters,
+ ClassName enclosingClass,
+ ClassName requestingClass) {
+ checkArgument(methodSpec.parameters.size() == parameters.size());
+ CodeBlock parameterBlock = makeParametersCodeBlock(parameters);
+ return enclosingClass.equals(requestingClass)
+ ? CodeBlock.of("$L($L)", methodSpec.name, parameterBlock)
+ : CodeBlock.of("$T.$L($L)", enclosingClass, methodSpec.name, parameterBlock);
+ }
+
+ private static void copyTypeParameters(
+ MethodSpec.Builder methodBuilder, Parameterizable element) {
+ element.getTypeParameters().stream()
+ .map(TypeVariableName::get)
+ .forEach(methodBuilder::addTypeVariable);
+ }
+
+ private static void copyThrows(MethodSpec.Builder methodBuilder, ExecutableElement method) {
+ method.getThrownTypes().stream().map(TypeName::get).forEach(methodBuilder::addException);
+ }
+
+ private static CodeBlock copyParameters(
+ MethodSpec.Builder methodBuilder,
+ UniqueNameSet parameterNameSet,
+ List<? extends VariableElement> parameters) {
+ return parameters.stream()
+ .map(
+ parameter -> {
+ String name =
+ parameterNameSet.getUniqueName(validJavaName(parameter.getSimpleName()));
+ TypeMirror type = parameter.asType();
+ boolean useObject = !isRawTypePubliclyAccessible(type);
+ return copyParameter(methodBuilder, type, name, useObject);
+ })
+ .collect(toParametersCodeBlock());
+ }
+
+ private static CodeBlock copyParameter(
+ MethodSpec.Builder methodBuilder, TypeMirror type, String name, boolean useObject) {
+ TypeName typeName = useObject ? TypeName.OBJECT : TypeName.get(type);
+ methodBuilder.addParameter(ParameterSpec.builder(typeName, name).build());
+ return useObject ? CodeBlock.of("($T) $L", type, name) : CodeBlock.of("$L", name);
+ }
+
+ private static CodeBlock copyInstance(
+ MethodSpec.Builder methodBuilder,
+ UniqueNameSet parameterNameSet,
+ TypeMirror type,
+ boolean useObject) {
+ CodeBlock instance =
+ copyParameter(methodBuilder, type, parameterNameSet.getUniqueName("instance"), useObject);
+ // If we had to cast the instance add an extra parenthesis incase we're calling a method on it.
+ return useObject ? CodeBlock.of("($L)", instance) : instance;
+ }
+
+ private static String validJavaName(CharSequence name) {
+ if (SourceVersion.isIdentifier(name)) {
+ return protectAgainstKeywords(name.toString());
+ }
+
+ StringBuilder newName = new StringBuilder(name.length());
+ char firstChar = name.charAt(0);
+ if (!Character.isJavaIdentifierStart(firstChar)) {
+ newName.append('_');
+ }
+
+ name.chars().forEach(c -> newName.append(Character.isJavaIdentifierPart(c) ? c : '_'));
+ return newName.toString();
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/InjectionOrProvisionProviderCreationExpression.java b/java/dagger/internal/codegen/writing/InjectionOrProvisionProviderCreationExpression.java
new file mode 100644
index 0000000..b5135b0
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/InjectionOrProvisionProviderCreationExpression.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static dagger.internal.codegen.binding.SourceFiles.generatedClassNameForBinding;
+import static dagger.model.BindingKind.INJECTION;
+
+import com.squareup.javapoet.CodeBlock;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.javapoet.CodeBlocks;
+import dagger.internal.codegen.writing.FrameworkFieldInitializer.FrameworkInstanceCreationExpression;
+import javax.inject.Provider;
+
+/**
+ * A {@link Provider} creation expression for an {@link javax.inject.Inject @Inject}-constructed
+ * class or a {@link dagger.Provides @Provides}-annotated module method.
+ */
+// TODO(dpb): Resolve with ProducerCreationExpression.
+final class InjectionOrProvisionProviderCreationExpression
+ implements FrameworkInstanceCreationExpression {
+
+ private final ContributionBinding binding;
+ private final ComponentBindingExpressions componentBindingExpressions;
+
+ InjectionOrProvisionProviderCreationExpression(
+ ContributionBinding binding, ComponentBindingExpressions componentBindingExpressions) {
+ this.binding = checkNotNull(binding);
+ this.componentBindingExpressions = checkNotNull(componentBindingExpressions);
+ }
+
+ @Override
+ public CodeBlock creationExpression() {
+ CodeBlock createFactory =
+ CodeBlock.of(
+ "$T.create($L)",
+ generatedClassNameForBinding(binding),
+ componentBindingExpressions.getCreateMethodArgumentsCodeBlock(binding));
+
+ // When scoping a parameterized factory for an @Inject class, Java 7 cannot always infer the
+ // type properly, so cast to a raw framework type before scoping.
+ if (binding.kind().equals(INJECTION)
+ && binding.unresolved().isPresent()
+ && binding.scope().isPresent()) {
+ return CodeBlocks.cast(createFactory, Provider.class);
+ } else {
+ return createFactory;
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/InnerSwitchingProviders.java b/java/dagger/internal/codegen/writing/InnerSwitchingProviders.java
new file mode 100644
index 0000000..c2f9893
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/InnerSwitchingProviders.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.squareup.javapoet.MethodSpec.constructorBuilder;
+import static dagger.internal.codegen.binding.BindingRequest.bindingRequest;
+import static dagger.model.RequestKind.INSTANCE;
+import static javax.lang.model.element.Modifier.FINAL;
+import static javax.lang.model.element.Modifier.PRIVATE;
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.TypeName;
+import com.squareup.javapoet.TypeSpec;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.javapoet.Expression;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.Key;
+import javax.inject.Provider;
+import javax.lang.model.type.TypeMirror;
+
+/**
+ * Generates {@linkplain BindingExpression binding expressions} for a binding that is represented by
+ * an inner {@code SwitchingProvider} class.
+ */
+final class InnerSwitchingProviders extends SwitchingProviders {
+ private final ComponentBindingExpressions componentBindingExpressions;
+ private final DaggerTypes types;
+
+ InnerSwitchingProviders(
+ ComponentImplementation componentImplementation,
+ ComponentBindingExpressions componentBindingExpressions,
+ DaggerTypes types) {
+ super(componentImplementation, types);
+ this.componentBindingExpressions = componentBindingExpressions;
+ this.types = types;
+ }
+
+ /**
+ * Returns the binding expression for a binding that satisfies a {@link Provider} requests with a
+ * inner {@code SwitchingProvider} class.
+ */
+ BindingExpression newBindingExpression(ContributionBinding binding) {
+ return new BindingExpression() {
+ @Override
+ Expression getDependencyExpression(ClassName requestingClass) {
+ return getProviderExpression(new SwitchCase(binding, requestingClass));
+ }
+ };
+ }
+
+ @Override
+ protected TypeSpec createSwitchingProviderType(TypeSpec.Builder builder) {
+ return builder
+ .addModifiers(PRIVATE, FINAL)
+ .addField(TypeName.INT, "id", PRIVATE, FINAL)
+ .addMethod(
+ constructorBuilder()
+ .addParameter(TypeName.INT, "id")
+ .addStatement("this.id = id")
+ .build())
+ .build();
+ }
+
+ private final class SwitchCase implements SwitchingProviders.SwitchCase {
+ private final ContributionBinding binding;
+ private final ClassName requestingClass;
+
+ SwitchCase(ContributionBinding binding, ClassName requestingClass) {
+ this.binding = binding;
+ this.requestingClass = requestingClass;
+ }
+
+ @Override
+ public Key key() {
+ return binding.key();
+ }
+
+ @Override
+ public Expression getProviderExpression(ClassName switchingProviderClass, int switchId) {
+ TypeMirror instanceType = types.accessibleType(binding.contributedType(), requestingClass);
+ return Expression.create(
+ types.wrapType(instanceType, Provider.class),
+ CodeBlock.of("new $T<>($L)", switchingProviderClass, switchId));
+ }
+
+ @Override
+ public Expression getReturnExpression(ClassName switchingProviderClass) {
+ return componentBindingExpressions.getDependencyExpression(
+ bindingRequest(binding.key(), INSTANCE), switchingProviderClass);
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/InstanceFactoryCreationExpression.java b/java/dagger/internal/codegen/writing/InstanceFactoryCreationExpression.java
new file mode 100644
index 0000000..a7d6685
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/InstanceFactoryCreationExpression.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.squareup.javapoet.CodeBlock;
+import dagger.internal.InstanceFactory;
+import dagger.internal.codegen.writing.FrameworkFieldInitializer.FrameworkInstanceCreationExpression;
+import java.util.function.Supplier;
+
+/**
+ * A {@link FrameworkInstanceCreationExpression} that creates an {@link InstanceFactory} for an
+ * instance.
+ */
+final class InstanceFactoryCreationExpression implements FrameworkInstanceCreationExpression {
+
+ private final boolean nullable;
+ private final Supplier<CodeBlock> instanceExpression;
+
+ InstanceFactoryCreationExpression(Supplier<CodeBlock> instanceExpression) {
+ this(false, instanceExpression);
+ }
+
+ InstanceFactoryCreationExpression(boolean nullable, Supplier<CodeBlock> instanceExpression) {
+ this.nullable = nullable;
+ this.instanceExpression = checkNotNull(instanceExpression);
+ }
+
+ @Override
+ public CodeBlock creationExpression() {
+ return CodeBlock.of(
+ "$T.$L($L)",
+ InstanceFactory.class,
+ nullable ? "createNullable" : "create",
+ instanceExpression.get());
+ }
+
+ @Override
+ public boolean useInnerSwitchingProvider() {
+ return false;
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/MapBindingExpression.java b/java/dagger/internal/codegen/writing/MapBindingExpression.java
new file mode 100644
index 0000000..255e85d
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/MapBindingExpression.java
@@ -0,0 +1,170 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static dagger.internal.codegen.binding.BindingRequest.bindingRequest;
+import static dagger.internal.codegen.binding.MapKeys.getMapKeyExpression;
+import static dagger.internal.codegen.javapoet.CodeBlocks.toParametersCodeBlock;
+import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
+import static dagger.model.BindingKind.MULTIBOUND_MAP;
+import static javax.lang.model.util.ElementFilter.methodsIn;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Maps;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import dagger.internal.MapBuilder;
+import dagger.internal.codegen.base.MapType;
+import dagger.internal.codegen.binding.BindingGraph;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.binding.ProvisionBinding;
+import dagger.internal.codegen.javapoet.Expression;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.BindingKind;
+import dagger.model.DependencyRequest;
+import java.util.Collections;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeMirror;
+
+/** A {@link BindingExpression} for multibound maps. */
+final class MapBindingExpression extends SimpleInvocationBindingExpression {
+ /** Maximum number of key-value pairs that can be passed to ImmutableMap.of(K, V, K, V, ...). */
+ private static final int MAX_IMMUTABLE_MAP_OF_KEY_VALUE_PAIRS = 5;
+
+ private final ProvisionBinding binding;
+ private final ImmutableMap<DependencyRequest, ContributionBinding> dependencies;
+ private final ComponentBindingExpressions componentBindingExpressions;
+ private final DaggerTypes types;
+ private final DaggerElements elements;
+
+ MapBindingExpression(
+ ProvisionBinding binding,
+ BindingGraph graph,
+ ComponentBindingExpressions componentBindingExpressions,
+ DaggerTypes types,
+ DaggerElements elements) {
+ super(binding);
+ this.binding = binding;
+ BindingKind bindingKind = this.binding.kind();
+ checkArgument(bindingKind.equals(MULTIBOUND_MAP), bindingKind);
+ this.componentBindingExpressions = componentBindingExpressions;
+ this.types = types;
+ this.elements = elements;
+ this.dependencies =
+ Maps.toMap(binding.dependencies(), dep -> graph.contributionBinding(dep.key()));
+ }
+
+ @Override
+ Expression getDependencyExpression(ClassName requestingClass) {
+ // TODO(ronshapiro): We should also make an ImmutableMap version of MapFactory
+ boolean isImmutableMapAvailable = isImmutableMapAvailable();
+ // TODO(ronshapiro, gak): Use Maps.immutableEnumMap() if it's available?
+ if (isImmutableMapAvailable && dependencies.size() <= MAX_IMMUTABLE_MAP_OF_KEY_VALUE_PAIRS) {
+ return Expression.create(
+ immutableMapType(),
+ CodeBlock.builder()
+ .add("$T.", ImmutableMap.class)
+ .add(maybeTypeParameters(requestingClass))
+ .add(
+ "of($L)",
+ dependencies
+ .keySet()
+ .stream()
+ .map(dependency -> keyAndValueExpression(dependency, requestingClass))
+ .collect(toParametersCodeBlock()))
+ .build());
+ }
+ switch (dependencies.size()) {
+ case 0:
+ return collectionsStaticFactoryInvocation(requestingClass, CodeBlock.of("emptyMap()"));
+ case 1:
+ return collectionsStaticFactoryInvocation(
+ requestingClass,
+ CodeBlock.of(
+ "singletonMap($L)",
+ keyAndValueExpression(getOnlyElement(dependencies.keySet()), requestingClass)));
+ default:
+ CodeBlock.Builder instantiation = CodeBlock.builder();
+ instantiation
+ .add("$T.", isImmutableMapAvailable ? ImmutableMap.class : MapBuilder.class)
+ .add(maybeTypeParameters(requestingClass));
+ if (isImmutableMapBuilderWithExpectedSizeAvailable()) {
+ instantiation.add("builderWithExpectedSize($L)", dependencies.size());
+ } else if (isImmutableMapAvailable) {
+ instantiation.add("builder()");
+ } else {
+ instantiation.add("newMapBuilder($L)", dependencies.size());
+ }
+ for (DependencyRequest dependency : dependencies.keySet()) {
+ instantiation.add(".put($L)", keyAndValueExpression(dependency, requestingClass));
+ }
+ return Expression.create(
+ isImmutableMapAvailable ? immutableMapType() : binding.key().type(),
+ instantiation.add(".build()").build());
+ }
+ }
+
+ private DeclaredType immutableMapType() {
+ MapType mapType = MapType.from(binding.key());
+ return types.getDeclaredType(
+ elements.getTypeElement(ImmutableMap.class), mapType.keyType(), mapType.valueType());
+ }
+
+ private CodeBlock keyAndValueExpression(DependencyRequest dependency, ClassName requestingClass) {
+ return CodeBlock.of(
+ "$L, $L",
+ getMapKeyExpression(dependencies.get(dependency), requestingClass, elements),
+ componentBindingExpressions
+ .getDependencyExpression(bindingRequest(dependency), requestingClass)
+ .codeBlock());
+ }
+
+ private Expression collectionsStaticFactoryInvocation(
+ ClassName requestingClass, CodeBlock methodInvocation) {
+ return Expression.create(
+ binding.key().type(),
+ CodeBlock.builder()
+ .add("$T.", Collections.class)
+ .add(maybeTypeParameters(requestingClass))
+ .add(methodInvocation)
+ .build());
+ }
+
+ private CodeBlock maybeTypeParameters(ClassName requestingClass) {
+ TypeMirror bindingKeyType = binding.key().type();
+ MapType mapType = MapType.from(binding.key());
+ return isTypeAccessibleFrom(bindingKeyType, requestingClass.packageName())
+ ? CodeBlock.of("<$T, $T>", mapType.keyType(), mapType.valueType())
+ : CodeBlock.of("");
+ }
+
+ private boolean isImmutableMapBuilderWithExpectedSizeAvailable() {
+ if (isImmutableMapAvailable()) {
+ return methodsIn(elements.getTypeElement(ImmutableMap.class).getEnclosedElements())
+ .stream()
+ .anyMatch(method -> method.getSimpleName().contentEquals("builderWithExpectedSize"));
+ }
+ return false;
+ }
+
+ private boolean isImmutableMapAvailable() {
+ return elements.getTypeElement(ImmutableMap.class) != null;
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/MapFactoryCreationExpression.java b/java/dagger/internal/codegen/writing/MapFactoryCreationExpression.java
new file mode 100644
index 0000000..104d48a
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/MapFactoryCreationExpression.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static dagger.internal.codegen.binding.MapKeys.getMapKeyExpression;
+import static dagger.internal.codegen.binding.SourceFiles.mapFactoryClassName;
+
+import com.google.common.collect.ImmutableSet;
+import com.squareup.javapoet.CodeBlock;
+import dagger.internal.codegen.base.MapType;
+import dagger.internal.codegen.binding.BindingGraph;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.model.DependencyRequest;
+import dagger.producers.Produced;
+import dagger.producers.Producer;
+import javax.inject.Provider;
+import javax.lang.model.type.TypeMirror;
+
+/** A factory creation expression for a multibound map. */
+final class MapFactoryCreationExpression extends MultibindingFactoryCreationExpression {
+
+ private final ComponentImplementation componentImplementation;
+ private final BindingGraph graph;
+ private final ContributionBinding binding;
+ private final DaggerElements elements;
+
+ MapFactoryCreationExpression(
+ ContributionBinding binding,
+ ComponentImplementation componentImplementation,
+ ComponentBindingExpressions componentBindingExpressions,
+ BindingGraph graph,
+ DaggerElements elements) {
+ super(binding, componentImplementation, componentBindingExpressions);
+ this.binding = checkNotNull(binding);
+ this.componentImplementation = checkNotNull(componentImplementation);
+ this.graph = checkNotNull(graph);
+ this.elements = checkNotNull(elements);
+ }
+
+ @Override
+ public CodeBlock creationExpression() {
+ CodeBlock.Builder builder = CodeBlock.builder().add("$T.", mapFactoryClassName(binding));
+ if (!useRawType()) {
+ MapType mapType = MapType.from(binding.key().type());
+ // TODO(ronshapiro): either inline this into mapFactoryClassName, or add a
+ // mapType.unwrappedValueType() method that doesn't require a framework type
+ TypeMirror valueType = mapType.valueType();
+ for (Class<?> frameworkClass :
+ ImmutableSet.of(Provider.class, Producer.class, Produced.class)) {
+ if (mapType.valuesAreTypeOf(frameworkClass)) {
+ valueType = mapType.unwrappedValueType(frameworkClass);
+ break;
+ }
+ }
+ builder.add("<$T, $T>", mapType.keyType(), valueType);
+ }
+
+ builder.add("builder($L)", binding.dependencies().size());
+
+ for (DependencyRequest dependency : binding.dependencies()) {
+ ContributionBinding contributionBinding = graph.contributionBinding(dependency.key());
+ builder.add(
+ ".put($L, $L)",
+ getMapKeyExpression(contributionBinding, componentImplementation.name(), elements),
+ multibindingDependencyExpression(dependency));
+ }
+ builder.add(".build()");
+
+ return builder.build();
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/MemberSelect.java b/java/dagger/internal/codegen/writing/MemberSelect.java
new file mode 100644
index 0000000..b04e21b
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/MemberSelect.java
@@ -0,0 +1,263 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static dagger.internal.codegen.binding.ContributionBinding.FactoryCreationStrategy.SINGLETON_INSTANCE;
+import static dagger.internal.codegen.binding.SourceFiles.bindingTypeElementTypeVariableNames;
+import static dagger.internal.codegen.binding.SourceFiles.generatedClassNameForBinding;
+import static dagger.internal.codegen.binding.SourceFiles.setFactoryClassName;
+import static dagger.internal.codegen.javapoet.CodeBlocks.toParametersCodeBlock;
+import static dagger.internal.codegen.javapoet.TypeNames.FACTORY;
+import static dagger.internal.codegen.javapoet.TypeNames.MAP_FACTORY;
+import static dagger.internal.codegen.javapoet.TypeNames.PRODUCER;
+import static dagger.internal.codegen.javapoet.TypeNames.PRODUCERS;
+import static dagger.internal.codegen.javapoet.TypeNames.PROVIDER;
+import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
+import static javax.lang.model.type.TypeKind.DECLARED;
+
+import com.google.auto.common.MoreTypes;
+import com.google.common.collect.ImmutableList;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.TypeVariableName;
+import dagger.internal.codegen.base.SetType;
+import dagger.internal.codegen.binding.BindingType;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.javapoet.CodeBlocks;
+import java.util.List;
+import java.util.Optional;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeMirror;
+
+/**
+ * Represents a {@link com.sun.source.tree.MemberSelectTree} as a {@link CodeBlock}.
+ */
+abstract class MemberSelect {
+
+ /**
+ * Returns a {@link MemberSelect} that accesses the field given by {@code fieldName} owned by
+ * {@code owningClass}. In this context "local" refers to the fact that the field is owned by the
+ * type (or an enclosing type) from which the code block will be used. The returned
+ * {@link MemberSelect} will not be valid for accessing the field from a different class
+ * (regardless of accessibility).
+ */
+ static MemberSelect localField(ClassName owningClass, String fieldName) {
+ return new LocalField(owningClass, fieldName);
+ }
+
+ private static final class LocalField extends MemberSelect {
+ final String fieldName;
+
+ LocalField(ClassName owningClass, String fieldName) {
+ super(owningClass, false);
+ this.fieldName = checkNotNull(fieldName);
+ }
+
+ @Override
+ CodeBlock getExpressionFor(ClassName usingClass) {
+ return owningClass().equals(usingClass)
+ ? CodeBlock.of("$N", fieldName)
+ : CodeBlock.of("$T.this.$N", owningClass(), fieldName);
+ }
+ }
+
+ /**
+ * Returns a {@link MemberSelect} that accesses the method given by {@code methodName} owned by
+ * {@code owningClass}. In this context "local" refers to the fact that the method is owned by the
+ * type (or an enclosing type) from which the code block will be used. The returned {@link
+ * MemberSelect} will not be valid for accessing the method from a different class (regardless of
+ * accessibility).
+ */
+ static MemberSelect localMethod(ClassName owningClass, String methodName) {
+ return new LocalMethod(owningClass, methodName);
+ }
+
+ private static final class LocalMethod extends MemberSelect {
+ final String methodName;
+
+ LocalMethod(ClassName owningClass, String methodName) {
+ super(owningClass, false);
+ this.methodName = checkNotNull(methodName);
+ }
+
+ @Override
+ CodeBlock getExpressionFor(ClassName usingClass) {
+ return owningClass().equals(usingClass)
+ ? CodeBlock.of("$N()", methodName)
+ : CodeBlock.of("$T.this.$N()", owningClass(), methodName);
+ }
+ }
+
+ /**
+ * If {@code resolvedBindings} is an unscoped provision binding with no factory arguments or a
+ * no-op members injection binding, then we don't need a field to hold its factory. In that case,
+ * this method returns the static member select that returns the factory or no-op members
+ * injector.
+ */
+ static Optional<MemberSelect> staticFactoryCreation(ContributionBinding contributionBinding) {
+ if (contributionBinding.factoryCreationStrategy().equals(SINGLETON_INSTANCE)
+ && !contributionBinding.scope().isPresent()) {
+ switch (contributionBinding.kind()) {
+ case MULTIBOUND_MAP:
+ return Optional.of(emptyMapFactory(contributionBinding));
+
+ case MULTIBOUND_SET:
+ return Optional.of(emptySetFactory(contributionBinding));
+
+ case INJECTION:
+ case PROVISION:
+ TypeMirror keyType = contributionBinding.key().type();
+ if (keyType.getKind().equals(DECLARED)) {
+ ImmutableList<TypeVariableName> typeVariables =
+ bindingTypeElementTypeVariableNames(contributionBinding);
+ if (!typeVariables.isEmpty()) {
+ List<? extends TypeMirror> typeArguments =
+ ((DeclaredType) keyType).getTypeArguments();
+ return Optional.of(
+ MemberSelect.parameterizedFactoryCreateMethod(
+ generatedClassNameForBinding(contributionBinding), typeArguments));
+ }
+ }
+ // fall through
+
+ default:
+ return Optional.of(
+ new StaticMethod(
+ generatedClassNameForBinding(contributionBinding), CodeBlock.of("create()")));
+ }
+ }
+
+ return Optional.empty();
+ }
+
+ /**
+ * Returns a {@link MemberSelect} for the instance of a {@code create()} method on a factory. This
+ * only applies for factories that do not have any dependencies.
+ */
+ private static MemberSelect parameterizedFactoryCreateMethod(
+ ClassName owningClass, List<? extends TypeMirror> parameters) {
+ return new ParameterizedStaticMethod(
+ owningClass, ImmutableList.copyOf(parameters), CodeBlock.of("create()"), FACTORY);
+ }
+
+ private static final class StaticMethod extends MemberSelect {
+ final CodeBlock methodCodeBlock;
+
+ StaticMethod(ClassName owningClass, CodeBlock methodCodeBlock) {
+ super(owningClass, true);
+ this.methodCodeBlock = checkNotNull(methodCodeBlock);
+ }
+
+ @Override
+ CodeBlock getExpressionFor(ClassName usingClass) {
+ return owningClass().equals(usingClass)
+ ? methodCodeBlock
+ : CodeBlock.of("$T.$L", owningClass(), methodCodeBlock);
+ }
+ }
+
+ /** A {@link MemberSelect} for a factory of an empty map. */
+ private static MemberSelect emptyMapFactory(ContributionBinding contributionBinding) {
+ BindingType bindingType = contributionBinding.bindingType();
+ ImmutableList<TypeMirror> typeParameters =
+ ImmutableList.copyOf(
+ MoreTypes.asDeclared(contributionBinding.key().type()).getTypeArguments());
+ if (bindingType.equals(BindingType.PRODUCTION)) {
+ return new ParameterizedStaticMethod(
+ PRODUCERS, typeParameters, CodeBlock.of("emptyMapProducer()"), PRODUCER);
+ } else {
+ return new ParameterizedStaticMethod(
+ MAP_FACTORY, typeParameters, CodeBlock.of("emptyMapProvider()"), PROVIDER);
+ }
+ }
+
+ /**
+ * A static member select for an empty set factory. Calls {@link
+ * dagger.internal.SetFactory#empty()}, {@link dagger.producers.internal.SetProducer#empty()}, or
+ * {@link dagger.producers.internal.SetOfProducedProducer#empty()}, depending on the set bindings.
+ */
+ private static MemberSelect emptySetFactory(ContributionBinding binding) {
+ return new ParameterizedStaticMethod(
+ setFactoryClassName(binding),
+ ImmutableList.of(SetType.from(binding.key()).elementType()),
+ CodeBlock.of("empty()"),
+ FACTORY);
+ }
+
+ private static final class ParameterizedStaticMethod extends MemberSelect {
+ final ImmutableList<TypeMirror> typeParameters;
+ final CodeBlock methodCodeBlock;
+ final ClassName rawReturnType;
+
+ ParameterizedStaticMethod(
+ ClassName owningClass,
+ ImmutableList<TypeMirror> typeParameters,
+ CodeBlock methodCodeBlock,
+ ClassName rawReturnType) {
+ super(owningClass, true);
+ this.typeParameters = typeParameters;
+ this.methodCodeBlock = methodCodeBlock;
+ this.rawReturnType = rawReturnType;
+ }
+
+ @Override
+ CodeBlock getExpressionFor(ClassName usingClass) {
+ boolean accessible = true;
+ for (TypeMirror typeParameter : typeParameters) {
+ accessible &= isTypeAccessibleFrom(typeParameter, usingClass.packageName());
+ }
+
+ if (accessible) {
+ return CodeBlock.of(
+ "$T.<$L>$L",
+ owningClass(),
+ typeParameters.stream().map(CodeBlocks::type).collect(toParametersCodeBlock()),
+ methodCodeBlock);
+ } else {
+ return CodeBlock.of("(($T) $T.$L)", rawReturnType, owningClass(), methodCodeBlock);
+ }
+ }
+ }
+
+ private final ClassName owningClass;
+ private final boolean staticMember;
+
+ MemberSelect(ClassName owningClass, boolean staticMemeber) {
+ this.owningClass = owningClass;
+ this.staticMember = staticMemeber;
+ }
+
+ /** Returns the class that owns the member being selected. */
+ ClassName owningClass() {
+ return owningClass;
+ }
+
+ /**
+ * Returns true if the member being selected is static and does not require an instance of
+ * {@link #owningClass()}.
+ */
+ boolean staticMember() {
+ return staticMember;
+ }
+
+ /**
+ * Returns a {@link CodeBlock} suitable for accessing the member from the given {@code
+ * usingClass}.
+ */
+ abstract CodeBlock getExpressionFor(ClassName usingClass);
+}
diff --git a/java/dagger/internal/codegen/writing/MembersInjectionBindingExpression.java b/java/dagger/internal/codegen/writing/MembersInjectionBindingExpression.java
new file mode 100644
index 0000000..abf9d03
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/MembersInjectionBindingExpression.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static javax.lang.model.type.TypeKind.VOID;
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.ParameterSpec;
+import dagger.internal.codegen.binding.ComponentDescriptor.ComponentMethodDescriptor;
+import dagger.internal.codegen.binding.MembersInjectionBinding;
+import dagger.internal.codegen.javapoet.Expression;
+import javax.lang.model.element.ExecutableElement;
+
+/**
+ * A binding expression for members injection component methods. See {@link
+ * MembersInjectionMethods}.
+ */
+final class MembersInjectionBindingExpression extends BindingExpression {
+ private final MembersInjectionBinding binding;
+ private final MembersInjectionMethods membersInjectionMethods;
+
+ MembersInjectionBindingExpression(
+ MembersInjectionBinding binding, MembersInjectionMethods membersInjectionMethods) {
+ this.binding = binding;
+ this.membersInjectionMethods = membersInjectionMethods;
+ }
+
+ @Override
+ Expression getDependencyExpression(ClassName requestingClass) {
+ throw new UnsupportedOperationException(binding.toString());
+ }
+
+ // TODO(ronshapiro): This class doesn't need to be a BindingExpression, as
+ // getDependencyExpression() should never be called for members injection methods. It's probably
+ // better suited as a method on MembersInjectionMethods
+ @Override
+ protected CodeBlock getComponentMethodImplementation(
+ ComponentMethodDescriptor componentMethod, ComponentImplementation component) {
+ ExecutableElement methodElement = componentMethod.methodElement();
+ ParameterSpec parameter = ParameterSpec.get(getOnlyElement(methodElement.getParameters()));
+
+ if (binding.injectionSites().isEmpty()) {
+ return methodElement.getReturnType().getKind().equals(VOID)
+ ? CodeBlock.of("")
+ : CodeBlock.of("return $N;", parameter);
+ } else {
+ return methodElement.getReturnType().getKind().equals(VOID)
+ ? CodeBlock.of("$L;", membersInjectionInvocation(parameter))
+ : CodeBlock.of("return $L;", membersInjectionInvocation(parameter));
+ }
+ }
+
+ CodeBlock membersInjectionInvocation(ParameterSpec target) {
+ return CodeBlock.of("$N($N)", membersInjectionMethods.getOrCreate(binding.key()), target);
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/MembersInjectionMethods.java b/java/dagger/internal/codegen/writing/MembersInjectionMethods.java
new file mode 100644
index 0000000..3d602b3
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/MembersInjectionMethods.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.squareup.javapoet.MethodSpec.methodBuilder;
+import static dagger.internal.codegen.base.Util.reentrantComputeIfAbsent;
+import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
+import static dagger.internal.codegen.writing.ComponentImplementation.MethodSpecKind.MEMBERS_INJECTION_METHOD;
+import static javax.lang.model.element.Modifier.PRIVATE;
+
+import com.google.common.collect.ImmutableSet;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterSpec;
+import com.squareup.javapoet.TypeName;
+import dagger.internal.codegen.binding.Binding;
+import dagger.internal.codegen.binding.BindingGraph;
+import dagger.internal.codegen.binding.MembersInjectionBinding;
+import dagger.internal.codegen.binding.MembersInjectionBinding.InjectionSite;
+import dagger.internal.codegen.binding.ProvisionBinding;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.internal.codegen.writing.InjectionMethods.InjectionSiteMethod;
+import dagger.model.Key;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import javax.lang.model.element.Name;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeMirror;
+
+/** Manages the member injection methods for a component. */
+final class MembersInjectionMethods {
+ private final Map<Key, MethodSpec> membersInjectionMethods = new LinkedHashMap<>();
+ private final ComponentImplementation componentImplementation;
+ private final ComponentBindingExpressions bindingExpressions;
+ private final BindingGraph graph;
+ private final DaggerElements elements;
+ private final DaggerTypes types;
+ private final KotlinMetadataUtil metadataUtil;
+
+ MembersInjectionMethods(
+ ComponentImplementation componentImplementation,
+ ComponentBindingExpressions bindingExpressions,
+ BindingGraph graph,
+ DaggerElements elements,
+ DaggerTypes types,
+ KotlinMetadataUtil metadataUtil) {
+ this.componentImplementation = checkNotNull(componentImplementation);
+ this.bindingExpressions = checkNotNull(bindingExpressions);
+ this.graph = checkNotNull(graph);
+ this.elements = checkNotNull(elements);
+ this.types = checkNotNull(types);
+ this.metadataUtil = metadataUtil;
+ }
+
+ /**
+ * Returns the members injection {@link MethodSpec} for the given {@link Key}, creating it if
+ * necessary.
+ */
+ MethodSpec getOrCreate(Key key) {
+ return reentrantComputeIfAbsent(membersInjectionMethods, key, this::membersInjectionMethod);
+ }
+
+ private MethodSpec membersInjectionMethod(Key key) {
+ Binding binding =
+ graph.membersInjectionBinding(key).isPresent()
+ ? graph.membersInjectionBinding(key).get()
+ : graph.contributionBinding(key);
+ TypeMirror keyType = binding.key().type();
+ TypeMirror membersInjectedType =
+ isTypeAccessibleFrom(keyType, componentImplementation.name().packageName())
+ ? keyType
+ : elements.getTypeElement(Object.class).asType();
+ TypeName membersInjectedTypeName = TypeName.get(membersInjectedType);
+ Name bindingTypeName = binding.bindingTypeElement().get().getSimpleName();
+ // TODO(ronshapiro): include type parameters in this name e.g. injectFooOfT, and outer class
+ // simple names Foo.Builder -> injectFooBuilder
+ String methodName = componentImplementation.getUniqueMethodName("inject" + bindingTypeName);
+ ParameterSpec parameter = ParameterSpec.builder(membersInjectedTypeName, "instance").build();
+ MethodSpec.Builder methodBuilder =
+ methodBuilder(methodName)
+ .addModifiers(PRIVATE)
+ .returns(membersInjectedTypeName)
+ .addParameter(parameter);
+ TypeElement canIgnoreReturnValue =
+ elements.getTypeElement("com.google.errorprone.annotations.CanIgnoreReturnValue");
+ if (canIgnoreReturnValue != null) {
+ methodBuilder.addAnnotation(ClassName.get(canIgnoreReturnValue));
+ }
+ CodeBlock instance = CodeBlock.of("$N", parameter);
+ methodBuilder.addCode(
+ InjectionSiteMethod.invokeAll(
+ injectionSites(binding),
+ componentImplementation.name(),
+ instance,
+ membersInjectedType,
+ request ->
+ bindingExpressions
+ .getDependencyArgumentExpression(request, componentImplementation.name())
+ .codeBlock(),
+ types,
+ metadataUtil));
+ methodBuilder.addStatement("return $L", instance);
+
+ MethodSpec method = methodBuilder.build();
+ componentImplementation.addMethod(MEMBERS_INJECTION_METHOD, method);
+ return method;
+ }
+
+ private static ImmutableSet<InjectionSite> injectionSites(Binding binding) {
+ if (binding instanceof ProvisionBinding) {
+ return ((ProvisionBinding) binding).injectionSites();
+ } else if (binding instanceof MembersInjectionBinding) {
+ return ((MembersInjectionBinding) binding).injectionSites();
+ }
+ throw new IllegalArgumentException(binding.key().toString());
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/MembersInjectorGenerator.java b/java/dagger/internal/codegen/writing/MembersInjectorGenerator.java
new file mode 100644
index 0000000..df618b0
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/MembersInjectorGenerator.java
@@ -0,0 +1,227 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkState;
+import static com.squareup.javapoet.MethodSpec.constructorBuilder;
+import static com.squareup.javapoet.MethodSpec.methodBuilder;
+import static com.squareup.javapoet.TypeSpec.classBuilder;
+import static dagger.internal.codegen.binding.AssistedInjectionAnnotations.assistedInjectedConstructors;
+import static dagger.internal.codegen.binding.InjectionAnnotations.injectedConstructors;
+import static dagger.internal.codegen.binding.SourceFiles.bindingTypeElementTypeVariableNames;
+import static dagger.internal.codegen.binding.SourceFiles.frameworkFieldUsages;
+import static dagger.internal.codegen.binding.SourceFiles.generateBindingFieldsForDependencies;
+import static dagger.internal.codegen.binding.SourceFiles.membersInjectorNameForType;
+import static dagger.internal.codegen.binding.SourceFiles.parameterizedGeneratedTypeNameForBinding;
+import static dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression.RAWTYPES;
+import static dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression.UNCHECKED;
+import static dagger.internal.codegen.javapoet.AnnotationSpecs.suppressWarnings;
+import static dagger.internal.codegen.javapoet.CodeBlocks.toParametersCodeBlock;
+import static dagger.internal.codegen.javapoet.TypeNames.membersInjectorOf;
+import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
+import static dagger.internal.codegen.writing.GwtCompatibility.gwtIncompatibleAnnotation;
+import static javax.lang.model.element.Modifier.FINAL;
+import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.PUBLIC;
+import static javax.lang.model.element.Modifier.STATIC;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterSpec;
+import com.squareup.javapoet.TypeName;
+import com.squareup.javapoet.TypeSpec;
+import com.squareup.javapoet.TypeVariableName;
+import dagger.MembersInjector;
+import dagger.internal.codegen.base.SourceFileGenerator;
+import dagger.internal.codegen.base.UniqueNameSet;
+import dagger.internal.codegen.binding.FrameworkField;
+import dagger.internal.codegen.binding.MembersInjectionBinding;
+import dagger.internal.codegen.binding.MembersInjectionBinding.InjectionSite;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.internal.codegen.writing.InjectionMethods.InjectionSiteMethod;
+import dagger.model.DependencyRequest;
+import java.util.Map.Entry;
+import java.util.Optional;
+import javax.annotation.processing.Filer;
+import javax.inject.Inject;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Element;
+
+/**
+ * Generates {@link MembersInjector} implementations from {@link MembersInjectionBinding} instances.
+ */
+public final class MembersInjectorGenerator extends SourceFileGenerator<MembersInjectionBinding> {
+ private final DaggerTypes types;
+ private final KotlinMetadataUtil metadataUtil;
+
+ @Inject
+ MembersInjectorGenerator(
+ Filer filer,
+ DaggerElements elements,
+ DaggerTypes types,
+ SourceVersion sourceVersion,
+ KotlinMetadataUtil metadataUtil) {
+ super(filer, elements, sourceVersion);
+ this.types = types;
+ this.metadataUtil = metadataUtil;
+ }
+
+ @Override
+ public ClassName nameGeneratedType(MembersInjectionBinding binding) {
+ return membersInjectorNameForType(binding.membersInjectedType());
+ }
+
+ @Override
+ public Element originatingElement(MembersInjectionBinding binding) {
+ return binding.membersInjectedType();
+ }
+
+ @Override
+ public Optional<TypeSpec.Builder> write(MembersInjectionBinding binding) {
+ // Empty members injection bindings are special and don't need source files.
+ if (binding.injectionSites().isEmpty()) {
+ return Optional.empty();
+ }
+
+ // Members injectors for classes with no local injection sites and no @Inject
+ // constructor are unused.
+ if (!binding.hasLocalInjectionSites()
+ && injectedConstructors(binding.membersInjectedType()).isEmpty()
+ && assistedInjectedConstructors(binding.membersInjectedType()).isEmpty()) {
+ return Optional.empty();
+ }
+
+
+ // We don't want to write out resolved bindings -- we want to write out the generic version.
+ checkState(
+ !binding.unresolved().isPresent(),
+ "tried to generate a MembersInjector for a binding of a resolved generic type: %s",
+ binding);
+
+ ClassName generatedTypeName = nameGeneratedType(binding);
+ ImmutableList<TypeVariableName> typeParameters = bindingTypeElementTypeVariableNames(binding);
+ TypeSpec.Builder injectorTypeBuilder =
+ classBuilder(generatedTypeName)
+ .addModifiers(PUBLIC, FINAL)
+ .addTypeVariables(typeParameters);
+
+ TypeName injectedTypeName = TypeName.get(binding.key().type());
+ TypeName implementedType = membersInjectorOf(injectedTypeName);
+ injectorTypeBuilder.addSuperinterface(implementedType);
+
+ MethodSpec.Builder injectMembersBuilder =
+ methodBuilder("injectMembers")
+ .addModifiers(PUBLIC)
+ .addAnnotation(Override.class)
+ .addParameter(injectedTypeName, "instance");
+
+ ImmutableMap<DependencyRequest, FrameworkField> fields =
+ generateBindingFieldsForDependencies(binding);
+
+ ImmutableMap.Builder<DependencyRequest, FieldSpec> dependencyFieldsBuilder =
+ ImmutableMap.builder();
+
+ MethodSpec.Builder constructorBuilder = constructorBuilder().addModifiers(PUBLIC);
+
+ // We use a static create method so that generated components can avoid having
+ // to refer to the generic types of the factory.
+ // (Otherwise they may have visibility problems referring to the types.)
+ MethodSpec.Builder createMethodBuilder =
+ methodBuilder("create")
+ .returns(implementedType)
+ .addModifiers(PUBLIC, STATIC)
+ .addTypeVariables(typeParameters);
+
+ createMethodBuilder.addCode(
+ "return new $T(", parameterizedGeneratedTypeNameForBinding(binding));
+ ImmutableList.Builder<CodeBlock> constructorInvocationParameters = ImmutableList.builder();
+
+ boolean usesRawFrameworkTypes = false;
+ UniqueNameSet fieldNames = new UniqueNameSet();
+ for (Entry<DependencyRequest, FrameworkField> fieldEntry : fields.entrySet()) {
+ DependencyRequest dependency = fieldEntry.getKey();
+ FrameworkField bindingField = fieldEntry.getValue();
+
+ // If the dependency type is not visible to this members injector, then use the raw framework
+ // type for the field.
+ boolean useRawFrameworkType =
+ !isTypeAccessibleFrom(dependency.key().type(), generatedTypeName.packageName());
+
+ String fieldName = fieldNames.getUniqueName(bindingField.name());
+ TypeName fieldType = useRawFrameworkType ? bindingField.type().rawType : bindingField.type();
+ FieldSpec.Builder fieldBuilder = FieldSpec.builder(fieldType, fieldName, PRIVATE, FINAL);
+ ParameterSpec.Builder parameterBuilder = ParameterSpec.builder(fieldType, fieldName);
+
+ // If we're using the raw type for the field, then suppress the injectMembers method's
+ // unchecked-type warning and the field's and the constructor and create-method's
+ // parameters' raw-type warnings.
+ if (useRawFrameworkType) {
+ usesRawFrameworkTypes = true;
+ fieldBuilder.addAnnotation(suppressWarnings(RAWTYPES));
+ parameterBuilder.addAnnotation(suppressWarnings(RAWTYPES));
+ }
+ constructorBuilder.addParameter(parameterBuilder.build());
+ createMethodBuilder.addParameter(parameterBuilder.build());
+
+ FieldSpec field = fieldBuilder.build();
+ injectorTypeBuilder.addField(field);
+ constructorBuilder.addStatement("this.$1N = $1N", field);
+ dependencyFieldsBuilder.put(dependency, field);
+ constructorInvocationParameters.add(CodeBlock.of("$N", field));
+ }
+
+ createMethodBuilder.addCode(
+ constructorInvocationParameters.build().stream().collect(toParametersCodeBlock()));
+ createMethodBuilder.addCode(");");
+
+ injectorTypeBuilder.addMethod(constructorBuilder.build());
+ injectorTypeBuilder.addMethod(createMethodBuilder.build());
+
+ ImmutableMap<DependencyRequest, FieldSpec> dependencyFields = dependencyFieldsBuilder.build();
+
+ injectMembersBuilder.addCode(
+ InjectionSiteMethod.invokeAll(
+ binding.injectionSites(),
+ generatedTypeName,
+ CodeBlock.of("instance"),
+ binding.key().type(),
+ frameworkFieldUsages(binding.dependencies(), dependencyFields)::get,
+ types,
+ metadataUtil));
+
+ if (usesRawFrameworkTypes) {
+ injectMembersBuilder.addAnnotation(suppressWarnings(UNCHECKED));
+ }
+ injectorTypeBuilder.addMethod(injectMembersBuilder.build());
+
+ for (InjectionSite injectionSite : binding.injectionSites()) {
+ if (injectionSite.element().getEnclosingElement().equals(binding.membersInjectedType())) {
+ injectorTypeBuilder.addMethod(InjectionSiteMethod.create(injectionSite, metadataUtil));
+ }
+ }
+
+ gwtIncompatibleAnnotation(binding).ifPresent(injectorTypeBuilder::addAnnotation);
+
+ return Optional.of(injectorTypeBuilder);
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/MembersInjectorProviderCreationExpression.java b/java/dagger/internal/codegen/writing/MembersInjectorProviderCreationExpression.java
new file mode 100644
index 0000000..534c057
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/MembersInjectorProviderCreationExpression.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static dagger.internal.codegen.binding.SourceFiles.membersInjectorNameForType;
+import static dagger.internal.codegen.javapoet.TypeNames.INSTANCE_FACTORY;
+import static dagger.internal.codegen.javapoet.TypeNames.MEMBERS_INJECTORS;
+
+import com.google.auto.common.MoreTypes;
+import com.squareup.javapoet.CodeBlock;
+import dagger.internal.codegen.binding.ProvisionBinding;
+import dagger.internal.codegen.writing.FrameworkFieldInitializer.FrameworkInstanceCreationExpression;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeMirror;
+
+/** A {@code Provider<MembersInjector<Foo>>} creation expression. */
+final class MembersInjectorProviderCreationExpression
+ implements FrameworkInstanceCreationExpression {
+
+ private final ComponentBindingExpressions componentBindingExpressions;
+ private final ProvisionBinding binding;
+
+ MembersInjectorProviderCreationExpression(
+ ProvisionBinding binding, ComponentBindingExpressions componentBindingExpressions) {
+ this.binding = checkNotNull(binding);
+ this.componentBindingExpressions = checkNotNull(componentBindingExpressions);
+ }
+
+ @Override
+ public CodeBlock creationExpression() {
+ TypeMirror membersInjectedType =
+ getOnlyElement(MoreTypes.asDeclared(binding.key().type()).getTypeArguments());
+
+ boolean castThroughRawType = false;
+ CodeBlock membersInjector;
+ if (binding.injectionSites().isEmpty()) {
+ membersInjector = CodeBlock.of("$T.<$T>noOp()", MEMBERS_INJECTORS, membersInjectedType);
+ } else {
+ TypeElement injectedTypeElement = MoreTypes.asTypeElement(membersInjectedType);
+ while (!hasLocalInjectionSites(injectedTypeElement)) {
+ // Cast through a raw type since we're going to be using the MembersInjector for the
+ // parent type.
+ castThroughRawType = true;
+ injectedTypeElement = MoreTypes.asTypeElement(injectedTypeElement.getSuperclass());
+ }
+
+ membersInjector = CodeBlock.of(
+ "$T.create($L)",
+ membersInjectorNameForType(injectedTypeElement),
+ componentBindingExpressions.getCreateMethodArgumentsCodeBlock(binding));
+ }
+
+ // TODO(ronshapiro): consider adding a MembersInjectorBindingExpression to return this directly
+ // (as it's rarely requested as a Provider).
+ CodeBlock providerExpression = CodeBlock.of("$T.create($L)", INSTANCE_FACTORY, membersInjector);
+ // If needed we cast through raw type around the InstanceFactory type as opposed to the
+ // MembersInjector since we end up with an InstanceFactory<MembersInjector> as opposed to a
+ // InstanceFactory<MembersInjector<Foo>> and that becomes unassignable. To fix it would require
+ // a second cast. If we just cast to the raw type InstanceFactory though, that becomes
+ // assignable.
+ return castThroughRawType
+ ? CodeBlock.of("($T) $L", INSTANCE_FACTORY, providerExpression) : providerExpression;
+ }
+
+ private boolean hasLocalInjectionSites(TypeElement injectedTypeElement) {
+ return binding.injectionSites()
+ .stream()
+ .anyMatch(
+ injectionSite ->
+ injectionSite.element().getEnclosingElement().equals(injectedTypeElement));
+ }
+
+ @Override
+ public boolean useInnerSwitchingProvider() {
+ return !binding.injectionSites().isEmpty();
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/MethodBindingExpression.java b/java/dagger/internal/codegen/writing/MethodBindingExpression.java
new file mode 100644
index 0000000..9c0c74a
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/MethodBindingExpression.java
@@ -0,0 +1,294 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static dagger.internal.codegen.binding.AssistedInjectionAnnotations.assistedParameterSpecs;
+import static dagger.internal.codegen.javapoet.CodeBlocks.parameterNames;
+import static dagger.internal.codegen.writing.ComponentImplementation.FieldSpecKind.PRIVATE_METHOD_SCOPED_FIELD;
+import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.VOLATILE;
+
+import com.google.common.base.Supplier;
+import com.google.common.base.Suppliers;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.TypeName;
+import dagger.internal.DoubleCheck;
+import dagger.internal.MemoizedSentinel;
+import dagger.internal.codegen.binding.BindingRequest;
+import dagger.internal.codegen.binding.ComponentDescriptor.ComponentMethodDescriptor;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.binding.FrameworkField;
+import dagger.internal.codegen.binding.KeyVariableNamer;
+import dagger.internal.codegen.javapoet.Expression;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.BindingKind;
+import dagger.model.RequestKind;
+import java.util.Optional;
+import javax.lang.model.type.TypeMirror;
+
+/** A binding expression that wraps another in a nullary method on the component. */
+abstract class MethodBindingExpression extends BindingExpression {
+ private final BindingRequest request;
+ private final ContributionBinding binding;
+ private final BindingMethodImplementation bindingMethodImplementation;
+ private final ComponentImplementation componentImplementation;
+ private final ProducerEntryPointView producerEntryPointView;
+ private final BindingExpression wrappedBindingExpression;
+ private final DaggerTypes types;
+
+ protected MethodBindingExpression(
+ BindingRequest request,
+ ContributionBinding binding,
+ MethodImplementationStrategy methodImplementationStrategy,
+ BindingExpression wrappedBindingExpression,
+ ComponentImplementation componentImplementation,
+ DaggerTypes types) {
+ this.request = checkNotNull(request);
+ this.binding = checkNotNull(binding);
+ this.bindingMethodImplementation = bindingMethodImplementation(methodImplementationStrategy);
+ this.wrappedBindingExpression = checkNotNull(wrappedBindingExpression);
+ this.componentImplementation = checkNotNull(componentImplementation);
+ this.producerEntryPointView = new ProducerEntryPointView(types);
+ this.types = checkNotNull(types);
+ }
+
+ @Override
+ Expression getDependencyExpression(ClassName requestingClass) {
+ if (request.frameworkType().isPresent()) {
+ // Initializing a framework instance that participates in a cycle requires that the underlying
+ // FrameworkInstanceBindingExpression is invoked in order for a cycle to be detected properly.
+ // When a MethodBindingExpression wraps a FrameworkInstanceBindingExpression, the wrapped
+ // expression will only be invoked once to implement the method body. This is a hack to work
+ // around that weirdness - methodImplementation.body() will invoke the framework instance
+ // initialization again in case the field is not fully initialized.
+ // TODO(b/121196706): use a less hacky approach to fix this bug
+ Object unused = methodBody();
+ }
+
+ addMethod();
+
+ CodeBlock methodCall =
+ binding.kind() == BindingKind.ASSISTED_INJECTION
+ // Private methods for assisted injection take assisted parameters as input.
+ ? CodeBlock.of(
+ "$N($L)", methodName(), parameterNames(assistedParameterSpecs(binding, types)))
+ : CodeBlock.of("$N()", methodName());
+
+ return Expression.create(
+ returnType(),
+ requestingClass.equals(componentImplementation.name())
+ ? methodCall
+ : CodeBlock.of("$L.$L", componentImplementation.externalReferenceBlock(), methodCall));
+ }
+
+ @Override
+ Expression getDependencyExpressionForComponentMethod(ComponentMethodDescriptor componentMethod,
+ ComponentImplementation component) {
+ return producerEntryPointView
+ .getProducerEntryPointField(this, componentMethod, component)
+ .orElseGet(
+ () -> super.getDependencyExpressionForComponentMethod(componentMethod, component));
+ }
+
+ /** Adds the method to the component (if necessary) the first time it's called. */
+ protected abstract void addMethod();
+
+ /** Returns the name of the method to call. */
+ protected abstract String methodName();
+
+ /** The method's body. */
+ protected final CodeBlock methodBody() {
+ return implementation(
+ wrappedBindingExpression.getDependencyExpression(componentImplementation.name())
+ ::codeBlock);
+ }
+
+ /** The method's body if this method is a component method. */
+ protected final CodeBlock methodBodyForComponentMethod(
+ ComponentMethodDescriptor componentMethod) {
+ return implementation(
+ wrappedBindingExpression.getDependencyExpressionForComponentMethod(
+ componentMethod, componentImplementation)
+ ::codeBlock);
+ }
+
+ private CodeBlock implementation(Supplier<CodeBlock> simpleBindingExpression) {
+ return bindingMethodImplementation.implementation(simpleBindingExpression);
+ }
+
+ private BindingMethodImplementation bindingMethodImplementation(
+ MethodImplementationStrategy methodImplementationStrategy) {
+ switch (methodImplementationStrategy) {
+ case SIMPLE:
+ return new SimpleMethodImplementation();
+ case SINGLE_CHECK:
+ return new SingleCheckedMethodImplementation();
+ case DOUBLE_CHECK:
+ return new DoubleCheckedMethodImplementation();
+ }
+ throw new AssertionError(methodImplementationStrategy);
+ }
+
+ /** Returns the return type for the dependency request. */
+ protected TypeMirror returnType() {
+ if (request.isRequestKind(RequestKind.INSTANCE)
+ && binding.contributedPrimitiveType().isPresent()) {
+ return binding.contributedPrimitiveType().get();
+ }
+
+ if (matchingComponentMethod().isPresent()) {
+ // Component methods are part of the user-defined API, and thus we must use the user-defined
+ // type.
+ return matchingComponentMethod().get().resolvedReturnType(types);
+ }
+
+ TypeMirror requestedType = request.requestedType(binding.contributedType(), types);
+ return types.accessibleType(requestedType, componentImplementation.name());
+ }
+
+ private Optional<ComponentMethodDescriptor> matchingComponentMethod() {
+ return componentImplementation.componentDescriptor().firstMatchingComponentMethod(request);
+ }
+
+ /** Strateg for implementing the body of this method. */
+ enum MethodImplementationStrategy {
+ SIMPLE,
+ SINGLE_CHECK,
+ DOUBLE_CHECK,
+ ;
+ }
+
+ private abstract static class BindingMethodImplementation {
+ /**
+ * Returns the method body, which contains zero or more statements (including semicolons).
+ *
+ * <p>If the implementation has a non-void return type, the body will also include the {@code
+ * return} statement.
+ *
+ * @param simpleBindingExpression the expression to retrieve an instance of this binding without
+ * the wrapping method.
+ */
+ abstract CodeBlock implementation(Supplier<CodeBlock> simpleBindingExpression);
+ }
+
+ /** Returns the {@code wrappedBindingExpression} directly. */
+ private static final class SimpleMethodImplementation extends BindingMethodImplementation {
+ @Override
+ CodeBlock implementation(Supplier<CodeBlock> simpleBindingExpression) {
+ return CodeBlock.of("return $L;", simpleBindingExpression.get());
+ }
+ }
+
+ /**
+ * Defines a method body for single checked caching of the given {@code wrappedBindingExpression}.
+ */
+ private final class SingleCheckedMethodImplementation extends BindingMethodImplementation {
+ private final Supplier<FieldSpec> field = Suppliers.memoize(this::createField);
+
+ @Override
+ CodeBlock implementation(Supplier<CodeBlock> simpleBindingExpression) {
+ String fieldExpression = field.get().name.equals("local") ? "this.local" : field.get().name;
+
+ CodeBlock.Builder builder = CodeBlock.builder()
+ .addStatement("Object local = $N", fieldExpression);
+
+ if (isNullable()) {
+ builder.beginControlFlow("if (local instanceof $T)", MemoizedSentinel.class);
+ } else {
+ builder.beginControlFlow("if (local == null)");
+ }
+
+ return builder
+ .addStatement("local = $L", simpleBindingExpression.get())
+ .addStatement("$N = ($T) local", fieldExpression, returnType())
+ .endControlFlow()
+ .addStatement("return ($T) local", returnType())
+ .build();
+ }
+
+ FieldSpec createField() {
+ String name =
+ componentImplementation.getUniqueFieldName(
+ request.isRequestKind(RequestKind.INSTANCE)
+ ? KeyVariableNamer.name(binding.key())
+ : FrameworkField.forBinding(binding, Optional.empty()).name());
+
+ FieldSpec.Builder builder = FieldSpec.builder(fieldType(), name, PRIVATE, VOLATILE);
+ if (isNullable()) {
+ builder.initializer("new $T()", MemoizedSentinel.class);
+ }
+
+ FieldSpec field = builder.build();
+ componentImplementation.addField(PRIVATE_METHOD_SCOPED_FIELD, field);
+ return field;
+ }
+
+ TypeName fieldType() {
+ if (isNullable()) {
+ // Nullable instances use `MemoizedSentinel` instead of `null` as the initialization value,
+ // so the field type must accept that and the return type
+ return TypeName.OBJECT;
+ }
+ TypeName returnType = TypeName.get(returnType());
+ return returnType.isPrimitive() ? returnType.box() : returnType;
+ }
+
+ private boolean isNullable() {
+ return request.isRequestKind(RequestKind.INSTANCE) && binding.isNullable();
+ }
+ }
+
+ /**
+ * Defines a method body for double checked caching of the given {@code wrappedBindingExpression}.
+ */
+ private final class DoubleCheckedMethodImplementation extends BindingMethodImplementation {
+ private final Supplier<String> fieldName = Suppliers.memoize(this::createField);
+
+ @Override
+ CodeBlock implementation(Supplier<CodeBlock> simpleBindingExpression) {
+ String fieldExpression = fieldName.get().equals("local") ? "this.local" : fieldName.get();
+ return CodeBlock.builder()
+ .addStatement("$T local = $L", TypeName.OBJECT, fieldExpression)
+ .beginControlFlow("if (local instanceof $T)", MemoizedSentinel.class)
+ .beginControlFlow("synchronized (local)")
+ .addStatement("local = $L", fieldExpression)
+ .beginControlFlow("if (local instanceof $T)", MemoizedSentinel.class)
+ .addStatement("local = $L", simpleBindingExpression.get())
+ .addStatement("$1L = $2T.reentrantCheck($1L, local)", fieldExpression, DoubleCheck.class)
+ .endControlFlow()
+ .endControlFlow()
+ .endControlFlow()
+ .addStatement("return ($T) local", returnType())
+ .build();
+ }
+
+ private String createField() {
+ String name =
+ componentImplementation.getUniqueFieldName(KeyVariableNamer.name(binding.key()));
+ componentImplementation.addField(
+ PRIVATE_METHOD_SCOPED_FIELD,
+ FieldSpec.builder(TypeName.OBJECT, name, PRIVATE, VOLATILE)
+ .initializer("new $T()", MemoizedSentinel.class)
+ .build());
+ return name;
+ }
+ }
+
+}
diff --git a/java/dagger/internal/codegen/writing/ModuleGenerator.java b/java/dagger/internal/codegen/writing/ModuleGenerator.java
new file mode 100644
index 0000000..afd0e99
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/ModuleGenerator.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import dagger.internal.codegen.base.SourceFileGenerator;
+import java.lang.annotation.Retention;
+import javax.inject.Qualifier;
+
+/** Qualifier for a {@link SourceFileGenerator} for modules. */
+@Qualifier
+@Retention(RUNTIME)
+public @interface ModuleGenerator {}
diff --git a/java/dagger/internal/codegen/writing/ModuleProxies.java b/java/dagger/internal/codegen/writing/ModuleProxies.java
new file mode 100644
index 0000000..fcd9b56
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/ModuleProxies.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.squareup.javapoet.MethodSpec.constructorBuilder;
+import static com.squareup.javapoet.MethodSpec.methodBuilder;
+import static com.squareup.javapoet.TypeSpec.classBuilder;
+import static dagger.internal.codegen.langmodel.Accessibility.isElementAccessibleFrom;
+import static javax.lang.model.element.Modifier.ABSTRACT;
+import static javax.lang.model.element.Modifier.FINAL;
+import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.PUBLIC;
+import static javax.lang.model.element.Modifier.STATIC;
+import static javax.lang.model.util.ElementFilter.constructorsIn;
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.TypeSpec;
+import dagger.internal.codegen.base.SourceFileGenerator;
+import dagger.internal.codegen.binding.ModuleKind;
+import dagger.internal.codegen.binding.SourceFiles;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.internal.codegen.langmodel.Accessibility;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import java.util.Optional;
+import javax.annotation.processing.Filer;
+import javax.inject.Inject;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.TypeElement;
+
+/** Convenience methods for generating and using module constructor proxy methods. */
+public final class ModuleProxies {
+
+ private final DaggerElements elements;
+ private final KotlinMetadataUtil metadataUtil;
+
+ @Inject
+ public ModuleProxies(DaggerElements elements, KotlinMetadataUtil metadataUtil) {
+ this.elements = elements;
+ this.metadataUtil = metadataUtil;
+ }
+
+ /** Generates a {@code public static} proxy method for constructing module instances. */
+ // TODO(dpb): See if this can become a SourceFileGenerator<ModuleDescriptor> instead. Doing so may
+ // cause ModuleProcessingStep to defer elements multiple times.
+ public static final class ModuleConstructorProxyGenerator
+ extends SourceFileGenerator<TypeElement> {
+
+ private final ModuleProxies moduleProxies;
+ private final KotlinMetadataUtil metadataUtil;
+
+ @Inject
+ ModuleConstructorProxyGenerator(
+ Filer filer,
+ DaggerElements elements,
+ SourceVersion sourceVersion,
+ ModuleProxies moduleProxies,
+ KotlinMetadataUtil metadataUtil) {
+ super(filer, elements, sourceVersion);
+ this.moduleProxies = moduleProxies;
+ this.metadataUtil = metadataUtil;
+ }
+
+ @Override
+ public ClassName nameGeneratedType(TypeElement moduleElement) {
+ return moduleProxies.constructorProxyTypeName(moduleElement);
+ }
+
+ @Override
+ public Element originatingElement(TypeElement moduleElement) {
+ return moduleElement;
+ }
+
+ @Override
+ public Optional<TypeSpec.Builder> write(TypeElement moduleElement) {
+ ModuleKind.checkIsModule(moduleElement, metadataUtil);
+ return moduleProxies.nonPublicNullaryConstructor(moduleElement).isPresent()
+ ? Optional.of(buildProxy(moduleElement))
+ : Optional.empty();
+ }
+
+ private TypeSpec.Builder buildProxy(TypeElement moduleElement) {
+ return classBuilder(nameGeneratedType(moduleElement))
+ .addModifiers(PUBLIC, FINAL)
+ .addMethod(constructorBuilder().addModifiers(PRIVATE).build())
+ .addMethod(
+ methodBuilder("newInstance")
+ .addModifiers(PUBLIC, STATIC)
+ .returns(ClassName.get(moduleElement))
+ .addStatement("return new $T()", moduleElement)
+ .build());
+ }
+ }
+
+ /** The name of the class that hosts the module constructor proxy method. */
+ private ClassName constructorProxyTypeName(TypeElement moduleElement) {
+ ModuleKind.checkIsModule(moduleElement, metadataUtil);
+ ClassName moduleClassName = ClassName.get(moduleElement);
+ return moduleClassName
+ .topLevelClassName()
+ .peerClass(SourceFiles.classFileName(moduleClassName) + "_Proxy");
+ }
+
+ /**
+ * The module constructor being proxied. A proxy is generated if it is not publicly accessible and
+ * has no arguments. If an implicit reference to the enclosing class exists, or the module is
+ * abstract, no proxy method can be generated.
+ */
+ private Optional<ExecutableElement> nonPublicNullaryConstructor(TypeElement moduleElement) {
+ ModuleKind.checkIsModule(moduleElement, metadataUtil);
+ if (moduleElement.getModifiers().contains(ABSTRACT)
+ || (moduleElement.getNestingKind().isNested()
+ && !moduleElement.getModifiers().contains(STATIC))) {
+ return Optional.empty();
+ }
+ return constructorsIn(elements.getAllMembers(moduleElement)).stream()
+ .filter(constructor -> !Accessibility.isElementPubliclyAccessible(constructor))
+ .filter(constructor -> !constructor.getModifiers().contains(PRIVATE))
+ .filter(constructor -> constructor.getParameters().isEmpty())
+ .findAny();
+ }
+
+ /**
+ * Returns a code block that creates a new module instance, either by invoking the nullary
+ * constructor if it's accessible from {@code requestingClass} or else by invoking the
+ * constructor's generated proxy method.
+ */
+ public CodeBlock newModuleInstance(TypeElement moduleElement, ClassName requestingClass) {
+ ModuleKind.checkIsModule(moduleElement, metadataUtil);
+ String packageName = requestingClass.packageName();
+ return nonPublicNullaryConstructor(moduleElement)
+ .filter(constructor -> !isElementAccessibleFrom(constructor, packageName))
+ .map(
+ constructor ->
+ CodeBlock.of("$T.newInstance()", constructorProxyTypeName(moduleElement)))
+ .orElse(CodeBlock.of("new $T()", moduleElement));
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/MultibindingFactoryCreationExpression.java b/java/dagger/internal/codegen/writing/MultibindingFactoryCreationExpression.java
new file mode 100644
index 0000000..64e008e
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/MultibindingFactoryCreationExpression.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.squareup.javapoet.CodeBlock;
+import dagger.internal.codegen.binding.BindingRequest;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.javapoet.CodeBlocks;
+import dagger.internal.codegen.writing.FrameworkFieldInitializer.FrameworkInstanceCreationExpression;
+import dagger.model.DependencyRequest;
+
+/** An abstract factory creation expression for multibindings. */
+abstract class MultibindingFactoryCreationExpression
+ implements FrameworkInstanceCreationExpression {
+ private final ComponentImplementation componentImplementation;
+ private final ComponentBindingExpressions componentBindingExpressions;
+ private final ContributionBinding binding;
+
+ MultibindingFactoryCreationExpression(
+ ContributionBinding binding,
+ ComponentImplementation componentImplementation,
+ ComponentBindingExpressions componentBindingExpressions) {
+ this.binding = checkNotNull(binding);
+ this.componentImplementation = checkNotNull(componentImplementation);
+ this.componentBindingExpressions = checkNotNull(componentBindingExpressions);
+ }
+
+ /** Returns the expression for a dependency of this multibinding. */
+ protected final CodeBlock multibindingDependencyExpression(DependencyRequest dependency) {
+ CodeBlock expression =
+ componentBindingExpressions
+ .getDependencyExpression(
+ BindingRequest.bindingRequest(dependency.key(), binding.frameworkType()),
+ componentImplementation.name())
+ .codeBlock();
+
+ return useRawType()
+ ? CodeBlocks.cast(expression, binding.frameworkType().frameworkClass())
+ : expression;
+ }
+
+ /** The binding request for this framework instance. */
+ protected final BindingRequest bindingRequest() {
+ return BindingRequest.bindingRequest(binding.key(), binding.frameworkType());
+ }
+
+ /**
+ * Returns true if the {@linkplain ContributionBinding#key() key type} is inaccessible from the
+ * component, and therefore a raw type must be used.
+ */
+ protected final boolean useRawType() {
+ return !componentImplementation.isTypeAccessible(binding.key().type());
+ }
+
+ @Override
+ public final boolean useInnerSwitchingProvider() {
+ return !binding.dependencies().isEmpty();
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/OptionalBindingExpression.java b/java/dagger/internal/codegen/writing/OptionalBindingExpression.java
new file mode 100644
index 0000000..4faf3fa
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/OptionalBindingExpression.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static dagger.internal.codegen.binding.BindingRequest.bindingRequest;
+import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import dagger.internal.codegen.base.OptionalType;
+import dagger.internal.codegen.base.OptionalType.OptionalKind;
+import dagger.internal.codegen.binding.ProvisionBinding;
+import dagger.internal.codegen.javapoet.Expression;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.DependencyRequest;
+import javax.inject.Inject;
+import javax.lang.model.SourceVersion;
+
+/** A binding expression for optional bindings. */
+final class OptionalBindingExpression extends SimpleInvocationBindingExpression {
+ private final ProvisionBinding binding;
+ private final ComponentBindingExpressions componentBindingExpressions;
+ private final DaggerTypes types;
+ private final SourceVersion sourceVersion;
+
+ @Inject
+ OptionalBindingExpression(
+ ProvisionBinding binding,
+ ComponentBindingExpressions componentBindingExpressions,
+ DaggerTypes types,
+ SourceVersion sourceVersion) {
+ super(binding);
+ this.binding = binding;
+ this.componentBindingExpressions = componentBindingExpressions;
+ this.types = types;
+ this.sourceVersion = sourceVersion;
+ }
+
+ @Override
+ Expression getDependencyExpression(ClassName requestingClass) {
+ OptionalType optionalType = OptionalType.from(binding.key());
+ OptionalKind optionalKind = optionalType.kind();
+ if (binding.dependencies().isEmpty()) {
+ if (sourceVersion.compareTo(SourceVersion.RELEASE_7) <= 0) {
+ // When compiling with -source 7, javac's type inference isn't strong enough to detect
+ // Futures.immediateFuture(Optional.absent()) for keys that aren't Object. It also has
+ // issues
+ // when used as an argument to some members injection proxy methods (see
+ // https://github.com/google/dagger/issues/916)
+ if (isTypeAccessibleFrom(binding.key().type(), requestingClass.packageName())) {
+ return Expression.create(
+ binding.key().type(), optionalKind.parameterizedAbsentValueExpression(optionalType));
+ }
+ }
+ return Expression.create(binding.key().type(), optionalKind.absentValueExpression());
+ }
+ DependencyRequest dependency = getOnlyElement(binding.dependencies());
+
+ CodeBlock dependencyExpression =
+ componentBindingExpressions
+ .getDependencyExpression(bindingRequest(dependency), requestingClass)
+ .codeBlock();
+
+ // If the dependency type is inaccessible, then we have to use Optional.<Object>of(...), or else
+ // we will get "incompatible types: inference variable has incompatible bounds.
+ return isTypeAccessibleFrom(dependency.key().type(), requestingClass.packageName())
+ ? Expression.create(
+ binding.key().type(), optionalKind.presentExpression(dependencyExpression))
+ : Expression.create(
+ types.erasure(binding.key().type()),
+ optionalKind.presentObjectExpression(dependencyExpression));
+ }
+
+ @Override
+ boolean requiresMethodEncapsulation() {
+ // TODO(dpb): Maybe require it for present bindings.
+ return false;
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/OptionalFactories.java b/java/dagger/internal/codegen/writing/OptionalFactories.java
new file mode 100644
index 0000000..2d80963
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/OptionalFactories.java
@@ -0,0 +1,443 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.CaseFormat.UPPER_CAMEL;
+import static com.google.common.base.CaseFormat.UPPER_UNDERSCORE;
+import static com.google.common.base.Verify.verify;
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static com.squareup.javapoet.MethodSpec.constructorBuilder;
+import static com.squareup.javapoet.MethodSpec.methodBuilder;
+import static com.squareup.javapoet.TypeSpec.anonymousClassBuilder;
+import static com.squareup.javapoet.TypeSpec.classBuilder;
+import static dagger.internal.codegen.base.RequestKinds.requestTypeName;
+import static dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression.RAWTYPES;
+import static dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression.UNCHECKED;
+import static dagger.internal.codegen.javapoet.TypeNames.PROVIDER;
+import static dagger.internal.codegen.javapoet.TypeNames.abstractProducerOf;
+import static dagger.internal.codegen.javapoet.TypeNames.listenableFutureOf;
+import static dagger.internal.codegen.javapoet.TypeNames.providerOf;
+import static dagger.internal.codegen.writing.ComponentImplementation.FieldSpecKind.ABSENT_OPTIONAL_FIELD;
+import static dagger.internal.codegen.writing.ComponentImplementation.MethodSpecKind.ABSENT_OPTIONAL_METHOD;
+import static dagger.internal.codegen.writing.ComponentImplementation.TypeSpecKind.PRESENT_FACTORY;
+import static javax.lang.model.element.Modifier.FINAL;
+import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.PUBLIC;
+import static javax.lang.model.element.Modifier.STATIC;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.base.Function;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterSpec;
+import com.squareup.javapoet.ParameterizedTypeName;
+import com.squareup.javapoet.TypeName;
+import com.squareup.javapoet.TypeSpec;
+import com.squareup.javapoet.TypeVariableName;
+import dagger.internal.InstanceFactory;
+import dagger.internal.Preconditions;
+import dagger.internal.codegen.base.OptionalType;
+import dagger.internal.codegen.base.OptionalType.OptionalKind;
+import dagger.internal.codegen.binding.BindingType;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.binding.FrameworkType;
+import dagger.internal.codegen.javapoet.AnnotationSpecs;
+import dagger.model.RequestKind;
+import dagger.producers.Producer;
+import dagger.producers.internal.Producers;
+import java.util.Comparator;
+import java.util.Map;
+import java.util.Optional;
+import java.util.TreeMap;
+import java.util.concurrent.Executor;
+import javax.inject.Inject;
+import javax.inject.Provider;
+
+/** The nested class and static methods required by the component to implement optional bindings. */
+// TODO(dpb): Name members simply if a component uses only one of Guava or JDK Optional.
+@PerGeneratedFile
+final class OptionalFactories {
+ private final ComponentImplementation componentImplementation;
+
+ @Inject OptionalFactories(@TopLevel ComponentImplementation componentImplementation) {
+ this.componentImplementation = componentImplementation;
+ }
+
+ /**
+ * The factory classes that implement {@code Provider<Optional<T>>} or {@code
+ * Producer<Optional<T>>} for present optional bindings for a given kind of dependency request
+ * within the component.
+ *
+ * <p>The key is the {@code Provider<Optional<T>>} type.
+ */
+ private final Map<PresentFactorySpec, TypeSpec> presentFactoryClasses =
+ new TreeMap<>(
+ Comparator.comparing(PresentFactorySpec::valueKind)
+ .thenComparing(PresentFactorySpec::frameworkType)
+ .thenComparing(PresentFactorySpec::optionalKind));
+
+ /**
+ * The static methods that return a {@code Provider<Optional<T>>} that always returns an absent
+ * value.
+ */
+ private final Map<OptionalKind, MethodSpec> absentOptionalProviderMethods = new TreeMap<>();
+
+ /**
+ * The static fields for {@code Provider<Optional<T>>} objects that always return an absent value.
+ */
+ private final Map<OptionalKind, FieldSpec> absentOptionalProviderFields = new TreeMap<>();
+
+ /**
+ * Returns an expression that calls a static method that returns a {@code Provider<Optional<T>>}
+ * for absent optional bindings.
+ */
+ CodeBlock absentOptionalProvider(ContributionBinding binding) {
+ verify(
+ binding.bindingType().equals(BindingType.PROVISION),
+ "Absent optional bindings should be provisions: %s",
+ binding);
+ OptionalKind optionalKind = OptionalType.from(binding.key()).kind();
+ return CodeBlock.of(
+ "$N()",
+ absentOptionalProviderMethods.computeIfAbsent(
+ optionalKind,
+ kind -> {
+ MethodSpec method = absentOptionalProviderMethod(kind);
+ componentImplementation.addMethod(ABSENT_OPTIONAL_METHOD, method);
+ return method;
+ }));
+ }
+
+ /**
+ * Creates a method specification for a {@code Provider<Optional<T>>} that always returns an
+ * absent value.
+ */
+ private MethodSpec absentOptionalProviderMethod(OptionalKind optionalKind) {
+ TypeVariableName typeVariable = TypeVariableName.get("T");
+ return methodBuilder(
+ String.format(
+ "absent%sProvider", UPPER_UNDERSCORE.to(UPPER_CAMEL, optionalKind.name())))
+ .addModifiers(PRIVATE, STATIC)
+ .addTypeVariable(typeVariable)
+ .returns(providerOf(optionalKind.of(typeVariable)))
+ .addJavadoc(
+ "Returns a {@link $T} that returns {@code $L}.",
+ Provider.class,
+ optionalKind.absentValueExpression())
+ .addCode("$L // safe covariant cast\n", AnnotationSpecs.suppressWarnings(UNCHECKED))
+ .addCode(
+ "$1T provider = ($1T) $2N;",
+ providerOf(optionalKind.of(typeVariable)),
+ absentOptionalProviderFields.computeIfAbsent(
+ optionalKind,
+ kind -> {
+ FieldSpec field = absentOptionalProviderField(kind);
+ componentImplementation.addField(ABSENT_OPTIONAL_FIELD, field);
+ return field;
+ }))
+ .addCode("return provider;")
+ .build();
+ }
+
+ /**
+ * Creates a field specification for a {@code Provider<Optional<T>>} that always returns an absent
+ * value.
+ */
+ private FieldSpec absentOptionalProviderField(OptionalKind optionalKind) {
+ return FieldSpec.builder(
+ PROVIDER,
+ String.format("ABSENT_%s_PROVIDER", optionalKind.name()),
+ PRIVATE,
+ STATIC,
+ FINAL)
+ .addAnnotation(AnnotationSpecs.suppressWarnings(RAWTYPES))
+ .initializer("$T.create($L)", InstanceFactory.class, optionalKind.absentValueExpression())
+ .addJavadoc(
+ "A {@link $T} that returns {@code $L}.",
+ Provider.class,
+ optionalKind.absentValueExpression())
+ .build();
+ }
+
+ /** Information about the type of a factory for present bindings. */
+ @AutoValue
+ abstract static class PresentFactorySpec {
+ /** Whether the factory is a {@link Provider} or a {@link Producer}. */
+ abstract FrameworkType frameworkType();
+
+ /** What kind of {@code Optional} is returned. */
+ abstract OptionalKind optionalKind();
+
+ /** The kind of request satisfied by the value of the {@code Optional}. */
+ abstract RequestKind valueKind();
+
+ /** The type variable for the factory class. */
+ TypeVariableName typeVariable() {
+ return TypeVariableName.get("T");
+ }
+
+ /** The type contained by the {@code Optional}. */
+ TypeName valueType() {
+ return requestTypeName(valueKind(), typeVariable());
+ }
+
+ /** The type provided or produced by the factory. */
+ ParameterizedTypeName optionalType() {
+ return optionalKind().of(valueType());
+ }
+
+ /** The type of the factory. */
+ ParameterizedTypeName factoryType() {
+ return frameworkType().frameworkClassOf(optionalType());
+ }
+
+ /** The type of the delegate provider or producer. */
+ ParameterizedTypeName delegateType() {
+ return frameworkType().frameworkClassOf(typeVariable());
+ }
+
+ /** Returns the superclass the generated factory should have, if any. */
+ Optional<ParameterizedTypeName> superclass() {
+ switch (frameworkType()) {
+ case PRODUCER_NODE:
+ // TODO(cgdecker): This probably isn't a big issue for now, but it's possible this
+ // shouldn't be an AbstractProducer:
+ // - As AbstractProducer, it'll only call the delegate's get() method once and then cache
+ // that result (essentially) rather than calling the delegate's get() method each time
+ // its get() method is called (which was what it did before the cancellation change).
+ // - It's not 100% clear to me whether the view-creation methods should return a view of
+ // the same view created by the delegate or if they should just return their own views.
+ return Optional.of(abstractProducerOf(optionalType()));
+ default:
+ return Optional.empty();
+ }
+ }
+
+ /** Returns the superinterface the generated factory should have, if any. */
+ Optional<ParameterizedTypeName> superinterface() {
+ switch (frameworkType()) {
+ case PROVIDER:
+ return Optional.of(factoryType());
+ default:
+ return Optional.empty();
+ }
+ }
+
+ /** Returns the name of the factory method to generate. */
+ String factoryMethodName() {
+ switch (frameworkType()) {
+ case PROVIDER:
+ return "get";
+ case PRODUCER_NODE:
+ return "compute";
+ }
+ throw new AssertionError(frameworkType());
+ }
+
+ /** The name of the factory class. */
+ String factoryClassName() {
+ return new StringBuilder("Present")
+ .append(UPPER_UNDERSCORE.to(UPPER_CAMEL, optionalKind().name()))
+ .append(UPPER_UNDERSCORE.to(UPPER_CAMEL, valueKind().toString()))
+ .append(frameworkType().frameworkClass().getSimpleName())
+ .toString();
+ }
+
+ private static PresentFactorySpec of(ContributionBinding binding) {
+ return new AutoValue_OptionalFactories_PresentFactorySpec(
+ FrameworkType.forBindingType(binding.bindingType()),
+ OptionalType.from(binding.key()).kind(),
+ getOnlyElement(binding.dependencies()).kind());
+ }
+ }
+
+ /**
+ * Returns an expression for an instance of a nested class that implements {@code
+ * Provider<Optional<T>>} or {@code Producer<Optional<T>>} for a present optional binding, where
+ * {@code T} represents dependency requests of that kind.
+ *
+ * <ul>
+ * <li>If {@code optionalRequestKind} is {@link RequestKind#INSTANCE}, the class implements
+ * {@code ProviderOrProducer<Optional<T>>}.
+ * <li>If {@code optionalRequestKind} is {@link RequestKind#PROVIDER}, the class implements
+ * {@code Provider<Optional<Provider<T>>>}.
+ * <li>If {@code optionalRequestKind} is {@link RequestKind#LAZY}, the class implements {@code
+ * Provider<Optional<Lazy<T>>>}.
+ * <li>If {@code optionalRequestKind} is {@link RequestKind#PROVIDER_OF_LAZY}, the class
+ * implements {@code Provider<Optional<Provider<Lazy<T>>>>}.
+ * <li>If {@code optionalRequestKind} is {@link RequestKind#PRODUCER}, the class implements
+ * {@code Producer<Optional<Producer<T>>>}.
+ * <li>If {@code optionalRequestKind} is {@link RequestKind#PRODUCED}, the class implements
+ * {@code Producer<Optional<Produced<T>>>}.
+ * </ul>
+ *
+ * @param delegateFactory an expression for a {@link Provider} or {@link Producer} of the
+ * underlying type
+ */
+ CodeBlock presentOptionalFactory(ContributionBinding binding, CodeBlock delegateFactory) {
+ return CodeBlock.of(
+ "$N.of($L)",
+ presentFactoryClasses.computeIfAbsent(
+ PresentFactorySpec.of(binding),
+ spec -> {
+ TypeSpec type = presentOptionalFactoryClass(spec);
+ componentImplementation.addType(PRESENT_FACTORY, type);
+ return type;
+ }),
+ delegateFactory);
+ }
+
+ private TypeSpec presentOptionalFactoryClass(PresentFactorySpec spec) {
+ FieldSpec delegateField =
+ FieldSpec.builder(spec.delegateType(), "delegate", PRIVATE, FINAL).build();
+ ParameterSpec delegateParameter = ParameterSpec.builder(delegateField.type, "delegate").build();
+ TypeSpec.Builder factoryClassBuilder =
+ classBuilder(spec.factoryClassName())
+ .addTypeVariable(spec.typeVariable())
+ .addModifiers(PRIVATE, STATIC, FINAL)
+ .addJavadoc(
+ "A {@code $T} that uses a delegate {@code $T}.",
+ spec.factoryType(),
+ delegateField.type);
+
+ spec.superclass().ifPresent(factoryClassBuilder::superclass);
+ spec.superinterface().ifPresent(factoryClassBuilder::addSuperinterface);
+
+ return factoryClassBuilder
+ .addField(delegateField)
+ .addMethod(
+ constructorBuilder()
+ .addModifiers(PRIVATE)
+ .addParameter(delegateParameter)
+ .addCode(
+ "this.$N = $T.checkNotNull($N);",
+ delegateField,
+ Preconditions.class,
+ delegateParameter)
+ .build())
+ .addMethod(presentOptionalFactoryGetMethod(spec, delegateField))
+ .addMethod(
+ methodBuilder("of")
+ .addModifiers(PRIVATE, STATIC)
+ .addTypeVariable(spec.typeVariable())
+ .returns(spec.factoryType())
+ .addParameter(delegateParameter)
+ .addCode(
+ "return new $L<$T>($N);",
+ spec.factoryClassName(),
+ spec.typeVariable(),
+ delegateParameter)
+ .build())
+ .build();
+ }
+
+ private MethodSpec presentOptionalFactoryGetMethod(
+ PresentFactorySpec spec, FieldSpec delegateField) {
+ MethodSpec.Builder getMethodBuilder =
+ methodBuilder(spec.factoryMethodName()).addAnnotation(Override.class).addModifiers(PUBLIC);
+
+ switch (spec.frameworkType()) {
+ case PROVIDER:
+ return getMethodBuilder
+ .returns(spec.optionalType())
+ .addCode(
+ "return $L;",
+ spec.optionalKind()
+ .presentExpression(
+ FrameworkType.PROVIDER.to(
+ spec.valueKind(), CodeBlock.of("$N", delegateField))))
+ .build();
+
+ case PRODUCER_NODE:
+ getMethodBuilder.returns(listenableFutureOf(spec.optionalType()));
+
+ switch (spec.valueKind()) {
+ case FUTURE: // return a ListenableFuture<Optional<ListenableFuture<T>>>
+ case PRODUCER: // return a ListenableFuture<Optional<Producer<T>>>
+ return getMethodBuilder
+ .addCode(
+ "return $T.immediateFuture($L);",
+ Futures.class,
+ spec.optionalKind()
+ .presentExpression(
+ FrameworkType.PRODUCER_NODE.to(
+ spec.valueKind(), CodeBlock.of("$N", delegateField))))
+ .build();
+
+ case INSTANCE: // return a ListenableFuture<Optional<T>>
+ return getMethodBuilder
+ .addCode(
+ "return $L;",
+ transformFutureToOptional(
+ spec.optionalKind(),
+ spec.typeVariable(),
+ CodeBlock.of("$N.get()", delegateField)))
+ .build();
+
+ case PRODUCED: // return a ListenableFuture<Optional<Produced<T>>>
+ return getMethodBuilder
+ .addCode(
+ "return $L;",
+ transformFutureToOptional(
+ spec.optionalKind(),
+ spec.valueType(),
+ CodeBlock.of(
+ "$T.createFutureProduced($N.get())", Producers.class, delegateField)))
+ .build();
+
+ default:
+ throw new UnsupportedOperationException(
+ spec.factoryType() + " objects are not supported");
+ }
+ }
+ throw new AssertionError(spec.frameworkType());
+ }
+
+ /**
+ * An expression that uses {@link Futures#transform(ListenableFuture, Function, Executor)} to
+ * transform a {@code ListenableFuture<inputType>} into a {@code
+ * ListenableFuture<Optional<inputType>>}.
+ *
+ * @param inputFuture an expression of type {@code ListenableFuture<inputType>}
+ */
+ private static CodeBlock transformFutureToOptional(
+ OptionalKind optionalKind, TypeName inputType, CodeBlock inputFuture) {
+ return CodeBlock.of(
+ "$T.transform($L, $L, $T.directExecutor())",
+ Futures.class,
+ inputFuture,
+ anonymousClassBuilder("")
+ .addSuperinterface(
+ ParameterizedTypeName.get(
+ ClassName.get(Function.class), inputType, optionalKind.of(inputType)))
+ .addMethod(
+ methodBuilder("apply")
+ .addAnnotation(Override.class)
+ .addModifiers(PUBLIC)
+ .returns(optionalKind.of(inputType))
+ .addParameter(inputType, "input")
+ .addCode("return $L;", optionalKind.presentExpression(CodeBlock.of("input")))
+ .build())
+ .build(),
+ MoreExecutors.class);
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/OptionalFactoryInstanceCreationExpression.java b/java/dagger/internal/codegen/writing/OptionalFactoryInstanceCreationExpression.java
new file mode 100644
index 0000000..593921e
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/OptionalFactoryInstanceCreationExpression.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static dagger.internal.codegen.binding.BindingRequest.bindingRequest;
+
+import com.squareup.javapoet.CodeBlock;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.writing.FrameworkFieldInitializer.FrameworkInstanceCreationExpression;
+
+/**
+ * A {@link FrameworkInstanceCreationExpression} for {@link dagger.model.BindingKind#OPTIONAL
+ * optional bindings}.
+ */
+final class OptionalFactoryInstanceCreationExpression
+ implements FrameworkInstanceCreationExpression {
+ private final OptionalFactories optionalFactories;
+ private final ContributionBinding binding;
+ private final ComponentImplementation componentImplementation;
+ private final ComponentBindingExpressions componentBindingExpressions;
+
+ OptionalFactoryInstanceCreationExpression(
+ OptionalFactories optionalFactories,
+ ContributionBinding binding,
+ ComponentImplementation componentImplementation,
+ ComponentBindingExpressions componentBindingExpressions) {
+ this.optionalFactories = optionalFactories;
+ this.binding = binding;
+ this.componentImplementation = componentImplementation;
+ this.componentBindingExpressions = componentBindingExpressions;
+ }
+
+ @Override
+ public CodeBlock creationExpression() {
+ return binding.dependencies().isEmpty()
+ ? optionalFactories.absentOptionalProvider(binding)
+ : optionalFactories.presentOptionalFactory(
+ binding,
+ componentBindingExpressions
+ .getDependencyExpression(
+ bindingRequest(
+ getOnlyElement(binding.dependencies()).key(), binding.frameworkType()),
+ componentImplementation.name())
+ .codeBlock());
+ }
+
+ @Override
+ public boolean useInnerSwitchingProvider() {
+ // Share providers for empty optionals from OptionalFactories so we don't have numerous
+ // switch cases that all return Optional.empty().
+ return !binding.dependencies().isEmpty();
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/ParentComponent.java b/java/dagger/internal/codegen/writing/ParentComponent.java
new file mode 100644
index 0000000..20b946e
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/ParentComponent.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Retention;
+import javax.inject.Qualifier;
+
+/**
+ * A {@link Qualifier} for bindings that are associated with a component implementation's parent
+ * component.
+ */
+@Retention(RUNTIME)
+@Qualifier
+public @interface ParentComponent {}
diff --git a/java/dagger/internal/codegen/writing/PerComponentImplementation.java b/java/dagger/internal/codegen/writing/PerComponentImplementation.java
new file mode 100644
index 0000000..80888df
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/PerComponentImplementation.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Retention;
+import javax.inject.Scope;
+
+/** A {@link Scope} that encompasses a single component implementation. */
+@Retention(RUNTIME)
+@Scope
+public @interface PerComponentImplementation {}
diff --git a/java/dagger/internal/codegen/writing/PerGeneratedFile.java b/java/dagger/internal/codegen/writing/PerGeneratedFile.java
new file mode 100644
index 0000000..c1fcaf7
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/PerGeneratedFile.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Retention;
+import javax.inject.Scope;
+
+/**
+ * A {@link Scope} that encompasses a top-level component implementation and any of its inner
+ * descendant component implementations in the same generated file.
+ */
+@Retention(RUNTIME)
+@Scope
+public @interface PerGeneratedFile {}
diff --git a/java/dagger/internal/codegen/writing/PrivateMethodBindingExpression.java b/java/dagger/internal/codegen/writing/PrivateMethodBindingExpression.java
new file mode 100644
index 0000000..b6502ea
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/PrivateMethodBindingExpression.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static com.squareup.javapoet.MethodSpec.methodBuilder;
+import static dagger.internal.codegen.binding.AssistedInjectionAnnotations.assistedParameterSpecs;
+import static dagger.internal.codegen.writing.ComponentImplementation.MethodSpecKind.PRIVATE_METHOD;
+import static javax.lang.model.element.Modifier.PRIVATE;
+
+import com.google.common.collect.ImmutableList;
+import com.squareup.javapoet.TypeName;
+import dagger.internal.codegen.binding.BindingRequest;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.compileroption.CompilerOptions;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.BindingKind;
+
+/**
+ * A binding expression that wraps the dependency expressions in a private, no-arg method.
+ *
+ * <p>Dependents of this binding expression will just call the no-arg private method.
+ */
+final class PrivateMethodBindingExpression extends MethodBindingExpression {
+ private final ContributionBinding binding;
+ private final BindingRequest request;
+ private final ComponentImplementation componentImplementation;
+ private final CompilerOptions compilerOptions;
+ private final DaggerTypes types;
+ private String methodName;
+
+ PrivateMethodBindingExpression(
+ BindingRequest request,
+ ContributionBinding binding,
+ MethodImplementationStrategy methodImplementationStrategy,
+ BindingExpression wrappedBindingExpression,
+ ComponentImplementation componentImplementation,
+ DaggerTypes types,
+ CompilerOptions compilerOptions) {
+ super(
+ request,
+ binding,
+ methodImplementationStrategy,
+ wrappedBindingExpression,
+ componentImplementation,
+ types);
+ this.binding = binding;
+ this.request = checkNotNull(request);
+ this.componentImplementation = checkNotNull(componentImplementation);
+ this.compilerOptions = checkNotNull(compilerOptions);
+ this.types = types;
+ }
+
+ @Override
+ protected void addMethod() {
+ if (methodName == null) {
+ // Have to set methodName field before implementing the method in order to handle recursion.
+ methodName = componentImplementation.getUniqueMethodName(request);
+
+ // TODO(bcorso): Fix the order that these generated methods are written to the component.
+ componentImplementation.addMethod(
+ PRIVATE_METHOD,
+ methodBuilder(methodName)
+ .addModifiers(PRIVATE)
+ .addParameters(
+ // Private methods for assisted injection take assisted parameters as input.
+ binding.kind() == BindingKind.ASSISTED_INJECTION
+ ? assistedParameterSpecs(binding, types)
+ : ImmutableList.of())
+ .returns(TypeName.get(returnType()))
+ .addCode(methodBody())
+ .build());
+ }
+ }
+
+ @Override
+ protected String methodName() {
+ checkState(methodName != null, "addMethod() must be called before methodName()");
+ return methodName;
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/ProducerCreationExpression.java b/java/dagger/internal/codegen/writing/ProducerCreationExpression.java
new file mode 100644
index 0000000..0d1ccf3
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/ProducerCreationExpression.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static dagger.internal.codegen.binding.SourceFiles.generatedClassNameForBinding;
+
+import com.squareup.javapoet.CodeBlock;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.writing.FrameworkFieldInitializer.FrameworkInstanceCreationExpression;
+
+/**
+ * A {@link dagger.producers.Producer} creation expression for a {@link
+ * dagger.producers.Produces @Produces}-annotated module method.
+ */
+// TODO(dpb): Resolve with InjectionOrProvisionProviderCreationExpression.
+final class ProducerCreationExpression implements FrameworkInstanceCreationExpression {
+
+ private final ComponentBindingExpressions componentBindingExpressions;
+ private final ContributionBinding binding;
+
+ ProducerCreationExpression(
+ ContributionBinding binding, ComponentBindingExpressions componentBindingExpressions) {
+ this.binding = checkNotNull(binding);
+ this.componentBindingExpressions = checkNotNull(componentBindingExpressions);
+ }
+
+ @Override
+ public CodeBlock creationExpression() {
+ return CodeBlock.of(
+ "$T.create($L)",
+ generatedClassNameForBinding(binding),
+ componentBindingExpressions.getCreateMethodArgumentsCodeBlock(binding));
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/ProducerEntryPointView.java b/java/dagger/internal/codegen/writing/ProducerEntryPointView.java
new file mode 100644
index 0000000..c58f4e0
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/ProducerEntryPointView.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static dagger.internal.codegen.writing.ComponentImplementation.FieldSpecKind.FRAMEWORK_FIELD;
+import static javax.lang.model.element.Modifier.PRIVATE;
+
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.TypeName;
+import dagger.internal.codegen.binding.ComponentDescriptor.ComponentMethodDescriptor;
+import dagger.internal.codegen.javapoet.Expression;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.RequestKind;
+import dagger.producers.Producer;
+import dagger.producers.internal.CancellationListener;
+import dagger.producers.internal.Producers;
+import java.util.Optional;
+import javax.lang.model.type.TypeMirror;
+
+/**
+ * A factory of {@linkplain Producers#entryPointViewOf(Producer, CancellationListener) entry point
+ * views} of {@link Producer}s.
+ */
+final class ProducerEntryPointView {
+ private final DaggerTypes types;
+
+ ProducerEntryPointView(DaggerTypes types) {
+ this.types = types;
+ }
+
+ /**
+ * Returns an expression for an {@linkplain Producers#entryPointViewOf(Producer,
+ * CancellationListener) entry point view} of a producer if the component method returns a {@link
+ * Producer} or {@link com.google.common.util.concurrent.ListenableFuture}.
+ *
+ * <p>This is intended to be a replacement implementation for {@link
+ * dagger.internal.codegen.writing.BindingExpression#getDependencyExpressionForComponentMethod(ComponentMethodDescriptor,
+ * ComponentImplementation)}, and in cases where {@link Optional#empty()} is returned, callers
+ * should call {@code super.getDependencyExpressionForComponentMethod()}.
+ */
+ Optional<Expression> getProducerEntryPointField(
+ BindingExpression producerExpression,
+ ComponentMethodDescriptor componentMethod,
+ ComponentImplementation component) {
+ if (component.componentDescriptor().isProduction()
+ && (componentMethod.dependencyRequest().get().kind().equals(RequestKind.FUTURE)
+ || componentMethod.dependencyRequest().get().kind().equals(RequestKind.PRODUCER))) {
+ return Optional.of(
+ Expression.create(
+ fieldType(componentMethod),
+ "$N",
+ createField(producerExpression, componentMethod, component)));
+ } else {
+ // If the component isn't a production component, it won't implement CancellationListener and
+ // as such we can't create an entry point. But this binding must also just be a Producer from
+ // Provider anyway in that case, so there shouldn't be an issue.
+ // TODO(b/116855531): Is it really intended that a non-production component can have Producer
+ // entry points?
+ return Optional.empty();
+ }
+ }
+
+ private FieldSpec createField(
+ BindingExpression producerExpression,
+ ComponentMethodDescriptor componentMethod,
+ ComponentImplementation component) {
+ // TODO(cgdecker): Use a FrameworkFieldInitializer for this?
+ // Though I don't think we need the once-only behavior of that, since I think
+ // getComponentMethodImplementation will only be called once anyway
+ String methodName = componentMethod.methodElement().getSimpleName().toString();
+ FieldSpec field =
+ FieldSpec.builder(
+ TypeName.get(fieldType(componentMethod)),
+ component.getUniqueFieldName(methodName + "EntryPoint"),
+ PRIVATE)
+ .build();
+ component.addField(FRAMEWORK_FIELD, field);
+
+ CodeBlock fieldInitialization =
+ CodeBlock.of(
+ "this.$N = $T.entryPointViewOf($L, this);",
+ field,
+ Producers.class,
+ producerExpression.getDependencyExpression(component.name()).codeBlock());
+ component.addInitialization(fieldInitialization);
+
+ return field;
+ }
+
+ // TODO(cgdecker): Can we use producerExpression.getDependencyExpression().type() instead of
+ // needing to (re)compute this?
+ private TypeMirror fieldType(ComponentMethodDescriptor componentMethod) {
+ return types.wrapType(componentMethod.dependencyRequest().get().key().type(), Producer.class);
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/ProducerFactoryGenerator.java b/java/dagger/internal/codegen/writing/ProducerFactoryGenerator.java
new file mode 100644
index 0000000..5e52923
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/ProducerFactoryGenerator.java
@@ -0,0 +1,567 @@
+/*
+ * Copyright (C) 2014 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Verify.verifyNotNull;
+import static com.squareup.javapoet.ClassName.OBJECT;
+import static com.squareup.javapoet.MethodSpec.constructorBuilder;
+import static com.squareup.javapoet.MethodSpec.methodBuilder;
+import static com.squareup.javapoet.TypeSpec.classBuilder;
+import static dagger.internal.codegen.binding.SourceFiles.bindingTypeElementTypeVariableNames;
+import static dagger.internal.codegen.binding.SourceFiles.generateBindingFieldsForDependencies;
+import static dagger.internal.codegen.binding.SourceFiles.generatedClassNameForBinding;
+import static dagger.internal.codegen.binding.SourceFiles.parameterizedGeneratedTypeNameForBinding;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
+import static dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression.FUTURE_RETURN_VALUE_IGNORED;
+import static dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression.UNCHECKED;
+import static dagger.internal.codegen.javapoet.CodeBlocks.makeParametersCodeBlock;
+import static dagger.internal.codegen.javapoet.CodeBlocks.toParametersCodeBlock;
+import static dagger.internal.codegen.javapoet.TypeNames.FUTURES;
+import static dagger.internal.codegen.javapoet.TypeNames.PRODUCERS;
+import static dagger.internal.codegen.javapoet.TypeNames.PRODUCER_TOKEN;
+import static dagger.internal.codegen.javapoet.TypeNames.VOID_CLASS;
+import static dagger.internal.codegen.javapoet.TypeNames.listOf;
+import static dagger.internal.codegen.javapoet.TypeNames.listenableFutureOf;
+import static dagger.internal.codegen.javapoet.TypeNames.producedOf;
+import static dagger.internal.codegen.writing.GwtCompatibility.gwtIncompatibleAnnotation;
+import static java.util.stream.Collectors.joining;
+import static javax.lang.model.element.Modifier.FINAL;
+import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.PROTECTED;
+import static javax.lang.model.element.Modifier.PUBLIC;
+import static javax.lang.model.element.Modifier.STATIC;
+
+import com.google.common.collect.FluentIterable;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterizedTypeName;
+import com.squareup.javapoet.TypeName;
+import com.squareup.javapoet.TypeSpec;
+import dagger.internal.codegen.base.SourceFileGenerator;
+import dagger.internal.codegen.base.UniqueNameSet;
+import dagger.internal.codegen.binding.Binding;
+import dagger.internal.codegen.binding.FrameworkField;
+import dagger.internal.codegen.binding.KeyFactory;
+import dagger.internal.codegen.binding.ProductionBinding;
+import dagger.internal.codegen.binding.SourceFiles;
+import dagger.internal.codegen.compileroption.CompilerOptions;
+import dagger.internal.codegen.javapoet.AnnotationSpecs;
+import dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression;
+import dagger.internal.codegen.javapoet.TypeNames;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.model.DependencyRequest;
+import dagger.model.Key;
+import dagger.model.RequestKind;
+import dagger.producers.Producer;
+import dagger.producers.internal.AbstractProducesMethodProducer;
+import dagger.producers.internal.Producers;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.Optional;
+import javax.annotation.processing.Filer;
+import javax.inject.Inject;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Element;
+import javax.lang.model.type.TypeMirror;
+
+/** Generates {@link Producer} implementations from {@link ProductionBinding} instances. */
+public final class ProducerFactoryGenerator extends SourceFileGenerator<ProductionBinding> {
+ private final CompilerOptions compilerOptions;
+ private final KeyFactory keyFactory;
+
+ @Inject
+ ProducerFactoryGenerator(
+ Filer filer,
+ DaggerElements elements,
+ SourceVersion sourceVersion,
+ CompilerOptions compilerOptions,
+ KeyFactory keyFactory) {
+ super(filer, elements, sourceVersion);
+ this.compilerOptions = compilerOptions;
+ this.keyFactory = keyFactory;
+ }
+
+ @Override
+ public ClassName nameGeneratedType(ProductionBinding binding) {
+ return generatedClassNameForBinding(binding);
+ }
+
+ @Override
+ public Element originatingElement(ProductionBinding binding) {
+ // we only create factories for bindings that have a binding element
+ return binding.bindingElement().get();
+ }
+
+ @Override
+ public Optional<TypeSpec.Builder> write(ProductionBinding binding) {
+ // We don't want to write out resolved bindings -- we want to write out the generic version.
+ checkArgument(!binding.unresolved().isPresent());
+ checkArgument(binding.bindingElement().isPresent());
+
+ TypeName providedTypeName = TypeName.get(binding.contributedType());
+ TypeName futureTypeName = listenableFutureOf(providedTypeName);
+
+ ClassName generatedTypeName = nameGeneratedType(binding);
+ TypeSpec.Builder factoryBuilder =
+ classBuilder(generatedTypeName)
+ .addModifiers(PUBLIC, FINAL)
+ .addTypeVariables(bindingTypeElementTypeVariableNames(binding));
+
+ UniqueNameSet uniqueFieldNames = new UniqueNameSet();
+ ImmutableMap.Builder<DependencyRequest, FieldSpec> fieldsBuilder = ImmutableMap.builder();
+
+ MethodSpec.Builder constructorBuilder = constructorBuilder().addModifiers(PRIVATE);
+
+ Optional<FieldSpec> moduleField =
+ binding.requiresModuleInstance()
+ ? Optional.of(
+ addFieldAndConstructorParameter(
+ factoryBuilder,
+ constructorBuilder,
+ uniqueFieldNames.getUniqueName("module"),
+ TypeName.get(binding.bindingTypeElement().get().asType())))
+ : Optional.empty();
+
+ List<CodeBlock> frameworkFieldAssignments = new ArrayList<>();
+
+ String executorParameterName = null;
+ String monitorParameterName = null;
+ ImmutableMap<DependencyRequest, FrameworkField> bindingFieldsForDependencies =
+ generateBindingFieldsForDependencies(binding);
+ for (Entry<DependencyRequest, FrameworkField> entry : bindingFieldsForDependencies.entrySet()) {
+ DependencyRequest dependency = entry.getKey();
+ Key key = dependency.key();
+ FrameworkField bindingField = entry.getValue();
+ String fieldName = uniqueFieldNames.getUniqueName(bindingField.name());
+ if (key.equals(keyFactory.forProductionImplementationExecutor())) {
+ executorParameterName = fieldName;
+ constructorBuilder.addParameter(bindingField.type(), executorParameterName);
+ } else if (key.equals(keyFactory.forProductionComponentMonitor())) {
+ monitorParameterName = fieldName;
+ constructorBuilder.addParameter(bindingField.type(), monitorParameterName);
+ } else {
+ FieldSpec field =
+ addFieldAndConstructorParameter(
+ factoryBuilder, constructorBuilder, fieldName, bindingField.type());
+ fieldsBuilder.put(dependency, field);
+ frameworkFieldAssignments.add(fieldAssignment(field, bindingField.type()));
+ }
+ }
+ ImmutableMap<DependencyRequest, FieldSpec> fields = fieldsBuilder.build();
+
+ constructorBuilder.addStatement(
+ "super($N, $L, $N)",
+ verifyNotNull(monitorParameterName),
+ producerTokenConstruction(generatedTypeName, binding),
+ verifyNotNull(executorParameterName));
+
+ if (binding.requiresModuleInstance()) {
+ assignField(constructorBuilder, moduleField.get(), null);
+ }
+
+ constructorBuilder.addCode(CodeBlock.join(frameworkFieldAssignments, "\n"));
+
+ MethodSpec.Builder collectDependenciesBuilder =
+ methodBuilder("collectDependencies").addAnnotation(Override.class).addModifiers(PROTECTED);
+
+ ImmutableList<DependencyRequest> asyncDependencies = asyncDependencies(binding);
+ for (DependencyRequest dependency : asyncDependencies) {
+ TypeName futureType = listenableFutureOf(asyncDependencyType(dependency));
+ CodeBlock futureAccess = CodeBlock.of("$N.get()", fields.get(dependency));
+ collectDependenciesBuilder.addStatement(
+ "$T $L = $L",
+ futureType,
+ dependencyFutureName(dependency),
+ dependency.kind().equals(RequestKind.PRODUCED)
+ ? CodeBlock.of("$T.createFutureProduced($L)", PRODUCERS, futureAccess)
+ : futureAccess);
+ }
+ FutureTransform futureTransform = FutureTransform.create(fields, binding, asyncDependencies);
+
+ collectDependenciesBuilder
+ .returns(listenableFutureOf(futureTransform.applyArgType()))
+ .addStatement("return $L", futureTransform.futureCodeBlock());
+
+ MethodSpec.Builder callProducesMethod =
+ methodBuilder("callProducesMethod")
+ .returns(futureTypeName)
+ .addAnnotation(Override.class)
+ .addModifiers(PUBLIC)
+ .addParameter(futureTransform.applyArgType(), futureTransform.applyArgName())
+ .addExceptions(getThrownTypeNames(binding.thrownTypes()))
+ .addCode(
+ getInvocationCodeBlock(
+ binding, providedTypeName, futureTransform.parameterCodeBlocks()));
+ if (futureTransform.hasUncheckedCast()) {
+ callProducesMethod.addAnnotation(AnnotationSpecs.suppressWarnings(UNCHECKED));
+ }
+
+ MethodSpec constructor = constructorBuilder.build();
+ factoryBuilder
+ .superclass(
+ ParameterizedTypeName.get(
+ ClassName.get(AbstractProducesMethodProducer.class),
+ futureTransform.applyArgType(),
+ providedTypeName))
+ .addMethod(constructor)
+ .addMethod(staticFactoryMethod(binding, constructor))
+ .addMethod(collectDependenciesBuilder.build())
+ .addMethod(callProducesMethod.build());
+
+ gwtIncompatibleAnnotation(binding).ifPresent(factoryBuilder::addAnnotation);
+
+ // TODO(gak): write a sensible toString
+ return Optional.of(factoryBuilder);
+ }
+
+ private MethodSpec staticFactoryMethod(ProductionBinding binding, MethodSpec constructor) {
+ return MethodSpec.methodBuilder("create")
+ .addModifiers(PUBLIC, STATIC)
+ .returns(parameterizedGeneratedTypeNameForBinding(binding))
+ .addTypeVariables(bindingTypeElementTypeVariableNames(binding))
+ .addParameters(constructor.parameters)
+ .addStatement(
+ "return new $T($L)",
+ parameterizedGeneratedTypeNameForBinding(binding),
+ constructor.parameters.stream()
+ .map(p -> CodeBlock.of("$N", p.name))
+ .collect(toParametersCodeBlock()))
+ .build();
+ }
+
+ // TODO(ronshapiro): consolidate versions of these
+ private static FieldSpec addFieldAndConstructorParameter(
+ TypeSpec.Builder typeBuilder,
+ MethodSpec.Builder constructorBuilder,
+ String variableName,
+ TypeName variableType) {
+ FieldSpec field = FieldSpec.builder(variableType, variableName, PRIVATE, FINAL).build();
+ typeBuilder.addField(field);
+ constructorBuilder.addParameter(field.type, field.name);
+ return field;
+ }
+
+ private static CodeBlock fieldAssignment(FieldSpec field, ParameterizedTypeName type) {
+ CodeBlock.Builder statement = CodeBlock.builder();
+ if (type != null && type.rawType.equals(TypeNames.PRODUCER)) {
+ statement.addStatement(
+ "this.$1N = $2T.nonCancellationPropagatingViewOf($1N)", field, Producers.class);
+ } else {
+ statement.addStatement("this.$1N = $1N", field);
+ }
+ return statement.build();
+ }
+
+ private static void assignField(
+ MethodSpec.Builder constructorBuilder, FieldSpec field, ParameterizedTypeName type) {
+ if (type != null && type.rawType.equals(TypeNames.PRODUCER)) {
+ constructorBuilder.addStatement(
+ "this.$1N = $2T.nonCancellationPropagatingViewOf($1N)", field, Producers.class);
+ } else {
+ constructorBuilder.addStatement("this.$1N = $1N", field);
+ }
+ }
+
+ /** Returns a list of dependencies that are generated asynchronously. */
+ private static ImmutableList<DependencyRequest> asyncDependencies(Binding binding) {
+ return binding.dependencies().stream()
+ .filter(ProducerFactoryGenerator::isAsyncDependency)
+ .collect(toImmutableList());
+ }
+
+ private CodeBlock producerTokenConstruction(
+ ClassName generatedTypeName, ProductionBinding binding) {
+ CodeBlock producerTokenArgs =
+ compilerOptions.writeProducerNameInToken()
+ ? CodeBlock.of(
+ "$S",
+ String.format(
+ "%s#%s",
+ ClassName.get(binding.bindingTypeElement().get()),
+ binding.bindingElement().get().getSimpleName()))
+ : CodeBlock.of("$T.class", generatedTypeName);
+ return CodeBlock.of("$T.create($L)", PRODUCER_TOKEN, producerTokenArgs);
+ }
+
+ /** Returns a name of the variable representing this dependency's future. */
+ private static String dependencyFutureName(DependencyRequest dependency) {
+ return dependency.requestElement().get().getSimpleName() + "Future";
+ }
+
+ /** Represents the transformation of an input future by a producer method. */
+ abstract static class FutureTransform {
+ protected final ImmutableMap<DependencyRequest, FieldSpec> fields;
+ protected final ProductionBinding binding;
+
+ FutureTransform(ImmutableMap<DependencyRequest, FieldSpec> fields, ProductionBinding binding) {
+ this.fields = fields;
+ this.binding = binding;
+ }
+
+ /** The code block representing the future that should be transformed. */
+ abstract CodeBlock futureCodeBlock();
+
+ /** The type of the argument to the apply method. */
+ abstract TypeName applyArgType();
+
+ /** The name of the argument to the apply method */
+ abstract String applyArgName();
+
+ /** The code blocks to be passed to the produces method itself. */
+ abstract ImmutableList<CodeBlock> parameterCodeBlocks();
+
+ /** Whether the transform method has an unchecked cast. */
+ boolean hasUncheckedCast() {
+ return false;
+ }
+
+ CodeBlock frameworkTypeUsageStatement(DependencyRequest dependency) {
+ return SourceFiles.frameworkTypeUsageStatement(
+ CodeBlock.of("$N", fields.get(dependency)), dependency.kind());
+ }
+
+ static FutureTransform create(
+ ImmutableMap<DependencyRequest, FieldSpec> fields,
+ ProductionBinding binding,
+ ImmutableList<DependencyRequest> asyncDependencies) {
+ if (asyncDependencies.isEmpty()) {
+ return new NoArgFutureTransform(fields, binding);
+ } else if (asyncDependencies.size() == 1) {
+ return new SingleArgFutureTransform(
+ fields, binding, Iterables.getOnlyElement(asyncDependencies));
+ } else {
+ return new MultiArgFutureTransform(fields, binding, asyncDependencies);
+ }
+ }
+ }
+
+ static final class NoArgFutureTransform extends FutureTransform {
+ NoArgFutureTransform(
+ ImmutableMap<DependencyRequest, FieldSpec> fields, ProductionBinding binding) {
+ super(fields, binding);
+ }
+
+ @Override
+ CodeBlock futureCodeBlock() {
+ return CodeBlock.of("$T.<$T>immediateFuture(null)", FUTURES, VOID_CLASS);
+ }
+
+ @Override
+ TypeName applyArgType() {
+ return VOID_CLASS;
+ }
+
+ @Override
+ String applyArgName() {
+ return "ignoredVoidArg";
+ }
+
+ @Override
+ ImmutableList<CodeBlock> parameterCodeBlocks() {
+ return binding.explicitDependencies().stream()
+ .map(this::frameworkTypeUsageStatement)
+ .collect(toImmutableList());
+ }
+ }
+
+ static final class SingleArgFutureTransform extends FutureTransform {
+ private final DependencyRequest asyncDependency;
+
+ SingleArgFutureTransform(
+ ImmutableMap<DependencyRequest, FieldSpec> fields,
+ ProductionBinding binding,
+ DependencyRequest asyncDependency) {
+ super(fields, binding);
+ this.asyncDependency = asyncDependency;
+ }
+
+ @Override
+ CodeBlock futureCodeBlock() {
+ return CodeBlock.of("$L", dependencyFutureName(asyncDependency));
+ }
+
+ @Override
+ TypeName applyArgType() {
+ return asyncDependencyType(asyncDependency);
+ }
+
+ @Override
+ String applyArgName() {
+ String argName = asyncDependency.requestElement().get().getSimpleName().toString();
+ if (argName.equals("module")) {
+ return "moduleArg";
+ }
+ return argName;
+ }
+
+ @Override
+ ImmutableList<CodeBlock> parameterCodeBlocks() {
+ ImmutableList.Builder<CodeBlock> parameterCodeBlocks = ImmutableList.builder();
+ for (DependencyRequest dependency : binding.explicitDependencies()) {
+ // We really want to compare instances here, because asyncDependency is an element in the
+ // set binding.dependencies().
+ if (dependency == asyncDependency) {
+ parameterCodeBlocks.add(CodeBlock.of("$L", applyArgName()));
+ } else {
+ parameterCodeBlocks.add(frameworkTypeUsageStatement(dependency));
+ }
+ }
+ return parameterCodeBlocks.build();
+ }
+ }
+
+ static final class MultiArgFutureTransform extends FutureTransform {
+ private final ImmutableList<DependencyRequest> asyncDependencies;
+
+ MultiArgFutureTransform(
+ ImmutableMap<DependencyRequest, FieldSpec> fields,
+ ProductionBinding binding,
+ ImmutableList<DependencyRequest> asyncDependencies) {
+ super(fields, binding);
+ this.asyncDependencies = asyncDependencies;
+ }
+
+ @Override
+ CodeBlock futureCodeBlock() {
+ return CodeBlock.of(
+ "$T.<$T>allAsList($L)",
+ FUTURES,
+ OBJECT,
+ asyncDependencies
+ .stream()
+ .map(ProducerFactoryGenerator::dependencyFutureName)
+ .collect(joining(", ")));
+ }
+
+ @Override
+ TypeName applyArgType() {
+ return listOf(OBJECT);
+ }
+
+ @Override
+ String applyArgName() {
+ return "args";
+ }
+
+ @Override
+ ImmutableList<CodeBlock> parameterCodeBlocks() {
+ int argIndex = 0;
+ ImmutableList.Builder<CodeBlock> codeBlocks = ImmutableList.builder();
+ for (DependencyRequest dependency : binding.explicitDependencies()) {
+ if (isAsyncDependency(dependency)) {
+ codeBlocks.add(
+ CodeBlock.of(
+ "($T) $L.get($L)", asyncDependencyType(dependency), applyArgName(), argIndex));
+ argIndex++;
+ } else {
+ codeBlocks.add(frameworkTypeUsageStatement(dependency));
+ }
+ }
+ return codeBlocks.build();
+ }
+
+ @Override
+ boolean hasUncheckedCast() {
+ return true;
+ }
+ }
+
+ private static boolean isAsyncDependency(DependencyRequest dependency) {
+ switch (dependency.kind()) {
+ case INSTANCE:
+ case PRODUCED:
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ private static TypeName asyncDependencyType(DependencyRequest dependency) {
+ TypeName keyName = TypeName.get(dependency.key().type());
+ switch (dependency.kind()) {
+ case INSTANCE:
+ return keyName;
+ case PRODUCED:
+ return producedOf(keyName);
+ default:
+ throw new AssertionError();
+ }
+ }
+
+ /**
+ * Creates a code block for the invocation of the producer method from the module, which should be
+ * used entirely within a method body.
+ *
+ * @param binding The binding to generate the invocation code block for.
+ * @param providedTypeName The type name that should be provided by this producer.
+ * @param parameterCodeBlocks The code blocks for all the parameters to the producer method.
+ */
+ private CodeBlock getInvocationCodeBlock(
+ ProductionBinding binding,
+ TypeName providedTypeName,
+ ImmutableList<CodeBlock> parameterCodeBlocks) {
+ CodeBlock moduleCodeBlock =
+ CodeBlock.of(
+ "$L.$L($L)",
+ binding.requiresModuleInstance()
+ ? "module"
+ : CodeBlock.of("$T", ClassName.get(binding.bindingTypeElement().get())),
+ binding.bindingElement().get().getSimpleName(),
+ makeParametersCodeBlock(parameterCodeBlocks));
+
+ final CodeBlock returnCodeBlock;
+ switch (binding.productionKind().get()) {
+ case IMMEDIATE:
+ returnCodeBlock =
+ CodeBlock.of("$T.<$T>immediateFuture($L)", FUTURES, providedTypeName, moduleCodeBlock);
+ break;
+ case FUTURE:
+ returnCodeBlock = moduleCodeBlock;
+ break;
+ case SET_OF_FUTURE:
+ returnCodeBlock = CodeBlock.of("$T.allAsSet($L)", PRODUCERS, moduleCodeBlock);
+ break;
+ default:
+ throw new AssertionError();
+ }
+ return CodeBlock.of("return $L;", returnCodeBlock);
+ }
+
+ /**
+ * Converts the list of thrown types into type names.
+ *
+ * @param thrownTypes the list of thrown types.
+ */
+ private FluentIterable<? extends TypeName> getThrownTypeNames(
+ Iterable<? extends TypeMirror> thrownTypes) {
+ return FluentIterable.from(thrownTypes).transform(TypeName::get);
+ }
+
+ @Override
+ protected ImmutableSet<Suppression> warningSuppressions() {
+ // TODO(beder): examine if we can remove this or prevent subtypes of Future from being produced
+ return ImmutableSet.of(FUTURE_RETURN_VALUE_IGNORED);
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/ProducerFromProviderCreationExpression.java b/java/dagger/internal/codegen/writing/ProducerFromProviderCreationExpression.java
new file mode 100644
index 0000000..9b0d4e8
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/ProducerFromProviderCreationExpression.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static dagger.internal.codegen.binding.BindingRequest.bindingRequest;
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.binding.FrameworkType;
+import dagger.internal.codegen.javapoet.TypeNames;
+import dagger.internal.codegen.writing.FrameworkFieldInitializer.FrameworkInstanceCreationExpression;
+import dagger.model.RequestKind;
+import dagger.producers.Producer;
+import java.util.Optional;
+
+/** An {@link Producer} creation expression for provision bindings. */
+final class ProducerFromProviderCreationExpression implements FrameworkInstanceCreationExpression {
+ private final ContributionBinding binding;
+ private final ComponentImplementation componentImplementation;
+ private final ComponentBindingExpressions componentBindingExpressions;
+
+ ProducerFromProviderCreationExpression(
+ ContributionBinding binding,
+ ComponentImplementation componentImplementation,
+ ComponentBindingExpressions componentBindingExpressions) {
+ this.binding = checkNotNull(binding);
+ this.componentImplementation = checkNotNull(componentImplementation);
+ this.componentBindingExpressions = checkNotNull(componentBindingExpressions);
+ }
+
+ @Override
+ public CodeBlock creationExpression() {
+ return FrameworkType.PROVIDER.to(
+ RequestKind.PRODUCER,
+ componentBindingExpressions
+ .getDependencyExpression(
+ bindingRequest(binding.key(), FrameworkType.PROVIDER),
+ componentImplementation.name())
+ .codeBlock());
+ }
+
+ @Override
+ public Optional<ClassName> alternativeFrameworkClass() {
+ return Optional.of(TypeNames.PRODUCER);
+ }
+
+ // TODO(ronshapiro): should this have a simple factory if the delegate expression is simple?
+}
diff --git a/java/dagger/internal/codegen/writing/ProducerNodeInstanceBindingExpression.java b/java/dagger/internal/codegen/writing/ProducerNodeInstanceBindingExpression.java
new file mode 100644
index 0000000..0d3f7e8
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/ProducerNodeInstanceBindingExpression.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.squareup.javapoet.ClassName;
+import dagger.internal.codegen.binding.ComponentDescriptor.ComponentMethodDescriptor;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.binding.FrameworkType;
+import dagger.internal.codegen.javapoet.Expression;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.Key;
+
+/** Binding expression for producer node instances. */
+final class ProducerNodeInstanceBindingExpression extends FrameworkInstanceBindingExpression {
+ /** The component defining this binding. */
+ private final ComponentImplementation componentImplementation;
+ private final Key key;
+ private final ProducerEntryPointView producerEntryPointView;
+
+ ProducerNodeInstanceBindingExpression(
+ ContributionBinding binding,
+ FrameworkInstanceSupplier frameworkInstanceSupplier,
+ DaggerTypes types,
+ DaggerElements elements,
+ ComponentImplementation componentImplementation) {
+ super(binding, frameworkInstanceSupplier, types, elements);
+ this.componentImplementation = checkNotNull(componentImplementation);
+ this.key = binding.key();
+ this.producerEntryPointView = new ProducerEntryPointView(types);
+ }
+
+ @Override
+ protected FrameworkType frameworkType() {
+ return FrameworkType.PRODUCER_NODE;
+ }
+
+ @Override
+ Expression getDependencyExpression(ClassName requestingClass) {
+ Expression result = super.getDependencyExpression(requestingClass);
+ componentImplementation.addCancellableProducerKey(key);
+ return result;
+ }
+
+ @Override
+ Expression getDependencyExpressionForComponentMethod(
+ ComponentMethodDescriptor componentMethod, ComponentImplementation component) {
+ return producerEntryPointView
+ .getProducerEntryPointField(this, componentMethod, component)
+ .orElseGet(
+ () -> super.getDependencyExpressionForComponentMethod(componentMethod, component));
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/ProviderInstanceBindingExpression.java b/java/dagger/internal/codegen/writing/ProviderInstanceBindingExpression.java
new file mode 100644
index 0000000..400c6a2
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/ProviderInstanceBindingExpression.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.binding.FrameworkType;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+
+/** Binding expression for provider instances. */
+final class ProviderInstanceBindingExpression extends FrameworkInstanceBindingExpression {
+
+ ProviderInstanceBindingExpression(
+ ContributionBinding binding,
+ FrameworkInstanceSupplier frameworkInstanceSupplier,
+ DaggerTypes types,
+ DaggerElements elements) {
+ super(
+ binding,
+ frameworkInstanceSupplier,
+ types,
+ elements);
+ }
+
+ @Override
+ protected FrameworkType frameworkType() {
+ return FrameworkType.PROVIDER;
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/SetBindingExpression.java b/java/dagger/internal/codegen/writing/SetBindingExpression.java
new file mode 100644
index 0000000..0b2e11a
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/SetBindingExpression.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static dagger.internal.codegen.binding.BindingRequest.bindingRequest;
+import static dagger.internal.codegen.javapoet.CodeBlocks.toParametersCodeBlock;
+import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
+import static javax.lang.model.util.ElementFilter.methodsIn;
+
+import com.google.common.collect.ImmutableSet;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import dagger.internal.SetBuilder;
+import dagger.internal.codegen.base.ContributionType;
+import dagger.internal.codegen.base.SetType;
+import dagger.internal.codegen.binding.BindingGraph;
+import dagger.internal.codegen.binding.ProvisionBinding;
+import dagger.internal.codegen.javapoet.Expression;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.DependencyRequest;
+import java.util.Collections;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeMirror;
+
+/** A binding expression for multibound sets. */
+final class SetBindingExpression extends SimpleInvocationBindingExpression {
+ private final ProvisionBinding binding;
+ private final BindingGraph graph;
+ private final ComponentBindingExpressions componentBindingExpressions;
+ private final DaggerTypes types;
+ private final DaggerElements elements;
+
+ SetBindingExpression(
+ ProvisionBinding binding,
+ BindingGraph graph,
+ ComponentBindingExpressions componentBindingExpressions,
+ DaggerTypes types,
+ DaggerElements elements) {
+ super(binding);
+ this.binding = binding;
+ this.graph = graph;
+ this.componentBindingExpressions = componentBindingExpressions;
+ this.types = types;
+ this.elements = elements;
+ }
+
+ @Override
+ Expression getDependencyExpression(ClassName requestingClass) {
+ // TODO(ronshapiro): We should also make an ImmutableSet version of SetFactory
+ boolean isImmutableSetAvailable = isImmutableSetAvailable();
+ // TODO(ronshapiro, gak): Use Sets.immutableEnumSet() if it's available?
+ if (isImmutableSetAvailable && binding.dependencies().stream().allMatch(this::isSingleValue)) {
+ return Expression.create(
+ immutableSetType(),
+ CodeBlock.builder()
+ .add("$T.", ImmutableSet.class)
+ .add(maybeTypeParameter(requestingClass))
+ .add(
+ "of($L)",
+ binding
+ .dependencies()
+ .stream()
+ .map(dependency -> getContributionExpression(dependency, requestingClass))
+ .collect(toParametersCodeBlock()))
+ .build());
+ }
+ switch (binding.dependencies().size()) {
+ case 0:
+ return collectionsStaticFactoryInvocation(requestingClass, CodeBlock.of("emptySet()"));
+ case 1:
+ {
+ DependencyRequest dependency = getOnlyElement(binding.dependencies());
+ CodeBlock contributionExpression = getContributionExpression(dependency, requestingClass);
+ if (isSingleValue(dependency)) {
+ return collectionsStaticFactoryInvocation(
+ requestingClass, CodeBlock.of("singleton($L)", contributionExpression));
+ } else if (isImmutableSetAvailable) {
+ return Expression.create(
+ immutableSetType(),
+ CodeBlock.builder()
+ .add("$T.", ImmutableSet.class)
+ .add(maybeTypeParameter(requestingClass))
+ .add("copyOf($L)", contributionExpression)
+ .build());
+ }
+ }
+ // fall through
+ default:
+ CodeBlock.Builder instantiation = CodeBlock.builder();
+ instantiation
+ .add("$T.", isImmutableSetAvailable ? ImmutableSet.class : SetBuilder.class)
+ .add(maybeTypeParameter(requestingClass));
+ if (isImmutableSetBuilderWithExpectedSizeAvailable()) {
+ instantiation.add("builderWithExpectedSize($L)", binding.dependencies().size());
+ } else if (isImmutableSetAvailable) {
+ instantiation.add("builder()");
+ } else {
+ instantiation.add("newSetBuilder($L)", binding.dependencies().size());
+ }
+ for (DependencyRequest dependency : binding.dependencies()) {
+ String builderMethod = isSingleValue(dependency) ? "add" : "addAll";
+ instantiation.add(
+ ".$L($L)", builderMethod, getContributionExpression(dependency, requestingClass));
+ }
+ instantiation.add(".build()");
+ return Expression.create(
+ isImmutableSetAvailable ? immutableSetType() : binding.key().type(),
+ instantiation.build());
+ }
+ }
+
+ private DeclaredType immutableSetType() {
+ return types.getDeclaredType(
+ elements.getTypeElement(ImmutableSet.class), SetType.from(binding.key()).elementType());
+ }
+
+ private CodeBlock getContributionExpression(
+ DependencyRequest dependency, ClassName requestingClass) {
+ return componentBindingExpressions
+ .getDependencyExpression(bindingRequest(dependency), requestingClass)
+ .codeBlock();
+ }
+
+ private Expression collectionsStaticFactoryInvocation(
+ ClassName requestingClass, CodeBlock methodInvocation) {
+ return Expression.create(
+ binding.key().type(),
+ CodeBlock.builder()
+ .add("$T.", Collections.class)
+ .add(maybeTypeParameter(requestingClass))
+ .add(methodInvocation)
+ .build());
+ }
+
+ private CodeBlock maybeTypeParameter(ClassName requestingClass) {
+ TypeMirror elementType = SetType.from(binding.key()).elementType();
+ return isTypeAccessibleFrom(elementType, requestingClass.packageName())
+ ? CodeBlock.of("<$T>", elementType)
+ : CodeBlock.of("");
+ }
+
+ private boolean isSingleValue(DependencyRequest dependency) {
+ return graph.contributionBinding(dependency.key())
+ .contributionType()
+ .equals(ContributionType.SET);
+ }
+
+ private boolean isImmutableSetBuilderWithExpectedSizeAvailable() {
+ if (isImmutableSetAvailable()) {
+ return methodsIn(elements.getTypeElement(ImmutableSet.class).getEnclosedElements())
+ .stream()
+ .anyMatch(method -> method.getSimpleName().contentEquals("builderWithExpectedSize"));
+ }
+ return false;
+ }
+
+ private boolean isImmutableSetAvailable() {
+ return elements.getTypeElement(ImmutableSet.class) != null;
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/SetFactoryCreationExpression.java b/java/dagger/internal/codegen/writing/SetFactoryCreationExpression.java
new file mode 100644
index 0000000..754f909
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/SetFactoryCreationExpression.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static dagger.internal.codegen.binding.SourceFiles.setFactoryClassName;
+
+import com.squareup.javapoet.CodeBlock;
+import dagger.internal.codegen.base.ContributionType;
+import dagger.internal.codegen.base.SetType;
+import dagger.internal.codegen.binding.BindingGraph;
+import dagger.internal.codegen.binding.BindingType;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.model.DependencyRequest;
+import dagger.producers.Produced;
+
+/** A factory creation expression for a multibound set. */
+final class SetFactoryCreationExpression extends MultibindingFactoryCreationExpression {
+ private final BindingGraph graph;
+ private final ContributionBinding binding;
+
+ SetFactoryCreationExpression(
+ ContributionBinding binding,
+ ComponentImplementation componentImplementation,
+ ComponentBindingExpressions componentBindingExpressions,
+ BindingGraph graph) {
+ super(binding, componentImplementation, componentBindingExpressions);
+ this.binding = checkNotNull(binding);
+ this.graph = checkNotNull(graph);
+ }
+
+ @Override
+ public CodeBlock creationExpression() {
+ CodeBlock.Builder builder = CodeBlock.builder().add("$T.", setFactoryClassName(binding));
+ if (!useRawType()) {
+ SetType setType = SetType.from(binding.key());
+ builder.add(
+ "<$T>",
+ setType.elementsAreTypeOf(Produced.class)
+ ? setType.unwrappedElementType(Produced.class)
+ : setType.elementType());
+ }
+
+ int individualProviders = 0;
+ int setProviders = 0;
+ CodeBlock.Builder builderMethodCalls = CodeBlock.builder();
+ String methodNameSuffix =
+ binding.bindingType().equals(BindingType.PROVISION) ? "Provider" : "Producer";
+
+ for (DependencyRequest dependency : binding.dependencies()) {
+ ContributionType contributionType =
+ graph.contributionBinding(dependency.key()).contributionType();
+ String methodNamePrefix;
+ switch (contributionType) {
+ case SET:
+ individualProviders++;
+ methodNamePrefix = "add";
+ break;
+ case SET_VALUES:
+ setProviders++;
+ methodNamePrefix = "addCollection";
+ break;
+ default:
+ throw new AssertionError(dependency + " is not a set multibinding");
+ }
+
+ builderMethodCalls.add(
+ ".$N$N($L)",
+ methodNamePrefix,
+ methodNameSuffix,
+ multibindingDependencyExpression(dependency));
+ }
+ builder.add("builder($L, $L)", individualProviders, setProviders);
+ builder.add(builderMethodCalls.build());
+
+ return builder.add(".build()").build();
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/SimpleInvocationBindingExpression.java b/java/dagger/internal/codegen/writing/SimpleInvocationBindingExpression.java
new file mode 100644
index 0000000..f2062f4
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/SimpleInvocationBindingExpression.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import dagger.internal.codegen.binding.ContributionBinding;
+
+/** A simple binding expression for instance requests. Does not scope. */
+abstract class SimpleInvocationBindingExpression extends BindingExpression {
+ private final ContributionBinding binding;
+
+ SimpleInvocationBindingExpression(ContributionBinding binding) {
+ this.binding = checkNotNull(binding);
+ }
+
+ @Override
+ boolean requiresMethodEncapsulation() {
+ return !binding.dependencies().isEmpty();
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/SimpleMethodBindingExpression.java b/java/dagger/internal/codegen/writing/SimpleMethodBindingExpression.java
new file mode 100644
index 0000000..82e6628
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/SimpleMethodBindingExpression.java
@@ -0,0 +1,186 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.auto.common.MoreElements.asExecutable;
+import static com.google.auto.common.MoreElements.asType;
+import static com.google.common.base.Preconditions.checkArgument;
+import static dagger.internal.codegen.javapoet.CodeBlocks.makeParametersCodeBlock;
+import static dagger.internal.codegen.javapoet.TypeNames.rawTypeName;
+import static dagger.internal.codegen.langmodel.Accessibility.isTypeAccessibleFrom;
+import static dagger.internal.codegen.writing.InjectionMethods.ProvisionMethod.requiresInjectionMethod;
+
+import com.google.auto.common.MoreTypes;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.TypeName;
+import dagger.internal.codegen.binding.ComponentRequirement;
+import dagger.internal.codegen.binding.ProvisionBinding;
+import dagger.internal.codegen.compileroption.CompilerOptions;
+import dagger.internal.codegen.javapoet.Expression;
+import dagger.internal.codegen.kotlin.KotlinMetadataUtil;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import dagger.internal.codegen.writing.InjectionMethods.ProvisionMethod;
+import dagger.model.DependencyRequest;
+import java.util.Optional;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeMirror;
+
+/**
+ * A binding expression that invokes methods or constructors directly (without attempting to scope)
+ * {@link dagger.model.RequestKind#INSTANCE} requests.
+ */
+final class SimpleMethodBindingExpression extends SimpleInvocationBindingExpression {
+ private final CompilerOptions compilerOptions;
+ private final ProvisionBinding provisionBinding;
+ private final ComponentBindingExpressions componentBindingExpressions;
+ private final MembersInjectionMethods membersInjectionMethods;
+ private final ComponentRequirementExpressions componentRequirementExpressions;
+ private final DaggerElements elements;
+ private final SourceVersion sourceVersion;
+ private final KotlinMetadataUtil metadataUtil;
+
+ SimpleMethodBindingExpression(
+ ProvisionBinding binding,
+ CompilerOptions compilerOptions,
+ ComponentBindingExpressions componentBindingExpressions,
+ MembersInjectionMethods membersInjectionMethods,
+ ComponentRequirementExpressions componentRequirementExpressions,
+ DaggerElements elements,
+ SourceVersion sourceVersion,
+ KotlinMetadataUtil metadataUtil) {
+ super(binding);
+ this.compilerOptions = compilerOptions;
+ this.provisionBinding = binding;
+ this.metadataUtil = metadataUtil;
+ checkArgument(
+ provisionBinding.implicitDependencies().isEmpty(),
+ "framework deps are not currently supported");
+ checkArgument(provisionBinding.bindingElement().isPresent());
+ this.componentBindingExpressions = componentBindingExpressions;
+ this.membersInjectionMethods = membersInjectionMethods;
+ this.componentRequirementExpressions = componentRequirementExpressions;
+ this.elements = elements;
+ this.sourceVersion = sourceVersion;
+ }
+
+ @Override
+ Expression getDependencyExpression(ClassName requestingClass) {
+ return requiresInjectionMethod(provisionBinding, compilerOptions, requestingClass)
+ ? invokeInjectionMethod(requestingClass)
+ : invokeMethod(requestingClass);
+ }
+
+ private Expression invokeMethod(ClassName requestingClass) {
+ // TODO(dpb): align this with the contents of InlineMethods.create
+ CodeBlock arguments =
+ makeParametersCodeBlock(
+ ProvisionMethod.invokeArguments(
+ provisionBinding,
+ request -> dependencyArgument(request, requestingClass).codeBlock(),
+ requestingClass));
+ ExecutableElement method = asExecutable(provisionBinding.bindingElement().get());
+ CodeBlock invocation;
+ switch (method.getKind()) {
+ case CONSTRUCTOR:
+ invocation = CodeBlock.of("new $T($L)", constructorTypeName(requestingClass), arguments);
+ break;
+ case METHOD:
+ CodeBlock module;
+ Optional<CodeBlock> requiredModuleInstance = moduleReference(requestingClass);
+ if (requiredModuleInstance.isPresent()) {
+ module = requiredModuleInstance.get();
+ } else if (metadataUtil.isObjectClass(asType(method.getEnclosingElement()))) {
+ // Call through the singleton instance.
+ // See: https://kotlinlang.org/docs/reference/java-to-kotlin-interop.html#static-methods
+ module = CodeBlock.of("$T.INSTANCE", provisionBinding.bindingTypeElement().get());
+ } else {
+ module = CodeBlock.of("$T", provisionBinding.bindingTypeElement().get());
+ }
+ invocation = CodeBlock.of("$L.$L($L)", module, method.getSimpleName(), arguments);
+ break;
+ default:
+ throw new IllegalStateException();
+ }
+
+ return Expression.create(simpleMethodReturnType(), invocation);
+ }
+
+ private TypeName constructorTypeName(ClassName requestingClass) {
+ DeclaredType type = MoreTypes.asDeclared(provisionBinding.key().type());
+ TypeName typeName = TypeName.get(type);
+ if (type.getTypeArguments().stream()
+ .allMatch(t -> isTypeAccessibleFrom(t, requestingClass.packageName()))) {
+ return typeName;
+ }
+ return rawTypeName(typeName);
+ }
+
+ private Expression invokeInjectionMethod(ClassName requestingClass) {
+ return injectMembers(
+ ProvisionMethod.invoke(
+ provisionBinding,
+ request -> dependencyArgument(request, requestingClass).codeBlock(),
+ requestingClass,
+ moduleReference(requestingClass),
+ compilerOptions,
+ metadataUtil));
+ }
+
+ private Expression dependencyArgument(DependencyRequest dependency, ClassName requestingClass) {
+ return componentBindingExpressions.getDependencyArgumentExpression(dependency, requestingClass);
+ }
+
+ private Expression injectMembers(CodeBlock instance) {
+ if (provisionBinding.injectionSites().isEmpty()) {
+ return Expression.create(simpleMethodReturnType(), instance);
+ }
+ if (sourceVersion.compareTo(SourceVersion.RELEASE_7) <= 0) {
+ // Java 7 type inference can't figure out that instance in
+ // injectParameterized(Parameterized_Factory.newParameterized()) is Parameterized<T> and not
+ // Parameterized<Object>
+ if (!MoreTypes.asDeclared(provisionBinding.key().type()).getTypeArguments().isEmpty()) {
+ TypeName keyType = TypeName.get(provisionBinding.key().type());
+ instance = CodeBlock.of("($T) ($T) $L", keyType, rawTypeName(keyType), instance);
+ }
+ }
+ MethodSpec membersInjectionMethod = membersInjectionMethods.getOrCreate(provisionBinding.key());
+ TypeMirror returnType =
+ membersInjectionMethod.returnType.equals(TypeName.OBJECT)
+ ? elements.getTypeElement(Object.class).asType()
+ : provisionBinding.key().type();
+ return Expression.create(returnType, CodeBlock.of("$N($L)", membersInjectionMethod, instance));
+ }
+
+ private Optional<CodeBlock> moduleReference(ClassName requestingClass) {
+ return provisionBinding.requiresModuleInstance()
+ ? provisionBinding
+ .contributingModule()
+ .map(Element::asType)
+ .map(ComponentRequirement::forModule)
+ .map(module -> componentRequirementExpressions.getExpression(module, requestingClass))
+ : Optional.empty();
+ }
+
+ private TypeMirror simpleMethodReturnType() {
+ return provisionBinding.contributedPrimitiveType().orElse(provisionBinding.key().type());
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/SubcomponentCreatorBindingExpression.java b/java/dagger/internal/codegen/writing/SubcomponentCreatorBindingExpression.java
new file mode 100644
index 0000000..3099048
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/SubcomponentCreatorBindingExpression.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2017 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import com.squareup.javapoet.ClassName;
+import dagger.internal.codegen.binding.ContributionBinding;
+import dagger.internal.codegen.javapoet.Expression;
+import javax.lang.model.type.TypeMirror;
+
+/** A binding expression for a subcomponent creator that just invokes the constructor. */
+final class SubcomponentCreatorBindingExpression extends SimpleInvocationBindingExpression {
+ private final TypeMirror creatorType;
+ private final String creatorImplementationName;
+
+ SubcomponentCreatorBindingExpression(
+ ContributionBinding binding, String creatorImplementationName) {
+ super(binding);
+ this.creatorType = binding.key().type();
+ this.creatorImplementationName = creatorImplementationName;
+ }
+
+ @Override
+ Expression getDependencyExpression(ClassName requestingClass) {
+ return Expression.create(creatorType, "new $L()", creatorImplementationName);
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/SubcomponentNames.java b/java/dagger/internal/codegen/writing/SubcomponentNames.java
new file mode 100644
index 0000000..fa0037b
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/SubcomponentNames.java
@@ -0,0 +1,156 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableMap;
+import static java.lang.Character.isUpperCase;
+import static java.lang.String.format;
+
+import com.google.common.base.CharMatcher;
+import com.google.common.base.Splitter;
+import com.google.common.collect.ImmutableListMultimap;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Multimaps;
+import dagger.internal.codegen.base.UniqueNameSet;
+import dagger.internal.codegen.binding.BindingGraph;
+import dagger.internal.codegen.binding.ComponentCreatorDescriptor;
+import dagger.internal.codegen.binding.ComponentDescriptor;
+import dagger.internal.codegen.binding.KeyFactory;
+import dagger.model.Key;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import javax.lang.model.element.Name;
+import javax.lang.model.element.TypeElement;
+
+/**
+ * Holds the unique simple names for all subcomponents, keyed by their {@link ComponentDescriptor}
+ * and {@link Key} of the subcomponent builder.
+ */
+public final class SubcomponentNames {
+ private static final Splitter QUALIFIED_NAME_SPLITTER = Splitter.on('.');
+
+ private final ImmutableMap<ComponentDescriptor, String> namesByDescriptor;
+ private final ImmutableMap<Key, ComponentDescriptor> descriptorsByCreatorKey;
+
+ public SubcomponentNames(BindingGraph graph, KeyFactory keyFactory) {
+ this.namesByDescriptor = namesByDescriptor(graph);
+ this.descriptorsByCreatorKey = descriptorsByCreatorKey(keyFactory, namesByDescriptor.keySet());
+ }
+
+ /** Returns the simple component name for the given {@link ComponentDescriptor}. */
+ String get(ComponentDescriptor componentDescriptor) {
+ return namesByDescriptor.get(componentDescriptor);
+ }
+
+ /**
+ * Returns the simple name for the subcomponent creator implementation with the given {@link Key}.
+ */
+ String getCreatorName(Key key) {
+ return getCreatorName(descriptorsByCreatorKey.get(key));
+ }
+
+ /**
+ * Returns the simple name for the subcomponent creator implementation for the given {@link
+ * ComponentDescriptor}.
+ */
+ String getCreatorName(ComponentDescriptor componentDescriptor) {
+ checkArgument(componentDescriptor.creatorDescriptor().isPresent());
+ ComponentCreatorDescriptor creatorDescriptor = componentDescriptor.creatorDescriptor().get();
+ return get(componentDescriptor) + creatorDescriptor.kind().typeName();
+ }
+
+ private static ImmutableMap<ComponentDescriptor, String> namesByDescriptor(BindingGraph graph) {
+ ImmutableListMultimap<String, ComponentDescriptor> componentDescriptorsBySimpleName =
+ Multimaps.index(graph.componentDescriptors(), SubcomponentNames::simpleName);
+ Map<ComponentDescriptor, String> subcomponentImplSimpleNames = new LinkedHashMap<>();
+ componentDescriptorsBySimpleName
+ .asMap()
+ .values()
+ .stream()
+ .map(SubcomponentNames::disambiguateConflictingSimpleNames)
+ .forEach(subcomponentImplSimpleNames::putAll);
+ subcomponentImplSimpleNames.remove(graph.componentDescriptor());
+ return ImmutableMap.copyOf(subcomponentImplSimpleNames);
+ }
+
+ private static ImmutableMap<Key, ComponentDescriptor> descriptorsByCreatorKey(
+ KeyFactory keyFactory, ImmutableSet<ComponentDescriptor> subcomponents) {
+ return subcomponents.stream()
+ .filter(subcomponent -> subcomponent.creatorDescriptor().isPresent())
+ .collect(
+ toImmutableMap(
+ subcomponent ->
+ keyFactory.forSubcomponentCreator(
+ subcomponent.creatorDescriptor().get().typeElement().asType()),
+ subcomponent -> subcomponent));
+ }
+
+ private static ImmutableMap<ComponentDescriptor, String> disambiguateConflictingSimpleNames(
+ Collection<ComponentDescriptor> componentsWithConflictingNames) {
+ // If there's only 1 component there's nothing to disambiguate so return the simple name.
+ if (componentsWithConflictingNames.size() == 1) {
+ ComponentDescriptor component = Iterables.getOnlyElement(componentsWithConflictingNames);
+ return ImmutableMap.of(component, simpleName(component));
+ }
+
+ // There are conflicting simple names, so disambiguate them with a unique prefix.
+ // We keep them small to fix https://github.com/google/dagger/issues/421.
+ UniqueNameSet nameSet = new UniqueNameSet();
+ ImmutableMap.Builder<ComponentDescriptor, String> uniqueNames = ImmutableMap.builder();
+ for (ComponentDescriptor component : componentsWithConflictingNames) {
+ String simpleName = simpleName(component);
+ String basePrefix = uniquingPrefix(component);
+ uniqueNames.put(component, format("%s_%s", nameSet.getUniqueName(basePrefix), simpleName));
+ }
+ return uniqueNames.build();
+ }
+
+ private static String simpleName(ComponentDescriptor component) {
+ return component.typeElement().getSimpleName().toString();
+ }
+
+ /** Returns a prefix that could make the component's simple name more unique. */
+ private static String uniquingPrefix(ComponentDescriptor component) {
+ TypeElement typeElement = component.typeElement();
+ String containerName = typeElement.getEnclosingElement().getSimpleName().toString();
+
+ // If parent element looks like a class, use its initials as a prefix.
+ if (!containerName.isEmpty() && isUpperCase(containerName.charAt(0))) {
+ return CharMatcher.javaLowerCase().removeFrom(containerName);
+ }
+
+ // Not in a normally named class. Prefix with the initials of the elements leading here.
+ Name qualifiedName = typeElement.getQualifiedName();
+ Iterator<String> pieces = QUALIFIED_NAME_SPLITTER.split(qualifiedName).iterator();
+ StringBuilder b = new StringBuilder();
+
+ while (pieces.hasNext()) {
+ String next = pieces.next();
+ if (pieces.hasNext()) {
+ b.append(next.charAt(0));
+ }
+ }
+
+ // Note that a top level class in the root package will be prefixed "$_".
+ return b.length() > 0 ? b.toString() : "$";
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/SwitchingProviders.java b/java/dagger/internal/codegen/writing/SwitchingProviders.java
new file mode 100644
index 0000000..d38b9d9
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/SwitchingProviders.java
@@ -0,0 +1,228 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.collect.Iterables.getLast;
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static com.squareup.javapoet.MethodSpec.methodBuilder;
+import static com.squareup.javapoet.TypeSpec.classBuilder;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableList;
+import static dagger.internal.codegen.javapoet.AnnotationSpecs.Suppression.UNCHECKED;
+import static dagger.internal.codegen.javapoet.AnnotationSpecs.suppressWarnings;
+import static dagger.internal.codegen.javapoet.TypeNames.providerOf;
+import static javax.lang.model.element.Modifier.PRIVATE;
+import static javax.lang.model.element.Modifier.PUBLIC;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.TypeSpec;
+import com.squareup.javapoet.TypeVariableName;
+import dagger.internal.codegen.base.UniqueNameSet;
+import dagger.internal.codegen.javapoet.CodeBlocks;
+import dagger.internal.codegen.javapoet.Expression;
+import dagger.internal.codegen.langmodel.DaggerTypes;
+import dagger.model.Key;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.TreeMap;
+
+/**
+ * Keeps track of all provider expression requests for a component.
+ *
+ * <p>The provider expression request will be satisfied by a single generated {@code Provider} inner
+ * class that can provide instances for all types by switching on an id.
+ */
+// TODO(ronshapiro): either merge this with InnerSwitchingProviders, or repurpose this for
+// SwitchingProducers
+abstract class SwitchingProviders {
+ /**
+ * Defines the {@linkplain Expression expressions} for a switch case in a {@code SwitchProvider}
+ * for a particular binding.
+ */
+ // TODO(bcorso): Consider handling SwitchingProviders with dependency arguments in this class,
+ // then we wouldn't need the getProviderExpression method.
+ // TODO(bcorso): Consider making this an abstract class with equals/hashCode defined by the key
+ // and then using this class directly in Map types instead of Key.
+ interface SwitchCase {
+ /** Returns the {@link Key} for this switch case. */
+ Key key();
+
+ /** Returns the {@link Expression} that returns the provided instance for this case. */
+ Expression getReturnExpression(ClassName switchingProviderClass);
+
+ /**
+ * Returns the {@link Expression} that returns the {@code SwitchProvider} instance for this
+ * case.
+ */
+ Expression getProviderExpression(ClassName switchingProviderClass, int switchId);
+ }
+
+ /**
+ * Each switch size is fixed at 100 cases each and put in its own method. This is to limit the
+ * size of the methods so that we don't reach the "huge" method size limit for Android that will
+ * prevent it from being AOT compiled in some versions of Android (b/77652521). This generally
+ * starts to happen around 1500 cases, but we are choosing 100 to be safe.
+ */
+ // TODO(bcorso): Include a proguard_spec in the Dagger library to prevent inlining these methods?
+ // TODO(ronshapiro): Consider making this configurable via a flag.
+ private static final int MAX_CASES_PER_SWITCH = 100;
+
+ private static final long MAX_CASES_PER_CLASS = MAX_CASES_PER_SWITCH * MAX_CASES_PER_SWITCH;
+ private static final TypeVariableName T = TypeVariableName.get("T");
+
+ /**
+ * Maps a {@link Key} to an instance of a {@link SwitchingProviderBuilder}. Each group of {@code
+ * MAX_CASES_PER_CLASS} keys will share the same instance.
+ */
+ private final Map<Key, SwitchingProviderBuilder> switchingProviderBuilders =
+ new LinkedHashMap<>();
+
+ private final ComponentImplementation componentImplementation;
+ private final ClassName owningComponent;
+ private final DaggerTypes types;
+ private final UniqueNameSet switchingProviderNames = new UniqueNameSet();
+
+ SwitchingProviders(ComponentImplementation componentImplementation, DaggerTypes types) {
+ this.componentImplementation = checkNotNull(componentImplementation);
+ this.types = checkNotNull(types);
+ this.owningComponent = checkNotNull(componentImplementation).name();
+ }
+
+ /** Returns the {@link TypeSpec} for a {@code SwitchingProvider} based on the given builder. */
+ protected abstract TypeSpec createSwitchingProviderType(TypeSpec.Builder builder);
+
+ /**
+ * Returns the {@link Expression} that returns the {@code SwitchProvider} instance for the case.
+ */
+ protected final Expression getProviderExpression(SwitchCase switchCase) {
+ return switchingProviderBuilders
+ .computeIfAbsent(switchCase.key(), key -> getSwitchingProviderBuilder())
+ .getProviderExpression(switchCase);
+ }
+
+ private SwitchingProviderBuilder getSwitchingProviderBuilder() {
+ if (switchingProviderBuilders.size() % MAX_CASES_PER_CLASS == 0) {
+ String name = switchingProviderNames.getUniqueName("SwitchingProvider");
+ SwitchingProviderBuilder switchingProviderBuilder =
+ new SwitchingProviderBuilder(owningComponent.nestedClass(name));
+ componentImplementation.addTypeSupplier(switchingProviderBuilder::build);
+ return switchingProviderBuilder;
+ }
+ return getLast(switchingProviderBuilders.values());
+ }
+
+ // TODO(bcorso): Consider just merging this class with SwitchingProviders.
+ private final class SwitchingProviderBuilder {
+ // Keep the switch cases ordered by switch id. The switch Ids are assigned in pre-order
+ // traversal, but the switch cases are assigned in post-order traversal of the binding graph.
+ private final Map<Integer, CodeBlock> switchCases = new TreeMap<>();
+ private final Map<Key, Integer> switchIds = new HashMap<>();
+ private final ClassName switchingProviderType;
+
+ SwitchingProviderBuilder(ClassName switchingProviderType) {
+ this.switchingProviderType = checkNotNull(switchingProviderType);
+ }
+
+ Expression getProviderExpression(SwitchCase switchCase) {
+ Key key = switchCase.key();
+ if (!switchIds.containsKey(key)) {
+ int switchId = switchIds.size();
+ switchIds.put(key, switchId);
+ switchCases.put(switchId, createSwitchCaseCodeBlock(switchCase));
+ }
+ return switchCase.getProviderExpression(switchingProviderType, switchIds.get(key));
+ }
+
+ private CodeBlock createSwitchCaseCodeBlock(SwitchCase switchCase) {
+ CodeBlock instanceCodeBlock =
+ switchCase.getReturnExpression(switchingProviderType).box(types).codeBlock();
+
+ return CodeBlock.builder()
+ // TODO(bcorso): Is there something else more useful than the key?
+ .add("case $L: // $L \n", switchIds.get(switchCase.key()), switchCase.key())
+ .addStatement("return ($T) $L", T, instanceCodeBlock)
+ .build();
+ }
+
+ private TypeSpec build() {
+ return createSwitchingProviderType(
+ classBuilder(switchingProviderType)
+ .addTypeVariable(T)
+ .addSuperinterface(providerOf(T))
+ .addMethods(getMethods()));
+ }
+
+ private ImmutableList<MethodSpec> getMethods() {
+ ImmutableList<CodeBlock> switchCodeBlockPartitions = switchCodeBlockPartitions();
+ if (switchCodeBlockPartitions.size() == 1) {
+ // There are less than MAX_CASES_PER_SWITCH cases, so no need for extra get methods.
+ return ImmutableList.of(
+ methodBuilder("get")
+ .addModifiers(PUBLIC)
+ .addAnnotation(suppressWarnings(UNCHECKED))
+ .addAnnotation(Override.class)
+ .returns(T)
+ .addCode(getOnlyElement(switchCodeBlockPartitions))
+ .build());
+ }
+
+ // This is the main public "get" method that will route to private getter methods.
+ MethodSpec.Builder routerMethod =
+ methodBuilder("get")
+ .addModifiers(PUBLIC)
+ .addAnnotation(Override.class)
+ .returns(T)
+ .beginControlFlow("switch (id / $L)", MAX_CASES_PER_SWITCH);
+
+ ImmutableList.Builder<MethodSpec> getMethods = ImmutableList.builder();
+ for (int i = 0; i < switchCodeBlockPartitions.size(); i++) {
+ MethodSpec method =
+ methodBuilder("get" + i)
+ .addModifiers(PRIVATE)
+ .addAnnotation(suppressWarnings(UNCHECKED))
+ .returns(T)
+ .addCode(switchCodeBlockPartitions.get(i))
+ .build();
+ getMethods.add(method);
+ routerMethod.addStatement("case $L: return $N()", i, method);
+ }
+
+ routerMethod.addStatement("default: throw new $T(id)", AssertionError.class).endControlFlow();
+
+ return getMethods.add(routerMethod.build()).build();
+ }
+
+ private ImmutableList<CodeBlock> switchCodeBlockPartitions() {
+ return Lists.partition(ImmutableList.copyOf(switchCases.values()), MAX_CASES_PER_SWITCH)
+ .stream()
+ .map(
+ partitionCases ->
+ CodeBlock.builder()
+ .beginControlFlow("switch (id)")
+ .add(CodeBlocks.concat(partitionCases))
+ .addStatement("default: throw new $T(id)", AssertionError.class)
+ .endControlFlow()
+ .build())
+ .collect(toImmutableList());
+ }
+ }
+}
diff --git a/java/dagger/internal/codegen/writing/TopLevel.java b/java/dagger/internal/codegen/writing/TopLevel.java
new file mode 100644
index 0000000..ce71907
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/TopLevel.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2015 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Retention;
+import javax.inject.Qualifier;
+
+/**
+ * A {@link Qualifier} for bindings that are associated with the top level component implementation.
+ */
+@Retention(RUNTIME)
+@Qualifier
+public @interface TopLevel {}
diff --git a/java/dagger/internal/codegen/writing/UnwrappedMapKeyGenerator.java b/java/dagger/internal/codegen/writing/UnwrappedMapKeyGenerator.java
new file mode 100644
index 0000000..f07b882
--- /dev/null
+++ b/java/dagger/internal/codegen/writing/UnwrappedMapKeyGenerator.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2016 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen.writing;
+
+import dagger.MapKey;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import java.util.Set;
+import javax.annotation.processing.Filer;
+import javax.inject.Inject;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.TypeElement;
+
+/**
+ * Generates classes that create annotation instances for an unwrapped {@link MapKey} annotation
+ * type whose nested value is an annotation. The generated class will have a private empty
+ * constructor and a static method that creates each annotation type that is nested in the top-level
+ * annotation type.
+ *
+ * <p>So for an example {@link MapKey} annotation:
+ *
+ * <pre>
+ * {@literal @MapKey}(unwrapValue = true)
+ * {@literal @interface} Foo {
+ * Bar bar();
+ * }
+ *
+ * {@literal @interface} Bar {
+ * {@literal Class<?> baz();}
+ * }
+ * </pre>
+ *
+ * the generated class will look like:
+ *
+ * <pre>
+ * public final class FooCreator {
+ * private FooCreator() {}
+ *
+ * public static Bar createBar({@literal Class<?> baz}) { … }
+ * }
+ * </pre>
+ */
+public final class UnwrappedMapKeyGenerator extends AnnotationCreatorGenerator {
+
+ @Inject
+ UnwrappedMapKeyGenerator(Filer filer, DaggerElements elements, SourceVersion sourceVersion) {
+ super(filer, elements, sourceVersion);
+ }
+
+ @Override
+ protected Set<TypeElement> annotationsToCreate(TypeElement annotationElement) {
+ Set<TypeElement> nestedAnnotationElements = super.annotationsToCreate(annotationElement);
+ nestedAnnotationElements.remove(annotationElement);
+ return nestedAnnotationElements;
+ }
+}
diff --git a/java/dagger/internal/guava/BUILD b/java/dagger/internal/guava/BUILD
new file mode 100644
index 0000000..0bd4dcc
--- /dev/null
+++ b/java/dagger/internal/guava/BUILD
@@ -0,0 +1,68 @@
+# Copyright (C) 2017 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Aliases from guava libraries to //third_party/java/guava.
+
+package(default_visibility = ["//:src"])
+
+alias(
+ name = "annotations",
+ actual = "@google_bazel_common//third_party/java/guava",
+)
+
+alias(
+ name = "base",
+ actual = "@google_bazel_common//third_party/java/guava",
+)
+
+alias(
+ name = "cache",
+ actual = "@google_bazel_common//third_party/java/guava",
+)
+
+alias(
+ name = "collect",
+ actual = "@google_bazel_common//third_party/java/guava",
+)
+
+alias(
+ name = "graph",
+ actual = "@google_bazel_common//third_party/java/guava",
+)
+
+alias(
+ name = "io",
+ actual = "@google_bazel_common//third_party/java/guava",
+)
+
+alias(
+ name = "concurrent",
+ actual = "@google_bazel_common//third_party/java/guava",
+)
+
+alias(
+ name = "base-android",
+ actual = "@maven//:com_google_guava_guava",
+)
+
+alias(
+ name = "collect-android",
+ actual = "@maven//:com_google_guava_guava",
+)
+
+alias(
+ name = "concurrent-android",
+ actual = "@maven//:com_google_guava_guava",
+)
diff --git a/java/dagger/lint/AndroidManifest.xml b/java/dagger/lint/AndroidManifest.xml
new file mode 100644
index 0000000..f75cee1
--- /dev/null
+++ b/java/dagger/lint/AndroidManifest.xml
@@ -0,0 +1,19 @@
+<!--
+ Copyright (C) 2020 The Dagger Authors.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="dagger.lint">
+ <uses-sdk android:minSdkVersion="14" />
+</manifest>
diff --git a/java/dagger/lint/BUILD b/java/dagger/lint/BUILD
new file mode 100644
index 0000000..3e0ffec
--- /dev/null
+++ b/java/dagger/lint/BUILD
@@ -0,0 +1,85 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Dagger Lint Rules
+
+load("//:build_defs.bzl", "POM_VERSION")
+load("//tools:maven.bzl", "gen_maven_artifact")
+load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "kt_jvm_library")
+
+package(default_visibility = ["//:src"])
+
+kt_jvm_library(
+ name = "lint-artifact-lib",
+ srcs = glob(["*.kt"]),
+ tags = ["maven_coordinates=com.google.dagger:dagger-lint:" + POM_VERSION],
+ deps = [
+ "@google_bazel_common//third_party/java/auto:service",
+ "@maven//:com_android_tools_external_com_intellij_intellij_core",
+ "@maven//:com_android_tools_external_com_intellij_kotlin_compiler",
+ "@maven//:com_android_tools_external_org_jetbrains_uast",
+ "@maven//:com_android_tools_lint_lint",
+ "@maven//:com_android_tools_lint_lint_api",
+ ],
+)
+
+# Current `kt_jvm_library` does not output source jars and gen_maven_artifact expects one.
+# See: https://github.com/bazelbuild/rules_kotlin/issues/324
+genrule(
+ name = "dagger-lint-sources",
+ srcs = glob(["*.kt"]),
+ outs = ["liblint-artifact-lib-src.jar"],
+ cmd = """
+ TEMP="$$(mktemp -d)"
+ for file in $(SRCS); do
+ filename="$$TEMP/$${file#java/}"
+ mkdir -p `dirname $$filename` && cp $$file $$filename
+ done
+ jar cf $@ -C $$TEMP .
+ """,
+)
+
+gen_maven_artifact(
+ name = "lint-artifact",
+ artifact_coordinates = "com.google.dagger:dagger-lint:" + POM_VERSION,
+ artifact_name = "Dagger Lint Rules",
+ artifact_target = ":lint-artifact-lib",
+ artifact_target_maven_deps = [
+ "com.android.tools.external.com-intellij:intellij-core",
+ "com.android.tools.external.com-intellij:kotlin-compiler",
+ "com.android.tools.external.org-jetbrains:uast",
+ "com.android.tools.lint:lint",
+ "com.android.tools.lint:lint-api",
+ ],
+ pom_name = "lint-pom",
+)
+
+# An empty android artifact to distribute and share the Dagger lint rules for
+# the Android sub-projects.
+android_library(
+ name = "lint-android-artifact-lib",
+ tags = ["maven_coordinates=com.google.dagger:dagger-lint-aar:" + POM_VERSION],
+)
+
+gen_maven_artifact(
+ name = "lint-android-artifact",
+ artifact_coordinates = "com.google.dagger:dagger-lint-aar:" + POM_VERSION,
+ artifact_name = "Dagger Lint Rules AAR Distribution",
+ artifact_target = ":lint-android-artifact-lib",
+ lint_deps = [":lint-artifact-lib"],
+ manifest = "AndroidManifest.xml",
+ packaging = "aar",
+ pom_name = "lint-android-pom",
+)
diff --git a/java/dagger/lint/DaggerIssueRegistry.kt b/java/dagger/lint/DaggerIssueRegistry.kt
new file mode 100644
index 0000000..113e85c
--- /dev/null
+++ b/java/dagger/lint/DaggerIssueRegistry.kt
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package dagger.lint
+
+import com.android.tools.lint.client.api.IssueRegistry
+import com.android.tools.lint.detector.api.CURRENT_API
+import com.android.tools.lint.detector.api.Issue
+import com.google.auto.service.AutoService
+
+/**
+ * Dagger Lint Issues Registry.
+ *
+ * A META-INF/services entry is added for this class that Lint will discover and call into for
+ * detecting issues.
+ */
+@AutoService(IssueRegistry::class)
+@Suppress("unused", "UnstableApiUsage")
+class DaggerIssueRegistry : IssueRegistry() {
+ // The minApi is set to the Api this registry was compiled with, if a user has an older Api, Lint
+ // will show a warning asking users to upgrade.
+ override val minApi: Int = CURRENT_API
+ // The api is meant to be the current api for which this registry was compiled, but we set a
+ // higher number without depending on a newer Lint to avoid Lint warning users of custom checks
+ // that might not work. This value eventually has to be updated as newer Api become available.
+ override val api: Int = 8
+ override val issues: List<Issue> = DaggerKotlinIssueDetector.issues
+}
diff --git a/java/dagger/lint/DaggerKotlinIssueDetector.kt b/java/dagger/lint/DaggerKotlinIssueDetector.kt
new file mode 100644
index 0000000..f3fdbd3
--- /dev/null
+++ b/java/dagger/lint/DaggerKotlinIssueDetector.kt
@@ -0,0 +1,262 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package dagger.lint
+
+import com.android.tools.lint.client.api.JavaEvaluator
+import com.android.tools.lint.client.api.UElementHandler
+import com.android.tools.lint.detector.api.Category
+import com.android.tools.lint.detector.api.Detector
+import com.android.tools.lint.detector.api.Implementation
+import com.android.tools.lint.detector.api.Issue
+import com.android.tools.lint.detector.api.JavaContext
+import com.android.tools.lint.detector.api.LintFix
+import com.android.tools.lint.detector.api.Scope
+import com.android.tools.lint.detector.api.Severity
+import com.android.tools.lint.detector.api.SourceCodeScanner
+import com.android.tools.lint.detector.api.TextFormat
+import com.android.tools.lint.detector.api.isKotlin
+import dagger.lint.DaggerKotlinIssueDetector.Companion.ISSUE_FIELD_SITE_TARGET_ON_QUALIFIER_ANNOTATION
+import dagger.lint.DaggerKotlinIssueDetector.Companion.ISSUE_JVM_STATIC_PROVIDES_IN_OBJECT
+import dagger.lint.DaggerKotlinIssueDetector.Companion.ISSUE_MODULE_COMPANION_OBJECTS
+import dagger.lint.DaggerKotlinIssueDetector.Companion.ISSUE_MODULE_COMPANION_OBJECTS_NOT_IN_MODULE_PARENT
+import java.util.EnumSet
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.psi.KtAnnotationEntry
+import org.jetbrains.kotlin.psi.KtObjectDeclaration
+import org.jetbrains.uast.UClass
+import org.jetbrains.uast.UElement
+import org.jetbrains.uast.UField
+import org.jetbrains.uast.UMethod
+import org.jetbrains.uast.getUastParentOfType
+import org.jetbrains.uast.kotlin.KotlinUClass
+import org.jetbrains.uast.toUElement
+
+/**
+ * This is a simple lint check to catch common Dagger+Kotlin usage issues.
+ *
+ * - [ISSUE_FIELD_SITE_TARGET_ON_QUALIFIER_ANNOTATION] covers using `field:` site targets for member
+ * injections, which are redundant as of Dagger 2.25.
+ * - [ISSUE_JVM_STATIC_PROVIDES_IN_OBJECT] covers using `@JvmStatic` for object
+ * `@Provides`-annotated functions, which are redundant as of Dagger 2.25. @JvmStatic on companion
+ * object functions are redundant as of Dagger 2.26.
+ * - [ISSUE_MODULE_COMPANION_OBJECTS] covers annotating companion objects with `@Module`, as they
+ * are now part of the enclosing module class's API in Dagger 2.26. This will also error if the
+ * enclosing class is _not_ in a `@Module`-annotated class, as this object just should be moved to a
+ * top-level object to avoid confusion.
+ * - [ISSUE_MODULE_COMPANION_OBJECTS_NOT_IN_MODULE_PARENT] covers annotating companion objects with
+ * `@Module` when the parent class is _not_ also annotated with `@Module`. While technically legal,
+ * these should be moved up to top-level objects to avoid confusion.
+ */
+@Suppress("UnstableApiUsage") // Lots of Lint APIs are marked with @Beta.
+class DaggerKotlinIssueDetector : Detector(), SourceCodeScanner {
+
+ companion object {
+ // We use the overloaded constructor that takes a varargs of `Scope` as the last param.
+ // This is to enable on-the-fly IDE checks. We are telling lint to run on both
+ // JAVA and TEST_SOURCES in the `scope` parameter but by providing the `analysisScopes`
+ // params, we're indicating that this check can run on either JAVA or TEST_SOURCES and
+ // doesn't require both of them together.
+ // From discussion on lint-dev https://groups.google.com/d/msg/lint-dev/ULQMzW1ZlP0/1dG4Vj3-AQAJ
+ // This was supposed to be fixed in AS 3.4 but still required as recently as 3.6.
+ private val SCOPES = Implementation(
+ DaggerKotlinIssueDetector::class.java,
+ EnumSet.of(Scope.JAVA_FILE, Scope.TEST_SOURCES),
+ EnumSet.of(Scope.JAVA_FILE),
+ EnumSet.of(Scope.TEST_SOURCES)
+ )
+
+ private val ISSUE_JVM_STATIC_PROVIDES_IN_OBJECT: Issue = Issue.create(
+ id = "JvmStaticProvidesInObjectDetector",
+ briefDescription = "@JvmStatic used for @Provides function in an object class",
+ explanation =
+ """
+ It's redundant to annotate @Provides functions in object classes with @JvmStatic.
+ """,
+ category = Category.CORRECTNESS,
+ priority = 5,
+ severity = Severity.WARNING,
+ implementation = SCOPES
+ )
+
+ private val ISSUE_FIELD_SITE_TARGET_ON_QUALIFIER_ANNOTATION: Issue = Issue.create(
+ id = "FieldSiteTargetOnQualifierAnnotation",
+ briefDescription = "Redundant 'field:' used for Dagger qualifier annotation.",
+ explanation =
+ """
+ It's redundant to use 'field:' site-targets for qualifier annotations.
+ """,
+ category = Category.CORRECTNESS,
+ priority = 5,
+ severity = Severity.WARNING,
+ implementation = SCOPES
+ )
+
+ private val ISSUE_MODULE_COMPANION_OBJECTS: Issue = Issue.create(
+ id = "ModuleCompanionObjects",
+ briefDescription = "Module companion objects should not be annotated with @Module.",
+ explanation =
+ """
+ Companion objects in @Module-annotated classes are considered part of the API.
+ """,
+ category = Category.CORRECTNESS,
+ priority = 5,
+ severity = Severity.WARNING,
+ implementation = SCOPES
+ )
+
+ private val ISSUE_MODULE_COMPANION_OBJECTS_NOT_IN_MODULE_PARENT: Issue = Issue.create(
+ id = "ModuleCompanionObjectsNotInModuleParent",
+ briefDescription = "Companion objects should not be annotated with @Module.",
+ explanation =
+ """
+ Companion objects in @Module-annotated classes are considered part of the API. This
+ companion object is not a companion to an @Module-annotated class though, and should be
+ moved to a top-level object declaration instead otherwise Dagger will ignore companion
+ object.
+ """,
+ category = Category.CORRECTNESS,
+ priority = 5,
+ severity = Severity.WARNING,
+ implementation = SCOPES
+ )
+
+ private const val PROVIDES_ANNOTATION = "dagger.Provides"
+ private const val JVM_STATIC_ANNOTATION = "kotlin.jvm.JvmStatic"
+ private const val INJECT_ANNOTATION = "javax.inject.Inject"
+ private const val QUALIFIER_ANNOTATION = "javax.inject.Qualifier"
+ private const val MODULE_ANNOTATION = "dagger.Module"
+
+ val issues: List<Issue> = listOf(
+ ISSUE_JVM_STATIC_PROVIDES_IN_OBJECT,
+ ISSUE_FIELD_SITE_TARGET_ON_QUALIFIER_ANNOTATION,
+ ISSUE_MODULE_COMPANION_OBJECTS,
+ ISSUE_MODULE_COMPANION_OBJECTS_NOT_IN_MODULE_PARENT
+ )
+ }
+
+ override fun getApplicableUastTypes(): List<Class<out UElement>>? {
+ return listOf(UMethod::class.java, UField::class.java, UClass::class.java)
+ }
+
+ override fun createUastHandler(context: JavaContext): UElementHandler? {
+ if (!isKotlin(context.psiFile)) {
+ // This is only relevant for Kotlin files.
+ return null
+ }
+ return object : UElementHandler() {
+ override fun visitField(node: UField) {
+ if (!context.evaluator.isLateInit(node)) {
+ return
+ }
+ // Can't use hasAnnotation because it doesn't capture all annotations!
+ val injectAnnotation =
+ node.annotations.find { it.qualifiedName == INJECT_ANNOTATION } ?: return
+ // Look for qualifier annotations
+ node.annotations.forEach { annotation ->
+ if (annotation === injectAnnotation) {
+ // Skip the inject annotation
+ return@forEach
+ }
+ // Check if it's a FIELD site target
+ val sourcePsi = annotation.sourcePsi
+ if (sourcePsi is KtAnnotationEntry &&
+ sourcePsi.useSiteTarget?.getAnnotationUseSiteTarget() == AnnotationUseSiteTarget.FIELD
+ ) {
+ // Check if this annotation is a qualifier annotation
+ if (annotation.resolve()?.hasAnnotation(QUALIFIER_ANNOTATION) == true) {
+ context.report(
+ ISSUE_FIELD_SITE_TARGET_ON_QUALIFIER_ANNOTATION,
+ context.getLocation(annotation),
+ ISSUE_FIELD_SITE_TARGET_ON_QUALIFIER_ANNOTATION
+ .getBriefDescription(TextFormat.TEXT),
+ LintFix.create()
+ .name("Remove 'field:'")
+ .replace()
+ .text("field:")
+ .with("")
+ .autoFix()
+ .build()
+ )
+ }
+ }
+ }
+ }
+
+ override fun visitMethod(node: UMethod) {
+ if (!node.isConstructor &&
+ node.hasAnnotation(PROVIDES_ANNOTATION) &&
+ node.hasAnnotation(JVM_STATIC_ANNOTATION)
+ ) {
+ val containingClass = node.containingClass?.toUElement(UClass::class.java) ?: return
+ if (containingClass.isObject()) {
+ val annotation = node.findAnnotation(JVM_STATIC_ANNOTATION)!!
+ context.report(
+ ISSUE_JVM_STATIC_PROVIDES_IN_OBJECT,
+ context.getLocation(annotation),
+ ISSUE_JVM_STATIC_PROVIDES_IN_OBJECT.getBriefDescription(TextFormat.TEXT),
+ LintFix.create()
+ .name("Remove @JvmStatic")
+ .replace()
+ .pattern("(@(kotlin\\.jvm\\.)?JvmStatic)")
+ .with("")
+ .autoFix()
+ .build()
+ )
+ }
+ }
+ }
+
+ override fun visitClass(node: UClass) {
+ if (node.hasAnnotation(MODULE_ANNOTATION) && node.isCompanionObject(context.evaluator)) {
+ val parent = node.getUastParentOfType(UClass::class.java, false)!!
+ if (parent.hasAnnotation(MODULE_ANNOTATION)) {
+ context.report(
+ ISSUE_MODULE_COMPANION_OBJECTS,
+ context.getLocation(node as UElement),
+ ISSUE_MODULE_COMPANION_OBJECTS.getBriefDescription(TextFormat.TEXT),
+ LintFix.create()
+ .name("Remove @Module")
+ .replace()
+ .pattern("(@(dagger\\.)?Module)")
+ .with("")
+ .autoFix()
+ .build()
+
+ )
+ } else {
+ context.report(
+ ISSUE_MODULE_COMPANION_OBJECTS_NOT_IN_MODULE_PARENT,
+ context.getLocation(node as UElement),
+ ISSUE_MODULE_COMPANION_OBJECTS_NOT_IN_MODULE_PARENT
+ .getBriefDescription(TextFormat.TEXT)
+ )
+ }
+ }
+ }
+ }
+ }
+
+ /** @return whether or not the [this] is a Kotlin `companion object` type. */
+ private fun UClass.isCompanionObject(evaluator: JavaEvaluator): Boolean {
+ return isObject() && evaluator.hasModifier(this, KtTokens.COMPANION_KEYWORD)
+ }
+
+ /** @return whether or not the [this] is a Kotlin `object` type. */
+ private fun UClass.isObject(): Boolean {
+ return this is KotlinUClass && ktClass is KtObjectDeclaration
+ }
+}
diff --git a/java/dagger/model/BUILD b/java/dagger/model/BUILD
index 5fe0db3..0be8fc5 100644
--- a/java/dagger/model/BUILD
+++ b/java/dagger/model/BUILD
@@ -15,14 +15,23 @@
# Description:
# Dagger's core APIs exposed for plugins
-package(default_visibility = ["//:src"])
-
+load("@rules_java//java:defs.bzl", "java_library")
load(
"//:build_defs.bzl",
"DOCLINT_HTML_AND_SYNTAX",
"DOCLINT_REFERENCES",
)
+package(
+ default_visibility = [
+ # The dagger/spi should be the only direct dependent on this target.
+ # If you need to depend on :model, depend on dagger/spi instead so
+ # that pom files correctly pick up the spi maven dependency.
+ # TODO(bcorso): Consider if :model should have its own maven coordinates.
+ "//java/dagger/spi:__pkg__",
+ ],
+)
+
INTERNAL_PROXIES = ["BindingGraphProxies.java"]
filegroup(
@@ -39,14 +48,16 @@
javacopts = DOCLINT_HTML_AND_SYNTAX + DOCLINT_REFERENCES,
deps = [
"//java/dagger:core",
- "//java/dagger/internal/codegen:jdk-and-guava-extras",
+ "//java/dagger/internal/codegen/extension",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/internal/guava:graph",
"//java/dagger/producers",
- "@google_bazel_common//third_party/java/auto:common",
"@google_bazel_common//third_party/java/auto:value",
"@google_bazel_common//third_party/java/error_prone:annotations",
- "@google_bazel_common//third_party/java/guava",
"@google_bazel_common//third_party/java/javapoet",
"@google_bazel_common//third_party/java/jsr330_inject",
+ "@maven//:com_google_auto_auto_common",
],
)
@@ -54,8 +65,11 @@
name = "internal-proxies",
srcs = INTERNAL_PROXIES,
tags = ["maven:merged"],
+ visibility = ["//:src"],
deps = [
":model",
- "@google_bazel_common//third_party/java/guava",
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/internal/guava:graph",
+ "@google_bazel_common//third_party/java/auto:value",
],
)
diff --git a/java/dagger/model/BindingGraph.java b/java/dagger/model/BindingGraph.java
index 748bf38..1ccba43 100644
--- a/java/dagger/model/BindingGraph.java
+++ b/java/dagger/model/BindingGraph.java
@@ -20,12 +20,10 @@
import static com.google.common.graph.Graphs.inducedSubgraph;
import static com.google.common.graph.Graphs.reachableNodes;
import static com.google.common.graph.Graphs.transpose;
-import static dagger.internal.codegen.DaggerStreams.instancesOf;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSetMultimap;
+import static dagger.internal.codegen.extension.DaggerStreams.instancesOf;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSetMultimap;
-import com.google.auto.value.AutoValue;
-import com.google.auto.value.extension.memoized.Memoized;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSetMultimap;
import com.google.common.graph.EndpointPair;
@@ -48,8 +46,8 @@
* <li>an entire component hierarchy rooted at a {@link dagger.Component} or {@link
* dagger.producers.ProductionComponent}
* <li>a partial component hierarchy rooted at a {@link dagger.Subcomponent} or {@link
- * dagger.producers.ProductionSubcomponent} (only when {@code
- * -Adagger.experimentalAheadOfTimeSubcomponents=enabled} is passed to the compiler)
+ * dagger.producers.ProductionSubcomponent} (only when the value of {@code
+ * -Adagger.fullBindingGraphValidation} is not {@code NONE})
* <li>the bindings installed by a {@link Module} or {@link dagger.producers.ProducerModule},
* including all subcomponents generated by {@link Module#subcomponents()} ()} and {@link
* dagger.producers.ProducerModule#subcomponents()} ()}
@@ -88,20 +86,12 @@
*
* <p><b>Note that this API is experimental and will change.</b>
*/
-@AutoValue
public abstract class BindingGraph {
-
- static BindingGraph create(Network<Node, Edge> network, boolean isFullBindingGraph) {
- return new AutoValue_BindingGraph(ImmutableNetwork.copyOf(network), isFullBindingGraph);
- }
-
- BindingGraph() {}
-
/** Returns the graph in its {@link Network} representation. */
public abstract ImmutableNetwork<Node, Edge> network();
@Override
- public final String toString() {
+ public String toString() {
return network().toString();
}
@@ -115,7 +105,7 @@
* full binding graphs for components and subcomponents as well as modules.
*/
@Deprecated
- public final boolean isModuleBindingGraph() {
+ public boolean isModuleBindingGraph() {
return !rootComponentNode().isRealComponent();
}
@@ -131,54 +121,54 @@
/**
* Returns {@code true} if the {@link #rootComponentNode()} is a subcomponent. This occurs in
- * ahead-of-time-subcomponents mode.
+ * when {@code -Adagger.fullBindingGraphValidation} is used in a compilation with a subcomponent.
*
* @deprecated use {@link ComponentNode#isSubcomponent() rootComponentNode().isSubcomponent()}
* instead
*/
@Deprecated
- public final boolean isPartialBindingGraph() {
+ public boolean isPartialBindingGraph() {
return rootComponentNode().isSubcomponent();
}
/** Returns the bindings. */
- public final ImmutableSet<Binding> bindings() {
+ public ImmutableSet<Binding> bindings() {
return nodes(Binding.class);
}
/** Returns the bindings for a key. */
- public final ImmutableSet<Binding> bindings(Key key) {
+ public ImmutableSet<Binding> bindings(Key key) {
return nodes(Binding.class).stream()
.filter(binding -> binding.key().equals(key))
.collect(toImmutableSet());
}
/** Returns the nodes that represent missing bindings. */
- public final ImmutableSet<MissingBinding> missingBindings() {
+ public ImmutableSet<MissingBinding> missingBindings() {
return nodes(MissingBinding.class);
}
/** Returns the component nodes. */
- public final ImmutableSet<ComponentNode> componentNodes() {
+ public ImmutableSet<ComponentNode> componentNodes() {
return nodes(ComponentNode.class);
}
/** Returns the component node for a component. */
- public final Optional<ComponentNode> componentNode(ComponentPath component) {
+ public Optional<ComponentNode> componentNode(ComponentPath component) {
return componentNodes().stream()
.filter(node -> node.componentPath().equals(component))
.findFirst();
}
/** Returns the component nodes for a component. */
- public final ImmutableSet<ComponentNode> componentNodes(TypeElement component) {
+ public ImmutableSet<ComponentNode> componentNodes(TypeElement component) {
return componentNodes().stream()
.filter(node -> node.componentPath().currentComponent().equals(component))
.collect(toImmutableSet());
}
/** Returns the component node for the root component. */
- public final ComponentNode rootComponentNode() {
+ public ComponentNode rootComponentNode() {
return componentNodes().stream()
.filter(node -> node.componentPath().atRoot())
.findFirst()
@@ -186,7 +176,7 @@
}
/** Returns the dependency edges. */
- public final ImmutableSet<DependencyEdge> dependencyEdges() {
+ public ImmutableSet<DependencyEdge> dependencyEdges() {
return dependencyEdgeStream().collect(toImmutableSet());
}
@@ -197,14 +187,14 @@
* have no binding for a key will have an edge whose {@linkplain EndpointPair#target() target
* node} is a {@link MissingBinding}.
*/
- public final ImmutableSetMultimap<DependencyRequest, DependencyEdge> dependencyEdges(
+ public ImmutableSetMultimap<DependencyRequest, DependencyEdge> dependencyEdges(
Binding binding) {
return dependencyEdgeStream(binding)
.collect(toImmutableSetMultimap(DependencyEdge::dependencyRequest, edge -> edge));
}
/** Returns the dependency edges for a dependency request. */
- public final ImmutableSet<DependencyEdge> dependencyEdges(DependencyRequest dependencyRequest) {
+ public ImmutableSet<DependencyEdge> dependencyEdges(DependencyRequest dependencyRequest) {
return dependencyEdgeStream()
.filter(edge -> edge.dependencyRequest().equals(dependencyRequest))
.collect(toImmutableSet());
@@ -214,7 +204,7 @@
* Returns the dependency edges for the entry points of a given {@code component}. Each edge's
* source node is that component's component node.
*/
- public final ImmutableSet<DependencyEdge> entryPointEdges(ComponentPath component) {
+ public ImmutableSet<DependencyEdge> entryPointEdges(ComponentPath component) {
return dependencyEdgeStream(componentNode(component).get()).collect(toImmutableSet());
}
@@ -226,12 +216,12 @@
* Returns the dependency edges for all entry points for all components and subcomponents. Each
* edge's source node is a component node.
*/
- public final ImmutableSet<DependencyEdge> entryPointEdges() {
+ public ImmutableSet<DependencyEdge> entryPointEdges() {
return entryPointEdgeStream().collect(toImmutableSet());
}
/** Returns the binding or missing binding nodes that directly satisfy entry points. */
- public final ImmutableSet<MaybeBinding> entryPointBindings() {
+ public ImmutableSet<MaybeBinding> entryPointBindings() {
return entryPointEdgeStream()
.map(edge -> (MaybeBinding) network().incidentNodes(edge).target())
.collect(toImmutableSet());
@@ -241,7 +231,7 @@
* Returns the edges for entry points that transitively depend on a binding or missing binding for
* a key.
*/
- public final ImmutableSet<DependencyEdge> entryPointEdgesDependingOnBinding(
+ public ImmutableSet<DependencyEdge> entryPointEdgesDependingOnBinding(
MaybeBinding binding) {
ImmutableNetwork<Node, DependencyEdge> dependencyGraph = dependencyGraph();
Network<Node, DependencyEdge> subgraphDependingOnBinding =
@@ -251,19 +241,19 @@
}
/** Returns the bindings that directly request a given binding as a dependency. */
- public final ImmutableSet<Binding> requestingBindings(MaybeBinding binding) {
+ public ImmutableSet<Binding> requestingBindings(MaybeBinding binding) {
return network().predecessors(binding).stream()
.flatMap(instancesOf(Binding.class))
.collect(toImmutableSet());
}
/**
- * Returns the bindings that a given binding directly request as a dependency. Does not include
+ * Returns the bindings that a given binding directly requests as a dependency. Does not include
* any {@link MissingBinding}s.
*
* @see #requestedMaybeMissingBindings(Binding)
*/
- public final ImmutableSet<Binding> requestedBindings(Binding binding) {
+ public ImmutableSet<Binding> requestedBindings(Binding binding) {
return network().successors(binding).stream()
.flatMap(instancesOf(Binding.class))
.collect(toImmutableSet());
@@ -275,7 +265,7 @@
*
* @see #requestedBindings(Binding)
*/
- public final ImmutableSet<MaybeBinding> requestedMaybeMissingBindings(Binding binding) {
+ public ImmutableSet<MaybeBinding> requestedMaybeMissingBindings(Binding binding) {
return network().successors(binding).stream()
.flatMap(instancesOf(MaybeBinding.class))
.collect(toImmutableSet());
@@ -307,8 +297,7 @@
private static final ImmutableSet<Class<? extends Node>> NODE_TYPES =
ImmutableSet.of(Binding.class, MissingBinding.class, ComponentNode.class);
- @Memoized
- ImmutableSetMultimap<Class<? extends Node>, ? extends Node> nodesByClass() {
+ protected ImmutableSetMultimap<Class<? extends Node>, ? extends Node> nodesByClass() {
return network().nodes().stream()
.collect(
toImmutableSetMultimap(
@@ -402,37 +391,26 @@
}
/** A node in the binding graph that represents a missing binding for a key in a component. */
- @AutoValue
public abstract static class MissingBinding implements MaybeBinding {
- static MissingBinding create(ComponentPath component, Key key) {
- return new AutoValue_BindingGraph_MissingBinding(component, key);
- }
-
/** The component in which the binding is missing. */
@Override
public abstract ComponentPath componentPath();
/** The key for which there is no binding. */
+ @Override
public abstract Key key();
/** @deprecated This always returns {@code Optional.empty()}. */
@Override
@Deprecated
- public final Optional<Binding> binding() {
+ public Optional<Binding> binding() {
return Optional.empty();
}
@Override
- public final String toString() {
+ public String toString() {
return String.format("missing binding for %s in %s", key(), componentPath());
}
-
- @Memoized
- @Override
- public abstract int hashCode();
-
- @Override
- public abstract boolean equals(Object o);
}
/**
diff --git a/java/dagger/model/BindingGraphProxies.java b/java/dagger/model/BindingGraphProxies.java
index c450475..85d4df8 100644
--- a/java/dagger/model/BindingGraphProxies.java
+++ b/java/dagger/model/BindingGraphProxies.java
@@ -16,6 +16,10 @@
package dagger.model;
+import com.google.auto.value.AutoValue;
+import com.google.auto.value.extension.memoized.Memoized;
+import com.google.common.collect.ImmutableSetMultimap;
+import com.google.common.graph.ImmutableNetwork;
import com.google.common.graph.Network;
import dagger.model.BindingGraph.Edge;
import dagger.model.BindingGraph.MissingBinding;
@@ -27,14 +31,35 @@
* API.</em>
*/
public final class BindingGraphProxies {
+
+ @AutoValue
+ abstract static class BindingGraphImpl extends BindingGraph {
+ @Override
+ @Memoized
+ public ImmutableSetMultimap<Class<? extends Node>, ? extends Node> nodesByClass() {
+ return super.nodesByClass();
+ }
+ }
+
+ @AutoValue
+ abstract static class MissingBindingImpl extends MissingBinding {
+ @Memoized
+ @Override
+ public abstract int hashCode();
+
+ @Override
+ public abstract boolean equals(Object o);
+ }
+
/** Creates a new {@link BindingGraph}. */
public static BindingGraph bindingGraph(Network<Node, Edge> network, boolean isFullBindingGraph) {
- return BindingGraph.create(network, isFullBindingGraph);
+ return new AutoValue_BindingGraphProxies_BindingGraphImpl(
+ ImmutableNetwork.copyOf(network), isFullBindingGraph);
}
/** Creates a new {@link MissingBinding}. */
public static MissingBinding missingBindingNode(ComponentPath component, Key key) {
- return MissingBinding.create(component, key);
+ return new AutoValue_BindingGraphProxies_MissingBindingImpl(component, key);
}
private BindingGraphProxies() {}
diff --git a/java/dagger/model/BindingKind.java b/java/dagger/model/BindingKind.java
index 20d7b42..9bef8fc 100644
--- a/java/dagger/model/BindingKind.java
+++ b/java/dagger/model/BindingKind.java
@@ -25,6 +25,15 @@
PROVISION,
/**
+ * A binding for an {@link javax.inject.Inject}-annotated constructor that contains at least one
+ * {@link dagger.assisted.Assisted}-annotated parameter.
+ */
+ ASSISTED_INJECTION,
+
+ /** A binding for an {@link dagger.assisted.AssistedFactory}-annotated type. */
+ ASSISTED_FACTORY,
+
+ /**
* An implicit binding for a {@link dagger.Component}- or {@link
* dagger.producers.ProductionComponent}-annotated type.
*/
diff --git a/java/dagger/model/testing/BUILD b/java/dagger/model/testing/BUILD
index a9d5f19..9c9f44a 100644
--- a/java/dagger/model/testing/BUILD
+++ b/java/dagger/model/testing/BUILD
@@ -15,25 +15,27 @@
# Description:
# Test utilities for the Dagger model
-package(default_visibility = ["//:src"])
-
+load("@rules_java//java:defs.bzl", "java_library")
load(
"//:build_defs.bzl",
"DOCLINT_HTML_AND_SYNTAX",
"DOCLINT_REFERENCES",
)
+package(default_visibility = ["//:src"])
+
java_library(
name = "testing",
testonly = 1,
srcs = glob(["*.java"]),
javacopts = DOCLINT_HTML_AND_SYNTAX + DOCLINT_REFERENCES,
deps = [
- "//java/dagger/internal/codegen:jdk-and-guava-extras",
- "//java/dagger/model",
+ "//java/dagger/internal/codegen/extension",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/spi",
"@google_bazel_common//third_party/java/auto:value",
"@google_bazel_common//third_party/java/checker_framework_annotations",
- "@google_bazel_common//third_party/java/guava",
"@google_bazel_common//third_party/java/truth",
],
)
diff --git a/java/dagger/model/testing/BindingGraphSubject.java b/java/dagger/model/testing/BindingGraphSubject.java
index dc17c1d..2f032cd 100644
--- a/java/dagger/model/testing/BindingGraphSubject.java
+++ b/java/dagger/model/testing/BindingGraphSubject.java
@@ -18,7 +18,7 @@
import static com.google.common.collect.Iterables.getOnlyElement;
import static com.google.common.truth.Truth.assertAbout;
-import static dagger.internal.codegen.DaggerStreams.toImmutableSet;
+import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet;
import com.google.common.collect.ImmutableSet;
import com.google.common.truth.FailureMetadata;
@@ -29,7 +29,7 @@
import org.checkerframework.checker.nullness.compatqual.NullableDecl;
/** A Truth subject for making assertions on a {@link BindingGraph}. */
-public final class BindingGraphSubject extends Subject<BindingGraphSubject, BindingGraph> {
+public final class BindingGraphSubject extends Subject {
/** Starts a fluent assertion about a {@link BindingGraph}. */
public static BindingGraphSubject assertThat(BindingGraph bindingGraph) {
@@ -107,7 +107,7 @@
}
/** A Truth subject for a {@link Binding}. */
- public final class BindingSubject extends Subject<BindingSubject, Binding> {
+ public final class BindingSubject extends Subject {
private final Binding actual;
diff --git a/java/dagger/producers/BUILD b/java/dagger/producers/BUILD
index ad065a1..41762e6 100644
--- a/java/dagger/producers/BUILD
+++ b/java/dagger/producers/BUILD
@@ -15,15 +15,17 @@
# Description:
# An asynchronous dependency injection system that extends JSR-330.
-package(default_visibility = ["//:src"])
-
+load("@rules_java//java:defs.bzl", "java_library")
load(
"//:build_defs.bzl",
"DOCLINT_HTML_AND_SYNTAX",
"DOCLINT_REFERENCES",
+ "POM_VERSION",
"SOURCE_7_TARGET_7",
)
-load("//tools:maven.bzl", "pom_file", "POM_VERSION")
+load("//tools:maven.bzl", "gen_maven_artifact")
+
+package(default_visibility = ["//:src"])
# Work around b/70476182 which prevents Kythe from connecting :producers to the .java files it
# contains.
@@ -40,35 +42,38 @@
javacopts = SOURCE_7_TARGET_7 + DOCLINT_HTML_AND_SYNTAX + DOCLINT_REFERENCES,
tags = ["maven_coordinates=com.google.dagger:dagger-producers:" + POM_VERSION],
exports = [
- # TODO(dpb): Don't export any of Guava.
- "@google_bazel_common//third_party/java/guava",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:concurrent",
"@google_bazel_common//third_party/java/jsr330_inject",
],
deps = [
"//java/dagger:core",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/internal/guava:concurrent",
"@google_bazel_common//third_party/java/checker_framework_annotations",
"@google_bazel_common//third_party/java/error_prone:annotations",
- "@google_bazel_common//third_party/java/guava",
"@google_bazel_common//third_party/java/jsr330_inject",
],
)
-pom_file(
- name = "pom",
- artifact_id = "dagger-producers",
+gen_maven_artifact(
+ name = "artifact",
+ artifact_coordinates = "com.google.dagger:dagger-producers:" + POM_VERSION,
artifact_name = "Dagger Producers",
- targets = [":producers"],
-)
-
-load("@google_bazel_common//tools/javadoc:javadoc.bzl", "javadoc_library")
-
-javadoc_library(
- name = "producers-javadoc",
- srcs = SRCS,
- exclude_packages = [
+ artifact_target = ":producers",
+ artifact_target_maven_deps = [
+ "com.google.dagger:dagger",
+ "com.google.guava:failureaccess",
+ "com.google.guava:guava", # TODO(bcorso): Remove guava dependency and ban it?
+ "javax.inject:javax.inject",
+ "org.checkerframework:checker-compat-qual",
+ ],
+ javadoc_exclude_packages = [
"dagger.producers.internal",
"dagger.producers.monitoring.internal",
],
- root_packages = ["dagger.producers"],
- deps = [":producers"],
+ javadoc_root_packages = ["dagger.producers"],
+ javadoc_srcs = SRCS,
+ # TODO(bcorso): Look more into why auto/common shading isn't needed here.
)
diff --git a/java/dagger/producers/internal/MissingBindingProducer.java b/java/dagger/producers/internal/MissingBindingProducer.java
deleted file mode 100644
index 5721569..0000000
--- a/java/dagger/producers/internal/MissingBindingProducer.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.producers.internal;
-
-import com.google.common.util.concurrent.ListenableFuture;
-import dagger.producers.Producer;
-
-/**
- * A {@link Producer} that always throws on calls to {@link Producer#get()}. This is necessary in
- * ahead-of-time subcomponents mode, where modifiable binding methods need to return a {@code
- * Producer<T>} to a framework instance initialization that is pruned and no longer in the binding
- * graph, but was present in a superclass implementation. This class fulfills that requirement but
- * is still practically unusable.
- */
-public final class MissingBindingProducer<T> extends AbstractProducer<T> {
- private static final MissingBindingProducer<Object> INSTANCE = new MissingBindingProducer<>();
-
- private MissingBindingProducer() {}
-
- @SuppressWarnings({"unchecked", "rawtypes"}) // safe covariant cast
- public static <T> Producer<T> create() {
- return (Producer) INSTANCE;
- }
-
- @Override
- protected ListenableFuture<T> compute() {
- throw new AssertionError(
- "This binding is not part of the final binding graph. The key was requested by a binding "
- + "that was believed to possibly be part of the graph, but is no longer requested. "
- + "If this exception is thrown, it is the result of a Dagger bug.");
- }
-}
diff --git a/java/dagger/producers/monitoring/TimingProducerMonitor.java b/java/dagger/producers/monitoring/TimingProducerMonitor.java
index c63e108..ebb90cf 100644
--- a/java/dagger/producers/monitoring/TimingProducerMonitor.java
+++ b/java/dagger/producers/monitoring/TimingProducerMonitor.java
@@ -25,6 +25,7 @@
* A monitor that measures the timing of the execution of a producer method, and logs those timings
* with the given recorder.
*/
+@SuppressWarnings("GoodTime") // should use java.time.Duration
final class TimingProducerMonitor extends ProducerMonitor {
private final ProducerTimingRecorder recorder;
private final Stopwatch stopwatch;
diff --git a/java/dagger/producers/monitoring/TimingRecorders.java b/java/dagger/producers/monitoring/TimingRecorders.java
index 5fbe3e3..be89319 100644
--- a/java/dagger/producers/monitoring/TimingRecorders.java
+++ b/java/dagger/producers/monitoring/TimingRecorders.java
@@ -30,6 +30,7 @@
*/
// TODO(beder): Reduce the visibility of this class to package-private.
@Beta
+@SuppressWarnings("GoodTime") // Should be using java.time.Instant/Duration as opposed to nanos
public final class TimingRecorders {
private static final Logger logger = Logger.getLogger(TimingRecorders.class.getName());
diff --git a/java/dagger/spi/BUILD b/java/dagger/spi/BUILD
index 9c04582..cbec465 100644
--- a/java/dagger/spi/BUILD
+++ b/java/dagger/spi/BUILD
@@ -15,42 +15,67 @@
# Description:
# The Service Provider Interface for Dagger's binding graph model
-package(default_visibility = ["//:src"])
-
+load("@rules_java//java:defs.bzl", "java_library")
load(
"//:build_defs.bzl",
"DOCLINT_HTML_AND_SYNTAX",
"DOCLINT_REFERENCES",
+ "POM_VERSION",
)
+load("//tools:maven.bzl", "gen_maven_artifact")
+
+package(default_visibility = ["//:src"])
filegroup(
name = "spi-srcs",
- srcs = glob(["*.java"]),
+ srcs = glob(["*.java"]) + [
+ "//java/dagger/model:model-srcs",
+ ],
)
-load("//tools:maven.bzl", "POM_VERSION", "pom_file")
-
java_library(
name = "spi",
- srcs = [":spi-srcs"],
+ srcs = glob(["*.java"]),
javacopts = DOCLINT_HTML_AND_SYNTAX + DOCLINT_REFERENCES,
tags = ["maven_coordinates=com.google.dagger:dagger-spi:" + POM_VERSION],
+ exports = [
+ "//java/dagger/model",
+ ],
deps = [
"//java/dagger:core",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
"//java/dagger/model",
"@google_bazel_common//third_party/java/auto:value",
"@google_bazel_common//third_party/java/error_prone:annotations",
- "@google_bazel_common//third_party/java/guava",
"@google_bazel_common//third_party/java/jsr330_inject",
],
)
-pom_file(
- name = "pom",
- artifact_id = "dagger-spi",
+gen_maven_artifact(
+ name = "artifact",
+ artifact_coordinates = "com.google.dagger:dagger-spi:" + POM_VERSION,
artifact_name = "Dagger SPI",
- targets = [
+ artifact_target = ":spi",
+ artifact_target_libs = [
+ "//java/dagger/internal/codegen/extension",
"//java/dagger/model",
- ":spi",
],
+ artifact_target_maven_deps = [
+ "com.google.auto:auto-common",
+ "com.google.code.findbugs:jsr305",
+ "com.google.dagger:dagger-producers",
+ "com.google.dagger:dagger",
+ "com.google.guava:failureaccess",
+ "com.google.guava:guava",
+ "com.squareup:javapoet",
+ "javax.inject:javax.inject",
+ ],
+ javadoc_root_packages = [
+ "dagger.model",
+ "dagger.spi",
+ ],
+ javadoc_srcs = [":spi-srcs"],
+ shaded_deps = ["@maven//:com_google_auto_auto_common"],
+ shaded_rules = ["rule com.google.auto.common.** dagger.spi.shaded.auto.common.@1"],
)
diff --git a/java/dagger/testing/compile/BUILD b/java/dagger/testing/compile/BUILD
new file mode 100644
index 0000000..20e6a3d
--- /dev/null
+++ b/java/dagger/testing/compile/BUILD
@@ -0,0 +1,32 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Helpers class for java compiler tests.
+
+load("@rules_java//java:defs.bzl", "java_library")
+
+package(default_visibility = ["//:src"])
+
+java_library(
+ name = "compile",
+ testonly = 1,
+ srcs = ["CompilerTests.java"],
+ deps = [
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/internal/guava:io",
+ "@google_bazel_common//third_party/java/compile_testing",
+ ],
+)
diff --git a/java/dagger/testing/compile/CompilerTests.java b/java/dagger/testing/compile/CompilerTests.java
new file mode 100644
index 0000000..6750d0c
--- /dev/null
+++ b/java/dagger/testing/compile/CompilerTests.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.testing.compile;
+
+import static com.google.common.base.Strings.isNullOrEmpty;
+import static com.google.common.collect.MoreCollectors.onlyElement;
+import static com.google.common.collect.Streams.stream;
+import static com.google.testing.compile.Compiler.javac;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.io.Files;
+import com.google.testing.compile.Compiler;
+import java.io.File;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Map;
+import java.util.NoSuchElementException;
+
+/**
+ * A helper class for working with java compiler tests.
+ */
+public final class CompilerTests {
+ private CompilerTests() {}
+
+ /** Returns the {@plainlink File jar file} containing the compiler deps. */
+ public static File compilerDepsJar() {
+ try {
+ return stream(Files.fileTraverser().breadthFirst(getRunfilesDir()))
+ .filter(file -> file.getName().endsWith("_compiler_deps_deploy.jar"))
+ .collect(onlyElement());
+ } catch (NoSuchElementException e) {
+ throw new IllegalStateException(
+ "No compiler deps jar found. Are you using the Dagger compiler_test macro?", e);
+ }
+ }
+
+ /** Returns a {@link Compiler} with the compiler deps jar added to the class path. */
+ public static Compiler compiler() {
+ return javac().withClasspath(ImmutableList.of(compilerDepsJar()));
+ }
+
+ private static File getRunfilesDir() {
+ return getRunfilesPath().toFile();
+ }
+
+ private static Path getRunfilesPath() {
+ Path propPath = getRunfilesPath(System.getProperties());
+ if (propPath != null) {
+ return propPath;
+ }
+
+ Path envPath = getRunfilesPath(System.getenv());
+ if (envPath != null) {
+ return envPath;
+ }
+
+ Path cwd = Paths.get("").toAbsolutePath();
+ return cwd.getParent();
+ }
+
+ private static Path getRunfilesPath(Map<?, ?> map) {
+ String runfilesPath = (String) map.get("TEST_SRCDIR");
+ return isNullOrEmpty(runfilesPath) ? null : Paths.get(runfilesPath);
+ }
+}
diff --git a/java/dagger/testing/compile/macros.bzl b/java/dagger/testing/compile/macros.bzl
new file mode 100644
index 0000000..9543e0e
--- /dev/null
+++ b/java/dagger/testing/compile/macros.bzl
@@ -0,0 +1,89 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Macros for building compiler tests."""
+
+load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "kt_jvm_library")
+
+def compiler_test(name, size = "large", compiler_deps = None, **kwargs):
+ """Generates a java_test that tests java compilation with the given compiler deps.
+
+ This macro separates the compiler dependencies from the test dependencies to avoid
+ 1-version violations. For example, this often happens when the java_test uses java
+ dependencies but the compiler test expects the android version of the dependencies.
+
+ Args:
+ name: The name of the java_test.
+ size: The size of the test (default "large" since this test does disk I/O).
+ compiler_deps: The deps needed during compilation.
+ **kwargs: The parameters to pass to the generated java_test.
+
+ Returns:
+ None
+ """
+
+ # This JAR is loaded at runtime and contains the dependencies used by the compiler during tests.
+ # We separate these dependencies from the java_test dependencies to avoid 1 version violations.
+ native.java_binary(
+ name = name + "_compiler_deps",
+ testonly = 1,
+ tags = ["notap"],
+ visibility = ["//visibility:private"],
+ main_class = "Object.class",
+ runtime_deps = compiler_deps,
+ )
+
+ # Add the compiler deps jar, generated above, to the test's data.
+ kwargs["data"] = kwargs.get("data", []) + [name + "_compiler_deps_deploy.jar"]
+
+ # Need to check for srcs since for Kotlin tests we use a runtime dep on the kt_jvm_library
+ # target. We don't need to worry about adding a compile testing dep since kt_compiler_test
+ # adds that in the kt_jvm_library. Adding this dep automatically is merely a convenience
+ # for cases with srcs anyway.
+ if kwargs.get("srcs", None):
+ # Add a dep to allow usage of CompilerTests.
+ kwargs["deps"] = kwargs.get("deps", []) + ["//java/dagger/testing/compile"]
+
+ native.java_test(name = name, size = size, **kwargs)
+
+def kt_compiler_test(name, srcs = [], deps = [], **kwargs):
+ """Generates a java_test that tests java compilation with the given compiler deps.
+
+ This macro works the same as the above compiler_test, but for Kotlin sources.
+
+ Args:
+ name: The name of the java_test.
+ srcs: Source files for the test (typically should include Kotlin sources). If no
+ sources are needed, just use compiler_test with runtime_deps.
+ deps: Deps for compiling the files in srcs.
+ **kwargs: The parameters to pass to compiler_test
+
+ Returns:
+ None
+ """
+ kt_jvm_library(
+ name = name + "_ktlib",
+ testonly = 1,
+ srcs = srcs,
+ deps = deps + ["//java/dagger/testing/compile"],
+ visibility = ["//visibility:private"],
+ )
+
+ compiler_test(
+ name = name,
+ runtime_deps = [
+ ":" + name + "_ktlib",
+ ],
+ **kwargs
+ )
diff --git a/javatests/artifacts/BUILD b/javatests/artifacts/BUILD
new file mode 100644
index 0000000..9b282de
--- /dev/null
+++ b/javatests/artifacts/BUILD
@@ -0,0 +1,18 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# This package contains gradle tests of the LOCAL-SNAPSHOT artifacts.
+
+package(default_visibility = ["//:src"])
diff --git a/javatests/artifacts/dagger-android/simple/app/build.gradle b/javatests/artifacts/dagger-android/simple/app/build.gradle
new file mode 100644
index 0000000..20a3734
--- /dev/null
+++ b/javatests/artifacts/dagger-android/simple/app/build.gradle
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+apply plugin: 'com.android.application'
+
+android {
+ compileSdkVersion 30
+ buildToolsVersion "30.0.2"
+
+ defaultConfig {
+ applicationId "dagger.android.simple"
+ minSdkVersion 15
+ targetSdkVersion 30
+ versionCode 1
+ versionName "1.0"
+ }
+ compileOptions {
+ sourceCompatibility 1.8
+ targetCompatibility 1.8
+ }
+ testOptions {
+ unitTests.includeAndroidResources = true
+ }
+ sourceSets {
+ String sharedTestDir = 'src/sharedTest/java'
+ test {
+ java.srcDirs += sharedTestDir
+ }
+ androidTest {
+ java.srcDirs += sharedTestDir
+ }
+ }
+}
+
+dependencies {
+ implementation 'androidx.appcompat:appcompat:1.2.0'
+ implementation 'com.google.dagger:dagger:LOCAL-SNAPSHOT'
+ implementation 'com.google.dagger:dagger-android-support:LOCAL-SNAPSHOT'
+ annotationProcessor 'com.google.dagger:dagger-compiler:LOCAL-SNAPSHOT'
+ annotationProcessor 'com.google.dagger:dagger-android-processor:LOCAL-SNAPSHOT'
+
+ testImplementation 'com.google.truth:truth:1.0.1'
+ testImplementation 'org.robolectric:robolectric:4.5-alpha-3'
+ testImplementation 'androidx.core:core:1.3.2'
+ testImplementation 'androidx.test.ext:junit:1.1.2'
+ testImplementation 'androidx.test:runner:1.3.0'
+ testImplementation 'androidx.test.espresso:espresso-core:3.3.0'
+ testImplementation 'com.google.dagger:dagger-compiler:LOCAL-SNAPSHOT'
+ testAnnotationProcessor 'com.google.dagger:dagger-android-processor:LOCAL-SNAPSHOT'
+
+ androidTestImplementation 'com.google.truth:truth:1.0.1'
+ androidTestImplementation 'androidx.test.ext:junit:1.1.2'
+ androidTestImplementation 'androidx.test:runner:1.3.0'
+ androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'
+ androidTestImplementation 'com.google.dagger:dagger-compiler:LOCAL-SNAPSHOT'
+ androidTestAnnotationProcessor 'com.google.dagger:dagger-android-processor:LOCAL-SNAPSHOT'
+
+ // To help us catch usages of Guava APIs for Java 8 in the '-jre' variant.
+ annotationProcessor'com.google.guava:guava:28.1-android'
+ testAnnotationProcessor'com.google.guava:guava:28.1-android'
+ androidTestAnnotationProcessor'com.google.guava:guava:28.1-android'
+}
diff --git a/javatests/artifacts/dagger-android/simple/app/src/main/AndroidManifest.xml b/javatests/artifacts/dagger-android/simple/app/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..0f765b5
--- /dev/null
+++ b/javatests/artifacts/dagger-android/simple/app/src/main/AndroidManifest.xml
@@ -0,0 +1,30 @@
+<!--
+ ~ Copyright (C) 2020 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="dagger.android.simple">
+
+ <application
+ android:name=".SimpleApplication"
+ android:label="@string/appName"
+ android:theme="@style/Theme.AppCompat.Light">
+ <activity android:name=".SimpleActivity" android:exported="true">
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN" />
+ <category android:name="android.intent.category.LAUNCHER" />
+ </intent-filter>
+ </activity>
+ </application>
+</manifest>
diff --git a/javatests/artifacts/dagger-android/simple/app/src/main/java/dagger/android/simple/Model.java b/javatests/artifacts/dagger-android/simple/app/src/main/java/dagger/android/simple/Model.java
new file mode 100644
index 0000000..d74a501
--- /dev/null
+++ b/javatests/artifacts/dagger-android/simple/app/src/main/java/dagger/android/simple/Model.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.android.simple;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import javax.inject.Qualifier;
+
+/** Qualifies bindings relating to {@link android.os.Build#MODEL}. */
+@Qualifier
+@Retention(RUNTIME)
+@Documented
+@interface Model {}
diff --git a/javatests/artifacts/dagger-android/simple/app/src/main/java/dagger/android/simple/ModelModule.java b/javatests/artifacts/dagger-android/simple/app/src/main/java/dagger/android/simple/ModelModule.java
new file mode 100644
index 0000000..5e04071
--- /dev/null
+++ b/javatests/artifacts/dagger-android/simple/app/src/main/java/dagger/android/simple/ModelModule.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.android.simple;
+
+import static android.os.Build.MODEL;
+
+import dagger.Module;
+import dagger.Provides;
+
+@Module
+final class ModelModule {
+ @Provides
+ @Model
+ static String provideModel() {
+ return MODEL;
+ }
+}
diff --git a/javatests/artifacts/dagger-android/simple/app/src/main/java/dagger/android/simple/SimpleActivity.java b/javatests/artifacts/dagger-android/simple/app/src/main/java/dagger/android/simple/SimpleActivity.java
new file mode 100644
index 0000000..39a88e3
--- /dev/null
+++ b/javatests/artifacts/dagger-android/simple/app/src/main/java/dagger/android/simple/SimpleActivity.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.android.simple;
+
+import android.os.Bundle;
+import android.util.Log;
+import android.widget.TextView;
+import dagger.Binds;
+import dagger.Module;
+import dagger.Subcomponent;
+import dagger.android.AndroidInjector;
+import dagger.android.support.DaggerAppCompatActivity;
+import dagger.multibindings.ClassKey;
+import dagger.multibindings.IntoMap;
+import javax.inject.Inject;
+
+/**
+ * The main activity of the application.
+ *
+ * <p>It can be injected with any binding from both {@link SimpleActivityComponent} and {@link
+ * SimpleApplication.SimpleComponent}.
+ */
+public class SimpleActivity extends DaggerAppCompatActivity {
+ @Subcomponent
+ interface SimpleActivityComponent extends AndroidInjector<SimpleActivity> {
+
+ @Subcomponent.Factory
+ interface Factory extends AndroidInjector.Factory<SimpleActivity> {}
+ }
+
+ @Module(
+ subcomponents = SimpleActivityComponent.class,
+ includes = UserNameModule.class
+ )
+ abstract static class InjectorModule {
+
+ @Binds
+ @IntoMap
+ @ClassKey(SimpleActivity.class)
+ abstract AndroidInjector.Factory<?> bind(SimpleActivityComponent.Factory factory);
+ }
+
+ private static final String TAG = SimpleActivity.class.getSimpleName();
+
+ @Inject @UserName String userName;
+ @Inject @Model String model;
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ Log.i(TAG, "Injected with userName and model: " + userName + ", " + model);
+
+ setContentView(R.layout.activity_main);
+
+ TextView greeting = (TextView) findViewById(R.id.greeting);
+ String text = getResources().getString(R.string.welcome, userName, model);
+ greeting.setText(text);
+ }
+}
diff --git a/javatests/artifacts/dagger-android/simple/app/src/main/java/dagger/android/simple/SimpleApplication.java b/javatests/artifacts/dagger-android/simple/app/src/main/java/dagger/android/simple/SimpleApplication.java
new file mode 100644
index 0000000..dcc7bcb
--- /dev/null
+++ b/javatests/artifacts/dagger-android/simple/app/src/main/java/dagger/android/simple/SimpleApplication.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.android.simple;
+
+import android.util.Log;
+import dagger.Component;
+import dagger.android.AndroidInjectionModule;
+import dagger.android.AndroidInjector;
+import dagger.android.DaggerApplication;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+/**
+ * A simple, skeletal application that demonstrates a dependency-injected application using the
+ * utilities in {@code dagger.android}.
+ */
+public class SimpleApplication extends DaggerApplication {
+ private static final String TAG = SimpleApplication.class.getSimpleName();
+
+ @Singleton
+ @Component(
+ modules = {
+ AndroidInjectionModule.class,
+ SimpleActivity.InjectorModule.class,
+ ModelModule.class
+ }
+ )
+ interface SimpleComponent extends AndroidInjector<SimpleApplication> {
+ @Component.Factory
+ interface Factory extends AndroidInjector.Factory<SimpleApplication> {}
+ }
+
+ @Inject @Model String model;
+
+ @Override
+ public void onCreate() {
+ super.onCreate();
+ Log.i(TAG, "Injected with model: " + model);
+ }
+
+ @Override
+ protected AndroidInjector<SimpleApplication> applicationInjector() {
+ return DaggerSimpleApplication_SimpleComponent.factory().create(this);
+ }
+}
diff --git a/javatests/artifacts/dagger-android/simple/app/src/main/java/dagger/android/simple/UserName.java b/javatests/artifacts/dagger-android/simple/app/src/main/java/dagger/android/simple/UserName.java
new file mode 100644
index 0000000..2f861b1
--- /dev/null
+++ b/javatests/artifacts/dagger-android/simple/app/src/main/java/dagger/android/simple/UserName.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.android.simple;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import javax.inject.Qualifier;
+
+/** Qualifies bindings relating to the user name. */
+@Qualifier
+@Retention(RUNTIME)
+@Documented
+@interface UserName {}
diff --git a/javatests/artifacts/dagger-android/simple/app/src/main/java/dagger/android/simple/UserNameModule.java b/javatests/artifacts/dagger-android/simple/app/src/main/java/dagger/android/simple/UserNameModule.java
new file mode 100644
index 0000000..d6bc0ac
--- /dev/null
+++ b/javatests/artifacts/dagger-android/simple/app/src/main/java/dagger/android/simple/UserNameModule.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.android.simple;
+
+import dagger.Module;
+import dagger.Provides;
+
+@Module
+final class UserNameModule {
+ @UserName
+ @Provides
+ static String provideUserName() {
+ return "ProdUser";
+ }
+
+ private UserNameModule() {}
+}
diff --git a/javatests/artifacts/dagger-android/simple/app/src/main/res/layout/activity_main.xml b/javatests/artifacts/dagger-android/simple/app/src/main/res/layout/activity_main.xml
new file mode 100644
index 0000000..3cecc4c
--- /dev/null
+++ b/javatests/artifacts/dagger-android/simple/app/src/main/res/layout/activity_main.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ Copyright (C) 2020 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+ android:layout_width="match_parent"
+ android:layout_height="match_parent"
+ android:background="@android:color/background_light">
+
+ <TextView
+ android:id="@+id/greeting"
+ android:layout_width="match_parent"
+ android:layout_height="match_parent"
+ android:layout_alignParentTop="true"
+ android:textColor="@android:color/primary_text_light"
+ />
+</RelativeLayout>
diff --git a/javatests/artifacts/dagger-android/simple/app/src/main/res/values/strings.xml b/javatests/artifacts/dagger-android/simple/app/src/main/res/values/strings.xml
new file mode 100644
index 0000000..579f478
--- /dev/null
+++ b/javatests/artifacts/dagger-android/simple/app/src/main/res/values/strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ Copyright (C) 2020 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+
+<resources>
+ <!--The app name [CHAR_LIMIT=25]-->
+ <string name="appName">Simple Dagger Android</string>
+
+ <!--The greeting message [CHAR_LIMIT=100]-->
+ <string name="welcome">Hello, %1$s! You are on build %2$s.</string>
+</resources>
diff --git a/javatests/artifacts/dagger-android/simple/app/src/sharedTest/java/dagger/android/simple/SimpleActivityTest.java b/javatests/artifacts/dagger-android/simple/app/src/sharedTest/java/dagger/android/simple/SimpleActivityTest.java
new file mode 100644
index 0000000..024da5c
--- /dev/null
+++ b/javatests/artifacts/dagger-android/simple/app/src/sharedTest/java/dagger/android/simple/SimpleActivityTest.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.android.simple;
+
+import static androidx.test.espresso.Espresso.onView;
+import static androidx.test.espresso.assertion.ViewAssertions.matches;
+import static androidx.test.espresso.matcher.ViewMatchers.withId;
+import static androidx.test.espresso.matcher.ViewMatchers.withText;
+import static com.google.common.truth.Truth.assertThat;
+
+import android.content.Context;
+import android.os.Build;
+import androidx.test.core.app.ActivityScenario;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.annotation.Config;
+
+/** A simple test using dagger-android that can be run with instrumentation or Robolectric tests. */
+@RunWith(AndroidJUnit4.class)
+// Robolectric requires Java9 to run API 29 and above, so use API 28 instead
+@Config(sdk = Build.VERSION_CODES.P)
+public final class SimpleActivityTest {
+
+ @Test
+ public void testActivityInject() throws Exception {
+ try (ActivityScenario<SimpleActivity> scenario =
+ ActivityScenario.launch(SimpleActivity.class)) {
+ scenario.onActivity(
+ activity -> {
+ onView(withId(R.id.greeting))
+ .check(matches(withText("Hello, ProdUser! You are on build robolectric.")));
+ });
+ }
+ }
+
+ @Test
+ public void verifyApplicationInstance() {
+ assertThat((Context) ApplicationProvider.getApplicationContext())
+ .isInstanceOf(SimpleApplication.class);
+ }
+}
diff --git a/javatests/artifacts/dagger-android/simple/build.gradle b/javatests/artifacts/dagger-android/simple/build.gradle
new file mode 100644
index 0000000..8c179e5
--- /dev/null
+++ b/javatests/artifacts/dagger-android/simple/build.gradle
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+buildscript {
+ ext {
+ agp_version = System.getenv('AGP_VERSION') ?: "4.2.0-beta04"
+ }
+ repositories {
+ google()
+ jcenter()
+ }
+ dependencies {
+ classpath "com.android.tools.build:gradle:$agp_version"
+ }
+}
+
+allprojects {
+ repositories {
+ google()
+ jcenter()
+ mavenCentral()
+ mavenLocal()
+ }
+}
+
diff --git a/javatests/artifacts/dagger-android/simple/gradle.properties b/javatests/artifacts/dagger-android/simple/gradle.properties
new file mode 100644
index 0000000..2d8d1e4
--- /dev/null
+++ b/javatests/artifacts/dagger-android/simple/gradle.properties
@@ -0,0 +1 @@
+android.useAndroidX=true
\ No newline at end of file
diff --git a/javatests/artifacts/dagger-android/simple/gradle/wrapper/gradle-wrapper.jar b/javatests/artifacts/dagger-android/simple/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000..5c2d1cf
--- /dev/null
+++ b/javatests/artifacts/dagger-android/simple/gradle/wrapper/gradle-wrapper.jar
Binary files differ
diff --git a/javatests/artifacts/dagger-android/simple/gradle/wrapper/gradle-wrapper.properties b/javatests/artifacts/dagger-android/simple/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000..4d9ca16
--- /dev/null
+++ b/javatests/artifacts/dagger-android/simple/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.7.1-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/javatests/artifacts/dagger-android/simple/gradlew b/javatests/artifacts/dagger-android/simple/gradlew
new file mode 100755
index 0000000..b0d6d0a
--- /dev/null
+++ b/javatests/artifacts/dagger-android/simple/gradlew
@@ -0,0 +1,188 @@
+#!/usr/bin/env sh
+
+#
+# Copyright 2015 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+##
+## Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+ ls=`ls -ld "$PRG"`
+ link=`expr "$ls" : '.*-> \(.*\)$'`
+ if expr "$link" : '/.*' > /dev/null; then
+ PRG="$link"
+ else
+ PRG=`dirname "$PRG"`"/$link"
+ fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+ echo "$*"
+}
+
+die () {
+ echo
+ echo "$*"
+ echo
+ exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+ CYGWIN* )
+ cygwin=true
+ ;;
+ Darwin* )
+ darwin=true
+ ;;
+ MINGW* )
+ msys=true
+ ;;
+ NONSTOP* )
+ nonstop=true
+ ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+ if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+ # IBM's JDK on AIX uses strange locations for the executables
+ JAVACMD="$JAVA_HOME/jre/sh/java"
+ else
+ JAVACMD="$JAVA_HOME/bin/java"
+ fi
+ if [ ! -x "$JAVACMD" ] ; then
+ die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+ fi
+else
+ JAVACMD="java"
+ which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+ MAX_FD_LIMIT=`ulimit -H -n`
+ if [ $? -eq 0 ] ; then
+ if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+ MAX_FD="$MAX_FD_LIMIT"
+ fi
+ ulimit -n $MAX_FD
+ if [ $? -ne 0 ] ; then
+ warn "Could not set maximum file descriptor limit: $MAX_FD"
+ fi
+ else
+ warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+ fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+ GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+ APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+ CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+ JAVACMD=`cygpath --unix "$JAVACMD"`
+
+ # We build the pattern for arguments to be converted via cygpath
+ ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+ SEP=""
+ for dir in $ROOTDIRSRAW ; do
+ ROOTDIRS="$ROOTDIRS$SEP$dir"
+ SEP="|"
+ done
+ OURCYGPATTERN="(^($ROOTDIRS))"
+ # Add a user-defined pattern to the cygpath arguments
+ if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+ OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+ fi
+ # Now convert the arguments - kludge to limit ourselves to /bin/sh
+ i=0
+ for arg in "$@" ; do
+ CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+ CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
+
+ if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
+ eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+ else
+ eval `echo args$i`="\"$arg\""
+ fi
+ i=$((i+1))
+ done
+ case $i in
+ (0) set -- ;;
+ (1) set -- "$args0" ;;
+ (2) set -- "$args0" "$args1" ;;
+ (3) set -- "$args0" "$args1" "$args2" ;;
+ (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+ (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+ (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+ (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+ (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+ (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+ esac
+fi
+
+# Escape application args
+save () {
+ for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+ echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+ cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"
diff --git a/javatests/artifacts/dagger-android/simple/settings.gradle b/javatests/artifacts/dagger-android/simple/settings.gradle
new file mode 100644
index 0000000..c5a07bc
--- /dev/null
+++ b/javatests/artifacts/dagger-android/simple/settings.gradle
@@ -0,0 +1,2 @@
+include ':app'
+rootProject.name='Simple Dagger Android'
\ No newline at end of file
diff --git a/javatests/artifacts/dagger/simple/build.gradle b/javatests/artifacts/dagger/simple/build.gradle
new file mode 100644
index 0000000..97c966e
--- /dev/null
+++ b/javatests/artifacts/dagger/simple/build.gradle
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+plugins {
+ id 'java'
+ id 'application'
+}
+
+repositories {
+ mavenCentral()
+ mavenLocal()
+}
+
+java {
+ // Make sure the generated source is compatible with Java 7.
+ sourceCompatibility = JavaVersion.VERSION_1_7
+}
+
+dependencies {
+ implementation 'com.google.dagger:dagger:LOCAL-SNAPSHOT'
+ annotationProcessor 'com.google.dagger:dagger-compiler:LOCAL-SNAPSHOT'
+}
+
+mainClassName = 'dagger.simple.SimpleApplication'
\ No newline at end of file
diff --git a/javatests/artifacts/dagger/simple/gradle/wrapper/gradle-wrapper.jar b/javatests/artifacts/dagger/simple/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000..5c2d1cf
--- /dev/null
+++ b/javatests/artifacts/dagger/simple/gradle/wrapper/gradle-wrapper.jar
Binary files differ
diff --git a/javatests/artifacts/dagger/simple/gradle/wrapper/gradle-wrapper.properties b/javatests/artifacts/dagger/simple/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000..4d9ca16
--- /dev/null
+++ b/javatests/artifacts/dagger/simple/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.7.1-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/javatests/artifacts/dagger/simple/gradlew b/javatests/artifacts/dagger/simple/gradlew
new file mode 100755
index 0000000..b0d6d0a
--- /dev/null
+++ b/javatests/artifacts/dagger/simple/gradlew
@@ -0,0 +1,188 @@
+#!/usr/bin/env sh
+
+#
+# Copyright 2015 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+##
+## Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+ ls=`ls -ld "$PRG"`
+ link=`expr "$ls" : '.*-> \(.*\)$'`
+ if expr "$link" : '/.*' > /dev/null; then
+ PRG="$link"
+ else
+ PRG=`dirname "$PRG"`"/$link"
+ fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+ echo "$*"
+}
+
+die () {
+ echo
+ echo "$*"
+ echo
+ exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+ CYGWIN* )
+ cygwin=true
+ ;;
+ Darwin* )
+ darwin=true
+ ;;
+ MINGW* )
+ msys=true
+ ;;
+ NONSTOP* )
+ nonstop=true
+ ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+ if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+ # IBM's JDK on AIX uses strange locations for the executables
+ JAVACMD="$JAVA_HOME/jre/sh/java"
+ else
+ JAVACMD="$JAVA_HOME/bin/java"
+ fi
+ if [ ! -x "$JAVACMD" ] ; then
+ die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+ fi
+else
+ JAVACMD="java"
+ which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+ MAX_FD_LIMIT=`ulimit -H -n`
+ if [ $? -eq 0 ] ; then
+ if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+ MAX_FD="$MAX_FD_LIMIT"
+ fi
+ ulimit -n $MAX_FD
+ if [ $? -ne 0 ] ; then
+ warn "Could not set maximum file descriptor limit: $MAX_FD"
+ fi
+ else
+ warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+ fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+ GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+ APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+ CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+ JAVACMD=`cygpath --unix "$JAVACMD"`
+
+ # We build the pattern for arguments to be converted via cygpath
+ ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+ SEP=""
+ for dir in $ROOTDIRSRAW ; do
+ ROOTDIRS="$ROOTDIRS$SEP$dir"
+ SEP="|"
+ done
+ OURCYGPATTERN="(^($ROOTDIRS))"
+ # Add a user-defined pattern to the cygpath arguments
+ if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+ OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+ fi
+ # Now convert the arguments - kludge to limit ourselves to /bin/sh
+ i=0
+ for arg in "$@" ; do
+ CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+ CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
+
+ if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
+ eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+ else
+ eval `echo args$i`="\"$arg\""
+ fi
+ i=$((i+1))
+ done
+ case $i in
+ (0) set -- ;;
+ (1) set -- "$args0" ;;
+ (2) set -- "$args0" "$args1" ;;
+ (3) set -- "$args0" "$args1" "$args2" ;;
+ (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+ (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+ (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+ (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+ (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+ (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+ esac
+fi
+
+# Escape application args
+save () {
+ for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+ echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+ cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"
diff --git a/javatests/artifacts/dagger/simple/src/main/java/dagger/simple/AssistedInjects.java b/javatests/artifacts/dagger/simple/src/main/java/dagger/simple/AssistedInjects.java
new file mode 100644
index 0000000..eb4946f
--- /dev/null
+++ b/javatests/artifacts/dagger/simple/src/main/java/dagger/simple/AssistedInjects.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2021 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.simple;
+
+import dagger.Component;
+import dagger.assisted.Assisted;
+import dagger.assisted.AssistedFactory;
+import dagger.assisted.AssistedInject;
+import javax.inject.Inject;
+
+// This is a regression test for https://github.com/google/dagger/issues/2309
+/** A simple, skeletal application that defines an assisted inject binding. */
+public class AssistedInjects {
+ @Component
+ interface MyComponent {
+ FooFactory fooFactory();
+
+ ParameterizedFooFactory<Bar, String> parameterizedFooFactory();
+ }
+
+ static final class Bar {
+ @Inject
+ Bar() {}
+ }
+
+ static class Foo {
+ @AssistedInject
+ Foo(Bar bar, @Assisted String str) {}
+ }
+
+ @AssistedFactory
+ interface FooFactory {
+ Foo create(String str);
+ }
+
+ static class ParameterizedFoo<T1, T2> {
+ @AssistedInject
+ ParameterizedFoo(T1 t1, @Assisted T2 t2) {}
+ }
+
+ @AssistedFactory
+ interface ParameterizedFooFactory<T1, T2> {
+ ParameterizedFoo<T1, T2> create(T2 t2);
+ }
+
+ public static void main(String[] args) {
+ Foo foo = DaggerAssistedInjects_MyComponent.create().fooFactory().create("");
+
+ ParameterizedFoo<Bar, String> parameterizedFoo =
+ DaggerAssistedInjects_MyComponent.create().parameterizedFooFactory().create("");
+ }
+}
diff --git a/javatests/artifacts/dagger/simple/src/main/java/dagger/simple/SimpleApplication.java b/javatests/artifacts/dagger/simple/src/main/java/dagger/simple/SimpleApplication.java
new file mode 100644
index 0000000..f136101
--- /dev/null
+++ b/javatests/artifacts/dagger/simple/src/main/java/dagger/simple/SimpleApplication.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.simple;
+
+import dagger.Component;
+import dagger.Module;
+import dagger.Provides;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+/** A simple, skeletal application that defines a simple component. */
+public class SimpleApplication {
+ static final class Foo {
+ @Inject Foo() {}
+ }
+
+ @Module
+ static final class SimpleModule {
+ @Provides
+ static Foo provideFoo() {
+ return new Foo();
+ }
+ }
+
+ @Singleton
+ @Component(modules = { SimpleModule.class })
+ interface SimpleComponent {
+ Foo foo();
+ }
+
+ public static void main(String[] args) {
+ Foo foo = DaggerSimpleApplication_SimpleComponent.create().foo();
+ }
+}
diff --git a/javatests/artifacts/hilt-android/gradleConfigCache/app/build.gradle b/javatests/artifacts/hilt-android/gradleConfigCache/app/build.gradle
new file mode 100644
index 0000000..43ccd1d
--- /dev/null
+++ b/javatests/artifacts/hilt-android/gradleConfigCache/app/build.gradle
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+apply plugin: 'com.android.application'
+apply plugin: 'kotlin-android'
+apply plugin: 'kotlin-kapt'
+apply plugin: 'dagger.hilt.android.plugin'
+
+android {
+ compileSdkVersion 30
+ buildToolsVersion "30.0.2"
+
+ defaultConfig {
+ applicationId "dagger.hilt.android.gradleConfigCache"
+ minSdkVersion 15
+ targetSdkVersion 30
+ versionCode 1
+ versionName "1.0"
+ testInstrumentationRunner "dagger.hilt.android.gradleConfigCache.TestRunner"
+ }
+ compileOptions {
+ sourceCompatibility 1.8
+ targetCompatibility 1.8
+ }
+ kotlinOptions {
+ jvmTarget = '1.8'
+ }
+ testOptions {
+ unitTests.includeAndroidResources = true
+ }
+}
+
+hilt {
+ enableTransformForLocalTests = true
+}
+
+dependencies {
+ implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+ implementation 'androidx.appcompat:appcompat:1.2.0'
+ implementation 'androidx.activity:activity-ktx:1.1.0'
+ implementation 'androidx.multidex:multidex:2.0.0'
+ implementation 'com.google.dagger:hilt-android:LOCAL-SNAPSHOT'
+ kapt 'com.google.dagger:hilt-compiler:LOCAL-SNAPSHOT'
+
+ testImplementation 'junit:junit:4.13'
+ testImplementation 'androidx.test.ext:junit:1.1.2'
+ testImplementation 'androidx.test:runner:1.3.0'
+ testImplementation 'org.robolectric:robolectric:4.5-alpha-3'
+ testImplementation 'com.google.dagger:hilt-android-testing:LOCAL-SNAPSHOT'
+ kaptTest 'com.google.dagger:hilt-compiler:LOCAL-SNAPSHOT'
+
+ androidTestImplementation 'androidx.test.ext:junit:1.1.2'
+ androidTestImplementation 'androidx.test:runner:1.3.0'
+ androidTestImplementation 'com.google.dagger:hilt-android-testing:LOCAL-SNAPSHOT'
+ kaptAndroidTest 'com.google.dagger:hilt-compiler:LOCAL-SNAPSHOT'
+}
diff --git a/javatests/artifacts/hilt-android/gradleConfigCache/app/src/androidTest/java/dagger/hilt/android/gradleConfigCache/EmulatorTest.kt b/javatests/artifacts/hilt-android/gradleConfigCache/app/src/androidTest/java/dagger/hilt/android/gradleConfigCache/EmulatorTest.kt
new file mode 100644
index 0000000..9099db4
--- /dev/null
+++ b/javatests/artifacts/hilt-android/gradleConfigCache/app/src/androidTest/java/dagger/hilt/android/gradleConfigCache/EmulatorTest.kt
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.gradleConfigCache
+
+import androidx.test.core.app.ActivityScenario
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import org.junit.Assert.assertNotNull
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@HiltAndroidTest
+@RunWith(AndroidJUnit4::class)
+class EmulatorTest {
+
+ @get:Rule
+ val rule = HiltAndroidRule(this)
+
+ @Test
+ fun testFooInjected() {
+ ActivityScenario.launch(MainActivity::class.java).use {
+ it.onActivity { activity ->
+ assertNotNull(activity.foo)
+ }
+ }
+ }
+}
diff --git a/javatests/artifacts/hilt-android/gradleConfigCache/app/src/androidTest/java/dagger/hilt/android/gradleConfigCache/TestRunner.kt b/javatests/artifacts/hilt-android/gradleConfigCache/app/src/androidTest/java/dagger/hilt/android/gradleConfigCache/TestRunner.kt
new file mode 100644
index 0000000..9fce7cd
--- /dev/null
+++ b/javatests/artifacts/hilt-android/gradleConfigCache/app/src/androidTest/java/dagger/hilt/android/gradleConfigCache/TestRunner.kt
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.gradleConfigCache
+
+import android.app.Application
+import android.content.Context
+import androidx.test.runner.AndroidJUnitRunner
+import dagger.hilt.android.testing.HiltTestApplication
+
+class TestRunner : AndroidJUnitRunner() {
+ override fun newApplication(cl: ClassLoader, appName: String, context: Context): Application {
+ return super.newApplication(cl, HiltTestApplication::class.java.name, context)
+ }
+}
diff --git a/javatests/artifacts/hilt-android/gradleConfigCache/app/src/main/AndroidManifest.xml b/javatests/artifacts/hilt-android/gradleConfigCache/app/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..ce1fb71
--- /dev/null
+++ b/javatests/artifacts/hilt-android/gradleConfigCache/app/src/main/AndroidManifest.xml
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ Copyright (C) 2020 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="dagger.hilt.android.gradleConfigCache">
+
+ <application
+ android:name=".App"
+ android:allowBackup="true"
+ android:label="@string/app_name"
+ android:supportsRtl="true"
+ android:theme="@style/Theme.AppCompat.Light">
+ <activity android:name=".MainActivity" android:exported="true">
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN" />
+ <category android:name="android.intent.category.LAUNCHER" />
+ </intent-filter>
+ </activity>
+ </application>
+</manifest>
diff --git a/javatests/artifacts/hilt-android/gradleConfigCache/app/src/main/java/dagger/hilt/android/gradleConfigCache/App.kt b/javatests/artifacts/hilt-android/gradleConfigCache/app/src/main/java/dagger/hilt/android/gradleConfigCache/App.kt
new file mode 100644
index 0000000..1cbd4b0
--- /dev/null
+++ b/javatests/artifacts/hilt-android/gradleConfigCache/app/src/main/java/dagger/hilt/android/gradleConfigCache/App.kt
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.gradleConfigCache
+
+import androidx.multidex.MultiDexApplication
+import dagger.hilt.android.HiltAndroidApp
+
+@HiltAndroidApp
+class App : MultiDexApplication()
diff --git a/javatests/artifacts/hilt-android/gradleConfigCache/app/src/main/java/dagger/hilt/android/gradleConfigCache/Foo.kt b/javatests/artifacts/hilt-android/gradleConfigCache/app/src/main/java/dagger/hilt/android/gradleConfigCache/Foo.kt
new file mode 100644
index 0000000..969e183
--- /dev/null
+++ b/javatests/artifacts/hilt-android/gradleConfigCache/app/src/main/java/dagger/hilt/android/gradleConfigCache/Foo.kt
@@ -0,0 +1,5 @@
+package dagger.hilt.android.gradleConfigCache
+
+import javax.inject.Inject
+
+class Foo @Inject constructor()
diff --git a/javatests/artifacts/hilt-android/gradleConfigCache/app/src/main/java/dagger/hilt/android/gradleConfigCache/MainActivity.kt b/javatests/artifacts/hilt-android/gradleConfigCache/app/src/main/java/dagger/hilt/android/gradleConfigCache/MainActivity.kt
new file mode 100644
index 0000000..0011bde
--- /dev/null
+++ b/javatests/artifacts/hilt-android/gradleConfigCache/app/src/main/java/dagger/hilt/android/gradleConfigCache/MainActivity.kt
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.gradleConfigCache
+
+import android.os.Bundle
+import android.util.Log
+import androidx.appcompat.app.AppCompatActivity
+import dagger.hilt.android.AndroidEntryPoint
+import javax.inject.Inject
+
+@AndroidEntryPoint
+class MainActivity : AppCompatActivity() {
+
+ @Inject
+ lateinit var foo: Foo
+
+ override fun onCreate(savedInstanceState: Bundle?) {
+ super.onCreate(savedInstanceState)
+ setContentView(R.layout.activity_main)
+ Log.d("Hilt", "Foo is $foo")
+ }
+}
diff --git a/javatests/artifacts/hilt-android/gradleConfigCache/app/src/main/res/layout/activity_main.xml b/javatests/artifacts/hilt-android/gradleConfigCache/app/src/main/res/layout/activity_main.xml
new file mode 100644
index 0000000..cb5a8df
--- /dev/null
+++ b/javatests/artifacts/hilt-android/gradleConfigCache/app/src/main/res/layout/activity_main.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ Copyright (C) 2020 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+ android:layout_width="match_parent"
+ android:layout_height="match_parent"
+ android:background="@android:color/background_light">
+</RelativeLayout>
diff --git a/javatests/artifacts/hilt-android/gradleConfigCache/app/src/main/res/values/strings.xml b/javatests/artifacts/hilt-android/gradleConfigCache/app/src/main/res/values/strings.xml
new file mode 100644
index 0000000..05afdbf
--- /dev/null
+++ b/javatests/artifacts/hilt-android/gradleConfigCache/app/src/main/res/values/strings.xml
@@ -0,0 +1,20 @@
+<!--
+ ~ Copyright (C) 2020 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+
+<resources>
+ <!--The app name [CHAR_LIMIT=40]-->
+ <string name="app_name">Gradle Configuration Cache App</string>
+</resources>
diff --git a/javatests/artifacts/hilt-android/gradleConfigCache/app/src/test/java/dagger/hilt/android/gradleConfigCache/LocalTest.kt b/javatests/artifacts/hilt-android/gradleConfigCache/app/src/test/java/dagger/hilt/android/gradleConfigCache/LocalTest.kt
new file mode 100644
index 0000000..527d887
--- /dev/null
+++ b/javatests/artifacts/hilt-android/gradleConfigCache/app/src/test/java/dagger/hilt/android/gradleConfigCache/LocalTest.kt
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.gradleConfigCache
+
+import androidx.test.core.app.ActivityScenario
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import dagger.hilt.android.testing.HiltTestApplication
+import org.junit.Assert.assertNotNull
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+
+@HiltAndroidTest
+@RunWith(AndroidJUnit4::class)
+@Config(application = HiltTestApplication::class)
+class LocalTest {
+
+ @get:Rule
+ val rule = HiltAndroidRule(this)
+
+ @Test
+ fun testFooInjected() {
+ ActivityScenario.launch(MainActivity::class.java).use {
+ it.onActivity { activity ->
+ assertNotNull(activity.foo)
+ }
+ }
+ }
+}
diff --git a/javatests/artifacts/hilt-android/gradleConfigCache/build.gradle b/javatests/artifacts/hilt-android/gradleConfigCache/build.gradle
new file mode 100644
index 0000000..3b0cdde
--- /dev/null
+++ b/javatests/artifacts/hilt-android/gradleConfigCache/build.gradle
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+buildscript {
+ ext {
+ kotlin_version = '1.4.20'
+ agp_version = "4.2.0-beta04"
+ }
+ repositories {
+ google()
+ jcenter()
+ mavenLocal()
+ }
+ dependencies {
+ classpath "com.android.tools.build:gradle:$agp_version"
+ classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+ classpath 'com.google.dagger:hilt-android-gradle-plugin:LOCAL-SNAPSHOT'
+ }
+}
+
+allprojects {
+ repositories {
+ google()
+ jcenter()
+ mavenCentral()
+ mavenLocal()
+ }
+}
diff --git a/javatests/artifacts/hilt-android/gradleConfigCache/gradle.properties b/javatests/artifacts/hilt-android/gradleConfigCache/gradle.properties
new file mode 100644
index 0000000..1813493
--- /dev/null
+++ b/javatests/artifacts/hilt-android/gradleConfigCache/gradle.properties
@@ -0,0 +1,8 @@
+android.useAndroidX=true
+android.enableJetifier=true
+
+# Error out if an issue is found that disallows the configuration cache.
+# These options along with this app being built in presubmit helps us cache
+# changes that would cause config cache to be disabled via the HiltGradlePlugin.
+org.gradle.unsafe.configuration-cache=ERROR
+org.gradle.unsafe.configuration-cache.max-problems=0
diff --git a/javatests/artifacts/hilt-android/gradleConfigCache/gradle/wrapper/gradle-wrapper.jar b/javatests/artifacts/hilt-android/gradleConfigCache/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000..62d4c05
--- /dev/null
+++ b/javatests/artifacts/hilt-android/gradleConfigCache/gradle/wrapper/gradle-wrapper.jar
Binary files differ
diff --git a/javatests/artifacts/hilt-android/gradleConfigCache/gradle/wrapper/gradle-wrapper.properties b/javatests/artifacts/hilt-android/gradleConfigCache/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000..4d9ca16
--- /dev/null
+++ b/javatests/artifacts/hilt-android/gradleConfigCache/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.7.1-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/javatests/artifacts/hilt-android/gradleConfigCache/gradlew b/javatests/artifacts/hilt-android/gradleConfigCache/gradlew
new file mode 100755
index 0000000..fbd7c51
--- /dev/null
+++ b/javatests/artifacts/hilt-android/gradleConfigCache/gradlew
@@ -0,0 +1,185 @@
+#!/usr/bin/env sh
+
+#
+# Copyright 2015 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+##
+## Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+ ls=`ls -ld "$PRG"`
+ link=`expr "$ls" : '.*-> \(.*\)$'`
+ if expr "$link" : '/.*' > /dev/null; then
+ PRG="$link"
+ else
+ PRG=`dirname "$PRG"`"/$link"
+ fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+ echo "$*"
+}
+
+die () {
+ echo
+ echo "$*"
+ echo
+ exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+ CYGWIN* )
+ cygwin=true
+ ;;
+ Darwin* )
+ darwin=true
+ ;;
+ MINGW* )
+ msys=true
+ ;;
+ NONSTOP* )
+ nonstop=true
+ ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+ if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+ # IBM's JDK on AIX uses strange locations for the executables
+ JAVACMD="$JAVA_HOME/jre/sh/java"
+ else
+ JAVACMD="$JAVA_HOME/bin/java"
+ fi
+ if [ ! -x "$JAVACMD" ] ; then
+ die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+ fi
+else
+ JAVACMD="java"
+ which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+ MAX_FD_LIMIT=`ulimit -H -n`
+ if [ $? -eq 0 ] ; then
+ if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+ MAX_FD="$MAX_FD_LIMIT"
+ fi
+ ulimit -n $MAX_FD
+ if [ $? -ne 0 ] ; then
+ warn "Could not set maximum file descriptor limit: $MAX_FD"
+ fi
+ else
+ warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+ fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+ GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
+ APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+ CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+
+ JAVACMD=`cygpath --unix "$JAVACMD"`
+
+ # We build the pattern for arguments to be converted via cygpath
+ ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+ SEP=""
+ for dir in $ROOTDIRSRAW ; do
+ ROOTDIRS="$ROOTDIRS$SEP$dir"
+ SEP="|"
+ done
+ OURCYGPATTERN="(^($ROOTDIRS))"
+ # Add a user-defined pattern to the cygpath arguments
+ if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+ OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+ fi
+ # Now convert the arguments - kludge to limit ourselves to /bin/sh
+ i=0
+ for arg in "$@" ; do
+ CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+ CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
+
+ if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
+ eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+ else
+ eval `echo args$i`="\"$arg\""
+ fi
+ i=`expr $i + 1`
+ done
+ case $i in
+ 0) set -- ;;
+ 1) set -- "$args0" ;;
+ 2) set -- "$args0" "$args1" ;;
+ 3) set -- "$args0" "$args1" "$args2" ;;
+ 4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+ 5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+ 6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+ 7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+ 8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+ 9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+ esac
+fi
+
+# Escape application args
+save () {
+ for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+ echo " "
+}
+APP_ARGS=`save "$@"`
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+exec "$JAVACMD" "$@"
diff --git a/javatests/artifacts/hilt-android/gradleConfigCache/gradlew.bat b/javatests/artifacts/hilt-android/gradleConfigCache/gradlew.bat
new file mode 100644
index 0000000..a9f778a
--- /dev/null
+++ b/javatests/artifacts/hilt-android/gradleConfigCache/gradlew.bat
@@ -0,0 +1,104 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/javatests/artifacts/hilt-android/gradleConfigCache/settings.gradle b/javatests/artifacts/hilt-android/gradleConfigCache/settings.gradle
new file mode 100644
index 0000000..d0d5fee
--- /dev/null
+++ b/javatests/artifacts/hilt-android/gradleConfigCache/settings.gradle
@@ -0,0 +1,2 @@
+rootProject.name='Gradle Configuration Cache App'
+include ':app'
diff --git a/javatests/artifacts/hilt-android/simple/app/build.gradle b/javatests/artifacts/hilt-android/simple/app/build.gradle
new file mode 100644
index 0000000..98b79e1
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/app/build.gradle
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+apply plugin: 'com.android.application'
+apply plugin: 'dagger.hilt.android.plugin'
+
+android {
+ compileSdkVersion 30
+ buildToolsVersion "30.0.2"
+
+ defaultConfig {
+ applicationId "dagger.hilt.android.simple"
+ minSdkVersion 15
+ targetSdkVersion 30
+ versionCode 1
+ versionName "1.0"
+ testInstrumentationRunner "dagger.hilt.android.simple.SimpleEmulatorTestRunner"
+ }
+ compileOptions {
+ sourceCompatibility 1.8
+ targetCompatibility 1.8
+ }
+ testOptions {
+ unitTests.includeAndroidResources = true
+ }
+ lintOptions {
+ checkReleaseBuilds = false
+ }
+ sourceSets {
+ String sharedTestDir = 'src/sharedTest/java'
+ test {
+ java.srcDirs += sharedTestDir
+ }
+ androidTest {
+ java.srcDirs += sharedTestDir
+ }
+ }
+}
+
+hilt {
+ enableExperimentalClasspathAggregation = true
+ enableTransformForLocalTests = true
+}
+
+configurations.all {
+ resolutionStrategy.eachDependency { DependencyResolveDetails details ->
+ if ("$dagger_version" == 'LOCAL-SNAPSHOT'
+ && details.requested.group == 'com.google.dagger') {
+ details.useVersion 'LOCAL-SNAPSHOT'
+ details.because 'LOCAL-SNAPSHOT should act as latest version.'
+ }
+ }
+}
+
+dependencies {
+ implementation project(':feature')
+ implementation project(':lib')
+ implementation 'androidx.appcompat:appcompat:1.2.0'
+ implementation "com.google.dagger:hilt-android:$dagger_version"
+ annotationProcessor "com.google.dagger:hilt-compiler:$dagger_version"
+
+ testImplementation 'com.google.truth:truth:1.0.1'
+ testImplementation 'junit:junit:4.13'
+ testImplementation 'org.robolectric:robolectric:4.5-alpha-3'
+ testImplementation 'androidx.core:core:1.3.2'
+ testImplementation 'androidx.test.ext:junit:1.1.2'
+ testImplementation 'androidx.test:runner:1.3.0'
+ testImplementation 'androidx.test.espresso:espresso-core:3.3.0'
+ testImplementation "com.google.dagger:hilt-android-testing:$dagger_version"
+ testAnnotationProcessor "com.google.dagger:hilt-compiler:$dagger_version"
+
+ androidTestImplementation 'com.google.truth:truth:1.0.1'
+ androidTestImplementation 'junit:junit:4.13'
+ androidTestImplementation 'androidx.test.ext:junit:1.1.2'
+ androidTestImplementation 'androidx.test:runner:1.3.0'
+ androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'
+ androidTestImplementation "com.google.dagger:hilt-android-testing:$dagger_version"
+ androidTestAnnotationProcessor "com.google.dagger:hilt-compiler:$dagger_version"
+
+ // To help us catch usages of Guava APIs for Java 8 in the '-jre' variant.
+ annotationProcessor'com.google.guava:guava:28.1-android'
+ testAnnotationProcessor'com.google.guava:guava:28.1-android'
+ androidTestAnnotationProcessor'com.google.guava:guava:28.1-android'
+
+ // To help us catch version skew related issues in hilt extensions.
+ // TODO(bcorso): Add examples testing the actual API.
+ implementation 'androidx.hilt:hilt-lifecycle-viewmodel:1.0.0-alpha01'
+ implementation 'androidx.hilt:hilt-work:1.0.0-alpha01'
+ annotationProcessor 'androidx.hilt:hilt-compiler:1.0.0-alpha01'
+ testAnnotationProcessor 'androidx.hilt:hilt-compiler:1.0.0-alpha01'
+ androidTestAnnotationProcessor 'androidx.hilt:hilt-compiler:1.0.0-alpha01'
+}
diff --git a/javatests/artifacts/hilt-android/simple/app/src/androidTest/java/dagger/hilt/android/simple/SimpleEmulatorTestRunner.java b/javatests/artifacts/hilt-android/simple/app/src/androidTest/java/dagger/hilt/android/simple/SimpleEmulatorTestRunner.java
new file mode 100644
index 0000000..6ee721c
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/app/src/androidTest/java/dagger/hilt/android/simple/SimpleEmulatorTestRunner.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simple;
+
+import android.app.Application;
+import android.content.Context;
+import androidx.test.runner.AndroidJUnitRunner;
+import dagger.hilt.android.testing.HiltTestApplication;
+
+/** A custom runner to setup the emulator application class for tests. */
+public final class SimpleEmulatorTestRunner extends AndroidJUnitRunner {
+
+ @Override
+ public Application newApplication(ClassLoader cl, String className, Context context)
+ throws ClassNotFoundException, IllegalAccessException, InstantiationException {
+ return super.newApplication(cl, HiltTestApplication.class.getName(), context);
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simple/app/src/debug/AndroidManifest.xml b/javatests/artifacts/hilt-android/simple/app/src/debug/AndroidManifest.xml
new file mode 100644
index 0000000..14d33b0
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/app/src/debug/AndroidManifest.xml
@@ -0,0 +1,33 @@
+<!--
+ ~ Copyright (C) 2020 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="dagger.hilt.android.simple">
+
+ <application>
+ <activity
+ android:name=".Injection1Test$TestActivity"
+ android:theme="@style/Theme.AppCompat.Light"
+ android:exported="false" />
+ <activity
+ android:name=".Injection2Test$TestActivity"
+ android:theme="@style/Theme.AppCompat.Light"
+ android:exported="false"/>
+ <activity
+ android:name=".ActivityScenarioRuleTest$TestActivity"
+ android:theme="@style/Theme.AppCompat.Light"
+ android:exported="false"/>
+ </application>
+</manifest>
diff --git a/javatests/artifacts/hilt-android/simple/app/src/main/AndroidManifest.xml b/javatests/artifacts/hilt-android/simple/app/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..0b12b13
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/app/src/main/AndroidManifest.xml
@@ -0,0 +1,35 @@
+<!--
+ ~ Copyright (C) 2020 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="dagger.hilt.android.simple">
+
+ <application android:name=".SimpleApplication" android:label="@string/appName">
+ <activity
+ android:name=".SimpleActivity"
+ android:theme="@style/Theme.AppCompat.Light"
+ android:exported="true">
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN" />
+ <category android:name="android.intent.category.LAUNCHER" />
+ </intent-filter>
+ </activity>
+ <activity
+ android:name=".SettingsActivity"
+ android:theme="@style/Theme.AppCompat.Light"
+ android:exported="false">
+ </activity>
+ </application>
+</manifest>
diff --git a/javatests/artifacts/hilt-android/simple/app/src/main/java/dagger/hilt/android/simple/Model.java b/javatests/artifacts/hilt-android/simple/app/src/main/java/dagger/hilt/android/simple/Model.java
new file mode 100644
index 0000000..9965b2e
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/app/src/main/java/dagger/hilt/android/simple/Model.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simple;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import javax.inject.Qualifier;
+
+/** Qualifies bindings relating to {@link android.os.Build#MODEL}. */
+@Qualifier
+@Retention(RUNTIME)
+@Documented
+@interface Model {}
diff --git a/javatests/artifacts/hilt-android/simple/app/src/main/java/dagger/hilt/android/simple/ModelModule.java b/javatests/artifacts/hilt-android/simple/app/src/main/java/dagger/hilt/android/simple/ModelModule.java
new file mode 100644
index 0000000..9a63f17
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/app/src/main/java/dagger/hilt/android/simple/ModelModule.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simple;
+
+import static android.os.Build.MODEL;
+
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.components.SingletonComponent;
+
+@Module
+@InstallIn(SingletonComponent.class)
+final class ModelModule {
+ @Provides
+ @Model
+ static String provideModel() {
+ return MODEL;
+ }
+
+ private ModelModule() {}
+}
diff --git a/javatests/artifacts/hilt-android/simple/app/src/main/java/dagger/hilt/android/simple/SimpleActivity.java b/javatests/artifacts/hilt-android/simple/app/src/main/java/dagger/hilt/android/simple/SimpleActivity.java
new file mode 100644
index 0000000..5d16cd4
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/app/src/main/java/dagger/hilt/android/simple/SimpleActivity.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simple;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.util.Log;
+import android.widget.Button;
+import android.widget.TextView;
+import androidx.appcompat.app.AppCompatActivity;
+import dagger.hilt.android.AndroidEntryPoint;
+import dagger.hilt.android.simple.feature.FeatureActivity;
+import dagger.hilt.android.simple.lib.Thing;
+import javax.inject.Inject;
+
+/** The main activity of the application. */
+@AndroidEntryPoint
+public class SimpleActivity extends AppCompatActivity {
+ private static final String TAG = SimpleActivity.class.getSimpleName();
+
+ @Inject @UserName String userName;
+ @Inject @Model String model;
+ @Inject Thing thing;
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ Log.i(TAG, "Injected with userName and model: " + userName + ", " + model);
+
+ setContentView(R.layout.activity_main);
+
+ ((TextView) findViewById(R.id.greeting))
+ .setText(getResources().getString(R.string.welcome, userName, model));
+
+ Button featureButton = (Button) findViewById(R.id.goto_feature);
+ featureButton.setOnClickListener(
+ view -> startActivity(new Intent(this, FeatureActivity.class)));
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simple/app/src/main/java/dagger/hilt/android/simple/SimpleApplication.java b/javatests/artifacts/hilt-android/simple/app/src/main/java/dagger/hilt/android/simple/SimpleApplication.java
new file mode 100644
index 0000000..3c7d1f3
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/app/src/main/java/dagger/hilt/android/simple/SimpleApplication.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simple;
+
+import android.app.Application;
+import android.util.Log;
+import dagger.hilt.android.HiltAndroidApp;
+import javax.inject.Inject;
+
+/**
+ * A simple, skeletal application that demonstrates a dependency-injected application using the
+ * utilities in {@code Hilt} in Android.
+ */
+@HiltAndroidApp
+public class SimpleApplication extends Application {
+ private static final String TAG = SimpleApplication.class.getSimpleName();
+
+ @Inject @Model String model;
+
+ @Override
+ public void onCreate() {
+ super.onCreate();
+ Log.i(TAG, "Injected with model: " + model);
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simple/app/src/main/java/dagger/hilt/android/simple/UserName.java b/javatests/artifacts/hilt-android/simple/app/src/main/java/dagger/hilt/android/simple/UserName.java
new file mode 100644
index 0000000..19f0679
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/app/src/main/java/dagger/hilt/android/simple/UserName.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simple;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import javax.inject.Qualifier;
+
+/** Qualifies bindings relating to the user name. */
+@Qualifier
+@Retention(RUNTIME)
+@Documented
+@interface UserName {}
diff --git a/javatests/artifacts/hilt-android/simple/app/src/main/java/dagger/hilt/android/simple/UserNameModule.java b/javatests/artifacts/hilt-android/simple/app/src/main/java/dagger/hilt/android/simple/UserNameModule.java
new file mode 100644
index 0000000..26d52df
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/app/src/main/java/dagger/hilt/android/simple/UserNameModule.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simple;
+
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityComponent;
+
+@Module
+@InstallIn(ActivityComponent.class)
+final class UserNameModule {
+ @UserName
+ @Provides
+ static String provideUserName() {
+ return "ProdUser";
+ }
+
+ private UserNameModule() {}
+}
diff --git a/javatests/artifacts/hilt-android/simple/app/src/main/res/layout/activity_main.xml b/javatests/artifacts/hilt-android/simple/app/src/main/res/layout/activity_main.xml
new file mode 100644
index 0000000..b786106
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/app/src/main/res/layout/activity_main.xml
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ Copyright (C) 2020 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+ android:layout_width="match_parent"
+ android:layout_height="match_parent"
+ android:background="@android:color/background_light">
+
+ <TextView
+ android:id="@+id/greeting"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:layout_alignParentTop="true"
+ android:textColor="@android:color/primary_text_light"
+ />
+
+ <Button
+ android:id="@+id/goto_feature"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:layout_below="@id/greeting"
+ android:text="@string/navigateToFeature"
+ />
+</RelativeLayout>
diff --git a/javatests/artifacts/hilt-android/simple/app/src/main/res/values/strings.xml b/javatests/artifacts/hilt-android/simple/app/src/main/res/values/strings.xml
new file mode 100644
index 0000000..c8f9b8a
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/app/src/main/res/values/strings.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ Copyright (C) 2020 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+
+<resources>
+ <!--The app name [CHAR_LIMIT=20]-->
+ <string name="appName">Simple Hilt Android</string>
+
+ <!--The greeting message [CHAR_LIMIT=100]-->
+ <string name="welcome">Hello, %1$s! You are on build %2$s.</string>
+
+ <!--The feature button message [CHAR_LIMIT=100]-->
+ <string name="navigateToFeature">Navigate to a feature!</string>
+</resources>
diff --git a/javatests/artifacts/hilt-android/simple/app/src/sharedTest/java/dagger/hilt/android/simple/ActivityScenarioRuleTest.java b/javatests/artifacts/hilt-android/simple/app/src/sharedTest/java/dagger/hilt/android/simple/ActivityScenarioRuleTest.java
new file mode 100644
index 0000000..b49e666
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/app/src/sharedTest/java/dagger/hilt/android/simple/ActivityScenarioRuleTest.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simple;
+
+import static androidx.lifecycle.Lifecycle.State.RESUMED;
+import static com.google.common.truth.Truth.assertThat;
+
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.test.core.app.ActivityScenario;
+import androidx.test.ext.junit.rules.ActivityScenarioRule;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import dagger.hilt.android.AndroidEntryPoint;
+import dagger.hilt.android.testing.BindValue;
+import dagger.hilt.android.testing.HiltAndroidRule;
+import dagger.hilt.android.testing.HiltAndroidTest;
+import javax.inject.Inject;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/** Tests that {@link ActivityScenarioRule} works with Hilt tests. */
+@HiltAndroidTest
+@RunWith(AndroidJUnit4.class)
+public final class ActivityScenarioRuleTest {
+ private static final String STR_VALUE = "STR_VALUE";
+
+ /** An activity to test injection. */
+ @AndroidEntryPoint
+ public static final class TestActivity extends AppCompatActivity {
+ @Inject String str;
+ }
+
+ @Rule(order = 0) public HiltAndroidRule hiltRule = new HiltAndroidRule(this);
+
+ @Rule(order = 1)
+ public ActivityScenarioRule<TestActivity> scenarioRule =
+ new ActivityScenarioRule<>(TestActivity.class);
+
+ @BindValue String str = STR_VALUE;
+
+ @Test
+ public void testState() {
+ assertThat(scenarioRule.getScenario().getState()).isEqualTo(RESUMED);
+ }
+
+ @Test
+ public void testInjection() {
+ scenarioRule
+ .getScenario()
+ .onActivity(activity -> assertThat(activity.str).isEqualTo(STR_VALUE));
+ }
+
+
+ @Test
+ public void verifyMainActivity() {
+ try (ActivityScenario<TestActivity> scenario =
+ ActivityScenario.launch(TestActivity.class)) {
+ scenario.onActivity(
+ activity -> {
+ assertThat(activity.getClass().getSuperclass().getSimpleName())
+ .isEqualTo("Hilt_ActivityScenarioRuleTest_TestActivity");
+ }
+ );
+ }
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simple/app/src/sharedTest/java/dagger/hilt/android/simple/BindValueTest.java b/javatests/artifacts/hilt-android/simple/app/src/sharedTest/java/dagger/hilt/android/simple/BindValueTest.java
new file mode 100644
index 0000000..e77f605
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/app/src/sharedTest/java/dagger/hilt/android/simple/BindValueTest.java
@@ -0,0 +1,155 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simple;
+
+import static androidx.test.core.app.ApplicationProvider.getApplicationContext;
+import static com.google.common.truth.Truth.assertThat;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import com.google.common.collect.ImmutableSet;
+import dagger.MapKey;
+import dagger.hilt.EntryPoint;
+import dagger.hilt.EntryPoints;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.testing.BindElementsIntoSet;
+import dagger.hilt.android.testing.BindValue;
+import dagger.hilt.android.testing.BindValueIntoMap;
+import dagger.hilt.android.testing.BindValueIntoSet;
+import dagger.hilt.android.testing.HiltAndroidRule;
+import dagger.hilt.android.testing.HiltAndroidTest;
+import dagger.hilt.components.SingletonComponent;
+import java.util.Map;
+import java.util.Set;
+import javax.inject.Inject;
+import javax.inject.Named;
+import javax.inject.Provider;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/** A simple test using Hilt. */
+@HiltAndroidTest
+@RunWith(AndroidJUnit4.class)
+public final class BindValueTest {
+ private static final String BIND_VALUE_STRING = "BIND_VALUE_STRING";
+ private static final String TEST_QUALIFIER = "TEST_QUALIFIER";
+
+ private static final String SET_STRING_1 = "SetString1";
+ private static final String SET_STRING_2 = "SetString2";
+ private static final String SET_STRING_3 = "SetString3";
+
+ private static final String KEY_1 = "Key1";
+ private static final String KEY_2 = "Key2";
+ private static final String VALUE_1 = "Value1";
+ private static final String VALUE_2 = "Value2";
+ private static final String VALUE_3 = "Value3";
+
+ private static final Integer SET_INT_1 = 1;
+ private static final Integer SET_INT_2 = 2;
+ private static final Integer SET_INT_3 = 3;
+
+ @EntryPoint
+ @InstallIn(SingletonComponent.class)
+ interface BindValueEntryPoint {
+ @Named(TEST_QUALIFIER)
+ String bindValueString();
+
+ Set<String> getStringSet();
+ }
+
+ @Rule public HiltAndroidRule rule = new HiltAndroidRule(this);
+
+ @BindValue
+ @Named(TEST_QUALIFIER)
+ String bindValueString = BIND_VALUE_STRING;
+
+ @BindElementsIntoSet Set<String> bindElementsSet1 = ImmutableSet.of(SET_STRING_1);
+ @BindElementsIntoSet Set<String> bindElementsSet2 = ImmutableSet.of(SET_STRING_2);
+
+ @BindValueIntoMap
+ @MyMapKey(KEY_1)
+ String boundValue1 = VALUE_1;
+
+ @BindValueIntoMap
+ @MyMapKey(KEY_2)
+ String boundValue2 = VALUE_2;
+
+ @BindValueIntoSet Integer bindValueSetInt1 = SET_INT_1;
+ @BindValueIntoSet Integer bindValueSetInt2 = SET_INT_2;
+
+ @Inject Set<String> stringSet;
+ @Inject Provider<Set<String>> providedStringSet;
+ @Inject Provider<Map<String, String>> mapProvider;
+ @Inject Set<Integer> intSet;
+ @Inject Provider<Set<Integer>> providedIntSet;
+
+ @Test
+ public void testBindValueFieldIsProvided() throws Exception {
+ assertThat(bindValueString).isEqualTo(BIND_VALUE_STRING);
+ assertThat(getBinding()).isEqualTo(BIND_VALUE_STRING);
+ }
+
+ @Test
+ public void testBindValueIsMutable() throws Exception {
+ bindValueString = "newValue";
+ assertThat(getBinding()).isEqualTo("newValue");
+ }
+
+ @Test
+ public void testElementsIntoSet() throws Exception {
+ rule.inject();
+ // basic check that initial/default values are properly injected
+ assertThat(providedStringSet.get()).containsExactly(SET_STRING_1, SET_STRING_2);
+ // Test empty sets (something that cannot be done with @BindValueIntoSet)
+ bindElementsSet1 = ImmutableSet.of();
+ bindElementsSet2 = ImmutableSet.of();
+ assertThat(providedStringSet.get()).isEmpty();
+ // Test multiple elements in set.
+ bindElementsSet1 = ImmutableSet.of(SET_STRING_1, SET_STRING_2, SET_STRING_3);
+ assertThat(providedStringSet.get()).containsExactly(SET_STRING_1, SET_STRING_2, SET_STRING_3);
+ }
+
+ @Test
+ public void testBindValueIntoMap() throws Exception {
+ rule.inject();
+ Map<String, String> oldMap = mapProvider.get();
+ assertThat(oldMap).containsExactly(KEY_1, VALUE_1, KEY_2, VALUE_2);
+ boundValue1 = VALUE_3;
+ Map<String, String> newMap = mapProvider.get();
+ assertThat(oldMap).containsExactly(KEY_1, VALUE_1, KEY_2, VALUE_2);
+ assertThat(newMap).containsExactly(KEY_1, VALUE_3, KEY_2, VALUE_2);
+ }
+
+ @Test
+ public void testBindValueIntoSet() throws Exception {
+ rule.inject();
+ // basic check that initial/default values are properly injected
+ assertThat(providedIntSet.get()).containsExactly(SET_INT_1, SET_INT_2);
+ bindValueSetInt1 = SET_INT_3;
+ // change the value for bindValueSetString from 1 to 3
+ assertThat(providedIntSet.get()).containsExactly(SET_INT_2, SET_INT_3);
+ }
+
+ @MapKey
+ @interface MyMapKey {
+ String value();
+ }
+
+ private static String getBinding() {
+ return EntryPoints.get(getApplicationContext(), BindValueEntryPoint.class).bindValueString();
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simple/app/src/sharedTest/java/dagger/hilt/android/simple/DelayComponentReadyTest.java b/javatests/artifacts/hilt-android/simple/app/src/sharedTest/java/dagger/hilt/android/simple/DelayComponentReadyTest.java
new file mode 100644
index 0000000..81afb6e
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/app/src/sharedTest/java/dagger/hilt/android/simple/DelayComponentReadyTest.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simple;
+
+import static androidx.test.core.app.ApplicationProvider.getApplicationContext;
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import dagger.hilt.EntryPoint;
+import dagger.hilt.EntryPoints;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.testing.BindValue;
+import dagger.hilt.android.testing.HiltAndroidRule;
+import dagger.hilt.android.testing.HiltAndroidTest;
+import dagger.hilt.android.testing.OnComponentReadyRunner;
+import dagger.hilt.components.SingletonComponent;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/** A simple test using Hilt. */
+@HiltAndroidTest
+@RunWith(AndroidJUnit4.class)
+public final class DelayComponentReadyTest {
+
+ private static final String EXPECTED_VALUE = "expected";
+
+ @EntryPoint
+ @InstallIn(SingletonComponent.class)
+ public interface FooEntryPoint {
+ String foo();
+ }
+
+ @Rule public HiltAndroidRule rule = new HiltAndroidRule(this).delayComponentReady();
+
+ @BindValue String foo;
+
+ @Test
+ public void testLateBindValue() throws Exception {
+ AtomicReference<String> fooRef = new AtomicReference<>();
+ OnComponentReadyRunner.addListener(
+ ApplicationProvider.getApplicationContext(),
+ FooEntryPoint.class,
+ entryPoint -> fooRef.set(entryPoint.foo()));
+
+ // Test that setting the listener before the component is ready doesn't run the listener.
+ assertThat(fooRef.get()).isNull();
+
+ foo = EXPECTED_VALUE;
+ rule.componentReady().inject();
+ assertThat(EntryPoints.get(getApplicationContext(), FooEntryPoint.class).foo())
+ .isEqualTo(EXPECTED_VALUE);
+ }
+
+ @Test
+ public void testUnitializedBindValue_fails() throws Exception {
+ OnComponentReadyRunner.addListener(
+ ApplicationProvider.getApplicationContext(), FooEntryPoint.class, FooEntryPoint::foo);
+
+ // foo not set
+ NullPointerException expected = assertThrows(NullPointerException.class, rule::componentReady);
+ // This is not the best error message, but it is equivalent to the message from a regular
+ // (non-delayed) @BindValue returning null;
+ assertThat(expected)
+ .hasMessageThat()
+ .isEqualTo("Cannot return null from a non-@Nullable @Provides method");
+ }
+
+ @Test
+ public void testDoubleComponentReady_fails() throws Exception {
+ foo = EXPECTED_VALUE;
+ rule.componentReady();
+ IllegalStateException expected =
+ assertThrows(IllegalStateException.class, rule::componentReady);
+ assertThat(expected).hasMessageThat().isEqualTo("Called componentReady() multiple times");
+ }
+
+ @Test
+ public void testMissingComponentReady_fails() throws Exception {
+ // componentReady not called
+ foo = EXPECTED_VALUE;
+ IllegalStateException expected = assertThrows(IllegalStateException.class, rule::inject);
+ assertThat(expected)
+ .hasMessageThat()
+ .isEqualTo("Called inject() before calling componentReady()");
+ }
+
+ @Test
+ public void testDelayComponentReadyAfterStart_fails() throws Exception {
+ IllegalStateException expected =
+ assertThrows(IllegalStateException.class, rule::delayComponentReady);
+ assertThat(expected)
+ .hasMessageThat()
+ .isEqualTo("Called delayComponentReady after test execution started");
+ // Prevents failure due to never calling componentReady()
+ foo = EXPECTED_VALUE;
+ rule.componentReady();
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simple/app/src/sharedTest/java/dagger/hilt/android/simple/Injection1Test.java b/javatests/artifacts/hilt-android/simple/app/src/sharedTest/java/dagger/hilt/android/simple/Injection1Test.java
new file mode 100644
index 0000000..6e5ad6a
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/app/src/sharedTest/java/dagger/hilt/android/simple/Injection1Test.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simple;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.test.core.app.ActivityScenario;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.AndroidEntryPoint;
+import dagger.hilt.android.components.ActivityComponent;
+import dagger.hilt.android.testing.HiltAndroidRule;
+import dagger.hilt.android.testing.HiltAndroidTest;
+import dagger.hilt.components.SingletonComponent;
+import javax.inject.Inject;
+import javax.inject.Named;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/** Tests basic injection APIs, and that bindings don't conflict with {@link Injection2Test}. */
+@HiltAndroidTest
+@RunWith(AndroidJUnit4.class)
+public final class Injection1Test {
+ private static final String APPLICATION_QUALIFIER = "APPLICATION_QUALIFIER";
+ private static final String ACTIVITY_QUALIFIER = "ACTIVITY_QUALIFIER";
+ private static final String APPLICATION_VALUE = "Injection1Test_ApplicationValue";
+ private static final String ACTIVITY_VALUE = "Injection1Test_ActivityValue";
+
+ @Module
+ @InstallIn(SingletonComponent.class)
+ interface TestApplicationModule {
+ @Provides
+ @Named(APPLICATION_QUALIFIER)
+ static String provideString() {
+ return APPLICATION_VALUE;
+ }
+ }
+
+ @Module
+ @InstallIn(ActivityComponent.class)
+ interface TestActivityModule {
+ @Provides
+ @Named(ACTIVITY_QUALIFIER)
+ static String provideString() {
+ return ACTIVITY_VALUE;
+ }
+ }
+
+ /** Test activity used to test activity injection */
+ @AndroidEntryPoint
+ public static final class TestActivity extends AppCompatActivity {
+ @Inject @Named(ACTIVITY_QUALIFIER) String activityValue;
+ }
+
+ @Rule public HiltAndroidRule rule = new HiltAndroidRule(this);
+
+ @Inject @Named(APPLICATION_QUALIFIER) String applicationValue;
+
+ @Test
+ public void testApplicationInjection() throws Exception {
+ assertThat(applicationValue).isNull();
+ rule.inject();
+ assertThat(applicationValue).isEqualTo(APPLICATION_VALUE);
+ }
+
+ @Test
+ public void testActivityInjection() throws Exception {
+ try (ActivityScenario<TestActivity> scenario = ActivityScenario.launch(TestActivity.class)) {
+ scenario.onActivity(activity -> assertThat(activity.activityValue).isEqualTo(ACTIVITY_VALUE));
+ }
+ }
+
+ @Test
+ public void testSuperClassTransformation() {
+ try (ActivityScenario<TestActivity> scenario = ActivityScenario.launch(TestActivity.class)) {
+ scenario.onActivity(
+ activity ->
+ assertThat(activity.getClass().getSuperclass().getSimpleName())
+ .isEqualTo("Hilt_Injection1Test_TestActivity"));
+ }
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simple/app/src/sharedTest/java/dagger/hilt/android/simple/Injection2Test.java b/javatests/artifacts/hilt-android/simple/app/src/sharedTest/java/dagger/hilt/android/simple/Injection2Test.java
new file mode 100644
index 0000000..1ba3c2f
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/app/src/sharedTest/java/dagger/hilt/android/simple/Injection2Test.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simple;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.test.core.app.ActivityScenario;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.AndroidEntryPoint;
+import dagger.hilt.android.components.ActivityComponent;
+import dagger.hilt.android.testing.HiltAndroidRule;
+import dagger.hilt.android.testing.HiltAndroidTest;
+import dagger.hilt.components.SingletonComponent;
+import javax.inject.Inject;
+import javax.inject.Named;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/** Tests basic injection APIs, and that bindings don't conflict with {@link Injection1Test}. */
+@HiltAndroidTest
+@RunWith(AndroidJUnit4.class)
+public final class Injection2Test {
+ private static final String APPLICATION_QUALIFIER = "APPLICATION_QUALIFIER";
+ private static final String ACTIVITY_QUALIFIER = "ACTIVITY_QUALIFIER";
+ private static final String APPLICATION_VALUE = "Injection2Test_ApplicationValue";
+ private static final String ACTIVITY_VALUE = "Injection2Test_ActivityValue";
+
+ @Module
+ @InstallIn(SingletonComponent.class)
+ interface TestApplicationModule {
+ @Provides
+ @Named(APPLICATION_QUALIFIER)
+ static String provideString() {
+ return APPLICATION_VALUE;
+ }
+ }
+
+ @Module
+ @InstallIn(ActivityComponent.class)
+ interface TestActivityModule {
+ @Provides
+ @Named(ACTIVITY_QUALIFIER)
+ static String provideString() {
+ return ACTIVITY_VALUE;
+ }
+ }
+
+ /** Test activity used to test activity injection */
+ @AndroidEntryPoint
+ public static final class TestActivity extends AppCompatActivity {
+ @Inject @Named(ACTIVITY_QUALIFIER) String activityValue;
+ }
+
+ @Rule public HiltAndroidRule rule = new HiltAndroidRule(this);
+
+ @Inject @Named(APPLICATION_QUALIFIER) String applicationValue;
+
+ @Test
+ public void testApplicationInjection() throws Exception {
+ assertThat(applicationValue).isNull();
+ rule.inject();
+ assertThat(applicationValue).isEqualTo(APPLICATION_VALUE);
+ }
+
+ @Test
+ public void testActivityInjection() throws Exception {
+ try (ActivityScenario<TestActivity> scenario = ActivityScenario.launch(TestActivity.class)) {
+ scenario.onActivity(activity -> assertThat(activity.activityValue).isEqualTo(ACTIVITY_VALUE));
+ }
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simple/app/src/sharedTest/java/dagger/hilt/android/simple/ModuleTest.java b/javatests/artifacts/hilt-android/simple/app/src/sharedTest/java/dagger/hilt/android/simple/ModuleTest.java
new file mode 100644
index 0000000..e1f4421
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/app/src/sharedTest/java/dagger/hilt/android/simple/ModuleTest.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simple;
+
+import static org.junit.Assert.assertEquals;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import dagger.Binds;
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.testing.HiltAndroidRule;
+import dagger.hilt.android.testing.HiltAndroidTest;
+import dagger.hilt.components.SingletonComponent;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+import javax.inject.Inject;
+import javax.inject.Qualifier;
+import javax.inject.Singleton;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/** Tests basic functionality of using modules in test. */
+@HiltAndroidTest
+@RunWith(AndroidJUnit4.class)
+public final class ModuleTest {
+ @Rule public final HiltAndroidRule rules = new HiltAndroidRule(this);
+
+ /** Qualifier for distinguishing test Strings, */
+ @Qualifier
+ @Target({ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD})
+ public @interface TestQualifier {
+ int value();
+ }
+
+ @Inject
+ @TestQualifier(1)
+ String testString1;
+
+ @Inject
+ @TestQualifier(2)
+ String testString2;
+
+ @Inject
+ @TestQualifier(3)
+ String testString3;
+
+ @Inject
+ @TestQualifier(4)
+ String testString4;
+
+ @Inject FooImpl fooImpl;
+ @Inject Foo foo;
+
+ /**
+ * Module which is used to test if non-static test modules get registered in the component
+ * correctly.
+ */
+ @Module
+ @InstallIn(SingletonComponent.class)
+ public final class NonStaticModuleNonStaticProvides {
+ @Provides
+ @TestQualifier(1)
+ String provideString() {
+ return "1";
+ }
+ }
+
+ /**
+ * Module which is used to test if static test modules get registered in the component correctly.
+ */
+ @Module
+ @InstallIn(SingletonComponent.class)
+ public static final class StaticModuleStaticProvides {
+ @Provides
+ @TestQualifier(2)
+ static String provideString() {
+ return "2";
+ }
+
+ private StaticModuleStaticProvides() {}
+ }
+
+ /**
+ * Module which is used to test if static test modules with a non-static methods get registered in
+ * the component correctly.
+ */
+ @Module
+ @InstallIn(SingletonComponent.class)
+ public static final class StaticModuleNonStaticProvidesDefaultConstructor {
+ @Provides
+ @TestQualifier(3)
+ String provideString() {
+ return "3";
+ }
+ }
+
+ /**
+ * Module which is used to test if abstract test modules get registered in the component
+ * correctly.
+ */
+ @Module
+ @InstallIn(SingletonComponent.class)
+ public abstract static class AbstractModuleStaticProvides {
+ @Provides
+ @TestQualifier(4)
+ static String provideString() {
+ return "4";
+ }
+
+ private AbstractModuleStaticProvides() {}
+ }
+
+ /**
+ * Module which is used to test if abstract test modules with a binds method get registered in the
+ * component correctly.
+ */
+ @Module
+ @InstallIn(SingletonComponent.class)
+ public abstract static class AbstractModuleBindsMethod {
+ @Binds
+ abstract Foo foo(FooImpl fooImpl);
+ }
+
+ interface Foo {}
+
+ @Singleton
+ static final class FooImpl implements Foo {
+ @Inject
+ FooImpl() {}
+ }
+
+ @Test
+ public void testInjection() throws Exception {
+ rules.inject();
+ assertEquals("1", testString1);
+ assertEquals("2", testString2);
+ assertEquals("3", testString3);
+ assertEquals("4", testString4);
+ assertEquals(fooImpl, foo);
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simple/app/src/sharedTest/java/dagger/hilt/android/simple/SimpleActivityTest.java b/javatests/artifacts/hilt-android/simple/app/src/sharedTest/java/dagger/hilt/android/simple/SimpleActivityTest.java
new file mode 100644
index 0000000..f2e2e77
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/app/src/sharedTest/java/dagger/hilt/android/simple/SimpleActivityTest.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simple;
+
+import static androidx.test.espresso.Espresso.onView;
+import static androidx.test.espresso.assertion.ViewAssertions.matches;
+import static androidx.test.espresso.matcher.ViewMatchers.withId;
+import static androidx.test.espresso.matcher.ViewMatchers.withText;
+import static com.google.common.truth.Truth.assertThat;
+
+import androidx.test.core.app.ActivityScenario;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import dagger.hilt.android.simple.lib.ThingImpl;
+import dagger.hilt.android.testing.BindValue;
+import dagger.hilt.android.testing.HiltAndroidRule;
+import dagger.hilt.android.testing.HiltAndroidTest;
+import dagger.hilt.android.testing.UninstallModules;
+import javax.inject.Inject;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/** A simple test using Hilt that can be run with instrumentation or Robolectric tests. */
+@UninstallModules({
+ UserNameModule.class,
+ ModelModule.class
+})
+@HiltAndroidTest
+@RunWith(AndroidJUnit4.class)
+public final class SimpleActivityTest {
+ @Rule public HiltAndroidRule rule = new HiltAndroidRule(this);
+
+ @BindValue @UserName String fakeUserName = "FakeUser";
+ @BindValue @Model String fakeModel = "FakeModel";
+
+ @Inject @UserName String injectedUserName;
+ @Inject @Model String injectedModel;
+
+ @Test
+ public void testInjectedUserName() throws Exception {
+ assertThat(injectedUserName).isNull();
+ rule.inject();
+ assertThat(injectedUserName).isEqualTo("FakeUser");
+ }
+
+ @Test
+ public void testInjectedModel() throws Exception {
+ assertThat(injectedModel).isNull();
+ rule.inject();
+ assertThat(injectedModel).isEqualTo("FakeModel");
+ }
+
+ @Test
+ public void testActivityInject() throws Exception {
+ try (ActivityScenario<SimpleActivity> scenario =
+ ActivityScenario.launch(SimpleActivity.class)) {
+ onView(withId(R.id.greeting))
+ .check(matches(withText("Hello, FakeUser! You are on build FakeModel.")));
+ } catch (RuntimeException e) {
+ // Just skip this test if the root view never becomes active.
+ // This issue occurs sporadically in emulator tests and causes the test to be flaky.
+ // It is likely caused by a race between our activity and a dialog or lock screen but
+ // it's difficult to debug this since it only fails in CI builds.
+ // TODO(b/176111885): Remove this once this bug is fixed.
+ if (!e.getMessage().startsWith("Waited for the root of the view hierarchy")) {
+ throw e;
+ }
+ }
+ }
+
+ @Test
+ public void verifyMainActivity() {
+ try (ActivityScenario<SimpleActivity> scenario =
+ ActivityScenario.launch(SimpleActivity.class)) {
+ scenario.onActivity(
+ activity -> {
+ assertThat(activity.getClass().getSuperclass().getSimpleName())
+ .isEqualTo("Hilt_SimpleActivity");
+ }
+ );
+ }
+ }
+
+ @Test
+ public void verifyThing() {
+ try (ActivityScenario<SimpleActivity> scenario =
+ ActivityScenario.launch(SimpleActivity.class)) {
+ scenario.onActivity(activity -> assertThat(activity.thing).isInstanceOf(ThingImpl.class));
+ }
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simple/app/src/sharedTest/java/dagger/hilt/android/simple/TransitiveDependenciesTest.java b/javatests/artifacts/hilt-android/simple/app/src/sharedTest/java/dagger/hilt/android/simple/TransitiveDependenciesTest.java
new file mode 100644
index 0000000..a4f900d
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/app/src/sharedTest/java/dagger/hilt/android/simple/TransitiveDependenciesTest.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simple;
+
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.platform.app.InstrumentationRegistry;
+import dagger.hilt.android.simple.feature.FeatureEntryPoints;
+import dagger.hilt.android.testing.HiltAndroidRule;
+import dagger.hilt.android.testing.HiltAndroidTest;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/**
+ * Tests that entry points in deep dependencies with `implementation` boundaries are available at
+ * runtime.
+ */
+@HiltAndroidTest
+@RunWith(AndroidJUnit4.class)
+public class TransitiveDependenciesTest {
+
+ @Rule public HiltAndroidRule rule = new HiltAndroidRule(this);
+
+ @Test
+ public void testEntryPoint() {
+ FeatureEntryPoints.invokeEntryPoints(
+ InstrumentationRegistry.getInstrumentation().getTargetContext().getApplicationContext());
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simple/app/src/test/resources/dagger/hilt/android/simple/robolectric.properties b/javatests/artifacts/hilt-android/simple/app/src/test/resources/dagger/hilt/android/simple/robolectric.properties
new file mode 100644
index 0000000..0234ffe
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/app/src/test/resources/dagger/hilt/android/simple/robolectric.properties
@@ -0,0 +1,2 @@
+sdk=28
+application=dagger.hilt.android.testing.HiltTestApplication
\ No newline at end of file
diff --git a/javatests/artifacts/hilt-android/simple/build.gradle b/javatests/artifacts/hilt-android/simple/build.gradle
new file mode 100644
index 0000000..770fabd
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/build.gradle
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+buildscript {
+ ext {
+ dagger_version = 'LOCAL-SNAPSHOT'
+ kotlin_version = '1.3.61'
+ agp_version = System.getenv('AGP_VERSION') ?: "4.2.0-beta04"
+ }
+ repositories {
+ google()
+ jcenter()
+ mavenLocal()
+ }
+ dependencies {
+ classpath "com.android.tools.build:gradle:$agp_version"
+ classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+ classpath "com.google.dagger:hilt-android-gradle-plugin:$dagger_version"
+ }
+}
+
+allprojects {
+ repositories {
+ google()
+ jcenter()
+ mavenCentral()
+ mavenLocal()
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simple/deep-android-lib/build.gradle b/javatests/artifacts/hilt-android/simple/deep-android-lib/build.gradle
new file mode 100644
index 0000000..e5ed046
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/deep-android-lib/build.gradle
@@ -0,0 +1,26 @@
+plugins {
+ id 'com.android.library'
+ id 'dagger.hilt.android.plugin'
+}
+
+android {
+ compileSdkVersion 30
+ buildToolsVersion "30.0.2"
+
+ defaultConfig {
+ minSdkVersion 15
+ targetSdkVersion 30
+ versionCode 1
+ versionName "1.0"
+ }
+
+ compileOptions {
+ sourceCompatibility 1.8
+ targetCompatibility 1.8
+ }
+}
+
+dependencies {
+ implementation "com.google.dagger:hilt-android:$dagger_version"
+ annotationProcessor "com.google.dagger:hilt-compiler:$dagger_version"
+}
\ No newline at end of file
diff --git a/javatests/artifacts/hilt-android/simple/deep-android-lib/src/main/AndroidManifest.xml b/javatests/artifacts/hilt-android/simple/deep-android-lib/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..49a304e
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/deep-android-lib/src/main/AndroidManifest.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ Copyright (C) 2020 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="dagger.hilt.android.simple.deep">
+
+</manifest>
\ No newline at end of file
diff --git a/javatests/artifacts/hilt-android/simple/deep-android-lib/src/main/java/dagger/hilt/android/simple/deep/DeepAndroidLib.java b/javatests/artifacts/hilt-android/simple/deep-android-lib/src/main/java/dagger/hilt/android/simple/deep/DeepAndroidLib.java
new file mode 100644
index 0000000..57fd803
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/deep-android-lib/src/main/java/dagger/hilt/android/simple/deep/DeepAndroidLib.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simple.deep;
+
+import android.content.Context;
+import dagger.hilt.EntryPoint;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.EntryPointAccessors;
+import dagger.hilt.components.SingletonComponent;
+import javax.inject.Inject;
+
+public class DeepAndroidLib {
+
+ @EntryPoint
+ @InstallIn(SingletonComponent.class)
+ interface LibEntryPoint {
+ DeepAndroidLib getDeepAndroidInstance();
+ }
+
+ @Inject
+ public DeepAndroidLib() {}
+
+ public static DeepAndroidLib getInstance(Context context) {
+ return EntryPointAccessors.fromApplication(context, LibEntryPoint.class)
+ .getDeepAndroidInstance();
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simple/deep-lib/build.gradle b/javatests/artifacts/hilt-android/simple/deep-lib/build.gradle
new file mode 100644
index 0000000..22f815c
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/deep-lib/build.gradle
@@ -0,0 +1,13 @@
+plugins {
+ id 'java-library'
+}
+
+java {
+ sourceCompatibility = JavaVersion.VERSION_1_7
+ targetCompatibility = JavaVersion.VERSION_1_7
+}
+
+dependencies {
+ implementation "com.google.dagger:hilt-core:$dagger_version"
+ annotationProcessor "com.google.dagger:hilt-compiler:$dagger_version"
+}
\ No newline at end of file
diff --git a/javatests/artifacts/hilt-android/simple/deep-lib/src/main/java/dagger/hilt/android/deep/DeepLib.java b/javatests/artifacts/hilt-android/simple/deep-lib/src/main/java/dagger/hilt/android/deep/DeepLib.java
new file mode 100644
index 0000000..419e539
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/deep-lib/src/main/java/dagger/hilt/android/deep/DeepLib.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.deep;
+
+import dagger.hilt.EntryPoint;
+import dagger.hilt.EntryPoints;
+import dagger.hilt.InstallIn;
+import dagger.hilt.components.SingletonComponent;
+import javax.inject.Inject;
+
+public class DeepLib {
+
+ @EntryPoint
+ @InstallIn(SingletonComponent.class)
+ interface LibEntryPoint {
+ DeepLib getDeepInstance();
+ }
+
+ @Inject
+ public DeepLib() {}
+
+ public static DeepLib getInstance(Object componentManager) {
+ return EntryPoints.get(componentManager, LibEntryPoint.class).getDeepInstance();
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simple/feature/build.gradle b/javatests/artifacts/hilt-android/simple/feature/build.gradle
new file mode 100644
index 0000000..0e772a8
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/feature/build.gradle
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+apply plugin: 'kotlin-kapt'
+apply plugin: 'dagger.hilt.android.plugin'
+
+android {
+ compileSdkVersion 30
+ buildToolsVersion "30.0.2"
+
+ defaultConfig {
+ minSdkVersion 15
+ targetSdkVersion 30
+ versionCode 1
+ versionName "1.0"
+ }
+ compileOptions {
+ sourceCompatibility 1.8
+ targetCompatibility 1.8
+ }
+}
+
+kapt {
+ correctErrorTypes true
+}
+
+hilt {
+ enableTransformForLocalTests = true
+}
+
+dependencies {
+ // This is api instead of implementation since Kotlin modules here consumed
+ // by the app need to expose @kotlin.Metadata
+ api "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
+
+ implementation project(":deep-android-lib")
+ implementation project(":deep-lib")
+
+ implementation 'androidx.appcompat:appcompat:1.2.0'
+ implementation "com.google.dagger:hilt-android:$dagger_version"
+ kapt "com.google.dagger:hilt-compiler:$dagger_version"
+}
diff --git a/javatests/artifacts/hilt-android/simple/feature/src/main/AndroidManifest.xml b/javatests/artifacts/hilt-android/simple/feature/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..fe583e5
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/feature/src/main/AndroidManifest.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ Copyright (C) 2020 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="dagger.hilt.android.simple.feature">
+ <application>
+ <activity
+ android:name=".FeatureActivity"
+ android:theme="@style/Theme.AppCompat.Light"
+ android:exported="true"/>
+ </application>
+</manifest>
diff --git a/javatests/artifacts/hilt-android/simple/feature/src/main/java/dagger/hilt/android/simple/feature/FeatureActivity.kt b/javatests/artifacts/hilt-android/simple/feature/src/main/java/dagger/hilt/android/simple/feature/FeatureActivity.kt
new file mode 100644
index 0000000..c1931ac
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/feature/src/main/java/dagger/hilt/android/simple/feature/FeatureActivity.kt
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simple.feature
+
+import android.os.Bundle
+import android.widget.Button
+import android.widget.TextView
+import androidx.appcompat.app.AppCompatActivity
+import dagger.hilt.android.AndroidEntryPoint
+import javax.inject.Inject
+
+@AndroidEntryPoint
+class FeatureActivity : AppCompatActivity() {
+ @Inject lateinit var counter: FeatureCounter
+
+ override fun onCreate(savedInstanceState: Bundle?) {
+ super.onCreate(savedInstanceState)
+
+ setContentView(R.layout.activity_feature)
+
+ findViewById<Button>(R.id.feature_button).setOnClickListener {
+ counter.count++
+ updateCountText()
+ }
+
+ updateCountText()
+ }
+
+ private fun updateCountText() {
+ findViewById<TextView>(R.id.feature_count).text = "The count: ${counter.count}"
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simple/feature/src/main/java/dagger/hilt/android/simple/feature/FeatureCounter.kt b/javatests/artifacts/hilt-android/simple/feature/src/main/java/dagger/hilt/android/simple/feature/FeatureCounter.kt
new file mode 100644
index 0000000..d55bb5a
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/feature/src/main/java/dagger/hilt/android/simple/feature/FeatureCounter.kt
@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simple.feature
+
+class FeatureCounter(var count: Int)
diff --git a/javatests/artifacts/hilt-android/simple/feature/src/main/java/dagger/hilt/android/simple/feature/FeatureEntryPoints.java b/javatests/artifacts/hilt-android/simple/feature/src/main/java/dagger/hilt/android/simple/feature/FeatureEntryPoints.java
new file mode 100644
index 0000000..c1ca22f
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/feature/src/main/java/dagger/hilt/android/simple/feature/FeatureEntryPoints.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simple.feature;
+
+import android.content.Context;
+import dagger.hilt.android.deep.DeepLib;
+import dagger.hilt.android.simple.deep.DeepAndroidLib;
+
+public final class FeatureEntryPoints {
+
+ public static void invokeEntryPoints(Context context) {
+ DeepAndroidLib.getInstance(context);
+ DeepLib.getInstance(context);
+ }
+
+ private FeatureEntryPoints() {}
+}
diff --git a/javatests/artifacts/hilt-android/simple/feature/src/main/java/dagger/hilt/android/simple/feature/FeatureModule.kt b/javatests/artifacts/hilt-android/simple/feature/src/main/java/dagger/hilt/android/simple/feature/FeatureModule.kt
new file mode 100644
index 0000000..d513f37
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/feature/src/main/java/dagger/hilt/android/simple/feature/FeatureModule.kt
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simple.feature
+
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.android.components.ActivityRetainedComponent
+import dagger.hilt.android.scopes.ActivityRetainedScoped
+
+@Module
+@InstallIn(ActivityRetainedComponent::class)
+object FeatureModule {
+ @Provides
+ @ActivityRetainedScoped
+ fun provideData() = FeatureCounter(0)
+}
diff --git a/javatests/artifacts/hilt-android/simple/feature/src/main/res/layout/activity_feature.xml b/javatests/artifacts/hilt-android/simple/feature/src/main/res/layout/activity_feature.xml
new file mode 100644
index 0000000..99adcfd
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/feature/src/main/res/layout/activity_feature.xml
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ Copyright (C) 2020 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+ android:layout_width="match_parent"
+ android:layout_height="match_parent"
+ android:background="@android:color/background_light">
+
+ <TextView
+ android:id="@+id/feature_count"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:layout_alignParentTop="true"
+ android:textColor="@android:color/primary_text_light"
+ />
+
+ <Button
+ android:id="@+id/feature_button"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:layout_below="@id/feature_count"
+ android:text="Count++"
+ />
+</RelativeLayout>
diff --git a/javatests/artifacts/hilt-android/simple/gradle.properties b/javatests/artifacts/hilt-android/simple/gradle.properties
new file mode 100644
index 0000000..646c51b
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/gradle.properties
@@ -0,0 +1,2 @@
+android.useAndroidX=true
+android.enableJetifier=true
diff --git a/javatests/artifacts/hilt-android/simple/gradle/wrapper/gradle-wrapper.jar b/javatests/artifacts/hilt-android/simple/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000..5c2d1cf
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/gradle/wrapper/gradle-wrapper.jar
Binary files differ
diff --git a/javatests/artifacts/hilt-android/simple/gradle/wrapper/gradle-wrapper.properties b/javatests/artifacts/hilt-android/simple/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000..4d9ca16
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.7.1-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/javatests/artifacts/hilt-android/simple/gradlew b/javatests/artifacts/hilt-android/simple/gradlew
new file mode 100755
index 0000000..b0d6d0a
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/gradlew
@@ -0,0 +1,188 @@
+#!/usr/bin/env sh
+
+#
+# Copyright 2015 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+##
+## Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+ ls=`ls -ld "$PRG"`
+ link=`expr "$ls" : '.*-> \(.*\)$'`
+ if expr "$link" : '/.*' > /dev/null; then
+ PRG="$link"
+ else
+ PRG=`dirname "$PRG"`"/$link"
+ fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+ echo "$*"
+}
+
+die () {
+ echo
+ echo "$*"
+ echo
+ exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+ CYGWIN* )
+ cygwin=true
+ ;;
+ Darwin* )
+ darwin=true
+ ;;
+ MINGW* )
+ msys=true
+ ;;
+ NONSTOP* )
+ nonstop=true
+ ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+ if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+ # IBM's JDK on AIX uses strange locations for the executables
+ JAVACMD="$JAVA_HOME/jre/sh/java"
+ else
+ JAVACMD="$JAVA_HOME/bin/java"
+ fi
+ if [ ! -x "$JAVACMD" ] ; then
+ die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+ fi
+else
+ JAVACMD="java"
+ which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+ MAX_FD_LIMIT=`ulimit -H -n`
+ if [ $? -eq 0 ] ; then
+ if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+ MAX_FD="$MAX_FD_LIMIT"
+ fi
+ ulimit -n $MAX_FD
+ if [ $? -ne 0 ] ; then
+ warn "Could not set maximum file descriptor limit: $MAX_FD"
+ fi
+ else
+ warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+ fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+ GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+ APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+ CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+ JAVACMD=`cygpath --unix "$JAVACMD"`
+
+ # We build the pattern for arguments to be converted via cygpath
+ ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+ SEP=""
+ for dir in $ROOTDIRSRAW ; do
+ ROOTDIRS="$ROOTDIRS$SEP$dir"
+ SEP="|"
+ done
+ OURCYGPATTERN="(^($ROOTDIRS))"
+ # Add a user-defined pattern to the cygpath arguments
+ if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+ OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+ fi
+ # Now convert the arguments - kludge to limit ourselves to /bin/sh
+ i=0
+ for arg in "$@" ; do
+ CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+ CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
+
+ if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
+ eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+ else
+ eval `echo args$i`="\"$arg\""
+ fi
+ i=$((i+1))
+ done
+ case $i in
+ (0) set -- ;;
+ (1) set -- "$args0" ;;
+ (2) set -- "$args0" "$args1" ;;
+ (3) set -- "$args0" "$args1" "$args2" ;;
+ (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+ (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+ (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+ (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+ (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+ (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+ esac
+fi
+
+# Escape application args
+save () {
+ for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+ echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+ cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"
diff --git a/javatests/artifacts/hilt-android/simple/lib/build.gradle b/javatests/artifacts/hilt-android/simple/lib/build.gradle
new file mode 100644
index 0000000..d67be3b
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/lib/build.gradle
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+plugins {
+ id 'java-library'
+}
+
+java {
+ sourceCompatibility = JavaVersion.VERSION_1_8
+ targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+dependencies {
+ implementation "com.google.dagger:hilt-core:$dagger_version"
+ annotationProcessor "com.google.dagger:hilt-compiler:$dagger_version"
+}
diff --git a/javatests/artifacts/hilt-android/simple/lib/src/main/java/dagger/hilt/android/simple/lib/Thing.java b/javatests/artifacts/hilt-android/simple/lib/src/main/java/dagger/hilt/android/simple/lib/Thing.java
new file mode 100644
index 0000000..baded09
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/lib/src/main/java/dagger/hilt/android/simple/lib/Thing.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simple.lib;
+
+/** A thing. */
+public interface Thing {}
diff --git a/javatests/artifacts/hilt-android/simple/lib/src/main/java/dagger/hilt/android/simple/lib/ThingImpl.java b/javatests/artifacts/hilt-android/simple/lib/src/main/java/dagger/hilt/android/simple/lib/ThingImpl.java
new file mode 100644
index 0000000..f6a628e
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/lib/src/main/java/dagger/hilt/android/simple/lib/ThingImpl.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simple.lib;
+
+import dagger.Binds;
+import dagger.Module;
+import dagger.hilt.InstallIn;
+import dagger.hilt.components.SingletonComponent;
+import javax.inject.Inject;
+
+/** An implementation of a thing. */
+public final class ThingImpl implements Thing {
+ @Inject
+ ThingImpl() {}
+
+ @Module
+ @InstallIn(SingletonComponent.class)
+ interface FooStringModule {
+ @Binds Thing bind(ThingImpl impl);
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simple/settings.gradle b/javatests/artifacts/hilt-android/simple/settings.gradle
new file mode 100644
index 0000000..bad895d
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simple/settings.gradle
@@ -0,0 +1,6 @@
+rootProject.name='Simple Hilt Android'
+include ':app'
+include ':feature'
+include ':lib'
+include ':deep-android-lib'
+include ':deep-lib'
\ No newline at end of file
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/android-library/build.gradle b/javatests/artifacts/hilt-android/simpleKotlin/android-library/build.gradle
new file mode 100644
index 0000000..383c4be
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/android-library/build.gradle
@@ -0,0 +1,31 @@
+plugins {
+ id 'com.android.library'
+ id 'kotlin-android'
+ id 'kotlin-kapt'
+}
+
+android {
+ compileSdkVersion 30
+ buildToolsVersion "30.0.2"
+
+ defaultConfig {
+ minSdkVersion 15
+ targetSdkVersion 30
+ versionCode 1
+ versionName "1.0"
+ }
+ compileOptions {
+ sourceCompatibility JavaVersion.VERSION_1_8
+ targetCompatibility JavaVersion.VERSION_1_8
+ }
+ kotlinOptions {
+ jvmTarget = '1.8'
+ }
+}
+
+dependencies {
+ implementation project(':deep-android-lib')
+ implementation project(':deep-kotlin-lib')
+ implementation 'com.google.dagger:hilt-android:LOCAL-SNAPSHOT'
+ kapt 'com.google.dagger:hilt-compiler:LOCAL-SNAPSHOT'
+}
\ No newline at end of file
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/android-library/src/main/AndroidManifest.xml b/javatests/artifacts/hilt-android/simpleKotlin/android-library/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..c60ba73
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/android-library/src/main/AndroidManifest.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="dagger.hilt.android.simpleKotlin.lib">
+
+</manifest>
\ No newline at end of file
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/android-library/src/main/java/dagger/hilt/android/simpleKotlin/lib/AndroidLibraryEntryPoints.kt b/javatests/artifacts/hilt-android/simpleKotlin/android-library/src/main/java/dagger/hilt/android/simpleKotlin/lib/AndroidLibraryEntryPoints.kt
new file mode 100644
index 0000000..cb10c8b
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/android-library/src/main/java/dagger/hilt/android/simpleKotlin/lib/AndroidLibraryEntryPoints.kt
@@ -0,0 +1,12 @@
+package dagger.hilt.android.simpleKotlin.lib
+
+import android.content.Context
+import dagger.hilt.android.simpleKotlin.deep.DeepAndroidLib
+import dagger.hilt.android.simpleKotlin.deep.DeepLib
+
+object AndroidLibraryEntryPoints {
+ fun invokeEntryPoints(context: Context) {
+ DeepAndroidLib.getInstance(context)
+ DeepLib.getInstance(context)
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/app/build.gradle b/javatests/artifacts/hilt-android/simpleKotlin/app/build.gradle
new file mode 100644
index 0000000..ecfaf6e
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/app/build.gradle
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+apply plugin: 'com.android.application'
+apply plugin: 'kotlin-android'
+apply plugin: 'dagger.hilt.android.plugin'
+apply plugin: 'kotlin-kapt'
+
+android {
+ compileSdkVersion 30
+ buildToolsVersion "30.0.2"
+
+ defaultConfig {
+ applicationId "dagger.hilt.android.simpleKotlin"
+ minSdkVersion 15
+ targetSdkVersion 30
+ versionCode 1
+ versionName "1.0"
+ testInstrumentationRunner "dagger.hilt.android.example.gradle.simpleKotlin.TestRunner"
+ }
+ buildTypes {
+ release {
+ minifyEnabled true
+ shrinkResources true
+ }
+ }
+ compileOptions {
+ sourceCompatibility 1.8
+ targetCompatibility 1.8
+ }
+ kotlinOptions {
+ jvmTarget = '1.8'
+ }
+ testOptions {
+ unitTests.includeAndroidResources = true
+ }
+ lintOptions {
+ checkReleaseBuilds = false
+ }
+ sourceSets {
+ String sharedTestDir = 'src/sharedTest/java'
+ test {
+ java.srcDirs += sharedTestDir
+ }
+ androidTest {
+ java.srcDirs += sharedTestDir
+ }
+ }
+}
+
+hilt {
+ enableExperimentalClasspathAggregation = true
+ enableTransformForLocalTests = true
+}
+
+dependencies {
+ implementation project(':android-library')
+ implementation project(':kotlin-library')
+ implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+ implementation 'androidx.appcompat:appcompat:1.2.0'
+ implementation 'androidx.activity:activity-ktx:1.1.0'
+
+ implementation 'com.google.dagger:hilt-android:LOCAL-SNAPSHOT'
+ kapt 'com.google.dagger:hilt-compiler:LOCAL-SNAPSHOT'
+
+ testImplementation 'androidx.test.ext:junit:1.1.2'
+ testImplementation 'androidx.test:runner:1.3.0'
+ testImplementation 'com.google.truth:truth:1.0.1'
+ testImplementation 'junit:junit:4.13'
+ testImplementation 'org.robolectric:robolectric:4.5-alpha-3'
+ testImplementation 'androidx.core:core:1.3.2'
+ // TODO(bcorso): This multidex dep shouldn't be required -- it's a dep for the generated code.
+ testImplementation 'androidx.multidex:multidex:2.0.0'
+ testImplementation 'com.google.dagger:hilt-android-testing:LOCAL-SNAPSHOT'
+ kaptTest 'com.google.dagger:hilt-compiler:LOCAL-SNAPSHOT'
+
+ androidTestImplementation 'androidx.fragment:fragment-ktx:1.2.5'
+ androidTestImplementation 'androidx.test.ext:junit:1.1.2'
+ androidTestImplementation 'androidx.test:runner:1.3.0'
+ androidTestImplementation 'com.google.truth:truth:1.0.1'
+ androidTestImplementation 'com.google.dagger:hilt-android-testing:LOCAL-SNAPSHOT'
+ kaptAndroidTest 'com.google.dagger:hilt-compiler:LOCAL-SNAPSHOT'
+}
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/app/src/androidTest/java/dagger/hilt/android/simpleKotlin/SimpleEmulatorTestRunner.kt b/javatests/artifacts/hilt-android/simpleKotlin/app/src/androidTest/java/dagger/hilt/android/simpleKotlin/SimpleEmulatorTestRunner.kt
new file mode 100644
index 0000000..d790265
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/app/src/androidTest/java/dagger/hilt/android/simpleKotlin/SimpleEmulatorTestRunner.kt
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package dagger.hilt.android.simpleKotlin
+
+import android.app.Application
+import android.content.Context
+import androidx.test.runner.AndroidJUnitRunner
+import dagger.hilt.android.testing.HiltTestApplication
+
+/** A custom runner to setup the emulator application class for tests. */
+class SimpleEmulatorTestRunner : AndroidJUnitRunner() {
+ override fun newApplication(cl: ClassLoader, className: String, context: Context): Application {
+ return super.newApplication(cl, HiltTestApplication::class.java.name, context)
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/app/src/androidTest/java/dagger/hilt/android/simpleKotlin/TestRunner.kt b/javatests/artifacts/hilt-android/simpleKotlin/app/src/androidTest/java/dagger/hilt/android/simpleKotlin/TestRunner.kt
new file mode 100644
index 0000000..29ffc9e
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/app/src/androidTest/java/dagger/hilt/android/simpleKotlin/TestRunner.kt
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.example.gradle.simpleKotlin
+
+import android.app.Application
+import android.content.Context
+import androidx.test.runner.AndroidJUnitRunner
+import dagger.hilt.android.testing.HiltTestApplication
+
+class TestRunner : AndroidJUnitRunner() {
+ override fun newApplication(cl: ClassLoader, appName: String, context: Context): Application {
+ return super.newApplication(cl, HiltTestApplication::class.java.name, context)
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/app/src/androidTest/java/dagger/hilt/android/simpleKotlin/viewmodel/ActivityInjectionTest.kt b/javatests/artifacts/hilt-android/simpleKotlin/app/src/androidTest/java/dagger/hilt/android/simpleKotlin/viewmodel/ActivityInjectionTest.kt
new file mode 100644
index 0000000..6786e9d
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/app/src/androidTest/java/dagger/hilt/android/simpleKotlin/viewmodel/ActivityInjectionTest.kt
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simpleKotlin.viewmodel
+
+import androidx.activity.viewModels
+import androidx.fragment.app.FragmentActivity
+import androidx.test.core.app.ActivityScenario
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.google.common.truth.Truth.assertThat
+import dagger.hilt.android.AndroidEntryPoint
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@HiltAndroidTest
+@RunWith(AndroidJUnit4::class)
+class ActivityInjectionTest {
+
+ @get:Rule
+ val rule = HiltAndroidRule(this)
+
+ @Test
+ fun verifyInjection() {
+ ActivityScenario.launch(TestActivity::class.java).use {
+ it.onActivity { activity ->
+ assertThat(activity.myAndroidViewModel).isNotNull()
+ assertThat(activity.myViewModel).isNotNull()
+ assertThat(activity.myInjectedViewModel).isNotNull()
+ assertThat(activity.myNestedInjectedViewModel).isNotNull()
+ assertThat(activity.myInjectedViewModelWithSavedState).isNotNull()
+ }
+ }
+ }
+
+ @AndroidEntryPoint
+ class TestActivity : FragmentActivity() {
+ val myAndroidViewModel by viewModels<MyAndroidViewModel>()
+ val myViewModel by viewModels<MyViewModel>()
+ val myInjectedViewModel by viewModels<MyInjectedViewModel>()
+ val myNestedInjectedViewModel by viewModels<TopClass.MyNestedInjectedViewModel>()
+ val myInjectedViewModelWithSavedState by viewModels<MyInjectedViewModelWithSavedState>()
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/app/src/androidTest/java/dagger/hilt/android/simpleKotlin/viewmodel/BaseActivityInjectionTest.kt b/javatests/artifacts/hilt-android/simpleKotlin/app/src/androidTest/java/dagger/hilt/android/simpleKotlin/viewmodel/BaseActivityInjectionTest.kt
new file mode 100644
index 0000000..7ac4ebf
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/app/src/androidTest/java/dagger/hilt/android/simpleKotlin/viewmodel/BaseActivityInjectionTest.kt
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simpleKotlin.viewmodel
+
+import androidx.activity.viewModels
+import androidx.fragment.app.FragmentActivity
+import androidx.test.core.app.ActivityScenario
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.google.common.truth.Truth.assertThat
+import dagger.hilt.android.AndroidEntryPoint
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@HiltAndroidTest
+@RunWith(AndroidJUnit4::class)
+class BaseActivityInjectionTest {
+
+ @get:Rule
+ val rule = HiltAndroidRule(this)
+
+ @Test
+ fun verifyInjection() {
+ ActivityScenario.launch(TestActivity::class.java).use {
+ it.onActivity { activity ->
+ assertThat(activity.myAndroidViewModel).isNotNull()
+ assertThat(activity.myViewModel).isNotNull()
+ assertThat(activity.myInjectedViewModel).isNotNull()
+ }
+ }
+ }
+
+ @AndroidEntryPoint
+ class TestActivity : BaseActivity()
+
+ abstract class BaseActivity : FragmentActivity() {
+ val myAndroidViewModel by viewModels<MyAndroidViewModel>()
+ val myViewModel by viewModels<MyViewModel>()
+ val myInjectedViewModel by viewModels<MyInjectedViewModel>()
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/app/src/androidTest/java/dagger/hilt/android/simpleKotlin/viewmodel/BaseFragmentInjectionTest.kt b/javatests/artifacts/hilt-android/simpleKotlin/app/src/androidTest/java/dagger/hilt/android/simpleKotlin/viewmodel/BaseFragmentInjectionTest.kt
new file mode 100644
index 0000000..679a0d9
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/app/src/androidTest/java/dagger/hilt/android/simpleKotlin/viewmodel/BaseFragmentInjectionTest.kt
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simpleKotlin.viewmodel
+
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentActivity
+import androidx.fragment.app.viewModels
+import androidx.test.core.app.ActivityScenario
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.google.common.truth.Truth.assertThat
+import dagger.hilt.android.AndroidEntryPoint
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@HiltAndroidTest
+@RunWith(AndroidJUnit4::class)
+class BaseFragmentInjectionTest {
+
+ @get:Rule
+ val rule = HiltAndroidRule(this)
+
+ @Test
+ fun verifyInjection() {
+ ActivityScenario.launch(TestActivity::class.java).use {
+ it.onActivity { activity ->
+ val fragment = activity.supportFragmentManager.fragmentFactory.instantiate(
+ TestFragment::class.java.classLoader!!,
+ TestFragment::class.java.name
+ ) as TestFragment
+ activity.supportFragmentManager.beginTransaction()
+ .add(0, fragment, FragmentInjectionTest.FRAGMENT_TAG)
+ .commitNow()
+ assertThat(fragment.myAndroidViewModel).isNotNull()
+ assertThat(fragment.myViewModel).isNotNull()
+ assertThat(fragment.myInjectedViewModel).isNotNull()
+ }
+ }
+ }
+
+ @AndroidEntryPoint
+ class TestActivity : FragmentActivity()
+
+ @AndroidEntryPoint
+ class TestFragment : BaseFragment()
+
+ abstract class BaseFragment : Fragment() {
+ val myAndroidViewModel by viewModels<MyAndroidViewModel>()
+ val myViewModel by viewModels<MyViewModel>()
+ val myInjectedViewModel by viewModels<MyInjectedViewModel>()
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/app/src/androidTest/java/dagger/hilt/android/simpleKotlin/viewmodel/Bindings.kt b/javatests/artifacts/hilt-android/simpleKotlin/app/src/androidTest/java/dagger/hilt/android/simpleKotlin/viewmodel/Bindings.kt
new file mode 100644
index 0000000..480aea1
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/app/src/androidTest/java/dagger/hilt/android/simpleKotlin/viewmodel/Bindings.kt
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simpleKotlin.viewmodel
+
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Inject
+import javax.inject.Named
+
+class Foo @Inject constructor()
+
+class Bar
+
+@Module
+@InstallIn(SingletonComponent::class)
+object StringModule {
+ @Provides
+ @Named("SayMyName")
+ fun provide() = "Heisenberg"
+}
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/app/src/androidTest/java/dagger/hilt/android/simpleKotlin/viewmodel/FragmentInjectionTest.kt b/javatests/artifacts/hilt-android/simpleKotlin/app/src/androidTest/java/dagger/hilt/android/simpleKotlin/viewmodel/FragmentInjectionTest.kt
new file mode 100644
index 0000000..8d98e92
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/app/src/androidTest/java/dagger/hilt/android/simpleKotlin/viewmodel/FragmentInjectionTest.kt
@@ -0,0 +1,129 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simpleKotlin.viewmodel
+
+import android.os.Bundle
+import androidx.activity.viewModels
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentActivity
+import androidx.fragment.app.FragmentManager
+import androidx.fragment.app.activityViewModels
+import androidx.fragment.app.viewModels
+import androidx.test.core.app.ActivityScenario
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.filters.LargeTest
+import com.google.common.truth.Truth.assertThat
+import dagger.hilt.android.AndroidEntryPoint
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@LargeTest
+@HiltAndroidTest
+@RunWith(AndroidJUnit4::class)
+class FragmentInjectionTest {
+
+ @get:Rule
+ val rule = HiltAndroidRule(this)
+
+ @Test
+ fun verifyInjection() {
+ ActivityScenario.launch(TestActivity::class.java).use {
+ it.onActivity { activity ->
+ activity.addTestFragment()
+ activity.supportFragmentManager.findTestFragment().let { fragment ->
+ assertThat(fragment.myAndroidViewModel).isNotNull()
+ assertThat(fragment.myViewModel).isNotNull()
+ assertThat(fragment.myInjectedViewModel).isNotNull()
+ assertThat(fragment.myInjectedViewModelWithSavedState).isNotNull()
+ }
+ }
+ }
+ }
+
+ @Test
+ fun verifyActivityViewModelInjection() {
+ ActivityScenario.launch(TestActivity::class.java).use {
+ it.onActivity { activity ->
+ activity.addTestFragment()
+ activity.supportFragmentManager.findTestFragment().let { fragment ->
+ assertThat(fragment.myInjectedViewModel).isNotNull()
+ assertThat(fragment.myActivityLevelInjectedViewModel).isNotNull()
+ assertThat(fragment.myInjectedViewModel)
+ .isNotEqualTo(fragment.myActivityLevelInjectedViewModel)
+ assertThat(fragment.myActivityLevelInjectedViewModel)
+ .isEqualTo(activity.myInjectedViewModel)
+ }
+ activity.removeTestFragment()
+ activity.addTestFragment()
+ activity.supportFragmentManager.findTestFragment().let { fragment ->
+ assertThat(fragment.myInjectedViewModel).isNotNull()
+ assertThat(fragment.myActivityLevelInjectedViewModel).isNotNull()
+ assertThat(fragment.myInjectedViewModel)
+ .isNotEqualTo(fragment.myActivityLevelInjectedViewModel)
+ assertThat(fragment.myActivityLevelInjectedViewModel)
+ .isEqualTo(activity.myInjectedViewModel)
+ }
+ }
+ }
+ }
+
+ @AndroidEntryPoint
+ class TestActivity : FragmentActivity() {
+
+ val myInjectedViewModel by viewModels<MyInjectedViewModel>()
+
+ override fun onCreate(savedInstanceState: Bundle?) {
+ super.onCreate(savedInstanceState)
+ addTestFragment()
+ }
+
+ fun addTestFragment() {
+ val fragment = supportFragmentManager.fragmentFactory.instantiate(
+ TestFragment::class.java.classLoader!!,
+ TestFragment::class.java.name
+ )
+ supportFragmentManager.beginTransaction()
+ .add(0, fragment, FRAGMENT_TAG)
+ .commitNow()
+ }
+
+ fun removeTestFragment() {
+ supportFragmentManager.beginTransaction()
+ .remove(supportFragmentManager.findFragmentByTag(FRAGMENT_TAG)!!)
+ .commitNow()
+ }
+ }
+
+ @AndroidEntryPoint
+ class TestFragment : Fragment() {
+ val myAndroidViewModel by viewModels<MyAndroidViewModel>()
+ val myViewModel by viewModels<MyViewModel>()
+ val myInjectedViewModel by viewModels<MyInjectedViewModel>()
+ val myInjectedViewModelWithSavedState by viewModels<MyInjectedViewModelWithSavedState>()
+ val myActivityLevelInjectedViewModel by activityViewModels<MyInjectedViewModel>()
+ }
+
+ private fun FragmentManager.findTestFragment() =
+ findFragmentByTag(FRAGMENT_TAG) as TestFragment
+
+ companion object {
+ const val FRAGMENT_TAG = "tag"
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/app/src/androidTest/java/dagger/hilt/android/simpleKotlin/viewmodel/MyViewModels.kt b/javatests/artifacts/hilt-android/simpleKotlin/app/src/androidTest/java/dagger/hilt/android/simpleKotlin/viewmodel/MyViewModels.kt
new file mode 100644
index 0000000..c24c6b7
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/app/src/androidTest/java/dagger/hilt/android/simpleKotlin/viewmodel/MyViewModels.kt
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simpleKotlin.viewmodel
+
+import android.app.Application
+import androidx.lifecycle.AndroidViewModel
+import androidx.lifecycle.SavedStateHandle
+import androidx.lifecycle.ViewModel
+import dagger.hilt.android.lifecycle.HiltViewModel
+import javax.inject.Inject
+import javax.inject.Named
+
+class MyAndroidViewModel(app: Application) : AndroidViewModel(app)
+
+class MyViewModel() : ViewModel()
+
+@Suppress("UNUSED_PARAMETER")
+@HiltViewModel
+class MyInjectedViewModel @Inject constructor(
+ foo: Foo,
+ @Named("SayMyName") theName: String
+) : ViewModel()
+
+object TopClass {
+ @Suppress("UNUSED_PARAMETER")
+ @HiltViewModel
+ class MyNestedInjectedViewModel @Inject constructor(foo: Foo) : ViewModel()
+}
+
+@Suppress("UNUSED_PARAMETER")
+@HiltViewModel
+class MyInjectedViewModelWithSavedState @Inject constructor(
+ foo: Foo,
+ handle: SavedStateHandle
+) : ViewModel()
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/app/src/androidTest/java/dagger/hilt/android/simpleKotlin/viewmodel/ViewModelScopedTest.kt b/javatests/artifacts/hilt-android/simpleKotlin/app/src/androidTest/java/dagger/hilt/android/simpleKotlin/viewmodel/ViewModelScopedTest.kt
new file mode 100644
index 0000000..cdf6a65
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/app/src/androidTest/java/dagger/hilt/android/simpleKotlin/viewmodel/ViewModelScopedTest.kt
@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simpleKotlin.viewmodel
+
+import android.os.Bundle
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentActivity
+import androidx.fragment.app.FragmentManager
+import androidx.fragment.app.viewModels
+import androidx.lifecycle.ViewModel
+import androidx.test.core.app.ActivityScenario
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.google.common.truth.Truth.assertThat
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.android.AndroidEntryPoint
+import dagger.hilt.android.components.ViewModelComponent
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dagger.hilt.android.scopes.ViewModelScoped
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import javax.inject.Inject
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@HiltAndroidTest
+@RunWith(AndroidJUnit4::class)
+class ViewModelScopedTest {
+
+ @get:Rule
+ val rule = HiltAndroidRule(this)
+
+ @Test
+ fun testViewModelScopeInFragment() {
+ ActivityScenario.launch(TestActivity::class.java).use {
+ it.onActivity { activity ->
+ activity.supportFragmentManager.findTestFragment().let { fragment ->
+ val vm = fragment.vm
+ assertThat(vm.one.bar).isEqualTo(vm.two.bar)
+ }
+ }
+ }
+ }
+
+ @Module
+ @InstallIn(ViewModelComponent::class)
+ object ScopedModule {
+ @Provides
+ @ViewModelScoped
+ fun provideBar() = Bar()
+ }
+
+ @AndroidEntryPoint
+ class TestActivity : FragmentActivity() {
+ override fun onCreate(savedInstanceState: Bundle?) {
+ super.onCreate(savedInstanceState)
+
+ if (savedInstanceState == null) {
+ val fragment = supportFragmentManager.fragmentFactory.instantiate(
+ TestFragment::class.java.classLoader!!,
+ TestFragment::class.java.name
+ )
+ supportFragmentManager.beginTransaction()
+ .add(0, fragment, FRAGMENT_TAG)
+ .commitNow()
+ }
+ }
+ }
+
+ @AndroidEntryPoint
+ class TestFragment : Fragment() {
+ val vm by viewModels<TestViewModel>()
+ }
+
+ @HiltViewModel
+ class TestViewModel @Inject constructor(
+ val one: DependsOnBarOne,
+ val two: DependsOnBarTwo
+ ) : ViewModel()
+
+ class DependsOnBarOne @Inject constructor(val bar: Bar)
+ class DependsOnBarTwo @Inject constructor(val bar: Bar)
+
+ private fun FragmentManager.findTestFragment() =
+ findFragmentByTag(FRAGMENT_TAG) as TestFragment
+
+ companion object {
+ const val FRAGMENT_TAG = "tag"
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/app/src/debug/AndroidManifest.xml b/javatests/artifacts/hilt-android/simpleKotlin/app/src/debug/AndroidManifest.xml
new file mode 100644
index 0000000..0a0270e
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/app/src/debug/AndroidManifest.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ Copyright (C) 2020 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="dagger.hilt.android.simpleKotlin">
+
+ <application>
+ <activity android:name=".SimpleTest$TestActivity" android:exported="false"/>
+ <activity android:name=".viewmodel.ActivityInjectionTest$TestActivity" android:exported="false"/>
+ <activity android:name=".viewmodel.BaseActivityInjectionTest$TestActivity" android:exported="false"/>
+ <activity android:name=".viewmodel.FragmentInjectionTest$TestActivity" android:exported="false"/>
+ <activity android:name=".viewmodel.BaseFragmentInjectionTest$TestActivity" android:exported="false"/>
+ <activity android:name=".viewmodel.ViewModelScopedTest$TestActivity" android:exported="false"/>
+ </application>
+</manifest>
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/AndroidManifest.xml b/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..ca700b2
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/AndroidManifest.xml
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ Copyright (C) 2020 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="dagger.hilt.android.simpleKotlin">
+
+ <application
+ android:name=".KotlinApplication"
+ android:allowBackup="true"
+ android:label="@string/app_name"
+ android:supportsRtl="true"
+ android:theme="@style/Theme.AppCompat.Light">
+ <activity android:name=".MainActivity" android:exported="true">
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN" />
+
+ <category android:name="android.intent.category.LAUNCHER" />
+ </intent-filter>
+ </activity>
+ </application>
+</manifest>
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/java/dagger/hilt/android/simpleKotlin/ActivityRetainedModule.kt b/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/java/dagger/hilt/android/simpleKotlin/ActivityRetainedModule.kt
new file mode 100644
index 0000000..b830f31
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/java/dagger/hilt/android/simpleKotlin/ActivityRetainedModule.kt
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package dagger.hilt.android.simpleKotlin
+
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.android.components.ActivityRetainedComponent
+
+@Module
+@InstallIn(ActivityRetainedComponent::class)
+object ActivityRetainedModule {
+ @UserName
+ @Provides
+ fun provideUserName(): String {
+ return "Android User"
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/java/dagger/hilt/android/simpleKotlin/ApplicationModule.kt b/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/java/dagger/hilt/android/simpleKotlin/ApplicationModule.kt
new file mode 100644
index 0000000..59b79bb
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/java/dagger/hilt/android/simpleKotlin/ApplicationModule.kt
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simpleKotlin
+
+import android.os.Build
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+
+@Module
+@InstallIn(SingletonComponent::class)
+object ApplicationModule {
+ @Provides
+ @Model
+ fun provideModel(): String {
+ return Build.MODEL
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/java/dagger/hilt/android/simpleKotlin/DefinedStrings.kt b/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/java/dagger/hilt/android/simpleKotlin/DefinedStrings.kt
new file mode 100644
index 0000000..b22e588
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/java/dagger/hilt/android/simpleKotlin/DefinedStrings.kt
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2021 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package dagger.hilt.android.simpleKotlin
+
+object DefinedStrings {
+ internal val morningSweet = "Mallorca"
+ internal fun getInternalSweet() = "Sugar Donuts"
+}
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/java/dagger/hilt/android/simpleKotlin/KotlinApplication.kt b/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/java/dagger/hilt/android/simpleKotlin/KotlinApplication.kt
new file mode 100644
index 0000000..c638706
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/java/dagger/hilt/android/simpleKotlin/KotlinApplication.kt
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simpleKotlin
+
+import android.app.Application
+import dagger.hilt.android.HiltAndroidApp
+import javax.inject.Inject
+
+@HiltAndroidApp
+class KotlinApplication : Application() {
+ // Shows that we can inject ApplicationComponent bindings into an application.
+ @Inject
+ @Model
+ @JvmField
+ var model: String? = null
+}
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/java/dagger/hilt/android/simpleKotlin/MainActivity.kt b/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/java/dagger/hilt/android/simpleKotlin/MainActivity.kt
new file mode 100644
index 0000000..bd7f8a7
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/java/dagger/hilt/android/simpleKotlin/MainActivity.kt
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simpleKotlin
+
+import android.os.Bundle
+import android.view.View
+import android.widget.TextView
+import androidx.activity.viewModels
+import androidx.appcompat.app.AppCompatActivity
+import androidx.lifecycle.ViewModel
+import dagger.hilt.android.AndroidEntryPoint
+import dagger.hilt.android.lifecycle.HiltViewModel
+import javax.inject.Inject
+
+@AndroidEntryPoint
+class MainActivity : AppCompatActivity() {
+
+ val viewModel by viewModels<MainViewModel>()
+
+ override fun onCreate(savedInstanceState: Bundle?) {
+ super.onCreate(savedInstanceState)
+ setContentView(R.layout.activity_main)
+ val greeting = findViewById<View>(R.id.greeting) as TextView
+ val text = resources.getString(R.string.welcome, viewModel.name, viewModel.model)
+ greeting.text = text
+ }
+
+ // Shows that we can inject bindings into a ViewModel
+ @HiltViewModel
+ class MainViewModel @Inject constructor(
+ @Model val model: String,
+ @UserName val name: String
+ ) : ViewModel()
+}
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/java/dagger/hilt/android/simpleKotlin/Model.kt b/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/java/dagger/hilt/android/simpleKotlin/Model.kt
new file mode 100644
index 0000000..7e7e9ae
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/java/dagger/hilt/android/simpleKotlin/Model.kt
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simpleKotlin
+
+import javax.inject.Qualifier
+
+/** Qualifies bindings relating to [android.os.Build.MODEL]. */
+@Qualifier
+@Retention(AnnotationRetention.RUNTIME)
+internal annotation class Model
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/java/dagger/hilt/android/simpleKotlin/UserName.kt b/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/java/dagger/hilt/android/simpleKotlin/UserName.kt
new file mode 100644
index 0000000..352e48c
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/java/dagger/hilt/android/simpleKotlin/UserName.kt
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simpleKotlin
+
+import javax.inject.Qualifier
+
+/** Qualifies bindings relating to the user name. */
+@Qualifier
+@Retention(AnnotationRetention.RUNTIME)
+internal annotation class UserName
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/res/layout/activity_main.xml b/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/res/layout/activity_main.xml
new file mode 100644
index 0000000..0d7637d
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/res/layout/activity_main.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ Copyright (C) 2020 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+ android:layout_width="match_parent"
+ android:layout_height="match_parent"
+ android:background="@android:color/background_light">
+
+ <TextView
+ android:id="@+id/greeting"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:layout_alignParentTop="true"
+ android:textColor="@android:color/primary_text_light"
+ />
+</RelativeLayout>
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/res/values/strings.xml b/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/res/values/strings.xml
new file mode 100644
index 0000000..c1e4f27
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/app/src/main/res/values/strings.xml
@@ -0,0 +1,23 @@
+<!--
+ ~ Copyright (C) 2020 The Dagger Authors.
+ ~
+ ~ Licensed under the Apache License, Version 2.0 (the "License");
+ ~ you may not use this file except in compliance with the License.
+ ~ You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ -->
+
+<resources>
+ <!--The app name [CHAR_LIMIT=40]-->
+ <string name="app_name">Simple Hilt Kotlin Android App</string>
+
+ <!--The greeting message [CHAR_LIMIT=100]-->
+ <string name="welcome">Hello, %1$s! You are on build %2$s.</string>
+</resources>
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/app/src/sharedTest/java/dagger/hilt/android/simpleKotlin/InternalAccessTest.kt b/javatests/artifacts/hilt-android/simpleKotlin/app/src/sharedTest/java/dagger/hilt/android/simpleKotlin/InternalAccessTest.kt
new file mode 100644
index 0000000..43a1abc
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/app/src/sharedTest/java/dagger/hilt/android/simpleKotlin/InternalAccessTest.kt
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2021 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package dagger.hilt.android.simpleKotlin
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * Verifies internal Kotlin classes are accessible with classpath aggregation.
+ */
+@RunWith(AndroidJUnit4::class)
+class InternalAccessTest {
+ @Test
+ fun verifyInternalMembersAreAccessible() {
+ assertThat(DefinedStrings.morningSweet).isNotNull()
+ assertThat(DefinedStrings.getInternalSweet()).isNotNull()
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/app/src/sharedTest/java/dagger/hilt/android/simpleKotlin/TransitiveDependenciesTest.kt b/javatests/artifacts/hilt-android/simpleKotlin/app/src/sharedTest/java/dagger/hilt/android/simpleKotlin/TransitiveDependenciesTest.kt
new file mode 100644
index 0000000..10e6515
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/app/src/sharedTest/java/dagger/hilt/android/simpleKotlin/TransitiveDependenciesTest.kt
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package dagger.hilt.android.simpleKotlin
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import dagger.hilt.android.simpleKotlin.lib.AndroidLibraryEntryPoints
+import dagger.hilt.android.simpleKotlin.lib.KotlinLibraryEntryPoints
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * Tests that entry points in deep dependencies with `implementation` boundaries are available at
+ * runtime.
+ */
+@HiltAndroidTest
+@RunWith(AndroidJUnit4::class)
+class TransitiveDependenciesTest {
+ @get:Rule
+ val rule = HiltAndroidRule(this)
+
+ @Test
+ fun testEntryPointFromAndroidLib() {
+ AndroidLibraryEntryPoints.invokeEntryPoints(
+ InstrumentationRegistry.getInstrumentation().targetContext.applicationContext
+ )
+ }
+
+ @Test
+ fun testEntryPointFromKotlinLib() {
+ KotlinLibraryEntryPoints.invokeEntryPoints(
+ InstrumentationRegistry.getInstrumentation().targetContext.applicationContext
+ )
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/app/src/test/java/dagger/hilt/android/simpleKotlin/SimpleTest.kt b/javatests/artifacts/hilt-android/simpleKotlin/app/src/test/java/dagger/hilt/android/simpleKotlin/SimpleTest.kt
new file mode 100644
index 0000000..1e04606
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/app/src/test/java/dagger/hilt/android/simpleKotlin/SimpleTest.kt
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simpleKotlin
+
+import android.os.Build
+import androidx.appcompat.app.AppCompatActivity
+import androidx.test.core.app.ActivityScenario
+import com.google.common.truth.Truth.assertThat
+import dagger.hilt.android.AndroidEntryPoint
+import dagger.hilt.android.testing.BindValue
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import dagger.hilt.android.testing.HiltTestApplication
+import javax.inject.Inject
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+/**
+ * Example local unit test, which will execute on the development machine (host).
+ *
+ * See [testing documentation](http://d.android.com/tools/testing).
+ */
+@HiltAndroidTest
+@RunWith(RobolectricTestRunner::class)
+// Robolectric requires Java9 to run API 29 and above, so use API 28 instead
+@Config(sdk = [Build.VERSION_CODES.P], application = HiltTestApplication::class)
+class SimpleTest {
+ @get:Rule val rule = HiltAndroidRule(this)
+
+ @BindValue val bindStr = "STRING_BINDING"
+
+ @Inject @JvmField
+ var str: String? = null
+
+ @AndroidEntryPoint
+ class TestActivity : AppCompatActivity()
+
+ @Test
+ fun testBindValue() {
+ assertThat(str).isNull()
+ rule.inject()
+ assertThat(str).isEqualTo(bindStr)
+ }
+
+ @Test
+ fun verifyMainActivity() {
+ ActivityScenario.launch(MainActivity::class.java).use { scenario ->
+ scenario.onActivity { activity ->
+ assertThat(activity::class.java.getSuperclass()?.getSimpleName())
+ .isEqualTo("Hilt_MainActivity")
+ assertThat(activity.viewModel.model).isNotNull()
+ assertThat(activity.viewModel.name).isNotNull()
+ }
+ }
+ }
+
+ @Test
+ fun verifyTestActivity() {
+ ActivityScenario.launch(TestActivity::class.java).use { scenario ->
+ scenario.onActivity { activity ->
+ assertThat(activity::class.java.getSuperclass()?.getSimpleName())
+ .isEqualTo("Hilt_SimpleTest_TestActivity")
+ }
+ }
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/app/src/test/resources/dagger/hilt/android/simpleKotlin/robolectric.properties b/javatests/artifacts/hilt-android/simpleKotlin/app/src/test/resources/dagger/hilt/android/simpleKotlin/robolectric.properties
new file mode 100644
index 0000000..0234ffe
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/app/src/test/resources/dagger/hilt/android/simpleKotlin/robolectric.properties
@@ -0,0 +1,2 @@
+sdk=28
+application=dagger.hilt.android.testing.HiltTestApplication
\ No newline at end of file
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/build.gradle b/javatests/artifacts/hilt-android/simpleKotlin/build.gradle
new file mode 100644
index 0000000..d594476
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/build.gradle
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+buildscript {
+ ext {
+ kotlin_version = '1.3.61'
+ agp_version = System.getenv('AGP_VERSION') ?: "4.2.0-beta04"
+ }
+ repositories {
+ google()
+ jcenter()
+ mavenLocal()
+ }
+ dependencies {
+ classpath "com.android.tools.build:gradle:$agp_version"
+ classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+ classpath 'com.google.dagger:hilt-android-gradle-plugin:LOCAL-SNAPSHOT'
+ }
+}
+
+allprojects {
+ repositories {
+ google()
+ jcenter()
+ mavenCentral()
+ mavenLocal()
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/deep-android-lib/build.gradle b/javatests/artifacts/hilt-android/simpleKotlin/deep-android-lib/build.gradle
new file mode 100644
index 0000000..3a1923a
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/deep-android-lib/build.gradle
@@ -0,0 +1,46 @@
+plugins {
+ id 'com.android.library'
+ id 'kotlin-android'
+ id 'kotlin-kapt'
+ id 'dagger.hilt.android.plugin'
+}
+
+android {
+ compileSdkVersion 30
+ buildToolsVersion "30.0.2"
+
+ defaultConfig {
+ minSdkVersion 15
+ targetSdkVersion 30
+ versionCode 1
+ versionName "1.0"
+
+ testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+ }
+ compileOptions {
+ sourceCompatibility JavaVersion.VERSION_1_8
+ targetCompatibility JavaVersion.VERSION_1_8
+ }
+ kotlinOptions {
+ jvmTarget = '1.8'
+ }
+ lintOptions {
+ checkReleaseBuilds = false
+ }
+}
+
+dependencies {
+ implementation 'com.google.dagger:hilt-android:LOCAL-SNAPSHOT'
+ kapt 'com.google.dagger:hilt-compiler:LOCAL-SNAPSHOT'
+
+ testImplementation 'androidx.test.ext:junit:1.1.2'
+ testImplementation 'com.google.truth:truth:1.0.1'
+
+ androidTestImplementation 'androidx.test.ext:junit:1.1.2'
+ androidTestImplementation 'androidx.test:runner:1.3.0'
+ androidTestImplementation 'com.google.truth:truth:1.0.1'
+}
+
+hilt {
+ enableExperimentalClasspathAggregation = true
+}
\ No newline at end of file
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/deep-android-lib/src/androidTest/java/dagger/hilt/android/simpleKotlin/deep/InternalAccessEmulatorTest.kt b/javatests/artifacts/hilt-android/simpleKotlin/deep-android-lib/src/androidTest/java/dagger/hilt/android/simpleKotlin/deep/InternalAccessEmulatorTest.kt
new file mode 100644
index 0000000..4ea4c09
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/deep-android-lib/src/androidTest/java/dagger/hilt/android/simpleKotlin/deep/InternalAccessEmulatorTest.kt
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2021 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package dagger.hilt.android.simpleKotlin.deep
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * Verifies internal Kotlin classes are accessible with classpath aggregation in Android library.
+ */
+@RunWith(AndroidJUnit4::class)
+class InternalAccessEmulatorTest {
+ @Test
+ fun verifyInternalMembersAreAccessible() {
+ assertThat(DeepAndroidLib.internalFunction()).isNotNull()
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/deep-android-lib/src/main/AndroidManifest.xml b/javatests/artifacts/hilt-android/simpleKotlin/deep-android-lib/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..ae2a5e3
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/deep-android-lib/src/main/AndroidManifest.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="dagger.hilt.android.simpleKotlin.deep">
+
+</manifest>
\ No newline at end of file
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/deep-android-lib/src/main/java/dagger/hilt/android/simpleKotlin/deep/DeepAndroidLib.kt b/javatests/artifacts/hilt-android/simpleKotlin/deep-android-lib/src/main/java/dagger/hilt/android/simpleKotlin/deep/DeepAndroidLib.kt
new file mode 100644
index 0000000..a2fcb73
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/deep-android-lib/src/main/java/dagger/hilt/android/simpleKotlin/deep/DeepAndroidLib.kt
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.simpleKotlin.deep
+
+import android.content.Context
+import dagger.hilt.EntryPoint
+import dagger.hilt.InstallIn
+import dagger.hilt.android.EntryPointAccessors
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Inject
+
+class DeepAndroidLib @Inject constructor() {
+ @EntryPoint
+ @InstallIn(SingletonComponent::class)
+ internal interface LibEntryPoint {
+ fun getDeepAndroidInstance(): DeepAndroidLib
+ }
+
+ companion object {
+ fun getInstance(context: Context) =
+ EntryPointAccessors.fromApplication(context, LibEntryPoint::class.java)
+ .getDeepAndroidInstance()
+
+ internal fun internalFunction() = Any()
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/deep-android-lib/src/test/java/dagger/hilt/android/simpleKotlin/deep/InternalAccessLocalTest.kt b/javatests/artifacts/hilt-android/simpleKotlin/deep-android-lib/src/test/java/dagger/hilt/android/simpleKotlin/deep/InternalAccessLocalTest.kt
new file mode 100644
index 0000000..508e7d5
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/deep-android-lib/src/test/java/dagger/hilt/android/simpleKotlin/deep/InternalAccessLocalTest.kt
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2021 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package dagger.hilt.android.simpleKotlin.deep
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+
+/**
+ * Verifies internal Kotlin classes are accessible with classpath aggregation in Android library.
+ */
+class InternalAccessLocalTest {
+ @Test
+ fun verifyInternalMembersAreAccessible() {
+ assertThat(DeepAndroidLib.internalFunction()).isNotNull()
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/deep-kotlin-lib/build.gradle b/javatests/artifacts/hilt-android/simpleKotlin/deep-kotlin-lib/build.gradle
new file mode 100644
index 0000000..306c171
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/deep-kotlin-lib/build.gradle
@@ -0,0 +1,16 @@
+plugins {
+ id 'java-library'
+ id 'kotlin'
+ id 'kotlin-kapt'
+}
+
+java {
+ sourceCompatibility = JavaVersion.VERSION_1_8
+ targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+dependencies {
+ implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+ implementation "com.google.dagger:hilt-core:LOCAL-SNAPSHOT"
+ kapt "com.google.dagger:hilt-compiler:LOCAL-SNAPSHOT"
+}
\ No newline at end of file
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/deep-kotlin-lib/src/main/java/dagger/hilt/android/simpleKotlin/deep/DeepLib.kt b/javatests/artifacts/hilt-android/simpleKotlin/deep-kotlin-lib/src/main/java/dagger/hilt/android/simpleKotlin/deep/DeepLib.kt
new file mode 100644
index 0000000..0d2bc61
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/deep-kotlin-lib/src/main/java/dagger/hilt/android/simpleKotlin/deep/DeepLib.kt
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package dagger.hilt.android.simpleKotlin.deep
+
+import dagger.hilt.EntryPoint
+import dagger.hilt.EntryPoints
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Inject
+
+class DeepLib @Inject constructor() {
+ @EntryPoint
+ @InstallIn(SingletonComponent::class)
+ internal interface LibEntryPoint {
+ fun getDeepInstance(): DeepLib
+ }
+
+ companion object {
+ fun getInstance(componentManager: Any) =
+ EntryPoints.get(componentManager, LibEntryPoint::class.java)
+ .getDeepInstance()
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/gradle.properties b/javatests/artifacts/hilt-android/simpleKotlin/gradle.properties
new file mode 100644
index 0000000..646c51b
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/gradle.properties
@@ -0,0 +1,2 @@
+android.useAndroidX=true
+android.enableJetifier=true
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/gradle/wrapper/gradle-wrapper.jar b/javatests/artifacts/hilt-android/simpleKotlin/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000..5c2d1cf
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/gradle/wrapper/gradle-wrapper.jar
Binary files differ
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/gradle/wrapper/gradle-wrapper.properties b/javatests/artifacts/hilt-android/simpleKotlin/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000..4d9ca16
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.7.1-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/gradlew b/javatests/artifacts/hilt-android/simpleKotlin/gradlew
new file mode 100755
index 0000000..b0d6d0a
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/gradlew
@@ -0,0 +1,188 @@
+#!/usr/bin/env sh
+
+#
+# Copyright 2015 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+##
+## Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+ ls=`ls -ld "$PRG"`
+ link=`expr "$ls" : '.*-> \(.*\)$'`
+ if expr "$link" : '/.*' > /dev/null; then
+ PRG="$link"
+ else
+ PRG=`dirname "$PRG"`"/$link"
+ fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+ echo "$*"
+}
+
+die () {
+ echo
+ echo "$*"
+ echo
+ exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+ CYGWIN* )
+ cygwin=true
+ ;;
+ Darwin* )
+ darwin=true
+ ;;
+ MINGW* )
+ msys=true
+ ;;
+ NONSTOP* )
+ nonstop=true
+ ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+ if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+ # IBM's JDK on AIX uses strange locations for the executables
+ JAVACMD="$JAVA_HOME/jre/sh/java"
+ else
+ JAVACMD="$JAVA_HOME/bin/java"
+ fi
+ if [ ! -x "$JAVACMD" ] ; then
+ die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+ fi
+else
+ JAVACMD="java"
+ which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+ MAX_FD_LIMIT=`ulimit -H -n`
+ if [ $? -eq 0 ] ; then
+ if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+ MAX_FD="$MAX_FD_LIMIT"
+ fi
+ ulimit -n $MAX_FD
+ if [ $? -ne 0 ] ; then
+ warn "Could not set maximum file descriptor limit: $MAX_FD"
+ fi
+ else
+ warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+ fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+ GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+ APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+ CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+ JAVACMD=`cygpath --unix "$JAVACMD"`
+
+ # We build the pattern for arguments to be converted via cygpath
+ ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+ SEP=""
+ for dir in $ROOTDIRSRAW ; do
+ ROOTDIRS="$ROOTDIRS$SEP$dir"
+ SEP="|"
+ done
+ OURCYGPATTERN="(^($ROOTDIRS))"
+ # Add a user-defined pattern to the cygpath arguments
+ if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+ OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+ fi
+ # Now convert the arguments - kludge to limit ourselves to /bin/sh
+ i=0
+ for arg in "$@" ; do
+ CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+ CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
+
+ if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
+ eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+ else
+ eval `echo args$i`="\"$arg\""
+ fi
+ i=$((i+1))
+ done
+ case $i in
+ (0) set -- ;;
+ (1) set -- "$args0" ;;
+ (2) set -- "$args0" "$args1" ;;
+ (3) set -- "$args0" "$args1" "$args2" ;;
+ (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+ (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+ (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+ (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+ (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+ (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+ esac
+fi
+
+# Escape application args
+save () {
+ for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+ echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+ cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/kotlin-library/build.gradle b/javatests/artifacts/hilt-android/simpleKotlin/kotlin-library/build.gradle
new file mode 100644
index 0000000..7c8462f
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/kotlin-library/build.gradle
@@ -0,0 +1,17 @@
+plugins {
+ id 'java-library'
+ id 'kotlin'
+ id 'kotlin-kapt'
+}
+
+java {
+ sourceCompatibility = JavaVersion.VERSION_1_8
+ targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+dependencies {
+ implementation project(':deep-kotlin-lib')
+ implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+ implementation "com.google.dagger:hilt-core:LOCAL-SNAPSHOT"
+ kapt "com.google.dagger:hilt-compiler:LOCAL-SNAPSHOT"
+}
\ No newline at end of file
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/kotlin-library/src/main/java/dagger/hilt/android/simpleKotlin/lib/KotlinLibraryEntryPoints.kt b/javatests/artifacts/hilt-android/simpleKotlin/kotlin-library/src/main/java/dagger/hilt/android/simpleKotlin/lib/KotlinLibraryEntryPoints.kt
new file mode 100644
index 0000000..8989ebb
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/kotlin-library/src/main/java/dagger/hilt/android/simpleKotlin/lib/KotlinLibraryEntryPoints.kt
@@ -0,0 +1,9 @@
+package dagger.hilt.android.simpleKotlin.lib
+
+import dagger.hilt.android.simpleKotlin.deep.DeepLib
+
+object KotlinLibraryEntryPoints {
+ fun invokeEntryPoints(component: Any) {
+ DeepLib.getInstance(component)
+ }
+}
diff --git a/javatests/artifacts/hilt-android/simpleKotlin/settings.gradle b/javatests/artifacts/hilt-android/simpleKotlin/settings.gradle
new file mode 100644
index 0000000..cea0913
--- /dev/null
+++ b/javatests/artifacts/hilt-android/simpleKotlin/settings.gradle
@@ -0,0 +1,6 @@
+rootProject.name='Simple Kotlin Hilt Android'
+include ':app'
+include ':android-library'
+include ':kotlin-library'
+include ':deep-android-lib'
+include ':deep-kotlin-lib'
diff --git a/javatests/dagger/BUILD b/javatests/dagger/BUILD
index 3debec5..c6ab360 100644
--- a/javatests/dagger/BUILD
+++ b/javatests/dagger/BUILD
@@ -15,11 +15,11 @@
# Description:
# A JSR-330 compliant dependency injection system for android and java
-package(default_visibility = ["//:src"])
-
load("//:build_defs.bzl", "DOCLINT_HTML_AND_SYNTAX", "DOCLINT_REFERENCES")
load("//:test_defs.bzl", "GenJavaTests")
+package(default_visibility = ["//:src"])
+
GenJavaTests(
name = "core_tests",
srcs = glob(["**/*.java"]),
@@ -27,7 +27,8 @@
javacopts = DOCLINT_HTML_AND_SYNTAX + DOCLINT_REFERENCES,
deps = [
"//java/dagger:core",
- "@google_bazel_common//third_party/java/guava",
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/internal/guava:concurrent",
"@google_bazel_common//third_party/java/jsr330_inject",
"@google_bazel_common//third_party/java/junit",
"@google_bazel_common//third_party/java/truth",
diff --git a/javatests/dagger/android/AndroidInjectionTest.java b/javatests/dagger/android/AndroidInjectionTest.java
index 19b6e84..7e60ebd 100644
--- a/javatests/dagger/android/AndroidInjectionTest.java
+++ b/javatests/dagger/android/AndroidInjectionTest.java
@@ -18,6 +18,7 @@
import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.fail;
+import static org.robolectric.annotation.LooperMode.Mode.LEGACY;
import android.app.Activity;
import android.app.Application;
@@ -27,9 +28,10 @@
import org.robolectric.Robolectric;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.annotation.Config;
+import org.robolectric.annotation.LooperMode;
import org.robolectric.util.FragmentTestUtil;
-@Config(manifest = Config.NONE)
+@LooperMode(LEGACY)
@RunWith(RobolectricTestRunner.class)
public final class AndroidInjectionTest {
@@ -39,7 +41,7 @@
String tag;
}
- private static AndroidInjector<Fragment> fakeFragmentInjector(String tag) {
+ private static AndroidInjector<Object> fakeFragmentInjector(String tag) {
return instance -> {
if (instance instanceof InjectableFragment) {
((InjectableFragment) instance).tag = tag;
@@ -47,15 +49,14 @@
};
}
- public static class ApplicationInjectsFragment extends Application
- implements HasFragmentInjector {
+ public static class ApplicationInjectsFragment extends Application implements HasAndroidInjector {
@Override
- public AndroidInjector<Fragment> fragmentInjector() {
+ public AndroidInjector<Object> androidInjector() {
return fakeFragmentInjector("injected by app");
}
}
- @Config(manifest = Config.NONE, application = ApplicationInjectsFragment.class)
+ @Config(application = ApplicationInjectsFragment.class)
@Test
public void fragmentInjectedByApplication() {
Activity activity = Robolectric.setupActivity(Activity.class);
@@ -67,14 +68,14 @@
assertThat(fragment.tag).isEqualTo("injected by app");
}
- public static class ActivityInjectsFragment extends Activity implements HasFragmentInjector {
+ public static class ActivityInjectsFragment extends Activity implements HasAndroidInjector {
@Override
- public AndroidInjector<Fragment> fragmentInjector() {
+ public AndroidInjector<Object> androidInjector() {
return fakeFragmentInjector("injected by activity");
}
}
- @Config(manifest = Config.NONE, application = ApplicationInjectsFragment.class)
+ @Config(application = ApplicationInjectsFragment.class)
@Test
public void fragmentInjectedByActivity() {
ActivityInjectsFragment activity = Robolectric.setupActivity(ActivityInjectsFragment.class);
@@ -87,14 +88,14 @@
}
public static class ParentFragmentInjectsChildFragment extends Fragment
- implements HasFragmentInjector {
+ implements HasAndroidInjector {
@Override
- public AndroidInjector<Fragment> fragmentInjector() {
+ public AndroidInjector<Object> androidInjector() {
return fakeFragmentInjector("injected by parent fragment");
}
}
- @Config(manifest = Config.NONE, application = ApplicationInjectsFragment.class)
+ @Config(application = ApplicationInjectsFragment.class)
@Test
public void fragmentInjectedByParentFragment() {
ActivityInjectsFragment activity = Robolectric.setupActivity(ActivityInjectsFragment.class);
@@ -113,7 +114,7 @@
}
@Test
- public void injectActivity_applicationDoesntImplementHasActivityInjector() {
+ public void injectActivity_applicationDoesntImplementHasAndroidInjector() {
Activity activity = Robolectric.setupActivity(Activity.class);
try {
@@ -139,21 +140,15 @@
}
}
- private static class ApplicationReturnsNull extends Application
- implements HasActivityInjector, HasFragmentInjector {
+ private static class ApplicationReturnsNull extends Application implements HasAndroidInjector {
@Override
- public AndroidInjector<Activity> activityInjector() {
- return null;
- }
-
- @Override
- public AndroidInjector<Fragment> fragmentInjector() {
+ public AndroidInjector<Object> androidInjector() {
return null;
}
}
@Test
- @Config(manifest = Config.NONE, application = ApplicationReturnsNull.class)
+ @Config(application = ApplicationReturnsNull.class)
public void activityInjector_returnsNull() {
Activity activity = Robolectric.setupActivity(Activity.class);
@@ -161,12 +156,12 @@
AndroidInjection.inject(activity);
fail();
} catch (Exception e) {
- assertThat(e).hasMessageThat().contains("activityInjector() returned null");
+ assertThat(e).hasMessageThat().contains("androidInjector() returned null");
}
}
@Test
- @Config(manifest = Config.NONE, application = ApplicationReturnsNull.class)
+ @Config(application = ApplicationReturnsNull.class)
public void fragmentInjector_returnsNull() {
Fragment fragment = new Fragment();
FragmentTestUtil.startFragment(fragment);
@@ -175,7 +170,7 @@
AndroidInjection.inject(fragment);
fail();
} catch (Exception e) {
- assertThat(e).hasMessageThat().contains("fragmentInjector() returned null");
+ assertThat(e).hasMessageThat().contains("androidInjector() returned null");
}
}
diff --git a/javatests/dagger/android/AndroidProguardTest.java b/javatests/dagger/android/AndroidProguardTest.java
new file mode 100644
index 0000000..0f51e49
--- /dev/null
+++ b/javatests/dagger/android/AndroidProguardTest.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.android;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import dagger.android.internal.AndroidInjectionKeys;
+import java.net.URL;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+
+@RunWith(RobolectricTestRunner.class)
+public class AndroidProguardTest {
+
+ @Test
+ public void checkLegacyProguardRules() {
+ URL resUrl =
+ AndroidInjectionKeys.class
+ .getClassLoader()
+ .getResource("META-INF/proguard/dagger-android.pro");
+ assertThat(resUrl).isNotNull();
+ }
+
+ // The com.android.tools files are only used outside Google, in Gradle projects.
+ @Test
+ public void checkProguardRules() {
+ URL resUrl =
+ AndroidInjectionKeys.class
+ .getClassLoader()
+ .getResource("META-INF/com.android.tools/proguard/dagger-android.pro");
+ assertThat(resUrl).isNotNull();
+ }
+
+ @Test
+ public void checkR8Rules() {
+ URL resUrl =
+ AndroidInjectionKeys.class
+ .getClassLoader()
+ .getResource("META-INF/com.android.tools/r8/dagger-android.pro");
+ assertThat(resUrl).isNotNull();
+ }
+}
diff --git a/javatests/dagger/android/BUILD b/javatests/dagger/android/BUILD
index 5bc3f45..38efb3a 100644
--- a/javatests/dagger/android/BUILD
+++ b/javatests/dagger/android/BUILD
@@ -15,11 +15,11 @@
# Description:
# Tests for Dagger's Android integrations
-package(default_visibility = ["//:src"])
-
load("//:build_defs.bzl", "DOCLINT_HTML_AND_SYNTAX")
load("//:test_defs.bzl", "GenRobolectricTests")
+package(default_visibility = ["//:src"])
+
GenRobolectricTests(
name = "android_tests",
srcs = glob(["*.java"]),
@@ -29,7 +29,7 @@
deps = [
"//:dagger_with_compiler",
"//java/dagger/android",
- "@google_bazel_common//third_party/java/guava",
+ "//java/dagger/internal/guava:collect",
"@google_bazel_common//third_party/java/junit",
"@google_bazel_common//third_party/java/truth",
],
diff --git a/javatests/dagger/android/DispatchingAndroidInjectorTest.java b/javatests/dagger/android/DispatchingAndroidInjectorTest.java
index d0306b8..37d3d61 100644
--- a/javatests/dagger/android/DispatchingAndroidInjectorTest.java
+++ b/javatests/dagger/android/DispatchingAndroidInjectorTest.java
@@ -29,9 +29,7 @@
import org.junit.runner.RunWith;
import org.robolectric.Robolectric;
import org.robolectric.RobolectricTestRunner;
-import org.robolectric.annotation.Config;
-@Config(manifest = Config.NONE)
@RunWith(RobolectricTestRunner.class)
public final class DispatchingAndroidInjectorTest {
@Test
diff --git a/javatests/dagger/android/processor/AndroidProcessorTest.java b/javatests/dagger/android/processor/AndroidProcessorTest.java
deleted file mode 100644
index 1a45bdd..0000000
--- a/javatests/dagger/android/processor/AndroidProcessorTest.java
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * Copyright (C) 2017 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.android.processor;
-
-import static com.google.common.truth.Truth8.assertThat;
-import static com.google.testing.compile.CompilationSubject.assertThat;
-import static com.google.testing.compile.Compiler.javac;
-import static javax.tools.StandardLocation.CLASS_OUTPUT;
-
-import com.google.testing.compile.Compilation;
-import com.google.testing.compile.JavaFileObjects;
-import javax.tools.JavaFileObject;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-@RunWith(JUnit4.class)
-public final class AndroidProcessorTest {
- @Test
- public void generatedProguardFile() {
- JavaFileObject module =
- JavaFileObjects.forSourceLines(
- "test.TestModule",
- "package test;",
- "",
- "import dagger.android.AndroidInjectionKey;",
- "import dagger.Module;",
- "import dagger.multibindings.IntoMap;",
- "import dagger.Provides;",
- "",
- "@Module",
- "class TestModule {",
- " @Provides",
- " @IntoMap",
- " @AndroidInjectionKey(\"test.TestActivity\")",
- " static int i() { ",
- " return 1;",
- " }",
- "}");
- Compilation enabled =
- javac()
- .withProcessors(new AndroidProcessor())
- .withOptions("-Adagger.android.experimentalUseStringKeys=true")
- .compile(module);
- assertThat(enabled).succeeded();
- assertThat(enabled)
- .generatedFile(CLASS_OUTPUT, "META-INF/proguard/dagger.android.AndroidInjectionKeys");
-
- Compilation disabled =
- javac()
- .withProcessors(new AndroidProcessor())
- .withOptions("-Adagger.android.experimentalUseStringKeys=false")
- .compile(module);
- assertThat(disabled).succeeded();
- assertThat(
- disabled.generatedFile(
- CLASS_OUTPUT, "META-INF/proguard/dagger.android.AndroidInjectionKeys"))
- .isEmpty();
-
- Compilation noFlag = javac().withProcessors(new AndroidProcessor()).compile(module);
- assertThat(noFlag).succeeded();
- assertThat(
- noFlag.generatedFile(
- CLASS_OUTPUT, "META-INF/proguard/dagger.android.AndroidInjectionKeys"))
- .isEmpty();
- }
-}
diff --git a/javatests/dagger/android/processor/BUILD b/javatests/dagger/android/processor/BUILD
index 8a9c16e..d7b210c 100644
--- a/javatests/dagger/android/processor/BUILD
+++ b/javatests/dagger/android/processor/BUILD
@@ -15,28 +15,27 @@
# Description:
# Tests for Dagger's Android integrations
-package(default_visibility = ["//:src"])
-
load("//:build_defs.bzl", "DOCLINT_HTML_AND_SYNTAX")
load("//:test_defs.bzl", "GenJavaTests")
+package(default_visibility = ["//:src"])
+
GenJavaTests(
name = "android_processor_tests",
srcs = glob(["*.java"]),
functional = False,
javacopts = DOCLINT_HTML_AND_SYNTAX,
deps = [
- "@google_bazel_common//third_party/java/guava",
- "@androidsdk//com.android.support:support-fragment-25.0.0",
- # TODO(ronshapiro): create a common location to define the current Android version
- "@androidsdk//:platforms/android-26/android.jar",
- "@google_bazel_common//third_party/java/compile_testing",
"//:dagger_with_compiler",
- "@google_bazel_common//third_party/java/junit",
- "@google_bazel_common//third_party/java/truth",
- "@google_bazel_common//third_party/java/truth:truth8",
"//java/dagger/android",
"//java/dagger/android/processor",
"//java/dagger/internal/codegen:processor",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "@androidsdk//:platforms/android-30/android.jar",
+ "@google_bazel_common//third_party/java/compile_testing",
+ "@google_bazel_common//third_party/java/junit",
+ "@google_bazel_common//third_party/java/truth",
+ "@maven//:androidx_fragment_fragment",
],
)
diff --git a/javatests/dagger/android/support/AndroidSupportInjectionTest.java b/javatests/dagger/android/support/AndroidSupportInjectionTest.java
index 51e9992..25c5e94 100644
--- a/javatests/dagger/android/support/AndroidSupportInjectionTest.java
+++ b/javatests/dagger/android/support/AndroidSupportInjectionTest.java
@@ -20,15 +20,15 @@
import static org.junit.Assert.fail;
import android.app.Application;
-import android.support.v4.app.Fragment;
+import androidx.fragment.app.Fragment;
import dagger.android.AndroidInjector;
+import dagger.android.HasAndroidInjector;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.annotation.Config;
import org.robolectric.shadows.support.v4.SupportFragmentTestUtil;
-@Config(manifest = Config.NONE)
@RunWith(RobolectricTestRunner.class)
public final class AndroidSupportInjectionTest {
@Test
@@ -45,15 +45,15 @@
}
private static class ApplicationReturnsNull extends Application
- implements HasSupportFragmentInjector {
+ implements HasAndroidInjector {
@Override
- public AndroidInjector<Fragment> supportFragmentInjector() {
+ public AndroidInjector<Object> androidInjector() {
return null;
}
}
@Test
- @Config(manifest = Config.NONE, application = ApplicationReturnsNull.class)
+ @Config(application = ApplicationReturnsNull.class)
public void fragmentInjector_returnsNull() {
Fragment fragment = new Fragment();
SupportFragmentTestUtil.startFragment(fragment);
@@ -62,7 +62,7 @@
AndroidSupportInjection.inject(fragment);
fail();
} catch (Exception e) {
- assertThat(e).hasMessageThat().contains("supportFragmentInjector() returned null");
+ assertThat(e).hasMessageThat().contains("androidInjector() returned null");
}
}
diff --git a/javatests/dagger/android/support/BUILD b/javatests/dagger/android/support/BUILD
index 6d8f43b..6bbfaa1 100644
--- a/javatests/dagger/android/support/BUILD
+++ b/javatests/dagger/android/support/BUILD
@@ -15,11 +15,11 @@
# Description:
# Tests for Dagger's Android and Support library integrations
-package(default_visibility = ["//:src"])
-
load("//:build_defs.bzl", "DOCLINT_HTML_AND_SYNTAX")
load("//:test_defs.bzl", "GenRobolectricTests")
+package(default_visibility = ["//:src"])
+
GenRobolectricTests(
name = "android-support-tests",
srcs = glob(["*.java"]),
@@ -29,10 +29,12 @@
"//:dagger_with_compiler",
"//java/dagger/android",
"//java/dagger/android/support",
- "@androidsdk//com.android.support:appcompat-v7-25.0.0",
- "@androidsdk//com.android.support:support-fragment-25.0.0",
- "@google_bazel_common//third_party/java/guava",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/internal/guava:concurrent",
"@google_bazel_common//third_party/java/junit",
"@google_bazel_common//third_party/java/truth",
+ "@maven//:androidx_appcompat_appcompat",
+ "@maven//:androidx_fragment_fragment",
],
)
diff --git a/javatests/dagger/android/support/functional/AndroidManifest.xml b/javatests/dagger/android/support/functional/AndroidManifest.xml
index 2e40a35..0b5f4cd 100644
--- a/javatests/dagger/android/support/functional/AndroidManifest.xml
+++ b/javatests/dagger/android/support/functional/AndroidManifest.xml
@@ -16,7 +16,8 @@
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="dagger.android.support.functional">
- <uses-sdk android:minSdkVersion="1" android:targetSdkVersion="26" />
+ <!-- Bump targetSdk to 29 when we update to Java 11 -->
+ <uses-sdk android:minSdkVersion="1" android:targetSdkVersion="28" />
<application android:theme="@style/Theme.AppCompat"
android:name=".UsesGeneratedModulesApplication">
diff --git a/javatests/dagger/android/support/functional/BUILD b/javatests/dagger/android/support/functional/BUILD
index 130b971..1ae1108 100644
--- a/javatests/dagger/android/support/functional/BUILD
+++ b/javatests/dagger/android/support/functional/BUILD
@@ -15,6 +15,8 @@
# Description:
# Functional test code for Dagger-Android
+load("//:test_defs.bzl", "GenRobolectricTests")
+
package(default_visibility = ["//:src"])
android_library(
@@ -27,9 +29,10 @@
manifest = "AndroidManifest.xml",
resource_files = glob(["res/**"]),
deps = [
- "@androidsdk//com.android.support:support-fragment-25.0.0",
- "@androidsdk//com.android.support:appcompat-v7-25.0.0",
- "@google_bazel_common//third_party/java/guava",
+ "@maven//:androidx_fragment_fragment",
+ "@maven//:androidx_appcompat_appcompat",
+ "@maven//:androidx_annotation_annotation",
+ "//java/dagger/internal/guava:collect-android",
"//:dagger_with_compiler",
"//:android",
"//:android-support",
@@ -38,8 +41,6 @@
],
)
-load("//:test_defs.bzl", "GenRobolectricTests")
-
GenRobolectricTests(
name = "functional_tests",
srcs = glob(["*Test.java"]),
@@ -48,9 +49,9 @@
"//:android",
"//:android-support",
"//:dagger_with_compiler",
- "@androidsdk//com.android.support:support-fragment-25.0.0",
- "@google_bazel_common//third_party/java/junit",
- "@google_bazel_common//third_party/java/robolectric",
"@google_bazel_common//third_party/java/truth",
+ "@maven//:androidx_fragment_fragment",
+ "@maven//:junit_junit",
+ "@maven//:org_robolectric_robolectric",
],
)
diff --git a/javatests/dagger/android/support/functional/InjectorsTest.java b/javatests/dagger/android/support/functional/InjectorsTest.java
index c5cb150..73bb98a 100644
--- a/javatests/dagger/android/support/functional/InjectorsTest.java
+++ b/javatests/dagger/android/support/functional/InjectorsTest.java
@@ -20,12 +20,12 @@
import android.content.Intent;
import android.content.res.Configuration;
+import androidx.test.core.app.ApplicationProvider;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.Robolectric;
import org.robolectric.RobolectricTestRunner;
-import org.robolectric.RuntimeEnvironment;
import org.robolectric.android.controller.ActivityController;
import org.robolectric.annotation.Config;
@@ -59,7 +59,7 @@
intentService = Robolectric.buildIntentService(TestIntentService.class).create().get();
broadcastReceiver = new TestBroadcastReceiver();
- broadcastReceiver.onReceive(RuntimeEnvironment.application, new Intent());
+ broadcastReceiver.onReceive(ApplicationProvider.getApplicationContext(), new Intent());
contentProvider = Robolectric.setupContentProvider(TestContentProvider.class);
}
diff --git a/javatests/dagger/android/support/functional/TestContentProvider.java b/javatests/dagger/android/support/functional/TestContentProvider.java
index 1668ce6..aff8961 100644
--- a/javatests/dagger/android/support/functional/TestContentProvider.java
+++ b/javatests/dagger/android/support/functional/TestContentProvider.java
@@ -19,7 +19,7 @@
import android.content.ContentValues;
import android.database.Cursor;
import android.net.Uri;
-import android.support.annotation.Nullable;
+import androidx.annotation.Nullable;
import dagger.android.DaggerContentProvider;
import java.util.Set;
import javax.inject.Inject;
diff --git a/javatests/dagger/functional/BUILD b/javatests/dagger/functional/BUILD
index f417bec..8e6a555 100644
--- a/javatests/dagger/functional/BUILD
+++ b/javatests/dagger/functional/BUILD
@@ -15,15 +15,11 @@
# Description:
# Functional tests for Dagger
-package(default_visibility = ["//:src"])
-
-load(
- "//:build_defs.bzl",
- "DOCLINT_HTML_AND_SYNTAX",
- "SOURCE_7_TARGET_7",
-)
+load("//:build_defs.bzl", "DOCLINT_HTML_AND_SYNTAX", "SOURCE_7_TARGET_7")
load("//:test_defs.bzl", "GenJavaTests")
+package(default_visibility = ["//:src"])
+
GenJavaTests(
name = "functional_tests",
srcs = glob(
@@ -31,14 +27,16 @@
),
javacopts = DOCLINT_HTML_AND_SYNTAX,
lib_javacopts = SOURCE_7_TARGET_7,
- # NOTE: This should not depend on Guava or jsr305 to ensure that Dagger can be
- # used without Guava and jsr305 deps.
test_only_deps = [
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/internal/guava:concurrent",
"@google_bazel_common//third_party/java/guava:testlib",
- "@google_bazel_common//third_party/java/guava",
"@google_bazel_common//third_party/java/truth",
"@google_bazel_common//third_party/java/junit",
],
+ # NOTE: This should not depend on Guava or jsr305 to ensure that Dagger can be
+ # used without Guava and jsr305 deps.
deps = [
"//:dagger_with_compiler",
"@google_bazel_common//third_party/java/auto:factory",
diff --git a/javatests/dagger/functional/BoundedGenerics.java b/javatests/dagger/functional/BoundedGenerics.java
index 812cd04..d514337 100644
--- a/javatests/dagger/functional/BoundedGenerics.java
+++ b/javatests/dagger/functional/BoundedGenerics.java
@@ -19,6 +19,7 @@
import java.util.List;
import javax.inject.Inject;
+
class BoundedGenerics<A extends Number & Comparable<? super A>,
B extends List<? extends CharSequence>,
C extends List<? super String>,
diff --git a/javatests/dagger/functional/ComponentDependenciesTest.java b/javatests/dagger/functional/ComponentDependenciesTest.java
new file mode 100644
index 0000000..502c51d
--- /dev/null
+++ b/javatests/dagger/functional/ComponentDependenciesTest.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import dagger.Component;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests component dependencies.
+ */
+@RunWith(JUnit4.class)
+public final class ComponentDependenciesTest {
+ public interface One {
+ String getString();
+ }
+
+ public interface Two {
+ String getString();
+ }
+
+ public interface Merged extends One, Two {
+ }
+
+ @Component(dependencies = Merged.class)
+ interface TestComponent {
+ String getString();
+
+ @Component.Builder
+ interface Builder {
+ Builder dep(Merged dep);
+
+ TestComponent build();
+ }
+ }
+
+ @Test
+ public void testSameMethodTwice() throws Exception {
+ TestComponent component =
+ DaggerComponentDependenciesTest_TestComponent.builder().dep(() -> "test").build();
+ assertThat(component.getString()).isEqualTo("test");
+ }
+
+ public interface OneOverride {
+ Object getString();
+ }
+
+ public interface TwoOverride {
+ Object getString();
+ }
+
+ public interface MergedOverride extends OneOverride, TwoOverride {
+ @Override
+ String getString();
+ }
+
+ @Component(dependencies = MergedOverride.class)
+ interface TestOverrideComponent {
+ String getString();
+
+ @Component.Builder
+ interface Builder {
+ Builder dep(MergedOverride dep);
+
+ TestOverrideComponent build();
+ }
+ }
+
+ @Test
+ public void testPolymorphicOverridesStillCompiles() throws Exception {
+ TestOverrideComponent component =
+ DaggerComponentDependenciesTest_TestOverrideComponent.builder().dep(() -> "test").build();
+ assertThat(component.getString()).isEqualTo("test");
+ }
+}
diff --git a/javatests/dagger/functional/Generic2.java b/javatests/dagger/functional/Generic2.java
index f53c0f8..40ef546 100644
--- a/javatests/dagger/functional/Generic2.java
+++ b/javatests/dagger/functional/Generic2.java
@@ -18,6 +18,7 @@
import javax.inject.Inject;
+
public class Generic2<T> {
final T t;
diff --git a/javatests/dagger/functional/GenericNoDeps.java b/javatests/dagger/functional/GenericNoDeps.java
index c3f38b4..0e3d41b 100644
--- a/javatests/dagger/functional/GenericNoDeps.java
+++ b/javatests/dagger/functional/GenericNoDeps.java
@@ -18,6 +18,7 @@
import javax.inject.Inject;
+
class GenericNoDeps<T> {
@Inject GenericNoDeps() {}
diff --git a/javatests/dagger/functional/MultibindingTest.java b/javatests/dagger/functional/MultibindingTest.java
index d99e46d..3da3901 100644
--- a/javatests/dagger/functional/MultibindingTest.java
+++ b/javatests/dagger/functional/MultibindingTest.java
@@ -80,7 +80,7 @@
@Test
public void wrappedAnnotationKeyMap() {
- @SuppressWarnings("unchecked")
+ @SuppressWarnings({"unchecked", "rawtypes"})
Class<? extends Number>[] classes = new Class[] {Long.class, Integer.class};
assertThat(multibindingComponent.wrappedAnnotationKeyMap())
.containsExactly(
diff --git a/javatests/dagger/functional/NeedsFactory.java b/javatests/dagger/functional/NeedsFactory.java
index 2ea01ec..14ab134 100644
--- a/javatests/dagger/functional/NeedsFactory.java
+++ b/javatests/dagger/functional/NeedsFactory.java
@@ -19,11 +19,19 @@
import com.google.auto.factory.AutoFactory;
import javax.inject.Inject;
-class NeedsFactory {
+public class NeedsFactory {
@Inject
- NeedsFactory(@SuppressWarnings("unused") NeedsFactory_SomethingFactory somethingFactory) {}
+ NeedsFactory(
+ @SuppressWarnings("unused") NeedsFactory_SomethingFactory somethingFactory,
+ @SuppressWarnings("unused") SomethingFactoryImpl somethingFactoryImpl) {}
- @AutoFactory
+ public interface SomethingFactory {}
+
+ @AutoFactory(implementing = SomethingFactory.class, allowSubclasses = true)
static class Something {}
+
+ public static final class SomethingFactoryImpl extends NeedsFactory_SomethingFactory {
+ @Inject SomethingFactoryImpl() {}
+ }
}
diff --git a/javatests/dagger/functional/NeedsProviderOfFactory.java b/javatests/dagger/functional/NeedsProviderOfFactory.java
index efbd73d..1ae797e 100644
--- a/javatests/dagger/functional/NeedsProviderOfFactory.java
+++ b/javatests/dagger/functional/NeedsProviderOfFactory.java
@@ -26,7 +26,8 @@
static class InjectsProviderOfFactory {
@Inject
InjectsProviderOfFactory(
- Provider<NeedsProviderOfFactory_SomethingFactory> provider) {}
+ Provider<NeedsProviderOfFactory_SomethingFactory> somethingFactoryProvider,
+ Provider<SomethingFactoryImpl> somethingFactoryImplProvider) {}
}
@Component
@@ -34,6 +35,12 @@
InjectsProviderOfFactory injectsProviderOfFactory();
}
- @AutoFactory
+ interface SomethingFactory {}
+
+ @AutoFactory(implementing = SomethingFactory.class, allowSubclasses = true)
static class Something {}
+
+ static final class SomethingFactoryImpl extends NeedsProviderOfFactory_SomethingFactory {
+ @Inject SomethingFactoryImpl() {}
+ }
}
diff --git a/javatests/dagger/functional/aot/DependsOnMissingArrayKey.java b/javatests/dagger/functional/aot/DependsOnMissingArrayKey.java
deleted file mode 100644
index 20a89d4..0000000
--- a/javatests/dagger/functional/aot/DependsOnMissingArrayKey.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.functional.aot;
-
-import dagger.Module;
-import dagger.Provides;
-import dagger.Subcomponent;
-
-/**
- * Regression test for an ahead-of-time subcomponents bug where generating the name for a missing
- * binding method for a key of an array type threw an exception.
- */
-final class DependsOnMissingArrayKey {
- @Module
- abstract static class ModuleArrayDependencies {
- @Provides
- static int dependsOnMissingArrayType(int[] primitive, Object[] object, String[][] doubleArray) {
- return 0;
- }
- }
-
- @Subcomponent(modules = ModuleArrayDependencies.class)
- interface HasMissingArrayBindings {
- int dependsOnMissingArrayType();
- }
-}
diff --git a/javatests/dagger/functional/aot/MapFrameworkInstanceWithContributionsInMultipleImplementationsTest.java b/javatests/dagger/functional/aot/MapFrameworkInstanceWithContributionsInMultipleImplementationsTest.java
deleted file mode 100644
index ae6b3a4..0000000
--- a/javatests/dagger/functional/aot/MapFrameworkInstanceWithContributionsInMultipleImplementationsTest.java
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * Copyright (C) 2019 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.functional.aot;
-
-import static com.google.common.truth.Truth.assertThat;
-
-import dagger.Component;
-import dagger.Module;
-import dagger.Provides;
-import dagger.Subcomponent;
-import dagger.multibindings.IntoMap;
-import dagger.multibindings.StringKey;
-import java.util.Map;
-import javax.inject.Provider;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/**
- * Tests that framework instances of map bindings are properly instantiated in ahead-of-time mode
- * when contributions are made in 3 or more implementations.
- */
-@RunWith(JUnit4.class)
-public final class MapFrameworkInstanceWithContributionsInMultipleImplementationsTest {
- @Subcomponent(modules = LeafModule.class)
- interface Leaf {
- Provider<Map<String, String>> providerOfMapOfValues();
- Provider<Map<String, Provider<String>>> providerOfMapOfProviders();
- }
-
- @Module
- interface LeafModule {
- @Provides
- @IntoMap
- @StringKey("a")
- static String fromLeaf() {
- return "a";
- }
- }
-
- @Subcomponent(modules = AncestorModule.class)
- interface Ancestor {
- Leaf leaf();
- }
-
- @Module
- interface AncestorModule {
- @Provides
- @IntoMap
- @StringKey("b")
- static String fromAncestor() {
- return "b";
- }
- }
-
- @Component(modules = RootModule.class)
- interface Root {
- Ancestor ancestor();
- }
-
- @Module
- interface RootModule {
- @Provides
- @IntoMap
- @StringKey("c")
- static String fromRoot() {
- return "c";
- }
- }
-
- @Test
- public void mapFactoryCanBeInstantiatedAcrossComponentImplementations() {
- Leaf leaf =
- DaggerMapFrameworkInstanceWithContributionsInMultipleImplementationsTest_Root.create()
- .ancestor()
- .leaf();
- assertThat(leaf.providerOfMapOfValues().get()).hasSize(3);
- assertThat(leaf.providerOfMapOfProviders().get()).hasSize(3);
- }
-}
diff --git a/javatests/dagger/functional/aot/MissingBindingReplacedWithGeneratedInstance.java b/javatests/dagger/functional/aot/MissingBindingReplacedWithGeneratedInstance.java
deleted file mode 100644
index 1813ad2..0000000
--- a/javatests/dagger/functional/aot/MissingBindingReplacedWithGeneratedInstance.java
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.functional.aot;
-
-import dagger.Subcomponent;
-import javax.inject.Inject;
-
-/**
- * This class demonstrates a regression where a missing binding method was generated in a leaf
- * component and then satisfied in an ancestor with a generated instance binding. If the ancestor's
- * generated instance method had the same name as the formerly-missing binding method, Dagger would
- * generate code without a proper {@code DaggerOuter.this} reference:
- *
- * <pre>{@code
- * public class DaggerAncestor implements Ancestor {
- * protected abstract Ancestor getAncestor();
- *
- * protected abstract class LeafImpl extends DaggerLeaf {
- * {@literal @Override}
- * protected final Ancestor getAncestor() {
- * return getAncestor();
- * // ^ should be DaggerAncestor.this.getAncestor()
- * }
- * }
- * }
- * }</pre>
- */
-final class MissingBindingReplacedWithGeneratedInstance {
- @Subcomponent
- interface Leaf {
- DependsOnGeneratedInstance dependsOnGeneratedInstance();
- }
-
- static class DependsOnGeneratedInstance {
- @Inject DependsOnGeneratedInstance(Ancestor generatedInstance) {}
- }
-
- @Subcomponent
- interface Ancestor {
- Leaf child();
- }
-}
diff --git a/javatests/dagger/functional/aot/ModifiedFrameworkInstancesTest.java b/javatests/dagger/functional/aot/ModifiedFrameworkInstancesTest.java
deleted file mode 100644
index 7084f83..0000000
--- a/javatests/dagger/functional/aot/ModifiedFrameworkInstancesTest.java
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.functional.aot;
-
-import dagger.Component;
-import dagger.Module;
-import dagger.Provides;
-import dagger.Subcomponent;
-import dagger.multibindings.IntoSet;
-import java.util.Set;
-import javax.inject.Inject;
-import javax.inject.Provider;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-@RunWith(JUnit4.class)
-public final class ModifiedFrameworkInstancesTest {
- static class DependsOnModifiableBinding {
- @Inject
- DependsOnModifiableBinding(Set<Integer> modifiableDependency) {}
- }
-
- @Module
- interface ChildModule {
- @Provides
- @IntoSet
- static int contribution() {
- return 1;
- }
- }
-
- @Subcomponent(modules = ChildModule.class)
- interface Child {
- Provider<DependsOnModifiableBinding> frameworkInstanceWithModifiedDependency();
- }
-
- @Module
- interface ParentModule {
- @Provides
- @IntoSet
- static int contribution() {
- return 2;
- }
- }
-
- @Component(modules = ParentModule.class)
- interface Parent {
- Child child();
- }
-
- @Test
- public void dependsOnModifiedFrameworkInstance() {
- DaggerModifiedFrameworkInstancesTest_Parent.create()
- .child()
- .frameworkInstanceWithModifiedDependency()
- // Ensure that modified framework instances that are dependencies to other framework
- // instances from superclass implementations are initialized correctly. This fixes a
- // regression where a null instance would be passed to the superclass initialization, and
- // then a NullPointerException would be thrown when the factory attempted to satisfy the
- // dependency in get(). If get() succeeds, this test should pass.
- .get();
- }
-}
diff --git a/javatests/dagger/functional/aot/PrunedBindingDependedOnInSuperInitializationTest.java b/javatests/dagger/functional/aot/PrunedBindingDependedOnInSuperInitializationTest.java
deleted file mode 100644
index 853e22b..0000000
--- a/javatests/dagger/functional/aot/PrunedBindingDependedOnInSuperInitializationTest.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.functional.aot;
-
-import dagger.Component;
-import dagger.Module;
-import dagger.Provides;
-import dagger.Subcomponent;
-import javax.inject.Inject;
-import javax.inject.Provider;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-@RunWith(JUnit4.class)
-public class PrunedBindingDependedOnInSuperInitializationTest {
- interface PrunedDependency {}
-
- static class WillHavePrunedDependency {
- @Inject WillHavePrunedDependency(PrunedDependency pruned) {}
- }
-
- @Subcomponent
- interface Child {
- Provider<WillHavePrunedDependency> frameworkInstance();
- }
-
- @Module
- static class ParentModule {
- @Provides
- static WillHavePrunedDependency pruneDependency() {
- return new WillHavePrunedDependency(new PrunedDependency() {});
- }
- }
-
- @Component(modules = ParentModule.class)
- interface Parent {
- Child child();
- }
-
- @Test
- public void prunedFrameworkInstanceBindingUsedInInitializationDoesntThrow() {
- Parent parent = DaggerPrunedBindingDependedOnInSuperInitializationTest_Parent.create();
- // This test ensures that pruned bindings that are used during unpruned initialization
- // statements do not throw exceptions. If the subcomponent initialization succeeds, the test
- // should pass
- parent.child();
- }
-}
diff --git a/javatests/dagger/functional/aot/PrunedFrameworkInstanceWithModuleInstanceTest.java b/javatests/dagger/functional/aot/PrunedFrameworkInstanceWithModuleInstanceTest.java
deleted file mode 100644
index f995789..0000000
--- a/javatests/dagger/functional/aot/PrunedFrameworkInstanceWithModuleInstanceTest.java
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * Copyright (C) 2019 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.functional.aot;
-
-import dagger.Component;
-import dagger.Module;
-import dagger.Provides;
-import dagger.Subcomponent;
-import javax.inject.Inject;
-import javax.inject.Provider;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-@RunWith(JUnit4.class)
-public class PrunedFrameworkInstanceWithModuleInstanceTest {
- static class Pruned {}
-
- static class InjectsPruned {
- @Inject
- InjectsPruned(Provider<Pruned> pruned) {}
- }
-
- @Module
- static class InstanceStateModule {
- @Provides
- /* intentionally not static */ Pruned pruned() {
- return new Pruned();
- }
- }
-
- @Subcomponent(modules = InstanceStateModule.class)
- interface LeafWithoutCreator {
- InjectsPruned injectsPruned();
- }
-
- @Subcomponent(modules = InstanceStateModule.class)
- interface LeafWithCreator {
- InjectsPruned injectsPruned();
-
- @Subcomponent.Builder
- interface Builder {
- Builder module(InstanceStateModule module);
- LeafWithCreator build();
- }
- }
-
- @Module
- interface RootModule {
- @Provides
- static InjectsPruned pruneBindingWithInstanceState() {
- return new InjectsPruned(null);
- }
- }
-
- @Component(modules = RootModule.class)
- interface Root {
- LeafWithoutCreator leafWithoutCreator(InstanceStateModule pruned);
- LeafWithCreator.Builder leafWithCreator();
- }
-
- @Test
- public void prunedBindingWithModuleInstance_doesntThrowDuringInitialization() {
- Root root = DaggerPrunedFrameworkInstanceWithModuleInstanceTest_Root.create();
-
- Object unused = root.leafWithoutCreator(new InstanceStateModule()).injectsPruned();
- unused = root.leafWithCreator().module(new InstanceStateModule()).build().injectsPruned();
- }
-}
diff --git a/javatests/dagger/functional/aot/ScopedBindsWithMissingDependency.java b/javatests/dagger/functional/aot/ScopedBindsWithMissingDependency.java
deleted file mode 100644
index 2723ac0..0000000
--- a/javatests/dagger/functional/aot/ScopedBindsWithMissingDependency.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.functional.aot;
-
-import dagger.Binds;
-import dagger.Module;
-import dagger.Reusable;
-import dagger.Subcomponent;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import javax.inject.Scope;
-
-/**
- * A regression test for ahead-of-time subcomponents mode where a scoped {@link Binds} method whose
- * dependency was missing in a partial subcomponent implementation threw an exception in the
- * processor.
- */
-final class ScopedBindsWithMissingDependency {
-
- @Retention(RetentionPolicy.RUNTIME)
- @Scope
- @interface CustomScope {}
-
- @Module
- interface ScopedBindsWithMissingDependencyModule {
- @Binds
- @CustomScope
- Object bindsCustomScopeToMissingDep(String missingDependency);
-
- @Binds
- @Reusable
- CharSequence bindsReusableScopeToMissingDep(String missingDependency);
- }
-
- @CustomScope
- @Subcomponent(modules = ScopedBindsWithMissingDependencyModule.class)
- interface HasScopedBindsWithMissingDependency {
- Object customScopedBindsWithMissingDependency();
- CharSequence reusableScopedBindsWithMissingDependency();
- }
-}
diff --git a/javatests/dagger/functional/aot/SubcomponentWithInaccessibleMissingBindingMethod.java b/javatests/dagger/functional/aot/SubcomponentWithInaccessibleMissingBindingMethod.java
deleted file mode 100644
index 689689c..0000000
--- a/javatests/dagger/functional/aot/SubcomponentWithInaccessibleMissingBindingMethod.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.functional.aot;
-
-import dagger.Subcomponent;
-import dagger.functional.aot.sub.PublicTypeWithPackagePrivateMissingDep;
-import javax.inject.Provider;
-
-@Subcomponent
-interface SubcomponentWithInaccessibleMissingBindingMethod {
- PublicTypeWithPackagePrivateMissingDep instance();
- Provider<PublicTypeWithPackagePrivateMissingDep> frameworkInstance();
-}
diff --git a/javatests/dagger/functional/aot/SubcomponentWithModifiedInaccessibleDependency.java b/javatests/dagger/functional/aot/SubcomponentWithModifiedInaccessibleDependency.java
deleted file mode 100644
index 06cebb9..0000000
--- a/javatests/dagger/functional/aot/SubcomponentWithModifiedInaccessibleDependency.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.functional.aot;
-
-import dagger.Subcomponent;
-import dagger.functional.aot.sub.BindsPackagePrivateModule;
-import dagger.functional.aot.sub.SubcomponentWithInaccessibleOptionalBindingMethod;
-
-/**
- * See {@link dagger.functional.aot.sub.SubcomponentWithInaccessibleOptionalBindingMethod}. This
- * subcomponent will induce a modified binding method for its single child for the key {@code
- * Optional<dagger.functional.aot.sub.PackagePrivate>}. When it tries to reimplement it, it must use
- * the publicly accessible type.
- */
-@Subcomponent(modules = BindsPackagePrivateModule.class)
-interface SubcomponentWithModifiedInaccessibleDependency {
- SubcomponentWithInaccessibleOptionalBindingMethod child();
-}
diff --git a/javatests/dagger/functional/aot/sub/BindsPackagePrivateModule.java b/javatests/dagger/functional/aot/sub/BindsPackagePrivateModule.java
deleted file mode 100644
index 2eee3c9..0000000
--- a/javatests/dagger/functional/aot/sub/BindsPackagePrivateModule.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.functional.aot.sub;
-
-import dagger.Module;
-import dagger.Provides;
-
-@Module
-public final class BindsPackagePrivateModule {
- @Provides
- static PackagePrivate packagePrivate() {
- return new PackagePrivate();
- }
-}
diff --git a/javatests/dagger/functional/aot/sub/PackagePrivate.java b/javatests/dagger/functional/aot/sub/PackagePrivate.java
deleted file mode 100644
index c629f6e..0000000
--- a/javatests/dagger/functional/aot/sub/PackagePrivate.java
+++ /dev/null
@@ -1,19 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.functional.aot.sub;
-
-final class PackagePrivate {}
diff --git a/javatests/dagger/functional/aot/sub/PublicTypeWithPackagePrivateMissingDep.java b/javatests/dagger/functional/aot/sub/PublicTypeWithPackagePrivateMissingDep.java
deleted file mode 100644
index b5ced6f..0000000
--- a/javatests/dagger/functional/aot/sub/PublicTypeWithPackagePrivateMissingDep.java
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.functional.aot.sub;
-
-import javax.inject.Inject;
-
-public class PublicTypeWithPackagePrivateMissingDep {
- @Inject
- PublicTypeWithPackagePrivateMissingDep(PackagePrivate packagePrivate) {}
-}
diff --git a/javatests/dagger/functional/aot/sub/PublicTypeWithPackagePrivateOptionalDep.java b/javatests/dagger/functional/aot/sub/PublicTypeWithPackagePrivateOptionalDep.java
deleted file mode 100644
index 1d69723..0000000
--- a/javatests/dagger/functional/aot/sub/PublicTypeWithPackagePrivateOptionalDep.java
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.functional.aot.sub;
-
-import java.util.Optional;
-import javax.inject.Inject;
-
-public class PublicTypeWithPackagePrivateOptionalDep {
- @Inject
- PublicTypeWithPackagePrivateOptionalDep(Optional<PackagePrivate> packagePrivateOptional) {}
-}
diff --git a/javatests/dagger/functional/aot/sub/SubcomponentWithInaccessibleOptionalBindingMethod.java b/javatests/dagger/functional/aot/sub/SubcomponentWithInaccessibleOptionalBindingMethod.java
deleted file mode 100644
index d908b1c..0000000
--- a/javatests/dagger/functional/aot/sub/SubcomponentWithInaccessibleOptionalBindingMethod.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.functional.aot.sub;
-
-import dagger.BindsOptionalOf;
-import dagger.Module;
-import dagger.Subcomponent;
-import dagger.functional.aot.sub.SubcomponentWithInaccessibleOptionalBindingMethod.ExposesModifiablePackagePrivateBindingModule;
-import javax.inject.Provider;
-
-/**
- * This component will generate a modifiable binding method for the key {@code
- * Optional<PackagePrivate>} as a dependency of {@link PublicTypeWithPackagePrivateOptionalDep}.
- * Even though this subcomponent implementation can refer to the parameterized type, a subclass
- * implementation in another package will not be able to, and thus the return type must be reduced
- * to the publicly accessible type. This is exhibited in {@link
- * dagger.functional.aot.SubcomponentWithModifiedInaccessibleDependency}.
- */
-@Subcomponent(modules = ExposesModifiablePackagePrivateBindingModule.class)
-public interface SubcomponentWithInaccessibleOptionalBindingMethod {
- PublicTypeWithPackagePrivateOptionalDep instance();
- Provider<PublicTypeWithPackagePrivateOptionalDep> frameworkInstance();
-
- @Module
- interface ExposesModifiablePackagePrivateBindingModule {
- @BindsOptionalOf
- PackagePrivate optional();
- }
-}
diff --git a/javatests/dagger/functional/assisted/AssistedFactoryBindsTest.java b/javatests/dagger/functional/assisted/AssistedFactoryBindsTest.java
new file mode 100644
index 0000000..78495b7
--- /dev/null
+++ b/javatests/dagger/functional/assisted/AssistedFactoryBindsTest.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.assisted;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import dagger.Binds;
+import dagger.Component;
+import dagger.Module;
+import dagger.assisted.Assisted;
+import dagger.assisted.AssistedFactory;
+import dagger.assisted.AssistedInject;
+import javax.inject.Inject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class AssistedFactoryBindsTest {
+ @Component(modules = FooFactoryModule.class)
+ interface ParentComponent {
+ // Test using @Binds where Foo => FooImpl and FooFactory => FooFactoryImpl
+ FooFactory fooFactory();
+ }
+
+ @Module
+ interface FooFactoryModule {
+ @Binds
+ FooFactory bind(FooFactoryImpl impl);
+ }
+
+ interface Foo {}
+
+ static final class FooImpl implements Foo {
+ private final Dep dep;
+ private final AssistedDep assistedDep;
+
+ @AssistedInject
+ FooImpl(Dep dep, @Assisted AssistedDep assistedDep) {
+ this.dep = dep;
+ this.assistedDep = assistedDep;
+ }
+ }
+
+ interface FooFactory {
+ Foo create(AssistedDep assistedDep);
+ }
+
+ @AssistedFactory
+ interface FooFactoryImpl extends FooFactory {
+ @Override
+ FooImpl create(AssistedDep assistedDep);
+ }
+
+ static final class AssistedDep {}
+
+ static final class Dep {
+ @Inject
+ Dep() {}
+ }
+
+ @Test
+ public void testFooFactory() {
+ FooFactory fooFactory = DaggerAssistedFactoryBindsTest_ParentComponent.create().fooFactory();
+ assertThat(fooFactory).isInstanceOf(FooFactoryImpl.class);
+
+ AssistedDep assistedDep = new AssistedDep();
+ Foo foo = fooFactory.create(assistedDep);
+ assertThat(foo).isInstanceOf(FooImpl.class);
+
+ FooImpl fooImpl = (FooImpl) foo;
+ assertThat(fooImpl.dep).isNotNull();
+ assertThat(fooImpl.assistedDep).isEqualTo(assistedDep);
+ }
+}
diff --git a/javatests/dagger/functional/assisted/AssistedFactoryInaccessibleTest.java b/javatests/dagger/functional/assisted/AssistedFactoryInaccessibleTest.java
new file mode 100644
index 0000000..d586c61
--- /dev/null
+++ b/javatests/dagger/functional/assisted/AssistedFactoryInaccessibleTest.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.assisted;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import dagger.Component;
+import dagger.assisted.AssistedFactory;
+import dagger.functional.assisted.subpackage.AccessibleFoo;
+import dagger.functional.assisted.subpackage.AssistedDep;
+import dagger.functional.assisted.subpackage.InaccessibleFooFactory;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class AssistedFactoryInaccessibleTest {
+ @Component
+ interface ParentComponent {
+ // Factory for an accessible type from another package
+ AccessibleFooFactory accessibleFooFactory();
+
+ // Factory for an inaccessible type from another package
+ InaccessibleFooFactory inaccessibleFooFactory();
+ }
+
+ @AssistedFactory
+ public interface AccessibleFooFactory {
+ // Use different parameter names than Foo to make sure we're not assuming they're the same.
+ AccessibleFoo create(AssistedDep factoryAssistedDep);
+ }
+
+ @Test
+ public void testAccessibleFooFactory() {
+ AssistedDep assistedDep = new AssistedDep();
+ AccessibleFoo accessibleFoo =
+ DaggerAssistedFactoryInaccessibleTest_ParentComponent.create()
+ .accessibleFooFactory()
+ .create(assistedDep);
+ assertThat(accessibleFoo).isNotNull();
+ assertThat(accessibleFoo.dep).isNotNull();
+ assertThat(accessibleFoo.assistedDep).isEqualTo(assistedDep);
+ }
+
+ @Test
+ public void testInaccessibleFooFactory() {
+ AssistedDep assistedDep = new AssistedDep();
+ // We can't access InaccessibleFoo directly, so just use Object instead.
+ Object inaccessibleFoo =
+ DaggerAssistedFactoryInaccessibleTest_ParentComponent.create()
+ .inaccessibleFooFactory()
+ .create(assistedDep);
+ assertThat(inaccessibleFoo).isNotNull();
+ }
+}
diff --git a/javatests/dagger/functional/assisted/AssistedFactoryParameterizedTest.java b/javatests/dagger/functional/assisted/AssistedFactoryParameterizedTest.java
new file mode 100644
index 0000000..d079430
--- /dev/null
+++ b/javatests/dagger/functional/assisted/AssistedFactoryParameterizedTest.java
@@ -0,0 +1,265 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.assisted;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import dagger.Component;
+import dagger.assisted.Assisted;
+import dagger.assisted.AssistedFactory;
+import dagger.assisted.AssistedInject;
+import javax.inject.Inject;
+import javax.inject.Provider;
+import javax.inject.Singleton;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class AssistedFactoryParameterizedTest {
+ @Singleton
+ @Component
+ interface ParentComponent {
+ // Tests a parameterized Factory with unique @Assisted types
+ ParameterizedFooFactory<Dep2, AssistedDep2> uniqueParameterizedFooFactory();
+
+ // Tests a parameterized Factory with duplicate @Assisted types in its resolved request type.
+ // Note: this is fine since the @Assisted types are still unique on the @AssistedInject and
+ // @AssistedFactory types, so that the generated code can correctly matches types.
+ ParameterizedFooFactory<Dep1, AssistedDep1> dupeParameterizedFooFactory();
+
+ // Tests a parameterized Factory with same type as binding
+ ParameterizedFooFactory<Dep1, Dep1> bindingParameterizedFooFactory();
+
+ // Tests a parameterized Factory with fixed type parameters
+ FixedParameterizedFooFactory fixedParameterizedFooFactory();
+
+ // Tests a parameterized Factory that extends an interface with a parameterized return type
+ ExtendedFooFactory<Dep2, AssistedDep2> extendedParameterizedFooFactory();
+
+ // Tests a request of factories from another binding.
+ SomeEntryPoint someEntryPoint();
+ }
+
+ static final class Dep1 {
+ @Inject
+ Dep1(Dep2 dep2, Dep3 dep3) {}
+ }
+
+ static final class Dep2 {
+ @Inject
+ Dep2(Dep3 dep3) {}
+ }
+
+ static final class Dep3 {
+ @Inject
+ Dep3(Dep4 dep4) {}
+ }
+
+ static final class Dep4 {
+ @Inject
+ Dep4() {}
+ }
+
+ // A base interface to test that factories can reference subclasses of the assisted parameter.
+ interface AssistedDep {}
+
+ static final class AssistedDep1 implements AssistedDep {}
+
+ static final class AssistedDep2 implements AssistedDep {}
+
+ abstract static class BaseFoo {
+ @Inject Dep4 dep4;
+ }
+
+ static final class ParameterizedFoo<DepT, AssistedDepT> extends BaseFoo {
+ private final Dep1 dep1;
+ private final Provider<DepT> depTProvider;
+ private final AssistedDep1 assistedDep1;
+ private final AssistedDepT assistedDepT;
+ private final int assistedInt;
+ private final ParameterizedFooFactory<DepT, AssistedDepT> factory;
+
+ @Inject Dep3 dep3;
+
+ @AssistedInject
+ ParameterizedFoo(
+ Dep1 dep1,
+ @Assisted AssistedDep1 assistedDep1,
+ Provider<DepT> depTProvider,
+ @Assisted AssistedDepT assistedDepT,
+ @Assisted int assistedInt,
+ ParameterizedFooFactory<DepT, AssistedDepT> factory) {
+ this.dep1 = dep1;
+ this.depTProvider = depTProvider;
+ this.assistedDep1 = assistedDep1;
+ this.assistedDepT = assistedDepT;
+ this.assistedInt = assistedInt;
+ this.factory = factory;
+ }
+ }
+
+ @AssistedFactory
+ interface ParameterizedFooFactory<DepT, AssistedDepT> {
+ ParameterizedFoo<DepT, AssistedDepT> create(
+ AssistedDep1 assistedDep1, AssistedDepT assistedDepT, int assistedInt);
+ }
+
+ @Test
+ public void testUniqueParameterizedFooFactory() {
+ AssistedDep1 assistedDep1 = new AssistedDep1();
+ AssistedDep2 assistedDep2 = new AssistedDep2();
+ int assistedInt = 7;
+ ParameterizedFoo<Dep2, AssistedDep2> parameterizedFoo =
+ DaggerAssistedFactoryParameterizedTest_ParentComponent.create()
+ .uniqueParameterizedFooFactory()
+ .create(assistedDep1, assistedDep2, assistedInt);
+ assertThat(parameterizedFoo.dep1).isNotNull();
+ assertThat(parameterizedFoo.depTProvider).isNotNull();
+ assertThat(parameterizedFoo.depTProvider.get()).isNotNull();
+ assertThat(parameterizedFoo.dep3).isNotNull();
+ assertThat(parameterizedFoo.dep4).isNotNull();
+ assertThat(parameterizedFoo.assistedDep1).isEqualTo(assistedDep1);
+ assertThat(parameterizedFoo.assistedDepT).isEqualTo(assistedDep2);
+ assertThat(parameterizedFoo.assistedInt).isEqualTo(assistedInt);
+ assertThat(parameterizedFoo.factory).isNotNull();
+ }
+
+ @Test
+ public void testDupeParameterizedFooFactory() {
+ AssistedDep1 assistedDep1 = new AssistedDep1();
+ int assistedInt = 7;
+ ParameterizedFoo<Dep1, AssistedDep1> parameterizedFoo =
+ DaggerAssistedFactoryParameterizedTest_ParentComponent.create()
+ .dupeParameterizedFooFactory()
+ .create(assistedDep1, assistedDep1, assistedInt);
+ assertThat(parameterizedFoo.dep1).isNotNull();
+ assertThat(parameterizedFoo.depTProvider).isNotNull();
+ assertThat(parameterizedFoo.depTProvider.get()).isNotNull();
+ assertThat(parameterizedFoo.dep3).isNotNull();
+ assertThat(parameterizedFoo.dep4).isNotNull();
+ assertThat(parameterizedFoo.assistedDep1).isEqualTo(assistedDep1);
+ assertThat(parameterizedFoo.assistedDepT).isEqualTo(assistedDep1);
+ assertThat(parameterizedFoo.assistedInt).isEqualTo(assistedInt);
+ assertThat(parameterizedFoo.factory).isNotNull();
+ }
+
+ @Test
+ public void testBindingParameterizedFooFactory() {
+ AssistedDep1 assistedDep1 = new AssistedDep1();
+ Dep1 dep1 = new Dep1(new Dep2(new Dep3(new Dep4())), new Dep3(new Dep4()));
+ int assistedInt = 7;
+ ParameterizedFoo<Dep1, Dep1> parameterizedFoo =
+ DaggerAssistedFactoryParameterizedTest_ParentComponent.create()
+ .bindingParameterizedFooFactory()
+ .create(assistedDep1, dep1, assistedInt);
+ assertThat(parameterizedFoo.dep1).isNotNull();
+ assertThat(parameterizedFoo.depTProvider).isNotNull();
+ assertThat(parameterizedFoo.depTProvider.get()).isNotNull();
+ assertThat(parameterizedFoo.dep3).isNotNull();
+ assertThat(parameterizedFoo.dep4).isNotNull();
+ assertThat(parameterizedFoo.assistedDep1).isEqualTo(assistedDep1);
+ assertThat(parameterizedFoo.assistedDepT).isEqualTo(dep1);
+ assertThat(parameterizedFoo.assistedInt).isEqualTo(assistedInt);
+ assertThat(parameterizedFoo.factory).isNotNull();
+ }
+
+ @AssistedFactory
+ interface FixedParameterizedFooFactory {
+ ParameterizedFoo<Dep2, AssistedDep2> create(
+ AssistedDep1 assistedDep1, AssistedDep2 assistedDep2, int assistedInt);
+ }
+
+ @Test
+ public void testFixedParameterizedFooFactory() {
+ AssistedDep1 assistedDep1 = new AssistedDep1();
+ AssistedDep2 assistedDep2 = new AssistedDep2();
+ int assistedInt = 7;
+ ParameterizedFoo<Dep2, AssistedDep2> parameterizedFoo =
+ DaggerAssistedFactoryParameterizedTest_ParentComponent.create()
+ .fixedParameterizedFooFactory()
+ .create(assistedDep1, assistedDep2, assistedInt);
+ assertThat(parameterizedFoo.dep1).isNotNull();
+ assertThat(parameterizedFoo.depTProvider).isNotNull();
+ assertThat(parameterizedFoo.depTProvider.get()).isNotNull();
+ assertThat(parameterizedFoo.dep3).isNotNull();
+ assertThat(parameterizedFoo.dep4).isNotNull();
+ assertThat(parameterizedFoo.assistedDep1).isEqualTo(assistedDep1);
+ assertThat(parameterizedFoo.assistedDepT).isEqualTo(assistedDep2);
+ assertThat(parameterizedFoo.assistedInt).isEqualTo(assistedInt);
+ assertThat(parameterizedFoo.factory).isNotNull();
+ }
+
+ interface ParameterizedFactory<ReturnT, DepT, AssistedDepT> {
+ // Use different parameter names than Foo to make sure we're not assuming they're the same.
+ ReturnT create(
+ AssistedDep1 factoryAssistedDep1, AssistedDepT factoryAssistedDepT, int factoryAssistedInt);
+ }
+
+ @AssistedFactory
+ interface ExtendedFooFactory<DepT, AssistedDepT>
+ extends ParameterizedFactory<ParameterizedFoo<DepT, AssistedDepT>, DepT, AssistedDepT> {}
+
+ @Test
+ public void testExtendedFooFactory() {
+ AssistedDep1 assistedDep1 = new AssistedDep1();
+ AssistedDep2 assistedDep2 = new AssistedDep2();
+ int assistedInt = 7;
+ ParameterizedFoo<Dep2, AssistedDep2> parameterizedFoo =
+ DaggerAssistedFactoryParameterizedTest_ParentComponent.create()
+ .extendedParameterizedFooFactory()
+ .create(assistedDep1, assistedDep2, assistedInt);
+ assertThat(parameterizedFoo.dep1).isNotNull();
+ assertThat(parameterizedFoo.depTProvider).isNotNull();
+ assertThat(parameterizedFoo.depTProvider.get()).isNotNull();
+ assertThat(parameterizedFoo.dep3).isNotNull();
+ assertThat(parameterizedFoo.dep4).isNotNull();
+ assertThat(parameterizedFoo.assistedDep1).isEqualTo(assistedDep1);
+ assertThat(parameterizedFoo.assistedDepT).isEqualTo(assistedDep2);
+ assertThat(parameterizedFoo.assistedInt).isEqualTo(assistedInt);
+ assertThat(parameterizedFoo.factory).isNotNull();
+ }
+
+ static class SomeEntryPoint {
+ private final ParameterizedFooFactory<Dep1, AssistedDep1> dupeParameterizedFooFactory;
+
+ @Inject
+ SomeEntryPoint(ParameterizedFooFactory<Dep1, AssistedDep1> dupeParameterizedFooFactory) {
+ this.dupeParameterizedFooFactory = dupeParameterizedFooFactory;
+ }
+ }
+
+ @Test
+ public void testParameterizedFooFactoryFromSomeEntryPoint() {
+ AssistedDep1 assistedDep1 = new AssistedDep1();
+ int assistedInt = 7;
+ ParameterizedFoo<Dep1, AssistedDep1> parameterizedFoo =
+ DaggerAssistedFactoryParameterizedTest_ParentComponent.create()
+ .someEntryPoint()
+ .dupeParameterizedFooFactory
+ .create(assistedDep1, assistedDep1, assistedInt);
+ assertThat(parameterizedFoo.dep1).isNotNull();
+ assertThat(parameterizedFoo.depTProvider).isNotNull();
+ assertThat(parameterizedFoo.depTProvider.get()).isNotNull();
+ assertThat(parameterizedFoo.dep3).isNotNull();
+ assertThat(parameterizedFoo.dep4).isNotNull();
+ assertThat(parameterizedFoo.assistedDep1).isEqualTo(assistedDep1);
+ assertThat(parameterizedFoo.assistedDepT).isEqualTo(assistedDep1);
+ assertThat(parameterizedFoo.assistedInt).isEqualTo(assistedInt);
+ assertThat(parameterizedFoo.factory).isNotNull();
+ }
+}
diff --git a/javatests/dagger/functional/assisted/AssistedFactoryTest.java b/javatests/dagger/functional/assisted/AssistedFactoryTest.java
new file mode 100644
index 0000000..3176add
--- /dev/null
+++ b/javatests/dagger/functional/assisted/AssistedFactoryTest.java
@@ -0,0 +1,332 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.assisted;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import dagger.Component;
+import dagger.assisted.Assisted;
+import dagger.assisted.AssistedFactory;
+import dagger.assisted.AssistedInject;
+import javax.inject.Inject;
+import javax.inject.Provider;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class AssistedFactoryTest {
+ @Component
+ interface ParentComponent {
+ // Simple factory using a nested factory.
+ SimpleFoo.Factory nestedSimpleFooFactory();
+
+ // Simple factory using a non-nested factory.
+ SimpleFooFactory nonNestedSimpleFooFactory();
+
+ // Simple factory using a factory that extends a supertype.
+ ExtendedSimpleFooFactory extendedSimpleFooFactory();
+
+ // Factory as interface
+ FooFactory fooFactory();
+
+ // Factory as abstract class
+ AbstractFooFactory abstractFooFactory();
+
+ // Factory without any assisted parameters
+ NoAssistedParametersFooFactory noAssistedParametersFooFactory();
+
+ // Test injecting the factories from another class
+ SomeEntryPoint someEntryPoint();
+ }
+
+ // This class tests the request of factories from another binding.
+ static class SomeEntryPoint {
+ private final SimpleFoo.Factory nestedSimpleFooFactory;
+ private final SimpleFooFactory nonNestedSimpleFooFactory;
+ private final ExtendedSimpleFooFactory extendedSimpleFooFactory;
+ private final FooFactory fooFactory;
+ private final AbstractFooFactory abstractFooFactory;
+ private final NoAssistedParametersFooFactory noAssistedParametersFooFactory;
+
+ @Inject
+ SomeEntryPoint(
+ SimpleFoo.Factory nestedSimpleFooFactory,
+ SimpleFooFactory nonNestedSimpleFooFactory,
+ ExtendedSimpleFooFactory extendedSimpleFooFactory,
+ FooFactory fooFactory,
+ AbstractFooFactory abstractFooFactory,
+ NoAssistedParametersFooFactory noAssistedParametersFooFactory) {
+ this.nestedSimpleFooFactory = nestedSimpleFooFactory;
+ this.nonNestedSimpleFooFactory = nonNestedSimpleFooFactory;
+ this.extendedSimpleFooFactory = extendedSimpleFooFactory;
+ this.fooFactory = fooFactory;
+ this.abstractFooFactory = abstractFooFactory;
+ this.noAssistedParametersFooFactory = noAssistedParametersFooFactory;
+ }
+ }
+
+ static final class Dep1 {
+ @Inject
+ Dep1(Dep2 dep2, Dep3 dep3) {}
+ }
+
+ static final class Dep2 {
+ @Inject
+ Dep2(Dep3 dep3) {}
+ }
+
+ static final class Dep3 {
+ @Inject
+ Dep3(Dep4 dep4) {}
+ }
+
+ static final class Dep4 {
+ @Inject
+ Dep4() {}
+ }
+
+ // A base interface to test that factories can reference subclasses of the assisted parameter.
+ interface AssistedDep {}
+
+ static final class AssistedDep1 implements AssistedDep {}
+
+ static final class AssistedDep2 implements AssistedDep {}
+
+ static final class SimpleFoo {
+ private final AssistedDep assistedDep;
+
+ @AssistedInject
+ SimpleFoo(@Assisted AssistedDep assistedDep) {
+ this.assistedDep = assistedDep;
+ }
+
+ @AssistedFactory
+ interface Factory {
+ // Use different parameter names than Foo to make sure we're not assuming they're the same.
+ SimpleFoo createSimpleFoo(AssistedDep factoryAssistedDep);
+
+ // A no-op method to test static methods in assisted factories
+ static void staticMethod() {
+ return;
+ }
+
+ // A no-op method to test default methods in assisted factories
+ default void defaultMethod() {
+ return;
+ }
+ }
+ }
+
+ @AssistedFactory
+ interface SimpleFooFactory {
+ // Use different parameter names than Foo to make sure we're not assuming they're the same.
+ SimpleFoo createSimpleFoo(AssistedDep factoryAssistedDep1);
+
+ // A no-op method to test static methods are allowed
+ static void staticMethod() {
+ return;
+ }
+
+ // A no-op method to test static methods that return assisted type are allowed
+ static SimpleFoo staticSimpleFooMethod() {
+ return null;
+ }
+
+ // A no-op method to test default methods are allowed
+ default void defaultMethod() {
+ return;
+ }
+
+ // A no-op method to test default methods that return assisted type are allowed
+ default SimpleFoo defaultSimpleFooMethod() {
+ return null;
+ }
+ }
+
+ @AssistedFactory
+ interface ExtendedSimpleFooFactory extends SimpleFooFactory {}
+
+ abstract static class BaseFoo {
+ @Inject Dep4 dep4;
+ }
+
+ static final class Foo extends BaseFoo {
+ private final Dep1 dep1;
+ private final Provider<Dep2> dep2Provider;
+ private final AssistedDep1 assistedDep1;
+ private final AssistedDep2 assistedDep2;
+ private final int assistedInt;
+ private final FooFactory factory;
+
+ @Inject Dep3 dep3;
+
+ @AssistedInject
+ Foo(
+ Dep1 dep1,
+ @Assisted AssistedDep1 assistedDep1,
+ Provider<Dep2> dep2Provider,
+ @Assisted AssistedDep2 assistedDep2,
+ @Assisted int assistedInt,
+ FooFactory factory) {
+ this.dep1 = dep1;
+ this.dep2Provider = dep2Provider;
+ this.assistedDep1 = assistedDep1;
+ this.assistedDep2 = assistedDep2;
+ this.assistedInt = assistedInt;
+ this.factory = factory;
+ }
+ }
+
+ @AssistedFactory
+ interface FooFactory {
+ // Use different parameter names than Foo to make sure we're not assuming they're the same.
+ Foo createFoo(
+ AssistedDep1 factoryAssistedDep1, AssistedDep2 factoryAssistedDep2, int factoryAssistedInt);
+ }
+
+ @AssistedFactory
+ abstract static class AbstractFooFactory {
+ // Use different parameter names than Foo to make sure we're not assuming they're the same.
+ abstract Foo createFoo(
+ AssistedDep1 factoryAssistedDep1, AssistedDep2 factoryAssistedDep2, int factoryAssistedInt);
+
+ // A no-op method to test static methods are allowed
+ static void staticMethod() {
+ return;
+ }
+
+ // A no-op method to test static methods that return assisted type are allowed
+ static Foo staticFooMethod() {
+ return null;
+ }
+
+ // A no-op method to test concrete methods are allowed
+ void concreteMethod() {
+ return;
+ }
+
+ // A no-op method to test concrete methods that return assisted type are allowed
+ Foo concreteFooMethod() {
+ return null;
+ }
+ }
+
+ static final class NoAssistedParametersFoo extends BaseFoo {
+ private final Dep1 dep1;
+ private final Provider<Dep2> dep2Provider;
+ private final NoAssistedParametersFooFactory factory;
+
+ @Inject Dep3 dep3;
+
+ @AssistedInject
+ NoAssistedParametersFoo(
+ Dep1 dep1, Provider<Dep2> dep2Provider, NoAssistedParametersFooFactory factory) {
+ this.dep1 = dep1;
+ this.dep2Provider = dep2Provider;
+ this.factory = factory;
+ }
+ }
+
+ @AssistedFactory
+ interface NoAssistedParametersFooFactory {
+ NoAssistedParametersFoo createNoAssistedParametersFoo();
+ }
+
+ @Test
+ public void testNestedSimpleFooFactory() {
+ AssistedDep1 assistedDep1 = new AssistedDep1();
+ SimpleFoo simpleFoo1 =
+ DaggerAssistedFactoryTest_ParentComponent.create()
+ .nestedSimpleFooFactory()
+ .createSimpleFoo(assistedDep1);
+ assertThat(simpleFoo1.assistedDep).isEqualTo(assistedDep1);
+
+ AssistedDep2 assistedDep2 = new AssistedDep2();
+ SimpleFoo simpleFoo2 =
+ DaggerAssistedFactoryTest_ParentComponent.create()
+ .nestedSimpleFooFactory()
+ .createSimpleFoo(assistedDep2);
+ assertThat(simpleFoo2.assistedDep).isEqualTo(assistedDep2);
+ }
+
+ @Test
+ public void testNonNestedSimpleFooFactory() {
+ AssistedDep1 assistedDep1 = new AssistedDep1();
+ SimpleFoo simpleFoo =
+ DaggerAssistedFactoryTest_ParentComponent.create()
+ .nonNestedSimpleFooFactory()
+ .createSimpleFoo(assistedDep1);
+ assertThat(simpleFoo.assistedDep).isEqualTo(assistedDep1);
+ }
+
+ @Test
+ public void testExtendedSimpleFooFactory() {
+ AssistedDep1 assistedDep1 = new AssistedDep1();
+ SimpleFoo simpleFoo =
+ DaggerAssistedFactoryTest_ParentComponent.create()
+ .extendedSimpleFooFactory()
+ .createSimpleFoo(assistedDep1);
+ assertThat(simpleFoo.assistedDep).isEqualTo(assistedDep1);
+ }
+
+ @Test
+ public void testFooFactory() {
+ AssistedDep1 assistedDep1 = new AssistedDep1();
+ AssistedDep2 assistedDep2 = new AssistedDep2();
+ int assistedInt = 7;
+ Foo foo =
+ DaggerAssistedFactoryTest_ParentComponent.create()
+ .fooFactory()
+ .createFoo(assistedDep1, assistedDep2, assistedInt);
+ assertThat(foo.dep1).isNotNull();
+ assertThat(foo.dep2Provider).isNotNull();
+ assertThat(foo.dep2Provider.get()).isNotNull();
+ assertThat(foo.dep3).isNotNull();
+ assertThat(foo.dep4).isNotNull();
+ assertThat(foo.assistedDep1).isEqualTo(assistedDep1);
+ assertThat(foo.assistedDep2).isEqualTo(assistedDep2);
+ assertThat(foo.assistedInt).isEqualTo(assistedInt);
+ assertThat(foo.factory).isNotNull();
+ }
+
+ @Test
+ public void testNoAssistedParametersFooFactory() {
+ NoAssistedParametersFoo foo =
+ DaggerAssistedFactoryTest_ParentComponent.create()
+ .noAssistedParametersFooFactory()
+ .createNoAssistedParametersFoo();
+ assertThat(foo.dep1).isNotNull();
+ assertThat(foo.dep2Provider).isNotNull();
+ assertThat(foo.dep2Provider.get()).isNotNull();
+ assertThat(foo.dep3).isNotNull();
+ assertThat(foo.dep4).isNotNull();
+ assertThat(foo.factory).isNotNull();
+ }
+
+ @Test
+ public void testAssistedFactoryFromSomeEntryPoint() {
+ SomeEntryPoint someEntryPoint =
+ DaggerAssistedFactoryTest_ParentComponent.create().someEntryPoint();
+ assertThat(someEntryPoint.nestedSimpleFooFactory).isNotNull();
+ assertThat(someEntryPoint.nonNestedSimpleFooFactory).isNotNull();
+ assertThat(someEntryPoint.extendedSimpleFooFactory).isNotNull();
+ assertThat(someEntryPoint.fooFactory).isNotNull();
+ assertThat(someEntryPoint.abstractFooFactory).isNotNull();
+ assertThat(someEntryPoint.noAssistedParametersFooFactory).isNotNull();
+ }
+}
diff --git a/javatests/dagger/functional/assisted/AssistedFactoryWithArrayTypesTest.java b/javatests/dagger/functional/assisted/AssistedFactoryWithArrayTypesTest.java
new file mode 100644
index 0000000..91f7e42
--- /dev/null
+++ b/javatests/dagger/functional/assisted/AssistedFactoryWithArrayTypesTest.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2021 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.assisted;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import dagger.Component;
+import dagger.assisted.Assisted;
+import dagger.assisted.AssistedFactory;
+import dagger.assisted.AssistedInject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class AssistedFactoryWithArrayTypesTest {
+ @Component
+ interface TestComponent {
+ FooFactory fooFactory();
+ }
+
+ @AssistedFactory
+ interface FooFactory {
+ Foo create(Dep[] depArray);
+ }
+
+ static class Dep {}
+
+ static class Foo {
+ private final Dep[] depArray;
+
+ @AssistedInject
+ Foo(@Assisted Dep[] depArray) {
+ this.depArray = depArray;
+ }
+ }
+
+ @Test
+ public void testFooFactory() {
+ Dep[] depArray = {new Dep(), new Dep()};
+ Foo foo =
+ DaggerAssistedFactoryWithArrayTypesTest_TestComponent.create()
+ .fooFactory()
+ .create(depArray);
+ assertThat(foo.depArray).isEqualTo(depArray);
+ }
+}
diff --git a/javatests/dagger/functional/assisted/AssistedFactoryWithAssistedInjectParamTest.java b/javatests/dagger/functional/assisted/AssistedFactoryWithAssistedInjectParamTest.java
new file mode 100644
index 0000000..9b794fd
--- /dev/null
+++ b/javatests/dagger/functional/assisted/AssistedFactoryWithAssistedInjectParamTest.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2021 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.assisted;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import dagger.Component;
+import dagger.assisted.Assisted;
+import dagger.assisted.AssistedFactory;
+import dagger.assisted.AssistedInject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+// This is a regression test for https://github.com/google/dagger/issues/2278
+@RunWith(JUnit4.class)
+public final class AssistedFactoryWithAssistedInjectParamTest {
+ @Component
+ interface ParentComponent {
+ FooFactory fooFactory();
+
+ BarFactory barFactory();
+ }
+
+ static class Foo {
+ private final Bar bar;
+
+ @AssistedInject
+ Foo(@Assisted Bar bar) {
+ this.bar = bar;
+ }
+ }
+
+ static class Bar {
+ @AssistedInject
+ Bar() {}
+ }
+
+ @AssistedFactory
+ interface FooFactory {
+ Foo create(Bar bar);
+ }
+
+ @AssistedFactory
+ interface BarFactory {
+ Bar create();
+ }
+
+ @Test
+ public void testFooFactory() {
+ ParentComponent component =
+ DaggerAssistedFactoryWithAssistedInjectParamTest_ParentComponent.create();
+ FooFactory fooFactory = component.fooFactory();
+ BarFactory barFactory = component.barFactory();
+
+ Bar bar = barFactory.create();
+ Foo foo = fooFactory.create(bar);
+ assertThat(foo.bar).isEqualTo(bar);
+ }
+}
diff --git a/javatests/dagger/functional/assisted/AssistedFactoryWithQualifiedTypesTest.java b/javatests/dagger/functional/assisted/AssistedFactoryWithQualifiedTypesTest.java
new file mode 100644
index 0000000..952b94d
--- /dev/null
+++ b/javatests/dagger/functional/assisted/AssistedFactoryWithQualifiedTypesTest.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2021 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.assisted;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import dagger.Component;
+import dagger.assisted.Assisted;
+import dagger.assisted.AssistedFactory;
+import dagger.assisted.AssistedInject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+// See https://github.com/google/dagger/issues/2281
+@RunWith(JUnit4.class)
+public final class AssistedFactoryWithQualifiedTypesTest {
+ @Component
+ interface TestComponent {
+ // Test a factory with duplicate types with unique qualifiers.
+ DupeTypeFactory dupeTypeFactory();
+
+ // Test a factory with duplicate qualifiers with unique types.
+ DupeQualifierFactory dupeQualifierFactory();
+
+ // Test a factory with unnecessary qualifiers on the factory.
+ UnnecessaryQualifierFactory unnecessaryQualifierFactory();
+
+ // Test a factory with different parameter order than the constructor.
+ SwappedDupeTypeFactory swappedDupeTypeFactory();
+ }
+
+ static class DupeType {
+ private final String str1;
+ private final String str2;
+
+ @AssistedInject
+ DupeType(@Assisted("1") String str1, @Assisted("2") String str2) {
+ this.str1 = str1;
+ this.str2 = str2;
+ }
+ }
+
+ @AssistedFactory
+ interface DupeTypeFactory {
+ DupeType create(@Assisted("1") String str1, @Assisted("2") String str2);
+ }
+
+ @Test
+ public void testDupeTypeFactory() {
+ String str1 = "str1";
+ String str2 = "str2";
+ DupeType dupeType =
+ DaggerAssistedFactoryWithQualifiedTypesTest_TestComponent.create()
+ .dupeTypeFactory()
+ .create(str1, str2);
+ assertThat(dupeType.str1).isEqualTo(str1);
+ assertThat(dupeType.str2).isEqualTo(str2);
+ }
+
+ @AssistedFactory
+ interface SwappedDupeTypeFactory {
+ DupeType create(@Assisted("2") String str2, @Assisted("1") String str1);
+ }
+
+ @Test
+ public void testSwappedDupeTypeFactory() {
+ String str1 = "str1";
+ String str2 = "str2";
+ DupeType dupeType =
+ DaggerAssistedFactoryWithQualifiedTypesTest_TestComponent.create()
+ .swappedDupeTypeFactory()
+ .create(str2, str1);
+ assertThat(dupeType.str1).isEqualTo(str1);
+ assertThat(dupeType.str2).isEqualTo(str2);
+ }
+
+ static class DupeQualifier {
+ private final String str;
+ private final int i;
+
+ @AssistedInject
+ DupeQualifier(@Assisted("1") String str, @Assisted("1") int i) {
+ this.str = str;
+ this.i = i;
+ }
+ }
+
+ @AssistedFactory
+ interface DupeQualifierFactory {
+ DupeQualifier create(@Assisted("1") String str, @Assisted("1") int i);
+ }
+
+ @Test
+ public void testDupeQualifierFactory() {
+ String str = "str";
+ int i = 11;
+ DupeQualifier dupeQualifier =
+ DaggerAssistedFactoryWithQualifiedTypesTest_TestComponent.create()
+ .dupeQualifierFactory()
+ .create(str, i);
+ assertThat(dupeQualifier.str).isEqualTo(str);
+ assertThat(dupeQualifier.i).isEqualTo(i);
+ }
+
+ static class UnnecessaryQualifier {
+ private final String str;
+ private final double d;
+ private final int i;
+
+ @AssistedInject
+ UnnecessaryQualifier(@Assisted String str, @Assisted double d, @Assisted("") int i) {
+ this.str = str;
+ this.d = d;
+ this.i = i;
+ }
+ }
+
+ @AssistedFactory
+ interface UnnecessaryQualifierFactory {
+ UnnecessaryQualifier create(@Assisted int i, @Assisted("") String str, double d);
+ }
+
+ @Test
+ public void testUnnecessaryQualifierFactory() {
+ String str = "str";
+ double d = 2.2;
+ int i = 11;
+ UnnecessaryQualifier unnecessaryQualifier =
+ DaggerAssistedFactoryWithQualifiedTypesTest_TestComponent.create()
+ .unnecessaryQualifierFactory()
+ .create(i, str, d);
+ assertThat(unnecessaryQualifier.str).isEqualTo(str);
+ assertThat(unnecessaryQualifier.d).isEqualTo(d);
+ assertThat(unnecessaryQualifier.i).isEqualTo(i);
+ }
+}
diff --git a/javatests/dagger/functional/assisted/BUILD b/javatests/dagger/functional/assisted/BUILD
new file mode 100644
index 0000000..5e663e7
--- /dev/null
+++ b/javatests/dagger/functional/assisted/BUILD
@@ -0,0 +1,45 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Functional tests for Dagger
+
+load("//:build_defs.bzl", "DOCLINT_HTML_AND_SYNTAX", "SOURCE_7_TARGET_7")
+load("//:test_defs.bzl", "GenJavaTests")
+
+package(default_visibility = ["//:src"])
+
+GenJavaTests(
+ name = "assisted",
+ srcs = glob(["*.java"]),
+ javacopts = DOCLINT_HTML_AND_SYNTAX,
+ lib_javacopts = SOURCE_7_TARGET_7,
+ test_only_deps = [
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/internal/guava:concurrent",
+ "@google_bazel_common//third_party/java/guava:testlib",
+ "@google_bazel_common//third_party/java/truth",
+ "@google_bazel_common//third_party/java/junit",
+ "//javatests/dagger/functional/assisted/subpackage",
+ ],
+ # NOTE: This should not depend on Guava or jsr305 to ensure that Dagger can be
+ # used without Guava and jsr305 deps.
+ deps = [
+ "//:dagger_with_compiler",
+ "@google_bazel_common//third_party/java/auto:factory",
+ "@google_bazel_common//third_party/java/auto:value",
+ "@google_bazel_common//third_party/java/jsr330_inject",
+ ],
+)
diff --git a/javatests/dagger/functional/assisted/kotlin/BUILD b/javatests/dagger/functional/assisted/kotlin/BUILD
new file mode 100644
index 0000000..3c3421d
--- /dev/null
+++ b/javatests/dagger/functional/assisted/kotlin/BUILD
@@ -0,0 +1,49 @@
+# Copyright (C) 2021 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# Description:
+# Tests for internal code for implementing Hilt processors.
+
+load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "kt_jvm_library")
+load("//:build_defs.bzl", "DOCLINT_HTML_AND_SYNTAX", "SOURCE_7_TARGET_7")
+load("//:test_defs.bzl", "GenJavaTests")
+
+package(default_visibility = ["//:src"])
+
+kt_jvm_library(
+ name = "KotlinAssistedInjectionClasses",
+ srcs = ["KotlinAssistedInjectionClasses.kt"],
+ deps = [
+ "//:dagger_with_compiler",
+ ],
+)
+
+GenJavaTests(
+ name = "kotlin",
+ srcs = glob(
+ ["*.java"],
+ exclude = ["*.kt"],
+ ),
+ javacopts = DOCLINT_HTML_AND_SYNTAX,
+ lib_javacopts = SOURCE_7_TARGET_7,
+ test_only_deps = [
+ "//:dagger_with_compiler",
+ "@google_bazel_common//third_party/java/junit",
+ "@google_bazel_common//third_party/java/truth",
+ ],
+ # NOTE: This should not depend on Guava or jsr305 to ensure that Dagger can be
+ # used without Guava and jsr305 deps.
+ deps = [
+ ":KotlinAssistedInjectionClasses",
+ ],
+)
diff --git a/javatests/dagger/functional/assisted/kotlin/KotlinAssistedInjectionClasses.kt b/javatests/dagger/functional/assisted/kotlin/KotlinAssistedInjectionClasses.kt
new file mode 100644
index 0000000..e78873d
--- /dev/null
+++ b/javatests/dagger/functional/assisted/kotlin/KotlinAssistedInjectionClasses.kt
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2021 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.assisted.kotlin
+
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedFactory
+import dagger.assisted.AssistedInject
+import javax.inject.Inject
+
+class Dep @Inject constructor()
+
+class AssistedDep
+
+/** Assisted injection for a kotlin class. */
+class Foo @AssistedInject constructor(val dep: Dep, @Assisted val assistedDep: AssistedDep)
+
+/** Assisted injection for a kotlin data class. */
+data class FooData @AssistedInject constructor(val dep: Dep, @Assisted val assistedDep: AssistedDep)
+
+/** Assisted factory for a kotlin class */
+@AssistedFactory
+interface FooFactory {
+ fun create(assistedDep: AssistedDep): Foo
+}
+
+/** Assisted factory for a kotlin data class */
+@AssistedFactory
+interface FooDataFactory {
+ fun create(assistedDep: AssistedDep): FooData
+}
diff --git a/javatests/dagger/functional/assisted/kotlin/KotlinAssistedInjectionTest.java b/javatests/dagger/functional/assisted/kotlin/KotlinAssistedInjectionTest.java
new file mode 100644
index 0000000..7c597f8
--- /dev/null
+++ b/javatests/dagger/functional/assisted/kotlin/KotlinAssistedInjectionTest.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2021 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.assisted.kotlin;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import dagger.Component;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+// This is a regression test for https://github.com/google/dagger/issues/2299
+@RunWith(JUnit4.class)
+public final class KotlinAssistedInjectionTest {
+ @Component
+ interface TestComponent {
+ FooFactory fooFactory();
+
+ FooDataFactory fooDataFactory();
+ }
+
+ @Test
+ public void testFooFactory() {
+ FooFactory fooFactory = DaggerKotlinAssistedInjectionTest_TestComponent.create().fooFactory();
+ AssistedDep assistedDep = new AssistedDep();
+ Foo foo = fooFactory.create(assistedDep);
+ assertThat(foo.getAssistedDep()).isEqualTo(assistedDep);
+ }
+
+ @Test
+ public void testFooDataFactory() {
+ FooDataFactory fooDataFactory =
+ DaggerKotlinAssistedInjectionTest_TestComponent.create().fooDataFactory();
+ AssistedDep assistedDep = new AssistedDep();
+ FooData fooData = fooDataFactory.create(assistedDep);
+ assertThat(fooData.getAssistedDep()).isEqualTo(assistedDep);
+ }
+}
diff --git a/javatests/dagger/functional/assisted/subpackage/AccessibleFoo.java b/javatests/dagger/functional/assisted/subpackage/AccessibleFoo.java
new file mode 100644
index 0000000..16d420a
--- /dev/null
+++ b/javatests/dagger/functional/assisted/subpackage/AccessibleFoo.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.assisted.subpackage;
+
+import dagger.assisted.Assisted;
+import dagger.assisted.AssistedInject;
+
+/** An accessible type using assisted inject from a separate package. */
+public final class AccessibleFoo {
+ // Accessible for testing
+ public final Dep dep;
+ public final AssistedDep assistedDep;
+
+ @AssistedInject
+ AccessibleFoo(Dep dep, @Assisted AssistedDep assistedDep) {
+ this.dep = dep;
+ this.assistedDep = assistedDep;
+ }
+}
diff --git a/javatests/dagger/functional/assisted/subpackage/AssistedDep.java b/javatests/dagger/functional/assisted/subpackage/AssistedDep.java
new file mode 100644
index 0000000..b27b029
--- /dev/null
+++ b/javatests/dagger/functional/assisted/subpackage/AssistedDep.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.assisted.subpackage;
+
+/** An assisted dependency. */
+public final class AssistedDep {}
diff --git a/javatests/dagger/functional/assisted/subpackage/BUILD b/javatests/dagger/functional/assisted/subpackage/BUILD
new file mode 100644
index 0000000..644cf44
--- /dev/null
+++ b/javatests/dagger/functional/assisted/subpackage/BUILD
@@ -0,0 +1,27 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Functional tests for Dagger
+
+package(default_visibility = ["//:src"])
+
+java_library(
+ name = "subpackage",
+ srcs = glob(["*.java"]),
+ deps = [
+ "//:dagger_with_compiler",
+ "@google_bazel_common//third_party/java/jsr330_inject",
+ ],
+)
diff --git a/javatests/dagger/functional/assisted/subpackage/Dep.java b/javatests/dagger/functional/assisted/subpackage/Dep.java
new file mode 100644
index 0000000..a519b3f
--- /dev/null
+++ b/javatests/dagger/functional/assisted/subpackage/Dep.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.assisted.subpackage;
+
+import javax.inject.Inject;
+
+/** An {@link Inject} constructor dependency. */
+public final class Dep {
+ @Inject
+ Dep() {}
+}
diff --git a/javatests/dagger/functional/assisted/subpackage/InaccessibleFoo.java b/javatests/dagger/functional/assisted/subpackage/InaccessibleFoo.java
new file mode 100644
index 0000000..e093365
--- /dev/null
+++ b/javatests/dagger/functional/assisted/subpackage/InaccessibleFoo.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.assisted.subpackage;
+
+import dagger.assisted.Assisted;
+import dagger.assisted.AssistedInject;
+
+/** An inaccessible type using assisted inject from a separate package. */
+// TODO(bcorso): Remove public once we allow inaccessible types in fastInit.
+public final class InaccessibleFoo {
+ private final Dep dep;
+ private final AssistedDep assistedDep;
+
+ @AssistedInject
+ InaccessibleFoo(Dep dep, @Assisted AssistedDep assistedDep) {
+ this.dep = dep;
+ this.assistedDep = assistedDep;
+ }
+}
diff --git a/javatests/dagger/functional/assisted/subpackage/InaccessibleFooFactory.java b/javatests/dagger/functional/assisted/subpackage/InaccessibleFooFactory.java
new file mode 100644
index 0000000..a7efe57
--- /dev/null
+++ b/javatests/dagger/functional/assisted/subpackage/InaccessibleFooFactory.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.assisted.subpackage;
+
+import dagger.assisted.AssistedFactory;
+
+/** An accessible factory that creates an inaccessible type. */
+@AssistedFactory
+public interface InaccessibleFooFactory {
+ InaccessibleFoo create(AssistedDep assistedDep);
+}
diff --git a/javatests/dagger/functional/binds/SimpleBindingModule.java b/javatests/dagger/functional/binds/SimpleBindingModule.java
index e1d5227..e8c3ca6 100644
--- a/javatests/dagger/functional/binds/SimpleBindingModule.java
+++ b/javatests/dagger/functional/binds/SimpleBindingModule.java
@@ -20,6 +20,7 @@
import dagger.Module;
import dagger.Provides;
import dagger.Reusable;
+import dagger.functional.NeedsFactory;
import dagger.functional.SomeQualifier;
import dagger.multibindings.ElementsIntoSet;
import dagger.multibindings.IntKey;
@@ -35,6 +36,12 @@
@Module(includes = InterfaceModule.class)
abstract class SimpleBindingModule {
+
+ // Regression test for b/161853413 that binds an implementation that extends a generated class
+ // that is processed in the same build unit as the @Binds method.
+ @Binds
+ abstract NeedsFactory.SomethingFactory bindFooFactory(NeedsFactory.SomethingFactoryImpl impl);
+
@Binds
abstract Object bindObject(FooOfStrings impl);
@@ -147,7 +154,7 @@
@IntKey(123)
@SomeQualifier
abstract Object bindFooOfStringsIntoQualifiedMap(FooOfStrings fooOfStrings);
-
+
@Provides
@Named("For-123")
static String provide123String() {
diff --git a/javatests/dagger/functional/builder/BuildMethodCovariantReturnInherited.java b/javatests/dagger/functional/builder/BuildMethodCovariantReturnInherited.java
index 07ebbc8..9b1447c 100644
--- a/javatests/dagger/functional/builder/BuildMethodCovariantReturnInherited.java
+++ b/javatests/dagger/functional/builder/BuildMethodCovariantReturnInherited.java
@@ -18,6 +18,7 @@
import dagger.Component;
+
interface BuildMethodCovariantReturnInherited {
@Component
interface Simple {
diff --git a/javatests/dagger/functional/builder/BuilderBindsInstanceParameterTest.java b/javatests/dagger/functional/builder/BuilderBindsInstanceParameterTest.java
index 33d3816..d47c892 100644
--- a/javatests/dagger/functional/builder/BuilderBindsInstanceParameterTest.java
+++ b/javatests/dagger/functional/builder/BuilderBindsInstanceParameterTest.java
@@ -18,6 +18,7 @@
import static com.google.common.truth.Truth.assertThat;
+
import dagger.BindsInstance;
import dagger.Component;
import org.junit.Test;
diff --git a/javatests/dagger/functional/builder/GenericParent.java b/javatests/dagger/functional/builder/GenericParent.java
index 9563103..949514e 100644
--- a/javatests/dagger/functional/builder/GenericParent.java
+++ b/javatests/dagger/functional/builder/GenericParent.java
@@ -16,6 +16,7 @@
package dagger.functional.builder;
+
interface GenericParent<B> {
B subcomponentBuilder();
}
diff --git a/javatests/dagger/functional/cycle/Cycles.java b/javatests/dagger/functional/cycle/Cycles.java
index f4faeab..e17d619 100644
--- a/javatests/dagger/functional/cycle/Cycles.java
+++ b/javatests/dagger/functional/cycle/Cycles.java
@@ -97,7 +97,7 @@
this.sProvider = sProvider;
}
}
-
+
static class X {
public final Y y;
@@ -143,10 +143,10 @@
A a();
C c();
-
+
ChildCycleComponent child();
}
-
+
@Module
static class CycleModule {
@Provides
@@ -160,12 +160,12 @@
interface SelfCycleComponent {
S s();
}
-
+
@Subcomponent
interface ChildCycleComponent {
@SuppressWarnings("dependency-cycle")
A a();
-
+
@SuppressWarnings("dependency-cycle")
Object object();
}
diff --git a/javatests/dagger/functional/cycle/DoubleCheckCycleTest.java b/javatests/dagger/functional/cycle/DoubleCheckCycleTest.java
index b77ee3e..d77a713 100644
--- a/javatests/dagger/functional/cycle/DoubleCheckCycleTest.java
+++ b/javatests/dagger/functional/cycle/DoubleCheckCycleTest.java
@@ -181,6 +181,7 @@
})
.build();
+
int numThreads = 10;
CountDownLatch remainingTasks = new CountDownLatch(numThreads);
List<Thread> tasks = new ArrayList<>(numThreads);
diff --git a/javatests/dagger/functional/guava/BUILD b/javatests/dagger/functional/guava/BUILD
index 66492eb..ed8efd3 100644
--- a/javatests/dagger/functional/guava/BUILD
+++ b/javatests/dagger/functional/guava/BUILD
@@ -15,19 +15,20 @@
# Description:
# Functional tests for Dagger that depend on Guava
-package(default_visibility = ["//:src"])
-
load("//:build_defs.bzl", "DOCLINT_HTML_AND_SYNTAX")
load("//:test_defs.bzl", "GenJavaTests")
+package(default_visibility = ["//:src"])
+
GenJavaTests(
name = "guava_tests",
srcs = glob(["**/*.java"]),
javacopts = DOCLINT_HTML_AND_SYNTAX,
deps = [
"//:dagger_with_compiler",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
"@google_bazel_common//third_party/java/auto:value",
- "@google_bazel_common//third_party/java/guava",
"@google_bazel_common//third_party/java/jsr305_annotations",
"@google_bazel_common//third_party/java/jsr330_inject",
"@google_bazel_common//third_party/java/junit",
diff --git a/javatests/dagger/functional/jdk8/BUILD b/javatests/dagger/functional/jdk8/BUILD
index 6b76ba3..5e35c75 100644
--- a/javatests/dagger/functional/jdk8/BUILD
+++ b/javatests/dagger/functional/jdk8/BUILD
@@ -15,19 +15,20 @@
# Description:
# Functional tests for Dagger that depend on Guava
-package(default_visibility = ["//:src"])
-
load("//:build_defs.bzl", "DOCLINT_HTML_AND_SYNTAX")
load("//:test_defs.bzl", "GenJavaTests")
+package(default_visibility = ["//:src"])
+
GenJavaTests(
name = "jdk8_tests",
srcs = glob(["**/*.java"]),
javacopts = DOCLINT_HTML_AND_SYNTAX,
test_only_deps = [
- "@google_bazel_common//third_party/java/guava",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
"@google_bazel_common//third_party/java/junit",
- "@google_bazel_common//third_party/java/truth:truth8",
+ "@google_bazel_common//third_party/java/truth",
],
deps = [
"//:dagger_with_compiler",
diff --git a/javatests/dagger/functional/kotlin/BUILD b/javatests/dagger/functional/kotlin/BUILD
new file mode 100644
index 0000000..529eb69
--- /dev/null
+++ b/javatests/dagger/functional/kotlin/BUILD
@@ -0,0 +1,79 @@
+# Copyright (C) 2019 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Description:
+# Functional test code for Dagger-Android
+
+load("@rules_java//java:defs.bzl", "java_library")
+load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "kt_jvm_library")
+load("//:test_defs.bzl", "GenJavaTests")
+
+package(default_visibility = ["//:src"])
+
+kt_jvm_library(
+ name = "kotlin",
+ srcs = glob(
+ [
+ "*.java",
+ "*.kt",
+ ],
+ exclude = [
+ "*Test.java",
+ "JavaTestQualifier.java",
+ "FooWithInjectedQualifier.kt",
+ ],
+ ),
+ # TODO(danysantiago): Remove 'plugins' once kt_jvm_library supports 'exported_plugins'.
+ plugins = ["//javatests/dagger/functional/kotlin/processor:plugin"],
+ deps = [
+ ":foo_with_injected_qualifier",
+ ":java_qualifier",
+ "//:dagger_with_compiler",
+ "//javatests/dagger/functional/kotlin/processor:annotation",
+ ],
+)
+
+kt_jvm_library(
+ name = "foo_with_injected_qualifier",
+ srcs = ["FooWithInjectedQualifier.kt"],
+ deps = [
+ ":java_qualifier",
+ "//:dagger_with_compiler",
+ ],
+)
+
+java_library(
+ name = "java_qualifier",
+ srcs = ["JavaTestQualifier.java"],
+ deps = [
+ "//:dagger_with_compiler",
+ ],
+)
+
+GenJavaTests(
+ name = "kotlin_tests",
+ srcs = glob(["*Test.java"]),
+ functional = True,
+ test_only_deps = [
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "@google_bazel_common//third_party/java/junit",
+ "@google_bazel_common//third_party/java/truth",
+ ],
+ deps = [
+ ":foo_with_injected_qualifier",
+ ":kotlin",
+ "//:dagger_with_compiler",
+ ],
+)
diff --git a/javatests/dagger/functional/kotlin/CompanionModuleTest.java b/javatests/dagger/functional/kotlin/CompanionModuleTest.java
new file mode 100644
index 0000000..591c5d6
--- /dev/null
+++ b/javatests/dagger/functional/kotlin/CompanionModuleTest.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.kotlin;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class CompanionModuleTest {
+
+ @Test
+ public void verifyCompanionModule() {
+ TestKotlinComponentWithCompanionModule component =
+ DaggerTestKotlinComponentWithCompanionModule.create();
+ assertThat(component.getDataA()).isNotNull();
+ assertThat(component.getDataB()).isNotNull();
+ assertThat(component.getBoolean()).isTrue();
+ assertThat(component.getStringType()).isNotNull();
+ assertThat(component.getCatNamedStringType()).isEqualTo("Cat");
+ assertThat(component.getDogNamedStringType()).isEqualTo("Dog");
+ assertThat(component.getInterface()).isNotNull();
+ assertThat(component.getLong()).isEqualTo(4L);
+ assertThat(component.getDouble()).isEqualTo(1.0);
+ assertThat(component.getInteger()).isEqualTo(2);
+ }
+}
diff --git a/javatests/dagger/functional/kotlin/FooWithInjectedQualifier.kt b/javatests/dagger/functional/kotlin/FooWithInjectedQualifier.kt
new file mode 100644
index 0000000..6602f10
--- /dev/null
+++ b/javatests/dagger/functional/kotlin/FooWithInjectedQualifier.kt
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.kotlin
+
+import javax.inject.Inject
+
+class FooWithInjectedQualifier {
+ @Inject
+ @JavaTestQualifier
+ lateinit var qualifiedString: String
+
+ @Inject
+ @field:JavaTestQualifier
+ @NotAQualifier
+ lateinit var qualifiedStringWithPropertyAnnotaion: String
+}
+
+@Target(AnnotationTarget.PROPERTY)
+annotation class NotAQualifier
diff --git a/javatests/dagger/functional/kotlin/JavaTestQualifier.java b/javatests/dagger/functional/kotlin/JavaTestQualifier.java
new file mode 100644
index 0000000..156f436
--- /dev/null
+++ b/javatests/dagger/functional/kotlin/JavaTestQualifier.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.kotlin;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Retention;
+import javax.inject.Qualifier;
+
+@Qualifier
+@Retention(RUNTIME)
+public @interface JavaTestQualifier {}
diff --git a/javatests/dagger/functional/kotlin/JavaTestQualifierWithTarget.java b/javatests/dagger/functional/kotlin/JavaTestQualifierWithTarget.java
new file mode 100644
index 0000000..3bc2e4e
--- /dev/null
+++ b/javatests/dagger/functional/kotlin/JavaTestQualifierWithTarget.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.kotlin;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+import javax.inject.Qualifier;
+
+@Qualifier
+@Retention(RUNTIME)
+@Target({ElementType.FIELD, ElementType.METHOD})
+public @interface JavaTestQualifierWithTarget {}
diff --git a/javatests/dagger/functional/kotlin/ObjectModuleTest.java b/javatests/dagger/functional/kotlin/ObjectModuleTest.java
new file mode 100644
index 0000000..a37be44
--- /dev/null
+++ b/javatests/dagger/functional/kotlin/ObjectModuleTest.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.kotlin;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class ObjectModuleTest {
+
+ @Test
+ public void verifyObjectModule() {
+ TestKotlinComponentWithObjectModule component =
+ DaggerTestKotlinComponentWithObjectModule.create();
+ assertThat(component.getDataA()).isNotNull();
+ assertThat(component.getDataAFromNestedModule()).isNotNull();
+ assertThat(component.getDataB()).isNotNull();
+ assertThat(component.getSetOfDataA()).isNotNull();
+ assertThat(component.getSetOfDataA()).hasSize(1);
+ assertThat(component.getPrimitiveType()).isTrue();
+ }
+}
diff --git a/javatests/dagger/functional/kotlin/PropertyQualifierTest.java b/javatests/dagger/functional/kotlin/PropertyQualifierTest.java
new file mode 100644
index 0000000..e0ebf3c
--- /dev/null
+++ b/javatests/dagger/functional/kotlin/PropertyQualifierTest.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.kotlin;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class PropertyQualifierTest {
+
+ @Test
+ public void verifyQualifiedBinding() {
+ TestMemberInjectedClassWithQualifier injectedClass = new TestMemberInjectedClassWithQualifier();
+ DaggerTestKotlinComponentWithQualifier.create().inject(injectedClass);
+
+ assertThat(injectedClass.javaDataA).isNotNull();
+ assertThat(injectedClass.javaDataB).isNotNull();
+ assertThat(injectedClass.javaWithTargetDataA).isNotNull();
+ assertThat(injectedClass.kotlinDataA).isNotNull();
+ assertThat(injectedClass.dataWithConstructionInjection).isNotNull();
+ assertThat(injectedClass.dataWithConstructionInjection.getData()).isNotNull();
+ }
+
+ @Test
+ public void verifyQualifiedBinding_acrossCompilation() {
+ FooWithInjectedQualifier injectedClass = new FooWithInjectedQualifier();
+ DaggerTestKotlinComponentWithQualifier.create().inject(injectedClass);
+
+ assertThat(injectedClass.getQualifiedString()).isEqualTo("qualified string");
+ assertThat(injectedClass.getQualifiedStringWithPropertyAnnotaion())
+ .isEqualTo("qualified string");
+ }
+}
diff --git a/javatests/dagger/functional/kotlin/PublicModuleWithNonPublicInclude.java b/javatests/dagger/functional/kotlin/PublicModuleWithNonPublicInclude.java
new file mode 100644
index 0000000..f927186
--- /dev/null
+++ b/javatests/dagger/functional/kotlin/PublicModuleWithNonPublicInclude.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.kotlin;
+
+import dagger.Module;
+
+/** Verifies that a non-public included Kotlin object module does not fail compilation. */
+@Module(includes = {NonPublicObjectModule.class})
+public class PublicModuleWithNonPublicInclude {}
diff --git a/javatests/dagger/functional/kotlin/TestComponentWithCompanionModule.kt b/javatests/dagger/functional/kotlin/TestComponentWithCompanionModule.kt
new file mode 100644
index 0000000..1eaa3f5
--- /dev/null
+++ b/javatests/dagger/functional/kotlin/TestComponentWithCompanionModule.kt
@@ -0,0 +1,97 @@
+package dagger.functional.kotlin
+
+import dagger.Binds
+import dagger.Component
+import dagger.Module
+import dagger.Provides
+import javax.inject.Named
+
+@Component(
+ modules = [
+ TestKotlinModuleWithCompanion::class,
+ TestKotlinModuleWithNamedCompanion::class,
+ TestKotlinAbstractModuleWithCompanion::class,
+ TestKotlinWorkaroundModuleWithCompanion::class,
+ TestKotlinModuleWithPrivateCompanion::class
+ ]
+)
+interface TestKotlinComponentWithCompanionModule {
+ fun getDataA(): TestDataA
+ fun getDataB(): TestDataB
+ fun getBoolean(): Boolean
+ fun getStringType(): String
+ @Named("Cat")
+ fun getCatNamedStringType(): String
+ @Named("Dog")
+ fun getDogNamedStringType(): String
+
+ fun getInterface(): TestInterface
+ fun getLong(): Long
+ fun getDouble(): Double
+ fun getInteger(): Int
+}
+
+@Module
+class TestKotlinModuleWithCompanion {
+ @Provides
+ fun provideDataA() = TestDataA("test")
+
+ companion object {
+ @Provides
+ fun provideDataB() = TestDataB("test")
+
+ @Provides
+ fun provideBoolean(): Boolean = true
+ }
+}
+
+@Module
+class TestKotlinModuleWithNamedCompanion {
+
+ @Provides
+ @Named("Cat")
+ fun provideNamedString() = "Cat"
+
+ companion object Foo {
+ @Provides
+ fun provideStringType(): String = ""
+ }
+}
+
+@Module
+abstract class TestKotlinAbstractModuleWithCompanion {
+
+ @Binds
+ abstract fun bindInterface(injectable: TestInjectable): TestInterface
+
+ companion object {
+ @Provides
+ fun provideLong() = 4L
+ }
+}
+
+@Module
+class TestKotlinWorkaroundModuleWithCompanion {
+
+ @Provides
+ fun provideDouble() = 1.0
+
+ @Module
+ companion object {
+ @Provides
+ @JvmStatic
+ fun provideInteger() = 2
+ }
+}
+
+@Module
+class TestKotlinModuleWithPrivateCompanion {
+
+ @Provides
+ @Named("Dog")
+ fun getNamedStringType() = "Dog"
+
+ private companion object {
+ fun randomFunction() = ""
+ }
+}
diff --git a/javatests/dagger/functional/kotlin/TestComponentWithObjectModule.kt b/javatests/dagger/functional/kotlin/TestComponentWithObjectModule.kt
new file mode 100644
index 0000000..e390aba
--- /dev/null
+++ b/javatests/dagger/functional/kotlin/TestComponentWithObjectModule.kt
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.kotlin
+
+import dagger.Component
+import dagger.Module
+import dagger.Provides
+import dagger.multibindings.IntoSet
+import javax.inject.Named
+
+@Component(
+ modules = [
+ TestKotlinObjectModule::class,
+ TestModuleForNesting.TestNestedKotlinObjectModule::class
+ ]
+)
+interface TestKotlinComponentWithObjectModule {
+ fun getDataA(): TestDataA
+ @Named("nested-data-a")
+ fun getDataAFromNestedModule(): TestDataA
+ fun getDataB(): TestDataB
+ fun getSetOfDataA(): Set<TestDataA>
+ fun getPrimitiveType(): Boolean
+}
+
+@Module
+object TestKotlinObjectModule {
+ @Provides
+ fun provideDataA() = TestDataA("test")
+
+ @Provides
+ fun providePrimitiveType(): Boolean = true
+
+ @Provides
+ @JvmStatic
+ fun provideDataB() = TestDataB("test")
+
+ @Provides
+ @IntoSet
+ fun provideIntoMapDataA() = TestDataA("set-test")
+}
+
+class TestModuleForNesting {
+ @Module
+ object TestNestedKotlinObjectModule {
+ @Provides
+ @Named("nested-data-a")
+ fun provideDataA() = TestDataA("test")
+ }
+}
+
+@Module
+private object NonPublicObjectModule {
+ @Provides
+ fun provideInt() = 42
+}
diff --git a/javatests/dagger/functional/kotlin/TestComponentWithQualifier.kt b/javatests/dagger/functional/kotlin/TestComponentWithQualifier.kt
new file mode 100644
index 0000000..9aeb2d8
--- /dev/null
+++ b/javatests/dagger/functional/kotlin/TestComponentWithQualifier.kt
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.kotlin
+
+import dagger.Component
+import dagger.Module
+import dagger.Provides
+import dagger.functional.kotlin.processor.TriggerGeneratedTypeProcessor
+import javax.inject.Inject
+
+@Component(modules = [TestKotlinModuleWithQualifier::class])
+interface TestKotlinComponentWithQualifier {
+ fun inject(testInjectedClassWithQualifier: TestMemberInjectedClassWithQualifier)
+ fun inject(fooWithInjectedQualifier: FooWithInjectedQualifier)
+}
+
+@Module
+class TestKotlinModuleWithQualifier {
+ @Provides
+ @JavaTestQualifier
+ fun provideJavaDataA() = TestDataA("test")
+
+ @Provides
+ @JavaTestQualifier
+ fun provideJavaDataB() = TestDataB("test")
+
+ @Provides
+ @JavaTestQualifierWithTarget
+ fun provideJavaWithTargetDataA() = TestDataA("test")
+
+ @Provides
+ @KotlinTestQualifier
+ fun provideKotlinDataA() = TestDataA("test")
+
+ @Provides
+ @JavaTestQualifier
+ fun provideString() = "qualified string"
+}
+
+class TestConstructionInjectedClassWithQualifier @Inject constructor(
+ @JavaTestQualifier val data: TestDataA
+)
+
+@TriggerGeneratedTypeProcessor
+class TestMemberInjectedClassWithQualifier {
+ @Inject
+ @JavaTestQualifier
+ lateinit var javaDataA: TestDataA
+
+ @Inject
+ @field:JavaTestQualifier
+ lateinit var javaDataB: TestDataB
+
+ @Inject
+ @JavaTestQualifierWithTarget
+ lateinit var javaWithTargetDataA: TestDataA
+
+ @Inject
+ @JavaTestQualifier
+ lateinit var kotlinDataA: TestDataA
+
+ @Inject
+ lateinit var dataWithConstructionInjection: TestConstructionInjectedClassWithQualifier
+
+ val noBackingFieldProperty: Int
+ get() = 0
+
+ val delegatedProperty by lazy { "" }
+
+ val generatedTypeProperty = dagger.functional.kotlin.GeneratedType()
+
+ val generatedTypeDelegatedProperty by lazy { dagger.functional.kotlin.GeneratedType() }
+}
diff --git a/javatests/dagger/functional/kotlin/TestKotlinClasses.kt b/javatests/dagger/functional/kotlin/TestKotlinClasses.kt
new file mode 100644
index 0000000..5d151fc
--- /dev/null
+++ b/javatests/dagger/functional/kotlin/TestKotlinClasses.kt
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.kotlin
+
+import javax.inject.Inject
+import javax.inject.Qualifier
+
+data class TestDataA(val data: String)
+data class TestDataB(val data: String)
+
+interface TestInterface
+class TestInjectable @Inject constructor() : TestInterface
+
+@Qualifier
+@Retention(AnnotationRetention.RUNTIME)
+annotation class KotlinTestQualifier
diff --git a/javatests/dagger/functional/kotlin/processor/BUILD b/javatests/dagger/functional/kotlin/processor/BUILD
new file mode 100644
index 0000000..31a45c7
--- /dev/null
+++ b/javatests/dagger/functional/kotlin/processor/BUILD
@@ -0,0 +1,37 @@
+# Copyright (C) 2019 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "kt_jvm_library")
+
+package(default_visibility = ["//:src"])
+
+java_plugin(
+ name = "plugin",
+ generates_api = 1,
+ processor_class = "dagger.functional.kotlin.processor.TestGeneratedTypeProcessor",
+ deps = [":processor"],
+)
+
+kt_jvm_library(
+ name = "processor",
+ srcs = ["TestGeneratedTypeProcessor.kt"],
+ deps = [
+ "@google_bazel_common//third_party/java/auto:service",
+ "@google_bazel_common//third_party/java/javapoet",
+ ],
+)
+
+kt_jvm_library(
+ name = "annotation",
+ srcs = ["TriggerGeneratedTypeProcessor.kt"],
+)
diff --git a/javatests/dagger/functional/kotlin/processor/TestGeneratedTypeProcessor.kt b/javatests/dagger/functional/kotlin/processor/TestGeneratedTypeProcessor.kt
new file mode 100644
index 0000000..4a1d6e2
--- /dev/null
+++ b/javatests/dagger/functional/kotlin/processor/TestGeneratedTypeProcessor.kt
@@ -0,0 +1,48 @@
+package dagger.functional.kotlin.processor
+
+import com.google.auto.service.AutoService
+import com.squareup.javapoet.JavaFile
+import com.squareup.javapoet.TypeSpec
+import javax.annotation.processing.AbstractProcessor
+import javax.annotation.processing.Processor
+import javax.annotation.processing.RoundEnvironment
+import javax.lang.model.SourceVersion
+import javax.lang.model.element.Modifier
+import javax.lang.model.element.TypeElement
+
+/**
+ * A processor to be used in functional tests that will generate a simple class with fqname
+ * 'dagger.functional.kotlin.GeneratedType'. This processor is useful for testing situations
+ * with KAPT where a type is not resolvable and for which KAPT will generate stubs containing
+ * the 'error.NonExistentClass' type.
+ */
+@AutoService(Processor::class)
+class TestGeneratedTypeProcessor : AbstractProcessor() {
+
+ private var isSourceGenerated = false
+
+ override fun getSupportedAnnotationTypes() =
+ mutableSetOf("dagger.functional.kotlin.processor.TriggerGeneratedTypeProcessor")
+
+ override fun getSupportedSourceVersion() = SourceVersion.latestSupported()
+
+ override fun process(
+ annotations: MutableSet<out TypeElement>,
+ roundEnv: RoundEnvironment
+ ): Boolean {
+ if (isSourceGenerated) {
+ return false
+ }
+
+ JavaFile.builder(
+ "dagger.functional.kotlin",
+ TypeSpec.classBuilder("GeneratedType")
+ .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
+ .build()
+ ).build().writeTo(processingEnv.filer)
+
+ isSourceGenerated = true
+
+ return false
+ }
+}
diff --git a/javatests/dagger/functional/kotlin/processor/TriggerGeneratedTypeProcessor.kt b/javatests/dagger/functional/kotlin/processor/TriggerGeneratedTypeProcessor.kt
new file mode 100644
index 0000000..c240fd3
--- /dev/null
+++ b/javatests/dagger/functional/kotlin/processor/TriggerGeneratedTypeProcessor.kt
@@ -0,0 +1,4 @@
+package dagger.functional.kotlin.processor
+
+@Retention(AnnotationRetention.BINARY)
+annotation class TriggerGeneratedTypeProcessor
diff --git a/javatests/dagger/functional/membersinject/MembersInjectGenericParent.java b/javatests/dagger/functional/membersinject/MembersInjectGenericParent.java
index 3519348..4a08455 100644
--- a/javatests/dagger/functional/membersinject/MembersInjectGenericParent.java
+++ b/javatests/dagger/functional/membersinject/MembersInjectGenericParent.java
@@ -18,6 +18,7 @@
import javax.inject.Inject;
+
class MembersInjectGenericParent<T> {
@Inject T t;
diff --git a/javatests/dagger/functional/membersinject/MembersInjectModule.java b/javatests/dagger/functional/membersinject/MembersInjectModule.java
index d60a7d1..6e182dd 100644
--- a/javatests/dagger/functional/membersinject/MembersInjectModule.java
+++ b/javatests/dagger/functional/membersinject/MembersInjectModule.java
@@ -26,7 +26,7 @@
@Provides int[] provideIntArray() { return new int[10]; }
- @SuppressWarnings("unchecked")
+ @SuppressWarnings({"unchecked", "rawtypes"})
@Provides MembersInjectGenericParent<String[]>[] provideFooArrayOfStringArray() { return new MembersInjectGenericParent[10]; }
}
diff --git a/javatests/dagger/functional/membersinject/MembersInjectTest.java b/javatests/dagger/functional/membersinject/MembersInjectTest.java
index 0617fd5..31e4f45 100644
--- a/javatests/dagger/functional/membersinject/MembersInjectTest.java
+++ b/javatests/dagger/functional/membersinject/MembersInjectTest.java
@@ -18,12 +18,15 @@
import static com.google.common.truth.Truth.assertThat;
+import dagger.BindsInstance;
+import dagger.Component;
import dagger.MembersInjector;
import dagger.functional.multipackage.DaggerMembersInjectionVisibilityComponent;
import dagger.functional.multipackage.MembersInjectionVisibilityComponent;
import dagger.functional.multipackage.a.AGrandchild;
import dagger.functional.multipackage.a.AParent;
import dagger.functional.multipackage.b.BChild;
+import javax.inject.Inject;
import javax.inject.Provider;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -93,4 +96,35 @@
injector.injectMembers(child);
assertThat(child.t).isEqualTo("field!");
}
+
+ public static final class A extends B {
+ // No injected members
+ }
+
+ public static class B extends C {
+ // No injected members
+ }
+
+ public static class C {
+ @Inject String value;
+ }
+
+ @Component
+ interface NonLocalMembersComponent {
+ MembersInjector<A> getAMembersInjector();
+
+ @Component.Factory
+ interface Factory {
+ NonLocalMembersComponent create(@BindsInstance String value);
+ }
+ }
+
+ @Test
+ public void testNonLocalMembersInjection() {
+ MembersInjector<A> membersInjector = DaggerMembersInjectTest_NonLocalMembersComponent.factory()
+ .create("test").getAMembersInjector();
+ A testA = new A();
+ membersInjector.injectMembers(testA);
+ assertThat(testA.value).isEqualTo("test");
+ }
}
diff --git a/javatests/dagger/functional/membersinject/MembersWithInstanceNameTest.java b/javatests/dagger/functional/membersinject/MembersWithInstanceNameTest.java
new file mode 100644
index 0000000..7cd97d9
--- /dev/null
+++ b/javatests/dagger/functional/membersinject/MembersWithInstanceNameTest.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.membersinject;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import dagger.Component;
+import dagger.Module;
+import dagger.Provides;
+import javax.inject.Inject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class MembersWithInstanceNameTest {
+
+ static final class Foo {
+ // Checks that member injection fields can use "instance" as a name (b/175818837).
+ @Inject String instance;
+
+ @Inject Foo() {}
+ }
+
+ @Module
+ interface TestModule {
+ @Provides
+ static String provideString() {
+ return "test";
+ }
+ }
+
+ @Component(modules = TestModule.class)
+ interface TestComponent {
+ Foo foo();
+ }
+
+ @Test
+ public void testMemberWithInstanceName() {
+ TestComponent component = DaggerMembersWithInstanceNameTest_TestComponent.create();
+ Foo foo = component.foo();
+ assertThat(foo).isNotNull();
+ assertThat(foo.instance).isEqualTo("test");
+ }
+}
diff --git a/javatests/dagger/functional/modules/ModuleIncludesTest.java b/javatests/dagger/functional/modules/ModuleIncludesTest.java
index 38f7d97..474cb80 100644
--- a/javatests/dagger/functional/modules/ModuleIncludesTest.java
+++ b/javatests/dagger/functional/modules/ModuleIncludesTest.java
@@ -19,6 +19,7 @@
import static com.google.common.truth.Truth.assertThat;
import dagger.Component;
+import dagger.functional.modules.subpackage.FooForProvision;
import dagger.functional.modules.subpackage.PublicModule;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -30,6 +31,8 @@
@Component(modules = PublicModule.class)
interface TestComponent {
Object object();
+
+ FooForProvision fooForProvision();
}
@Test
diff --git a/javatests/dagger/functional/modules/subpackage/FooForProvision.java b/javatests/dagger/functional/modules/subpackage/FooForProvision.java
new file mode 100644
index 0000000..60b4482
--- /dev/null
+++ b/javatests/dagger/functional/modules/subpackage/FooForProvision.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.modules.subpackage;
+
+/** This object is provisioned by NonAbstractPackagePrivate module */
+public class FooForProvision {}
diff --git a/javatests/dagger/functional/modules/subpackage/NonAbstractPackagePrivateModule.java b/javatests/dagger/functional/modules/subpackage/NonAbstractPackagePrivateModule.java
new file mode 100644
index 0000000..47d2441
--- /dev/null
+++ b/javatests/dagger/functional/modules/subpackage/NonAbstractPackagePrivateModule.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.modules.subpackage;
+
+import dagger.Module;
+import dagger.Provides;
+
+/**
+ * We needed a separate test for non-abstract transitively included pkg-private modules. The reason
+ * is that this caused a build failures when the component was generated in a separate package
+ * because the generated no-op method references the inaccessible package-private type, so we
+ * omitted those no-op methods to support such modules.
+ */
+@Module
+class NonAbstractPackagePrivateModule {
+ @Provides
+ static FooForProvision provideFoo() {
+ return new FooForProvision();
+ }
+
+ private NonAbstractPackagePrivateModule() {}
+}
diff --git a/javatests/dagger/functional/modules/subpackage/PublicModule.java b/javatests/dagger/functional/modules/subpackage/PublicModule.java
index 7c5fd29..9eade52 100644
--- a/javatests/dagger/functional/modules/subpackage/PublicModule.java
+++ b/javatests/dagger/functional/modules/subpackage/PublicModule.java
@@ -19,7 +19,7 @@
import dagger.Module;
import dagger.Provides;
-@Module(includes = PackagePrivateModule.class)
+@Module(includes = {PackagePrivateModule.class, NonAbstractPackagePrivateModule.class})
public abstract class PublicModule {
@Provides
static int provideInt() {
diff --git a/javatests/dagger/functional/multibindings/ComplexMapKeysInDifferentOrderTest.java b/javatests/dagger/functional/multibindings/ComplexMapKeysInDifferentOrderTest.java
index f2b5598..801d120 100644
--- a/javatests/dagger/functional/multibindings/ComplexMapKeysInDifferentOrderTest.java
+++ b/javatests/dagger/functional/multibindings/ComplexMapKeysInDifferentOrderTest.java
@@ -17,6 +17,7 @@
package dagger.functional.multibindings;
import static com.google.common.truth.Truth.assertThat;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
import com.google.auto.value.AutoAnnotation;
import dagger.Component;
@@ -24,6 +25,7 @@
import dagger.Module;
import dagger.Provides;
import dagger.multibindings.IntoMap;
+import java.lang.annotation.Retention;
import java.util.Map;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -31,6 +33,7 @@
@RunWith(JUnit4.class)
public final class ComplexMapKeysInDifferentOrderTest {
+ @Retention(RUNTIME)
@MapKey(unwrapValue = false)
@interface ComplexMapKey {
int i();
diff --git a/javatests/dagger/functional/multibindings/MapKeyWithDefaultTest.java b/javatests/dagger/functional/multibindings/MapKeyWithDefaultTest.java
index f188405..70260e7 100644
--- a/javatests/dagger/functional/multibindings/MapKeyWithDefaultTest.java
+++ b/javatests/dagger/functional/multibindings/MapKeyWithDefaultTest.java
@@ -17,6 +17,7 @@
package dagger.functional.multibindings;
import static com.google.common.truth.Truth.assertThat;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
import com.google.auto.value.AutoAnnotation;
import dagger.Component;
@@ -24,6 +25,7 @@
import dagger.Module;
import dagger.Provides;
import dagger.multibindings.IntoMap;
+import java.lang.annotation.Retention;
import java.util.Map;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -31,6 +33,7 @@
@RunWith(JUnit4.class)
public final class MapKeyWithDefaultTest {
+ @Retention(RUNTIME)
@MapKey(unwrapValue = false)
@interface MapKeyWithDefault {
boolean hasDefault() default true;
diff --git a/javatests/dagger/functional/producers/BUILD b/javatests/dagger/functional/producers/BUILD
index 36c9701..f69b3cb 100644
--- a/javatests/dagger/functional/producers/BUILD
+++ b/javatests/dagger/functional/producers/BUILD
@@ -15,8 +15,6 @@
# Description:
# Functional tests for Dagger Producers
-package(default_visibility = ["//:src"])
-
load(
"//:build_defs.bzl",
"DOCLINT_HTML_AND_SYNTAX",
@@ -25,20 +23,24 @@
)
load("//:test_defs.bzl", "GenJavaTests")
+package(default_visibility = ["//:src"])
+
GenJavaTests(
name = "producers-functional-tests",
srcs = glob(["**/*.java"]),
- javacopts = SOURCE_7_TARGET_7 + DOCLINT_HTML_AND_SYNTAX + DOCLINT_REFERENCES,
+ javacopts = DOCLINT_HTML_AND_SYNTAX + DOCLINT_REFERENCES,
+ lib_javacopts = SOURCE_7_TARGET_7,
deps = [
"//:producers_with_compiler",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/internal/guava:concurrent",
"@google_bazel_common//third_party/java/auto:value",
- "@google_bazel_common//third_party/java/guava",
"@google_bazel_common//third_party/java/jsr305_annotations",
"@google_bazel_common//third_party/java/jsr330_inject",
"@google_bazel_common//third_party/java/junit",
"@google_bazel_common//third_party/java/mockito",
"@google_bazel_common//third_party/java/truth",
- "@google_bazel_common//third_party/java/truth:truth8",
],
)
diff --git a/javatests/dagger/functional/producers/ComponentDependenciesTest.java b/javatests/dagger/functional/producers/ComponentDependenciesTest.java
new file mode 100644
index 0000000..d4ad9f0
--- /dev/null
+++ b/javatests/dagger/functional/producers/ComponentDependenciesTest.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.functional.producers;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import dagger.producers.ProductionComponent;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests component dependencies.
+ */
+@RunWith(JUnit4.class)
+public final class ComponentDependenciesTest {
+ public interface One {
+ ListenableFuture<String> getString();
+ }
+
+ public interface Two {
+ ListenableFuture<String> getString();
+ }
+
+ public interface Merged extends One, Two {
+ }
+
+ @ProductionComponent(dependencies = Merged.class)
+ interface TestProductionComponent {
+ ListenableFuture<String> getString();
+
+ @ProductionComponent.Builder
+ interface Builder {
+ Builder dep(Merged dep);
+
+ TestProductionComponent build();
+ }
+ }
+
+ @Test
+ public void testSameMethodTwiceProduction() throws Exception {
+ TestProductionComponent component =
+ DaggerComponentDependenciesTest_TestProductionComponent.builder().dep(
+ () -> Futures.immediateFuture("test")).build();
+ assertThat(component.getString().get()).isEqualTo("test");
+ }
+
+ public interface OneOverride {
+ ListenableFuture<?> getString();
+ }
+
+ public interface TwoOverride {
+ ListenableFuture<?> getString();
+ }
+
+ public interface MergedOverride extends OneOverride, TwoOverride {
+ @Override
+ ListenableFuture<String> getString();
+ }
+
+ @ProductionComponent(dependencies = MergedOverride.class)
+ interface TestOverrideComponent {
+ ListenableFuture<String> getString();
+
+ @ProductionComponent.Builder
+ interface Builder {
+ Builder dep(MergedOverride dep);
+
+ TestOverrideComponent build();
+ }
+ }
+
+ @Test
+ public void testPolymorphicOverridesStillCompiles() throws Exception {
+ TestOverrideComponent component =
+ DaggerComponentDependenciesTest_TestOverrideComponent.builder().dep(
+ () -> Futures.immediateFuture("test")).build();
+ assertThat(component.getString().get()).isEqualTo("test");
+ }
+}
diff --git a/javatests/dagger/functional/producers/ProducerFactoryTest.java b/javatests/dagger/functional/producers/ProducerFactoryTest.java
index c85e342..6df526e 100644
--- a/javatests/dagger/functional/producers/ProducerFactoryTest.java
+++ b/javatests/dagger/functional/producers/ProducerFactoryTest.java
@@ -18,7 +18,7 @@
import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.when;
diff --git a/javatests/dagger/functional/producers/monitoring/MonitoringTest.java b/javatests/dagger/functional/producers/monitoring/MonitoringTest.java
index 543835f..32007a9 100644
--- a/javatests/dagger/functional/producers/monitoring/MonitoringTest.java
+++ b/javatests/dagger/functional/producers/monitoring/MonitoringTest.java
@@ -18,7 +18,7 @@
import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.fail;
-import static org.mockito.Mockito.any;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verifyNoMoreInteractions;
diff --git a/javatests/dagger/functional/producers/multibindings/MultibindingComponent.java b/javatests/dagger/functional/producers/multibindings/MultibindingComponent.java
index fa5c6ee..a5eb8a3 100644
--- a/javatests/dagger/functional/producers/multibindings/MultibindingComponent.java
+++ b/javatests/dagger/functional/producers/multibindings/MultibindingComponent.java
@@ -30,6 +30,7 @@
import java.util.Map;
import java.util.Set;
+
@ProductionComponent(
modules = {ExecutorModule.class, MultibindingProducerModule.class, MultibindingModule.class}
)
diff --git a/javatests/dagger/functional/spi/BUILD b/javatests/dagger/functional/spi/BUILD
index fffaddb..8119bdd 100644
--- a/javatests/dagger/functional/spi/BUILD
+++ b/javatests/dagger/functional/spi/BUILD
@@ -15,18 +15,19 @@
# Description:
# Functional tests for the experimental Dagger SPI
-package(default_visibility = ["//:src"])
-
+load("@rules_java//java:defs.bzl", "java_library", "java_plugin")
load("//:test_defs.bzl", "GenJavaTests")
+package(default_visibility = ["//:src"])
+
java_plugin(
name = "test_plugin",
srcs = ["TestPlugin.java"],
deps = [
- "//java/dagger/model",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
"//java/dagger/spi",
"@google_bazel_common//third_party/java/auto:service",
- "@google_bazel_common//third_party/java/guava",
"@google_bazel_common//third_party/java/javapoet",
],
)
diff --git a/javatests/dagger/functional/subcomponent/GenericParentComponent.java b/javatests/dagger/functional/subcomponent/GenericParentComponent.java
index f49083b..10745d7 100644
--- a/javatests/dagger/functional/subcomponent/GenericParentComponent.java
+++ b/javatests/dagger/functional/subcomponent/GenericParentComponent.java
@@ -16,6 +16,7 @@
package dagger.functional.subcomponent;
+
interface GenericParentComponent<B> {
B subcomponent();
}
diff --git a/javatests/dagger/functional/subcomponent/SubcomponentTest.java b/javatests/dagger/functional/subcomponent/SubcomponentTest.java
index c34de0a..380322b 100644
--- a/javatests/dagger/functional/subcomponent/SubcomponentTest.java
+++ b/javatests/dagger/functional/subcomponent/SubcomponentTest.java
@@ -50,6 +50,7 @@
this.childComponent = childComponent;
}
+
@Test
public void scopePropagatesUpward_class() {
assertThat(childComponent.requiresSingleton().singletonType())
diff --git a/javatests/dagger/functional/subcomponent/hiding/ChildComponent.java b/javatests/dagger/functional/subcomponent/hiding/ChildComponent.java
index 7cb4fce..846ceb0 100644
--- a/javatests/dagger/functional/subcomponent/hiding/ChildComponent.java
+++ b/javatests/dagger/functional/subcomponent/hiding/ChildComponent.java
@@ -16,6 +16,7 @@
package dagger.functional.subcomponent.hiding;
+
import dagger.Subcomponent;
@Subcomponent(modules = dagger.functional.subcomponent.hiding.b.CommonModuleName.class)
diff --git a/javatests/dagger/functional/tck/BUILD b/javatests/dagger/functional/tck/BUILD
index 7526bf0..9cad2a0 100644
--- a/javatests/dagger/functional/tck/BUILD
+++ b/javatests/dagger/functional/tck/BUILD
@@ -15,8 +15,6 @@
# Description:
# TCK tests for Dagger
-package(default_visibility = ["//:src"])
-
load(
"//:build_defs.bzl",
"DOCLINT_HTML_AND_SYNTAX",
@@ -24,6 +22,8 @@
)
load("//:test_defs.bzl", "GenJavaTests")
+package(default_visibility = ["//:src"])
+
GenJavaTests(
name = "tck_tests",
srcs = glob(["*.java"]),
diff --git a/javatests/dagger/grpc/functional/server/BUILD b/javatests/dagger/grpc/functional/server/BUILD
index 1e8c2e6..0603801 100644
--- a/javatests/dagger/grpc/functional/server/BUILD
+++ b/javatests/dagger/grpc/functional/server/BUILD
@@ -1,9 +1,8 @@
# Functional tests for Dagger-gRPC
-package(default_visibility = ["//:src"])
+load("@rules_java//java:defs.bzl", "java_proto_library")
-load("//:build_defs.bzl", "DOCLINT_HTML_AND_SYNTAX", "DOCLINT_REFERENCES")
-load("//:test_defs.bzl", "GenJavaTests")
+package(default_visibility = ["//:src"])
# TODO(dpb): enable tests once java_grpc_library is ready in bazel:
# https://github.com/grpc/grpc-java/issues/2756
diff --git a/javatests/dagger/hilt/android/processor/AndroidCompilers.java b/javatests/dagger/hilt/android/processor/AndroidCompilers.java
new file mode 100644
index 0000000..5ce0a2a
--- /dev/null
+++ b/javatests/dagger/hilt/android/processor/AndroidCompilers.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor;
+
+import static java.util.stream.Collectors.toMap;
+
+import com.google.common.collect.ImmutableList;
+import com.google.testing.compile.Compiler;
+import dagger.hilt.android.processor.internal.androidentrypoint.AndroidEntryPointProcessor;
+import dagger.hilt.android.processor.internal.customtestapplication.CustomTestApplicationProcessor;
+import dagger.hilt.android.processor.internal.uninstallmodules.UninstallModulesProcessor;
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsProcessor;
+import dagger.hilt.processor.internal.definecomponent.DefineComponentProcessor;
+import dagger.hilt.processor.internal.generatesrootinput.GeneratesRootInputProcessor;
+import dagger.hilt.processor.internal.originatingelement.OriginatingElementProcessor;
+import dagger.hilt.processor.internal.root.RootProcessor;
+import dagger.internal.codegen.ComponentProcessor;
+import dagger.testing.compile.CompilerTests;
+import java.util.Arrays;
+import java.util.Map;
+import javax.annotation.processing.Processor;
+import com.tschuchort.compiletesting.KotlinCompilation;
+
+/** {@link Compiler} instances for testing Android Hilt. */
+public final class AndroidCompilers {
+
+ public static Compiler compiler(Processor... extraProcessors) {
+ Map<Class<?>, Processor> processors =
+ defaultProcessors().stream()
+ .collect(toMap((Processor e) -> e.getClass(), (Processor e) -> e));
+
+ // Adds extra processors, and allows overriding any processors of the same class.
+ Arrays.stream(extraProcessors)
+ .forEach(processor -> processors.put(processor.getClass(), processor));
+
+ return CompilerTests.compiler().withProcessors(processors.values());
+ }
+
+ public static KotlinCompilation kotlinCompiler() {
+ KotlinCompilation compilation = new KotlinCompilation();
+ compilation.setAnnotationProcessors(defaultProcessors());
+ compilation.setClasspaths(
+ ImmutableList.<java.io.File>builder()
+ .addAll(compilation.getClasspaths())
+ .add(CompilerTests.compilerDepsJar())
+ .build()
+ );
+ return compilation;
+ }
+
+ private static ImmutableList<Processor> defaultProcessors() {
+ return ImmutableList.of(
+ new AggregatedDepsProcessor(),
+ new AndroidEntryPointProcessor(),
+ new ComponentProcessor(),
+ new DefineComponentProcessor(),
+ new GeneratesRootInputProcessor(),
+ new OriginatingElementProcessor(),
+ new CustomTestApplicationProcessor(),
+ new UninstallModulesProcessor(),
+ new RootProcessor());
+ }
+
+ private AndroidCompilers() {}
+}
diff --git a/javatests/dagger/hilt/android/processor/BUILD b/javatests/dagger/hilt/android/processor/BUILD
new file mode 100644
index 0000000..7fb2320
--- /dev/null
+++ b/javatests/dagger/hilt/android/processor/BUILD
@@ -0,0 +1,38 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# Description:
+# Tests for internal code for implementing Hilt processors.
+
+package(default_visibility = ["//:src"])
+
+java_library(
+ name = "android_compilers",
+ srcs = ["AndroidCompilers.java"],
+ deps = [
+ "//java/dagger/hilt/android/processor/internal/androidentrypoint:processor_lib",
+ "//java/dagger/hilt/android/processor/internal/customtestapplication:processor_lib",
+ "//java/dagger/hilt/android/processor/internal/uninstallmodules:processor_lib",
+ "//java/dagger/hilt/android/processor/internal/viewmodel:processor_lib",
+ "//java/dagger/hilt/processor/internal/aggregateddeps:processor_lib",
+ "//java/dagger/hilt/processor/internal/definecomponent:processor_lib",
+ "//java/dagger/hilt/processor/internal/generatesrootinput:processor_lib",
+ "//java/dagger/hilt/processor/internal/originatingelement:processor_lib",
+ "//java/dagger/hilt/processor/internal/root:processor_lib",
+ "//java/dagger/internal/codegen:processor",
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/testing/compile",
+ "@google_bazel_common//third_party/java/compile_testing",
+ "@maven//:com_github_tschuchortdev_kotlin_compile_testing",
+ ],
+)
diff --git a/javatests/dagger/hilt/android/processor/internal/aggregateddeps/BUILD b/javatests/dagger/hilt/android/processor/internal/aggregateddeps/BUILD
new file mode 100644
index 0000000..bf2ed4c
--- /dev/null
+++ b/javatests/dagger/hilt/android/processor/internal/aggregateddeps/BUILD
@@ -0,0 +1,51 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# Description:
+# Tests for internal code for implementing Hilt processors.
+
+load("//java/dagger/testing/compile:macros.bzl", "compiler_test")
+
+package(default_visibility = ["//:src"])
+
+compiler_test(
+ name = "TestInstallInTest",
+ srcs = ["TestInstallInTest.java"],
+ compiler_deps = [
+ ":InstallInModule",
+ "//:dagger_with_compiler",
+ "//java/dagger/hilt:install_in",
+ "//java/dagger/hilt:entry_point",
+ "//java/dagger/hilt/components",
+ "//java/dagger/hilt/android/internal/modules",
+ "//java/dagger/hilt/testing:test_install_in",
+ "//java/dagger/hilt/android/testing:hilt_android_test",
+ "@androidsdk//:platforms/android-30/android.jar",
+ ],
+ deps = [
+ "@google_bazel_common//third_party/java/compile_testing",
+ "@google_bazel_common//third_party/java/junit",
+ "@google_bazel_common//third_party/java/truth",
+ "//javatests/dagger/hilt/android/processor:android_compilers",
+ ],
+)
+
+java_library(
+ name = "InstallInModule",
+ srcs = ["InstallInModule.java"],
+ deps = [
+ "//:dagger_with_compiler",
+ "//java/dagger/hilt:install_in",
+ "//java/dagger/hilt/components",
+ ],
+)
diff --git a/javatests/dagger/hilt/android/processor/internal/aggregateddeps/InstallInModule.java b/javatests/dagger/hilt/android/processor/internal/aggregateddeps/InstallInModule.java
new file mode 100644
index 0000000..af535f5
--- /dev/null
+++ b/javatests/dagger/hilt/android/processor/internal/aggregateddeps/InstallInModule.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.aggregateddeps;
+
+import dagger.Module;
+import dagger.hilt.InstallIn;
+import dagger.hilt.components.SingletonComponent;
+
+/**
+ * This is used in TestInstallInTest to test that the wrapper module, HiltWrapper_InstallInModule,
+ * cannot be replaced. This needs to be compiled in a separate library because
+ * AggregatedDepsProcesor does not defer modules that have not been generated yet.
+ */
+@Module
+@InstallIn(SingletonComponent.class)
+interface InstallInModule {}
diff --git a/javatests/dagger/hilt/android/processor/internal/aggregateddeps/TestInstallInTest.java b/javatests/dagger/hilt/android/processor/internal/aggregateddeps/TestInstallInTest.java
new file mode 100644
index 0000000..3af5be6
--- /dev/null
+++ b/javatests/dagger/hilt/android/processor/internal/aggregateddeps/TestInstallInTest.java
@@ -0,0 +1,365 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.aggregateddeps;
+
+import static com.google.testing.compile.CompilationSubject.assertThat;
+import static dagger.hilt.android.processor.AndroidCompilers.compiler;
+
+import com.google.testing.compile.Compilation;
+import com.google.testing.compile.JavaFileObjects;
+import javax.tools.JavaFileObject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class TestInstallInTest {
+
+ @Test
+ public void testMissingValues() {
+ JavaFileObject testInstallInModule =
+ JavaFileObjects.forSourceLines(
+ "test.TestInstallInModule",
+ "package test;",
+ "",
+ "import dagger.Module;",
+ "import dagger.hilt.testing.TestInstallIn;",
+ "",
+ "@Module",
+ "@TestInstallIn",
+ "interface TestInstallInModule {}");
+ Compilation compilation = compiler().compile(testInstallInModule);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@dagger.hilt.testing.TestInstallIn is missing default values for elements "
+ + "components,replaces")
+ .inFile(testInstallInModule)
+ .onLine(7);
+ }
+
+ @Test
+ public void testEmptyComponentValues() {
+ JavaFileObject installInModule =
+ JavaFileObjects.forSourceLines(
+ "test.InstallInModule",
+ "package test;",
+ "",
+ "import dagger.Module;",
+ "import dagger.hilt.InstallIn;",
+ "import dagger.hilt.components.SingletonComponent;",
+ "",
+ "@Module",
+ "@InstallIn(SingletonComponent.class)",
+ "interface InstallInModule {}");
+ JavaFileObject testInstallInModule =
+ JavaFileObjects.forSourceLines(
+ "test.TestInstallInModule",
+ "package test;",
+ "",
+ "import dagger.Module;",
+ "import dagger.hilt.testing.TestInstallIn;",
+ "",
+ "@Module",
+ "@TestInstallIn(components = {}, replaces = InstallInModule.class)",
+ "interface TestInstallInModule {}");
+ Compilation compilation = compiler().compile(installInModule, testInstallInModule);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ // TODO(bcorso): Add inFile().onLine() whenever we've fixed Processors.getAnnotationClassValues
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@TestInstallIn, 'components' class is invalid or missing: "
+ + "@dagger.hilt.testing.TestInstallIn("
+ + "components={}, replaces={test.InstallInModule.class})");
+ }
+
+ @Test
+ public void testEmptyReplacesValues() {
+ JavaFileObject testInstallInModule =
+ JavaFileObjects.forSourceLines(
+ "test.TestInstallInModule",
+ "package test;",
+ "",
+ "import dagger.Module;",
+ "import dagger.hilt.testing.TestInstallIn;",
+ "import dagger.hilt.components.SingletonComponent;",
+ "",
+ "@Module",
+ "@TestInstallIn(components = SingletonComponent.class, replaces = {})",
+ "interface TestInstallInModule {}");
+ Compilation compilation = compiler().compile(testInstallInModule);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ // TODO(bcorso): Add inFile().onLine() whenever we've fixed Processors.getAnnotationClassValues
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@TestInstallIn, 'replaces' class is invalid or missing: "
+ + "@dagger.hilt.testing.TestInstallIn("
+ + "components={dagger.hilt.components.SingletonComponent.class}, replaces={})");
+ }
+
+ @Test
+ public void testMissingModuleAnnotation() {
+ JavaFileObject installInModule =
+ JavaFileObjects.forSourceLines(
+ "test.InstallInModule",
+ "package test;",
+ "",
+ "import dagger.Module;",
+ "import dagger.hilt.InstallIn;",
+ "import dagger.hilt.components.SingletonComponent;",
+ "",
+ "@Module",
+ "@InstallIn(SingletonComponent.class)",
+ "interface InstallInModule {}");
+ JavaFileObject testInstallInModule =
+ JavaFileObjects.forSourceLines(
+ "test.TestInstallInModule",
+ "package test;",
+ "",
+ "import dagger.Module;",
+ "import dagger.hilt.components.SingletonComponent;",
+ "import dagger.hilt.testing.TestInstallIn;",
+ "",
+ "@TestInstallIn(",
+ " components = SingletonComponent.class,",
+ " replaces = InstallInModule.class)",
+ "interface TestInstallInModule {}");
+ Compilation compilation = compiler().compile(installInModule, testInstallInModule);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@TestInstallIn-annotated classes must also be annotated with @Module or @EntryPoint: "
+ + "test.TestInstallInModule")
+ .inFile(testInstallInModule)
+ .onLine(10);
+ }
+
+ @Test
+ public void testInvalidUsageOnEntryPoint() {
+ JavaFileObject installInModule =
+ JavaFileObjects.forSourceLines(
+ "test.InstallInModule",
+ "package test;",
+ "",
+ "import dagger.Module;",
+ "import dagger.hilt.InstallIn;",
+ "import dagger.hilt.components.SingletonComponent;",
+ "",
+ "@Module",
+ "@InstallIn(SingletonComponent.class)",
+ "interface InstallInModule {}");
+ JavaFileObject testInstallInEntryPoint =
+ JavaFileObjects.forSourceLines(
+ "test.TestInstallInEntryPoint",
+ "package test;",
+ "",
+ "import dagger.hilt.EntryPoint;",
+ "import dagger.hilt.components.SingletonComponent;",
+ "import dagger.hilt.testing.TestInstallIn;",
+ "",
+ "@EntryPoint",
+ "@TestInstallIn(",
+ " components = SingletonComponent.class,",
+ " replaces = InstallInModule.class)",
+ "interface TestInstallInEntryPoint {}");
+ Compilation compilation = compiler().compile(installInModule, testInstallInEntryPoint);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining("@TestInstallIn can only be used with modules")
+ .inFile(testInstallInEntryPoint)
+ .onLine(11);
+ }
+
+ @Test
+ public void testInvalidReplaceModules() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines("test.Foo", "package test;", "", "class Foo {}");
+ JavaFileObject testInstallInModule =
+ JavaFileObjects.forSourceLines(
+ "test.TestInstallInModule",
+ "package test;",
+ "",
+ "import dagger.Module;",
+ "import dagger.hilt.components.SingletonComponent;",
+ "import dagger.hilt.testing.TestInstallIn;",
+ "",
+ "@Module",
+ "@TestInstallIn(",
+ " components = SingletonComponent.class,",
+ " replaces = Foo.class)",
+ "interface TestInstallInModule {}");
+ Compilation compilation = compiler().compile(foo, testInstallInModule);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@TestInstallIn#replaces() can only contain @InstallIn modules, but found: [test.Foo]")
+ .inFile(testInstallInModule)
+ .onLine(11);
+ }
+
+ @Test
+ public void testInternalDaggerReplaceModules() {
+ JavaFileObject testInstallInModule =
+ JavaFileObjects.forSourceLines(
+ "test.TestInstallInModule",
+ "package test;",
+ "",
+ "import dagger.Module;",
+ "import dagger.hilt.components.SingletonComponent;",
+ "import dagger.hilt.testing.TestInstallIn;",
+ "",
+ "@Module",
+ "@TestInstallIn(",
+ " components = SingletonComponent.class,",
+ " replaces = dagger.hilt.android.internal.modules.ApplicationContextModule.class)",
+ "interface TestInstallInModule {}");
+ Compilation compilation = compiler().compile(testInstallInModule);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@TestInstallIn#replaces() cannot contain internal Hilt modules, but found: "
+ + "[dagger.hilt.android.internal.modules.ApplicationContextModule]")
+ .inFile(testInstallInModule)
+ .onLine(11);
+ }
+
+ @Test
+ public void testHiltWrapperDaggerReplaceModules() {
+ JavaFileObject testInstallInModule =
+ JavaFileObjects.forSourceLines(
+ "test.TestInstallInModule",
+ "package test;",
+ "",
+ "import dagger.Module;",
+ "import dagger.hilt.components.SingletonComponent;",
+ "import dagger.hilt.testing.TestInstallIn;",
+ "import"
+ + " dagger.hilt.android.processor.internal.aggregateddeps.HiltWrapper_InstallInModule;",
+ "",
+ "@Module",
+ "@TestInstallIn(",
+ " components = SingletonComponent.class,",
+ // Note: this module is built in a separate library since AggregatedDepsProcessor can't
+ // handle modules generated in the same round.
+ " replaces = HiltWrapper_InstallInModule.class)",
+ "interface TestInstallInModule {}");
+ Compilation compilation = compiler().compile(testInstallInModule);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@TestInstallIn#replaces() cannot contain Hilt generated public wrapper modules, "
+ + "but found: [dagger.hilt.android.processor.internal.aggregateddeps."
+ + "HiltWrapper_InstallInModule]")
+ .inFile(testInstallInModule)
+ .onLine(12);
+ }
+
+ @Test
+ public void testCannotReplaceLocalInstallInModule() {
+ JavaFileObject test =
+ JavaFileObjects.forSourceLines(
+ "test.MyTest",
+ "package test;",
+ "",
+ "import dagger.Module;",
+ "import dagger.hilt.InstallIn;",
+ "import dagger.hilt.components.SingletonComponent;",
+ "import dagger.hilt.testing.TestInstallIn;",
+ "import dagger.hilt.android.testing.HiltAndroidTest;",
+ "",
+ "@HiltAndroidTest",
+ "public class MyTest {",
+ " @Module",
+ " @InstallIn(SingletonComponent.class)",
+ " interface LocalInstallInModule {}",
+ "}");
+ JavaFileObject testInstallIn =
+ JavaFileObjects.forSourceLines(
+ "test.TestInstallInModule",
+ "package test;",
+ "",
+ "import dagger.Module;",
+ "import dagger.hilt.components.SingletonComponent;",
+ "import dagger.hilt.testing.TestInstallIn;",
+ "",
+ "@Module",
+ "@TestInstallIn(",
+ " components = SingletonComponent.class,",
+ " replaces = MyTest.LocalInstallInModule.class)",
+ "interface TestInstallInModule {}");
+ Compilation compilation = compiler().compile(test, testInstallIn);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "TestInstallIn#replaces() cannot replace test specific @InstallIn modules, but found: "
+ + "[test.MyTest.LocalInstallInModule].")
+ .inFile(testInstallIn)
+ .onLine(11);
+ }
+
+ @Test
+ public void testThatTestInstallInCannotOriginateFromTest() {
+ JavaFileObject installInModule =
+ JavaFileObjects.forSourceLines(
+ "test.InstallInModule",
+ "package test;",
+ "",
+ "import dagger.Module;",
+ "import dagger.hilt.InstallIn;",
+ "import dagger.hilt.components.SingletonComponent;",
+ "",
+ "@Module",
+ "@InstallIn(SingletonComponent.class)",
+ "interface InstallInModule {}");
+ JavaFileObject test =
+ JavaFileObjects.forSourceLines(
+ "test.MyTest",
+ "package test;",
+ "",
+ "import dagger.Module;",
+ "import dagger.hilt.components.SingletonComponent;",
+ "import dagger.hilt.testing.TestInstallIn;",
+ "import dagger.hilt.android.testing.HiltAndroidTest;",
+ "",
+ "@HiltAndroidTest",
+ "public class MyTest {",
+ " @Module",
+ " @TestInstallIn(",
+ " components = SingletonComponent.class,",
+ " replaces = InstallInModule.class)",
+ " interface TestInstallInModule {}",
+ "}");
+ Compilation compilation = compiler().compile(test, installInModule);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@TestInstallIn modules cannot be nested in (or originate from) a "
+ + "@HiltAndroidTest-annotated class: test.MyTest")
+ .inFile(test)
+ .onLine(14);
+ }
+}
diff --git a/javatests/dagger/hilt/android/processor/internal/androidentrypoint/ActivityGeneratorTest.java b/javatests/dagger/hilt/android/processor/internal/androidentrypoint/ActivityGeneratorTest.java
new file mode 100644
index 0000000..25a1abd
--- /dev/null
+++ b/javatests/dagger/hilt/android/processor/internal/androidentrypoint/ActivityGeneratorTest.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.androidentrypoint;
+
+import static com.google.testing.compile.CompilationSubject.assertThat;
+import static dagger.hilt.android.processor.AndroidCompilers.compiler;
+
+import com.google.testing.compile.Compilation;
+import com.google.testing.compile.JavaFileObjects;
+import javax.tools.JavaFileObject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class ActivityGeneratorTest {
+
+ @Test
+ public void generate_componentActivity() {
+ JavaFileObject myActivity =
+ JavaFileObjects.forSourceLines(
+ "test.MyActivity",
+ "package test;",
+ "",
+ "import androidx.activity.ComponentActivity;",
+ "import dagger.hilt.android.AndroidEntryPoint;",
+ "",
+ "@AndroidEntryPoint(ComponentActivity.class)",
+ "public class MyActivity extends Hilt_MyActivity {",
+ "}");
+ Compilation compilation = compiler().compile(myActivity);
+ assertThat(compilation).succeeded();
+ }
+
+ @Test
+ public void generate_baseHiltComponentActivity() {
+ JavaFileObject baseActivity =
+ JavaFileObjects.forSourceLines(
+ "test.BaseActivity",
+ "package test;",
+ "",
+ "import androidx.activity.ComponentActivity;",
+ "import dagger.hilt.android.AndroidEntryPoint;",
+ "",
+ "@AndroidEntryPoint(ComponentActivity.class)",
+ "public class BaseActivity extends Hilt_BaseActivity {",
+ "}");
+ JavaFileObject myActivity =
+ JavaFileObjects.forSourceLines(
+ "test.MyActivity",
+ "package test;",
+ "",
+ "import androidx.activity.ComponentActivity;",
+ "import dagger.hilt.android.AndroidEntryPoint;",
+ "",
+ "@AndroidEntryPoint(BaseActivity.class)",
+ "public class MyActivity extends Hilt_MyActivity {",
+ "}");
+ Compilation compilation = compiler().compile(baseActivity, myActivity);
+ assertThat(compilation).succeeded();
+ }
+}
diff --git a/javatests/dagger/hilt/android/processor/internal/androidentrypoint/AndroidEntryPointProcessorTest.java b/javatests/dagger/hilt/android/processor/internal/androidentrypoint/AndroidEntryPointProcessorTest.java
new file mode 100644
index 0000000..c024a9c
--- /dev/null
+++ b/javatests/dagger/hilt/android/processor/internal/androidentrypoint/AndroidEntryPointProcessorTest.java
@@ -0,0 +1,169 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.androidentrypoint;
+
+import static com.google.testing.compile.CompilationSubject.assertThat;
+import static dagger.hilt.android.processor.AndroidCompilers.compiler;
+
+import com.google.testing.compile.Compilation;
+import com.google.testing.compile.JavaFileObjects;
+import javax.tools.JavaFileObject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class AndroidEntryPointProcessorTest {
+
+ @Test
+ public void missingBaseClass() {
+ JavaFileObject testActivity =
+ JavaFileObjects.forSourceLines(
+ "test.MyActivity",
+ "package test;",
+ "",
+ "import androidx.activity.ComponentActivity;",
+ "import dagger.hilt.android.AndroidEntryPoint;",
+ "",
+ "@AndroidEntryPoint",
+ "public class MyActivity extends ComponentActivity { }");
+ Compilation compilation = compiler().compile(testActivity);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining("Expected @AndroidEntryPoint to have a value.")
+ ;
+ }
+
+ @Test
+ public void incorrectSuperclass() {
+ JavaFileObject testActivity =
+ JavaFileObjects.forSourceLines(
+ "test.MyActivity",
+ "package test;",
+ "",
+ "import androidx.activity.ComponentActivity;",
+ "import dagger.hilt.android.AndroidEntryPoint;",
+ "",
+ "@AndroidEntryPoint(ComponentActivity.class)",
+ "public class MyActivity extends ComponentActivity { }");
+ Compilation compilation = compiler().compile(testActivity);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@AndroidEntryPoint class expected to extend Hilt_MyActivity. "
+ + "Found: ComponentActivity")
+ ;
+ }
+
+ @Test
+ public void disableSuperclassValidation_activity() {
+ JavaFileObject testActivity =
+ JavaFileObjects.forSourceLines(
+ "test.MyActivity",
+ "package test;",
+ "",
+ "import androidx.activity.ComponentActivity;",
+ "import dagger.hilt.android.AndroidEntryPoint;",
+ "",
+ "@AndroidEntryPoint",
+ "public class MyActivity extends ComponentActivity { }");
+ Compilation compilation =
+ compiler()
+ .withOptions("-Adagger.hilt.android.internal.disableAndroidSuperclassValidation=true")
+ .compile(testActivity);
+ assertThat(compilation).succeeded();
+ }
+
+ @Test
+ public void disableSuperclassValidation_application() {
+ JavaFileObject testApplication =
+ JavaFileObjects.forSourceLines(
+ "test.MyApp",
+ "package test;",
+ "",
+ "import android.app.Application;",
+ "import dagger.hilt.android.HiltAndroidApp;",
+ "",
+ "@HiltAndroidApp",
+ "public class MyApp extends Application { }");
+ Compilation compilation =
+ compiler()
+ .withOptions("-Adagger.hilt.android.internal.disableAndroidSuperclassValidation=true")
+ .compile(testApplication);
+ assertThat(compilation).succeeded();
+ }
+
+ @Test
+ public void checkBaseActivityExtendsComponentActivity() {
+ JavaFileObject testActivity =
+ JavaFileObjects.forSourceLines(
+ "test.MyActivity",
+ "package test;",
+ "",
+ "import android.app.Activity;",
+ "import dagger.hilt.android.AndroidEntryPoint;",
+ "",
+ "@AndroidEntryPoint(Activity.class)",
+ "public class MyActivity extends Hilt_MyActivity { }");
+ Compilation compilation = compiler().compile(testActivity);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining("Activities annotated with @AndroidEntryPoint must be a subclass of "
+ + "androidx.activity.ComponentActivity. (e.g. FragmentActivity, AppCompatActivity, "
+ + "etc.)");
+ }
+
+ @Test
+ public void checkBaseActivityWithTypeParameters() {
+ JavaFileObject testActivity =
+ JavaFileObjects.forSourceLines(
+ "test.BaseActivity",
+ "package test;",
+ "",
+ "import androidx.activity.ComponentActivity;",
+ "import dagger.hilt.android.AndroidEntryPoint;",
+ "",
+ "@AndroidEntryPoint(ComponentActivity.class)",
+ "public class BaseActivity<T> extends Hilt_BaseActivity {}");
+ Compilation compilation = compiler().compile(testActivity);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(2);
+ assertThat(compilation).hadErrorContaining(
+ "cannot find symbol\n symbol: class Hilt_BaseActivity");
+ assertThat(compilation).hadErrorContaining(
+ "@AndroidEntryPoint-annotated classes cannot have type parameters.");
+ }
+
+ @Test
+ public void checkAndroidEntryPointOnApplicationRecommendsHiltAndroidApp() {
+ JavaFileObject testActivity =
+ JavaFileObjects.forSourceLines(
+ "test.MyApplication",
+ "package test;",
+ "",
+ "import android.app.Application;",
+ "import dagger.hilt.android.AndroidEntryPoint;",
+ "",
+ "@AndroidEntryPoint(Application.class)",
+ "public class MyApplication extends Hilt_MyApplication { }");
+ Compilation compilation = compiler().compile(testActivity);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining("@AndroidEntryPoint cannot be used on an Application. "
+ + "Use @HiltAndroidApp instead.");
+ }
+}
diff --git a/javatests/dagger/hilt/android/processor/internal/androidentrypoint/BUILD b/javatests/dagger/hilt/android/processor/internal/androidentrypoint/BUILD
new file mode 100644
index 0000000..e53d9e2
--- /dev/null
+++ b/javatests/dagger/hilt/android/processor/internal/androidentrypoint/BUILD
@@ -0,0 +1,67 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# Description:
+# Tests for internal code for implementing Hilt processors.
+
+load("//java/dagger/testing/compile:macros.bzl", "compiler_test")
+
+package(default_visibility = ["//:src"])
+
+compiler_test(
+ name = "ActivityGeneratorTest",
+ srcs = ["ActivityGeneratorTest.java"],
+ compiler_deps = [
+ "//java/dagger/hilt/android:android_entry_point",
+ "@androidsdk//:platforms/android-30/android.jar",
+ ],
+ deps = [
+ "@google_bazel_common//third_party/java/compile_testing",
+ "@google_bazel_common//third_party/java/junit",
+ "@google_bazel_common//third_party/java/truth",
+ "//javatests/dagger/hilt/android/processor:android_compilers",
+ ],
+)
+
+compiler_test(
+ name = "AndroidEntryPointProcessorTest",
+ srcs = ["AndroidEntryPointProcessorTest.java"],
+ compiler_deps = [
+ "//java/dagger/hilt/android:hilt_android_app",
+ "//java/dagger/hilt/android:android_entry_point",
+ "@androidsdk//:platforms/android-30/android.jar",
+ ],
+ deps = [
+ "@google_bazel_common//third_party/java/compile_testing",
+ "@google_bazel_common//third_party/java/junit",
+ "@google_bazel_common//third_party/java/truth",
+ "//javatests/dagger/hilt/android/processor:android_compilers",
+ ],
+)
+
+compiler_test(
+ name = "KotlinAndroidEntryPointProcessorTest",
+ srcs = ["KotlinAndroidEntryPointProcessorTest.java"],
+ compiler_deps = [
+ "//java/dagger/hilt/android:hilt_android_app",
+ "//java/dagger/hilt/android:android_entry_point",
+ "@androidsdk//:platforms/android-30/android.jar",
+ ],
+ deps = [
+ "//java/dagger/internal/guava:collect",
+ "@google_bazel_common//third_party/java/junit",
+ "@google_bazel_common//third_party/java/truth",
+ "//javatests/dagger/hilt/android/processor:android_compilers",
+ "@maven//:com_github_tschuchortdev_kotlin_compile_testing",
+ ],
+)
diff --git a/javatests/dagger/hilt/android/processor/internal/androidentrypoint/KotlinAndroidEntryPointProcessorTest.java b/javatests/dagger/hilt/android/processor/internal/androidentrypoint/KotlinAndroidEntryPointProcessorTest.java
new file mode 100644
index 0000000..739c87c
--- /dev/null
+++ b/javatests/dagger/hilt/android/processor/internal/androidentrypoint/KotlinAndroidEntryPointProcessorTest.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.androidentrypoint;
+
+import static dagger.hilt.android.processor.AndroidCompilers.kotlinCompiler;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.truth.Truth;
+import com.tschuchort.compiletesting.KotlinCompilation;
+import com.tschuchort.compiletesting.KotlinCompilation.ExitCode;
+import com.tschuchort.compiletesting.SourceFile;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class KotlinAndroidEntryPointProcessorTest {
+ @Test
+ public void checkBaseClassConstructorHasNotDefaultParameters() {
+ SourceFile fragmentSrc = SourceFile.Companion.kotlin("MyFragment.kt",
+ String.join("\n",
+ "package test",
+ "",
+ "import dagger.hilt.android.AndroidEntryPoint",
+ "",
+ "@AndroidEntryPoint",
+ "class MyFragment : BaseFragment()"
+ ),
+ false);
+ SourceFile baseFragmentSrc = SourceFile.Companion.kotlin("BaseFragment.kt",
+ String.join("\n",
+ "package test",
+ "",
+ "import androidx.fragment.app.Fragment",
+ "",
+ "abstract class BaseFragment(layoutId: Int = 0) : Fragment()"
+ ),
+ false);
+ KotlinCompilation compilation = kotlinCompiler();
+ compilation.setSources(ImmutableList.of(fragmentSrc, baseFragmentSrc));
+ compilation.setKaptArgs(ImmutableMap.of(
+ "dagger.hilt.android.internal.disableAndroidSuperclassValidation", "true"));
+ KotlinCompilation.Result result = compilation.compile();
+ Truth.assertThat(result.getExitCode()).isEqualTo(ExitCode.COMPILATION_ERROR);
+ Truth.assertThat(result.getMessages()).contains("The base class, 'test.BaseFragment', of the "
+ + "@AndroidEntryPoint, 'test.MyFragment', contains a constructor with default parameters. "
+ + "This is currently not supported by the Gradle plugin. Either specify the base class as "
+ + "described at https://dagger.dev/hilt/gradle-setup#why-use-the-plugin or remove the "
+ + "default value declaration.");
+ }
+}
diff --git a/javatests/dagger/hilt/android/processor/internal/viewmodel/BUILD b/javatests/dagger/hilt/android/processor/internal/viewmodel/BUILD
new file mode 100644
index 0000000..030efd9
--- /dev/null
+++ b/javatests/dagger/hilt/android/processor/internal/viewmodel/BUILD
@@ -0,0 +1,112 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Tests for internal code for implementing Hilt processors.
+
+load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "kt_jvm_library")
+load("//java/dagger/testing/compile:macros.bzl", "kt_compiler_test")
+
+package(default_visibility = ["//:src"])
+
+java_test(
+ name = "ViewModelProcessorTest",
+ runtime_deps = [
+ ":ViewModelProcessorTestLib",
+ "//java/dagger/hilt/android/lifecycle",
+ "@androidsdk//:platforms/android-30/android.jar",
+ "@google_bazel_common//third_party/java/compile_testing",
+ "@google_bazel_common//third_party/java/truth",
+ "@maven//:androidx_lifecycle_lifecycle_viewmodel",
+ "@maven//:androidx_lifecycle_lifecycle_viewmodel_savedstate",
+ ],
+)
+
+kt_jvm_library(
+ name = "ViewModelProcessorTestLib",
+ srcs = [
+ "ViewModelProcessorTest.kt",
+ ],
+ deps = [
+ ":test_utils",
+ "//java/dagger/hilt/android/processor/internal/viewmodel:processor_lib",
+ "@google_bazel_common//third_party/java/compile_testing",
+ "@google_bazel_common//third_party/java/junit",
+ "@google_bazel_common//third_party/java/truth",
+ ],
+)
+
+java_test(
+ name = "ViewModelGeneratorTest",
+ runtime_deps = [
+ ":ViewModelGeneratorTestLib",
+ "//java/dagger/hilt/android/lifecycle",
+ "@androidsdk//:platforms/android-30/android.jar",
+ "@google_bazel_common//third_party/java/compile_testing",
+ "@google_bazel_common//third_party/java/truth",
+ "@maven//:androidx_lifecycle_lifecycle_viewmodel",
+ "@maven//:androidx_lifecycle_lifecycle_viewmodel_savedstate",
+ ],
+)
+
+kt_jvm_library(
+ name = "ViewModelGeneratorTestLib",
+ srcs = [
+ "ViewModelGeneratorTest.kt",
+ ],
+ deps = [
+ ":test_utils",
+ "//java/dagger/hilt/android/processor/internal/viewmodel:processor_lib",
+ "@google_bazel_common//third_party/java/compile_testing",
+ "@google_bazel_common//third_party/java/junit",
+ "@google_bazel_common//third_party/java/truth",
+ ],
+)
+
+kt_compiler_test(
+ name = "ViewModelValidationPluginTest",
+ srcs = [
+ "ViewModelValidationPluginTest.kt",
+ ],
+ compiler_deps = [
+ "@androidsdk//:platforms/android-30/android.jar",
+ "@maven//:androidx_lifecycle_lifecycle_viewmodel",
+ "@maven//:androidx_lifecycle_lifecycle_viewmodel_savedstate",
+ "@google_bazel_common//third_party/java/compile_testing",
+ "@google_bazel_common//third_party/java/truth",
+ "//java/dagger/hilt/android/lifecycle",
+ "//java/dagger/hilt/android:android_entry_point",
+ "//java/dagger/hilt/android:hilt_android_app",
+ ],
+ deps = [
+ ":test_utils",
+ "//:compiler_internals",
+ "//java/dagger/hilt/android/processor/internal/viewmodel:processor_lib",
+ "//java/dagger/hilt/android/processor/internal/viewmodel:validation_plugin_lib",
+ "//javatests/dagger/hilt/android/processor:android_compilers",
+ "@google_bazel_common//third_party/java/compile_testing",
+ "@google_bazel_common//third_party/java/junit",
+ "@google_bazel_common//third_party/java/truth",
+ ],
+)
+
+kt_jvm_library(
+ name = "test_utils",
+ srcs = [
+ "TestUtils.kt",
+ ],
+ deps = [
+ "@google_bazel_common//third_party/java/compile_testing",
+ ],
+)
diff --git a/javatests/dagger/hilt/android/processor/internal/viewmodel/TestUtils.kt b/javatests/dagger/hilt/android/processor/internal/viewmodel/TestUtils.kt
new file mode 100644
index 0000000..713cd22
--- /dev/null
+++ b/javatests/dagger/hilt/android/processor/internal/viewmodel/TestUtils.kt
@@ -0,0 +1,15 @@
+package dagger.hilt.android.processor.internal.viewmodel
+
+import com.google.testing.compile.JavaFileObjects
+
+val GENERATED_TYPE = try {
+ Class.forName("javax.annotation.processing.Generated")
+ "javax.annotation.processing.Generated"
+} catch (_: ClassNotFoundException) {
+ "javax.annotation.Generated"
+}
+
+const val GENERATED_ANNOTATION =
+ "@Generated(\"dagger.hilt.android.processor.internal.viewmodel.ViewModelProcessor\")"
+
+fun String.toJFO(qName: String) = JavaFileObjects.forSourceString(qName, this.trimIndent())
diff --git a/javatests/dagger/hilt/android/processor/internal/viewmodel/ViewModelGeneratorTest.kt b/javatests/dagger/hilt/android/processor/internal/viewmodel/ViewModelGeneratorTest.kt
new file mode 100644
index 0000000..7c3e45f
--- /dev/null
+++ b/javatests/dagger/hilt/android/processor/internal/viewmodel/ViewModelGeneratorTest.kt
@@ -0,0 +1,527 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.viewmodel
+
+import com.google.testing.compile.CompilationSubject.assertThat
+import com.google.testing.compile.Compiler
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+@RunWith(JUnit4::class)
+class ViewModelGeneratorTest {
+
+ private fun compiler(): Compiler = Compiler.javac().withProcessors(ViewModelProcessor())
+
+ @Test
+ fun verifyModule_noArg() {
+ val myViewModel = """
+ package dagger.hilt.android.test;
+
+ import dagger.hilt.android.lifecycle.HiltViewModel;
+ import androidx.lifecycle.ViewModel;
+ import javax.inject.Inject;
+
+ @HiltViewModel
+ class MyViewModel extends ViewModel {
+ @Inject
+ MyViewModel() { }
+ }
+ """.toJFO("dagger.hilt.android.test.MyViewModel")
+
+ val expected = """
+ package dagger.hilt.android.test;
+
+ import androidx.lifecycle.ViewModel;
+ import dagger.Binds;
+ import dagger.Module;
+ import dagger.Provides;
+ import dagger.hilt.InstallIn;
+ import dagger.hilt.android.components.ActivityRetainedComponent;
+ import dagger.hilt.android.components.ViewModelComponent;
+ import dagger.hilt.android.internal.lifecycle.HiltViewModelMap;
+ import dagger.hilt.codegen.OriginatingElement;
+ import dagger.multibindings.IntoMap;
+ import dagger.multibindings.IntoSet;
+ import dagger.multibindings.StringKey;
+ import java.lang.String;
+ import $GENERATED_TYPE
+
+ $GENERATED_ANNOTATION
+ @OriginatingElement(
+ topLevelClass = MyViewModel.class
+ )
+ public final class MyViewModel_HiltModules {
+ private MyViewModel_HiltModules() {
+ }
+
+ @Module
+ @InstallIn(ViewModelComponent.class)
+ public static abstract class BindsModule {
+ @Binds
+ @IntoMap
+ @StringKey("dagger.hilt.android.test.MyViewModel")
+ @HiltViewModelMap
+ public abstract ViewModel binds(MyViewModel vm);
+ }
+
+ @Module
+ @InstallIn(ActivityRetainedComponent.class)
+ public static final class KeyModule {
+ private KeyModule() {
+ }
+
+ @Provides
+ @IntoSet
+ @HiltViewModelMap.KeySet
+ public static String provide() {
+ return "dagger.hilt.android.test.MyViewModel";
+ }
+ }
+ }
+ """.toJFO("dagger.hilt.android.test.MyViewModel_HiltModule")
+
+ val compilation = compiler()
+ .compile(myViewModel)
+ assertThat(compilation).apply {
+ succeeded()
+ generatedSourceFile("dagger.hilt.android.test.MyViewModel_HiltModules")
+ .hasSourceEquivalentTo(expected)
+ }
+ }
+
+ @Test
+ fun verifyModule_savedStateOnlyArg() {
+ val myViewModel = """
+ package dagger.hilt.android.test;
+
+ import dagger.hilt.android.lifecycle.HiltViewModel;
+ import androidx.lifecycle.ViewModel;
+ import androidx.lifecycle.SavedStateHandle;
+ import javax.inject.Inject;
+
+ @HiltViewModel
+ class MyViewModel extends ViewModel {
+ @Inject
+ MyViewModel(SavedStateHandle savedState) { }
+ }
+ """.toJFO("dagger.hilt.android.test.MyViewModel")
+
+ val expected = """
+ package dagger.hilt.android.test;
+
+ import androidx.lifecycle.ViewModel;
+ import dagger.Binds;
+ import dagger.Module;
+ import dagger.Provides;
+ import dagger.hilt.InstallIn;
+ import dagger.hilt.android.components.ActivityRetainedComponent;
+ import dagger.hilt.android.components.ViewModelComponent;
+ import dagger.hilt.android.internal.lifecycle.HiltViewModelMap;
+ import dagger.hilt.codegen.OriginatingElement;
+ import dagger.multibindings.IntoMap;
+ import dagger.multibindings.IntoSet;
+ import dagger.multibindings.StringKey;
+ import java.lang.String;
+ import $GENERATED_TYPE
+
+ $GENERATED_ANNOTATION
+ @OriginatingElement(
+ topLevelClass = MyViewModel.class
+ )
+ public final class MyViewModel_HiltModules {
+ private MyViewModel_HiltModules() {
+ }
+
+ @Module
+ @InstallIn(ViewModelComponent.class)
+ public static abstract class BindsModule {
+ @Binds
+ @IntoMap
+ @StringKey("dagger.hilt.android.test.MyViewModel")
+ @HiltViewModelMap
+ public abstract ViewModel binds(MyViewModel vm);
+ }
+
+ @Module
+ @InstallIn(ActivityRetainedComponent.class)
+ public static final class KeyModule {
+ private KeyModule() {
+ }
+
+ @Provides
+ @IntoSet
+ @HiltViewModelMap.KeySet
+ public static String provide() {
+ return "dagger.hilt.android.test.MyViewModel";
+ }
+ }
+ }
+ """.toJFO("dagger.hilt.android.test.MyViewModel_HiltModule")
+
+ val compilation = compiler()
+ .compile(myViewModel)
+ assertThat(compilation).apply {
+ succeeded()
+ generatedSourceFile("dagger.hilt.android.test.MyViewModel_HiltModules")
+ .hasSourceEquivalentTo(expected)
+ }
+ }
+
+ @Test
+ fun verifyModule_mixedArgs() {
+ val foo = """
+ package dagger.hilt.android.test;
+
+ public class Foo { }
+ """.toJFO("dagger.hilt.android.test.Foo")
+
+ val myViewModel = """
+ package dagger.hilt.android.test;
+
+ import dagger.hilt.android.lifecycle.HiltViewModel;
+ import androidx.lifecycle.ViewModel;
+ import androidx.lifecycle.SavedStateHandle;
+ import java.lang.String;
+ import javax.inject.Inject;
+
+ @HiltViewModel
+ class MyViewModel extends ViewModel {
+ @Inject
+ MyViewModel(String s, Foo f, SavedStateHandle savedState, long l) { }
+ }
+ """.toJFO("dagger.hilt.android.test.MyViewModel")
+
+ val expected = """
+ package dagger.hilt.android.test;
+
+ import androidx.lifecycle.ViewModel;
+ import dagger.Binds;
+ import dagger.Module;
+ import dagger.Provides;
+ import dagger.hilt.InstallIn;
+ import dagger.hilt.android.components.ActivityRetainedComponent;
+ import dagger.hilt.android.components.ViewModelComponent;
+ import dagger.hilt.android.internal.lifecycle.HiltViewModelMap;
+ import dagger.hilt.codegen.OriginatingElement;
+ import dagger.multibindings.IntoMap;
+ import dagger.multibindings.IntoSet;
+ import dagger.multibindings.StringKey;
+ import java.lang.String;
+ import $GENERATED_TYPE
+
+ $GENERATED_ANNOTATION
+ @OriginatingElement(
+ topLevelClass = MyViewModel.class
+ )
+ public final class MyViewModel_HiltModules {
+ private MyViewModel_HiltModules() {
+ }
+
+ @Module
+ @InstallIn(ViewModelComponent.class)
+ public static abstract class BindsModule {
+ @Binds
+ @IntoMap
+ @StringKey("dagger.hilt.android.test.MyViewModel")
+ @HiltViewModelMap
+ public abstract ViewModel binds(MyViewModel vm);
+ }
+
+ @Module
+ @InstallIn(ActivityRetainedComponent.class)
+ public static final class KeyModule {
+ private KeyModule() {
+ }
+
+ @Provides
+ @IntoSet
+ @HiltViewModelMap.KeySet
+ public static String provide() {
+ return "dagger.hilt.android.test.MyViewModel";
+ }
+ }
+ }
+ """.toJFO("dagger.hilt.android.test.MyViewModel_HiltModule")
+
+ val compilation = compiler()
+ .compile(foo, myViewModel)
+ assertThat(compilation).apply {
+ succeeded()
+ generatedSourceFile("dagger.hilt.android.test.MyViewModel_HiltModules")
+ .hasSourceEquivalentTo(expected)
+ }
+ }
+
+ @Test
+ fun verifyModule_mixedAndProviderArgs() {
+ val foo = """
+ package dagger.hilt.android.test;
+
+ public class Foo { }
+ """.toJFO("dagger.hilt.android.test.Foo")
+
+ val myViewModel = """
+ package dagger.hilt.android.test;
+
+ import dagger.hilt.android.lifecycle.HiltViewModel;
+ import androidx.lifecycle.ViewModel;
+ import androidx.lifecycle.SavedStateHandle;
+ import java.lang.String;
+ import javax.inject.Inject;
+ import javax.inject.Provider;
+
+ @HiltViewModel
+ class MyViewModel extends ViewModel {
+ @Inject
+ MyViewModel(String s, Provider<Foo> f, SavedStateHandle savedState) { }
+ }
+ """.toJFO("dagger.hilt.android.test.MyViewModel")
+
+ val expected = """
+ package dagger.hilt.android.test;
+
+ import androidx.lifecycle.ViewModel;
+ import dagger.Binds;
+ import dagger.Module;
+ import dagger.Provides;
+ import dagger.hilt.InstallIn;
+ import dagger.hilt.android.components.ActivityRetainedComponent;
+ import dagger.hilt.android.components.ViewModelComponent;
+ import dagger.hilt.android.internal.lifecycle.HiltViewModelMap;
+ import dagger.hilt.codegen.OriginatingElement;
+ import dagger.multibindings.IntoMap;
+ import dagger.multibindings.IntoSet;
+ import dagger.multibindings.StringKey;
+ import java.lang.String;
+ import $GENERATED_TYPE;
+
+ $GENERATED_ANNOTATION
+ @OriginatingElement(
+ topLevelClass = MyViewModel.class
+ )
+ public final class MyViewModel_HiltModules {
+ private MyViewModel_HiltModules() {
+ }
+
+ @Module
+ @InstallIn(ViewModelComponent.class)
+ public static abstract class BindsModule {
+ @Binds
+ @IntoMap
+ @StringKey("dagger.hilt.android.test.MyViewModel")
+ @HiltViewModelMap
+ public abstract ViewModel binds(MyViewModel vm);
+ }
+
+ @Module
+ @InstallIn(ActivityRetainedComponent.class)
+ public static final class KeyModule {
+ private KeyModule() {
+ }
+
+ @Provides
+ @IntoSet
+ @HiltViewModelMap.KeySet
+ public static String provide() {
+ return "dagger.hilt.android.test.MyViewModel";
+ }
+ }
+ }
+ """.toJFO("dagger.hilt.android.test.MyViewModel_HiltModules")
+
+ val compilation = compiler()
+ .compile(foo, myViewModel)
+ assertThat(compilation).apply {
+ succeeded()
+ generatedSourceFile("dagger.hilt.android.test.MyViewModel_HiltModules")
+ .hasSourceEquivalentTo(expected)
+ }
+ }
+
+ @Test
+ fun verifyModule_qualifiedArgs() {
+ val myQualifier = """
+ package dagger.hilt.android.test;
+
+ import javax.inject.Qualifier;
+
+ @Qualifier
+ public @interface MyQualifier { }
+ """.toJFO("dagger.hilt.android.test.MyQualifier")
+
+ val myViewModel = """
+ package dagger.hilt.android.test;
+
+ import dagger.hilt.android.lifecycle.HiltViewModel;
+ import androidx.lifecycle.ViewModel;
+ import androidx.lifecycle.SavedStateHandle;
+ import java.lang.Long;
+ import java.lang.String;
+ import javax.inject.Inject;
+ import javax.inject.Named;
+ import javax.inject.Provider;
+
+ @HiltViewModel
+ class MyViewModel extends ViewModel {
+ @Inject
+ MyViewModel(@Named("TheString") String s, @MyQualifier Provider<Long> l,
+ SavedStateHandle savedState) {
+ }
+ }
+ """.toJFO("dagger.hilt.android.test.MyViewModel")
+
+ val expected = """
+ package dagger.hilt.android.test;
+
+ import androidx.lifecycle.ViewModel;
+ import dagger.Binds;
+ import dagger.Module;
+ import dagger.Provides;
+ import dagger.hilt.InstallIn;
+ import dagger.hilt.android.components.ActivityRetainedComponent;
+ import dagger.hilt.android.components.ViewModelComponent;
+ import dagger.hilt.android.internal.lifecycle.HiltViewModelMap;
+ import dagger.hilt.codegen.OriginatingElement;
+ import dagger.multibindings.IntoMap;
+ import dagger.multibindings.IntoSet;
+ import dagger.multibindings.StringKey;
+ import java.lang.String;
+ import $GENERATED_TYPE;
+
+ $GENERATED_ANNOTATION
+ @OriginatingElement(
+ topLevelClass = MyViewModel.class
+ )
+ public final class MyViewModel_HiltModules {
+ private MyViewModel_HiltModules() {
+ }
+
+ @Module
+ @InstallIn(ViewModelComponent.class)
+ public static abstract class BindsModule {
+ @Binds
+ @IntoMap
+ @StringKey("dagger.hilt.android.test.MyViewModel")
+ @HiltViewModelMap
+ public abstract ViewModel binds(MyViewModel vm);
+ }
+
+ @Module
+ @InstallIn(ActivityRetainedComponent.class)
+ public static final class KeyModule {
+ private KeyModule() {
+ }
+
+ @Provides
+ @IntoSet
+ @HiltViewModelMap.KeySet
+ public static String provide() {
+ return "dagger.hilt.android.test.MyViewModel";
+ }
+ }
+ }
+ """.toJFO("dagger.hilt.android.test.MyViewModel_HiltModules")
+
+ val compilation = compiler()
+ .compile(myQualifier, myViewModel)
+ assertThat(compilation).apply {
+ succeeded()
+ generatedSourceFile("dagger.hilt.android.test.MyViewModel_HiltModules")
+ .hasSourceEquivalentTo(expected)
+ }
+ }
+
+ @Test
+ fun verifyInnerClass() {
+ val viewModel = """
+ package dagger.hilt.android.test;
+
+ import dagger.hilt.android.lifecycle.HiltViewModel;
+ import androidx.lifecycle.ViewModel;
+ import javax.inject.Inject;
+
+ class Outer {
+ @HiltViewModel
+ static class InnerViewModel extends ViewModel {
+ @Inject
+ InnerViewModel() { }
+ }
+ }
+ """.toJFO("dagger.hilt.android.test.Outer")
+
+ val expectedModule = """
+ package dagger.hilt.android.test;
+
+ import androidx.lifecycle.ViewModel;
+ import dagger.Binds;
+ import dagger.Module;
+ import dagger.Provides;
+ import dagger.hilt.InstallIn;
+ import dagger.hilt.android.components.ActivityRetainedComponent;
+ import dagger.hilt.android.components.ViewModelComponent;
+ import dagger.hilt.android.internal.lifecycle.HiltViewModelMap;
+ import dagger.hilt.codegen.OriginatingElement;
+ import dagger.multibindings.IntoMap;
+ import dagger.multibindings.IntoSet;
+ import dagger.multibindings.StringKey;
+ import java.lang.String;
+ import $GENERATED_TYPE
+
+ $GENERATED_ANNOTATION
+ @OriginatingElement(
+ topLevelClass = Outer.class
+ )
+ public final class Outer_InnerViewModel_HiltModules {
+ private Outer_InnerViewModel_HiltModules() {
+ }
+
+ @Module
+ @InstallIn(ViewModelComponent.class)
+ public static abstract class BindsModule {
+ @Binds
+ @IntoMap
+ @StringKey("dagger.hilt.android.test.Outer${'$'}InnerViewModel")
+ @HiltViewModelMap
+ public abstract ViewModel binds(Outer.InnerViewModel vm);
+ }
+
+ @Module
+ @InstallIn(ActivityRetainedComponent.class)
+ public static final class KeyModule {
+ private KeyModule() {
+ }
+
+ @Provides
+ @IntoSet
+ @HiltViewModelMap.KeySet
+ public static String provide() {
+ return "dagger.hilt.android.test.Outer${'$'}InnerViewModel";
+ }
+ }
+ }
+ """.toJFO("dagger.hilt.android.test.Outer_InnerViewModel_HiltModules")
+
+ val compilation = compiler()
+ .compile(viewModel)
+ assertThat(compilation).apply {
+ succeeded()
+ generatedSourceFile("dagger.hilt.android.test.Outer_InnerViewModel_HiltModules")
+ .hasSourceEquivalentTo(expectedModule)
+ }
+ }
+}
diff --git a/javatests/dagger/hilt/android/processor/internal/viewmodel/ViewModelProcessorTest.kt b/javatests/dagger/hilt/android/processor/internal/viewmodel/ViewModelProcessorTest.kt
new file mode 100644
index 0000000..b3eaeab
--- /dev/null
+++ b/javatests/dagger/hilt/android/processor/internal/viewmodel/ViewModelProcessorTest.kt
@@ -0,0 +1,184 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.viewmodel
+
+import com.google.testing.compile.CompilationSubject.assertThat
+import com.google.testing.compile.Compiler
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+@RunWith(JUnit4::class)
+class ViewModelProcessorTest {
+
+ private fun compiler(): Compiler = Compiler.javac().withProcessors(ViewModelProcessor())
+
+ @Test
+ fun validViewModel() {
+ val myViewModel = """
+ package dagger.hilt.android.test;
+
+ import androidx.lifecycle.ViewModel;
+ import dagger.hilt.android.lifecycle.HiltViewModel;
+ import javax.inject.Inject;
+
+ @HiltViewModel
+ class MyViewModel extends ViewModel {
+ @Inject MyViewModel() { }
+ }
+ """.toJFO("dagger.hilt.android.test.MyViewModel")
+
+ val compilation = compiler().compile(myViewModel)
+ assertThat(compilation).succeeded()
+ }
+
+ @Test
+ fun verifyEnclosingElementExtendsViewModel() {
+ val myViewModel = """
+ package dagger.hilt.android.test;
+
+ import dagger.hilt.android.lifecycle.HiltViewModel;
+ import javax.inject.Inject;
+
+ @HiltViewModel
+ class MyViewModel {
+ @Inject
+ MyViewModel() { }
+ }
+ """.toJFO("dagger.hilt.android.test.MyViewModel")
+
+ val compilation = compiler().compile(myViewModel)
+ assertThat(compilation).apply {
+ failed()
+ hadErrorCount(1)
+ hadErrorContainingMatch(
+ "@HiltViewModel is only supported on types that subclass androidx.lifecycle.ViewModel."
+ )
+ }
+ }
+
+ @Test
+ fun verifySingleAnnotatedConstructor() {
+ val myViewModel = """
+ package dagger.hilt.android.test;
+
+ import androidx.lifecycle.ViewModel;
+ import dagger.hilt.android.lifecycle.HiltViewModel;
+ import javax.inject.Inject;
+
+ @HiltViewModel
+ class MyViewModel extends ViewModel {
+ @Inject
+ MyViewModel() { }
+
+ @Inject
+ MyViewModel(String s) { }
+ }
+ """.toJFO("dagger.hilt.android.test.MyViewModel")
+
+ val compilation = compiler().compile(myViewModel)
+ assertThat(compilation).apply {
+ failed()
+ hadErrorCount(1)
+ hadErrorContainingMatch(
+ "@HiltViewModel annotated class should contain exactly one @Inject annotated constructor."
+ )
+ }
+ }
+
+ @Test
+ fun verifyNonPrivateConstructor() {
+ val myViewModel = """
+ package dagger.hilt.android.test;
+
+ import androidx.lifecycle.ViewModel;
+ import dagger.hilt.android.lifecycle.HiltViewModel;
+ import javax.inject.Inject;
+
+ @HiltViewModel
+ class MyViewModel extends ViewModel {
+ @Inject
+ private MyViewModel() { }
+ }
+ """.toJFO("dagger.hilt.android.test.MyViewModel")
+
+ val compilation = compiler().compile(myViewModel)
+ assertThat(compilation).apply {
+ failed()
+ hadErrorCount(1)
+ hadErrorContainingMatch(
+ "@Inject annotated constructors must not be " +
+ "private."
+ )
+ }
+ }
+
+ @Test
+ fun verifyInnerClassIsStatic() {
+ val myViewModel = """
+ package dagger.hilt.android.test;
+
+ import androidx.lifecycle.ViewModel;
+ import dagger.hilt.android.lifecycle.HiltViewModel;
+ import javax.inject.Inject;
+
+ class Outer {
+ @HiltViewModel
+ class MyViewModel extends ViewModel {
+ @Inject
+ MyViewModel() { }
+ }
+ }
+ """.toJFO("dagger.hilt.android.test.Outer")
+
+ val compilation = compiler().compile(myViewModel)
+ assertThat(compilation).apply {
+ failed()
+ hadErrorCount(1)
+ hadErrorContainingMatch(
+ "@HiltViewModel may only be used on inner classes if they are static."
+ )
+ }
+ }
+
+ @Test
+ fun verifyNoScopeAnnotation() {
+ val myViewModel = """
+ package dagger.hilt.android.test;
+
+ import androidx.lifecycle.ViewModel;
+ import dagger.hilt.android.lifecycle.HiltViewModel;
+ import javax.inject.Inject;
+ import javax.inject.Singleton;
+
+ @Singleton
+ @HiltViewModel
+ class MyViewModel extends ViewModel {
+ @Inject MyViewModel() { }
+ }
+ """.toJFO("dagger.hilt.android.test.MyViewModel")
+
+ val compilation = compiler().compile(myViewModel)
+ assertThat(compilation).apply {
+ failed()
+ hadErrorCount(1)
+ hadErrorContainingMatch(
+ "@HiltViewModel classes should not be scoped. Found: @javax.inject.Singleton"
+ )
+ }
+ }
+}
diff --git a/javatests/dagger/hilt/android/processor/internal/viewmodel/ViewModelValidationPluginTest.kt b/javatests/dagger/hilt/android/processor/internal/viewmodel/ViewModelValidationPluginTest.kt
new file mode 100644
index 0000000..b5c22c1
--- /dev/null
+++ b/javatests/dagger/hilt/android/processor/internal/viewmodel/ViewModelValidationPluginTest.kt
@@ -0,0 +1,352 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.processor.internal.viewmodel
+
+import com.google.testing.compile.CompilationSubject.assertThat
+import com.google.testing.compile.Compiler
+import dagger.hilt.android.processor.AndroidCompilers.compiler
+import dagger.internal.codegen.ComponentProcessor
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+@RunWith(JUnit4::class)
+class ViewModelValidationPluginTest {
+
+ private fun testCompiler(): Compiler = compiler(
+ ComponentProcessor.forTesting(ViewModelValidationPlugin()),
+ ViewModelProcessor()
+ )
+
+ private val hiltAndroidApp = """
+ package test;
+
+ import android.app.Application;
+ import dagger.hilt.android.HiltAndroidApp;
+
+ @HiltAndroidApp(Application.class)
+ public class TestApplication extends Hilt_TestApplication {}
+ """.toJFO("test.TestApplication")
+
+ @Test
+ fun injectViewModelIsProhibited() {
+ val hiltActivity = """
+ package test;
+
+ import androidx.fragment.app.FragmentActivity;
+ import dagger.hilt.android.AndroidEntryPoint;
+ import javax.inject.Inject;
+
+ @AndroidEntryPoint(FragmentActivity.class)
+ public class TestActivity extends Hilt_TestActivity {
+ @Inject Foo foo;
+ }
+ """.toJFO("test.TestActivity")
+ val hiltViewModel = """
+ package test;
+
+ import androidx.lifecycle.ViewModel;
+ import dagger.hilt.android.lifecycle.HiltViewModel;
+ import javax.inject.Inject;
+
+ @HiltViewModel
+ class MyViewModel extends ViewModel {
+ @Inject MyViewModel() { }
+ }
+ """.toJFO("test.MyViewModel")
+ val foo = """
+ package test;
+
+ import javax.inject.Inject;
+
+ final class Foo {
+ @Inject Foo(MyViewModel viewModel) {}
+ }
+ """.toJFO("test.Foo")
+
+ val compilation = testCompiler().compile(foo, hiltViewModel, hiltAndroidApp, hiltActivity)
+ assertThat(compilation).apply {
+ failed()
+ hadErrorCount(1)
+ hadErrorContainingMatch(
+ "Injection of an @HiltViewModel class is prohibited"
+ )
+ }
+ }
+
+ @Test
+ fun fieldInjectedViewModelIsProhibited() {
+ val hiltActivity = """
+ package test;
+
+ import androidx.fragment.app.FragmentActivity;
+ import dagger.hilt.android.AndroidEntryPoint;
+ import javax.inject.Inject;
+
+ @AndroidEntryPoint(FragmentActivity.class)
+ public class TestActivity extends Hilt_TestActivity {
+ @Inject MyViewModel viewModel;
+ }
+ """.toJFO("test.TestActivity")
+ val hiltViewModel = """
+ package test;
+
+ import androidx.lifecycle.ViewModel;
+ import dagger.hilt.android.lifecycle.HiltViewModel;
+ import javax.inject.Inject;
+
+ @HiltViewModel
+ class MyViewModel extends ViewModel {
+ @Inject MyViewModel() { }
+ }
+ """.toJFO("test.MyViewModel")
+
+ val compilation = testCompiler().compile(hiltViewModel, hiltAndroidApp, hiltActivity)
+ assertThat(compilation).apply {
+ failed()
+ hadErrorCount(1)
+ hadErrorContainingMatch(
+ "Injection of an @HiltViewModel class is prohibited"
+ )
+ }
+ }
+
+ @Test
+ fun injectViewModelFromViewModelComponentIsProhibited() {
+ // Use an @HiltViewModel that injects a Foo to get the binding inside the ViewModelComponent
+ val hiltViewModel = """
+ package test;
+
+ import androidx.lifecycle.ViewModel;
+ import dagger.hilt.android.lifecycle.HiltViewModel;
+ import javax.inject.Inject;
+
+ @HiltViewModel
+ class MyViewModel extends ViewModel {
+ @Inject MyViewModel(Foo foo) { }
+ }
+ """.toJFO("test.MyViewModel")
+
+ val foo = """
+ package test;
+
+ import javax.inject.Inject;
+ import javax.inject.Provider;
+
+ final class Foo {
+ @Inject Foo(Provider<MyViewModel> viewModelProvider) {}
+ }
+ """.toJFO("test.Foo")
+
+ val compilation = testCompiler().compile(foo, hiltViewModel, hiltAndroidApp)
+ assertThat(compilation).apply {
+ failed()
+ hadErrorCount(1)
+ hadErrorContainingMatch(
+ "Injection of an @HiltViewModel class is prohibited"
+ )
+ }
+ }
+
+ @Test
+ fun injectOverriddenViewModelBindingIsAllowed() {
+ val hiltActivity = """
+ package test;
+
+ import androidx.fragment.app.FragmentActivity;
+ import dagger.hilt.android.AndroidEntryPoint;
+ import javax.inject.Inject;
+
+ @AndroidEntryPoint(FragmentActivity.class)
+ public class TestActivity extends Hilt_TestActivity {
+ @Inject Foo foo;
+ }
+ """.toJFO("test.TestActivity")
+ val hiltViewModel = """
+ package test;
+
+ import androidx.lifecycle.ViewModel;
+ import dagger.hilt.android.lifecycle.HiltViewModel;
+ import javax.inject.Inject;
+
+ @HiltViewModel
+ class MyViewModel extends ViewModel {
+ @Inject MyViewModel() { }
+ }
+ """.toJFO("test.MyViewModel")
+ val foo = """
+ package test;
+
+ import javax.inject.Inject;
+
+ final class Foo {
+ @Inject Foo(MyViewModel viewModel) {}
+ }
+ """.toJFO("test.Foo")
+ val activityModule = """
+ package test;
+
+ import dagger.Module;
+ import dagger.Provides;
+ import dagger.hilt.InstallIn;
+ import dagger.hilt.android.components.ActivityComponent;
+
+ @InstallIn(ActivityComponent.class)
+ @Module
+ public final class ActivityModule {
+ @Provides static MyViewModel provideMyViewModel() {
+ // Normally you'd expect this to use a ViewModelProvider or something but
+ // since this test is just testing the binding graph, for simplicity just return
+ // null.
+ return null;
+ }
+ }
+ """.toJFO("test.ActivityModule")
+
+ val compilation = testCompiler().compile(
+ foo, activityModule, hiltViewModel, hiltAndroidApp, hiltActivity
+ )
+ assertThat(compilation).succeeded()
+ }
+
+ @Test
+ fun injectQualifiedViewModelBindingIsAllowed() {
+ val hiltActivity = """
+ package test;
+
+ import androidx.fragment.app.FragmentActivity;
+ import dagger.hilt.android.AndroidEntryPoint;
+ import javax.inject.Inject;
+
+ @AndroidEntryPoint(FragmentActivity.class)
+ public class TestActivity extends Hilt_TestActivity {
+ @Inject Foo foo;
+ }
+ """.toJFO("test.TestActivity")
+ val hiltViewModel = """
+ package test;
+
+ import androidx.lifecycle.ViewModel;
+ import dagger.hilt.android.lifecycle.HiltViewModel;
+ import javax.inject.Inject;
+
+ @HiltViewModel
+ class MyViewModel extends ViewModel {
+ @Inject MyViewModel() { }
+ }
+ """.toJFO("test.MyViewModel")
+ val foo = """
+ package test;
+
+ import javax.inject.Inject;
+
+ final class Foo {
+ @Inject Foo(@ActivityModule.MyQualifier MyViewModel viewModel) {}
+ }
+ """.toJFO("test.Foo")
+ val activityModule = """
+ package test;
+
+ import dagger.Module;
+ import dagger.Provides;
+ import dagger.hilt.InstallIn;
+ import dagger.hilt.android.components.ActivityComponent;
+ import javax.inject.Qualifier;
+
+ @InstallIn(ActivityComponent.class)
+ @Module
+ public final class ActivityModule {
+ @Qualifier
+ public @interface MyQualifier {}
+
+ @Provides
+ @MyQualifier
+ static MyViewModel provideMyViewModel() {
+ // Normally you'd expect this to use a ViewModelProvider or something but
+ // since this test is just testing the binding graph, for simplicity just return
+ // null.
+ return null;
+ }
+ }
+ """.toJFO("test.ActivityModule")
+
+ val compilation = testCompiler().compile(
+ foo, activityModule, hiltViewModel, hiltAndroidApp, hiltActivity
+ )
+ assertThat(compilation).succeeded()
+ }
+
+ // Regression test for not handling array types properly
+ @Test
+ fun correctlyAllowsOtherBindings() {
+ val hiltActivity = """
+ package test;
+
+ import androidx.fragment.app.FragmentActivity;
+ import dagger.hilt.android.AndroidEntryPoint;
+ import javax.inject.Inject;
+
+ @AndroidEntryPoint(FragmentActivity.class)
+ public class TestActivity extends Hilt_TestActivity {
+ @Inject Foo foo;
+ }
+ """.toJFO("test.TestActivity")
+ val hiltViewModel = """
+ package test;
+
+ import androidx.lifecycle.ViewModel;
+ import dagger.hilt.android.lifecycle.HiltViewModel;
+ import javax.inject.Inject;
+
+ @HiltViewModel
+ class MyViewModel extends ViewModel {
+ @Inject MyViewModel() { }
+ }
+ """.toJFO("test.MyViewModel")
+ val foo = """
+ package test;
+
+ import javax.inject.Inject;
+
+ final class Foo {
+ @Inject Foo(Long[] longArray) {}
+ }
+ """.toJFO("test.Foo")
+ val activityModule = """
+ package test;
+
+ import dagger.Module;
+ import dagger.Provides;
+ import dagger.hilt.InstallIn;
+ import dagger.hilt.android.components.ActivityComponent;
+
+ @InstallIn(ActivityComponent.class)
+ @Module
+ public final class ActivityModule {
+ @Provides
+ static Long[] provideLongArray() {
+ return null;
+ }
+ }
+ """.toJFO("test.ActivityModule")
+
+ val compilation = testCompiler().compile(
+ foo, activityModule, hiltViewModel, hiltAndroidApp, hiltActivity
+ )
+ assertThat(compilation).succeeded()
+ }
+}
diff --git a/javatests/dagger/hilt/processor/internal/BUILD b/javatests/dagger/hilt/processor/internal/BUILD
new file mode 100644
index 0000000..e6e1cfb
--- /dev/null
+++ b/javatests/dagger/hilt/processor/internal/BUILD
@@ -0,0 +1,40 @@
+# Copyright (C) 2019 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Tests for internal code for implementing Hilt processors.
+
+package(default_visibility = ["//:src"])
+
+java_test(
+ name = "ProcessorsTest",
+ size = "small",
+ srcs = ["ProcessorsTest.java"],
+ deps = [
+ "//java/dagger/hilt/processor/internal:processors",
+ "@google_bazel_common//third_party/java/javapoet",
+ "@google_bazel_common//third_party/java/junit",
+ "@google_bazel_common//third_party/java/truth",
+ ],
+)
+
+java_library(
+ name = "generated_import",
+ srcs = ["GeneratedImport.java"],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["**/*"]),
+)
diff --git a/javatests/dagger/hilt/processor/internal/GeneratedImport.java b/javatests/dagger/hilt/processor/internal/GeneratedImport.java
new file mode 100644
index 0000000..0feaa4e
--- /dev/null
+++ b/javatests/dagger/hilt/processor/internal/GeneratedImport.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal;
+
+/** Utility class for @Generated usage in tests. */
+public final class GeneratedImport {
+ public static final String IMPORT_GENERATED_ANNOTATION =
+ isBeforeJava9()
+ ? "import javax.annotation.Generated;"
+ : "import javax.annotation.processing.Generated;";
+
+ private static boolean isBeforeJava9() {
+ try {
+ Class.forName("java.lang.Module");
+ return false;
+ } catch (ClassNotFoundException e) {
+ return true;
+ }
+ }
+
+ private GeneratedImport() {}
+}
diff --git a/javatests/dagger/hilt/processor/internal/ProcessorsTest.java b/javatests/dagger/hilt/processor/internal/ProcessorsTest.java
new file mode 100644
index 0000000..cad41aa
--- /dev/null
+++ b/javatests/dagger/hilt/processor/internal/ProcessorsTest.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterizedTypeName;
+import com.squareup.javapoet.TypeVariableName;
+import java.util.List;
+import javax.lang.model.element.Modifier;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class ProcessorsTest {
+
+ @Test
+ public void testCopyMethodSpecWithoutBodyForMethod() throws Exception {
+ TypeVariableName t = TypeVariableName.get("T", Number.class);
+ ClassName list = ClassName.get(List.class);
+ MethodSpec.Builder builder = MethodSpec.methodBuilder("myMethod")
+ .addJavadoc("This is a test line 1 in the java doc \n"
+ + "This is a test line 2 in the java doc \n"
+ + "<p>Test Use of links {@link $T} \n", list)
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC)
+ .addParameter(ParameterizedTypeName.get(list, t), "list", Modifier.FINAL)
+ .returns(ParameterizedTypeName.get(list, t))
+ .addException(IllegalArgumentException.class)
+ .addTypeVariable(t);
+
+ // Test that method copy is the same as original
+ MethodSpec method = builder.build();
+ MethodSpec methodCopy = Processors.copyMethodSpecWithoutBody(method).build();
+ assertThat(method.toString()).contains(methodCopy.toString());
+
+ // Test that method copy removes the body, compare with the old copy
+ MethodSpec methodWithBody = builder.addStatement("return list").build();
+ MethodSpec methodCopyWithBody = Processors.copyMethodSpecWithoutBody(methodWithBody).build();
+ assertThat(methodCopyWithBody.toString()).isEqualTo(methodCopy.toString());
+
+ }
+
+ @Test
+ public void testCopyMethodSpecWithoutBodyForConstructor() throws Exception {
+ TypeVariableName t = TypeVariableName.get("T", Number.class);
+ ClassName list = ClassName.get(List.class);
+ MethodSpec.Builder builder = MethodSpec.constructorBuilder()
+ .addJavadoc("This is a test line 1 in the java doc \n"
+ + "This is a test line 2 in the java doc \n"
+ + "<p>Test Use of links {@link $T} \n", list)
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC)
+ .addParameter(ParameterizedTypeName.get(list, t), "list", Modifier.FINAL)
+ .addException(IllegalArgumentException.class)
+ .addTypeVariable(t);
+
+ // Test that method copy is the same as original
+ MethodSpec method = builder.build();
+ MethodSpec methodCopy = Processors.copyMethodSpecWithoutBody(method).build();
+ assertThat(method.toString()).contains(methodCopy.toString());
+
+ // Test that method copy removes the body, compare with the old copy
+ MethodSpec methodWithBody = builder.addStatement("this.list = list").build();
+ MethodSpec methodCopyWithBody = Processors.copyMethodSpecWithoutBody(methodWithBody).build();
+ assertThat(methodCopyWithBody.toString()).isEqualTo(methodCopy.toString());
+ }
+}
diff --git a/javatests/dagger/hilt/processor/internal/aggregateddeps/AggregatedDepsProcessorErrorsTest.java b/javatests/dagger/hilt/processor/internal/aggregateddeps/AggregatedDepsProcessorErrorsTest.java
new file mode 100644
index 0000000..b36a71d
--- /dev/null
+++ b/javatests/dagger/hilt/processor/internal/aggregateddeps/AggregatedDepsProcessorErrorsTest.java
@@ -0,0 +1,286 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.aggregateddeps;
+
+import static com.google.testing.compile.CompilationSubject.assertThat;
+
+import com.google.common.base.Joiner;
+import com.google.testing.compile.Compilation;
+import com.google.testing.compile.JavaFileObjects;
+import dagger.hilt.processor.internal.GeneratedImport;
+import dagger.testing.compile.CompilerTests;
+import javax.tools.JavaFileObject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for errors generated by {@link AggregatedDepsProcessor} */
+@RunWith(JUnit4.class)
+public class AggregatedDepsProcessorErrorsTest {
+ private static final Joiner LINES = Joiner.on("\n");
+
+ @Test
+ public void reportMultipleAnnotationTypeKindErrors() {
+ JavaFileObject source =
+ JavaFileObjects.forSourceString(
+ "foo.bar.AnnotationsOnWrongTypeKind",
+ LINES.join(
+ "package foo.bar;",
+ "",
+ "import dagger.hilt.EntryPoint;",
+ "import dagger.hilt.InstallIn;",
+ "import dagger.Module;",
+ "import dagger.hilt.components.SingletonComponent;",
+ "import dagger.hilt.internal.ComponentEntryPoint;",
+ "import dagger.hilt.internal.GeneratedEntryPoint;",
+ "",
+ "@InstallIn(SingletonComponent.class)",
+ "@Module",
+ "enum FooModule { VALUE }",
+ "",
+ "@InstallIn(SingletonComponent.class)",
+ "@EntryPoint",
+ "final class BarEntryPoint {}",
+ "",
+ "@InstallIn(SingletonComponent.class)",
+ "@ComponentEntryPoint",
+ "final class BazComponentEntryPoint {}",
+ "",
+ "@EntryPoint",
+ "interface QuxEntryPoint {}",
+ "",
+ "@EntryPoint",
+ "@Module",
+ "interface DontMix{}",
+ ""));
+
+ Compilation compilation =
+ CompilerTests.compiler().withProcessors(new AggregatedDepsProcessor()).compile(source);
+
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining("Only classes and interfaces can be annotated with @Module")
+ .inFile(source)
+ .onLine(12);
+ assertThat(compilation)
+ .hadErrorContaining("Only interfaces can be annotated with @EntryPoint")
+ .inFile(source)
+ .onLine(16);
+ assertThat(compilation)
+ .hadErrorContaining("Only interfaces can be annotated with @ComponentEntryPoint")
+ .inFile(source)
+ .onLine(20);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@EntryPoint foo.bar.QuxEntryPoint must also be annotated with @InstallIn")
+ .inFile(source)
+ .onLine(23);
+ assertThat(compilation)
+ .hadErrorContaining("@Module and @EntryPoint cannot be used on the same interface")
+ .inFile(source)
+ .onLine(27);
+ }
+
+ @Test
+ public void testInvalidComponentInInstallInAnnotation() {
+ JavaFileObject module = JavaFileObjects.forSourceLines(
+ "test.FooModule",
+ "package test;",
+ "",
+ "import dagger.Module;",
+ "import dagger.hilt.InstallIn;",
+ "import dagger.hilt.android.qualifiers.ApplicationContext;",
+ "",
+ "@InstallIn(ApplicationContext.class)", // Error: Not a Hilt component
+ "@Module",
+ "final class FooModule {}");
+
+ Compilation compilation =
+ CompilerTests.compiler().withProcessors(new AggregatedDepsProcessor()).compile(module);
+
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@InstallIn, can only be used with @DefineComponent-annotated classes, but found: "
+ + "[dagger.hilt.android.qualifiers.ApplicationContext]")
+ .inFile(module)
+ .onLine(9);
+ }
+
+ @Test
+ public void testMissingInstallInAnnotation() {
+ JavaFileObject source = JavaFileObjects.forSourceString(
+ "foo.bar.AnnotationsOnWrongTypeKind",
+ LINES.join(
+ "package foo.bar;",
+ "",
+ "import dagger.Module;",
+ "",
+ "@Module", // Error: Doesn't have InstallIn annotation
+ "final class FooModule {}"));
+
+ Compilation compilation =
+ CompilerTests.compiler().withProcessors(new AggregatedDepsProcessor()).compile(source);
+
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining("foo.bar.FooModule is missing an @InstallIn annotation")
+ .inFile(source)
+ .onLine(6);
+ }
+
+ @Test
+ public void testNoErrorOnDaggerGeneratedModules() {
+ JavaFileObject source =
+ JavaFileObjects.forSourceString(
+ "foo.bar",
+ LINES.join(
+ "package foo.bar;",
+ "",
+ GeneratedImport.IMPORT_GENERATED_ANNOTATION,
+ "import dagger.Module;",
+ "",
+ "@Module",
+ "@Generated(value = \"something\")", // Error: Isn't Dagger-generated but missing
+ // InstallIn
+ "final class FooModule {}",
+ "",
+ "@Module",
+ "@Generated(value = \"dagger\")", // No error because the module is dagger generated
+ "final class BarModule {}"));
+
+ Compilation compilation =
+ CompilerTests.compiler().withProcessors(new AggregatedDepsProcessor()).compile(source);
+
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining("foo.bar.FooModule is missing an @InstallIn annotation")
+ .inFile(source)
+ .onLine(8);
+ }
+
+ @Test
+ public void testModuleWithOnlyParamConstructor_fails() {
+ JavaFileObject source = JavaFileObjects.forSourceString("foo.bar", LINES.join(
+ "package foo.bar;",
+ "",
+ "import dagger.Module;",
+ "import dagger.Provides;",
+ "import dagger.hilt.InstallIn;",
+ "import dagger.hilt.components.SingletonComponent;",
+ "",
+ "@Module",
+ "@InstallIn(SingletonComponent.class)",
+ "final class FooModule {",
+ " FooModule(String arg) {}",
+ "",
+ " @Provides",
+ " String provideString() {",
+ " return \"\";",
+ " }",
+ "}"));
+
+ Compilation compilation =
+ CompilerTests.compiler().withProcessors(new AggregatedDepsProcessor()).compile(source);
+
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "Modules that need to be instantiated by Hilt must have a visible, empty constructor.");
+ }
+
+ @Test
+ public void testInnerModule() {
+ JavaFileObject source = JavaFileObjects.forSourceString("foo.bar", LINES.join(
+ "package foo.bar;",
+ "",
+ "import dagger.Module;",
+ "import dagger.hilt.InstallIn;",
+ "import dagger.hilt.components.SingletonComponent;",
+ "",
+ "final class Outer {",
+ " @Module",
+ " @InstallIn(SingletonComponent.class)",
+ " final class InnerModule {}",
+ "}"));
+
+ Compilation compilation =
+ CompilerTests.compiler().withProcessors(new AggregatedDepsProcessor()).compile(source);
+
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "Nested @InstallIn modules must be static unless they are directly nested within a "
+ + "test. Found: foo.bar.Outer.InnerModule");
+ }
+
+ @Test
+ public void testInnerModuleInTest() {
+ JavaFileObject source = JavaFileObjects.forSourceString("foo.bar", LINES.join(
+ "package foo.bar;",
+ "",
+ "import dagger.Module;",
+ "import dagger.hilt.InstallIn;",
+ "import dagger.hilt.components.SingletonComponent;",
+ "import dagger.hilt.android.testing.HiltAndroidTest;",
+ "",
+ "@HiltAndroidTest",
+ "final class Outer {",
+ " static class Nested {",
+ " @Module",
+ " @InstallIn(SingletonComponent.class)",
+ " final class InnerModule {}",
+ " }",
+ "}"));
+
+ Compilation compilation =
+ CompilerTests.compiler().withProcessors(new AggregatedDepsProcessor()).compile(source);
+
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "Nested @InstallIn modules must be static unless they are directly nested within a "
+ + "test. Found: foo.bar.Outer.Nested.InnerModule");
+ }
+
+ @Test
+ public void testInnerModuleInTest_succeeds() {
+ JavaFileObject source = JavaFileObjects.forSourceString("foo.bar", LINES.join(
+ "package foo.bar;",
+ "",
+ "import dagger.Module;",
+ "import dagger.hilt.InstallIn;",
+ "import dagger.hilt.components.SingletonComponent;",
+ "import dagger.hilt.android.testing.HiltAndroidTest;",
+ "",
+ "@HiltAndroidTest",
+ "final class Outer {",
+ " @Module",
+ " @InstallIn(SingletonComponent.class)",
+ " final class InnerModule {}",
+ "}"));
+
+ Compilation compilation =
+ CompilerTests.compiler().withProcessors(new AggregatedDepsProcessor()).compile(source);
+
+ assertThat(compilation).succeeded();
+ }
+}
diff --git a/javatests/dagger/hilt/processor/internal/aggregateddeps/BUILD b/javatests/dagger/hilt/processor/internal/aggregateddeps/BUILD
new file mode 100644
index 0000000..f52b051
--- /dev/null
+++ b/javatests/dagger/hilt/processor/internal/aggregateddeps/BUILD
@@ -0,0 +1,49 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Description:
+# Builds and run tests related to AggregatedDepsProcessor.
+
+load("//java/dagger/testing/compile:macros.bzl", "compiler_test")
+
+package(default_visibility = ["//:src"])
+
+compiler_test(
+ name = "AggregatedDepsProcessorErrorsTest",
+ size = "small",
+ srcs = ["AggregatedDepsProcessorErrorsTest.java"],
+ compiler_deps = [
+ "//java/dagger/hilt/internal:component_entry_point",
+ "//java/dagger/hilt/internal:generated_entry_point",
+ "//:dagger_with_compiler",
+ "@google_bazel_common//third_party/java/jsr250_annotations",
+ "//java/dagger/hilt:entry_point",
+ "//java/dagger/hilt:install_in",
+ "//java/dagger/hilt/android/testing:hilt_android_test",
+ "//java/dagger/hilt/android/components",
+ ],
+ deps = [
+ "//java/dagger/hilt/processor/internal/aggregateddeps:processor_lib",
+ "//java/dagger/internal/guava:base",
+ "//javatests/dagger/hilt/processor/internal:generated_import",
+ "@google_bazel_common//third_party/java/compile_testing",
+ "@google_bazel_common//third_party/java/junit",
+ "@google_bazel_common//third_party/java/truth",
+ ],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/javatests/dagger/hilt/processor/internal/definecomponent/BUILD b/javatests/dagger/hilt/processor/internal/definecomponent/BUILD
new file mode 100644
index 0000000..ce5cc0a
--- /dev/null
+++ b/javatests/dagger/hilt/processor/internal/definecomponent/BUILD
@@ -0,0 +1,46 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Description:
+# Tests for Hilt's DefineComponentProcessor
+
+load("//:build_defs.bzl", "DOCLINT_HTML_AND_SYNTAX")
+load("//:test_defs.bzl", "GenJavaTests")
+
+package(default_visibility = ["//:src"])
+
+GenJavaTests(
+ name = "hilt_processor_tests",
+ srcs = glob(["*.java"]),
+ functional = False,
+ javacopts = DOCLINT_HTML_AND_SYNTAX,
+ deps = [
+ "//:dagger_with_compiler",
+ "//java/dagger/hilt:entry_point",
+ "//java/dagger/hilt:install_in",
+ "//java/dagger/hilt/android/components",
+ "//java/dagger/hilt/android/qualifiers",
+ "//java/dagger/hilt/processor/internal/definecomponent:define_components",
+ "//java/dagger/hilt/processor/internal/definecomponent:processor_lib",
+ "//javatests/dagger/hilt/processor/internal:generated_import",
+ "@google_bazel_common//third_party/java/compile_testing",
+ "@google_bazel_common//third_party/java/junit",
+ "@google_bazel_common//third_party/java/truth",
+ ],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/javatests/dagger/hilt/processor/internal/definecomponent/DefineComponentProcessorTest.java b/javatests/dagger/hilt/processor/internal/definecomponent/DefineComponentProcessorTest.java
new file mode 100644
index 0000000..901c7a3
--- /dev/null
+++ b/javatests/dagger/hilt/processor/internal/definecomponent/DefineComponentProcessorTest.java
@@ -0,0 +1,401 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.definecomponent;
+
+import static com.google.testing.compile.CompilationSubject.assertThat;
+import static com.google.testing.compile.Compiler.javac;
+
+import com.google.testing.compile.Compilation;
+import com.google.testing.compile.Compiler;
+import com.google.testing.compile.JavaFileObjects;
+import dagger.hilt.processor.internal.GeneratedImport;
+import javax.tools.JavaFileObject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class DefineComponentProcessorTest {
+
+ @Test
+ public void testDefineComponentOutput() {
+ JavaFileObject component =
+ JavaFileObjects.forSourceLines(
+ "test.FooComponent",
+ "package test;",
+ "",
+ "import dagger.hilt.components.SingletonComponent;",
+ "import dagger.hilt.DefineComponent;",
+ "",
+ "@DefineComponent(parent = SingletonComponent.class)",
+ "interface FooComponent {",
+ " static int staticField = 1;",
+ " static int staticMethod() { return staticField; }",
+ "}");
+
+ JavaFileObject builder =
+ JavaFileObjects.forSourceLines(
+ "test.FooComponentBuilder",
+ "package test;",
+ "",
+ "import dagger.hilt.DefineComponent;",
+ "",
+ "@DefineComponent.Builder",
+ "interface FooComponentBuilder {",
+ " static int staticField = 1;",
+ " static int staticMethod() { return staticField; }",
+ "",
+ " FooComponent create();",
+ "}");
+
+ JavaFileObject componentOutput =
+ JavaFileObjects.forSourceLines(
+ "dagger.hilt.processor.internal.definecomponent.codegen.test_FooComponent",
+ "package dagger.hilt.processor.internal.definecomponent.codegen;",
+ "",
+ "import dagger.hilt.internal.definecomponent.DefineComponentClasses;",
+ GeneratedImport.IMPORT_GENERATED_ANNOTATION,
+ "",
+ "@DefineComponentClasses(component = \"test.FooComponent\")",
+ "@Generated(\"" + DefineComponentProcessor.class.getName() + "\")",
+ "interface test_FooComponent {}");
+
+ JavaFileObject builderOutput =
+ JavaFileObjects.forSourceLines(
+ "dagger.hilt.processor.internal.definecomponent.codegen.test_FooComponentBuilder",
+ "package dagger.hilt.processor.internal.definecomponent.codegen;",
+ "",
+ "import dagger.hilt.internal.definecomponent.DefineComponentClasses;",
+ GeneratedImport.IMPORT_GENERATED_ANNOTATION,
+ "",
+ "@DefineComponentClasses(builder = \"test.FooComponentBuilder\")",
+ "@Generated(\"" + DefineComponentProcessor.class.getName() + "\")",
+ "interface test_FooComponentBuilder {}");
+
+ Compilation compilation = compiler().compile(component, builder);
+ assertThat(compilation).succeeded();
+ assertThat(compilation)
+ .generatedSourceFile(sourceName(componentOutput))
+ .hasSourceEquivalentTo(componentOutput);
+ assertThat(compilation)
+ .generatedSourceFile(sourceName(builderOutput))
+ .hasSourceEquivalentTo(builderOutput);
+ }
+
+ private static String sourceName(JavaFileObject fileObject) {
+ return fileObject.getName().replace(".java", "").replace('.', '/');
+ }
+
+ @Test
+ public void testDefineComponentClass_fails() {
+ JavaFileObject component =
+ JavaFileObjects.forSourceLines(
+ "test.FooComponent",
+ "package test;",
+ "",
+ "import dagger.hilt.components.SingletonComponent;",
+ "import dagger.hilt.DefineComponent;",
+ "",
+ "@DefineComponent( parent = SingletonComponent.class )",
+ "abstract class FooComponent {}");
+
+ Compilation compilation = compiler().compile(component);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@DefineComponent is only allowed on interfaces. Found: test.FooComponent");
+ }
+
+ @Test
+ public void testDefineComponentWithTypeParameters_fails() {
+ JavaFileObject component =
+ JavaFileObjects.forSourceLines(
+ "test.FooComponent",
+ "package test;",
+ "",
+ "import dagger.hilt.components.SingletonComponent;",
+ "import dagger.hilt.DefineComponent;",
+ "",
+ "@DefineComponent( parent = SingletonComponent.class )",
+ "interface FooComponent<T> {}");
+
+ Compilation compilation = compiler().compile(component);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining("@DefineComponent test.FooComponent<T>, cannot have type parameters.");
+ }
+
+ @Test
+ public void testDefineComponentWithInvalidComponent_fails() {
+ JavaFileObject component =
+ JavaFileObjects.forSourceLines(
+ "test.FooComponent",
+ "package test;",
+ "",
+ "import dagger.hilt.DefineComponent;",
+ "import dagger.hilt.android.qualifiers.ApplicationContext;",
+ "",
+ "@DefineComponent( parent = ApplicationContext.class )",
+ "interface FooComponent {}");
+
+ Compilation compilation = compiler().compile(component);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@DefineComponent test.FooComponent, references a type not annotated with "
+ + "@DefineComponent: dagger.hilt.android.qualifiers.ApplicationContext")
+ .inFile(component);
+ }
+
+ @Test
+ public void testDefineComponentExtendsInterface_fails() {
+ JavaFileObject component =
+ JavaFileObjects.forSourceLines(
+ "test.FooComponent",
+ "package test;",
+ "",
+ "import dagger.hilt.components.SingletonComponent;",
+ "import dagger.hilt.DefineComponent;",
+ "",
+ "interface Foo {}",
+ "",
+ "@DefineComponent( parent = SingletonComponent.class )",
+ "interface FooComponent extends Foo {}");
+
+ Compilation compilation = compiler().compile(component);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@DefineComponent test.FooComponent, cannot extend a super class or interface."
+ + " Found: test.Foo");
+ }
+
+ @Test
+ public void testDefineComponentNonStaticMethod_fails() {
+ JavaFileObject component =
+ JavaFileObjects.forSourceLines(
+ "test.FooComponent",
+ "package test;",
+ "",
+ "import dagger.hilt.components.SingletonComponent;",
+ "import dagger.hilt.DefineComponent;",
+ "",
+ "@DefineComponent( parent = SingletonComponent.class )",
+ "interface FooComponent {",
+ " int nonStaticMethod();",
+ "}");
+
+ Compilation compilation = compiler().compile(component);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@DefineComponent test.FooComponent, cannot have non-static methods. "
+ + "Found: [nonStaticMethod()]");
+ }
+
+ @Test
+ public void testDefineComponentDependencyCycle_fails() {
+ JavaFileObject component1 =
+ JavaFileObjects.forSourceLines(
+ "test.Component1",
+ "package test;",
+ "",
+ "import dagger.hilt.DefineComponent;",
+ "",
+ "@DefineComponent(parent = Component2.class)",
+ "interface Component1 {}");
+
+ JavaFileObject component2 =
+ JavaFileObjects.forSourceLines(
+ "test.Component2",
+ "package test;",
+ "",
+ "import dagger.hilt.DefineComponent;",
+ "",
+ "@DefineComponent(parent = Component1.class)",
+ "interface Component2 {}");
+
+ Compilation compilation = compiler().compile(component1, component2);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(2);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@DefineComponent cycle: test.Component1 -> test.Component2 -> test.Component1");
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@DefineComponent cycle: test.Component2 -> test.Component1 -> test.Component2");
+ }
+
+ @Test
+ public void testDefineComponentNoParent_fails() {
+ JavaFileObject component =
+ JavaFileObjects.forSourceLines(
+ "test.FooComponent",
+ "package test;",
+ "",
+ "import dagger.hilt.DefineComponent;",
+ "",
+ "@DefineComponent",
+ "interface FooComponent {}");
+ Compilation compilation = compiler().compile(component);
+ assertThat(compilation)
+ .hadErrorContaining("@DefineComponent test.FooComponent is missing a parent declaration.");
+ }
+
+ @Test
+ public void testDefineComponentBuilderClass_fails() {
+ JavaFileObject builder =
+ JavaFileObjects.forSourceLines(
+ "test.FooComponentBuilder",
+ "package test;",
+ "",
+ "import dagger.hilt.DefineComponent;",
+ "",
+ "@DefineComponent.Builder",
+ "abstract class FooComponentBuilder {}");
+
+ Compilation compilation = compiler().compile(builder);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@DefineComponent.Builder is only allowed on interfaces. "
+ + "Found: test.FooComponentBuilder");
+ }
+
+ @Test
+ public void testDefineComponentBuilderWithTypeParameters_fails() {
+ JavaFileObject builder =
+ JavaFileObjects.forSourceLines(
+ "test.FooComponentBuilder",
+ "package test;",
+ "",
+ "import dagger.hilt.DefineComponent;",
+ "",
+ "@DefineComponent.Builder",
+ "interface FooComponentBuilder<T> {}");
+
+ Compilation compilation = compiler().compile(builder);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@DefineComponent.Builder test.FooComponentBuilder<T>, cannot have type "
+ + "parameters.");
+ }
+
+ @Test
+ public void testDefineComponentBuilderExtendsInterface_fails() {
+ JavaFileObject builder =
+ JavaFileObjects.forSourceLines(
+ "test.FooComponentBuilder",
+ "package test;",
+ "",
+ "import dagger.hilt.DefineComponent;",
+ "",
+ "interface Foo {}",
+ "",
+ "@DefineComponent.Builder",
+ "interface FooComponentBuilder extends Foo {}");
+
+ Compilation compilation = compiler().compile(builder);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@DefineComponent.Builder test.FooComponentBuilder, cannot extend a super class "
+ + "or interface. Found: test.Foo");
+ }
+
+ @Test
+ public void testDefineComponentBuilderNoBuilderMethod_fails() {
+ JavaFileObject component =
+ JavaFileObjects.forSourceLines(
+ "test.FooComponent",
+ "package test;",
+ "",
+ "import dagger.hilt.DefineComponent;",
+ "",
+ "@DefineComponent.Builder",
+ "interface FooComponentBuilder {}");
+
+ Compilation compilation = compiler().compile(component);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@DefineComponent.Builder test.FooComponentBuilder, must have exactly 1 build "
+ + "method that takes no parameters. Found: []");
+ }
+
+ @Test
+ public void testDefineComponentBuilderPrimitiveReturnType_fails() {
+ JavaFileObject component =
+ JavaFileObjects.forSourceLines(
+ "test.FooComponent",
+ "package test;",
+ "",
+ "import dagger.hilt.DefineComponent;",
+ "",
+ "@DefineComponent.Builder",
+ "interface FooComponentBuilder {",
+ " int nonStaticMethod();",
+ "}");
+
+ Compilation compilation = compiler().compile(component);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@DefineComponent.Builder method, test.FooComponentBuilder#nonStaticMethod(), "
+ + "must return a @DefineComponent type. Found: int");
+ }
+
+ @Test
+ public void testDefineComponentBuilderWrongReturnType_fails() {
+ JavaFileObject component =
+ JavaFileObjects.forSourceLines(
+ "test.FooComponent",
+ "package test;",
+ "",
+ "import dagger.hilt.DefineComponent;",
+ "",
+ "interface Foo {}",
+ "",
+ "@DefineComponent.Builder",
+ "interface FooComponentBuilder {",
+ " Foo build();",
+ "}");
+
+ Compilation compilation = compiler().compile(component);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@DefineComponent.Builder method, test.FooComponentBuilder#build(), must return "
+ + "a @DefineComponent type. Found: test.Foo");
+ }
+
+ private static Compiler compiler() {
+ return javac().withProcessors(new DefineComponentProcessor());
+ }
+}
diff --git a/javatests/dagger/hilt/processor/internal/disableinstallincheck/BUILD b/javatests/dagger/hilt/processor/internal/disableinstallincheck/BUILD
new file mode 100644
index 0000000..90b0596
--- /dev/null
+++ b/javatests/dagger/hilt/processor/internal/disableinstallincheck/BUILD
@@ -0,0 +1,43 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Description:
+# Builds and run tests related to DisableInstallInCheckProcessor.
+
+load("//java/dagger/testing/compile:macros.bzl", "compiler_test")
+
+package(default_visibility = ["//:src"])
+
+compiler_test(
+ name = "DisableInstallInCheckProcessorErrorsTest",
+ size = "small",
+ srcs = ["DisableInstallInCheckProcessorErrorsTest.java"],
+ compiler_deps = [
+ "//java/dagger/hilt/migration:disable_install_in_check",
+ "//:dagger_with_compiler",
+ "@google_bazel_common//third_party/java/jsr250_annotations",
+ "//java/dagger/hilt:entry_point",
+ ],
+ deps = [
+ "//java/dagger/hilt/processor/internal/disableinstallincheck:processor_lib",
+ "@google_bazel_common//third_party/java/compile_testing",
+ "@google_bazel_common//third_party/java/junit",
+ "@google_bazel_common//third_party/java/truth",
+ ],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["*"]),
+)
diff --git a/javatests/dagger/hilt/processor/internal/disableinstallincheck/DisableInstallInCheckProcessorErrorsTest.java b/javatests/dagger/hilt/processor/internal/disableinstallincheck/DisableInstallInCheckProcessorErrorsTest.java
new file mode 100644
index 0000000..8ea715d
--- /dev/null
+++ b/javatests/dagger/hilt/processor/internal/disableinstallincheck/DisableInstallInCheckProcessorErrorsTest.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.disableinstallincheck;
+
+import static com.google.testing.compile.CompilationSubject.assertThat;
+
+import com.google.testing.compile.Compilation;
+import com.google.testing.compile.JavaFileObjects;
+import dagger.testing.compile.CompilerTests;
+import javax.tools.JavaFileObject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for errors generated by {@link DisableInstallInCheckProcessor} */
+@RunWith(JUnit4.class)
+public class DisableInstallInCheckProcessorErrorsTest {
+
+ @Test
+ public void testIllegalCombinationInstallIn() {
+ JavaFileObject source =
+ JavaFileObjects.forSourceLines(
+ "foo.bar",
+ "package foo.bar;",
+ "",
+ "import dagger.hilt.migration.DisableInstallInCheck;",
+ "import dagger.hilt.EntryPoint;",
+ "",
+ "@DisableInstallInCheck",
+ "final class NotModule {}",
+ "",
+ "@DisableInstallInCheck",
+ "@EntryPoint",
+ "interface FooEntryPoint {}");
+
+ Compilation compilation =
+ CompilerTests.compiler()
+ .withProcessors(new DisableInstallInCheckProcessor())
+ .compile(source);
+
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@DisableInstallInCheck should only be used on modules. However, it was found"
+ + " annotating foo.bar.NotModule")
+ .inFile(source)
+ .onLine(7);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@DisableInstallInCheck should only be used on modules. However, it was found"
+ + " annotating foo.bar.FooEntryPoint")
+ .inFile(source)
+ .onLine(11);
+ }
+}
diff --git a/javatests/dagger/hilt/processor/internal/generatesrootinput/BUILD b/javatests/dagger/hilt/processor/internal/generatesrootinput/BUILD
new file mode 100644
index 0000000..c5dacd9
--- /dev/null
+++ b/javatests/dagger/hilt/processor/internal/generatesrootinput/BUILD
@@ -0,0 +1,45 @@
+# Copyright (C) 2017 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Description:
+# Tests the functionality of GeneratesRootInputProcessor.
+
+load("//:build_defs.bzl", "DOCLINT_HTML_AND_SYNTAX")
+load("//:test_defs.bzl", "GenJavaTests")
+
+package(default_visibility = ["//:src"])
+
+GenJavaTests(
+ name = "GeneratesRootInputProcessorTest",
+ srcs = glob(["*.java"]),
+ functional = False,
+ javacopts = DOCLINT_HTML_AND_SYNTAX,
+ deps = [
+ "//:dagger_with_compiler",
+ "//java/dagger/hilt:generates_root_input",
+ "//java/dagger/hilt/processor/internal:base_processor",
+ "//java/dagger/hilt/processor/internal/generatesrootinput:generates_root_inputs",
+ "//java/dagger/hilt/processor/internal/generatesrootinput:processor_lib",
+ "@google_bazel_common//third_party/java/compile_testing",
+ "@google_bazel_common//third_party/java/javapoet",
+ "@google_bazel_common//third_party/java/junit",
+ "@google_bazel_common//third_party/java/truth",
+ "@maven//:com_google_auto_auto_common",
+ ],
+)
+
+filegroup(
+ name = "srcs_filegroup",
+ srcs = glob(["**/*"]),
+)
diff --git a/javatests/dagger/hilt/processor/internal/generatesrootinput/GeneratesRootInputProcessorTest.java b/javatests/dagger/hilt/processor/internal/generatesrootinput/GeneratesRootInputProcessorTest.java
new file mode 100644
index 0000000..fb62c3d
--- /dev/null
+++ b/javatests/dagger/hilt/processor/internal/generatesrootinput/GeneratesRootInputProcessorTest.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.processor.internal.generatesrootinput;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.testing.compile.CompilationSubject.assertThat;
+import static com.google.testing.compile.Compiler.javac;
+
+import com.google.auto.common.MoreElements;
+import com.google.common.truth.Correspondence;
+import com.google.testing.compile.Compilation;
+import com.google.testing.compile.JavaFileObjects;
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.TypeSpec;
+import dagger.hilt.processor.internal.BaseProcessor;
+import java.util.ArrayList;
+import java.util.List;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.annotation.processing.RoundEnvironment;
+import javax.annotation.processing.SupportedAnnotationTypes;
+import javax.lang.model.element.Element;
+import javax.tools.JavaFileObject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests that {@link GeneratesRootInputs} returns the elements to wait for. */
+@RunWith(JUnit4.class)
+public final class GeneratesRootInputProcessorTest {
+ private static final int GENERATED_CLASSES = 5;
+ private static final ClassName TEST_ANNOTATION = ClassName.get("test", "TestAnnotation");
+
+ private final List<Element> elementsToWaitFor = new ArrayList<>();
+ private int generatedClasses = 0;
+
+ @SupportedAnnotationTypes("*")
+ public final class TestAnnotationProcessor extends BaseProcessor {
+ private GeneratesRootInputs generatesRootInputs;
+
+ @Override
+ public synchronized void init(ProcessingEnvironment processingEnv) {
+ super.init(processingEnv);
+ generatesRootInputs = new GeneratesRootInputs(processingEnv);
+ }
+
+ @Override
+ protected void postRoundProcess(RoundEnvironment roundEnv) throws Exception {
+ if (generatedClasses > 0) {
+ elementsToWaitFor.addAll(generatesRootInputs.getElementsToWaitFor(roundEnv));
+ }
+ if (generatedClasses < GENERATED_CLASSES) {
+ TypeSpec typeSpec =
+ TypeSpec.classBuilder("Foo" + generatedClasses++)
+ .addAnnotation(TEST_ANNOTATION)
+ .build();
+ JavaFile.builder("foo", typeSpec).build().writeTo(processingEnv.getFiler());
+ }
+ }
+ }
+
+ @Test
+ public void succeeds_ComponentProcessorWaitsForAnnotationsWithgeneratesstinginput() {
+ JavaFileObject testAnnotation =
+ JavaFileObjects.forSourceLines(
+ "test.TestAnnotation",
+ "package test;",
+ "@dagger.hilt.GeneratesRootInput",
+ "public @interface TestAnnotation {}");
+
+ Compilation compilation =
+ javac()
+ .withProcessors(new TestAnnotationProcessor(), new GeneratesRootInputProcessor())
+ .compile(testAnnotation);
+
+ assertThat(compilation).succeeded();
+ assertThat(elementsToWaitFor)
+ .comparingElementsUsing(
+ Correspondence.<Element, String>transforming(
+ element -> MoreElements.asType(element).getQualifiedName().toString(),
+ "has qualified name of"))
+ .containsExactly("foo.Foo0", "foo.Foo1", "foo.Foo2", "foo.Foo3", "foo.Foo4")
+ .inOrder();
+ }
+}
diff --git a/javatests/dagger/internal/MapProviderFactoryTest.java b/javatests/dagger/internal/MapProviderFactoryTest.java
index 5598ff2..c55bee3 100644
--- a/javatests/dagger/internal/MapProviderFactoryTest.java
+++ b/javatests/dagger/internal/MapProviderFactoryTest.java
@@ -46,6 +46,7 @@
MapProviderFactory.<String, Integer>builder(1).put("Hello", null);
}
+
@Test
public void iterationOrder() {
Provider<Integer> p1 = incrementingIntegerProvider(10);
@@ -74,6 +75,7 @@
.inOrder();
}
+
private static Provider<Integer> incrementingIntegerProvider(int seed) {
return new AtomicInteger(seed)::getAndIncrement;
}
diff --git a/javatests/dagger/internal/codegen/AheadOfTimeSubcomponentsMultibindingsTest.java b/javatests/dagger/internal/codegen/AheadOfTimeSubcomponentsMultibindingsTest.java
deleted file mode 100644
index bb967b1..0000000
--- a/javatests/dagger/internal/codegen/AheadOfTimeSubcomponentsMultibindingsTest.java
+++ /dev/null
@@ -1,2838 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.testing.compile.CompilationSubject.assertThat;
-import static dagger.internal.codegen.CompilerMode.AHEAD_OF_TIME_SUBCOMPONENTS_MODE;
-import static dagger.internal.codegen.CompilerMode.FAST_INIT_MODE;
-import static dagger.internal.codegen.Compilers.CLASS_PATH_WITHOUT_GUAVA_OPTION;
-import static dagger.internal.codegen.Compilers.compilerWithOptions;
-import static dagger.internal.codegen.Compilers.daggerCompiler;
-import static dagger.internal.codegen.GeneratedLines.GENERATED_ANNOTATION;
-import static dagger.internal.codegen.GeneratedLines.GENERATION_OPTIONS_ANNOTATION;
-import static dagger.internal.codegen.GeneratedLines.IMPORT_GENERATED_ANNOTATION;
-
-import com.google.common.collect.ImmutableList;
-import com.google.testing.compile.Compilation;
-import com.google.testing.compile.JavaFileObjects;
-import javax.tools.JavaFileObject;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-@RunWith(JUnit4.class)
-public final class AheadOfTimeSubcomponentsMultibindingsTest {
- @Test
- public void setMultibindings_contributionsInLeaf() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "InLeaf");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Set;",
- "",
- "@Subcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " Set<InLeaf> contributionsInLeaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.IntoSet;",
- "",
- "@Module",
- "class LeafModule {",
- " @Provides",
- " @IntoSet",
- " static InLeaf provideInLeaf() {",
- " return new InLeaf();",
- " }",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableSet;",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Set;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public Set<InLeaf> contributionsInLeaf() {",
- " return ImmutableSet.<InLeaf>of(",
- " LeafModule_ProvideInLeafFactory.provideInLeaf());",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
- }
-
- @Test
- public void setMultibindings_contributionsInAncestorOnly() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "InAncestor");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Set;",
- "",
- "@Subcomponent",
- "interface Leaf {",
- " Set<InAncestor> contributionsInAncestor();",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Set;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public abstract Set<InAncestor> contributionsInAncestor();",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Set;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableSet;",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.ElementsIntoSet;",
- "import java.util.Set;",
- "",
- "@Module",
- "class AncestorModule {",
- " @Provides",
- " @ElementsIntoSet",
- " static Set<InAncestor> provideInAncestors() {",
- " return ImmutableSet.of(new InAncestor(), new InAncestor());",
- " }",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableSet;",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Set;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " public Set<InAncestor> contributionsInAncestor() {",
- " return ImmutableSet.<InAncestor>copyOf(",
- " AncestorModule_ProvideInAncestorsFactory.provideInAncestors());",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
- }
-
- @Test
- public void setMultibindings_contributionsInLeafAndAncestor() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "InEachSubcomponent");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Set;",
- "",
- "@Subcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " Set<InEachSubcomponent> contributionsInEachSubcomponent();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.IntoSet;",
- "",
- "@Module",
- "class LeafModule {",
- " @Provides",
- " @IntoSet",
- " static InEachSubcomponent provideInLeaf() {",
- " return new InEachSubcomponent();",
- " }",
- "",
- " @Provides",
- " @IntoSet",
- " static InEachSubcomponent provideAnotherInLeaf() {",
- " return new InEachSubcomponent();",
- " }",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableSet;",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Set;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public Set<InEachSubcomponent> contributionsInEachSubcomponent() {",
- " return ImmutableSet.<InEachSubcomponent>of(",
- " LeafModule_ProvideInLeafFactory.provideInLeaf(),",
- " LeafModule_ProvideAnotherInLeafFactory.provideAnotherInLeaf());",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Set;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableSet;",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.ElementsIntoSet;",
- "import java.util.Set;",
- "",
- "@Module",
- "class AncestorModule {",
- " @Provides",
- " @ElementsIntoSet",
- " static Set<InEachSubcomponent> provideInAncestor() {",
- " return ImmutableSet.of(new InEachSubcomponent(), new InEachSubcomponent());",
- " }",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableSet;",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Set;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " public Set<InEachSubcomponent> contributionsInEachSubcomponent() {",
- " return ImmutableSet.<InEachSubcomponent>builderWithExpectedSize(3)",
- " .addAll(AncestorModule_ProvideInAncestorFactory.provideInAncestor())",
- " .addAll(super.contributionsInEachSubcomponent())",
- " .build();",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
- }
-
- @Test
- public void setMultibindings_contributionsInLeafAndGrandAncestor() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "InLeafAndGrandAncestor");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Set;",
- "",
- "@Subcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " Set<InLeafAndGrandAncestor> contributionsInLeafAndGrandAncestor();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.IntoSet;",
- "",
- "@Module",
- "class LeafModule {",
- " @Provides",
- " @IntoSet",
- " static InLeafAndGrandAncestor provideInLeaf() {",
- " return new InLeafAndGrandAncestor();",
- " }",
- "",
- " @Provides",
- " @IntoSet",
- " static InLeafAndGrandAncestor provideAnotherInLeaf() {",
- " return new InLeafAndGrandAncestor();",
- " }",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableSet;",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Set;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public Set<InLeafAndGrandAncestor> contributionsInLeafAndGrandAncestor() {",
- " return ImmutableSet.<InLeafAndGrandAncestor>of(",
- " LeafModule_ProvideInLeafFactory.provideInLeaf(),",
- " LeafModule_ProvideAnotherInLeafFactory.provideAnotherInLeaf());",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Set;",
- "",
- "@Subcomponent",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.GrandAncestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Set;",
- "",
- "@Subcomponent(modules = GrandAncestorModule.class)",
- "interface GrandAncestor {",
- " Leaf leaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.GrandAncestorModule",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableSet;",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.ElementsIntoSet;",
- "import java.util.Set;",
- "",
- "@Module",
- "class GrandAncestorModule {",
- " @Provides",
- " @ElementsIntoSet",
- " static Set<InLeafAndGrandAncestor> provideInGrandAncestor() {",
- " return ImmutableSet.of(new InLeafAndGrandAncestor(),",
- " new InLeafAndGrandAncestor());",
- " }",
- "}"));
- JavaFileObject generatedGrandAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerGrandAncestor",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableSet;",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Set;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerGrandAncestor implements GrandAncestor {",
- " protected DaggerGrandAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " public Set<InLeafAndGrandAncestor> contributionsInLeafAndGrandAncestor() {",
- " return ImmutableSet.<InLeafAndGrandAncestor>builderWithExpectedSize(3)",
- " .addAll(GrandAncestorModule_ProvideInGrandAncestorFactory",
- " .provideInGrandAncestor())",
- " .addAll(super.contributionsInLeafAndGrandAncestor())",
- " .build();",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerGrandAncestor")
- .hasSourceEquivalentTo(generatedGrandAncestor);
- }
-
- @Test
- public void setMultibindings_nonComponentMethodDependency() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(
- filesToCompile, "InAllSubcomponents", "RequresInAllSubcomponentsSet");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Set;",
- "",
- "@Subcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " RequresInAllSubcomponentsSet requiresNonComponentMethod();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.IntoSet;",
- "import java.util.Set;",
- "",
- "@Module",
- "class LeafModule {",
- " @Provides",
- " @IntoSet",
- " static InAllSubcomponents provideInAllSubcomponents() {",
- " return new InAllSubcomponents();",
- " }",
- "",
- " @Provides",
- " static RequresInAllSubcomponentsSet providesRequresInAllSubcomponentsSet(",
- " Set<InAllSubcomponents> inAllSubcomponents) {",
- " return new RequresInAllSubcomponentsSet();",
- " }",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableSet;",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Set;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public RequresInAllSubcomponentsSet requiresNonComponentMethod() {",
- " return LeafModule_ProvidesRequresInAllSubcomponentsSetFactory",
- " .providesRequresInAllSubcomponentsSet(getSetOfInAllSubcomponents());",
- " }",
- "",
- " protected Set getSetOfInAllSubcomponents() {",
- " return ImmutableSet.<InAllSubcomponents>of(",
- " LeafModule_ProvideInAllSubcomponentsFactory",
- " .provideInAllSubcomponents());",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.IntoSet;",
- "",
- "@Module",
- "class AncestorModule {",
- " @Provides",
- " @IntoSet",
- " static InAllSubcomponents provideInAllSubcomponents() {",
- " return new InAllSubcomponents();",
- " }",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableSet;",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Set;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " protected Set getSetOfInAllSubcomponents() {",
- " return ImmutableSet.<InAllSubcomponents>builderWithExpectedSize(2)",
- " .add(AncestorModule_ProvideInAllSubcomponentsFactory",
- " .provideInAllSubcomponents())",
- " .addAll(super.getSetOfInAllSubcomponents())",
- " .build();",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
- }
-
- @Test
- public void setMultibindings_newSubclass() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "InAncestor", "RequiresInAncestorSet");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent",
- "interface Leaf {",
- " RequiresInAncestorSet missingWithSetDependency();",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public abstract RequiresInAncestorSet missingWithSetDependency();",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.IntoSet;",
- "import java.util.Set;",
- "",
- "@Module",
- "class AncestorModule {",
- "",
- " @Provides",
- " static RequiresInAncestorSet provideRequiresInAncestorSet(",
- " Set<InAncestor> inAncestors) {",
- " return new RequiresInAncestorSet();",
- " }",
- "",
- " @Provides",
- " @IntoSet",
- " static InAncestor provideInAncestor() {",
- " return new InAncestor();",
- " }",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableSet;",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Set;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " private RequiresInAncestorSet getRequiresInAncestorSet() {",
- " return AncestorModule_ProvideRequiresInAncestorSetFactory",
- " .provideRequiresInAncestorSet(getSetOfInAncestor());",
- " }",
- "",
- " protected Set getSetOfInAncestor() {",
- " return ImmutableSet.<InAncestor>of(",
- " AncestorModule_ProvideInAncestorFactory.provideInAncestor());",
- " }",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " public final RequiresInAncestorSet missingWithSetDependency() {",
- " return DaggerAncestor.this.getRequiresInAncestorSet();",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
- }
-
- @Test
- public void setMultibinding_requestedAsInstanceInLeaf_requestedAsFrameworkInstanceFromAncestor() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(
- filesToCompile, "Multibound", "MissingInLeaf_WillDependOnFrameworkInstance");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Set;",
- "import javax.inject.Provider;",
- "",
- "@Subcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " Set<Multibound> instance();",
- " MissingInLeaf_WillDependOnFrameworkInstance willDependOnFrameworkInstance();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.IntoSet;",
- "import java.util.Set;",
- "",
- "@Module",
- "class LeafModule {",
- " @Provides",
- " @IntoSet",
- " static Multibound contribution() {",
- " return new Multibound();",
- " }",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableSet;",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Set;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public Set<Multibound> instance() {",
- " return ImmutableSet.<Multibound>of(",
- " LeafModule_ContributionFactory.contribution());",
- " }",
- "",
- " @Override",
- " public abstract MissingInLeaf_WillDependOnFrameworkInstance",
- " willDependOnFrameworkInstance();",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.Multibinds;",
- "import java.util.Set;",
- "import javax.inject.Provider;",
- "",
- "@Module",
- "interface AncestorModule {",
- " @Provides",
- " static MissingInLeaf_WillDependOnFrameworkInstance providedInAncestor(",
- " Provider<Set<Multibound>> frameworkInstance) {",
- " return null;",
- " }",
- "",
- " @Multibinds Set<Multibound> multibinds();",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- "import dagger.internal.SetFactory;",
- "import java.util.Set;",
- IMPORT_GENERATED_ANNOTATION,
- "import javax.inject.Provider;",
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " private Provider<Set<Multibound>> setOfMultiboundProvider;",
- "",
- " protected LeafImpl() {}",
- "",
- " protected void configureInitialization() { ",
- " initialize();",
- " }",
- "",
- " @SuppressWarnings(\"unchecked\")",
- " private void initialize() { ",
- " this.setOfMultiboundProvider =",
- " SetFactory.<Multibound>builder(1, 0)",
- " .addProvider(LeafModule_ContributionFactory.create())",
- " .build();",
- " }",
- "",
- " protected Provider getSetOfMultiboundProvider() {",
- " return setOfMultiboundProvider;",
- " }",
- "",
- " @Override",
- " public final MissingInLeaf_WillDependOnFrameworkInstance ",
- " willDependOnFrameworkInstance() {",
- " return AncestorModule_ProvidedInAncestorFactory.providedInAncestor(",
- " getSetOfMultiboundProvider());",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
- }
-
- @Test
- public void missingMultibindingInLeaf_onlyContributionsInAncestor_notReModifiedInRoot() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Set;",
- "import javax.inject.Provider;",
- "",
- "@Subcomponent",
- "interface Leaf {",
- " Set<Object> set();",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Set;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public abstract Set<Object> set();",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Set;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.IntoSet;",
- "",
- "@Module",
- "class AncestorModule {",
- " @Provides",
- " @IntoSet",
- " static Object onlyContribution() {",
- " return new Object();",
- " }",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableSet;",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Set;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " public Set<Object> set() {",
- " return ImmutableSet.<Object>of(",
- " AncestorModule_OnlyContributionFactory.onlyContribution());",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Root",
- "package test;",
- "",
- "import dagger.Component;",
- "",
- "@Component",
- "interface Root {",
- " Ancestor ancestor();",
- "}"));
- JavaFileObject generatedRoot =
- JavaFileObjects.forSourceLines(
- "test.DaggerRoot",
- "package test;",
- "",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATED_ANNOTATION,
- "final class DaggerRoot implements Root {",
- " private DaggerRoot() {}",
- "",
- " public static Builder builder() {",
- " return new Builder();",
- " }",
- "",
- " public static Root create() {",
- " return new Builder().build();",
- " }",
- "",
- " @Override",
- " public Ancestor ancestor() {",
- " return new AncestorImpl();",
- " }",
- "",
- " static final class Builder {",
- " private Builder() {}",
- "",
- " public Root build() {",
- " return new DaggerRoot();",
- " }",
- " }",
- "",
- " protected final class AncestorImpl extends DaggerAncestor {",
- " private AncestorImpl() {}",
- "",
- " @Override",
- " public Leaf leaf() {",
- " return new LeafImpl();",
- " }",
- "",
- " protected final class LeafImpl extends DaggerAncestor.LeafImpl {",
- " private LeafImpl() {}",
- // This tests a regression case where Dagger used to reimplement Leaf.set(), even though
- // there were no new contributions, because the state change from missing ->
- // multibinding wasn't properly recorded
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerRoot")
- .hasSourceEquivalentTo(generatedRoot);
- }
-
- @Test
- public void setMultibindings_contributionsInLeafAndAncestor_frameworkInstances() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "InEachSubcomponent");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Set;",
- "import javax.inject.Provider;",
- "",
- "@Subcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " Provider<Set<InEachSubcomponent>> contributionsInEachSubcomponent();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.IntoSet;",
- "",
- "@Module",
- "class LeafModule {",
- " @Provides",
- " @IntoSet",
- " static InEachSubcomponent provideInLeaf() {",
- " return new InEachSubcomponent();",
- " }",
- "",
- " @Provides",
- " @IntoSet",
- " static InEachSubcomponent provideAnotherInLeaf() {",
- " return new InEachSubcomponent();",
- " }",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- "import dagger.internal.SetFactory;",
- "import java.util.Set;",
- IMPORT_GENERATED_ANNOTATION,
- "import javax.inject.Provider;",
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " private Provider<Set<InEachSubcomponent>> setOfInEachSubcomponentProvider;",
- "",
- " protected DaggerLeaf() {}",
- "",
- " protected void configureInitialization() {",
- " initialize();",
- " }",
- "",
- " @SuppressWarnings(\"unchecked\")",
- " private void initialize() {",
- " this.setOfInEachSubcomponentProvider =",
- " SetFactory.<InEachSubcomponent>builder(2, 0)",
- " .addProvider(LeafModule_ProvideInLeafFactory.create())",
- " .addProvider(LeafModule_ProvideAnotherInLeafFactory.create())",
- " .build();",
- " }",
- "",
- " @Override",
- " public Provider<Set<InEachSubcomponent>> contributionsInEachSubcomponent() {",
- " return setOfInEachSubcomponentProvider;",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Set;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableSet;",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.ElementsIntoSet;",
- "import java.util.Set;",
- "",
- "@Module",
- "class AncestorModule {",
- " @Provides",
- " @ElementsIntoSet",
- " static Set<InEachSubcomponent> provideInAncestor() {",
- " return ImmutableSet.of(new InEachSubcomponent(), new InEachSubcomponent());",
- " }",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import dagger.internal.DelegateFactory;",
- "import dagger.internal.GenerationOptions;",
- "import dagger.internal.SetFactory;",
- "import java.util.Set;",
- IMPORT_GENERATED_ANNOTATION,
- "import javax.inject.Provider;",
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " private Provider<Set<InEachSubcomponent>> setOfInEachSubcomponentProvider = ",
- " new DelegateFactory<>();",
- "",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " protected void configureInitialization() {",
- " super.configureInitialization();",
- " initialize();",
- " }",
- "",
- " @SuppressWarnings(\"unchecked\")",
- " private void initialize() {",
- " DelegateFactory.setDelegate(",
- " setOfInEachSubcomponentProvider,",
- " SetFactory.<InEachSubcomponent>builder(0, 2)",
- " .addCollectionProvider(super.contributionsInEachSubcomponent())",
- " .addCollectionProvider(",
- " AncestorModule_ProvideInAncestorFactory.create())",
- " .build());",
- " }",
- "",
- " @Override",
- " public Provider<Set<InEachSubcomponent>> contributionsInEachSubcomponent() {",
- " return setOfInEachSubcomponentProvider;",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
- }
-
- @Test
- public void mapMultibindings_contributionsInLeaf() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "InLeaf");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Map;",
- "",
- "@Subcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " Map<String, InLeaf> contributionsInLeaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.IntoMap;",
- "import dagger.multibindings.StringKey;",
- "import java.util.Map;",
- "",
- "@Module",
- "class LeafModule {",
- " @Provides",
- " @IntoMap",
- " @StringKey(\"leafmodule\")",
- " static InLeaf provideInLeaf() {",
- " return new InLeaf();",
- " }",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableMap;",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Map;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public Map<String, InLeaf> contributionsInLeaf() {",
- " return ImmutableMap.<String, InLeaf>of(",
- " \"leafmodule\",",
- " LeafModule_ProvideInLeafFactory.provideInLeaf());",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
- }
-
- @Test
- public void mapMultibindings_contributionsInAncestorOnly() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "InAncestor");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Map;",
- "",
- "@Subcomponent",
- "interface Leaf {",
- " Map<String, InAncestor> contributionsInAncestor();",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Map;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public abstract Map<String, InAncestor> contributionsInAncestor();",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.IntoMap;",
- "import dagger.multibindings.StringKey;",
- "import java.util.Map;",
- "",
- "@Module",
- "class AncestorModule {",
- " @Provides",
- " @IntoMap",
- " @StringKey(\"ancestormodule\")",
- " static InAncestor provideInAncestor() {",
- " return new InAncestor();",
- " }",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableMap;",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Map;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " public Map<String, InAncestor> contributionsInAncestor() {",
- " return ImmutableMap.<String, InAncestor>of(\"ancestormodule\",",
- " AncestorModule_ProvideInAncestorFactory.provideInAncestor());",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
- }
-
- @Test
- public void mapMultibindings_contributionsInLeafAndAncestor() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "InEachSubcomponent");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Map;",
- "",
- "@Subcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " Map<String, InEachSubcomponent> contributionsInEachSubcomponent();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.IntoMap;",
- "import dagger.multibindings.StringKey;",
- "import java.util.Map;",
- "",
- "@Module",
- "class LeafModule {",
- " @Provides",
- " @IntoMap",
- " @StringKey(\"leafmodule\")",
- " static InEachSubcomponent provideInLeaf() {",
- " return new InEachSubcomponent();",
- " }",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableMap;",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Map;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public Map<String, InEachSubcomponent> contributionsInEachSubcomponent() {",
- " return ImmutableMap.<String, InEachSubcomponent>of(",
- " \"leafmodule\", LeafModule_ProvideInLeafFactory.provideInLeaf());",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.IntoMap;",
- "import dagger.multibindings.StringKey;",
- "import java.util.Map;",
- "",
- "@Module",
- "class AncestorModule {",
- " @Provides",
- " @IntoMap",
- " @StringKey(\"ancestormodule\")",
- " static InEachSubcomponent provideInAncestor() {",
- " return new InEachSubcomponent();",
- " }",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableMap;",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Map;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " public Map<String, InEachSubcomponent> contributionsInEachSubcomponent() {",
- " return ImmutableMap.<String, InEachSubcomponent>builderWithExpectedSize(2)",
- " .put(\"ancestormodule\",",
- " AncestorModule_ProvideInAncestorFactory.provideInAncestor())",
- " .putAll(super.contributionsInEachSubcomponent())",
- " .build();",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
- }
-
- @Test
- public void mapMultibindings_contributionsInLeafAndAncestor_frameworkInstance() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "InEachSubcomponent");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Map;",
- "import javax.inject.Provider;",
- "",
- "@Subcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " Provider<Map<String, InEachSubcomponent>> contributionsInEachSubcomponent();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.IntoMap;",
- "import dagger.multibindings.StringKey;",
- "import java.util.Map;",
- "",
- "@Module",
- "class LeafModule {",
- " @Provides",
- " @IntoMap",
- " @StringKey(\"leafmodule\")",
- " static InEachSubcomponent provideInLeaf() {",
- " return new InEachSubcomponent();",
- " }",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- "import dagger.internal.MapFactory;",
- "import java.util.Map;",
- IMPORT_GENERATED_ANNOTATION,
- "import javax.inject.Provider;",
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " private Provider<Map<String, InEachSubcomponent>> ",
- " mapOfStringAndInEachSubcomponentProvider;",
- "",
- " protected DaggerLeaf() {}",
- "",
- " protected void configureInitialization() {",
- " initialize();",
- " }",
- "",
- " @SuppressWarnings(\"unchecked\")",
- " private void initialize() {",
- " this.mapOfStringAndInEachSubcomponentProvider =",
- " MapFactory.<String, InEachSubcomponent>builder(1)",
- " .put(\"leafmodule\", LeafModule_ProvideInLeafFactory.create())",
- " .build();",
- " }",
- "",
- " @Override",
- " public Provider<Map<String, InEachSubcomponent>> ",
- " contributionsInEachSubcomponent() {",
- " return mapOfStringAndInEachSubcomponentProvider;",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.IntoMap;",
- "import dagger.multibindings.StringKey;",
- "import java.util.Map;",
- "",
- "@Module",
- "class AncestorModule {",
- " @Provides",
- " @IntoMap",
- " @StringKey(\"ancestormodule\")",
- " static InEachSubcomponent provideInAncestor() {",
- " return new InEachSubcomponent();",
- " }",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import dagger.internal.DelegateFactory;",
- "import dagger.internal.GenerationOptions;",
- "import dagger.internal.MapFactory;",
- "import java.util.Map;",
- IMPORT_GENERATED_ANNOTATION,
- "import javax.inject.Provider;",
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " private Provider<Map<String, InEachSubcomponent>> ",
- " mapOfStringAndInEachSubcomponentProvider = new DelegateFactory<>();",
- "",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " protected void configureInitialization() { ",
- " super.configureInitialization();",
- " initialize();",
- " }",
- "",
- " @SuppressWarnings(\"unchecked\")",
- " private void initialize() { ",
- " DelegateFactory.setDelegate(",
- " mapOfStringAndInEachSubcomponentProvider,",
- " MapFactory.<String, InEachSubcomponent>builder(2)",
- " .putAll(super.contributionsInEachSubcomponent())",
- " .put(",
- " \"ancestormodule\",",
- " AncestorModule_ProvideInAncestorFactory.create())",
- " .build());",
- " }",
- "",
- " @Override",
- " public Provider<Map<String, InEachSubcomponent>> ",
- " contributionsInEachSubcomponent() {",
- " return mapOfStringAndInEachSubcomponentProvider;",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
- }
-
- @Test
- public void mapMultibindings_contributionsInLeafAndGrandAncestor() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "InLeafAndGrandAncestor");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Map;",
- "",
- "@Subcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " Map<String, InLeafAndGrandAncestor> contributionsInLeafAndGrandAncestor();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.IntoMap;",
- "import dagger.multibindings.StringKey;",
- "import java.util.Map;",
- "",
- "@Module",
- "class LeafModule {",
- " @Provides",
- " @IntoMap",
- " @StringKey(\"leafmodule\")",
- " static InLeafAndGrandAncestor provideInLeaf() {",
- " return new InLeafAndGrandAncestor();",
- " }",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableMap;",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Map;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public Map<String, InLeafAndGrandAncestor> contributionsInLeafAndGrandAncestor() {",
- " return ImmutableMap.<String, InLeafAndGrandAncestor>of(",
- " \"leafmodule\", LeafModule_ProvideInLeafFactory.provideInLeaf());",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.GrandAncestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = GrandAncestorModule.class)",
- "interface GrandAncestor {",
- " Ancestor ancestor();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.GrandAncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.IntoMap;",
- "import dagger.multibindings.StringKey;",
- "import java.util.Map;",
- "",
- "@Module",
- "class GrandAncestorModule {",
- " @Provides",
- " @IntoMap",
- " @StringKey(\"grandancestormodule\")",
- " static InLeafAndGrandAncestor provideInGrandAncestor() {",
- " return new InLeafAndGrandAncestor();",
- " }",
- "}"));
- JavaFileObject generatedGrandAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerGrandAncestor",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableMap;",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Map;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerGrandAncestor implements GrandAncestor {",
- " protected DaggerGrandAncestor() {}",
- "",
- " protected abstract class AncestorImpl extends DaggerAncestor {",
- " protected AncestorImpl() {}",
- "",
- " protected abstract class LeafImpl extends DaggerAncestor.LeafImpl {",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " public Map<String, InLeafAndGrandAncestor>",
- " contributionsInLeafAndGrandAncestor() {",
- " return",
- " ImmutableMap.<String, InLeafAndGrandAncestor>builderWithExpectedSize(2)",
- " .put(\"grandancestormodule\",",
- " GrandAncestorModule_ProvideInGrandAncestorFactory",
- " .provideInGrandAncestor())",
- " .putAll(super.contributionsInLeafAndGrandAncestor())",
- " .build();",
- " }",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerGrandAncestor")
- .hasSourceEquivalentTo(generatedGrandAncestor);
- }
-
- @Test
- public void mapMultibindings_contributionsInLeafAndAncestorWithoutGuava() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "InEachSubcomponent");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Map;",
- "",
- "@Subcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " Map<String, InEachSubcomponent> contributionsInEachSubcomponent();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.IntoMap;",
- "import dagger.multibindings.StringKey;",
- "import java.util.Map;",
- "",
- "@Module",
- "class LeafModule {",
- " @Provides",
- " @IntoMap",
- " @StringKey(\"leafmodule\")",
- " static InEachSubcomponent provideInLeaf() {",
- " return new InEachSubcomponent();",
- " }",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Collections;",
- "import java.util.Map",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public Map<String, InEachSubcomponent> contributionsInEachSubcomponent() {",
- " return Collections.<String, InEachSubcomponent>singletonMap(",
- " \"leafmodule\", LeafModule_ProvideInLeafFactory.provideInLeaf());",
- " }",
- "}");
- Compilation compilation = compileWithoutGuava(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.IntoMap;",
- "import dagger.multibindings.StringKey;",
- "import java.util.Map;",
- "",
- "@Module",
- "class AncestorModule {",
- " @Provides",
- " @IntoMap",
- " @StringKey(\"ancestormodule\")",
- " static InEachSubcomponent provideInAncestor() {",
- " return new InEachSubcomponent();",
- " }",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- "import dagger.internal.MapBuilder;",
- "import java.util.Map;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " public Map<String, InEachSubcomponent> contributionsInEachSubcomponent() {",
- " return MapBuilder.<String, InEachSubcomponent>newMapBuilder(2)",
- " .put(\"ancestormodule\",",
- " AncestorModule_ProvideInAncestorFactory.provideInAncestor())",
- " .putAll(super.contributionsInEachSubcomponent())",
- " .build();",
- " }",
- " }",
- "}");
- compilation = compileWithoutGuava(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
- }
-
- @Test
- public void mapMultibinding_requestedAsInstanceInLeaf_requestedAsFrameworkInstanceFromAncestor() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(
- filesToCompile, "Multibound", "MissingInLeaf_WillDependOnFrameworkInstance");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Map;",
- "import javax.inject.Provider;",
- "",
- "@Subcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " Map<Integer, Multibound> instance();",
- " MissingInLeaf_WillDependOnFrameworkInstance willDependOnFrameworkInstance();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.IntKey;",
- "import dagger.multibindings.IntoMap;",
- "import java.util.Map;",
- "",
- "@Module",
- "class LeafModule {",
- " @Provides",
- " @IntoMap",
- " @IntKey(111)",
- " static Multibound contribution() {",
- " return new Multibound();",
- " }",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableMap;",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Map;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public Map<Integer, Multibound> instance() {",
- " return ImmutableMap.<Integer, Multibound>of(",
- " 111, LeafModule_ContributionFactory.contribution());",
- " }",
- "",
- " @Override",
- " public abstract MissingInLeaf_WillDependOnFrameworkInstance",
- " willDependOnFrameworkInstance();",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.Multibinds;",
- "import java.util.Map;",
- "import javax.inject.Provider;",
- "",
- "@Module",
- "interface AncestorModule {",
- " @Provides",
- " static MissingInLeaf_WillDependOnFrameworkInstance providedInAncestor(",
- " Provider<Map<Integer, Multibound>> frameworkInstance) {",
- " return null;",
- " }",
- "",
- " @Multibinds Map<Integer, Multibound> multibinds();",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- "import dagger.internal.MapFactory;",
- "import java.util.Map;",
- IMPORT_GENERATED_ANNOTATION,
- "import javax.inject.Provider;",
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " private Provider<Map<Integer, Multibound>> mapOfIntegerAndMultiboundProvider;",
- "",
- " protected LeafImpl() {}",
- "",
- " protected void configureInitialization() { ",
- " initialize();",
- " }",
- "",
- " @SuppressWarnings(\"unchecked\")",
- " private void initialize() { ",
- " this.mapOfIntegerAndMultiboundProvider =",
- " MapFactory.<Integer, Multibound>builder(1)",
- " .put(111, LeafModule_ContributionFactory.create())",
- " .build();",
- " }",
- "",
- " protected Provider getMapOfIntegerAndMultiboundProvider() {",
- " return mapOfIntegerAndMultiboundProvider;",
- " }",
- "",
- " @Override",
- " public final MissingInLeaf_WillDependOnFrameworkInstance ",
- " willDependOnFrameworkInstance() {",
- " return AncestorModule_ProvidedInAncestorFactory.providedInAncestor(",
- " getMapOfIntegerAndMultiboundProvider());",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
- }
-
- @Test
- public void emptyMultibinds_set() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "Multibound");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.multibindings.Multibinds;",
- "import java.util.Set;",
- "",
- "@Module",
- "interface LeafModule {",
- " @Multibinds",
- " Set<Multibound> set();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Set;",
- "",
- "@Subcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " Set<Multibound> set();",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableSet;",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Set;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public Set<Multibound> set() {",
- " return ImmutableSet.<Multibound>of();",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.IntoSet;",
- "",
- "@Module",
- "class AncestorModule {",
- " @Provides",
- " @IntoSet",
- " static Multibound fromAncestor() {",
- " return new Multibound();",
- " }",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableSet;",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Set;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " public Set<Multibound> set() {",
- " return ImmutableSet.<Multibound>of(",
- " AncestorModule_FromAncestorFactory.fromAncestor());",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
- }
-
- @Test
- public void emptyMultibinds_set_frameworkInstance() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "Multibound");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.multibindings.Multibinds;",
- "import java.util.Set;",
- "",
- "@Module",
- "interface LeafModule {",
- " @Multibinds",
- " Set<Multibound> set();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Set;",
- "import javax.inject.Provider;",
- "",
- "@Subcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " Provider<Set<Multibound>> set();",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- "import dagger.internal.SetFactory;",
- "import java.util.Set;",
- IMPORT_GENERATED_ANNOTATION,
- "import javax.inject.Provider;",
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public Provider<Set<Multibound>> set() {",
- " return SetFactory.<Multibound>empty();",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.IntoSet;",
- "",
- "@Module",
- "class AncestorModule {",
- " @Provides",
- " @IntoSet",
- " static Multibound fromAncestor() {",
- " return new Multibound();",
- " }",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import dagger.internal.DelegateFactory;",
- "import dagger.internal.GenerationOptions;",
- "import dagger.internal.SetFactory;",
- "import java.util.Set;",
- IMPORT_GENERATED_ANNOTATION,
- "import javax.inject.Provider;",
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " private Provider<Set<Multibound>> setOfMultiboundProvider =",
- " new DelegateFactory<>();",
- "",
- " protected LeafImpl() {}",
- "",
- " protected void configureInitialization() {",
- " initialize();",
- " }",
- "",
- " @SuppressWarnings(\"unchecked\")",
- " private void initialize() {",
- " DelegateFactory.setDelegate(",
- " setOfMultiboundProvider,",
- " SetFactory.<Multibound>builder(1, 0)",
- " .addProvider(AncestorModule_FromAncestorFactory.create())",
- " .build());",
- " }",
- "",
- " @Override",
- " public Provider<Set<Multibound>> set() {",
- " return setOfMultiboundProvider;",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
- }
-
- @Test
- public void emptyMultibinds_map() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "Multibound");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.multibindings.Multibinds;",
- "import java.util.Map;",
- "",
- "@Module",
- "interface LeafModule {",
- " @Multibinds",
- " Map<Integer, Multibound> map();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Map;",
- "",
- "@Subcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " Map<Integer, Multibound> map();",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableMap;",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Map;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public Map<Integer, Multibound> map() {",
- " return ImmutableMap.<Integer, Multibound>of();",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.IntKey;",
- "import dagger.multibindings.IntoMap;",
- "",
- "@Module",
- "class AncestorModule {",
- " @Provides",
- " @IntoMap",
- " @IntKey(111)",
- " static Multibound fromAncestor() {",
- " return new Multibound();",
- " }",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableMap;",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Map;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " public Map<Integer, Multibound> map() {",
- " return ImmutableMap.<Integer, Multibound>of(",
- " 111, AncestorModule_FromAncestorFactory.fromAncestor());",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
- }
-
- @Test
- public void emptyMultibinds_map_frameworkInstance() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "Multibound");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.multibindings.Multibinds;",
- "import java.util.Map;",
- "",
- "@Module",
- "interface LeafModule {",
- " @Multibinds",
- " Map<Integer, Multibound> map();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Map;",
- "import javax.inject.Provider;",
- "",
- "@Subcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " Provider<Map<Integer, Multibound>> map();",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- "import dagger.internal.MapFactory;",
- "import java.util.Map;",
- IMPORT_GENERATED_ANNOTATION,
- "import javax.inject.Provider;",
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public Provider<Map<Integer, Multibound>> map() {",
- " return MapFactory.<Integer, Multibound>emptyMapProvider();",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.IntKey;",
- "import dagger.multibindings.IntoMap;",
- "",
- "@Module",
- "class AncestorModule {",
- " @Provides",
- " @IntoMap",
- " @IntKey(111)",
- " static Multibound fromAncestor() {",
- " return new Multibound();",
- " }",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import dagger.internal.DelegateFactory;",
- "import dagger.internal.GenerationOptions;",
- "import dagger.internal.MapFactory;",
- "import java.util.Map;",
- IMPORT_GENERATED_ANNOTATION,
- "import javax.inject.Provider;",
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " private Provider<Map<Integer, Multibound>> mapOfIntegerAndMultiboundProvider =",
- " new DelegateFactory<>()",
- "",
- " protected LeafImpl() {}",
- "",
- " protected void configureInitialization() {",
- " initialize();",
- " }",
- "",
- " @SuppressWarnings(\"unchecked\")",
- " private void initialize() {",
- " DelegateFactory.setDelegate(",
- " mapOfIntegerAndMultiboundProvider,",
- " MapFactory.<Integer, Multibound>builder(1)",
- " .put(111, AncestorModule_FromAncestorFactory.create())",
- " .build());",
- " }",
- "",
- " @Override",
- " public Provider<Map<Integer, Multibound>> map() {",
- " return mapOfIntegerAndMultiboundProvider;",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
- }
-
- @Test
- public void bindsMissingDep_Multibindings() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.Binds;",
- "import dagger.Module;",
- "import dagger.multibindings.IntoSet;",
- "",
- "@Module",
- "interface LeafModule {",
- " @Binds",
- " @IntoSet",
- " CharSequence bindsMultibindingWithMissingDep(String string);",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Set;",
- "",
- "@Subcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " Set<CharSequence> set();",
- "}"));
-
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableSet;",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Set;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public Set<CharSequence> set() {",
- " return ImmutableSet.<CharSequence>of(getBindsMultibindingWithMissingDep());",
- " }",
- "",
- // The expected output here is subtle: the Key of
- // LeafModule.bindsMultibindingWithMissingDep() is Set<CharSequence>, but the binding
- // method should only be returning an individual CharSequence. Otherwise the
- // ImmutableSet factory method above will fail.
- " protected abstract CharSequence getBindsMultibindingWithMissingDep();",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
- }
-
- @Test
- public void multibindingsAndFastInit() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "PackagePrivate");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.MultibindingModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.IntKey;",
- "import dagger.multibindings.IntoMap;",
- "import dagger.multibindings.IntoSet;",
- "",
- "@Module",
- "interface MultibindingModule {",
- " @Provides",
- " @IntoSet",
- " @LeafScope",
- " static PackagePrivate setContribution() {",
- " return new PackagePrivate();",
- " }",
- "",
- " @Provides",
- " @IntoMap",
- " @IntKey(1)",
- " @LeafScope",
- " static PackagePrivate mapContribution() {",
- " return new PackagePrivate();",
- " }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.LeafScope",
- "package test;",
- "",
- "import javax.inject.Scope;",
- "",
- "@Scope",
- "@interface LeafScope {}"),
- JavaFileObjects.forSourceLines(
- "test.UsesMultibindings",
- "package test;",
- "",
- "import java.util.Map;",
- "import java.util.Set;",
- "import javax.inject.Inject;",
- "",
- "class UsesMultibindings {",
- " @Inject",
- " UsesMultibindings(Set<PackagePrivate> set, Map<Integer, PackagePrivate> map) {}",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Map;",
- "import java.util.Set;",
- "",
- "@LeafScope",
- "@Subcomponent(modules = MultibindingModule.class)",
- "interface Leaf {",
- " UsesMultibindings entryPoint();",
- "}"));
-
- Compilation compilation =
- compilerWithOptions(AHEAD_OF_TIME_SUBCOMPONENTS_MODE, FAST_INIT_MODE)
- .compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
-
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "@GenerationOptions(fastInit = true)",
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " private PackagePrivate getSetContribution() {",
- " Object local = setContribution;",
- " if (local instanceof MemoizedSentinel) {",
- " synchronized (local) {",
- " local = setContribution;",
- " if (local instanceof MemoizedSentinel) {",
- " local = MultibindingModule_SetContributionFactory.setContribution();",
- " setContribution = DoubleCheck.reentrantCheck(setContribution, local);",
- " }",
- " }",
- " }",
- " return (PackagePrivate) local;",
- " }",
- "",
- " private PackagePrivate getMapContribution() {",
- " Object local = mapContribution;",
- " if (local instanceof MemoizedSentinel) {",
- " synchronized (local) {",
- " local = mapContribution;",
- " if (local instanceof MemoizedSentinel) {",
- " local = MultibindingModule_MapContributionFactory.mapContribution();",
- " mapContribution = DoubleCheck.reentrantCheck(mapContribution, local);",
- " }",
- " }",
- " }",
- " return (PackagePrivate) local;",
- " }",
- "",
- " @Override",
- " public UsesMultibindings entryPoint() {",
- " return new UsesMultibindings(",
- " getSetOfPackagePrivate(), getMapOfIntegerAndPackagePrivate());",
- " }",
- "",
- " protected Set getSetOfPackagePrivate() {",
- " return ImmutableSet.<PackagePrivate>of(getSetContribution());",
- " }",
- "",
- " protected Map getMapOfIntegerAndPackagePrivate() {",
- " return ImmutableMap.<Integer, PackagePrivate>of(1, getMapContribution());",
- " }",
- "}");
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .containsElementsIn(generatedLeaf);
- }
-
- // TODO(ronshapiro): remove copies from AheadOfTimeSubcomponents*Test classes
- private void createSimplePackagePrivateClasses(
- ImmutableList.Builder<JavaFileObject> filesBuilder, String... ancillaryClasses) {
- for (String className : ancillaryClasses) {
- filesBuilder.add(
- JavaFileObjects.forSourceLines(
- String.format("test.%s", className),
- "package test;",
- "",
- String.format("class %s { }", className)));
- }
- }
-
- private static Compilation compile(Iterable<JavaFileObject> files) {
- return compilerWithOptions(AHEAD_OF_TIME_SUBCOMPONENTS_MODE).compile(files);
- }
-
- private static Compilation compileWithoutGuava(Iterable<JavaFileObject> files) {
- return daggerCompiler()
- .withOptions(
- AHEAD_OF_TIME_SUBCOMPONENTS_MODE.javacopts().append(CLASS_PATH_WITHOUT_GUAVA_OPTION))
- .compile(files);
- }
-}
diff --git a/javatests/dagger/internal/codegen/AheadOfTimeSubcomponentsTest.java b/javatests/dagger/internal/codegen/AheadOfTimeSubcomponentsTest.java
deleted file mode 100644
index 1bd221a..0000000
--- a/javatests/dagger/internal/codegen/AheadOfTimeSubcomponentsTest.java
+++ /dev/null
@@ -1,5677 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.testing.compile.CompilationSubject.assertThat;
-import static dagger.internal.codegen.CompilerMode.AHEAD_OF_TIME_SUBCOMPONENTS_MODE;
-import static dagger.internal.codegen.Compilers.compilerWithOptions;
-import static dagger.internal.codegen.GeneratedLines.GENERATED_ANNOTATION;
-import static dagger.internal.codegen.GeneratedLines.GENERATION_OPTIONS_ANNOTATION;
-import static dagger.internal.codegen.GeneratedLines.IMPORT_GENERATED_ANNOTATION;
-
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ObjectArrays;
-import com.google.testing.compile.Compilation;
-import com.google.testing.compile.JavaFileObjects;
-import javax.tools.JavaFileObject;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-@RunWith(JUnit4.class)
-public final class AheadOfTimeSubcomponentsTest {
- private static final String PRUNED_METHOD_BODY =
- "throw new UnsupportedOperationException(\"This binding is not part of the final binding "
- + "graph. The key was requested by a binding that was believed to possibly be part of "
- + "the graph, but is no longer requested. If this exception is thrown, it is the result "
- + "of a Dagger bug.\");";
-
- @Test
- public void missingBindings_fromComponentMethod() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "MissingInLeaf");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent",
- "interface Leaf {",
- " MissingInLeaf missingFromComponentMethod();",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public abstract MissingInLeaf missingFromComponentMethod();",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "class AncestorModule {",
- " @Provides",
- " static MissingInLeaf satisfiedInAncestor() { return new MissingInLeaf(); }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " public final MissingInLeaf missingFromComponentMethod() {",
- " return AncestorModule_SatisfiedInAncestorFactory.satisfiedInAncestor();",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
- }
-
- @Test
- public void missingBindings_dependsOnBindingWithMatchingComponentMethod() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "MissingInLeaf");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent",
- "interface Leaf {",
- " MissingInLeaf missingComponentMethod();",
- " DependsOnComponentMethod dependsOnComponentMethod();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.DependsOnComponentMethod",
- "package test;",
- "",
- "import javax.inject.Inject;",
- "",
- "class DependsOnComponentMethod {",
- " @Inject DependsOnComponentMethod(MissingInLeaf missingInLeaf) {}",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public abstract MissingInLeaf missingComponentMethod();",
- "",
- " @Override",
- " public DependsOnComponentMethod dependsOnComponentMethod() {",
- " return new DependsOnComponentMethod(missingComponentMethod());",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
- }
-
- @Test
- public void missingBindings_dependsOnMissingBinding() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "MissingInLeaf");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent",
- "interface Leaf {",
- " DependsOnMissingBinding dependsOnMissingBinding();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.DependsOnMissingBinding",
- "package test;",
- "",
- "import javax.inject.Inject;",
- "",
- "class DependsOnMissingBinding {",
- " @Inject DependsOnMissingBinding(MissingInLeaf missing) {}",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public DependsOnMissingBinding dependsOnMissingBinding() {",
- " return new DependsOnMissingBinding((MissingInLeaf) getMissingInLeaf());",
- " }",
- "",
- " protected abstract Object getMissingInLeaf();",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "class AncestorModule {",
- " @Provides",
- " static MissingInLeaf satisfiedInAncestor() { return new MissingInLeaf(); }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " protected final Object getMissingInLeaf() {",
- " return AncestorModule_SatisfiedInAncestorFactory.satisfiedInAncestor();",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
- }
-
- @Test
- public void missingBindings_satisfiedInGreatAncestor() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "MissingInLeaf");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent",
- "interface Leaf {",
- " DependsOnMissingBinding dependsOnMissingBinding();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.DependsOnMissingBinding",
- "package test;",
- "",
- "import javax.inject.Inject;",
- "",
- "class DependsOnMissingBinding {",
- " @Inject DependsOnMissingBinding(MissingInLeaf missing) {}",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.GreatAncestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = SatisfiesMissingBindingModule.class)",
- "interface GreatAncestor {",
- " Ancestor ancestor();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.SatisfiesMissingBindingModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "class SatisfiesMissingBindingModule {",
- " @Provides",
- " static MissingInLeaf satisfy() { return new MissingInLeaf(); }",
- "}"));
- // DaggerLeaf+DaggerAncestor generated types are ignored - they're not the focus of this test
- // and are tested elsewhere
- JavaFileObject generatedGreatAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerGreatAncestor implements GreatAncestor {",
- " protected DaggerGreatAncestor() {}",
- "",
- " protected abstract class AncestorImpl extends DaggerAncestor {",
- " protected AncestorImpl() {}",
- "",
- " protected abstract class LeafImpl extends DaggerAncestor.LeafImpl {",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " protected final Object getMissingInLeaf() {",
- " return SatisfiesMissingBindingModule_SatisfyFactory.satisfy();",
- " }",
- " }",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerGreatAncestor")
- .hasSourceEquivalentTo(generatedGreatAncestor);
- }
-
- @Test
- public void moduleInstanceDependency() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = TestModule.class)",
- "interface Leaf {",
- " String string();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.TestModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "class TestModule {",
- " @Provides String provideString() { return \"florp\"; }",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public String string() {",
- " return TestModule_ProvideStringFactory.provideString(testModule());",
- " }",
- "",
- " protected abstract TestModule testModule();",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Root",
- "package test;",
- "",
- "import dagger.Component;",
- "",
- "@Component",
- "interface Root {",
- " Ancestor ancestor();",
- "}"));
- JavaFileObject generatedRoot =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATED_ANNOTATION,
- "final class DaggerRoot implements Root {",
- " private DaggerRoot() {}",
- "",
- " public static Builder builder() {",
- " return new Builder();",
- " }",
- "",
- " public static Root create() {",
- " return new Builder().build();",
- " }",
- "",
- " @Override",
- " public Ancestor ancestor() {",
- " return new AncestorImpl();",
- " }",
- "",
- " static final class Builder {",
- " private Builder() {}",
- "",
- " public Root build() {",
- " return new DaggerRoot();",
- " }",
- " }",
- "",
- " protected final class AncestorImpl extends DaggerAncestor {",
- " private AncestorImpl() {}",
- "",
- " @Override",
- " public Leaf leaf() {",
- " return new LeafImpl();",
- " }",
- "",
- " protected final class LeafImpl extends DaggerAncestor.LeafImpl {",
- " private final TestModule testModule;",
- "",
- " private LeafImpl() {",
- " this.testModule = new TestModule();",
- " }",
- "",
- " @Override",
- " protected TestModule testModule() {",
- " return testModule;",
- " }",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerRoot")
- .hasSourceEquivalentTo(generatedRoot);
- }
-
- @Test
- public void moduleInstanceDependency_withModuleParams() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = TestModule.class)",
- "interface Leaf {",
- " int getInt();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.TestModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "final class TestModule {",
- " private int i;",
- "",
- " TestModule(int i) {}",
- "",
- " @Provides int provideInt() {",
- " return i++;",
- " }",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public int getInt() {",
- " return testModule().provideInt();",
- " }",
- "",
- " protected abstract TestModule testModule();",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent",
- "interface Ancestor {",
- " Leaf leaf(TestModule module);",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Root",
- "package test;",
- "",
- "import dagger.Component;",
- "",
- "@Component",
- "interface Root {",
- " Ancestor ancestor();",
- "}"));
- JavaFileObject generatedRoot =
- JavaFileObjects.forSourceLines(
- "test.DaggerRoot",
- "package test;",
- "",
- "import dagger.internal.Preconditions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATED_ANNOTATION,
- "final class DaggerRoot implements Root {",
- " private DaggerRoot() {}",
- "",
- " public static Builder builder() {",
- " return new Builder();",
- " }",
- "",
- " public static Root create() {",
- " return new Builder().build();",
- " }",
- "",
- " @Override",
- " public Ancestor ancestor() {",
- " return new AncestorImpl();",
- " }",
- "",
- " static final class Builder {",
- " private Builder() {}",
- "",
- " public Root build() {",
- " return new DaggerRoot();",
- " }",
- " }",
- "",
- " protected final class AncestorImpl extends DaggerAncestor {",
- " private AncestorImpl() {}",
- "",
- " @Override",
- " public Leaf leaf(TestModule module) {",
- " Preconditions.checkNotNull(module);",
- " return new LeafImpl(module);",
- " }",
- "",
- " protected final class LeafImpl extends DaggerAncestor.LeafImpl {",
- " private final TestModule testModule;",
- "",
- " private LeafImpl(TestModule module) {",
- " this.testModule = module;",
- " }",
- "",
- " @Override",
- " protected TestModule testModule() {",
- " return testModule;",
- " }",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerRoot")
- .hasSourceEquivalentTo(generatedRoot);
- }
-
- @Test
- public void generatedInstanceBinding() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent",
- "interface Leaf {",
- " @Subcomponent.Builder",
- " interface Builder {",
- " Leaf build();",
- " }",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent",
- "interface Ancestor {",
- " Leaf.Builder leaf();",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " @Override",
- " public abstract Leaf.Builder leaf();",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Root",
- "package test;",
- "",
- "import dagger.Component;",
- "",
- "@Component",
- "interface Root {",
- " Ancestor ancestor();",
- "}"));
- JavaFileObject generatedRoot =
- JavaFileObjects.forSourceLines(
- "test.DaggerRoot",
- "package test;",
- "",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATED_ANNOTATION,
- "final class DaggerRoot implements Root {",
- " private DaggerRoot() {}",
- "",
- " public static Builder builder() {",
- " return new Builder();",
- " }",
- "",
- " public static Root create() {",
- " return new Builder().build();",
- " }",
- "",
- " @Override",
- " public Ancestor ancestor() {",
- " return new AncestorImpl();",
- " }",
- "",
- " static final class Builder {",
- " private Builder() {}",
- "",
- " public Root build() {",
- " return new DaggerRoot();",
- " }",
- " }",
- "",
- " protected final class AncestorImpl extends DaggerAncestor {",
- " private AncestorImpl() {}",
- "",
- " @Override",
- " public Leaf.Builder leaf() {",
- " return new LeafBuilder();",
- " }",
- "",
- " private final class LeafBuilder implements Leaf.Builder {",
- " @Override",
- " public Leaf build() {",
- " return new LeafImpl();",
- " }",
- " }",
- "",
- " protected final class LeafImpl extends DaggerAncestor.LeafImpl {",
- " private LeafImpl() {}",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerRoot")
- .hasSourceEquivalentTo(generatedRoot);
- }
-
- @Test
- public void prunedGeneratedInstanceBinding() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.PrunedSubcomponent",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent",
- "interface PrunedSubcomponent {",
- " @Subcomponent.Builder",
- " interface Builder {",
- " PrunedSubcomponent build();",
- " }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.InstallsPrunedSubcomponentModule",
- "package test;",
- "",
- "import dagger.Module;",
- "",
- "@Module(subcomponents = PrunedSubcomponent.class)",
- "interface InstallsPrunedSubcomponentModule {}"),
- JavaFileObjects.forSourceLines(
- "test.DependsOnPrunedSubcomponentBuilder",
- "package test;",
- "",
- "import javax.inject.Inject;",
- "",
- "class DependsOnPrunedSubcomponentBuilder {",
- " @Inject DependsOnPrunedSubcomponentBuilder(PrunedSubcomponent.Builder builder) {}",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.MaybeLeaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = InstallsPrunedSubcomponentModule.class)",
- "interface MaybeLeaf {",
- " DependsOnPrunedSubcomponentBuilder dependsOnPrunedSubcomponentBuilder();",
- "}"));
- JavaFileObject generatedMaybeLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerMaybeLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerMaybeLeaf implements MaybeLeaf {",
- " protected DaggerMaybeLeaf() {}",
- "",
- " @Override",
- " public DependsOnPrunedSubcomponentBuilder dependsOnPrunedSubcomponentBuilder() {",
- " return new DependsOnPrunedSubcomponentBuilder(",
- " (PrunedSubcomponent.Builder) getPrunedSubcomponentBuilder());",
- " }",
- "",
- " protected abstract Object getPrunedSubcomponentBuilder();",
- "",
- " protected abstract class PrunedSubcomponentImpl extends DaggerPrunedSubcomponent {",
- " protected PrunedSubcomponentImpl() {}",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerMaybeLeaf")
- .hasSourceEquivalentTo(generatedMaybeLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.PrunesGeneratedInstanceModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "interface PrunesGeneratedInstanceModule {",
- " @Provides",
- " static DependsOnPrunedSubcomponentBuilder pruneGeneratedInstance() {",
- " return new DependsOnPrunedSubcomponentBuilder(null);",
- " }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Root",
- "package test;",
- "",
- "import dagger.Component;",
- "",
- "@Component(modules = PrunesGeneratedInstanceModule.class)",
- "interface Root {",
- " MaybeLeaf actuallyLeaf();",
- "}"));
- JavaFileObject generatedRoot =
- JavaFileObjects.forSourceLines(
- "test.DaggerRoot",
- "package test;",
- "",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATED_ANNOTATION,
- "final class DaggerRoot implements Root {",
- " private DaggerRoot() {}",
- "",
- " public static Builder builder() {",
- " return new Builder();",
- " }",
- "",
- " public static Root create() {",
- " return new Builder().build();",
- " }",
- "",
- " @Override",
- " public MaybeLeaf actuallyLeaf() {",
- " return new MaybeLeafImpl();",
- " }",
- "",
- " static final class Builder {",
- " private Builder() {}",
- "",
- " public Root build() {",
- " return new DaggerRoot();",
- " }",
- " }",
- "",
- " protected final class MaybeLeafImpl extends DaggerMaybeLeaf {",
- " private MaybeLeafImpl() {}",
- "",
- " @Override",
- " protected Object getPrunedSubcomponentBuilder() {",
- " " + PRUNED_METHOD_BODY,
- " }",
- "",
- " @Override",
- " public DependsOnPrunedSubcomponentBuilder dependsOnPrunedSubcomponentBuilder() {",
- " return PrunesGeneratedInstanceModule_PruneGeneratedInstanceFactory",
- " .pruneGeneratedInstance();",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerRoot")
- .hasSourceEquivalentTo(generatedRoot);
- }
-
- @Test
- public void optionalBindings_boundAndSatisfiedInSameSubcomponent() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "SatisfiedInSub");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Sub",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Optional;",
- "",
- "@Subcomponent(modules = {SubModule.class, BindsSatisfiedInSubModule.class})",
- "interface Sub {",
- " Optional<SatisfiedInSub> satisfiedInSub();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.SubModule",
- "package test;",
- "",
- "import dagger.BindsOptionalOf;",
- "import dagger.Module;",
- "",
- "@Module",
- "abstract class SubModule {",
- " @BindsOptionalOf abstract SatisfiedInSub optionalSatisfiedInSub();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.BindsSatisfiedInSubModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "abstract class BindsSatisfiedInSubModule {",
- " @Provides static SatisfiedInSub provideSatisfiedInSub() {",
- " return new SatisfiedInSub();",
- " }",
- "}"));
- JavaFileObject generatedSubcomponent =
- JavaFileObjects.forSourceLines(
- "test.DaggerSub",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Optional;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerSub implements Sub {",
- " protected DaggerSub() {}",
- "",
- " @Override",
- " public Optional<SatisfiedInSub> satisfiedInSub() {",
- " return Optional.of(",
- " BindsSatisfiedInSubModule_ProvideSatisfiedInSubFactory",
- " .provideSatisfiedInSub());",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerSub")
- .hasSourceEquivalentTo(generatedSubcomponent);
- }
-
- @Test
- public void optionalBindings_satisfiedInAncestor() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "SatisfiedInAncestor");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Optional;",
- "",
- "@Subcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " Optional<SatisfiedInAncestor> satisfiedInAncestor();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.BindsOptionalOf;",
- "import dagger.Module;",
- "",
- "@Module",
- "abstract class LeafModule {",
- " @BindsOptionalOf abstract SatisfiedInAncestor optionalSatisfiedInAncestor();",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Optional;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public Optional<SatisfiedInAncestor> satisfiedInAncestor() {",
- " return Optional.<SatisfiedInAncestor>empty();",
- " }",
- "}");
- Compilation compilation =
- compile(
- filesToCompile.build()
- , CompilerMode.JAVA7
- );
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "abstract class AncestorModule {",
- " @Provides",
- " static SatisfiedInAncestor satisfiedInAncestor(){",
- " return new SatisfiedInAncestor();",
- " }",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Optional;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " public final Optional<SatisfiedInAncestor> satisfiedInAncestor() {",
- " return Optional.of(AncestorModule_SatisfiedInAncestorFactory",
- " .satisfiedInAncestor());",
- " }",
- "",
- " }",
- "}");
- compilation =
- compile(
- filesToCompile.build()
- , CompilerMode.JAVA7
- );
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
- }
-
- @Test
- public void optionalBindings_satisfiedInGrandAncestor() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "SatisfiedInGrandAncestor");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Optional;",
- "",
- "@Subcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " Optional<SatisfiedInGrandAncestor> satisfiedInGrandAncestor();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.BindsOptionalOf;",
- "import dagger.Module;",
- "",
- "@Module",
- "abstract class LeafModule {",
- " @BindsOptionalOf",
- " abstract SatisfiedInGrandAncestor optionalSatisfiedInGrandAncestor();",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Optional;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public Optional<SatisfiedInGrandAncestor> satisfiedInGrandAncestor() {",
- " return Optional.<SatisfiedInGrandAncestor>empty();",
- " }",
- "}");
- Compilation compilation =
- compile(
- filesToCompile.build()
- , CompilerMode.JAVA7
- );
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- " }",
- "}");
- compilation =
- compile(
- filesToCompile.build()
- , CompilerMode.JAVA7
- );
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.GreatAncestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = GreatAncestorModule.class)",
- "interface GreatAncestor {",
- " Ancestor ancestor();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.GreatAncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "abstract class GreatAncestorModule {",
- " @Provides",
- " static SatisfiedInGrandAncestor satisfiedInGrandAncestor(){",
- " return new SatisfiedInGrandAncestor();",
- " }",
- "}"));
- JavaFileObject generatedGreatAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerGreatAncestor",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Optional;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerGreatAncestor implements GreatAncestor {",
- " protected DaggerGreatAncestor() {}",
- "",
- " protected abstract class AncestorImpl extends DaggerAncestor {",
- " protected AncestorImpl() {}",
- "",
- " protected abstract class LeafImpl extends DaggerAncestor.LeafImpl {",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " public final Optional<SatisfiedInGrandAncestor> satisfiedInGrandAncestor() {",
- " return Optional.of(",
- " GreatAncestorModule_SatisfiedInGrandAncestorFactory",
- " .satisfiedInGrandAncestor());",
- " }",
- " }",
- " }",
- "}");
- compilation =
- compile(
- filesToCompile.build()
- , CompilerMode.JAVA7
- );
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerGreatAncestor")
- .hasSourceEquivalentTo(generatedGreatAncestor);
- }
-
- @Test
- public void optionalBindings_nonComponentMethodDependencySatisfiedInAncestor() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(
- filesToCompile, "SatisfiedInAncestor", "RequiresOptionalSatisfiedInAncestor");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Optional;",
- "",
- "@Subcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " RequiresOptionalSatisfiedInAncestor requiresOptionalSatisfiedInAncestor();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.BindsOptionalOf;",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import java.util.Optional;",
- "",
- "@Module",
- "abstract class LeafModule {",
- " @Provides static RequiresOptionalSatisfiedInAncestor",
- " provideRequiresOptionalSatisfiedInAncestor(",
- " Optional<SatisfiedInAncestor> satisfiedInAncestor) {",
- " return new RequiresOptionalSatisfiedInAncestor();",
- " }",
- "",
- " @BindsOptionalOf abstract SatisfiedInAncestor optionalSatisfiedInAncestor();",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Optional;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public RequiresOptionalSatisfiedInAncestor",
- " requiresOptionalSatisfiedInAncestor() {",
- " return LeafModule_ProvideRequiresOptionalSatisfiedInAncestorFactory",
- " .provideRequiresOptionalSatisfiedInAncestor(",
- " getOptionalOfSatisfiedInAncestor());",
- " }",
- "",
- " protected Optional getOptionalOfSatisfiedInAncestor() {",
- " return Optional.<SatisfiedInAncestor>empty();",
- " }",
- "}");
- Compilation compilation =
- compile(
- filesToCompile.build()
- , CompilerMode.JAVA7
- );
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "abstract class AncestorModule {",
- " @Provides",
- " static SatisfiedInAncestor satisfiedInAncestor(){",
- " return new SatisfiedInAncestor();",
- " }",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Optional;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " protected final Optional getOptionalOfSatisfiedInAncestor() {",
- " return Optional.of(",
- " AncestorModule_SatisfiedInAncestorFactory.satisfiedInAncestor());",
- " }",
- " }",
- "}");
- compilation =
- compile(
- filesToCompile.build()
- , CompilerMode.JAVA7
- );
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
- }
-
- @Test
- public void optionalBindings_boundInAncestorAndSatisfiedInGrandAncestor() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "SatisfiedInGrandAncestor");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import java.util.Optional;",
- "",
- "@Subcomponent",
- "interface Leaf {",
- " Optional<SatisfiedInGrandAncestor> boundInAncestorSatisfiedInGrandAncestor();",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Optional;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public abstract Optional<SatisfiedInGrandAncestor>",
- " boundInAncestorSatisfiedInGrandAncestor();",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import dagger.BindsOptionalOf;",
- "import dagger.Module;",
- "",
- "@Module",
- "abstract class AncestorModule {",
- " @BindsOptionalOf",
- " abstract SatisfiedInGrandAncestor optionalSatisfiedInGrandAncestor();",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Optional;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " public Optional<SatisfiedInGrandAncestor>",
- " boundInAncestorSatisfiedInGrandAncestor() {",
- " return Optional.<SatisfiedInGrandAncestor>empty();",
- " }",
- " }",
- "}");
- compilation =
- compile(
- filesToCompile.build()
- , CompilerMode.JAVA7
- );
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.GrandAncestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = GrandAncestorModule.class)",
- "interface GrandAncestor {",
- " Ancestor ancestor();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.GrandAncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "class GrandAncestorModule {",
- " @Provides static SatisfiedInGrandAncestor provideSatisfiedInGrandAncestor() {",
- " return new SatisfiedInGrandAncestor();",
- " }",
- "}"));
- JavaFileObject generatedGrandAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerGrandAncestor",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Optional;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerGrandAncestor implements GrandAncestor {",
- " protected DaggerGrandAncestor() {}",
- "",
- " protected abstract class AncestorImpl extends DaggerAncestor {",
- " protected AncestorImpl() {}",
- "",
- " protected abstract class LeafImpl extends DaggerAncestor.LeafImpl {",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " public final Optional<SatisfiedInGrandAncestor>",
- " boundInAncestorSatisfiedInGrandAncestor() {",
- " return Optional.of(",
- " GrandAncestorModule_ProvideSatisfiedInGrandAncestorFactory",
- " .provideSatisfiedInGrandAncestor());",
- " }",
- " }",
- " }",
- "}");
- compilation =
- compile(
- filesToCompile.build()
- , CompilerMode.JAVA7
- );
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerGrandAncestor")
- .hasSourceEquivalentTo(generatedGrandAncestor);
- }
-
- @Test
- public void provisionOverInjection_providedInAncestor() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.ProvidedInAncestor",
- "package test;",
- "",
- "import javax.inject.Inject;",
- "",
- "class ProvidedInAncestor {",
- " @Inject",
- " ProvidedInAncestor(String string) {}",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent",
- "interface Leaf {",
- " ProvidedInAncestor injectedInLeaf();",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public ProvidedInAncestor injectedInLeaf() {",
- " return new ProvidedInAncestor(getString());",
- " }",
- "",
- " protected abstract String getString();",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "class AncestorModule {",
- " @Provides",
- " static ProvidedInAncestor provideProvidedInAncestor() {",
- " return new ProvidedInAncestor(\"static\");",
- " }",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " public final ProvidedInAncestor injectedInLeaf() {",
- " return AncestorModule_ProvideProvidedInAncestorFactory",
- " .provideProvidedInAncestor();",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
- }
-
- @Test
- public void provisionOverInjection_providedInGrandAncestor() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.ProvidedInGrandAncestor",
- "package test;",
- "",
- "import javax.inject.Inject;",
- "",
- "class ProvidedInGrandAncestor {",
- " @Inject",
- " ProvidedInGrandAncestor(String string) {}",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent",
- "interface Leaf {",
- " ProvidedInGrandAncestor injectedInLeaf();",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public ProvidedInGrandAncestor injectedInLeaf() {",
- " return new ProvidedInGrandAncestor(getString());",
- " }",
- "",
- " protected abstract String getString();",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.GrandAncestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = GrandAncestorModule.class)",
- "interface GrandAncestor {",
- " Ancestor ancestor();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.GrandAncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "class GrandAncestorModule {",
- " @Provides",
- " static ProvidedInGrandAncestor provideProvidedInGrandAncestor() {",
- " return new ProvidedInGrandAncestor(\"static\");",
- " }",
- "}"));
- JavaFileObject generatedGrandAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerGrandAncestor",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerGrandAncestor implements GrandAncestor {",
- " protected DaggerGrandAncestor() {}",
- "",
- " protected abstract class AncestorImpl extends DaggerAncestor {",
- " protected AncestorImpl() {}",
- "",
- " protected abstract class LeafImpl extends DaggerAncestor.LeafImpl {",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " public final ProvidedInGrandAncestor injectedInLeaf() {",
- " return GrandAncestorModule_ProvideProvidedInGrandAncestorFactory",
- " .provideProvidedInGrandAncestor();",
- " }",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerGrandAncestor")
- .hasSourceEquivalentTo(generatedGrandAncestor);
- }
-
- @Test
- public void provisionOverInjection_indirectDependency() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.ProvidedInAncestor",
- "package test;",
- "",
- "import javax.inject.Inject;",
- "",
- "class ProvidedInAncestor {",
- " @Inject",
- " ProvidedInAncestor(String string) {}",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.InjectedInLeaf",
- "package test;",
- "",
- "import javax.inject.Inject;",
- "",
- "class InjectedInLeaf {",
- " @Inject",
- " InjectedInLeaf(ProvidedInAncestor providedInAncestor) {}",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent",
- "interface Leaf {",
- " InjectedInLeaf injectedInLeaf();",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public InjectedInLeaf injectedInLeaf() {",
- " return new InjectedInLeaf((ProvidedInAncestor) getProvidedInAncestor());",
- " }",
- "",
- " protected abstract String getString();",
- "",
- " protected Object getProvidedInAncestor() {",
- " return new ProvidedInAncestor(getString());",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "class AncestorModule {",
- " @Provides",
- " static ProvidedInAncestor provideProvidedInAncestor() {",
- " return new ProvidedInAncestor(\"static\");",
- " }",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " protected final Object getProvidedInAncestor() {",
- " return AncestorModule_ProvideProvidedInAncestorFactory",
- " .provideProvidedInAncestor();",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
- }
-
- @Test
- public void provisionOverInjection_prunedIndirectDependency() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "PrunedDependency");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.InjectsPrunedDependency",
- "package test;",
- "",
- "import javax.inject.Inject;",
- "",
- "class InjectsPrunedDependency {",
- " @Inject",
- " InjectsPrunedDependency(PrunedDependency prunedDependency) {}",
- "",
- " private InjectsPrunedDependency() { }",
- "",
- " static InjectsPrunedDependency create() { return new InjectsPrunedDependency(); }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent",
- "interface Leaf {",
- " InjectsPrunedDependency injectsPrunedDependency();",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public InjectsPrunedDependency injectsPrunedDependency() {",
- " return new InjectsPrunedDependency((PrunedDependency) getPrunedDependency());",
- " }",
- "",
- " protected abstract Object getPrunedDependency();",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Root",
- "package test;",
- "",
- "import dagger.Component;",
- "",
- "@Component(modules = RootModule.class)",
- "interface Root {",
- " Leaf leaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.RootModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "class RootModule {",
- " @Provides",
- " static InjectsPrunedDependency injectsPrunedDependency() {",
- " return InjectsPrunedDependency.create();",
- " }",
- "}"));
- JavaFileObject generatedRoot =
- JavaFileObjects.forSourceLines(
- "test.DaggerRoot",
- "package test;",
- "",
- "import dagger.internal.Preconditions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATED_ANNOTATION,
- "final class DaggerRoot implements Root {",
- " private DaggerRoot() {}",
- "",
- " public static Builder builder() {",
- " return new Builder();",
- " }",
- "",
- " public static Root create() {",
- " return new Builder().build();",
- " }",
- "",
- " @Override",
- " public Leaf leaf() {",
- " return new LeafImpl();",
- " }",
- "",
- " static final class Builder {",
- " private Builder() {}",
- "",
- " @Deprecated",
- " public Builder rootModule(RootModule rootModule) {",
- " Preconditions.checkNotNull(rootModule);",
- " return this;",
- " }",
- "",
- " public Root build() {",
- " return new DaggerRoot();",
- " }",
- " }",
- "",
- " protected final class LeafImpl extends DaggerLeaf {",
- " private LeafImpl() {}",
- "",
- " @Override",
- " protected Object getPrunedDependency() {",
- " " + PRUNED_METHOD_BODY,
- " }",
- "",
- " @Override",
- " public InjectsPrunedDependency injectsPrunedDependency() {",
- " return RootModule_InjectsPrunedDependencyFactory",
- " .injectsPrunedDependency();",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerRoot")
- .hasSourceEquivalentTo(generatedRoot);
- }
-
- @Test
- public void provisionOverInjection_prunedDirectDependency_prunedInConcreteImplementation() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- filesToCompile.add(
- // The binding for PrunedDependency will always exist, but will change from
- // ModifiableBindingType.INJECTION to ModifiableBindingType.MISSING. We should correctly
- // ignore this change leave the modifiable binding method alone
- JavaFileObjects.forSourceLines(
- "test.PrunedDependency",
- "package test;",
- "",
- "import javax.inject.Inject;",
- "",
- "class PrunedDependency {",
- " @Inject PrunedDependency() {}",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.InjectsPrunedDependency",
- "package test;",
- "",
- "import javax.inject.Inject;",
- "",
- "class InjectsPrunedDependency {",
- " @Inject",
- " InjectsPrunedDependency(PrunedDependency prunedDependency) {}",
- "",
- " private InjectsPrunedDependency() { }",
- "",
- " static InjectsPrunedDependency create() { return new InjectsPrunedDependency(); }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent",
- "interface Leaf {",
- " InjectsPrunedDependency injectsPrunedDependency();",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public InjectsPrunedDependency injectsPrunedDependency() {",
- " return new InjectsPrunedDependency((PrunedDependency) getPrunedDependency());",
- " }",
- "",
- " protected Object getPrunedDependency() {",
- " return new PrunedDependency();",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Root",
- "package test;",
- "",
- "import dagger.Component;",
- "",
- "@Component(modules = RootModule.class)",
- "interface Root {",
- " Leaf leaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.RootModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "class RootModule {",
- " @Provides",
- " static InjectsPrunedDependency injectsPrunedDependency() {",
- " return InjectsPrunedDependency.create();",
- " }",
- "}"));
- JavaFileObject generatedRoot =
- JavaFileObjects.forSourceLines(
- "test.DaggerRoot",
- "package test;",
- "",
- "import dagger.internal.Preconditions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATED_ANNOTATION,
- "final class DaggerRoot implements Root {",
- " private DaggerRoot() {}",
- "",
- " public static Builder builder() {",
- " return new Builder();",
- " }",
- "",
- " public static Root create() {",
- " return new Builder().build();",
- " }",
- "",
- " @Override",
- " public Leaf leaf() {",
- " return new LeafImpl();",
- " }",
- "",
- " static final class Builder {",
- " private Builder() {}",
- "",
- " @Deprecated",
- " public Builder rootModule(RootModule rootModule) {",
- " Preconditions.checkNotNull(rootModule);",
- " return this;",
- " }",
- "",
- " public Root build() {",
- " return new DaggerRoot();",
- " }",
- " }",
- "",
- " protected final class LeafImpl extends DaggerLeaf {",
- " private LeafImpl() {}",
- "",
- " @Override",
- " public InjectsPrunedDependency injectsPrunedDependency() {",
- " return RootModule_InjectsPrunedDependencyFactory",
- " .injectsPrunedDependency();",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerRoot")
- .hasSourceEquivalentTo(generatedRoot);
- }
-
- @Test
- public void provisionOverInjection_prunedDirectDependency_prunedInAbstractImplementation() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- filesToCompile.add(
- // The binding for PrunedDependency will always exist, but will change from
- // ModifiableBindingType.INJECTION to ModifiableBindingType.MISSING. We should correctly
- // ignore this change leave the modifiable binding method alone
- JavaFileObjects.forSourceLines(
- "test.PrunedDependency",
- "package test;",
- "",
- "import javax.inject.Inject;",
- "",
- "class PrunedDependency {",
- " @Inject PrunedDependency() {}",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.InjectsPrunedDependency",
- "package test;",
- "",
- "import javax.inject.Inject;",
- "",
- "class InjectsPrunedDependency {",
- " @Inject",
- " InjectsPrunedDependency(PrunedDependency prunedDependency) {}",
- "",
- " private InjectsPrunedDependency() { }",
- "",
- " static InjectsPrunedDependency create() { return new InjectsPrunedDependency(); }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent",
- "interface Leaf {",
- " InjectsPrunedDependency injectsPrunedDependency();",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public InjectsPrunedDependency injectsPrunedDependency() {",
- " return new InjectsPrunedDependency((PrunedDependency) getPrunedDependency());",
- " }",
- "",
- " protected Object getPrunedDependency() {",
- " return new PrunedDependency();",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "class AncestorModule {",
- " @Provides",
- " static InjectsPrunedDependency injectsPrunedDependency() {",
- " return InjectsPrunedDependency.create();",
- " }",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " public final InjectsPrunedDependency injectsPrunedDependency() {",
- " return AncestorModule_InjectsPrunedDependencyFactory",
- " .injectsPrunedDependency();",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Root",
- "package test;",
- "",
- "import dagger.Component;",
- "",
- "@Component",
- "interface Root {",
- " Ancestor ancestor();",
- "}"));
- JavaFileObject generatedRoot =
- JavaFileObjects.forSourceLines(
- "test.DaggerRoot",
- "package test;",
- "",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATED_ANNOTATION,
- "final class DaggerRoot implements Root {",
- " private DaggerRoot() {}",
- "",
- " public static Builder builder() {",
- " return new Builder();",
- " }",
- "",
- " public static Root create() {",
- " return new Builder().build();",
- " }",
- "",
- " @Override",
- " public Ancestor ancestor() {",
- " return new AncestorImpl();",
- " }",
- "",
- " static final class Builder {",
- " private Builder() {}",
- "",
- " public Root build() {",
- " return new DaggerRoot();",
- " }",
- " }",
- "",
- " protected final class AncestorImpl extends DaggerAncestor {",
- " private AncestorImpl() {}",
- "",
- " @Override",
- " public Leaf leaf() {",
- " return new LeafImpl();",
- " }",
- "",
- " protected final class LeafImpl extends DaggerAncestor.LeafImpl {",
- " private LeafImpl() {}",
- // even though DaggerAncestor.LeafImpl.getPrunedDependency() was
- // ModifiableBindingType.MISSING, it doesn't need to be reimplemented because there was
- // a base implementation
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerRoot")
- .hasSourceEquivalentTo(generatedRoot);
- }
-
- @Test
- public void productionSubcomponentAndModifiableFrameworkInstance() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "Response", "ResponseDependency");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import com.google.common.util.concurrent.ListenableFuture;",
- "import dagger.producers.ProductionSubcomponent;",
- "import java.util.Set;",
- "",
- "@ProductionSubcomponent(modules = ResponseProducerModule.class)",
- "interface Leaf {",
- " ListenableFuture<Set<Response>> responses();",
- "",
- " @ProductionSubcomponent.Builder",
- " interface Builder {",
- " Leaf build();",
- " }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.ResponseProducerModule",
- "package test;",
- "",
- "import dagger.multibindings.IntoSet;",
- "import dagger.producers.ProducerModule;",
- "import dagger.producers.Produces;",
- "",
- "@ProducerModule",
- "final class ResponseProducerModule {",
- " @Produces",
- " @IntoSet",
- " static Response response(ResponseDependency responseDependency) {",
- " return new Response();",
- " }",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import com.google.common.util.concurrent.ListenableFuture;",
- "import dagger.internal.GenerationOptions;",
- "import dagger.producers.Producer;",
- "import dagger.producers.internal.CancellationListener;",
- "import dagger.producers.internal.Producers;",
- "import dagger.producers.internal.SetProducer;",
- "import dagger.producers.monitoring.ProductionComponentMonitor;",
- "import java.util.Set;",
- "import java.util.concurrent.Executor;",
- IMPORT_GENERATED_ANNOTATION,
- "import javax.inject.Provider;",
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf, CancellationListener {",
- " private Producer<Set<Response>> responsesEntryPoint;",
- " private Producer<Response> responseProducer;",
- " private Producer<Set<Response>> setOfResponseProducer;",
- "",
- " protected DaggerLeaf() {}",
- "",
- " protected void configureInitialization() {",
- " initialize();",
- " }",
- "",
- " @SuppressWarnings(\"unchecked\")",
- " private void initialize() {",
- " this.responseProducer =",
- " ResponseProducerModule_ResponseFactory.create(",
- " getProductionImplementationExecutorProvider(),",
- " getProductionComponentMonitorProvider(),",
- " getResponseDependencyProducer());",
- " this.setOfResponseProducer =",
- " SetProducer.<Response>builder(1, 0)",
- " .addProducer(responseProducer).build();",
- " this.responsesEntryPoint =",
- " Producers.entryPointViewOf(getSetOfResponseProducer(), this);",
- " }",
- "",
- " @Override",
- " public ListenableFuture<Set<Response>> responses() {",
- " return responsesEntryPoint.get();",
- " }",
- "",
- " protected abstract Provider<Executor>",
- " getProductionImplementationExecutorProvider();",
- "",
- " protected abstract Provider<ProductionComponentMonitor>",
- " getProductionComponentMonitorProvider();",
- "",
- " protected abstract Producer getResponseDependencyProducer();",
- "",
- " protected Producer getSetOfResponseProducer() {",
- " return setOfResponseProducer;",
- " }",
- "",
- " @Override",
- " public void onProducerFutureCancelled(boolean mayInterruptIfRunning) {",
- " Producers.cancel(getSetOfResponseProducer(), mayInterruptIfRunning);",
- " Producers.cancel(responseProducer, mayInterruptIfRunning);",
- " }",
- "}");
-
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.ExecutorModule",
- "package test;",
- "",
- "import com.google.common.util.concurrent.MoreExecutors;",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.producers.Production;",
- "import java.util.concurrent.Executor;",
- "",
- "@Module",
- "final class ExecutorModule {",
- " @Provides",
- " @Production",
- " static Executor executor() {",
- " return MoreExecutors.directExecutor();",
- " }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Root",
- "package test;",
- "",
- "import com.google.common.util.concurrent.ListenableFuture;",
- "import dagger.producers.ProductionComponent;",
- "",
- "@ProductionComponent(",
- " modules = {",
- " ExecutorModule.class,",
- " ResponseDependencyProducerModule.class,",
- " RootMultibindingModule.class,",
- " })",
- "interface Root {",
- " Leaf.Builder leaf();",
- "",
- " @ProductionComponent.Builder",
- " interface Builder {",
- " Root build();",
- " }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.ResponseDependencyProducerModule",
- "package test;",
- "",
- "import com.google.common.util.concurrent.Futures;",
- "import com.google.common.util.concurrent.ListenableFuture;",
- "import dagger.producers.ProducerModule;",
- "import dagger.producers.Produces;",
- "",
- "@ProducerModule",
- "final class ResponseDependencyProducerModule {",
- " @Produces",
- " static ListenableFuture<ResponseDependency> responseDependency() {",
- " return Futures.immediateFuture(new ResponseDependency());",
- " }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.RootMultibindingModule",
- "package test;",
- "",
- "import dagger.multibindings.IntoSet;",
- "import dagger.producers.ProducerModule;",
- "import dagger.producers.Produces;",
- "",
- "@ProducerModule",
- "final class RootMultibindingModule {",
- " @Produces",
- " @IntoSet",
- " static Response response() {",
- " return new Response();",
- " }",
- "}"));
- JavaFileObject generatedRoot =
- JavaFileObjects.forSourceLines(
- "test.DaggerRoot",
- "package test;",
- "",
- "import dagger.internal.DoubleCheck;",
- "import dagger.internal.InstanceFactory;",
- "import dagger.internal.SetFactory;",
- "import dagger.producers.Producer;",
- "import dagger.producers.internal.CancellationListener;",
- "import dagger.producers.internal.DelegateProducer;",
- "import dagger.producers.internal.Producers;",
- "import dagger.producers.internal.SetProducer;",
- "import dagger.producers.monitoring.ProductionComponentMonitor;",
- "import java.util.Set;",
- "import java.util.concurrent.Executor;",
- IMPORT_GENERATED_ANNOTATION,
- "import javax.inject.Provider;",
- "",
- GENERATED_ANNOTATION,
- "final class DaggerRoot implements Root, CancellationListener {",
- " private Provider<Executor> productionImplementationExecutorProvider;",
- " private Provider<Root> rootProvider;",
- " private Provider<ProductionComponentMonitor> monitorProvider;",
- " private Producer<ResponseDependency> responseDependencyProducer;",
- " private Producer<Response> responseProducer;",
- "",
- " private DaggerRoot() {",
- " initialize();",
- " }",
- "",
- " public static Root.Builder builder() {",
- " return new Builder();",
- " }",
- "",
- " public static Root create() {",
- " return new Builder().build();",
- " }",
- "",
- " @SuppressWarnings(\"unchecked\")",
- " private void initialize() {",
- " this.productionImplementationExecutorProvider =",
- " DoubleCheck.provider((Provider) ExecutorModule_ExecutorFactory.create());",
- " this.rootProvider = InstanceFactory.create((Root) this);",
- " this.monitorProvider =",
- " DoubleCheck.provider(",
- " Root_MonitoringModule_MonitorFactory.create(",
- " rootProvider,",
- " SetFactory.<ProductionComponentMonitor.Factory>empty()));",
- " this.responseDependencyProducer =",
- " ResponseDependencyProducerModule_ResponseDependencyFactory.create(",
- " productionImplementationExecutorProvider, monitorProvider);",
- " this.responseProducer =",
- " RootMultibindingModule_ResponseFactory.create(",
- " productionImplementationExecutorProvider, monitorProvider);",
- " }",
- "",
- " @Override",
- " public Leaf.Builder leaf() {",
- " return new LeafBuilder();",
- " }",
- "",
- " @Override",
- " public void onProducerFutureCancelled(boolean mayInterruptIfRunning) {",
- " Producers.cancel(responseProducer, mayInterruptIfRunning);",
- " Producers.cancel(responseDependencyProducer, mayInterruptIfRunning);",
- " }",
- "",
- " private static final class Builder implements Root.Builder {",
- " @Override",
- " public Root build() {",
- " return new DaggerRoot();",
- " }",
- " }",
- "",
- " private final class LeafBuilder implements Leaf.Builder {",
- " @Override",
- " public Leaf build() {",
- " return new LeafImpl();",
- " }",
- " }",
- "",
- " protected final class LeafImpl extends DaggerLeaf implements CancellationListener {",
- " private Producer<Set<Response>> setOfResponseProducer = new DelegateProducer<>();",
- "",
- " private LeafImpl() {",
- " configureInitialization();",
- " initialize();",
- " }",
- "",
- " @SuppressWarnings(\"unchecked\")",
- " private void initialize() {",
- " DelegateProducer.setDelegate(",
- " setOfResponseProducer,",
- " SetProducer.<Response>builder(1, 1)",
- " .addCollectionProducer(super.getSetOfResponseProducer())",
- " .addProducer(DaggerRoot.this.responseProducer)",
- " .build());",
- " }",
- "",
- " @Override",
- " protected Provider<Executor> getProductionImplementationExecutorProvider() {",
- " return DaggerRoot.this.productionImplementationExecutorProvider;",
- " }",
- "",
- " @Override",
- " protected Provider<ProductionComponentMonitor>",
- " getProductionComponentMonitorProvider() {",
- " return DaggerRoot.this.monitorProvider;",
- " }",
- "",
- " @Override",
- " protected Producer getResponseDependencyProducer() {",
- " return DaggerRoot.this.responseDependencyProducer;",
- " }",
- "",
- " @Override",
- " protected Producer getSetOfResponseProducer() {",
- " return setOfResponseProducer;",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerRoot")
- .hasSourceEquivalentTo(generatedRoot);
- }
-
- @Test
- public void lazyOfModifiableBinding() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "MissingInLeaf");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Lazy;",
- "import dagger.Subcomponent;",
- "import javax.inject.Provider;",
- "",
- "@Subcomponent",
- "interface Leaf {",
- " Lazy<MissingInLeaf> lazy();",
- " Provider<Lazy<MissingInLeaf>> providerOfLazy();",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.Lazy;",
- "import dagger.internal.DoubleCheck;",
- "import dagger.internal.GenerationOptions;",
- "import dagger.internal.ProviderOfLazy;",
- IMPORT_GENERATED_ANNOTATION,
- "import javax.inject.Provider;",
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public Lazy<MissingInLeaf> lazy() {",
- " return DoubleCheck.lazy(getMissingInLeafProvider());",
- " }",
- "",
- " @Override",
- " public Provider<Lazy<MissingInLeaf>> providerOfLazy() {",
- " return ProviderOfLazy.create(getMissingInLeafProvider());",
- " }",
- "",
- " protected abstract Provider getMissingInLeafProvider();",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "class AncestorModule {",
- " @Provides",
- " static MissingInLeaf satisfiedInAncestor() { return new MissingInLeaf(); }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "import javax.inject.Provider;",
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " protected final Provider getMissingInLeafProvider() {",
- " return AncestorModule_SatisfiedInAncestorFactory.create();",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
- }
-
- @Test
- public void missingBindingAccessInLeafAndAncestor() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(
- filesToCompile, "Missing", "DependsOnMissing", "ProvidedInAncestor_InducesSetBinding");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.multibindings.IntoSet;",
- "import dagger.Provides;",
- "import javax.inject.Provider;",
- "",
- "@Module",
- "class LeafModule {",
- " @Provides",
- " static DependsOnMissing test(",
- " Missing missing,",
- " Provider<Missing> missingProvider,",
- " ProvidedInAncestor_InducesSetBinding missingInLeaf) {",
- " return new DependsOnMissing();",
- " }",
- "",
- " @Provides",
- " @IntoSet",
- " static Object unresolvedSetBinding(",
- " Missing missing, Provider<Missing> missingProvider) {",
- " return new Object();",
- " }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import javax.inject.Provider;",
- "",
- "@Subcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " DependsOnMissing instance();",
- " Provider<DependsOnMissing> frameworkInstance();",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "import javax.inject.Provider;",
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " private Provider<DependsOnMissing> testProvider;",
- "",
- " protected DaggerLeaf() {}",
- "",
- " protected void configureInitialization() {",
- " initialize();",
- " }",
- "",
- " @SuppressWarnings(\"unchecked\")",
- " private void initialize() {",
- " this.testProvider =",
- " LeafModule_TestFactory.create(",
- " getMissingProvider(), getProvidedInAncestor_InducesSetBindingProvider());",
- " }",
- "",
- " @Override",
- " public DependsOnMissing instance() {",
- " return LeafModule_TestFactory.test(",
- // TODO(b/117833324): remove these unnecessary casts
- " (Missing) getMissing(),",
- " getMissingProvider(),",
- " (ProvidedInAncestor_InducesSetBinding)",
- " getProvidedInAncestor_InducesSetBinding());",
- " }",
- "",
- " @Override",
- " public Provider<DependsOnMissing> frameworkInstance() {",
- " return testProvider;",
- " }",
- "",
- " protected abstract Object getMissing();",
- " protected abstract Provider getMissingProvider();",
- " protected abstract Object getProvidedInAncestor_InducesSetBinding();",
- " protected abstract Provider getProvidedInAncestor_InducesSetBindingProvider();",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.multibindings.IntoSet;",
- "import dagger.Provides;",
- "import java.util.Set;",
- "",
- "@Module",
- "interface AncestorModule {",
- " @Provides",
- " static ProvidedInAncestor_InducesSetBinding providedInAncestor(",
- " Set<Object> setThatInducesMissingBindingInChildSubclassImplementation) {",
- " return new ProvidedInAncestor_InducesSetBinding();",
- " }",
- "",
- " @Provides",
- " @IntoSet",
- " static Object setContribution() {",
- " return new Object();",
- " }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableSet;",
- "import dagger.internal.DelegateFactory;",
- "import dagger.internal.GenerationOptions;",
- "import dagger.internal.SetFactory;",
- "import java.util.Set;",
- IMPORT_GENERATED_ANNOTATION,
- "import javax.inject.Provider;",
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " private Provider<Object> unresolvedSetBindingProvider;",
- " private Provider<Set<Object>> setOfObjectProvider;",
- " private Provider<ProvidedInAncestor_InducesSetBinding> ",
- " providedInAncestorProvider = ",
- " new DelegateFactory<>();",
- "",
- " protected LeafImpl() {}",
- "",
- " @Override",
- " protected void configureInitialization() {",
- " super.configureInitialization();",
- " initialize();",
- " }",
- "",
- " private Object getUnresolvedSetBinding() {",
- " return LeafModule_UnresolvedSetBindingFactory.unresolvedSetBinding(",
- // TODO(b/117833324): remove this unnecessary cast
- " (Missing) getMissing(), getMissingProvider());",
- " }",
- "",
- " @SuppressWarnings(\"unchecked\")",
- " private void initialize() {",
- " this.unresolvedSetBindingProvider =",
- " LeafModule_UnresolvedSetBindingFactory.create(getMissingProvider());",
- " this.setOfObjectProvider =",
- " SetFactory.<Object>builder(2, 0)",
- " .addProvider(AncestorModule_SetContributionFactory.create())",
- " .addProvider(unresolvedSetBindingProvider)",
- " .build();",
- " DelegateFactory.setDelegate(",
- " providedInAncestorProvider,",
- " AncestorModule_ProvidedInAncestorFactory.create(getSetOfObjectProvider()));",
- " }",
- "",
- " protected Set<Object> getSetOfObject() {",
- " return ImmutableSet.<Object>of(",
- " AncestorModule_SetContributionFactory.setContribution(),",
- " getUnresolvedSetBinding());",
- " }",
- "",
- " @Override",
- " protected final Object getProvidedInAncestor_InducesSetBinding() {",
- " return AncestorModule_ProvidedInAncestorFactory.providedInAncestor(",
- " getSetOfObject());",
- " }",
- "",
- " protected Provider<Set<Object>> getSetOfObjectProvider() {",
- " return setOfObjectProvider;",
- " }",
- "",
- " @Override",
- " protected final Provider getProvidedInAncestor_InducesSetBindingProvider() {",
- " return providedInAncestorProvider;",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
- }
-
- @Test
- public void subcomponentBuilders() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "InducesDependenciesOnBuilderFields");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "class LeafModule {",
- " private final Object object;",
- "",
- " LeafModule(Object object) {",
- " this.object = object;",
- " }",
- "",
- " @Provides",
- " Object fromModule() {",
- " return object;",
- " }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.MultibindingsModule",
- "package test;",
- "",
- "import dagger.Binds;",
- "import dagger.Module;",
- "import dagger.multibindings.IntoSet;",
- "",
- "@Module",
- "interface MultibindingsModule {",
- " @Binds",
- " @IntoSet",
- " String string(String string);",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.BindsInstance;",
- "import dagger.Subcomponent;",
- "import javax.inject.Provider;",
- "",
- "@Subcomponent(modules = {LeafModule.class, MultibindingsModule.class})",
- "interface Leaf {",
- " int bindsInstance();",
- " Object fromModule();",
- " InducesDependenciesOnBuilderFields inducesDependenciesOnBuilderFields();",
- "",
- " @Subcomponent.Builder",
- " interface Builder {",
- " @BindsInstance Builder bindsInstance(int boundInstance);",
- " @BindsInstance Builder inducedInSubclass(String induced);",
- " Builder module(LeafModule module);",
- "",
- " Leaf build();",
- " }",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- "import dagger.internal.Preconditions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " private Integer bindsInstance;",
- " private LeafModule leafModule;",
- "",
- " protected DaggerLeaf() {}",
- "",
- " protected void configureInitialization(",
- " LeafModule leafModuleParam, Integer bindsInstanceParam) {",
- " this.bindsInstance = bindsInstanceParam;",
- " this.leafModule = leafModuleParam;",
- " }",
- "",
- " @Override",
- " public int bindsInstance() {",
- " return bindsInstance;",
- " }",
- "",
- " @Override",
- " public Object fromModule() {",
- " return LeafModule_FromModuleFactory.fromModule(leafModule());",
- " }",
- "",
- " @Override",
- " public abstract InducesDependenciesOnBuilderFields",
- " inducesDependenciesOnBuilderFields();",
- "",
- " protected LeafModule leafModule() {",
- " return leafModule;",
- " }",
- "",
- " public abstract static class Builder implements Leaf.Builder {",
- " protected Integer bindsInstance;",
- " protected String inducedInSubclass;",
- " protected LeafModule leafModule;",
- "",
- " @Override",
- " public Builder bindsInstance(int boundInstance) {",
- " this.bindsInstance = Preconditions.checkNotNull(boundInstance);",
- " return this;",
- " }",
- "",
- " @Override",
- " public Builder inducedInSubclass(String induced) {",
- " this.inducedInSubclass = Preconditions.checkNotNull(induced);",
- " return this;",
- " }",
- "",
- " @Override",
- " public Builder module(LeafModule module) {",
- " this.leafModule = Preconditions.checkNotNull(module);",
- " return this;",
- " }",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = MultibindingInducingModule.class)",
- "interface Ancestor {",
- " Leaf.Builder leaf();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.MultibindingInducingModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.multibindings.Multibinds;",
- "import dagger.Provides;",
- "import java.util.Set;",
- "",
- "@Module",
- "interface MultibindingInducingModule {",
- " @Provides",
- " static InducesDependenciesOnBuilderFields induce(",
- " Set<String> multibindingWithBuilderFieldDeps) { ",
- " return new InducesDependenciesOnBuilderFields();",
- " }",
- "",
- " @Multibinds",
- " Set<String> multibinding();",
- "}"));
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableSet;",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Set;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " @Override",
- " public abstract Leaf.Builder leaf();",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " private String inducedInSubclass;",
- "",
- " protected LeafImpl() {}",
- "",
- " protected void configureInitialization(",
- " LeafModule leafModule,",
- " Integer bindsInstance,",
- " String inducedInSubclassParam) {",
- " this.inducedInSubclass = inducedInSubclassParam;",
- " configureInitialization(leafModule, bindsInstance);",
- " }",
- "",
- " protected Set<String> getSetOfString() {",
- " return ImmutableSet.<String>of(inducedInSubclass);",
- " }",
- "",
- " @Override",
- " public final InducesDependenciesOnBuilderFields",
- " inducesDependenciesOnBuilderFields() {",
- " return MultibindingInducingModule_InduceFactory.induce(getSetOfString());",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Root",
- "package test;",
- "",
- "import dagger.Component;",
- "",
- "@Component",
- "interface Root {",
- " Ancestor ancestor();",
- "}"));
- JavaFileObject generatedRoot =
- JavaFileObjects.forSourceLines(
- "test.DaggerRoot",
- "package test;",
- "",
- "import dagger.internal.Preconditions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATED_ANNOTATION,
- "final class DaggerRoot implements Root {",
- " private DaggerRoot() {}",
- "",
- " public static Builder builder() {",
- " return new Builder();",
- " }",
- "",
- " public static Root create() {",
- " return new Builder().build();",
- " }",
- "",
- " @Override",
- " public Ancestor ancestor() {",
- " return new AncestorImpl();",
- " }",
- "",
- " static final class Builder {",
- " private Builder() {}",
- "",
- " public Root build() {",
- " return new DaggerRoot();",
- " }",
- " }",
- "",
- " protected final class AncestorImpl extends DaggerAncestor {",
- " private AncestorImpl() {}",
- "",
- " @Override",
- " public Leaf.Builder leaf() {",
- " return new LeafBuilder();",
- " }",
- "",
- " private final class LeafBuilder extends DaggerLeaf.Builder {",
- " @Override",
- " public Leaf build() {",
- // TODO(b/117833324): Can we stick the validations into a method on the base class
- // builder so that the contents of this method are just call to that and then new
- // FooImpl? But repeated modules may make this more complicated, since those *should*
- // be null
- " Preconditions.checkBuilderRequirement(bindsInstance, Integer.class);",
- " Preconditions.checkBuilderRequirement(inducedInSubclass, String.class);",
- " Preconditions.checkBuilderRequirement(leafModule, LeafModule.class);",
- " return new LeafImpl(leafModule, bindsInstance, inducedInSubclass);",
- " }",
- " }",
- "",
- " protected final class LeafImpl extends DaggerAncestor.LeafImpl {",
- " private final LeafModule leafModule;",
- "",
- " private LeafImpl(",
- " LeafModule leafModuleParam,",
- " Integer bindsInstance,",
- " String inducedInSubclass) {",
- " this.leafModule = leafModuleParam;",
- " configureInitialization(leafModuleParam, bindsInstance, inducedInSubclass);",
- " }",
- "",
- " @Override",
- " protected LeafModule leafModule() {",
- " return leafModule;",
- " }",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerRoot")
- .hasSourceEquivalentTo(generatedRoot);
- }
-
- @Test
- public void subcomponentBuilders_moduleWithUnusedInstanceBindings() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "Used", "Unused");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.ModuleWithUsedBinding",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "class ModuleWithUsedBinding {",
- " @Provides",
- " Used used() {",
- " return new Used();",
- " }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.ModuleWithUnusedBinding",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "class ModuleWithUnusedBinding {",
- " @Provides",
- " Unused unused() {",
- " return new Unused();",
- " }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = {ModuleWithUsedBinding.class, ModuleWithUnusedBinding.class})",
- "interface Leaf {",
- " Used used();",
- "",
- " @Subcomponent.Builder",
- " interface Builder {",
- " Builder setUsed(ModuleWithUsedBinding module);",
- " Builder setUnused(ModuleWithUnusedBinding module);",
- " Leaf build();",
- " }",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- "import dagger.internal.Preconditions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " private ModuleWithUsedBinding moduleWithUsedBinding;",
- "",
- " protected DaggerLeaf() {}",
- "",
- " protected void configureInitialization(",
- " ModuleWithUsedBinding moduleWithUsedBindingParam) {",
- " this.moduleWithUsedBinding = moduleWithUsedBindingParam;",
- " }",
- "",
- " @Override",
- " public Used used() {",
- " return ModuleWithUsedBinding_UsedFactory.used(",
- " moduleWithUsedBinding());",
- " }",
- "",
- " protected ModuleWithUsedBinding moduleWithUsedBinding() {",
- " return moduleWithUsedBinding;",
- " }",
- "",
- " public abstract static class Builder implements Leaf.Builder {",
- " protected ModuleWithUsedBinding moduleWithUsedBinding;",
- " protected ModuleWithUnusedBinding moduleWithUnusedBinding;",
- "",
- " @Override",
- " public Builder setUsed(ModuleWithUsedBinding module) {",
- " this.moduleWithUsedBinding = Preconditions.checkNotNull(module);",
- " return this;",
- " }",
- "",
- " @Override",
- " public Builder setUnused(ModuleWithUnusedBinding module) {",
- " this.moduleWithUnusedBinding = Preconditions.checkNotNull(module);",
- " return this;",
- " }",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Root",
- "package test;",
- "",
- "import dagger.Component;",
- "",
- "@Component",
- "interface Root {",
- " Leaf.Builder leaf();",
- "}"));
- JavaFileObject generatedRoot =
- JavaFileObjects.forSourceLines(
- "test.DaggerRoot",
- "package test;",
- "",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATED_ANNOTATION,
- "final class DaggerRoot implements Root {",
- " private DaggerRoot() {}",
- "",
- " public static Builder builder() {",
- " return new Builder();",
- " }",
- "",
- " public static Root create() {",
- " return new Builder().build();",
- " }",
- "",
- " @Override",
- " public Leaf.Builder leaf() {",
- " return new LeafBuilder();",
- " }",
- "",
- " static final class Builder {",
- " private Builder() {}",
- "",
- " public Root build() {",
- " return new DaggerRoot();",
- " }",
- " }",
- "",
- " private final class LeafBuilder extends DaggerLeaf.Builder {",
- " @Override",
- " public Leaf build() {",
- " if (moduleWithUsedBinding == null) {",
- " this.moduleWithUsedBinding = new ModuleWithUsedBinding();",
- " }",
- // ModuleWithUnusedBinding is not verified since it's not used
- " return new LeafImpl(moduleWithUsedBinding);",
- " }",
- " }",
- "",
- " protected final class LeafImpl extends DaggerLeaf {",
- " private final ModuleWithUsedBinding moduleWithUsedBinding;",
- "",
- " private LeafImpl(ModuleWithUsedBinding moduleWithUsedBindingParam) {",
- " this.moduleWithUsedBinding = moduleWithUsedBindingParam;",
- " configureInitialization(moduleWithUsedBindingParam);",
- " }",
- "",
- " @Override",
- " protected ModuleWithUsedBinding moduleWithUsedBinding() {",
- " return moduleWithUsedBinding;",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerRoot")
- .hasSourceEquivalentTo(generatedRoot);
- }
-
- @Test
- public void subcomponentBuilders_repeatedModule() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.RepeatedModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "class RepeatedModule {",
- " @Provides",
- " int i() {",
- " return 1;",
- " }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = RepeatedModule.class)",
- "interface Leaf {",
- " int i();",
- "",
- " @Subcomponent.Builder",
- " interface Builder {",
- " Builder repeatedModule(RepeatedModule repeatedModule);",
- " Leaf build();",
- " }",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- "import dagger.internal.Preconditions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " private RepeatedModule repeatedModule;",
- "",
- " protected DaggerLeaf() {}",
- "",
- " protected void configureInitialization(RepeatedModule repeatedModuleParam) {",
- " this.repeatedModule = repeatedModuleParam;",
- " }",
- "",
- " @Override",
- " public int i() {",
- " return repeatedModule().i();",
- " }",
- "",
- " protected RepeatedModule repeatedModule() {",
- " return repeatedModule;",
- " }",
- "",
- " public abstract static class Builder implements Leaf.Builder {",
- " protected RepeatedModule repeatedModule;",
- "",
- " @Override",
- " public Builder repeatedModule(RepeatedModule repeatedModule) {",
- " this.repeatedModule = Preconditions.checkNotNull(repeatedModule);",
- " return this;",
- " }",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Root",
- "package test;",
- "",
- "import dagger.Component;",
- "",
- "@Component(modules = RepeatedModule.class)",
- "interface Root {",
- " Leaf.Builder leaf();",
- "}"));
- JavaFileObject generatedRoot =
- JavaFileObjects.forSourceLines(
- "test.DaggerRoot",
- "package test;",
- "",
- "import dagger.internal.Preconditions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATED_ANNOTATION,
- "final class DaggerRoot implements Root {",
- " private final RepeatedModule repeatedModule;",
- "",
- " private DaggerRoot(RepeatedModule repeatedModuleParam) {",
- " this.repeatedModule = repeatedModuleParam;",
- " }",
- "",
- " public static Builder builder() {",
- " return new Builder();",
- " }",
- "",
- " public static Root create() {",
- " return new Builder().build();",
- " }",
- "",
- " @Override",
- " public Leaf.Builder leaf() {",
- " return new LeafBuilder();",
- " }",
- "",
- " static final class Builder {",
- " private RepeatedModule repeatedModule;",
- "",
- " private Builder() {}",
- "",
- " public Builder repeatedModule(RepeatedModule repeatedModule) {",
- " this.repeatedModule = Preconditions.checkNotNull(repeatedModule);",
- " return this;",
- " }",
- "",
- " public Root build() {",
- " if (repeatedModule == null) {",
- " this.repeatedModule = new RepeatedModule();",
- " }",
- " return new DaggerRoot(repeatedModule);",
- " }",
- " }",
- "",
- " private final class LeafBuilder extends DaggerLeaf.Builder {",
- " @Override",
- " public LeafBuilder repeatedModule(RepeatedModule repeatedModule) {",
- " throw new UnsupportedOperationException(",
- " String.format(",
- " \"%s cannot be set because it is inherited from the enclosing component\",",
- " RepeatedModule.class.getCanonicalName()));",
- " }",
- "",
- " @Override",
- " public Leaf build() {",
- " return new LeafImpl();",
- " }",
- " }",
- "",
- " protected final class LeafImpl extends DaggerLeaf {",
- " private LeafImpl() {",
- " configureInitialization(null);",
- " }",
- "",
- " @Override",
- " protected RepeatedModule repeatedModule() {",
- " return DaggerRoot.this.repeatedModule;",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerRoot")
- .hasSourceEquivalentTo(generatedRoot);
- }
-
- @Test
- public void bindsWithMissingDependency() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "MissingInLeaf");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Binds;",
- "",
- "@Module",
- "interface LeafModule {",
- " @Binds Object missingBindsDependency(MissingInLeaf missing);",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " Object bindsWithMissingDependencyInLeaf();",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public abstract Object bindsWithMissingDependencyInLeaf();",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.MissingInLeafModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "interface MissingInLeafModule {",
- " @Provides",
- " static MissingInLeaf boundInRoot() {",
- " return new MissingInLeaf();",
- " }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Root",
- "package test;",
- "",
- "import dagger.Component;",
- "",
- "@Component(modules = MissingInLeafModule.class)",
- "interface Root {",
- " Leaf leaf();",
- "}"));
- JavaFileObject generatedRoot =
- JavaFileObjects.forSourceLines(
- "test.DaggerRoot",
- "package test;",
- "",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATED_ANNOTATION,
- "final class DaggerRoot implements Root {",
- " private DaggerRoot() {}",
- "",
- " public static Builder builder() {",
- " return new Builder();",
- " }",
- "",
- " public static Root create() {",
- " return new Builder().build();",
- " }",
- "",
- " @Override",
- " public Leaf leaf() {",
- " return new LeafImpl();",
- " }",
- "",
- " static final class Builder {",
- " private Builder() {}",
- "",
- " public Root build() {",
- " return new DaggerRoot();",
- " }",
- " }",
- "",
- " protected final class LeafImpl extends DaggerLeaf {",
- " private LeafImpl() {}",
- "",
- " @Override",
- " public Object bindsWithMissingDependencyInLeaf() {",
- " return MissingInLeafModule_BoundInRootFactory.boundInRoot();",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerRoot")
- .hasSourceEquivalentTo(generatedRoot);
- }
-
- @Test
- public void bindsWithMissingDependency_pruned() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "MissingInLeaf");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Binds;",
- "",
- "@Module",
- "interface LeafModule {",
- " @Binds Object missingBindsDependency(MissingInLeaf missing);",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.DependsOnBindsWithMissingDep",
- "package test;",
- "",
- "import javax.inject.Inject;",
- "",
- "class DependsOnBindsWithMissingDep {",
- " @Inject DependsOnBindsWithMissingDep(Object bindsWithMissingDep) {}",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " DependsOnBindsWithMissingDep DependsOnBindsWithMissingDep();",
- "}"));
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public DependsOnBindsWithMissingDep DependsOnBindsWithMissingDep() {",
- " return new DependsOnBindsWithMissingDep(getObject());",
- " }",
- "",
- " protected abstract Object getObject();",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.PrunesInjectConstructorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "interface PrunesInjectConstructorModule {",
- " @Provides",
- " static DependsOnBindsWithMissingDep pruneInjectConstructor() {",
- " return new DependsOnBindsWithMissingDep(new Object());",
- " }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Root",
- "package test;",
- "",
- "import dagger.Component;",
- "",
- "@Component(modules = PrunesInjectConstructorModule.class)",
- "interface Root {",
- " Leaf leaf();",
- "}"));
- JavaFileObject generatedRoot =
- JavaFileObjects.forSourceLines(
- "test.DaggerRoot",
- "package test;",
- "",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATED_ANNOTATION,
- "final class DaggerRoot implements Root {",
- " private DaggerRoot() {}",
- "",
- " public static Builder builder() {",
- " return new Builder();",
- " }",
- "",
- " public static Root create() {",
- " return new Builder().build();",
- " }",
- "",
- " @Override",
- " public Leaf leaf() {",
- " return new LeafImpl();",
- " }",
- "",
- " static final class Builder {",
- " private Builder() {}",
- "",
- " public Root build() {",
- " return new DaggerRoot();",
- " }",
- " }",
- "",
- " protected final class LeafImpl extends DaggerLeaf {",
- " private LeafImpl() {}",
- "",
- " @Override",
- " protected Object getObject() {",
- " " + PRUNED_METHOD_BODY,
- " }",
- "",
- " @Override",
- " public DependsOnBindsWithMissingDep DependsOnBindsWithMissingDep() {",
- " return PrunesInjectConstructorModule_PruneInjectConstructorFactory",
- " .pruneInjectConstructor();",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerRoot")
- .hasSourceEquivalentTo(generatedRoot);
- }
-
- @Test
- public void modifiedProducerFromProvider() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "DependsOnModifiedProducerFromProvider");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.multibindings.IntoSet;",
- "import dagger.producers.ProducerModule;",
- "import dagger.producers.Produces;",
- "import dagger.Provides;",
- "import java.util.Set;",
- "",
- "@ProducerModule",
- "interface LeafModule {",
- " @Produces",
- " static DependsOnModifiedProducerFromProvider dependsOnModified(Set<String> set) {",
- " return new DependsOnModifiedProducerFromProvider();",
- " }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.producers.Producer;",
- "import dagger.producers.ProductionSubcomponent;",
- "import java.util.Set;",
- "",
- "@ProductionSubcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " Producer<DependsOnModifiedProducerFromProvider>",
- " dependsOnModifiedProducerFromProvider();",
- "}"));
-
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- "import dagger.producers.Producer;",
- "import dagger.producers.internal.CancellationListener;",
- "import dagger.producers.internal.Producers;",
- "import dagger.producers.monitoring.ProductionComponentMonitor;",
- "import java.util.Set;",
- "import java.util.concurrent.Executor;",
- IMPORT_GENERATED_ANNOTATION,
- "import javax.inject.Provider;",
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf, CancellationListener {",
- " private Producer<DependsOnModifiedProducerFromProvider>",
- " dependsOnModifiedProducerFromProviderEntryPoint;",
- " private Producer<DependsOnModifiedProducerFromProvider> dependsOnModifiedProducer;",
- "",
- " protected DaggerLeaf() {}",
- "",
- " protected void configureInitialization() {",
- " initialize();",
- " }",
- "",
- " @SuppressWarnings(\"unchecked\")",
- " private void initialize() {",
- " this.dependsOnModifiedProducer =",
- " LeafModule_DependsOnModifiedFactory.create(",
- " getProductionImplementationExecutorProvider(),",
- " getProductionComponentMonitorProvider(),",
- " getSetOfStringProducer());",
- " this.dependsOnModifiedProducerFromProviderEntryPoint =",
- " Producers.entryPointViewOf(dependsOnModifiedProducer, this);",
- " }",
- "",
- " @Override",
- " public Producer<DependsOnModifiedProducerFromProvider> ",
- " dependsOnModifiedProducerFromProvider() {",
- " return dependsOnModifiedProducerFromProviderEntryPoint;",
- " }",
- "",
- " protected abstract Provider<Executor> ",
- " getProductionImplementationExecutorProvider();",
- "",
- " protected abstract Provider<ProductionComponentMonitor>",
- " getProductionComponentMonitorProvider();",
- "",
- " protected abstract Producer<Set<String>> getSetOfStringProducer();",
- "",
- " @Override",
- " public void onProducerFutureCancelled(boolean mayInterruptIfRunning) {",
- " Producers.cancel(dependsOnModifiedProducer, mayInterruptIfRunning);",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.RootModule",
- "package test;",
- "",
- "import dagger.multibindings.IntoSet;",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.producers.Production;",
- "import java.util.Set;",
- "import java.util.concurrent.Executor;",
- "",
- "@Module",
- "interface RootModule {",
- " @Provides",
- " @IntoSet",
- " static String induceModificationInLeaf() {",
- " return new String();",
- " }",
- "",
- " @Provides",
- " @Production",
- " static Executor productionExecutor() {",
- " return null;",
- " }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Root",
- "package test;",
- "",
- "import dagger.Component;",
- "",
- "@Component(modules = RootModule.class)",
- "interface Root {",
- " Leaf leaf();",
- "}"));
- JavaFileObject generatedRoot =
- JavaFileObjects.forSourceLines(
- "test.DaggerRoot",
- "package test;",
- "",
- "import dagger.internal.DelegateFactory;",
- "import dagger.internal.DoubleCheck;",
- "import dagger.internal.InstanceFactory;",
- "import dagger.internal.SetFactory;",
- "import dagger.producers.Producer;",
- "import dagger.producers.internal.CancellationListener;",
- "import dagger.producers.internal.DelegateProducer;",
- "import dagger.producers.internal.Producers;",
- "import dagger.producers.monitoring.ProductionComponentMonitor;",
- "import java.util.Set;",
- "import java.util.concurrent.Executor;",
- IMPORT_GENERATED_ANNOTATION,
- "import javax.inject.Provider;",
- "",
- GENERATED_ANNOTATION,
- "final class DaggerRoot implements Root {",
- " private DaggerRoot() {}",
- "",
- " public static Builder builder() {",
- " return new Builder();",
- " }",
- "",
- " public static Root create() {",
- " return new Builder().build();",
- " }",
- "",
- " @Override",
- " public Leaf leaf() {",
- " return new LeafImpl();",
- " }",
- "",
- " static final class Builder {",
- " private Builder() {}",
- "",
- " public Root build() {",
- " return new DaggerRoot();",
- " }",
- " }",
- "",
- " protected final class LeafImpl extends DaggerLeaf implements CancellationListener {",
- " private Provider<Executor> productionImplementationExecutorProvider =",
- " new DelegateFactory<>();",
- " private Provider<Leaf> leafProvider;",
- " private Provider<ProductionComponentMonitor> monitorProvider =",
- " new DelegateFactory<>();",
- " private Provider<Set<String>> setOfStringProvider;",
- " private Producer<Set<String>> setOfStringProducer = new DelegateProducer<>();",
- "",
- " private LeafImpl() {",
- " configureInitialization();",
- " initialize();",
- " }",
- "",
- " @SuppressWarnings(\"unchecked\")",
- " private void initialize() {",
- " DelegateFactory.setDelegate(",
- " productionImplementationExecutorProvider,",
- " DoubleCheck.provider(",
- " (Provider) RootModule_ProductionExecutorFactory.create()));",
- " this.leafProvider = InstanceFactory.create((Leaf) this);",
- " DelegateFactory.setDelegate(",
- " monitorProvider,",
- " DoubleCheck.provider(",
- " Leaf_MonitoringModule_MonitorFactory.create(",
- " leafProvider,",
- " getSetOfProductionComponentMonitorFactoryProvider())));",
- " this.setOfStringProvider =",
- " SetFactory.<String>builder(1, 0)",
- " .addProvider(RootModule_InduceModificationInLeafFactory.create())",
- " .build();",
- " DelegateProducer.setDelegate(",
- " setOfStringProducer,",
- " Producers.producerFromProvider(getSetOfStringProvider()));",
- " }",
- "",
- " @Override",
- " protected Provider<Executor> getProductionImplementationExecutorProvider() {",
- " return productionImplementationExecutorProvider;",
- " }",
- "",
- " protected Provider<Set<ProductionComponentMonitor.Factory>> ",
- " getSetOfProductionComponentMonitorFactoryProvider() {",
- " return SetFactory.<ProductionComponentMonitor.Factory>empty();",
- " }",
- "",
- " @Override",
- " protected Provider<ProductionComponentMonitor> ",
- " getProductionComponentMonitorProvider() {",
- " return monitorProvider;",
- " }",
- "",
- " protected Provider<Set<String>> getSetOfStringProvider() {",
- " return setOfStringProvider;",
- " }",
- "",
- " @Override",
- " protected Producer<Set<String>> getSetOfStringProducer() {",
- " return setOfStringProducer;",
- " }",
- "",
- " @Override",
- " public void onProducerFutureCancelled(boolean mayInterruptIfRunning) {",
- " super.onProducerFutureCancelled(mayInterruptIfRunning);",
- " Producers.cancel(getSetOfStringProducer(), mayInterruptIfRunning);",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerRoot")
- .hasSourceEquivalentTo(generatedRoot);
- }
-
- @Test
- public void modifiableBindingMethods_namesDedupedAcrossImplementations() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "foo.Thing",
- "package foo;",
- "", // force multi-line format
- "public interface Thing extends CharSequence {}"),
- JavaFileObjects.forSourceLines(
- "bar.Thing",
- "package bar;",
- "", // force multi-line format
- "public interface Thing extends Runnable {}"),
- JavaFileObjects.forSourceLines(
- "test.WillInduceSetOfRunnable",
- "package test;",
- "", // force multi-line format
- "class WillInduceSetOfRunnable {}"),
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.IntoSet;",
- "",
- "@Module",
- "interface LeafModule {",
- " @Provides",
- " static CharSequence depOnFooThing(foo.Thing thing) {",
- " return thing.toString();",
- " }",
- "",
- " @Provides",
- " @IntoSet",
- " static Runnable depOnBarThing(bar.Thing thing) {",
- " return () -> {};",
- " }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " CharSequence inducesFoo();",
- " WillInduceSetOfRunnable willInduceSetOfRunnable();",
- "}"));
-
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- "import foo.Thing;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public CharSequence inducesFoo() {",
- " return LeafModule_DepOnFooThingFactory.depOnFooThing(getThing());",
- " }",
- "",
- " @Override",
- " public abstract WillInduceSetOfRunnable willInduceSetOfRunnable();",
- "",
- " protected abstract Thing getThing();",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.Multibinds;",
- "import java.util.Set;",
- "",
- "@Module",
- "interface AncestorModule {",
- " @Provides",
- " static WillInduceSetOfRunnable induce(Set<Runnable> set) {",
- " return null;",
- " }",
- "",
- " @Multibinds Set<Runnable> runnables();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " Leaf leaf();",
- "}"));
-
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import bar.Thing;",
- "import com.google.common.collect.ImmutableSet;",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Set;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class LeafImpl extends DaggerLeaf {",
- " protected LeafImpl() {}",
- "",
- " private Runnable getDepOnBarThing() {",
- " return LeafModule_DepOnBarThingFactory.depOnBarThing(getThing2());",
- " }",
- "",
- " protected abstract Thing getThing2();",
- "",
- " protected Set<Runnable> getSetOfRunnable() {",
- " return ImmutableSet.<Runnable>of(getDepOnBarThing());",
- " }",
- "",
- " @Override",
- " public final WillInduceSetOfRunnable willInduceSetOfRunnable() {",
- " return AncestorModule_InduceFactory.induce(getSetOfRunnable());",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
- }
-
- /**
- * This test verifies that Dagger can find the appropriate child subcomponent
- * super-implementation, even if it is not enclosed in the current component's
- * super-implementation. This can happen if a subcomponent is installed with a module's {@code
- * subcomponents} attribute, but the binding is not accessed in a super-implementation. To exhibit
- * this, we use multibindings that reference the pruned subcomponent, but make the multibinding
- * also unresolved in the base implementation. An ancestor component defines a binding that
- * depends on the multibinding, which induces the previously unresolved multibinding
- * contributions, which itself induces the previously unresolved subcomponent.
- */
- @Test
- public void subcomponentInducedFromAncestor() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "Inducer");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.InducedSubcomponent",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent",
- "interface InducedSubcomponent {",
- " @Subcomponent.Builder",
- " interface Builder {",
- " InducedSubcomponent build();",
- " }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.MaybeLeaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = InducedSubcomponentModule.class)",
- "interface MaybeLeaf {",
- " Inducer inducer();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.MaybeLeaf",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.IntoSet;",
- "",
- "@Module(subcomponents = InducedSubcomponent.class)",
- "interface InducedSubcomponentModule {",
- " @Provides",
- " @IntoSet",
- " static Object inducedSet(InducedSubcomponent.Builder builder) {",
- " return new Object();",
- " }",
- "}"));
-
- JavaFileObject generatedMaybeLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerMaybeLeaf implements MaybeLeaf {",
- " protected DaggerMaybeLeaf() {}",
- "",
- " @Override",
- " public abstract Inducer inducer();",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerMaybeLeaf")
- .hasSourceEquivalentTo(generatedMaybeLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import dagger.multibindings.Multibinds;",
- "import java.util.Set;",
- "",
- "@Module",
- "interface AncestorModule {",
- " @Provides",
- " static Inducer inducer(Set<Object> set) {",
- " return null;",
- " }",
- "",
- " @Multibinds Set<Object> set();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = AncestorModule.class)",
- "interface Ancestor {",
- " MaybeLeaf noLongerLeaf();",
- "}"));
-
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- "import com.google.common.collect.ImmutableSet;",
- "import dagger.internal.GenerationOptions;",
- "import java.util.Set;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected DaggerAncestor() {}",
- "",
- " protected abstract class MaybeLeafImpl extends DaggerMaybeLeaf {",
- " protected MaybeLeafImpl() {}",
- "",
- " private Object getInducedSet() {",
- " return InducedSubcomponentModule_InducedSetFactory.inducedSet(",
- // TODO(b/117833324): remove this unnecessary cast
- " (InducedSubcomponent.Builder) getInducedSubcomponentBuilder());",
- " }",
- "",
- " protected abstract Object getInducedSubcomponentBuilder();",
- "",
- " protected Set<Object> getSetOfObject() {",
- " return ImmutableSet.<Object>of(getInducedSet());",
- " }",
- "",
- " @Override",
- " public final Inducer inducer() {",
- " return AncestorModule_InducerFactory.inducer(getSetOfObject());",
- " }",
- "",
- " protected abstract class InducedSubcomponentImpl extends",
- " DaggerInducedSubcomponent {",
- // ^ Note that this is DaggerInducedSubcomponent, not
- // DaggerMaybeLeaf.InducedSubcomponentImpl
- " protected InducedSubcomponentImpl() {}",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .hasSourceEquivalentTo(generatedAncestor);
- }
-
- @Test
- public void rootScopedAtInjectConstructor_effectivelyMissingInSubcomponent() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "ProvidesMethodRootScoped");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.RootScope",
- "package test;",
- "",
- "import javax.inject.Scope;",
- "",
- "@Scope",
- "public @interface RootScope {}"),
- JavaFileObjects.forSourceLines(
- "test.AtInjectRootScoped",
- "package test;",
- "",
- "import javax.inject.Inject;",
- "",
- "@RootScope",
- "class AtInjectRootScoped {",
- " @Inject AtInjectRootScoped() {}",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent",
- "interface Leaf {",
- " AtInjectRootScoped shouldBeEffectivelyMissingInLeaf();",
- "}"));
-
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public abstract AtInjectRootScoped shouldBeEffectivelyMissingInLeaf();",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Component;",
- "",
- "@RootScope",
- "@Component",
- "interface Root {",
- " Leaf leaf();",
- "}"));
-
- JavaFileObject generatedRoot =
- JavaFileObjects.forSourceLines(
- "test.DaggerRoot",
- "package test;",
- "",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATED_ANNOTATION,
- "final class DaggerRoot implements Root {",
- " protected final class LeafImpl extends DaggerLeaf {",
- " @Override",
- " public AtInjectRootScoped shouldBeEffectivelyMissingInLeaf() {",
- " return DaggerRoot.this.atInjectRootScopedProvider.get();",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerRoot")
- .containsElementsIn(generatedRoot);
- }
-
- @Test
- public void prunedModuleWithInstanceState() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "Pruned");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Modified",
- "package test;",
- "",
- "import javax.inject.Inject;",
- "",
- "class Modified {",
- " @Inject Modified(Pruned pruned) {}",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "class LeafModule {",
- " @Provides",
- " Pruned pruned() {",
- " return new Pruned();",
- " }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " Modified modified();",
- "}"));
-
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected DaggerLeaf() {}",
- "",
- " @Override",
- " public Modified modified() {",
- " return new Modified(LeafModule_PrunedFactory.pruned(leafModule()));",
- " }",
- "",
- " protected abstract LeafModule leafModule();",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.RootModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "class RootModule {",
- " @Provides",
- " static Modified modified() {",
- " return new Modified(null);",
- " }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Root",
- "package test;",
- "",
- "import dagger.Component;",
- "",
- "@Component(modules = RootModule.class)",
- "interface Root {",
- " Leaf leaf();",
- "}"));
-
- JavaFileObject generatedRoot =
- JavaFileObjects.forSourceLines(
- "test.DaggerRoot",
- "package test;",
- "",
- IMPORT_GENERATED_ANNOTATION,
- "",
- GENERATED_ANNOTATION,
- "final class DaggerRoot implements Root {",
- " protected final class LeafImpl extends DaggerLeaf {",
- " @Override",
- " public Modified modified() {",
- " return RootModule_ModifiedFactory.modified();",
- " }",
- "",
- " @Override",
- " protected LeafModule leafModule() {",
- " return null;",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerRoot")
- .containsElementsIn(generatedRoot);
- }
-
- @Test
- public void modifiableCycles() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.A",
- "package test;",
- "",
- "import javax.inject.Inject;",
- "",
- "class A {",
- " @Inject A(B b) {}",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.B",
- "package test;",
- "",
- "import javax.inject.Inject;",
- "import javax.inject.Provider;",
- "",
- "class B {",
- " @Inject B(Provider<A> a) {}",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "import javax.inject.Provider;",
- "",
- "@Subcomponent",
- "interface Leaf {",
- " Provider<A> frameworkInstanceCycle();",
- "}"));
-
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import dagger.internal.DelegateFactory;",
- "import dagger.internal.GenerationOptions;",
- IMPORT_GENERATED_ANNOTATION,
- "import javax.inject.Provider;",
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " private Provider<A> aProvider;",
- " private Provider<B> bProvider;",
- "",
- " protected DaggerLeaf() {}",
- "",
- " protected void configureInitialization() {",
- " initialize();",
- " }",
- "",
- " @SuppressWarnings(\"unchecked\")",
- " private void initialize() {",
- " this.aProvider = new DelegateFactory<>();",
- " this.bProvider = B_Factory.create(frameworkInstanceCycle());",
- " DelegateFactory.setDelegate(aProvider, A_Factory.create(getBProvider()));",
- " }",
- "",
- " @Override",
- " public Provider<A> frameworkInstanceCycle() {",
- " return aProvider;",
- " }",
- "",
- " protected Provider getBProvider() {",
- " return bProvider;",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .hasSourceEquivalentTo(generatedLeaf);
- }
-
- /**
- * This tests a regression case where the component builder in the base implementation used one
- * set of disambiguated names from all of the {@link ComponentDescriptor#requirements()}, and the
- * final implementation used a different set of disambiguated names from the resolved {@link
- * BindingGraph#componentRequirements()}. This resulted in generated output that didn't compile,
- * as the builder implementation attempted to use the new names in validation, which didn't line
- * up with the old names.
- */
- @Test
- public void componentBuilderFields_consistencyAcrossImplementations() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "a.Mod",
- "package a;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import javax.inject.Named;",
- "",
- "@Module",
- "public class Mod {",
- " @Provides",
- " @Named(\"a\")",
- " int i() { return 0; }",
- "}"),
- JavaFileObjects.forSourceLines(
- "b.Mod",
- "package b;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import javax.inject.Named;",
- "",
- "@Module",
- "public class Mod {",
- " @Provides",
- " @Named(\"b\")",
- " int i() { return 0; }",
- "}"),
- JavaFileObjects.forSourceLines(
- "c.Mod",
- "package c;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "import javax.inject.Named;",
- "",
- "@Module",
- "public class Mod {",
- " @Provides",
- " @Named(\"c\")",
- " int i() { return 0; }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.HasUnusedModuleLeaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "import javax.inject.Named;",
- "",
- "@Subcomponent(modules = {a.Mod.class, b.Mod.class, c.Mod.class})",
- "interface HasUnusedModuleLeaf {",
- " @Named(\"a\") int a();",
- // b omitted intentionally
- " @Named(\"c\") int c();",
- "",
- " @Subcomponent.Builder",
- " interface Builder {",
- " Builder setAMod(a.Mod mod);",
- " Builder setBMod(b.Mod mod);",
- " Builder setCMod(c.Mod mod);",
- " HasUnusedModuleLeaf build();",
- " }",
- "}"));
-
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import a.Mod;",
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerHasUnusedModuleLeaf implements HasUnusedModuleLeaf {",
- " public abstract static class Builder implements HasUnusedModuleLeaf.Builder {",
- " protected Mod mod;",
- " protected b.Mod mod2;",
- " protected c.Mod mod3;",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerHasUnusedModuleLeaf")
- .containsElementsIn(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Root",
- "package test;",
- "",
- "import dagger.Component;",
- "",
- "@Component",
- "interface Root {",
- " HasUnusedModuleLeaf.Builder leaf();",
- "}"));
-
- JavaFileObject generatedRoot =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- "import a.Mod;",
- "",
- GENERATED_ANNOTATION,
- "final class DaggerRoot implements Root {",
- " private final class HasUnusedModuleLeafBuilder",
- " extends DaggerHasUnusedModuleLeaf.Builder {",
- " @Override",
- " public HasUnusedModuleLeaf build() {",
- " if (mod == null) {",
- " this.mod = new Mod();",
- " }",
- // Before this regression was fixed, `mod3` was instead `mod2`, since the `b.Mod` was
- // pruned from the graph and did not need validation.
- " if (mod3 == null) {",
- " this.mod3 = new c.Mod();",
- " }",
- " return new HasUnusedModuleLeafImpl(mod, mod3);",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerRoot")
- .containsElementsIn(generatedRoot);
- }
-
- @Test
- public void dependencyExpressionCasting() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.PublicType",
- "package test;",
- "", //
- "public class PublicType {}"),
- JavaFileObjects.forSourceLines(
- "test.ModifiableNonPublicSubclass",
- "package test;",
- "",
- "import javax.inject.Inject;",
- "",
- "class ModifiableNonPublicSubclass extends PublicType {",
- " @Inject ModifiableNonPublicSubclass() {}",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Parameterized",
- "package test;",
- "",
- "import javax.inject.Inject;",
- "",
- "class Parameterized<T extends PublicType> {",
- " @Inject Parameterized(T t) {}",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "import javax.inject.Provider;",
- "",
- "@Subcomponent",
- "interface Leaf {",
- " Parameterized<ModifiableNonPublicSubclass> parameterizedWithNonPublicSubtype();",
- "}"));
-
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " @Override",
- " public Parameterized<ModifiableNonPublicSubclass> ",
- " parameterizedWithNonPublicSubtype() {",
- " return Parameterized_Factory.newInstance(",
- " (ModifiableNonPublicSubclass) getModifiableNonPublicSubclass());",
- " }",
- "",
- " protected Object getModifiableNonPublicSubclass() {",
- " return new ModifiableNonPublicSubclass();",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .containsElementsIn(generatedLeaf);
- }
-
- @Test
- public void multipleComponentMethodsForSameBindingRequest() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent",
- "interface Leaf {",
- " String string1();",
- " String string2();",
- "}"));
-
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " @Override",
- " public final String string2() {",
- " return string1();",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .containsElementsIn(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.RootModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "interface RootModule {",
- " @Provides",
- " static String string() {",
- " return new String();",
- " }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Root",
- "package test;",
- "",
- "import dagger.Component;",
- "",
- "@Component(modules = RootModule.class)",
- "interface Root {",
- " Leaf leaf();",
- "}"));
-
- JavaFileObject generatedRoot =
- JavaFileObjects.forSourceLines(
- "test.DaggerRoot",
- "package test;",
- "",
- GENERATED_ANNOTATION,
- "final class DaggerRoot implements Root {",
- " protected final class LeafImpl extends DaggerLeaf {",
- " private LeafImpl() {}",
- "",
- " @Override",
- " public String string1() {",
- " return RootModule_StringFactory.string();",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerRoot")
- .containsElementsIn(generatedRoot);
- }
-
- @Test
- public void boundInstanceUsedOnlyInInitialize() {
- JavaFileObject subcomponent =
- JavaFileObjects.forSourceLines(
- "test.Sub",
- "package test;",
- "",
- "import dagger.BindsInstance;",
- "import dagger.Subcomponent;",
- "import javax.inject.Provider;",
- "",
- "@Subcomponent",
- "interface Sub {",
- " Provider<String> stringProvider();",
- "",
- " @Subcomponent.Builder",
- " interface Builder {",
- " @BindsInstance",
- " Builder string(String string);",
- " Sub build();",
- " }",
- "}");
-
- JavaFileObject generated =
- JavaFileObjects.forSourceLines(
- "test.Sub",
- "package test;",
- "",
- "import dagger.internal.InstanceFactory;",
- "import dagger.internal.Preconditions;",
- IMPORT_GENERATED_ANNOTATION,
- "import javax.inject.Provider;",
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerSub implements Sub {",
- " private Provider<String> stringProvider;",
- "",
- " protected DaggerSub() {}",
- "",
- " protected void configureInitialization(String stringParam) {",
- " initialize(stringParam);",
- " }",
- "",
- " @SuppressWarnings(\"unchecked\")",
- " private void initialize(final String stringParam) {",
- " this.stringProvider = InstanceFactory.create(stringParam);",
- " }",
- "",
- " @Override",
- " public Provider<String> stringProvider() {",
- " return stringProvider;",
- " }",
- "}");
-
- Compilation compilation = compile(ImmutableList.of(subcomponent));
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerSub")
- .containsElementsIn(generated);
- }
-
- @Test
- public void packagePrivate_derivedFromFrameworkInstance_ComponentMethod() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.PackagePrivate",
- "package test;",
- "",
- "import dagger.Reusable;",
- "import javax.inject.Inject;",
- "",
- "@Reusable", // Use @Reusable to force a framework field
- "class PackagePrivate {",
- " @Inject PackagePrivate() {}",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent",
- "interface Leaf {",
- " PackagePrivate packagePrivate();",
- "}"));
-
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " private Provider<PackagePrivate> packagePrivateProvider;",
- "",
- " @Override",
- " public PackagePrivate packagePrivate() {",
- " return (PackagePrivate) getPackagePrivateProvider().get();",
- " }",
- "",
- " protected Provider getPackagePrivateProvider() {",
- " return packagePrivateProvider;",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .containsElementsIn(generatedLeaf);
- }
-
- @Test
- public void castModifiableMethodAccessedInFinalImplementation() {
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "PackagePrivate");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.PublicBaseType",
- "package test;",
- "", //
- "public class PublicBaseType {}"),
- JavaFileObjects.forSourceLines(
- "test.PackagePrivateSubtype",
- "package test;",
- "",
- "import javax.inject.Inject;",
- "",
- // Force this to be a modifiable binding resolved in the ancestor even though the
- // binding is requested in the leaf.
- "@AncestorScope",
- "class PackagePrivateSubtype extends PublicBaseType {",
- " @Inject PackagePrivateSubtype() {}",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.AncestorScope",
- "package test;",
- "",
- "import javax.inject.Scope;",
- "",
- "@Scope @interface AncestorScope {}"),
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.Binds;",
- "import dagger.BindsOptionalOf;",
- "import dagger.Module;",
- "",
- "@Module",
- "interface LeafModule {",
- " @Binds PublicBaseType publicBaseType(PackagePrivateSubtype subtype);",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.InjectsOptionalOfModifiable",
- "package test;",
- "",
- "import java.util.Optional;",
- "import javax.inject.Inject;",
- "",
- "class InjectsOptionalOfModifiable {",
- " @Inject InjectsOptionalOfModifiable(",
- " Optional<PublicBaseType> optionalOfModifiable) {}",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@Subcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " InjectsOptionalOfModifiable injectsOptionalOfModifiable();",
- "}"));
-
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf {",
- " protected abstract Optional<PublicBaseType> getOptionalOfPublicBaseType();",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .containsElementsIn(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.InjectsPackagePrivateSubtype",
- "package test;",
- "",
- "import java.util.Optional;",
- "import javax.inject.Inject;",
- "",
- "class InjectsPackagePrivateSubtype {",
- " @Inject InjectsPackagePrivateSubtype(",
- // Force a modifiable binding method for PackagePrivateSubtype in Ancestor. The
- // final Leaf implementation will refer to this method, but will need to cast it
- // since the PackagePrivateSubtype is accessible from the current package, but the
- // method returns Object
- " PackagePrivateSubtype packagePrivateSubtype) {}",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.AncestorModule",
- "package test;",
- "",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "interface AncestorModule {",
- " @Provides",
- " static PackagePrivateSubtype packagePrivateSubtype() {",
- " return new PackagePrivateSubtype();",
- " }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Ancestor",
- "package test;",
- "",
- "import dagger.Subcomponent;",
- "",
- "@AncestorScope",
- "@Subcomponent",
- "interface Ancestor {",
- " InjectsPackagePrivateSubtype injectsPackagePrivateSubtype();",
- " Leaf leaf();",
- "}"));
-
- JavaFileObject generatedAncestor =
- JavaFileObjects.forSourceLines(
- "test.DaggerAncestor",
- "package test;",
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerAncestor implements Ancestor {",
- " protected Object getPackagePrivateSubtype() {",
- " return getPackagePrivateSubtypeProvider().get();",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerAncestor")
- .containsElementsIn(generatedAncestor);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.RootModule",
- "package test;",
- "",
- "import dagger.BindsOptionalOf;",
- "import dagger.Module;",
- "",
- "@Module",
- "interface RootModule {",
- " @BindsOptionalOf",
- " PublicBaseType optionalPublicBaseType();",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Root",
- "package test;",
- "",
- "import dagger.Component;",
- "",
- "@Component(modules = RootModule.class)",
- "interface Root {",
- " Ancestor ancestor();",
- "}"));
-
- JavaFileObject generatedRoot =
- JavaFileObjects.forSourceLines(
- "test.DaggerRoot",
- "package test;",
- "",
- GENERATED_ANNOTATION,
- "final class DaggerRoot implements Root {",
- " protected final class AncestorImpl extends DaggerAncestor {",
- " protected final class LeafImpl extends DaggerAncestor.LeafImpl {",
- " @Override",
- " protected Optional<PublicBaseType> getOptionalOfPublicBaseType() {",
- " return Optional.of(",
- " (PublicBaseType) AncestorImpl.this.getPackagePrivateSubtype());",
- " }",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerRoot")
- .containsElementsIn(generatedRoot);
- }
-
- @Test
- public void injectInLeaf_ProductionInRoot() {
- // most of this is also covered in ProducesMethodShadowsInjectConstructorTest, but this test
- // asserts that the correct PrunedConcreteBindingExpression is used
- ImmutableList.Builder<JavaFileObject> filesToCompile = ImmutableList.builder();
- createSimplePackagePrivateClasses(filesToCompile, "Dependency", "Missing");
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.Injected",
- "package test;",
- "",
- "import javax.inject.Inject;",
- "",
- "class Injected {",
- " @Inject Injected(Dependency dependency, Missing missing) {}",
- "",
- " Injected(Dependency dependency) {}",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.LeafModule",
- "package test;",
- "",
- "import dagger.producers.ProducerModule;",
- "import dagger.producers.Produces;",
- "",
- "@ProducerModule",
- "interface LeafModule {",
- " @Produces",
- " static Object dependsOnInjectReplacedWithProduces(Injected injected) {",
- " return new Object();",
- " }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Leaf",
- "package test;",
- "",
- "import dagger.producers.Producer;",
- "import dagger.producers.ProductionSubcomponent;",
- "",
- "@ProductionSubcomponent(modules = LeafModule.class)",
- "interface Leaf {",
- " Producer<Object> objectProducer();",
- "}"));
-
- JavaFileObject generatedLeaf =
- JavaFileObjects.forSourceLines(
- "test.DaggerLeaf",
- "package test;",
- "",
- GENERATION_OPTIONS_ANNOTATION,
- GENERATED_ANNOTATION,
- "public abstract class DaggerLeaf implements Leaf, CancellationListener {",
- "",
- " @SuppressWarnings(\"unchecked\")",
- " private void initialize() {",
- " this.injectedProvider = Injected_Factory.create(",
- " getDependencyProvider(), getMissingProvider());",
- " this.injectedProducer = Producers.producerFromProvider(getInjectedProvider());",
- " this.dependsOnInjectReplacedWithProducesProducer =",
- " LeafModule_DependsOnInjectReplacedWithProducesFactory.create(",
- " getProductionImplementationExecutorProvider(),",
- " getProductionComponentMonitorProvider(),",
- " getInjectedProducer());",
- " this.objectProducerEntryPoint =",
- " Producers.entryPointViewOf(",
- " dependsOnInjectReplacedWithProducesProducer, this);",
- " }",
- "",
- " protected abstract Provider getDependencyProvider();",
- " protected abstract Provider getMissingProvider();",
- "",
- " protected Provider getInjectedProvider() {",
- " return injectedProvider;",
- " }",
- "",
- " protected Producer getInjectedProducer() {",
- " return injectedProducer;",
- " }",
- "}");
- Compilation compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerLeaf")
- .containsElementsIn(generatedLeaf);
-
- filesToCompile.add(
- JavaFileObjects.forSourceLines(
- "test.RootModule",
- "package test;",
- "",
- "import com.google.common.util.concurrent.MoreExecutors;",
- "import dagger.Provides;",
- "import dagger.producers.ProducerModule;",
- "import dagger.producers.Produces;",
- "import dagger.producers.Production;",
- "import java.util.concurrent.Executor;",
- "",
- "@ProducerModule",
- "interface RootModule {",
- " @Produces",
- " static Injected replaceInjectWithProduces(Dependency dependency) {",
- " return new Injected(dependency);",
- " }",
- "",
- " @Produces",
- " static Dependency dependency() {",
- " return new Dependency();",
- " }",
- "",
- " @Provides",
- " @Production",
- " static Executor executor() {",
- " return MoreExecutors.directExecutor();",
- " }",
- "}"),
- JavaFileObjects.forSourceLines(
- "test.Root",
- "package test;",
- "",
- "import dagger.producers.ProductionComponent;",
- "",
- "@ProductionComponent(modules = RootModule.class)",
- "interface Root {",
- " Leaf leaf();",
- "}"));
-
- JavaFileObject generatedRoot =
- JavaFileObjects.forSourceLines(
- "test.DaggerRoot",
- "package test;",
- "",
- GENERATED_ANNOTATION,
- "final class DaggerRoot implements Root, CancellationListener {",
- " private Producer<Dependency> dependencyProducer;",
- " private Producer<Injected> replaceInjectWithProducesProducer;",
- "",
- " @SuppressWarnings(\"unchecked\")",
- " private void initialize() {",
- " this.productionImplementationExecutorProvider =",
- " DoubleCheck.provider((Provider) RootModule_ExecutorFactory.create());",
- " this.rootProvider = InstanceFactory.create((Root) this);",
- " this.monitorProvider =",
- " DoubleCheck.provider(",
- " Root_MonitoringModule_MonitorFactory.create(",
- " rootProvider,",
- " SetFactory.<ProductionComponentMonitor.Factory>empty()));",
- " this.dependencyProducer =",
- " RootModule_DependencyFactory.create(",
- " productionImplementationExecutorProvider, monitorProvider);",
- " this.replaceInjectWithProducesProducer =",
- " RootModule_ReplaceInjectWithProducesFactory.create(",
- " productionImplementationExecutorProvider,",
- " monitorProvider,",
- " dependencyProducer);",
- " }",
- "",
- " protected final class LeafImpl extends DaggerLeaf",
- " implements CancellationListener {",
- " @Override",
- " protected Provider getDependencyProvider() {",
- " return MissingBindingFactory.create();",
- " }",
- "",
- " @Override",
- " protected Provider getMissingProvider() {",
- " return MissingBindingFactory.create();",
- " }",
- "",
- " @Override",
- " protected Producer getInjectedProducer() {",
- " return DaggerRoot.this.replaceInjectWithProducesProducer;",
- " }",
- " }",
- "}");
- compilation = compile(filesToCompile.build());
- assertThat(compilation).succeededWithoutWarnings();
- assertThat(compilation)
- .generatedSourceFile("test.DaggerRoot")
- .containsElementsIn(generatedRoot);
- }
-
- // TODO(ronshapiro): remove copies from AheadOfTimeSubcomponents*Test classes
- private void createSimplePackagePrivateClasses(
- ImmutableList.Builder<JavaFileObject> filesBuilder, String... ancillaryClasses) {
- for (String className : ancillaryClasses) {
- filesBuilder.add(
- JavaFileObjects.forSourceLines(
- String.format("test.%s", className),
- "package test;",
- "",
- String.format("class %s { }", className)));
- }
- }
-
- private static Compilation compile(Iterable<JavaFileObject> files, CompilerMode... modes) {
- return compilerWithOptions(
- ObjectArrays.concat(
- new CompilerMode[] {AHEAD_OF_TIME_SUBCOMPONENTS_MODE}, modes, CompilerMode.class))
- .compile(files);
- }
-}
diff --git a/javatests/dagger/internal/codegen/AnnotationProtoConverterTest.java b/javatests/dagger/internal/codegen/AnnotationProtoConverterTest.java
deleted file mode 100644
index fda5859..0000000
--- a/javatests/dagger/internal/codegen/AnnotationProtoConverterTest.java
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Copyright (C) 2019 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.collect.Iterables.getOnlyElement;
-import static com.google.common.truth.Truth.assertThat;
-
-import com.google.auto.common.AnnotationMirrors;
-import com.google.testing.compile.CompilationRule;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import javax.lang.model.element.AnnotationMirror;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/** Tests {@link TypeProtoConverter}. */
-@RunWith(JUnit4.class)
-public class AnnotationProtoConverterTest {
- @Rule public CompilationRule compilationRule = new CompilationRule();
-
- private DaggerElements elements;
- private DaggerTypes types;
- private AnnotationProtoConverter annotationProtoConverter;
-
- @Before
- public void setUp() {
- this.elements = new DaggerElements(compilationRule.getElements(), compilationRule.getTypes());
- this.types = new DaggerTypes(compilationRule.getTypes(), elements);
- this.annotationProtoConverter =
- new AnnotationProtoConverter(new TypeProtoConverter(types, elements));
- }
-
- @Retention(RetentionPolicy.RUNTIME)
- @interface TestAnnotation {
- byte b();
- boolean bool();
- short s();
- char c();
- int i();
- long l();
- double d();
- float f();
-
- String string();
- RetentionPolicy enumValue();
- Class<?> classValue();
- HasDefaults[] nestedAnnotations();
- }
-
- @Retention(RetentionPolicy.RUNTIME)
- @interface HasDefaults {
- int value() default 2;
- }
-
- @TestAnnotation(
- b = 1,
- bool = true,
- s = 2,
- c = 'c',
- i = 4,
- l = 5,
- d = 6.0d,
- f = 7.0f,
- string = "hello, world",
- enumValue = RetentionPolicy.CLASS,
- classValue = AnnotationProtoConverter.class,
- nestedAnnotations = {@HasDefaults, @HasDefaults(8)})
- static class TestSubject {}
-
- @Test
- public void conversion() {
- AnnotationMirror actual =
- getOnlyElement(elements.getTypeElement(TestSubject.class).getAnnotationMirrors());
- AnnotationMirror translated =
- annotationProtoConverter.fromProto(AnnotationProtoConverter.toProto(actual));
- assertThat(AnnotationMirrors.equivalence().equivalent(actual, translated)).isTrue();
- }
-}
diff --git a/javatests/dagger/internal/codegen/AssistedErrorsTest.java b/javatests/dagger/internal/codegen/AssistedErrorsTest.java
new file mode 100644
index 0000000..bf61412
--- /dev/null
+++ b/javatests/dagger/internal/codegen/AssistedErrorsTest.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen;
+
+import static com.google.testing.compile.CompilationSubject.assertThat;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
+
+import com.google.common.collect.ImmutableCollection;
+import com.google.testing.compile.Compilation;
+import com.google.testing.compile.JavaFileObjects;
+import javax.tools.JavaFileObject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class AssistedErrorsTest {
+ @Parameters(name = "{0}")
+ public static ImmutableCollection<Object[]> parameters() {
+ return CompilerMode.TEST_PARAMETERS;
+ }
+
+ private final CompilerMode compilerMode;
+
+ public AssistedErrorsTest(CompilerMode compilerMode) {
+ this.compilerMode = compilerMode;
+ }
+
+ @Test
+ public void testAssistedNotWithAssistedInjectionConstructor() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.Foo",
+ "package test;",
+ "",
+ "import dagger.assisted.Assisted;",
+ "",
+ "final class Foo {",
+ " Foo(",
+ " @Assisted String str",
+ " ) {}",
+ "",
+ " void someMethod(",
+ " @Assisted int i",
+ " ) {}",
+ "}");
+ Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(foo);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(2);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@Assisted parameters can only be used within an @AssistedInject-annotated constructor")
+ .inFile(foo)
+ .onLine(7);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@Assisted parameters can only be used within an @AssistedInject-annotated constructor")
+ .inFile(foo)
+ .onLine(11);
+ }
+
+ @Test
+ public void testNestedFactoryNotStatic() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.Foo",
+ "package test;",
+ "",
+ "import dagger.assisted.Assisted;",
+ "import dagger.assisted.AssistedInject;",
+ "import javax.inject.Qualifier;",
+ "",
+ "class Foo {",
+ " @Qualifier @interface FooQualifier {}",
+ "",
+ " @AssistedInject",
+ " Foo(",
+ " @FooQualifier @Assisted int i",
+ " ) {}",
+ "}");
+ Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(foo);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining("Qualifiers cannot be used with @Assisted parameters.")
+ .inFile(foo)
+ .onLine(12);
+ }
+}
diff --git a/javatests/dagger/internal/codegen/AssistedFactoryErrorsTest.java b/javatests/dagger/internal/codegen/AssistedFactoryErrorsTest.java
new file mode 100644
index 0000000..2bcfedc
--- /dev/null
+++ b/javatests/dagger/internal/codegen/AssistedFactoryErrorsTest.java
@@ -0,0 +1,839 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen;
+
+import static com.google.testing.compile.CompilationSubject.assertThat;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
+
+import com.google.common.collect.ImmutableCollection;
+import com.google.testing.compile.Compilation;
+import com.google.testing.compile.JavaFileObjects;
+import javax.tools.JavaFileObject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class AssistedFactoryErrorsTest {
+ @Parameters(name = "{0}")
+ public static ImmutableCollection<Object[]> parameters() {
+ return CompilerMode.TEST_PARAMETERS;
+ }
+
+ private final CompilerMode compilerMode;
+
+ public AssistedFactoryErrorsTest(CompilerMode compilerMode) {
+ this.compilerMode = compilerMode;
+ }
+
+ @Test
+ public void testFactoryNotAbstract() {
+ JavaFileObject factory =
+ JavaFileObjects.forSourceLines(
+ "test.Factory",
+ "package test;",
+ "",
+ "import dagger.assisted.AssistedFactory;",
+ "",
+ "@AssistedFactory class Factory {}");
+ Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(factory);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "The @AssistedFactory-annotated type must be either an abstract class or interface.");
+ }
+
+ @Test
+ public void testNestedFactoryNotStatic() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.Foo",
+ "package test;",
+ "",
+ "import dagger.assisted.Assisted;",
+ "import dagger.assisted.AssistedInject;",
+ "import dagger.assisted.AssistedFactory;",
+ "",
+ "class Foo {",
+ " @AssistedInject",
+ " Foo(@Assisted int i) {}",
+ "",
+ " @AssistedFactory",
+ " abstract class Factory {",
+ " abstract Foo create(int i);",
+ " }",
+ "}");
+ Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(foo);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining("Nested @AssistedFactory-annotated types must be static.");
+ }
+
+ @Test
+ public void testFactoryMissingAbstractMethod() {
+ JavaFileObject factory =
+ JavaFileObjects.forSourceLines(
+ "test.Factory",
+ "package test;",
+ "",
+ "import dagger.assisted.AssistedFactory;",
+ "",
+ "@AssistedFactory interface Factory {}");
+ Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(factory);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "The @AssistedFactory-annotated type is missing an abstract, non-default method whose"
+ + " return type matches the assisted injection type.");
+ }
+
+ @Test
+ public void testFactoryReturnsNonDeclaredType() {
+ JavaFileObject noInject =
+ JavaFileObjects.forSourceLines(
+ "test.NoInject", "package test;", "", "final class NoInject {}");
+ JavaFileObject noAssistedParam =
+ JavaFileObjects.forSourceLines(
+ "test.NoAssistedParam",
+ "package test;",
+ "",
+ "import dagger.assisted.AssistedInject;",
+ "",
+ "final class NoAssistedParam {",
+ " @AssistedInject NoAssistedParam() {}",
+ "}");
+ JavaFileObject factory =
+ JavaFileObjects.forSourceLines(
+ "test.Factory",
+ "package test;",
+ "",
+ "import dagger.assisted.AssistedFactory;",
+ "",
+ "@AssistedFactory",
+ "interface Factory<T> {",
+ " int createInt();", // Fails return type not @AssistedInject
+ "",
+ " NoInject createNoInject();", // Fails return type not @AssistedInject
+ "",
+ " NoAssistedParam createNoAssistedParam();", // Succeeds
+ "",
+ " T createT();", // Fails return type not @AssistedInject
+ "}");
+ Compilation compilation =
+ compilerWithOptions(compilerMode.javacopts()).compile(factory, noInject, noAssistedParam);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(4);
+
+ assertThat(compilation)
+ .hadErrorContaining(
+ "The @AssistedFactory-annotated type should contain a single abstract, non-default "
+ + "method but found multiple: ["
+ + "createInt(), createNoInject(), createNoAssistedParam(), createT()]")
+ .inFile(factory)
+ .onLine(6);
+
+ assertThat(compilation)
+ .hadErrorContaining(
+ "Invalid return type: int. "
+ + "An assisted factory's abstract method must return a type with an "
+ + "@AssistedInject-annotated constructor.")
+ .inFile(factory)
+ .onLine(7);
+
+ assertThat(compilation)
+ .hadErrorContaining(
+ "Invalid return type: test.NoInject. "
+ + "An assisted factory's abstract method must return a type with an "
+ + "@AssistedInject-annotated constructor.")
+ .inFile(factory)
+ .onLine(9);
+
+ assertThat(compilation)
+ .hadErrorContaining(
+ "Invalid return type: T. "
+ + "An assisted factory's abstract method must return a type with an "
+ + "@AssistedInject-annotated constructor.")
+ .inFile(factory)
+ .onLine(13);
+ }
+
+ @Test
+ public void testFactoryMultipleAbstractMethods() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.Foo",
+ "package test;",
+ "",
+ "import dagger.assisted.Assisted;",
+ "import dagger.assisted.AssistedInject;",
+ "",
+ "class Foo {",
+ " @AssistedInject Foo(@Assisted int i) {}",
+ "}");
+
+ JavaFileObject fooFactoryInterface =
+ JavaFileObjects.forSourceLines(
+ "test.FooFactoryInterface",
+ "package test;",
+ "",
+ "interface FooFactoryInterface {",
+ " Foo createFoo1(int i);",
+ "}");
+
+ JavaFileObject fooFactory =
+ JavaFileObjects.forSourceLines(
+ "test.FooFactory",
+ "package test;",
+ "",
+ "import dagger.assisted.AssistedFactory;",
+ "",
+ "@AssistedFactory",
+ "interface FooFactory extends FooFactoryInterface {",
+ " Foo createFoo2(int i);",
+ "",
+ " Foo createFoo3(int i);",
+ "}");
+
+ Compilation compilation =
+ compilerWithOptions(compilerMode.javacopts()).compile(foo, fooFactory, fooFactoryInterface);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "The @AssistedFactory-annotated type should contain a single abstract, non-default "
+ + "method but found multiple: [createFoo1(int), createFoo2(int), createFoo3(int)]");
+ }
+
+ @Test
+ public void testFactoryMismatchingParameter() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.Foo",
+ "package test;",
+ "",
+ "import dagger.assisted.Assisted;",
+ "import dagger.assisted.AssistedInject;",
+ "",
+ "class Foo {",
+ " @AssistedInject Foo(@Assisted int i) {}",
+ "}");
+
+ JavaFileObject fooFactory =
+ JavaFileObjects.forSourceLines(
+ "test.FooFactory",
+ "package test;",
+ "",
+ "import dagger.assisted.AssistedFactory;",
+ "",
+ "@AssistedFactory",
+ "interface FooFactory {",
+ " Foo create(String i);",
+ "}");
+ Compilation compilation =
+ compilerWithOptions(compilerMode.javacopts()).compile(foo, fooFactory);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "The parameters in the factory method must match the @Assisted parameters in "
+ + "test.Foo.\n"
+ + " Actual: test.FooFactory#create(java.lang.String)\n"
+ + " Expected: test.FooFactory#create(int)");
+ }
+
+ @Test
+ public void testFactoryMismatchingGenericParameter() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.Foo",
+ "package test;",
+ "",
+ "import dagger.assisted.Assisted;",
+ "import dagger.assisted.AssistedInject;",
+ "",
+ "class Foo<T> {",
+ " @AssistedInject Foo(@Assisted T t) {}",
+ "}");
+
+ JavaFileObject fooFactory =
+ JavaFileObjects.forSourceLines(
+ "test.FooFactory",
+ "package test;",
+ "",
+ "import dagger.assisted.AssistedFactory;",
+ "",
+ "@AssistedFactory",
+ "interface FooFactory<T> {",
+ " Foo<T> create(String str);",
+ "}");
+ Compilation compilation =
+ compilerWithOptions(compilerMode.javacopts()).compile(foo, fooFactory);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "The parameters in the factory method must match the @Assisted parameters in "
+ + "test.Foo<T>.\n"
+ + " Actual: test.FooFactory#create(java.lang.String)\n"
+ + " Expected: test.FooFactory#create(T)");
+ }
+
+ @Test
+ public void testFactoryDuplicateGenericParameter() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.Foo",
+ "package test;",
+ "",
+ "import dagger.assisted.Assisted;",
+ "import dagger.assisted.AssistedInject;",
+ "",
+ "class Foo<T> {",
+ " @AssistedInject Foo(@Assisted String str, @Assisted T t) {}",
+ "}");
+
+ JavaFileObject fooFactory =
+ JavaFileObjects.forSourceLines(
+ "test.FooFactory",
+ "package test;",
+ "",
+ "import dagger.assisted.AssistedFactory;",
+ "",
+ "@AssistedFactory",
+ "interface FooFactory {",
+ " Foo<String> create(String str1, String str2);",
+ "}");
+ Compilation compilation =
+ compilerWithOptions(compilerMode.javacopts()).compile(foo, fooFactory);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@AssistedFactory method has duplicate @Assisted types: @Assisted java.lang.String");
+ }
+
+ @Test
+ public void testAssistedInjectionRequest() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.Foo",
+ "package test;",
+ "",
+ "import dagger.assisted.Assisted;",
+ "import dagger.assisted.AssistedInject;",
+ "",
+ "class Foo {",
+ " @AssistedInject Foo(@Assisted String str) {}",
+ "}");
+
+ JavaFileObject bar =
+ JavaFileObjects.forSourceLines(
+ "test.Bar",
+ "package test;",
+ "",
+ "import javax.inject.Inject;",
+ "import javax.inject.Provider;",
+ "",
+ "class Bar {",
+ " @Inject",
+ " Bar(Foo foo, Provider<Foo> fooProvider) {}",
+ "}");
+
+ JavaFileObject module =
+ JavaFileObjects.forSourceLines(
+ "test.FooModule",
+ "package test;",
+ "",
+ "import dagger.Module;",
+ "import dagger.Provides;",
+ "import javax.inject.Provider;",
+ "",
+ "@Module",
+ "class FooModule {",
+ " @Provides",
+ " static int provideInt(Foo foo, Provider<Foo> fooProvider) {",
+ " return 0;",
+ " }",
+ "}");
+
+ JavaFileObject component =
+ JavaFileObjects.forSourceLines(
+ "test.FooComponent",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "import javax.inject.Provider;",
+ "",
+ "@Component",
+ "interface FooComponent {",
+ " Foo foo();",
+ "",
+ " Provider<Foo> fooProvider();",
+ "}");
+
+ Compilation compilation =
+ compilerWithOptions(compilerMode.javacopts()).compile(foo, bar, module, component);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(6);
+
+ String fooError =
+ "Dagger does not support injecting @AssistedInject type, test.Foo. "
+ + "Did you mean to inject its assisted factory type instead?";
+ assertThat(compilation).hadErrorContaining(fooError).inFile(bar).onLine(8);
+ assertThat(compilation).hadErrorContaining(fooError).inFile(module).onLine(10);
+ assertThat(compilation).hadErrorContaining(fooError).inFile(component).onLine(8);
+
+ String fooProviderError =
+ "Dagger does not support injecting @AssistedInject type, javax.inject.Provider<test.Foo>. "
+ + "Did you mean to inject its assisted factory type instead?";
+ assertThat(compilation).hadErrorContaining(fooProviderError).inFile(bar).onLine(8);
+ assertThat(compilation).hadErrorContaining(fooProviderError).inFile(module).onLine(10);
+ assertThat(compilation).hadErrorContaining(fooProviderError).inFile(component).onLine(10);
+ }
+
+ @Test
+ public void testProvidesAssistedBindings() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.Foo",
+ "package test;",
+ "",
+ "import dagger.assisted.Assisted;",
+ "import dagger.assisted.AssistedInject;",
+ "import dagger.assisted.AssistedFactory;",
+ "",
+ "class Foo {",
+ " @AssistedInject Foo(@Assisted int i) {}",
+ "",
+ " @AssistedFactory",
+ " interface Factory {",
+ " Foo create(int i);",
+ " }",
+ "}");
+
+ JavaFileObject module =
+ JavaFileObjects.forSourceLines(
+ "test.FooModule",
+ "package test;",
+ "",
+ "import dagger.Module;",
+ "import dagger.Provides;",
+ "import javax.inject.Provider;",
+ "",
+ "@Module",
+ "class FooModule {",
+ " @Provides",
+ " static Foo provideFoo() {",
+ " return null;",
+ " }",
+ "",
+ " @Provides",
+ " static Foo.Factory provideFooFactory() {",
+ " return null;",
+ " }",
+ "}");
+
+ Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(foo, module);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(2);
+ assertThat(compilation)
+ .hadErrorContaining("[test.Foo] Dagger does not support providing @AssistedInject types.")
+ .inFile(module)
+ .onLine(10);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "[test.Foo.Factory] Dagger does not support providing @AssistedFactory types.")
+ .inFile(module)
+ .onLine(15);
+ }
+
+ @Test
+ public void testProvidesAssistedBindingsAsFactoryBindsInstance() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.Foo",
+ "package test;",
+ "",
+ "import dagger.assisted.Assisted;",
+ "import dagger.assisted.AssistedInject;",
+ "import dagger.assisted.AssistedFactory;",
+ "",
+ "class Foo {",
+ " @AssistedInject Foo(@Assisted int i) {}",
+ "",
+ " @AssistedFactory",
+ " interface Factory {",
+ " Foo create(int i);",
+ " }",
+ "}");
+
+ JavaFileObject component =
+ JavaFileObjects.forSourceLines(
+ "test.FooComponent",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "import dagger.BindsInstance;",
+ "",
+ "@Component",
+ "interface FooComponent {",
+ " @Component.Factory",
+ " interface Factory {",
+ " FooComponent create(",
+ " @BindsInstance Foo foo,",
+ " @BindsInstance Foo.Factory fooFactory);",
+ " }",
+ "}");
+
+ Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(foo, component);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(2);
+ assertThat(compilation)
+ .hadErrorContaining("[test.Foo] Dagger does not support providing @AssistedInject types.")
+ .inFile(component)
+ .onLine(11);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "[test.Foo.Factory] Dagger does not support providing @AssistedFactory types.")
+ .inFile(component)
+ .onLine(12);
+ }
+
+ @Test
+ public void testProvidesAssistedBindingsAsBuilderBindsInstance() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.Foo",
+ "package test;",
+ "",
+ "import dagger.assisted.Assisted;",
+ "import dagger.assisted.AssistedInject;",
+ "import dagger.assisted.AssistedFactory;",
+ "",
+ "class Foo {",
+ " @AssistedInject Foo(@Assisted int i) {}",
+ "",
+ " @AssistedFactory",
+ " interface Factory {",
+ " Foo create(int i);",
+ " }",
+ "}");
+
+ JavaFileObject component =
+ JavaFileObjects.forSourceLines(
+ "test.FooComponent",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "import dagger.BindsInstance;",
+ "",
+ "@Component",
+ "interface FooComponent {",
+ " @Component.Builder",
+ " interface Builder {",
+ " @BindsInstance Builder foo(Foo foo);",
+ " @BindsInstance Builder fooFactory(Foo.Factory fooFactory);",
+ " FooComponent build();",
+ " }",
+ "}");
+
+ Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(foo, component);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(2);
+ assertThat(compilation)
+ .hadErrorContaining("[test.Foo] Dagger does not support providing @AssistedInject types.")
+ .inFile(component)
+ .onLine(10);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "[test.Foo.Factory] Dagger does not support providing @AssistedFactory types.")
+ .inFile(component)
+ .onLine(11);
+ }
+
+ @Test
+ public void testInjectsProviderOfAssistedFactory() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.Foo",
+ "package test;",
+ "",
+ "import dagger.assisted.Assisted;",
+ "import dagger.assisted.AssistedInject;",
+ "import dagger.assisted.AssistedFactory;",
+ "",
+ "class Foo {",
+ " @AssistedInject Foo(@Assisted int i) {}",
+ "",
+ " @AssistedFactory",
+ " interface Factory {",
+ " Foo create(int i);",
+ " }",
+ "}");
+
+ JavaFileObject bar =
+ JavaFileObjects.forSourceLines(
+ "test.Bar",
+ "package test;",
+ "",
+ "import javax.inject.Inject;",
+ "import javax.inject.Provider;",
+ "",
+ "class Bar {",
+ " @Inject",
+ " Bar(Foo.Factory fooFactory, Provider<Foo.Factory> fooFactoryProvider) {}",
+ "}");
+
+ Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(foo, bar);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "Dagger does not support injecting Provider<T>, Lazy<T>, Producer<T>, or Produced<T> "
+ + "when T is an @AssistedFactory-annotated type such as test.Foo.Factory")
+ .inFile(bar)
+ .onLine(8);
+ }
+
+ @Test
+ public void testScopedAssistedInjection() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.Foo",
+ "package test;",
+ "",
+ "import dagger.assisted.Assisted;",
+ "import dagger.assisted.AssistedInject;",
+ "import dagger.assisted.AssistedFactory;",
+ "import javax.inject.Singleton;",
+ "",
+ "@Singleton",
+ "class Foo {",
+ " @AssistedInject",
+ " Foo(@Assisted int i) {}",
+ "",
+ " @AssistedFactory",
+ " interface Factory {",
+ " Foo create(int i);",
+ " }",
+ "}");
+
+ Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(foo);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining("A type with an @AssistedInject-annotated constructor cannot be scoped")
+ .inFile(foo)
+ .onLine(8);
+ }
+
+ @Test
+ public void testMultipleInjectAnnotations() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.Foo",
+ "package test;",
+ "",
+ "import dagger.assisted.Assisted;",
+ "import dagger.assisted.AssistedInject;",
+ "import javax.inject.Inject;",
+ "",
+ "class Foo {",
+ " @Inject",
+ " @AssistedInject",
+ " Foo(@Assisted int i) {}",
+ "}");
+
+ Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(foo);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "Constructors cannot be annotated with both @Inject and @AssistedInject");
+ }
+
+ @Test
+ public void testAssistedInjectNotOnConstructor() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.Foo",
+ "package test;",
+ "",
+ "import dagger.assisted.AssistedInject;",
+ "",
+ "class Foo {",
+ " @AssistedInject",
+ " void someMethod() {}",
+ "}");
+
+ Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(foo);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+
+ // Note: this isn't actually a Dagger error, it's a javac error since @AssistedInject only
+ // targets constructors. However, it's good to have this test in case that ever changes.
+ assertThat(compilation)
+ .hadErrorContaining("annotation type not applicable to this kind of declaration")
+ .inFile(foo)
+ .onLine(6);
+ }
+
+ @Test
+ public void testAssistedInjectWithNoAssistedParametersIsNotInjectable() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.Foo",
+ "package test;",
+ "",
+ "import javax.inject.Inject;",
+ "",
+ "class Foo {",
+ " @Inject",
+ " Foo(Bar bar) {}",
+ "}");
+
+ JavaFileObject bar =
+ JavaFileObjects.forSourceLines(
+ "test.Bar",
+ "package test;",
+ "",
+ "import dagger.assisted.AssistedInject;",
+ "import javax.inject.Inject;",
+ "",
+ "class Bar {",
+ " @AssistedInject",
+ " Bar() {}",
+ "}");
+
+ JavaFileObject component =
+ JavaFileObjects.forSourceLines(
+ "test.FooComponent",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "",
+ "@Component",
+ "interface FooComponent {",
+ " Foo foo();",
+ "}");
+
+ Compilation compilation =
+ compilerWithOptions(compilerMode.javacopts()).compile(foo, bar, component);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(2);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "Dagger does not support injecting @AssistedInject type, test.Bar. "
+ + "Did you mean to inject its assisted factory type instead?")
+ .inFile(foo)
+ .onLine(7);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "\033[1;31m[Dagger/MissingBinding]\033[0m "
+ + "Foo cannot be provided without an @Inject constructor or an @Provides-annotated "
+ + "method.");
+ }
+
+ @Test
+ public void testInaccessibleFoo() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.subpackage.InaccessibleFoo",
+ "package test.subpackage;",
+ "",
+ "import dagger.assisted.Assisted;",
+ "import dagger.assisted.AssistedInject;",
+ "",
+ "class InaccessibleFoo {",
+ " @AssistedInject InaccessibleFoo(@Assisted int i) {}",
+ "}");
+
+ JavaFileObject fooFactory =
+ JavaFileObjects.forSourceLines(
+ "test.subpackage.InaccessibleFooFactory",
+ "package test.subpackage;",
+ "",
+ "import dagger.assisted.AssistedFactory;",
+ "",
+ "@AssistedFactory",
+ "public interface InaccessibleFooFactory {",
+ " InaccessibleFoo create(int i);",
+ "}");
+
+ JavaFileObject component =
+ JavaFileObjects.forSourceLines(
+ "test.FooFactoryComponent",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "import test.subpackage.InaccessibleFooFactory;",
+ "",
+ "@Component",
+ "interface FooFactoryComponent {",
+ " InaccessibleFooFactory inaccessibleFooFactory();",
+ "}");
+
+ Compilation compilation =
+ compilerWithOptions(compilerMode.javacopts()).compile(foo, fooFactory, component);
+
+ if (compilerMode == CompilerMode.FAST_INIT_MODE) {
+ // TODO(bcorso): Remove once we fix inaccessible assisted factory imlementation for fastInit.
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "test.subpackage.InaccessibleFoo is not public in test.subpackage; cannot be "
+ + "accessed from outside package");
+ } else {
+ assertThat(compilation).succeeded();
+ }
+ }
+
+ @Test
+ public void testAssistedFactoryMethodWithTypeParametersFails() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.Foo",
+ "package test;",
+ "",
+ "import dagger.assisted.AssistedInject;",
+ "import dagger.assisted.AssistedFactory;",
+ "",
+ "class Foo<T> {",
+ " @AssistedInject",
+ " Foo() {}",
+ "",
+ " @AssistedFactory",
+ " interface FooFactory {",
+ " <T> Foo<T> create();",
+ " }",
+ "}");
+
+ Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(foo);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@AssistedFactory does not currently support type parameters in the creator method.")
+ .inFile(foo)
+ .onLine(12);
+ }
+}
diff --git a/javatests/dagger/internal/codegen/AssistedFactoryTest.java b/javatests/dagger/internal/codegen/AssistedFactoryTest.java
new file mode 100644
index 0000000..d752321
--- /dev/null
+++ b/javatests/dagger/internal/codegen/AssistedFactoryTest.java
@@ -0,0 +1,247 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen;
+
+import static com.google.testing.compile.CompilationSubject.assertThat;
+import static dagger.internal.codegen.CompilerMode.DEFAULT_MODE;
+import static dagger.internal.codegen.CompilerMode.FAST_INIT_MODE;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
+import static dagger.internal.codegen.GeneratedLines.GENERATED_CODE_ANNOTATIONS;
+
+import com.google.common.collect.ImmutableCollection;
+import com.google.testing.compile.Compilation;
+import com.google.testing.compile.JavaFileObjects;
+import javax.tools.JavaFileObject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class AssistedFactoryTest {
+ @Parameters(name = "{0}")
+ public static ImmutableCollection<Object[]> parameters() {
+ return CompilerMode.TEST_PARAMETERS;
+ }
+
+ private final CompilerMode compilerMode;
+
+ public AssistedFactoryTest(CompilerMode compilerMode) {
+ this.compilerMode = compilerMode;
+ }
+
+ @Test
+ public void testAssistedFactory() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.Foo",
+ "package test;",
+ "",
+ "import dagger.assisted.Assisted;",
+ "import dagger.assisted.AssistedInject;",
+ "",
+ "class Foo {",
+ " @AssistedInject",
+ " Foo(@Assisted String str, Bar bar) {}",
+ "}");
+ JavaFileObject fooFactory =
+ JavaFileObjects.forSourceLines(
+ "test.FooFactory",
+ "package test;",
+ "",
+ "import dagger.assisted.AssistedFactory;",
+ "",
+ "@AssistedFactory",
+ "interface FooFactory {",
+ " Foo create(String factoryStr);",
+ "}");
+ JavaFileObject bar =
+ JavaFileObjects.forSourceLines(
+ "test.Bar",
+ "package test;",
+ "",
+ "import javax.inject.Inject;",
+ "",
+ "class Bar {",
+ " @Inject Bar() {}",
+ "}");
+ JavaFileObject component =
+ JavaFileObjects.forSourceLines(
+ "test.TestComponent",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "",
+ "@Component",
+ "interface TestComponent {",
+ " FooFactory fooFactory();",
+ "}");
+ Compilation compilation =
+ compilerWithOptions(compilerMode.javacopts()).compile(foo, bar, fooFactory, component);
+ assertThat(compilation).succeeded();
+ JavaFileObject generatedComponent =
+ compilerMode
+ .javaFileBuilder("test.DaggerTestComponent")
+ .addLines("package test;", "", GENERATED_CODE_ANNOTATIONS)
+ .addLinesIn(
+ FAST_INIT_MODE,
+ "final class DaggerTestComponent implements TestComponent {",
+ "",
+ " private Foo foo(String str) {",
+ " return new Foo(str, new Bar());",
+ " }",
+ "",
+ " @Override",
+ " public FooFactory fooFactory() {",
+ " return new FooFactory() {",
+ " @Override",
+ " public Foo create(String str) {",
+ " return DaggerTestComponent.this.foo(str);",
+ " }",
+ " };",
+ " }",
+ "}")
+ .addLinesIn(
+ DEFAULT_MODE,
+ "final class DaggerTestComponent implements TestComponent {",
+ "",
+ " private Foo_Factory fooProvider;",
+ "",
+ " private Provider<FooFactory> fooFactoryProvider;",
+ "",
+ " @SuppressWarnings(\"unchecked\")",
+ " private void initialize() {",
+ " this.fooProvider = Foo_Factory.create(Bar_Factory.create());",
+ " this.fooFactoryProvider = FooFactory_Impl.create(fooProvider);",
+ " }",
+ "",
+ " @Override",
+ " public FooFactory fooFactory() {",
+ " return fooFactoryProvider.get();",
+ " }",
+ "}")
+ .build();
+ assertThat(compilation)
+ .generatedSourceFile("test.DaggerTestComponent")
+ .containsElementsIn(generatedComponent);
+ }
+
+ @Test
+ public void testAssistedFactoryCycle() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.Foo",
+ "package test;",
+ "",
+ "import dagger.assisted.Assisted;",
+ "import dagger.assisted.AssistedInject;",
+ "",
+ "class Foo {",
+ " @AssistedInject",
+ " Foo(@Assisted String str, Bar bar) {}",
+ "}");
+ JavaFileObject fooFactory =
+ JavaFileObjects.forSourceLines(
+ "test.FooFactory",
+ "package test;",
+ "",
+ "import dagger.assisted.AssistedFactory;",
+ "",
+ "@AssistedFactory",
+ "interface FooFactory {",
+ " Foo create(String factoryStr);",
+ "}");
+ JavaFileObject bar =
+ JavaFileObjects.forSourceLines(
+ "test.Bar",
+ "package test;",
+ "",
+ "import javax.inject.Inject;",
+ "",
+ "class Bar {",
+ " @Inject Bar(FooFactory fooFactory) {}",
+ "}");
+ JavaFileObject component =
+ JavaFileObjects.forSourceLines(
+ "test.TestComponent",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "",
+ "@Component",
+ "interface TestComponent {",
+ " FooFactory fooFactory();",
+ "}");
+ Compilation compilation =
+ compilerWithOptions(compilerMode.javacopts()).compile(foo, bar, fooFactory, component);
+ assertThat(compilation).succeeded();
+ JavaFileObject generatedComponent =
+ compilerMode
+ .javaFileBuilder("test.DaggerTestComponent")
+ .addLines("package test;", "", GENERATED_CODE_ANNOTATIONS)
+ .addLinesIn(
+ FAST_INIT_MODE,
+ "final class DaggerTestComponent implements TestComponent {",
+ "",
+ " private Bar bar() {",
+ " return new Bar(fooFactory());",
+ " }",
+ "",
+ " private Foo foo(String str) {",
+ " return new Foo(str, bar());",
+ " }",
+ "",
+ " @Override",
+ " public FooFactory fooFactory() {",
+ " return new FooFactory() {",
+ " @Override",
+ " public Foo create(String str) {",
+ " return DaggerTestComponent.this.foo(str);",
+ " }",
+ " };",
+ " }",
+ "}")
+ .addLinesIn(
+ DEFAULT_MODE,
+ "final class DaggerTestComponent implements TestComponent {",
+ "",
+ " private Provider<FooFactory> fooFactoryProvider;",
+ "",
+ " private Provider<Bar> barProvider;",
+ "",
+ " private Foo_Factory fooProvider;",
+ "",
+ " @SuppressWarnings(\"unchecked\")",
+ " private void initialize() {",
+ " this.fooFactoryProvider = new DelegateFactory<>();",
+ " this.barProvider = Bar_Factory.create(fooFactoryProvider);",
+ " this.fooProvider = Foo_Factory.create(barProvider);",
+ " DelegateFactory.setDelegate(",
+ " fooFactoryProvider, FooFactory_Impl.create(fooProvider));",
+ " }",
+ "",
+ " @Override",
+ " public FooFactory fooFactory() {",
+ " return fooFactoryProvider.get();",
+ " }",
+ "}")
+ .build();
+ assertThat(compilation)
+ .generatedSourceFile("test.DaggerTestComponent")
+ .containsElementsIn(generatedComponent);
+ }
+}
diff --git a/javatests/dagger/internal/codegen/AssistedInjectErrorsTest.java b/javatests/dagger/internal/codegen/AssistedInjectErrorsTest.java
new file mode 100644
index 0000000..47e2171
--- /dev/null
+++ b/javatests/dagger/internal/codegen/AssistedInjectErrorsTest.java
@@ -0,0 +1,234 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen;
+
+import static com.google.testing.compile.CompilationSubject.assertThat;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
+
+import com.google.common.collect.ImmutableCollection;
+import com.google.testing.compile.Compilation;
+import com.google.testing.compile.JavaFileObjects;
+import javax.tools.JavaFileObject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class AssistedInjectErrorsTest {
+ @Parameters(name = "{0}")
+ public static ImmutableCollection<Object[]> parameters() {
+ return CompilerMode.TEST_PARAMETERS;
+ }
+
+ private final CompilerMode compilerMode;
+
+ public AssistedInjectErrorsTest(CompilerMode compilerMode) {
+ this.compilerMode = compilerMode;
+ }
+
+ @Test
+ public void testAssistedInjectWithDuplicateTypesFails() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.Foo",
+ "package test;",
+ "",
+ "import dagger.assisted.Assisted;",
+ "import dagger.assisted.AssistedInject;",
+ "",
+ "class Foo {",
+ " @AssistedInject",
+ " Foo(@Assisted String str1, @Assisted String str2) {}",
+ "}");
+
+ Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(foo);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@AssistedInject constructor has duplicate @Assisted type: @Assisted java.lang.String")
+ .inFile(foo)
+ .onLine(8);
+ }
+
+ @Test
+ public void testAssistedInjectWithDuplicateTypesEmptyQualifierFails() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.Foo",
+ "package test;",
+ "",
+ "import dagger.assisted.Assisted;",
+ "import dagger.assisted.AssistedInject;",
+ "",
+ "class Foo {",
+ " @AssistedInject",
+ " Foo(@Assisted(\"\") String str1, @Assisted String str2) {}",
+ "}");
+
+ Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(foo);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@AssistedInject constructor has duplicate @Assisted type: @Assisted java.lang.String")
+ .inFile(foo)
+ .onLine(8);
+ }
+
+ @Test
+ public void testAssistedInjectWithDuplicateQualifiedTypesFails() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.Foo",
+ "package test;",
+ "",
+ "import dagger.assisted.Assisted;",
+ "import dagger.assisted.AssistedInject;",
+ "",
+ "class Foo<T> {",
+ " @AssistedInject",
+ " Foo(@Assisted(\"MyQualfier\") String s1, @Assisted(\"MyQualfier\") String s2) {}",
+ "}");
+
+ Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(foo);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@AssistedInject constructor has duplicate @Assisted type: "
+ + "@Assisted(\"MyQualfier\") java.lang.String")
+ .inFile(foo)
+ .onLine(8);
+ }
+
+ @Test
+ public void testAssistedInjectWithDuplicateGenericTypesFails() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.Foo",
+ "package test;",
+ "",
+ "import dagger.assisted.Assisted;",
+ "import dagger.assisted.AssistedInject;",
+ "import java.util.List;",
+ "",
+ "class Foo {",
+ " @AssistedInject",
+ " Foo(@Assisted List<String> list1, @Assisted List<String> list2) {}",
+ "}");
+
+ Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(foo);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@AssistedInject constructor has duplicate @Assisted type: "
+ + "@Assisted java.util.List<java.lang.String>")
+ .inFile(foo)
+ .onLine(9);
+ }
+
+ @Test
+ public void testAssistedInjectWithDuplicateParameterizedTypesFails() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.Foo",
+ "package test;",
+ "",
+ "import dagger.assisted.Assisted;",
+ "import dagger.assisted.AssistedInject;",
+ "",
+ "class Foo<T> {",
+ " @AssistedInject",
+ " Foo(@Assisted T t1, @Assisted T t2) {}",
+ "}");
+
+ Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(foo);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining("@AssistedInject constructor has duplicate @Assisted type: @Assisted T")
+ .inFile(foo)
+ .onLine(8);
+ }
+
+ @Test
+ public void testAssistedInjectWithUniqueParameterizedTypesPasses() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.Foo",
+ "package test;",
+ "",
+ "import dagger.assisted.Assisted;",
+ "import dagger.assisted.AssistedInject;",
+ "import java.util.List;",
+ "",
+ "class Foo<T1, T2> {",
+ " @AssistedInject",
+ " Foo(@Assisted T1 t1, @Assisted T2 t2) {}",
+ "}");
+
+ Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(foo);
+ assertThat(compilation).succeeded();
+ }
+
+ @Test
+ public void testAssistedInjectWithUniqueGenericTypesPasses() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.Foo",
+ "package test;",
+ "",
+ "import dagger.assisted.Assisted;",
+ "import dagger.assisted.AssistedInject;",
+ "import java.util.List;",
+ "",
+ "class Foo {",
+ " @AssistedInject",
+ " Foo(@Assisted List<String> list1, @Assisted List<Integer> list2) {}",
+ "}");
+
+ Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(foo);
+ assertThat(compilation).succeeded();
+ }
+
+ @Test
+ public void testAssistedInjectWithUniqueQualifiedTypesPasses() {
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "test.Foo",
+ "package test;",
+ "",
+ "import dagger.assisted.Assisted;",
+ "import dagger.assisted.AssistedInject;",
+ "import java.util.List;",
+ "",
+ "class Foo {",
+ " @AssistedInject",
+ " Foo(",
+ " @Assisted(\"1\") Integer i1,",
+ " @Assisted(\"1\") String s1,",
+ " @Assisted(\"2\") String s2,",
+ " @Assisted String s3) {}",
+ "}");
+
+ Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(foo);
+ assertThat(compilation).succeeded();
+ }
+}
diff --git a/javatests/dagger/internal/codegen/BUILD b/javatests/dagger/internal/codegen/BUILD
index ad214ff..979ae71 100644
--- a/javatests/dagger/internal/codegen/BUILD
+++ b/javatests/dagger/internal/codegen/BUILD
@@ -15,42 +15,84 @@
# Description:
# Tests for the Dagger compiler/codegen
-package(default_visibility = ["//:src"])
-
+load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "kt_jvm_library")
load("//:build_defs.bzl", "DOCLINT_HTML_AND_SYNTAX")
load("//:test_defs.bzl", "GenJavaTests")
-GenJavaTests(
- name = "compiler_tests",
- srcs = glob(["*.java"]),
- functional = False,
- javacopts = DOCLINT_HTML_AND_SYNTAX,
+package(default_visibility = ["//:src"])
+
+kt_jvm_library(
+ name = "kotlin_sources",
+ srcs = [
+ "KotlinInjectedQualifier.kt",
+ "KotlinObjectWithMemberInjection.kt",
+ ],
deps = [
"//java/dagger:core",
- "//java/dagger/internal/codegen:base",
- "//java/dagger/internal/codegen:binding",
- "//java/dagger/internal/codegen:binding_graph_validation",
+ ],
+)
+
+# TODO(bcorso): Move this into a subpackage.
+java_library(
+ name = "compilers",
+ srcs = [
+ "CompilerMode.java",
+ "Compilers.java",
+ "JavaFileBuilder.java",
+ ],
+ deps = [
+ "//java/dagger/internal/codegen:package_info",
"//java/dagger/internal/codegen:processor",
- "//java/dagger/internal/codegen:validation",
- "//java/dagger/internal/codegen:writing",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "@com_google_auto_value_auto_value//jar",
+ "@google_bazel_common//third_party/java/compile_testing",
+ ],
+)
+
+GenJavaTests(
+ name = "compiler_tests",
+ srcs = glob(
+ ["*.java"],
+ exclude = [
+ "CompilerMode.java",
+ "Compilers.java",
+ "JavaFileBuilder.java",
+ ],
+ ),
+ functional = False,
+ javacopts = DOCLINT_HTML_AND_SYNTAX,
+ plugins = ["//java/dagger/internal/codegen/bootstrap"],
+ deps = [
+ ":compilers",
+ ":kotlin_sources",
+ "//java/dagger:core",
+ "//java/dagger/internal/codegen:package_info",
+ "//java/dagger/internal/codegen:processor",
+ "//java/dagger/internal/codegen/base",
+ "//java/dagger/internal/codegen/binding",
+ "//java/dagger/internal/codegen/bindinggraphvalidation",
+ "//java/dagger/internal/codegen/compileroption",
"//java/dagger/internal/codegen/javapoet",
+ "//java/dagger/internal/codegen/kotlin",
"//java/dagger/internal/codegen/langmodel",
- "//java/dagger/internal/codegen/serialization",
- "//java/dagger/model",
+ "//java/dagger/internal/codegen/validation",
+ "//java/dagger/internal/codegen/writing",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/internal/guava:concurrent",
"//java/dagger/model/testing",
"//java/dagger/producers",
"//java/dagger/spi",
- "@com_google_auto_value_auto_value//jar", # For AutoAnnotationProcessor
- "@google_bazel_common//third_party/java/auto:common",
+ "@com_google_auto_value_auto_value//jar",
"@google_bazel_common//third_party/java/auto:value",
"@google_bazel_common//third_party/java/compile_testing",
- "@google_bazel_common//third_party/java/guava",
"@google_bazel_common//third_party/java/javapoet",
"@google_bazel_common//third_party/java/jsr250_annotations",
"@google_bazel_common//third_party/java/jsr330_inject",
"@google_bazel_common//third_party/java/junit",
"@google_bazel_common//third_party/java/mockito",
"@google_bazel_common//third_party/java/truth",
- "@google_bazel_common//third_party/java/truth:truth8",
+ "@maven//:com_google_auto_auto_common",
],
)
diff --git a/javatests/dagger/internal/codegen/BindsDependsOnSubcomponentValidationTest.java b/javatests/dagger/internal/codegen/BindsDependsOnSubcomponentValidationTest.java
new file mode 100644
index 0000000..aa01b3a
--- /dev/null
+++ b/javatests/dagger/internal/codegen/BindsDependsOnSubcomponentValidationTest.java
@@ -0,0 +1,340 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen;
+
+import static com.google.testing.compile.CompilationSubject.assertThat;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
+import static dagger.internal.codegen.Compilers.daggerCompiler;
+
+import com.google.testing.compile.Compilation;
+import com.google.testing.compile.JavaFileObjects;
+import javax.tools.JavaFileObject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests to make sure that delegate bindings where the impl depends on a binding in a subcomponent
+ * properly fail. These are regression tests for b/147020838.
+ */
+@RunWith(JUnit4.class)
+public class BindsDependsOnSubcomponentValidationTest {
+ @Test
+ public void testBinds() {
+ JavaFileObject parentComponent =
+ JavaFileObjects.forSourceLines(
+ "test.ParentComponent",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "",
+ "@Component(modules = ParentModule.class)",
+ "interface ParentComponent {",
+ " ChildComponent getChild();",
+ "}");
+ JavaFileObject parentModule =
+ JavaFileObjects.forSourceLines(
+ "test.ParentModule",
+ "package test;",
+ "",
+ "import dagger.Binds;",
+ "import dagger.Module;",
+ "",
+ "@Module",
+ "interface ParentModule {",
+ " @Binds Foo bindFoo(FooImpl impl);",
+ "}");
+ JavaFileObject childComponent =
+ JavaFileObjects.forSourceLines(
+ "test.ChildComponent",
+ "package test;",
+ "",
+ "import dagger.Subcomponent;",
+ "",
+ "@Subcomponent(modules = ChildModule.class)",
+ "interface ChildComponent {",
+ " Foo getFoo();",
+ "}");
+ JavaFileObject childModule =
+ JavaFileObjects.forSourceLines(
+ "test.ChildModule",
+ "package test;",
+ "",
+ "import dagger.Module;",
+ "import dagger.Provides;",
+ "",
+ "@Module",
+ "interface ChildModule {",
+ " @Provides static Long providLong() {",
+ " return 0L;",
+ " }",
+ "}");
+ JavaFileObject iface =
+ JavaFileObjects.forSourceLines("test.Foo", "package test;", "", "interface Foo {", "}");
+ JavaFileObject impl =
+ JavaFileObjects.forSourceLines(
+ "test.FooImpl",
+ "package test;",
+ "",
+ "import javax.inject.Inject;",
+ "",
+ "class FooImpl implements Foo {",
+ " @Inject FooImpl(Long l) {}",
+ "}");
+ Compilation compilation =
+ daggerCompiler()
+ .compile(parentComponent, parentModule, childComponent, childModule, iface, impl);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining("Long cannot be provided without an @Inject constructor")
+ .inFile(parentComponent)
+ .onLineContaining("interface ParentComponent");
+ }
+
+ @Test
+ public void testSetBindings() {
+ JavaFileObject parentComponent =
+ JavaFileObjects.forSourceLines(
+ "test.ParentComponent",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "",
+ "@Component(modules = ParentModule.class)",
+ "interface ParentComponent {",
+ " ChildComponent getChild();",
+ "}");
+ JavaFileObject parentModule =
+ JavaFileObjects.forSourceLines(
+ "test.ParentModule",
+ "package test;",
+ "",
+ "import dagger.Binds;",
+ "import dagger.Module;",
+ "import dagger.multibindings.IntoSet;",
+ "",
+ "@Module",
+ "interface ParentModule {",
+ " @Binds @IntoSet Foo bindFoo(FooImpl impl);",
+ "}");
+ JavaFileObject childComponent =
+ JavaFileObjects.forSourceLines(
+ "test.ChildComponent",
+ "package test;",
+ "",
+ "import dagger.Subcomponent;",
+ "import java.util.Set;",
+ "",
+ "@Subcomponent(modules = ChildModule.class)",
+ "interface ChildComponent {",
+ " Set<Foo> getFooSet();",
+ "}");
+ JavaFileObject childModule =
+ JavaFileObjects.forSourceLines(
+ "test.ChildModule",
+ "package test;",
+ "",
+ "import dagger.Module;",
+ "import dagger.Provides;",
+ "",
+ "@Module",
+ "interface ChildModule {",
+ " @Provides static Long providLong() {",
+ " return 0L;",
+ " }",
+ "}");
+ JavaFileObject iface =
+ JavaFileObjects.forSourceLines("test.Foo", "package test;", "", "interface Foo {", "}");
+ JavaFileObject impl =
+ JavaFileObjects.forSourceLines(
+ "test.FooImpl",
+ "package test;",
+ "",
+ "import javax.inject.Inject;",
+ "",
+ "class FooImpl implements Foo {",
+ " @Inject FooImpl(Long l) {}",
+ "}");
+ Compilation compilation =
+ daggerCompiler()
+ .compile(parentComponent, parentModule, childComponent, childModule, iface, impl);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining("Long cannot be provided without an @Inject constructor")
+ .inFile(parentComponent)
+ .onLineContaining("interface ParentComponent");
+ }
+
+ @Test
+ public void testSetValueBindings() {
+ JavaFileObject parentComponent =
+ JavaFileObjects.forSourceLines(
+ "test.ParentComponent",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "",
+ "@Component(modules = ParentModule.class)",
+ "interface ParentComponent {",
+ " ChildComponent getChild();",
+ "}");
+ JavaFileObject parentModule =
+ JavaFileObjects.forSourceLines(
+ "test.ParentModule",
+ "package test;",
+ "",
+ "import dagger.Module;",
+ "import dagger.Provides;",
+ "import dagger.multibindings.ElementsIntoSet;",
+ "import java.util.Collections;",
+ "import java.util.Set;",
+ "",
+ "@Module",
+ "interface ParentModule {",
+ " @Provides @ElementsIntoSet",
+ " static Set<Foo> provideFoo(FooImpl impl) {",
+ " return Collections.singleton(impl);",
+ " }",
+ "}");
+ JavaFileObject childComponent =
+ JavaFileObjects.forSourceLines(
+ "test.ChildComponent",
+ "package test;",
+ "",
+ "import dagger.Subcomponent;",
+ "import java.util.Set;",
+ "",
+ "@Subcomponent(modules = ChildModule.class)",
+ "interface ChildComponent {",
+ " Set<Foo> getFooSet();",
+ "}");
+ JavaFileObject childModule =
+ JavaFileObjects.forSourceLines(
+ "test.ChildModule",
+ "package test;",
+ "",
+ "import dagger.Module;",
+ "import dagger.Provides;",
+ "",
+ "@Module",
+ "interface ChildModule {",
+ " @Provides static Long providLong() {",
+ " return 0L;",
+ " }",
+ "}");
+ JavaFileObject iface =
+ JavaFileObjects.forSourceLines("test.Foo", "package test;", "", "interface Foo {", "}");
+ JavaFileObject impl =
+ JavaFileObjects.forSourceLines(
+ "test.FooImpl",
+ "package test;",
+ "",
+ "import javax.inject.Inject;",
+ "",
+ "class FooImpl implements Foo {",
+ " @Inject FooImpl(Long l) {}",
+ "}");
+ Compilation compilation =
+ daggerCompiler()
+ .compile(parentComponent, parentModule, childComponent, childModule, iface, impl);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining("Long cannot be provided without an @Inject constructor")
+ .inFile(parentComponent)
+ .onLineContaining("interface ParentComponent");
+ }
+
+ @Test
+ public void testMapBindings() {
+ JavaFileObject parentComponent =
+ JavaFileObjects.forSourceLines(
+ "test.ParentComponent",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "",
+ "@Component(modules = ParentModule.class)",
+ "interface ParentComponent {",
+ " ChildComponent getChild();",
+ "}");
+ JavaFileObject parentModule =
+ JavaFileObjects.forSourceLines(
+ "test.ParentModule",
+ "package test;",
+ "",
+ "import dagger.Binds;",
+ "import dagger.Module;",
+ "import dagger.multibindings.IntoMap;",
+ "import dagger.multibindings.StringKey;",
+ "",
+ "@Module",
+ "interface ParentModule {",
+ " @Binds @IntoMap @StringKey(\"foo\") Foo bindFoo(FooImpl impl);",
+ "}");
+ JavaFileObject childComponent =
+ JavaFileObjects.forSourceLines(
+ "test.ChildComponent",
+ "package test;",
+ "",
+ "import dagger.Subcomponent;",
+ "import java.util.Map;",
+ "",
+ "@Subcomponent(modules = ChildModule.class)",
+ "interface ChildComponent {",
+ " Map<String, Foo> getFooSet();",
+ "}");
+ JavaFileObject childModule =
+ JavaFileObjects.forSourceLines(
+ "test.ChildModule",
+ "package test;",
+ "",
+ "import dagger.Module;",
+ "import dagger.Provides;",
+ "",
+ "@Module",
+ "interface ChildModule {",
+ " @Provides static Long providLong() {",
+ " return 0L;",
+ " }",
+ "}");
+ JavaFileObject iface =
+ JavaFileObjects.forSourceLines("test.Foo", "package test;", "", "interface Foo {", "}");
+ JavaFileObject impl =
+ JavaFileObjects.forSourceLines(
+ "test.FooImpl",
+ "package test;",
+ "",
+ "import javax.inject.Inject;",
+ "",
+ "class FooImpl implements Foo {",
+ " @Inject FooImpl(Long l) {}",
+ "}");
+ Compilation compilation =
+ // TODO(erichang): make this flag the default and remove this
+ compilerWithOptions("-Adagger.strictMultibindingValidation=enabled")
+ .compile(parentComponent, parentModule, childComponent, childModule, iface, impl);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining("Long cannot be provided without an @Inject constructor")
+ .inFile(parentComponent)
+ .onLineContaining("interface ParentComponent");
+ }
+}
diff --git a/javatests/dagger/internal/codegen/BindsMethodValidationTest.java b/javatests/dagger/internal/codegen/BindsMethodValidationTest.java
index 6ba9e3e..ab26010 100644
--- a/javatests/dagger/internal/codegen/BindsMethodValidationTest.java
+++ b/javatests/dagger/internal/codegen/BindsMethodValidationTest.java
@@ -25,7 +25,6 @@
import dagger.multibindings.IntKey;
import dagger.multibindings.LongKey;
import dagger.producers.ProducerModule;
-import java.io.IOException;
import java.lang.annotation.Annotation;
import java.lang.annotation.Retention;
import java.util.Collection;
@@ -79,9 +78,8 @@
@Test
public void throwsException() {
- assertThatMethod("@Binds abstract Object throwsException(String s1) throws IOException;")
- .importing(IOException.class)
- .hasError("only throw unchecked");
+ assertThatMethod("@Binds abstract Object throwsException(String s1) throws RuntimeException;")
+ .hasError("may not throw");
}
@Test
diff --git a/javatests/dagger/internal/codegen/BindsMissingDelegateValidationTest.java b/javatests/dagger/internal/codegen/BindsMissingDelegateValidationTest.java
index 28b75be..bfc3617 100644
--- a/javatests/dagger/internal/codegen/BindsMissingDelegateValidationTest.java
+++ b/javatests/dagger/internal/codegen/BindsMissingDelegateValidationTest.java
@@ -97,7 +97,7 @@
.hadErrorContainingMatch(
"\\Qtest.C.NotBound cannot be provided\\E|"
+ message(
- "\\Qjava.lang.Object is bound multiple times:",
+ "\\QObject is bound multiple times:",
" @Binds Object test.C.TestModule.bindObject(test.C.NotBound)",
" @Provides Object test.C.TestModule.provideObject()\\E"))
.inFile(component)
diff --git a/javatests/dagger/internal/codegen/BindsOptionalOfMethodValidationTest.java b/javatests/dagger/internal/codegen/BindsOptionalOfMethodValidationTest.java
index fa44a6e..ca3e5e4 100644
--- a/javatests/dagger/internal/codegen/BindsOptionalOfMethodValidationTest.java
+++ b/javatests/dagger/internal/codegen/BindsOptionalOfMethodValidationTest.java
@@ -37,7 +37,7 @@
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
-/** Tests {@link BindsOptionalOfMethodValidator}. */
+/** Tests {@link dagger.internal.codegen.validation.BindsOptionalOfMethodValidator}. */
@RunWith(Parameterized.class)
public class BindsOptionalOfMethodValidationTest {
@Parameters(name = "{0}")
diff --git a/javatests/dagger/internal/codegen/CompilerMode.java b/javatests/dagger/internal/codegen/CompilerMode.java
index 23aa312..86ce53d 100644
--- a/javatests/dagger/internal/codegen/CompilerMode.java
+++ b/javatests/dagger/internal/codegen/CompilerMode.java
@@ -23,9 +23,6 @@
enum CompilerMode {
DEFAULT_MODE,
FAST_INIT_MODE("-Adagger.fastInit=enabled"),
- AHEAD_OF_TIME_SUBCOMPONENTS_MODE(
- "-Adagger.experimentalAheadOfTimeSubcomponents=enabled",
- "-Adagger.emitModifiableMetadataAnnotations=disabled"),
JAVA7("-source", "7", "-target", "7"),
;
diff --git a/javatests/dagger/internal/codegen/Compilers.java b/javatests/dagger/internal/codegen/Compilers.java
index 3e08f63..26796bf 100644
--- a/javatests/dagger/internal/codegen/Compilers.java
+++ b/javatests/dagger/internal/codegen/Compilers.java
@@ -19,42 +19,60 @@
import static com.google.common.base.StandardSystemProperty.JAVA_CLASS_PATH;
import static com.google.common.base.StandardSystemProperty.PATH_SEPARATOR;
import static com.google.testing.compile.Compiler.javac;
-import static java.util.stream.Collectors.joining;
+import static java.util.stream.Collectors.collectingAndThen;
+import static java.util.stream.Collectors.toList;
import com.google.auto.value.processor.AutoAnnotationProcessor;
import com.google.common.base.Splitter;
-import com.google.common.collect.FluentIterable;
import com.google.common.collect.ImmutableList;
import com.google.testing.compile.Compiler;
+import java.io.File;
+import java.util.Arrays;
import javax.annotation.processing.Processor;
/** {@link Compiler} instances for testing Dagger. */
-final class Compilers {
+public final class Compilers {
private static final String GUAVA = "guava";
- static final ImmutableList<String> CLASS_PATH_WITHOUT_GUAVA_OPTION =
- ImmutableList.of(
- "-classpath",
- Splitter.on(PATH_SEPARATOR.value()).splitToList(JAVA_CLASS_PATH.value()).stream()
- .filter(jar -> !jar.contains(GUAVA))
- .collect(joining(PATH_SEPARATOR.value())));
+ static final ImmutableList<File> CLASS_PATH_WITHOUT_GUAVA_OPTION =
+ Splitter.on(PATH_SEPARATOR.value()).splitToList(JAVA_CLASS_PATH.value()).stream()
+ .filter(jar -> !jar.contains(GUAVA))
+ // Remove Bazel's runner deploy jar which leaks Guava classes into the classpath and
+ // the compile testing tests.
+ .filter(jar -> !jar.contains("Runner_deploy.jar"))
+ .map(File::new)
+ .collect(collectingAndThen(toList(), ImmutableList::copyOf));
+
+ static final ImmutableList<String> DEFAULT_JAVACOPTS =
+ ImmutableList.of("-Adagger.experimentalDaggerErrorMessages=enabled");
/**
* Returns a compiler that runs the Dagger and {@code @AutoAnnotation} processors, along with
* extras.
*/
- static Compiler daggerCompiler(Processor... extraProcessors) {
+ public static Compiler daggerCompiler(Processor... extraProcessors) {
ImmutableList.Builder<Processor> processors = ImmutableList.builder();
processors.add(new ComponentProcessor(), new AutoAnnotationProcessor());
processors.add(extraProcessors);
- return javac().withProcessors(processors.build());
+ return javac().withProcessors(processors.build()).withOptions(DEFAULT_JAVACOPTS);
}
- static Compiler compilerWithOptions(CompilerMode... compilerModes) {
- FluentIterable<String> options = FluentIterable.of();
+ public static Compiler compilerWithOptions(CompilerMode... compilerModes) {
+ ImmutableList.Builder<String> options = ImmutableList.builder();
for (CompilerMode compilerMode : compilerModes) {
- options = options.append(compilerMode.javacopts());
+ options = options.addAll(compilerMode.javacopts());
}
- return daggerCompiler().withOptions(options);
+ return compilerWithOptions(options.build());
}
+
+ public static Compiler compilerWithOptions(String... options) {
+ return compilerWithOptions(Arrays.asList(options));
+ }
+
+ public static Compiler compilerWithOptions(Iterable<String> options) {
+ return daggerCompiler()
+ .withOptions(ImmutableList.builder().addAll(DEFAULT_JAVACOPTS).addAll(options).build());
+ }
+
+ private Compilers() {}
}
diff --git a/javatests/dagger/internal/codegen/ComponentBuilderTest.java b/javatests/dagger/internal/codegen/ComponentBuilderTest.java
index f280bdd..acf5437 100644
--- a/javatests/dagger/internal/codegen/ComponentBuilderTest.java
+++ b/javatests/dagger/internal/codegen/ComponentBuilderTest.java
@@ -17,13 +17,14 @@
package dagger.internal.codegen;
import static com.google.testing.compile.CompilationSubject.assertThat;
-import static dagger.internal.codegen.Compilers.daggerCompiler;
-import static dagger.internal.codegen.ComponentCreatorAnnotation.COMPONENT_BUILDER;
-import static dagger.internal.codegen.ErrorMessages.creatorMessagesFor;
-import static dagger.internal.codegen.GeneratedLines.GENERATED_ANNOTATION;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
+import static dagger.internal.codegen.GeneratedLines.GENERATED_CODE_ANNOTATIONS;
+import static dagger.internal.codegen.binding.ComponentCreatorAnnotation.COMPONENT_BUILDER;
+import static dagger.internal.codegen.binding.ErrorMessages.creatorMessagesFor;
import com.google.testing.compile.Compilation;
import com.google.testing.compile.JavaFileObjects;
+import dagger.internal.codegen.binding.ErrorMessages;
import java.util.Collection;
import javax.tools.JavaFileObject;
import org.junit.Test;
@@ -87,7 +88,7 @@
"",
"import dagger.internal.Preconditions;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" private static final class Builder implements TestComponent.Builder {",
" private TestModule testModule;",
@@ -108,7 +109,7 @@
" }",
"}");
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(moduleFile, componentFile);
+ compilerWithOptions(compilerMode.javacopts()).compile(moduleFile, componentFile);
assertThat(compilation).succeeded();
assertThat(compilation)
.generatedSourceFile("test.DaggerTestComponent")
@@ -135,7 +136,7 @@
" }",
"}");
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(componentFile);
+ compilerWithOptions(compilerMode.javacopts()).compile(componentFile);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(MSGS.setterMethodsMustTakeOneArg())
@@ -168,7 +169,7 @@
" interface Builder extends Parent {}",
"}");
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(componentFile);
+ compilerWithOptions(compilerMode.javacopts()).compile(componentFile);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
@@ -198,7 +199,7 @@
" }",
"}");
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(componentFile);
+ compilerWithOptions(compilerMode.javacopts()).compile(componentFile);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(MSGS.setterMethodsMustReturnVoidOrBuilder())
@@ -227,7 +228,7 @@
" interface Builder extends Parent {}",
"}");
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(componentFile);
+ compilerWithOptions(compilerMode.javacopts()).compile(componentFile);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
@@ -256,7 +257,7 @@
" }",
"}");
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(componentFile);
+ compilerWithOptions(compilerMode.javacopts()).compile(componentFile);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(MSGS.methodsMayNotHaveTypeParameters())
@@ -285,7 +286,7 @@
" interface Builder extends Parent {}",
"}");
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(componentFile);
+ compilerWithOptions(compilerMode.javacopts()).compile(componentFile);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
@@ -318,7 +319,7 @@
"}");
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(componentFile);
+ compilerWithOptions(compilerMode.javacopts()).compile(componentFile);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(MSGS.bindsInstanceNotAllowedOnBothSetterMethodAndParameter())
@@ -352,7 +353,7 @@
"}");
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(componentFile);
+ compilerWithOptions(compilerMode.javacopts()).compile(componentFile);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
diff --git a/javatests/dagger/internal/codegen/ComponentCreatorTest.java b/javatests/dagger/internal/codegen/ComponentCreatorTest.java
index 6f4ea8d..0a7e40e 100644
--- a/javatests/dagger/internal/codegen/ComponentCreatorTest.java
+++ b/javatests/dagger/internal/codegen/ComponentCreatorTest.java
@@ -16,28 +16,27 @@
package dagger.internal.codegen;
-import static com.google.common.collect.Sets.immutableEnumSet;
+import static com.google.common.truth.TruthJUnit.assume;
import static com.google.testing.compile.CompilationSubject.assertThat;
import static dagger.internal.codegen.CompilerMode.DEFAULT_MODE;
import static dagger.internal.codegen.CompilerMode.FAST_INIT_MODE;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
import static dagger.internal.codegen.Compilers.daggerCompiler;
-import static dagger.internal.codegen.ComponentCreatorAnnotation.COMPONENT_BUILDER;
-import static dagger.internal.codegen.ComponentCreatorAnnotation.COMPONENT_FACTORY;
-import static dagger.internal.codegen.ComponentCreatorKind.BUILDER;
-import static dagger.internal.codegen.ComponentCreatorKind.FACTORY;
-import static dagger.internal.codegen.ComponentKind.COMPONENT;
-import static dagger.internal.codegen.ErrorMessages.componentMessagesFor;
-import static dagger.internal.codegen.GeneratedLines.GENERATED_ANNOTATION;
+import static dagger.internal.codegen.ComponentCreatorTest.CompilerType.JAVAC;
+import static dagger.internal.codegen.GeneratedLines.GENERATED_CODE_ANNOTATIONS;
import static dagger.internal.codegen.GeneratedLines.IMPORT_GENERATED_ANNOTATION;
+import static dagger.internal.codegen.binding.ComponentCreatorAnnotation.COMPONENT_BUILDER;
+import static dagger.internal.codegen.binding.ComponentCreatorAnnotation.COMPONENT_FACTORY;
+import static dagger.internal.codegen.binding.ComponentCreatorKind.BUILDER;
+import static dagger.internal.codegen.binding.ComponentCreatorKind.FACTORY;
+import static dagger.internal.codegen.binding.ComponentKind.COMPONENT;
+import static dagger.internal.codegen.binding.ErrorMessages.componentMessagesFor;
import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.Sets;
import com.google.testing.compile.Compilation;
import com.google.testing.compile.JavaFileObjects;
+import dagger.internal.codegen.binding.ComponentCreatorAnnotation;
import java.util.Collection;
-import java.util.List;
-import java.util.Set;
import javax.tools.JavaFileObject;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -47,22 +46,34 @@
/** Tests for properties of component creators shared by both builders and factories. */
@RunWith(Parameterized.class)
public class ComponentCreatorTest extends ComponentCreatorTestHelper {
+ enum CompilerType {
+ JAVAC
+ }
+
+ private final CompilerType compilerType;
+ private final CompilerMode compilerMode;
+
@Parameters(name = "compilerMode={0}, creatorKind={1}")
public static Collection<Object[]> parameters() {
- Set<List<Object>> params =
- Sets.<Object>cartesianProduct(
- immutableEnumSet(DEFAULT_MODE, FAST_INIT_MODE),
- immutableEnumSet(COMPONENT_BUILDER, COMPONENT_FACTORY));
- return ImmutableList.copyOf(Iterables.transform(params, Collection::toArray));
+ return ImmutableList.of(
+ new Object[]{DEFAULT_MODE, COMPONENT_BUILDER, JAVAC},
+ new Object[]{DEFAULT_MODE, COMPONENT_FACTORY, JAVAC},
+ new Object[]{FAST_INIT_MODE, COMPONENT_BUILDER, JAVAC},
+ new Object[]{FAST_INIT_MODE, COMPONENT_FACTORY, JAVAC});
}
public ComponentCreatorTest(
- CompilerMode compilerMode, ComponentCreatorAnnotation componentCreatorAnnotation) {
+ CompilerMode compilerMode,
+ ComponentCreatorAnnotation componentCreatorAnnotation,
+ CompilerType compilerType) {
super(compilerMode, componentCreatorAnnotation);
+ this.compilerMode = compilerMode;
+ this.compilerType = compilerType;
}
@Test
public void testEmptyCreator() {
+ assume().that(compilerType).isEqualTo(JAVAC);
JavaFileObject injectableTypeFile =
JavaFileObjects.forSourceLines(
"test.SomeInjectableType",
@@ -95,7 +106,7 @@
"test.DaggerSimpleComponent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerSimpleComponent implements SimpleComponent {",
" private static final class Builder implements SimpleComponent.Builder {",
" @Override",
@@ -113,6 +124,7 @@
@Test
public void testCanInstantiateModulesUserCannotSet() {
+ assume().that(compilerType).isEqualTo(JAVAC);
JavaFileObject module =
JavaFileObjects.forSourceLines(
"test.TestModule",
@@ -149,7 +161,7 @@
"",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" private final TestModule testModule;",
"",
@@ -310,6 +322,7 @@
@Test
public void testCreatorWithBindsInstanceNoStaticCreateGenerated() {
+ assume().that(compilerType).isEqualTo(JAVAC);
JavaFileObject componentFile =
javaFileBuilder("test.SimpleComponent")
.addLines(
@@ -347,7 +360,7 @@
"import dagger.internal.Preconditions;",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerSimpleComponent implements SimpleComponent {",
" private final Object object;",
"",
@@ -410,6 +423,7 @@
@Test
public void testCreatorWithPrimitiveBindsInstance() {
+ assume().that(compilerType).isEqualTo(JAVAC);
JavaFileObject componentFile =
javaFileBuilder("test.SimpleComponent")
.addLines(
@@ -448,7 +462,7 @@
"import dagger.internal.Preconditions;",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerSimpleComponent implements SimpleComponent {",
" private final Integer i;",
"",
@@ -779,6 +793,7 @@
@Test
public void testMultipleSettersPerTypeFails() {
+ assume().that(compilerType).isEqualTo(JAVAC);
JavaFileObject moduleFile =
JavaFileObjects.forSourceLines(
"test.TestModule",
@@ -837,6 +852,7 @@
@Test
public void testMultipleSettersPerTypeIncludingResolvedGenericsFails() {
+ assume().that(compilerType).isEqualTo(JAVAC);
JavaFileObject moduleFile =
JavaFileObjects.forSourceLines(
"test.TestModule",
@@ -900,6 +916,7 @@
@Test
public void testExtraSettersFails() {
+ assume().that(compilerType).isEqualTo(JAVAC);
JavaFileObject componentFile =
javaFileBuilder("test.SimpleComponent")
.addLines(
@@ -1032,6 +1049,7 @@
@Test
public void covariantFactoryMethodReturnType() {
+ assume().that(compilerType).isEqualTo(JAVAC);
JavaFileObject foo =
JavaFileObjects.forSourceLines(
"test.Foo",
@@ -1072,6 +1090,7 @@
@Test
public void covariantFactoryMethodReturnType_hasNewMethod() {
+ assume().that(compilerType).isEqualTo(JAVAC);
JavaFileObject foo =
JavaFileObjects.forSourceLines(
"test.Foo",
@@ -1133,6 +1152,7 @@
@Test
public void covariantFactoryMethodReturnType_hasNewMethod_factoryMethodInherited() {
+ assume().that(compilerType).isEqualTo(JAVAC);
JavaFileObject foo =
JavaFileObjects.forSourceLines(
"test.Foo",
@@ -1250,4 +1270,13 @@
.inFile(componentFile)
.onLineContaining(process("interface Builder"));
}
+
+ /** Compiles the given files with the set compiler mode's javacopts. */
+ @Override
+ Compilation compile(JavaFileObject... files) {
+ ImmutableList.Builder<String> options =
+ ImmutableList.<String>builder().addAll(compilerMode.javacopts());
+
+ return compilerWithOptions(options.build()).compile(files);
+ }
}
diff --git a/javatests/dagger/internal/codegen/ComponentCreatorTestHelper.java b/javatests/dagger/internal/codegen/ComponentCreatorTestHelper.java
index 2ee120e..8ad4322 100644
--- a/javatests/dagger/internal/codegen/ComponentCreatorTestHelper.java
+++ b/javatests/dagger/internal/codegen/ComponentCreatorTestHelper.java
@@ -16,13 +16,16 @@
package dagger.internal.codegen;
-import static dagger.internal.codegen.Compilers.daggerCompiler;
-import static dagger.internal.codegen.ComponentCreatorKind.FACTORY;
-import static dagger.internal.codegen.ErrorMessages.creatorMessagesFor;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
+import static dagger.internal.codegen.binding.ComponentCreatorKind.FACTORY;
+import static dagger.internal.codegen.binding.ErrorMessages.creatorMessagesFor;
import static java.util.stream.Collectors.joining;
import com.google.testing.compile.Compilation;
import com.google.testing.compile.JavaFileObjects;
+import dagger.internal.codegen.binding.ComponentCreatorAnnotation;
+import dagger.internal.codegen.binding.ComponentCreatorKind;
+import dagger.internal.codegen.binding.ErrorMessages;
import java.util.Arrays;
import java.util.stream.Stream;
import javax.tools.JavaFileObject;
@@ -84,6 +87,6 @@
/** Compiles the given files with the set compiler mode's javacopts. */
Compilation compile(JavaFileObject... files) {
- return daggerCompiler().withOptions(compilerMode.javacopts()).compile(files);
+ return compilerWithOptions(compilerMode.javacopts()).compile(files);
}
}
diff --git a/javatests/dagger/internal/codegen/ComponentDependenciesTest.java b/javatests/dagger/internal/codegen/ComponentDependenciesTest.java
new file mode 100644
index 0000000..bbfa51c
--- /dev/null
+++ b/javatests/dagger/internal/codegen/ComponentDependenciesTest.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen;
+
+import static com.google.testing.compile.CompilationSubject.assertThat;
+import static dagger.internal.codegen.Compilers.daggerCompiler;
+
+import com.google.testing.compile.Compilation;
+import com.google.testing.compile.JavaFileObjects;
+import javax.tools.JavaFileObject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class ComponentDependenciesTest {
+ @Test
+ public void dependenciesWithTwoOfSameMethodOnDifferentInterfaces_fail() {
+ JavaFileObject interfaceOne = JavaFileObjects.forSourceLines("test.One",
+ "package test;",
+ "",
+ "interface One {",
+ " String getOne();",
+ "}");
+ JavaFileObject interfaceTwo = JavaFileObjects.forSourceLines("test.Two",
+ "package test;",
+ "",
+ "interface Two {",
+ " String getTwo();",
+ "}");
+ JavaFileObject mergedInterface = JavaFileObjects.forSourceLines("test.Merged",
+ "package test;",
+ "",
+ "interface Merged extends One, Two {}");
+ JavaFileObject componentFile = JavaFileObjects.forSourceLines("test.TestComponent",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "",
+ "@Component(dependencies = Merged.class)",
+ "interface TestComponent {",
+ " String getString();",
+ "}");
+ Compilation compilation = daggerCompiler().compile(
+ interfaceOne, interfaceTwo, mergedInterface, componentFile);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorContaining("DuplicateBindings");
+ }
+
+ @Test
+ public void dependenciesWithTwoOfSameMethodOnDifferentInterfaces_producers_fail() {
+ JavaFileObject interfaceOne = JavaFileObjects.forSourceLines("test.One",
+ "package test;",
+ "",
+ "import com.google.common.util.concurrent.ListenableFuture;",
+ "",
+ "interface One {",
+ " ListenableFuture<String> getOne();",
+ "}");
+ JavaFileObject interfaceTwo = JavaFileObjects.forSourceLines("test.Two",
+ "package test;",
+ "",
+ "import com.google.common.util.concurrent.ListenableFuture;",
+ "",
+ "interface Two {",
+ " ListenableFuture<String> getTwo();",
+ "}");
+ JavaFileObject mergedInterface = JavaFileObjects.forSourceLines("test.Merged",
+ "package test;",
+ "",
+ "interface Merged extends One, Two {}");
+ JavaFileObject componentFile = JavaFileObjects.forSourceLines("test.TestComponent",
+ "package test;",
+ "",
+ "import com.google.common.util.concurrent.ListenableFuture;",
+ "import dagger.producers.ProductionComponent;",
+ "",
+ "@ProductionComponent(dependencies = Merged.class)",
+ "interface TestComponent {",
+ " ListenableFuture<String> getString();",
+ "}");
+ Compilation compilation = daggerCompiler().compile(
+ interfaceOne, interfaceTwo, mergedInterface, componentFile);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorContaining("DuplicateBindings");
+ }
+
+ @Test
+ public void dependenciesWithTwoOfSameMethodButDifferentNullability_fail() {
+ JavaFileObject interfaceOne = JavaFileObjects.forSourceLines("test.One",
+ "package test;",
+ "",
+ "interface One {",
+ " String getString();",
+ "}");
+ JavaFileObject interfaceTwo = JavaFileObjects.forSourceLines("test.Two",
+ "package test;",
+ "import javax.annotation.Nullable;",
+ "",
+ "interface Two {",
+ " @Nullable String getString();",
+ "}");
+ JavaFileObject mergedInterface = JavaFileObjects.forSourceLines("test.Merged",
+ "package test;",
+ "",
+ "interface Merged extends One, Two {}");
+ JavaFileObject componentFile = JavaFileObjects.forSourceLines("test.TestComponent",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "",
+ "@Component(dependencies = Merged.class)",
+ "interface TestComponent {",
+ " String getString();",
+ "}");
+ Compilation compilation = daggerCompiler().compile(
+ interfaceOne, interfaceTwo, mergedInterface, componentFile);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorContaining("DuplicateBindings");
+ }
+
+}
diff --git a/javatests/dagger/internal/codegen/ComponentFactoryTest.java b/javatests/dagger/internal/codegen/ComponentFactoryTest.java
index 403498b..0f155b9 100644
--- a/javatests/dagger/internal/codegen/ComponentFactoryTest.java
+++ b/javatests/dagger/internal/codegen/ComponentFactoryTest.java
@@ -17,13 +17,14 @@
package dagger.internal.codegen;
import static com.google.testing.compile.CompilationSubject.assertThat;
-import static dagger.internal.codegen.Compilers.daggerCompiler;
-import static dagger.internal.codegen.ComponentCreatorAnnotation.COMPONENT_FACTORY;
-import static dagger.internal.codegen.ErrorMessages.creatorMessagesFor;
-import static dagger.internal.codegen.GeneratedLines.GENERATED_ANNOTATION;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
+import static dagger.internal.codegen.GeneratedLines.GENERATED_CODE_ANNOTATIONS;
+import static dagger.internal.codegen.binding.ComponentCreatorAnnotation.COMPONENT_FACTORY;
+import static dagger.internal.codegen.binding.ErrorMessages.creatorMessagesFor;
import com.google.testing.compile.Compilation;
import com.google.testing.compile.JavaFileObjects;
+import dagger.internal.codegen.binding.ErrorMessages;
import java.util.Collection;
import javax.tools.JavaFileObject;
import org.junit.Test;
@@ -86,7 +87,7 @@
"",
"import dagger.internal.Preconditions;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" private static final class Factory implements TestComponent.Factory {",
" @Override",
@@ -97,7 +98,7 @@
" }",
"}");
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(moduleFile, componentFile);
+ compilerWithOptions(compilerMode.javacopts()).compile(moduleFile, componentFile);
assertThat(compilation).succeeded();
assertThat(compilation)
.generatedSourceFile("test.DaggerTestComponent")
@@ -123,7 +124,7 @@
" }",
"}");
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(componentFile);
+ compilerWithOptions(compilerMode.javacopts()).compile(componentFile);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(String.format(MSGS.twoFactoryMethods(), "create()"))
@@ -152,7 +153,7 @@
" interface Factory extends Parent {}",
"}");
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(componentFile);
+ compilerWithOptions(compilerMode.javacopts()).compile(componentFile);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(String.format(MSGS.twoFactoryMethods(), "create()"))
diff --git a/javatests/dagger/internal/codegen/ComponentHierarchyValidationTest.java b/javatests/dagger/internal/codegen/ComponentHierarchyValidationTest.java
index 19eabac..6fb1820 100644
--- a/javatests/dagger/internal/codegen/ComponentHierarchyValidationTest.java
+++ b/javatests/dagger/internal/codegen/ComponentHierarchyValidationTest.java
@@ -17,6 +17,7 @@
package dagger.internal.codegen;
import static com.google.testing.compile.CompilationSubject.assertThat;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
import static dagger.internal.codegen.Compilers.daggerCompiler;
import static dagger.internal.codegen.TestUtils.message;
@@ -63,8 +64,7 @@
assertThat(compilation).hadErrorContaining("test.Parent also has @Singleton");
Compilation withoutScopeValidation =
- daggerCompiler()
- .withOptions("-Adagger.disableInterComponentScopeValidation=none")
+ compilerWithOptions("-Adagger.disableInterComponentScopeValidation=none")
.compile(component, subcomponent);
assertThat(withoutScopeValidation).succeeded();
}
diff --git a/javatests/dagger/internal/codegen/ComponentProcessorTest.java b/javatests/dagger/internal/codegen/ComponentProcessorTest.java
index 2b79b6f..eee6a0c 100644
--- a/javatests/dagger/internal/codegen/ComponentProcessorTest.java
+++ b/javatests/dagger/internal/codegen/ComponentProcessorTest.java
@@ -20,11 +20,10 @@
import static com.google.testing.compile.Compiler.javac;
import static dagger.internal.codegen.CompilerMode.DEFAULT_MODE;
import static dagger.internal.codegen.CompilerMode.FAST_INIT_MODE;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
import static dagger.internal.codegen.Compilers.daggerCompiler;
-import static dagger.internal.codegen.GeneratedLines.GENERATED_ANNOTATION;
+import static dagger.internal.codegen.GeneratedLines.GENERATED_CODE_ANNOTATIONS;
import static dagger.internal.codegen.GeneratedLines.IMPORT_GENERATED_ANNOTATION;
-import static dagger.internal.codegen.GeneratedLines.NPE_FROM_COMPONENT_METHOD;
-import static dagger.internal.codegen.GeneratedLines.NPE_FROM_PROVIDES_METHOD;
import com.google.auto.common.MoreElements;
import com.google.common.base.Predicate;
@@ -107,16 +106,15 @@
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(parent, child, another, componentFile);
assertThat(compilation).failed();
assertThat(compilation)
- .hadErrorContaining("java.util.List<java.lang.Integer> is bound multiple times");
+ .hadErrorContaining("List<Integer> is bound multiple times");
assertThat(compilation)
- .hadErrorContaining("@Provides List<Integer> test.ChildNumberModule.provideListB(Integer)");
+ .hadErrorContaining("@Provides List<Integer> ChildNumberModule.provideListB(Integer)");
assertThat(compilation)
- .hadErrorContaining("@Provides List<Integer> test.AnotherModule.provideListOfInteger()");
+ .hadErrorContaining("@Provides List<Integer> AnotherModule.provideListOfInteger()");
}
@Test public void privateNestedClassWithWarningThatIsAnErrorInComponent() {
@@ -142,8 +140,7 @@
" OuterClass outerClass();",
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(
+ compilerWithOptions(
compilerMode.javacopts().append("-Adagger.privateMemberValidation=WARNING"))
.compile(outerClass, componentFile);
assertThat(compilation).failed();
@@ -185,7 +182,7 @@
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerSimpleComponent implements SimpleComponent {")
.addLinesIn(
FAST_INIT_MODE,
@@ -261,8 +258,7 @@
.build();
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(injectableTypeFile, componentFile);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -302,7 +298,7 @@
.addLines(
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerSimpleComponent implements SimpleComponent {")
.addLinesIn(
FAST_INIT_MODE,
@@ -387,8 +383,7 @@
" }")
.build();
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(injectableTypeFile, componentFile);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -422,7 +417,7 @@
.addLines(
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerOuterType_SimpleComponent",
" implements OuterType.SimpleComponent {",
" private DaggerOuterType_SimpleComponent() {}",
@@ -446,7 +441,7 @@
.build();
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(nestedTypesFile);
+ compilerWithOptions(compilerMode.javacopts()).compile(nestedTypesFile);
assertThat(compilation).succeeded();
assertThat(compilation)
.generatedSourceFile("test.DaggerOuterType_SimpleComponent")
@@ -506,7 +501,7 @@
"import dagger.internal.Preconditions;",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" private final TestModule testModule;",
"",
@@ -514,13 +509,13 @@
" this.testModule = testModuleParam;",
" }",
"",
- " private B getB() {",
+ " private B b() {",
" return TestModule_BFactory.b(testModule, new C());",
" }",
"",
" @Override",
" public A a() {",
- " return new A(getB());",
+ " return new A(b());",
" }",
"",
" static final class Builder {",
@@ -542,8 +537,7 @@
.build();
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(aFile, bFile, cFile, moduleFile, componentFile);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -610,22 +604,21 @@
.addLines(
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
- " private B getB() {",
+ " private B b() {",
" return TestModule_BFactory.b(new C());",
" }",
"",
" @Override",
" public A a() {",
- " return new A(getB());",
+ " return new A(b());",
" }",
"}")
.build();
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(aFile, bFile, cFile, moduleFile, componentFile);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -708,7 +701,7 @@
"import dagger.internal.Preconditions;",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" static final class Builder {",
"",
@@ -754,8 +747,7 @@
" }",
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(
always,
testModule,
@@ -789,7 +781,7 @@
"@Component(modules = RootModule.class)",
"interface TestComponent {}");
assertThat(
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(rootModule, component))
+ compilerWithOptions(compilerMode.javacopts()).compile(rootModule, component))
.failed();
assertThat(
daggerCompiler(
@@ -828,7 +820,7 @@
" ChildComponent childComponent();",
"}");
assertThat(
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(subcomponent, component))
+ compilerWithOptions(compilerMode.javacopts()).compile(subcomponent, component))
.failed();
assertThat(
daggerCompiler(
@@ -893,7 +885,7 @@
"import dagger.internal.Preconditions;",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerParent implements Parent {",
"",
" private DaggerParent() {}",
@@ -927,8 +919,7 @@
" }",
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(component, module, subcomponent);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -962,8 +953,7 @@
" BClass bClass();",
"}");
assertThat(
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(aModule, aClass, bClass, component))
.succeeded();
}
@@ -1007,7 +997,7 @@
"",
"import com.google.errorprone.annotations.CanIgnoreReturnValue;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerSimpleComponent implements SimpleComponent {",
" @Override",
" public void inject(SomeInjectedType instance) {",
@@ -1029,8 +1019,7 @@
.build();
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(injectableTypeFile, injectedTypeFile, componentFile);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -1064,7 +1053,7 @@
"test.DaggerSimpleComponent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerSimpleComponent implements SimpleComponent {",
" private Provider<SimpleComponent> simpleComponentProvider;",
"",
@@ -1084,8 +1073,7 @@
" }",
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(injectableTypeFile, componentFile);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -1129,7 +1117,7 @@
"",
"import com.google.errorprone.annotations.CanIgnoreReturnValue;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerSimpleComponent implements SimpleComponent {",
" @Override",
" public SomeInjectedType createAndInject() {",
@@ -1147,8 +1135,7 @@
.build();
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(injectableTypeFile, injectedTypeFile, componentFile);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -1198,11 +1185,9 @@
.addLines(
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerBComponent implements BComponent {")
- .addLinesIn(
- DEFAULT_MODE,
- " private Provider<A> aProvider;")
+ .addLinesIn(DEFAULT_MODE, " private Provider<A> aProvider;")
.addLinesIn(
FAST_INIT_MODE,
" private final AComponent aComponent;",
@@ -1212,7 +1197,7 @@
" this.aComponent = aComponentParam;",
" }",
"",
- " private Provider<A> getAProvider() {",
+ " private Provider<A> aProvider() {",
" Object local = aProvider;",
" if (local == null) {",
" local = new SwitchingProvider<>(0);",
@@ -1226,16 +1211,9 @@
" private void initialize(final AComponent aComponentParam) {",
" this.aProvider = new test_AComponent_a(aComponentParam);",
" }")
- .addLines(
- "",
- " @Override",
- " public B b() {")
- .addLinesIn(
- DEFAULT_MODE,
- " return new B(aProvider);")
- .addLinesIn(
- FAST_INIT_MODE,
- " return new B(getAProvider());")
+ .addLines("", " @Override", " public B b() {")
+ .addLinesIn(DEFAULT_MODE, " return new B(aProvider);")
+ .addLinesIn(FAST_INIT_MODE, " return new B(aProvider());")
.addLines(
" }",
"",
@@ -1263,8 +1241,7 @@
" ",
" @Override()",
" public A get() {",
- " return Preconditions.checkNotNull(",
- " aComponent.a(), " + NPE_FROM_COMPONENT_METHOD + ");",
+ " return Preconditions.checkNotNullFromComponent(aComponent.a());",
" }",
" }",
"}")
@@ -1277,9 +1254,8 @@
" switch (id) {",
" case 0:",
" return (T)",
- " Preconditions.checkNotNull(",
- " DaggerBComponent.this.aComponent.a(),",
- " " + NPE_FROM_COMPONENT_METHOD + ");",
+ " Preconditions.checkNotNullFromComponent(",
+ " DaggerBComponent.this.aComponent.a());",
" default:",
" throw new AssertionError(id);",
" }",
@@ -1287,8 +1263,7 @@
" }")
.build();
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(aFile, bFile, aComponentFile, bComponentFile);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -1343,7 +1318,7 @@
"test.DaggerTestComponent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" private final TestModule testModule;",
" private final other.test.TestModule testModule2;",
@@ -1391,8 +1366,7 @@
" }",
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(aFile, otherAFile, moduleFile, otherModuleFile, componentFile);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -1469,7 +1443,7 @@
"import dagger.internal.Preconditions;",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerBComponent implements BComponent {",
" private final AComponent aComponent;",
"",
@@ -1480,20 +1454,17 @@
" @Override",
" public InjectedType injectedType() {",
" return new InjectedType(",
- " Preconditions.checkNotNull(",
- " aComponent.someStringInjection(),",
- " \"Cannot return null from a non-@Nullable component method\"),",
+ " Preconditions.checkNotNullFromComponent(",
+ " aComponent.someStringInjection()),",
" aComponent.someIntInjection(),",
" aComponent,",
- " Preconditions.checkNotNull(",
- " aComponent.someClassInjection(),",
- " \"Cannot return null from a non-@Nullable component method\"));",
+ " Preconditions.checkNotNullFromComponent(",
+ " aComponent.someClassInjection()));",
" }",
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(injectedTypeFile, aComponentFile, bComponentFile);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -1556,15 +1527,15 @@
"",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
- " private B getB() {",
+ " private B b() {",
" return new B(new C());",
" }",
"",
" @Override",
" public A a() {",
- " return new A(getB());",
+ " return new A(b());",
" }",
"",
" @Override",
@@ -1580,8 +1551,7 @@
.build();
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(aFile, bFile, cFile, xFile, componentFile);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -1637,7 +1607,7 @@
"",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerSimpleComponent implements SimpleComponent {",
" private DaggerSimpleComponent() {}",
"",
@@ -1663,8 +1633,7 @@
" }",
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(
injectableTypeFile,
componentSupertypeAFile,
@@ -1707,7 +1676,7 @@
"test.DaggerSimpleComponent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerSimpleComponent implements SimpleComponent {",
" @Override",
" public SomeInjectableType someInjectableType() {",
@@ -1715,8 +1684,7 @@
" }",
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(injectableTypeFile, componentSupertype, depComponentFile);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -1763,8 +1731,7 @@
" C c();",
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(aFile, bFile, cFile, componentFile);
assertThat(compilation).failed();
assertThat(compilation)
@@ -1787,7 +1754,7 @@
" String[] array();",
"}");
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(component);
+ compilerWithOptions(compilerMode.javacopts()).compile(component);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining("String[] cannot be provided without an @Provides-annotated method");
@@ -2013,7 +1980,7 @@
" @Inject @AScope AClass() {}",
"}");
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(aScope, aClass);
+ compilerWithOptions(compilerMode.javacopts()).compile(aScope, aClass);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining("@Scope annotations are not allowed on @Inject constructors")
@@ -2082,7 +2049,7 @@
"import dagger.internal.Preconditions;",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerParent implements Parent {",
" private DaggerParent() {",
" }",
@@ -2111,8 +2078,7 @@
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(foo, module, component, prunedSubcomponent);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -2175,7 +2141,7 @@
assertThat(compilation).failed();
assertThat(compilation).hadErrorCount(1);
assertThat(compilation)
- .hadErrorContaining("java.lang.String is bound multiple times")
+ .hadErrorContaining("String is bound multiple times")
.inFile(component)
.onLineContaining("interface TestComponent");
}
@@ -2183,8 +2149,7 @@
@Test
public void nullIncorrectlyReturnedFromNonNullableInlinedProvider() {
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(
JavaFileObjects.forSourceLines(
"test.TestModule",
@@ -2225,7 +2190,7 @@
"test.TestModule_NonNullableStringFactory",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class TestModule_NonNullableStringFactory",
" implements Factory<String> {",
" @Override",
@@ -2234,8 +2199,8 @@
" }",
"",
" public static String nonNullableString() {",
- " return Preconditions.checkNotNull(",
- " TestModule.nonNullableString(), " + NPE_FROM_PROVIDES_METHOD + ");",
+ " return Preconditions.checkNotNullFromProvides(",
+ " TestModule.nonNullableString());",
" }",
"}"));
@@ -2245,7 +2210,7 @@
.addLines(
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" @Override",
" public String nonNullableString() {",
@@ -2274,8 +2239,7 @@
@Test
public void nullCheckingIgnoredWhenProviderReturnsPrimitive() {
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(
JavaFileObjects.forSourceLines(
"test.TestModule",
@@ -2316,7 +2280,7 @@
"test.TestModule_PrimitiveIntegerFactory",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class TestModule_PrimitiveIntegerFactory",
" implements Factory<Integer> {",
"",
@@ -2336,7 +2300,7 @@
.addLines(
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" @Override",
" public Integer nonNullableInteger() {",
@@ -2412,9 +2376,9 @@
JavaFileObjects.forSourceLines(
"test.DaggerParent",
"package test;",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerParent implements Parent {",
- " private String getString() {",
+ " private String string() {",
" return TestModule_StringFactory.string(numberProvider.get());",
" }",
"}");
@@ -2482,7 +2446,7 @@
JavaFileObjects.forSourceLines(
"test.DaggerParent",
"package test;",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerParent implements Parent {",
" private final class ChildImpl implements Child {",
" @Override",
@@ -2549,7 +2513,7 @@
"test.DaggerTestComponent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" @Override",
" public Injected injected() {",
@@ -2622,7 +2586,7 @@
"test.DaggerTestComponent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" @Override",
" public String unqualified() {",
@@ -2676,7 +2640,7 @@
"",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class DaggerPublicComponent implements PublicComponent {",
" private DaggerPublicComponent() {}",
"",
diff --git a/javatests/dagger/internal/codegen/ComponentRequirementFieldTest.java b/javatests/dagger/internal/codegen/ComponentRequirementFieldTest.java
index 85e2d7b..049ff85 100644
--- a/javatests/dagger/internal/codegen/ComponentRequirementFieldTest.java
+++ b/javatests/dagger/internal/codegen/ComponentRequirementFieldTest.java
@@ -17,9 +17,8 @@
package dagger.internal.codegen;
import static com.google.testing.compile.CompilationSubject.assertThat;
-import static dagger.internal.codegen.Compilers.daggerCompiler;
-import static dagger.internal.codegen.GeneratedLines.GENERATED_ANNOTATION;
-import static dagger.internal.codegen.GeneratedLines.NPE_FROM_COMPONENT_METHOD;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
+import static dagger.internal.codegen.GeneratedLines.GENERATED_CODE_ANNOTATIONS;
import com.google.testing.compile.Compilation;
import com.google.testing.compile.JavaFileObjects;
@@ -67,7 +66,7 @@
" }",
"}");
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(component);
+ compilerWithOptions(compilerMode.javacopts()).compile(component);
assertThat(compilation).succeeded();
assertThat(compilation)
.generatedSourceFile("test.DaggerTestComponent")
@@ -76,7 +75,7 @@
"test.DaggerTestComponent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" private final Integer i;",
" private final List<String> list;",
@@ -162,8 +161,7 @@
" long l();",
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(module, otherPackageModule, component);
assertThat(compilation).succeeded();
JavaFileObject generatedComponent =
@@ -174,7 +172,7 @@
"import other.OtherPackageModule;",
"import other.OtherPackageModule_LFactory;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" private final ParentModule parentModule;",
" private final OtherPackageModule otherPackageModule;",
@@ -236,8 +234,7 @@
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(dependency, component, subcomponent);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -247,7 +244,7 @@
"test.DaggerTestComponent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" private final Dep dep;",
"",
@@ -267,14 +264,13 @@
"",
" @Override",
" public String methodOnDep() {",
- " return Preconditions.checkNotNull(",
- " dep.string(), " + NPE_FROM_COMPONENT_METHOD + " );",
+ " return Preconditions.checkNotNullFromComponent(",
+ " dep.string());",
" }",
"",
" @Override",
" public Object otherMethodOnDep() {",
- " return Preconditions.checkNotNull(",
- " dep.object(), " + NPE_FROM_COMPONENT_METHOD + " );",
+ " return Preconditions.checkNotNullFromComponent(dep.object());",
" }",
"",
" private final class TestSubcomponentImpl implements TestSubcomponent {",
@@ -361,7 +357,7 @@
"test.DaggerTestComponent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" private final ParentModule parentModule;",
"",
@@ -370,15 +366,15 @@
" }",
"",
" private final class TestSubcomponentImpl implements TestSubcomponent {",
- " private Set<Object> getSetOfObject() {",
+ " private Set<Object> setOfObject() {",
" return ImmutableSet.<Object>of(",
" ParentModule_ContributionFactory.contribution(),",
" ChildModule_ContributionFactory.contribution());",
" }",
"",
- " private Object getObject() {",
+ " private Object object() {",
" return ParentModule_ReliesOnMultibindingFactory.reliesOnMultibinding(",
- " DaggerTestComponent.this.parentModule, getSetOfObject());",
+ " DaggerTestComponent.this.parentModule, setOfObject());",
" }",
" }",
"}");
@@ -389,7 +385,7 @@
"test.DaggerTestComponent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" private final ParentModule parentModule;",
"",
@@ -425,8 +421,7 @@
"}");
}
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(parentModule, childModule, component, subcomponent);
assertThat(compilation).succeeded();
assertThat(compilation)
diff --git a/javatests/dagger/internal/codegen/ComponentShardTest.java b/javatests/dagger/internal/codegen/ComponentShardTest.java
new file mode 100644
index 0000000..fc59c92
--- /dev/null
+++ b/javatests/dagger/internal/codegen/ComponentShardTest.java
@@ -0,0 +1,281 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen;
+
+import static com.google.testing.compile.CompilationSubject.assertThat;
+import static com.google.testing.compile.Compiler.javac;
+import static dagger.internal.codegen.GeneratedLines.GENERATED_CODE_ANNOTATIONS;
+import static java.util.stream.Collectors.joining;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.testing.compile.Compilation;
+import com.google.testing.compile.Compiler;
+import com.google.testing.compile.JavaFileObjects;
+import java.util.Arrays;
+import javax.tools.JavaFileObject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class ComponentShardTest {
+ private static final int BINDINGS_PER_SHARD = 10;
+
+ @Test
+ public void testNewShardCreated() {
+ // Create 2N + 1 bindings: N in DaggerTestComponent, N in Shard1, and 1 in Shard2
+ int numBindings = 2 * BINDINGS_PER_SHARD + 1;
+ ImmutableList.Builder<JavaFileObject> javaFileObjects = ImmutableList.builder();
+ ImmutableList.Builder<String> entryPoints = ImmutableList.builder();
+ for (int i = 0; i < numBindings; i++) {
+ String bindingName = "Binding" + i;
+ entryPoints.add(String.format("%1$s get%1$s();", bindingName));
+ entryPoints.add(String.format("Provider<%1$s> get%1$sProvider();", bindingName));
+
+ // Add dependencies between main component and shard1: 9 -> 10 -> Provider<9>
+ // Add dependencies between shard1 and shard2: 19 -> 20 -> Provider<19>
+ switch (i) {
+ case 9:
+ javaFileObjects.add(createBinding(bindingName, "Binding10 dep"));
+ break;
+ case 10:
+ javaFileObjects.add(createBinding(bindingName, "Provider<Binding9> dep"));
+ break;
+ case 19:
+ javaFileObjects.add(createBinding(bindingName, "Binding20 dep"));
+ break;
+ case 20:
+ javaFileObjects.add(createBinding(bindingName, "Provider<Binding19> dep"));
+ break;
+ default:
+ javaFileObjects.add(createBinding(bindingName));
+ break;
+ }
+ }
+
+ javaFileObjects.add(createComponent(entryPoints.build()));
+
+ // This generated component shows a couple things:
+ // 1. Binding locations:
+ // * Binding #9 belongs to DaggerTestComponent
+ // * Binding #10 belongs to Shard1
+ // * Binding #20 belongs to Shard2
+ // 2. DaggerTestComponent entry point methods:
+ // * Binding #9 implementation is inlined DaggerTestComponent.
+ // * Binding #10 implementation is delegated to Shard1.
+ // * Binding #20 implementation is delegated to Shard2.
+ // 3. Dependencies between component and shard:
+ // * Binding #9 in DaggerTestComponent depends on #10 in Shard1.
+ // * Binding #10 in Shard1 depends on Provider<#9> in DaggerTestComponent.
+ // 4. Dependencies between shard and shard:
+ // * Binding #19 in Shard1 depends on #20 in Shard2.
+ // * Binding #20 in Shard2 depends on Provider<#19> in Shard1.
+ JavaFileObject generatedComponent =
+ JavaFileObjects.forSourceLines(
+ "dagger.internal.codegen.DaggerTestComponent",
+ "package dagger.internal.codegen;",
+ GENERATED_CODE_ANNOTATIONS,
+ "final class DaggerTestComponent implements TestComponent {",
+ " private final Shard1 shard1 = new Shard1();",
+ "",
+ " private volatile Provider<Binding9> binding9Provider;",
+ "",
+ " private volatile Object binding9 = new MemoizedSentinel();",
+ "",
+ " @Override",
+ " public Binding9 getBinding9() {",
+ " Object local = binding9;",
+ " if (local instanceof MemoizedSentinel) {",
+ " synchronized (local) {",
+ " local = binding9;",
+ " if (local instanceof MemoizedSentinel) {",
+ " local = new Binding9(DaggerTestComponent.this.shard1.binding10());",
+ " binding9 = DoubleCheck.reentrantCheck(binding9, local);",
+ " }",
+ " }",
+ " }",
+ " return (Binding9) local;",
+ " }",
+ "",
+ " @Override",
+ " public Provider<Binding9> getBinding9Provider() {",
+ " Object local = binding9Provider;",
+ " if (local == null) {",
+ " local = new SwitchingProvider<>(9);",
+ " binding9Provider = (Provider<Binding9>) local;",
+ " }",
+ " return (Provider<Binding9>) local;",
+ " }",
+ "",
+ " @Override",
+ " public Binding10 getBinding10() {",
+ " return DaggerTestComponent.this.shard1.binding10();",
+ " }",
+ "",
+ " @Override",
+ " public Provider<Binding10> getBinding10Provider() {",
+ " return DaggerTestComponent.this.shard1.binding10Provider();",
+ " }",
+ "",
+ " @Override",
+ " public Binding20 getBinding20() {",
+ " return DaggerTestComponent.this.shard2.binding20();",
+ " }",
+ "",
+ " @Override",
+ " public Provider<Binding20> getBinding20Provider() {",
+ " return DaggerTestComponent.this.shard2.binding20Provider();",
+ " }",
+ "",
+ " private final class Shard1 {",
+ " private volatile Object binding10 = new MemoizedSentinel();",
+ "",
+ " private volatile Provider<Binding10> binding10Provider;",
+ "",
+ " private volatile Provider<Binding19> binding19Provider;",
+ "",
+ " private volatile Object binding19 = new MemoizedSentinel();",
+ "",
+ " private Binding10 binding10() {",
+ " Object local = binding10;",
+ " if (local instanceof MemoizedSentinel) {",
+ " synchronized (local) {",
+ " local = binding10;",
+ " if (local instanceof MemoizedSentinel) {",
+ " local = new Binding10(",
+ " DaggerTestComponent.this.getBinding9Provider());",
+ " binding10 = DoubleCheck.reentrantCheck(binding10, local);",
+ " }",
+ " }",
+ " }",
+ " return (Binding10) local;",
+ " }",
+ "",
+ " private Provider<Binding10> binding10Provider() {",
+ " Object local = binding10Provider;",
+ " if (local == null) {",
+ " local = new SwitchingProvider<>(10);",
+ " binding10Provider = (Provider<Binding10>) local;",
+ " }",
+ " return (Provider<Binding10>) local;",
+ " }",
+ "",
+ " private Provider<Binding19> binding19Provider() {",
+ " Object local = binding19Provider;",
+ " if (local == null) {",
+ " local = new SwitchingProvider<>(19);",
+ " binding19Provider = (Provider<Binding19>) local;",
+ " }",
+ " return (Provider<Binding19>) local;",
+ " }",
+ "",
+ " private Binding19 binding19() {",
+ " Object local = binding19;",
+ " if (local instanceof MemoizedSentinel) {",
+ " synchronized (local) {",
+ " local = binding19;",
+ " if (local instanceof MemoizedSentinel) {",
+ " local = new Binding19(DaggerTestComponent.this.shard2.binding20());",
+ " binding19 = DoubleCheck.reentrantCheck(binding19, local);",
+ " }",
+ " }",
+ " }",
+ " return (Binding19) local;",
+ " }",
+ " }",
+ "",
+ " private final class Shard2 {",
+ " private volatile Object binding20 = new MemoizedSentinel();",
+ "",
+ " private volatile Provider<Binding20> binding20Provider;",
+ "",
+ " private Binding20 binding20() {",
+ " Object local = binding20;",
+ " if (local instanceof MemoizedSentinel) {",
+ " synchronized (local) {",
+ " local = binding20;",
+ " if (local instanceof MemoizedSentinel) {",
+ " local = new Binding20(",
+ " DaggerTestComponent.this.shard1.binding19Provider());",
+ " binding20 = DoubleCheck.reentrantCheck(binding20, local);",
+ " }",
+ " }",
+ " }",
+ " return (Binding20) local;",
+ " }",
+ "",
+ " private Provider<Binding20> binding20Provider() {",
+ " Object local = binding20Provider;",
+ " if (local == null) {",
+ " local = new SwitchingProvider<>(20);",
+ " binding20Provider = (Provider<Binding20>) local;",
+ " }",
+ " return (Provider<Binding20>) local;",
+ " }",
+ " }",
+ "}");
+
+ Compilation compilation = compilerWithAndroidMode().compile(javaFileObjects.build());
+ assertThat(compilation).succeededWithoutWarnings();
+ assertThat(compilation)
+ .generatedSourceFile("dagger.internal.codegen.DaggerTestComponent")
+ .containsElementsIn(generatedComponent);
+ }
+
+ private static JavaFileObject createBinding(String bindingName, String... deps) {
+ return JavaFileObjects.forSourceLines(
+ "dagger.internal.codegen." + bindingName,
+ "package dagger.internal.codegen;",
+ "",
+ "import javax.inject.Inject;",
+ "import javax.inject.Provider;",
+ "import javax.inject.Singleton;",
+ "",
+ "@Singleton",
+ "final class " + bindingName + " {",
+ " @Inject",
+ " " + bindingName + "(" + Arrays.stream(deps).collect(joining(", ")) + ") {}",
+ "}");
+ }
+
+ private static JavaFileObject createComponent(ImmutableList<String> entryPoints) {
+ return JavaFileObjects.forSourceLines(
+ "dagger.internal.codegen.TestComponent",
+ "package dagger.internal.codegen;",
+ "",
+ "import dagger.Component;",
+ "import javax.inject.Provider;",
+ "import javax.inject.Singleton;",
+ "",
+ "@Singleton",
+ "@Component",
+ "interface TestComponent {",
+ " " + entryPoints.stream().collect(joining("\n ")),
+ "}");
+ }
+
+ private static Compiler compilerWithAndroidMode() {
+ return javac()
+ .withProcessors(new ComponentProcessor())
+ .withOptions(
+ ImmutableSet.builder()
+ .add("-Adagger.keysPerComponentShard=" + BINDINGS_PER_SHARD)
+ .addAll(CompilerMode.FAST_INIT_MODE.javacopts())
+ .build());
+ }
+}
diff --git a/javatests/dagger/internal/codegen/ComponentValidationTest.java b/javatests/dagger/internal/codegen/ComponentValidationTest.java
index 169a318..6c642a4 100644
--- a/javatests/dagger/internal/codegen/ComponentValidationTest.java
+++ b/javatests/dagger/internal/codegen/ComponentValidationTest.java
@@ -17,6 +17,7 @@
package dagger.internal.codegen;
import static com.google.testing.compile.CompilationSubject.assertThat;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
import static dagger.internal.codegen.Compilers.daggerCompiler;
import static dagger.internal.codegen.TestUtils.message;
@@ -219,6 +220,17 @@
message(
"test.ComponentShort contains a cycle in its component dependencies:",
" test.ComponentShort"));
+
+ // Test that this also fails when transitive validation is disabled.
+ compilation =
+ compilerWithOptions("-Adagger.validateTransitiveComponentDependencies=DISABLED")
+ .compile(shortLifetime);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
+ message(
+ "test.ComponentShort contains a cycle in its component dependencies:",
+ " test.ComponentShort"));
}
@Test
@@ -281,6 +293,13 @@
" test.ComponentMedium",
" test.ComponentShort"))
.inFile(shortLifetime);
+
+ // Test that compilation succeeds when transitive validation is disabled because the cycle
+ // cannot be detected.
+ compilation =
+ compilerWithOptions("-Adagger.validateTransitiveComponentDependencies=DISABLED")
+ .compile(longLifetime, mediumLifetime, shortLifetime);
+ assertThat(compilation).succeeded();
}
@Test
diff --git a/javatests/dagger/internal/codegen/DaggerModuleMethodSubject.java b/javatests/dagger/internal/codegen/DaggerModuleMethodSubject.java
index 1fcf7bc..470b1ed 100644
--- a/javatests/dagger/internal/codegen/DaggerModuleMethodSubject.java
+++ b/javatests/dagger/internal/codegen/DaggerModuleMethodSubject.java
@@ -36,7 +36,7 @@
import javax.tools.JavaFileObject;
/** A {@link Truth} subject for testing Dagger module methods. */
-final class DaggerModuleMethodSubject extends Subject<DaggerModuleMethodSubject, String> {
+final class DaggerModuleMethodSubject extends Subject {
/** A {@link Truth} subject factory for testing Dagger module methods. */
static final class Factory implements Subject.Factory<DaggerModuleMethodSubject, String> {
diff --git a/javatests/dagger/internal/codegen/DelegateBindingExpressionTest.java b/javatests/dagger/internal/codegen/DelegateBindingExpressionTest.java
index 2f4aecf..bc729fc 100644
--- a/javatests/dagger/internal/codegen/DelegateBindingExpressionTest.java
+++ b/javatests/dagger/internal/codegen/DelegateBindingExpressionTest.java
@@ -19,8 +19,8 @@
import static com.google.testing.compile.CompilationSubject.assertThat;
import static dagger.internal.codegen.CompilerMode.DEFAULT_MODE;
import static dagger.internal.codegen.CompilerMode.FAST_INIT_MODE;
-import static dagger.internal.codegen.Compilers.daggerCompiler;
-import static dagger.internal.codegen.GeneratedLines.GENERATED_ANNOTATION;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
+import static dagger.internal.codegen.GeneratedLines.GENERATED_CODE_ANNOTATIONS;
import com.google.testing.compile.Compilation;
import com.google.testing.compile.CompilationSubject;
@@ -144,14 +144,14 @@
.addLines(
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {")
.addLinesIn(
FAST_INIT_MODE,
" private volatile Object regularScoped = new MemoizedSentinel();",
" private volatile ReusableScoped reusableScoped;",
"",
- " private RegularScoped getRegularScoped() {",
+ " private RegularScoped regularScoped() {",
" Object local = regularScoped;",
" if (local instanceof MemoizedSentinel) {",
" synchronized (local) {",
@@ -165,7 +165,7 @@
" return (RegularScoped) local;",
" }",
"",
- " private ReusableScoped getReusableScoped() {",
+ " private ReusableScoped reusableScoped() {",
" Object local = reusableScoped;",
" if (local == null) {",
" local = new ReusableScoped();",
@@ -223,14 +223,14 @@
.addLines(
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {")
.addLinesIn(
FAST_INIT_MODE,
" private volatile Object regularScoped = new MemoizedSentinel();",
" private volatile ReusableScoped reusableScoped;",
"",
- " private RegularScoped getRegularScoped() {",
+ " private RegularScoped regularScoped() {",
" Object local = regularScoped;",
" if (local instanceof MemoizedSentinel) {",
" synchronized (local) {",
@@ -244,7 +244,7 @@
" return (RegularScoped) local;",
" }",
"",
- " private ReusableScoped getReusableScoped() {",
+ " private ReusableScoped reusableScoped() {",
" Object local = reusableScoped;",
" if (local == null) {",
" local = new ReusableScoped();",
@@ -299,14 +299,14 @@
.addLines(
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {")
.addLinesIn(
FAST_INIT_MODE,
" private volatile Object regularScoped = new MemoizedSentinel();",
" private volatile ReusableScoped reusableScoped;",
"",
- " private RegularScoped getRegularScoped() {",
+ " private RegularScoped regularScoped() {",
" Object local = regularScoped;",
" if (local instanceof MemoizedSentinel) {",
" synchronized (local) {",
@@ -320,7 +320,7 @@
" return (RegularScoped) local;",
" }",
"",
- " private ReusableScoped getReusableScoped() {",
+ " private ReusableScoped reusableScoped() {",
" Object local = reusableScoped;",
" if (local == null) {",
" local = new ReusableScoped();",
@@ -390,8 +390,7 @@
" other.Supertype supertype();",
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(accessibleSupertype, inaccessibleSubtype, module, component);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -402,7 +401,7 @@
.addLines(
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {")
.addLinesIn(
DEFAULT_MODE,
@@ -422,7 +421,7 @@
FAST_INIT_MODE,
" private volatile Object subtype = new MemoizedSentinel();",
"",
- " private Object getSubtype() {",
+ " private Object subtype() {",
" Object local = subtype;",
" if (local instanceof MemoizedSentinel) {",
" synchronized (local) {",
@@ -438,7 +437,7 @@
"",
" @Override",
" public Supertype supertype() {",
- " return (Supertype) getSubtype();",
+ " return (Supertype) subtype();",
" }")
.build());
}
@@ -499,8 +498,7 @@
" other.UsesSupertype usesSupertype();",
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(supertype, subtype, usesSupertype, module, component);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -511,7 +509,7 @@
.addLines(
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {")
.addLinesIn(
DEFAULT_MODE,
@@ -528,7 +526,7 @@
FAST_INIT_MODE,
" private volatile Object subtype = new MemoizedSentinel();",
"",
- " private Object getSubtype() {",
+ " private Object subtype() {",
" Object local = subtype;",
" if (local instanceof MemoizedSentinel) {",
" synchronized (local) {",
@@ -544,7 +542,7 @@
"",
" @Override",
" public UsesSupertype usesSupertype() {",
- " return UsesSupertype_Factory.newInstance(getSubtype());",
+ " return UsesSupertype_Factory.newInstance(subtype());",
" }")
.build());
}
@@ -590,8 +588,7 @@
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(module, component);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -602,7 +599,7 @@
.addLines(
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {")
.addLinesIn(
DEFAULT_MODE,
@@ -620,7 +617,7 @@
FAST_INIT_MODE,
" private volatile Provider<String> provideStringProvider;",
"",
- " private Provider<String> getStringProvider() {",
+ " private Provider<String> stringProvider() {",
" Object local = provideStringProvider;",
" if (local == null) {",
" local = new SwitchingProvider<>(0);",
@@ -631,12 +628,12 @@
"",
" @Override",
" public Provider<CharSequence> charSequence() {",
- " return (Provider) getStringProvider();",
+ " return (Provider) stringProvider();",
" }",
"",
" @Override",
" public Provider<String> namedString() {",
- " return getStringProvider();",
+ " return stringProvider();",
" }",
"",
" private final class SwitchingProvider<T> implements Provider<T> {",
@@ -692,8 +689,7 @@
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(module, component);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -704,7 +700,7 @@
.addLines(
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {")
.addLinesIn(
DEFAULT_MODE,
@@ -721,7 +717,7 @@
FAST_INIT_MODE,
" private volatile Provider<String> provideStringProvider;",
"",
- " private Provider<String> getStringProvider() {",
+ " private Provider<String> stringProvider() {",
" Object local = provideStringProvider;",
" if (local == null) {",
" local = new SwitchingProvider<>(0);",
@@ -732,12 +728,12 @@
"",
" @Override",
" public Provider<CharSequence> charSequence() {",
- " return (Provider) getStringProvider();",
+ " return (Provider) stringProvider();",
" }",
"",
" @Override",
" public Provider<Object> object() {",
- " return (Provider) getStringProvider();",
+ " return (Provider) stringProvider();",
" }",
"",
" private final class SwitchingProvider<T> implements Provider<T> {",
@@ -798,8 +794,7 @@
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(supertype, injectableSubtype, module, component);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -810,7 +805,7 @@
.addLines(
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerRequestsSubtypeAsProvider",
" implements RequestsSubtypeAsProvider {")
.addLinesIn(
@@ -824,7 +819,7 @@
FAST_INIT_MODE,
" private volatile Provider subtypeProvider;",
"",
- " private Provider getSubtypeProvider() {",
+ " private Provider subtypeProvider() {",
" Object local = subtypeProvider;",
" if (local == null) {",
" local = new SwitchingProvider<>(0);",
@@ -835,7 +830,7 @@
"",
" @Override",
" public Provider<Supertype> supertypeProvider() {",
- " return getSubtypeProvider();",
+ " return subtypeProvider();",
" }",
"",
" private final class SwitchingProvider<T> implements Provider<T> {",
@@ -888,11 +883,10 @@
"@Singleton",
"@Component(modules = TestModule.class)",
"interface TestComponent {",
- " Provider<Object> getObject();",
+ " Provider<Object> object();",
"}");
- Compilation compilation = daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ Compilation compilation = compilerWithOptions(compilerMode.javacopts())
.compile(module, component);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -903,7 +897,7 @@
.addLines(
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {")
.addLinesIn(
DEFAULT_MODE,
@@ -919,7 +913,7 @@
" }",
"",
" @Override",
- " public Provider<Object> getObject() {",
+ " public Provider<Object> object() {",
" return bindStringProvider;",
" }",
"}")
@@ -929,7 +923,7 @@
" private volatile Object object = new MemoizedSentinel();",
" private volatile Provider<Object> bindStringProvider;",
"",
- " private String getString() {",
+ " private String string() {",
" Object local = string;",
" if (local == null) {",
" local = TestModule_ProvideStringFactory.provideString();",
@@ -938,13 +932,13 @@
" return (String) local;",
" }",
"",
- " private Object getObject2() {",
+ " private Object object2() {",
" Object local = object;",
" if (local instanceof MemoizedSentinel) {",
" synchronized (local) {",
" local = object;",
" if (local instanceof MemoizedSentinel) {",
- " local = getString();",
+ " local = string();",
" object = DoubleCheck.reentrantCheck(object, local);",
" }",
" }",
@@ -953,7 +947,7 @@
" }",
"",
" @Override",
- " public Provider<Object> getObject() {",
+ " public Provider<Object> object() {",
" Object local = bindStringProvider;",
" if (local == null) {",
" local = new SwitchingProvider<>(0);",
@@ -967,7 +961,7 @@
" @Override",
" public T get() {",
" switch (id) {",
- " case 0: return (T) DaggerTestComponent.this.getObject2();",
+ " case 0: return (T) DaggerTestComponent.this.object2();",
" default: throw new AssertionError(id);",
" }",
" }",
@@ -977,8 +971,7 @@
private CompilationSubject assertThatCompilationWithModule(JavaFileObject module) {
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(
module,
COMPONENT,
diff --git a/javatests/dagger/internal/codegen/DependencyCycleValidationTest.java b/javatests/dagger/internal/codegen/DependencyCycleValidationTest.java
index 4a4e0a5..22547b5 100644
--- a/javatests/dagger/internal/codegen/DependencyCycleValidationTest.java
+++ b/javatests/dagger/internal/codegen/DependencyCycleValidationTest.java
@@ -17,6 +17,7 @@
package dagger.internal.codegen;
import static com.google.testing.compile.CompilationSubject.assertThat;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
import static dagger.internal.codegen.Compilers.daggerCompiler;
import static dagger.internal.codegen.TestUtils.endsWithMessage;
import static dagger.internal.codegen.TestUtils.message;
@@ -75,14 +76,14 @@
.hadErrorContaining(
message(
"Found a dependency cycle:",
- " test.Outer.C is injected at",
- " test.Outer.A(cParam)",
- " test.Outer.A is injected at",
- " test.Outer.B(aParam)",
- " test.Outer.B is injected at",
- " test.Outer.C(bParam)",
- " test.Outer.C is provided at",
- " test.Outer.CComponent.getC()"))
+ " Outer.C is injected at",
+ " Outer.A(cParam)",
+ " Outer.A is injected at",
+ " Outer.B(aParam)",
+ " Outer.B is injected at",
+ " Outer.C(bParam)",
+ " Outer.C is requested at",
+ " Outer.CComponent.getC()"))
.inFile(SIMPLE_CYCLIC_DEPENDENCY)
.onLineContaining("interface CComponent");
@@ -92,21 +93,28 @@
@Test
public void cyclicDependencyWithModuleBindingValidation() {
// Cycle errors should not show a dependency trace to an entry point when doing full binding
- // graph validation. So ensure that the message doesn't end with "test.Outer.C is provided at
+ // graph validation. So ensure that the message doesn't end with "test.Outer.C is requested at
// test.Outer.CComponent.getC()", as the previous test's message does.
Pattern moduleBindingValidationError =
endsWithMessage(
"Found a dependency cycle:",
- " test.Outer.C is injected at",
- " test.Outer.A(cParam)",
- " test.Outer.A is injected at",
- " test.Outer.B(aParam)",
- " test.Outer.B is injected at",
- " test.Outer.C(bParam)");
+ " Outer.C is injected at",
+ " Outer.A(cParam)",
+ " Outer.A is injected at",
+ " Outer.B(aParam)",
+ " Outer.B is injected at",
+ " Outer.C(bParam)",
+ "",
+ "======================",
+ "Full classname legend:",
+ "======================",
+ "Outer: test.Outer",
+ "========================",
+ "End of classname legend:",
+ "========================");
Compilation compilation =
- daggerCompiler()
- .withOptions("-Adagger.fullBindingGraphValidation=ERROR")
+ compilerWithOptions("-Adagger.fullBindingGraphValidation=ERROR")
.compile(SIMPLE_CYCLIC_DEPENDENCY);
assertThat(compilation).failed();
@@ -163,16 +171,16 @@
.hadErrorContaining(
message(
"Found a dependency cycle:",
- " test.Outer.C is injected at",
- " test.Outer.A(cParam)",
- " test.Outer.A is injected at",
- " test.Outer.B(aParam)",
- " test.Outer.B is injected at",
- " test.Outer.C(bParam)",
- " test.Outer.C is injected at",
- " test.Outer.D(cParam)",
- " test.Outer.D is provided at",
- " test.Outer.DComponent.getD()"))
+ " Outer.C is injected at",
+ " Outer.A(cParam)",
+ " Outer.A is injected at",
+ " Outer.B(aParam)",
+ " Outer.B is injected at",
+ " Outer.C(bParam)",
+ " Outer.C is injected at",
+ " Outer.D(cParam)",
+ " Outer.D is requested at",
+ " Outer.DComponent.getD()"))
.inFile(component)
.onLineContaining("interface DComponent");
}
@@ -226,16 +234,16 @@
.hadErrorContaining(
message(
"Found a dependency cycle:",
- " test.Outer.C is injected at",
- " test.Outer.CModule.c(c)",
- " java.util.Map<java.lang.String,test.Outer.C> is injected at",
- " test.Outer.A(cMap)",
- " test.Outer.A is injected at",
- " test.Outer.B(aParam)",
- " test.Outer.B is injected at",
- " test.Outer.C(bParam)",
- " test.Outer.C is provided at",
- " test.Outer.CComponent.getC()"))
+ " Outer.C is injected at",
+ " Outer.CModule.c(c)",
+ " Map<String,Outer.C> is injected at",
+ " Outer.A(cMap)",
+ " Outer.A is injected at",
+ " Outer.B(aParam)",
+ " Outer.B is injected at",
+ " Outer.C(bParam)",
+ " Outer.C is requested at",
+ " Outer.CComponent.getC()"))
.inFile(component)
.onLineContaining("interface CComponent");
}
@@ -287,16 +295,16 @@
.hadErrorContaining(
message(
"Found a dependency cycle:",
- " test.Outer.C is injected at",
- " test.Outer.CModule.c(c)",
- " java.util.Set<test.Outer.C> is injected at",
- " test.Outer.A(cSet)",
- " test.Outer.A is injected at",
- " test.Outer.B(aParam)",
- " test.Outer.B is injected at",
- " test.Outer.C(bParam)",
- " test.Outer.C is provided at",
- " test.Outer.CComponent.getC()"))
+ " Outer.C is injected at",
+ " Outer.CModule.c(c)",
+ " Set<Outer.C> is injected at",
+ " Outer.A(cSet)",
+ " Outer.A is injected at",
+ " Outer.B(aParam)",
+ " Outer.B is injected at",
+ " Outer.C(bParam)",
+ " Outer.C is requested at",
+ " Outer.CComponent.getC()"))
.inFile(component)
.onLineContaining("interface CComponent");
}
@@ -343,16 +351,16 @@
.hadErrorContaining(
message(
"Found a dependency cycle:",
- " test.Outer.C is injected at",
- " test.Outer.A(cParam)",
- " test.Outer.A is injected at",
- " test.Outer.B(aParam)",
- " test.Outer.B is injected at",
- " test.Outer.C(bParam)",
- " javax.inject.Provider<test.Outer.C> is injected at",
- " test.Outer.D(cParam)",
- " test.Outer.D is provided at",
- " test.Outer.DComponent.getD()"))
+ " Outer.C is injected at",
+ " Outer.A(cParam)",
+ " Outer.A is injected at",
+ " Outer.B(aParam)",
+ " Outer.B is injected at",
+ " Outer.C(bParam)",
+ " Provider<Outer.C> is injected at",
+ " Outer.D(cParam)",
+ " Outer.D is requested at",
+ " Outer.DComponent.getD()"))
.inFile(component)
.onLineContaining("interface DComponent");
}
@@ -427,12 +435,12 @@
.hadErrorContaining(
message(
"Found a dependency cycle:",
- " java.lang.String is injected at",
- " test.CycleModule.object(string)",
- " java.lang.Object is injected at",
- " test.CycleModule.string(object)",
- " java.lang.String is provided at",
- " test.Grandchild.entry()"))
+ " String is injected at",
+ " CycleModule.object(string)",
+ " Object is injected at",
+ " CycleModule.string(object)",
+ " String is requested at",
+ " Grandchild.entry()"))
.inFile(parent)
.onLineContaining("interface Parent");
}
@@ -509,12 +517,12 @@
.hadErrorContaining(
message(
"Found a dependency cycle:",
- " java.lang.String is injected at",
- " test.CycleModule.object(string)",
- " java.lang.Object is injected at",
- " test.CycleModule.string(object)",
- " java.lang.String is provided at",
- " test.Child.entry() [test.Parent → test.Child]"))
+ " String is injected at",
+ " CycleModule.object(string)",
+ " Object is injected at",
+ " CycleModule.string(object)",
+ " String is requested at",
+ " Child.entry() [Parent → Child]"))
.inFile(parent)
.onLineContaining("interface Parent");
}
@@ -560,12 +568,12 @@
.hadErrorContaining(
message(
"Found a dependency cycle:",
- " java.lang.Object is injected at",
- " test.TestModule.bindQualified(unqualified)",
- " @test.SomeQualifier java.lang.Object is injected at",
- " test.TestModule.bindUnqualified(qualified)",
- " java.lang.Object is provided at",
- " test.TestComponent.unqualified()"))
+ " Object is injected at",
+ " TestModule.bindQualified(unqualified)",
+ " @SomeQualifier Object is injected at",
+ " TestModule.bindUnqualified(qualified)",
+ " Object is requested at",
+ " TestComponent.unqualified()"))
.inFile(component)
.onLineContaining("interface TestComponent");
}
@@ -602,10 +610,10 @@
.hadErrorContaining(
message(
"Found a dependency cycle:",
- " java.lang.Object is injected at",
- " test.TestModule.bindToSelf(sameKey)",
- " java.lang.Object is provided at",
- " test.TestComponent.selfReferential()"))
+ " Object is injected at",
+ " TestModule.bindToSelf(sameKey)",
+ " Object is requested at",
+ " TestComponent.selfReferential()"))
.inFile(component)
.onLineContaining("interface TestComponent");
}
@@ -659,7 +667,7 @@
" test.B is injected at",
" test.A.b",
" test.A is injected at",
- " test.CycleComponent.inject(test.A)"))
+ " CycleComponent.inject(test.A)"))
.inFile(component)
.onLineContaining("interface CycleComponent");
}
diff --git a/javatests/dagger/internal/codegen/DiagnosticFormattingTest.java b/javatests/dagger/internal/codegen/DiagnosticFormattingTest.java
index a2da92f..9b0dde0 100644
--- a/javatests/dagger/internal/codegen/DiagnosticFormattingTest.java
+++ b/javatests/dagger/internal/codegen/DiagnosticFormattingTest.java
@@ -18,6 +18,7 @@
import static com.google.common.truth.Truth.assertThat;
+import dagger.internal.codegen.base.DiagnosticFormatting;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
diff --git a/javatests/dagger/internal/codegen/DuplicateBindingsValidationTest.java b/javatests/dagger/internal/codegen/DuplicateBindingsValidationTest.java
index 14a6fb9..fbda59d 100644
--- a/javatests/dagger/internal/codegen/DuplicateBindingsValidationTest.java
+++ b/javatests/dagger/internal/codegen/DuplicateBindingsValidationTest.java
@@ -17,6 +17,7 @@
package dagger.internal.codegen;
import static com.google.testing.compile.CompilationSubject.assertThat;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
import static dagger.internal.codegen.Compilers.daggerCompiler;
import static dagger.internal.codegen.TestUtils.message;
import static org.junit.Assume.assumeFalse;
@@ -82,14 +83,16 @@
"}");
Compilation compilation =
- daggerCompiler().withOptions(fullBindingGraphValidationOption()).compile(component);
+ compilerWithOptions(
+ fullBindingGraphValidationOption())
+ .compile(component);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
message(
- "test.Outer.A is bound multiple times:",
- " @Provides test.Outer.A test.Outer.AModule.provideA(String)",
- " test.Outer.A test.Outer.Parent.getA()"))
+ "Outer.A is bound multiple times:",
+ " @Provides Outer.A Outer.AModule.provideA(String)",
+ " Outer.A Outer.Parent.getA()"))
.inFile(component)
.onLineContaining("interface Child");
}
@@ -134,14 +137,16 @@
"}");
Compilation compilation =
- daggerCompiler().withOptions(fullBindingGraphValidationOption()).compile(component);
+ compilerWithOptions(
+ fullBindingGraphValidationOption())
+ .compile(component);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
message(
- "test.Outer.A is bound multiple times:",
- " @Provides test.Outer.A test.Outer.Module1.provideA1()",
- " @Provides test.Outer.A test.Outer.Module2.provideA2(String)"))
+ "Outer.A is bound multiple times:",
+ " @Provides Outer.A Outer.Module1.provideA1()",
+ " @Provides Outer.A Outer.Module2.provideA2(String)"))
.inFile(component)
.onLineContaining("interface TestComponent");
@@ -149,9 +154,9 @@
assertThat(compilation)
.hadErrorContaining(
message(
- "test.Outer.A is bound multiple times:",
- " @Provides test.Outer.A test.Outer.Module1.provideA1()",
- " @Provides test.Outer.A test.Outer.Module2.provideA2(String)"))
+ "Outer.A is bound multiple times:",
+ " @Provides Outer.A Outer.Module1.provideA1()",
+ " @Provides Outer.A Outer.Module2.provideA2(String)"))
.inFile(component)
.onLineContaining("class Module3");
}
@@ -200,14 +205,16 @@
"}");
Compilation compilation =
- daggerCompiler().withOptions(fullBindingGraphValidationOption()).compile(component);
+ compilerWithOptions(
+ fullBindingGraphValidationOption())
+ .compile(component);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
message(
- "test.Outer.A is bound multiple times:",
- " @Provides test.Outer.A test.Outer.Module1.provideA1()",
- " @Binds test.Outer.A test.Outer.Module2.bindA2(test.Outer.B)"))
+ "Outer.A is bound multiple times:",
+ " @Provides Outer.A Outer.Module1.provideA1()",
+ " @Binds Outer.A Outer.Module2.bindA2(Outer.B)"))
.inFile(component)
.onLineContaining("interface TestComponent");
@@ -215,9 +222,9 @@
assertThat(compilation)
.hadErrorContaining(
message(
- "test.Outer.A is bound multiple times:",
- " @Provides test.Outer.A test.Outer.Module1.provideA1()",
- " @Binds test.Outer.A test.Outer.Module2.bindA2(test.Outer.B)"))
+ "Outer.A is bound multiple times:",
+ " @Provides Outer.A Outer.Module1.provideA1()",
+ " @Binds Outer.A Outer.Module2.bindA2(Outer.B)"))
.inFile(component)
.onLineContaining("class Module3");
}
@@ -268,20 +275,22 @@
"}");
Compilation compilation =
- daggerCompiler().withOptions(fullBindingGraphValidationOption()).compile(component);
+ compilerWithOptions(
+ fullBindingGraphValidationOption())
+ .compile(component);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
message(
- "java.util.Set<java.lang.String> has incompatible bindings or declarations:",
+ "Set<String> has incompatible bindings or declarations:",
" Set bindings and declarations:",
- " @Binds @dagger.multibindings.IntoSet String "
- + "test.Outer.TestModule1.bindStringSetElement(@test.Outer.SomeQualifier "
+ " @Binds @IntoSet String "
+ + "Outer.TestModule1.bindStringSetElement(@Outer.SomeQualifier "
+ "String)",
- " @Provides @dagger.multibindings.IntoSet String "
- + "test.Outer.TestModule1.stringSetElement()",
+ " @Provides @IntoSet String "
+ + "Outer.TestModule1.stringSetElement()",
" Unique bindings and declarations:",
- " @Provides Set<String> test.Outer.TestModule2.stringSet()"))
+ " @Provides Set<String> Outer.TestModule2.stringSet()"))
.inFile(component)
.onLineContaining(
fullBindingGraphValidation ? "class TestModule3" : "interface TestComponent");
@@ -337,23 +346,23 @@
"}");
Compilation compilation =
- daggerCompiler().withOptions(fullBindingGraphValidationOption()).compile(component);
+ compilerWithOptions(
+ fullBindingGraphValidationOption())
+ .compile(component);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
message(
- "java.util.Map<java.lang.String,java.lang.String> has incompatible bindings "
+ "Map<String,String> has incompatible bindings "
+ "or declarations:",
" Map bindings and declarations:",
- " @Binds @dagger.multibindings.IntoMap "
- + "@dagger.multibindings.StringKey(\"bar\") String"
- + " test.Outer.TestModule1.bindStringMapEntry(@test.Outer.SomeQualifier "
+ " @Binds @IntoMap @StringKey(\"bar\") String"
+ + " Outer.TestModule1.bindStringMapEntry(@Outer.SomeQualifier "
+ "String)",
- " @Provides @dagger.multibindings.IntoMap "
- + "@dagger.multibindings.StringKey(\"foo\") String"
- + " test.Outer.TestModule1.stringMapEntry()",
+ " @Provides @IntoMap @StringKey(\"foo\") String"
+ + " Outer.TestModule1.stringMapEntry()",
" Unique bindings and declarations:",
- " @Provides Map<String,String> test.Outer.TestModule2.stringMap()"))
+ " @Provides Map<String,String> Outer.TestModule2.stringMap()"))
.inFile(component)
.onLineContaining(
fullBindingGraphValidation ? "class TestModule3" : "interface TestComponent");
@@ -394,17 +403,19 @@
"}");
Compilation compilation =
- daggerCompiler().withOptions(fullBindingGraphValidationOption()).compile(component);
+ compilerWithOptions(
+ fullBindingGraphValidationOption())
+ .compile(component);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
message(
- "java.util.Set<java.lang.String> has incompatible bindings or declarations:",
+ "Set<String> has incompatible bindings or declarations:",
" Set bindings and declarations:",
- " @dagger.multibindings.Multibinds Set<String> "
- + "test.Outer.TestModule1.stringSet()",
+ " @Multibinds Set<String> "
+ + "Outer.TestModule1.stringSet()",
" Unique bindings and declarations:",
- " @Provides Set<String> test.Outer.TestModule2.stringSet()"))
+ " @Provides Set<String> Outer.TestModule2.stringSet()"))
.inFile(component)
.onLineContaining(
fullBindingGraphValidation ? "class TestModule3" : "interface TestComponent");
@@ -447,18 +458,20 @@
"}");
Compilation compilation =
- daggerCompiler().withOptions(fullBindingGraphValidationOption()).compile(component);
+ compilerWithOptions(
+ fullBindingGraphValidationOption())
+ .compile(component);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
message(
- "java.util.Map<java.lang.String,java.lang.String> has incompatible bindings "
+ "Map<String,String> has incompatible bindings "
+ "or declarations:",
" Map bindings and declarations:",
- " @dagger.multibindings.Multibinds Map<String,String> "
- + "test.Outer.TestModule1.stringMap()",
+ " @Multibinds Map<String,String> "
+ + "Outer.TestModule1.stringMap()",
" Unique bindings and declarations:",
- " @Provides Map<String,String> test.Outer.TestModule2.stringMap()"))
+ " @Provides Map<String,String> Outer.TestModule2.stringMap()"))
.inFile(component)
.onLineContaining(
fullBindingGraphValidation ? "class TestModule3" : "interface TestComponent");
@@ -574,22 +587,24 @@
"}");
Compilation compilation =
- daggerCompiler().withOptions(fullBindingGraphValidationOption()).compile(component);
+ compilerWithOptions(
+ fullBindingGraphValidationOption())
+ .compile(component);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
message(
- "test.Outer.A is bound multiple times:",
- " @Provides test.Outer.A test.Outer.Module01.provideA()",
- " @Provides test.Outer.A test.Outer.Module02.provideA()",
- " @Provides test.Outer.A test.Outer.Module03.provideA()",
- " @Provides test.Outer.A test.Outer.Module04.provideA()",
- " @Provides test.Outer.A test.Outer.Module05.provideA()",
- " @Provides test.Outer.A test.Outer.Module06.provideA()",
- " @Provides test.Outer.A test.Outer.Module07.provideA()",
- " @Provides test.Outer.A test.Outer.Module08.provideA()",
- " @Provides test.Outer.A test.Outer.Module09.provideA()",
- " @Provides test.Outer.A test.Outer.Module10.provideA()",
+ "Outer.A is bound multiple times:",
+ " @Provides Outer.A Outer.Module01.provideA()",
+ " @Provides Outer.A Outer.Module02.provideA()",
+ " @Provides Outer.A Outer.Module03.provideA()",
+ " @Provides Outer.A Outer.Module04.provideA()",
+ " @Provides Outer.A Outer.Module05.provideA()",
+ " @Provides Outer.A Outer.Module06.provideA()",
+ " @Provides Outer.A Outer.Module07.provideA()",
+ " @Provides Outer.A Outer.Module08.provideA()",
+ " @Provides Outer.A Outer.Module09.provideA()",
+ " @Provides Outer.A Outer.Module10.provideA()",
" and 2 others"))
.inFile(component)
.onLineContaining(fullBindingGraphValidation ? "class Modules" : "interface TestComponent");
@@ -646,14 +661,14 @@
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(fullBindingGraphValidationOption())
+ compilerWithOptions(
+ fullBindingGraphValidationOption())
.compile(aComponent, bComponent);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
message(
- "java.lang.Object is bound multiple times:",
+ "Object is bound multiple times:",
" @Provides Object test.A.AModule.abConflict()",
" @Provides Object test.B.BModule.abConflict()"))
.inFile(aComponent)
@@ -727,14 +742,14 @@
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(fullBindingGraphValidationOption())
+ compilerWithOptions(
+ fullBindingGraphValidationOption())
.compile(aComponent, bComponent, cComponent);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
message(
- "java.lang.Object is bound multiple times:",
+ "Object is bound multiple times:",
" @Provides Object test.A.AModule.acConflict()",
" @Provides Object test.C.CModule.acConflict()"))
.inFile(aComponent)
@@ -803,14 +818,14 @@
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(fullBindingGraphValidationOption())
+ compilerWithOptions(
+ fullBindingGraphValidationOption())
.compile(aComponent, bComponent, cComponent);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
message(
- "java.lang.Object is bound multiple times:",
+ "Object is bound multiple times:",
" @Provides Object test.B.BModule.bcConflict()",
" @Provides Object test.C.CModule.bcConflict()"))
.inFile(fullBindingGraphValidation ? bComponent : aComponent)
@@ -933,10 +948,10 @@
assertThat(compilation)
.hadWarningContaining(
message(
- "test.Foo is bound multiple times:",
- " @Inject test.Foo(Set<String>) [test.Injected1]",
- " @Provides test.Foo test.Provided1.Provided1Module.provideFoo(Set<String>) "
- + "[test.Injected1 → test.Injected2 → test.Provided1]"))
+ "Foo is bound multiple times:",
+ " @Inject Foo(Set<String>) [Injected1]",
+ " @Provides Foo Provided1.Provided1Module.provideFoo(Set<String>) "
+ + "[Injected1 → Injected2 → Provided1]"))
.inFile(injected1)
.onLineContaining("interface Injected1 {");
}
@@ -991,17 +1006,18 @@
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions("-Adagger.nullableValidation=WARNING", fullBindingGraphValidationOption())
+ compilerWithOptions(
+ "-Adagger.nullableValidation=WARNING",
+ fullBindingGraphValidationOption())
.compile(parentConflictsWithChild, child);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
message(
- "java.lang.Object is bound multiple times:",
- " @Provides Object test.Child.ChildModule.nonNullableParentChildConflict()",
- " @Provides @javax.annotation.Nullable Object"
- + " test.ParentConflictsWithChild.ParentModule.nullableParentChildConflict()"))
+ "Object is bound multiple times:",
+ " @Provides Object Child.ChildModule.nonNullableParentChildConflict()",
+ " @Provides @Nullable Object"
+ + " ParentConflictsWithChild.ParentModule.nullableParentChildConflict()"))
.inFile(parentConflictsWithChild)
.onLineContaining(
fullBindingGraphValidation
@@ -1075,7 +1091,7 @@
Compilation compilation = daggerCompiler().compile(parent, parentModule, child, childModule);
assertThat(compilation).failed();
assertThat(compilation)
- .hadErrorContaining("java.lang.String is bound multiple times")
+ .hadErrorContaining("String is bound multiple times")
.inFile(parent)
.onLineContaining("interface Parent");
assertThat(compilation).hadErrorCount(1);
diff --git a/javatests/dagger/internal/codegen/ElementDescriptorsTest.java b/javatests/dagger/internal/codegen/ElementDescriptorsTest.java
new file mode 100644
index 0000000..e97e360
--- /dev/null
+++ b/javatests/dagger/internal/codegen/ElementDescriptorsTest.java
@@ -0,0 +1,239 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.testing.compile.CompilationRule;
+import dagger.internal.codegen.langmodel.DaggerElements;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.util.ElementFilter;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class ElementDescriptorsTest {
+
+ @Rule public CompilationRule compilation = new CompilationRule();
+
+ static class TestClassA<T> {
+ int field1;
+ String field2;
+ T field3;
+ List<String> field4;
+ }
+
+ @Test
+ public void fieldDescriptor() {
+ assertThat(getFieldDescriptors(TestClassA.class.getCanonicalName()))
+ .containsExactly(
+ "field1:I",
+ "field2:Ljava/lang/String;",
+ "field3:Ljava/lang/Object;",
+ "field4:Ljava/util/List;");
+ }
+
+ static class TestClassB<T> {
+ void method1(boolean yesOrNo, int number) {}
+
+ byte method2(char letter) {
+ return 0;
+ }
+
+ void method3(double realNumber1, float realNummber2) {}
+
+ void method4(long bigNumber, short littlerNumber) {}
+ }
+
+ @Test
+ public void methodDescriptor_primitives() {
+ assertThat(getMethodDescriptors(TestClassB.class.getCanonicalName()))
+ .containsExactly("method1(ZI)V", "method2(C)B", "method3(DF)V", "method4(JS)V");
+ }
+
+ static class TestClassC<T> {
+ void method1(Object something) {}
+
+ Object method2() {
+ return null;
+ }
+
+ List<String> method3(ArrayList<Integer> list) {
+ return null;
+ }
+
+ Map<String, Object> method4() {
+ return null;
+ }
+ }
+
+ @Test
+ public void methodDescriptor_javaTypes() {
+ assertThat(getMethodDescriptors(TestClassC.class.getCanonicalName()))
+ .containsExactly(
+ "method1(Ljava/lang/Object;)V",
+ "method2()Ljava/lang/Object;",
+ "method3(Ljava/util/ArrayList;)Ljava/util/List;",
+ "method4()Ljava/util/Map;");
+ }
+
+ static class TestClassD<T> {
+ void method1(TestDataClass data) {}
+
+ TestDataClass method2() {
+ return null;
+ }
+ }
+
+ @Test
+ public void methodDescriptor_testTypes() {
+ assertThat(getMethodDescriptors(TestClassD.class.getCanonicalName()))
+ .containsExactly(
+ "method1(Ldagger/internal/codegen/TestDataClass;)V",
+ "method2()Ldagger/internal/codegen/TestDataClass;");
+ }
+
+ static class TestClassE<T> {
+ void method1(TestDataClass[] data) {}
+
+ TestDataClass[] method2() {
+ return null;
+ }
+
+ void method3(int[] array) {}
+
+ void method4(int... array) {}
+ }
+
+ @Test
+ public void methodDescriptor_arrays() {
+ assertThat(getMethodDescriptors(TestClassE.class.getCanonicalName()))
+ .containsExactly(
+ "method1([Ldagger/internal/codegen/TestDataClass;)V",
+ "method2()[Ldagger/internal/codegen/TestDataClass;",
+ "method3([I)V",
+ "method4([I)V");
+ }
+
+ static class TestClassF<T> {
+ void method1(TestDataClass.MemberInnerData data) {}
+
+ void method2(TestDataClass.StaticInnerData data) {}
+
+ void method3(TestDataClass.EnumData enumData) {}
+
+ TestDataClass.StaticInnerData method4() {
+ return null;
+ }
+ }
+
+ @Test
+ public void methodDescriptor_innerTestType() {
+ assertThat(getMethodDescriptors(TestClassF.class.getCanonicalName()))
+ .containsExactly(
+ "method1(Ldagger/internal/codegen/TestDataClass$MemberInnerData;)V",
+ "method2(Ldagger/internal/codegen/TestDataClass$StaticInnerData;)V",
+ "method3(Ldagger/internal/codegen/TestDataClass$EnumData;)V",
+ "method4()Ldagger/internal/codegen/TestDataClass$StaticInnerData;");
+ }
+
+ @SuppressWarnings("TypeParameterUnusedInFormals")
+ static class TestClassG<T> {
+ void method1(T something) {}
+
+ T method2() {
+ return null;
+ }
+
+ List<? extends String> method3() {
+ return null;
+ }
+
+ Map<T, String> method4() {
+ return null;
+ }
+
+ ArrayList<Map<T, String>> method5() {
+ return null;
+ }
+
+ static <I, O extends I> O method6(I input) {
+ return null;
+ }
+
+ static <I, O extends String> O method7(I input) {
+ return null;
+ }
+
+ static <P extends Collection<String> & Comparable<String>> P method8() {
+ return null;
+ }
+
+ static <P extends String & List<Character>> P method9() {
+ return null;
+ }
+ }
+
+ @Test
+ public void methodDescriptor_erasure() {
+ assertThat(getMethodDescriptors(TestClassG.class.getCanonicalName()))
+ .containsExactly(
+ "method1(Ljava/lang/Object;)V",
+ "method2()Ljava/lang/Object;",
+ "method3()Ljava/util/List;",
+ "method4()Ljava/util/Map;",
+ "method5()Ljava/util/ArrayList;",
+ "method6(Ljava/lang/Object;)Ljava/lang/Object;",
+ "method7(Ljava/lang/Object;)Ljava/lang/String;",
+ "method8()Ljava/util/Collection;",
+ "method9()Ljava/lang/String;");
+ }
+
+ private Set<String> getFieldDescriptors(String className) {
+ TypeElement testElement = compilation.getElements().getTypeElement(className);
+ return ElementFilter.fieldsIn(testElement.getEnclosedElements()).stream()
+ .map(DaggerElements::getFieldDescriptor)
+ .collect(Collectors.toSet());
+ }
+
+ private Set<String> getMethodDescriptors(String className) {
+ TypeElement testElement = compilation.getElements().getTypeElement(className);
+ return ElementFilter.methodsIn(testElement.getEnclosedElements()).stream()
+ .map(DaggerElements::getMethodDescriptor)
+ .collect(Collectors.toSet());
+ }
+}
+
+@SuppressWarnings("ClassCanBeStatic")
+class TestDataClass {
+ class MemberInnerData {}
+
+ static class StaticInnerData {}
+
+ enum EnumData {
+ VALUE1,
+ VALUE2
+ }
+}
diff --git a/javatests/dagger/internal/codegen/ElidedFactoriesTest.java b/javatests/dagger/internal/codegen/ElidedFactoriesTest.java
index 58ddb82..6857039 100644
--- a/javatests/dagger/internal/codegen/ElidedFactoriesTest.java
+++ b/javatests/dagger/internal/codegen/ElidedFactoriesTest.java
@@ -17,8 +17,8 @@
package dagger.internal.codegen;
import static com.google.testing.compile.CompilationSubject.assertThat;
-import static dagger.internal.codegen.Compilers.daggerCompiler;
-import static dagger.internal.codegen.GeneratedLines.GENERATED_ANNOTATION;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
+import static dagger.internal.codegen.GeneratedLines.GENERATED_CODE_ANNOTATIONS;
import static dagger.internal.codegen.GeneratedLines.IMPORT_GENERATED_ANNOTATION;
import com.google.testing.compile.Compilation;
@@ -84,7 +84,7 @@
"",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerSimpleComponent implements SimpleComponent {",
" private DaggerSimpleComponent() {}",
"",
@@ -112,8 +112,7 @@
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(injectedType, dependsOnInjected, componentFile);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -185,7 +184,7 @@
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerSimpleComponent implements SimpleComponent {",
" private volatile Object scopedType = new MemoizedSentinel();",
" private volatile Provider<DependsOnScoped> dependsOnScopedProvider;",
@@ -200,7 +199,7 @@
" return new Builder().build();",
" }",
"",
- " private ScopedType getScopedType() {",
+ " private ScopedType scopedType() {",
" Object local = scopedType;",
" if (local instanceof MemoizedSentinel) {",
" synchronized (local) {",
@@ -214,11 +213,11 @@
" return (ScopedType) local;",
" }",
"",
- " private DependsOnScoped getDependsOnScoped() {",
- " return new DependsOnScoped(getScopedType());",
+ " private DependsOnScoped dependsOnScoped() {",
+ " return new DependsOnScoped(scopedType());",
" }",
"",
- " private Provider<DependsOnScoped> getDependsOnScopedProvider() {",
+ " private Provider<DependsOnScoped> dependsOnScopedProvider() {",
" Object local = dependsOnScopedProvider;",
" if (local == null) {",
" local = new SwitchingProvider<>(0);",
@@ -229,7 +228,7 @@
"",
" @Override",
" public NeedsProvider needsProvider() {",
- " return new NeedsProvider(getDependsOnScopedProvider());",
+ " return new NeedsProvider(dependsOnScopedProvider());",
" }",
"",
" static final class Builder {",
@@ -250,7 +249,7 @@
" @Override",
" public T get() {",
" switch (id) {",
- " case 0: return (T) DaggerSimpleComponent.this.getDependsOnScoped();",
+ " case 0: return (T) DaggerSimpleComponent.this.dependsOnScoped();",
" default: throw new AssertionError(id);",
" }",
" }",
@@ -267,7 +266,7 @@
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerSimpleComponent implements SimpleComponent {",
" private Provider<ScopedType> scopedTypeProvider;",
" private Provider<DependsOnScoped> dependsOnScopedProvider;",
@@ -307,8 +306,7 @@
"}");
}
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(scopedType, dependsOnScoped, componentFile, needsProvider);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -379,7 +377,7 @@
"import dagger.internal.MemoizedSentinel;",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerSimpleComponent implements SimpleComponent {",
" private volatile Object scopedType = new MemoizedSentinel();",
"",
@@ -393,7 +391,7 @@
" return new Builder().build();",
" }",
"",
- " private ScopedType getScopedType() {",
+ " private ScopedType scopedType() {",
" Object local = scopedType;",
" if (local instanceof MemoizedSentinel) {",
" synchronized (local) {",
@@ -425,7 +423,7 @@
"",
" @Override",
" public DependsOnScoped dependsOnScoped() {",
- " return new DependsOnScoped(DaggerSimpleComponent.this.getScopedType());",
+ " return new DependsOnScoped(DaggerSimpleComponent.this.scopedType());",
" }",
" }",
"}");
@@ -440,7 +438,7 @@
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerSimpleComponent implements SimpleComponent {",
" private Provider<ScopedType> scopedTypeProvider;",
"",
@@ -486,8 +484,7 @@
"}");
}
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(scopedType, dependsOnScoped, componentFile, subcomponentFile);
assertThat(compilation).succeeded();
assertThat(compilation)
diff --git a/javatests/dagger/internal/codegen/FrameworkFieldTest.java b/javatests/dagger/internal/codegen/FrameworkFieldTest.java
index cbc8c03..be495d7 100644
--- a/javatests/dagger/internal/codegen/FrameworkFieldTest.java
+++ b/javatests/dagger/internal/codegen/FrameworkFieldTest.java
@@ -24,6 +24,7 @@
import com.google.testing.compile.CompilationRule;
import com.squareup.javapoet.ClassName;
+import dagger.internal.codegen.binding.FrameworkField;
import javax.inject.Inject;
import org.junit.Before;
import org.junit.Rule;
diff --git a/javatests/dagger/internal/codegen/FrameworkTypeMapperTest.java b/javatests/dagger/internal/codegen/FrameworkTypeMapperTest.java
index 3e6e3ad..e27534d 100644
--- a/javatests/dagger/internal/codegen/FrameworkTypeMapperTest.java
+++ b/javatests/dagger/internal/codegen/FrameworkTypeMapperTest.java
@@ -23,6 +23,8 @@
import static dagger.model.RequestKind.PRODUCER;
import static dagger.model.RequestKind.PROVIDER;
+import dagger.internal.codegen.binding.FrameworkType;
+import dagger.internal.codegen.binding.FrameworkTypeMapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
diff --git a/javatests/dagger/internal/codegen/FullBindingGraphValidationTest.java b/javatests/dagger/internal/codegen/FullBindingGraphValidationTest.java
index 944e307..b56bc04 100644
--- a/javatests/dagger/internal/codegen/FullBindingGraphValidationTest.java
+++ b/javatests/dagger/internal/codegen/FullBindingGraphValidationTest.java
@@ -17,6 +17,7 @@
package dagger.internal.codegen;
import static com.google.testing.compile.CompilationSubject.assertThat;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
import static dagger.internal.codegen.Compilers.daggerCompiler;
import static dagger.internal.codegen.TestUtils.endsWithMessage;
@@ -48,9 +49,35 @@
// Make sure the error doesn't show other bindings or a dependency trace afterwards.
private static final Pattern MODULE_WITH_ERRORS_MESSAGE =
endsWithMessage(
- "[Dagger/DuplicateBindings] java.lang.Object is bound multiple times:",
- " @Binds Object test.ModuleWithErrors.object1(String)",
- " @Binds Object test.ModuleWithErrors.object2(Long)");
+ "\033[1;31m[Dagger/DuplicateBindings]\033[0m Object is bound multiple times:",
+ " @Binds Object ModuleWithErrors.object1(String)",
+ " @Binds Object ModuleWithErrors.object2(Long)",
+ " in component: [ModuleWithErrors]",
+ "",
+ "======================",
+ "Full classname legend:",
+ "======================",
+ "ModuleWithErrors: test.ModuleWithErrors",
+ "========================",
+ "End of classname legend:",
+ "========================");
+
+ private static final Pattern INCLUDES_MODULE_WITH_ERRORS_MESSAGE =
+ endsWithMessage(
+ "\033[1;31m[Dagger/DuplicateBindings]\033[0m Object is bound multiple times:",
+ " @Binds Object ModuleWithErrors.object1(String)",
+ " @Binds Object ModuleWithErrors.object2(Long)",
+ " in component: [IncludesModuleWithErrors]",
+ "",
+ "======================",
+ "Full classname legend:",
+ "======================",
+ "IncludesModuleWithErrors: test.IncludesModuleWithErrors",
+ "ModuleWithErrors: test.ModuleWithErrors",
+ "========================",
+ "End of classname legend:",
+ "========================");
+
@Test
public void moduleWithErrors_validationTypeNone() {
@@ -61,8 +88,7 @@
@Test
public void moduleWithErrors_validationTypeError() {
Compilation compilation =
- daggerCompiler()
- .withOptions("-Adagger.fullBindingGraphValidation=ERROR")
+ compilerWithOptions("-Adagger.fullBindingGraphValidation=ERROR")
.compile(MODULE_WITH_ERRORS);
assertThat(compilation).failed();
@@ -78,8 +104,7 @@
@Test
public void moduleWithErrors_validationTypeWarning() {
Compilation compilation =
- daggerCompiler()
- .withOptions("-Adagger.fullBindingGraphValidation=WARNING")
+ compilerWithOptions("-Adagger.fullBindingGraphValidation=WARNING")
.compile(MODULE_WITH_ERRORS);
assertThat(compilation).succeeded();
@@ -113,8 +138,7 @@
@Test
public void includesModuleWithErrors_validationTypeError() {
Compilation compilation =
- daggerCompiler()
- .withOptions("-Adagger.fullBindingGraphValidation=ERROR")
+ compilerWithOptions("-Adagger.fullBindingGraphValidation=ERROR")
.compile(MODULE_WITH_ERRORS, INCLUDES_MODULE_WITH_ERRORS);
assertThat(compilation).failed();
@@ -125,7 +149,7 @@
.onLineContaining("interface ModuleWithErrors");
assertThat(compilation)
- .hadErrorContainingMatch("test.ModuleWithErrors has errors")
+ .hadErrorContainingMatch("ModuleWithErrors has errors")
.inFile(INCLUDES_MODULE_WITH_ERRORS)
.onLineContaining("ModuleWithErrors.class");
@@ -135,8 +159,7 @@
@Test
public void includesModuleWithErrors_validationTypeWarning() {
Compilation compilation =
- daggerCompiler()
- .withOptions("-Adagger.fullBindingGraphValidation=WARNING")
+ compilerWithOptions("-Adagger.fullBindingGraphValidation=WARNING")
.compile(MODULE_WITH_ERRORS, INCLUDES_MODULE_WITH_ERRORS);
assertThat(compilation).succeeded();
@@ -148,7 +171,7 @@
// TODO(b/130284666)
assertThat(compilation)
- .hadWarningContainingMatch(MODULE_WITH_ERRORS_MESSAGE)
+ .hadWarningContainingMatch(INCLUDES_MODULE_WITH_ERRORS_MESSAGE)
.inFile(INCLUDES_MODULE_WITH_ERRORS)
.onLineContaining("interface IncludesModuleWithErrors");
@@ -184,9 +207,19 @@
// Make sure the error doesn't show other bindings or a dependency trace afterwards.
private static final Pattern COMBINED_WITH_A_MODULE_HAS_ERRORS_MESSAGE =
endsWithMessage(
- "[Dagger/DuplicateBindings] java.lang.Object is bound multiple times:",
- " @Binds Object test.AModule.object(String)",
- " @Binds Object test.CombinedWithAModuleHasErrors.object(Long)");
+ "\033[1;31m[Dagger/DuplicateBindings]\033[0m Object is bound multiple times:",
+ " @Binds Object AModule.object(String)",
+ " @Binds Object CombinedWithAModuleHasErrors.object(Long)",
+ " in component: [CombinedWithAModuleHasErrors]",
+ "",
+ "======================",
+ "Full classname legend:",
+ "======================",
+ "AModule: test.AModule",
+ "CombinedWithAModuleHasErrors: test.CombinedWithAModuleHasErrors",
+ "========================",
+ "End of classname legend:",
+ "========================");
@Test
public void moduleIncludingModuleWithCombinedErrors_validationTypeNone() {
@@ -198,8 +231,7 @@
@Test
public void moduleIncludingModuleWithCombinedErrors_validationTypeError() {
Compilation compilation =
- daggerCompiler()
- .withOptions("-Adagger.fullBindingGraphValidation=ERROR")
+ compilerWithOptions("-Adagger.fullBindingGraphValidation=ERROR")
.compile(A_MODULE, COMBINED_WITH_A_MODULE_HAS_ERRORS);
assertThat(compilation).failed();
@@ -215,8 +247,7 @@
@Test
public void moduleIncludingModuleWithCombinedErrors_validationTypeWarning() {
Compilation compilation =
- daggerCompiler()
- .withOptions("-Adagger.fullBindingGraphValidation=WARNING")
+ compilerWithOptions("-Adagger.fullBindingGraphValidation=WARNING")
.compile(A_MODULE, COMBINED_WITH_A_MODULE_HAS_ERRORS);
assertThat(compilation).succeeded();
@@ -249,10 +280,38 @@
// Make sure the error doesn't show other bindings or a dependency trace afterwards.
private static final Pattern SUBCOMPONENT_WITH_ERRORS_MESSAGE =
endsWithMessage(
- "[Dagger/DuplicateBindings] java.lang.Object is bound multiple times:",
- " @Binds Object test.AModule.object(String)",
- " @BindsInstance test.SubcomponentWithErrors.Builder"
- + " test.SubcomponentWithErrors.Builder.object(Object)");
+ "\033[1;31m[Dagger/DuplicateBindings]\033[0m Object is bound multiple times:",
+ " @Binds Object AModule.object(String)",
+ " @BindsInstance SubcomponentWithErrors.Builder"
+ + " SubcomponentWithErrors.Builder.object(Object)",
+ " in component: [SubcomponentWithErrors]",
+ "",
+ "======================",
+ "Full classname legend:",
+ "======================",
+ "AModule: test.AModule",
+ "SubcomponentWithErrors: test.SubcomponentWithErrors",
+ "========================",
+ "End of classname legend:",
+ "========================");
+
+ private static final Pattern MODULE_WITH_SUBCOMPONENT_WITH_ERRORS_MESSAGE =
+ endsWithMessage(
+ "\033[1;31m[Dagger/DuplicateBindings]\033[0m Object is bound multiple times:",
+ " @Binds Object AModule.object(String)",
+ " @BindsInstance SubcomponentWithErrors.Builder"
+ + " SubcomponentWithErrors.Builder.object(Object)",
+ " in component: [ModuleWithSubcomponentWithErrors → SubcomponentWithErrors]",
+ "",
+ "======================",
+ "Full classname legend:",
+ "======================",
+ "AModule: test.AModule",
+ "ModuleWithSubcomponentWithErrors: test.ModuleWithSubcomponentWithErrors",
+ "SubcomponentWithErrors: test.SubcomponentWithErrors",
+ "========================",
+ "End of classname legend:",
+ "========================");
@Test
public void subcomponentWithErrors_validationTypeNone() {
@@ -264,8 +323,7 @@
@Test
public void subcomponentWithErrors_validationTypeError() {
Compilation compilation =
- daggerCompiler()
- .withOptions("-Adagger.fullBindingGraphValidation=ERROR")
+ compilerWithOptions("-Adagger.fullBindingGraphValidation=ERROR")
.compile(SUBCOMPONENT_WITH_ERRORS, A_MODULE);
assertThat(compilation).failed();
@@ -281,8 +339,7 @@
@Test
public void subcomponentWithErrors_validationTypeWarning() {
Compilation compilation =
- daggerCompiler()
- .withOptions("-Adagger.fullBindingGraphValidation=WARNING")
+ compilerWithOptions("-Adagger.fullBindingGraphValidation=WARNING")
.compile(SUBCOMPONENT_WITH_ERRORS, A_MODULE);
assertThat(compilation).succeeded();
@@ -318,14 +375,13 @@
@Test
public void moduleWithSubcomponentWithErrors_validationTypeError() {
Compilation compilation =
- daggerCompiler()
- .withOptions("-Adagger.fullBindingGraphValidation=ERROR")
+ compilerWithOptions("-Adagger.fullBindingGraphValidation=ERROR")
.compile(MODULE_WITH_SUBCOMPONENT_WITH_ERRORS, SUBCOMPONENT_WITH_ERRORS, A_MODULE);
assertThat(compilation).failed();
assertThat(compilation)
- .hadErrorContainingMatch(SUBCOMPONENT_WITH_ERRORS_MESSAGE)
+ .hadErrorContainingMatch(MODULE_WITH_SUBCOMPONENT_WITH_ERRORS_MESSAGE)
.inFile(MODULE_WITH_SUBCOMPONENT_WITH_ERRORS)
.onLineContaining("interface ModuleWithSubcomponentWithErrors");
@@ -341,14 +397,13 @@
@Test
public void moduleWithSubcomponentWithErrors_validationTypeWarning() {
Compilation compilation =
- daggerCompiler()
- .withOptions("-Adagger.fullBindingGraphValidation=WARNING")
+ compilerWithOptions("-Adagger.fullBindingGraphValidation=WARNING")
.compile(MODULE_WITH_SUBCOMPONENT_WITH_ERRORS, SUBCOMPONENT_WITH_ERRORS, A_MODULE);
assertThat(compilation).succeeded();
assertThat(compilation)
- .hadWarningContainingMatch(SUBCOMPONENT_WITH_ERRORS_MESSAGE)
+ .hadWarningContainingMatch(MODULE_WITH_SUBCOMPONENT_WITH_ERRORS_MESSAGE)
.inFile(MODULE_WITH_SUBCOMPONENT_WITH_ERRORS)
.onLineContaining("interface ModuleWithSubcomponentWithErrors");
@@ -393,9 +448,20 @@
// Make sure the error doesn't show other bindings or a dependency trace afterwards.
private static final Pattern COMBINED_WITH_A_SUBCOMPONENT_HAS_ERRORS_MESSAGE =
endsWithMessage(
- "[Dagger/DuplicateBindings] java.lang.Object is bound multiple times:",
- " @Binds Object test.AModule.object(String)",
- " @Binds Object test.CombinedWithASubcomponentHasErrors.object(Number)");
+ "\033[1;31m[Dagger/DuplicateBindings]\033[0m Object is bound multiple times:",
+ " @Binds Object AModule.object(String)",
+ " @Binds Object CombinedWithASubcomponentHasErrors.object(Number)",
+ " in component: [CombinedWithASubcomponentHasErrors → ASubcomponent]",
+ "",
+ "======================",
+ "Full classname legend:",
+ "======================",
+ "AModule: test.AModule",
+ "ASubcomponent: test.ASubcomponent",
+ "CombinedWithASubcomponentHasErrors: test.CombinedWithASubcomponentHasErrors",
+ "========================",
+ "End of classname legend:",
+ "========================");
@Test
public void moduleWithSubcomponentWithCombinedErrors_validationTypeNone() {
@@ -408,8 +474,7 @@
@Test
public void moduleWithSubcomponentWithCombinedErrors_validationTypeError() {
Compilation compilation =
- daggerCompiler()
- .withOptions("-Adagger.fullBindingGraphValidation=ERROR")
+ compilerWithOptions("-Adagger.fullBindingGraphValidation=ERROR")
.compile(COMBINED_WITH_A_SUBCOMPONENT_HAS_ERRORS, A_SUBCOMPONENT, A_MODULE);
assertThat(compilation).failed();
@@ -425,8 +490,7 @@
@Test
public void moduleWithSubcomponentWithCombinedErrors_validationTypeWarning() {
Compilation compilation =
- daggerCompiler()
- .withOptions("-Adagger.fullBindingGraphValidation=WARNING")
+ compilerWithOptions("-Adagger.fullBindingGraphValidation=WARNING")
.compile(COMBINED_WITH_A_SUBCOMPONENT_HAS_ERRORS, A_SUBCOMPONENT, A_MODULE);
assertThat(compilation).succeeded();
@@ -442,8 +506,7 @@
@Test
public void bothAliasesDifferentValues() {
Compilation compilation =
- daggerCompiler()
- .withOptions(
+ compilerWithOptions(
"-Adagger.moduleBindingValidation=NONE",
"-Adagger.fullBindingGraphValidation=ERROR")
.compile(MODULE_WITH_ERRORS);
@@ -462,8 +525,7 @@
@Test
public void bothAliasesSameValue() {
Compilation compilation =
- daggerCompiler()
- .withOptions(
+ compilerWithOptions(
"-Adagger.moduleBindingValidation=NONE", "-Adagger.fullBindingGraphValidation=NONE")
.compile(MODULE_WITH_ERRORS);
diff --git a/javatests/dagger/internal/codegen/GeneratedLines.java b/javatests/dagger/internal/codegen/GeneratedLines.java
index 2aa17ac..f9a1b70 100644
--- a/javatests/dagger/internal/codegen/GeneratedLines.java
+++ b/javatests/dagger/internal/codegen/GeneratedLines.java
@@ -16,9 +16,7 @@
package dagger.internal.codegen;
-import static dagger.internal.codegen.javapoet.CodeBlocks.stringLiteral;
-
-import com.squareup.javapoet.CodeBlock;
+import com.google.common.base.Joiner;
/**
* Common lines outputted during code generation.
@@ -29,6 +27,12 @@
+ "value = \"dagger.internal.codegen.ComponentProcessor\", "
+ "comments = \"https://dagger.dev\")";
+ private static final String SUPPRESS_WARNINGS_ANNOTATION =
+ "@SuppressWarnings({\"unchecked\", \"rawtypes\"})";
+
+ public static final String GENERATED_CODE_ANNOTATIONS =
+ Joiner.on('\n').join(GENERATED_ANNOTATION, SUPPRESS_WARNINGS_ANNOTATION);
+
public static final String IMPORT_GENERATED_ANNOTATION =
isBeforeJava9()
? "import javax.annotation.Generated;"
@@ -44,10 +48,4 @@
return true;
}
}
-
- public static final CodeBlock NPE_FROM_PROVIDES_METHOD =
- stringLiteral("Cannot return null from a non-@Nullable @Provides method");
-
- public static final CodeBlock NPE_FROM_COMPONENT_METHOD =
- stringLiteral("Cannot return null from a non-@Nullable component method");
}
diff --git a/javatests/dagger/internal/codegen/InjectConstructorFactoryGeneratorTest.java b/javatests/dagger/internal/codegen/InjectConstructorFactoryGeneratorTest.java
index e6e9706..579e87a 100644
--- a/javatests/dagger/internal/codegen/InjectConstructorFactoryGeneratorTest.java
+++ b/javatests/dagger/internal/codegen/InjectConstructorFactoryGeneratorTest.java
@@ -20,8 +20,9 @@
import static com.google.testing.compile.CompilationSubject.assertThat;
import static com.google.testing.compile.JavaSourceSubjectFactory.javaSource;
import static com.google.testing.compile.JavaSourcesSubjectFactory.javaSources;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
import static dagger.internal.codegen.Compilers.daggerCompiler;
-import static dagger.internal.codegen.GeneratedLines.GENERATED_ANNOTATION;
+import static dagger.internal.codegen.GeneratedLines.GENERATED_CODE_ANNOTATIONS;
import static dagger.internal.codegen.GeneratedLines.IMPORT_GENERATED_ANNOTATION;
import com.google.common.collect.ImmutableList;
@@ -137,7 +138,7 @@
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class GenericClass_Factory<T> implements Factory<GenericClass<T>> {",
" private final Provider<T> tProvider;",
"",
@@ -147,7 +148,7 @@
"",
" @Override",
" public GenericClass<T> get() {",
- " return new GenericClass<T>(tProvider.get());",
+ " return newInstance(tProvider.get());",
" }",
"",
" public static <T> GenericClass_Factory<T> create(Provider<T> tProvider) {",
@@ -186,8 +187,9 @@
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
- "public final class GenericClass_Factory<A, B> implements Factory<GenericClass<A, B>> {",
+ GENERATED_CODE_ANNOTATIONS,
+ "public final class GenericClass_Factory<A, B> implements",
+ " Factory<GenericClass<A, B>> {",
" private final Provider<A> aProvider;",
" private final Provider<B> bProvider;",
"",
@@ -199,7 +201,7 @@
"",
" @Override",
" public GenericClass<A, B> get() {",
- " GenericClass<A, B> instance = new GenericClass<A, B>();",
+ " GenericClass<A, B> instance = newInstance();",
" GenericClass_MembersInjector.injectA(instance, aProvider.get());",
" GenericClass_MembersInjector.injectRegister(instance, bProvider.get());",
" return instance;",
@@ -237,24 +239,26 @@
"import dagger.internal.Factory;",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class GenericClass_Factory<T> implements Factory<GenericClass<T>> {",
- " @SuppressWarnings(\"rawtypes\")",
- " private static final GenericClass_Factory INSTANCE = new GenericClass_Factory();",
- "",
" @Override",
" public GenericClass<T> get() {",
- " return new GenericClass<T>();",
+ " return newInstance();",
" }",
"",
" @SuppressWarnings(\"unchecked\")",
" public static <T> GenericClass_Factory<T> create() {",
- " return INSTANCE;",
+ " return InstanceHolder.INSTANCE;",
" }",
"",
" public static <T> GenericClass<T> newInstance() {",
" return new GenericClass<T>();",
" }",
+ "",
+ " private static final class InstanceHolder {",
+ " @SuppressWarnings(\"rawtypes\")",
+ " private static final GenericClass_Factory INSTANCE = new GenericClass_Factory();",
+ " }",
"}");
assertAbout(javaSource()).that(file)
.processedWith(new ComponentProcessor())
@@ -280,8 +284,9 @@
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
- "public final class GenericClass_Factory<A, B> implements Factory<GenericClass<A, B>> {",
+ GENERATED_CODE_ANNOTATIONS,
+ "public final class GenericClass_Factory<A, B>",
+ " implements Factory<GenericClass<A, B>> {",
" private final Provider<A> aProvider;",
" private final Provider<B> bProvider;",
"",
@@ -292,7 +297,7 @@
"",
" @Override",
" public GenericClass<A, B> get() {",
- " return new GenericClass<A, B>(aProvider.get(), bProvider.get());",
+ " return newInstance(aProvider.get(), bProvider.get());",
" }",
"",
" public static <A, B> GenericClass_Factory<A, B> create(",
@@ -332,7 +337,7 @@
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class GenericClass_Factory<A extends Number & Comparable<A>,",
" B extends List<? extends String>,",
" C extends List<? super String>>",
@@ -351,8 +356,7 @@
"",
" @Override",
" public GenericClass<A, B, C> get() {",
- " return new GenericClass<A, B, C>(",
- " aProvider.get(), bProvider.get(), cProvider.get());",
+ " return newInstance(aProvider.get(), bProvider.get(), cProvider.get());",
" }",
"",
" public static <A extends Number & Comparable<A>,",
@@ -401,64 +405,110 @@
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class GenericClass_Factory<A, B>",
" implements Factory<GenericClass<A, B>> {",
- " private final Provider<A> aAndA2AndPaAndLaProvider;",
+ " private final Provider<A> aProvider;",
+ " private final Provider<A> a2Provider;",
+ " private final Provider<A> paProvider;",
" private final Provider<A> qaProvider;",
- " private final Provider<String> sAndS2AndPsAndLsProvider;",
+ " private final Provider<A> laProvider;",
+ " private final Provider<String> sProvider;",
+ " private final Provider<String> s2Provider;",
+ " private final Provider<String> psProvider;",
" private final Provider<String> qsProvider;",
- " private final Provider<B> bAndB2AndPbAndLbProvider;",
+ " private final Provider<String> lsProvider;",
+ " private final Provider<B> bProvider;",
+ " private final Provider<B> b2Provider;",
+ " private final Provider<B> pbProvider;",
" private final Provider<B> qbProvider;",
+ " private final Provider<B> lbProvider;",
"",
- " public GenericClass_Factory(Provider<A> aAndA2AndPaAndLaProvider,",
+ " public GenericClass_Factory(",
+ " Provider<A> aProvider,",
+ " Provider<A> a2Provider,",
+ " Provider<A> paProvider,",
" Provider<A> qaProvider,",
- " Provider<String> sAndS2AndPsAndLsProvider,",
+ " Provider<A> laProvider,",
+ " Provider<String> sProvider,",
+ " Provider<String> s2Provider,",
+ " Provider<String> psProvider,",
" Provider<String> qsProvider,",
- " Provider<B> bAndB2AndPbAndLbProvider,",
- " Provider<B> qbProvider) {",
- " this.aAndA2AndPaAndLaProvider = aAndA2AndPaAndLaProvider;",
+ " Provider<String> lsProvider,",
+ " Provider<B> bProvider,",
+ " Provider<B> b2Provider,",
+ " Provider<B> pbProvider,",
+ " Provider<B> qbProvider,",
+ " Provider<B> lbProvider) {",
+ " this.aProvider = aProvider;",
+ " this.a2Provider = a2Provider;",
+ " this.paProvider = paProvider;",
" this.qaProvider = qaProvider;",
- " this.sAndS2AndPsAndLsProvider = sAndS2AndPsAndLsProvider;",
+ " this.laProvider = laProvider;",
+ " this.sProvider = sProvider;",
+ " this.s2Provider = s2Provider;",
+ " this.psProvider = psProvider;",
" this.qsProvider = qsProvider;",
- " this.bAndB2AndPbAndLbProvider = bAndB2AndPbAndLbProvider;",
+ " this.lsProvider = lsProvider;",
+ " this.bProvider = bProvider;",
+ " this.b2Provider = b2Provider;",
+ " this.pbProvider = pbProvider;",
" this.qbProvider = qbProvider;",
+ " this.lbProvider = lbProvider;",
" }",
"",
" @Override",
" public GenericClass<A, B> get() {",
- " return new GenericClass<A, B>(",
- " aAndA2AndPaAndLaProvider.get(),",
- " aAndA2AndPaAndLaProvider.get(),",
- " aAndA2AndPaAndLaProvider,",
- " qaProvider.get(),",
- " DoubleCheck.lazy(aAndA2AndPaAndLaProvider),",
- " sAndS2AndPsAndLsProvider.get(),",
- " sAndS2AndPsAndLsProvider.get(),",
- " sAndS2AndPsAndLsProvider,",
- " qsProvider.get(),",
- " DoubleCheck.lazy(sAndS2AndPsAndLsProvider),",
- " bAndB2AndPbAndLbProvider.get(),",
- " bAndB2AndPbAndLbProvider.get(),",
- " bAndB2AndPbAndLbProvider,",
- " qbProvider.get(),",
- " DoubleCheck.lazy(bAndB2AndPbAndLbProvider));",
+ " return newInstance(",
+ " aProvider.get(),",
+ " a2Provider.get(),",
+ " paProvider,",
+ " qaProvider.get(),",
+ " DoubleCheck.lazy(laProvider),",
+ " sProvider.get(),",
+ " s2Provider.get(),",
+ " psProvider,",
+ " qsProvider.get(),",
+ " DoubleCheck.lazy(lsProvider),",
+ " bProvider.get(),",
+ " b2Provider.get(),",
+ " pbProvider,",
+ " qbProvider.get(),",
+ " DoubleCheck.lazy(lbProvider));",
" }",
"",
" public static <A, B> GenericClass_Factory<A, B> create(",
- " Provider<A> aAndA2AndPaAndLaProvider,",
+ " Provider<A> aProvider,",
+ " Provider<A> a2Provider,",
+ " Provider<A> paProvider,",
" Provider<A> qaProvider,",
- " Provider<String> sAndS2AndPsAndLsProvider,",
+ " Provider<A> laProvider,",
+ " Provider<String> sProvider,",
+ " Provider<String> s2Provider,",
+ " Provider<String> psProvider,",
" Provider<String> qsProvider,",
- " Provider<B> bAndB2AndPbAndLbProvider,",
- " Provider<B> qbProvider) {",
+ " Provider<String> lsProvider,",
+ " Provider<B> bProvider,",
+ " Provider<B> b2Provider,",
+ " Provider<B> pbProvider,",
+ " Provider<B> qbProvider,",
+ " Provider<B> lbProvider) {",
" return new GenericClass_Factory<A, B>(",
- " aAndA2AndPaAndLaProvider,",
+ " aProvider,",
+ " a2Provider,",
+ " paProvider,",
" qaProvider,",
- " sAndS2AndPsAndLsProvider,",
+ " laProvider,",
+ " sProvider,",
+ " s2Provider,",
+ " psProvider,",
" qsProvider,",
- " bAndB2AndPbAndLbProvider,",
- " qbProvider);",
+ " lsProvider,",
+ " bProvider,",
+ " b2Provider,",
+ " pbProvider,",
+ " qbProvider,",
+ " lbProvider);",
" }",
"",
" public static <A, B> GenericClass<A, B> newInstance(",
@@ -501,11 +551,11 @@
Compilation compilation = daggerCompiler().compile(file);
assertThat(compilation).failed();
assertThat(compilation)
- .hadErrorContaining("Types may only contain one @Inject constructor")
+ .hadErrorContaining("Types may only contain one injected constructor")
.inFile(file)
.onLine(6);
assertThat(compilation)
- .hadErrorContaining("Types may only contain one @Inject constructor")
+ .hadErrorContaining("Types may only contain one injected constructor")
.inFile(file)
.onLine(8);
}
@@ -602,7 +652,7 @@
" @Inject CheckedExceptionClass() throws Exception {}",
"}");
Compilation compilation =
- daggerCompiler().withOptions("-Adagger.privateMemberValidation=WARNING").compile(file);
+ compilerWithOptions("-Adagger.privateMemberValidation=WARNING").compile(file);
assertThat(compilation).succeeded();
assertThat(compilation)
.hadWarningContaining("Dagger does not support checked exceptions on @Inject constructors")
@@ -641,7 +691,7 @@
" }",
"}");
Compilation compilation =
- daggerCompiler().withOptions("-Adagger.privateMemberValidation=WARNING").compile(file);
+ compilerWithOptions("-Adagger.privateMemberValidation=WARNING").compile(file);
assertThat(compilation).succeeded();
assertThat(compilation)
.hadWarningContaining("Dagger does not support injection into private classes")
@@ -684,7 +734,7 @@
" }",
"}");
Compilation compilation =
- daggerCompiler().withOptions("-Adagger.privateMemberValidation=WARNING").compile(file);
+ compilerWithOptions("-Adagger.privateMemberValidation=WARNING").compile(file);
assertThat(compilation).succeeded();
assertThat(compilation)
.hadWarningContaining("Dagger does not support injection into private classes")
@@ -736,7 +786,7 @@
" @Inject private String s;",
"}");
Compilation compilation =
- daggerCompiler().withOptions("-Adagger.privateMemberValidation=WARNING").compile(file);
+ compilerWithOptions("-Adagger.privateMemberValidation=WARNING").compile(file);
assertThat(compilation).succeeded(); // TODO: Verify warning message when supported
}
@@ -767,7 +817,7 @@
" @Inject static String s;",
"}");
Compilation compilation =
- daggerCompiler().withOptions("-Adagger.staticMemberValidation=WARNING").compile(file);
+ compilerWithOptions("-Adagger.staticMemberValidation=WARNING").compile(file);
assertThat(compilation).succeeded(); // TODO: Verify warning message when supported
}
@@ -838,7 +888,7 @@
" @Inject private void method(){}",
"}");
Compilation compilation =
- daggerCompiler().withOptions("-Adagger.privateMemberValidation=WARNING").compile(file);
+ compilerWithOptions("-Adagger.privateMemberValidation=WARNING").compile(file);
assertThat(compilation).succeeded(); // TODO: Verify warning message when supported
}
@@ -869,7 +919,7 @@
" @Inject static void method(){}",
"}");
Compilation compilation =
- daggerCompiler().withOptions("-Adagger.staticMemberValidation=WARNING").compile(file);
+ compilerWithOptions("-Adagger.staticMemberValidation=WARNING").compile(file);
assertThat(compilation).succeeded(); // TODO: Verify warning message when supported
}
@@ -1003,6 +1053,7 @@
.hadErrorContaining("Producer may only be injected in @Produces methods");
}
+
@Test public void injectConstructor() {
JavaFileObject file = JavaFileObjects.forSourceLines("test.InjectConstructor",
"package test;",
@@ -1021,7 +1072,7 @@
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class InjectConstructor_Factory ",
" implements Factory<InjectConstructor> {",
"",
@@ -1032,7 +1083,7 @@
" }",
"",
" @Override public InjectConstructor get() {",
- " return new InjectConstructor(sProvider.get());",
+ " return newInstance(sProvider.get());",
" }",
"",
" public static InjectConstructor_Factory create(Provider<String> sProvider) {",
@@ -1068,28 +1119,39 @@
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class AllInjections_Factory implements Factory<AllInjections> {",
" private final Provider<String> sProvider;",
+ " private final Provider<String> sProvider2;",
+ " private final Provider<String> sProvider3;",
"",
- " public AllInjections_Factory(Provider<String> sProvider) {",
+ " public AllInjections_Factory(",
+ " Provider<String> sProvider,",
+ " Provider<String> sProvider2,",
+ " Provider<String> sProvider3) {",
" this.sProvider = sProvider;",
+ " this.sProvider2 = sProvider2;",
+ " this.sProvider3 = sProvider3;",
" }",
"",
- " @Override public AllInjections get() {",
- " AllInjections instance = new AllInjections(sProvider.get());",
- " AllInjections_MembersInjector.injectS(instance, sProvider.get());",
- " AllInjections_MembersInjector.injectS2(instance, sProvider.get());",
+ " @Override",
+ " public AllInjections get() {",
+ " AllInjections instance = newInstance(sProvider.get());",
+ " AllInjections_MembersInjector.injectS(instance, sProvider2.get());",
+ " AllInjections_MembersInjector.injectS2(instance, sProvider3.get());",
" return instance;",
" }",
"",
- " public static AllInjections_Factory create(Provider<String> sProvider) {",
- " return new AllInjections_Factory(sProvider);",
+ " public static AllInjections_Factory create(",
+ " Provider<String> sProvider,",
+ " Provider<String> sProvider2,",
+ " Provider<String> sProvider3) {",
+ " return new AllInjections_Factory(sProvider, sProvider2, sProvider3);",
" }",
"",
" public static AllInjections newInstance(String s) {",
- " return new AllInjections(s);",
- " }",
+ " return new AllInjections(s);",
+ " }",
"}");
assertAbout(javaSource()).that(file).processedWith(new ComponentProcessor())
.compilesWithoutError()
@@ -1118,7 +1180,7 @@
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class InjectConstructor_Factory ",
" implements Factory<InjectConstructor> {",
"",
@@ -1129,7 +1191,7 @@
" }",
"",
" @Override public InjectConstructor get() {",
- " return new InjectConstructor(objectsProvider.get());",
+ " return newInstance(objectsProvider.get());",
" }",
"",
" public static InjectConstructor_Factory create(",
@@ -1170,7 +1232,7 @@
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class InjectConstructor_Factory ",
" implements Factory<InjectConstructor> {",
"",
@@ -1181,7 +1243,7 @@
" }",
"",
" @Override public InjectConstructor get() {",
- " return new InjectConstructor(factoryProvider.get());",
+ " return newInstance(factoryProvider.get());",
" }",
"",
" public static InjectConstructor_Factory create(",
@@ -1227,7 +1289,7 @@
"import javax.inject.Provider;",
"import other.pkg.Outer;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class InjectConstructor_Factory ",
" implements Factory<InjectConstructor> {",
"",
@@ -1238,7 +1300,7 @@
" }",
"",
" @Override public InjectConstructor get() {",
- " return new InjectConstructor(factoryProvider.get());",
+ " return newInstance(factoryProvider.get());",
" }",
"",
" public static InjectConstructor_Factory create(",
@@ -1285,7 +1347,7 @@
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class InjectConstructor_Factory ",
" implements Factory<InjectConstructor> {",
"",
@@ -1300,8 +1362,7 @@
" }",
"",
" @Override public InjectConstructor get() {",
- " return new InjectConstructor(",
- " otherPackageProvider.get(), samePackageProvider.get());",
+ " return newInstance(otherPackageProvider.get(), samePackageProvider.get());",
" }",
"",
" public static InjectConstructor_Factory create(",
@@ -1340,21 +1401,23 @@
"import dagger.internal.Factory;",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class SimpleType_Factory implements Factory<SimpleType> {",
- " private static final SimpleType_Factory INSTANCE = new SimpleType_Factory();",
- "",
" @Override public SimpleType get() {",
- " return new SimpleType();",
+ " return newInstance();",
" }",
"",
" public static SimpleType_Factory create() {",
- " return INSTANCE;",
+ " return InstanceHolder.INSTANCE;",
" }",
"",
" public static SimpleType newInstance() {",
" return new SimpleType();",
" }",
+ "",
+ " private static final class InstanceHolder {",
+ " private static final SimpleType_Factory INSTANCE = new SimpleType_Factory();",
+ " }",
"}");
assertAbout(javaSource())
.that(simpleType)
@@ -1386,21 +1449,23 @@
"import dagger.internal.Factory;",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class OuterType_A_Factory implements Factory<OuterType.A> {",
- " private static final OuterType_A_Factory INSTANCE = new OuterType_A_Factory();",
- "",
" @Override public OuterType.A get() {",
- " return new OuterType.A();",
+ " return newInstance();",
" }",
"",
" public static OuterType_A_Factory create() {",
- " return INSTANCE;",
+ " return InstanceHolder.INSTANCE;",
" }",
"",
" public static OuterType.A newInstance() {",
" return new OuterType.A();",
" }",
+ "",
+ " private static final class InstanceHolder {",
+ " private static final OuterType_A_Factory INSTANCE = new OuterType_A_Factory();",
+ " }",
"}");
assertAbout(javaSources()).that(ImmutableList.of(nestedTypesFile))
.processedWith(new ComponentProcessor())
diff --git a/javatests/dagger/internal/codegen/KeyFactoryTest.java b/javatests/dagger/internal/codegen/KeyFactoryTest.java
index d526ec9..fdf62cb 100644
--- a/javatests/dagger/internal/codegen/KeyFactoryTest.java
+++ b/javatests/dagger/internal/codegen/KeyFactoryTest.java
@@ -24,8 +24,11 @@
import com.google.common.collect.Iterables;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.testing.compile.CompilationRule;
+import dagger.BindsInstance;
+import dagger.Component;
import dagger.Module;
import dagger.Provides;
+import dagger.internal.codegen.binding.KeyFactory;
import dagger.internal.codegen.langmodel.DaggerElements;
import dagger.internal.codegen.langmodel.DaggerTypes;
import dagger.model.Key;
@@ -38,6 +41,7 @@
import java.util.Set;
import javax.inject.Inject;
import javax.inject.Qualifier;
+import javax.inject.Singleton;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.element.Element;
import javax.lang.model.element.ExecutableElement;
@@ -57,16 +61,12 @@
public class KeyFactoryTest {
@Rule public CompilationRule compilationRule = new CompilationRule();
- private DaggerElements elements;
- private DaggerTypes types;
- private KeyFactory keyFactory;
+ @Inject DaggerElements elements;
+ @Inject DaggerTypes types;
+ @Inject KeyFactory keyFactory;
@Before public void setUp() {
- this.elements = new DaggerElements(compilationRule.getElements(), compilationRule.getTypes());
- this.types = new DaggerTypes(compilationRule.getTypes(), elements);
- TypeProtoConverter typeProtoConverter = new TypeProtoConverter(types, elements);
- this.keyFactory = new KeyFactory(
- types, elements, typeProtoConverter, new AnnotationProtoConverter(typeProtoConverter));
+ DaggerKeyFactoryTest_TestComponent.factory().create(compilationRule).inject(this);
}
@Test public void forInjectConstructorWithResolvedType() {
@@ -250,7 +250,7 @@
ExecutableElement integerMethod = Iterables.getOnlyElement(
ElementFilter.methodsIn(boxedPrimitiveHolder.getEnclosedElements()));
- // TODO(cgruber): Truth subject for TypeMirror and TypeElement
+ // TODO(user): Truth subject for TypeMirror and TypeElement
TypeMirror intType = intMethod.getReturnType();
assertThat(intType.getKind().isPrimitive()).isTrue();
TypeMirror integerType = integerMethod.getReturnType();
@@ -329,4 +329,28 @@
throw new UnsupportedOperationException();
}
}
+
+ @Singleton
+ @Component(modules = {TestModule.class})
+ interface TestComponent {
+ void inject(KeyFactoryTest test);
+
+ @Component.Factory
+ interface Factory {
+ TestComponent create(@BindsInstance CompilationRule compilationRule);
+ }
+ }
+
+ @Module
+ static class TestModule {
+ @Provides
+ static DaggerElements elements(CompilationRule compilationRule) {
+ return new DaggerElements(compilationRule.getElements(), compilationRule.getTypes());
+ }
+
+ @Provides
+ static DaggerTypes types(CompilationRule compilationRule, DaggerElements elements) {
+ return new DaggerTypes(compilationRule.getTypes(), elements);
+ }
+ }
}
diff --git a/javatests/dagger/internal/codegen/KotlinInjectedQualifier.kt b/javatests/dagger/internal/codegen/KotlinInjectedQualifier.kt
new file mode 100644
index 0000000..05e2758
--- /dev/null
+++ b/javatests/dagger/internal/codegen/KotlinInjectedQualifier.kt
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2019 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen
+
+import javax.inject.Inject
+import javax.inject.Named
+
+class KotlinInjectedQualifier {
+ @Inject
+ @Named("TheString")
+ lateinit var qualifiedString: String
+}
diff --git a/javatests/dagger/internal/codegen/KotlinObjectWithMemberInjection.kt b/javatests/dagger/internal/codegen/KotlinObjectWithMemberInjection.kt
new file mode 100644
index 0000000..619c1dd
--- /dev/null
+++ b/javatests/dagger/internal/codegen/KotlinObjectWithMemberInjection.kt
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen
+
+import javax.inject.Inject
+
+object KotlinObjectWithMemberInjection {
+ @Inject
+ lateinit var property: String
+}
+
+object KotlinObjectWithSetterMemberInjection {
+ @set:Inject
+ lateinit var setterProperty: String
+}
+
+class KotlinClassWithMemberInjectedCompanion {
+ companion object {
+ @Inject
+ lateinit var property: String
+ }
+}
+
+class KotlinClassWithSetterMemberInjectedCompanion {
+ companion object {
+ @set:Inject
+ lateinit var setterProperty: String
+ }
+}
+
+class KotlinClassWithMemberInjectedNamedCompanion {
+ companion object TheCompanion {
+ @Inject
+ lateinit var property: String
+ }
+}
+
+class KotlinClassWithSetterMemberInjectedNamedCompanion {
+ companion object TheCompanion {
+ @set:Inject
+ lateinit var setterProperty: String
+ }
+}
diff --git a/javatests/dagger/internal/codegen/MapBindingComponentProcessorTest.java b/javatests/dagger/internal/codegen/MapBindingComponentProcessorTest.java
index ad48712..ed9dd65 100644
--- a/javatests/dagger/internal/codegen/MapBindingComponentProcessorTest.java
+++ b/javatests/dagger/internal/codegen/MapBindingComponentProcessorTest.java
@@ -17,8 +17,9 @@
package dagger.internal.codegen;
import static com.google.testing.compile.CompilationSubject.assertThat;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
import static dagger.internal.codegen.Compilers.daggerCompiler;
-import static dagger.internal.codegen.GeneratedLines.GENERATED_ANNOTATION;
+import static dagger.internal.codegen.GeneratedLines.GENERATED_CODE_ANNOTATIONS;
import com.google.testing.compile.Compilation;
import com.google.testing.compile.JavaFileObjects;
@@ -128,7 +129,7 @@
"test.DaggerTestComponent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" private final MapModuleOne mapModuleOne;",
" private final MapModuleTwo mapModuleTwo;",
@@ -137,7 +138,7 @@
" private volatile Provider<Map<PathEnum, Provider<Handler>>>",
" mapOfPathEnumAndProviderOfHandlerProvider;",
"",
- " private Provider<Handler> getProvideAdminHandlerProvider() {",
+ " private Provider<Handler> provideAdminHandlerProvider() {",
" Object local = provideAdminHandlerProvider;",
" if (local == null) {",
" local = new SwitchingProvider<>(1);",
@@ -146,7 +147,7 @@
" return (Provider<Handler>) local;",
" }",
"",
- " private Provider<Handler> getProvideLoginHandlerProvider() {",
+ " private Provider<Handler> provideLoginHandlerProvider() {",
" Object local = provideLoginHandlerProvider;",
" if (local == null) {",
" local = new SwitchingProvider<>(2);",
@@ -156,10 +157,10 @@
" }",
"",
" private Map<PathEnum, Provider<Handler>>",
- " getMapOfPathEnumAndProviderOfHandler() {",
+ " mapOfPathEnumAndProviderOfHandler() {",
" return ImmutableMap.<PathEnum, Provider<Handler>>of(",
- " PathEnum.ADMIN, getProvideAdminHandlerProvider(),",
- " PathEnum.LOGIN, getProvideLoginHandlerProvider());",
+ " PathEnum.ADMIN, provideAdminHandlerProvider(),",
+ " PathEnum.LOGIN, provideLoginHandlerProvider());",
" }",
"",
" @Override",
@@ -186,7 +187,7 @@
" switch (id) {",
" case 0:",
" return (T) DaggerTestComponent.this",
- " .getMapOfPathEnumAndProviderOfHandler();",
+ " .mapOfPathEnumAndProviderOfHandler();",
" case 1:",
" return (T) MapModuleOne_ProvideAdminHandlerFactory",
" .provideAdminHandler(DaggerTestComponent.this.mapModuleOne);",
@@ -205,7 +206,7 @@
"test.DaggerTestComponent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" private Provider<Handler> provideAdminHandlerProvider;",
" private Provider<Handler> provideLoginHandlerProvider;",
@@ -234,8 +235,7 @@
"}");
}
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(
mapModuleOneFile,
mapModuleTwoFile,
@@ -357,7 +357,7 @@
"test.DaggerTestComponent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" private Provider<Map<Class<?>, Integer>> mapOfClassOfAndIntegerProvider;",
"",
@@ -367,7 +367,7 @@
" private Provider<Map<MapKeys.ComplexKey, Integer>>",
" mapOfComplexKeyAndIntegerProvider;",
"",
- " private Map getMapOfPackagePrivateEnumAndInteger() {",
+ " private Map mapOfPackagePrivateEnumAndInteger() {",
" return ImmutableMap.of(",
" MapModule_EnumKeyMapKey.create(), MapModule.enumKey());",
" }",
@@ -411,7 +411,7 @@
"",
" @Override",
" public Object inaccessibleEnum() {",
- " return getMapOfPackagePrivateEnumAndInteger();",
+ " return mapOfPackagePrivateEnumAndInteger();",
" }",
"",
" @Override",
@@ -443,7 +443,7 @@
"mapkeys.MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey",
"package mapkeys;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey {",
" public static MapKeys.ComplexKey create() {",
" return MapKeys_ComplexKeyCreator.createComplexKey(",
@@ -459,7 +459,7 @@
"mapkeys.MapModule_ClassKeyMapKey",
"package mapkeys;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class MapModule_ClassKeyMapKey {",
" public static Class<?> create() {",
" return MapKeys.Inaccessible.class;",
@@ -536,7 +536,7 @@
"test.DaggerTestComponent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" private final MapModuleOne mapModuleOne;",
" private final MapModuleTwo mapModuleTwo;",
@@ -545,7 +545,7 @@
" private volatile Provider<Map<String, Provider<Handler>>>",
" mapOfStringAndProviderOfHandlerProvider;",
"",
- " private Provider<Handler> getProvideAdminHandlerProvider() {",
+ " private Provider<Handler> provideAdminHandlerProvider() {",
" Object local = provideAdminHandlerProvider;",
" if (local == null) {",
" local = new SwitchingProvider<>(1);",
@@ -554,7 +554,7 @@
" return (Provider<Handler>) local;",
" }",
"",
- " private Provider<Handler> getProvideLoginHandlerProvider() {",
+ " private Provider<Handler> provideLoginHandlerProvider() {",
" Object local = provideLoginHandlerProvider;",
" if (local == null) {",
" local = new SwitchingProvider<>(2);",
@@ -564,10 +564,10 @@
" }",
"",
" private Map<String, Provider<Handler>>",
- " getMapOfStringAndProviderOfHandler() {",
+ " mapOfStringAndProviderOfHandler() {",
" return ImmutableMap.<String, Provider<Handler>>of(",
- " \"Admin\", getProvideAdminHandlerProvider(),",
- " \"Login\", getProvideLoginHandlerProvider());",
+ " \"Admin\", provideAdminHandlerProvider(),",
+ " \"Login\", provideLoginHandlerProvider());",
" }",
"",
" @Override",
@@ -594,7 +594,7 @@
" switch (id) {",
" case 0:",
" return (T) DaggerTestComponent.this",
- " .getMapOfStringAndProviderOfHandler();",
+ " .mapOfStringAndProviderOfHandler();",
" case 1:",
" return (T) MapModuleOne_ProvideAdminHandlerFactory",
" .provideAdminHandler(DaggerTestComponent.this.mapModuleOne);",
@@ -613,7 +613,7 @@
"test.DaggerTestComponent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" private Provider<Handler> provideAdminHandlerProvider;",
" private Provider<Handler> provideLoginHandlerProvider;",
@@ -642,8 +642,7 @@
"}");
}
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(
mapModuleOneFile,
mapModuleTwoFile,
@@ -737,7 +736,7 @@
"test.DaggerTestComponent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" private final MapModuleOne mapModuleOne;",
" private final MapModuleTwo mapModuleTwo;",
@@ -753,7 +752,7 @@
" this.mapModuleTwo = mapModuleTwoParam;",
" }",
"",
- " private Provider<Handler> getProvideAdminHandlerProvider() {",
+ " private Provider<Handler> provideAdminHandlerProvider() {",
" Object local = provideAdminHandlerProvider;",
" if (local == null) {",
" local = new SwitchingProvider<>(1);",
@@ -762,7 +761,7 @@
" return (Provider<Handler>) local;",
" }",
"",
- " private Provider<Handler> getProvideLoginHandlerProvider() {",
+ " private Provider<Handler> provideLoginHandlerProvider() {",
" Object local = provideLoginHandlerProvider;",
" if (local == null) {",
" local = new SwitchingProvider<>(2);",
@@ -772,12 +771,12 @@
" }",
"",
" private Map<WrappedClassKey, Provider<Handler>>",
- " getMapOfWrappedClassKeyAndProviderOfHandler() {",
+ " mapOfWrappedClassKeyAndProviderOfHandler() {",
" return ImmutableMap.<WrappedClassKey, Provider<Handler>>of(",
" WrappedClassKeyCreator.createWrappedClassKey(Integer.class),",
- " getProvideAdminHandlerProvider(),",
+ " provideAdminHandlerProvider(),",
" WrappedClassKeyCreator.createWrappedClassKey(Long.class),",
- " getProvideLoginHandlerProvider());",
+ " provideLoginHandlerProvider());",
" }",
"",
" @Override",
@@ -804,7 +803,7 @@
" switch (id) {",
" case 0:",
" return (T) DaggerTestComponent.this",
- " .getMapOfWrappedClassKeyAndProviderOfHandler();",
+ " .mapOfWrappedClassKeyAndProviderOfHandler();",
" case 1:",
" return (T) MapModuleOne_ProvideAdminHandlerFactory",
" .provideAdminHandler(DaggerTestComponent.this.mapModuleOne);",
@@ -823,7 +822,7 @@
"test.DaggerTestComponent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" private Provider<Handler> provideAdminHandlerProvider;",
" private Provider<Handler> provideLoginHandlerProvider;",
@@ -854,8 +853,7 @@
"}");
}
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(
mapModuleOneFile,
mapModuleTwoFile,
@@ -951,14 +949,14 @@
"test.DaggerTestComponent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" private final MapModuleOne mapModuleOne;",
" private final MapModuleTwo mapModuleTwo;",
" private volatile Provider<Map<PathEnum, Handler>>",
" mapOfPathEnumAndHandlerProvider;",
"",
- " private Map<PathEnum, Handler> getMapOfPathEnumAndHandler() {",
+ " private Map<PathEnum, Handler> mapOfPathEnumAndHandler() {",
" return ImmutableMap.<PathEnum, Handler>of(",
" PathEnum.ADMIN,",
" MapModuleOne_ProvideAdminHandlerFactory.provideAdminHandler(",
@@ -989,7 +987,7 @@
" @Override",
" public T get() {",
" switch (id) {",
- " case 0: return (T) DaggerTestComponent.this.getMapOfPathEnumAndHandler();",
+ " case 0: return (T) DaggerTestComponent.this.mapOfPathEnumAndHandler();",
" default: throw new AssertionError(id);",
" }",
" }",
@@ -1002,7 +1000,7 @@
"test.DaggerTestComponent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" private Provider<Handler> provideAdminHandlerProvider;",
" private Provider<Handler> provideLoginHandlerProvider;",
@@ -1030,8 +1028,7 @@
"}");
}
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(
mapModuleOneFile,
mapModuleTwoFile,
@@ -1080,7 +1077,7 @@
"test.DaggerTestComponent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" private final MapModule mapModule;",
"",
@@ -1090,8 +1087,7 @@
" }",
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(mapModuleFile, componentFile);
assertThat(compilation).succeeded();
assertThat(compilation)
diff --git a/javatests/dagger/internal/codegen/MapBindingExpressionTest.java b/javatests/dagger/internal/codegen/MapBindingExpressionTest.java
index 11f6bc1..3f33bd5 100644
--- a/javatests/dagger/internal/codegen/MapBindingExpressionTest.java
+++ b/javatests/dagger/internal/codegen/MapBindingExpressionTest.java
@@ -20,8 +20,8 @@
import static dagger.internal.codegen.CompilerMode.DEFAULT_MODE;
import static dagger.internal.codegen.CompilerMode.FAST_INIT_MODE;
import static dagger.internal.codegen.Compilers.CLASS_PATH_WITHOUT_GUAVA_OPTION;
-import static dagger.internal.codegen.Compilers.daggerCompiler;
-import static dagger.internal.codegen.GeneratedLines.GENERATED_ANNOTATION;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
+import static dagger.internal.codegen.GeneratedLines.GENERATED_CODE_ANNOTATIONS;
import com.google.testing.compile.Compilation;
import com.google.testing.compile.Compiler;
@@ -92,7 +92,7 @@
"",
"import dagger.internal.MapBuilder;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {")
.addLinesIn(
FAST_INIT_MODE,
@@ -101,7 +101,7 @@
" private volatile Provider<Long> provideLong1Provider;",
" private volatile Provider<Long> provideLong2Provider;",
"",
- " private Provider<Integer> getProvideIntProvider() {",
+ " private Provider<Integer> provideIntProvider() {",
" Object local = provideIntProvider;",
" if (local == null) {",
" local = new SwitchingProvider<>(0);",
@@ -110,7 +110,7 @@
" return (Provider<Integer>) local;",
" }",
"",
- " private Provider<Long> getProvideLong0Provider() {",
+ " private Provider<Long> provideLong0Provider() {",
" Object local = provideLong0Provider;",
" if (local == null) {",
" local = new SwitchingProvider<>(1);",
@@ -119,7 +119,7 @@
" return (Provider<Long>) local;",
" }",
"",
- " private Provider<Long> getProvideLong1Provider() {",
+ " private Provider<Long> provideLong1Provider() {",
" Object local = provideLong1Provider;",
" if (local == null) {",
" local = new SwitchingProvider<>(2);",
@@ -128,7 +128,7 @@
" return (Provider<Long>) local;",
" }",
"",
- " private Provider<Long> getProvideLong2Provider() {",
+ " private Provider<Long> provideLong2Provider() {",
" Object local = provideLong2Provider;",
" if (local == null) {",
" local = new SwitchingProvider<>(3);",
@@ -160,7 +160,7 @@
" 0, MapModule_ProvideIntFactory.create());")
.addLinesIn(
FAST_INIT_MODE,
- " 0, getProvideIntProvider());")
+ " 0, provideIntProvider());")
.addLines(
" }",
"",
@@ -183,9 +183,9 @@
" .put(2L, MapModule_ProvideLong2Factory.create())")
.addLinesIn(
FAST_INIT_MODE,
- " .put(0L, getProvideLong0Provider())",
- " .put(1L, getProvideLong1Provider())",
- " .put(2L, getProvideLong2Provider())")
+ " .put(0L, provideLong0Provider())",
+ " .put(1L, provideLong1Provider())",
+ " .put(2L, provideLong2Provider())")
.addLines( //
" .build();", " }")
.addLinesIn(
@@ -274,7 +274,7 @@
"import other.UsesInaccessible;",
"import other.UsesInaccessible_Factory;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" @Override",
" public UsesInaccessible usesInaccessible() {",
@@ -337,7 +337,7 @@
"test.DaggerParent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerParent implements Parent {",
" private final ParentModule parentModule;",
"",
@@ -360,7 +360,7 @@
}
private Compiler daggerCompilerWithoutGuava() {
- return daggerCompiler()
- .withOptions(compilerMode.javacopts().append(CLASS_PATH_WITHOUT_GUAVA_OPTION));
+ return compilerWithOptions(compilerMode.javacopts())
+ .withClasspath(CLASS_PATH_WITHOUT_GUAVA_OPTION);
}
}
diff --git a/javatests/dagger/internal/codegen/MapBindingExpressionWithGuavaTest.java b/javatests/dagger/internal/codegen/MapBindingExpressionWithGuavaTest.java
index aa1a715..69ab5a7 100644
--- a/javatests/dagger/internal/codegen/MapBindingExpressionWithGuavaTest.java
+++ b/javatests/dagger/internal/codegen/MapBindingExpressionWithGuavaTest.java
@@ -20,8 +20,7 @@
import static dagger.internal.codegen.CompilerMode.DEFAULT_MODE;
import static dagger.internal.codegen.CompilerMode.FAST_INIT_MODE;
import static dagger.internal.codegen.Compilers.compilerWithOptions;
-import static dagger.internal.codegen.Compilers.daggerCompiler;
-import static dagger.internal.codegen.GeneratedLines.GENERATED_ANNOTATION;
+import static dagger.internal.codegen.GeneratedLines.GENERATED_CODE_ANNOTATIONS;
import com.google.testing.compile.Compilation;
import com.google.testing.compile.JavaFileObjects;
@@ -128,7 +127,7 @@
.addLines(
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {")
.addLinesIn(
FAST_INIT_MODE,
@@ -137,7 +136,7 @@
" private volatile Provider<Long> provideLong1Provider;",
" private volatile Provider<Long> provideLong2Provider;",
"",
- " private Provider<Integer> getProvideIntProvider() {",
+ " private Provider<Integer> provideIntProvider() {",
" Object local = provideIntProvider;",
" if (local == null) {",
" local = new SwitchingProvider<>(0);",
@@ -146,7 +145,7 @@
" return (Provider<Integer>) local;",
" }",
"",
- " private Provider<Long> getProvideLong0Provider() {",
+ " private Provider<Long> provideLong0Provider() {",
" Object local = provideLong0Provider;",
" if (local == null) {",
" local = new SwitchingProvider<>(1);",
@@ -155,7 +154,7 @@
" return (Provider<Long>) local;",
" }",
"",
- " private Provider<Long> getProvideLong1Provider() {",
+ " private Provider<Long> provideLong1Provider() {",
" Object local = provideLong1Provider;",
" if (local == null) {",
" local = new SwitchingProvider<>(2);",
@@ -164,7 +163,7 @@
" return (Provider<Long>) local;",
" }",
"",
- " private Provider<Long> getProvideLong2Provider() {",
+ " private Provider<Long> provideLong2Provider() {",
" Object local = provideLong2Provider;",
" if (local == null) {",
" local = new SwitchingProvider<>(3);",
@@ -196,7 +195,7 @@
" 0, MapModule_ProvideIntFactory.create());")
.addLinesIn(
FAST_INIT_MODE, //
- " 0, getProvideIntProvider());")
+ " 0, provideIntProvider());")
.addLines(
" }",
"",
@@ -218,9 +217,9 @@
" 2L, MapModule_ProvideLong2Factory.create());")
.addLinesIn(
FAST_INIT_MODE,
- " 0L, getProvideLong0Provider(),",
- " 1L, getProvideLong1Provider(),",
- " 2L, getProvideLong2Provider());")
+ " 0L, provideLong0Provider(),",
+ " 1L, provideLong1Provider(),",
+ " 2L, provideLong2Provider());")
.addLines(
" }",
"",
@@ -237,7 +236,7 @@
" private volatile Provider<Long> provideLong5Provider;",
" private SubImpl() {}",
"",
- " private Provider<Long> getProvideLong3Provider() {",
+ " private Provider<Long> provideLong3Provider() {",
" Object local = provideLong3Provider;",
" if (local == null) {",
" local = new SwitchingProvider<>(0);",
@@ -246,7 +245,7 @@
" return (Provider<Long>) local;",
" }",
"",
- " private Provider<Long> getProvideLong4Provider() {",
+ " private Provider<Long> provideLong4Provider() {",
" Object local = provideLong4Provider;",
" if (local == null) {",
" local = new SwitchingProvider<>(1);",
@@ -255,7 +254,7 @@
" return (Provider<Long>) local;",
" }",
"",
- " private Provider<Long> getProvideLong5Provider() {",
+ " private Provider<Long> provideLong5Provider() {",
" Object local = provideLong5Provider;",
" if (local == null) {",
" local = new SwitchingProvider<>(2);",
@@ -289,12 +288,12 @@
" .put(5L, SubcomponentMapModule_ProvideLong5Factory.create())")
.addLinesIn(
FAST_INIT_MODE,
- " .put(0L, DaggerTestComponent.this.getProvideLong0Provider())",
- " .put(1L, DaggerTestComponent.this.getProvideLong1Provider())",
- " .put(2L, DaggerTestComponent.this.getProvideLong2Provider())",
- " .put(3L, getProvideLong3Provider())",
- " .put(4L, getProvideLong4Provider())",
- " .put(5L, getProvideLong5Provider())")
+ " .put(0L, DaggerTestComponent.this.provideLong0Provider())",
+ " .put(1L, DaggerTestComponent.this.provideLong1Provider())",
+ " .put(2L, DaggerTestComponent.this.provideLong2Provider())",
+ " .put(3L, provideLong3Provider())",
+ " .put(4L, provideLong4Provider())",
+ " .put(5L, provideLong5Provider())")
.addLines( //
" .build();", " }")
.addLinesIn(
@@ -341,8 +340,7 @@
"}")
.build();
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(mapModuleFile, componentFile, subcomponentModuleFile, subcomponent);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -403,7 +401,7 @@
"import other.UsesInaccessible;",
"import other.UsesInaccessible_Factory;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" @Override",
" public UsesInaccessible usesInaccessible() {",
@@ -411,8 +409,7 @@
" }",
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(module, inaccessible, usesInaccessible, componentFile);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -466,7 +463,7 @@
"test.DaggerParent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerParent implements Parent {",
" private final ParentModule parentModule;",
"",
@@ -482,7 +479,7 @@
"}");
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(parent, parentModule, child);
+ compilerWithOptions(compilerMode.javacopts()).compile(parent, parentModule, child);
assertThat(compilation).succeeded();
assertThat(compilation)
.generatedSourceFile("test.DaggerParent")
@@ -522,7 +519,7 @@
"",
"import dagger.producers.internal.CancellationListener;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent, "
+ "CancellationListener {",
" @Override",
diff --git a/javatests/dagger/internal/codegen/MapKeyProcessorTest.java b/javatests/dagger/internal/codegen/MapKeyProcessorTest.java
index 746c60d..ffdb2bc 100644
--- a/javatests/dagger/internal/codegen/MapKeyProcessorTest.java
+++ b/javatests/dagger/internal/codegen/MapKeyProcessorTest.java
@@ -18,7 +18,7 @@
import static com.google.common.truth.Truth.assertAbout;
import static com.google.testing.compile.JavaSourcesSubjectFactory.javaSources;
-import static dagger.internal.codegen.GeneratedLines.GENERATED_ANNOTATION;
+import static dagger.internal.codegen.GeneratedLines.GENERATED_CODE_ANNOTATIONS;
import static dagger.internal.codegen.GeneratedLines.IMPORT_GENERATED_ANNOTATION;
import com.google.auto.value.processor.AutoAnnotationProcessor;
@@ -73,7 +73,7 @@
"import com.google.auto.value.AutoAnnotation;",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class PathKeyCreator {",
" private PathKeyCreator() {}",
"",
@@ -122,7 +122,7 @@
"import com.google.auto.value.AutoAnnotation;",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class Container_PathKeyCreator {",
" private Container_PathKeyCreator() {}",
"",
diff --git a/javatests/dagger/internal/codegen/MapMultibindingValidationTest.java b/javatests/dagger/internal/codegen/MapMultibindingValidationTest.java
index 04b0986..753fb53 100644
--- a/javatests/dagger/internal/codegen/MapMultibindingValidationTest.java
+++ b/javatests/dagger/internal/codegen/MapMultibindingValidationTest.java
@@ -17,7 +17,9 @@
package dagger.internal.codegen;
import static com.google.testing.compile.CompilationSubject.assertThat;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
import static dagger.internal.codegen.Compilers.daggerCompiler;
+import static dagger.internal.codegen.TestUtils.message;
import com.google.common.collect.ImmutableList;
import com.google.testing.compile.Compilation;
@@ -30,7 +32,7 @@
@RunWith(JUnit4.class)
public class MapMultibindingValidationTest {
@Test
- public void duplicateMapKeys() {
+ public void duplicateMapKeys_UnwrappedMapKey() {
JavaFileObject module =
JavaFileObjects.forSourceLines(
"test.MapModule",
@@ -65,18 +67,19 @@
assertThat(compilation)
.hadErrorContaining(
"The same map key is bound more than once for "
- + "java.util.Map<java.lang.String,java.lang.Object>");
+ + "Map<String,Object>");
assertThat(compilation).hadErrorContaining("provideObjectForAKey()");
assertThat(compilation).hadErrorContaining("provideObjectForAKeyAgain()");
assertThat(compilation).hadErrorCount(1);
compilation =
- daggerCompiler().withOptions("-Adagger.fullBindingGraphValidation=ERROR").compile(module);
+ compilerWithOptions("-Adagger.fullBindingGraphValidation=ERROR")
+ .compile(module);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
"The same map key is bound more than once for "
- + "java.util.Map<java.lang.String,javax.inject.Provider<java.lang.Object>>")
+ + "Map<String,Provider<Object>>")
.inFile(module)
.onLineContaining("class MapModule");
assertThat(compilation).hadErrorContaining("provideObjectForAKey()");
@@ -95,7 +98,7 @@
assertThat(compilation)
.hadErrorContaining(
"The same map key is bound more than once for "
- + "java.util.Map<java.lang.String,java.lang.Object>");
+ + "Map<String,Object>");
assertThat(compilation).hadErrorCount(1);
// If there's Map<K, V> and Map<K, Producer<V>>, report only Map<K, V>.
@@ -110,7 +113,7 @@
assertThat(compilation)
.hadErrorContaining(
"The same map key is bound more than once for "
- + "java.util.Map<java.lang.String,java.lang.Object>");
+ + "Map<String,Object>");
assertThat(compilation).hadErrorCount(1);
// If there's Map<K, Provider<V>> and Map<K, Producer<V>>, report only Map<K, Provider<V>>.
@@ -125,7 +128,7 @@
assertThat(compilation)
.hadErrorContaining(
"The same map key is bound more than once for "
- + "java.util.Map<java.lang.String,javax.inject.Provider<java.lang.Object>>");
+ + "Map<String,Provider<Object>>");
assertThat(compilation).hadErrorCount(1);
compilation = daggerCompiler().compile(module, component("Map<String, Object> objects();"));
@@ -133,7 +136,7 @@
assertThat(compilation)
.hadErrorContaining(
"The same map key is bound more than once for "
- + "java.util.Map<java.lang.String,java.lang.Object>");
+ + "Map<String,Object>");
assertThat(compilation).hadErrorCount(1);
compilation =
@@ -143,7 +146,7 @@
assertThat(compilation)
.hadErrorContaining(
"The same map key is bound more than once for "
- + "java.util.Map<java.lang.String,javax.inject.Provider<java.lang.Object>>");
+ + "Map<String,Provider<Object>>");
assertThat(compilation).hadErrorCount(1);
compilation =
@@ -154,11 +157,59 @@
assertThat(compilation)
.hadErrorContaining(
"The same map key is bound more than once for "
- + "java.util.Map<java.lang.String,dagger.producers.Producer<java.lang.Object>>");
+ + "Map<String,Producer<Object>>");
assertThat(compilation).hadErrorCount(1);
}
@Test
+ public void duplicateMapKeys_WrappedMapKey() {
+ JavaFileObject module =
+ JavaFileObjects.forSourceLines(
+ "test.MapModule",
+ "package test;",
+ "",
+ "import dagger.Module;",
+ "import dagger.Provides;",
+ "import dagger.multibindings.IntoMap;",
+ "import dagger.MapKey;",
+ "",
+ "@Module",
+ "abstract class MapModule {",
+ "",
+ " @MapKey(unwrapValue = false)",
+ " @interface WrappedMapKey {",
+ " String value();",
+ " }",
+ "",
+ " @Provides",
+ " @IntoMap",
+ " @WrappedMapKey(\"foo\")",
+ " static String stringMapEntry1() { return \"\"; }",
+ "",
+ " @Provides",
+ " @IntoMap",
+ " @WrappedMapKey(\"foo\")",
+ " static String stringMapEntry2() { return \"\"; }",
+ "}");
+
+ JavaFileObject component = component("Map<test.MapModule.WrappedMapKey, String> objects();");
+
+ Compilation compilation = daggerCompiler().compile(component, module);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
+ message(
+ "\033[1;31m[Dagger/MapKeys]\033[0m The same map key is bound more than once for "
+ + "Map<MapModule.WrappedMapKey,String>",
+ " @Provides @IntoMap @MapModule.WrappedMapKey(\"foo\") String "
+ + "MapModule.stringMapEntry1()",
+ " @Provides @IntoMap @MapModule.WrappedMapKey(\"foo\") String "
+ + "MapModule.stringMapEntry2()"))
+ .inFile(component)
+ .onLineContaining("interface TestComponent");
+ }
+
+ @Test
public void inconsistentMapKeyAnnotations() {
JavaFileObject module =
JavaFileObjects.forSourceLines(
@@ -205,20 +256,19 @@
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
- "java.util.Map<java.lang.String,java.lang.Object>"
+ "Map<String,Object>"
+ " uses more than one @MapKey annotation type");
assertThat(compilation).hadErrorContaining("provideObjectForAKey()");
assertThat(compilation).hadErrorContaining("provideObjectForBKey()");
assertThat(compilation).hadErrorCount(1);
compilation =
- daggerCompiler()
- .withOptions("-Adagger.fullBindingGraphValidation=ERROR")
+ compilerWithOptions("-Adagger.fullBindingGraphValidation=ERROR")
.compile(module, stringKeyTwoFile);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
- "java.util.Map<java.lang.String,javax.inject.Provider<java.lang.Object>>"
+ "Map<String,Provider<Object>>"
+ " uses more than one @MapKey annotation type")
.inFile(module)
.onLineContaining("class MapModule");
@@ -238,7 +288,7 @@
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
- "java.util.Map<java.lang.String,java.lang.Object>"
+ "Map<String,Object>"
+ " uses more than one @MapKey annotation type");
assertThat(compilation).hadErrorCount(1);
@@ -254,7 +304,7 @@
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
- "java.util.Map<java.lang.String,java.lang.Object>"
+ "Map<String,Object>"
+ " uses more than one @MapKey annotation type");
assertThat(compilation).hadErrorCount(1);
@@ -270,7 +320,7 @@
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
- "java.util.Map<java.lang.String,javax.inject.Provider<java.lang.Object>>"
+ "Map<String,Provider<Object>>"
+ " uses more than one @MapKey annotation type");
assertThat(compilation).hadErrorCount(1);
@@ -280,7 +330,7 @@
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
- "java.util.Map<java.lang.String,java.lang.Object>"
+ "Map<String,Object>"
+ " uses more than one @MapKey annotation type");
assertThat(compilation).hadErrorCount(1);
@@ -293,7 +343,7 @@
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
- "java.util.Map<java.lang.String,javax.inject.Provider<java.lang.Object>>"
+ "Map<String,Provider<Object>>"
+ " uses more than one @MapKey annotation type");
assertThat(compilation).hadErrorCount(1);
@@ -306,7 +356,7 @@
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
- "java.util.Map<java.lang.String,dagger.producers.Producer<java.lang.Object>>"
+ "Map<String,Producer<Object>>"
+ " uses more than one @MapKey annotation type");
assertThat(compilation).hadErrorCount(1);
}
diff --git a/javatests/dagger/internal/codegen/MembersInjectionTest.java b/javatests/dagger/internal/codegen/MembersInjectionTest.java
index edaedaf..ef69c71 100644
--- a/javatests/dagger/internal/codegen/MembersInjectionTest.java
+++ b/javatests/dagger/internal/codegen/MembersInjectionTest.java
@@ -22,8 +22,8 @@
import static com.google.testing.compile.JavaSourcesSubjectFactory.javaSources;
import static dagger.internal.codegen.CompilerMode.DEFAULT_MODE;
import static dagger.internal.codegen.CompilerMode.FAST_INIT_MODE;
-import static dagger.internal.codegen.Compilers.daggerCompiler;
-import static dagger.internal.codegen.GeneratedLines.GENERATED_ANNOTATION;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
+import static dagger.internal.codegen.GeneratedLines.GENERATED_CODE_ANNOTATIONS;
import static dagger.internal.codegen.GeneratedLines.IMPORT_GENERATED_ANNOTATION;
import static javax.tools.StandardLocation.CLASS_OUTPUT;
@@ -87,7 +87,7 @@
"test.DaggerTestComponent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" @Override",
" public Child child() {",
@@ -95,8 +95,7 @@
" }",
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(childFile, parentFile, componentFile);
assertThat(compilation).succeeded();
@@ -147,7 +146,7 @@
"",
"import com.google.errorprone.annotations.CanIgnoreReturnValue;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" @Override",
" public Child child() {",
@@ -161,8 +160,7 @@
" }",
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(childFile, parentFile, depFile, componentFile);
assertThat(compilation).succeeded();
@@ -184,44 +182,47 @@
"",
" @Inject void register(B b) {}",
"}");
- JavaFileObject expected = JavaFileObjects.forSourceLines(
- "test.GenericClass_MembersInjector",
- "package test;",
- "",
- "import dagger.MembersInjector;",
- IMPORT_GENERATED_ANNOTATION,
- "import javax.inject.Provider;",
- "",
- GENERATED_ANNOTATION,
- "public final class GenericClass_MembersInjector<A, B>",
- " implements MembersInjector<GenericClass<A, B>> {",
- " private final Provider<A> aProvider;",
- " private final Provider<B> bProvider;",
- "",
- " public GenericClass_MembersInjector(Provider<A> aProvider, Provider<B> bProvider) {",
- " this.aProvider = aProvider;",
- " this.bProvider = bProvider;",
- " }",
- "",
- " public static <A, B> MembersInjector<GenericClass<A, B>> create(",
- " Provider<A> aProvider, Provider<B> bProvider) {",
- " return new GenericClass_MembersInjector<A, B>(aProvider, bProvider);",
- " }",
- "",
- " @Override",
- " public void injectMembers(GenericClass<A, B> instance) {",
- " injectA(instance, aProvider.get());",
- " injectRegister(instance, bProvider.get());",
- " }",
- "",
- " public static <A, B> void injectA(Object instance, A a) {",
- " ((GenericClass<A, B>) instance).a = a;",
- " }",
- "",
- " public static <A, B> void injectRegister(Object instance, B b) {",
- " ((GenericClass<A, B>) instance).register(b);",
- " }",
- "}");
+ JavaFileObject expected =
+ JavaFileObjects.forSourceLines(
+ "test.GenericClass_MembersInjector",
+ "package test;",
+ "",
+ "import dagger.MembersInjector;",
+ "import dagger.internal.InjectedFieldSignature;",
+ IMPORT_GENERATED_ANNOTATION,
+ "import javax.inject.Provider;",
+ "",
+ GENERATED_CODE_ANNOTATIONS,
+ "public final class GenericClass_MembersInjector<A, B>",
+ " implements MembersInjector<GenericClass<A, B>> {",
+ " private final Provider<A> aProvider;",
+ " private final Provider<B> bProvider;",
+ "",
+ " public GenericClass_MembersInjector(Provider<A> aProvider, Provider<B> bProvider) {",
+ " this.aProvider = aProvider;",
+ " this.bProvider = bProvider;",
+ " }",
+ "",
+ " public static <A, B> MembersInjector<GenericClass<A, B>> create(",
+ " Provider<A> aProvider, Provider<B> bProvider) {",
+ " return new GenericClass_MembersInjector<A, B>(aProvider, bProvider);",
+ " }",
+ "",
+ " @Override",
+ " public void injectMembers(GenericClass<A, B> instance) {",
+ " injectA(instance, aProvider.get());",
+ " injectRegister(instance, bProvider.get());",
+ " }",
+ "",
+ " @InjectedFieldSignature(\"test.GenericClass.a\")",
+ " public static <A, B> void injectA(Object instance, A a) {",
+ " ((GenericClass<A, B>) instance).a = a;",
+ " }",
+ "",
+ " public static <A, B> void injectRegister(Object instance, B b) {",
+ " ((GenericClass<A, B>) instance).register(b);",
+ " }",
+ "}");
assertAbout(javaSource())
.that(file)
.withCompilerOptions(compilerMode.javacopts())
@@ -271,50 +272,67 @@
"",
" @Inject Child() {}",
"}");
- JavaFileObject expected = JavaFileObjects.forSourceLines(
- "test.Child_MembersInjector",
- "package test;",
- "",
- "import dagger.MembersInjector;",
- IMPORT_GENERATED_ANNOTATION,
- "import javax.inject.Provider;",
- "",
- GENERATED_ANNOTATION,
- "public final class Child_MembersInjector<T>",
- " implements MembersInjector<Child<T>> {",
- " private final Provider<T> tAndXProvider;",
- " private final Provider<A> aAndYProvider;",
- " private final Provider<A2> a2Provider;",
- "",
- " public Child_MembersInjector(",
- " Provider<T> tAndXProvider, Provider<A> aAndYProvider, Provider<A2> a2Provider) {",
- " this.tAndXProvider = tAndXProvider;",
- " this.aAndYProvider = aAndYProvider;",
- " this.a2Provider = a2Provider;",
- " }",
- "",
- " public static <T> MembersInjector<Child<T>> create(",
- " Provider<T> tAndXProvider, Provider<A> aAndYProvider, Provider<A2> a2Provider) {",
- " return new Child_MembersInjector<T>(tAndXProvider, aAndYProvider, a2Provider);",
- " }",
- "",
- " @Override",
- " public void injectMembers(Child<T> instance) {",
- " Parent_MembersInjector.injectX(instance, tAndXProvider.get());",
- " Parent_MembersInjector.injectY(instance, aAndYProvider.get());",
- " Parent_MembersInjector.injectA2(instance, a2Provider.get());",
- " injectA(instance, aAndYProvider.get());",
- " injectT(instance, tAndXProvider.get());",
- " }",
- "",
- " public static <T> void injectA(Object instance, Object a) {",
- " ((Child<T>) instance).a = (A) a;",
- " }",
- "",
- " public static <T> void injectT(Object instance, T t) {",
- " ((Child<T>) instance).t = t;",
- " }",
- "}");
+ JavaFileObject expected =
+ JavaFileObjects.forSourceLines(
+ "test.Child_MembersInjector",
+ "package test;",
+ "",
+ "import dagger.MembersInjector;",
+ "import dagger.internal.InjectedFieldSignature;",
+ IMPORT_GENERATED_ANNOTATION,
+ "import javax.inject.Provider;",
+ "",
+ GENERATED_CODE_ANNOTATIONS,
+ "public final class Child_MembersInjector<T>",
+ " implements MembersInjector<Child<T>> {",
+ " private final Provider<T> xProvider;",
+ " private final Provider<A> yProvider;",
+ " private final Provider<A2> a2Provider;",
+ " private final Provider<A> aProvider;",
+ " private final Provider<T> tProvider;",
+ "",
+ " public Child_MembersInjector(",
+ " Provider<T> xProvider,",
+ " Provider<A> yProvider,",
+ " Provider<A2> a2Provider,",
+ " Provider<A> aProvider,",
+ " Provider<T> tProvider) {",
+ " this.xProvider = xProvider;",
+ " this.yProvider = yProvider;",
+ " this.a2Provider = a2Provider;",
+ " this.aProvider = aProvider;",
+ " this.tProvider = tProvider;",
+ " }",
+ "",
+ " public static <T> MembersInjector<Child<T>> create(",
+ " Provider<T> xProvider,",
+ " Provider<A> yProvider,",
+ " Provider<A2> a2Provider,",
+ " Provider<A> aProvider,",
+ " Provider<T> tProvider) {",
+ " return new Child_MembersInjector<T>(xProvider, yProvider, a2Provider, aProvider,"
+ + " tProvider);",
+ "}",
+ "",
+ " @Override",
+ " public void injectMembers(Child<T> instance) {",
+ " Parent_MembersInjector.injectX(instance, xProvider.get());",
+ " Parent_MembersInjector.injectY(instance, yProvider.get());",
+ " Parent_MembersInjector.injectA2(instance, a2Provider.get());",
+ " injectA(instance, aProvider.get());",
+ " injectT(instance, tProvider.get());",
+ " }",
+ "",
+ " @InjectedFieldSignature(\"test.Child.a\")",
+ " public static <T> void injectA(Object instance, Object a) {",
+ " ((Child<T>) instance).a = (A) a;",
+ " }",
+ "",
+ " @InjectedFieldSignature(\"test.Child.t\")",
+ " public static <T> void injectT(Object instance, T t) {",
+ " ((Child<T>) instance).t = t;",
+ " }",
+ "}");
assertAbout(javaSources())
.that(ImmutableList.of(a, a2, parent, child))
.withCompilerOptions(compilerMode.javacopts())
@@ -345,38 +363,50 @@
"import dagger.Lazy;",
"import dagger.MembersInjector;",
"import dagger.internal.DoubleCheck;",
+ "import dagger.internal.InjectedFieldSignature;",
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class FieldInjection_MembersInjector",
" implements MembersInjector<FieldInjection> {",
" private final Provider<String> stringProvider;",
+ " private final Provider<String> stringProvider2;",
+ " private final Provider<String> stringProvider3;",
"",
- " public FieldInjection_MembersInjector(Provider<String> stringProvider) {",
+ " public FieldInjection_MembersInjector(Provider<String> stringProvider,",
+ " Provider<String> stringProvider2, Provider<String> stringProvider3) {",
" this.stringProvider = stringProvider;",
+ " this.stringProvider2 = stringProvider2;",
+ " this.stringProvider3 = stringProvider3;",
" }",
"",
" public static MembersInjector<FieldInjection> create(",
- " Provider<String> stringProvider) {",
- " return new FieldInjection_MembersInjector(stringProvider);",
+ " Provider<String> stringProvider,",
+ " Provider<String> stringProvider2,",
+ " Provider<String> stringProvider3) {",
+ " return new FieldInjection_MembersInjector(",
+ " stringProvider, stringProvider2, stringProvider3);",
" }",
"",
" @Override",
" public void injectMembers(FieldInjection instance) {",
" injectString(instance, stringProvider.get());",
- " injectLazyString(instance, DoubleCheck.lazy(stringProvider));",
- " injectStringProvider(instance, stringProvider);",
+ " injectLazyString(instance, DoubleCheck.lazy(stringProvider2));",
+ " injectStringProvider(instance, stringProvider3);",
" }",
"",
+ " @InjectedFieldSignature(\"test.FieldInjection.string\")",
" public static void injectString(Object instance, String string) {",
" ((FieldInjection) instance).string = string;",
" }",
"",
+ " @InjectedFieldSignature(\"test.FieldInjection.lazyString\")",
" public static void injectLazyString(Object instance, Lazy<String> lazyString) {",
" ((FieldInjection) instance).lazyString = lazyString;",
" }",
"",
+ " @InjectedFieldSignature(\"test.FieldInjection.stringProvider\")",
" public static void injectStringProvider(",
" Object instance, Provider<String> stringProvider) {",
" ((FieldInjection) instance).stringProvider = stringProvider;",
@@ -391,6 +421,77 @@
.generatesSources(expected);
}
+ @Test
+ public void fieldInjectionWithQualifier() {
+ JavaFileObject file =
+ JavaFileObjects.forSourceLines(
+ "test.FieldInjectionWithQualifier",
+ "package test;",
+ "",
+ "import dagger.Lazy;",
+ "import javax.inject.Inject;",
+ "import javax.inject.Named;",
+ "import javax.inject.Provider;",
+ "",
+ "class FieldInjectionWithQualifier {",
+ " @Inject @Named(\"A\") String a;",
+ " @Inject @Named(\"B\") String b;",
+ "}");
+ JavaFileObject expected =
+ JavaFileObjects.forSourceLines(
+ "test.FieldInjectionWithQualifier_MembersInjector",
+ "package test;",
+ "",
+ "import dagger.MembersInjector;",
+ "import dagger.internal.InjectedFieldSignature;",
+ IMPORT_GENERATED_ANNOTATION,
+ "import javax.inject.Named;",
+ "import javax.inject.Provider;",
+ "",
+ GENERATED_CODE_ANNOTATIONS,
+ "public final class FieldInjectionWithQualifier_MembersInjector",
+ " implements MembersInjector<FieldInjectionWithQualifier> {",
+ " private final Provider<String> aProvider;",
+ " private final Provider<String> bProvider;",
+ "",
+ " public FieldInjectionWithQualifier_MembersInjector(Provider<String> aProvider,",
+ " Provider<String> bProvider) {",
+ " this.aProvider = aProvider;",
+ " this.bProvider = bProvider;",
+ " }",
+ "",
+ " public static MembersInjector<FieldInjectionWithQualifier> create(",
+ " Provider<String> aProvider, Provider<String> bProvider) {",
+ " return new FieldInjectionWithQualifier_MembersInjector(aProvider, bProvider);",
+ " }",
+ "",
+ "@Override",
+ " public void injectMembers(FieldInjectionWithQualifier instance) {",
+ " injectA(instance, aProvider.get());",
+ " injectB(instance, bProvider.get());",
+ "}",
+ "",
+ " @InjectedFieldSignature(\"test.FieldInjectionWithQualifier.a\")",
+ " @Named(\"A\")",
+ " public static void injectA(Object instance, String a) {",
+ " ((FieldInjectionWithQualifier) instance).a = a;",
+ " }",
+ "",
+ " @InjectedFieldSignature(\"test.FieldInjectionWithQualifier.b\")",
+ " @Named(\"B\")",
+ " public static void injectB(Object instance, String b) {",
+ " ((FieldInjectionWithQualifier) instance).b = b;",
+ " }",
+ "}");
+ assertAbout(javaSource())
+ .that(file)
+ .withCompilerOptions(compilerMode.javacopts())
+ .processedWith(new ComponentProcessor())
+ .compilesWithoutError()
+ .and()
+ .generatesSources(expected);
+ }
+
@Test public void methodInjection() {
JavaFileObject file = JavaFileObjects.forSourceLines("test.MethodInjection",
"package test;",
@@ -416,20 +517,32 @@
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class MethodInjection_MembersInjector",
" implements MembersInjector<MethodInjection> {",
- "",
" private final Provider<String> stringProvider;",
+ " private final Provider<String> stringProvider2;",
+ " private final Provider<String> stringProvider3;",
+ " private final Provider<String> stringProvider4;",
"",
- " public MethodInjection_MembersInjector(Provider<String> stringProvider) {",
+ " public MethodInjection_MembersInjector(",
+ " Provider<String> stringProvider,",
+ " Provider<String> stringProvider2,",
+ " Provider<String> stringProvider3,",
+ " Provider<String> stringProvider4) {",
" this.stringProvider = stringProvider;",
+ " this.stringProvider2 = stringProvider2;",
+ " this.stringProvider3 = stringProvider3;",
+ " this.stringProvider4 = stringProvider4;",
" }",
"",
" public static MembersInjector<MethodInjection> create(",
- " Provider<String> stringProvider) {",
- " return new MethodInjection_MembersInjector(stringProvider);",
- " }",
+ " Provider<String> stringProvider,",
+ " Provider<String> stringProvider2,",
+ " Provider<String> stringProvider3,",
+ " Provider<String> stringProvider4) {",
+ " return new MethodInjection_MembersInjector(",
+ " stringProvider, stringProvider2, stringProvider3, stringProvider4);}",
"",
" @Override",
" public void injectMembers(MethodInjection instance) {",
@@ -437,9 +550,9 @@
" injectOneArg(instance, stringProvider.get());",
" injectManyArgs(",
" instance,",
- " stringProvider.get(),",
- " DoubleCheck.lazy(stringProvider),",
- " stringProvider);",
+ " stringProvider2.get(),",
+ " DoubleCheck.lazy(stringProvider3),",
+ " stringProvider4);",
" }",
"",
" public static void injectNoArgs(Object instance) {",
@@ -483,59 +596,69 @@
" @Inject Object object;",
" @Inject void setObject(Object o) {}",
"}");
- JavaFileObject expected = JavaFileObjects.forSourceLines(
- "test.MixedMemberInjection_MembersInjector",
- "package test;",
- "",
- "import dagger.MembersInjector;",
- IMPORT_GENERATED_ANNOTATION,
- "import javax.inject.Provider;",
- "",
- GENERATED_ANNOTATION,
- "public final class MixedMemberInjection_MembersInjector",
- " implements MembersInjector<MixedMemberInjection> {",
- "",
- " private final Provider<String> stringAndSProvider;",
- " private final Provider<Object> objectAndOProvider;",
- "",
- " public MixedMemberInjection_MembersInjector(",
- " Provider<String> stringAndSProvider,",
- " Provider<Object> objectAndOProvider) {",
- " this.stringAndSProvider = stringAndSProvider;",
- " this.objectAndOProvider = objectAndOProvider;",
- " }",
- "",
- " public static MembersInjector<MixedMemberInjection> create(",
- " Provider<String> stringAndSProvider,",
- " Provider<Object> objectAndOProvider) {",
- " return new MixedMemberInjection_MembersInjector(",
- " stringAndSProvider, objectAndOProvider);",
- " }",
- "",
- " @Override",
- " public void injectMembers(MixedMemberInjection instance) {",
- " injectString(instance, stringAndSProvider.get());",
- " injectObject(instance, objectAndOProvider.get());",
- " injectSetString(instance, stringAndSProvider.get());",
- " injectSetObject(instance, objectAndOProvider.get());",
- " }",
- "",
- " public static void injectString(Object instance, String string) {",
- " ((MixedMemberInjection) instance).string = string;",
- " }",
- "",
- " public static void injectObject(Object instance, Object object) {",
- " ((MixedMemberInjection) instance).object = object;",
- " }",
- "",
- " public static void injectSetString(Object instance, String s) {",
- " ((MixedMemberInjection) instance).setString(s);",
- " }",
- "",
- " public static void injectSetObject(Object instance, Object o) {",
- " ((MixedMemberInjection) instance).setObject(o);",
- " }",
- "}");
+ JavaFileObject expected =
+ JavaFileObjects.forSourceLines(
+ "test.MixedMemberInjection_MembersInjector",
+ "package test;",
+ "",
+ "import dagger.MembersInjector;",
+ "import dagger.internal.InjectedFieldSignature;",
+ IMPORT_GENERATED_ANNOTATION,
+ "import javax.inject.Provider;",
+ "",
+ GENERATED_CODE_ANNOTATIONS,
+ "public final class MixedMemberInjection_MembersInjector",
+ " implements MembersInjector<MixedMemberInjection> {",
+ " private final Provider<String> stringProvider;",
+ " private final Provider<Object> objectProvider;",
+ " private final Provider<String> sProvider;",
+ " private final Provider<Object> oProvider;",
+ "",
+ " public MixedMemberInjection_MembersInjector(",
+ " Provider<String> stringProvider,",
+ " Provider<Object> objectProvider,",
+ " Provider<String> sProvider,",
+ " Provider<Object> oProvider) {",
+ " this.stringProvider = stringProvider;",
+ " this.objectProvider = objectProvider;",
+ " this.sProvider = sProvider;",
+ " this.oProvider = oProvider;",
+ " }",
+ "",
+ " public static MembersInjector<MixedMemberInjection> create(",
+ " Provider<String> stringProvider,",
+ " Provider<Object> objectProvider,",
+ " Provider<String> sProvider,",
+ " Provider<Object> oProvider) {",
+ " return new MixedMemberInjection_MembersInjector(",
+ " stringProvider, objectProvider, sProvider, oProvider);}",
+ "",
+ " @Override",
+ " public void injectMembers(MixedMemberInjection instance) {",
+ " injectString(instance, stringProvider.get());",
+ " injectObject(instance, objectProvider.get());",
+ " injectSetString(instance, sProvider.get());",
+ " injectSetObject(instance, oProvider.get());",
+ " }",
+ "",
+ " @InjectedFieldSignature(\"test.MixedMemberInjection.string\")",
+ " public static void injectString(Object instance, String string) {",
+ " ((MixedMemberInjection) instance).string = string;",
+ " }",
+ "",
+ " @InjectedFieldSignature(\"test.MixedMemberInjection.object\")",
+ " public static void injectObject(Object instance, Object object) {",
+ " ((MixedMemberInjection) instance).object = object;",
+ " }",
+ "",
+ " public static void injectSetString(Object instance, String s) {",
+ " ((MixedMemberInjection) instance).setString(s);",
+ " }",
+ "",
+ " public static void injectSetObject(Object instance, Object o) {",
+ " ((MixedMemberInjection) instance).setObject(o);",
+ " }",
+ "}");
assertAbout(javaSource())
.that(file)
.withCompilerOptions(compilerMode.javacopts())
@@ -556,45 +679,51 @@
" @Inject AllInjections(String s) {}",
" @Inject void s(String s) {}",
"}");
- JavaFileObject expectedMembersInjector = JavaFileObjects.forSourceLines(
- "test.AllInjections_MembersInjector",
- "package test;",
- "",
- "import dagger.MembersInjector;",
- IMPORT_GENERATED_ANNOTATION,
- "import javax.inject.Provider;",
- "",
- GENERATED_ANNOTATION,
- "public final class AllInjections_MembersInjector ",
- " implements MembersInjector<AllInjections> {",
- "",
- " private final Provider<String> sProvider;",
- "",
- " public AllInjections_MembersInjector(Provider<String> sProvider) {",
- " this.sProvider = sProvider;",
- " }",
- "",
- " public static MembersInjector<AllInjections> create(Provider<String> sProvider) {",
- " return new AllInjections_MembersInjector(sProvider);",
- " }",
- "",
- " @Override",
- " public void injectMembers(AllInjections instance) {",
- " injectS(instance, sProvider.get());",
- " injectS2(instance, sProvider.get());",
- " }",
- "",
- // TODO(b/64477506): now that these all take "object", it would be nice to rename "instance"
- // to the type name
- " public static void injectS(Object instance, String s) {",
- " ((AllInjections) instance).s = s;",
- " }",
- "",
- " public static void injectS2(Object instance, String s) {",
- " ((AllInjections) instance).s(s);",
- " }",
- "",
- "}");
+ JavaFileObject expectedMembersInjector =
+ JavaFileObjects.forSourceLines(
+ "test.AllInjections_MembersInjector",
+ "package test;",
+ "",
+ "import dagger.MembersInjector;",
+ "import dagger.internal.InjectedFieldSignature;",
+ IMPORT_GENERATED_ANNOTATION,
+ "import javax.inject.Provider;",
+ "",
+ GENERATED_CODE_ANNOTATIONS,
+ "public final class AllInjections_MembersInjector ",
+ " implements MembersInjector<AllInjections> {",
+ " private final Provider<String> sProvider;",
+ " private final Provider<String> sProvider2;",
+ "",
+ " public AllInjections_MembersInjector(",
+ " Provider<String> sProvider, Provider<String> sProvider2) {",
+ " this.sProvider = sProvider;",
+ " this.sProvider2 = sProvider2;",
+ " }",
+ "",
+ " public static MembersInjector<AllInjections> create(",
+ " Provider<String> sProvider, Provider<String> sProvider2) {",
+ " return new AllInjections_MembersInjector(sProvider, sProvider2);}",
+ "",
+ " @Override",
+ " public void injectMembers(AllInjections instance) {",
+ " injectS(instance, sProvider.get());",
+ " injectS2(instance, sProvider2.get());",
+ " }",
+ "",
+ // TODO(b/64477506): now that these all take "object", it would be nice to rename
+ // "instance"
+ // to the type name
+ " @InjectedFieldSignature(\"test.AllInjections.s\")",
+ " public static void injectS(Object instance, String s) {",
+ " ((AllInjections) instance).s = s;",
+ " }",
+ "",
+ " public static void injectS2(Object instance, String s) {",
+ " ((AllInjections) instance).s(s);",
+ " }",
+ "",
+ "}");
assertAbout(javaSource())
.that(file)
.withCompilerOptions(compilerMode.javacopts())
@@ -617,35 +746,38 @@
"class B extends A {",
" @Inject String s;",
"}");
- JavaFileObject expectedMembersInjector = JavaFileObjects.forSourceLines(
- "test.AllInjections_MembersInjector",
- "package test;",
- "",
- "import dagger.MembersInjector;",
- IMPORT_GENERATED_ANNOTATION,
- "import javax.inject.Provider;",
- "",
- GENERATED_ANNOTATION,
- "public final class B_MembersInjector implements MembersInjector<B> {",
- " private final Provider<String> sProvider;",
- "",
- " public B_MembersInjector(Provider<String> sProvider) {",
- " this.sProvider = sProvider;",
- " }",
- "",
- " public static MembersInjector<B> create(Provider<String> sProvider) {",
- " return new B_MembersInjector(sProvider);",
- " }",
- "",
- " @Override",
- " public void injectMembers(B instance) {",
- " injectS(instance, sProvider.get());",
- " }",
- "",
- " public static void injectS(Object instance, String s) {",
- " ((B) instance).s = s;",
- " }",
- "}");
+ JavaFileObject expectedMembersInjector =
+ JavaFileObjects.forSourceLines(
+ "test.AllInjections_MembersInjector",
+ "package test;",
+ "",
+ "import dagger.MembersInjector;",
+ "import dagger.internal.InjectedFieldSignature;",
+ IMPORT_GENERATED_ANNOTATION,
+ "import javax.inject.Provider;",
+ "",
+ GENERATED_CODE_ANNOTATIONS,
+ "public final class B_MembersInjector implements MembersInjector<B> {",
+ " private final Provider<String> sProvider;",
+ "",
+ " public B_MembersInjector(Provider<String> sProvider) {",
+ " this.sProvider = sProvider;",
+ " }",
+ "",
+ " public static MembersInjector<B> create(Provider<String> sProvider) {",
+ " return new B_MembersInjector(sProvider);",
+ " }",
+ "",
+ " @Override",
+ " public void injectMembers(B instance) {",
+ " injectS(instance, sProvider.get());",
+ " }",
+ "",
+ " @InjectedFieldSignature(\"test.B.s\")",
+ " public static void injectS(Object instance, String s) {",
+ " ((B) instance).s = s;",
+ " }",
+ "}");
assertAbout(javaSources())
.that(ImmutableList.of(aFile, bFile))
.withCompilerOptions(compilerMode.javacopts())
@@ -676,36 +808,40 @@
" void inject(B b);",
" }",
"}");
- JavaFileObject bMembersInjector = JavaFileObjects.forSourceLines(
- "test.OuterType_B_MembersInjector",
- "package test;",
- "",
- "import dagger.MembersInjector;",
- IMPORT_GENERATED_ANNOTATION,
- "import javax.inject.Provider;",
- "",
- GENERATED_ANNOTATION,
- "public final class OuterType_B_MembersInjector",
- " implements MembersInjector<OuterType.B> {",
- " private final Provider<OuterType.A> aProvider;",
- "",
- " public OuterType_B_MembersInjector(Provider<OuterType.A> aProvider) {",
- " this.aProvider = aProvider;",
- " }",
- "",
- " public static MembersInjector<OuterType.B> create(Provider<OuterType.A> aProvider) {",
- " return new OuterType_B_MembersInjector(aProvider);",
- " }",
- "",
- " @Override",
- " public void injectMembers(OuterType.B instance) {",
- " injectA(instance, aProvider.get());",
- " }",
- "",
- " public static void injectA(Object instance, Object a) {",
- " ((OuterType.B) instance).a = (OuterType.A) a;",
- " }",
- "}");
+ JavaFileObject bMembersInjector =
+ JavaFileObjects.forSourceLines(
+ "test.OuterType_B_MembersInjector",
+ "package test;",
+ "",
+ "import dagger.MembersInjector;",
+ "import dagger.internal.InjectedFieldSignature;",
+ IMPORT_GENERATED_ANNOTATION,
+ "import javax.inject.Provider;",
+ "",
+ GENERATED_CODE_ANNOTATIONS,
+ "public final class OuterType_B_MembersInjector",
+ " implements MembersInjector<OuterType.B> {",
+ " private final Provider<OuterType.A> aProvider;",
+ "",
+ " public OuterType_B_MembersInjector(Provider<OuterType.A> aProvider) {",
+ " this.aProvider = aProvider;",
+ " }",
+ "",
+ " public static MembersInjector<OuterType.B> create(",
+ " Provider<OuterType.A> aProvider) {",
+ " return new OuterType_B_MembersInjector(aProvider);",
+ " }",
+ "",
+ " @Override",
+ " public void injectMembers(OuterType.B instance) {",
+ " injectA(instance, aProvider.get());",
+ " }",
+ "",
+ " @InjectedFieldSignature(\"test.OuterType.B.a\")",
+ " public static void injectA(Object instance, Object a) {",
+ " ((OuterType.B) instance).a = (OuterType.A) a;",
+ " }",
+ "}");
assertAbout(javaSources())
.that(ImmutableList.of(nestedTypesFile))
.withCompilerOptions(compilerMode.javacopts())
@@ -744,10 +880,11 @@
"package test;",
"",
"import dagger.MembersInjector;",
+ "import dagger.internal.InjectedFieldSignature;",
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class OuterType_B_MembersInjector",
" implements MembersInjector<OuterType.B> {",
" private final Provider<OuterType.A> aProvider;",
@@ -766,6 +903,7 @@
" injectA(instance, aProvider.get());",
" }",
"",
+ " @InjectedFieldSignature(\"test.OuterType.B.a\")",
" public static void injectA(Object instance, Object a) {",
" ((OuterType.B) instance).a = (OuterType.A) a;",
" }",
@@ -852,8 +990,7 @@
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(foo, fooModule, fooComponent);
assertThat(compilation).succeeded();
assertThat(compilation).generatedFile(CLASS_OUTPUT, "test", "foo_MembersInjector.class");
@@ -919,10 +1056,11 @@
"package test;",
"",
"import dagger.MembersInjector;",
+ "import dagger.internal.InjectedFieldSignature;",
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class Child_MembersInjector implements MembersInjector<Child> {",
" private final Provider<Foo> objectProvider;",
" private final Provider<Bar> objectProvider2;",
@@ -944,6 +1082,7 @@
" injectObject(instance, objectProvider2.get());",
" }",
"",
+ " @InjectedFieldSignature(\"test.Child.object\")",
" public static void injectObject(Object instance, Object object) {",
" ((Child) instance).object = (Bar) object;",
" }",
@@ -969,7 +1108,7 @@
" @Inject int field;",
" }",
"}");
- Compilation compilation = daggerCompiler().withOptions(compilerMode.javacopts()).compile(file);
+ Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(file);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining("Dagger does not support injection into private classes")
@@ -989,8 +1128,7 @@
" }",
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(
+ compilerWithOptions(
compilerMode.javacopts().append("-Adagger.privateMemberValidation=WARNING"))
.compile(file);
assertThat(compilation).succeeded();
@@ -1013,7 +1151,7 @@
" @Inject int field;",
" }",
"}");
- Compilation compilation = daggerCompiler().withOptions(compilerMode.javacopts()).compile(file);
+ Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(file);
assertThat(compilation).succeeded();
}
@@ -1037,15 +1175,37 @@
" void inject(RawProviderField rawProviderField);",
"}");
- Compilation compilation = daggerCompiler().withOptions(compilerMode.javacopts()).compile(file);
+ Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(file);
assertThat(compilation).failed();
assertThat(compilation)
- .hadErrorContaining("javax.inject.Provider cannot be provided")
+ .hadErrorContaining("Provider cannot be provided")
.inFile(file)
.onLineContaining("interface C");
}
@Test
+ public void throwExceptionInjectedMethod() {
+ JavaFileObject file =
+ JavaFileObjects.forSourceLines(
+ "test.",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "import javax.inject.Inject;",
+ "class SomeClass {",
+ "@Inject void inject() throws Exception {}",
+ "}");
+
+ Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(file);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining("Methods with @Inject may not throw checked exceptions. "
+ + "Please wrap your exceptions in a RuntimeException instead.")
+ .inFile(file)
+ .onLineContaining("throws Exception");
+ }
+
+ @Test
public void rawFrameworkTypeParameter() {
JavaFileObject file =
JavaFileObjects.forSourceLines(
@@ -1065,10 +1225,10 @@
" void inject(RawProviderParameter rawProviderParameter);",
"}");
- Compilation compilation = daggerCompiler().withOptions(compilerMode.javacopts()).compile(file);
+ Compilation compilation = compilerWithOptions(compilerMode.javacopts()).compile(file);
assertThat(compilation).failed();
assertThat(compilation)
- .hadErrorContaining("javax.inject.Provider cannot be provided")
+ .hadErrorContaining("Provider cannot be provided")
.inFile(file)
.onLineContaining("interface C");
}
@@ -1094,34 +1254,38 @@
"package test;",
"",
"import dagger.MembersInjector;",
+ "import dagger.internal.InjectedFieldSignature;",
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class InjectedType_MembersInjector ",
" implements MembersInjector<InjectedType> {",
- " private final Provider<Integer> boxedIntAndPrimitiveIntProvider;",
+ " private final Provider<Integer> primitiveIntProvider;",
+ " private final Provider<Integer> boxedIntProvider;",
"",
" public InjectedType_MembersInjector(",
- " Provider<Integer> boxedIntAndPrimitiveIntProvider) {",
- " this.boxedIntAndPrimitiveIntProvider = boxedIntAndPrimitiveIntProvider;",
+ " Provider<Integer> primitiveIntProvider, Provider<Integer> boxedIntProvider) {",
+ " this.primitiveIntProvider = primitiveIntProvider;",
+ " this.boxedIntProvider = boxedIntProvider;",
" }",
"",
" public static MembersInjector<InjectedType> create(",
- " Provider<Integer> boxedIntAndPrimitiveIntProvider) {",
- " return new InjectedType_MembersInjector(boxedIntAndPrimitiveIntProvider);",
- " }",
+ " Provider<Integer> primitiveIntProvider, Provider<Integer> boxedIntProvider) {",
+ " return new InjectedType_MembersInjector(primitiveIntProvider, boxedIntProvider);}",
"",
" @Override",
" public void injectMembers(InjectedType instance) {",
- " injectPrimitiveInt(instance, boxedIntAndPrimitiveIntProvider.get());",
- " injectBoxedInt(instance, boxedIntAndPrimitiveIntProvider.get());",
+ " injectPrimitiveInt(instance, primitiveIntProvider.get());",
+ " injectBoxedInt(instance, boxedIntProvider.get());",
" }",
"",
+ " @InjectedFieldSignature(\"test.InjectedType.primitiveInt\")",
" public static void injectPrimitiveInt(Object instance, int primitiveInt) {",
" ((InjectedType) instance).primitiveInt = primitiveInt;",
" }",
"",
+ " @InjectedFieldSignature(\"test.InjectedType.boxedInt\")",
" public static void injectBoxedInt(Object instance, Integer boxedInt) {",
" ((InjectedType) instance).boxedInt = boxedInt;",
" }",
@@ -1135,27 +1299,30 @@
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class InjectedType_Factory implements Factory<InjectedType> {",
- " private final Provider<Integer> boxedIntAndPrimitiveIntProvider;",
+ " private final Provider<Integer> primitiveIntProvider;",
"",
- " public InjectedType_Factory(Provider<Integer> boxedIntAndPrimitiveIntProvider) {",
- " this.boxedIntAndPrimitiveIntProvider = boxedIntAndPrimitiveIntProvider;",
+ " private final Provider<Integer> boxedIntProvider;",
+ "",
+ " public InjectedType_Factory(",
+ " Provider<Integer> primitiveIntProvider, Provider<Integer> boxedIntProvider) {",
+ " this.primitiveIntProvider = primitiveIntProvider;",
+ " this.boxedIntProvider = boxedIntProvider;",
" }",
"",
" @Override",
" public InjectedType get() {",
- " InjectedType instance = new InjectedType();",
+ " InjectedType instance = newInstance();",
" InjectedType_MembersInjector.injectPrimitiveInt(",
- " instance, boxedIntAndPrimitiveIntProvider.get());",
- " InjectedType_MembersInjector.injectBoxedInt(",
- " instance, boxedIntAndPrimitiveIntProvider.get());",
+ " instance, primitiveIntProvider.get());",
+ " InjectedType_MembersInjector.injectBoxedInt(instance, boxedIntProvider.get());",
" return instance;",
" }",
"",
" public static InjectedType_Factory create(",
- " Provider<Integer> boxedIntAndPrimitiveIntProvider) {",
- " return new InjectedType_Factory(boxedIntAndPrimitiveIntProvider);",
+ " Provider<Integer> primitiveIntProvider, Provider<Integer> boxedIntProvider) {",
+ " return new InjectedType_Factory(primitiveIntProvider, boxedIntProvider);",
" }",
"",
" public static InjectedType newInstance() {",
@@ -1163,7 +1330,7 @@
" }",
"}");
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(injectedType);
+ compilerWithOptions(compilerMode.javacopts()).compile(injectedType);
assertThat(compilation).succeeded();
assertThat(compilation)
.generatedSourceFile("test.InjectedType_MembersInjector")
@@ -1221,8 +1388,7 @@
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(foo, inaccessible, usesInaccessible, component);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -1233,28 +1399,33 @@
"package other;",
"",
"import dagger.MembersInjector;",
+ "import dagger.internal.InjectedFieldSignature;",
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class Inaccessible_MembersInjector",
" implements MembersInjector<Inaccessible> {",
" private final Provider<Foo> fooProvider;",
+ " private final Provider<Foo> fooProvider2;",
"",
- " public Inaccessible_MembersInjector(Provider<Foo> fooProvider) {",
+ " public Inaccessible_MembersInjector(",
+ " Provider<Foo> fooProvider, Provider<Foo> fooProvider2) {",
" this.fooProvider = fooProvider;",
+ " this.fooProvider2 = fooProvider2;",
" }",
"",
- " public static MembersInjector<Inaccessible> create(Provider<Foo> fooProvider) {",
- " return new Inaccessible_MembersInjector(fooProvider);",
- " }",
+ " public static MembersInjector<Inaccessible> create(",
+ " Provider<Foo> fooProvider, Provider<Foo> fooProvider2) {",
+ " return new Inaccessible_MembersInjector(fooProvider, fooProvider2);}",
"",
" @Override",
" public void injectMembers(Inaccessible instance) {",
" injectFoo(instance, fooProvider.get());",
- " injectMethod(instance, fooProvider.get());",
+ " injectMethod(instance, fooProvider2.get());",
" }",
"",
+ " @InjectedFieldSignature(\"other.Inaccessible.foo\")",
" public static void injectFoo(Object instance, Object foo) {",
" ((Inaccessible) instance).foo = (Foo) foo;",
" }",
@@ -1276,16 +1447,16 @@
"import other.UsesInaccessible;",
"import other.UsesInaccessible_Factory;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
- " private Object getInaccessible() {",
+ " private Object inaccessible() {",
" return injectInaccessible(Inaccessible_Factory.newInstance());",
" }",
"",
" @Override",
" public UsesInaccessible usesInaccessible() {",
" return UsesInaccessible_Factory.newInstance(",
- " getInaccessible());",
+ " inaccessible());",
" }",
"",
// TODO(ronshapiro): if possible, it would be great to rename "instance", but we
@@ -1358,8 +1529,7 @@
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(inaccessible, inaccessiblesModule, usesInaccessibles, component);
assertThat(compilation).succeeded();
JavaFileObject generatedComponent =
@@ -1375,13 +1545,13 @@
"import other.UsesInaccessibles_Factory;",
"import other.UsesInaccessibles_MembersInjector;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {")
.addLinesIn(
FAST_INIT_MODE,
" private volatile Object listOfInaccessible = new MemoizedSentinel();",
"",
- " private List getListOfInaccessible() {",
+ " private List listOfInaccessible() {",
" Object local = listOfInaccessible;",
" if (local instanceof MemoizedSentinel) {",
" synchronized (local) {",
@@ -1419,7 +1589,7 @@
" UsesInaccessibles_MembersInjector.injectInaccessibles(")
.addLinesIn(
FAST_INIT_MODE,
- " instance, (List) getListOfInaccessible());")
+ " instance, (List) listOfInaccessible());")
.addLinesIn(
DEFAULT_MODE,
" instance, (List) inaccessiblesProvider.get());")
@@ -1488,8 +1658,7 @@
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(foo, supertype, subtype, injectsSubtype, component);
assertThat(compilation).succeeded();
JavaFileObject generatedComponent =
@@ -1505,15 +1674,15 @@
"import other.Supertype;",
"import other.Supertype_MembersInjector;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
- " private Object getSubtype() {",
+ " private Object subtype() {",
" return injectSubtype(Subtype_Factory.newInstance());",
" }",
"",
" @Override",
" public InjectsSubtype injectsSubtype() {",
- " return InjectsSubtype_Factory.newInstance(getSubtype());",
+ " return InjectsSubtype_Factory.newInstance(subtype());",
" }",
"",
" @CanIgnoreReturnValue",
@@ -1528,4 +1697,227 @@
.generatedSourceFile("test.DaggerTestComponent")
.containsElementsIn(generatedComponent);
}
+
+ // Shows that we shouldn't create a members injector for a type that doesn't have
+ // @Inject fields or @Inject constructor even if it extends and is extended by types that do.
+ @Test
+ public void middleClassNoFieldInjection() {
+ JavaFileObject classA =
+ JavaFileObjects.forSourceLines(
+ "test.A",
+ "package test;",
+ "",
+ "import javax.inject.Inject;",
+ "",
+ "class A extends B {",
+ " @Inject String valueA;",
+ "}");
+ JavaFileObject classB =
+ JavaFileObjects.forSourceLines(
+ "test.B",
+ "package test;",
+ "",
+ "class B extends C {",
+ "}");
+ JavaFileObject classC =
+ JavaFileObjects.forSourceLines(
+ "test.C",
+ "package test;",
+ "",
+ "import javax.inject.Inject;",
+ "",
+ "class C { ",
+ " @Inject String valueC;",
+ "}");
+ JavaFileObject expectedAMembersInjector =
+ JavaFileObjects.forSourceLines(
+ "test.A_MembersInjector",
+ "package test;",
+ "",
+ "import dagger.MembersInjector;",
+ "import dagger.internal.InjectedFieldSignature;",
+ IMPORT_GENERATED_ANNOTATION,
+ "import javax.inject.Provider;",
+ "",
+ GENERATED_CODE_ANNOTATIONS,
+ "public final class A_MembersInjector implements MembersInjector<A> {",
+ " private final Provider<String> valueCProvider;",
+ " private final Provider<String> valueAProvider;",
+ "",
+ " public A_MembersInjector(",
+ " Provider<String> valueCProvider, Provider<String> valueAProvider) {",
+ " this.valueCProvider = valueCProvider;",
+ " this.valueAProvider = valueAProvider;",
+ " }",
+ "",
+ " public static MembersInjector<A> create(",
+ " Provider<String> valueCProvider, Provider<String> valueAProvider) {",
+ " return new A_MembersInjector(valueCProvider, valueAProvider);",
+ " }",
+ "",
+ " @Override",
+ " public void injectMembers(A instance) {",
+ " C_MembersInjector.injectValueC(instance, valueCProvider.get());",
+ " injectValueA(instance, valueAProvider.get());",
+ " }",
+ "",
+ " @InjectedFieldSignature(\"test.A.valueA\")",
+ " public static void injectValueA(Object instance, String valueA) {",
+ " ((A) instance).valueA = valueA;",
+ " }",
+ "}");
+
+ JavaFileObject expectedCMembersInjector =
+ JavaFileObjects.forSourceLines(
+ "test.C_MembersInjector",
+ "package test;",
+ "",
+ "import dagger.MembersInjector;",
+ "import dagger.internal.InjectedFieldSignature;",
+ IMPORT_GENERATED_ANNOTATION,
+ "import javax.inject.Provider;",
+ "",
+ GENERATED_CODE_ANNOTATIONS,
+ "public final class C_MembersInjector implements MembersInjector<C> {",
+ " private final Provider<String> valueCProvider;",
+ "",
+ " public C_MembersInjector(Provider<String> valueCProvider) {",
+ " this.valueCProvider = valueCProvider;",
+ " }",
+ "",
+ " public static MembersInjector<C> create(",
+ " Provider<String> valueCProvider) {",
+ " return new C_MembersInjector(valueCProvider);",
+ " }",
+ "",
+ " @Override",
+ " public void injectMembers(C instance) {",
+ " injectValueC(instance, valueCProvider.get());",
+ " }",
+ "",
+ " @InjectedFieldSignature(\"test.C.valueC\")",
+ " public static void injectValueC(Object instance, String valueC) {",
+ " ((C) instance).valueC = valueC;",
+ " }",
+ "}");
+
+
+ Compilation compilation =
+ compilerWithOptions(compilerMode.javacopts())
+ .compile(classA, classB, classC);
+ assertThat(compilation).succeeded();
+ assertThat(compilation)
+ .generatedSourceFile("test.A_MembersInjector")
+ .hasSourceEquivalentTo(expectedAMembersInjector);
+ assertThat(compilation)
+ .generatedSourceFile("test.C_MembersInjector")
+ .hasSourceEquivalentTo(expectedCMembersInjector);
+
+ try {
+ assertThat(compilation).generatedSourceFile("test.B_MembersInjector");
+ // Can't throw an assertion error since it would be caught.
+ throw new IllegalStateException("Test generated a B_MembersInjector");
+ } catch (AssertionError expected) {
+ }
+ }
+
+ // Shows that we do generate a MembersInjector for a type that has an @Inject
+ // constructor and that extends a type with @Inject fields, even if it has no local field
+ // injection sites
+ // TODO(erichang): Are these even used anymore?
+ @Test
+ public void testConstructorInjectedFieldInjection() {
+ JavaFileObject classA =
+ JavaFileObjects.forSourceLines(
+ "test.A",
+ "package test;",
+ "",
+ "import javax.inject.Inject;",
+ "",
+ "class A extends B {",
+ " @Inject A() {}",
+ "}");
+ JavaFileObject classB =
+ JavaFileObjects.forSourceLines(
+ "test.B",
+ "package test;",
+ "",
+ "import javax.inject.Inject;",
+ "",
+ "class B { ",
+ " @Inject String valueB;",
+ "}");
+ JavaFileObject expectedAMembersInjector =
+ JavaFileObjects.forSourceLines(
+ "test.A_MembersInjector",
+ "package test;",
+ "",
+ "import dagger.MembersInjector;",
+ IMPORT_GENERATED_ANNOTATION,
+ "import javax.inject.Provider;",
+ "",
+ GENERATED_CODE_ANNOTATIONS,
+ "public final class A_MembersInjector implements MembersInjector<A> {",
+ " private final Provider<String> valueBProvider;",
+ "",
+ " public A_MembersInjector(Provider<String> valueBProvider) {",
+ " this.valueBProvider = valueBProvider;",
+ " }",
+ "",
+ " public static MembersInjector<A> create(Provider<String> valueBProvider) {",
+ " return new A_MembersInjector(valueBProvider);",
+ " }",
+ "",
+ " @Override",
+ " public void injectMembers(A instance) {",
+ " B_MembersInjector.injectValueB(instance, valueBProvider.get());",
+ " }",
+ "}");
+
+ JavaFileObject expectedBMembersInjector =
+ JavaFileObjects.forSourceLines(
+ "test.B_MembersInjector",
+ "package test;",
+ "",
+ "import dagger.MembersInjector;",
+ "import dagger.internal.InjectedFieldSignature;",
+ IMPORT_GENERATED_ANNOTATION,
+ "import javax.inject.Provider;",
+ "",
+ GENERATED_CODE_ANNOTATIONS,
+ "public final class B_MembersInjector implements MembersInjector<B> {",
+ " private final Provider<String> valueBProvider;",
+ "",
+ " public B_MembersInjector(Provider<String> valueBProvider) {",
+ " this.valueBProvider = valueBProvider;",
+ " }",
+ "",
+ " public static MembersInjector<B> create(",
+ " Provider<String> valueBProvider) {",
+ " return new B_MembersInjector(valueBProvider);",
+ " }",
+ "",
+ " @Override",
+ " public void injectMembers(B instance) {",
+ " injectValueB(instance, valueBProvider.get());",
+ " }",
+ "",
+ " @InjectedFieldSignature(\"test.B.valueB\")",
+ " public static void injectValueB(Object instance, String valueB) {",
+ " ((B) instance).valueB = valueB;",
+ " }",
+ "}");
+
+
+ Compilation compilation =
+ compilerWithOptions(compilerMode.javacopts())
+ .compile(classA, classB);
+ assertThat(compilation).succeeded();
+ assertThat(compilation)
+ .generatedSourceFile("test.A_MembersInjector")
+ .hasSourceEquivalentTo(expectedAMembersInjector);
+ assertThat(compilation)
+ .generatedSourceFile("test.B_MembersInjector")
+ .hasSourceEquivalentTo(expectedBMembersInjector);
+ }
}
diff --git a/javatests/dagger/internal/codegen/MembersInjectionValidationTest.java b/javatests/dagger/internal/codegen/MembersInjectionValidationTest.java
index 68d5daa..d8cd6d9 100644
--- a/javatests/dagger/internal/codegen/MembersInjectionValidationTest.java
+++ b/javatests/dagger/internal/codegen/MembersInjectionValidationTest.java
@@ -236,4 +236,177 @@
assertThat(compilation).failed();
assertThat(compilation).hadErrorContaining("static fields").inFile(injected).onLine(6);
}
+
+ @Test
+ public void missingMembersInjectorForKotlinProperty() {
+ JavaFileObject component =
+ JavaFileObjects.forSourceLines(
+ "test.TestComponent",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "import dagger.internal.codegen.KotlinInjectedQualifier;",
+ "",
+ "@Component(modules = TestModule.class)",
+ "interface TestComponent {",
+ " void inject(KotlinInjectedQualifier injected);",
+ "}");
+ JavaFileObject module =
+ JavaFileObjects.forSourceLines(
+ "test.TestModule",
+ "package test;",
+ "",
+ "import dagger.Module;",
+ "import dagger.Provides;",
+ "import javax.inject.Named;",
+ "",
+ "@Module",
+ "class TestModule {",
+ " @Provides",
+ " @Named(\"TheString\")",
+ " String theString() { return \"\"; }",
+ "}");
+ Compilation compilation = daggerCompiler().compile(component, module);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining("Unable to read annotations on an injected Kotlin property.");
+ }
+
+ @Test
+ public void memberInjectionForKotlinObjectFails() {
+ JavaFileObject component =
+ JavaFileObjects.forSourceLines(
+ "test.TestComponent",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "import dagger.internal.codegen.KotlinObjectWithMemberInjection;",
+ "",
+ "@Component(modules = TestModule.class)",
+ "interface TestComponent {",
+ " void inject(KotlinObjectWithMemberInjection injected);",
+ "}");
+ Compilation compilation = daggerCompiler().compile(component, testModule);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining("Dagger does not support injection into Kotlin objects");
+ }
+
+ @Test
+ public void setterMemberInjectionForKotlinObjectFails() {
+ JavaFileObject component =
+ JavaFileObjects.forSourceLines(
+ "test.TestComponent",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "import dagger.internal.codegen.KotlinObjectWithSetterMemberInjection;",
+ "",
+ "@Component(modules = TestModule.class)",
+ "interface TestComponent {",
+ " void inject(KotlinObjectWithSetterMemberInjection injected);",
+ "}");
+ Compilation compilation = daggerCompiler().compile(component, testModule);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining("Dagger does not support injection into Kotlin objects");
+ }
+
+ @Test
+ public void memberInjectionForKotlinClassWithCompanionObjectFails() {
+ JavaFileObject component =
+ JavaFileObjects.forSourceLines(
+ "test.TestComponent",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "import dagger.internal.codegen.KotlinClassWithMemberInjectedCompanion;",
+ "",
+ "@Component(modules = TestModule.class)",
+ "interface TestComponent {",
+ " void inject(KotlinClassWithMemberInjectedCompanion injected);",
+ " void injectCompanion(KotlinClassWithMemberInjectedCompanion.Companion injected);",
+ "}");
+ Compilation compilation = daggerCompiler().compile(component, testModule);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining("Dagger does not support injection into static fields");
+ }
+
+ @Test
+ public void setterMemberInjectionForKotlinClassWithCompanionObjectFails() {
+ JavaFileObject component =
+ JavaFileObjects.forSourceLines(
+ "test.TestComponent",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "import dagger.internal.codegen.KotlinClassWithSetterMemberInjectedCompanion;",
+ "",
+ "@Component(modules = TestModule.class)",
+ "interface TestComponent {",
+ " void inject(KotlinClassWithSetterMemberInjectedCompanion.Companion injected);",
+ "}");
+ Compilation compilation = daggerCompiler().compile(component, testModule);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining("Dagger does not support injection into Kotlin objects");
+ }
+
+ @Test
+ public void memberInjectionForKotlinClassWithNamedCompanionObjectFails() {
+ JavaFileObject component =
+ JavaFileObjects.forSourceLines(
+ "test.TestComponent",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "import dagger.internal.codegen.KotlinClassWithMemberInjectedNamedCompanion;",
+ "",
+ "@Component(modules = TestModule.class)",
+ "interface TestComponent {",
+ " void inject(KotlinClassWithMemberInjectedNamedCompanion injected);",
+ " void injectCompanion(KotlinClassWithMemberInjectedNamedCompanion.TheCompanion"
+ + " injected);",
+ "}");
+ Compilation compilation = daggerCompiler().compile(component, testModule);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining("Dagger does not support injection into static fields");
+ }
+
+ @Test
+ public void setterMemberInjectionForKotlinClassWithNamedCompanionObjectFails() {
+ JavaFileObject component =
+ JavaFileObjects.forSourceLines(
+ "test.TestComponent",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "import dagger.internal.codegen.KotlinClassWithSetterMemberInjectedNamedCompanion;",
+ "",
+ "@Component(modules = TestModule.class)",
+ "interface TestComponent {",
+ " void inject(",
+ " KotlinClassWithSetterMemberInjectedNamedCompanion.TheCompanion injected);",
+ "}");
+ Compilation compilation = daggerCompiler().compile(component, testModule);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining("Dagger does not support injection into Kotlin objects");
+ }
+
+ private final JavaFileObject testModule =
+ JavaFileObjects.forSourceLines(
+ "test.TestModule",
+ "package test;",
+ "",
+ "import dagger.Module;",
+ "import dagger.Provides;",
+ "",
+ "@Module",
+ "class TestModule {",
+ " @Provides",
+ " String theString() { return \"\"; }",
+ "}");
}
diff --git a/javatests/dagger/internal/codegen/MethodSignatureFormatterTest.java b/javatests/dagger/internal/codegen/MethodSignatureFormatterTest.java
index 687c29a..6d2f989 100644
--- a/javatests/dagger/internal/codegen/MethodSignatureFormatterTest.java
+++ b/javatests/dagger/internal/codegen/MethodSignatureFormatterTest.java
@@ -22,12 +22,20 @@
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import com.google.testing.compile.CompilationRule;
+import dagger.BindsInstance;
+import dagger.Component;
+import dagger.Module;
+import dagger.Provides;
import dagger.internal.codegen.MethodSignatureFormatterTest.OuterClass.InnerClass;
+import dagger.internal.codegen.binding.InjectionAnnotations;
+import dagger.internal.codegen.binding.MethodSignatureFormatter;
import dagger.internal.codegen.langmodel.DaggerElements;
import dagger.internal.codegen.langmodel.DaggerTypes;
+import javax.inject.Inject;
import javax.inject.Singleton;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.TypeElement;
+import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -37,6 +45,10 @@
public class MethodSignatureFormatterTest {
@Rule public CompilationRule compilationRule = new CompilationRule();
+ @Inject DaggerElements elements;
+ @Inject DaggerTypes types;
+ @Inject InjectionAnnotations injectionAnnotations;
+
static class OuterClass {
@interface Foo {
Class<?> bar();
@@ -53,13 +65,15 @@
}
}
+ @Before
+ public void setUp() {
+ DaggerMethodSignatureFormatterTest_TestComponent.factory().create(compilationRule).inject(this);
+ }
+
@Test public void methodSignatureTest() {
- DaggerElements elements =
- new DaggerElements(compilationRule.getElements(), compilationRule.getTypes());
- DaggerTypes types = new DaggerTypes(compilationRule.getTypes(), elements);
TypeElement inner = elements.getTypeElement(InnerClass.class);
ExecutableElement method = Iterables.getOnlyElement(methodsIn(inner.getEnclosedElements()));
- String formatted = new MethodSignatureFormatter(types).format(method);
+ String formatted = new MethodSignatureFormatter(types, injectionAnnotations).format(method);
// This is gross, but it turns out that annotation order is not guaranteed when getting
// all the AnnotationMirrors from an Element, so I have to test this chopped-up to make it
// less brittle.
@@ -71,4 +85,28 @@
assertThat(formatted).contains(" String "); // return type compressed
assertThat(formatted).contains("int, ImmutableList<Boolean>)"); // parameters compressed.
}
+
+ @Singleton
+ @Component(modules = TestModule.class)
+ interface TestComponent {
+ void inject(MethodSignatureFormatterTest test);
+
+ @Component.Factory
+ interface Factory {
+ TestComponent create(@BindsInstance CompilationRule compilationRule);
+ }
+ }
+
+ @Module
+ static class TestModule {
+ @Provides
+ static DaggerElements elements(CompilationRule compilationRule) {
+ return new DaggerElements(compilationRule.getElements(), compilationRule.getTypes());
+ }
+
+ @Provides
+ static DaggerTypes types(CompilationRule compilationRule, DaggerElements elements) {
+ return new DaggerTypes(compilationRule.getTypes(), elements);
+ }
+ }
}
diff --git a/javatests/dagger/internal/codegen/MissingBindingSuggestionsTest.java b/javatests/dagger/internal/codegen/MissingBindingSuggestionsTest.java
index e2f9634..3c066ba 100644
--- a/javatests/dagger/internal/codegen/MissingBindingSuggestionsTest.java
+++ b/javatests/dagger/internal/codegen/MissingBindingSuggestionsTest.java
@@ -18,6 +18,7 @@
import static com.google.testing.compile.CompilationSubject.assertThat;
import static dagger.internal.codegen.Compilers.daggerCompiler;
+import static dagger.internal.codegen.TestUtils.message;
import com.google.testing.compile.Compilation;
import com.google.testing.compile.JavaFileObjects;
@@ -94,8 +95,9 @@
Compilation compilation =
daggerCompiler().compile(fooComponent, barComponent, topComponent, foo, bar, barModule);
assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
assertThat(compilation)
- .hadErrorContaining("A binding with matching key exists in component: test.BarComponent");
+ .hadErrorContaining("A binding with matching key exists in component: BarComponent");
}
@Test public void suggestsBindingInNestedSubcomponent() {
@@ -154,7 +156,164 @@
daggerCompiler()
.compile(fooComponent, barComponent, bazComponent, topComponent, foo, baz, bazModule);
assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
assertThat(compilation)
- .hadErrorContaining("A binding with matching key exists in component: test.BazComponent");
+ .hadErrorContaining("A binding with matching key exists in component: BazComponent");
+ }
+
+ @Test
+ public void missingBindingInParentComponent() {
+ JavaFileObject parent =
+ JavaFileObjects.forSourceLines(
+ "Parent",
+ "import dagger.Component;",
+ "",
+ "@Component",
+ "interface Parent {",
+ " Foo foo();",
+ " Bar bar();",
+ " Child child();",
+ "}");
+ JavaFileObject child =
+ JavaFileObjects.forSourceLines(
+ "Child",
+ "import dagger.Subcomponent;",
+ "",
+ "@Subcomponent(modules=BazModule.class)",
+ "interface Child {",
+ " Foo foo();",
+ " Baz baz();",
+ "}");
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "Foo",
+ "import javax.inject.Inject;",
+ "",
+ "class Foo {",
+ " @Inject Foo(Bar bar) {}",
+ "}");
+ JavaFileObject bar =
+ JavaFileObjects.forSourceLines(
+ "Bar",
+ "import javax.inject.Inject;",
+ "",
+ "class Bar {",
+ " @Inject Bar(Baz baz) {}",
+ "}");
+ JavaFileObject baz = JavaFileObjects.forSourceLines("Baz", "class Baz {}");
+ JavaFileObject bazModule = JavaFileObjects.forSourceLines(
+ "BazModule",
+ "import dagger.Module;",
+ "import dagger.Provides;",
+ "import javax.inject.Inject;",
+ "",
+ "@Module",
+ "final class BazModule {",
+ " @Provides Baz provideBaz() {return new Baz();}",
+ "}");
+
+ Compilation compilation = daggerCompiler().compile(parent, child, foo, bar, baz, bazModule);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ message(
+ "\033[1;31m[Dagger/MissingBinding]\033[0m Baz cannot be provided without an "
+ + "@Inject constructor or an @Provides-annotated method.",
+ "A binding with matching key exists in component: Child",
+ " Baz is injected at",
+ " Bar(baz)",
+ " Bar is requested at",
+ " Parent.bar()",
+ "The following other entry points also depend on it:",
+ " Parent.foo()",
+ " Child.foo() [Parent → Child]"))
+ .inFile(parent)
+ .onLineContaining("interface Parent");
+ }
+
+ @Test
+ public void missingBindingInSiblingComponent() {
+ JavaFileObject parent =
+ JavaFileObjects.forSourceLines(
+ "Parent",
+ "import dagger.Component;",
+ "",
+ "@Component",
+ "interface Parent {",
+ " Foo foo();",
+ " Bar bar();",
+ " Child1 child1();",
+ " Child2 child2();",
+ "}");
+ JavaFileObject child1 =
+ JavaFileObjects.forSourceLines(
+ "Child1",
+ "import dagger.Subcomponent;",
+ "",
+ "@Subcomponent",
+ "interface Child1 {",
+ " Foo foo();",
+ " Baz baz();",
+ "}");
+ JavaFileObject child2 =
+ JavaFileObjects.forSourceLines(
+ "Child2",
+ "import dagger.Subcomponent;",
+ "",
+ "@Subcomponent(modules = BazModule.class)",
+ "interface Child2 {",
+ " Foo foo();",
+ " Baz baz();",
+ "}");
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "Foo",
+ "import javax.inject.Inject;",
+ "",
+ "class Foo {",
+ " @Inject Foo(Bar bar) {}",
+ "}");
+ JavaFileObject bar =
+ JavaFileObjects.forSourceLines(
+ "Bar",
+ "import javax.inject.Inject;",
+ "",
+ "class Bar {",
+ " @Inject Bar(Baz baz) {}",
+ "}");
+ JavaFileObject baz = JavaFileObjects.forSourceLines("Baz", "class Baz {}");
+ JavaFileObject bazModule = JavaFileObjects.forSourceLines(
+ "BazModule",
+ "import dagger.Module;",
+ "import dagger.Provides;",
+ "import javax.inject.Inject;",
+ "",
+ "@Module",
+ "final class BazModule {",
+ " @Provides Baz provideBaz() {return new Baz();}",
+ "}");
+
+ Compilation compilation =
+ daggerCompiler().compile(parent, child1, child2, foo, bar, baz, bazModule);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ message(
+ "\033[1;31m[Dagger/MissingBinding]\033[0m Baz cannot be provided without an "
+ + "@Inject constructor or an @Provides-annotated method.",
+ "A binding with matching key exists in component: Child2",
+ " Baz is injected at",
+ " Bar(baz)",
+ " Bar is requested at",
+ " Parent.bar()",
+ "The following other entry points also depend on it:",
+ " Parent.foo()",
+ " Child1.foo() [Parent → Child1]",
+ " Child2.foo() [Parent → Child2]",
+ " Child1.baz() [Parent → Child1]"))
+ .inFile(parent)
+ .onLineContaining("interface Parent");
}
}
diff --git a/javatests/dagger/internal/codegen/MissingBindingValidationTest.java b/javatests/dagger/internal/codegen/MissingBindingValidationTest.java
index 8eaa8d5..1aabd48 100644
--- a/javatests/dagger/internal/codegen/MissingBindingValidationTest.java
+++ b/javatests/dagger/internal/codegen/MissingBindingValidationTest.java
@@ -56,8 +56,9 @@
"interface Bar {}");
Compilation compilation = daggerCompiler().compile(component, injectable, nonInjectable);
assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
assertThat(compilation)
- .hadErrorContaining("test.Bar cannot be provided without an @Provides-annotated method.")
+ .hadErrorContaining("Bar cannot be provided without an @Provides-annotated method.")
.inFile(component)
.onLineContaining("interface MyComponent");
}
@@ -81,9 +82,10 @@
"}");
Compilation compilation = daggerCompiler().compile(component);
assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
assertThat(compilation)
.hadErrorContaining(
- "[Dagger/MissingBinding] test.TestClass.A cannot be provided "
+ "\033[1;31m[Dagger/MissingBinding]\033[0m TestClass.A cannot be provided "
+ "without an @Provides-annotated method.")
.inFile(component)
.onLineContaining("interface AComponent");
@@ -110,9 +112,10 @@
"}");
Compilation compilation = daggerCompiler().compile(component);
assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
assertThat(compilation)
.hadErrorContaining(
- "[Dagger/MissingBinding] @test.TestClass.Q test.TestClass.A cannot be provided "
+ "\033[1;31m[Dagger/MissingBinding]\033[0m @TestClass.Q TestClass.A cannot be provided "
+ "without an @Provides-annotated method.")
.inFile(component)
.onLineContaining("interface AComponent");
@@ -140,9 +143,10 @@
Compilation compilation = daggerCompiler().compile(component);
assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
assertThat(compilation)
.hadErrorContaining(
- "test.TestClass.A cannot be provided without an @Inject constructor or an "
+ "TestClass.A cannot be provided without an @Inject constructor or an "
+ "@Provides-annotated method.")
.inFile(component)
.onLineContaining("interface AComponent");
@@ -174,9 +178,10 @@
Compilation compilation = daggerCompiler().compile(component);
assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
assertThat(compilation)
.hadErrorContaining(
- "test.TestClass.B cannot be provided without an @Inject constructor or an "
+ "TestClass.B cannot be provided without an @Inject constructor or an "
+ "@Provides-annotated method. This type supports members injection but cannot be "
+ "implicitly provided.")
.inFile(component)
@@ -210,8 +215,9 @@
Compilation compilation = daggerCompiler().compile(self, component);
assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
assertThat(compilation)
- .hadErrorContaining("test.Self cannot be provided without an @Inject constructor")
+ .hadErrorContaining("Self cannot be provided without an @Inject constructor")
.inFile(component)
.onLineContaining("interface SelfComponent");
}
@@ -241,9 +247,10 @@
"}");
Compilation compilation = daggerCompiler().compile(component, foo);
assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
assertThat(compilation)
.hadErrorContaining(
- "test.Foo<? extends java.lang.Number> cannot be provided "
+ "Foo<? extends Number> cannot be provided "
+ "without an @Provides-annotated method");
}
@@ -300,21 +307,22 @@
Compilation compilation = daggerCompiler().compile(component);
assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
assertThat(compilation)
.hadErrorContaining(
message(
- "test.TestClass.A cannot be provided without an @Provides-annotated method.",
- " test.TestClass.A is injected at",
- " test.TestClass.B(a)",
- " test.TestClass.B is injected at",
- " test.TestClass.C.b",
- " test.TestClass.C is injected at",
- " test.TestClass.AComponent.injectC(test.TestClass.C)",
+ "TestClass.A cannot be provided without an @Provides-annotated method.",
+ " TestClass.A is injected at",
+ " TestClass.B(a)",
+ " TestClass.B is injected at",
+ " TestClass.C.b",
+ " TestClass.C is injected at",
+ " TestClass.AComponent.injectC(TestClass.C)",
"The following other entry points also depend on it:",
- " test.TestClass.AComponent.getFoo()",
- " test.TestClass.AComponent.cProvider()",
- " test.TestClass.AComponent.lazyC()",
- " test.TestClass.AComponent.lazyCProvider()"))
+ " TestClass.AComponent.getFoo()",
+ " TestClass.AComponent.cProvider()",
+ " TestClass.AComponent.lazyC()",
+ " TestClass.AComponent.lazyCProvider()"))
.inFile(component)
.onLineContaining("interface AComponent");
}
@@ -354,16 +362,17 @@
Compilation compilation =
daggerCompiler().compile(component, module, interfaceFile, implementationFile);
assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
assertThat(compilation)
.hadErrorContaining(
message(
- "java.lang.String cannot be provided without an @Inject constructor or an "
+ "String cannot be provided without an @Inject constructor or an "
+ "@Provides-annotated method.",
- " java.lang.String is injected at",
+ " String is injected at",
" TestImplementation(missingBinding)",
" TestImplementation is injected at",
" TestModule.bindTestInterface(implementation)",
- " TestInterface is provided at",
+ " TestInterface is requested at",
" TestComponent.testInterface()"))
.inFile(component)
.onLineContaining("interface TestComponent");
@@ -408,18 +417,19 @@
Compilation compilation = daggerCompiler().compile(generic, testClass, usesTest, component);
assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
assertThat(compilation)
.hadErrorContaining(
message(
- "java.util.List cannot be provided without an @Provides-annotated method.",
- " java.util.List is injected at",
- " test.TestClass(list)",
- " test.TestClass is injected at",
- " test.Generic(t)",
- " test.Generic<test.TestClass> is injected at",
- " test.UsesTest(genericTestClass)",
- " test.UsesTest is provided at",
- " test.TestComponent.usesTest()"));
+ "List cannot be provided without an @Provides-annotated method.",
+ " List is injected at",
+ " TestClass(list)",
+ " TestClass is injected at",
+ " Generic(t)",
+ " Generic<TestClass> is injected at",
+ " UsesTest(genericTestClass)",
+ " UsesTest is requested at",
+ " TestComponent.usesTest()"));
}
@Test public void resolvedVariablesInDependencyTrace() {
@@ -462,18 +472,19 @@
Compilation compilation = daggerCompiler().compile(generic, testClass, usesTest, component);
assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
assertThat(compilation)
.hadErrorContaining(
message(
- "java.util.List cannot be provided without an @Provides-annotated method.",
- " java.util.List is injected at",
- " test.TestClass(list)",
- " test.TestClass is injected at",
- " test.Generic.t",
- " test.Generic<test.TestClass> is injected at",
- " test.UsesTest(genericTestClass)",
- " test.UsesTest is provided at",
- " test.TestComponent.usesTest()"));
+ "List cannot be provided without an @Provides-annotated method.",
+ " List is injected at",
+ " TestClass(list)",
+ " TestClass is injected at",
+ " Generic.t",
+ " Generic<TestClass> is injected at",
+ " UsesTest(genericTestClass)",
+ " UsesTest is requested at",
+ " TestComponent.usesTest()"));
}
@Test
@@ -524,9 +535,10 @@
Compilation compilation = daggerCompiler().compile(parent, parentModule, child, childModule);
assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
assertThat(compilation)
.hadErrorContainingMatch(
- "(?s)\\Qjava.lang.String cannot be provided\\E.*\\QChild.needsString()\\E")
+ "(?s)\\QString cannot be provided\\E.*\\QChild.needsString()\\E")
.inFile(parent)
.onLineContaining("interface Parent");
}
@@ -599,9 +611,10 @@
Compilation compilation =
daggerCompiler().compile(parent, parentModule, child, childModule, grandchild);
assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
assertThat(compilation)
.hadErrorContainingMatch(
- "(?s)\\Qjava.lang.Double cannot be provided\\E.*"
+ "(?s)\\QDouble cannot be provided\\E.*"
+ "\\QGrandchild.object() [Parent → Child → Grandchild]\\E$")
.inFile(parent)
.onLineContaining("interface Parent");
@@ -646,19 +659,20 @@
"interface NotBound {}");
Compilation compilation = daggerCompiler().compile(component, module, notBound);
assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
assertThat(compilation)
.hadErrorContaining(
message(
- "[Dagger/MissingBinding] "
- + "test.NotBound cannot be provided without an @Provides-annotated method.",
- " test.NotBound is injected at",
- " test.TestModule.object(notBound)",
- " java.lang.Object is provided at",
- " test.TestComponent.object()",
+ "\033[1;31m[Dagger/MissingBinding]\033[0m "
+ + "NotBound cannot be provided without an @Provides-annotated method.",
+ " NotBound is injected at",
+ " TestModule.object(notBound)",
+ " Object is requested at",
+ " TestComponent.object()",
"It is also requested at:",
- " test.TestModule.string(notBound, …)",
+ " TestModule.string(notBound, …)",
"The following other entry points also depend on it:",
- " test.TestComponent.string()"))
+ " TestComponent.string()"))
.inFile(component)
.onLineContaining("interface TestComponent");
assertThat(compilation).hadErrorCount(1);
@@ -705,24 +719,25 @@
Compilation compilation = daggerCompiler().compile(foo, component);
assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
assertThat(compilation)
.hadErrorContaining(
message(
- "[Dagger/MissingBinding] java.lang.String cannot be provided without an @Inject "
- + "constructor or an @Provides-annotated method.",
- " java.lang.String is provided at",
- " test.TestComponent.string()",
+ "\033[1;31m[Dagger/MissingBinding]\033[0m String cannot be provided without an "
+ + "@Inject constructor or an @Provides-annotated method.",
+ " String is requested at",
+ " TestComponent.string()",
"It is also requested at:",
- " test.Foo(one, …)",
- " test.Foo(…, two, …)",
- " test.Foo(…, three, …)",
- " test.Foo(…, four, …)",
- " test.Foo(…, five, …)",
- " test.Foo(…, six, …)",
- " test.Foo(…, seven, …)",
- " test.Foo(…, eight, …)",
- " test.Foo(…, nine, …)",
- " test.Foo(…, ten, …)",
+ " Foo(one, …)",
+ " Foo(…, two, …)",
+ " Foo(…, three, …)",
+ " Foo(…, four, …)",
+ " Foo(…, five, …)",
+ " Foo(…, six, …)",
+ " Foo(…, seven, …)",
+ " Foo(…, eight, …)",
+ " Foo(…, nine, …)",
+ " Foo(…, ten, …)",
" and 3 others"))
.inFile(component)
.onLineContaining("interface TestComponent");
@@ -755,26 +770,162 @@
Compilation compilation = daggerCompiler().compile(component);
assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
assertThat(compilation)
.hadErrorContaining(
message(
- "[Dagger/MissingBinding] java.lang.String cannot be provided without an @Inject "
- + "constructor or an @Provides-annotated method.",
- " java.lang.String is provided at",
- " test.TestComponent.string1()",
+ "\033[1;31m[Dagger/MissingBinding]\033[0m String cannot be provided without an "
+ + "@Inject constructor or an @Provides-annotated method.",
+ " String is requested at",
+ " TestComponent.string1()",
"The following other entry points also depend on it:",
- " test.TestComponent.string2()",
- " test.TestComponent.string3()",
- " test.TestComponent.string4()",
- " test.TestComponent.string5()",
- " test.TestComponent.string6()",
- " test.TestComponent.string7()",
- " test.TestComponent.string8()",
- " test.TestComponent.string9()",
- " test.TestComponent.string10()",
- " test.TestComponent.string11()",
+ " TestComponent.string2()",
+ " TestComponent.string3()",
+ " TestComponent.string4()",
+ " TestComponent.string5()",
+ " TestComponent.string6()",
+ " TestComponent.string7()",
+ " TestComponent.string8()",
+ " TestComponent.string9()",
+ " TestComponent.string10()",
+ " TestComponent.string11()",
" and 1 other"))
.inFile(component)
.onLineContaining("interface TestComponent");
}
+
+ @Test
+ public void missingBindingInAllComponentsAndEntryPoints() {
+ JavaFileObject parent =
+ JavaFileObjects.forSourceLines(
+ "Parent",
+ "import dagger.Component;",
+ "",
+ "@Component",
+ "interface Parent {",
+ " Foo foo();",
+ " Bar bar();",
+ " Child child();",
+ "}");
+ JavaFileObject child =
+ JavaFileObjects.forSourceLines(
+ "Child",
+ "import dagger.Subcomponent;",
+ "",
+ "@Subcomponent",
+ "interface Child {",
+ " Foo foo();",
+ " Baz baz();",
+ "}");
+ JavaFileObject foo =
+ JavaFileObjects.forSourceLines(
+ "Foo",
+ "import javax.inject.Inject;",
+ "",
+ "class Foo {",
+ " @Inject Foo(Bar bar) {}",
+ "}");
+ JavaFileObject bar =
+ JavaFileObjects.forSourceLines(
+ "Bar",
+ "import javax.inject.Inject;",
+ "",
+ "class Bar {",
+ " @Inject Bar(Baz baz) {}",
+ "}");
+ JavaFileObject baz = JavaFileObjects.forSourceLines("Baz", "class Baz {}");
+
+ Compilation compilation = daggerCompiler().compile(parent, child, foo, bar, baz);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining(
+ message(
+ "\033[1;31m[Dagger/MissingBinding]\033[0m Baz cannot be provided without an "
+ + "@Inject constructor or an @Provides-annotated method.",
+ " Baz is injected at",
+ " Bar(baz)",
+ " Bar is requested at",
+ " Parent.bar()",
+ "The following other entry points also depend on it:",
+ " Parent.foo()",
+ " Child.foo() [Parent → Child]",
+ " Child.baz() [Parent → Child]"))
+ .inFile(parent)
+ .onLineContaining("interface Parent");
+ }
+
+ // Regression test for b/147423208 where if the same subcomponent was used
+ // in two different parts of the hierarchy and only one side had a missing binding
+ // incorrect caching during binding graph conversion might cause validation to pass
+ // incorrectly.
+ @Test
+ public void sameSubcomponentUsedInDifferentHierarchies() {
+ JavaFileObject parent = JavaFileObjects.forSourceLines("test.Parent",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "",
+ "@Component",
+ "interface Parent {",
+ " Child1 getChild1();",
+ " Child2 getChild2();",
+ "}");
+ JavaFileObject child1 = JavaFileObjects.forSourceLines("test.Child1",
+ "package test;",
+ "",
+ "import dagger.Subcomponent;",
+ "",
+ "@Subcomponent(modules = LongModule.class)",
+ "interface Child1 {",
+ " RepeatedSub getSub();",
+ "}");
+ JavaFileObject child2 = JavaFileObjects.forSourceLines("test.Child2",
+ "package test;",
+ "",
+ "import dagger.Subcomponent;",
+ "",
+ "@Subcomponent",
+ "interface Child2 {",
+ " RepeatedSub getSub();",
+ "}");
+ JavaFileObject repeatedSub = JavaFileObjects.forSourceLines("test.RepeatedSub",
+ "package test;",
+ "",
+ "import dagger.Subcomponent;",
+ "",
+ "@Subcomponent",
+ "interface RepeatedSub {",
+ " Foo getFoo();",
+ "}");
+ JavaFileObject injectable = JavaFileObjects.forSourceLines("test.Foo",
+ "package test;",
+ "",
+ "import javax.inject.Inject;",
+ "",
+ "class Foo {",
+ " @Inject Foo(Long value) {}",
+ "}");
+ JavaFileObject module = JavaFileObjects.forSourceLines("test.LongModule",
+ "package test;",
+ "",
+ "import dagger.Module;",
+ "import dagger.Provides;",
+ "",
+ "@Module",
+ "interface LongModule {",
+ " @Provides static Long provideLong() {",
+ " return 0L;",
+ " }",
+ "}");
+ Compilation compilation = daggerCompiler().compile(
+ parent, child1, child2, repeatedSub, injectable, module);
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContaining("Long cannot be provided without an @Inject constructor")
+ .inFile(parent)
+ .onLineContaining("interface Parent");
+ }
+
}
diff --git a/javatests/dagger/internal/codegen/ModuleFactoryGeneratorTest.java b/javatests/dagger/internal/codegen/ModuleFactoryGeneratorTest.java
index 50c41ed..cbda1b8 100644
--- a/javatests/dagger/internal/codegen/ModuleFactoryGeneratorTest.java
+++ b/javatests/dagger/internal/codegen/ModuleFactoryGeneratorTest.java
@@ -24,9 +24,8 @@
import static dagger.internal.codegen.Compilers.daggerCompiler;
import static dagger.internal.codegen.DaggerModuleMethodSubject.Factory.assertThatMethodInUnannotatedClass;
import static dagger.internal.codegen.DaggerModuleMethodSubject.Factory.assertThatModuleMethod;
-import static dagger.internal.codegen.GeneratedLines.GENERATED_ANNOTATION;
+import static dagger.internal.codegen.GeneratedLines.GENERATED_CODE_ANNOTATIONS;
import static dagger.internal.codegen.GeneratedLines.IMPORT_GENERATED_ANNOTATION;
-import static dagger.internal.codegen.GeneratedLines.NPE_FROM_PROVIDES_METHOD;
import com.google.common.collect.ImmutableList;
import com.google.testing.compile.Compilation;
@@ -229,7 +228,7 @@
"import dagger.internal.Preconditions;",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class TestModule_ProvideStringFactory implements Factory<String> {",
" private final TestModule module;",
"",
@@ -246,8 +245,7 @@
" }",
"",
" public static String provideString(TestModule instance) {",
- " return Preconditions.checkNotNull(",
- " instance.provideString(), " + NPE_FROM_PROVIDES_METHOD + ");",
+ " return Preconditions.checkNotNullFromProvides(instance.provideString());",
" }",
"}");
assertAbout(javaSource()).that(moduleFile)
@@ -277,7 +275,7 @@
"import dagger.internal.Factory;",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class TestModule_ProvideStringFactory implements Factory<String> {",
" private final TestModule module;",
"",
@@ -323,7 +321,7 @@
"import dagger.internal.Factory;",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class TestModule_ProvideStringFactory implements Factory<String> {",
" private final TestModule module;",
"",
@@ -397,7 +395,7 @@
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class TestModule_ProvideObjectsFactory",
" implements Factory<List<Object>> {",
" private final TestModule module;",
@@ -432,8 +430,8 @@
"",
" public static List<Object> provideObjects(",
" TestModule instance, Object a, Object b, MembersInjector<X> xInjector) {",
- " return Preconditions.checkNotNull(",
- " instance.provideObjects(a, b, xInjector), " + NPE_FROM_PROVIDES_METHOD + ");",
+ " return Preconditions.checkNotNullFromProvides(",
+ " instance.provideObjects(a, b, xInjector));",
" }",
"}");
assertAbout(javaSources()).that(
@@ -467,7 +465,7 @@
"import dagger.internal.Preconditions;",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class TestModule_ProvideStringFactory implements Factory<String> {",
" private final TestModule module;",
"",
@@ -484,9 +482,7 @@
" }",
"",
" public static String provideString(TestModule instance) {",
- " return Preconditions.checkNotNull(instance.provideString(), "
- + NPE_FROM_PROVIDES_METHOD
- + ");",
+ " return Preconditions.checkNotNullFromProvides(instance.provideString());",
" }",
"}");
assertAbout(javaSource()).that(moduleFile)
@@ -522,7 +518,7 @@
"import java.util.List;",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class TestModule_ProvideWildcardListFactory implements "
+ "Factory<List<List<?>>> {",
" private final TestModule module;",
@@ -540,8 +536,8 @@
" }",
"",
" public static List<List<?>> provideWildcardList(TestModule instance) {",
- " return Preconditions.checkNotNull(",
- " instance.provideWildcardList(), " + NPE_FROM_PROVIDES_METHOD + ");",
+ " return Preconditions.checkNotNullFromProvides(",
+ " instance.provideWildcardList());",
" }",
"}");
assertAbout(javaSource()).that(moduleFile)
@@ -575,7 +571,7 @@
"import java.util.Set;",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class TestModule_ProvideStringsFactory implements Factory<Set<String>> {",
" private final TestModule module;",
"",
@@ -592,8 +588,8 @@
" }",
"",
" public static Set<String> provideStrings(TestModule instance) {",
- " return Preconditions.checkNotNull(",
- " instance.provideStrings(), " + NPE_FROM_PROVIDES_METHOD + ");",
+ " return Preconditions.checkNotNullFromProvides(",
+ " instance.provideStrings());",
" }",
"}");
assertAbout(javaSource()).that(moduleFile)
@@ -724,6 +720,7 @@
.onLine(6);
}
+
@Test
public void enclosedInPrivateModule() {
JavaFileObject moduleFile = JavaFileObjects.forSourceLines("test.Enclosing",
@@ -886,7 +883,7 @@
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class ParentModule_ProvideListBFactory<A extends CharSequence,",
" B, C extends Number & Comparable<C>> implements Factory<List<B>> {",
" private final ParentModule<A, B, C> module;",
@@ -911,8 +908,7 @@
"",
" public static <A extends CharSequence, B, C extends Number & Comparable<C>> List<B>",
" provideListB(ParentModule<A, B, C> instance, B b) {",
- " return Preconditions.checkNotNull(",
- " instance.provideListB(b), " + NPE_FROM_PROVIDES_METHOD + ");",
+ " return Preconditions.checkNotNullFromProvides(instance.provideListB(b));",
" }",
"}");
JavaFileObject bElementFactory =
@@ -925,7 +921,7 @@
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class ParentModule_ProvideBElementFactory<A extends CharSequence,",
" B, C extends Number & Comparable<C>> implements Factory<B> {",
" private final ParentModule<A, B, C> module;",
@@ -951,8 +947,7 @@
" public static <A extends CharSequence, B, C extends Number & Comparable<C>>",
" B provideBElement(",
" ParentModule<A, B, C> instance, B b) {",
- " return Preconditions.checkNotNull(",
- " instance.provideBElement(b), " + NPE_FROM_PROVIDES_METHOD + ");",
+ " return Preconditions.checkNotNullFromProvides(instance.provideBElement(b));",
" }",
"}");
JavaFileObject bEntryFactory =
@@ -965,7 +960,7 @@
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class ParentModule_ProvideBEntryFactory<A extends CharSequence,",
" B, C extends Number & Comparable<C>> implements Factory<B>> {",
" private final ParentModule<A, B, C> module;",
@@ -991,8 +986,7 @@
" public static <A extends CharSequence, B, C extends Number & Comparable<C>>",
" B provideBEntry(",
" ParentModule<A, B, C> instance, B b) {",
- " return Preconditions.checkNotNull(",
- " instance.provideBEntry(b), " + NPE_FROM_PROVIDES_METHOD + ");",
+ " return Preconditions.checkNotNullFromProvides(instance.provideBEntry(b));",
" }",
"}");
JavaFileObject numberFactory =
@@ -1004,7 +998,7 @@
"import dagger.internal.Preconditions;",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class ChildNumberModule_ProvideNumberFactory",
" implements Factory<Number> {",
" private final ChildNumberModule module;",
@@ -1024,8 +1018,7 @@
" }",
"",
" public static Number provideNumber(ChildNumberModule instance) {",
- " return Preconditions.checkNotNull(",
- " instance.provideNumber(), " + NPE_FROM_PROVIDES_METHOD + ");",
+ " return Preconditions.checkNotNullFromProvides(instance.provideNumber());",
" }",
"}");
JavaFileObject integerFactory =
@@ -1037,7 +1030,7 @@
"import dagger.internal.Preconditions;",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class ChildIntegerModule_ProvideIntegerFactory",
" implements Factory<Integer> {",
" private final ChildIntegerModule module;",
@@ -1057,8 +1050,8 @@
" }",
"",
" public static Integer provideInteger(ChildIntegerModule instance) {",
- " return Preconditions.checkNotNull(",
- " instance.provideInteger(), " + NPE_FROM_PROVIDES_METHOD + ");",
+ " return Preconditions.checkNotNullFromProvides(",
+ " instance.provideInteger());",
" }",
"}");
assertAbout(javaSources())
@@ -1111,24 +1104,26 @@
"import java.util.Map;",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class ParameterizedModule_ProvideMapStringNumberFactory",
" implements Factory<Map<String, Number>> {",
- " private static final ParameterizedModule_ProvideMapStringNumberFactory INSTANCE =",
- " new ParameterizedModule_ProvideMapStringNumberFactory();",
- "",
" @Override",
" public Map<String, Number> get() {",
" return provideMapStringNumber();",
" }",
"",
" public static ParameterizedModule_ProvideMapStringNumberFactory create() {",
- " return INSTANCE;",
+ " return InstanceHolder.INSTANCE;",
" }",
"",
" public static Map<String, Number> provideMapStringNumber() {",
- " return Preconditions.checkNotNull(ParameterizedModule.provideMapStringNumber(),",
- " " + NPE_FROM_PROVIDES_METHOD + ");",
+ " return Preconditions.checkNotNullFromProvides(",
+ " ParameterizedModule.provideMapStringNumber());",
+ " }",
+ "",
+ " private static final class InstanceHolder {",
+ " private static final ParameterizedModule_ProvideMapStringNumberFactory INSTANCE =",
+ " new ParameterizedModule_ProvideMapStringNumberFactory();",
" }",
"}");
@@ -1141,24 +1136,26 @@
"import dagger.internal.Preconditions;",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class ParameterizedModule_ProvideNonGenericTypeFactory",
" implements Factory<Object> {",
- " private static final ParameterizedModule_ProvideNonGenericTypeFactory INSTANCE = ",
- " new ParameterizedModule_ProvideNonGenericTypeFactory();",
- "",
" @Override",
" public Object get() {",
" return provideNonGenericType();",
" }",
"",
" public static ParameterizedModule_ProvideNonGenericTypeFactory create() {",
- " return INSTANCE;",
+ " return InstanceHolder.INSTANCE;",
" }",
"",
" public static Object provideNonGenericType() {",
- " return Preconditions.checkNotNull(ParameterizedModule.provideNonGenericType(),",
- " " + NPE_FROM_PROVIDES_METHOD + ");",
+ " return Preconditions.checkNotNullFromProvides(",
+ " ParameterizedModule.provideNonGenericType());",
+ " }",
+ "",
+ " private static final class InstanceHolder {",
+ " private static final ParameterizedModule_ProvideNonGenericTypeFactory INSTANCE =",
+ " new ParameterizedModule_ProvideNonGenericTypeFactory();",
" }",
"}");
@@ -1172,7 +1169,7 @@
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class ParameterizedModule_ProvideNonGenericTypeWithDepsFactory",
" implements Factory<String> {",
" private final Provider<Object> oProvider;",
@@ -1193,9 +1190,8 @@
" }",
"",
" public static String provideNonGenericTypeWithDeps(Object o) {",
- " return Preconditions.checkNotNull(",
- " ParameterizedModule.provideNonGenericTypeWithDeps(o),",
- " " + NPE_FROM_PROVIDES_METHOD + ");",
+ " return Preconditions.checkNotNullFromProvides(",
+ " ParameterizedModule.provideNonGenericTypeWithDeps(o));",
" }",
"}");
@@ -1410,7 +1406,7 @@
"test.TestModule_GetFactory",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class TestModule_GetFactory implements Factory<Integer> {",
" @Override",
" public Integer get() {",
@@ -1418,7 +1414,7 @@
" }",
"",
" public static TestModule_GetFactory create() {",
- " return INSTANCE;",
+ " return InstanceHolder.INSTANCE;",
" }",
"",
" public static int proxyGet() {",
@@ -1433,7 +1429,7 @@
"test.TestModule_CreateFactory",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"public final class TestModule_CreateFactory implements Factory<Boolean> {",
" @Override",
" public Boolean get() {",
@@ -1441,7 +1437,7 @@
" }",
"",
" public static TestModule_CreateFactory create() {",
- " return INSTANCE;",
+ " return InstanceHolder.INSTANCE;",
" }",
"",
" public static boolean proxyCreate() {",
diff --git a/javatests/dagger/internal/codegen/ModuleValidationTest.java b/javatests/dagger/internal/codegen/ModuleValidationTest.java
index 649649a..162c8c0 100644
--- a/javatests/dagger/internal/codegen/ModuleValidationTest.java
+++ b/javatests/dagger/internal/codegen/ModuleValidationTest.java
@@ -342,10 +342,18 @@
"",
"@Module(includes = BadModule.class)",
"abstract class IncludesBadModule {}");
- assertThat(daggerCompiler().compile(badModule, module))
+ Compilation compilation = daggerCompiler().compile(badModule, module);
+ assertThat(compilation).hadErrorCount(2);
+ assertThat(compilation)
.hadErrorContaining("test.BadModule has errors")
.inFile(module)
.onLine(5);
+ assertThat(compilation)
+ .hadErrorContaining(
+ "@Binds methods must have exactly one parameter, whose type is assignable to the "
+ + "return type")
+ .inFile(badModule)
+ .onLine(8);
}
@Test
diff --git a/javatests/dagger/internal/codegen/MultibindingTest.java b/javatests/dagger/internal/codegen/MultibindingTest.java
index 2bf9494..152adb0 100644
--- a/javatests/dagger/internal/codegen/MultibindingTest.java
+++ b/javatests/dagger/internal/codegen/MultibindingTest.java
@@ -131,7 +131,7 @@
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
- "java.util.Map<java.lang.String,java.lang.String> "
+ "Map<String,String> "
+ "cannot be provided without an @Provides-annotated method")
.inFile(component)
.onLineContaining("interface TestComponent");
@@ -183,7 +183,7 @@
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
- "java.util.Set<dagger.producers.Produced<java.lang.String>> "
+ "Set<Produced<String>> "
+ "cannot be provided without an @Provides- or @Produces-annotated method")
.inFile(component)
.onLineContaining("interface TestComponent");
diff --git a/javatests/dagger/internal/codegen/NullableBindingValidationTest.java b/javatests/dagger/internal/codegen/NullableBindingValidationTest.java
deleted file mode 100644
index 24d5636..0000000
--- a/javatests/dagger/internal/codegen/NullableBindingValidationTest.java
+++ /dev/null
@@ -1,419 +0,0 @@
-/*
- * Copyright (C) 2018 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.testing.compile.CompilationSubject.assertThat;
-import static com.google.testing.compile.Compiler.javac;
-import static dagger.internal.codegen.Compilers.daggerCompiler;
-import static dagger.internal.codegen.NullableBindingValidator.nullableToNonNullable;
-
-import com.google.testing.compile.Compilation;
-import com.google.testing.compile.JavaFileObjects;
-import javax.tools.JavaFileObject;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-@RunWith(JUnit4.class)
-public class NullableBindingValidationTest {
- private static final JavaFileObject NULLABLE =
- JavaFileObjects.forSourceLines(
- "test.Nullable", // force one-string-per-line format
- "package test;",
- "",
- "public @interface Nullable {}");
-
- @Test public void nullCheckForConstructorParameters() {
- JavaFileObject a = JavaFileObjects.forSourceLines("test.A",
- "package test;",
- "",
- "import javax.inject.Inject;",
- "",
- "final class A {",
- " @Inject A(String string) {}",
- "}");
- JavaFileObject module = JavaFileObjects.forSourceLines("test.TestModule",
- "package test;",
- "",
- "import dagger.Provides;",
- "import javax.inject.Inject;",
- "",
- "@dagger.Module",
- "final class TestModule {",
- " @Nullable @Provides String provideString() { return null; }",
- "}");
- JavaFileObject component = JavaFileObjects.forSourceLines("test.TestComponent",
- "package test;",
- "",
- "import dagger.Component;",
- "",
- "@Component(modules = TestModule.class)",
- "interface TestComponent {",
- " A a();",
- "}");
- Compilation compilation = daggerCompiler().compile(NULLABLE, a, module, component);
- assertThat(compilation).failed();
- assertThat(compilation)
- .hadErrorContaining(
- nullableToNonNullable(
- "java.lang.String",
- "@test.Nullable @Provides String test.TestModule.provideString()"));
-
- // but if we disable the validation, then it compiles fine.
- Compilation compilation2 =
- javac()
- .withOptions("-Adagger.nullableValidation=WARNING")
- .withProcessors(new ComponentProcessor())
- .compile(NULLABLE, a, module, component);
- assertThat(compilation2).succeeded();
- }
-
- @Test public void nullCheckForMembersInjectParam() {
- JavaFileObject a = JavaFileObjects.forSourceLines("test.A",
- "package test;",
- "",
- "import javax.inject.Inject;",
- "",
- "final class A {",
- " @Inject A() {}",
- " @Inject void register(String string) {}",
- "}");
- JavaFileObject module = JavaFileObjects.forSourceLines("test.TestModule",
- "package test;",
- "",
- "import dagger.Provides;",
- "import javax.inject.Inject;",
- "",
- "@dagger.Module",
- "final class TestModule {",
- " @Nullable @Provides String provideString() { return null; }",
- "}");
- JavaFileObject component = JavaFileObjects.forSourceLines("test.TestComponent",
- "package test;",
- "",
- "import dagger.Component;",
- "",
- "@Component(modules = TestModule.class)",
- "interface TestComponent {",
- " A a();",
- "}");
- Compilation compilation = daggerCompiler().compile(NULLABLE, a, module, component);
- assertThat(compilation).failed();
- assertThat(compilation)
- .hadErrorContaining(
- nullableToNonNullable(
- "java.lang.String",
- "@test.Nullable @Provides String test.TestModule.provideString()"));
-
- // but if we disable the validation, then it compiles fine.
- Compilation compilation2 =
- javac()
- .withOptions("-Adagger.nullableValidation=WARNING")
- .withProcessors(new ComponentProcessor())
- .compile(NULLABLE, a, module, component);
- assertThat(compilation2).succeeded();
- }
-
- @Test public void nullCheckForVariable() {
- JavaFileObject a = JavaFileObjects.forSourceLines("test.A",
- "package test;",
- "",
- "import javax.inject.Inject;",
- "",
- "final class A {",
- " @Inject String string;",
- " @Inject A() {}",
- "}");
- JavaFileObject module = JavaFileObjects.forSourceLines("test.TestModule",
- "package test;",
- "",
- "import dagger.Provides;",
- "import javax.inject.Inject;",
- "",
- "@dagger.Module",
- "final class TestModule {",
- " @Nullable @Provides String provideString() { return null; }",
- "}");
- JavaFileObject component = JavaFileObjects.forSourceLines("test.TestComponent",
- "package test;",
- "",
- "import dagger.Component;",
- "",
- "@Component(modules = TestModule.class)",
- "interface TestComponent {",
- " A a();",
- "}");
- Compilation compilation = daggerCompiler().compile(NULLABLE, a, module, component);
- assertThat(compilation).failed();
- assertThat(compilation)
- .hadErrorContaining(
- nullableToNonNullable(
- "java.lang.String",
- "@test.Nullable @Provides String test.TestModule.provideString()"));
-
- // but if we disable the validation, then it compiles fine.
- Compilation compilation2 =
- javac()
- .withOptions("-Adagger.nullableValidation=WARNING")
- .withProcessors(new ComponentProcessor())
- .compile(NULLABLE, a, module, component);
- assertThat(compilation2).succeeded();
- }
-
- @Test public void nullCheckForComponentReturn() {
- JavaFileObject module = JavaFileObjects.forSourceLines("test.TestModule",
- "package test;",
- "",
- "import dagger.Provides;",
- "import javax.inject.Inject;",
- "",
- "@dagger.Module",
- "final class TestModule {",
- " @Nullable @Provides String provideString() { return null; }",
- "}");
- JavaFileObject component = JavaFileObjects.forSourceLines("test.TestComponent",
- "package test;",
- "",
- "import dagger.Component;",
- "",
- "@Component(modules = TestModule.class)",
- "interface TestComponent {",
- " String string();",
- "}");
- Compilation compilation = daggerCompiler().compile(NULLABLE, module, component);
- assertThat(compilation).failed();
- assertThat(compilation)
- .hadErrorContaining(
- nullableToNonNullable(
- "java.lang.String",
- "@test.Nullable @Provides String test.TestModule.provideString()"));
-
- // but if we disable the validation, then it compiles fine.
- Compilation compilation2 =
- javac()
- .withOptions("-Adagger.nullableValidation=WARNING")
- .withProcessors(new ComponentProcessor())
- .compile(NULLABLE, module, component);
- assertThat(compilation2).succeeded();
- }
-
- @Test
- public void nullCheckForOptionalInstance() {
- JavaFileObject a =
- JavaFileObjects.forSourceLines(
- "test.A",
- "package test;",
- "",
- "import com.google.common.base.Optional;",
- "import javax.inject.Inject;",
- "",
- "final class A {",
- " @Inject A(Optional<String> optional) {}",
- "}");
- JavaFileObject module =
- JavaFileObjects.forSourceLines(
- "test.TestModule",
- "package test;",
- "",
- "import dagger.BindsOptionalOf;",
- "import dagger.Provides;",
- "import javax.inject.Inject;",
- "",
- "@dagger.Module",
- "abstract class TestModule {",
- " @Nullable @Provides static String provideString() { return null; }",
- " @BindsOptionalOf abstract String optionalString();",
- "}");
- JavaFileObject component =
- JavaFileObjects.forSourceLines(
- "test.TestComponent",
- "package test;",
- "",
- "import dagger.Component;",
- "",
- "@Component(modules = TestModule.class)",
- "interface TestComponent {",
- " A a();",
- "}");
- Compilation compilation = daggerCompiler().compile(NULLABLE, a, module, component);
- assertThat(compilation).failed();
- assertThat(compilation)
- .hadErrorContaining(
- nullableToNonNullable(
- "java.lang.String",
- "@test.Nullable @Provides String test.TestModule.provideString()"));
- }
-
- @Test
- public void nullCheckForOptionalProvider() {
- JavaFileObject a =
- JavaFileObjects.forSourceLines(
- "test.A",
- "package test;",
- "",
- "import com.google.common.base.Optional;",
- "import javax.inject.Inject;",
- "import javax.inject.Provider;",
- "",
- "final class A {",
- " @Inject A(Optional<Provider<String>> optional) {}",
- "}");
- JavaFileObject module =
- JavaFileObjects.forSourceLines(
- "test.TestModule",
- "package test;",
- "",
- "import dagger.BindsOptionalOf;",
- "import dagger.Provides;",
- "import javax.inject.Inject;",
- "",
- "@dagger.Module",
- "abstract class TestModule {",
- " @Nullable @Provides static String provideString() { return null; }",
- " @BindsOptionalOf abstract String optionalString();",
- "}");
- JavaFileObject component =
- JavaFileObjects.forSourceLines(
- "test.TestComponent",
- "package test;",
- "",
- "import dagger.Component;",
- "",
- "@Component(modules = TestModule.class)",
- "interface TestComponent {",
- " A a();",
- "}");
- Compilation compilation = daggerCompiler().compile(NULLABLE, a, module, component);
- assertThat(compilation).succeeded();
- }
-
- @Test
- public void nullCheckForOptionalLazy() {
- JavaFileObject a =
- JavaFileObjects.forSourceLines(
- "test.A",
- "package test;",
- "",
- "import com.google.common.base.Optional;",
- "import dagger.Lazy;",
- "import javax.inject.Inject;",
- "",
- "final class A {",
- " @Inject A(Optional<Lazy<String>> optional) {}",
- "}");
- JavaFileObject module =
- JavaFileObjects.forSourceLines(
- "test.TestModule",
- "package test;",
- "",
- "import dagger.BindsOptionalOf;",
- "import dagger.Provides;",
- "import javax.inject.Inject;",
- "",
- "@dagger.Module",
- "abstract class TestModule {",
- " @Nullable @Provides static String provideString() { return null; }",
- " @BindsOptionalOf abstract String optionalString();",
- "}");
- JavaFileObject component =
- JavaFileObjects.forSourceLines(
- "test.TestComponent",
- "package test;",
- "",
- "import dagger.Component;",
- "",
- "@Component(modules = TestModule.class)",
- "interface TestComponent {",
- " A a();",
- "}");
- Compilation compilation = daggerCompiler().compile(NULLABLE, a, module, component);
- assertThat(compilation).succeeded();
- }
-
- @Test
- public void nullCheckForOptionalProviderOfLazy() {
- JavaFileObject a =
- JavaFileObjects.forSourceLines(
- "test.A",
- "package test;",
- "",
- "import com.google.common.base.Optional;",
- "import dagger.Lazy;",
- "import javax.inject.Inject;",
- "import javax.inject.Provider;",
- "",
- "final class A {",
- " @Inject A(Optional<Provider<Lazy<String>>> optional) {}",
- "}");
- JavaFileObject module =
- JavaFileObjects.forSourceLines(
- "test.TestModule",
- "package test;",
- "",
- "import dagger.BindsOptionalOf;",
- "import dagger.Provides;",
- "import javax.inject.Inject;",
- "",
- "@dagger.Module",
- "abstract class TestModule {",
- " @Nullable @Provides static String provideString() { return null; }",
- " @BindsOptionalOf abstract String optionalString();",
- "}");
- JavaFileObject component =
- JavaFileObjects.forSourceLines(
- "test.TestComponent",
- "package test;",
- "",
- "import dagger.Component;",
- "",
- "@Component(modules = TestModule.class)",
- "interface TestComponent {",
- " A a();",
- "}");
- Compilation compilation = daggerCompiler().compile(NULLABLE, a, module, component);
- assertThat(compilation).succeeded();
- }
-
- @Test
- public void moduleValidation() {
- JavaFileObject module =
- JavaFileObjects.forSourceLines(
- "test.TestModule",
- "package test;",
- "",
- "import dagger.Binds;",
- "import dagger.Module;",
- "import dagger.Provides;",
- "",
- "@Module",
- "abstract class TestModule {",
- " @Provides @Nullable static String nullableString() { return null; }",
- " @Binds abstract Object object(String string);",
- "}");
-
- Compilation compilation =
- daggerCompiler()
- .withOptions("-Adagger.fullBindingGraphValidation=ERROR")
- .compile(module, NULLABLE);
- assertThat(compilation).failed();
- assertThat(compilation)
- .hadErrorContaining(
- nullableToNonNullable(
- "java.lang.String",
- "@Provides @test.Nullable String test.TestModule.nullableString()"));
- }
-}
diff --git a/javatests/dagger/internal/codegen/OptionalBindingRequestFulfillmentTest.java b/javatests/dagger/internal/codegen/OptionalBindingRequestFulfillmentTest.java
index b765166..60b6898 100644
--- a/javatests/dagger/internal/codegen/OptionalBindingRequestFulfillmentTest.java
+++ b/javatests/dagger/internal/codegen/OptionalBindingRequestFulfillmentTest.java
@@ -20,7 +20,7 @@
import static dagger.internal.codegen.CompilerMode.DEFAULT_MODE;
import static dagger.internal.codegen.CompilerMode.FAST_INIT_MODE;
import static dagger.internal.codegen.Compilers.compilerWithOptions;
-import static dagger.internal.codegen.GeneratedLines.GENERATED_ANNOTATION;
+import static dagger.internal.codegen.GeneratedLines.GENERATED_CODE_ANNOTATIONS;
import com.google.testing.compile.Compilation;
import com.google.testing.compile.JavaFileObjects;
@@ -110,13 +110,13 @@
"",
"import com.google.common.base.Optional;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {")
.addLinesIn(
FAST_INIT_MODE,
" private volatile Provider<Maybe> provideMaybeProvider;",
"",
- " private Provider<Maybe> getMaybeProvider() {",
+ " private Provider<Maybe> maybeProvider() {",
" Object local = provideMaybeProvider;",
" if (local == null) {",
" local = new SwitchingProvider<>(0);",
@@ -139,7 +139,7 @@
" Maybe_MaybeModule_ProvideMaybeFactory.create()));")
.addLinesIn(
FAST_INIT_MODE, //
- " getMaybeProvider()));")
+ " maybeProvider()));")
.addLines(
" }",
"",
@@ -250,7 +250,7 @@
"import com.google.common.base.Optional;",
"import dagger.producers.internal.CancellationListener;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent, CancellationListener {",
" @Override",
" public ListenableFuture<Optional<Maybe>> maybe() {",
@@ -261,7 +261,6 @@
" @Override",
" public ListenableFuture<Optional<DefinitelyNot>> definitelyNot() {",
" return Futures.immediateFuture(Optional.<DefinitelyNot>absent());",
-
" }",
"",
" @Override",
diff --git a/javatests/dagger/internal/codegen/OptionalBindingTest.java b/javatests/dagger/internal/codegen/OptionalBindingTest.java
index 1755101..4e158ef 100644
--- a/javatests/dagger/internal/codegen/OptionalBindingTest.java
+++ b/javatests/dagger/internal/codegen/OptionalBindingTest.java
@@ -89,7 +89,7 @@
Compilation compilation = daggerCompiler().compile(parent, parentModule, child, childModule);
assertThat(compilation).failed();
assertThat(compilation)
- .hadErrorContaining("Optional<java.lang.String> is bound multiple times")
+ .hadErrorContaining("Optional<String> is bound multiple times")
.inFile(parent)
.onLineContaining("interface Parent");
}
diff --git a/javatests/dagger/internal/codegen/PluginsVisitFullBindingGraphTest.java b/javatests/dagger/internal/codegen/PluginsVisitFullBindingGraphTest.java
new file mode 100644
index 0000000..b766463
--- /dev/null
+++ b/javatests/dagger/internal/codegen/PluginsVisitFullBindingGraphTest.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright (C) 2018 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.internal.codegen;
+
+import static com.google.testing.compile.CompilationSubject.assertThat;
+import static com.google.testing.compile.Compiler.javac;
+import static dagger.internal.codegen.TestUtils.endsWithMessage;
+import static javax.tools.Diagnostic.Kind.ERROR;
+
+import com.google.testing.compile.Compilation;
+import com.google.testing.compile.Compiler;
+import com.google.testing.compile.JavaFileObjects;
+import dagger.model.BindingGraph;
+import dagger.spi.BindingGraphPlugin;
+import dagger.spi.DiagnosticReporter;
+import java.util.regex.Pattern;
+import javax.tools.JavaFileObject;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for -Adagger.pluginsVisitFullBindingGraph. */
+@RunWith(JUnit4.class)
+public final class PluginsVisitFullBindingGraphTest {
+ private static final JavaFileObject MODULE_WITHOUT_ERRORS =
+ JavaFileObjects.forSourceLines(
+ "test.ModuleWithoutErrors",
+ "package test;",
+ "",
+ "import dagger.Binds;",
+ "import dagger.Module;",
+ "",
+ "@Module",
+ "interface ModuleWithoutErrors {",
+ " @Binds Object object(String string);",
+ "}");
+
+ private static final JavaFileObject MODULE_WITH_ERRORS =
+ JavaFileObjects.forSourceLines(
+ "test.ModuleWithErrors",
+ "package test;",
+ "",
+ "import dagger.Binds;",
+ "import dagger.Module;",
+ "",
+ "@Module",
+ "interface ModuleWithErrors {",
+ " @Binds Object object1(String string);",
+ " @Binds Object object2(Long l);",
+ "}");
+
+ private static final Pattern PLUGIN_ERROR_MESSAGE =
+ endsWithMessage(
+ "[dagger.internal.codegen.PluginsVisitFullBindingGraphTest.ErrorPlugin] Error!");
+
+ @Test
+ public void testNoFlags() {
+ Compilation compilation = daggerCompiler().compile(MODULE_WITH_ERRORS);
+ assertThat(compilation).succeeded();
+ }
+
+ @Test
+ public void testWithVisitPlugins() {
+ Compilation compilation =
+ daggerCompiler()
+ .withOptions("-Adagger.pluginsVisitFullBindingGraphs=Enabled")
+ .compile(MODULE_WITH_ERRORS);
+
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContainingMatch(PLUGIN_ERROR_MESSAGE)
+ .inFile(MODULE_WITH_ERRORS)
+ .onLineContaining("interface ModuleWithErrors");
+ }
+
+ @Test
+ public void testWithValidationNone() {
+ Compilation compilation =
+ daggerCompiler()
+ .withOptions("-Adagger.fullBindingGraphValidation=NONE")
+ .compile(MODULE_WITHOUT_ERRORS);
+ assertThat(compilation).succeeded();
+ }
+
+ @Test
+ public void testWithValidationError() {
+ // Test that pluginsVisitFullBindingGraph is enabled with fullBindingGraphValidation.
+ Compilation compilation =
+ daggerCompiler()
+ .withOptions("-Adagger.fullBindingGraphValidation=ERROR")
+ .compile(MODULE_WITHOUT_ERRORS);
+
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContainingMatch(PLUGIN_ERROR_MESSAGE)
+ .inFile(MODULE_WITHOUT_ERRORS)
+ .onLineContaining("interface ModuleWithoutErrors");
+ }
+
+ @Test
+ public void testWithValidationErrorAndVisitPlugins() {
+ Compilation compilation =
+ daggerCompiler()
+ .withOptions("-Adagger.fullBindingGraphValidation=ERROR")
+ .withOptions("-Adagger.pluginsVisitFullBindingGraphs=Enabled")
+ .compile(MODULE_WITHOUT_ERRORS);
+
+ assertThat(compilation).failed();
+ assertThat(compilation).hadErrorCount(1);
+ assertThat(compilation)
+ .hadErrorContainingMatch(PLUGIN_ERROR_MESSAGE)
+ .inFile(MODULE_WITHOUT_ERRORS)
+ .onLineContaining("interface ModuleWithoutErrors");
+ }
+
+ /** A test plugin that just reports each component with the given {@link Diagnostic.Kind}. */
+ private static final class ErrorPlugin implements BindingGraphPlugin {
+ @Override
+ public void visitGraph(BindingGraph bindingGraph, DiagnosticReporter diagnosticReporter) {
+ diagnosticReporter.reportComponent(ERROR, bindingGraph.rootComponentNode(), "Error!");
+ }
+ }
+
+ private static Compiler daggerCompiler() {
+ return javac().withProcessors(ComponentProcessor.forTesting(new ErrorPlugin()));
+ }
+}
diff --git a/javatests/dagger/internal/codegen/ProducerModuleFactoryGeneratorTest.java b/javatests/dagger/internal/codegen/ProducerModuleFactoryGeneratorTest.java
index 0b6ef8f..d41bc2d 100644
--- a/javatests/dagger/internal/codegen/ProducerModuleFactoryGeneratorTest.java
+++ b/javatests/dagger/internal/codegen/ProducerModuleFactoryGeneratorTest.java
@@ -214,6 +214,7 @@
.onLine(6);
}
+
@Test
public void enclosedInPrivateModule() {
JavaFileObject moduleFile = JavaFileObjects.forSourceLines("test.Enclosing",
@@ -369,8 +370,8 @@
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- "@SuppressWarnings(\"FutureReturnValueIgnored\")",
GENERATED_ANNOTATION,
+ "@SuppressWarnings({\"FutureReturnValueIgnored\", \"unchecked\", \"rawtypes\"})",
"public final class TestModule_ProduceStringFactory",
" extends AbstractProducesMethodProducer<Void, String> {",
" private final TestModule module;",
@@ -442,8 +443,8 @@
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- "@SuppressWarnings(\"FutureReturnValueIgnored\")",
GENERATED_ANNOTATION,
+ "@SuppressWarnings({\"FutureReturnValueIgnored\", \"unchecked\", \"rawtypes\"})",
"public final class TestModule_ProduceStringFactory",
" extends AbstractProducesMethodProducer<Void, String> {",
" private final TestModule module;",
diff --git a/javatests/dagger/internal/codegen/ProductionComponentProcessorTest.java b/javatests/dagger/internal/codegen/ProductionComponentProcessorTest.java
index 9a852c7..797fe2e 100644
--- a/javatests/dagger/internal/codegen/ProductionComponentProcessorTest.java
+++ b/javatests/dagger/internal/codegen/ProductionComponentProcessorTest.java
@@ -19,8 +19,9 @@
import static com.google.common.truth.Truth.assertAbout;
import static com.google.testing.compile.CompilationSubject.assertThat;
import static com.google.testing.compile.JavaSourceSubjectFactory.javaSource;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
import static dagger.internal.codegen.Compilers.daggerCompiler;
-import static dagger.internal.codegen.GeneratedLines.GENERATED_ANNOTATION;
+import static dagger.internal.codegen.GeneratedLines.GENERATED_CODE_ANNOTATIONS;
import static dagger.internal.codegen.GeneratedLines.IMPORT_GENERATED_ANNOTATION;
import com.google.testing.compile.Compilation;
@@ -69,7 +70,7 @@
" INSTANCE",
"}");
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(componentFile);
+ compilerWithOptions(compilerMode.javacopts()).compile(componentFile);
assertThat(compilation).failed();
assertThat(compilation).hadErrorContaining("interface");
}
@@ -83,7 +84,7 @@
"@ProductionComponent",
"@interface NotAComponent {}");
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(componentFile);
+ compilerWithOptions(compilerMode.javacopts()).compile(componentFile);
assertThat(compilation).failed();
assertThat(compilation).hadErrorContaining("interface");
}
@@ -97,7 +98,7 @@
"@ProductionComponent(modules = Object.class)",
"interface NotAComponent {}");
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(componentFile);
+ compilerWithOptions(compilerMode.javacopts()).compile(componentFile);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining("is not annotated with one of @Module, @ProducerModule");
@@ -161,17 +162,16 @@
.compile(moduleFile, producerModuleFile, componentFile);
assertThat(compilation).failed();
assertThat(compilation)
- .hadErrorContaining("java.lang.String may not depend on the production executor")
+ .hadErrorContaining("String may not depend on the production executor")
.inFile(componentFile)
.onLineContaining("interface SimpleComponent");
compilation =
- daggerCompiler()
- .withOptions("-Adagger.fullBindingGraphValidation=ERROR")
+ compilerWithOptions("-Adagger.fullBindingGraphValidation=ERROR")
.compile(producerModuleFile);
assertThat(compilation).failed();
assertThat(compilation)
- .hadErrorContaining("java.lang.String may not depend on the production executor")
+ .hadErrorContaining("String may not depend on the production executor")
.inFile(producerModuleFile)
.onLineContaining("class SimpleModule");
// TODO(dpb): Report at the binding if enclosed in the module.
@@ -248,7 +248,7 @@
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestClass_SimpleComponent",
" implements TestClass.SimpleComponent, CancellationListener {",
" private final TestClass.BModule bModule;",
@@ -278,7 +278,7 @@
" return new Builder().build();",
" }",
"",
- " private Executor getProductionImplementationExecutor() {",
+ " private Executor productionImplementationExecutor() {",
" Object local = productionImplementationExecutor;",
" if (local instanceof MemoizedSentinel) {",
" synchronized (local) {",
@@ -295,7 +295,7 @@
" return (Executor) local;",
" }",
"",
- " private Provider<Executor> getProductionImplementationExecutorProvider() {",
+ " private Provider<Executor> productionImplementationExecutorProvider() {",
" Object local = productionImplementationExecutorProvider;",
" if (local == null) {",
" local = new SwitchingProvider<>(0);",
@@ -304,7 +304,7 @@
" return (Provider<Executor>) local;",
" }",
"",
- " private ProductionComponentMonitor getProductionComponentMonitor() {",
+ " private ProductionComponentMonitor productionComponentMonitor() {",
" Object local = productionComponentMonitor;",
" if (local instanceof MemoizedSentinel) {",
" synchronized (local) {",
@@ -325,7 +325,7 @@
" }",
"",
" private Provider<ProductionComponentMonitor>",
- " getProductionComponentMonitorProvider() {",
+ " productionComponentMonitorProvider() {",
" Object local = monitorProvider;",
" if (local == null) {",
" local = new SwitchingProvider<>(1);",
@@ -334,11 +334,11 @@
" return (Provider<ProductionComponentMonitor>) local;",
" }",
"",
- " private TestClass.B getB() {",
+ " private TestClass.B b() {",
" return TestClass_BModule_BFactory.b(bModule, new TestClass.C());",
" }",
"",
- " private Provider<TestClass.B> getBProvider() {",
+ " private Provider<TestClass.B> bProvider() {",
" Object local = bProvider;",
" if (local == null) {",
" local = new SwitchingProvider<>(2);",
@@ -353,12 +353,12 @@
" final TestClass.BModule bModuleParam) {",
" this.simpleComponentProvider =",
" InstanceFactory.create((TestClass.SimpleComponent) this);",
- " this.bProducer = Producers.producerFromProvider(getBProvider());",
+ " this.bProducer = Producers.producerFromProvider(bProvider());",
" this.aProducer =",
" TestClass_AModule_AFactory.create(",
" aModuleParam,",
- " getProductionImplementationExecutorProvider(),",
- " getProductionComponentMonitorProvider(),",
+ " productionImplementationExecutorProvider(),",
+ " productionComponentMonitorProvider(),",
" bProducer);",
" this.aEntryPoint = Producers.entryPointViewOf(aProducer, this);",
" }",
@@ -413,11 +413,11 @@
" public T get() {",
" switch (id) {",
" case 0: return (T) DaggerTestClass_SimpleComponent.this",
- " .getProductionImplementationExecutor();",
+ " .productionImplementationExecutor();",
" case 1: return (T)",
- " DaggerTestClass_SimpleComponent.this.getProductionComponentMonitor();",
+ " DaggerTestClass_SimpleComponent.this.productionComponentMonitor();",
" case 2: return (T)",
- " DaggerTestClass_SimpleComponent.this.getB();",
+ " DaggerTestClass_SimpleComponent.this.b();",
" default: throw new AssertionError(id);",
" }",
" }",
@@ -443,7 +443,7 @@
IMPORT_GENERATED_ANNOTATION,
"import javax.inject.Provider;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestClass_SimpleComponent",
" implements TestClass.SimpleComponent, CancellationListener {",
" private Producer<TestClass.A> aEntryPoint;",
@@ -592,7 +592,7 @@
" }",
"}");
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(component);
+ compilerWithOptions(compilerMode.javacopts()).compile(component);
assertThat(compilation).succeeded();
assertThat(compilation)
.hadWarningContaining("@Nullable on @Produces methods does not do anything")
@@ -641,8 +641,7 @@
" ProductionScoped productionScoped();",
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(productionScoped, parent, child);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -651,7 +650,7 @@
new JavaFileBuilder(compilerMode, "test.DaggerRoot")
.addLines(
"package test;",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerParent implements Parent, CancellationListener {",
" private final class ChildImpl implements Child, CancellationListener {",
" @Override",
@@ -661,7 +660,7 @@
" return DaggerParent.this.productionScopedProvider.get();")
.addLinesIn(
CompilerMode.FAST_INIT_MODE, //
- " return DaggerParent.this.getProductionScoped();")
+ " return DaggerParent.this.productionScoped();")
.addLines(
" }", //
" }", //
diff --git a/javatests/dagger/internal/codegen/ProductionGraphValidationTest.java b/javatests/dagger/internal/codegen/ProductionGraphValidationTest.java
index 8453e03..3e416e9 100644
--- a/javatests/dagger/internal/codegen/ProductionGraphValidationTest.java
+++ b/javatests/dagger/internal/codegen/ProductionGraphValidationTest.java
@@ -17,6 +17,7 @@
package dagger.internal.codegen;
import static com.google.testing.compile.CompilationSubject.assertThat;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
import static dagger.internal.codegen.Compilers.daggerCompiler;
import com.google.testing.compile.Compilation;
@@ -77,7 +78,7 @@
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
- "test.Bar cannot be provided without an @Inject constructor or an @Provides- or "
+ "Bar cannot be provided without an @Inject constructor or an @Provides- or "
+ "@Produces-annotated method.")
.inFile(component)
.onLineContaining("interface MyComponent");
@@ -103,7 +104,7 @@
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
- "test.TestClass.A cannot be provided without an @Provides- or @Produces-annotated "
+ "TestClass.A cannot be provided without an @Provides- or @Produces-annotated "
+ "method.")
.inFile(component)
.onLineContaining("interface AComponent");
@@ -148,17 +149,16 @@
Compilation compilation = daggerCompiler().compile(EXECUTOR_MODULE, component);
assertThat(compilation).failed();
assertThat(compilation)
- .hadErrorContaining("test.TestClass.A is a provision, which cannot depend on a production.")
+ .hadErrorContaining("TestClass.A is a provision, which cannot depend on a production.")
.inFile(component)
.onLineContaining("interface AComponent");
compilation =
- daggerCompiler()
- .withOptions("-Adagger.fullBindingGraphValidation=ERROR")
+ compilerWithOptions("-Adagger.fullBindingGraphValidation=ERROR")
.compile(EXECUTOR_MODULE, component);
assertThat(compilation).failed();
assertThat(compilation)
- .hadErrorContaining("test.TestClass.A is a provision, which cannot depend on a production.")
+ .hadErrorContaining("TestClass.A is a provision, which cannot depend on a production.")
.inFile(component)
.onLineContaining("class AModule");
}
@@ -194,7 +194,7 @@
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
- "test.TestClass.A is a provision entry-point, which cannot depend on a production.")
+ "TestClass.A is a provision entry-point, which cannot depend on a production.")
.inFile(component)
.onLineContaining("interface AComponent");
}
@@ -252,7 +252,7 @@
Compilation compilation = daggerCompiler().compile(EXECUTOR_MODULE, component);
assertThat(compilation).failed();
assertThat(compilation)
- .hadErrorContaining("test.TestClass.A is a provision, which cannot depend on a production")
+ .hadErrorContaining("TestClass.A is a provision, which cannot depend on a production")
.inFile(component)
.onLineContaining("interface AComponent");
}
@@ -303,7 +303,7 @@
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
- "test.TestClass.A cannot be provided without an @Provides-annotated method.")
+ "TestClass.A cannot be provided without an @Provides-annotated method.")
.inFile(component)
.onLineContaining("interface StringComponent");
}
@@ -357,8 +357,8 @@
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
- "java.util.Set<dagger.producers.monitoring.ProductionComponentMonitor.Factory>"
- + " test.TestClass.MonitoringModule#monitorFactory is a provision,"
+ "Set<ProductionComponentMonitor.Factory>"
+ + " TestClass.MonitoringModule#monitorFactory is a provision,"
+ " which cannot depend on a production.")
.inFile(component)
.onLineContaining("interface StringComponent");
@@ -488,7 +488,7 @@
Compilation compilation = daggerCompiler().compile(badModule, badComponent);
assertThat(compilation).failed();
assertThat(compilation)
- .hadErrorContaining("test.BadModule has errors")
+ .hadErrorContaining("BadModule has errors")
.inFile(badComponent)
.onLine(7);
}
diff --git a/javatests/dagger/internal/codegen/ScopingValidationTest.java b/javatests/dagger/internal/codegen/ScopingValidationTest.java
index 9efcc2a..58ab2af 100644
--- a/javatests/dagger/internal/codegen/ScopingValidationTest.java
+++ b/javatests/dagger/internal/codegen/ScopingValidationTest.java
@@ -17,6 +17,7 @@
package dagger.internal.codegen;
import static com.google.testing.compile.CompilationSubject.assertThat;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
import static dagger.internal.codegen.Compilers.daggerCompiler;
import static dagger.internal.codegen.TestUtils.message;
@@ -76,9 +77,9 @@
assertThat(compilation)
.hadErrorContaining(
message(
- "test.MyComponent (unscoped) may not reference scoped bindings:",
- " @Singleton class test.ScopedType",
- " @Provides @Singleton String test.ScopedModule.string()"));
+ "MyComponent (unscoped) may not reference scoped bindings:",
+ " @Singleton class ScopedType",
+ " @Provides @Singleton String ScopedModule.string()"));
}
@Test // b/79859714
@@ -157,9 +158,9 @@
assertThat(compilation)
.hadErrorContaining(
message(
- "test.Parent scoped with @Singleton may not reference bindings with different "
+ "Parent scoped with @Singleton may not reference bindings with different "
+ "scopes:",
- " @Binds @test.ChildScope test.Foo test.ParentModule.bind(test.FooImpl)"));
+ " @Binds @ChildScope Foo ParentModule.bind(FooImpl)"));
}
@Test
@@ -232,28 +233,27 @@
assertThat(compilation)
.hadErrorContaining(
message(
- "test.MyComponent scoped with @Singleton "
+ "MyComponent scoped with @Singleton "
+ "may not reference bindings with different scopes:",
- " @test.PerTest class test.ScopedType",
- " @Provides @test.PerTest String test.ScopedModule.string()",
- " @Provides @test.Per(test.MyComponent.class) boolean "
- + "test.ScopedModule.bool()"))
+ " @PerTest class ScopedType",
+ " @Provides @PerTest String ScopedModule.string()",
+ " @Provides @Per(MyComponent.class) boolean "
+ + "ScopedModule.bool()"))
.inFile(componentFile)
.onLineContaining("interface MyComponent");
compilation =
- daggerCompiler()
- .withOptions("-Adagger.fullBindingGraphValidation=ERROR")
+ compilerWithOptions("-Adagger.fullBindingGraphValidation=ERROR")
.compile(componentFile, scopeFile, scopeWithAttribute, typeFile, moduleFile);
// The @Inject binding for ScopedType should not appear here, but the @Singleton binding should.
assertThat(compilation)
.hadErrorContaining(
message(
- "test.ScopedModule contains bindings with different scopes:",
- " @Provides @test.PerTest String test.ScopedModule.string()",
- " @Provides @Singleton float test.ScopedModule.floatingPoint()",
- " @Provides @test.Per(test.MyComponent.class) boolean "
- + "test.ScopedModule.bool()"))
+ "ScopedModule contains bindings with different scopes:",
+ " @Provides @PerTest String ScopedModule.string()",
+ " @Provides @Singleton float ScopedModule.floatingPoint()",
+ " @Provides @Per(MyComponent.class) boolean "
+ + "ScopedModule.bool()"))
.inFile(moduleFile)
.onLineContaining("class ScopedModule");
}
@@ -261,8 +261,7 @@
@Test
public void fullBindingGraphValidationDoesNotReportForOneScope() {
Compilation compilation =
- daggerCompiler()
- .withOptions(
+ compilerWithOptions(
"-Adagger.fullBindingGraphValidation=ERROR",
"-Adagger.moduleHasDifferentScopesValidation=ERROR")
.compile(
@@ -286,8 +285,7 @@
@Test
public void fullBindingGraphValidationDoesNotReportInjectBindings() {
Compilation compilation =
- daggerCompiler()
- .withOptions(
+ compilerWithOptions(
"-Adagger.fullBindingGraphValidation=ERROR",
"-Adagger.moduleHasDifferentScopesValidation=ERROR")
.compile(
@@ -384,9 +382,8 @@
}
@Test
- public void componentWithScopeMayDependOnOnlyOneScopedComponent() {
- // If a scoped component will have dependencies, they must only include, at most, a single
- // scoped component
+ public void componentWithScopeCanDependOnMultipleScopedComponents() {
+ // If a scoped component will have dependencies, they can include multiple scoped component
JavaFileObject type =
JavaFileObjects.forSourceLines(
"test.SimpleType",
@@ -461,14 +458,116 @@
daggerCompiler()
.compile(
type, simpleScope, simpleScoped, singletonScopedA, singletonScopedB, scopeless);
- assertThat(compilation).failed();
- assertThat(compilation)
- .hadErrorContaining(
- message(
- "@test.SimpleScope test.SimpleScopedComponent depends on more than one scoped "
- + "component:",
- " @Singleton test.SingletonComponentA",
- " @Singleton test.SingletonComponentB"));
+ assertThat(compilation).succeededWithoutWarnings();
+ }
+
+
+
+ // Tests the following component hierarchy:
+ //
+ // @ScopeA
+ // ComponentA
+ // [SimpleType getSimpleType()]
+ // / \
+ // / \
+ // @ScopeB @ScopeB
+ // ComponentB1 ComponentB2
+ // \ [SimpleType getSimpleType()]
+ // \ /
+ // \ /
+ // @ScopeC
+ // ComponentC
+ // [SimpleType getSimpleType()]
+ @Test
+ public void componentWithScopeCanDependOnMultipleScopedComponentsEvenDoingADiamond() {
+ JavaFileObject type =
+ JavaFileObjects.forSourceLines(
+ "test.SimpleType",
+ "package test;",
+ "",
+ "import javax.inject.Inject;",
+ "",
+ "class SimpleType {",
+ " @Inject SimpleType() {}",
+ "}");
+ JavaFileObject simpleScope =
+ JavaFileObjects.forSourceLines(
+ "test.SimpleScope",
+ "package test;",
+ "",
+ "import javax.inject.Scope;",
+ "",
+ "@Scope @interface SimpleScope {}");
+ JavaFileObject scopeA =
+ JavaFileObjects.forSourceLines(
+ "test.ScopeA",
+ "package test;",
+ "",
+ "import javax.inject.Scope;",
+ "",
+ "@Scope @interface ScopeA {}");
+ JavaFileObject scopeB =
+ JavaFileObjects.forSourceLines(
+ "test.ScopeB",
+ "package test;",
+ "",
+ "import javax.inject.Scope;",
+ "",
+ "@Scope @interface ScopeB {}");
+ JavaFileObject componentA =
+ JavaFileObjects.forSourceLines(
+ "test.ComponentA",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "",
+ "@ScopeA",
+ "@Component",
+ "interface ComponentA {",
+ " SimpleType type();",
+ "}");
+ JavaFileObject componentB1 =
+ JavaFileObjects.forSourceLines(
+ "test.ComponentB1",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "",
+ "@ScopeB",
+ "@Component(dependencies = ComponentA.class)",
+ "interface ComponentB1 {",
+ " SimpleType type();",
+ "}");
+ JavaFileObject componentB2 =
+ JavaFileObjects.forSourceLines(
+ "test.ComponentB2",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "",
+ "@ScopeB",
+ "@Component(dependencies = ComponentA.class)",
+ "interface ComponentB2 {",
+ "}");
+ JavaFileObject componentC =
+ JavaFileObjects.forSourceLines(
+ "test.ComponentC",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "",
+ "@SimpleScope",
+ "@Component(dependencies = {ComponentB1.class, ComponentB2.class})",
+ "interface ComponentC {",
+ " SimpleType type();",
+ "}");
+
+ Compilation compilation =
+ daggerCompiler()
+ .compile(
+ type, simpleScope, scopeA, scopeB,
+ componentA, componentB1, componentB2, componentC);
+ assertThat(compilation).succeededWithoutWarnings();
}
@Test
@@ -576,6 +675,98 @@
}
@Test
+ public void componentScopeWithMultipleScopedDependenciesMustNotCycle() {
+ JavaFileObject type =
+ JavaFileObjects.forSourceLines(
+ "test.SimpleType",
+ "package test;",
+ "",
+ "import javax.inject.Inject;",
+ "",
+ "class SimpleType {",
+ " @Inject SimpleType() {}",
+ "}");
+ JavaFileObject scopeA =
+ JavaFileObjects.forSourceLines(
+ "test.ScopeA",
+ "package test;",
+ "",
+ "import javax.inject.Scope;",
+ "",
+ "@Scope @interface ScopeA {}");
+ JavaFileObject scopeB =
+ JavaFileObjects.forSourceLines(
+ "test.ScopeB",
+ "package test;",
+ "",
+ "import javax.inject.Scope;",
+ "",
+ "@Scope @interface ScopeB {}");
+ JavaFileObject longLifetime =
+ JavaFileObjects.forSourceLines(
+ "test.ComponentLong",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "",
+ "@ScopeA",
+ "@Component",
+ "interface ComponentLong {",
+ " SimpleType type();",
+ "}");
+ JavaFileObject mediumLifetime1 =
+ JavaFileObjects.forSourceLines(
+ "test.ComponentMedium1",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "",
+ "@ScopeB",
+ "@Component(dependencies = ComponentLong.class)",
+ "interface ComponentMedium1 {",
+ " SimpleType type();",
+ "}");
+ JavaFileObject mediumLifetime2 =
+ JavaFileObjects.forSourceLines(
+ "test.ComponentMedium2",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "",
+ "@ScopeB",
+ "@Component",
+ "interface ComponentMedium2 {",
+ "}");
+ JavaFileObject shortLifetime =
+ JavaFileObjects.forSourceLines(
+ "test.ComponentShort",
+ "package test;",
+ "",
+ "import dagger.Component;",
+ "",
+ "@ScopeA",
+ "@Component(dependencies = {ComponentMedium1.class, ComponentMedium2.class})",
+ "interface ComponentShort {",
+ " SimpleType type();",
+ "}");
+
+ Compilation compilation =
+ daggerCompiler()
+ .compile(
+ type, scopeA, scopeB,
+ longLifetime, mediumLifetime1, mediumLifetime2, shortLifetime);
+ assertThat(compilation).failed();
+ assertThat(compilation)
+ .hadErrorContaining(
+ message(
+ "test.ComponentShort depends on scoped components in a non-hierarchical scope "
+ + "ordering:",
+ " @test.ScopeA test.ComponentLong",
+ " @test.ScopeB test.ComponentMedium1",
+ " @test.ScopeA test.ComponentShort"));
+ }
+
+ @Test
public void componentScopeAncestryMustNotCycle() {
// The dependency relationship of components is necessarily from shorter lifetimes to
// longer lifetimes. The scoping annotations must reflect this, and so one cannot declare
@@ -654,6 +845,14 @@
" @test.ScopeA test.ComponentLong",
" @test.ScopeB test.ComponentMedium",
" @test.ScopeA test.ComponentShort"));
+
+
+ // Test that compilation succeeds when transitive validation is disabled because the scope cycle
+ // cannot be detected.
+ compilation =
+ compilerWithOptions("-Adagger.validateTransitiveComponentDependencies=DISABLED")
+ .compile(type, scopeA, scopeB, longLifetime, mediumLifetime, shortLifetime);
+ assertThat(compilation).succeeded();
}
@Test
diff --git a/javatests/dagger/internal/codegen/SetBindingRequestFulfillmentTest.java b/javatests/dagger/internal/codegen/SetBindingRequestFulfillmentTest.java
index 3fb0e9c..e143370 100644
--- a/javatests/dagger/internal/codegen/SetBindingRequestFulfillmentTest.java
+++ b/javatests/dagger/internal/codegen/SetBindingRequestFulfillmentTest.java
@@ -18,8 +18,8 @@
import static com.google.testing.compile.CompilationSubject.assertThat;
import static dagger.internal.codegen.Compilers.CLASS_PATH_WITHOUT_GUAVA_OPTION;
-import static dagger.internal.codegen.Compilers.daggerCompiler;
-import static dagger.internal.codegen.GeneratedLines.GENERATED_ANNOTATION;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
+import static dagger.internal.codegen.GeneratedLines.GENERATED_CODE_ANNOTATIONS;
import static dagger.internal.codegen.GeneratedLines.IMPORT_GENERATED_ANNOTATION;
import com.google.testing.compile.Compilation;
@@ -96,7 +96,7 @@
"",
"import dagger.internal.SetBuilder;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" @Override",
" public Set<String> strings() {",
@@ -191,9 +191,9 @@
"import other.UsesInaccessible;",
"import other.UsesInaccessible_Factory;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
- " private Set getSetOfInaccessible2() {",
+ " private Set setOfInaccessible2() {",
" return SetBuilder.newSetBuilder(1)",
" .addAll(TestModule_EmptySetFactory.emptySet())",
" .build();",
@@ -203,7 +203,7 @@
" public UsesInaccessible usesInaccessible() {",
" return UsesInaccessible_Factory.newInstance(",
" (Set) Collections.emptySet(),",
- " (Set) getSetOfInaccessible2());",
+ " (Set) setOfInaccessible2());",
" }",
"}");
Compilation compilation =
@@ -266,7 +266,7 @@
"import java.util.Set;",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerParent implements Parent {",
" private DaggerParent() {}",
"",
@@ -316,7 +316,7 @@
}
private Compiler daggerCompilerWithoutGuava() {
- return daggerCompiler()
- .withOptions(compilerMode.javacopts().append(CLASS_PATH_WITHOUT_GUAVA_OPTION));
+ return compilerWithOptions(compilerMode.javacopts())
+ .withClasspath(CLASS_PATH_WITHOUT_GUAVA_OPTION);
}
}
diff --git a/javatests/dagger/internal/codegen/SetBindingRequestFulfillmentWithGuavaTest.java b/javatests/dagger/internal/codegen/SetBindingRequestFulfillmentWithGuavaTest.java
index 7a47393..2e3686f 100644
--- a/javatests/dagger/internal/codegen/SetBindingRequestFulfillmentWithGuavaTest.java
+++ b/javatests/dagger/internal/codegen/SetBindingRequestFulfillmentWithGuavaTest.java
@@ -17,8 +17,8 @@
package dagger.internal.codegen;
import static com.google.testing.compile.CompilationSubject.assertThat;
-import static dagger.internal.codegen.Compilers.daggerCompiler;
-import static dagger.internal.codegen.GeneratedLines.GENERATED_ANNOTATION;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
+import static dagger.internal.codegen.GeneratedLines.GENERATED_CODE_ANNOTATIONS;
import static dagger.internal.codegen.GeneratedLines.IMPORT_GENERATED_ANNOTATION;
import com.google.testing.compile.Compilation;
@@ -99,7 +99,7 @@
"",
"import com.google.common.collect.ImmutableSet;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" @Override",
" public Set<String> strings() {",
@@ -122,8 +122,7 @@
" }",
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(emptySetModuleFile, setModuleFile, componentFile);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -203,9 +202,9 @@
"import other.UsesInaccessible;",
"import other.UsesInaccessible_Factory;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
- " private Set getSetOfInaccessible2() {",
+ " private Set setOfInaccessible2() {",
" return ImmutableSet.copyOf(TestModule_EmptySetFactory.emptySet());",
" }",
"",
@@ -213,12 +212,11 @@
" public UsesInaccessible usesInaccessible() {",
" return UsesInaccessible_Factory.newInstance(",
" (Set) ImmutableSet.of(),",
- " (Set) getSetOfInaccessible2());",
+ " (Set) setOfInaccessible2());",
" }",
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(module, inaccessible, inaccessible2, usesInaccessible, componentFile);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -274,7 +272,7 @@
"",
"import com.google.common.collect.ImmutableSet;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerParent implements Parent {",
" private final class ChildImpl implements Child {",
" @Override",
@@ -285,7 +283,7 @@
" }",
"}");
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(parent, parentModule, child);
+ compilerWithOptions(compilerMode.javacopts()).compile(parent, parentModule, child);
assertThat(compilation).succeeded();
assertThat(compilation)
.generatedSourceFile("test.DaggerParent")
@@ -333,7 +331,7 @@
"import java.util.Set;",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent, "
+ "CancellationListener {",
" private DaggerTestComponent() {}",
@@ -346,14 +344,14 @@
" return new Builder().build();",
" }",
"",
- " private Set<String> getSetOfString() {",
+ " private Set<String> setOfString() {",
" return ImmutableSet.<String>copyOf(",
" EmptySetModule_EmptySetFactory.emptySet());",
" }",
"",
" @Override",
" public ListenableFuture<Set<String>> strings() {",
- " return Futures.immediateFuture(getSetOfString());",
+ " return Futures.immediateFuture(setOfString());",
" }",
"",
" @Override",
@@ -369,8 +367,7 @@
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(emptySetModuleFile, componentFile);
assertThat(compilation).succeeded();
assertThat(compilation)
diff --git a/javatests/dagger/internal/codegen/SourceFilesTest.java b/javatests/dagger/internal/codegen/SourceFilesTest.java
index c7fe998..248e2ef 100644
--- a/javatests/dagger/internal/codegen/SourceFilesTest.java
+++ b/javatests/dagger/internal/codegen/SourceFilesTest.java
@@ -17,9 +17,10 @@
package dagger.internal.codegen;
import static com.google.common.truth.Truth.assertThat;
-import static dagger.internal.codegen.SourceFiles.simpleVariableName;
+import static dagger.internal.codegen.binding.SourceFiles.simpleVariableName;
import com.google.testing.compile.CompilationRule;
+import dagger.internal.codegen.binding.SourceFiles;
import java.util.List;
import javax.lang.model.element.TypeElement;
import org.junit.Rule;
diff --git a/javatests/dagger/internal/codegen/SubcomponentBuilderValidationTest.java b/javatests/dagger/internal/codegen/SubcomponentBuilderValidationTest.java
index 5dab4c4..0fd7e08 100644
--- a/javatests/dagger/internal/codegen/SubcomponentBuilderValidationTest.java
+++ b/javatests/dagger/internal/codegen/SubcomponentBuilderValidationTest.java
@@ -18,11 +18,12 @@
import static com.google.testing.compile.CompilationSubject.assertThat;
import static dagger.internal.codegen.Compilers.daggerCompiler;
-import static dagger.internal.codegen.ComponentCreatorAnnotation.SUBCOMPONENT_BUILDER;
-import static dagger.internal.codegen.ErrorMessages.creatorMessagesFor;
+import static dagger.internal.codegen.binding.ComponentCreatorAnnotation.SUBCOMPONENT_BUILDER;
+import static dagger.internal.codegen.binding.ErrorMessages.creatorMessagesFor;
import com.google.testing.compile.Compilation;
import com.google.testing.compile.JavaFileObjects;
+import dagger.internal.codegen.binding.ErrorMessages;
import javax.tools.JavaFileObject;
import org.junit.Test;
import org.junit.runner.RunWith;
diff --git a/javatests/dagger/internal/codegen/SubcomponentCreatorRequestFulfillmentTest.java b/javatests/dagger/internal/codegen/SubcomponentCreatorRequestFulfillmentTest.java
index de0067f..ea0b4cc 100644
--- a/javatests/dagger/internal/codegen/SubcomponentCreatorRequestFulfillmentTest.java
+++ b/javatests/dagger/internal/codegen/SubcomponentCreatorRequestFulfillmentTest.java
@@ -21,14 +21,15 @@
import static com.google.testing.compile.CompilationSubject.assertThat;
import static dagger.internal.codegen.CompilerMode.DEFAULT_MODE;
import static dagger.internal.codegen.CompilerMode.FAST_INIT_MODE;
-import static dagger.internal.codegen.ComponentCreatorAnnotation.SUBCOMPONENT_BUILDER;
-import static dagger.internal.codegen.ComponentCreatorAnnotation.SUBCOMPONENT_FACTORY;
-import static dagger.internal.codegen.GeneratedLines.GENERATED_ANNOTATION;
+import static dagger.internal.codegen.GeneratedLines.GENERATED_CODE_ANNOTATIONS;
import static dagger.internal.codegen.GeneratedLines.IMPORT_GENERATED_ANNOTATION;
+import static dagger.internal.codegen.binding.ComponentCreatorAnnotation.SUBCOMPONENT_BUILDER;
+import static dagger.internal.codegen.binding.ComponentCreatorAnnotation.SUBCOMPONENT_FACTORY;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import com.google.testing.compile.Compilation;
+import dagger.internal.codegen.binding.ComponentCreatorAnnotation;
import java.util.Collection;
import java.util.List;
import java.util.Set;
@@ -100,7 +101,7 @@
"",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerC implements C {",
" @Override",
" public Sub.Builder sBuilder() {",
diff --git a/javatests/dagger/internal/codegen/SubcomponentCreatorValidationTest.java b/javatests/dagger/internal/codegen/SubcomponentCreatorValidationTest.java
index b5753d4..371253a 100644
--- a/javatests/dagger/internal/codegen/SubcomponentCreatorValidationTest.java
+++ b/javatests/dagger/internal/codegen/SubcomponentCreatorValidationTest.java
@@ -18,18 +18,19 @@
import static com.google.testing.compile.CompilationSubject.assertThat;
import static dagger.internal.codegen.CompilerMode.DEFAULT_MODE;
-import static dagger.internal.codegen.ComponentCreatorAnnotation.SUBCOMPONENT_BUILDER;
-import static dagger.internal.codegen.ComponentCreatorAnnotation.SUBCOMPONENT_FACTORY;
-import static dagger.internal.codegen.ComponentCreatorKind.BUILDER;
-import static dagger.internal.codegen.ComponentCreatorKind.FACTORY;
-import static dagger.internal.codegen.ComponentKind.SUBCOMPONENT;
-import static dagger.internal.codegen.ErrorMessages.ComponentCreatorMessages.moreThanOneRefToSubcomponent;
-import static dagger.internal.codegen.ErrorMessages.componentMessagesFor;
import static dagger.internal.codegen.TestUtils.message;
+import static dagger.internal.codegen.binding.ComponentCreatorAnnotation.SUBCOMPONENT_BUILDER;
+import static dagger.internal.codegen.binding.ComponentCreatorAnnotation.SUBCOMPONENT_FACTORY;
+import static dagger.internal.codegen.binding.ComponentCreatorKind.BUILDER;
+import static dagger.internal.codegen.binding.ComponentCreatorKind.FACTORY;
+import static dagger.internal.codegen.binding.ComponentKind.SUBCOMPONENT;
+import static dagger.internal.codegen.binding.ErrorMessages.ComponentCreatorMessages.moreThanOneRefToSubcomponent;
+import static dagger.internal.codegen.binding.ErrorMessages.componentMessagesFor;
import com.google.common.collect.ImmutableList;
import com.google.testing.compile.Compilation;
import com.google.testing.compile.JavaFileObjects;
+import dagger.internal.codegen.binding.ComponentCreatorAnnotation;
import java.util.Collection;
import javax.tools.JavaFileObject;
import org.junit.Test;
@@ -673,19 +674,18 @@
Compilation compilation = compile(componentFile, childComponentFile);
assertThat(compilation).failed();
String firstBinding = creatorKind.equals(FACTORY)
- ? "test.ChildComponent.Factory.create(s1, …)"
- : "@BindsInstance void test.ChildComponent.Builder.set1(String)";
+ ? "ChildComponent.Factory.create(s1, …)"
+ : "@BindsInstance void ChildComponent.Builder.set1(String)";
String secondBinding = creatorKind.equals(FACTORY)
- ? "test.ChildComponent.Factory.create(…, s2)"
- : "@BindsInstance void test.ChildComponent.Builder.set2(String)";
+ ? "ChildComponent.Factory.create(…, s2)"
+ : "@BindsInstance void ChildComponent.Builder.set2(String)";
assertThat(compilation)
.hadErrorContaining(
message(
- "java.lang.String is bound multiple times:",
+ "String is bound multiple times:",
" " + firstBinding,
" " + secondBinding,
- " java.lang.String is provided at",
- " test.ChildComponent.s() [test.ParentComponent → test.ChildComponent]"))
+ " in component: [ParentComponent → ChildComponent]"))
.inFile(componentFile)
.onLineContaining("interface ParentComponent {");
}
diff --git a/javatests/dagger/internal/codegen/SubcomponentValidationTest.java b/javatests/dagger/internal/codegen/SubcomponentValidationTest.java
index ad08160..19a27ff 100644
--- a/javatests/dagger/internal/codegen/SubcomponentValidationTest.java
+++ b/javatests/dagger/internal/codegen/SubcomponentValidationTest.java
@@ -19,8 +19,9 @@
import static com.google.testing.compile.CompilationSubject.assertThat;
import static dagger.internal.codegen.CompilerMode.DEFAULT_MODE;
import static dagger.internal.codegen.CompilerMode.FAST_INIT_MODE;
+import static dagger.internal.codegen.Compilers.compilerWithOptions;
import static dagger.internal.codegen.Compilers.daggerCompiler;
-import static dagger.internal.codegen.GeneratedLines.GENERATED_ANNOTATION;
+import static dagger.internal.codegen.GeneratedLines.GENERATED_CODE_ANNOTATIONS;
import static dagger.internal.codegen.GeneratedLines.IMPORT_GENERATED_ANNOTATION;
import com.google.testing.compile.Compilation;
@@ -83,8 +84,7 @@
" }",
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(componentFile, childComponentFile, moduleFile);
assertThat(compilation).failed();
assertThat(compilation)
@@ -152,16 +152,15 @@
" }",
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(component, childComponent, grandchildComponent, grandchildModule);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
- "[test.ChildComponent.newGrandchildComponent()] "
- + "test.GrandchildComponent requires modules which have no visible default "
+ "[ChildComponent.newGrandchildComponent()] "
+ + "GrandchildComponent requires modules which have no visible default "
+ "constructors. Add the following modules as parameters to this method: "
- + "test.GrandchildModule")
+ + "GrandchildModule")
.inFile(component)
.onLineContaining("interface TestComponent");
}
@@ -184,8 +183,7 @@
"@Subcomponent",
"interface ChildComponent {}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(componentFile, childComponentFile);
assertThat(compilation).failed();
assertThat(compilation)
@@ -221,8 +219,7 @@
"@Subcomponent(modules = TestModule.class)",
"interface ChildComponent {}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(moduleFile, componentFile, childComponentFile);
assertThat(compilation).failed();
assertThat(compilation)
@@ -259,8 +256,7 @@
"@Subcomponent",
"interface ChildComponent {}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(moduleFile, componentFile, childComponentFile);
assertThat(compilation).failed();
assertThat(compilation)
@@ -300,16 +296,15 @@
"",
"@Subcomponent(modules = TestModule.class)",
"interface ChildComponent {",
- " String getString();",
+ " String string();",
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(moduleFile, componentFile, childComponentFile);
assertThat(compilation).failed();
assertThat(compilation)
.hadErrorContaining(
- "java.lang.Integer cannot be provided without an @Inject constructor or an "
+ "Integer cannot be provided without an @Inject constructor or an "
+ "@Provides-annotated method")
.inFile(componentFile)
.onLineContaining("interface TestComponent");
@@ -324,7 +319,7 @@
"@Subcomponent",
"final class NotASubcomponent {}");
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(subcomponentFile);
+ compilerWithOptions(compilerMode.javacopts()).compile(subcomponentFile);
assertThat(compilation).failed();
assertThat(compilation).hadErrorContaining("interface");
}
@@ -348,7 +343,7 @@
"",
"@Subcomponent(modules = ChildModule.class)",
"interface ChildComponent {",
- " Object getObject();",
+ " Object object();",
"}");
JavaFileObject moduleFile = JavaFileObjects.forSourceLines("test.ChildModule",
"package test;",
@@ -362,8 +357,7 @@
" @Provides @Singleton Object provideObject() { return null; }",
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(componentFile, subcomponentFile, moduleFile);
assertThat(compilation).failed();
assertThat(compilation).hadErrorContaining("@Singleton");
@@ -383,8 +377,8 @@
"@Component",
"interface ParentComponent {",
" ChildComponent childComponent();",
- " Dep1 getDep1();",
- " Dep2 getDep2();",
+ " Dep1 dep1();",
+ " Dep2 dep2();",
"}");
JavaFileObject childComponentFile =
JavaFileObjects.forSourceLines(
@@ -395,7 +389,7 @@
"",
"@Subcomponent(modules = ChildModule.class)",
"interface ChildComponent {",
- " Object getObject();",
+ " Object object();",
"}");
JavaFileObject childModuleFile =
JavaFileObjects.forSourceLines(
@@ -463,7 +457,7 @@
.addLines(
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerParentComponent implements ParentComponent {")
.addLinesIn(
DEFAULT_MODE,
@@ -475,7 +469,7 @@
"")
.addLines(
" @Override", //
- " public Dep1 getDep1() {")
+ " public Dep1 dep1() {")
.addLinesIn(
FAST_INIT_MODE,
" Object local = dep1;",
@@ -496,7 +490,7 @@
" }", //
"",
" @Override",
- " public Dep2 getDep2() {")
+ " public Dep2 dep2() {")
.addLinesIn(
FAST_INIT_MODE,
" Object local = dep2;",
@@ -545,34 +539,34 @@
"")
.addLinesIn(
DEFAULT_MODE,
- " private NeedsDep1 getNeedsDep1() {",
+ " private NeedsDep1 needsDep1() {",
" return new NeedsDep1(DaggerParentComponent.this.dep1Provider.get());",
" }")
.addLinesIn(
FAST_INIT_MODE,
- " private NeedsDep1 getNeedsDep1() {",
- " return new NeedsDep1(DaggerParentComponent.this.getDep1());",
+ " private NeedsDep1 needsDep1() {",
+ " return new NeedsDep1(DaggerParentComponent.this.dep1());",
" }")
.addLines(
- " private A getA() {",
+ " private A a() {",
" return injectA(",
" A_Factory.newInstance(",
- " getNeedsDep1(),")
+ " needsDep1(),")
.addLinesIn(
DEFAULT_MODE,
" DaggerParentComponent.this.dep1Provider.get(),",
" DaggerParentComponent.this.dep2Provider.get()));")
.addLinesIn(
FAST_INIT_MODE,
- " DaggerParentComponent.this.getDep1(),",
- " DaggerParentComponent.this.getDep2()));")
+ " DaggerParentComponent.this.dep1(),",
+ " DaggerParentComponent.this.dep2()));")
.addLines(
" }",
"",
" @Override",
- " public Object getObject() {",
+ " public Object object() {",
" return ChildModule_ProvideObjectFactory.provideObject(",
- " childModule, getA());",
+ " childModule, a());",
" }",
"",
" @CanIgnoreReturnValue",
@@ -585,8 +579,7 @@
.build();
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(
parentComponentFile,
childComponentFile,
@@ -663,7 +656,7 @@
"",
"import test.subpackage.Sub;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerParentComponent implements ParentComponent {",
" @Override",
" public Foo.Sub newInstanceSubcomponent() {",
@@ -700,8 +693,7 @@
" private final class NoConflictImpl implements NoConflict {}",
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(parent, foo, bar, baz, noConflict);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -746,7 +738,7 @@
"test.DaggerParentComponent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerParentComponent implements ParentComponent {",
" @Override",
" public Sub newSubcomponent() {",
@@ -772,7 +764,7 @@
" }",
"}");
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(parent, sub, deepSub);
+ compilerWithOptions(compilerMode.javacopts()).compile(parent, sub, deepSub);
assertThat(compilation).succeeded();
assertThat(compilation)
.generatedSourceFile("test.DaggerParentComponent")
@@ -811,7 +803,7 @@
JavaFileObjects.forSourceLines(
"DaggerParentComponent",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerParentComponent implements ParentComponent {",
" @Override",
" public Sub newSubcomponent() {",
@@ -835,7 +827,7 @@
"");
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(parent, sub, deepSub);
+ compilerWithOptions(compilerMode.javacopts()).compile(parent, sub, deepSub);
assertThat(compilation).succeeded();
assertThat(compilation)
.generatedSourceFile("DaggerParentComponent")
@@ -888,7 +880,7 @@
"",
"import top1.a.b.c.d.E;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerParentComponent implements ParentComponent {",
" @Override",
" public E.F.Sub top1() {",
@@ -909,7 +901,7 @@
"}");
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(parent, top1, top2);
+ compilerWithOptions(compilerMode.javacopts()).compile(parent, top1, top2);
assertThat(compilation).succeeded();
assertThat(compilation)
.generatedSourceFile("test.DaggerParentComponent")
@@ -945,7 +937,7 @@
"test.DaggerC",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerC implements C {",
" @Override",
" public Foo.C newInstanceC() {",
@@ -956,8 +948,7 @@
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(parent, subcomponentWithSameSimpleNameAsParent);
assertThat(compilation).succeeded();
assertThat(compilation)
@@ -1007,7 +998,7 @@
"",
IMPORT_GENERATED_ANNOTATION,
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerC implements C {",
" @Override",
" public C.Foo.Sub.Builder fooBuilder() {",
@@ -1019,7 +1010,7 @@
" return new B_SubBuilder();",
" }",
"",
- // TODO(user): Reverse the order of subcomponent and builder so that subcomponent
+ // TODO(bcorso): Reverse the order of subcomponent and builder so that subcomponent
// comes first.
" private final class F_SubBuilder implements C.Foo.Sub.Builder {",
" @Override",
@@ -1044,7 +1035,7 @@
" }",
"}");
Compilation compilation =
- daggerCompiler().withOptions(compilerMode.javacopts()).compile(parent);
+ compilerWithOptions(compilerMode.javacopts()).compile(parent);
assertThat(compilation).succeeded();
assertThat(compilation)
.generatedSourceFile("test.DaggerC")
@@ -1097,17 +1088,16 @@
"}");
Compilation compilation =
- daggerCompiler()
- .withOptions(compilerMode.javacopts())
+ compilerWithOptions(compilerMode.javacopts())
.compile(module, component, subcomponent);
assertThat(compilation).failed();
- assertThat(compilation).hadErrorContaining("test.Sub.Builder is bound multiple times:");
+ assertThat(compilation).hadErrorContaining("Sub.Builder is bound multiple times:");
assertThat(compilation)
.hadErrorContaining(
- "@Provides test.Sub.Builder "
- + "test.TestModule.providesConflictsWithModuleSubcomponents()");
+ "@Provides Sub.Builder "
+ + "TestModule.providesConflictsWithModuleSubcomponents()");
assertThat(compilation)
- .hadErrorContaining("@Module(subcomponents = test.Sub.class) for test.TestModule");
+ .hadErrorContaining("@Module(subcomponents = Sub.class) for TestModule");
}
@Test
diff --git a/javatests/dagger/internal/codegen/SwitchingProviderTest.java b/javatests/dagger/internal/codegen/SwitchingProviderTest.java
index 2898f2e..593ad49 100644
--- a/javatests/dagger/internal/codegen/SwitchingProviderTest.java
+++ b/javatests/dagger/internal/codegen/SwitchingProviderTest.java
@@ -18,7 +18,7 @@
import static com.google.testing.compile.CompilationSubject.assertThat;
import static com.google.testing.compile.Compiler.javac;
-import static dagger.internal.codegen.GeneratedLines.GENERATED_ANNOTATION;
+import static dagger.internal.codegen.GeneratedLines.GENERATED_CODE_ANNOTATIONS;
import com.google.common.collect.ImmutableList;
import com.google.testing.compile.Compilation;
@@ -68,7 +68,7 @@
JavaFileObjects.forSourceLines(
"test.DaggerTestComponent",
"package test;",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" private final class SwitchingProvider<T> implements Provider<T> {",
" @SuppressWarnings(\"unchecked\")",
@@ -248,11 +248,11 @@
"test.DaggerTestComponent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" private volatile Provider<String> sProvider;",
"",
- " private Provider<String> getStringProvider() {",
+ " private Provider<String> stringProvider() {",
" Object local = sProvider;",
" if (local == null) {",
" local = new SwitchingProvider<>(0);",
@@ -263,12 +263,12 @@
"",
" @Override",
" public Provider<Object> objectProvider() {",
- " return (Provider) getStringProvider();",
+ " return (Provider) stringProvider();",
" }",
"",
" @Override",
" public Provider<CharSequence> charSequenceProvider() {",
- " return (Provider) getStringProvider();",
+ " return (Provider) stringProvider();",
" }",
"",
" private final class SwitchingProvider<T> implements Provider<T> {",
@@ -333,12 +333,12 @@
"test.DaggerTestComponent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" private volatile Object charSequence = new MemoizedSentinel();",
" private volatile Provider<CharSequence> cProvider;",
"",
- " private CharSequence getCharSequence() {",
+ " private CharSequence charSequence() {",
" Object local = charSequence;",
" if (local instanceof MemoizedSentinel) {",
" synchronized (local) {",
@@ -373,7 +373,7 @@
" public T get() {",
" switch (id) {",
" case 0:",
- " return (T) DaggerTestComponent.this.getCharSequence();",
+ " return (T) DaggerTestComponent.this.charSequence();",
" default:",
" throw new AssertionError(id);",
" }",
@@ -424,7 +424,7 @@
"test.DaggerTestComponent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" @Override",
" public Provider<Set<String>> setProvider() {",
@@ -469,7 +469,7 @@
"test.DaggerTestComponent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" private Provider<MembersInjector<Foo>> fooMembersInjectorProvider;",
"",
@@ -540,7 +540,7 @@
"test.DaggerTestComponent",
"package test;",
"",
- GENERATED_ANNOTATION,
+ GENERATED_CODE_ANNOTATIONS,
"final class DaggerTestComponent implements TestComponent {",
" @SuppressWarnings(\"rawtypes\")",
" private static final Provider ABSENT_JDK_OPTIONAL_PROVIDER =",
diff --git a/javatests/dagger/internal/codegen/TypeProtoConverterTest.java b/javatests/dagger/internal/codegen/TypeProtoConverterTest.java
deleted file mode 100644
index 8c8628c..0000000
--- a/javatests/dagger/internal/codegen/TypeProtoConverterTest.java
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * Copyright (C) 2019 The Dagger Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dagger.internal.codegen;
-
-import static com.google.common.truth.Truth.assertWithMessage;
-import static javax.lang.model.util.ElementFilter.fieldsIn;
-
-import com.google.testing.compile.CompilationRule;
-import dagger.internal.Factory;
-import dagger.internal.codegen.langmodel.DaggerElements;
-import dagger.internal.codegen.langmodel.DaggerTypes;
-import dagger.internal.codegen.serialization.TypeProto;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import javax.lang.model.type.TypeMirror;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/** Tests {@link TypeProtoConverter}. */
-@RunWith(JUnit4.class)
-public class TypeProtoConverterTest {
- @Rule public CompilationRule compilationRule = new CompilationRule();
-
- private DaggerElements elements;
- private DaggerTypes types;
- private TypeProtoConverter typeProtoConverter;
-
- @Before
- public void setUp() {
- this.elements = new DaggerElements(compilationRule.getElements(), compilationRule.getTypes());
- this.types = new DaggerTypes(compilationRule.getTypes(), elements);
- this.typeProtoConverter = new TypeProtoConverter(types, elements);
- }
-
- static class Outer<O> {
- @SuppressWarnings("ClassCanBeStatic") // We want to specifically test inner classes
- class Inner<I> {}
- }
-
- @SuppressWarnings({"rawtypes", "unused"})
- static class TypeMirrorConversionSubjects {
- private Map rawMap;
- private List<String> listOfString;
- private List<HashMap<String, Integer>> listOfHashMapOfStringToInteger;
- private Map<HashMap<String, Integer>, Set<Factory>> mapOfHashMapOfStringToIntegerToSetOfFactory;
- private Map<HashMap<String, Integer>, Set<Factory>>[][]
- arrayOfArrayOfMapOfHashMapOfStringToIntegerToSetOfFactory;
- private Map<HashMap<?, Integer>, ?> mapOfHashMapOfWildcardToIntegerToWildcard;
- private List<? extends String> listOfWildcardExtendsString;
- private List<? extends Set<? super String>> listOfWildcardExtendsSetOfWildcardSuperString;
- private Outer<Object>.Inner<Integer> outerOfObjectDotInnerOfInteger;
- private List<int[]> listOfIntArray;
- private List<? extends CharSequence[]> listOfWildcardExtendsCharSequenceArray;
- }
-
- @Test
- public void typeMirrorProtoConversions() {
- assertProtoConversionEquality(fieldType("rawMap"));
- assertProtoConversionEquality(fieldType("listOfString"));
- assertProtoConversionEquality(fieldType("listOfHashMapOfStringToInteger"));
- assertProtoConversionEquality(fieldType("mapOfHashMapOfStringToIntegerToSetOfFactory"));
- assertProtoConversionEquality(
- fieldType("arrayOfArrayOfMapOfHashMapOfStringToIntegerToSetOfFactory"));
- assertProtoConversionEquality(fieldType("mapOfHashMapOfWildcardToIntegerToWildcard"));
- assertProtoConversionEquality(fieldType("listOfWildcardExtendsString"));
- assertProtoConversionEquality(fieldType("listOfWildcardExtendsSetOfWildcardSuperString"));
- assertProtoConversionEquality(fieldType("outerOfObjectDotInnerOfInteger"));
- assertProtoConversionEquality(fieldType("listOfIntArray"));
- assertProtoConversionEquality(fieldType("listOfWildcardExtendsCharSequenceArray"));
- }
-
- private TypeMirror fieldType(String fieldName) {
- return fieldsIn(
- elements.getTypeElement(TypeMirrorConversionSubjects.class).getEnclosedElements())
- .stream()
- .filter(field -> field.getSimpleName().contentEquals(fieldName))
- .findFirst()
- .get()
- .asType();
- }
-
- /**
- * Converts {@link TypeMirror} to a {@link dagger.internal.codegen.serialization.TypeProto} and
- * back to a {@link TypeMirror}. Asserts that the round-trip conversion is lossless.
- */
- private void assertProtoConversionEquality(TypeMirror typeMirror) {
- TypeProto toProto = TypeProtoConverter.toProto(typeMirror);
- TypeMirror fromProto = typeProtoConverter.fromProto(toProto);
- assertWithMessage("expected: %s\nactual : %s", typeMirror, fromProto)
- .that(types.isSameType(typeMirror, fromProto))
- .isTrue();
- }
-}
diff --git a/javatests/dagger/internal/codegen/ValidationReportTest.java b/javatests/dagger/internal/codegen/ValidationReportTest.java
index b0f2f2f..d1c3a2e 100644
--- a/javatests/dagger/internal/codegen/ValidationReportTest.java
+++ b/javatests/dagger/internal/codegen/ValidationReportTest.java
@@ -23,7 +23,8 @@
import com.google.common.collect.ImmutableSet;
import com.google.testing.compile.Compilation;
import com.google.testing.compile.JavaFileObjects;
-import dagger.internal.codegen.ValidationReport.Builder;
+import dagger.internal.codegen.validation.ValidationReport;
+import dagger.internal.codegen.validation.ValidationReport.Builder;
import java.util.Set;
import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.RoundEnvironment;
diff --git a/javatests/dagger/internal/codegen/javapoet/BUILD b/javatests/dagger/internal/codegen/javapoet/BUILD
index 99c11bd..438d377 100644
--- a/javatests/dagger/internal/codegen/javapoet/BUILD
+++ b/javatests/dagger/internal/codegen/javapoet/BUILD
@@ -15,11 +15,11 @@
# Description:
# Tests for dagger.internal.codegen.javapoet
-package(default_visibility = ["//:src"])
-
load("//:build_defs.bzl", "DOCLINT_HTML_AND_SYNTAX")
load("//:test_defs.bzl", "GenJavaTests")
+package(default_visibility = ["//:src"])
+
GenJavaTests(
name = "javapoet_tests",
srcs = glob(["*.java"]),
@@ -28,10 +28,10 @@
deps = [
"//java/dagger/internal/codegen/javapoet",
"//java/dagger/internal/codegen/langmodel",
- "@google_bazel_common//third_party/java/auto:common",
"@google_bazel_common//third_party/java/compile_testing",
"@google_bazel_common//third_party/java/javapoet",
"@google_bazel_common//third_party/java/junit",
"@google_bazel_common//third_party/java/truth",
+ "@maven//:com_google_auto_auto_common",
],
)
diff --git a/javatests/dagger/lint/BUILD b/javatests/dagger/lint/BUILD
new file mode 100644
index 0000000..268340d
--- /dev/null
+++ b/javatests/dagger/lint/BUILD
@@ -0,0 +1,33 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+# Tests for the Dagger Lint Rules
+
+load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "kt_jvm_test")
+
+package(default_visibility = ["//:src"])
+
+kt_jvm_test(
+ name = "DaggerKotlinIssueDetectorTest",
+ srcs = ["DaggerKotlinIssueDetectorTest.kt"],
+ deps = [
+ "@google_bazel_common//third_party/java/junit",
+ "//java/dagger/lint:lint-artifact-lib",
+ "@maven//:com_android_tools_lint_lint_checks",
+ "@maven//:com_android_tools_lint_lint_tests",
+ "@maven//:com_android_tools_testutils",
+ "@maven//:org_jetbrains_kotlin_kotlin_stdlib",
+ ],
+)
diff --git a/javatests/dagger/lint/DaggerKotlinIssueDetectorTest.kt b/javatests/dagger/lint/DaggerKotlinIssueDetectorTest.kt
new file mode 100644
index 0000000..f112392
--- /dev/null
+++ b/javatests/dagger/lint/DaggerKotlinIssueDetectorTest.kt
@@ -0,0 +1,246 @@
+/*
+ * Copyright (C) 2020 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package dagger.lint
+
+import com.android.tools.lint.checks.infrastructure.LintDetectorTest
+import com.android.tools.lint.detector.api.Detector
+import com.android.tools.lint.detector.api.Issue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+@Suppress("UnstableApiUsage")
+@RunWith(JUnit4::class)
+class DaggerKotlinIssueDetectorTest : LintDetectorTest() {
+
+ private companion object {
+ private val javaxInjectStubs = kotlin(
+ """
+ package javax.inject
+
+ annotation class Inject
+ annotation class Qualifier
+ """
+ ).indented()
+
+ private val daggerStubs = kotlin(
+ """
+ package dagger
+
+ annotation class Provides
+ annotation class Module
+ """
+ ).indented()
+
+ // For some reason in Bazel the stdlib dependency on the classpath isn't visible to the
+ // LintTestTask, so we just include it ourselves here for now.
+ private val jvmStaticStubs = kotlin(
+ """
+ package kotlin.jvm
+
+ annotation class JvmStatic
+ """
+ ).indented()
+ }
+
+ override fun getDetector(): Detector = DaggerKotlinIssueDetector()
+
+ override fun getIssues(): List<Issue> = DaggerKotlinIssueDetector.issues
+
+ @Test
+ fun simpleSmokeTestForQualifiersAndProviders() {
+ lint()
+ .allowMissingSdk()
+ .files(
+ javaxInjectStubs,
+ daggerStubs,
+ jvmStaticStubs,
+ kotlin(
+ """
+ package foo
+ import javax.inject.Inject
+ import javax.inject.Qualifier
+ import kotlin.jvm.JvmStatic
+ import dagger.Provides
+ import dagger.Module
+
+ @Qualifier
+ annotation class MyQualifier
+
+ class InjectedTest {
+ // This should fail because of `:field`
+ @Inject
+ @field:MyQualifier
+ lateinit var prop: String
+
+ // This is fine!
+ @Inject
+ @MyQualifier
+ lateinit var prop2: String
+ }
+
+ @Module
+ object ObjectModule {
+ // This should fail because it uses `@JvmStatic`
+ @JvmStatic
+ @Provides
+ fun provideFoo(): String {
+
+ }
+
+ // This is fine!
+ @Provides
+ fun provideBar(): String {
+
+ }
+ }
+
+ @Module
+ class ClassModule {
+ companion object {
+ // This should fail because the companion object is part of ClassModule, so this is unnecessary.
+ @JvmStatic
+ @Provides
+ fun provideBaz(): String {
+
+ }
+ }
+ }
+
+ @Module
+ class ClassModuleQualified {
+ companion object {
+ // This should fail because the companion object is part of ClassModule, so this is unnecessary.
+ // This specifically tests a fully qualified annotation
+ @kotlin.jvm.JvmStatic
+ @Provides
+ fun provideBaz(): String {
+
+ }
+ }
+ }
+
+ @Module
+ class ClassModule2 {
+ // This should fail because the companion object is part of ClassModule
+ @Module
+ companion object {
+ @Provides
+ fun provideBaz(): String {
+
+ }
+ }
+ }
+
+ @Module
+ class ClassModule2Qualified {
+ // This should fail because the companion object is part of ClassModule
+ // This specifically tests a fully qualified annotation
+ @dagger.Module
+ companion object {
+ @Provides
+ fun provideBaz(): String {
+
+ }
+ }
+ }
+
+ // This is correct as of Dagger 2.26!
+ @Module
+ class ClassModule3 {
+ companion object {
+ @Provides
+ fun provideBaz(): String {
+
+ }
+ }
+ }
+
+ class ClassModule4 {
+ // This is should fail because this should be extracted to a standalone object.
+ @Module
+ companion object {
+ @Provides
+ fun provideBaz(): String {
+
+ }
+ }
+ }
+ """
+ ).indented()
+ )
+ .allowCompilationErrors(false)
+ .run()
+ .expect(
+ """
+ src/foo/MyQualifier.kt:14: Warning: Redundant 'field:' used for Dagger qualifier annotation. [FieldSiteTargetOnQualifierAnnotation]
+ @field:MyQualifier
+ ~~~~~~~~~~~~~~~~~~
+ src/foo/MyQualifier.kt:26: Warning: @JvmStatic used for @Provides function in an object class [JvmStaticProvidesInObjectDetector]
+ @JvmStatic
+ ~~~~~~~~~~
+ src/foo/MyQualifier.kt:43: Warning: @JvmStatic used for @Provides function in an object class [JvmStaticProvidesInObjectDetector]
+ @JvmStatic
+ ~~~~~~~~~~
+ src/foo/MyQualifier.kt:56: Warning: @JvmStatic used for @Provides function in an object class [JvmStaticProvidesInObjectDetector]
+ @kotlin.jvm.JvmStatic
+ ~~~~~~~~~~~~~~~~~~~~~
+ src/foo/MyQualifier.kt:66: Warning: Module companion objects should not be annotated with @Module. [ModuleCompanionObjects]
+ // This should fail because the companion object is part of ClassModule
+ ^
+ src/foo/MyQualifier.kt:78: Warning: Module companion objects should not be annotated with @Module. [ModuleCompanionObjects]
+ // This should fail because the companion object is part of ClassModule
+ ^
+ src/foo/MyQualifier.kt:101: Warning: Module companion objects should not be annotated with @Module. [ModuleCompanionObjects]
+ // This is should fail because this should be extracted to a standalone object.
+ ^
+ 0 errors, 7 warnings
+ """.trimIndent()
+ )
+ .expectFixDiffs(
+ """
+ Fix for src/foo/MyQualifier.kt line 14: Remove 'field:':
+ @@ -14 +14
+ - @field:MyQualifier
+ + @MyQualifier
+ Fix for src/foo/MyQualifier.kt line 26: Remove @JvmStatic:
+ @@ -26 +26
+ - @JvmStatic
+ +
+ Fix for src/foo/MyQualifier.kt line 43: Remove @JvmStatic:
+ @@ -43 +43
+ - @JvmStatic
+ +
+ Fix for src/foo/MyQualifier.kt line 56: Remove @JvmStatic:
+ @@ -56 +56
+ - @kotlin.jvm.JvmStatic
+ +
+ Fix for src/foo/MyQualifier.kt line 66: Remove @Module:
+ @@ -67 +67
+ - @Module
+ +
+ Fix for src/foo/MyQualifier.kt line 78: Remove @Module:
+ @@ -80 +80
+ - @dagger.Module
+ +
+ Fix for src/foo/MyQualifier.kt line 101: Remove @Module:
+ @@ -102 +102
+ - @Module
+ +
+ """.trimIndent()
+ )
+ }
+}
diff --git a/javatests/dagger/producers/BUILD b/javatests/dagger/producers/BUILD
index 1e1bd66..9404d85 100644
--- a/javatests/dagger/producers/BUILD
+++ b/javatests/dagger/producers/BUILD
@@ -15,8 +15,6 @@
# Description:
# Tests for dagger.producers
-package(default_visibility = ["//:src"])
-
load(
"//:build_defs.bzl",
"DOCLINT_HTML_AND_SYNTAX",
@@ -25,14 +23,17 @@
)
load("//:test_defs.bzl", "GenJavaTests")
+package(default_visibility = ["//:src"])
+
GenJavaTests(
name = "producers_tests",
srcs = glob(["**/*.java"]),
functional = 0,
javacopts = SOURCE_7_TARGET_7 + DOCLINT_REFERENCES + DOCLINT_HTML_AND_SYNTAX,
deps = [
+ "//java/dagger/internal/guava:collect",
+ "//java/dagger/internal/guava:concurrent",
"//java/dagger/producers",
- "@google_bazel_common//third_party/java/guava",
"@google_bazel_common//third_party/java/guava:testlib",
"@google_bazel_common//third_party/java/junit",
"@google_bazel_common//third_party/java/mockito",
diff --git a/javatests/dagger/producers/internal/AbstractProducesMethodProducerTest.java b/javatests/dagger/producers/internal/AbstractProducesMethodProducerTest.java
index b29cb3c..af13504 100644
--- a/javatests/dagger/producers/internal/AbstractProducesMethodProducerTest.java
+++ b/javatests/dagger/producers/internal/AbstractProducesMethodProducerTest.java
@@ -18,7 +18,8 @@
import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
@@ -55,7 +56,7 @@
public void initMocks() {
MockitoAnnotations.initMocks(this);
monitor = Mockito.mock(ProducerMonitor.class, Mockito.CALLS_REAL_METHODS);
- when(componentMonitor.producerMonitorFor(any(ProducerToken.class))).thenReturn(monitor);
+ when(componentMonitor.producerMonitorFor(nullable(ProducerToken.class))).thenReturn(monitor);
componentMonitorProvider =
new Provider<ProductionComponentMonitor>() {
@Override
diff --git a/javatests/dagger/producers/monitoring/TimingProductionComponentMonitorTest.java b/javatests/dagger/producers/monitoring/TimingProductionComponentMonitorTest.java
index 449b5a6..5c443a4 100644
--- a/javatests/dagger/producers/monitoring/TimingProductionComponentMonitorTest.java
+++ b/javatests/dagger/producers/monitoring/TimingProductionComponentMonitorTest.java
@@ -16,7 +16,7 @@
package dagger.producers.monitoring;
-import static org.mockito.Mockito.any;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
diff --git a/javatests/dagger/producers/monitoring/TimingRecordersTest.java b/javatests/dagger/producers/monitoring/TimingRecordersTest.java
index 4e5d74f..eefcb01 100644
--- a/javatests/dagger/producers/monitoring/TimingRecordersTest.java
+++ b/javatests/dagger/producers/monitoring/TimingRecordersTest.java
@@ -17,8 +17,9 @@
package dagger.producers.monitoring;
import static com.google.common.truth.Truth.assertThat;
-import static org.mockito.Mockito.any;
-import static org.mockito.Mockito.anyLong;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.verifyNoMoreInteractions;
@@ -96,7 +97,8 @@
public void singleRecorder_nullProducerTimingRecorder() {
when(mockProductionComponentTimingRecorderFactory.create(any(Object.class)))
.thenReturn(mockProductionComponentTimingRecorder);
- when(mockProductionComponentTimingRecorder.producerTimingRecorderFor(any(ProducerToken.class)))
+ when(mockProductionComponentTimingRecorder.producerTimingRecorderFor(
+ nullable(ProducerToken.class)))
.thenReturn(null);
ProductionComponentTimingRecorder.Factory factory =
TimingRecorders.delegatingProductionComponentTimingRecorderFactory(
@@ -110,7 +112,8 @@
public void singleRecorder_throwingProductionComponentTimingRecorder() {
when(mockProductionComponentTimingRecorderFactory.create(any(Object.class)))
.thenReturn(mockProductionComponentTimingRecorder);
- when(mockProductionComponentTimingRecorder.producerTimingRecorderFor(any(ProducerToken.class)))
+ when(mockProductionComponentTimingRecorder.producerTimingRecorderFor(
+ nullable(ProducerToken.class)))
.thenThrow(new RuntimeException("monkey"));
ProductionComponentTimingRecorder.Factory factory =
TimingRecorders.delegatingProductionComponentTimingRecorderFactory(
@@ -220,7 +223,8 @@
.thenReturn(mockProductionComponentTimingRecorderA);
when(mockProductionComponentTimingRecorderFactoryB.create(any(Object.class))).thenReturn(null);
when(mockProductionComponentTimingRecorderFactoryC.create(any(Object.class))).thenReturn(null);
- when(mockProductionComponentTimingRecorderA.producerTimingRecorderFor(any(ProducerToken.class)))
+ when(mockProductionComponentTimingRecorderA.producerTimingRecorderFor(
+ nullable(ProducerToken.class)))
.thenReturn(mockProducerTimingRecorderA);
ProductionComponentTimingRecorder.Factory factory =
TimingRecorders.delegatingProductionComponentTimingRecorderFactory(
@@ -249,7 +253,8 @@
.thenThrow(new RuntimeException("monkey"));
when(mockProductionComponentTimingRecorderFactoryC.create(any(Object.class)))
.thenThrow(new RuntimeException("monkey"));
- when(mockProductionComponentTimingRecorderA.producerTimingRecorderFor(any(ProducerToken.class)))
+ when(mockProductionComponentTimingRecorderA.producerTimingRecorderFor(
+ nullable(ProducerToken.class)))
.thenReturn(mockProducerTimingRecorderA);
ProductionComponentTimingRecorder.Factory factory =
TimingRecorders.delegatingProductionComponentTimingRecorderFactory(
@@ -340,7 +345,8 @@
private void setUpNormalSingleRecorder() {
when(mockProductionComponentTimingRecorderFactory.create(any(Object.class)))
.thenReturn(mockProductionComponentTimingRecorder);
- when(mockProductionComponentTimingRecorder.producerTimingRecorderFor(any(ProducerToken.class)))
+ when(mockProductionComponentTimingRecorder.producerTimingRecorderFor(
+ nullable(ProducerToken.class)))
.thenReturn(mockProducerTimingRecorder);
}
@@ -351,11 +357,14 @@
.thenReturn(mockProductionComponentTimingRecorderB);
when(mockProductionComponentTimingRecorderFactoryC.create(any(Object.class)))
.thenReturn(mockProductionComponentTimingRecorderC);
- when(mockProductionComponentTimingRecorderA.producerTimingRecorderFor(any(ProducerToken.class)))
+ when(mockProductionComponentTimingRecorderA.producerTimingRecorderFor(
+ nullable(ProducerToken.class)))
.thenReturn(mockProducerTimingRecorderA);
- when(mockProductionComponentTimingRecorderB.producerTimingRecorderFor(any(ProducerToken.class)))
+ when(mockProductionComponentTimingRecorderB.producerTimingRecorderFor(
+ nullable(ProducerToken.class)))
.thenReturn(mockProducerTimingRecorderB);
- when(mockProductionComponentTimingRecorderC.producerTimingRecorderFor(any(ProducerToken.class)))
+ when(mockProductionComponentTimingRecorderC.producerTimingRecorderFor(
+ nullable(ProducerToken.class)))
.thenReturn(mockProducerTimingRecorderC);
}
}
diff --git a/javatests/dagger/producers/monitoring/internal/MonitorsTest.java b/javatests/dagger/producers/monitoring/internal/MonitorsTest.java
index 47ccccb..ada4e33 100644
--- a/javatests/dagger/producers/monitoring/internal/MonitorsTest.java
+++ b/javatests/dagger/producers/monitoring/internal/MonitorsTest.java
@@ -17,7 +17,8 @@
package dagger.producers.monitoring.internal;
import static com.google.common.truth.Truth.assertThat;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.verifyNoMoreInteractions;
@@ -87,7 +88,7 @@
public void singleMonitor_nullProducerMonitor() {
when(mockProductionComponentMonitorFactory.create(any(Object.class)))
.thenReturn(mockProductionComponentMonitor);
- when(mockProductionComponentMonitor.producerMonitorFor(any(ProducerToken.class)))
+ when(mockProductionComponentMonitor.producerMonitorFor(nullable(ProducerToken.class)))
.thenReturn(null);
ProductionComponentMonitor.Factory factory =
Monitors.delegatingProductionComponentMonitorFactory(
@@ -103,7 +104,7 @@
.thenReturn(mockProductionComponentMonitor);
doThrow(new RuntimeException("monkey"))
.when(mockProductionComponentMonitor)
- .producerMonitorFor(any(ProducerToken.class));
+ .producerMonitorFor(nullable(ProducerToken.class));
ProductionComponentMonitor.Factory factory =
Monitors.delegatingProductionComponentMonitorFactory(
ImmutableList.of(mockProductionComponentMonitorFactory));
@@ -164,7 +165,9 @@
doThrow(new RuntimeException("monkey")).when(mockProducerMonitor).requested();
doThrow(new RuntimeException("monkey")).when(mockProducerMonitor).methodStarting();
doThrow(new RuntimeException("monkey")).when(mockProducerMonitor).methodFinished();
- doThrow(new RuntimeException("monkey")).when(mockProducerMonitor).succeeded(any(Object.class));
+ doThrow(new RuntimeException("monkey"))
+ .when(mockProducerMonitor)
+ .succeeded(nullable(Object.class));
ProductionComponentMonitor.Factory factory =
Monitors.delegatingProductionComponentMonitorFactory(
ImmutableList.of(mockProductionComponentMonitorFactory));
@@ -252,7 +255,7 @@
.thenReturn(mockProductionComponentMonitorA);
when(mockProductionComponentMonitorFactoryB.create(any(Object.class))).thenReturn(null);
when(mockProductionComponentMonitorFactoryC.create(any(Object.class))).thenReturn(null);
- when(mockProductionComponentMonitorA.producerMonitorFor(any(ProducerToken.class)))
+ when(mockProductionComponentMonitorA.producerMonitorFor(nullable(ProducerToken.class)))
.thenReturn(mockProducerMonitorA);
ProductionComponentMonitor.Factory factory =
Monitors.delegatingProductionComponentMonitorFactory(
@@ -288,7 +291,7 @@
doThrow(new RuntimeException("monkey"))
.when(mockProductionComponentMonitorFactoryC)
.create(any(Object.class));
- when(mockProductionComponentMonitorA.producerMonitorFor(any(ProducerToken.class)))
+ when(mockProductionComponentMonitorA.producerMonitorFor(nullable(ProducerToken.class)))
.thenReturn(mockProducerMonitorA);
ProductionComponentMonitor.Factory factory =
Monitors.delegatingProductionComponentMonitorFactory(
@@ -390,7 +393,9 @@
doThrow(new RuntimeException("monkey")).when(mockProducerMonitorA).requested();
doThrow(new RuntimeException("monkey")).when(mockProducerMonitorA).methodStarting();
doThrow(new RuntimeException("monkey")).when(mockProducerMonitorB).methodFinished();
- doThrow(new RuntimeException("monkey")).when(mockProducerMonitorC).succeeded(any(Object.class));
+ doThrow(new RuntimeException("monkey"))
+ .when(mockProducerMonitorC)
+ .succeeded(nullable(Object.class));
ProductionComponentMonitor.Factory factory =
Monitors.delegatingProductionComponentMonitorFactory(
ImmutableList.of(
@@ -465,7 +470,7 @@
private void setUpNormalSingleMonitor() {
when(mockProductionComponentMonitorFactory.create(any(Object.class)))
.thenReturn(mockProductionComponentMonitor);
- when(mockProductionComponentMonitor.producerMonitorFor(any(ProducerToken.class)))
+ when(mockProductionComponentMonitor.producerMonitorFor(nullable(ProducerToken.class)))
.thenReturn(mockProducerMonitor);
}
@@ -476,11 +481,11 @@
.thenReturn(mockProductionComponentMonitorB);
when(mockProductionComponentMonitorFactoryC.create(any(Object.class)))
.thenReturn(mockProductionComponentMonitorC);
- when(mockProductionComponentMonitorA.producerMonitorFor(any(ProducerToken.class)))
+ when(mockProductionComponentMonitorA.producerMonitorFor(nullable(ProducerToken.class)))
.thenReturn(mockProducerMonitorA);
- when(mockProductionComponentMonitorB.producerMonitorFor(any(ProducerToken.class)))
+ when(mockProductionComponentMonitorB.producerMonitorFor(nullable(ProducerToken.class)))
.thenReturn(mockProducerMonitorB);
- when(mockProductionComponentMonitorC.producerMonitorFor(any(ProducerToken.class)))
+ when(mockProductionComponentMonitorC.producerMonitorFor(nullable(ProducerToken.class)))
.thenReturn(mockProducerMonitorC);
}
}
diff --git a/javatests/dagger/spi/BUILD b/javatests/dagger/spi/BUILD
index a94461b..849037b 100644
--- a/javatests/dagger/spi/BUILD
+++ b/javatests/dagger/spi/BUILD
@@ -15,8 +15,6 @@
# Description:
# Tests for the Dagger SPI
-package(default_visibility = ["//:src"])
-
load("//:test_defs.bzl", "GenJavaTests")
load(
"//:build_defs.bzl",
@@ -24,6 +22,8 @@
"DOCLINT_REFERENCES",
)
+package(default_visibility = ["//:src"])
+
GenJavaTests(
name = "spi_tests",
srcs = glob(["*.java"]),
@@ -32,11 +32,11 @@
deps = [
"//java/dagger:core",
"//java/dagger/internal/codegen:processor",
- "//java/dagger/model",
+ "//java/dagger/internal/guava:base",
+ "//java/dagger/internal/guava:collect",
"//java/dagger/spi",
"@google_bazel_common//third_party/java/auto:service",
"@google_bazel_common//third_party/java/compile_testing",
- "@google_bazel_common//third_party/java/guava",
"@google_bazel_common//third_party/java/jsr330_inject",
"@google_bazel_common//third_party/java/junit",
"@google_bazel_common//third_party/java/truth",
diff --git a/javatests/dagger/spi/FailingPlugin.java b/javatests/dagger/spi/FailingPlugin.java
index 8fd0e35..2d13e21 100644
--- a/javatests/dagger/spi/FailingPlugin.java
+++ b/javatests/dagger/spi/FailingPlugin.java
@@ -83,7 +83,6 @@
.forEach(
edge -> diagnosticReporter.reportDependency(ERROR, edge, "Bad Dependency: %s", edge));
}
-
}
@Override
diff --git a/javatests/dagger/spi/SpiPluginTest.java b/javatests/dagger/spi/SpiPluginTest.java
index 613a915..1df8cd1 100644
--- a/javatests/dagger/spi/SpiPluginTest.java
+++ b/javatests/dagger/spi/SpiPluginTest.java
@@ -53,7 +53,9 @@
javac()
.withProcessors(new ComponentProcessor())
.withOptions(
- "-Aerror_on_binding=java.lang.Integer", "-Adagger.fullBindingGraphValidation=ERROR")
+ "-Aerror_on_binding=java.lang.Integer",
+ "-Adagger.fullBindingGraphValidation=ERROR",
+ "-Adagger.pluginsVisitFullBindingGraphs=ENABLED")
.compile(module);
assertThat(compilation).failed();
assertThat(compilation)
@@ -97,7 +99,7 @@
.hadErrorContaining(
message(
"[FailingPlugin] Bad Binding: @Inject test.Foo()",
- " test.Foo is provided at",
+ " test.Foo is requested at",
" test.TestComponent.foo()"))
.inFile(component)
.onLineContaining("interface TestComponent");
@@ -185,7 +187,7 @@
.hadErrorContaining(
message(
"[FailingPlugin] Bad Dependency: test.TestComponent.entryPoint() (entry point)",
- " test.EntryPoint is provided at",
+ " test.EntryPoint is requested at",
" test.TestComponent.entryPoint()"))
.inFile(component)
.onLineContaining("interface TestComponent");
@@ -195,7 +197,7 @@
"[FailingPlugin] Bad Dependency: test.EntryPoint(…, dup1, …)",
" test.Duplicated is injected at",
" test.EntryPoint(…, dup1, …)",
- " test.EntryPoint is provided at",
+ " test.EntryPoint is requested at",
" test.TestComponent.entryPoint()"))
.inFile(component)
.onLineContaining("interface TestComponent");
@@ -205,7 +207,7 @@
"[FailingPlugin] Bad Dependency: test.EntryPoint(…, dup2)",
" test.Duplicated is injected at",
" test.EntryPoint(…, dup2)",
- " test.EntryPoint is provided at",
+ " test.EntryPoint is requested at",
" test.TestComponent.entryPoint()"))
.inFile(component)
.onLineContaining("interface TestComponent");
@@ -220,7 +222,7 @@
" test.Foo(inFooDep)",
" test.Foo is injected at",
" test.EntryPoint(foo, …)",
- " test.EntryPoint is provided at",
+ " test.EntryPoint is requested at",
" test.TestComponent.entryPoint()",
"The following other entry points also depend on it:",
" test.TestComponent.chain()"))
@@ -280,7 +282,7 @@
message(
"[FailingPlugin] Bad Dependency: "
+ "test.TestSubcomponent.childEntryPoint() (entry point)",
- " test.EntryPoint is provided at",
+ " test.EntryPoint is requested at",
" test.TestSubcomponent.childEntryPoint()"
+ " [test.TestComponent → test.TestSubcomponent]"))
.inFile(component)
@@ -295,7 +297,7 @@
"[FailingPlugin] Bad Dependency: test.EntryPoint(foo)",
" test.Foo is injected at",
" test.EntryPoint(foo)",
- " test.EntryPoint is provided at",
+ " test.EntryPoint is requested at",
" test.TestSubcomponent.childEntryPoint() "
+ "[test.TestComponent → test.TestSubcomponent]"))
.inFile(component)
@@ -472,7 +474,7 @@
" test.Chain2(chain)",
" test.Chain2 is injected at",
" test.Chain1(chain)",
- " test.Chain1 is provided at",
+ " test.Chain1 is requested at",
" test.TestComponent.chain()",
"The following other entry points also depend on it:",
" test.TestSubcomponent.exposedOnSubcomponent() "
diff --git a/lib/NOTICE b/lib/NOTICE
deleted file mode 100644
index d645695..0000000
--- a/lib/NOTICE
+++ /dev/null
@@ -1,202 +0,0 @@
-
- Apache License
- Version 2.0, January 2004
- http://www.apache.org/licenses/
-
- TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
- 1. Definitions.
-
- "License" shall mean the terms and conditions for use, reproduction,
- and distribution as defined by Sections 1 through 9 of this document.
-
- "Licensor" shall mean the copyright owner or entity authorized by
- the copyright owner that is granting the License.
-
- "Legal Entity" shall mean the union of the acting entity and all
- other entities that control, are controlled by, or are under common
- control with that entity. For the purposes of this definition,
- "control" means (i) the power, direct or indirect, to cause the
- direction or management of such entity, whether by contract or
- otherwise, or (ii) ownership of fifty percent (50%) or more of the
- outstanding shares, or (iii) beneficial ownership of such entity.
-
- "You" (or "Your") shall mean an individual or Legal Entity
- exercising permissions granted by this License.
-
- "Source" form shall mean the preferred form for making modifications,
- including but not limited to software source code, documentation
- source, and configuration files.
-
- "Object" form shall mean any form resulting from mechanical
- transformation or translation of a Source form, including but
- not limited to compiled object code, generated documentation,
- and conversions to other media types.
-
- "Work" shall mean the work of authorship, whether in Source or
- Object form, made available under the License, as indicated by a
- copyright notice that is included in or attached to the work
- (an example is provided in the Appendix below).
-
- "Derivative Works" shall mean any work, whether in Source or Object
- form, that is based on (or derived from) the Work and for which the
- editorial revisions, annotations, elaborations, or other modifications
- represent, as a whole, an original work of authorship. For the purposes
- of this License, Derivative Works shall not include works that remain
- separable from, or merely link (or bind by name) to the interfaces of,
- the Work and Derivative Works thereof.
-
- "Contribution" shall mean any work of authorship, including
- the original version of the Work and any modifications or additions
- to that Work or Derivative Works thereof, that is intentionally
- submitted to Licensor for inclusion in the Work by the copyright owner
- or by an individual or Legal Entity authorized to submit on behalf of
- the copyright owner. For the purposes of this definition, "submitted"
- means any form of electronic, verbal, or written communication sent
- to the Licensor or its representatives, including but not limited to
- communication on electronic mailing lists, source code control systems,
- and issue tracking systems that are managed by, or on behalf of, the
- Licensor for the purpose of discussing and improving the Work, but
- excluding communication that is conspicuously marked or otherwise
- designated in writing by the copyright owner as "Not a Contribution."
-
- "Contributor" shall mean Licensor and any individual or Legal Entity
- on behalf of whom a Contribution has been received by Licensor and
- subsequently incorporated within the Work.
-
- 2. Grant of Copyright License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- copyright license to reproduce, prepare Derivative Works of,
- publicly display, publicly perform, sublicense, and distribute the
- Work and such Derivative Works in Source or Object form.
-
- 3. Grant of Patent License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- (except as stated in this section) patent license to make, have made,
- use, offer to sell, sell, import, and otherwise transfer the Work,
- where such license applies only to those patent claims licensable
- by such Contributor that are necessarily infringed by their
- Contribution(s) alone or by combination of their Contribution(s)
- with the Work to which such Contribution(s) was submitted. If You
- institute patent litigation against any entity (including a
- cross-claim or counterclaim in a lawsuit) alleging that the Work
- or a Contribution incorporated within the Work constitutes direct
- or contributory patent infringement, then any patent licenses
- granted to You under this License for that Work shall terminate
- as of the date such litigation is filed.
-
- 4. Redistribution. You may reproduce and distribute copies of the
- Work or Derivative Works thereof in any medium, with or without
- modifications, and in Source or Object form, provided that You
- meet the following conditions:
-
- (a) You must give any other recipients of the Work or
- Derivative Works a copy of this License; and
-
- (b) You must cause any modified files to carry prominent notices
- stating that You changed the files; and
-
- (c) You must retain, in the Source form of any Derivative Works
- that You distribute, all copyright, patent, trademark, and
- attribution notices from the Source form of the Work,
- excluding those notices that do not pertain to any part of
- the Derivative Works; and
-
- (d) If the Work includes a "NOTICE" text file as part of its
- distribution, then any Derivative Works that You distribute must
- include a readable copy of the attribution notices contained
- within such NOTICE file, excluding those notices that do not
- pertain to any part of the Derivative Works, in at least one
- of the following places: within a NOTICE text file distributed
- as part of the Derivative Works; within the Source form or
- documentation, if provided along with the Derivative Works; or,
- within a display generated by the Derivative Works, if and
- wherever such third-party notices normally appear. The contents
- of the NOTICE file are for informational purposes only and
- do not modify the License. You may add Your own attribution
- notices within Derivative Works that You distribute, alongside
- or as an addendum to the NOTICE text from the Work, provided
- that such additional attribution notices cannot be construed
- as modifying the License.
-
- You may add Your own copyright statement to Your modifications and
- may provide additional or different license terms and conditions
- for use, reproduction, or distribution of Your modifications, or
- for any such Derivative Works as a whole, provided Your use,
- reproduction, and distribution of the Work otherwise complies with
- the conditions stated in this License.
-
- 5. Submission of Contributions. Unless You explicitly state otherwise,
- any Contribution intentionally submitted for inclusion in the Work
- by You to the Licensor shall be under the terms and conditions of
- this License, without any additional terms or conditions.
- Notwithstanding the above, nothing herein shall supersede or modify
- the terms of any separate license agreement you may have executed
- with Licensor regarding such Contributions.
-
- 6. Trademarks. This License does not grant permission to use the trade
- names, trademarks, service marks, or product names of the Licensor,
- except as required for reasonable and customary use in describing the
- origin of the Work and reproducing the content of the NOTICE file.
-
- 7. Disclaimer of Warranty. Unless required by applicable law or
- agreed to in writing, Licensor provides the Work (and each
- Contributor provides its Contributions) on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
- implied, including, without limitation, any warranties or conditions
- of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
- PARTICULAR PURPOSE. You are solely responsible for determining the
- appropriateness of using or redistributing the Work and assume any
- risks associated with Your exercise of permissions under this License.
-
- 8. Limitation of Liability. In no event and under no legal theory,
- whether in tort (including negligence), contract, or otherwise,
- unless required by applicable law (such as deliberate and grossly
- negligent acts) or agreed to in writing, shall any Contributor be
- liable to You for damages, including any direct, indirect, special,
- incidental, or consequential damages of any character arising as a
- result of this License or out of the use or inability to use the
- Work (including but not limited to damages for loss of goodwill,
- work stoppage, computer failure or malfunction, or any and all
- other commercial damages or losses), even if such Contributor
- has been advised of the possibility of such damages.
-
- 9. Accepting Warranty or Additional Liability. While redistributing
- the Work or Derivative Works thereof, You may choose to offer,
- and charge a fee for, acceptance of support, warranty, indemnity,
- or other liability obligations and/or rights consistent with this
- License. However, in accepting such obligations, You may act only
- on Your own behalf and on Your sole responsibility, not on behalf
- of any other Contributor, and only if You agree to indemnify,
- defend, and hold each Contributor harmless for any liability
- incurred by, or claims asserted against, such Contributor by reason
- of your accepting any such warranty or additional liability.
-
- END OF TERMS AND CONDITIONS
-
- APPENDIX: How to apply the Apache License to your work.
-
- To apply the Apache License to your work, attach the following
- boilerplate notice, with the fields enclosed by brackets "[]"
- replaced with your own identifying information. (Don't include
- the brackets!) The text should be enclosed in the appropriate
- comment syntax for the file format. We also recommend that a
- file or class name and description of purpose be included on the
- same "printed page" as the copyright notice for easier
- identification within third-party archives.
-
- Copyright [yyyy] [name of copyright owner]
-
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
diff --git a/lib/auto-common-0.10-sources.jar b/lib/auto-common-0.10-sources.jar
deleted file mode 100644
index 59bf056..0000000
--- a/lib/auto-common-0.10-sources.jar
+++ /dev/null
Binary files differ
diff --git a/lib/auto-common-0.10-sources.jar.asc b/lib/auto-common-0.10-sources.jar.asc
deleted file mode 100644
index ecc3339..0000000
--- a/lib/auto-common-0.10-sources.jar.asc
+++ /dev/null
@@ -1,11 +0,0 @@
------BEGIN PGP SIGNATURE-----
-Version: GnuPG v1
-
-iQEcBAABAgAGBQJaYLeuAAoJEF4feafCmGYeVzIH/A0rkeHli229WFOj5c3HnFqK
-hbyy32JRw8GZXTqNFamkuxWDF03jHwQn0ymp0nxRQ+I3JRTzbfuTnT73e+kiNSI8
-02PowzbrghgsuaifiOGpHaO/FRSBaexzjE1TbZncO6jM8RIg1J7GPqgUenRwA5YT
-7VL7Ig+5G9bXOZMcQ4OuHwqi2O1rSfnSDDIFGlDqmKNiJWHi4KijxNred9CvUGeW
-7zFBOzQkqUqm7Vs2MHmBvNM79fcD1F1SFa2I7+p6/oD1ecC0TAHLdlLhR1/sLBaG
-iw3uQeeflVZ6ilzJg93Rl2kNUw77nnywkt12SY76j1tpF5Ny2l8tid3bBrQEUPE=
-=0e1a
------END PGP SIGNATURE-----
diff --git a/lib/auto-common-0.10-sources.jar.sha1 b/lib/auto-common-0.10-sources.jar.sha1
deleted file mode 100644
index b9b3bee..0000000
--- a/lib/auto-common-0.10-sources.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-913c8de9604380c6e135086132adb26c77fa6c53
\ No newline at end of file
diff --git a/lib/auto-common-0.10.jar b/lib/auto-common-0.10.jar
deleted file mode 100644
index 8cbfa72..0000000
--- a/lib/auto-common-0.10.jar
+++ /dev/null
Binary files differ
diff --git a/lib/auto-common-0.10.jar.asc b/lib/auto-common-0.10.jar.asc
deleted file mode 100644
index 6d81bdf..0000000
--- a/lib/auto-common-0.10.jar.asc
+++ /dev/null
@@ -1,11 +0,0 @@
------BEGIN PGP SIGNATURE-----
-Version: GnuPG v1
-
-iQEcBAABAgAGBQJaYLeuAAoJEF4feafCmGYe/1gIAInqdd+9NqxfOKRw6ujpL3nT
-XmmsP9gR/Tvvi3xRKj8PjcO9ydO2IfQ9ySAS6qbKuS9SIQn+Plq+6E+rwYkKy5t/
-MZ7Ff59XgMW0uxFEA2zUbcprgQyR6M4A31MYVmKuZ2fGBs5OsoN0+sZPCDmo4EzN
-TIgZ/LdNUWXLIsIRAKzCnUkYjlnNHKcJbW527obNH0UF/TBARrEAtmfCbKT6f91/
-zl1GtnxNR/9LVRxErFHQPcHrRxVP72xRHjdTCJHsL0t5cJJPr9maqkXq8DAyyptU
-XcjisvelIubTqnBDXcqJBIM3beGYPa5rot+3NjnNbylbfSqMED1dSGJL/fypY/U=
-=5BoX
------END PGP SIGNATURE-----
diff --git a/lib/auto-common-0.10.jar.sha1 b/lib/auto-common-0.10.jar.sha1
deleted file mode 100644
index 2056a80..0000000
--- a/lib/auto-common-0.10.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-c8f153ebe04a17183480ab4016098055fb474364
\ No newline at end of file
diff --git a/lib/auto-factory-1.0-beta6-sources.jar b/lib/auto-factory-1.0-beta6-sources.jar
deleted file mode 100644
index 56c6909..0000000
--- a/lib/auto-factory-1.0-beta6-sources.jar
+++ /dev/null
Binary files differ
diff --git a/lib/auto-factory-1.0-beta6-sources.jar.asc b/lib/auto-factory-1.0-beta6-sources.jar.asc
deleted file mode 100644
index be05c6e..0000000
--- a/lib/auto-factory-1.0-beta6-sources.jar.asc
+++ /dev/null
@@ -1,11 +0,0 @@
------BEGIN PGP SIGNATURE-----
-
-iQEzBAABCgAdFiEEMoi4voUS1sDKGFJoxR5svH/0bwsFAlvN1rYACgkQxR5svH/0
-bwsyngf8C60gBeqMcbTJ05w6IccmLONiVEBfXXVASLGxJRW6A4C6CZCOaeu/JTGV
-RlyKSL4RxT6LdN4IE1k/b+SWwhAGxES6n2J1G9TFq/SiRSEjPL2a41qRynjXo9Sx
-D/jWX4flGS4fT229EDx18d+Vy3So5+jPNLN7KyB4E9yBZfnTTmeENsgvs0Y1jw5D
-MNK73Nwwg+f7R42J+07FauRU8YXPYcG1UYZcnmAeHNDmwfL1UOsfSzrglHbU59mw
-MrupMb3h5VSBZcqknQUBbPQUUWo7e+jSJZKDB750CxBNSBfF3tN2D1vJ1/ynCIDA
-i+iY39xggnIbyKTPj1/aOGTBVfiVJQ==
-=xs9M
------END PGP SIGNATURE-----
diff --git a/lib/auto-factory-1.0-beta6-sources.jar.sha1 b/lib/auto-factory-1.0-beta6-sources.jar.sha1
deleted file mode 100644
index 9b5c0a8..0000000
--- a/lib/auto-factory-1.0-beta6-sources.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-fab31580230ac3001579238a8857a74bd045e3b9
\ No newline at end of file
diff --git a/lib/auto-factory-1.0-beta6.jar b/lib/auto-factory-1.0-beta6.jar
deleted file mode 100644
index e47130f..0000000
--- a/lib/auto-factory-1.0-beta6.jar
+++ /dev/null
Binary files differ
diff --git a/lib/auto-factory-1.0-beta6.jar.asc b/lib/auto-factory-1.0-beta6.jar.asc
deleted file mode 100644
index 5da4253..0000000
--- a/lib/auto-factory-1.0-beta6.jar.asc
+++ /dev/null
@@ -1,11 +0,0 @@
------BEGIN PGP SIGNATURE-----
-
-iQEzBAABCgAdFiEEMoi4voUS1sDKGFJoxR5svH/0bwsFAlvN1rIACgkQxR5svH/0
-bwt0VAf/S4AELEOE7cdcSkSF8vNCUhHgJbyRIb9SLT9Jh6ZXt0sVt1ZMB4Jcx9WL
-GfIwCAZhPcidTF3yVRvK0Sj2zHq53bGNsejL5BLO73oSoVowv7NV96v42zbBtMDU
-K6AI8G7lXEHYDlW4gwiyz/5CjP8VYSJgQ5vuC81rNL0vrBY0S30MlzHmCLjCvE2b
-DpV+thGWluhStwJRwvQArtUDgXYW6BPGetls/Mr0LKiSvz9uS9EvRvcQHiiwqxPu
-Jj5vheKyyeaRq7BOOswoUvfidr+UrNBt/Jit3L2kuo5n4n7sfb6irR610X8mMMN/
-kx5cA78f+p7XHbLZh6w3pySp+HCvKw==
-=1KAq
------END PGP SIGNATURE-----
diff --git a/lib/auto-factory-1.0-beta6.jar.sha1 b/lib/auto-factory-1.0-beta6.jar.sha1
deleted file mode 100644
index 57a5e61..0000000
--- a/lib/auto-factory-1.0-beta6.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-58c804763a4d80c0884ac8a740fcff4d61da72bc
\ No newline at end of file
diff --git a/lib/auto-service-1.0-rc5-sources.jar b/lib/auto-service-1.0-rc5-sources.jar
deleted file mode 100644
index 8a05c9d..0000000
--- a/lib/auto-service-1.0-rc5-sources.jar
+++ /dev/null
Binary files differ
diff --git a/lib/auto-service-1.0-rc5-sources.jar.asc b/lib/auto-service-1.0-rc5-sources.jar.asc
deleted file mode 100644
index 08ea732..0000000
--- a/lib/auto-service-1.0-rc5-sources.jar.asc
+++ /dev/null
@@ -1,11 +0,0 @@
------BEGIN PGP SIGNATURE-----
-
-iQEzBAABCgAdFiEEMoi4voUS1sDKGFJoxR5svH/0bwsFAlyZH5AACgkQxR5svH/0
-bwuBWwf/QMOlEF0td8ykweHGoOt5B6JmBLk4lPNhZDZdGmvqn+RzbWHo7F5QoBL6
-RQ+Wn97UDroLrIeMRsWvOzL/dA/kMhE2tNX8OKP1kaU7d1ahSkY6PRrPrdcf34IA
-Ku62psSXM5L78HdmhfVpf6UBsa3QJ9ZtLrBMjubxJ7aVrHCTIPP8obVgfgFWHnZD
-nGiynMUNXT6H+L9mDtkWHnVEkC07VBTCFr+6HA3TIf76KQ8LiIj6h+7l6KlPz48h
-eyaElzUUn5deTIG7jrPC2SaVhC0fKu/j1ZazN8tj/25+v9Q9mgZieYYEtiKjrEJU
-tli80ajN26E2NduLldkSVPt6N1Nf/w==
-=6nn7
------END PGP SIGNATURE-----
diff --git a/lib/auto-service-1.0-rc5-sources.jar.sha1 b/lib/auto-service-1.0-rc5-sources.jar.sha1
deleted file mode 100644
index 3638b53..0000000
--- a/lib/auto-service-1.0-rc5-sources.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-76bf7fbfc5a924f13115005a134546c4e2d1b245
\ No newline at end of file
diff --git a/lib/auto-service-1.0-rc5.jar b/lib/auto-service-1.0-rc5.jar
deleted file mode 100644
index 8c43e8f..0000000
--- a/lib/auto-service-1.0-rc5.jar
+++ /dev/null
Binary files differ
diff --git a/lib/auto-service-1.0-rc5.jar.2 b/lib/auto-service-1.0-rc5.jar.2
deleted file mode 100644
index 8c43e8f..0000000
--- a/lib/auto-service-1.0-rc5.jar.2
+++ /dev/null
Binary files differ
diff --git a/lib/auto-service-1.0-rc5.jar.asc b/lib/auto-service-1.0-rc5.jar.asc
deleted file mode 100644
index e1d0163..0000000
--- a/lib/auto-service-1.0-rc5.jar.asc
+++ /dev/null
@@ -1,11 +0,0 @@
------BEGIN PGP SIGNATURE-----
-
-iQEzBAABCgAdFiEEMoi4voUS1sDKGFJoxR5svH/0bwsFAlyZH48ACgkQxR5svH/0
-bwuZSAgAgmJ8gEx+MLtdt8IJY0ZGZtzntCOv2kTmieTQdwLKbmEc/WeQBXZeAWjb
-xKctEnesbNGwJY5jpPBiQH0nDd0MyIOc25gCvug2ezveo9eNe9ptOQFi+4gsG3mv
-0SGD9ZnRkzW8wNyMMWdBUJYdGPJp/FshsOVajBVsMDSev3OBxw8qfT4ZqhTO3LN6
-UnFydeqtbukqBiQRBrWEO7zXDmeHP+6GMWOD4Tkt60VRrSo7Sk6WeUkSJcB0rrmw
-+/blQ3jBlN2/ummOc1dWUu7EyBoWhJhChQDQAuwev5oMMyQnhTLiFcHPvoKWFTlO
-GsBFENSqqxlW4j2ZYpoMX42inuaqbQ==
-=AMUZ
------END PGP SIGNATURE-----
diff --git a/lib/auto-service-1.0-rc5.jar.sha1 b/lib/auto-service-1.0-rc5.jar.sha1
deleted file mode 100644
index 2edbbf4..0000000
--- a/lib/auto-service-1.0-rc5.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-d25246bae325b4bcc63b55d6d782515fac32215a
\ No newline at end of file
diff --git a/lib/auto-service-annotations-1.0-rc5-sources.jar b/lib/auto-service-annotations-1.0-rc5-sources.jar
deleted file mode 100644
index 72fd4a9..0000000
--- a/lib/auto-service-annotations-1.0-rc5-sources.jar
+++ /dev/null
Binary files differ
diff --git a/lib/auto-service-annotations-1.0-rc5-sources.jar.asc b/lib/auto-service-annotations-1.0-rc5-sources.jar.asc
deleted file mode 100644
index 0058623..0000000
--- a/lib/auto-service-annotations-1.0-rc5-sources.jar.asc
+++ /dev/null
@@ -1,11 +0,0 @@
------BEGIN PGP SIGNATURE-----
-
-iQEzBAABCgAdFiEEMoi4voUS1sDKGFJoxR5svH/0bwsFAlyZH4IACgkQxR5svH/0
-bwtnEwgAntYeAk/i4kaPhOdKCni4pZpkJ3WcEaDIiZROIvxn3GLFxDp1+WaFOuZS
-kYrqKLmDJdOwEK31FGP/XjsedmB6PP90pp01apaw2XS7pAzXQyNGMOypgCntJsN6
-ZkQYNLum8HQ6XXvEQh9j0eKU/9D+x7DRaxQZ69GkjFS1EwpytEYIEdFsjvHz3SYW
-G15++0H5+l7ZyNjXCs//x6tQ73nqhEu6UylwR4A9YvDuZhpMoFPNvB1+L6mlARgi
-cDRtm8hGLhsNeIYqGmbUEzwwKtKY/n7NwJX1zpXAg86/9E8R1xdbdzfGL6ctqQal
-w3WSYcNnmiZQfPinZuGHnrqDk/rN2w==
-=lgp6
------END PGP SIGNATURE-----
diff --git a/lib/auto-service-annotations-1.0-rc5-sources.jar.sha1 b/lib/auto-service-annotations-1.0-rc5-sources.jar.sha1
deleted file mode 100644
index fc01aa3..0000000
--- a/lib/auto-service-annotations-1.0-rc5-sources.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-a2e50e3ba1f9a88f89142e7ea9a0f5380574f4e4
\ No newline at end of file
diff --git a/lib/auto-service-annotations-1.0-rc5.jar b/lib/auto-service-annotations-1.0-rc5.jar
deleted file mode 100644
index fbc08ab..0000000
--- a/lib/auto-service-annotations-1.0-rc5.jar
+++ /dev/null
Binary files differ
diff --git a/lib/auto-service-annotations-1.0-rc5.jar.asc b/lib/auto-service-annotations-1.0-rc5.jar.asc
deleted file mode 100644
index b7e43ce..0000000
--- a/lib/auto-service-annotations-1.0-rc5.jar.asc
+++ /dev/null
@@ -1,11 +0,0 @@
------BEGIN PGP SIGNATURE-----
-
-iQEzBAABCgAdFiEEMoi4voUS1sDKGFJoxR5svH/0bwsFAlyZH4EACgkQxR5svH/0
-bwtNcwf+IvcoHSI7AvrM+z6Lhqes8wEdU9Q59ixakvEos/umjYwCXoGJyAG/w8N5
-4woRDJRg8KgWC0Kls7CGs5ZwplQTLRte/SmXWux8CV0/3v6OlIP4voWvXBueqKST
-gNN/Miy0Qx5uX1Qwh0inqlFF7jOj+IuTofQ4ZM3UjZPLVYhSfS/wTwLmNWNawQq7
-b/PkxaYgC1RuNv9onA8Vru2UCIlH8NFP9iPqPMwhRVVxoSaZzo5NxrRNRPZUfPzF
-GUH/SRDOfXHJ1joeZRK21s8adOGzZZJsSxxZ393xx1jl5qLdoowjTtENgc9gOSQG
-FzxOfWCoWncsJP10KfyYRV70JnJMrQ==
-=dWz/
------END PGP SIGNATURE-----
diff --git a/lib/auto-service-annotations-1.0-rc5.jar.sha1 b/lib/auto-service-annotations-1.0-rc5.jar.sha1
deleted file mode 100644
index 4c48b47..0000000
--- a/lib/auto-service-annotations-1.0-rc5.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-6ea999af2b6262a7179a09c51a3d54e7b40a3833
\ No newline at end of file
diff --git a/lib/auto-value-1.6.5-sources.jar b/lib/auto-value-1.6.5-sources.jar
deleted file mode 100644
index 7d08fa7..0000000
--- a/lib/auto-value-1.6.5-sources.jar
+++ /dev/null
Binary files differ
diff --git a/lib/auto-value-1.6.5-sources.jar.asc b/lib/auto-value-1.6.5-sources.jar.asc
deleted file mode 100644
index 36551c1..0000000
--- a/lib/auto-value-1.6.5-sources.jar.asc
+++ /dev/null
@@ -1,12 +0,0 @@
------BEGIN PGP SIGNATURE-----
-Comment: GPGTools - https://gpgtools.org
-
-iQEzBAABCgAdFiEEx75bzJ/sFVGM/aiCsPNxD6ZJAOcFAlyuMe0ACgkQsPNxD6ZJ
-AOc+4wgAkYRN5mdnQ54oLb/YGL9jnU7tdcFnq73ddH9wJH9cTGE8dAHIlNT4lEjy
-ligUXdi6YbuAC2Fjs7nMZiSOjEEDlKRozbwE82WOiIdV/MltMJgFCdBbVpszHFmu
-NWxDq5KocdgLODHwmIWJ0Xey6M1rjVZEshNf/U70604eEbGl9Hu0aTVFFVcASMM5
-CC38/X/G72Ja1Cz404WqGpmAsrHgDHdcPUVT3xxDReV1B+yPKxazzuKZA8/+KkWP
-RddLifE3W2NYnLVX49DS9iWCBiEbh5P6jtHvQSiyXIawexhQJGhjQMwHoi0+jHJd
-INp5YyrB64PHqaSgtuXhwgTfXmxkMA==
-=5Cw9
------END PGP SIGNATURE-----
diff --git a/lib/auto-value-1.6.5-sources.jar.md5 b/lib/auto-value-1.6.5-sources.jar.md5
deleted file mode 100644
index ca18ea4..0000000
--- a/lib/auto-value-1.6.5-sources.jar.md5
+++ /dev/null
@@ -1 +0,0 @@
-4a433a939d3f77766c785288d5c24c10
\ No newline at end of file
diff --git a/lib/auto-value-1.6.5-sources.jar.sha1 b/lib/auto-value-1.6.5-sources.jar.sha1
deleted file mode 100644
index 17f16a8..0000000
--- a/lib/auto-value-1.6.5-sources.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-bfc251753f9bbdd8855825361d5f8c7fec8a1471
\ No newline at end of file
diff --git a/lib/auto-value-1.6.5.jar b/lib/auto-value-1.6.5.jar
deleted file mode 100644
index be17cd1..0000000
--- a/lib/auto-value-1.6.5.jar
+++ /dev/null
Binary files differ
diff --git a/lib/auto-value-1.6.5.jar.asc b/lib/auto-value-1.6.5.jar.asc
deleted file mode 100644
index f0cdc39..0000000
--- a/lib/auto-value-1.6.5.jar.asc
+++ /dev/null
@@ -1,12 +0,0 @@
------BEGIN PGP SIGNATURE-----
-Comment: GPGTools - https://gpgtools.org
-
-iQEzBAABCgAdFiEEx75bzJ/sFVGM/aiCsPNxD6ZJAOcFAlyuMewACgkQsPNxD6ZJ
-AOd5ygf8DOjgClYv8hCaiHiu2mDwFV4s24SbyvSZrAeBrHOoY6/E7leSqilJ+mF9
-3kjDv/VtHTv9Ds2cX2daH5hnvuYIwiCzdze3ZWdKJ+PtWsKpqEAevfEMRmSPPUV4
-ZZ5Zd6VZspD+rUViKfwF8ZW1zjKjdcIPbhuiYR4TF718kPL8WCV2bGruYidjYBoe
-hzLUUqY0rv+IwV+OycbyZwtmx1DVCTkYlDdepSyswr2RGb/UFIf44E0koboI+Xue
-6nF+w6AaOaufjdqe2ObIWNa2tsPTj4KABh3tHmOMs35x367/PzwQmh0I25gFAQrX
-KYo6dYVZeLWmNpdIJxeMIZRok0MAKA==
-=KnCZ
------END PGP SIGNATURE-----
diff --git a/lib/auto-value-1.6.5.jar.md5 b/lib/auto-value-1.6.5.jar.md5
deleted file mode 100644
index 11a5e9d..0000000
--- a/lib/auto-value-1.6.5.jar.md5
+++ /dev/null
@@ -1 +0,0 @@
-d3730b8e2f9c6f62153181618a13f3a2
\ No newline at end of file
diff --git a/lib/auto-value-1.6.5.jar.sha1 b/lib/auto-value-1.6.5.jar.sha1
deleted file mode 100644
index edf62d8..0000000
--- a/lib/auto-value-1.6.5.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-816872c85048f36a67a276ef7a49cc2e4595711c
\ No newline at end of file
diff --git a/lib/auto-value-annotations-1.6.5-sources.jar b/lib/auto-value-annotations-1.6.5-sources.jar
deleted file mode 100644
index b1a8b08..0000000
--- a/lib/auto-value-annotations-1.6.5-sources.jar
+++ /dev/null
Binary files differ
diff --git a/lib/auto-value-annotations-1.6.5-sources.jar.asc b/lib/auto-value-annotations-1.6.5-sources.jar.asc
deleted file mode 100644
index 81a4515..0000000
--- a/lib/auto-value-annotations-1.6.5-sources.jar.asc
+++ /dev/null
@@ -1,12 +0,0 @@
------BEGIN PGP SIGNATURE-----
-Comment: GPGTools - https://gpgtools.org
-
-iQEzBAABCgAdFiEEx75bzJ/sFVGM/aiCsPNxD6ZJAOcFAlyuMdUACgkQsPNxD6ZJ
-AOfNYwgAqoJ9hi7JyS1iwf646TPLPbtRaaRzl/w9hrZntVlMiHL5Ov+LHq6WW1tS
-IWqz9K6dbEDW4O3WbNXUsiWTGzUvkNc/bjQOY4MTCthTj/LO9PqHVSDGgWo/Y37c
-jazTbUNxctFSziu9mVZdw1VdCI65LVCbhSaOeIc7Msmr/ALtZ1pBGdJ8dzxuC3Dl
-BeT2khADj7C13Kicu7QtZfZypbTqB6JnjAwMO56c4pRviIqRpJsOKHbJM1KBxms+
-6JGv63XTBP22f83XX38wAAPocT5NZBn+lZcDcbC6Mh0NIhaISdx73ujWtTwHX5fC
-x0NYKIIBdyEb5GkPeD1D/IjB4w8o5w==
-=Hbou
------END PGP SIGNATURE-----
diff --git a/lib/auto-value-annotations-1.6.5-sources.jar.sha1 b/lib/auto-value-annotations-1.6.5-sources.jar.sha1
deleted file mode 100644
index 897752c..0000000
--- a/lib/auto-value-annotations-1.6.5-sources.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-3499fd80025705c502699d1154c4b9631cb7a95e
\ No newline at end of file
diff --git a/lib/auto-value-annotations-1.6.5.jar b/lib/auto-value-annotations-1.6.5.jar
deleted file mode 100644
index f68a013..0000000
--- a/lib/auto-value-annotations-1.6.5.jar
+++ /dev/null
Binary files differ
diff --git a/lib/auto-value-annotations-1.6.5.jar.asc b/lib/auto-value-annotations-1.6.5.jar.asc
deleted file mode 100644
index 1356995..0000000
--- a/lib/auto-value-annotations-1.6.5.jar.asc
+++ /dev/null
@@ -1,12 +0,0 @@
------BEGIN PGP SIGNATURE-----
-Comment: GPGTools - https://gpgtools.org
-
-iQEzBAABCgAdFiEEx75bzJ/sFVGM/aiCsPNxD6ZJAOcFAlyuMdQACgkQsPNxD6ZJ
-AOeeQQf/cRfXuh8RCDR5WWAHPXpK9JzA5OEEvtXl13uSqpcU+f2/APNOmG9tJz2B
-53bp6d18knaoSAWtC1Hl2kM8eZPYNlpB+MC8VJ+/JAZMf2arLMKGuvii9eYmGrvJ
-kXfRHqWgZQMQIKrd2ne/PMgnmixLPSF6HtyFh2JN/LbjR7ipQR3VAJe89QGmIFFf
-njSptIgKuDauQrjq//yXpWRyhUNheAH42y3aIaUvydcSOLsGIqQfTJLOe3sSMxlU
-d0fJWP47uW04y2j6kXv4SYKXGnBrv2M+c/6YRriPv69tSBc+2DY6SpMZsYdV9Car
-pDM+7m5lxCN8mI/KRRNcXaSR9GLJ2A==
-=ey6m
------END PGP SIGNATURE-----
diff --git a/lib/auto-value-annotations-1.6.5.jar.sha1 b/lib/auto-value-annotations-1.6.5.jar.sha1
deleted file mode 100644
index 858c96e..0000000
--- a/lib/auto-value-annotations-1.6.5.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-c3dad10377f0e2242c9a4b88e9704eaf79103679
\ No newline at end of file
diff --git a/lib/google-java-format-1.7-all-deps.jar b/lib/google-java-format-1.7-all-deps.jar
deleted file mode 100644
index e2d40de..0000000
--- a/lib/google-java-format-1.7-all-deps.jar
+++ /dev/null
Binary files differ
diff --git a/lib/google-java-format-1.7-all-deps.jar.asc b/lib/google-java-format-1.7-all-deps.jar.asc
deleted file mode 100644
index 73ae0e2..0000000
--- a/lib/google-java-format-1.7-all-deps.jar.asc
+++ /dev/null
@@ -1,16 +0,0 @@
------BEGIN PGP SIGNATURE-----
-
-iQIzBAABCgAdFiEE53QXrBlBYKP6vQSWmiWcfuY2xe0FAlw2hwoACgkQmiWcfuY2
-xe22Ww//YIHLWoQApuSmLdq4A1fcNOYbSpm6J9I2J1i2VoK84XSXP1XJTWsoYNbx
-Y3Xx6I8p28AxH7LOWcdtds9enbF06blzz+1CxuSxvN32M7DDursiihsUYU9wmZVU
-7V1ZYBtaYTYYw8C5U+UchcIVJrHdG9KrAiBcn1s76gigNAtCYV/1PyryupS1wcDZ
-bdj48mI6adcnIpV+9D9W4rLuXw2Hg+ewktXTj3HYqkg+5Nvc/zP9ueBvqEsyh5Iz
-3+69egblhuN7gRaEWarlYfJ2n/kF9T/UMAkQrWD8+9cOgUcgTHkNADNOLpmDH6t7
-OYvZhgwQT920ZJgGP8e3DGyvMxBMxlr19ciTT19HL5qglyhFm/SeHvFdpaHkIjb9
-CmASWrlkALdEv2gPx+m79EJifyK5tYtViZgLhfjwYkS/opw5TfJX0+Ngh9ehgune
-c6TgEIzRQAEQ/9QoVk2crGT/lhXnJI3Zid7cSP2/fRdui91KaKGi9qFvXyJf7XKI
-vH0De+e3yZN/GXLYyQSUzmdQU8HMF9iuc81CT1ANgU+e9HU5k9FWSPHrA3gN7CKt
-/a3qIsIBpcdKe9zcPxSoEqRzVNept4IhszgiIVxZPNrPShzCRbS1sGURoOTbSFSP
-+aKWNFoswX/RANGQVajOyfF5mJ3lB4N0u2eI0HIR3NzNx0HN+2Q=
-=+/96
------END PGP SIGNATURE-----
diff --git a/lib/google-java-format-1.7-all-deps.jar.sha1 b/lib/google-java-format-1.7-all-deps.jar.sha1
deleted file mode 100644
index b247a7c..0000000
--- a/lib/google-java-format-1.7-all-deps.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b6d34a51e579b08db7c624505bdf9af4397f1702
\ No newline at end of file
diff --git a/lib/google-java-format-1.7-sources.jar b/lib/google-java-format-1.7-sources.jar
deleted file mode 100644
index 70fca1b..0000000
--- a/lib/google-java-format-1.7-sources.jar
+++ /dev/null
Binary files differ
diff --git a/lib/google-java-format-1.7-sources.jar.asc b/lib/google-java-format-1.7-sources.jar.asc
deleted file mode 100644
index 713333c..0000000
--- a/lib/google-java-format-1.7-sources.jar.asc
+++ /dev/null
@@ -1,16 +0,0 @@
------BEGIN PGP SIGNATURE-----
-
-iQIzBAABCgAdFiEE53QXrBlBYKP6vQSWmiWcfuY2xe0FAlw2hwsACgkQmiWcfuY2
-xe1j6BAAsDY9DTTcjRtrT6AiZchELcJleOdqK3TRdbl193Mtw5eR+BdKqtcLZSmZ
-1EqYNcldOu9wgbZFpFL99xWNAPOt8tTU9hTsZvrRN0e5CwKXrlJl0MeJi/6yYquG
-FerYGZuDMMEza1q9D2TG5erLOjDEWVLjkSs3jw8mSyMvN0OJFhhMrU4sqhlXMGNV
-lDxeYXLXr+QtIi0tXAUQ5XSwtR7eukSevA7n3zQJKfYMlFbG82lMGJccfazJpdPf
-cJLAGY9/q3RVZx5vk00kz3sDmL+rMU01Lh+CHwT9D8ASRfzjkssHuKaMYBysuh7s
-YZ6X3Txvtkzf3fJjYl5jID3jEui82iR5jv5ncZFZFCsZsTRM0sLAP5/KeX128dHM
-fJzVH4GIUvOqt9aIDKQ+3aNsARsIH2Z2AHymUxVZoP33V9HoC8x0ghxM0xohvkh5
-L+VgUOEjekOneqWD1QEF+HD7S3hpy36+g37PYGcQRRaCIDn00Se+UbJ9RZrUVdvu
-JgmVXcpagrLmcSnkG265zdDW9Vu7vjAKhxjLXmbE0aowzdo/HZ+u3R2hpZbOyv33
-NmakhTwaUtQtDm34GVPqoypnu85va27vxVDQgTsk3im9M1l/UP65NidPuuSk7iOI
-UECD7wc6Ddh80jmDlXdlxSNG+zzGp95gS5UVoDXgwNEok7UgrY4=
-=zj6k
------END PGP SIGNATURE-----
diff --git a/lib/google-java-format-1.7-sources.jar.sha1 b/lib/google-java-format-1.7-sources.jar.sha1
deleted file mode 100644
index 31d6337..0000000
--- a/lib/google-java-format-1.7-sources.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-dbb14f20004dfaf01a5ce9f5e75c5993f18cc0a5
\ No newline at end of file
diff --git a/lib/google-java-format-1.7.jar b/lib/google-java-format-1.7.jar
deleted file mode 100644
index 953541c..0000000
--- a/lib/google-java-format-1.7.jar
+++ /dev/null
Binary files differ
diff --git a/lib/google-java-format-1.7.jar.asc b/lib/google-java-format-1.7.jar.asc
deleted file mode 100644
index 3642d69..0000000
--- a/lib/google-java-format-1.7.jar.asc
+++ /dev/null
@@ -1,16 +0,0 @@
------BEGIN PGP SIGNATURE-----
-
-iQIzBAABCgAdFiEE53QXrBlBYKP6vQSWmiWcfuY2xe0FAlw2hwkACgkQmiWcfuY2
-xe1uIhAAt9sWjStHkfHmWNFd5exYsjBmN0eObgOU5A386j5Q5P4hZjFDYsDvKlVo
-DWZKI2A9ZvpisuI083DwGJCXvbtD1WICh5Xx1B2tK2oCgl5bYiU88LCw5jS9F2IZ
-thPFhFDMIw4tQZp2J4o+itO7gtoUMfN5J9Y7ZcOWG60F3ouGc6vd8PnMk/CfxNZ0
-Zy21dkBzJVJsNghUWsHfP6WS2ySVBNQaarY+/4IuIrBVqRNZBhD+qEtZRG3mwc4X
-ydd4hCvoAQ7lysrdZEMDRx0qLQoqEWyfNFX7b8X/Oi6Ape765mD3Ss1WFgsjLqo+
-kt4Ge09f4QOCtMP95M8AnnHGjpVuibC0tb2E7qXfcrMWf+EX8ksFJKwaXZQfG4lv
-7kxZDTeeDdU6SUakiwfkEKN6s4v0MrGi8TM+776gLihcD/tx09555h+EwXrbp3IE
-1SWJCiYCuaqe1UXNEsZGYKv72GkPSEjY813Tn3endvGXX+QrLCU6DrLRyy1IWFKJ
-Yu6THeT0Z+M6h+oTO0ug2gJ6Ur7apQC4JBIi12XE+QhwuTuV0byiUArmO+3elLH4
-Nd9O0yFhKClaJ+ye+X+XLYkIjh+IJGFmbUahvCFuMMKuwbFRHwn5pw0DOJvE7qjg
-dBZhwjzKN8RHzik5nFwzhBBIzj3UglacGkUPFv7JW1TqcY2X6kE=
-=VIxo
------END PGP SIGNATURE-----
diff --git a/lib/google-java-format-1.7.jar.sha1 b/lib/google-java-format-1.7.jar.sha1
deleted file mode 100644
index d0a76c2..0000000
--- a/lib/google-java-format-1.7.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-97cb6afc835d65682edc248e19170a8e4ecfe4c4
\ No newline at end of file
diff --git a/lib/javax.inject-1-sources.jar b/lib/javax.inject-1-sources.jar
deleted file mode 100644
index 0c98053..0000000
--- a/lib/javax.inject-1-sources.jar
+++ /dev/null
Binary files differ
diff --git a/lib/javax.inject-1-sources.jar.sha1 b/lib/javax.inject-1-sources.jar.sha1
deleted file mode 100644
index b69cdf0..0000000
--- a/lib/javax.inject-1-sources.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-a00123f261762a7c5e0ec916a2c7c8298d29c400 /home/maven/repository-staging/to-ibiblio/maven2/javax/inject/javax.inject/1/javax.inject-1-sources.jar
diff --git a/lib/javax.inject-1.jar b/lib/javax.inject-1.jar
deleted file mode 100644
index b2a9d0b..0000000
--- a/lib/javax.inject-1.jar
+++ /dev/null
Binary files differ
diff --git a/lib/javax.inject-1.jar.sha1 b/lib/javax.inject-1.jar.sha1
deleted file mode 100644
index 41e75ef..0000000
--- a/lib/javax.inject-1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-6975da39a7040257bd51d21a231b76c915872d38 /home/maven/repository-staging/to-ibiblio/maven2/javax/inject/javax.inject/1/javax.inject-1.jar
diff --git a/lint-baseline.xml b/lint-baseline.xml
new file mode 100644
index 0000000..cf790c2
--- /dev/null
+++ b/lint-baseline.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<issues format="5" by="lint 4.1.0" client="cli" variant="all" version="4.1.0">
+
+ <issue
+ id="NewApi"
+ message="Multi-catch with these reflection exceptions requires API level 19 (current min is 14) because they get compiled to the common but new super type `ReflectiveOperationException`. As a workaround either create individual catch statements, or catch `Exception`."
+ errorLine1=" } catch (ClassNotFoundException"
+ errorLine2=" ^">
+ <location
+ file="external/dagger2/java/dagger/hilt/android/internal/testing/TestApplicationComponentManager.java"
+ line="85"
+ column="14"/>
+ </issue>
+
+</issues>
diff --git a/test_defs.bzl b/test_defs.bzl
index 15ab299..d16ad36 100644
--- a/test_defs.bzl
+++ b/test_defs.bzl
@@ -12,24 +12,18 @@
# See the License for the specific language governing permissions and
# limitations under the License.
+"""This file defines constants useful across the Dagger tests."""
+
+load("@rules_java//java:defs.bzl", "java_library", "java_test")
# Defines a set of build variants and the list of extra javacopts to build with.
# The key will be appended to the generated test names to ensure uniqueness.
BUILD_VARIANTS = {
"FastInit": ["-Adagger.fastInit=enabled"],
- "AheadOfTimeSubcomponents": ["-Adagger.experimentalAheadOfTimeSubcomponents=enabled"],
- "FastInitAndAheadOfTimeSubcomponents": [
- "-Adagger.fastInit=enabled",
- "-Adagger.experimentalAheadOfTimeSubcomponents=enabled",
- ],
- "AheadOfTimeSubcomponents_ForceUseSerializedComponentImplementations": [
- "-Adagger.experimentalAheadOfTimeSubcomponents=enabled",
- "-Adagger.forceUseSerializedComponentImplementations=enabled",
- ],
}
# TODO(ronshapiro): convert this to use bazel_common
-# TODO(user): split into two functions for functional vs non-functional tests?
+# TODO(bcorso): split into two functions for functional vs non-functional tests?
def GenJavaTests(
name,
srcs,
@@ -41,8 +35,8 @@
test_javacopts = None,
functional = True):
_GenTests(
- native.java_library,
- native.java_test,
+ java_library,
+ java_test,
name,
srcs,
deps,
@@ -190,6 +184,5 @@
**test_kwargs
)
-
def _hjar_test(name, tags):
pass
diff --git a/tools/BUILD b/tools/BUILD
index 7b3cc6c..83d5048 100644
--- a/tools/BUILD
+++ b/tools/BUILD
@@ -15,8 +15,30 @@
# Description:
# Tools for Dagger
+load("@bazel_skylib//:bzl_library.bzl", "bzl_library")
+load(":maven_info.bzl", "maven_info_tests")
+
package(default_visibility = ["//:src"])
+maven_info_tests()
+
exports_files([
"pom-template.xml",
])
+
+bzl_library(
+ name = "maven_bzl",
+ srcs = ["maven.bzl"],
+ deps = [":maven_info_bzl"],
+)
+
+bzl_library(
+ name = "maven_info_bzl",
+ srcs = ["maven_info.bzl"],
+ deps = ["@bazel_skylib//lib:unittest"],
+)
+
+bzl_library(
+ name = "dejetify_bzl",
+ srcs = ["dejetify.bzl"],
+)
diff --git a/tools/dejetify.bzl b/tools/dejetify.bzl
new file mode 100644
index 0000000..4f0b0ce
--- /dev/null
+++ b/tools/dejetify.bzl
@@ -0,0 +1,47 @@
+# Copyright (C) 2020 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Macro for producing dejetified artifacts.
+"""
+
+# See: https://developer.android.com/studio/command-line/jetifier
+JETIFIER_STANDALONE = "https://dl.google.com/dl/android/studio/jetifier-zips/1.0.0-beta08/jetifier-standalone.zip"
+
+def dejetified_library(name, input, output):
+ _dejetify_library(name, input, output)
+
+def _dejetify_library(name, input, output):
+ """Generates a dejetified library artifact.
+
+ A dejetified artifact is one that has been transformed to migrate its
+ AndroidX APIs to the support equivalents.
+
+ Args:
+ name: The name of the target.
+ input: The android_library input, e.g. ":myLibrary.aar".
+ output: The name of the output artifact, e.g. "dejetified-myLibrary.aar".
+ """
+ native.genrule(
+ name = name,
+ srcs = [input],
+ outs = [output],
+ cmd = """
+ TEMP="$$(mktemp -d)"
+ curl {tool_link} --output $$TEMP/jetifier-standalone.zip
+ unzip $$TEMP/jetifier-standalone.zip -d $$TEMP/
+ $$TEMP/jetifier-standalone/bin/jetifier-standalone -r \
+ -l info -i $< -o $@
+ """.format(tool_link = JETIFIER_STANDALONE),
+ local = 1,
+ )
diff --git a/tools/maven.bzl b/tools/maven.bzl
index 2ac0359..2c648a2 100644
--- a/tools/maven.bzl
+++ b/tools/maven.bzl
@@ -16,6 +16,9 @@
"""
load("@google_bazel_common//tools/maven:pom_file.bzl", default_pom_file = "pom_file")
+load(":maven_info.bzl", "MavenInfo", "collect_maven_info")
+load("@google_bazel_common//tools/javadoc:javadoc.bzl", "javadoc_library")
+load("@google_bazel_common//tools/jarjar:jarjar.bzl", "jarjar_library")
def pom_file(name, targets, artifact_name, artifact_id, packaging = None, **kwargs):
default_pom_file(
@@ -35,4 +38,366 @@
**kwargs
)
-POM_VERSION = "2.23.1"
+def gen_maven_artifact(
+ name,
+ artifact_name,
+ artifact_coordinates,
+ artifact_target,
+ artifact_target_libs = None,
+ artifact_target_maven_deps = None,
+ artifact_target_maven_deps_banned = None,
+ testonly = 0,
+ pom_name = "pom",
+ packaging = None,
+ javadoc_srcs = None,
+ javadoc_root_packages = None,
+ javadoc_exclude_packages = None,
+ javadoc_android_api_level = None,
+ shaded_deps = None,
+ shaded_rules = None,
+ manifest = None,
+ lint_deps = None,
+ proguard_specs = None):
+ _gen_maven_artifact(
+ name,
+ artifact_name,
+ artifact_coordinates,
+ artifact_target,
+ artifact_target_libs,
+ artifact_target_maven_deps,
+ artifact_target_maven_deps_banned,
+ testonly,
+ pom_name,
+ packaging,
+ javadoc_srcs,
+ javadoc_root_packages,
+ javadoc_exclude_packages,
+ javadoc_android_api_level,
+ shaded_deps,
+ shaded_rules,
+ manifest,
+ lint_deps,
+ proguard_specs
+ )
+
+def _gen_maven_artifact(
+ name,
+ artifact_name,
+ artifact_coordinates,
+ artifact_target,
+ artifact_target_libs,
+ artifact_target_maven_deps,
+ artifact_target_maven_deps_banned,
+ testonly,
+ pom_name,
+ packaging,
+ javadoc_srcs,
+ javadoc_root_packages,
+ javadoc_exclude_packages,
+ javadoc_android_api_level,
+ shaded_deps,
+ shaded_rules,
+ manifest,
+ lint_deps,
+ proguard_specs):
+ """Generates the files required for a maven artifact.
+
+ This macro generates the following targets:
+ * ":pom": The pom file for the given target and deps
+ * ":<NAME>": The artifact file for the given target and deps
+ * ":<NAME>-src": The sources jar file for the given target and deps
+ * ":<NAME>-javadoc": The javadocs jar file for the given target and deps
+
+ This macro also validates a few things. First, it validates that the
+ given "target" is a maven artifact (i.e. the "tags" attribute contains
+ "maven_coordinates=..."). Second, it calculates the list of transitive
+ dependencies of the target that are not owned by another maven artifact,
+ and validates that the given "deps" matches exactly.
+
+ Args:
+ name: The name associated with the various output targets.
+ artifact_target: The target containing the maven_coordinates.
+ artifact_name: The name of the maven artifact.
+ artifact_coordinates: The coordinates of the maven artifact in the
+ form: "<group_id>:<artifact_id>:<version>"
+ artifact_target_libs: The set of transitive libraries of the target.
+ artifact_target_maven_deps: The required maven deps of the target.
+ artifact_target_maven_deps_banned: The banned maven deps of the target.
+ testonly: True if the jar should be testonly.
+ packaging: The packaging of the maven artifact. E.g. "aar"
+ pom_name: The name of the pom file (or "pom" if absent).
+ javadoc_srcs: The srcs for the javadocs.
+ javadoc_root_packages: The root packages for the javadocs.
+ javadoc_exclude_packages: The packages to exclude from the javadocs.
+ javadoc_android_api_level: The android api level for the javadocs.
+ shaded_deps: The shaded deps for the jarjar.
+ shaded_rules: The shaded rules for the jarjar.
+ manifest: The AndroidManifest.xml to bundle in when packaing an 'aar'.
+ lint_deps: The lint targets to be bundled in when packaging an 'aar'.
+ proguard_specs: The proguard spec files to be bundled in when packaging an 'aar'
+ """
+
+ _validate_maven_deps(
+ name = name + "-validation",
+ testonly = 1,
+ target = artifact_target,
+ expected_artifact = artifact_coordinates,
+ expected_libs = artifact_target_libs,
+ expected_maven_deps = artifact_target_maven_deps,
+ banned_maven_deps = artifact_target_maven_deps_banned,
+ )
+
+ shaded_deps = shaded_deps or []
+ shaded_rules = shaded_rules or []
+ artifact_targets = [artifact_target] + (artifact_target_libs or [])
+ lint_deps = lint_deps or []
+
+ # META-INF resources files that can be combined by appending lines.
+ merge_meta_inf_files = [
+ "gradle/incremental.annotation.processors",
+ ]
+
+ artifact_id = artifact_coordinates.split(":")[1]
+ pom_file(
+ name = pom_name,
+ testonly = testonly,
+ artifact_id = artifact_id,
+ artifact_name = artifact_name,
+ packaging = packaging,
+ targets = artifact_targets,
+ )
+
+ if (packaging == "aar"):
+ jarjar_library(
+ name = name + "-classes",
+ testonly = testonly,
+ jars = artifact_targets + shaded_deps,
+ rules = shaded_rules,
+ merge_meta_inf_files = merge_meta_inf_files,
+ )
+ if lint_deps:
+ # jarjar all lint artifacts since an aar only contains a single lint.jar.
+ jarjar_library(
+ name = name + "-lint",
+ jars = lint_deps,
+ )
+ lint_jar_name = name + "-lint.jar"
+ else:
+ lint_jar_name = None
+
+ if proguard_specs:
+ # Concatenate all proguard rules since an aar only contains a single proguard.txt
+ native.genrule(
+ name = name + "-proguard",
+ srcs = proguard_specs,
+ outs = [name + "-proguard.txt"],
+ cmd = "cat $(SRCS) > $@",
+ )
+ proguard_file = name + "-proguard.txt"
+ else:
+ proguard_file = None
+
+ _package_android_library(
+ name = name + "-android-lib",
+ manifest = manifest,
+ classesJar = name + "-classes.jar",
+ lintJar = lint_jar_name,
+ proguardSpec = proguard_file,
+ )
+
+ # Copy intermediate outputs to final one.
+ native.genrule(
+ name = name,
+ srcs = [name + "-android-lib"],
+ outs = [name + ".aar"],
+ cmd = "cp $< $@",
+ )
+ else:
+ jarjar_library(
+ name = name,
+ testonly = testonly,
+ jars = artifact_targets + shaded_deps,
+ rules = shaded_rules,
+ merge_meta_inf_files = merge_meta_inf_files,
+ )
+
+ jarjar_library(
+ name = name + "-src",
+ testonly = testonly,
+ jars = [_src_jar(dep) for dep in artifact_targets],
+ merge_meta_inf_files = merge_meta_inf_files,
+ )
+
+ if javadoc_srcs != None:
+ javadoc_library(
+ name = name + "-javadoc",
+ srcs = javadoc_srcs,
+ testonly = testonly,
+ root_packages = javadoc_root_packages,
+ exclude_packages = javadoc_exclude_packages,
+ android_api_level = javadoc_android_api_level,
+ deps = artifact_targets,
+ )
+ else:
+ # Build an empty javadoc because Sonatype requires javadocs
+ # even if the jar is empty.
+ # https://central.sonatype.org/pages/requirements.html#supply-javadoc-and-sources
+ native.java_binary(
+ name = name + "-javadoc",
+ )
+
+def _src_jar(target):
+ if target.startswith(":"):
+ target = Label("//" + native.package_name() + target)
+ else:
+ target = Label(target)
+ return "//%s:lib%s-src.jar" % (target.package, target.name)
+
+def _validate_maven_deps_impl(ctx):
+ """Validates the given Maven target and deps
+
+ Validates that the given "target" is a maven artifact (i.e. the "tags"
+ attribute contains "maven_coordinates=..."). Second, it calculates the
+ list of transitive dependencies of the target that are not owned by
+ another maven artifact, and validates that the given "deps" matches
+ exactly.
+ """
+ target = ctx.attr.target
+ artifact = target[MavenInfo].artifact
+ if not artifact:
+ fail("\t[Error]: %s is not a maven artifact" % target.label)
+
+ if artifact != ctx.attr.expected_artifact:
+ fail(
+ "\t[Error]: %s expected artifact, %s, but was: %s" % (
+ target.label,
+ ctx.attr.expected_artifact,
+ artifact,
+ ),
+ )
+
+ all_transitive_deps = target[MavenInfo].all_transitive_deps.to_list()
+ maven_nearest_artifacts = target[MavenInfo].maven_nearest_artifacts.to_list()
+ maven_transitive_deps = target[MavenInfo].maven_transitive_deps.to_list()
+
+ expected_libs = [dep.label for dep in getattr(ctx.attr, "expected_libs", [])]
+ actual_libs = [dep for dep in all_transitive_deps if dep not in maven_transitive_deps]
+ _validate_list("artifact_target_libs", actual_libs, expected_libs)
+
+ expected_maven_deps = [dep for dep in getattr(ctx.attr, "expected_maven_deps", [])]
+ actual_maven_deps = [_strip_artifact_version(artifact) for artifact in maven_nearest_artifacts]
+ _validate_list(
+ "artifact_target_maven_deps",
+ actual_maven_deps,
+ expected_maven_deps,
+ ctx.attr.banned_maven_deps,
+ )
+
+def _validate_list(name, actual_list, expected_list, banned_list = []):
+ missing = sorted(['"{}",'.format(x) for x in actual_list if x not in expected_list])
+ if missing:
+ fail("\t[Error]: Found missing {}: \n\t\t".format(name) + "\n\t\t".join(missing))
+
+ extra = sorted(['"{}",'.format(x) for x in expected_list if x not in actual_list])
+ if extra:
+ fail("\t[Error]: Found extra {}: \n\t\t".format(name) + "\n\t\t".join(extra))
+
+ banned = sorted(['"{}",'.format(x) for x in actual_list if x in banned_list])
+ if banned:
+ fail("\t[Error]: Found banned {}: \n\t\t".format(name) + "\n\t\t".join(banned))
+
+def _strip_artifact_version(artifact):
+ return artifact.rsplit(":", 1)[0]
+
+_validate_maven_deps = rule(
+ implementation = _validate_maven_deps_impl,
+ attrs = {
+ "target": attr.label(
+ doc = "The target to generate a maven artifact for.",
+ aspects = [collect_maven_info],
+ mandatory = True,
+ ),
+ "expected_artifact": attr.string(
+ doc = "The artifact name of the target.",
+ mandatory = True,
+ ),
+ "expected_libs": attr.label_list(
+ doc = "The set of transitive libraries of the target, if any.",
+ ),
+ "expected_maven_deps": attr.string_list(
+ doc = "The required maven dependencies of the target, if any.",
+ ),
+ "banned_maven_deps": attr.string_list(
+ doc = "The required maven dependencies of the target, if any.",
+ ),
+ },
+)
+
+def _package_android_library_impl(ctx):
+ """A very, very simple Android Library (aar) packaging rule.
+
+ This rule only support packaging simple android libraries. No resources
+ support, assets, extra libs, nor jni. This rule is needed because
+ there is no 'JarJar equivalent' for AARs and some of our artifacts are
+ composed of sources spread across multiple android_library targets.
+
+ See: https://developer.android.com/studio/projects/android-library.html#aar-contents
+ """
+ inputs = [ctx.file.manifest, ctx.file.classesJar]
+ if ctx.file.lintJar:
+ inputs.append(ctx.file.lintJar)
+ if ctx.file.proguardSpec:
+ inputs.append(ctx.file.proguardSpec)
+
+ ctx.actions.run_shell(
+ inputs = inputs,
+ outputs = [ctx.outputs.aar],
+ command = """
+ TMPDIR="$(mktemp -d)"
+ cp {manifest} $TMPDIR/AndroidManifest.xml
+ cp {classesJar} $TMPDIR/classes.jar
+ if [[ -a {lintJar} ]]; then
+ cp {lintJar} $TMPDIR/lint.jar
+ fi
+ if [[ -a {proguardSpec} ]]; then
+ cp {proguardSpec} $TMPDIR/proguard.txt
+ fi
+ touch $TMPDIR/R.txt
+ zip -j {outputFile} $TMPDIR/*
+ """.format(
+ manifest = ctx.file.manifest.path,
+ classesJar = ctx.file.classesJar.path,
+ lintJar = ctx.file.lintJar.path if ctx.file.lintJar else "none",
+ proguardSpec = ctx.file.proguardSpec.path if ctx.file.proguardSpec else "none",
+ outputFile = ctx.outputs.aar.path,
+ ),
+ )
+
+_package_android_library = rule(
+ implementation = _package_android_library_impl,
+ attrs = {
+ "manifest": attr.label(
+ doc = "The AndroidManifest.xml file.",
+ allow_single_file = True,
+ mandatory = True,
+ ),
+ "classesJar": attr.label(
+ doc = "The classes.jar file.",
+ allow_single_file = True,
+ mandatory = True,
+ ),
+ "lintJar": attr.label(
+ doc = "The lint.jar file.",
+ allow_single_file = True,
+ mandatory = False,
+ ),
+ "proguardSpec": attr.label(
+ doc = "The proguard.txt file.",
+ allow_single_file = True,
+ mandatory = False,
+ ),
+ },
+ outputs = {
+ "aar": "%{name}.aar",
+ },
+)
diff --git a/tools/maven_info.bzl b/tools/maven_info.bzl
new file mode 100644
index 0000000..5ebed3f
--- /dev/null
+++ b/tools/maven_info.bzl
@@ -0,0 +1,243 @@
+# Copyright (C) 2019 The Dagger Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Skylark rules to collect Maven artifacts information.
+"""
+
+load("@bazel_skylib//lib:unittest.bzl", "asserts", "unittest")
+
+# TODO(b/142057516): Unfork this file once we've settled on a more general API.
+MavenInfo = provider(
+ fields = {
+ "artifact": """
+ The Maven coordinate for the artifact that is exported by this target, if one exists.
+ """,
+ "has_srcs": """
+ True if this library contains srcs..
+ """,
+ "all_transitive_deps": """
+ All transitive deps of the target with srcs.
+ """,
+ "maven_nearest_artifacts": """
+ The nearest maven deps of the target.
+ """,
+ "maven_transitive_deps": """
+ All transitive deps that are included in some maven dependency.
+ """,
+ },
+)
+
+_EMPTY_MAVEN_INFO = MavenInfo(
+ artifact = None,
+ has_srcs = False,
+ maven_nearest_artifacts = depset(),
+ maven_transitive_deps = depset(),
+ all_transitive_deps = depset(),
+)
+
+_MAVEN_COORDINATES_PREFIX = "maven_coordinates="
+
+def _collect_maven_info_impl(target, ctx):
+ tags = getattr(ctx.rule.attr, "tags", [])
+ srcs = getattr(ctx.rule.attr, "srcs", [])
+ deps = getattr(ctx.rule.attr, "deps", [])
+ exports = getattr(ctx.rule.attr, "exports", [])
+
+ artifact = None
+ for tag in tags:
+ if tag in ("maven:compile_only", "maven:shaded"):
+ return [_EMPTY_MAVEN_INFO]
+ if tag.startswith(_MAVEN_COORDINATES_PREFIX):
+ artifact = tag[len(_MAVEN_COORDINATES_PREFIX):]
+
+ all_deps = [dep.label for dep in (deps + exports) if dep[MavenInfo].has_srcs]
+ all_transitive_deps = [dep[MavenInfo].all_transitive_deps for dep in (deps + exports)]
+
+ maven_artifacts = []
+ maven_nearest_artifacts = []
+ maven_deps = []
+ maven_transitive_deps = []
+ for dep in (deps + exports):
+ # If the dep is itself a maven artifact, add it and all of its transitive deps.
+ # Otherwise, just propagate its transitive maven deps.
+ if dep[MavenInfo].artifact or dep[MavenInfo] == _EMPTY_MAVEN_INFO:
+ if (dep[MavenInfo].artifact):
+ maven_artifacts.append(dep[MavenInfo].artifact)
+ maven_deps.append(dep.label)
+ maven_transitive_deps.append(dep[MavenInfo].all_transitive_deps)
+ else:
+ maven_nearest_artifacts.append(dep[MavenInfo].maven_nearest_artifacts)
+ maven_transitive_deps.append(dep[MavenInfo].maven_transitive_deps)
+
+ return [MavenInfo(
+ artifact = artifact,
+ has_srcs = len(srcs) > 0,
+ maven_nearest_artifacts = depset(maven_artifacts, transitive = maven_nearest_artifacts),
+ maven_transitive_deps = depset(maven_deps, transitive = maven_transitive_deps),
+ all_transitive_deps = depset(all_deps, transitive = all_transitive_deps),
+ )]
+
+collect_maven_info = aspect(
+ attr_aspects = [
+ "deps",
+ "exports",
+ ],
+ doc = """
+ Collects the Maven information for targets, their dependencies, and their transitive exports.
+ """,
+ implementation = _collect_maven_info_impl,
+)
+
+def _fake_java_library(name, deps = None, exports = None, is_artifact = True):
+ src_file = ["%s.java" % name]
+ native.genrule(
+ name = "%s_source_file" % name,
+ outs = src_file,
+ cmd = "echo 'package pkg; class %s {}' > $@" % name,
+ )
+ native.java_library(
+ name = name,
+ srcs = src_file,
+ tags = ["maven_coordinates=%s:_:_" % name] if is_artifact else [],
+ deps = deps or [],
+ exports = exports or [],
+ )
+
+def _maven_info_test_impl(ctx):
+ env = unittest.begin(ctx)
+ asserts.equals(
+ env,
+ expected = ctx.attr.artifact if ctx.attr.artifact else None,
+ actual = ctx.attr.target[MavenInfo].artifact,
+ msg = "MavenInfo.artifact",
+ )
+ asserts.equals(
+ env,
+ expected = sorted([ctx.label.relative(dep) for dep in ctx.attr.maven_transitive_deps]),
+ actual = sorted(ctx.attr.target[MavenInfo].maven_transitive_deps.to_list()),
+ msg = "MavenInfo.maven_transitive_deps",
+ )
+ asserts.equals(
+ env,
+ expected = sorted([ctx.label.relative(dep) for dep in ctx.attr.all_transitive_deps]),
+ actual = sorted(ctx.attr.target[MavenInfo].all_transitive_deps.to_list()),
+ msg = "MavenInfo.all_transitive_deps",
+ )
+ return unittest.end(env)
+
+_maven_info_test = unittest.make(
+ _maven_info_test_impl,
+ attrs = {
+ "target": attr.label(aspects = [collect_maven_info]),
+ "artifact": attr.string(),
+ "maven_transitive_deps": attr.string_list(),
+ "all_transitive_deps": attr.string_list(),
+ },
+)
+
+def maven_info_tests():
+ """Tests for `pom_file` and `MavenInfo`.
+ """
+ _fake_java_library(name = "A")
+ _fake_java_library(
+ name = "DepOnA",
+ deps = [":A"],
+ )
+
+ _maven_info_test(
+ name = "a_test",
+ target = ":A",
+ artifact = "A:_:_",
+ maven_transitive_deps = [],
+ all_transitive_deps = [],
+ )
+
+ _maven_info_test(
+ name = "dependencies_test",
+ target = ":DepOnA",
+ artifact = "DepOnA:_:_",
+ maven_transitive_deps = [":A"],
+ all_transitive_deps = [":A"],
+ )
+
+ _fake_java_library(
+ name = "ExportsA",
+ exports = [":A"],
+ )
+
+ _maven_info_test(
+ name = "exports_test",
+ target = ":ExportsA",
+ artifact = "ExportsA:_:_",
+ maven_transitive_deps = [":A"],
+ all_transitive_deps = [":A"],
+ )
+
+ _fake_java_library(
+ name = "TransitiveExports",
+ exports = [":ExportsA"],
+ )
+
+ _maven_info_test(
+ name = "transitive_exports_test",
+ target = ":TransitiveExports",
+ artifact = "TransitiveExports:_:_",
+ maven_transitive_deps = [":ExportsA", ":A"],
+ all_transitive_deps = [":ExportsA", ":A"],
+ )
+
+ _fake_java_library(
+ name = "TransitiveDeps",
+ deps = [":ExportsA"],
+ )
+
+ _maven_info_test(
+ name = "transitive_deps_test",
+ target = ":TransitiveDeps",
+ artifact = "TransitiveDeps:_:_",
+ maven_transitive_deps = [":ExportsA", ":A"],
+ all_transitive_deps = [":ExportsA", ":A"],
+ )
+
+ _fake_java_library(name = "Node1", is_artifact = False)
+ _maven_info_test(
+ name = "test_node1",
+ target = ":Node1",
+ maven_transitive_deps = [],
+ all_transitive_deps = [],
+ )
+
+ _fake_java_library(name = "Node2_Artifact", deps = [":Node1"])
+ _maven_info_test(
+ name = "test_node2",
+ target = ":Node2_Artifact",
+ artifact = "Node2_Artifact:_:_",
+ maven_transitive_deps = [],
+ all_transitive_deps = [":Node1"],
+ )
+
+ _fake_java_library(name = "Node3", deps = [":Node2_Artifact"], is_artifact = False)
+ _maven_info_test(
+ name = "test_node3",
+ target = ":Node3",
+ maven_transitive_deps = [":Node1", ":Node2_Artifact"],
+ all_transitive_deps = [":Node1", ":Node2_Artifact"],
+ )
+
+ _fake_java_library(name = "Node4", deps = [":Node3"], is_artifact = False)
+ _maven_info_test(
+ name = "test_node4",
+ target = ":Node4",
+ maven_transitive_deps = [":Node1", ":Node2_Artifact"],
+ all_transitive_deps = [":Node1", ":Node2_Artifact", ":Node3"],
+ )
diff --git a/tools/pom-template.xml b/tools/pom-template.xml
index 39ed62d..68b6ac0 100644
--- a/tools/pom-template.xml
+++ b/tools/pom-template.xml
@@ -16,7 +16,6 @@
-->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
-
<parent>
<groupId>org.sonatype.oss</groupId>
<artifactId>oss-parent</artifactId>
@@ -32,7 +31,7 @@
<packaging>{packaging}</packaging>
<scm>
- <url>http://github.com/google/dagger/</url>
+ <url>https://github.com/google/dagger/</url>
<connection>scm:git:git://github.com/google/dagger.git</connection>
<developerConnection>scm:git:ssh://git@github.com/google/dagger.git</developerConnection>
<tag>HEAD</tag>
@@ -40,22 +39,21 @@
<issueManagement>
<system>GitHub Issues</system>
- <url>http://github.com/google/dagger/issues</url>
+ <url>https://github.com/google/dagger/issues</url>
</issueManagement>
<licenses>
<license>
<name>Apache 2.0</name>
- <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
+ <url>https://www.apache.org/licenses/LICENSE-2.0.txt</url>
</license>
</licenses>
<organization>
<name>Google, Inc.</name>
- <url>http://www.google.com</url>
+ <url>https://www.google.com</url>
</organization>
-
<dependencies>
-{generated_bzl_deps}
+ {generated_bzl_deps}
</dependencies>
</project>
diff --git a/util/deploy-dagger.sh b/util/deploy-dagger.sh
new file mode 100755
index 0000000..ddf4926
--- /dev/null
+++ b/util/deploy-dagger.sh
@@ -0,0 +1,127 @@
+#!/bin/bash
+
+set -eu
+
+readonly MVN_GOAL="$1"
+readonly VERSION_NAME="$2"
+shift 2
+readonly EXTRA_MAVEN_ARGS=("$@")
+
+# Builds and deploys the given artifacts to a configured maven goal.
+# @param {string} library the library to deploy.
+# @param {string} pomfile the pom file to deploy.
+# @param {string} srcjar the sources jar of the library. This is an optional
+# parameter, if provided then javadoc must also be provided.
+# @param {string} javadoc the java doc jar of the library. This is an optional
+# parameter, if provided then srcjar must also be provided.
+_deploy() {
+ local library=$1
+ local pomfile=$2
+ local srcjar=$3
+ local javadoc=$4
+ bash $(dirname $0)/deploy-library.sh \
+ "$library" \
+ "$pomfile" \
+ "$srcjar" \
+ "$javadoc" \
+ "$MVN_GOAL" \
+ "$VERSION_NAME" \
+ "${EXTRA_MAVEN_ARGS[@]:+${EXTRA_MAVEN_ARGS[@]}}"
+}
+
+_deploy \
+ java/dagger/libcore.jar \
+ java/dagger/pom.xml \
+ java/dagger/libcore-src.jar \
+ java/dagger/core-javadoc.jar
+
+_deploy \
+ gwt/libgwt.jar \
+ gwt/pom.xml \
+ gwt/libgwt.jar \
+ gwt/libgwt.jar
+
+_deploy \
+ java/dagger/internal/codegen/artifact.jar \
+ java/dagger/internal/codegen/pom.xml \
+ java/dagger/internal/codegen/artifact-src.jar \
+ java/dagger/internal/codegen/artifact-javadoc.jar
+
+_deploy \
+ java/dagger/producers/artifact.jar \
+ java/dagger/producers/pom.xml \
+ java/dagger/producers/artifact-src.jar \
+ java/dagger/producers/artifact-javadoc.jar
+
+_deploy \
+ java/dagger/spi/artifact.jar \
+ java/dagger/spi/pom.xml \
+ java/dagger/spi/artifact-src.jar \
+ java/dagger/spi/artifact-javadoc.jar
+
+_deploy \
+ java/dagger/android/android.aar \
+ java/dagger/android/pom.xml \
+ java/dagger/android/libandroid-src.jar \
+ java/dagger/android/android-javadoc.jar
+
+_deploy \
+ java/dagger/android/android-legacy.aar \
+ java/dagger/android/legacy-pom.xml \
+ "" \
+ ""
+
+# b/37741866 and https://github.com/google/dagger/issues/715
+_deploy \
+ java/dagger/android/libandroid.jar \
+ java/dagger/android/jarimpl-pom.xml \
+ java/dagger/android/libandroid-src.jar \
+ java/dagger/android/android-javadoc.jar
+
+_deploy \
+ java/dagger/android/support/support.aar \
+ java/dagger/android/support/pom.xml \
+ java/dagger/android/support/libsupport-src.jar \
+ java/dagger/android/support/support-javadoc.jar
+
+_deploy \
+ java/dagger/android/support/support-legacy.aar \
+ java/dagger/android/support/legacy-pom.xml \
+ "" \
+ ""
+
+_deploy \
+ shaded_android_processor.jar \
+ java/dagger/android/processor/pom.xml \
+ java/dagger/android/processor/libprocessor-src.jar \
+ java/dagger/android/processor/processor-javadoc.jar
+
+_deploy \
+ java/dagger/grpc/server/libserver.jar \
+ java/dagger/grpc/server/server-pom.xml \
+ java/dagger/grpc/server/libserver-src.jar \
+ java/dagger/grpc/server/javadoc.jar
+
+_deploy \
+ java/dagger/grpc/server/libannotations.jar \
+ java/dagger/grpc/server/annotations-pom.xml \
+ java/dagger/grpc/server/libannotations-src.jar \
+ java/dagger/grpc/server/javadoc.jar
+
+_deploy \
+ shaded_grpc_server_processor.jar \
+ java/dagger/grpc/server/processor/pom.xml \
+ java/dagger/grpc/server/processor/libprocessor-src.jar \
+ java/dagger/grpc/server/processor/javadoc.jar
+
+_deploy \
+ java/dagger/lint/lint-artifact.jar \
+ java/dagger/lint/lint-pom.xml \
+ java/dagger/lint/lint-artifact-src.jar \
+ java/dagger/lint/lint-artifact-javadoc.jar
+
+_deploy \
+ java/dagger/lint/lint-android-artifact.aar \
+ java/dagger/lint/lint-android-pom.xml \
+ "" \
+ ""
diff --git a/util/deploy-hilt.sh b/util/deploy-hilt.sh
new file mode 100755
index 0000000..3c25c10
--- /dev/null
+++ b/util/deploy-hilt.sh
@@ -0,0 +1,88 @@
+#!/bin/bash
+
+set -eu
+
+readonly MVN_GOAL="$1"
+readonly VERSION_NAME="$2"
+shift 2
+readonly EXTRA_MAVEN_ARGS=("$@")
+
+# Builds and deploys the given artifacts to a configured maven goal.
+# @param {string} library the library to deploy.
+# @param {string} pomfile the pom file to deploy.
+# @param {string} srcjar the sources jar of the library. This is an optional
+# parameter, if provided then javadoc must also be provided.
+# @param {string} javadoc the java doc jar of the library. This is an optional
+# parameter, if provided then srcjar must also be provided.
+_deploy() {
+ local library=$1
+ local pomfile=$2
+ local srcjar=$3
+ local javadoc=$4
+ bash $(dirname $0)/deploy-library.sh \
+ "$library" \
+ "$pomfile" \
+ "$srcjar" \
+ "$javadoc" \
+ "$MVN_GOAL" \
+ "$VERSION_NAME" \
+ "${EXTRA_MAVEN_ARGS[@]:+${EXTRA_MAVEN_ARGS[@]}}"
+}
+
+_deploy \
+ java/dagger/hilt/android/artifact.aar \
+ java/dagger/hilt/android/pom.xml \
+ java/dagger/hilt/android/artifact-src.jar \
+ java/dagger/hilt/android/artifact-javadoc.jar
+
+_deploy \
+ java/dagger/hilt/android/testing/artifact.aar \
+ java/dagger/hilt/android/testing/pom.xml \
+ java/dagger/hilt/android/testing/artifact-src.jar \
+ java/dagger/hilt/android/testing/artifact-javadoc.jar
+
+_deploy \
+ java/dagger/hilt/processor/artifact.jar \
+ java/dagger/hilt/processor/pom.xml \
+ java/dagger/hilt/processor/artifact-src.jar \
+ java/dagger/hilt/processor/artifact-javadoc.jar
+
+_deploy \
+ java/dagger/hilt/android/processor/artifact.jar \
+ java/dagger/hilt/android/processor/pom.xml \
+ java/dagger/hilt/android/processor/artifact-src.jar \
+ java/dagger/hilt/android/processor/artifact-javadoc.jar
+
+_deploy \
+ java/dagger/hilt/artifact-core.jar \
+ java/dagger/hilt/pom.xml \
+ java/dagger/hilt/artifact-core-src.jar \
+ java/dagger/hilt/artifact-core-javadoc.jar
+
+# Builds and deploy the Gradle plugin.
+_deploy_plugin() {
+ local plugindir=java/dagger/hilt/android/plugin
+ ./$plugindir/gradlew -p $plugindir --no-daemon clean \
+ publishAllPublicationsToMavenRepository -PPublishVersion="$VERSION_NAME"
+ local outdir=$plugindir/build/repo/com/google/dagger/hilt-android-gradle-plugin/$VERSION_NAME
+ # When building '-SNAPSHOT' versions in gradle, the filenames replaces
+ # '-SNAPSHOT' with timestamps, so we need to disambiguate by finding each file
+ # to deploy. See: https://stackoverflow.com/questions/54182823/
+ local suffix
+ if [[ "$VERSION_NAME" == *"-SNAPSHOT" ]]; then
+ # Gets the timestamp part out of the name to be used as suffix.
+ # Timestamp format is ########.######-#.
+ suffix=$(find $outdir -name "*.pom" | grep -Eo '[0-9]{8}\.[0-9]{6}-[0-9]{1}')
+ else
+ suffix=$VERSION_NAME
+ fi
+ mvn "$MVN_GOAL" \
+ -Dfile="$(find $outdir -name "*-$suffix.jar")" \
+ -DpomFile="$(find $outdir -name "*-$suffix.pom")" \
+ -Dsources="$(find $outdir -name "*-$suffix-sources.jar")" \
+ -Djavadoc="$(find $outdir -name "*-$suffix-javadoc.jar")" \
+ "${EXTRA_MAVEN_ARGS[@]:+${EXTRA_MAVEN_ARGS[@]}}"
+}
+
+# Gradle Plugin is built with Gradle, but still deployed via Maven (mvn)
+_deploy_plugin
diff --git a/util/deploy-library.sh b/util/deploy-library.sh
new file mode 100755
index 0000000..a744402
--- /dev/null
+++ b/util/deploy-library.sh
@@ -0,0 +1,92 @@
+#!/bin/bash
+
+set -eu
+
+# Builds and deploys the given artifacts to a configured maven goal.
+# @param {string} library the library to deploy.
+# @param {string} pomfile the pom file to deploy.
+# @param {string} srcjar the sources jar of the library. This is an optional
+# parameter, if provided then javadoc must also be provided.
+# @param {string} javadoc the java doc jar of the library. This is an optional
+# parameter, if provided then srcjar must also be provided.
+deploy_library() {
+ local library=$1
+ local pomfile=$2
+ local srcjar=$3
+ local javadoc=$4
+ local mvn_goal=$5
+ local version_name=$6
+ shift 6
+ local extra_maven_args=("$@")
+
+ bazel build --define=pom_version="$version_name" \
+ $library $pomfile
+
+ # TODO(bcorso): Consider moving this into the "gen_maven_artifact" macro, this
+ # requires having the version checked-in for the build system.
+ add_tracking_version \
+ $(bazel_output_file $library) \
+ $(bazel_output_file $pomfile) \
+ $version_name
+
+ if [ -n "$srcjar" ] && [ -n "$javadoc" ] ; then
+ bazel build --define=pom_version="$version_name" \
+ $srcjar $javadoc
+ mvn $mvn_goal \
+ -Dfile=$(bazel_output_file $library) \
+ -Djavadoc=$(bazel_output_file $javadoc) \
+ -DpomFile=$(bazel_output_file $pomfile) \
+ -Dsources=$(bazel_output_file $srcjar) \
+ "${extra_maven_args[@]:+${extra_maven_args[@]}}"
+ else
+ mvn $mvn_goal \
+ -Dfile=$(bazel_output_file $library) \
+ -DpomFile=$(bazel_output_file $pomfile) \
+ "${extra_maven_args[@]:+${extra_maven_args[@]}}"
+ fi
+}
+
+bazel_output_file() {
+ local library=$1
+ local output_file=bazel-bin/$library
+ if [[ ! -e $output_file ]]; then
+ output_file=bazel-genfiles/$library
+ fi
+ if [[ ! -e $output_file ]]; then
+ echo "Could not find bazel output file for $library"
+ exit 1
+ fi
+ echo -n $output_file
+}
+
+add_tracking_version() {
+ local library=$1
+ local pomfile=$2
+ local version_name=$3
+ local group_id=$(find_pom_value $pomfile "groupId")
+ local artifact_id=$(find_pom_value $pomfile "artifactId")
+ local temp_dir=$(mktemp -d)
+ local version_file="META-INF/${group_id}_${artifact_id}.version"
+ mkdir -p "$temp_dir/META-INF/"
+ echo $version_name >> "$temp_dir/$version_file"
+ if [[ $library =~ \.jar$ ]]; then
+ jar uf $library -C $temp_dir $version_file
+ elif [[ $library =~ \.aar$ ]]; then
+ unzip $library classes.jar -d $temp_dir
+ jar uf $temp_dir/classes.jar -C $temp_dir $version_file
+ jar uf $library -C $temp_dir classes.jar
+ else
+ echo "Could not add tracking version file to $library"
+ exit 1
+ fi
+}
+
+find_pom_value() {
+ local pomfile=$1
+ local attribute=$2
+ # Using Python here because `mvn help:evaluate` doesn't work with our gen pom
+ # files since they don't include the aar packaging plugin.
+ python $(dirname $0)/find_pom_value.py $pomfile $attribute
+}
+
+deploy_library "$@"
diff --git a/util/deploy-to-maven-central.sh b/util/deploy-to-maven-central.sh
index 1f721a1..de2b49c 100755
--- a/util/deploy-to-maven-central.sh
+++ b/util/deploy-to-maven-central.sh
@@ -6,50 +6,69 @@
echo "usage $0 <ssl-key> <version-name> [<param> ...]"
exit 1;
fi
-key=$1
-version_name=$2
+readonly KEY=$1
+readonly VERSION_NAME=$2
shift 2
-if [[ ! "$version_name" =~ ^2\. ]]; then
+if [[ ! "$VERSION_NAME" =~ ^2\. ]]; then
echo 'Version name must begin with "2."'
exit 2
fi
-if [[ "$version_name" =~ " " ]]; then
+if [[ "$VERSION_NAME" =~ " " ]]; then
echo "Version name must not have any spaces"
exit 3
fi
-bazel test //...
+bash $(dirname $0)/run-local-tests.sh
-bash $(dirname $0)/execute-deploy.sh \
+# Note: we detach from head before making any sed changes to avoid commiting
+# a particular version to master. This sed change used to be done at the very
+# end of the script, but with the introduction of "-alpha" to the Hilt
+# artifacts, we need to do the sed replacement before deploying the artifacts to
+# maven. Note, that this sed replacement is only done for versioned releases.
+# HEAD-SNAPSHOT and LOCAL_SNAPSHOT versions of Hilt artifacts do not contain
+# "-alpha".
+git checkout --detach
+
+# Set the version string that is used as a tag in all of our libraries. If
+# another repo depends on a versioned tag of Dagger, their java_library.tags
+# should match the versioned release.
+sed -i s/'#ALPHA_POSTFIX'/'+ "-alpha"'/g build_defs.bzl
+sed -i s/'${project.version}'/"${VERSION_NAME}"/g build_defs.bzl
+
+bash $(dirname $0)/deploy-dagger.sh \
"gpg:sign-and-deploy-file" \
- "$version_name" \
+ "$VERSION_NAME" \
"-DrepositoryId=sonatype-nexus-staging" \
"-Durl=https://oss.sonatype.org/service/local/staging/deploy/maven2/" \
- "-Dgpg.keyname=${key}"
+ "-Dgpg.keyname=${KEY}"
+
+bash $(dirname $0)/deploy-hilt.sh \
+ "gpg:sign-and-deploy-file" \
+ "${VERSION_NAME}-alpha" \
+ "-DrepositoryId=sonatype-nexus-staging" \
+ "-Durl=https://oss.sonatype.org/service/local/staging/deploy/maven2/" \
+ "-Dgpg.keyname=${KEY}"
+
+# Note: We avoid commiting until after deploying in case deploying fails and
+# we need to run the script again.
+git commit -m "${VERSION_NAME} release" build_defs.bzl
+git tag -a -m "Dagger ${VERSION_NAME}" dagger-"${VERSION_NAME}"
+git push origin tag dagger-"${VERSION_NAME}"
+
+# Switch back to the original HEAD
+git checkout -
# Publish javadocs to gh-pages
bazel build //:user-docs.jar
git clone --quiet --branch gh-pages \
https://github.com/google/dagger gh-pages > /dev/null
cd gh-pages
-unzip ../bazel-bin/user-docs.jar -d api/$version_name
-rm -rf api/$version_name/META-INF/
-git add api/$version_name
-git commit -m "$version_name docs"
+unzip ../bazel-bin/user-docs.jar -d api/$VERSION_NAME
+rm -rf api/$VERSION_NAME/META-INF/
+git add api/$VERSION_NAME
+git commit -m "$VERSION_NAME docs"
git push origin gh-pages
cd ..
rm -rf gh-pages
-
-git checkout --detach
-# Set the version string that is used as a tag in all of our libraries. If another repo depends on
-# a versioned tag of Dagger, their java_library.tags should match the versioned release.
-sed -i s/'${project.version}'/"${version_name}"/g tools/maven.bzl
-git commit -m "${version_name} release" tools/maven.bzl
-
-git tag -a -m "Dagger ${version_name}" dagger-"${version_name}"
-git push origin tag dagger-"${version_name}"
-
-# Switch back to the original HEAD
-git checkout -
diff --git a/util/execute-deploy.sh b/util/execute-deploy.sh
deleted file mode 100755
index 1153468..0000000
--- a/util/execute-deploy.sh
+++ /dev/null
@@ -1,110 +0,0 @@
-#!/bin/bash
-
-set -eu
-
-readonly MVN_GOAL="$1"
-readonly VERSION_NAME="$2"
-shift 2
-readonly EXTRA_MAVEN_ARGS=("$@")
-
-bazel_output_file() {
- local library=$1
- local output_file=bazel-bin/$library
- if [[ ! -e $output_file ]]; then
- output_file=bazel-genfiles/$library
- fi
- if [[ ! -e $output_file ]]; then
- echo "Could not find bazel output file for $library"
- exit 1
- fi
- echo -n $output_file
-}
-
-deploy_library() {
- local library=$1
- local srcjar=$2
- local javadoc=$3
- local pomfile=$4
- bazel build --define=pom_version="$VERSION_NAME" \
- $library $srcjar $javadoc $pomfile
-
- mvn $MVN_GOAL \
- -Dfile=$(bazel_output_file $library) \
- -Djavadoc=$(bazel_output_file $javadoc) \
- -DpomFile=$(bazel_output_file $pomfile) \
- -Dsources=$(bazel_output_file $srcjar) \
- "${EXTRA_MAVEN_ARGS[@]:+${EXTRA_MAVEN_ARGS[@]}}"
-}
-
-deploy_library \
- java/dagger/libcore.jar \
- java/dagger/libcore-src.jar \
- java/dagger/core-javadoc.jar \
- java/dagger/pom.xml
-
-deploy_library \
- gwt/libgwt.jar \
- gwt/libgwt.jar \
- gwt/libgwt.jar \
- gwt/pom.xml
-
-deploy_library \
- shaded_compiler.jar \
- shaded_compiler_src.jar \
- java/dagger/internal/codegen/codegen-javadoc.jar \
- java/dagger/internal/codegen/pom.xml
-
-deploy_library \
- java/dagger/producers/libproducers.jar \
- java/dagger/producers/libproducers-src.jar \
- java/dagger/producers/producers-javadoc.jar \
- java/dagger/producers/pom.xml
-
-deploy_library \
- shaded_spi.jar \
- shaded_spi_src.jar \
- spi-javadoc.jar \
- java/dagger/spi/pom.xml
-
-deploy_library \
- java/dagger/android/android.aar \
- java/dagger/android/libandroid-src.jar \
- java/dagger/android/android-javadoc.jar \
- java/dagger/android/pom.xml
-
-# b/37741866 and https://github.com/google/dagger/issues/715
-deploy_library \
- java/dagger/android/libandroid.jar \
- java/dagger/android/libandroid-src.jar \
- java/dagger/android/android-javadoc.jar \
- java/dagger/android/jarimpl-pom.xml
-
-deploy_library \
- java/dagger/android/support/support.aar \
- java/dagger/android/support/libsupport-src.jar \
- java/dagger/android/support/support-javadoc.jar \
- java/dagger/android/support/pom.xml
-
-deploy_library \
- shaded_android_processor.jar \
- java/dagger/android/processor/libprocessor-src.jar \
- java/dagger/android/processor/processor-javadoc.jar \
- java/dagger/android/processor/pom.xml
-
-deploy_library \
- java/dagger/grpc/server/libserver.jar \
- java/dagger/grpc/server/libserver-src.jar \
- java/dagger/grpc/server/javadoc.jar \
- java/dagger/grpc/server/server-pom.xml
-
-deploy_library \
- java/dagger/grpc/server/libannotations.jar \
- java/dagger/grpc/server/libannotations-src.jar \
- java/dagger/grpc/server/javadoc.jar \
- java/dagger/grpc/server/annotations-pom.xml
-
-deploy_library \
- shaded_grpc_server_processor.jar \
- java/dagger/grpc/server/processor/libprocessor-src.jar \
- java/dagger/grpc/server/processor/javadoc.jar \
- java/dagger/grpc/server/processor/pom.xml
diff --git a/util/find_pom_value.py b/util/find_pom_value.py
new file mode 100644
index 0000000..c662b0e
--- /dev/null
+++ b/util/find_pom_value.py
@@ -0,0 +1,19 @@
+"""Find value of a Maven pom attribute given a pom file.
+
+ Usage:
+ python find_pom_value.py <pom-file> <pom-attribute>
+"""
+import sys
+import xml.etree.ElementTree as Xml
+
+
+def main(argv):
+ pom_file = argv[1]
+ pom_attribute = argv[2]
+ print(
+ Xml.ElementTree(file=pom_file).findtext(
+ "{http://maven.apache.org/POM/4.0.0}%s" % pom_attribute))
+
+
+if __name__ == "__main__":
+ main(sys.argv)
diff --git a/util/generate-latest-docs.sh b/util/generate-latest-docs.sh
index 8e9304c..c5f71fd 100755
--- a/util/generate-latest-docs.sh
+++ b/util/generate-latest-docs.sh
@@ -1,30 +1,35 @@
-# see http://benlimmer.com/2013/12/26/automatically-publish-javadoc-to-gh-pages-with-travis-ci/ for details
+set -eux
-set -eu
-
-if [ "$TRAVIS_REPO_SLUG" == "google/dagger" ] && \
- [ "$TRAVIS_JDK_VERSION" == "$JDK_FOR_PUBLISHING" ] && \
- [ "$TRAVIS_PULL_REQUEST" == "false" ] && \
- [ "$TRAVIS_BRANCH" == "master" ]; then
+if [ "$GITHUB_REPOSITORY" == "google/dagger" ] && \
+ [ "$GITHUB_EVENT_NAME" == "push" ] && \
+ [ "$GITHUB_REF" == "refs/heads/master" ]; then
echo -e "Publishing javadoc...\n"
bazel build //:user-docs.jar
JAVADOC_JAR="$(pwd)/bazel-bin/user-docs.jar"
cd $HOME
- git clone --quiet --branch=gh-pages https://${GH_TOKEN}@github.com/google/dagger gh-pages > /dev/null
+ git clone --quiet --branch=gh-pages https://x-access-token:${GH_TOKEN}@github.com/google/dagger gh-pages > /dev/null
cd gh-pages
- git config --global user.email "travis@travis-ci.org"
- git config --global user.name "travis-ci"
+ git config --global user.email "dagger-dev+github@google.com"
+ git config --global user.name "Dagger Team"
git rm -rf api/latest
mkdir -p api
unzip "$JAVADOC_JAR" -d api/latest
rm -rf api/latest/META-INF/
git add -f api/latest
- git commit -m "Latest javadoc on successful travis build $TRAVIS_BUILD_NUMBER auto-pushed to gh-pages"
- git push -fq origin gh-pages > /dev/null
- echo -e "Published Javadoc to gh-pages.\n"
+ # Check if there are any changes before committing, otherwise attempting
+ # to commit will fail the build (https://stackoverflow.com/a/2659808).
+ if [[ $(git diff-index --quiet HEAD --) || $? == 1 ]]; then
+ # The exist status is 1, meaning there are changes to commit
+ git commit -m "Latest javadoc on successful Github build $GITHUB_WORKFLOW/$GITHUB_RUN_ID auto-pushed to gh-pages"
+ git push -fq origin gh-pages > /dev/null
+ echo -e "Published Javadoc to gh-pages.\n"
+ else
+ # The exist status is 0, meaning there are no changes to commit
+ echo -e "Skipping publishing docs since no changes were detected."
+ fi
else
- echo -e "Not publishing docs for jdk=${TRAVIS_JDK_VERSION} and branch=${TRAVIS_BRANCH}"
+ echo -e "Not publishing docs for branch=${$GITHUB_REF}"
fi
diff --git a/util/install-local-snapshot.sh b/util/install-local-snapshot.sh
index 8f77a41..be6030c 100755
--- a/util/install-local-snapshot.sh
+++ b/util/install-local-snapshot.sh
@@ -4,8 +4,43 @@
echo -e "Installing maven snapshot locally...\n"
-bash $(dirname $0)/execute-deploy.sh \
+bash $(dirname $0)/deploy-dagger.sh \
+ "install:install-file" \
+ "LOCAL-SNAPSHOT"
+
+bash $(dirname $0)/deploy-hilt.sh \
"install:install-file" \
"LOCAL-SNAPSHOT"
echo -e "Installed local snapshot"
+
+verify_version_file() {
+ local m2_repo=$(mvn help:evaluate -Dexpression=settings.localRepository -q -DforceStdout)
+ local group_path=com/google/dagger
+ local artifact_id=$1
+ local type=$2
+ local version="LOCAL-SNAPSHOT"
+ local temp_dir=$(mktemp -d)
+ local content
+ if [ $type = "jar" ]; then
+ unzip $m2_repo/$group_path/$artifact_id/$version/$artifact_id-$version.jar \
+ META-INF/com.google.dagger_$artifact_id.version \
+ -d $temp_dir
+ elif [ $type = "aar" ]; then
+ unzip $m2_repo/$group_path/$artifact_id/$version/$artifact_id-$version.aar \
+ classes.jar \
+ -d $temp_dir
+ unzip $temp_dir/classes.jar \
+ META-INF/com.google.dagger_$artifact_id.version \
+ -d $temp_dir
+ fi
+ local content=$(cat $temp_dir/META-INF/com.google.dagger_${artifact_id}.version)
+ if [[ $content != $version ]]; then
+ echo "Version file failed verification for artifact: $artifact_id"
+ exit 1
+ fi
+}
+
+# Verify tracking version file in Dagger and Dagger Android
+verify_version_file "dagger" "jar"
+verify_version_file "dagger-android" "aar"
diff --git a/util/publish-snapshot-on-commit.sh b/util/publish-snapshot-on-commit.sh
index 944a2c3..63cc3ea 100755
--- a/util/publish-snapshot-on-commit.sh
+++ b/util/publish-snapshot-on-commit.sh
@@ -1,14 +1,20 @@
# see https://coderwall.com/p/9b_lfq
-set -eu
+set -eux
-if [ "$TRAVIS_REPO_SLUG" == "google/dagger" ] && \
- [ "$TRAVIS_JDK_VERSION" == "$JDK_FOR_PUBLISHING" ] && \
- [ "$TRAVIS_PULL_REQUEST" == "false" ] && \
- [ "$TRAVIS_BRANCH" == "master" ]; then
+if [ "$GITHUB_REPOSITORY" == "google/dagger" ] && \
+ [ "$GITHUB_EVENT_NAME" == "push" ] && \
+ [ "$GITHUB_REF" == "refs/heads/master" ]; then
echo -e "Publishing maven snapshot...\n"
- bash $(dirname $0)/execute-deploy.sh \
+ bash $(dirname $0)/deploy-dagger.sh \
+ "deploy:deploy-file" \
+ "HEAD-SNAPSHOT" \
+ "-DrepositoryId=sonatype-nexus-snapshots" \
+ "-Durl=https://oss.sonatype.org/content/repositories/snapshots" \
+ "--settings=$(dirname $0)/settings.xml"
+
+ bash $(dirname $0)/deploy-hilt.sh \
"deploy:deploy-file" \
"HEAD-SNAPSHOT" \
"-DrepositoryId=sonatype-nexus-snapshots" \
@@ -17,5 +23,5 @@
echo -e "Published maven snapshot"
else
- echo -e "Not publishing snapshot for jdk=${TRAVIS_JDK_VERSION} and branch=${TRAVIS_BRANCH}"
+ echo -e "Not publishing snapshot for branch=${$GITHUB_REF}"
fi
diff --git a/util/run-local-emulator-tests.sh b/util/run-local-emulator-tests.sh
new file mode 100755
index 0000000..7fc7762
--- /dev/null
+++ b/util/run-local-emulator-tests.sh
@@ -0,0 +1,18 @@
+#!/bin/bash
+
+set -ex
+
+readonly GRADLE_PROJECTS=(
+ "javatests/artifacts/hilt-android/simple"
+ "javatests/artifacts/hilt-android/simpleKotlin"
+)
+for project in "${GRADLE_PROJECTS[@]}"; do
+ echo "Running gradle Android emulator tests for $project"
+ ./$project/gradlew -p $project connectedAndroidTest --no-daemon --stacktrace
+done
+
+# Run emulator tests in a project with configuration cache enabled
+# TODO(danysantiago): Once AGP 4.2.0 is stable, remove these project and enable
+# config cache in the other test projects.
+readonly CONFIG_CACHE_PROJECT="javatests/artifacts/hilt-android/gradleConfigCache"
+./$CONFIG_CACHE_PROJECT/gradlew -p $CONFIG_CACHE_PROJECT connectedAndroidTest --no-daemon --stacktrace --configuration-cache
diff --git a/util/run-local-gradle-android-tests.sh b/util/run-local-gradle-android-tests.sh
new file mode 100755
index 0000000..ba51078
--- /dev/null
+++ b/util/run-local-gradle-android-tests.sh
@@ -0,0 +1,22 @@
+#!/bin/bash
+
+set -ex
+
+readonly AGP_VERSION_INPUT=$1
+readonly ANDROID_GRADLE_PROJECTS=(
+ "java/dagger/example/gradle/android/simple"
+ "javatests/artifacts/dagger-android/simple"
+ "javatests/artifacts/hilt-android/simple"
+ "javatests/artifacts/hilt-android/simpleKotlin"
+)
+for project in "${ANDROID_GRADLE_PROJECTS[@]}"; do
+ echo "Running gradle tests for $project with AGP $AGP_VERSION_INPUT"
+ AGP_VERSION=$AGP_VERSION_INPUT ./$project/gradlew -p $project buildDebug --no-daemon --stacktrace
+ AGP_VERSION=$AGP_VERSION_INPUT ./$project/gradlew -p $project testDebug --no-daemon --stacktrace
+done
+
+# Run gradle tests in a project with configuration cache enabled
+# TODO(danysantiago): Once AGP 4.2.0 is stable, remove these project and enable
+# config cache in the other test projects.
+readonly CONFIG_CACHE_PROJECT="javatests/artifacts/hilt-android/gradleConfigCache"
+./$CONFIG_CACHE_PROJECT/gradlew -p $CONFIG_CACHE_PROJECT assembleDebug --no-daemon --stacktrace --configuration-cache
diff --git a/util/run-local-gradle-tests.sh b/util/run-local-gradle-tests.sh
new file mode 100755
index 0000000..b88ccab
--- /dev/null
+++ b/util/run-local-gradle-tests.sh
@@ -0,0 +1,14 @@
+#!/bin/bash
+
+set -ex
+
+readonly GRADLE_PROJECTS=(
+ "java/dagger/example/gradle/simple"
+ "java/dagger/hilt/android/plugin"
+ "javatests/artifacts/dagger/simple"
+)
+for project in "${GRADLE_PROJECTS[@]}"; do
+ echo "Running gradle tests for $project"
+ ./$project/gradlew -p $project build --no-daemon --stacktrace
+ ./$project/gradlew -p $project test --no-daemon --stacktrace
+done
diff --git a/util/run-local-tests.sh b/util/run-local-tests.sh
new file mode 100755
index 0000000..ea78671
--- /dev/null
+++ b/util/run-local-tests.sh
@@ -0,0 +1,21 @@
+#!/bin/bash
+
+set -ex
+
+# These jobs should match .github/workflows/ci.yml. We can't run this script
+# directly in Github since it's too slow for a single job.
+
+# Run local bazel tests
+bazel test --test_output=errors //...
+
+# Install local maven artifacts.
+util/install-local-snapshot.sh
+
+# Run local mvn tests
+pushd examples/maven && mvn compile && popd
+
+# Run local gradle tests
+util/run-local-gradle-tests.sh
+util/run-local-gradle-android-tests.sh "4.1.0"
+util/run-local-gradle-android-tests.sh "4.2.0-beta04"
+
diff --git a/workspace_defs.bzl b/workspace_defs.bzl
new file mode 100644
index 0000000..c017b76
--- /dev/null
+++ b/workspace_defs.bzl
@@ -0,0 +1,292 @@
+# Copyright (C) 2020 The Google Bazel Common Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""A macro to configure Dagger deps within a workspace"""
+
+load("//:build_defs.bzl", "POM_VERSION", "POM_VERSION_ALPHA")
+
+_DAGGER_VERSION = POM_VERSION
+_HILT_VERSION = POM_VERSION_ALPHA
+
+DAGGER_ARTIFACTS = [
+ "com.google.dagger:dagger:" + _DAGGER_VERSION,
+ "com.google.dagger:dagger-compiler:" + _DAGGER_VERSION,
+ "com.google.dagger:dagger-producers:" + _DAGGER_VERSION,
+ "com.google.dagger:dagger-spi:" + _DAGGER_VERSION,
+]
+
+DAGGER_ANDROID_ARTIFACTS = [
+ "com.google.dagger:dagger-android-processor:" + _DAGGER_VERSION,
+ "com.google.dagger:dagger-android-support:" + _DAGGER_VERSION,
+ "com.google.dagger:dagger-android:" + _DAGGER_VERSION,
+]
+
+HILT_ANDROID_ARTIFACTS = [
+ "androidx.test:core:1.1.0", # Export for ApplicationProvider
+ "javax.annotation:jsr250-api:1.0", # Export for @Generated
+ "androidx.annotation:annotation:1.1.0", # Export for @CallSuper/@Nullable
+ "com.google.dagger:dagger:" + _DAGGER_VERSION,
+ "com.google.dagger:dagger-compiler:" + _DAGGER_VERSION,
+ "com.google.dagger:hilt-android:" + _HILT_VERSION,
+ "com.google.dagger:hilt-android-testing:" + _HILT_VERSION,
+ "com.google.dagger:hilt-android-compiler:" + _HILT_VERSION,
+]
+
+DAGGER_REPOSITORIES = [
+ "https://maven.google.com",
+ "https://repo1.maven.org/maven2",
+]
+
+DAGGER_ANDROID_REPOSITORIES = DAGGER_REPOSITORIES
+
+HILT_ANDROID_REPOSITORIES = DAGGER_REPOSITORIES
+
+# https://github.com/bazelbuild/buildtools/blob/master/WARNINGS.md#unnamed-macro
+# buildifier: disable=unnamed-macro
+def dagger_rules(repo_name = "@maven"):
+ """Defines the Dagger targets with proper exported dependencies and plugins.
+
+ The targets will be of the form ":<artifact-id>".
+
+ Args:
+ repo_name: The name of the dependency repository (default is "@maven").
+ """
+ native.java_library(
+ name = "dagger",
+ exported_plugins = [":dagger-compiler"],
+ visibility = ["//visibility:public"],
+ exports = [
+ "%s//:com_google_dagger_dagger" % repo_name,
+ "%s//:javax_inject_javax_inject" % repo_name,
+ ],
+ )
+
+ native.java_plugin(
+ name = "dagger-compiler",
+ generates_api = 1,
+ processor_class = "dagger.internal.codegen.ComponentProcessor",
+ deps = [
+ "%s//:com_google_dagger_dagger_compiler" % repo_name,
+ ],
+ )
+
+ native.java_library(
+ name = "dagger-producers",
+ visibility = ["//visibility:public"],
+ exports = [
+ ":dagger",
+ "%s//:com_google_dagger_dagger_producers" % repo_name,
+ ],
+ )
+
+ native.java_library(
+ name = "dagger-spi",
+ visibility = ["//visibility:public"],
+ exports = [
+ "%s//:com_google_dagger_dagger_spi" % repo_name,
+ ],
+ )
+
+# https://github.com/bazelbuild/buildtools/blob/master/WARNINGS.md#unnamed-macro
+# buildifier: disable=unnamed-macro
+def dagger_android_rules(repo_name = "@maven"):
+ """Defines the Dagger Android targets with proper exported dependencies and plugins.
+
+ The targets will be of the form ":<artifact-id>".
+
+ Args:
+ repo_name: The name of the dependency repository (default is "@maven").
+ """
+
+ # https://github.com/bazelbuild/buildtools/blob/master/WARNINGS.md#native-android
+ # buildifier: disable=native-android
+ native.android_library(
+ name = "dagger-android",
+ exported_plugins = [":dagger-android-processor"],
+ visibility = ["//visibility:public"],
+ exports = [
+ "%s//:com_google_dagger_dagger_android" % repo_name,
+ ],
+ )
+
+ # https://github.com/bazelbuild/buildtools/blob/master/WARNINGS.md#native-android
+ # buildifier: disable=native-android
+ native.android_library(
+ name = "dagger-android-support",
+ exported_plugins = [":dagger-android-processor"],
+ visibility = ["//visibility:public"],
+ exports = [
+ ":dagger-android",
+ "%s//:com_google_dagger_dagger_android_support" % repo_name,
+ ],
+ )
+
+ native.java_plugin(
+ name = "dagger-android-processor",
+ generates_api = 1,
+ processor_class = "dagger.android.processor.AndroidProcessor",
+ deps = [
+ "%s//:com_google_dagger_dagger_android_processor" % repo_name,
+ ],
+ )
+
+# https://github.com/bazelbuild/buildtools/blob/master/WARNINGS.md#unnamed-macro
+# buildifier: disable=unnamed-macro
+def hilt_android_rules(repo_name = "@maven"):
+ """Defines the Hilt Android targets with proper exported dependencies and plugins.
+
+ The targets will be of the form ":<artifact-id>".
+
+ Args:
+ repo_name: The name of the dependency repository (default is "@maven").
+ """
+
+ # https://github.com/bazelbuild/buildtools/blob/master/WARNINGS.md#native-android
+ # buildifier: disable=native-android
+ native.android_library(
+ name = "hilt-android",
+ exported_plugins = [
+ ":hilt_dagger_compiler",
+ ":hilt_android_entry_point_processor",
+ ":hilt_aggregated_deps_processor",
+ ":hilt_alias_of_processor",
+ ":hilt_define_component_processor",
+ ":hilt_generates_root_input_processor",
+ ":hilt_originating_element_processor",
+ ":hilt_root_processor",
+ ":hilt_view_model_processor",
+ ],
+ visibility = ["//visibility:public"],
+ exports = [
+ "%s//:com_google_dagger_dagger" % repo_name, # For Dagger APIs
+ "%s//:javax_inject_javax_inject" % repo_name, # For @Inject
+ "%s//:androidx_annotation_annotation" % repo_name, # For @CallSuper
+ "%s//:com_google_dagger_hilt_android" % repo_name,
+ "%s//:javax_annotation_jsr250_api" % repo_name, # For @Generated
+ ],
+ )
+
+ # This target is same as dagger-compiler, but we're redefining it here
+ # so that users don't have to call dagger_rules() first.
+ native.java_plugin(
+ name = "hilt_dagger_compiler",
+ generates_api = 1,
+ processor_class = "dagger.internal.codegen.ComponentProcessor",
+ deps = [
+ "%s//:com_google_dagger_dagger_compiler" % repo_name,
+ ],
+ )
+
+ native.java_plugin(
+ name = "hilt_android_entry_point_processor",
+ generates_api = 1,
+ processor_class = "dagger.hilt.android.processor.internal.androidentrypoint.AndroidEntryPointProcessor",
+ deps = ["%s//:com_google_dagger_hilt_android_compiler" % repo_name],
+ )
+
+ native.java_plugin(
+ name = "hilt_aggregated_deps_processor",
+ generates_api = 1,
+ processor_class = "dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsProcessor",
+ deps = ["%s//:com_google_dagger_hilt_android_compiler" % repo_name],
+ )
+
+ native.java_plugin(
+ name = "hilt_alias_of_processor",
+ generates_api = 1,
+ processor_class = "dagger.hilt.processor.internal.aliasof.AliasOfProcessor",
+ deps = ["%s//:com_google_dagger_hilt_android_compiler" % repo_name],
+ )
+
+ native.java_plugin(
+ name = "hilt_define_component_processor",
+ generates_api = 1,
+ processor_class = "dagger.hilt.processor.internal.definecomponent.DefineComponentProcessor",
+ deps = ["%s//:com_google_dagger_hilt_android_compiler" % repo_name],
+ )
+
+ native.java_plugin(
+ name = "hilt_generates_root_input_processor",
+ generates_api = 1,
+ processor_class = "dagger.hilt.processor.internal.generatesrootinput.GeneratesRootInputProcessor",
+ deps = ["%s//:com_google_dagger_hilt_android_compiler" % repo_name],
+ )
+
+ native.java_plugin(
+ name = "hilt_originating_element_processor",
+ generates_api = 1,
+ processor_class = "dagger.hilt.processor.internal.originatingelement.OriginatingElementProcessor",
+ deps = ["%s//:com_google_dagger_hilt_android_compiler" % repo_name],
+ )
+
+ native.java_plugin(
+ name = "hilt_root_processor",
+ generates_api = 1,
+ processor_class = "dagger.hilt.processor.internal.root.RootProcessor",
+ deps = ["%s//:com_google_dagger_hilt_android_compiler" % repo_name],
+ )
+
+ native.java_plugin(
+ name = "hilt_view_model_processor",
+ generates_api = 1,
+ processor_class = "dagger.hilt.android.processor.internal.viewmodel.ViewModelProcessor",
+ deps = ["%s//:com_google_dagger_hilt_android_compiler" % repo_name],
+ )
+
+ # https://github.com/bazelbuild/buildtools/blob/master/WARNINGS.md#native-android
+ # buildifier: disable=native-android
+ native.android_library(
+ name = "hilt-android-testing",
+ testonly = 1,
+ exported_plugins = [
+ ":hilt_bind_value_processor",
+ ":hilt_custom_test_application_processor",
+ ":hilt_testroot_processor",
+ ":hilt_uninstall_modules_processor",
+ ],
+ visibility = ["//visibility:public"],
+ exports = [
+ ":hilt-android",
+ "%s//:androidx_test_core" % repo_name, # For ApplicationProvider
+ "%s//:com_google_dagger_hilt_android_testing" % repo_name,
+ ],
+ )
+
+ native.java_plugin(
+ name = "hilt_bind_value_processor",
+ generates_api = 1,
+ processor_class = "dagger.hilt.android.processor.internal.bindvalue.BindValueProcessor",
+ deps = ["%s//:com_google_dagger_hilt_android_compiler" % repo_name],
+ )
+
+ native.java_plugin(
+ name = "hilt_custom_test_application_processor",
+ generates_api = 1,
+ processor_class = "dagger.hilt.android.processor.internal.customtestapplication.CustomTestApplicationProcessor",
+ deps = ["%s//:com_google_dagger_hilt_android_compiler" % repo_name],
+ )
+
+ native.java_plugin(
+ name = "hilt_testroot_processor",
+ generates_api = 1,
+ processor_class = "dagger.hilt.android.processor.internal.testroot.TestRootProcessor",
+ deps = ["%s//:com_google_dagger_hilt_android_compiler" % repo_name],
+ )
+
+ native.java_plugin(
+ name = "hilt_uninstall_modules_processor",
+ generates_api = 1,
+ processor_class = "dagger.hilt.android.processor.internal.uninstallmodules.UninstallModulesProcessor",
+ deps = ["%s//:com_google_dagger_hilt_android_compiler" % repo_name],
+ )
