Merge commit 'a5db06d'
This is the upstream commit for JavaPoet v1.11.1
Change-Id: I3372f7a59c8888b66930b67e73f8a9d3a6c51167
diff --git a/.buildscript/deploy_snapshot.sh b/.buildscript/deploy_snapshot.sh
new file mode 100755
index 0000000..395a873
--- /dev/null
+++ b/.buildscript/deploy_snapshot.sh
@@ -0,0 +1,26 @@
+#!/bin/bash
+#
+# Deploy a jar, source jar, and javadoc jar to Sonatype's snapshot repo.
+#
+# Adapted from https://coderwall.com/p/9b_lfq and
+# https://benlimmer.com/2013/12/26/automatically-publish-javadoc-to-gh-pages-with-travis-ci/
+
+SLUG="square/javapoet"
+JDK="oraclejdk8"
+BRANCH="master"
+
+set -e
+
+if [ "$TRAVIS_REPO_SLUG" != "$SLUG" ]; then
+ echo "Skipping snapshot deployment: wrong repository. Expected '$SLUG' but was '$TRAVIS_REPO_SLUG'."
+elif [ "$TRAVIS_JDK_VERSION" != "$JDK" ]; then
+ echo "Skipping snapshot deployment: wrong JDK. Expected '$JDK' but was '$TRAVIS_JDK_VERSION'."
+elif [ "$TRAVIS_PULL_REQUEST" != "false" ]; then
+ echo "Skipping snapshot deployment: was pull request."
+elif [ "$TRAVIS_BRANCH" != "$BRANCH" ]; then
+ echo "Skipping snapshot deployment: wrong branch. Expected '$BRANCH' but was '$TRAVIS_BRANCH'."
+else
+ echo "Deploying snapshot..."
+ mvn clean source:jar javadoc:jar deploy --settings=".buildscript/settings.xml" -Dmaven.test.skip=true
+ echo "Snapshot deployed!"
+fi
diff --git a/.buildscript/settings.xml b/.buildscript/settings.xml
new file mode 100644
index 0000000..91f444b
--- /dev/null
+++ b/.buildscript/settings.xml
@@ -0,0 +1,9 @@
+<settings>
+ <servers>
+ <server>
+ <id>sonatype-nexus-snapshots</id>
+ <username>${env.CI_DEPLOY_USERNAME}</username>
+ <password>${env.CI_DEPLOY_PASSWORD}</password>
+ </server>
+ </servers>
+</settings>
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..be0d31a
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,23 @@
+.classpath
+.project
+.settings
+.checkstyle
+eclipsebin
+
+bin
+gen
+build
+out
+lib
+
+target
+pom.xml.*
+release.properties
+
+.idea
+*.iml
+classes
+
+obj
+
+.DS_Store
diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 0000000..4e0a881
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,46 @@
+language: java
+
+matrix:
+ include:
+ - env: JDK='Oracle JDK 8'
+ jdk: oraclejdk8
+ - env: JDK='Oracle JDK 9'
+ jdk: oraclejdk9
+ - env: JDK='Oracle JDK 10'
+ install: . ./install-jdk.sh -F 10 -L BCL
+ - env: JDK='OpenJDK 10'
+ install: . ./install-jdk.sh -F 10 -L GPL
+ - env: JDK='Oracle JDK 11'
+ install: . ./install-jdk.sh -F 11 -L BCL
+ - env: JDK='OpenJDK 11'
+ install: . ./install-jdk.sh -F 11 -L GPL
+ allow_failures:
+ # ErrorProne/javac is not yet working on JDK 11
+ - env: JDK='Oracle JDK 11'
+ - env: JDK='OpenJDK 11'
+
+# Direct usage of `install-jdk.sh` might be superseded by https://github.com/travis-ci/travis-build/pull/1347
+before_install:
+ - unset _JAVA_OPTIONS
+ - wget https://github.com/sormuras/bach/raw/1.0.1/install-jdk.sh
+
+after_success:
+ - .buildscript/deploy_snapshot.sh
+
+env:
+ global:
+ - secure: "nkVNCk8H2orIZOmow0t+Qub1lFQCYpJgNZf17zYI5x0JVqQNCqkcTYYDHqzwkvkmixXFCrfYZQuXy7x2qg9zjCX+vmhlmiMWwe8dNa34OLTseuuR2irS0C8nRGRYxKM7EGenRZSqbFVUksKRm2iWnHKxtmCzeDaS7MoMit2wdUo="
+ - secure: "j8+hPaZnyM+UlOBYOEA96fPbVWbN6bMQ28SGQnFMwxo2axHi9ww9Au1N7002HzHnxX8iyesdWFBigArnEL8zKEoXH9Bmur0sn3Ys4bu72C3ozscP4cjXfYSHj8aVLp1EIMdQPDF7MkCccx9l7ONdsW0ltmdiVUtDxzqkH+63WLU="
+
+branches:
+ except:
+ - gh-pages
+
+notifications:
+ email: false
+
+sudo: false
+
+cache:
+ directories:
+ - $HOME/.m2
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..3933dd0
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,302 @@
+Change Log
+==========
+
+JavaPoet 1.11.1 *(2018-05-16)*
+-----------------------------
+
+ * Fix: JavaPoet 1.11 had a regression where `TypeName.get()` would throw on error types, masking
+ other errors in an annotation processing round. This is fixed with a test to prevent future
+ regressions!
+
+
+JavaPoet 1.11.0 *(2018-04-29)*
+-----------------------------
+
+ * New: Support `TYPE_USE` annotations on each enclosing `ClassName`.
+ * New: Work around a compiler bug in `TypeName.get(TypeElement)`. There was a problem getting an
+ element's kind when building from source ABIs.
+
+
+JavaPoet 1.10.0 *(2018-01-27)*
+-----------------------------
+
+ * **JavaPoet now requires Java 8 or newer.**
+ * New: `$Z` as an optional newline (zero-width space) if a line may exceed 100 chars.
+ * New: `CodeBlock.join()` and `CodeBlock.joining()` let you join codeblocks by delimiters.
+ * New: Add `CodeBlock.Builder.isEmpty()`.
+ * New: `addStatement(CodeBlock)` overloads for `CodeBlock` and `MethodSpec`.
+ * Fix: Include annotations when emitting type variables.
+ * Fix: Use the right imports for annotated type parameters.
+ * Fix: Don't incorrectly escape classnames that start with `$`.
+
+
+JavaPoet 1.9.0 *(2017-05-13)*
+-----------------------------
+
+ * Fix: Don't emit incorrect code when the declared type's signature references another type with
+ the same simple name.
+ * Fix: Support anonymous inner classes in `ClassName.get()`.
+ * New: `MethodSpec.Builder.addNamedCode()` and `TypeSpec.anonymousClassBuilder(CodeBlock)`.
+
+
+JavaPoet 1.8.0 *(2016-11-09)*
+-----------------------------
+
+ * New: Basic support for line wrapping. Use `$W` to insert a Wrappable Whitespace character. It'll
+ emit either a single space or a newline with appropriate indentation.
+ * New: Named arguments in `CodeBlock`. These are intended to make larger code snippets easier to
+ read:
+
+ ```
+ Map<String, Object> map = new LinkedHashMap<>();
+ map.put("count", 3);
+ map.put("greeting", "Hello, ");
+ map.put("system", System.class);
+
+ String template = ""
+ + "for (int i = 0; i < $count:L; i++) {\n"
+ + " $system:T.out.println($greeting:S + list.get(i));\n"
+ + "}\n";
+
+ CodeBlock.Builder builder = CodeBlock.builder();
+ builder.addNamed(template, map);
+ ```
+
+ * New: `addJavadoc(CodeBlock)` overloads for TypeSpec, MethodSpec, and FieldSpec.
+ * New: `MethodSpec.addComment()` makes it easy to add a `// single-line comment.`
+ * New: `ClassName.getReflectionName()` returns a string like `java.util.Map$Entry`.
+ * Fix: Always write UTF-8. Previously JavaPoet would use the system default charset which was
+ potentially inconsistent across environments.
+ * Fix: Permit (constant) fields to be defined in annotation types.
+
+
+JavaPoet 1.7.0 *(2016-04-26)*
+-----------------------------
+
+ * New: Support parameterized types that enclose other types, like `Outer<String>.Inner`.
+ * New: `TypeName.isBoxedPrimitive()`.
+
+
+JavaPoet 1.6.1 *(2016-03-21)*
+-----------------------------
+
+ * Fix: Double quotes and backslashes in string literals were not properly quoted in 1.6.0. This is
+ now fixed.
+
+
+JavaPoet 1.6.0 *(2016-03-19)*
+-----------------------------
+
+ * New: Revive `CodeBlock.of()`, a handy factory method for building code blocks.
+ * New: Add `TypeSpec` factory methods that take a `ClassName`.
+ * New: `TypeName.annotated()` adds an annotation to a type.
+ * New: `TypeVariableName.withBounds()` adds bounds to a type variable.
+ * New: `TypeSpec.Builder.addInitializerBlock()` adds an instance initializer.
+ * Fix: Make `TypeSpec.Kind` enum public. This can be used to check if a `TypeSpec` is a class,
+ interface, enum, or annotation.
+ * Fix: Don’t break import resolution on annotated types.
+ * Fix: Forbid unexpected modifiers like `private` on annotation members.
+ * Fix: Deduplicate exceptions in `MethodSpec.Builder`.
+ * Fix: Treat `ErrorType` like a regular `DeclaredType` in `TypeName.get()`. This should make it
+ easier to write annotation processors.
+
+
+JavaPoet 1.5.1 *(2016-01-10)*
+-----------------------------
+
+ * Fix: Annotated `TypeName` instances are only equal if their annotations are equal.
+
+JavaPoet 1.5.0 *(2016-01-10)*
+-----------------------------
+
+ * New: `import static`! See `JavaFile.Builder.addStaticImport()` variants.
+ * New: Overload `NameAllocator.newName(String)` for creating a one-off name without a tag.
+ * Fix: AnnotationSpec escapes character literals properly.
+ * Fix: Don't stack overflow when `TypeVariableName` is part of `ParameterizedTypeName`.
+ * Fix: Reporting not used indexed arguments in like `add("$1S", "a", "b")`.
+ * Fix: Prevent import of types located in the default package, i.e. have no package name.
+
+
+JavaPoet 1.4.0 *(2015-11-13)*
+-----------------------------
+
+ * New: `AnnotationSpec.get(Annotation)`.
+ * New: Type annotations! `TypeName.annotated()` can attach annotations like `@Nullable` directly to
+ types. This works for both top-level types and type parameters as in `List<@Nullable String>`.
+ * New: `equals()` and `hashCode()` on `AnnotationSpec`, `CodeBlock`, `FieldSpec`, `JavaFile`,
+ `MethodSpec`, `ParameterSpec`, `TypeName`, and `TypeSpec`.
+ * New: `NameAllocator.clone()` to refine a NameAllocator for use in an inner scope code block.
+ * Fix: Don't stack overflow when `TypeVariableName` gets a self-referential type.
+ * Fix: Better handling of name collisions on imports. Previously JavaPoet did the wrong thing when
+ a referenced type and a nested types had the same name.
+
+
+JavaPoet 1.3.0 *(2015-09-20)*
+-----------------------------
+
+ * New: `NameAllocator` API makes it easy to declare non-conflicting names.
+ * New: Support annotations on enum values.
+ * Fix: Avoid infinite recursion in `TypeName.get(TypeMirror)`.
+ * Fix: Use qualified name for conflicting simple names in the same file.
+ * Fix: Better messages for parameter indexing errors.
+
+
+JavaPoet 1.2.0 *(2015-07-04)*
+-----------------------------
+
+ * New: Arguments may have positional indexes like `$1T` and `$2N`. Indexes can be used to refer to
+ the same argument multiple times in a single format string.
+ * New: Permit Javadoc on enum constants.
+ * New: Class initializer blocks with `addStaticBlock()`.
+ * Fix: `MethodSpec.overriding()` retains annotations.
+
+
+JavaPoet 1.1.0 *(2015-05-25)*
+-----------------------------
+
+ * New: Eager validation of argument types like `$T` and `$N`.
+ * New: `MethodSpec.varargs(boolean)` to generate varags methods.
+ * New: `AnnotationSpec.get()` and `MethodSpec.overriding()` to create annotations and methods from
+ the `javax.lang.model` API.
+ * New: `JavaFile.toJavaFileObject()`.
+ * New: Java 8 `DEFAULT` modifier.
+ * New: `toBuilder()` methods to build upon objects already constructed.
+ * New: Generate `@interface` annotation types.
+ * New: `TypeName.box()` and `TypeName.unbox()` convenience APIs.
+ * Fix: `nextControlFlow()` accepts arguments.
+ * Fix: Reject duplicate calls to set the superclass.
+ * Fix: `WildcardTypeName.get(WildcardType)` no longer throws a `NullPointerException`.
+ * Fix: Don't allow double field initialization.
+
+JavaPoet 1.0.0 *(2015-01-28)*
+-----------------------------
+
+ * This update is a complete rewrite. The project name is now `javapoet`. We renamed the it so you
+ can simultaneously use the old JavaWriter API and our new builder-based APIs in one project.
+ * Immutable value objects and builders. Instead of streaming the `.java` file from top to bottom,
+ you now define members in whatever way is convenient.
+ * We now use our own models for type names.
+ * Imports are now added automatically.
+
+
+JavaWriter 2.5.1 *(2014-12-03)*
+-------------------------------
+
+ * New: `StringLiteral` type which encapsulates the behavior of `stringLiteral`.
+ * Fix: Use canonical name when emitting a class import.
+ * Fix: Apply type compression to varargs and array types.
+ * Fix: Restore binary compatibility with pre-2.5 versions.
+
+
+JavaWriter 2.5.0 *(2014-04-18)*
+-------------------------------
+
+ * New: Methods in interfaces will always have no body declaration.
+ * New: Control flow begin declaration now supports String format arguments.
+ * Fix: Truncate any generic type when emitting constructors.
+ * Fix: Do not emit trailing whitespace after '=' at end-of-line.
+
+
+JavaWriter 2.4.0 *(2014-01-10)*
+-------------------------------
+
+ * New: Properly indent hanging lines in field initializers.
+ * New: `emitEnumValue` variant which exposes a boolean of whether the current value is the last.
+
+
+JavaWriter 2.3.1 *(2013-12-16)*
+-------------------------------
+
+ * Fix: Properly handle subpackages of `java.lang` in `compressType`.
+
+
+JavaWriter 2.3.0 *(2013-11-24)*
+-------------------------------
+
+ * New: Configurable indent level via `setIndent`.
+ * New: `beginConstructor` method is a semantically clearer alternative for constructors.
+ * New: `emitEnumValues` method emits a list of values followed by semicolon.
+ * `emitImports` now supports `Class` arguments directly.
+ * Previously-deprecated, `int`-based modifier methods have been removed.
+
+
+JavaWriter 2.2.1 *(2013-10-23)*
+-------------------------------
+
+ * Fix: Do not emit trailing whitespace for empty Javadoc lines.
+
+
+JavaWriter 2.2.0 *(2013-09-25)*
+-------------------------------
+
+ * `setCompressingTypes` controls whether types are emitted as fully-qualified or not.
+
+
+JavaWriter 2.1.2 *(2013-08-23)*
+-------------------------------
+
+ * Attempt to keep annotations on a single line.
+
+
+JavaWriter 2.1.1 *(2013-07-23)*
+-------------------------------
+
+ * Fix: `stringLiteral` now correctly handles escapes and control characters.
+
+
+JavaWriter 2.1.0 *(2013-07-15)*
+-------------------------------
+
+ * New: All methods now take a `Set` of `Modifier`s rather than an `int`. The `int` methods are
+ now deprecated for removal in JavaPoet 1.0.
+ * Annotations with a single "value" attribute will now omit the key.
+
+
+JavaWriter 2.0.1 *(2013-06-17)*
+-------------------------------
+
+ * Correct casing of `emitSingleLineComment`.
+
+
+JavaWriter 2.0.0 *(2013-06-06)*
+-------------------------------
+
+ * Package name is now `com.squareup.javawriter`.
+ * Support declaring `throws` clause on methods.
+
+
+JavaWriter 1.0.5 *(2013-05-08)*
+-------------------------------
+
+ * Fix: Fully qualify types whose simple name matches an import.
+
+
+JavaWriter 1.0.4 *(2013-03-15)*
+-------------------------------
+
+ * Fix: Static import emit now properly supports method imports.
+
+
+JavaWriter 1.0.3 *(2013-02-21)*
+-------------------------------
+
+ * Add support for emitting static imports.
+
+
+JavaWriter 1.0.2 *(2013-02-11)*
+-------------------------------
+
+ * Add `type` API for helping build generic types.
+ * Minor performance improvements.
+
+
+JavaWriter 1.0.1 *(2013-02-03)*
+-------------------------------
+
+ * Expose `compressType` API.
+
+
+JavaWriter 1.0.0 *(2013-02-01)*
+-------------------------------
+
+Initial release.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..8131805
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,17 @@
+Contributing
+============
+
+If you would like to contribute code you can do so through GitHub by forking
+the repository and sending a pull request.
+
+When submitting code, please make every effort to follow existing conventions
+and style in order to keep the code as readable as possible. Please also make
+sure your code compiles by running `mvn clean verify`. Checkstyle failures
+during compilation indicate errors in your style and can be viewed in the
+`checkstyle-result.xml` file.
+
+Before your code can be accepted into the project you must also sign the
+[Individual Contributor License Agreement (CLA)][1].
+
+
+ [1]: https://spreadsheets.google.com/spreadsheet/viewform?formkey=dDViT2xzUHAwRkI3X3k5Z0lQM091OGc6MQ&ndplr=1
diff --git a/LICENSE.txt b/LICENSE.txt
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/LICENSE.txt
@@ -0,0 +1,202 @@
+
+ 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/README.md b/README.md
new file mode 100644
index 0000000..1dffbad
--- /dev/null
+++ b/README.md
@@ -0,0 +1,889 @@
+JavaPoet
+========
+
+`JavaPoet` is a Java API for generating `.java` source files.
+
+Source file generation can be useful when doing things such as annotation processing or interacting
+with metadata files (e.g., database schemas, protocol formats). By generating code, you eliminate
+the need to write boilerplate while also keeping a single source of truth for the metadata.
+
+
+### Example
+
+Here's a (boring) `HelloWorld` class:
+
+```java
+package com.example.helloworld;
+
+public final class HelloWorld {
+ public static void main(String[] args) {
+ System.out.println("Hello, JavaPoet!");
+ }
+}
+```
+
+And this is the (exciting) code to generate it with JavaPoet:
+
+```java
+MethodSpec main = MethodSpec.methodBuilder("main")
+ .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
+ .returns(void.class)
+ .addParameter(String[].class, "args")
+ .addStatement("$T.out.println($S)", System.class, "Hello, JavaPoet!")
+ .build();
+
+TypeSpec helloWorld = TypeSpec.classBuilder("HelloWorld")
+ .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
+ .addMethod(main)
+ .build();
+
+JavaFile javaFile = JavaFile.builder("com.example.helloworld", helloWorld)
+ .build();
+
+javaFile.writeTo(System.out);
+```
+
+To declare the main method, we've created a `MethodSpec` "main" configured with modifiers, return
+type, parameters and code statements. We add the main method to a `HelloWorld` class, and then add
+that to a `HelloWorld.java` file.
+
+In this case we write the file to `System.out`, but we could also get it as a string
+(`JavaFile.toString()`) or write it to the file system (`JavaFile.writeTo()`).
+
+The [Javadoc][javadoc] catalogs the complete JavaPoet API, which we explore below.
+
+### Code & Control Flow
+
+Most of JavaPoet's API uses plain old immutable Java objects. There's also builders, method chaining
+and varargs to make the API friendly. JavaPoet offers models for classes & interfaces (`TypeSpec`),
+fields (`FieldSpec`), methods & constructors (`MethodSpec`), parameters (`ParameterSpec`) and
+annotations (`AnnotationSpec`).
+
+But the _body_ of methods and constructors is not modeled. There's no expression class, no
+statement class or syntax tree nodes. Instead, JavaPoet uses strings for code blocks:
+
+```java
+MethodSpec main = MethodSpec.methodBuilder("main")
+ .addCode(""
+ + "int total = 0;\n"
+ + "for (int i = 0; i < 10; i++) {\n"
+ + " total += i;\n"
+ + "}\n")
+ .build();
+```
+
+Which generates this:
+
+```java
+void main() {
+ int total = 0;
+ for (int i = 0; i < 10; i++) {
+ total += i;
+ }
+}
+```
+
+The manual semicolons, line wrapping, and indentation are tedious and so JavaPoet offers APIs to
+make it easier. There's `addStatement()` which takes care of semicolons and newline, and
+`beginControlFlow()` + `endControlFlow()` which are used together for braces, newlines, and
+indentation:
+
+```java
+MethodSpec main = MethodSpec.methodBuilder("main")
+ .addStatement("int total = 0")
+ .beginControlFlow("for (int i = 0; i < 10; i++)")
+ .addStatement("total += i")
+ .endControlFlow()
+ .build();
+```
+
+This example is lame because the generated code is constant! Suppose instead of just adding 0 to 10,
+we want to make the operation and range configurable. Here's a method that generates a method:
+
+```java
+private MethodSpec computeRange(String name, int from, int to, String op) {
+ return MethodSpec.methodBuilder(name)
+ .returns(int.class)
+ .addStatement("int result = 1")
+ .beginControlFlow("for (int i = " + from + "; i < " + to + "; i++)")
+ .addStatement("result = result " + op + " i")
+ .endControlFlow()
+ .addStatement("return result")
+ .build();
+}
+```
+
+And here's what we get when we call `computeRange("multiply10to20", 10, 20, "*")`:
+
+```java
+int multiply10to20() {
+ int result = 1;
+ for (int i = 10; i < 20; i++) {
+ result = result * i;
+ }
+ return result;
+}
+```
+
+Methods generating methods! And since JavaPoet generates source instead of bytecode, you can
+read through it to make sure it's right.
+
+
+### $L for Literals
+
+The string-concatenation in calls to `beginControlFlow()` and `addStatement` is distracting. Too
+many operators. To address this, JavaPoet offers a syntax inspired-by but incompatible-with
+[`String.format()`][formatter]. It accepts **`$L`** to emit a **literal** value in the output. This
+works just like `Formatter`'s `%s`:
+
+```java
+private MethodSpec computeRange(String name, int from, int to, String op) {
+ return MethodSpec.methodBuilder(name)
+ .returns(int.class)
+ .addStatement("int result = 0")
+ .beginControlFlow("for (int i = $L; i < $L; i++)", from, to)
+ .addStatement("result = result $L i", op)
+ .endControlFlow()
+ .addStatement("return result")
+ .build();
+}
+```
+
+Literals are emitted directly to the output code with no escaping. Arguments for literals may be
+strings, primitives, and a few JavaPoet types described below.
+
+### $S for Strings
+
+When emitting code that includes string literals, we can use **`$S`** to emit a **string**, complete
+with wrapping quotation marks and escaping. Here's a program that emits 3 methods, each of which
+returns its own name:
+
+```java
+public static void main(String[] args) throws Exception {
+ TypeSpec helloWorld = TypeSpec.classBuilder("HelloWorld")
+ .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
+ .addMethod(whatsMyName("slimShady"))
+ .addMethod(whatsMyName("eminem"))
+ .addMethod(whatsMyName("marshallMathers"))
+ .build();
+
+ JavaFile javaFile = JavaFile.builder("com.example.helloworld", helloWorld)
+ .build();
+
+ javaFile.writeTo(System.out);
+}
+
+private static MethodSpec whatsMyName(String name) {
+ return MethodSpec.methodBuilder(name)
+ .returns(String.class)
+ .addStatement("return $S", name)
+ .build();
+}
+```
+
+In this case, using `$S` gives us quotation marks:
+
+```java
+public final class HelloWorld {
+ String slimShady() {
+ return "slimShady";
+ }
+
+ String eminem() {
+ return "eminem";
+ }
+
+ String marshallMathers() {
+ return "marshallMathers";
+ }
+}
+```
+
+### $T for Types
+
+We Java programmers love our types: they make our code easier to understand. And JavaPoet is on
+board. It has rich built-in support for types, including automatic generation of `import`
+statements. Just use **`$T`** to reference **types**:
+
+```java
+MethodSpec today = MethodSpec.methodBuilder("today")
+ .returns(Date.class)
+ .addStatement("return new $T()", Date.class)
+ .build();
+
+TypeSpec helloWorld = TypeSpec.classBuilder("HelloWorld")
+ .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
+ .addMethod(today)
+ .build();
+
+JavaFile javaFile = JavaFile.builder("com.example.helloworld", helloWorld)
+ .build();
+
+javaFile.writeTo(System.out);
+```
+
+That generates the following `.java` file, complete with the necessary `import`:
+
+```java
+package com.example.helloworld;
+
+import java.util.Date;
+
+public final class HelloWorld {
+ Date today() {
+ return new Date();
+ }
+}
+```
+
+We passed `Date.class` to reference a class that just-so-happens to be available when we're
+generating code. This doesn't need to be the case. Here's a similar example, but this one
+references a class that doesn't exist (yet):
+
+```java
+ClassName hoverboard = ClassName.get("com.mattel", "Hoverboard");
+
+MethodSpec today = MethodSpec.methodBuilder("tomorrow")
+ .returns(hoverboard)
+ .addStatement("return new $T()", hoverboard)
+ .build();
+```
+
+And that not-yet-existent class is imported as well:
+
+```java
+package com.example.helloworld;
+
+import com.mattel.Hoverboard;
+
+public final class HelloWorld {
+ Hoverboard tomorrow() {
+ return new Hoverboard();
+ }
+}
+```
+
+The `ClassName` type is very important, and you'll need it frequently when you're using JavaPoet.
+It can identify any _declared_ class. Declared types are just the beginning of Java's rich type
+system: we also have arrays, parameterized types, wildcard types, and type variables. JavaPoet has
+classes for building each of these:
+
+```java
+ClassName hoverboard = ClassName.get("com.mattel", "Hoverboard");
+ClassName list = ClassName.get("java.util", "List");
+ClassName arrayList = ClassName.get("java.util", "ArrayList");
+TypeName listOfHoverboards = ParameterizedTypeName.get(list, hoverboard);
+
+MethodSpec beyond = MethodSpec.methodBuilder("beyond")
+ .returns(listOfHoverboards)
+ .addStatement("$T result = new $T<>()", listOfHoverboards, arrayList)
+ .addStatement("result.add(new $T())", hoverboard)
+ .addStatement("result.add(new $T())", hoverboard)
+ .addStatement("result.add(new $T())", hoverboard)
+ .addStatement("return result")
+ .build();
+```
+
+JavaPoet will decompose each type and import its components where possible.
+
+```java
+package com.example.helloworld;
+
+import com.mattel.Hoverboard;
+import java.util.ArrayList;
+import java.util.List;
+
+public final class HelloWorld {
+ List<Hoverboard> beyond() {
+ List<Hoverboard> result = new ArrayList<>();
+ result.add(new Hoverboard());
+ result.add(new Hoverboard());
+ result.add(new Hoverboard());
+ return result;
+ }
+}
+```
+
+#### Import static
+
+JavaPoet supports `import static`. It does it via explicitly collecting type member names. Let's
+enhance the previous example with some static sugar:
+
+```java
+...
+ClassName namedBoards = ClassName.get("com.mattel", "Hoverboard", "Boards");
+
+MethodSpec beyond = MethodSpec.methodBuilder("beyond")
+ .returns(listOfHoverboards)
+ .addStatement("$T result = new $T<>()", listOfHoverboards, arrayList)
+ .addStatement("result.add($T.createNimbus(2000))", hoverboard)
+ .addStatement("result.add($T.createNimbus(\"2001\"))", hoverboard)
+ .addStatement("result.add($T.createNimbus($T.THUNDERBOLT))", hoverboard, namedBoards)
+ .addStatement("$T.sort(result)", Collections.class)
+ .addStatement("return result.isEmpty() ? $T.emptyList() : result", Collections.class)
+ .build();
+
+TypeSpec hello = TypeSpec.classBuilder("HelloWorld")
+ .addMethod(beyond)
+ .build();
+
+JavaFile.builder("com.example.helloworld", hello)
+ .addStaticImport(hoverboard, "createNimbus")
+ .addStaticImport(namedBoards, "*")
+ .addStaticImport(Collections.class, "*")
+ .build();
+```
+
+JavaPoet will first add your `import static` block to the file as configured, match and mangle
+all calls accordingly and also import all other types as needed.
+
+```java
+package com.example.helloworld;
+
+import static com.mattel.Hoverboard.Boards.*;
+import static com.mattel.Hoverboard.createNimbus;
+import static java.util.Collections.*;
+
+import com.mattel.Hoverboard;
+import java.util.ArrayList;
+import java.util.List;
+
+class HelloWorld {
+ List<Hoverboard> beyond() {
+ List<Hoverboard> result = new ArrayList<>();
+ result.add(createNimbus(2000));
+ result.add(createNimbus("2001"));
+ result.add(createNimbus(THUNDERBOLT));
+ sort(result);
+ return result.isEmpty() ? emptyList() : result;
+ }
+}
+```
+
+### $N for Names
+
+Generated code is often self-referential. Use **`$N`** to refer to another generated declaration by
+its name. Here's a method that calls another:
+
+```java
+public String byteToHex(int b) {
+ char[] result = new char[2];
+ result[0] = hexDigit((b >>> 4) & 0xf);
+ result[1] = hexDigit(b & 0xf);
+ return new String(result);
+}
+
+public char hexDigit(int i) {
+ return (char) (i < 10 ? i + '0' : i - 10 + 'a');
+}
+```
+
+When generating the code above, we pass the `hexDigit()` method as an argument to the `byteToHex()`
+method using `$N`:
+
+```java
+MethodSpec hexDigit = MethodSpec.methodBuilder("hexDigit")
+ .addParameter(int.class, "i")
+ .returns(char.class)
+ .addStatement("return (char) (i < 10 ? i + '0' : i - 10 + 'a')")
+ .build();
+
+MethodSpec byteToHex = MethodSpec.methodBuilder("byteToHex")
+ .addParameter(int.class, "b")
+ .returns(String.class)
+ .addStatement("char[] result = new char[2]")
+ .addStatement("result[0] = $N((b >>> 4) & 0xf)", hexDigit)
+ .addStatement("result[1] = $N(b & 0xf)", hexDigit)
+ .addStatement("return new String(result)")
+ .build();
+```
+
+### Code block format strings
+
+Code blocks may specify the values for their placeholders in a few ways. Only one style may be used
+for each operation on a code block.
+
+#### Relative Arguments
+
+Pass an argument value for each placeholder in the format string to `CodeBlock.add()`. In each
+example, we generate code to say "I ate 3 tacos"
+
+```java
+CodeBlock.builder().add("I ate $L $L", 3, "tacos")
+```
+
+#### Positional Arguments
+
+Place an integer index (1-based) before the placeholder in the format string to specify which
+ argument to use.
+
+```java
+CodeBlock.builder().add("I ate $2L $1L", "tacos", 3)
+```
+
+#### Named Arguments
+
+Use the syntax `$argumentName:X` where `X` is the format character and call `CodeBlock.addNamed()`
+with a map containing all argument keys in the format string. Argument names use characters in
+`a-z`, `A-Z`, `0-9`, and `_`, and must start with a lowercase character.
+
+```java
+Map<String, Object> map = new LinkedHashMap<>();
+map.put("food", "tacos");
+map.put("count", 3);
+CodeBlock.builder().addNamed("I ate $count:L $food:L", map)
+```
+
+### Methods
+
+All of the above methods have a code body. Use `Modifiers.ABSTRACT` to get a method without any
+body. This is only legal if the enclosing class is either abstract or an interface.
+
+```java
+MethodSpec flux = MethodSpec.methodBuilder("flux")
+ .addModifiers(Modifier.ABSTRACT, Modifier.PROTECTED)
+ .build();
+
+TypeSpec helloWorld = TypeSpec.classBuilder("HelloWorld")
+ .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
+ .addMethod(flux)
+ .build();
+```
+
+Which generates this:
+
+```java
+public abstract class HelloWorld {
+ protected abstract void flux();
+}
+```
+
+The other modifiers work where permitted. Note that when specifying modifiers, JavaPoet uses
+[`javax.lang.model.element.Modifier`][modifier], a class that is not available on Android. This
+limitation applies to code-generating-code only; the output code runs everywhere: JVMs, Android,
+and GWT.
+
+Methods also have parameters, exceptions, varargs, Javadoc, annotations, type variables, and a
+return type. All of these are configured with `MethodSpec.Builder`.
+
+### Constructors
+
+`MethodSpec` is a slight misnomer; it can also be used for constructors:
+
+```java
+MethodSpec flux = MethodSpec.constructorBuilder()
+ .addModifiers(Modifier.PUBLIC)
+ .addParameter(String.class, "greeting")
+ .addStatement("this.$N = $N", "greeting", "greeting")
+ .build();
+
+TypeSpec helloWorld = TypeSpec.classBuilder("HelloWorld")
+ .addModifiers(Modifier.PUBLIC)
+ .addField(String.class, "greeting", Modifier.PRIVATE, Modifier.FINAL)
+ .addMethod(flux)
+ .build();
+```
+
+Which generates this:
+
+```java
+public class HelloWorld {
+ private final String greeting;
+
+ public HelloWorld(String greeting) {
+ this.greeting = greeting;
+ }
+}
+```
+
+For the most part, constructors work just like methods. When emitting code, JavaPoet will place
+constructors before methods in the output file.
+
+### Parameters
+
+Declare parameters on methods and constructors with either `ParameterSpec.builder()` or
+`MethodSpec`'s convenient `addParameter()` API:
+
+```java
+ParameterSpec android = ParameterSpec.builder(String.class, "android")
+ .addModifiers(Modifier.FINAL)
+ .build();
+
+MethodSpec welcomeOverlords = MethodSpec.methodBuilder("welcomeOverlords")
+ .addParameter(android)
+ .addParameter(String.class, "robot", Modifier.FINAL)
+ .build();
+```
+
+Though the code above to generate `android` and `robot` parameters is different, the output is the
+same:
+
+```java
+void welcomeOverlords(final String android, final String robot) {
+}
+```
+
+The extended `Builder` form is necessary when the parameter has annotations (such as `@Nullable`).
+
+### Fields
+
+Like parameters, fields can be created either with builders or by using convenient helper methods:
+
+```java
+FieldSpec android = FieldSpec.builder(String.class, "android")
+ .addModifiers(Modifier.PRIVATE, Modifier.FINAL)
+ .build();
+
+TypeSpec helloWorld = TypeSpec.classBuilder("HelloWorld")
+ .addModifiers(Modifier.PUBLIC)
+ .addField(android)
+ .addField(String.class, "robot", Modifier.PRIVATE, Modifier.FINAL)
+ .build();
+```
+
+Which generates:
+
+```java
+public class HelloWorld {
+ private final String android;
+
+ private final String robot;
+}
+```
+
+The extended `Builder` form is necessary when a field has Javadoc, annotations, or a field
+initializer. Field initializers use the same [`String.format()`][formatter]-like syntax as the code
+blocks above:
+
+```java
+FieldSpec android = FieldSpec.builder(String.class, "android")
+ .addModifiers(Modifier.PRIVATE, Modifier.FINAL)
+ .initializer("$S + $L", "Lollipop v.", 5.0d)
+ .build();
+```
+
+Which generates:
+
+```java
+private final String android = "Lollipop v." + 5.0;
+```
+
+### Interfaces
+
+JavaPoet has no trouble with interfaces. Note that interface methods must always be `PUBLIC
+ABSTRACT` and interface fields must always be `PUBLIC STATIC FINAL`. These modifiers are necessary
+when defining the interface:
+
+```java
+TypeSpec helloWorld = TypeSpec.interfaceBuilder("HelloWorld")
+ .addModifiers(Modifier.PUBLIC)
+ .addField(FieldSpec.builder(String.class, "ONLY_THING_THAT_IS_CONSTANT")
+ .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)
+ .initializer("$S", "change")
+ .build())
+ .addMethod(MethodSpec.methodBuilder("beep")
+ .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
+ .build())
+ .build();
+```
+
+But these modifiers are omitted when the code is generated. These are the defaults so we don't need
+to include them for `javac`'s benefit!
+
+```java
+public interface HelloWorld {
+ String ONLY_THING_THAT_IS_CONSTANT = "change";
+
+ void beep();
+}
+```
+
+### Enums
+
+Use `enumBuilder` to create the enum type, and `addEnumConstant()` for each value:
+
+```java
+TypeSpec helloWorld = TypeSpec.enumBuilder("Roshambo")
+ .addModifiers(Modifier.PUBLIC)
+ .addEnumConstant("ROCK")
+ .addEnumConstant("SCISSORS")
+ .addEnumConstant("PAPER")
+ .build();
+```
+
+To generate this:
+
+```java
+public enum Roshambo {
+ ROCK,
+
+ SCISSORS,
+
+ PAPER
+}
+```
+
+Fancy enums are supported, where the enum values override methods or call a superclass constructor.
+Here's a comprehensive example:
+
+```java
+TypeSpec helloWorld = TypeSpec.enumBuilder("Roshambo")
+ .addModifiers(Modifier.PUBLIC)
+ .addEnumConstant("ROCK", TypeSpec.anonymousClassBuilder("$S", "fist")
+ .addMethod(MethodSpec.methodBuilder("toString")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC)
+ .addStatement("return $S", "avalanche!")
+ .returns(String.class)
+ .build())
+ .build())
+ .addEnumConstant("SCISSORS", TypeSpec.anonymousClassBuilder("$S", "peace")
+ .build())
+ .addEnumConstant("PAPER", TypeSpec.anonymousClassBuilder("$S", "flat")
+ .build())
+ .addField(String.class, "handsign", Modifier.PRIVATE, Modifier.FINAL)
+ .addMethod(MethodSpec.constructorBuilder()
+ .addParameter(String.class, "handsign")
+ .addStatement("this.$N = $N", "handsign", "handsign")
+ .build())
+ .build();
+```
+
+Which generates this:
+
+```java
+public enum Roshambo {
+ ROCK("fist") {
+ @Override
+ public String toString() {
+ return "avalanche!";
+ }
+ },
+
+ SCISSORS("peace"),
+
+ PAPER("flat");
+
+ private final String handsign;
+
+ Roshambo(String handsign) {
+ this.handsign = handsign;
+ }
+}
+```
+
+### Anonymous Inner Classes
+
+In the enum code, we used `Types.anonymousInnerClass()`. Anonymous inner classes can also be used in
+code blocks. They are values that can be referenced with `$L`:
+
+```java
+TypeSpec comparator = TypeSpec.anonymousClassBuilder("")
+ .addSuperinterface(ParameterizedTypeName.get(Comparator.class, String.class))
+ .addMethod(MethodSpec.methodBuilder("compare")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC)
+ .addParameter(String.class, "a")
+ .addParameter(String.class, "b")
+ .returns(int.class)
+ .addStatement("return $N.length() - $N.length()", "a", "b")
+ .build())
+ .build();
+
+TypeSpec helloWorld = TypeSpec.classBuilder("HelloWorld")
+ .addMethod(MethodSpec.methodBuilder("sortByLength")
+ .addParameter(ParameterizedTypeName.get(List.class, String.class), "strings")
+ .addStatement("$T.sort($N, $L)", Collections.class, "strings", comparator)
+ .build())
+ .build();
+```
+
+This generates a method that contains a class that contains a method:
+
+```java
+void sortByLength(List<String> strings) {
+ Collections.sort(strings, new Comparator<String>() {
+ @Override
+ public int compare(String a, String b) {
+ return a.length() - b.length();
+ }
+ });
+}
+```
+
+One particularly tricky part of defining anonymous inner classes is the arguments to the superclass
+constructor. In the above code we're passing the empty string for no arguments:
+`TypeSpec.anonymousClassBuilder("")`. To pass different parameters use JavaPoet's code block
+syntax with commas to separate arguments.
+
+
+### Annotations
+
+Simple annotations are easy:
+
+```java
+MethodSpec toString = MethodSpec.methodBuilder("toString")
+ .addAnnotation(Override.class)
+ .returns(String.class)
+ .addModifiers(Modifier.PUBLIC)
+ .addStatement("return $S", "Hoverboard")
+ .build();
+```
+
+Which generates this method with an `@Override` annotation:
+
+```java
+ @Override
+ public String toString() {
+ return "Hoverboard";
+ }
+```
+
+Use `AnnotationSpec.builder()` to set properties on annotations:
+
+```java
+MethodSpec logRecord = MethodSpec.methodBuilder("recordEvent")
+ .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
+ .addAnnotation(AnnotationSpec.builder(Headers.class)
+ .addMember("accept", "$S", "application/json; charset=utf-8")
+ .addMember("userAgent", "$S", "Square Cash")
+ .build())
+ .addParameter(LogRecord.class, "logRecord")
+ .returns(LogReceipt.class)
+ .build();
+```
+
+Which generates this annotation with `accept` and `userAgent` properties:
+
+```java
+@Headers(
+ accept = "application/json; charset=utf-8",
+ userAgent = "Square Cash"
+)
+LogReceipt recordEvent(LogRecord logRecord);
+```
+
+When you get fancy, annotation values can be annotations themselves. Use `$L` for embedded
+annotations:
+
+```java
+MethodSpec logRecord = MethodSpec.methodBuilder("recordEvent")
+ .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
+ .addAnnotation(AnnotationSpec.builder(HeaderList.class)
+ .addMember("value", "$L", AnnotationSpec.builder(Header.class)
+ .addMember("name", "$S", "Accept")
+ .addMember("value", "$S", "application/json; charset=utf-8")
+ .build())
+ .addMember("value", "$L", AnnotationSpec.builder(Header.class)
+ .addMember("name", "$S", "User-Agent")
+ .addMember("value", "$S", "Square Cash")
+ .build())
+ .build())
+ .addParameter(LogRecord.class, "logRecord")
+ .returns(LogReceipt.class)
+ .build();
+```
+
+Which generates this:
+
+```java
+@HeaderList({
+ @Header(name = "Accept", value = "application/json; charset=utf-8"),
+ @Header(name = "User-Agent", value = "Square Cash")
+})
+LogReceipt recordEvent(LogRecord logRecord);
+```
+
+Note that you can call `addMember()` multiple times with the same property name to populate a list
+of values for that property.
+
+### Javadoc
+
+Fields, methods and types can be documented with Javadoc:
+
+```java
+MethodSpec dismiss = MethodSpec.methodBuilder("dismiss")
+ .addJavadoc("Hides {@code message} from the caller's history. Other\n"
+ + "participants in the conversation will continue to see the\n"
+ + "message in their own history unless they also delete it.\n")
+ .addJavadoc("\n")
+ .addJavadoc("<p>Use {@link #delete($T)} to delete the entire\n"
+ + "conversation for all participants.\n", Conversation.class)
+ .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
+ .addParameter(Message.class, "message")
+ .build();
+```
+
+Which generates this:
+
+```java
+ /**
+ * Hides {@code message} from the caller's history. Other
+ * participants in the conversation will continue to see the
+ * message in their own history unless they also delete it.
+ *
+ * <p>Use {@link #delete(Conversation)} to delete the entire
+ * conversation for all participants.
+ */
+ void dismiss(Message message);
+```
+
+Use `$T` when referencing types in Javadoc to get automatic imports.
+
+Download
+--------
+
+Download [the latest .jar][dl] or depend via Maven:
+```xml
+<dependency>
+ <groupId>com.squareup</groupId>
+ <artifactId>javapoet</artifactId>
+ <version>1.11.1</version>
+</dependency>
+```
+or Gradle:
+```groovy
+compile 'com.squareup:javapoet:1.11.1'
+```
+
+Snapshots of the development version are available in [Sonatype's `snapshots` repository][snap].
+
+
+
+License
+-------
+
+ Copyright 2015 Square, Inc.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+
+
+JavaWriter
+==========
+
+JavaPoet is the successor to [JavaWriter][javawriter]. New projects should prefer JavaPoet because
+it has a stronger code model: it understands types and can manage imports automatically. JavaPoet is
+also better suited to composition: rather than streaming the contents of a `.java` file
+top-to-bottom in a single pass, a file can be assembled as a tree of declarations.
+
+JavaWriter continues to be available in [GitHub][javawriter] and [Maven Central][javawriter_maven].
+
+
+ [dl]: https://search.maven.org/remote_content?g=com.squareup&a=javapoet&v=LATEST
+ [snap]: https://oss.sonatype.org/content/repositories/snapshots/com/squareup/javapoet/
+ [javadoc]: https://square.github.io/javapoet/1.x/javapoet/
+ [javawriter]: https://github.com/square/javapoet/tree/javawriter_2
+ [javawriter_maven]: https://search.maven.org/#artifactdetails%7Ccom.squareup%7Cjavawriter%7C2.5.1%7Cjar
+ [formatter]: https://developer.android.com/reference/java/util/Formatter.html
+ [modifier]: https://docs.oracle.com/javase/8/docs/api/javax/lang/model/element/Modifier.html
diff --git a/checkstyle.xml b/checkstyle.xml
new file mode 100644
index 0000000..bbf690e
--- /dev/null
+++ b/checkstyle.xml
@@ -0,0 +1,148 @@
+<?xml version="1.0"?>
+<!DOCTYPE module PUBLIC
+ "-//Puppy Crawl//DTD Check Configuration 1.3//EN"
+ "http://www.puppycrawl.com/dtds/configuration_1_3.dtd">
+
+<module name="Checker">
+ <module name="SuppressWarningsFilter"/>
+ <module name="NewlineAtEndOfFile"/>
+ <module name="FileLength"/>
+ <module name="FileTabCharacter"/>
+
+ <!-- Trailing spaces -->
+ <module name="RegexpSingleline">
+ <property name="format" value="\s+$"/>
+ <property name="message" value="Line has trailing spaces."/>
+ </module>
+
+ <!-- Space after 'for' and 'if' -->
+ <module name="RegexpSingleline">
+ <property name="format" value="^\s*(for|if)\b[^ ]"/>
+ <property name="message" value="Space needed before opening parenthesis."/>
+ </module>
+
+ <!-- For each spacing -->
+ <module name="RegexpSingleline">
+ <property name="format" value="^\s*for \(.*?([^ ]:|:[^ ])"/>
+ <property name="message" value="Space needed around ':' character."/>
+ </module>
+
+ <module name="TreeWalker">
+ <property name="cacheFile" value="${checkstyle.cache.file}"/>
+
+ <!-- Checks for Javadoc comments. -->
+ <!-- See http://checkstyle.sf.net/config_javadoc.html -->
+ <!--module name="JavadocMethod"/-->
+ <!--module name="JavadocType"/-->
+ <!--module name="JavadocVariable"/-->
+ <module name="JavadocStyle"/>
+
+
+ <!-- Checks for Naming Conventions. -->
+ <!-- See http://checkstyle.sf.net/config_naming.html -->
+ <module name="ConstantName"/>
+ <module name="LocalFinalVariableName"/>
+ <module name="LocalVariableName"/>
+ <module name="MemberName"/>
+ <module name="MethodName"/>
+ <module name="PackageName"/>
+ <module name="ParameterName"/>
+ <module name="StaticVariableName"/>
+ <module name="TypeName"/>
+
+
+ <!-- Checks for imports -->
+ <!-- See http://checkstyle.sf.net/config_import.html -->
+ <module name="AvoidStarImport"/>
+ <module name="IllegalImport"/>
+ <!-- defaults to sun.* packages -->
+ <module name="RedundantImport"/>
+ <module name="UnusedImports">
+ <property name="processJavadoc" value="true"/>
+ </module>
+
+
+ <!-- Checks for Size Violations. -->
+ <!-- See http://checkstyle.sf.net/config_sizes.html -->
+ <module name="LineLength">
+ <property name="max" value="100"/>
+ </module>
+ <module name="MethodLength">
+ <property name="max" value="160"/>
+ </module>
+ <module name="ParameterNumber"/>
+
+
+ <!-- Checks for whitespace -->
+ <!-- See http://checkstyle.sf.net/config_whitespace.html -->
+ <module name="GenericWhitespace"/>
+ <!--<module name="EmptyForIteratorPad"/>-->
+ <module name="MethodParamPad"/>
+ <module name="NoWhitespaceAfter"/>
+ <module name="NoWhitespaceBefore"/>
+ <module name="OperatorWrap"/>
+ <module name="ParenPad"/>
+ <module name="TypecastParenPad"/>
+ <module name="WhitespaceAfter"/>
+ <module name="WhitespaceAround">
+ <property name="tokens"
+ value="ASSIGN, BAND, BAND_ASSIGN, BOR, BOR_ASSIGN, BSR, BSR_ASSIGN, BXOR, BXOR_ASSIGN,
+ COLON, DIV, DIV_ASSIGN, DO_WHILE, EQUAL, GE, GT, LAND, LCURLY, LE, LITERAL_CATCH,
+ LITERAL_DO, LITERAL_ELSE, LITERAL_FINALLY, LITERAL_FOR, LITERAL_IF, LITERAL_RETURN,
+ LITERAL_SWITCH, LITERAL_SYNCHRONIZED, LITERAL_TRY, LITERAL_WHILE, LOR, LT, MINUS,
+ MINUS_ASSIGN, MOD, MOD_ASSIGN, NOT_EQUAL, PLUS, PLUS_ASSIGN, QUESTION, SL, SLIST,
+ SL_ASSIGN, SR, SR_ASSIGN, STAR, STAR_ASSIGN, LITERAL_ASSERT, TYPE_EXTENSION_AND"/>
+ </module>
+
+
+ <!-- Modifier Checks -->
+ <!-- See http://checkstyle.sf.net/config_modifiers.html -->
+ <module name="ModifierOrder"/>
+ <module name="RedundantModifier"/>
+
+
+ <!-- Checks for blocks. You know, those {}'s -->
+ <!-- See http://checkstyle.sf.net/config_blocks.html -->
+ <module name="AvoidNestedBlocks"/>
+ <!--module name="EmptyBlock"/-->
+ <module name="LeftCurly"/>
+ <!--<module name="NeedBraces"/>-->
+ <module name="RightCurly"/>
+
+
+ <!-- Checks for common coding problems -->
+ <!-- See http://checkstyle.sf.net/config_coding.html -->
+ <!--module name="AvoidInlineConditionals"/-->
+ <module name="CovariantEquals"/>
+ <module name="EmptyStatement"/>
+ <!--<module name="EqualsAvoidNull"/>-->
+ <module name="EqualsHashCode"/>
+ <!--module name="HiddenField"/-->
+ <module name="IllegalInstantiation"/>
+ <module name="InnerAssignment"/>
+ <!--<module name="MagicNumber"/>-->
+ <module name="MissingSwitchDefault"/>
+ <!--module name="RedundantThrows"/-->
+ <module name="SimplifyBooleanExpression"/>
+ <module name="SimplifyBooleanReturn"/>
+
+ <!-- Checks for class design -->
+ <!-- See http://checkstyle.sf.net/config_design.html -->
+ <!--module name="DesignForExtension"/-->
+ <module name="FinalClass"/>
+ <module name="HideUtilityClassConstructor"/>
+ <module name="InterfaceIsType"/>
+ <!--module name="VisibilityModifier"/-->
+
+
+ <!-- Miscellaneous other checks. -->
+ <!-- See http://checkstyle.sf.net/config_misc.html -->
+ <module name="ArrayTypeStyle"/>
+ <!--module name="FinalParameters"/-->
+ <module name="TodoComment"/>
+ <module name="UpperEll"/>
+
+ <!-- Make the @SuppressWarnings annotations available to Checkstyle -->
+ <module name="SuppressWarningsHolder"/>
+ </module>
+</module>
diff --git a/pom.xml b/pom.xml
new file mode 100644
index 0000000..a531637
--- /dev/null
+++ b/pom.xml
@@ -0,0 +1,159 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<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>7</version>
+ </parent>
+
+ <groupId>com.squareup</groupId>
+ <artifactId>javapoet</artifactId>
+ <version>1.11.1</version>
+
+ <name>JavaPoet</name>
+ <description>Use beautiful Java code to generate beautiful Java code.</description>
+ <url>http://github.com/square/javapoet/</url>
+
+ <properties>
+ <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+
+ <java.version>1.8</java.version>
+ <junit.version>4.12</junit.version>
+ <truth.version>0.39</truth.version>
+ <compile-testing.version>0.15</compile-testing.version>
+ </properties>
+
+ <scm>
+ <url>http://github.com/square/javapoet/</url>
+ <connection>scm:git:git://github.com/square/javapoet.git</connection>
+ <developerConnection>scm:git:ssh://git@github.com/square/javapoet.git</developerConnection>
+ <tag>HEAD</tag>
+ </scm>
+
+ <issueManagement>
+ <system>GitHub Issues</system>
+ <url>http://github.com/square/javapoet/issues</url>
+ </issueManagement>
+
+ <licenses>
+ <license>
+ <name>Apache 2.0</name>
+ <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
+ </license>
+ </licenses>
+
+ <organization>
+ <name>Square, Inc.</name>
+ <url>http://squareup.com</url>
+ </organization>
+
+ <dependencies>
+ <dependency>
+ <groupId>com.google.truth</groupId>
+ <artifactId>truth</artifactId>
+ <version>${truth.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>com.google.testing.compile</groupId>
+ <artifactId>compile-testing</artifactId>
+ <version>${compile-testing.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <version>${junit.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>com.google.jimfs</groupId>
+ <artifactId>jimfs</artifactId>
+ <version>1.1</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.mockito</groupId>
+ <artifactId>mockito-core</artifactId>
+ <version>2.13.0</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.eclipse.jdt.core.compiler</groupId>
+ <artifactId>ecj</artifactId>
+ <version>4.6.1</version>
+ <scope>test</scope>
+ </dependency>
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-compiler-plugin</artifactId>
+ <version>3.7.0</version>
+ <configuration>
+ <compilerId>javac-with-errorprone</compilerId>
+ <forceJavacCompilerUse>true</forceJavacCompilerUse>
+ <source>${java.version}</source>
+ <target>${java.version}</target>
+ </configuration>
+ <dependencies>
+ <dependency>
+ <groupId>org.codehaus.plexus</groupId>
+ <artifactId>plexus-compiler-javac-errorprone</artifactId>
+ <version>2.8.2</version>
+ </dependency>
+ <dependency>
+ <groupId>com.google.errorprone</groupId>
+ <artifactId>error_prone_core</artifactId>
+ <version>2.3.1</version>
+ </dependency>
+ </dependencies>
+ </plugin>
+
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-checkstyle-plugin</artifactId>
+ <version>2.17</version>
+ <dependencies>
+ <dependency>
+ <groupId>com.puppycrawl.tools</groupId>
+ <artifactId>checkstyle</artifactId>
+ <version>8.7</version>
+ </dependency>
+ </dependencies>
+ <configuration>
+ <failsOnError>true</failsOnError>
+ <configLocation>checkstyle.xml</configLocation>
+ <consoleOutput>true</consoleOutput>
+ </configuration>
+ <executions>
+ <execution>
+ <phase>verify</phase>
+ <goals>
+ <goal>checkstyle</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
+
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-jar-plugin</artifactId>
+ <version>3.0.2</version>
+ <configuration>
+ <archive>
+ <manifestEntries>
+ <Automatic-Module-Name>com.squareup.javapoet</Automatic-Module-Name>
+ </manifestEntries>
+ </archive>
+ </configuration>
+ </plugin>
+
+ </plugins>
+ </build>
+</project>
diff --git a/src/main/java/com/squareup/javapoet/AnnotationSpec.java b/src/main/java/com/squareup/javapoet/AnnotationSpec.java
new file mode 100644
index 0000000..d1c5e53
--- /dev/null
+++ b/src/main/java/com/squareup/javapoet/AnnotationSpec.java
@@ -0,0 +1,279 @@
+/*
+ * Copyright (C) 2015 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Array;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import javax.lang.model.SourceVersion;
+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.element.VariableElement;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.SimpleAnnotationValueVisitor8;
+
+import static com.squareup.javapoet.Util.characterLiteralWithoutSingleQuotes;
+import static com.squareup.javapoet.Util.checkArgument;
+import static com.squareup.javapoet.Util.checkNotNull;
+
+/** A generated annotation on a declaration. */
+public final class AnnotationSpec {
+ public final TypeName type;
+ public final Map<String, List<CodeBlock>> members;
+
+ private AnnotationSpec(Builder builder) {
+ this.type = builder.type;
+ this.members = Util.immutableMultimap(builder.members);
+ }
+
+ void emit(CodeWriter codeWriter, boolean inline) throws IOException {
+ String whitespace = inline ? "" : "\n";
+ String memberSeparator = inline ? ", " : ",\n";
+ if (members.isEmpty()) {
+ // @Singleton
+ codeWriter.emit("@$T", type);
+ } else if (members.size() == 1 && members.containsKey("value")) {
+ // @Named("foo")
+ codeWriter.emit("@$T(", type);
+ emitAnnotationValues(codeWriter, whitespace, memberSeparator, members.get("value"));
+ codeWriter.emit(")");
+ } else {
+ // Inline:
+ // @Column(name = "updated_at", nullable = false)
+ //
+ // Not inline:
+ // @Column(
+ // name = "updated_at",
+ // nullable = false
+ // )
+ codeWriter.emit("@$T(" + whitespace, type);
+ codeWriter.indent(2);
+ for (Iterator<Map.Entry<String, List<CodeBlock>>> i
+ = members.entrySet().iterator(); i.hasNext(); ) {
+ Map.Entry<String, List<CodeBlock>> entry = i.next();
+ codeWriter.emit("$L = ", entry.getKey());
+ emitAnnotationValues(codeWriter, whitespace, memberSeparator, entry.getValue());
+ if (i.hasNext()) codeWriter.emit(memberSeparator);
+ }
+ codeWriter.unindent(2);
+ codeWriter.emit(whitespace + ")");
+ }
+ }
+
+ private void emitAnnotationValues(CodeWriter codeWriter, String whitespace,
+ String memberSeparator, List<CodeBlock> values) throws IOException {
+ if (values.size() == 1) {
+ codeWriter.indent(2);
+ codeWriter.emit(values.get(0));
+ codeWriter.unindent(2);
+ return;
+ }
+
+ codeWriter.emit("{" + whitespace);
+ codeWriter.indent(2);
+ boolean first = true;
+ for (CodeBlock codeBlock : values) {
+ if (!first) codeWriter.emit(memberSeparator);
+ codeWriter.emit(codeBlock);
+ first = false;
+ }
+ codeWriter.unindent(2);
+ codeWriter.emit(whitespace + "}");
+ }
+
+ public static AnnotationSpec get(Annotation annotation) {
+ return get(annotation, false);
+ }
+
+ public static AnnotationSpec get(Annotation annotation, boolean includeDefaultValues) {
+ Builder builder = builder(annotation.annotationType());
+ try {
+ Method[] methods = annotation.annotationType().getDeclaredMethods();
+ Arrays.sort(methods, Comparator.comparing(Method::getName));
+ for (Method method : methods) {
+ Object value = method.invoke(annotation);
+ if (!includeDefaultValues) {
+ if (Objects.deepEquals(value, method.getDefaultValue())) {
+ continue;
+ }
+ }
+ if (value.getClass().isArray()) {
+ for (int i = 0; i < Array.getLength(value); i++) {
+ builder.addMemberForValue(method.getName(), Array.get(value, i));
+ }
+ continue;
+ }
+ if (value instanceof Annotation) {
+ builder.addMember(method.getName(), "$L", get((Annotation) value));
+ continue;
+ }
+ builder.addMemberForValue(method.getName(), value);
+ }
+ } catch (Exception e) {
+ throw new RuntimeException("Reflecting " + annotation + " failed!", e);
+ }
+ return builder.build();
+ }
+
+ public static AnnotationSpec get(AnnotationMirror annotation) {
+ TypeElement element = (TypeElement) annotation.getAnnotationType().asElement();
+ AnnotationSpec.Builder builder = AnnotationSpec.builder(ClassName.get(element));
+ Visitor visitor = new Visitor(builder);
+ for (ExecutableElement executableElement : annotation.getElementValues().keySet()) {
+ String name = executableElement.getSimpleName().toString();
+ AnnotationValue value = annotation.getElementValues().get(executableElement);
+ value.accept(visitor, name);
+ }
+ return builder.build();
+ }
+
+ public static Builder builder(ClassName type) {
+ checkNotNull(type, "type == null");
+ return new Builder(type);
+ }
+
+ public static Builder builder(Class<?> type) {
+ return builder(ClassName.get(type));
+ }
+
+ public Builder toBuilder() {
+ Builder builder = new Builder(type);
+ for (Map.Entry<String, List<CodeBlock>> entry : members.entrySet()) {
+ builder.members.put(entry.getKey(), new ArrayList<>(entry.getValue()));
+ }
+ return builder;
+ }
+
+ @Override public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o == null) return false;
+ if (getClass() != o.getClass()) return false;
+ return toString().equals(o.toString());
+ }
+
+ @Override public int hashCode() {
+ return toString().hashCode();
+ }
+
+ @Override public String toString() {
+ StringBuilder out = new StringBuilder();
+ try {
+ CodeWriter codeWriter = new CodeWriter(out);
+ codeWriter.emit("$L", this);
+ return out.toString();
+ } catch (IOException e) {
+ throw new AssertionError();
+ }
+ }
+
+ public static final class Builder {
+ private final TypeName type;
+ private final Map<String, List<CodeBlock>> members = new LinkedHashMap<>();
+
+ private Builder(TypeName type) {
+ this.type = type;
+ }
+
+ public Builder addMember(String name, String format, Object... args) {
+ return addMember(name, CodeBlock.of(format, args));
+ }
+
+ public Builder addMember(String name, CodeBlock codeBlock) {
+ checkNotNull(name, "name == null");
+ checkArgument(SourceVersion.isName(name), "not a valid name: %s", name);
+ List<CodeBlock> values = members.computeIfAbsent(name, k -> new ArrayList<>());
+ values.add(codeBlock);
+ return this;
+ }
+
+ /**
+ * Delegates to {@link #addMember(String, String, Object...)}, with parameter {@code format}
+ * depending on the given {@code value} object. Falls back to {@code "$L"} literal format if
+ * the class of the given {@code value} object is not supported.
+ */
+ Builder addMemberForValue(String memberName, Object value) {
+ checkNotNull(memberName, "memberName == null");
+ checkNotNull(value, "value == null, constant non-null value expected for %s", memberName);
+ checkArgument(SourceVersion.isName(memberName), "not a valid name: %s", memberName);
+ if (value instanceof Class<?>) {
+ return addMember(memberName, "$T.class", value);
+ }
+ if (value instanceof Enum) {
+ return addMember(memberName, "$T.$L", value.getClass(), ((Enum<?>) value).name());
+ }
+ if (value instanceof String) {
+ return addMember(memberName, "$S", value);
+ }
+ if (value instanceof Float) {
+ return addMember(memberName, "$Lf", value);
+ }
+ if (value instanceof Character) {
+ return addMember(memberName, "'$L'", characterLiteralWithoutSingleQuotes((char) value));
+ }
+ return addMember(memberName, "$L", value);
+ }
+
+ public AnnotationSpec build() {
+ return new AnnotationSpec(this);
+ }
+ }
+
+ /**
+ * Annotation value visitor adding members to the given builder instance.
+ */
+ private static class Visitor extends SimpleAnnotationValueVisitor8<Builder, String> {
+ final Builder builder;
+
+ Visitor(Builder builder) {
+ super(builder);
+ this.builder = builder;
+ }
+
+ @Override protected Builder defaultAction(Object o, String name) {
+ return builder.addMemberForValue(name, o);
+ }
+
+ @Override public Builder visitAnnotation(AnnotationMirror a, String name) {
+ return builder.addMember(name, "$L", get(a));
+ }
+
+ @Override public Builder visitEnumConstant(VariableElement c, String name) {
+ return builder.addMember(name, "$T.$L", c.asType(), c.getSimpleName());
+ }
+
+ @Override public Builder visitType(TypeMirror t, String name) {
+ return builder.addMember(name, "$T.class", t);
+ }
+
+ @Override public Builder visitArray(List<? extends AnnotationValue> values, String name) {
+ for (AnnotationValue value : values) {
+ value.accept(this, name);
+ }
+ return builder;
+ }
+ }
+}
diff --git a/src/main/java/com/squareup/javapoet/ArrayTypeName.java b/src/main/java/com/squareup/javapoet/ArrayTypeName.java
new file mode 100644
index 0000000..219c3f3
--- /dev/null
+++ b/src/main/java/com/squareup/javapoet/ArrayTypeName.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2015 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import java.io.IOException;
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import javax.lang.model.element.TypeParameterElement;
+import javax.lang.model.type.ArrayType;
+
+import static com.squareup.javapoet.Util.checkNotNull;
+
+public final class ArrayTypeName extends TypeName {
+ public final TypeName componentType;
+
+ private ArrayTypeName(TypeName componentType) {
+ this(componentType, new ArrayList<>());
+ }
+
+ private ArrayTypeName(TypeName componentType, List<AnnotationSpec> annotations) {
+ super(annotations);
+ this.componentType = checkNotNull(componentType, "rawType == null");
+ }
+
+ @Override public ArrayTypeName annotated(List<AnnotationSpec> annotations) {
+ return new ArrayTypeName(componentType, concatAnnotations(annotations));
+ }
+
+ @Override public TypeName withoutAnnotations() {
+ return new ArrayTypeName(componentType);
+ }
+
+ @Override CodeWriter emit(CodeWriter out) throws IOException {
+ return emit(out, false);
+ }
+
+ CodeWriter emit(CodeWriter out, boolean varargs) throws IOException {
+ emitLeafType(out);
+ return emitBrackets(out, varargs);
+ }
+
+ private CodeWriter emitLeafType(CodeWriter out) throws IOException {
+ if (TypeName.asArray(componentType) != null) {
+ return TypeName.asArray(componentType).emitLeafType(out);
+ }
+ return componentType.emit(out);
+ }
+
+ private CodeWriter emitBrackets(CodeWriter out, boolean varargs) throws IOException {
+ if (isAnnotated()) {
+ out.emit(" ");
+ emitAnnotations(out);
+ }
+
+ if (TypeName.asArray(componentType) == null) {
+ // Last bracket.
+ return out.emit(varargs ? "..." : "[]");
+ }
+ out.emit("[]");
+ return TypeName.asArray(componentType) .emitBrackets(out, varargs);
+ }
+
+
+ /** Returns an array type whose elements are all instances of {@code componentType}. */
+ public static ArrayTypeName of(TypeName componentType) {
+ return new ArrayTypeName(componentType);
+ }
+
+ /** Returns an array type whose elements are all instances of {@code componentType}. */
+ public static ArrayTypeName of(Type componentType) {
+ return of(TypeName.get(componentType));
+ }
+
+ /** Returns an array type equivalent to {@code mirror}. */
+ public static ArrayTypeName get(ArrayType mirror) {
+ return get(mirror, new LinkedHashMap<>());
+ }
+
+ static ArrayTypeName get(
+ ArrayType mirror, Map<TypeParameterElement, TypeVariableName> typeVariables) {
+ return new ArrayTypeName(get(mirror.getComponentType(), typeVariables));
+ }
+
+ /** Returns an array type equivalent to {@code type}. */
+ public static ArrayTypeName get(GenericArrayType type) {
+ return get(type, new LinkedHashMap<>());
+ }
+
+ static ArrayTypeName get(GenericArrayType type, Map<Type, TypeVariableName> map) {
+ return ArrayTypeName.of(get(type.getGenericComponentType(), map));
+ }
+}
diff --git a/src/main/java/com/squareup/javapoet/ClassName.java b/src/main/java/com/squareup/javapoet/ClassName.java
new file mode 100644
index 0000000..99c4ed2
--- /dev/null
+++ b/src/main/java/com/squareup/javapoet/ClassName.java
@@ -0,0 +1,280 @@
+/*
+ * Copyright (C) 2014 Google, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.PackageElement;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.util.SimpleElementVisitor8;
+
+import static com.squareup.javapoet.Util.checkArgument;
+import static com.squareup.javapoet.Util.checkNotNull;
+
+/** A fully-qualified class name for top-level and member classes. */
+public final class ClassName extends TypeName implements Comparable<ClassName> {
+ public static final ClassName OBJECT = ClassName.get(Object.class);
+
+ /** The package name of this class, or "" if this is in the default package. */
+ final String packageName;
+
+ /** The enclosing class, or null if this is not enclosed in another class. */
+ final ClassName enclosingClassName;
+
+ /** This class name, like "Entry" for java.util.Map.Entry. */
+ final String simpleName;
+
+ /** The full class name like "java.util.Map.Entry". */
+ final String canonicalName;
+
+ private ClassName(String packageName, ClassName enclosingClassName, String simpleName) {
+ this(packageName, enclosingClassName, simpleName, Collections.emptyList());
+ }
+
+ private ClassName(String packageName, ClassName enclosingClassName, String simpleName,
+ List<AnnotationSpec> annotations) {
+ super(annotations);
+ this.packageName = packageName;
+ this.enclosingClassName = enclosingClassName;
+ this.simpleName = simpleName;
+ this.canonicalName = enclosingClassName != null
+ ? (enclosingClassName.canonicalName + '.' + simpleName)
+ : (packageName.isEmpty() ? simpleName : packageName + '.' + simpleName);
+ }
+
+ @Override public ClassName annotated(List<AnnotationSpec> annotations) {
+ return new ClassName(packageName, enclosingClassName, simpleName,
+ concatAnnotations(annotations));
+ }
+
+ @Override public ClassName withoutAnnotations() {
+ if (!isAnnotated()) return this;
+ ClassName resultEnclosingClassName = enclosingClassName != null
+ ? enclosingClassName.withoutAnnotations()
+ : null;
+ return new ClassName(packageName, resultEnclosingClassName, simpleName);
+ }
+
+ @Override public boolean isAnnotated() {
+ return super.isAnnotated() || (enclosingClassName != null && enclosingClassName.isAnnotated());
+ }
+
+ /**
+ * Returns the package name, like {@code "java.util"} for {@code Map.Entry}. Returns the empty
+ * string for the default package.
+ */
+ public String packageName() {
+ return packageName;
+ }
+
+ /**
+ * Returns the enclosing class, like {@link Map} for {@code Map.Entry}. Returns null if this class
+ * is not nested in another class.
+ */
+ public ClassName enclosingClassName() {
+ return enclosingClassName;
+ }
+
+ /**
+ * Returns the top class in this nesting group. Equivalent to chained calls to {@link
+ * #enclosingClassName()} until the result's enclosing class is null.
+ */
+ public ClassName topLevelClassName() {
+ return enclosingClassName != null ? enclosingClassName.topLevelClassName() : this;
+ }
+
+ /** Return the binary name of a class. */
+ public String reflectionName() {
+ return enclosingClassName != null
+ ? (enclosingClassName.reflectionName() + '$' + simpleName)
+ : (packageName.isEmpty() ? simpleName : packageName + '.' + simpleName);
+ }
+
+ public List<String> simpleNames() {
+ List<String> simpleNames = new ArrayList<>();
+ if (enclosingClassName != null) {
+ simpleNames.addAll(enclosingClassName().simpleNames());
+ }
+ simpleNames.add(simpleName);
+ return simpleNames;
+ }
+
+ /**
+ * Returns a class that shares the same enclosing package or class. If this class is enclosed by
+ * another class, this is equivalent to {@code enclosingClassName().nestedClass(name)}. Otherwise
+ * it is equivalent to {@code get(packageName(), name)}.
+ */
+ public ClassName peerClass(String name) {
+ return new ClassName(packageName, enclosingClassName, name);
+ }
+
+ /**
+ * Returns a new {@link ClassName} instance for the specified {@code name} as nested inside this
+ * class.
+ */
+ public ClassName nestedClass(String name) {
+ return new ClassName(packageName, this, name);
+ }
+
+ /** Returns the simple name of this class, like {@code "Entry"} for {@link Map.Entry}. */
+ public String simpleName() {
+ return simpleName;
+ }
+
+ public static ClassName get(Class<?> clazz) {
+ checkNotNull(clazz, "clazz == null");
+ checkArgument(!clazz.isPrimitive(), "primitive types cannot be represented as a ClassName");
+ checkArgument(!void.class.equals(clazz), "'void' type cannot be represented as a ClassName");
+ checkArgument(!clazz.isArray(), "array types cannot be represented as a ClassName");
+
+ String anonymousSuffix = "";
+ while (clazz.isAnonymousClass()) {
+ int lastDollar = clazz.getName().lastIndexOf('$');
+ anonymousSuffix = clazz.getName().substring(lastDollar) + anonymousSuffix;
+ clazz = clazz.getEnclosingClass();
+ }
+ String name = clazz.getSimpleName() + anonymousSuffix;
+
+ if (clazz.getEnclosingClass() == null) {
+ // Avoid unreliable Class.getPackage(). https://github.com/square/javapoet/issues/295
+ int lastDot = clazz.getName().lastIndexOf('.');
+ String packageName = (lastDot != -1) ? clazz.getName().substring(0, lastDot) : null;
+ return new ClassName(packageName, null, name);
+ }
+
+ return ClassName.get(clazz.getEnclosingClass()).nestedClass(name);
+ }
+
+ /**
+ * Returns a new {@link ClassName} instance for the given fully-qualified class name string. This
+ * method assumes that the input is ASCII and follows typical Java style (lowercase package
+ * names, UpperCamelCase class names) and may produce incorrect results or throw
+ * {@link IllegalArgumentException} otherwise. For that reason, {@link #get(Class)} and
+ * {@link #get(Class)} should be preferred as they can correctly create {@link ClassName}
+ * instances without such restrictions.
+ */
+ public static ClassName bestGuess(String classNameString) {
+ // Add the package name, like "java.util.concurrent", or "" for no package.
+ int p = 0;
+ while (p < classNameString.length() && Character.isLowerCase(classNameString.codePointAt(p))) {
+ p = classNameString.indexOf('.', p) + 1;
+ checkArgument(p != 0, "couldn't make a guess for %s", classNameString);
+ }
+ String packageName = p == 0 ? "" : classNameString.substring(0, p - 1);
+
+ // Add class names like "Map" and "Entry".
+ ClassName className = null;
+ for (String simpleName : classNameString.substring(p).split("\\.", -1)) {
+ checkArgument(!simpleName.isEmpty() && Character.isUpperCase(simpleName.codePointAt(0)),
+ "couldn't make a guess for %s", classNameString);
+ className = new ClassName(packageName, className, simpleName);
+ }
+
+ return className;
+ }
+
+ /**
+ * Returns a class name created from the given parts. For example, calling this with package name
+ * {@code "java.util"} and simple names {@code "Map"}, {@code "Entry"} yields {@link Map.Entry}.
+ */
+ public static ClassName get(String packageName, String simpleName, String... simpleNames) {
+ ClassName className = new ClassName(packageName, null, simpleName);
+ for (String name : simpleNames) {
+ className = className.nestedClass(name);
+ }
+ return className;
+ }
+
+ /** Returns the class name for {@code element}. */
+ public static ClassName get(TypeElement element) {
+ checkNotNull(element, "element == null");
+ String simpleName = element.getSimpleName().toString();
+
+ return element.getEnclosingElement().accept(new SimpleElementVisitor8<ClassName, Void>() {
+ @Override public ClassName visitPackage(PackageElement packageElement, Void p) {
+ return new ClassName(packageElement.getQualifiedName().toString(), null, simpleName);
+ }
+
+ @Override public ClassName visitType(TypeElement enclosingClass, Void p) {
+ return ClassName.get(enclosingClass).nestedClass(simpleName);
+ }
+
+ @Override public ClassName visitUnknown(Element unknown, Void p) {
+ return get("", simpleName);
+ }
+
+ @Override public ClassName defaultAction(Element enclosingElement, Void p) {
+ throw new IllegalArgumentException("Unexpected type nesting: " + element);
+ }
+ }, null);
+ }
+
+ @Override public int compareTo(ClassName o) {
+ return canonicalName.compareTo(o.canonicalName);
+ }
+
+ @Override CodeWriter emit(CodeWriter out) throws IOException {
+ boolean charsEmitted = false;
+ for (ClassName className : enclosingClasses()) {
+ String simpleName;
+ if (charsEmitted) {
+ // We've already emitted an enclosing class. Emit as we go.
+ out.emit(".");
+ simpleName = className.simpleName;
+
+ } else if (className.isAnnotated() || className == this) {
+ // We encountered the first enclosing class that must be emitted.
+ String qualifiedName = out.lookupName(className);
+ int dot = qualifiedName.lastIndexOf('.');
+ if (dot != -1) {
+ out.emitAndIndent(qualifiedName.substring(0, dot + 1));
+ simpleName = qualifiedName.substring(dot + 1);
+ charsEmitted = true;
+ } else {
+ simpleName = qualifiedName;
+ }
+
+ } else {
+ // Don't emit this enclosing type. Keep going so we can be more precise.
+ continue;
+ }
+
+ if (className.isAnnotated()) {
+ if (charsEmitted) out.emit(" ");
+ className.emitAnnotations(out);
+ }
+
+ out.emit(simpleName);
+ charsEmitted = true;
+ }
+
+ return out;
+ }
+
+ /** Returns all enclosing classes in this, outermost first. */
+ private List<ClassName> enclosingClasses() {
+ List<ClassName> result = new ArrayList<>();
+ for (ClassName c = this; c != null; c = c.enclosingClassName) {
+ result.add(c);
+ }
+ Collections.reverse(result);
+ return result;
+ }
+}
diff --git a/src/main/java/com/squareup/javapoet/CodeBlock.java b/src/main/java/com/squareup/javapoet/CodeBlock.java
new file mode 100644
index 0000000..33e3846
--- /dev/null
+++ b/src/main/java/com/squareup/javapoet/CodeBlock.java
@@ -0,0 +1,464 @@
+/*
+ * Copyright (C) 2015 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collector;
+import java.util.stream.StreamSupport;
+import javax.lang.model.element.Element;
+import javax.lang.model.type.TypeMirror;
+
+import static com.squareup.javapoet.Util.checkArgument;
+
+/**
+ * A fragment of a .java file, potentially containing declarations, statements, and documentation.
+ * Code blocks are not necessarily well-formed Java code, and are not validated. This class assumes
+ * javac will check correctness later!
+ *
+ * <p>Code blocks support placeholders like {@link java.text.Format}. Where {@link String#format}
+ * uses percent {@code %} to reference target values, this class uses dollar sign {@code $} and has
+ * its own set of permitted placeholders:
+ *
+ * <ul>
+ * <li>{@code $L} emits a <em>literal</em> value with no escaping. Arguments for literals may be
+ * strings, primitives, {@linkplain TypeSpec type declarations}, {@linkplain AnnotationSpec
+ * annotations} and even other code blocks.
+ * <li>{@code $N} emits a <em>name</em>, using name collision avoidance where necessary. Arguments
+ * for names may be strings (actually any {@linkplain CharSequence character sequence}),
+ * {@linkplain ParameterSpec parameters}, {@linkplain FieldSpec fields}, {@linkplain
+ * MethodSpec methods}, and {@linkplain TypeSpec types}.
+ * <li>{@code $S} escapes the value as a <em>string</em>, wraps it with double quotes, and emits
+ * that. For example, {@code 6" sandwich} is emitted {@code "6\" sandwich"}.
+ * <li>{@code $T} emits a <em>type</em> reference. Types will be imported if possible. Arguments
+ * for types may be {@linkplain Class classes}, {@linkplain javax.lang.model.type.TypeMirror
+,* type mirrors}, and {@linkplain javax.lang.model.element.Element elements}.
+ * <li>{@code $$} emits a dollar sign.
+ * <li>{@code $W} emits a space or a newline, depending on its position on the line. This prefers
+ * to wrap lines before 100 columns.
+ * <li>{@code $Z} acts as a zero-width space. This prefers to wrap lines before 100 columns.
+ * <li>{@code $>} increases the indentation level.
+ * <li>{@code $<} decreases the indentation level.
+ * <li>{@code $[} begins a statement. For multiline statements, every line after the first line
+ * is double-indented.
+ * <li>{@code $]} ends a statement.
+ * </ul>
+ */
+public final class CodeBlock {
+ private static final Pattern NAMED_ARGUMENT =
+ Pattern.compile("\\$(?<argumentName>[\\w_]+):(?<typeChar>[\\w]).*");
+ private static final Pattern LOWERCASE = Pattern.compile("[a-z]+[\\w_]*");
+
+ /** A heterogeneous list containing string literals and value placeholders. */
+ final List<String> formatParts;
+ final List<Object> args;
+
+ private CodeBlock(Builder builder) {
+ this.formatParts = Util.immutableList(builder.formatParts);
+ this.args = Util.immutableList(builder.args);
+ }
+
+ public boolean isEmpty() {
+ return formatParts.isEmpty();
+ }
+
+ @Override public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o == null) return false;
+ if (getClass() != o.getClass()) return false;
+ return toString().equals(o.toString());
+ }
+
+ @Override public int hashCode() {
+ return toString().hashCode();
+ }
+
+ @Override public String toString() {
+ StringBuilder out = new StringBuilder();
+ try {
+ new CodeWriter(out).emit(this);
+ return out.toString();
+ } catch (IOException e) {
+ throw new AssertionError();
+ }
+ }
+
+ public static CodeBlock of(String format, Object... args) {
+ return new Builder().add(format, args).build();
+ }
+
+ /**
+ * Joins {@code codeBlocks} into a single {@link CodeBlock}, each separated by {@code separator}.
+ * For example, joining {@code String s}, {@code Object o} and {@code int i} using {@code ", "}
+ * would produce {@code String s, Object o, int i}.
+ */
+ public static CodeBlock join(Iterable<CodeBlock> codeBlocks, String separator) {
+ return StreamSupport.stream(codeBlocks.spliterator(), false).collect(joining(separator));
+ }
+
+ /**
+ * A {@link Collector} implementation that joins {@link CodeBlock} instances together into one
+ * separated by {@code separator}. For example, joining {@code String s}, {@code Object o} and
+ * {@code int i} using {@code ", "} would produce {@code String s, Object o, int i}.
+ */
+ public static Collector<CodeBlock, ?, CodeBlock> joining(String separator) {
+ return Collector.of(
+ () -> new CodeBlockJoiner(separator, builder()),
+ CodeBlockJoiner::add,
+ CodeBlockJoiner::merge,
+ CodeBlockJoiner::join);
+ }
+
+ /**
+ * A {@link Collector} implementation that joins {@link CodeBlock} instances together into one
+ * separated by {@code separator}. For example, joining {@code String s}, {@code Object o} and
+ * {@code int i} using {@code ", "} would produce {@code String s, Object o, int i}.
+ */
+ public static Collector<CodeBlock, ?, CodeBlock> joining(
+ String separator, String prefix, String suffix) {
+ Builder builder = builder().add("$N", prefix);
+ return Collector.of(
+ () -> new CodeBlockJoiner(separator, builder),
+ CodeBlockJoiner::add,
+ CodeBlockJoiner::merge,
+ joiner -> {
+ builder.add(CodeBlock.of("$N", suffix));
+ return joiner.join();
+ });
+ }
+
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ public Builder toBuilder() {
+ Builder builder = new Builder();
+ builder.formatParts.addAll(formatParts);
+ builder.args.addAll(args);
+ return builder;
+ }
+
+ public static final class Builder {
+ final List<String> formatParts = new ArrayList<>();
+ final List<Object> args = new ArrayList<>();
+
+ private Builder() {
+ }
+
+ public boolean isEmpty() {
+ return formatParts.isEmpty();
+ }
+
+ /**
+ * Adds code using named arguments.
+ *
+ * <p>Named arguments specify their name after the '$' followed by : and the corresponding type
+ * character. Argument names consist of characters in {@code a-z, A-Z, 0-9, and _} and must
+ * start with a lowercase character.
+ *
+ * <p>For example, to refer to the type {@link java.lang.Integer} with the argument name {@code
+ * clazz} use a format string containing {@code $clazz:T} and include the key {@code clazz} with
+ * value {@code java.lang.Integer.class} in the argument map.
+ */
+ public Builder addNamed(String format, Map<String, ?> arguments) {
+ int p = 0;
+
+ for (String argument : arguments.keySet()) {
+ checkArgument(LOWERCASE.matcher(argument).matches(),
+ "argument '%s' must start with a lowercase character", argument);
+ }
+
+ while (p < format.length()) {
+ int nextP = format.indexOf("$", p);
+ if (nextP == -1) {
+ formatParts.add(format.substring(p, format.length()));
+ break;
+ }
+
+ if (p != nextP) {
+ formatParts.add(format.substring(p, nextP));
+ p = nextP;
+ }
+
+ Matcher matcher = null;
+ int colon = format.indexOf(':', p);
+ if (colon != -1) {
+ int endIndex = Math.min(colon + 2, format.length());
+ matcher = NAMED_ARGUMENT.matcher(format.substring(p, endIndex));
+ }
+ if (matcher != null && matcher.lookingAt()) {
+ String argumentName = matcher.group("argumentName");
+ checkArgument(arguments.containsKey(argumentName), "Missing named argument for $%s",
+ argumentName);
+ char formatChar = matcher.group("typeChar").charAt(0);
+ addArgument(format, formatChar, arguments.get(argumentName));
+ formatParts.add("$" + formatChar);
+ p += matcher.regionEnd();
+ } else {
+ checkArgument(p < format.length() - 1, "dangling $ at end");
+ checkArgument(isNoArgPlaceholder(format.charAt(p + 1)),
+ "unknown format $%s at %s in '%s'", format.charAt(p + 1), p + 1, format);
+ formatParts.add(format.substring(p, p + 2));
+ p += 2;
+ }
+ }
+
+ return this;
+ }
+
+ /**
+ * Add code with positional or relative arguments.
+ *
+ * <p>Relative arguments map 1:1 with the placeholders in the format string.
+ *
+ * <p>Positional arguments use an index after the placeholder to identify which argument index
+ * to use. For example, for a literal to reference the 3rd argument: "$3L" (1 based index)
+ *
+ * <p>Mixing relative and positional arguments in a call to add is invalid and will result in an
+ * error.
+ */
+ public Builder add(String format, Object... args) {
+ boolean hasRelative = false;
+ boolean hasIndexed = false;
+
+ int relativeParameterCount = 0;
+ int[] indexedParameterCount = new int[args.length];
+
+ for (int p = 0; p < format.length(); ) {
+ if (format.charAt(p) != '$') {
+ int nextP = format.indexOf('$', p + 1);
+ if (nextP == -1) nextP = format.length();
+ formatParts.add(format.substring(p, nextP));
+ p = nextP;
+ continue;
+ }
+
+ p++; // '$'.
+
+ // Consume zero or more digits, leaving 'c' as the first non-digit char after the '$'.
+ int indexStart = p;
+ char c;
+ do {
+ checkArgument(p < format.length(), "dangling format characters in '%s'", format);
+ c = format.charAt(p++);
+ } while (c >= '0' && c <= '9');
+ int indexEnd = p - 1;
+
+ // If 'c' doesn't take an argument, we're done.
+ if (isNoArgPlaceholder(c)) {
+ checkArgument(
+ indexStart == indexEnd, "$$, $>, $<, $[, $], $W, and $Z may not have an index");
+ formatParts.add("$" + c);
+ continue;
+ }
+
+ // Find either the indexed argument, or the relative argument. (0-based).
+ int index;
+ if (indexStart < indexEnd) {
+ index = Integer.parseInt(format.substring(indexStart, indexEnd)) - 1;
+ hasIndexed = true;
+ if (args.length > 0) {
+ indexedParameterCount[index % args.length]++; // modulo is needed, checked below anyway
+ }
+ } else {
+ index = relativeParameterCount;
+ hasRelative = true;
+ relativeParameterCount++;
+ }
+
+ checkArgument(index >= 0 && index < args.length,
+ "index %d for '%s' not in range (received %s arguments)",
+ index + 1, format.substring(indexStart - 1, indexEnd + 1), args.length);
+ checkArgument(!hasIndexed || !hasRelative, "cannot mix indexed and positional parameters");
+
+ addArgument(format, c, args[index]);
+
+ formatParts.add("$" + c);
+ }
+
+ if (hasRelative) {
+ checkArgument(relativeParameterCount >= args.length,
+ "unused arguments: expected %s, received %s", relativeParameterCount, args.length);
+ }
+ if (hasIndexed) {
+ List<String> unused = new ArrayList<>();
+ for (int i = 0; i < args.length; i++) {
+ if (indexedParameterCount[i] == 0) {
+ unused.add("$" + (i + 1));
+ }
+ }
+ String s = unused.size() == 1 ? "" : "s";
+ checkArgument(unused.isEmpty(), "unused argument%s: %s", s, String.join(", ", unused));
+ }
+ return this;
+ }
+
+ private boolean isNoArgPlaceholder(char c) {
+ return c == '$' || c == '>' || c == '<' || c == '[' || c == ']' || c == 'W' || c == 'Z';
+ }
+
+ private void addArgument(String format, char c, Object arg) {
+ switch (c) {
+ case 'N':
+ this.args.add(argToName(arg));
+ break;
+ case 'L':
+ this.args.add(argToLiteral(arg));
+ break;
+ case 'S':
+ this.args.add(argToString(arg));
+ break;
+ case 'T':
+ this.args.add(argToType(arg));
+ break;
+ default:
+ throw new IllegalArgumentException(
+ String.format("invalid format string: '%s'", format));
+ }
+ }
+
+ private String argToName(Object o) {
+ if (o instanceof CharSequence) return o.toString();
+ if (o instanceof ParameterSpec) return ((ParameterSpec) o).name;
+ if (o instanceof FieldSpec) return ((FieldSpec) o).name;
+ if (o instanceof MethodSpec) return ((MethodSpec) o).name;
+ if (o instanceof TypeSpec) return ((TypeSpec) o).name;
+ throw new IllegalArgumentException("expected name but was " + o);
+ }
+
+ private Object argToLiteral(Object o) {
+ return o;
+ }
+
+ private String argToString(Object o) {
+ return o != null ? String.valueOf(o) : null;
+ }
+
+ private TypeName argToType(Object o) {
+ if (o instanceof TypeName) return (TypeName) o;
+ if (o instanceof TypeMirror) return TypeName.get((TypeMirror) o);
+ if (o instanceof Element) return TypeName.get(((Element) o).asType());
+ if (o instanceof Type) return TypeName.get((Type) o);
+ throw new IllegalArgumentException("expected type but was " + o);
+ }
+
+ /**
+ * @param controlFlow the control flow construct and its code, such as "if (foo == 5)".
+ * Shouldn't contain braces or newline characters.
+ */
+ public Builder beginControlFlow(String controlFlow, Object... args) {
+ add(controlFlow + " {\n", args);
+ indent();
+ return this;
+ }
+
+ /**
+ * @param controlFlow the control flow construct and its code, such as "else if (foo == 10)".
+ * Shouldn't contain braces or newline characters.
+ */
+ public Builder nextControlFlow(String controlFlow, Object... args) {
+ unindent();
+ add("} " + controlFlow + " {\n", args);
+ indent();
+ return this;
+ }
+
+ public Builder endControlFlow() {
+ unindent();
+ add("}\n");
+ return this;
+ }
+
+ /**
+ * @param controlFlow the optional control flow construct and its code, such as
+ * "while(foo == 20)". Only used for "do/while" control flows.
+ */
+ public Builder endControlFlow(String controlFlow, Object... args) {
+ unindent();
+ add("} " + controlFlow + ";\n", args);
+ return this;
+ }
+
+ public Builder addStatement(String format, Object... args) {
+ add("$[");
+ add(format, args);
+ add(";\n$]");
+ return this;
+ }
+
+ public Builder addStatement(CodeBlock codeBlock) {
+ return addStatement("$L", codeBlock);
+ }
+
+ public Builder add(CodeBlock codeBlock) {
+ formatParts.addAll(codeBlock.formatParts);
+ args.addAll(codeBlock.args);
+ return this;
+ }
+
+ public Builder indent() {
+ this.formatParts.add("$>");
+ return this;
+ }
+
+ public Builder unindent() {
+ this.formatParts.add("$<");
+ return this;
+ }
+
+ public CodeBlock build() {
+ return new CodeBlock(this);
+ }
+ }
+
+ private static final class CodeBlockJoiner {
+ private final String delimiter;
+ private final Builder builder;
+ private boolean first = true;
+
+ CodeBlockJoiner(String delimiter, Builder builder) {
+ this.delimiter = delimiter;
+ this.builder = builder;
+ }
+
+ CodeBlockJoiner add(CodeBlock codeBlock) {
+ if (!first) {
+ builder.add(delimiter);
+ }
+ first = false;
+
+ builder.add(codeBlock);
+ return this;
+ }
+
+ CodeBlockJoiner merge(CodeBlockJoiner other) {
+ CodeBlock otherBlock = other.builder.build();
+ if (!otherBlock.isEmpty()) {
+ add(otherBlock);
+ }
+ return this;
+ }
+
+ CodeBlock join() {
+ return builder.build();
+ }
+ }
+}
diff --git a/src/main/java/com/squareup/javapoet/CodeWriter.java b/src/main/java/com/squareup/javapoet/CodeWriter.java
new file mode 100644
index 0000000..542f434
--- /dev/null
+++ b/src/main/java/com/squareup/javapoet/CodeWriter.java
@@ -0,0 +1,497 @@
+/*
+ * Copyright (C) 2015 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Modifier;
+
+import static com.squareup.javapoet.Util.checkArgument;
+import static com.squareup.javapoet.Util.checkNotNull;
+import static com.squareup.javapoet.Util.checkState;
+import static com.squareup.javapoet.Util.stringLiteralWithDoubleQuotes;
+import static java.lang.String.join;
+
+/**
+ * Converts a {@link JavaFile} to a string suitable to both human- and javac-consumption. This
+ * honors imports, indentation, and deferred variable names.
+ */
+final class CodeWriter {
+ /** Sentinel value that indicates that no user-provided package has been set. */
+ private static final String NO_PACKAGE = new String();
+
+ private final String indent;
+ private final LineWrapper out;
+ private int indentLevel;
+
+ private boolean javadoc = false;
+ private boolean comment = false;
+ private String packageName = NO_PACKAGE;
+ private final List<TypeSpec> typeSpecStack = new ArrayList<>();
+ private final Set<String> staticImportClassNames;
+ private final Set<String> staticImports;
+ private final Map<String, ClassName> importedTypes;
+ private final Map<String, ClassName> importableTypes = new LinkedHashMap<>();
+ private final Set<String> referencedNames = new LinkedHashSet<>();
+ private boolean trailingNewline;
+
+ /**
+ * When emitting a statement, this is the line of the statement currently being written. The first
+ * line of a statement is indented normally and subsequent wrapped lines are double-indented. This
+ * is -1 when the currently-written line isn't part of a statement.
+ */
+ int statementLine = -1;
+
+ CodeWriter(Appendable out) {
+ this(out, " ", Collections.emptySet());
+ }
+
+ CodeWriter(Appendable out, String indent, Set<String> staticImports) {
+ this(out, indent, Collections.emptyMap(), staticImports);
+ }
+
+ CodeWriter(Appendable out, String indent, Map<String, ClassName> importedTypes,
+ Set<String> staticImports) {
+ this.out = new LineWrapper(out, indent, 100);
+ this.indent = checkNotNull(indent, "indent == null");
+ this.importedTypes = checkNotNull(importedTypes, "importedTypes == null");
+ this.staticImports = checkNotNull(staticImports, "staticImports == null");
+ this.staticImportClassNames = new LinkedHashSet<>();
+ for (String signature : staticImports) {
+ staticImportClassNames.add(signature.substring(0, signature.lastIndexOf('.')));
+ }
+ }
+
+ public Map<String, ClassName> importedTypes() {
+ return importedTypes;
+ }
+
+ public CodeWriter indent() {
+ return indent(1);
+ }
+
+ public CodeWriter indent(int levels) {
+ indentLevel += levels;
+ return this;
+ }
+
+ public CodeWriter unindent() {
+ return unindent(1);
+ }
+
+ public CodeWriter unindent(int levels) {
+ checkArgument(indentLevel - levels >= 0, "cannot unindent %s from %s", levels, indentLevel);
+ indentLevel -= levels;
+ return this;
+ }
+
+ public CodeWriter pushPackage(String packageName) {
+ checkState(this.packageName == NO_PACKAGE, "package already set: %s", this.packageName);
+ this.packageName = checkNotNull(packageName, "packageName == null");
+ return this;
+ }
+
+ public CodeWriter popPackage() {
+ checkState(this.packageName != NO_PACKAGE, "package not set");
+ this.packageName = NO_PACKAGE;
+ return this;
+ }
+
+ public CodeWriter pushType(TypeSpec type) {
+ this.typeSpecStack.add(type);
+ return this;
+ }
+
+ public CodeWriter popType() {
+ this.typeSpecStack.remove(typeSpecStack.size() - 1);
+ return this;
+ }
+
+ public void emitComment(CodeBlock codeBlock) throws IOException {
+ trailingNewline = true; // Force the '//' prefix for the comment.
+ comment = true;
+ try {
+ emit(codeBlock);
+ emit("\n");
+ } finally {
+ comment = false;
+ }
+ }
+
+ public void emitJavadoc(CodeBlock javadocCodeBlock) throws IOException {
+ if (javadocCodeBlock.isEmpty()) return;
+
+ emit("/**\n");
+ javadoc = true;
+ try {
+ emit(javadocCodeBlock);
+ } finally {
+ javadoc = false;
+ }
+ emit(" */\n");
+ }
+
+ public void emitAnnotations(List<AnnotationSpec> annotations, boolean inline) throws IOException {
+ for (AnnotationSpec annotationSpec : annotations) {
+ annotationSpec.emit(this, inline);
+ emit(inline ? " " : "\n");
+ }
+ }
+
+ /**
+ * Emits {@code modifiers} in the standard order. Modifiers in {@code implicitModifiers} will not
+ * be emitted.
+ */
+ public void emitModifiers(Set<Modifier> modifiers, Set<Modifier> implicitModifiers)
+ throws IOException {
+ if (modifiers.isEmpty()) return;
+ for (Modifier modifier : EnumSet.copyOf(modifiers)) {
+ if (implicitModifiers.contains(modifier)) continue;
+ emitAndIndent(modifier.name().toLowerCase(Locale.US));
+ emitAndIndent(" ");
+ }
+ }
+
+ public void emitModifiers(Set<Modifier> modifiers) throws IOException {
+ emitModifiers(modifiers, Collections.emptySet());
+ }
+
+ /**
+ * Emit type variables with their bounds. This should only be used when declaring type variables;
+ * everywhere else bounds are omitted.
+ */
+ public void emitTypeVariables(List<TypeVariableName> typeVariables) throws IOException {
+ if (typeVariables.isEmpty()) return;
+
+ emit("<");
+ boolean firstTypeVariable = true;
+ for (TypeVariableName typeVariable : typeVariables) {
+ if (!firstTypeVariable) emit(", ");
+ emitAnnotations(typeVariable.annotations, true);
+ emit("$L", typeVariable.name);
+ boolean firstBound = true;
+ for (TypeName bound : typeVariable.bounds) {
+ emit(firstBound ? " extends $T" : " & $T", bound);
+ firstBound = false;
+ }
+ firstTypeVariable = false;
+ }
+ emit(">");
+ }
+
+ public CodeWriter emit(String s) throws IOException {
+ return emitAndIndent(s);
+ }
+
+ public CodeWriter emit(String format, Object... args) throws IOException {
+ return emit(CodeBlock.of(format, args));
+ }
+
+ public CodeWriter emit(CodeBlock codeBlock) throws IOException {
+ int a = 0;
+ ClassName deferredTypeName = null; // used by "import static" logic
+ ListIterator<String> partIterator = codeBlock.formatParts.listIterator();
+ while (partIterator.hasNext()) {
+ String part = partIterator.next();
+ switch (part) {
+ case "$L":
+ emitLiteral(codeBlock.args.get(a++));
+ break;
+
+ case "$N":
+ emitAndIndent((String) codeBlock.args.get(a++));
+ break;
+
+ case "$S":
+ String string = (String) codeBlock.args.get(a++);
+ // Emit null as a literal null: no quotes.
+ emitAndIndent(string != null
+ ? stringLiteralWithDoubleQuotes(string, indent)
+ : "null");
+ break;
+
+ case "$T":
+ TypeName typeName = (TypeName) codeBlock.args.get(a++);
+ // defer "typeName.emit(this)" if next format part will be handled by the default case
+ if (typeName instanceof ClassName && partIterator.hasNext()) {
+ if (!codeBlock.formatParts.get(partIterator.nextIndex()).startsWith("$")) {
+ ClassName candidate = (ClassName) typeName;
+ if (staticImportClassNames.contains(candidate.canonicalName)) {
+ checkState(deferredTypeName == null, "pending type for static import?!");
+ deferredTypeName = candidate;
+ break;
+ }
+ }
+ }
+ typeName.emit(this);
+ break;
+
+ case "$$":
+ emitAndIndent("$");
+ break;
+
+ case "$>":
+ indent();
+ break;
+
+ case "$<":
+ unindent();
+ break;
+
+ case "$[":
+ checkState(statementLine == -1, "statement enter $[ followed by statement enter $[");
+ statementLine = 0;
+ break;
+
+ case "$]":
+ checkState(statementLine != -1, "statement exit $] has no matching statement enter $[");
+ if (statementLine > 0) {
+ unindent(2); // End a multi-line statement. Decrease the indentation level.
+ }
+ statementLine = -1;
+ break;
+
+ case "$W":
+ out.wrappingSpace(indentLevel + 2);
+ break;
+
+ case "$Z":
+ out.zeroWidthSpace(indentLevel + 2);
+ break;
+
+ default:
+ // handle deferred type
+ if (deferredTypeName != null) {
+ if (part.startsWith(".")) {
+ if (emitStaticImportMember(deferredTypeName.canonicalName, part)) {
+ // okay, static import hit and all was emitted, so clean-up and jump to next part
+ deferredTypeName = null;
+ break;
+ }
+ }
+ deferredTypeName.emit(this);
+ deferredTypeName = null;
+ }
+ emitAndIndent(part);
+ break;
+ }
+ }
+ return this;
+ }
+
+ public CodeWriter emitWrappingSpace() throws IOException {
+ out.wrappingSpace(indentLevel + 2);
+ return this;
+ }
+
+ private static String extractMemberName(String part) {
+ checkArgument(Character.isJavaIdentifierStart(part.charAt(0)), "not an identifier: %s", part);
+ for (int i = 1; i <= part.length(); i++) {
+ if (!SourceVersion.isIdentifier(part.substring(0, i))) {
+ return part.substring(0, i - 1);
+ }
+ }
+ return part;
+ }
+
+ private boolean emitStaticImportMember(String canonical, String part) throws IOException {
+ String partWithoutLeadingDot = part.substring(1);
+ if (partWithoutLeadingDot.isEmpty()) return false;
+ char first = partWithoutLeadingDot.charAt(0);
+ if (!Character.isJavaIdentifierStart(first)) return false;
+ String explicit = canonical + "." + extractMemberName(partWithoutLeadingDot);
+ String wildcard = canonical + ".*";
+ if (staticImports.contains(explicit) || staticImports.contains(wildcard)) {
+ emitAndIndent(partWithoutLeadingDot);
+ return true;
+ }
+ return false;
+ }
+
+ private void emitLiteral(Object o) throws IOException {
+ if (o instanceof TypeSpec) {
+ TypeSpec typeSpec = (TypeSpec) o;
+ typeSpec.emit(this, null, Collections.emptySet());
+ } else if (o instanceof AnnotationSpec) {
+ AnnotationSpec annotationSpec = (AnnotationSpec) o;
+ annotationSpec.emit(this, true);
+ } else if (o instanceof CodeBlock) {
+ CodeBlock codeBlock = (CodeBlock) o;
+ emit(codeBlock);
+ } else {
+ emitAndIndent(String.valueOf(o));
+ }
+ }
+
+ /**
+ * Returns the best name to identify {@code className} with in the current context. This uses the
+ * available imports and the current scope to find the shortest name available. It does not honor
+ * names visible due to inheritance.
+ */
+ String lookupName(ClassName className) {
+ // Find the shortest suffix of className that resolves to className. This uses both local type
+ // names (so `Entry` in `Map` refers to `Map.Entry`). Also uses imports.
+ boolean nameResolved = false;
+ for (ClassName c = className; c != null; c = c.enclosingClassName()) {
+ ClassName resolved = resolve(c.simpleName());
+ nameResolved = resolved != null;
+
+ if (resolved != null && Objects.equals(resolved.canonicalName, c.canonicalName)) {
+ int suffixOffset = c.simpleNames().size() - 1;
+ return join(".", className.simpleNames().subList(
+ suffixOffset, className.simpleNames().size()));
+ }
+ }
+
+ // If the name resolved but wasn't a match, we're stuck with the fully qualified name.
+ if (nameResolved) {
+ return className.canonicalName;
+ }
+
+ // If the class is in the same package, we're done.
+ if (Objects.equals(packageName, className.packageName())) {
+ referencedNames.add(className.topLevelClassName().simpleName());
+ return join(".", className.simpleNames());
+ }
+
+ // We'll have to use the fully-qualified name. Mark the type as importable for a future pass.
+ if (!javadoc) {
+ importableType(className);
+ }
+
+ return className.canonicalName;
+ }
+
+ private void importableType(ClassName className) {
+ if (className.packageName().isEmpty()) {
+ return;
+ }
+ ClassName topLevelClassName = className.topLevelClassName();
+ String simpleName = topLevelClassName.simpleName();
+ ClassName replaced = importableTypes.put(simpleName, topLevelClassName);
+ if (replaced != null) {
+ importableTypes.put(simpleName, replaced); // On collision, prefer the first inserted.
+ }
+ }
+
+ /**
+ * Returns the class referenced by {@code simpleName}, using the current nesting context and
+ * imports.
+ */
+ // TODO(jwilson): also honor superclass members when resolving names.
+ private ClassName resolve(String simpleName) {
+ // Match a child of the current (potentially nested) class.
+ for (int i = typeSpecStack.size() - 1; i >= 0; i--) {
+ TypeSpec typeSpec = typeSpecStack.get(i);
+ for (TypeSpec visibleChild : typeSpec.typeSpecs) {
+ if (Objects.equals(visibleChild.name, simpleName)) {
+ return stackClassName(i, simpleName);
+ }
+ }
+ }
+
+ // Match the top-level class.
+ if (typeSpecStack.size() > 0 && Objects.equals(typeSpecStack.get(0).name, simpleName)) {
+ return ClassName.get(packageName, simpleName);
+ }
+
+ // Match an imported type.
+ ClassName importedType = importedTypes.get(simpleName);
+ if (importedType != null) return importedType;
+
+ // No match.
+ return null;
+ }
+
+ /** Returns the class named {@code simpleName} when nested in the class at {@code stackDepth}. */
+ private ClassName stackClassName(int stackDepth, String simpleName) {
+ ClassName className = ClassName.get(packageName, typeSpecStack.get(0).name);
+ for (int i = 1; i <= stackDepth; i++) {
+ className = className.nestedClass(typeSpecStack.get(i).name);
+ }
+ return className.nestedClass(simpleName);
+ }
+
+ /**
+ * Emits {@code s} with indentation as required. It's important that all code that writes to
+ * {@link #out} does it through here, since we emit indentation lazily in order to avoid
+ * unnecessary trailing whitespace.
+ */
+ CodeWriter emitAndIndent(String s) throws IOException {
+ boolean first = true;
+ for (String line : s.split("\n", -1)) {
+ // Emit a newline character. Make sure blank lines in Javadoc & comments look good.
+ if (!first) {
+ if ((javadoc || comment) && trailingNewline) {
+ emitIndentation();
+ out.append(javadoc ? " *" : "//");
+ }
+ out.append("\n");
+ trailingNewline = true;
+ if (statementLine != -1) {
+ if (statementLine == 0) {
+ indent(2); // Begin multiple-line statement. Increase the indentation level.
+ }
+ statementLine++;
+ }
+ }
+
+ first = false;
+ if (line.isEmpty()) continue; // Don't indent empty lines.
+
+ // Emit indentation and comment prefix if necessary.
+ if (trailingNewline) {
+ emitIndentation();
+ if (javadoc) {
+ out.append(" * ");
+ } else if (comment) {
+ out.append("// ");
+ }
+ }
+
+ out.append(line);
+ trailingNewline = false;
+ }
+ return this;
+ }
+
+ private void emitIndentation() throws IOException {
+ for (int j = 0; j < indentLevel; j++) {
+ out.append(indent);
+ }
+ }
+
+ /**
+ * Returns the types that should have been imported for this code. If there were any simple name
+ * collisions, that type's first use is imported.
+ */
+ Map<String, ClassName> suggestedImports() {
+ Map<String, ClassName> result = new LinkedHashMap<>(importableTypes);
+ result.keySet().removeAll(referencedNames);
+ return result;
+ }
+}
diff --git a/src/main/java/com/squareup/javapoet/FieldSpec.java b/src/main/java/com/squareup/javapoet/FieldSpec.java
new file mode 100644
index 0000000..851b36d
--- /dev/null
+++ b/src/main/java/com/squareup/javapoet/FieldSpec.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright (C) 2015 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Modifier;
+
+import static com.squareup.javapoet.Util.checkArgument;
+import static com.squareup.javapoet.Util.checkNotNull;
+import static com.squareup.javapoet.Util.checkState;
+
+/** A generated field declaration. */
+public final class FieldSpec {
+ public final TypeName type;
+ public final String name;
+ public final CodeBlock javadoc;
+ public final List<AnnotationSpec> annotations;
+ public final Set<Modifier> modifiers;
+ public final CodeBlock initializer;
+
+ private FieldSpec(Builder builder) {
+ this.type = checkNotNull(builder.type, "type == null");
+ this.name = checkNotNull(builder.name, "name == null");
+ this.javadoc = builder.javadoc.build();
+ this.annotations = Util.immutableList(builder.annotations);
+ this.modifiers = Util.immutableSet(builder.modifiers);
+ this.initializer = (builder.initializer == null)
+ ? CodeBlock.builder().build()
+ : builder.initializer;
+ }
+
+ public boolean hasModifier(Modifier modifier) {
+ return modifiers.contains(modifier);
+ }
+
+ void emit(CodeWriter codeWriter, Set<Modifier> implicitModifiers) throws IOException {
+ codeWriter.emitJavadoc(javadoc);
+ codeWriter.emitAnnotations(annotations, false);
+ codeWriter.emitModifiers(modifiers, implicitModifiers);
+ codeWriter.emit("$T $L", type, name);
+ if (!initializer.isEmpty()) {
+ codeWriter.emit(" = ");
+ codeWriter.emit(initializer);
+ }
+ codeWriter.emit(";\n");
+ }
+
+ @Override public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o == null) return false;
+ if (getClass() != o.getClass()) return false;
+ return toString().equals(o.toString());
+ }
+
+ @Override public int hashCode() {
+ return toString().hashCode();
+ }
+
+ @Override public String toString() {
+ StringBuilder out = new StringBuilder();
+ try {
+ CodeWriter codeWriter = new CodeWriter(out);
+ emit(codeWriter, Collections.emptySet());
+ return out.toString();
+ } catch (IOException e) {
+ throw new AssertionError();
+ }
+ }
+
+ public static Builder builder(TypeName type, String name, Modifier... modifiers) {
+ checkNotNull(type, "type == null");
+ checkArgument(SourceVersion.isName(name), "not a valid name: %s", name);
+ return new Builder(type, name)
+ .addModifiers(modifiers);
+ }
+
+ public static Builder builder(Type type, String name, Modifier... modifiers) {
+ return builder(TypeName.get(type), name, modifiers);
+ }
+
+ public Builder toBuilder() {
+ Builder builder = new Builder(type, name);
+ builder.javadoc.add(javadoc);
+ builder.annotations.addAll(annotations);
+ builder.modifiers.addAll(modifiers);
+ builder.initializer = initializer.isEmpty() ? null : initializer;
+ return builder;
+ }
+
+ public static final class Builder {
+ private final TypeName type;
+ private final String name;
+
+ private final CodeBlock.Builder javadoc = CodeBlock.builder();
+ private final List<AnnotationSpec> annotations = new ArrayList<>();
+ private final List<Modifier> modifiers = new ArrayList<>();
+ private CodeBlock initializer = null;
+
+ private Builder(TypeName type, String name) {
+ this.type = type;
+ this.name = name;
+ }
+
+ public Builder addJavadoc(String format, Object... args) {
+ javadoc.add(format, args);
+ return this;
+ }
+
+ public Builder addJavadoc(CodeBlock block) {
+ javadoc.add(block);
+ return this;
+ }
+
+ public Builder addAnnotations(Iterable<AnnotationSpec> annotationSpecs) {
+ checkArgument(annotationSpecs != null, "annotationSpecs == null");
+ for (AnnotationSpec annotationSpec : annotationSpecs) {
+ this.annotations.add(annotationSpec);
+ }
+ return this;
+ }
+
+ public Builder addAnnotation(AnnotationSpec annotationSpec) {
+ this.annotations.add(annotationSpec);
+ return this;
+ }
+
+ public Builder addAnnotation(ClassName annotation) {
+ this.annotations.add(AnnotationSpec.builder(annotation).build());
+ return this;
+ }
+
+ public Builder addAnnotation(Class<?> annotation) {
+ return addAnnotation(ClassName.get(annotation));
+ }
+
+ public Builder addModifiers(Modifier... modifiers) {
+ Collections.addAll(this.modifiers, modifiers);
+ return this;
+ }
+
+ public Builder initializer(String format, Object... args) {
+ return initializer(CodeBlock.of(format, args));
+ }
+
+ public Builder initializer(CodeBlock codeBlock) {
+ checkState(this.initializer == null, "initializer was already set");
+ this.initializer = checkNotNull(codeBlock, "codeBlock == null");
+ return this;
+ }
+
+ public FieldSpec build() {
+ return new FieldSpec(this);
+ }
+ }
+}
diff --git a/src/main/java/com/squareup/javapoet/JavaFile.java b/src/main/java/com/squareup/javapoet/JavaFile.java
new file mode 100644
index 0000000..e7662dd
--- /dev/null
+++ b/src/main/java/com/squareup/javapoet/JavaFile.java
@@ -0,0 +1,274 @@
+/*
+ * Copyright (C) 2015 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.net.URI;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+import javax.annotation.processing.Filer;
+import javax.lang.model.element.Element;
+import javax.tools.JavaFileObject;
+import javax.tools.JavaFileObject.Kind;
+import javax.tools.SimpleJavaFileObject;
+
+import static com.squareup.javapoet.Util.checkArgument;
+import static com.squareup.javapoet.Util.checkNotNull;
+import static java.nio.charset.StandardCharsets.UTF_8;
+
+/** A Java file containing a single top level class. */
+public final class JavaFile {
+ private static final Appendable NULL_APPENDABLE = new Appendable() {
+ @Override public Appendable append(CharSequence charSequence) {
+ return this;
+ }
+ @Override public Appendable append(CharSequence charSequence, int start, int end) {
+ return this;
+ }
+ @Override public Appendable append(char c) {
+ return this;
+ }
+ };
+
+ public final CodeBlock fileComment;
+ public final String packageName;
+ public final TypeSpec typeSpec;
+ public final boolean skipJavaLangImports;
+ private final Set<String> staticImports;
+ private final String indent;
+
+ private JavaFile(Builder builder) {
+ this.fileComment = builder.fileComment.build();
+ this.packageName = builder.packageName;
+ this.typeSpec = builder.typeSpec;
+ this.skipJavaLangImports = builder.skipJavaLangImports;
+ this.staticImports = Util.immutableSet(builder.staticImports);
+ this.indent = builder.indent;
+ }
+
+ public void writeTo(Appendable out) throws IOException {
+ // First pass: emit the entire class, just to collect the types we'll need to import.
+ CodeWriter importsCollector = new CodeWriter(NULL_APPENDABLE, indent, staticImports);
+ emit(importsCollector);
+ Map<String, ClassName> suggestedImports = importsCollector.suggestedImports();
+
+ // Second pass: write the code, taking advantage of the imports.
+ CodeWriter codeWriter = new CodeWriter(out, indent, suggestedImports, staticImports);
+ emit(codeWriter);
+ }
+
+ /** Writes this to {@code directory} as UTF-8 using the standard directory structure. */
+ public void writeTo(Path directory) throws IOException {
+ checkArgument(Files.notExists(directory) || Files.isDirectory(directory),
+ "path %s exists but is not a directory.", directory);
+ Path outputDirectory = directory;
+ if (!packageName.isEmpty()) {
+ for (String packageComponent : packageName.split("\\.")) {
+ outputDirectory = outputDirectory.resolve(packageComponent);
+ }
+ Files.createDirectories(outputDirectory);
+ }
+
+ Path outputPath = outputDirectory.resolve(typeSpec.name + ".java");
+ try (Writer writer = new OutputStreamWriter(Files.newOutputStream(outputPath), UTF_8)) {
+ writeTo(writer);
+ }
+ }
+
+ /** Writes this to {@code directory} as UTF-8 using the standard directory structure. */
+ public void writeTo(File directory) throws IOException {
+ writeTo(directory.toPath());
+ }
+
+ /** Writes this to {@code filer}. */
+ public void writeTo(Filer filer) throws IOException {
+ String fileName = packageName.isEmpty()
+ ? typeSpec.name
+ : packageName + "." + typeSpec.name;
+ List<Element> originatingElements = typeSpec.originatingElements;
+ JavaFileObject filerSourceFile = filer.createSourceFile(fileName,
+ originatingElements.toArray(new Element[originatingElements.size()]));
+ try (Writer writer = filerSourceFile.openWriter()) {
+ writeTo(writer);
+ } catch (Exception e) {
+ try {
+ filerSourceFile.delete();
+ } catch (Exception ignored) {
+ }
+ throw e;
+ }
+ }
+
+ private void emit(CodeWriter codeWriter) throws IOException {
+ codeWriter.pushPackage(packageName);
+
+ if (!fileComment.isEmpty()) {
+ codeWriter.emitComment(fileComment);
+ }
+
+ if (!packageName.isEmpty()) {
+ codeWriter.emit("package $L;\n", packageName);
+ codeWriter.emit("\n");
+ }
+
+ if (!staticImports.isEmpty()) {
+ for (String signature : staticImports) {
+ codeWriter.emit("import static $L;\n", signature);
+ }
+ codeWriter.emit("\n");
+ }
+
+ int importedTypesCount = 0;
+ for (ClassName className : new TreeSet<>(codeWriter.importedTypes().values())) {
+ if (skipJavaLangImports && className.packageName().equals("java.lang")) continue;
+ codeWriter.emit("import $L;\n", className.withoutAnnotations());
+ importedTypesCount++;
+ }
+
+ if (importedTypesCount > 0) {
+ codeWriter.emit("\n");
+ }
+
+ typeSpec.emit(codeWriter, null, Collections.emptySet());
+
+ codeWriter.popPackage();
+ }
+
+ @Override public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o == null) return false;
+ if (getClass() != o.getClass()) return false;
+ return toString().equals(o.toString());
+ }
+
+ @Override public int hashCode() {
+ return toString().hashCode();
+ }
+
+ @Override public String toString() {
+ try {
+ StringBuilder result = new StringBuilder();
+ writeTo(result);
+ return result.toString();
+ } catch (IOException e) {
+ throw new AssertionError();
+ }
+ }
+
+ public JavaFileObject toJavaFileObject() {
+ URI uri = URI.create((packageName.isEmpty()
+ ? typeSpec.name
+ : packageName.replace('.', '/') + '/' + typeSpec.name)
+ + Kind.SOURCE.extension);
+ return new SimpleJavaFileObject(uri, Kind.SOURCE) {
+ private final long lastModified = System.currentTimeMillis();
+ @Override public String getCharContent(boolean ignoreEncodingErrors) {
+ return JavaFile.this.toString();
+ }
+ @Override public InputStream openInputStream() throws IOException {
+ return new ByteArrayInputStream(getCharContent(true).getBytes(UTF_8));
+ }
+ @Override public long getLastModified() {
+ return lastModified;
+ }
+ };
+ }
+
+ public static Builder builder(String packageName, TypeSpec typeSpec) {
+ checkNotNull(packageName, "packageName == null");
+ checkNotNull(typeSpec, "typeSpec == null");
+ return new Builder(packageName, typeSpec);
+ }
+
+ public Builder toBuilder() {
+ Builder builder = new Builder(packageName, typeSpec);
+ builder.fileComment.add(fileComment);
+ builder.skipJavaLangImports = skipJavaLangImports;
+ builder.indent = indent;
+ return builder;
+ }
+
+ public static final class Builder {
+ private final String packageName;
+ private final TypeSpec typeSpec;
+ private final CodeBlock.Builder fileComment = CodeBlock.builder();
+ private final Set<String> staticImports = new TreeSet<>();
+ private boolean skipJavaLangImports;
+ private String indent = " ";
+
+ private Builder(String packageName, TypeSpec typeSpec) {
+ this.packageName = packageName;
+ this.typeSpec = typeSpec;
+ }
+
+ public Builder addFileComment(String format, Object... args) {
+ this.fileComment.add(format, args);
+ return this;
+ }
+
+ public Builder addStaticImport(Enum<?> constant) {
+ return addStaticImport(ClassName.get(constant.getDeclaringClass()), constant.name());
+ }
+
+ public Builder addStaticImport(Class<?> clazz, String... names) {
+ return addStaticImport(ClassName.get(clazz), names);
+ }
+
+ public Builder addStaticImport(ClassName className, String... names) {
+ checkArgument(className != null, "className == null");
+ checkArgument(names != null, "names == null");
+ checkArgument(names.length > 0, "names array is empty");
+ for (String name : names) {
+ checkArgument(name != null, "null entry in names array: %s", Arrays.toString(names));
+ staticImports.add(className.canonicalName + "." + name);
+ }
+ return this;
+ }
+
+ /**
+ * Call this to omit imports for classes in {@code java.lang}, such as {@code java.lang.String}.
+ *
+ * <p>By default, JavaPoet explicitly imports types in {@code java.lang} to defend against
+ * naming conflicts. Suppose an (ill-advised) class is named {@code com.example.String}. When
+ * {@code java.lang} imports are skipped, generated code in {@code com.example} that references
+ * {@code java.lang.String} will get {@code com.example.String} instead.
+ */
+ public Builder skipJavaLangImports(boolean skipJavaLangImports) {
+ this.skipJavaLangImports = skipJavaLangImports;
+ return this;
+ }
+
+ public Builder indent(String indent) {
+ this.indent = indent;
+ return this;
+ }
+
+ public JavaFile build() {
+ return new JavaFile(this);
+ }
+ }
+}
diff --git a/src/main/java/com/squareup/javapoet/LineWrapper.java b/src/main/java/com/squareup/javapoet/LineWrapper.java
new file mode 100644
index 0000000..6aa3131
--- /dev/null
+++ b/src/main/java/com/squareup/javapoet/LineWrapper.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (C) 2016 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import java.io.IOException;
+
+import static com.squareup.javapoet.Util.checkNotNull;
+
+/**
+ * Implements soft line wrapping on an appendable. To use, append characters using {@link #append}
+ * or soft-wrapping spaces using {@link #wrappingSpace}.
+ */
+final class LineWrapper {
+ private final Appendable out;
+ private final String indent;
+ private final int columnLimit;
+ private boolean closed;
+
+ /** Characters written since the last wrapping space that haven't yet been flushed. */
+ private final StringBuilder buffer = new StringBuilder();
+
+ /** The number of characters since the most recent newline. Includes both out and the buffer. */
+ private int column = 0;
+
+ /**
+ * -1 if we have no buffering; otherwise the number of {@code indent}s to write after wrapping.
+ */
+ private int indentLevel = -1;
+
+ /**
+ * Null if we have no buffering; otherwise the type to pass to the next call to {@link #flush}.
+ */
+ private FlushType nextFlush;
+
+ LineWrapper(Appendable out, String indent, int columnLimit) {
+ checkNotNull(out, "out == null");
+ this.out = out;
+ this.indent = indent;
+ this.columnLimit = columnLimit;
+ }
+
+ /** Emit {@code s}. This may be buffered to permit line wraps to be inserted. */
+ void append(String s) throws IOException {
+ if (closed) throw new IllegalStateException("closed");
+
+ if (nextFlush != null) {
+ int nextNewline = s.indexOf('\n');
+
+ // If s doesn't cause the current line to cross the limit, buffer it and return. We'll decide
+ // whether or not we have to wrap it later.
+ if (nextNewline == -1 && column + s.length() <= columnLimit) {
+ buffer.append(s);
+ column += s.length();
+ return;
+ }
+
+ // Wrap if appending s would overflow the current line.
+ boolean wrap = nextNewline == -1 || column + nextNewline > columnLimit;
+ flush(wrap ? FlushType.WRAP : nextFlush);
+ }
+
+ out.append(s);
+ int lastNewline = s.lastIndexOf('\n');
+ column = lastNewline != -1
+ ? s.length() - lastNewline - 1
+ : column + s.length();
+ }
+
+ /** Emit either a space or a newline character. */
+ void wrappingSpace(int indentLevel) throws IOException {
+ if (closed) throw new IllegalStateException("closed");
+
+ if (this.nextFlush != null) flush(nextFlush);
+ column++; // Increment the column even though the space is deferred to next call to flush().
+ this.nextFlush = FlushType.SPACE;
+ this.indentLevel = indentLevel;
+ }
+
+ /** Emit a newline character if the line will exceed it's limit, otherwise do nothing. */
+ void zeroWidthSpace(int indentLevel) throws IOException {
+ if (closed) throw new IllegalStateException("closed");
+
+ if (column == 0) return;
+ if (this.nextFlush != null) flush(nextFlush);
+ this.nextFlush = FlushType.EMPTY;
+ this.indentLevel = indentLevel;
+ }
+
+ /** Flush any outstanding text and forbid future writes to this line wrapper. */
+ void close() throws IOException {
+ if (nextFlush != null) flush(nextFlush);
+ closed = true;
+ }
+
+ /** Write the space followed by any buffered text that follows it. */
+ private void flush(FlushType flushType) throws IOException {
+ switch (flushType) {
+ case WRAP:
+ out.append('\n');
+ for (int i = 0; i < indentLevel; i++) {
+ out.append(indent);
+ }
+ column = indentLevel * indent.length();
+ column += buffer.length();
+ break;
+ case SPACE:
+ out.append(' ');
+ break;
+ case EMPTY:
+ break;
+ default:
+ throw new IllegalArgumentException("Unknown FlushType: " + flushType);
+ }
+
+ out.append(buffer);
+ buffer.delete(0, buffer.length());
+ indentLevel = -1;
+ nextFlush = null;
+ }
+
+ private enum FlushType {
+ WRAP, SPACE, EMPTY;
+ }
+}
diff --git a/src/main/java/com/squareup/javapoet/MethodSpec.java b/src/main/java/com/squareup/javapoet/MethodSpec.java
new file mode 100644
index 0000000..a2c7c43
--- /dev/null
+++ b/src/main/java/com/squareup/javapoet/MethodSpec.java
@@ -0,0 +1,493 @@
+/*
+ * Copyright (C) 2015 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.TypeParameterElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.ExecutableType;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.type.TypeVariable;
+import javax.lang.model.util.Types;
+
+import static com.squareup.javapoet.Util.checkArgument;
+import static com.squareup.javapoet.Util.checkNotNull;
+import static com.squareup.javapoet.Util.checkState;
+
+/** A generated constructor or method declaration. */
+public final class MethodSpec {
+ static final String CONSTRUCTOR = "<init>";
+
+ public final String name;
+ public final CodeBlock javadoc;
+ public final List<AnnotationSpec> annotations;
+ public final Set<Modifier> modifiers;
+ public final List<TypeVariableName> typeVariables;
+ public final TypeName returnType;
+ public final List<ParameterSpec> parameters;
+ public final boolean varargs;
+ public final List<TypeName> exceptions;
+ public final CodeBlock code;
+ public final CodeBlock defaultValue;
+
+ private MethodSpec(Builder builder) {
+ CodeBlock code = builder.code.build();
+ checkArgument(code.isEmpty() || !builder.modifiers.contains(Modifier.ABSTRACT),
+ "abstract method %s cannot have code", builder.name);
+ checkArgument(!builder.varargs || lastParameterIsArray(builder.parameters),
+ "last parameter of varargs method %s must be an array", builder.name);
+
+ this.name = checkNotNull(builder.name, "name == null");
+ this.javadoc = builder.javadoc.build();
+ this.annotations = Util.immutableList(builder.annotations);
+ this.modifiers = Util.immutableSet(builder.modifiers);
+ this.typeVariables = Util.immutableList(builder.typeVariables);
+ this.returnType = builder.returnType;
+ this.parameters = Util.immutableList(builder.parameters);
+ this.varargs = builder.varargs;
+ this.exceptions = Util.immutableList(builder.exceptions);
+ this.defaultValue = builder.defaultValue;
+ this.code = code;
+ }
+
+ private boolean lastParameterIsArray(List<ParameterSpec> parameters) {
+ return !parameters.isEmpty()
+ && TypeName.asArray((parameters.get(parameters.size() - 1).type)) != null;
+ }
+
+ void emit(CodeWriter codeWriter, String enclosingName, Set<Modifier> implicitModifiers)
+ throws IOException {
+ codeWriter.emitJavadoc(javadoc);
+ codeWriter.emitAnnotations(annotations, false);
+ codeWriter.emitModifiers(modifiers, implicitModifiers);
+
+ if (!typeVariables.isEmpty()) {
+ codeWriter.emitTypeVariables(typeVariables);
+ codeWriter.emit(" ");
+ }
+
+ if (isConstructor()) {
+ codeWriter.emit("$L($Z", enclosingName);
+ } else {
+ codeWriter.emit("$T $L($Z", returnType, name);
+ }
+
+ boolean firstParameter = true;
+ for (Iterator<ParameterSpec> i = parameters.iterator(); i.hasNext(); ) {
+ ParameterSpec parameter = i.next();
+ if (!firstParameter) codeWriter.emit(",").emitWrappingSpace();
+ parameter.emit(codeWriter, !i.hasNext() && varargs);
+ firstParameter = false;
+ }
+
+ codeWriter.emit(")");
+
+ if (defaultValue != null && !defaultValue.isEmpty()) {
+ codeWriter.emit(" default ");
+ codeWriter.emit(defaultValue);
+ }
+
+ if (!exceptions.isEmpty()) {
+ codeWriter.emitWrappingSpace().emit("throws");
+ boolean firstException = true;
+ for (TypeName exception : exceptions) {
+ if (!firstException) codeWriter.emit(",");
+ codeWriter.emitWrappingSpace().emit("$T", exception);
+ firstException = false;
+ }
+ }
+
+ if (hasModifier(Modifier.ABSTRACT)) {
+ codeWriter.emit(";\n");
+ } else if (hasModifier(Modifier.NATIVE)) {
+ // Code is allowed to support stuff like GWT JSNI.
+ codeWriter.emit(code);
+ codeWriter.emit(";\n");
+ } else {
+ codeWriter.emit(" {\n");
+
+ codeWriter.indent();
+ codeWriter.emit(code);
+ codeWriter.unindent();
+
+ codeWriter.emit("}\n");
+ }
+ }
+
+ public boolean hasModifier(Modifier modifier) {
+ return modifiers.contains(modifier);
+ }
+
+ public boolean isConstructor() {
+ return name.equals(CONSTRUCTOR);
+ }
+
+ @Override public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o == null) return false;
+ if (getClass() != o.getClass()) return false;
+ return toString().equals(o.toString());
+ }
+
+ @Override public int hashCode() {
+ return toString().hashCode();
+ }
+
+ @Override public String toString() {
+ StringBuilder out = new StringBuilder();
+ try {
+ CodeWriter codeWriter = new CodeWriter(out);
+ emit(codeWriter, "Constructor", Collections.emptySet());
+ return out.toString();
+ } catch (IOException e) {
+ throw new AssertionError();
+ }
+ }
+
+ public static Builder methodBuilder(String name) {
+ return new Builder(name);
+ }
+
+ public static Builder constructorBuilder() {
+ return new Builder(CONSTRUCTOR);
+ }
+
+ /**
+ * Returns a new method spec builder that overrides {@code method}.
+ *
+ * <p>This will copy its visibility modifiers, type parameters, return type, name, parameters, and
+ * throws declarations. An {@link Override} annotation will be added.
+ *
+ * <p>Note that in JavaPoet 1.2 through 1.7 this method retained annotations from the method and
+ * parameters of the overridden method. Since JavaPoet 1.8 annotations must be added separately.
+ */
+ public static Builder overriding(ExecutableElement method) {
+ checkNotNull(method, "method == null");
+
+ Element enclosingClass = method.getEnclosingElement();
+ if (enclosingClass.getModifiers().contains(Modifier.FINAL)) {
+ throw new IllegalArgumentException("Cannot override method on final class " + enclosingClass);
+ }
+
+ Set<Modifier> modifiers = method.getModifiers();
+ if (modifiers.contains(Modifier.PRIVATE)
+ || modifiers.contains(Modifier.FINAL)
+ || modifiers.contains(Modifier.STATIC)) {
+ throw new IllegalArgumentException("cannot override method with modifiers: " + modifiers);
+ }
+
+ String methodName = method.getSimpleName().toString();
+ MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder(methodName);
+
+ methodBuilder.addAnnotation(Override.class);
+
+ modifiers = new LinkedHashSet<>(modifiers);
+ modifiers.remove(Modifier.ABSTRACT);
+ modifiers.remove(Modifier.DEFAULT);
+ methodBuilder.addModifiers(modifiers);
+
+ for (TypeParameterElement typeParameterElement : method.getTypeParameters()) {
+ TypeVariable var = (TypeVariable) typeParameterElement.asType();
+ methodBuilder.addTypeVariable(TypeVariableName.get(var));
+ }
+
+ methodBuilder.returns(TypeName.get(method.getReturnType()));
+ methodBuilder.addParameters(ParameterSpec.parametersOf(method));
+ methodBuilder.varargs(method.isVarArgs());
+
+ for (TypeMirror thrownType : method.getThrownTypes()) {
+ methodBuilder.addException(TypeName.get(thrownType));
+ }
+
+ return methodBuilder;
+ }
+
+ /**
+ * Returns a new method spec builder that overrides {@code method} as a member of {@code
+ * enclosing}. This will resolve type parameters: for example overriding {@link
+ * Comparable#compareTo} in a type that implements {@code Comparable<Movie>}, the {@code T}
+ * parameter will be resolved to {@code Movie}.
+ *
+ * <p>This will copy its visibility modifiers, type parameters, return type, name, parameters, and
+ * throws declarations. An {@link Override} annotation will be added.
+ *
+ * <p>Note that in JavaPoet 1.2 through 1.7 this method retained annotations from the method and
+ * parameters of the overridden method. Since JavaPoet 1.8 annotations must be added separately.
+ */
+ public static Builder overriding(
+ ExecutableElement method, DeclaredType enclosing, Types types) {
+ ExecutableType executableType = (ExecutableType) types.asMemberOf(enclosing, method);
+ List<? extends TypeMirror> resolvedParameterTypes = executableType.getParameterTypes();
+ List<? extends TypeMirror> resolvedThrownTypes = executableType.getThrownTypes();
+ TypeMirror resolvedReturnType = executableType.getReturnType();
+
+ Builder builder = overriding(method);
+ builder.returns(TypeName.get(resolvedReturnType));
+ for (int i = 0, size = builder.parameters.size(); i < size; i++) {
+ ParameterSpec parameter = builder.parameters.get(i);
+ TypeName type = TypeName.get(resolvedParameterTypes.get(i));
+ builder.parameters.set(i, parameter.toBuilder(type, parameter.name).build());
+ }
+ builder.exceptions.clear();
+ for (int i = 0, size = resolvedThrownTypes.size(); i < size; i++) {
+ builder.addException(TypeName.get(resolvedThrownTypes.get(i)));
+ }
+
+ return builder;
+ }
+
+ public Builder toBuilder() {
+ Builder builder = new Builder(name);
+ builder.javadoc.add(javadoc);
+ builder.annotations.addAll(annotations);
+ builder.modifiers.addAll(modifiers);
+ builder.typeVariables.addAll(typeVariables);
+ builder.returnType = returnType;
+ builder.parameters.addAll(parameters);
+ builder.exceptions.addAll(exceptions);
+ builder.code.add(code);
+ builder.varargs = varargs;
+ builder.defaultValue = defaultValue;
+ return builder;
+ }
+
+ public static final class Builder {
+ private final String name;
+
+ private final CodeBlock.Builder javadoc = CodeBlock.builder();
+ private final List<AnnotationSpec> annotations = new ArrayList<>();
+ private final List<Modifier> modifiers = new ArrayList<>();
+ private List<TypeVariableName> typeVariables = new ArrayList<>();
+ private TypeName returnType;
+ private final List<ParameterSpec> parameters = new ArrayList<>();
+ private final Set<TypeName> exceptions = new LinkedHashSet<>();
+ private final CodeBlock.Builder code = CodeBlock.builder();
+ private boolean varargs;
+ private CodeBlock defaultValue;
+
+ private Builder(String name) {
+ checkNotNull(name, "name == null");
+ checkArgument(name.equals(CONSTRUCTOR) || SourceVersion.isName(name),
+ "not a valid name: %s", name);
+ this.name = name;
+ this.returnType = name.equals(CONSTRUCTOR) ? null : TypeName.VOID;
+ }
+
+ public Builder addJavadoc(String format, Object... args) {
+ javadoc.add(format, args);
+ return this;
+ }
+
+ public Builder addJavadoc(CodeBlock block) {
+ javadoc.add(block);
+ return this;
+ }
+
+ public Builder addAnnotations(Iterable<AnnotationSpec> annotationSpecs) {
+ checkArgument(annotationSpecs != null, "annotationSpecs == null");
+ for (AnnotationSpec annotationSpec : annotationSpecs) {
+ this.annotations.add(annotationSpec);
+ }
+ return this;
+ }
+
+ public Builder addAnnotation(AnnotationSpec annotationSpec) {
+ this.annotations.add(annotationSpec);
+ return this;
+ }
+
+ public Builder addAnnotation(ClassName annotation) {
+ this.annotations.add(AnnotationSpec.builder(annotation).build());
+ return this;
+ }
+
+ public Builder addAnnotation(Class<?> annotation) {
+ return addAnnotation(ClassName.get(annotation));
+ }
+
+ public Builder addModifiers(Modifier... modifiers) {
+ checkNotNull(modifiers, "modifiers == null");
+ Collections.addAll(this.modifiers, modifiers);
+ return this;
+ }
+
+ public Builder addModifiers(Iterable<Modifier> modifiers) {
+ checkNotNull(modifiers, "modifiers == null");
+ for (Modifier modifier : modifiers) {
+ this.modifiers.add(modifier);
+ }
+ return this;
+ }
+
+ public Builder addTypeVariables(Iterable<TypeVariableName> typeVariables) {
+ checkArgument(typeVariables != null, "typeVariables == null");
+ for (TypeVariableName typeVariable : typeVariables) {
+ this.typeVariables.add(typeVariable);
+ }
+ return this;
+ }
+
+ public Builder addTypeVariable(TypeVariableName typeVariable) {
+ typeVariables.add(typeVariable);
+ return this;
+ }
+
+ public Builder returns(TypeName returnType) {
+ checkState(!name.equals(CONSTRUCTOR), "constructor cannot have return type.");
+ this.returnType = returnType;
+ return this;
+ }
+
+ public Builder returns(Type returnType) {
+ return returns(TypeName.get(returnType));
+ }
+
+ public Builder addParameters(Iterable<ParameterSpec> parameterSpecs) {
+ checkArgument(parameterSpecs != null, "parameterSpecs == null");
+ for (ParameterSpec parameterSpec : parameterSpecs) {
+ this.parameters.add(parameterSpec);
+ }
+ return this;
+ }
+
+ public Builder addParameter(ParameterSpec parameterSpec) {
+ this.parameters.add(parameterSpec);
+ return this;
+ }
+
+ public Builder addParameter(TypeName type, String name, Modifier... modifiers) {
+ return addParameter(ParameterSpec.builder(type, name, modifiers).build());
+ }
+
+ public Builder addParameter(Type type, String name, Modifier... modifiers) {
+ return addParameter(TypeName.get(type), name, modifiers);
+ }
+
+ public Builder varargs() {
+ return varargs(true);
+ }
+
+ public Builder varargs(boolean varargs) {
+ this.varargs = varargs;
+ return this;
+ }
+
+ public Builder addExceptions(Iterable<? extends TypeName> exceptions) {
+ checkArgument(exceptions != null, "exceptions == null");
+ for (TypeName exception : exceptions) {
+ this.exceptions.add(exception);
+ }
+ return this;
+ }
+
+ public Builder addException(TypeName exception) {
+ this.exceptions.add(exception);
+ return this;
+ }
+
+ public Builder addException(Type exception) {
+ return addException(TypeName.get(exception));
+ }
+
+ public Builder addCode(String format, Object... args) {
+ code.add(format, args);
+ return this;
+ }
+
+ public Builder addNamedCode(String format, Map<String, ?> args) {
+ code.addNamed(format, args);
+ return this;
+ }
+
+ public Builder addCode(CodeBlock codeBlock) {
+ code.add(codeBlock);
+ return this;
+ }
+
+ public Builder addComment(String format, Object... args) {
+ code.add("// " + format + "\n", args);
+ return this;
+ }
+
+ public Builder defaultValue(String format, Object... args) {
+ return defaultValue(CodeBlock.of(format, args));
+ }
+
+ public Builder defaultValue(CodeBlock codeBlock) {
+ checkState(this.defaultValue == null, "defaultValue was already set");
+ this.defaultValue = checkNotNull(codeBlock, "codeBlock == null");
+ return this;
+ }
+
+ /**
+ * @param controlFlow the control flow construct and its code, such as "if (foo == 5)".
+ * Shouldn't contain braces or newline characters.
+ */
+ public Builder beginControlFlow(String controlFlow, Object... args) {
+ code.beginControlFlow(controlFlow, args);
+ return this;
+ }
+
+ /**
+ * @param controlFlow the control flow construct and its code, such as "else if (foo == 10)".
+ * Shouldn't contain braces or newline characters.
+ */
+ public Builder nextControlFlow(String controlFlow, Object... args) {
+ code.nextControlFlow(controlFlow, args);
+ return this;
+ }
+
+ public Builder endControlFlow() {
+ code.endControlFlow();
+ return this;
+ }
+
+ /**
+ * @param controlFlow the optional control flow construct and its code, such as
+ * "while(foo == 20)". Only used for "do/while" control flows.
+ */
+ public Builder endControlFlow(String controlFlow, Object... args) {
+ code.endControlFlow(controlFlow, args);
+ return this;
+ }
+
+ public Builder addStatement(String format, Object... args) {
+ code.addStatement(format, args);
+ return this;
+ }
+
+ public Builder addStatement(CodeBlock codeBlock) {
+ code.addStatement(codeBlock);
+ return this;
+ }
+
+ public MethodSpec build() {
+ return new MethodSpec(this);
+ }
+ }
+}
diff --git a/src/main/java/com/squareup/javapoet/NameAllocator.java b/src/main/java/com/squareup/javapoet/NameAllocator.java
new file mode 100644
index 0000000..8269664
--- /dev/null
+++ b/src/main/java/com/squareup/javapoet/NameAllocator.java
@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 2015 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import javax.lang.model.SourceVersion;
+
+import static com.squareup.javapoet.Util.checkNotNull;
+
+/**
+ * Assigns Java identifier names to avoid collisions, keywords, and invalid characters. To use,
+ * first create an instance and allocate all of the names that you need. Typically this is a
+ * mix of user-supplied names and constants: <pre> {@code
+ *
+ * NameAllocator nameAllocator = new NameAllocator();
+ * for (MyProperty property : properties) {
+ * nameAllocator.newName(property.name(), property);
+ * }
+ * nameAllocator.newName("sb", "string builder");
+ * }</pre>
+ *
+ * Pass a unique tag object to each allocation. The tag scopes the name, and can be used to look up
+ * the allocated name later. Typically the tag is the object that is being named. In the above
+ * example we use {@code property} for the user-supplied property names, and {@code "string
+ * builder"} for our constant string builder.
+ *
+ * <p>Once we've allocated names we can use them when generating code: <pre> {@code
+ *
+ * MethodSpec.Builder builder = MethodSpec.methodBuilder("toString")
+ * .addAnnotation(Override.class)
+ * .addModifiers(Modifier.PUBLIC)
+ * .returns(String.class);
+ *
+ * builder.addStatement("$1T $2N = new $1T()",
+ * StringBuilder.class, nameAllocator.get("string builder"));
+ * for (MyProperty property : properties) {
+ * builder.addStatement("$N.append($N)",
+ * nameAllocator.get("string builder"), nameAllocator.get(property));
+ * }
+ * builder.addStatement("return $N", nameAllocator.get("string builder"));
+ * return builder.build();
+ * }</pre>
+ *
+ * The above code generates unique names if presented with conflicts. Given user-supplied properties
+ * with names {@code ab} and {@code sb} this generates the following: <pre> {@code
+ *
+ * @Override
+ * public String toString() {
+ * StringBuilder sb_ = new StringBuilder();
+ * sb_.append(ab);
+ * sb_.append(sb);
+ * return sb_.toString();
+ * }
+ * }</pre>
+ *
+ * The underscore is appended to {@code sb} to avoid conflicting with the user-supplied {@code sb}
+ * property. Underscores are also prefixed for names that start with a digit, and used to replace
+ * name-unsafe characters like space or dash.
+ *
+ * <p>When dealing with multiple independent inner scopes, use a {@link #clone()} of the
+ * NameAllocator used for the outer scope to further refine name allocation for a specific inner
+ * scope.
+ */
+public final class NameAllocator implements Cloneable {
+ private final Set<String> allocatedNames;
+ private final Map<Object, String> tagToName;
+
+ public NameAllocator() {
+ this(new LinkedHashSet<>(), new LinkedHashMap<>());
+ }
+
+ private NameAllocator(LinkedHashSet<String> allocatedNames,
+ LinkedHashMap<Object, String> tagToName) {
+ this.allocatedNames = allocatedNames;
+ this.tagToName = tagToName;
+ }
+
+ /**
+ * Return a new name using {@code suggestion} that will not be a Java identifier or clash with
+ * other names.
+ */
+ public String newName(String suggestion) {
+ return newName(suggestion, UUID.randomUUID().toString());
+ }
+
+ /**
+ * Return a new name using {@code suggestion} that will not be a Java identifier or clash with
+ * other names. The returned value can be queried multiple times by passing {@code tag} to
+ * {@link #get(Object)}.
+ */
+ public String newName(String suggestion, Object tag) {
+ checkNotNull(suggestion, "suggestion");
+ checkNotNull(tag, "tag");
+
+ suggestion = toJavaIdentifier(suggestion);
+
+ while (SourceVersion.isKeyword(suggestion) || !allocatedNames.add(suggestion)) {
+ suggestion = suggestion + "_";
+ }
+
+ String replaced = tagToName.put(tag, suggestion);
+ if (replaced != null) {
+ tagToName.put(tag, replaced); // Put things back as they were!
+ throw new IllegalArgumentException("tag " + tag + " cannot be used for both '" + replaced
+ + "' and '" + suggestion + "'");
+ }
+
+ return suggestion;
+ }
+
+ public static String toJavaIdentifier(String suggestion) {
+ StringBuilder result = new StringBuilder();
+ for (int i = 0; i < suggestion.length(); ) {
+ int codePoint = suggestion.codePointAt(i);
+ if (i == 0
+ && !Character.isJavaIdentifierStart(codePoint)
+ && Character.isJavaIdentifierPart(codePoint)) {
+ result.append("_");
+ }
+
+ int validCodePoint = Character.isJavaIdentifierPart(codePoint) ? codePoint : '_';
+ result.appendCodePoint(validCodePoint);
+ i += Character.charCount(codePoint);
+ }
+ return result.toString();
+ }
+
+ /** Retrieve a name created with {@link #newName(String, Object)}. */
+ public String get(Object tag) {
+ String result = tagToName.get(tag);
+ if (result == null) {
+ throw new IllegalArgumentException("unknown tag: " + tag);
+ }
+ return result;
+ }
+
+ /**
+ * Create a deep copy of this NameAllocator. Useful to create multiple independent refinements
+ * of a NameAllocator to be used in the respective definition of multiples, independently-scoped,
+ * inner code blocks.
+ *
+ * @return A deep copy of this NameAllocator.
+ */
+ @Override
+ public NameAllocator clone() {
+ return new NameAllocator(
+ new LinkedHashSet<>(this.allocatedNames),
+ new LinkedHashMap<>(this.tagToName));
+ }
+
+}
diff --git a/src/main/java/com/squareup/javapoet/ParameterSpec.java b/src/main/java/com/squareup/javapoet/ParameterSpec.java
new file mode 100644
index 0000000..63da3f2
--- /dev/null
+++ b/src/main/java/com/squareup/javapoet/ParameterSpec.java
@@ -0,0 +1,172 @@
+/*
+ * Copyright (C) 2015 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.VariableElement;
+
+import static com.squareup.javapoet.Util.checkArgument;
+import static com.squareup.javapoet.Util.checkNotNull;
+
+/** A generated parameter declaration. */
+public final class ParameterSpec {
+ public final String name;
+ public final List<AnnotationSpec> annotations;
+ public final Set<Modifier> modifiers;
+ public final TypeName type;
+
+ private ParameterSpec(Builder builder) {
+ this.name = checkNotNull(builder.name, "name == null");
+ this.annotations = Util.immutableList(builder.annotations);
+ this.modifiers = Util.immutableSet(builder.modifiers);
+ this.type = checkNotNull(builder.type, "type == null");
+ }
+
+ public boolean hasModifier(Modifier modifier) {
+ return modifiers.contains(modifier);
+ }
+
+ void emit(CodeWriter codeWriter, boolean varargs) throws IOException {
+ codeWriter.emitAnnotations(annotations, true);
+ codeWriter.emitModifiers(modifiers);
+ if (varargs) {
+ TypeName.asArray(type).emit(codeWriter, true);
+ } else {
+ type.emit(codeWriter);
+ }
+ codeWriter.emit(" $L", name);
+ }
+
+ @Override public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o == null) return false;
+ if (getClass() != o.getClass()) return false;
+ return toString().equals(o.toString());
+ }
+
+ @Override public int hashCode() {
+ return toString().hashCode();
+ }
+
+ @Override public String toString() {
+ StringBuilder out = new StringBuilder();
+ try {
+ CodeWriter codeWriter = new CodeWriter(out);
+ emit(codeWriter, false);
+ return out.toString();
+ } catch (IOException e) {
+ throw new AssertionError();
+ }
+ }
+
+ public static ParameterSpec get(VariableElement element) {
+ TypeName type = TypeName.get(element.asType());
+ String name = element.getSimpleName().toString();
+ return ParameterSpec.builder(type, name)
+ .addModifiers(element.getModifiers())
+ .build();
+ }
+
+ static List<ParameterSpec> parametersOf(ExecutableElement method) {
+ List<ParameterSpec> result = new ArrayList<>();
+ for (VariableElement parameter : method.getParameters()) {
+ result.add(ParameterSpec.get(parameter));
+ }
+ return result;
+ }
+
+ public static Builder builder(TypeName type, String name, Modifier... modifiers) {
+ checkNotNull(type, "type == null");
+ checkArgument(SourceVersion.isName(name), "not a valid name: %s", name);
+ return new Builder(type, name)
+ .addModifiers(modifiers);
+ }
+
+ public static Builder builder(Type type, String name, Modifier... modifiers) {
+ return builder(TypeName.get(type), name, modifiers);
+ }
+
+ public Builder toBuilder() {
+ return toBuilder(type, name);
+ }
+
+ Builder toBuilder(TypeName type, String name) {
+ Builder builder = new Builder(type, name);
+ builder.annotations.addAll(annotations);
+ builder.modifiers.addAll(modifiers);
+ return builder;
+ }
+
+ public static final class Builder {
+ private final TypeName type;
+ private final String name;
+
+ private final List<AnnotationSpec> annotations = new ArrayList<>();
+ private final List<Modifier> modifiers = new ArrayList<>();
+
+ private Builder(TypeName type, String name) {
+ this.type = type;
+ this.name = name;
+ }
+
+ public Builder addAnnotations(Iterable<AnnotationSpec> annotationSpecs) {
+ checkArgument(annotationSpecs != null, "annotationSpecs == null");
+ for (AnnotationSpec annotationSpec : annotationSpecs) {
+ this.annotations.add(annotationSpec);
+ }
+ return this;
+ }
+
+ public Builder addAnnotation(AnnotationSpec annotationSpec) {
+ this.annotations.add(annotationSpec);
+ return this;
+ }
+
+ public Builder addAnnotation(ClassName annotation) {
+ this.annotations.add(AnnotationSpec.builder(annotation).build());
+ return this;
+ }
+
+ public Builder addAnnotation(Class<?> annotation) {
+ return addAnnotation(ClassName.get(annotation));
+ }
+
+ public Builder addModifiers(Modifier... modifiers) {
+ Collections.addAll(this.modifiers, modifiers);
+ return this;
+ }
+
+ public Builder addModifiers(Iterable<Modifier> modifiers) {
+ checkNotNull(modifiers, "modifiers == null");
+ for (Modifier modifier : modifiers) {
+ this.modifiers.add(modifier);
+ }
+ return this;
+ }
+
+ public ParameterSpec build() {
+ return new ParameterSpec(this);
+ }
+ }
+}
diff --git a/src/main/java/com/squareup/javapoet/ParameterizedTypeName.java b/src/main/java/com/squareup/javapoet/ParameterizedTypeName.java
new file mode 100644
index 0000000..3a8bf62
--- /dev/null
+++ b/src/main/java/com/squareup/javapoet/ParameterizedTypeName.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright (C) 2015 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import java.io.IOException;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import static com.squareup.javapoet.Util.checkArgument;
+import static com.squareup.javapoet.Util.checkNotNull;
+
+public final class ParameterizedTypeName extends TypeName {
+ private final ParameterizedTypeName enclosingType;
+ public final ClassName rawType;
+ public final List<TypeName> typeArguments;
+
+ ParameterizedTypeName(ParameterizedTypeName enclosingType, ClassName rawType,
+ List<TypeName> typeArguments) {
+ this(enclosingType, rawType, typeArguments, new ArrayList<>());
+ }
+
+ private ParameterizedTypeName(ParameterizedTypeName enclosingType, ClassName rawType,
+ List<TypeName> typeArguments, List<AnnotationSpec> annotations) {
+ super(annotations);
+ this.rawType = checkNotNull(rawType, "rawType == null").annotated(annotations);
+ this.enclosingType = enclosingType;
+ this.typeArguments = Util.immutableList(typeArguments);
+
+ checkArgument(!this.typeArguments.isEmpty() || enclosingType != null,
+ "no type arguments: %s", rawType);
+ for (TypeName typeArgument : this.typeArguments) {
+ checkArgument(!typeArgument.isPrimitive() && typeArgument != VOID,
+ "invalid type parameter: %s", typeArgument);
+ }
+ }
+
+ @Override public ParameterizedTypeName annotated(List<AnnotationSpec> annotations) {
+ return new ParameterizedTypeName(
+ enclosingType, rawType, typeArguments, concatAnnotations(annotations));
+ }
+
+ @Override
+ public TypeName withoutAnnotations() {
+ return new ParameterizedTypeName(
+ enclosingType, rawType.withoutAnnotations(), typeArguments, new ArrayList<>());
+ }
+
+ @Override CodeWriter emit(CodeWriter out) throws IOException {
+ if (enclosingType != null) {
+ enclosingType.emit(out);
+ out.emit(".");
+ if (isAnnotated()) {
+ out.emit(" ");
+ emitAnnotations(out);
+ }
+ out.emit(rawType.simpleName());
+ } else {
+ rawType.emit(out);
+ }
+ if (!typeArguments.isEmpty()) {
+ out.emitAndIndent("<");
+ boolean firstParameter = true;
+ for (TypeName parameter : typeArguments) {
+ if (!firstParameter) out.emitAndIndent(", ");
+ parameter.emit(out);
+ firstParameter = false;
+ }
+ out.emitAndIndent(">");
+ }
+ return out;
+ }
+
+ /**
+ * Returns a new {@link ParameterizedTypeName} instance for the specified {@code name} as nested
+ * inside this class.
+ */
+ public ParameterizedTypeName nestedClass(String name) {
+ checkNotNull(name, "name == null");
+ return new ParameterizedTypeName(this, rawType.nestedClass(name), new ArrayList<>(),
+ new ArrayList<>());
+ }
+
+ /**
+ * Returns a new {@link ParameterizedTypeName} instance for the specified {@code name} as nested
+ * inside this class, with the specified {@code typeArguments}.
+ */
+ public ParameterizedTypeName nestedClass(String name, List<TypeName> typeArguments) {
+ checkNotNull(name, "name == null");
+ return new ParameterizedTypeName(this, rawType.nestedClass(name), typeArguments,
+ new ArrayList<>());
+ }
+
+ /** Returns a parameterized type, applying {@code typeArguments} to {@code rawType}. */
+ public static ParameterizedTypeName get(ClassName rawType, TypeName... typeArguments) {
+ return new ParameterizedTypeName(null, rawType, Arrays.asList(typeArguments));
+ }
+
+ /** Returns a parameterized type, applying {@code typeArguments} to {@code rawType}. */
+ public static ParameterizedTypeName get(Class<?> rawType, Type... typeArguments) {
+ return new ParameterizedTypeName(null, ClassName.get(rawType), list(typeArguments));
+ }
+
+ /** Returns a parameterized type equivalent to {@code type}. */
+ public static ParameterizedTypeName get(ParameterizedType type) {
+ return get(type, new LinkedHashMap<>());
+ }
+
+ /** Returns a parameterized type equivalent to {@code type}. */
+ static ParameterizedTypeName get(ParameterizedType type, Map<Type, TypeVariableName> map) {
+ ClassName rawType = ClassName.get((Class<?>) type.getRawType());
+ ParameterizedType ownerType = (type.getOwnerType() instanceof ParameterizedType)
+ && !Modifier.isStatic(((Class<?>) type.getRawType()).getModifiers())
+ ? (ParameterizedType) type.getOwnerType() : null;
+ List<TypeName> typeArguments = TypeName.list(type.getActualTypeArguments(), map);
+ return (ownerType != null)
+ ? get(ownerType, map).nestedClass(rawType.simpleName(), typeArguments)
+ : new ParameterizedTypeName(null, rawType, typeArguments);
+ }
+}
diff --git a/src/main/java/com/squareup/javapoet/TypeName.java b/src/main/java/com/squareup/javapoet/TypeName.java
new file mode 100644
index 0000000..38877f7
--- /dev/null
+++ b/src/main/java/com/squareup/javapoet/TypeName.java
@@ -0,0 +1,385 @@
+/*
+ * Copyright (C) 2015 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import java.io.IOException;
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.lang.reflect.WildcardType;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.TypeParameterElement;
+import javax.lang.model.type.ArrayType;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.ErrorType;
+import javax.lang.model.type.NoType;
+import javax.lang.model.type.PrimitiveType;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.SimpleTypeVisitor8;
+
+/**
+ * Any type in Java's type system, plus {@code void}. This class is an identifier for primitive
+ * types like {@code int} and raw reference types like {@code String} and {@code List}. It also
+ * identifies composite types like {@code char[]} and {@code Set<Long>}.
+ *
+ * <p>Type names are dumb identifiers only and do not model the values they name. For example, the
+ * type name for {@code java.lang.List} doesn't know about the {@code size()} method, the fact that
+ * lists are collections, or even that it accepts a single type parameter.
+ *
+ * <p>Instances of this class are immutable value objects that implement {@code equals()} and {@code
+ * hashCode()} properly.
+ *
+ * <h3>Referencing existing types</h3>
+ *
+ * <p>Primitives and void are constants that you can reference directly: see {@link #INT}, {@link
+ * #DOUBLE}, and {@link #VOID}.
+ *
+ * <p>In an annotation processor you can get a type name instance for a type mirror by calling
+ * {@link #get(TypeMirror)}. In reflection code, you can use {@link #get(Type)}.
+ *
+ * <h3>Defining new types</h3>
+ *
+ * <p>Create new reference types like {@code com.example.HelloWorld} with {@link
+ * ClassName#get(String, String, String...)}. To build composite types like {@code char[]} and
+ * {@code Set<Long>}, use the factory methods on {@link ArrayTypeName}, {@link
+ * ParameterizedTypeName}, {@link TypeVariableName}, and {@link WildcardTypeName}.
+ */
+public class TypeName {
+ public static final TypeName VOID = new TypeName("void");
+ public static final TypeName BOOLEAN = new TypeName("boolean");
+ public static final TypeName BYTE = new TypeName("byte");
+ public static final TypeName SHORT = new TypeName("short");
+ public static final TypeName INT = new TypeName("int");
+ public static final TypeName LONG = new TypeName("long");
+ public static final TypeName CHAR = new TypeName("char");
+ public static final TypeName FLOAT = new TypeName("float");
+ public static final TypeName DOUBLE = new TypeName("double");
+ public static final ClassName OBJECT = ClassName.get("java.lang", "Object");
+
+ private static final ClassName BOXED_VOID = ClassName.get("java.lang", "Void");
+ private static final ClassName BOXED_BOOLEAN = ClassName.get("java.lang", "Boolean");
+ private static final ClassName BOXED_BYTE = ClassName.get("java.lang", "Byte");
+ private static final ClassName BOXED_SHORT = ClassName.get("java.lang", "Short");
+ private static final ClassName BOXED_INT = ClassName.get("java.lang", "Integer");
+ private static final ClassName BOXED_LONG = ClassName.get("java.lang", "Long");
+ private static final ClassName BOXED_CHAR = ClassName.get("java.lang", "Character");
+ private static final ClassName BOXED_FLOAT = ClassName.get("java.lang", "Float");
+ private static final ClassName BOXED_DOUBLE = ClassName.get("java.lang", "Double");
+
+ /** The name of this type if it is a keyword, or null. */
+ private final String keyword;
+ public final List<AnnotationSpec> annotations;
+
+ /** Lazily-initialized toString of this type name. */
+ private String cachedString;
+
+ private TypeName(String keyword) {
+ this(keyword, new ArrayList<>());
+ }
+
+ private TypeName(String keyword, List<AnnotationSpec> annotations) {
+ this.keyword = keyword;
+ this.annotations = Util.immutableList(annotations);
+ }
+
+ // Package-private constructor to prevent third-party subclasses.
+ TypeName(List<AnnotationSpec> annotations) {
+ this(null, annotations);
+ }
+
+ public final TypeName annotated(AnnotationSpec... annotations) {
+ return annotated(Arrays.asList(annotations));
+ }
+
+ public TypeName annotated(List<AnnotationSpec> annotations) {
+ Util.checkNotNull(annotations, "annotations == null");
+ return new TypeName(keyword, concatAnnotations(annotations));
+ }
+
+ public TypeName withoutAnnotations() {
+ return new TypeName(keyword);
+ }
+
+ protected final List<AnnotationSpec> concatAnnotations(List<AnnotationSpec> annotations) {
+ List<AnnotationSpec> allAnnotations = new ArrayList<>(this.annotations);
+ allAnnotations.addAll(annotations);
+ return allAnnotations;
+ }
+
+ public boolean isAnnotated() {
+ return !annotations.isEmpty();
+ }
+
+ /**
+ * Returns true if this is a primitive type like {@code int}. Returns false for all other types
+ * types including boxed primitives and {@code void}.
+ */
+ public boolean isPrimitive() {
+ return keyword != null && this != VOID;
+ }
+
+ /**
+ * Returns true if this is a boxed primitive type like {@code Integer}. Returns false for all
+ * other types types including unboxed primitives and {@code java.lang.Void}.
+ */
+ public boolean isBoxedPrimitive() {
+ return this.equals(BOXED_BOOLEAN)
+ || this.equals(BOXED_BYTE)
+ || this.equals(BOXED_SHORT)
+ || this.equals(BOXED_INT)
+ || this.equals(BOXED_LONG)
+ || this.equals(BOXED_CHAR)
+ || this.equals(BOXED_FLOAT)
+ || this.equals(BOXED_DOUBLE);
+ }
+
+ /**
+ * Returns a boxed type if this is a primitive type (like {@code Integer} for {@code int}) or
+ * {@code void}. Returns this type if boxing doesn't apply.
+ */
+ public TypeName box() {
+ if (keyword == null) return this; // Doesn't need boxing.
+ if (this == VOID) return BOXED_VOID;
+ if (this == BOOLEAN) return BOXED_BOOLEAN;
+ if (this == BYTE) return BOXED_BYTE;
+ if (this == SHORT) return BOXED_SHORT;
+ if (this == INT) return BOXED_INT;
+ if (this == LONG) return BOXED_LONG;
+ if (this == CHAR) return BOXED_CHAR;
+ if (this == FLOAT) return BOXED_FLOAT;
+ if (this == DOUBLE) return BOXED_DOUBLE;
+ throw new AssertionError(keyword);
+ }
+
+ /**
+ * Returns an unboxed type if this is a boxed primitive type (like {@code int} for {@code
+ * Integer}) or {@code Void}. Returns this type if it is already unboxed.
+ *
+ * @throws UnsupportedOperationException if this type isn't eligible for unboxing.
+ */
+ public TypeName unbox() {
+ if (keyword != null) return this; // Already unboxed.
+ if (this.equals(BOXED_VOID)) return VOID;
+ if (this.equals(BOXED_BOOLEAN)) return BOOLEAN;
+ if (this.equals(BOXED_BYTE)) return BYTE;
+ if (this.equals(BOXED_SHORT)) return SHORT;
+ if (this.equals(BOXED_INT)) return INT;
+ if (this.equals(BOXED_LONG)) return LONG;
+ if (this.equals(BOXED_CHAR)) return CHAR;
+ if (this.equals(BOXED_FLOAT)) return FLOAT;
+ if (this.equals(BOXED_DOUBLE)) return DOUBLE;
+ throw new UnsupportedOperationException("cannot unbox " + this);
+ }
+
+ @Override public final boolean equals(Object o) {
+ if (this == o) return true;
+ if (o == null) return false;
+ if (getClass() != o.getClass()) return false;
+ return toString().equals(o.toString());
+ }
+
+ @Override public final int hashCode() {
+ return toString().hashCode();
+ }
+
+ @Override public final String toString() {
+ String result = cachedString;
+ if (result == null) {
+ try {
+ StringBuilder resultBuilder = new StringBuilder();
+ CodeWriter codeWriter = new CodeWriter(resultBuilder);
+ emit(codeWriter);
+ result = resultBuilder.toString();
+ cachedString = result;
+ } catch (IOException e) {
+ throw new AssertionError();
+ }
+ }
+ return result;
+ }
+
+ CodeWriter emit(CodeWriter out) throws IOException {
+ if (keyword == null) throw new AssertionError();
+
+ if (isAnnotated()) {
+ out.emit("");
+ emitAnnotations(out);
+ }
+ return out.emitAndIndent(keyword);
+ }
+
+ CodeWriter emitAnnotations(CodeWriter out) throws IOException {
+ for (AnnotationSpec annotation : annotations) {
+ annotation.emit(out, true);
+ out.emit(" ");
+ }
+ return out;
+ }
+
+
+ /** Returns a type name equivalent to {@code mirror}. */
+ public static TypeName get(TypeMirror mirror) {
+ return get(mirror, new LinkedHashMap<>());
+ }
+
+ static TypeName get(TypeMirror mirror,
+ final Map<TypeParameterElement, TypeVariableName> typeVariables) {
+ return mirror.accept(new SimpleTypeVisitor8<TypeName, Void>() {
+ @Override public TypeName visitPrimitive(PrimitiveType t, Void p) {
+ switch (t.getKind()) {
+ case BOOLEAN:
+ return TypeName.BOOLEAN;
+ case BYTE:
+ return TypeName.BYTE;
+ case SHORT:
+ return TypeName.SHORT;
+ case INT:
+ return TypeName.INT;
+ case LONG:
+ return TypeName.LONG;
+ case CHAR:
+ return TypeName.CHAR;
+ case FLOAT:
+ return TypeName.FLOAT;
+ case DOUBLE:
+ return TypeName.DOUBLE;
+ default:
+ throw new AssertionError();
+ }
+ }
+
+ @Override public TypeName visitDeclared(DeclaredType t, Void p) {
+ ClassName rawType = ClassName.get((TypeElement) t.asElement());
+ TypeMirror enclosingType = t.getEnclosingType();
+ TypeName enclosing =
+ (enclosingType.getKind() != TypeKind.NONE)
+ && !t.asElement().getModifiers().contains(Modifier.STATIC)
+ ? enclosingType.accept(this, null)
+ : null;
+ if (t.getTypeArguments().isEmpty() && !(enclosing instanceof ParameterizedTypeName)) {
+ return rawType;
+ }
+
+ List<TypeName> typeArgumentNames = new ArrayList<>();
+ for (TypeMirror mirror : t.getTypeArguments()) {
+ typeArgumentNames.add(get(mirror, typeVariables));
+ }
+ return enclosing instanceof ParameterizedTypeName
+ ? ((ParameterizedTypeName) enclosing).nestedClass(
+ rawType.simpleName(), typeArgumentNames)
+ : new ParameterizedTypeName(null, rawType, typeArgumentNames);
+ }
+
+ @Override public TypeName visitError(ErrorType t, Void p) {
+ return visitDeclared(t, p);
+ }
+
+ @Override public ArrayTypeName visitArray(ArrayType t, Void p) {
+ return ArrayTypeName.get(t, typeVariables);
+ }
+
+ @Override public TypeName visitTypeVariable(javax.lang.model.type.TypeVariable t, Void p) {
+ return TypeVariableName.get(t, typeVariables);
+ }
+
+ @Override public TypeName visitWildcard(javax.lang.model.type.WildcardType t, Void p) {
+ return WildcardTypeName.get(t, typeVariables);
+ }
+
+ @Override public TypeName visitNoType(NoType t, Void p) {
+ if (t.getKind() == TypeKind.VOID) return TypeName.VOID;
+ return super.visitUnknown(t, p);
+ }
+
+ @Override protected TypeName defaultAction(TypeMirror e, Void p) {
+ throw new IllegalArgumentException("Unexpected type mirror: " + e);
+ }
+ }, null);
+ }
+
+ /** Returns a type name equivalent to {@code type}. */
+ public static TypeName get(Type type) {
+ return get(type, new LinkedHashMap<>());
+ }
+
+ static TypeName get(Type type, Map<Type, TypeVariableName> map) {
+ if (type instanceof Class<?>) {
+ Class<?> classType = (Class<?>) type;
+ if (type == void.class) return VOID;
+ if (type == boolean.class) return BOOLEAN;
+ if (type == byte.class) return BYTE;
+ if (type == short.class) return SHORT;
+ if (type == int.class) return INT;
+ if (type == long.class) return LONG;
+ if (type == char.class) return CHAR;
+ if (type == float.class) return FLOAT;
+ if (type == double.class) return DOUBLE;
+ if (classType.isArray()) return ArrayTypeName.of(get(classType.getComponentType(), map));
+ return ClassName.get(classType);
+
+ } else if (type instanceof ParameterizedType) {
+ return ParameterizedTypeName.get((ParameterizedType) type, map);
+
+ } else if (type instanceof WildcardType) {
+ return WildcardTypeName.get((WildcardType) type, map);
+
+ } else if (type instanceof TypeVariable<?>) {
+ return TypeVariableName.get((TypeVariable<?>) type, map);
+
+ } else if (type instanceof GenericArrayType) {
+ return ArrayTypeName.get((GenericArrayType) type, map);
+
+ } else {
+ throw new IllegalArgumentException("unexpected type: " + type);
+ }
+ }
+
+ /** Converts an array of types to a list of type names. */
+ static List<TypeName> list(Type[] types) {
+ return list(types, new LinkedHashMap<>());
+ }
+
+ static List<TypeName> list(Type[] types, Map<Type, TypeVariableName> map) {
+ List<TypeName> result = new ArrayList<>(types.length);
+ for (Type type : types) {
+ result.add(get(type, map));
+ }
+ return result;
+ }
+
+ /** Returns the array component of {@code type}, or null if {@code type} is not an array. */
+ static TypeName arrayComponent(TypeName type) {
+ return type instanceof ArrayTypeName
+ ? ((ArrayTypeName) type).componentType
+ : null;
+ }
+
+ /** Returns {@code type} as an array, or null if {@code type} is not an array. */
+ static ArrayTypeName asArray(TypeName type) {
+ return type instanceof ArrayTypeName
+ ? ((ArrayTypeName) type)
+ : null;
+ }
+
+}
diff --git a/src/main/java/com/squareup/javapoet/TypeSpec.java b/src/main/java/com/squareup/javapoet/TypeSpec.java
new file mode 100644
index 0000000..46de3a5
--- /dev/null
+++ b/src/main/java/com/squareup/javapoet/TypeSpec.java
@@ -0,0 +1,632 @@
+/*
+ * Copyright (C) 2015 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.Modifier;
+
+import static com.squareup.javapoet.Util.checkArgument;
+import static com.squareup.javapoet.Util.checkNotNull;
+import static com.squareup.javapoet.Util.checkState;
+import static com.squareup.javapoet.Util.requireExactlyOneOf;
+
+/** A generated class, interface, or enum declaration. */
+public final class TypeSpec {
+ public final Kind kind;
+ public final String name;
+ public final CodeBlock anonymousTypeArguments;
+ public final CodeBlock javadoc;
+ public final List<AnnotationSpec> annotations;
+ public final Set<Modifier> modifiers;
+ public final List<TypeVariableName> typeVariables;
+ public final TypeName superclass;
+ public final List<TypeName> superinterfaces;
+ public final Map<String, TypeSpec> enumConstants;
+ public final List<FieldSpec> fieldSpecs;
+ public final CodeBlock staticBlock;
+ public final CodeBlock initializerBlock;
+ public final List<MethodSpec> methodSpecs;
+ public final List<TypeSpec> typeSpecs;
+ public final List<Element> originatingElements;
+
+ private TypeSpec(Builder builder) {
+ this.kind = builder.kind;
+ this.name = builder.name;
+ this.anonymousTypeArguments = builder.anonymousTypeArguments;
+ this.javadoc = builder.javadoc.build();
+ this.annotations = Util.immutableList(builder.annotations);
+ this.modifiers = Util.immutableSet(builder.modifiers);
+ this.typeVariables = Util.immutableList(builder.typeVariables);
+ this.superclass = builder.superclass;
+ this.superinterfaces = Util.immutableList(builder.superinterfaces);
+ this.enumConstants = Util.immutableMap(builder.enumConstants);
+ this.fieldSpecs = Util.immutableList(builder.fieldSpecs);
+ this.staticBlock = builder.staticBlock.build();
+ this.initializerBlock = builder.initializerBlock.build();
+ this.methodSpecs = Util.immutableList(builder.methodSpecs);
+ this.typeSpecs = Util.immutableList(builder.typeSpecs);
+
+ List<Element> originatingElementsMutable = new ArrayList<>();
+ originatingElementsMutable.addAll(builder.originatingElements);
+ for (TypeSpec typeSpec : builder.typeSpecs) {
+ originatingElementsMutable.addAll(typeSpec.originatingElements);
+ }
+ this.originatingElements = Util.immutableList(originatingElementsMutable);
+ }
+
+ /**
+ * Creates a dummy type spec for type-resolution only (in CodeWriter)
+ * while emitting the type declaration but before entering the type body.
+ */
+ private TypeSpec(TypeSpec type) {
+ assert type.anonymousTypeArguments == null;
+ this.kind = type.kind;
+ this.name = type.name;
+ this.anonymousTypeArguments = null;
+ this.javadoc = type.javadoc;
+ this.annotations = Collections.emptyList();
+ this.modifiers = Collections.emptySet();
+ this.typeVariables = Collections.emptyList();
+ this.superclass = null;
+ this.superinterfaces = Collections.emptyList();
+ this.enumConstants = Collections.emptyMap();
+ this.fieldSpecs = Collections.emptyList();
+ this.staticBlock = type.staticBlock;
+ this.initializerBlock = type.initializerBlock;
+ this.methodSpecs = Collections.emptyList();
+ this.typeSpecs = Collections.emptyList();
+ this.originatingElements = Collections.emptyList();
+ }
+
+ public boolean hasModifier(Modifier modifier) {
+ return modifiers.contains(modifier);
+ }
+
+ public static Builder classBuilder(String name) {
+ return new Builder(Kind.CLASS, checkNotNull(name, "name == null"), null);
+ }
+
+ public static Builder classBuilder(ClassName className) {
+ return classBuilder(checkNotNull(className, "className == null").simpleName());
+ }
+
+ public static Builder interfaceBuilder(String name) {
+ return new Builder(Kind.INTERFACE, checkNotNull(name, "name == null"), null);
+ }
+
+ public static Builder interfaceBuilder(ClassName className) {
+ return interfaceBuilder(checkNotNull(className, "className == null").simpleName());
+ }
+
+ public static Builder enumBuilder(String name) {
+ return new Builder(Kind.ENUM, checkNotNull(name, "name == null"), null);
+ }
+
+ public static Builder enumBuilder(ClassName className) {
+ return enumBuilder(checkNotNull(className, "className == null").simpleName());
+ }
+
+ public static Builder anonymousClassBuilder(String typeArgumentsFormat, Object... args) {
+ return anonymousClassBuilder(CodeBlock.builder()
+ .add(typeArgumentsFormat, args)
+ .build());
+ }
+
+ public static Builder anonymousClassBuilder(CodeBlock typeArguments) {
+ return new Builder(Kind.CLASS, null, typeArguments);
+ }
+
+ public static Builder annotationBuilder(String name) {
+ return new Builder(Kind.ANNOTATION, checkNotNull(name, "name == null"), null);
+ }
+
+ public static Builder annotationBuilder(ClassName className) {
+ return annotationBuilder(checkNotNull(className, "className == null").simpleName());
+ }
+
+ public Builder toBuilder() {
+ Builder builder = new Builder(kind, name, anonymousTypeArguments);
+ builder.javadoc.add(javadoc);
+ builder.annotations.addAll(annotations);
+ builder.modifiers.addAll(modifiers);
+ builder.typeVariables.addAll(typeVariables);
+ builder.superclass = superclass;
+ builder.superinterfaces.addAll(superinterfaces);
+ builder.enumConstants.putAll(enumConstants);
+ builder.fieldSpecs.addAll(fieldSpecs);
+ builder.methodSpecs.addAll(methodSpecs);
+ builder.typeSpecs.addAll(typeSpecs);
+ builder.initializerBlock.add(initializerBlock);
+ builder.staticBlock.add(staticBlock);
+ return builder;
+ }
+
+ void emit(CodeWriter codeWriter, String enumName, Set<Modifier> implicitModifiers)
+ throws IOException {
+ // Nested classes interrupt wrapped line indentation. Stash the current wrapping state and put
+ // it back afterwards when this type is complete.
+ int previousStatementLine = codeWriter.statementLine;
+ codeWriter.statementLine = -1;
+
+ try {
+ if (enumName != null) {
+ codeWriter.emitJavadoc(javadoc);
+ codeWriter.emitAnnotations(annotations, false);
+ codeWriter.emit("$L", enumName);
+ if (!anonymousTypeArguments.formatParts.isEmpty()) {
+ codeWriter.emit("(");
+ codeWriter.emit(anonymousTypeArguments);
+ codeWriter.emit(")");
+ }
+ if (fieldSpecs.isEmpty() && methodSpecs.isEmpty() && typeSpecs.isEmpty()) {
+ return; // Avoid unnecessary braces "{}".
+ }
+ codeWriter.emit(" {\n");
+ } else if (anonymousTypeArguments != null) {
+ TypeName supertype = !superinterfaces.isEmpty() ? superinterfaces.get(0) : superclass;
+ codeWriter.emit("new $T(", supertype);
+ codeWriter.emit(anonymousTypeArguments);
+ codeWriter.emit(") {\n");
+ } else {
+ // Push an empty type (specifically without nested types) for type-resolution.
+ codeWriter.pushType(new TypeSpec(this));
+
+ codeWriter.emitJavadoc(javadoc);
+ codeWriter.emitAnnotations(annotations, false);
+ codeWriter.emitModifiers(modifiers, Util.union(implicitModifiers, kind.asMemberModifiers));
+ if (kind == Kind.ANNOTATION) {
+ codeWriter.emit("$L $L", "@interface", name);
+ } else {
+ codeWriter.emit("$L $L", kind.name().toLowerCase(Locale.US), name);
+ }
+ codeWriter.emitTypeVariables(typeVariables);
+
+ List<TypeName> extendsTypes;
+ List<TypeName> implementsTypes;
+ if (kind == Kind.INTERFACE) {
+ extendsTypes = superinterfaces;
+ implementsTypes = Collections.emptyList();
+ } else {
+ extendsTypes = superclass.equals(ClassName.OBJECT)
+ ? Collections.emptyList()
+ : Collections.singletonList(superclass);
+ implementsTypes = superinterfaces;
+ }
+
+ if (!extendsTypes.isEmpty()) {
+ codeWriter.emit(" extends");
+ boolean firstType = true;
+ for (TypeName type : extendsTypes) {
+ if (!firstType) codeWriter.emit(",");
+ codeWriter.emit(" $T", type);
+ firstType = false;
+ }
+ }
+
+ if (!implementsTypes.isEmpty()) {
+ codeWriter.emit(" implements");
+ boolean firstType = true;
+ for (TypeName type : implementsTypes) {
+ if (!firstType) codeWriter.emit(",");
+ codeWriter.emit(" $T", type);
+ firstType = false;
+ }
+ }
+
+ codeWriter.popType();
+
+ codeWriter.emit(" {\n");
+ }
+
+ codeWriter.pushType(this);
+ codeWriter.indent();
+ boolean firstMember = true;
+ for (Iterator<Map.Entry<String, TypeSpec>> i = enumConstants.entrySet().iterator();
+ i.hasNext(); ) {
+ Map.Entry<String, TypeSpec> enumConstant = i.next();
+ if (!firstMember) codeWriter.emit("\n");
+ enumConstant.getValue().emit(codeWriter, enumConstant.getKey(), Collections.emptySet());
+ firstMember = false;
+ if (i.hasNext()) {
+ codeWriter.emit(",\n");
+ } else if (!fieldSpecs.isEmpty() || !methodSpecs.isEmpty() || !typeSpecs.isEmpty()) {
+ codeWriter.emit(";\n");
+ } else {
+ codeWriter.emit("\n");
+ }
+ }
+
+ // Static fields.
+ for (FieldSpec fieldSpec : fieldSpecs) {
+ if (!fieldSpec.hasModifier(Modifier.STATIC)) continue;
+ if (!firstMember) codeWriter.emit("\n");
+ fieldSpec.emit(codeWriter, kind.implicitFieldModifiers);
+ firstMember = false;
+ }
+
+ if (!staticBlock.isEmpty()) {
+ if (!firstMember) codeWriter.emit("\n");
+ codeWriter.emit(staticBlock);
+ firstMember = false;
+ }
+
+ // Non-static fields.
+ for (FieldSpec fieldSpec : fieldSpecs) {
+ if (fieldSpec.hasModifier(Modifier.STATIC)) continue;
+ if (!firstMember) codeWriter.emit("\n");
+ fieldSpec.emit(codeWriter, kind.implicitFieldModifiers);
+ firstMember = false;
+ }
+
+ // Initializer block.
+ if (!initializerBlock.isEmpty()) {
+ if (!firstMember) codeWriter.emit("\n");
+ codeWriter.emit(initializerBlock);
+ firstMember = false;
+ }
+
+ // Constructors.
+ for (MethodSpec methodSpec : methodSpecs) {
+ if (!methodSpec.isConstructor()) continue;
+ if (!firstMember) codeWriter.emit("\n");
+ methodSpec.emit(codeWriter, name, kind.implicitMethodModifiers);
+ firstMember = false;
+ }
+
+ // Methods (static and non-static).
+ for (MethodSpec methodSpec : methodSpecs) {
+ if (methodSpec.isConstructor()) continue;
+ if (!firstMember) codeWriter.emit("\n");
+ methodSpec.emit(codeWriter, name, kind.implicitMethodModifiers);
+ firstMember = false;
+ }
+
+ // Types.
+ for (TypeSpec typeSpec : typeSpecs) {
+ if (!firstMember) codeWriter.emit("\n");
+ typeSpec.emit(codeWriter, null, kind.implicitTypeModifiers);
+ firstMember = false;
+ }
+
+ codeWriter.unindent();
+ codeWriter.popType();
+
+ codeWriter.emit("}");
+ if (enumName == null && anonymousTypeArguments == null) {
+ codeWriter.emit("\n"); // If this type isn't also a value, include a trailing newline.
+ }
+ } finally {
+ codeWriter.statementLine = previousStatementLine;
+ }
+ }
+
+ @Override public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o == null) return false;
+ if (getClass() != o.getClass()) return false;
+ return toString().equals(o.toString());
+ }
+
+ @Override public int hashCode() {
+ return toString().hashCode();
+ }
+
+ @Override public String toString() {
+ StringBuilder out = new StringBuilder();
+ try {
+ CodeWriter codeWriter = new CodeWriter(out);
+ emit(codeWriter, null, Collections.emptySet());
+ return out.toString();
+ } catch (IOException e) {
+ throw new AssertionError();
+ }
+ }
+
+ public enum Kind {
+ CLASS(
+ Collections.emptySet(),
+ Collections.emptySet(),
+ Collections.emptySet(),
+ Collections.emptySet()),
+
+ INTERFACE(
+ Util.immutableSet(Arrays.asList(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)),
+ Util.immutableSet(Arrays.asList(Modifier.PUBLIC, Modifier.ABSTRACT)),
+ Util.immutableSet(Arrays.asList(Modifier.PUBLIC, Modifier.STATIC)),
+ Util.immutableSet(Collections.singletonList(Modifier.STATIC))),
+
+ ENUM(
+ Collections.emptySet(),
+ Collections.emptySet(),
+ Collections.emptySet(),
+ Collections.singleton(Modifier.STATIC)),
+
+ ANNOTATION(
+ Util.immutableSet(Arrays.asList(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)),
+ Util.immutableSet(Arrays.asList(Modifier.PUBLIC, Modifier.ABSTRACT)),
+ Util.immutableSet(Arrays.asList(Modifier.PUBLIC, Modifier.STATIC)),
+ Util.immutableSet(Collections.singletonList(Modifier.STATIC)));
+
+ private final Set<Modifier> implicitFieldModifiers;
+ private final Set<Modifier> implicitMethodModifiers;
+ private final Set<Modifier> implicitTypeModifiers;
+ private final Set<Modifier> asMemberModifiers;
+
+ Kind(Set<Modifier> implicitFieldModifiers,
+ Set<Modifier> implicitMethodModifiers,
+ Set<Modifier> implicitTypeModifiers,
+ Set<Modifier> asMemberModifiers) {
+ this.implicitFieldModifiers = implicitFieldModifiers;
+ this.implicitMethodModifiers = implicitMethodModifiers;
+ this.implicitTypeModifiers = implicitTypeModifiers;
+ this.asMemberModifiers = asMemberModifiers;
+ }
+ }
+
+ public static final class Builder {
+ private final Kind kind;
+ private final String name;
+ private final CodeBlock anonymousTypeArguments;
+
+ private final CodeBlock.Builder javadoc = CodeBlock.builder();
+ private final List<AnnotationSpec> annotations = new ArrayList<>();
+ private final List<Modifier> modifiers = new ArrayList<>();
+ private final List<TypeVariableName> typeVariables = new ArrayList<>();
+ private TypeName superclass = ClassName.OBJECT;
+ private final List<TypeName> superinterfaces = new ArrayList<>();
+ private final Map<String, TypeSpec> enumConstants = new LinkedHashMap<>();
+ private final List<FieldSpec> fieldSpecs = new ArrayList<>();
+ private final CodeBlock.Builder staticBlock = CodeBlock.builder();
+ private final CodeBlock.Builder initializerBlock = CodeBlock.builder();
+ private final List<MethodSpec> methodSpecs = new ArrayList<>();
+ private final List<TypeSpec> typeSpecs = new ArrayList<>();
+ private final List<Element> originatingElements = new ArrayList<>();
+
+ private Builder(Kind kind, String name,
+ CodeBlock anonymousTypeArguments) {
+ checkArgument(name == null || SourceVersion.isName(name), "not a valid name: %s", name);
+ this.kind = kind;
+ this.name = name;
+ this.anonymousTypeArguments = anonymousTypeArguments;
+ }
+
+ public Builder addJavadoc(String format, Object... args) {
+ javadoc.add(format, args);
+ return this;
+ }
+
+ public Builder addJavadoc(CodeBlock block) {
+ javadoc.add(block);
+ return this;
+ }
+
+ public Builder addAnnotations(Iterable<AnnotationSpec> annotationSpecs) {
+ checkArgument(annotationSpecs != null, "annotationSpecs == null");
+ for (AnnotationSpec annotationSpec : annotationSpecs) {
+ this.annotations.add(annotationSpec);
+ }
+ return this;
+ }
+
+ public Builder addAnnotation(AnnotationSpec annotationSpec) {
+ checkNotNull(annotationSpec, "annotationSpec == null");
+ this.annotations.add(annotationSpec);
+ return this;
+ }
+
+ public Builder addAnnotation(ClassName annotation) {
+ return addAnnotation(AnnotationSpec.builder(annotation).build());
+ }
+
+ public Builder addAnnotation(Class<?> annotation) {
+ return addAnnotation(ClassName.get(annotation));
+ }
+
+ public Builder addModifiers(Modifier... modifiers) {
+ checkState(anonymousTypeArguments == null, "forbidden on anonymous types.");
+ for (Modifier modifier : modifiers) {
+ checkArgument(modifier != null, "modifiers contain null");
+ this.modifiers.add(modifier);
+ }
+ return this;
+ }
+
+ public Builder addTypeVariables(Iterable<TypeVariableName> typeVariables) {
+ checkState(anonymousTypeArguments == null, "forbidden on anonymous types.");
+ checkArgument(typeVariables != null, "typeVariables == null");
+ for (TypeVariableName typeVariable : typeVariables) {
+ this.typeVariables.add(typeVariable);
+ }
+ return this;
+ }
+
+ public Builder addTypeVariable(TypeVariableName typeVariable) {
+ checkState(anonymousTypeArguments == null, "forbidden on anonymous types.");
+ typeVariables.add(typeVariable);
+ return this;
+ }
+
+ public Builder superclass(TypeName superclass) {
+ checkState(this.kind == Kind.CLASS, "only classes have super classes, not " + this.kind);
+ checkState(this.superclass == ClassName.OBJECT,
+ "superclass already set to " + this.superclass);
+ checkArgument(!superclass.isPrimitive(), "superclass may not be a primitive");
+ this.superclass = superclass;
+ return this;
+ }
+
+ public Builder superclass(Type superclass) {
+ return superclass(TypeName.get(superclass));
+ }
+
+ public Builder addSuperinterfaces(Iterable<? extends TypeName> superinterfaces) {
+ checkArgument(superinterfaces != null, "superinterfaces == null");
+ for (TypeName superinterface : superinterfaces) {
+ addSuperinterface(superinterface);
+ }
+ return this;
+ }
+
+ public Builder addSuperinterface(TypeName superinterface) {
+ checkArgument(superinterface != null, "superinterface == null");
+ this.superinterfaces.add(superinterface);
+ return this;
+ }
+
+ public Builder addSuperinterface(Type superinterface) {
+ return addSuperinterface(TypeName.get(superinterface));
+ }
+
+ public Builder addEnumConstant(String name) {
+ return addEnumConstant(name, anonymousClassBuilder("").build());
+ }
+
+ public Builder addEnumConstant(String name, TypeSpec typeSpec) {
+ checkState(kind == Kind.ENUM, "%s is not enum", this.name);
+ checkArgument(typeSpec.anonymousTypeArguments != null,
+ "enum constants must have anonymous type arguments");
+ checkArgument(SourceVersion.isName(name), "not a valid enum constant: %s", name);
+ enumConstants.put(name, typeSpec);
+ return this;
+ }
+
+ public Builder addFields(Iterable<FieldSpec> fieldSpecs) {
+ checkArgument(fieldSpecs != null, "fieldSpecs == null");
+ for (FieldSpec fieldSpec : fieldSpecs) {
+ addField(fieldSpec);
+ }
+ return this;
+ }
+
+ public Builder addField(FieldSpec fieldSpec) {
+ if (kind == Kind.INTERFACE || kind == Kind.ANNOTATION) {
+ requireExactlyOneOf(fieldSpec.modifiers, Modifier.PUBLIC, Modifier.PRIVATE);
+ Set<Modifier> check = EnumSet.of(Modifier.STATIC, Modifier.FINAL);
+ checkState(fieldSpec.modifiers.containsAll(check), "%s %s.%s requires modifiers %s",
+ kind, name, fieldSpec.name, check);
+ }
+ fieldSpecs.add(fieldSpec);
+ return this;
+ }
+
+ public Builder addField(TypeName type, String name, Modifier... modifiers) {
+ return addField(FieldSpec.builder(type, name, modifiers).build());
+ }
+
+ public Builder addField(Type type, String name, Modifier... modifiers) {
+ return addField(TypeName.get(type), name, modifiers);
+ }
+
+ public Builder addStaticBlock(CodeBlock block) {
+ staticBlock.beginControlFlow("static").add(block).endControlFlow();
+ return this;
+ }
+
+ public Builder addInitializerBlock(CodeBlock block) {
+ if ((kind != Kind.CLASS && kind != Kind.ENUM)) {
+ throw new UnsupportedOperationException(kind + " can't have initializer blocks");
+ }
+ initializerBlock.add("{\n")
+ .indent()
+ .add(block)
+ .unindent()
+ .add("}\n");
+ return this;
+ }
+
+ public Builder addMethods(Iterable<MethodSpec> methodSpecs) {
+ checkArgument(methodSpecs != null, "methodSpecs == null");
+ for (MethodSpec methodSpec : methodSpecs) {
+ addMethod(methodSpec);
+ }
+ return this;
+ }
+
+ public Builder addMethod(MethodSpec methodSpec) {
+ if (kind == Kind.INTERFACE) {
+ requireExactlyOneOf(methodSpec.modifiers, Modifier.ABSTRACT, Modifier.STATIC,
+ Modifier.DEFAULT);
+ requireExactlyOneOf(methodSpec.modifiers, Modifier.PUBLIC, Modifier.PRIVATE);
+ } else if (kind == Kind.ANNOTATION) {
+ checkState(methodSpec.modifiers.equals(kind.implicitMethodModifiers),
+ "%s %s.%s requires modifiers %s",
+ kind, name, methodSpec.name, kind.implicitMethodModifiers);
+ }
+ if (kind != Kind.ANNOTATION) {
+ checkState(methodSpec.defaultValue == null, "%s %s.%s cannot have a default value",
+ kind, name, methodSpec.name);
+ }
+ if (kind != Kind.INTERFACE) {
+ checkState(!methodSpec.hasModifier(Modifier.DEFAULT), "%s %s.%s cannot be default",
+ kind, name, methodSpec.name);
+ }
+ methodSpecs.add(methodSpec);
+ return this;
+ }
+
+ public Builder addTypes(Iterable<TypeSpec> typeSpecs) {
+ checkArgument(typeSpecs != null, "typeSpecs == null");
+ for (TypeSpec typeSpec : typeSpecs) {
+ addType(typeSpec);
+ }
+ return this;
+ }
+
+ public Builder addType(TypeSpec typeSpec) {
+ checkArgument(typeSpec.modifiers.containsAll(kind.implicitTypeModifiers),
+ "%s %s.%s requires modifiers %s", kind, name, typeSpec.name,
+ kind.implicitTypeModifiers);
+ typeSpecs.add(typeSpec);
+ return this;
+ }
+
+ public Builder addOriginatingElement(Element originatingElement) {
+ originatingElements.add(originatingElement);
+ return this;
+ }
+
+ public TypeSpec build() {
+ checkArgument(kind != Kind.ENUM || !enumConstants.isEmpty(),
+ "at least one enum constant is required for %s", name);
+
+ boolean isAbstract = modifiers.contains(Modifier.ABSTRACT) || kind != Kind.CLASS;
+ for (MethodSpec methodSpec : methodSpecs) {
+ checkArgument(isAbstract || !methodSpec.hasModifier(Modifier.ABSTRACT),
+ "non-abstract type %s cannot declare abstract method %s", name, methodSpec.name);
+ }
+
+ boolean superclassIsObject = superclass.equals(ClassName.OBJECT);
+ int interestingSupertypeCount = (superclassIsObject ? 0 : 1) + superinterfaces.size();
+ checkArgument(anonymousTypeArguments == null || interestingSupertypeCount <= 1,
+ "anonymous type has too many supertypes");
+
+ return new TypeSpec(this);
+ }
+ }
+}
diff --git a/src/main/java/com/squareup/javapoet/TypeVariableName.java b/src/main/java/com/squareup/javapoet/TypeVariableName.java
new file mode 100644
index 0000000..54c2fa5
--- /dev/null
+++ b/src/main/java/com/squareup/javapoet/TypeVariableName.java
@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 2015 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.lang.model.element.TypeParameterElement;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.type.TypeVariable;
+
+import static com.squareup.javapoet.Util.checkArgument;
+import static com.squareup.javapoet.Util.checkNotNull;
+
+public final class TypeVariableName extends TypeName {
+ public final String name;
+ public final List<TypeName> bounds;
+
+ private TypeVariableName(String name, List<TypeName> bounds) {
+ this(name, bounds, new ArrayList<>());
+ }
+
+ private TypeVariableName(String name, List<TypeName> bounds, List<AnnotationSpec> annotations) {
+ super(annotations);
+ this.name = checkNotNull(name, "name == null");
+ this.bounds = bounds;
+
+ for (TypeName bound : this.bounds) {
+ checkArgument(!bound.isPrimitive() && bound != VOID, "invalid bound: %s", bound);
+ }
+ }
+
+ @Override public TypeVariableName annotated(List<AnnotationSpec> annotations) {
+ return new TypeVariableName(name, bounds, annotations);
+ }
+
+ @Override public TypeName withoutAnnotations() {
+ return new TypeVariableName(name, bounds);
+ }
+
+ public TypeVariableName withBounds(Type... bounds) {
+ return withBounds(TypeName.list(bounds));
+ }
+
+ public TypeVariableName withBounds(TypeName... bounds) {
+ return withBounds(Arrays.asList(bounds));
+ }
+
+ public TypeVariableName withBounds(List<? extends TypeName> bounds) {
+ ArrayList<TypeName> newBounds = new ArrayList<>();
+ newBounds.addAll(this.bounds);
+ newBounds.addAll(bounds);
+ return new TypeVariableName(name, newBounds, annotations);
+ }
+
+ private static TypeVariableName of(String name, List<TypeName> bounds) {
+ // Strip java.lang.Object from bounds if it is present.
+ List<TypeName> boundsNoObject = new ArrayList<>(bounds);
+ boundsNoObject.remove(OBJECT);
+ return new TypeVariableName(name, Collections.unmodifiableList(boundsNoObject));
+ }
+
+ @Override CodeWriter emit(CodeWriter out) throws IOException {
+ emitAnnotations(out);
+ return out.emitAndIndent(name);
+ }
+
+ /** Returns type variable named {@code name} without bounds. */
+ public static TypeVariableName get(String name) {
+ return TypeVariableName.of(name, Collections.emptyList());
+ }
+
+ /** Returns type variable named {@code name} with {@code bounds}. */
+ public static TypeVariableName get(String name, TypeName... bounds) {
+ return TypeVariableName.of(name, Arrays.asList(bounds));
+ }
+
+ /** Returns type variable named {@code name} with {@code bounds}. */
+ public static TypeVariableName get(String name, Type... bounds) {
+ return TypeVariableName.of(name, TypeName.list(bounds));
+ }
+
+ /** Returns type variable equivalent to {@code mirror}. */
+ public static TypeVariableName get(TypeVariable mirror) {
+ return get((TypeParameterElement) mirror.asElement());
+ }
+
+ /**
+ * Make a TypeVariableName for the given TypeMirror. This form is used internally to avoid
+ * infinite recursion in cases like {@code Enum<E extends Enum<E>>}. When we encounter such a
+ * thing, we will make a TypeVariableName without bounds and add that to the {@code typeVariables}
+ * map before looking up the bounds. Then if we encounter this TypeVariable again while
+ * constructing the bounds, we can just return it from the map. And, the code that put the entry
+ * in {@code variables} will make sure that the bounds are filled in before returning.
+ */
+ static TypeVariableName get(
+ TypeVariable mirror, Map<TypeParameterElement, TypeVariableName> typeVariables) {
+ TypeParameterElement element = (TypeParameterElement) mirror.asElement();
+ TypeVariableName typeVariableName = typeVariables.get(element);
+ if (typeVariableName == null) {
+ // Since the bounds field is public, we need to make it an unmodifiableList. But we control
+ // the List that that wraps, which means we can change it before returning.
+ List<TypeName> bounds = new ArrayList<>();
+ List<TypeName> visibleBounds = Collections.unmodifiableList(bounds);
+ typeVariableName = new TypeVariableName(element.getSimpleName().toString(), visibleBounds);
+ typeVariables.put(element, typeVariableName);
+ for (TypeMirror typeMirror : element.getBounds()) {
+ bounds.add(TypeName.get(typeMirror, typeVariables));
+ }
+ bounds.remove(OBJECT);
+ }
+ return typeVariableName;
+ }
+
+ /** Returns type variable equivalent to {@code element}. */
+ public static TypeVariableName get(TypeParameterElement element) {
+ String name = element.getSimpleName().toString();
+ List<? extends TypeMirror> boundsMirrors = element.getBounds();
+
+ List<TypeName> boundsTypeNames = new ArrayList<>();
+ for (TypeMirror typeMirror : boundsMirrors) {
+ boundsTypeNames.add(TypeName.get(typeMirror));
+ }
+
+ return TypeVariableName.of(name, boundsTypeNames);
+ }
+
+ /** Returns type variable equivalent to {@code type}. */
+ public static TypeVariableName get(java.lang.reflect.TypeVariable<?> type) {
+ return get(type, new LinkedHashMap<>());
+ }
+
+ /** @see #get(java.lang.reflect.TypeVariable, Map) */
+ static TypeVariableName get(java.lang.reflect.TypeVariable<?> type,
+ Map<Type, TypeVariableName> map) {
+ TypeVariableName result = map.get(type);
+ if (result == null) {
+ List<TypeName> bounds = new ArrayList<>();
+ List<TypeName> visibleBounds = Collections.unmodifiableList(bounds);
+ result = new TypeVariableName(type.getName(), visibleBounds);
+ map.put(type, result);
+ for (Type bound : type.getBounds()) {
+ bounds.add(TypeName.get(bound, map));
+ }
+ bounds.remove(OBJECT);
+ }
+ return result;
+ }
+}
diff --git a/src/main/java/com/squareup/javapoet/Util.java b/src/main/java/com/squareup/javapoet/Util.java
new file mode 100644
index 0000000..e0eabad
--- /dev/null
+++ b/src/main/java/com/squareup/javapoet/Util.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2015 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import javax.lang.model.element.Modifier;
+
+import static java.lang.Character.isISOControl;
+
+/**
+ * Like Guava, but worse and standalone. This makes it easier to mix JavaPoet with libraries that
+ * bring their own version of Guava.
+ */
+final class Util {
+ private Util() {
+ }
+
+ static <K, V> Map<K, List<V>> immutableMultimap(Map<K, List<V>> multimap) {
+ LinkedHashMap<K, List<V>> result = new LinkedHashMap<>();
+ for (Map.Entry<K, List<V>> entry : multimap.entrySet()) {
+ if (entry.getValue().isEmpty()) continue;
+ result.put(entry.getKey(), immutableList(entry.getValue()));
+ }
+ return Collections.unmodifiableMap(result);
+ }
+
+ static <K, V> Map<K, V> immutableMap(Map<K, V> map) {
+ return Collections.unmodifiableMap(new LinkedHashMap<>(map));
+ }
+
+ static void checkArgument(boolean condition, String format, Object... args) {
+ if (!condition) throw new IllegalArgumentException(String.format(format, args));
+ }
+
+ static <T> T checkNotNull(T reference, String format, Object... args) {
+ if (reference == null) throw new NullPointerException(String.format(format, args));
+ return reference;
+ }
+
+ static void checkState(boolean condition, String format, Object... args) {
+ if (!condition) throw new IllegalStateException(String.format(format, args));
+ }
+
+ static <T> List<T> immutableList(Collection<T> collection) {
+ return Collections.unmodifiableList(new ArrayList<>(collection));
+ }
+
+ static <T> Set<T> immutableSet(Collection<T> set) {
+ return Collections.unmodifiableSet(new LinkedHashSet<>(set));
+ }
+
+ static <T> Set<T> union(Set<T> a, Set<T> b) {
+ Set<T> result = new LinkedHashSet<>();
+ result.addAll(a);
+ result.addAll(b);
+ return result;
+ }
+
+ static void requireExactlyOneOf(Set<Modifier> modifiers, Modifier... mutuallyExclusive) {
+ int count = 0;
+ for (Modifier modifier : mutuallyExclusive) {
+ if (modifiers.contains(modifier)) count++;
+ }
+ checkArgument(count == 1, "modifiers %s must contain one of %s",
+ modifiers, Arrays.toString(mutuallyExclusive));
+ }
+
+ static String characterLiteralWithoutSingleQuotes(char c) {
+ // see https://docs.oracle.com/javase/specs/jls/se7/html/jls-3.html#jls-3.10.6
+ switch (c) {
+ case '\b': return "\\b"; /* \u0008: backspace (BS) */
+ case '\t': return "\\t"; /* \u0009: horizontal tab (HT) */
+ case '\n': return "\\n"; /* \u000a: linefeed (LF) */
+ case '\f': return "\\f"; /* \u000c: form feed (FF) */
+ case '\r': return "\\r"; /* \u000d: carriage return (CR) */
+ case '\"': return "\""; /* \u0022: double quote (") */
+ case '\'': return "\\'"; /* \u0027: single quote (') */
+ case '\\': return "\\\\"; /* \u005c: backslash (\) */
+ default:
+ return isISOControl(c) ? String.format("\\u%04x", (int) c) : Character.toString(c);
+ }
+ }
+
+ /** Returns the string literal representing {@code value}, including wrapping double quotes. */
+ static String stringLiteralWithDoubleQuotes(String value, String indent) {
+ StringBuilder result = new StringBuilder(value.length() + 2);
+ result.append('"');
+ for (int i = 0; i < value.length(); i++) {
+ char c = value.charAt(i);
+ // trivial case: single quote must not be escaped
+ if (c == '\'') {
+ result.append("'");
+ continue;
+ }
+ // trivial case: double quotes must be escaped
+ if (c == '\"') {
+ result.append("\\\"");
+ continue;
+ }
+ // default case: just let character literal do its work
+ result.append(characterLiteralWithoutSingleQuotes(c));
+ // need to append indent after linefeed?
+ if (c == '\n' && i + 1 < value.length()) {
+ result.append("\"\n").append(indent).append(indent).append("+ \"");
+ }
+ }
+ result.append('"');
+ return result.toString();
+ }
+}
diff --git a/src/main/java/com/squareup/javapoet/WildcardTypeName.java b/src/main/java/com/squareup/javapoet/WildcardTypeName.java
new file mode 100644
index 0000000..17cb73f
--- /dev/null
+++ b/src/main/java/com/squareup/javapoet/WildcardTypeName.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (C) 2015 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.lang.reflect.WildcardType;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import javax.lang.model.element.TypeParameterElement;
+import javax.lang.model.type.TypeMirror;
+
+import static com.squareup.javapoet.Util.checkArgument;
+
+public final class WildcardTypeName extends TypeName {
+ public final List<TypeName> upperBounds;
+ public final List<TypeName> lowerBounds;
+
+ private WildcardTypeName(List<TypeName> upperBounds, List<TypeName> lowerBounds) {
+ this(upperBounds, lowerBounds, new ArrayList<>());
+ }
+
+ private WildcardTypeName(List<TypeName> upperBounds, List<TypeName> lowerBounds,
+ List<AnnotationSpec> annotations) {
+ super(annotations);
+ this.upperBounds = Util.immutableList(upperBounds);
+ this.lowerBounds = Util.immutableList(lowerBounds);
+
+ checkArgument(this.upperBounds.size() == 1, "unexpected extends bounds: %s", upperBounds);
+ for (TypeName upperBound : this.upperBounds) {
+ checkArgument(!upperBound.isPrimitive() && upperBound != VOID,
+ "invalid upper bound: %s", upperBound);
+ }
+ for (TypeName lowerBound : this.lowerBounds) {
+ checkArgument(!lowerBound.isPrimitive() && lowerBound != VOID,
+ "invalid lower bound: %s", lowerBound);
+ }
+ }
+
+ @Override public WildcardTypeName annotated(List<AnnotationSpec> annotations) {
+ return new WildcardTypeName(upperBounds, lowerBounds, concatAnnotations(annotations));
+ }
+
+ @Override public TypeName withoutAnnotations() {
+ return new WildcardTypeName(upperBounds, lowerBounds);
+ }
+
+ @Override CodeWriter emit(CodeWriter out) throws IOException {
+ if (lowerBounds.size() == 1) {
+ return out.emit("? super $T", lowerBounds.get(0));
+ }
+ return upperBounds.get(0).equals(TypeName.OBJECT)
+ ? out.emit("?")
+ : out.emit("? extends $T", upperBounds.get(0));
+ }
+
+ /**
+ * Returns a type that represents an unknown type that extends {@code bound}. For example, if
+ * {@code bound} is {@code CharSequence.class}, this returns {@code ? extends CharSequence}. If
+ * {@code bound} is {@code Object.class}, this returns {@code ?}, which is shorthand for {@code
+ * ? extends Object}.
+ */
+ public static WildcardTypeName subtypeOf(TypeName upperBound) {
+ return new WildcardTypeName(Collections.singletonList(upperBound), Collections.emptyList());
+ }
+
+ public static WildcardTypeName subtypeOf(Type upperBound) {
+ return subtypeOf(TypeName.get(upperBound));
+ }
+
+ /**
+ * Returns a type that represents an unknown supertype of {@code bound}. For example, if {@code
+ * bound} is {@code String.class}, this returns {@code ? super String}.
+ */
+ public static WildcardTypeName supertypeOf(TypeName lowerBound) {
+ return new WildcardTypeName(Collections.singletonList(OBJECT),
+ Collections.singletonList(lowerBound));
+ }
+
+ public static WildcardTypeName supertypeOf(Type lowerBound) {
+ return supertypeOf(TypeName.get(lowerBound));
+ }
+
+ public static TypeName get(javax.lang.model.type.WildcardType mirror) {
+ return get(mirror, new LinkedHashMap<>());
+ }
+
+ static TypeName get(
+ javax.lang.model.type.WildcardType mirror,
+ Map<TypeParameterElement, TypeVariableName> typeVariables) {
+ TypeMirror extendsBound = mirror.getExtendsBound();
+ if (extendsBound == null) {
+ TypeMirror superBound = mirror.getSuperBound();
+ if (superBound == null) {
+ return subtypeOf(Object.class);
+ } else {
+ return supertypeOf(TypeName.get(superBound, typeVariables));
+ }
+ } else {
+ return subtypeOf(TypeName.get(extendsBound, typeVariables));
+ }
+ }
+
+ public static TypeName get(WildcardType wildcardName) {
+ return get(wildcardName, new LinkedHashMap<>());
+ }
+
+ static TypeName get(WildcardType wildcardName, Map<Type, TypeVariableName> map) {
+ return new WildcardTypeName(
+ list(wildcardName.getUpperBounds(), map),
+ list(wildcardName.getLowerBounds(), map));
+ }
+}
diff --git a/src/test/java/com/squareup/javapoet/AbstractTypesTest.java b/src/test/java/com/squareup/javapoet/AbstractTypesTest.java
new file mode 100644
index 0000000..86d9cbc
--- /dev/null
+++ b/src/test/java/com/squareup/javapoet/AbstractTypesTest.java
@@ -0,0 +1,285 @@
+/*
+ * Copyright (C) 2014 Google, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+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 static javax.lang.model.util.ElementFilter.fieldsIn;
+import static org.junit.Assert.*;
+
+import com.google.testing.compile.Compilation;
+import com.google.testing.compile.JavaFileObjects;
+import java.io.Serializable;
+import java.lang.annotation.Annotation;
+import java.nio.charset.Charset;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import javax.annotation.processing.AbstractProcessor;
+import javax.annotation.processing.RoundEnvironment;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.TypeParameterElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.ErrorType;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.type.TypeVisitor;
+import javax.lang.model.type.WildcardType;
+import javax.lang.model.util.Elements;
+import javax.lang.model.util.Types;
+import javax.tools.JavaFileObject;
+
+import org.junit.Test;
+
+public abstract class AbstractTypesTest {
+ protected abstract Elements getElements();
+ protected abstract Types getTypes();
+
+ private TypeElement getElement(Class<?> clazz) {
+ return getElements().getTypeElement(clazz.getCanonicalName());
+ }
+
+ private TypeMirror getMirror(Class<?> clazz) {
+ return getElement(clazz).asType();
+ }
+
+ @Test public void getBasicTypeMirror() {
+ assertThat(TypeName.get(getMirror(Object.class)))
+ .isEqualTo(ClassName.get(Object.class));
+ assertThat(TypeName.get(getMirror(Charset.class)))
+ .isEqualTo(ClassName.get(Charset.class));
+ assertThat(TypeName.get(getMirror(AbstractTypesTest.class)))
+ .isEqualTo(ClassName.get(AbstractTypesTest.class));
+ }
+
+ @Test public void getParameterizedTypeMirror() {
+ DeclaredType setType =
+ getTypes().getDeclaredType(getElement(Set.class), getMirror(Object.class));
+ assertThat(TypeName.get(setType))
+ .isEqualTo(ParameterizedTypeName.get(ClassName.get(Set.class), ClassName.OBJECT));
+ }
+
+ @Test public void errorTypes() {
+ JavaFileObject hasErrorTypes =
+ JavaFileObjects.forSourceLines(
+ "com.squareup.tacos.ErrorTypes",
+ "package com.squareup.tacos;",
+ "",
+ "@SuppressWarnings(\"hook-into-compiler\")",
+ "class ErrorTypes {",
+ " Tacos tacos;",
+ " Ingredients.Guacamole guacamole;",
+ "}");
+ Compilation compilation = javac().withProcessors(new AbstractProcessor() {
+ @Override
+ public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
+ TypeElement classFile =
+ processingEnv.getElementUtils().getTypeElement("com.squareup.tacos.ErrorTypes");
+ List<VariableElement> fields = fieldsIn(classFile.getEnclosedElements());
+ ErrorType topLevel = (ErrorType) fields.get(0).asType();
+ ErrorType member = (ErrorType) fields.get(1).asType();
+
+ assertThat(TypeName.get(topLevel)).isEqualTo(ClassName.get("", "Tacos"));
+ assertThat(TypeName.get(member)).isEqualTo(ClassName.get("Ingredients", "Guacamole"));
+ return false;
+ }
+
+ @Override
+ public Set<String> getSupportedAnnotationTypes() {
+ return Collections.singleton("*");
+ }
+ }).compile(hasErrorTypes);
+
+ assertThat(compilation).failed();
+ }
+
+ static class Parameterized<
+ Simple,
+ ExtendsClass extends Number,
+ ExtendsInterface extends Runnable,
+ ExtendsTypeVariable extends Simple,
+ Intersection extends Number & Runnable,
+ IntersectionOfInterfaces extends Runnable & Serializable> {}
+
+ @Test public void getTypeVariableTypeMirror() {
+ List<? extends TypeParameterElement> typeVariables =
+ getElement(Parameterized.class).getTypeParameters();
+
+ // Members of converted types use ClassName and not Class<?>.
+ ClassName number = ClassName.get(Number.class);
+ ClassName runnable = ClassName.get(Runnable.class);
+ ClassName serializable = ClassName.get(Serializable.class);
+
+ assertThat(TypeName.get(typeVariables.get(0).asType()))
+ .isEqualTo(TypeVariableName.get("Simple"));
+ assertThat(TypeName.get(typeVariables.get(1).asType()))
+ .isEqualTo(TypeVariableName.get("ExtendsClass", number));
+ assertThat(TypeName.get(typeVariables.get(2).asType()))
+ .isEqualTo(TypeVariableName.get("ExtendsInterface", runnable));
+ assertThat(TypeName.get(typeVariables.get(3).asType()))
+ .isEqualTo(TypeVariableName.get("ExtendsTypeVariable", TypeVariableName.get("Simple")));
+ assertThat(TypeName.get(typeVariables.get(4).asType()))
+ .isEqualTo(TypeVariableName.get("Intersection", number, runnable));
+ assertThat(TypeName.get(typeVariables.get(5).asType()))
+ .isEqualTo(TypeVariableName.get("IntersectionOfInterfaces", runnable, serializable));
+ assertThat(((TypeVariableName) TypeName.get(typeVariables.get(4).asType())).bounds)
+ .containsExactly(number, runnable);
+ }
+
+ static class Recursive<T extends Map<List<T>, Set<T[]>>> {}
+
+ @Test
+ public void getTypeVariableTypeMirrorRecursive() {
+ TypeMirror typeMirror = getElement(Recursive.class).asType();
+ ParameterizedTypeName typeName = (ParameterizedTypeName) TypeName.get(typeMirror);
+ String className = Recursive.class.getCanonicalName();
+ assertThat(typeName.toString()).isEqualTo(className + "<T>");
+
+ TypeVariableName typeVariableName = (TypeVariableName) typeName.typeArguments.get(0);
+
+ try {
+ typeVariableName.bounds.set(0, null);
+ fail("Expected UnsupportedOperationException");
+ } catch (UnsupportedOperationException expected) {
+ }
+
+ assertThat(typeVariableName.toString()).isEqualTo("T");
+ assertThat(typeVariableName.bounds.toString())
+ .isEqualTo("[java.util.Map<java.util.List<T>, java.util.Set<T[]>>]");
+ }
+
+ @Test public void getPrimitiveTypeMirror() {
+ assertThat(TypeName.get(getTypes().getPrimitiveType(TypeKind.BOOLEAN)))
+ .isEqualTo(TypeName.BOOLEAN);
+ assertThat(TypeName.get(getTypes().getPrimitiveType(TypeKind.BYTE)))
+ .isEqualTo(TypeName.BYTE);
+ assertThat(TypeName.get(getTypes().getPrimitiveType(TypeKind.SHORT)))
+ .isEqualTo(TypeName.SHORT);
+ assertThat(TypeName.get(getTypes().getPrimitiveType(TypeKind.INT)))
+ .isEqualTo(TypeName.INT);
+ assertThat(TypeName.get(getTypes().getPrimitiveType(TypeKind.LONG)))
+ .isEqualTo(TypeName.LONG);
+ assertThat(TypeName.get(getTypes().getPrimitiveType(TypeKind.CHAR)))
+ .isEqualTo(TypeName.CHAR);
+ assertThat(TypeName.get(getTypes().getPrimitiveType(TypeKind.FLOAT)))
+ .isEqualTo(TypeName.FLOAT);
+ assertThat(TypeName.get(getTypes().getPrimitiveType(TypeKind.DOUBLE)))
+ .isEqualTo(TypeName.DOUBLE);
+ }
+
+ @Test public void getArrayTypeMirror() {
+ assertThat(TypeName.get(getTypes().getArrayType(getMirror(Object.class))))
+ .isEqualTo(ArrayTypeName.of(ClassName.OBJECT));
+ }
+
+ @Test public void getVoidTypeMirror() {
+ assertThat(TypeName.get(getTypes().getNoType(TypeKind.VOID)))
+ .isEqualTo(TypeName.VOID);
+ }
+
+ @Test public void getNullTypeMirror() {
+ try {
+ TypeName.get(getTypes().getNullType());
+ fail();
+ } catch (IllegalArgumentException expected) {
+ }
+ }
+
+ @Test public void parameterizedType() throws Exception {
+ ParameterizedTypeName type = ParameterizedTypeName.get(Map.class, String.class, Long.class);
+ assertThat(type.toString()).isEqualTo("java.util.Map<java.lang.String, java.lang.Long>");
+ }
+
+ @Test public void arrayType() throws Exception {
+ ArrayTypeName type = ArrayTypeName.of(String.class);
+ assertThat(type.toString()).isEqualTo("java.lang.String[]");
+ }
+
+ @Test public void wildcardExtendsType() throws Exception {
+ WildcardTypeName type = WildcardTypeName.subtypeOf(CharSequence.class);
+ assertThat(type.toString()).isEqualTo("? extends java.lang.CharSequence");
+ }
+
+ @Test public void wildcardExtendsObject() throws Exception {
+ WildcardTypeName type = WildcardTypeName.subtypeOf(Object.class);
+ assertThat(type.toString()).isEqualTo("?");
+ }
+
+ @Test public void wildcardSuperType() throws Exception {
+ WildcardTypeName type = WildcardTypeName.supertypeOf(String.class);
+ assertThat(type.toString()).isEqualTo("? super java.lang.String");
+ }
+
+ @Test public void wildcardMirrorNoBounds() throws Exception {
+ WildcardType wildcard = getTypes().getWildcardType(null, null);
+ TypeName type = TypeName.get(wildcard);
+ assertThat(type.toString()).isEqualTo("?");
+ }
+
+ @Test public void wildcardMirrorExtendsType() throws Exception {
+ Types types = getTypes();
+ Elements elements = getElements();
+ TypeMirror charSequence = elements.getTypeElement(CharSequence.class.getName()).asType();
+ WildcardType wildcard = types.getWildcardType(charSequence, null);
+ TypeName type = TypeName.get(wildcard);
+ assertThat(type.toString()).isEqualTo("? extends java.lang.CharSequence");
+ }
+
+ @Test public void wildcardMirrorSuperType() throws Exception {
+ Types types = getTypes();
+ Elements elements = getElements();
+ TypeMirror string = elements.getTypeElement(String.class.getName()).asType();
+ WildcardType wildcard = types.getWildcardType(null, string);
+ TypeName type = TypeName.get(wildcard);
+ assertThat(type.toString()).isEqualTo("? super java.lang.String");
+ }
+
+ @Test public void typeVariable() throws Exception {
+ TypeVariableName type = TypeVariableName.get("T", CharSequence.class);
+ assertThat(type.toString()).isEqualTo("T"); // (Bounds are only emitted in declaration.)
+ }
+
+ @Test public void box() throws Exception {
+ assertThat(TypeName.INT.box()).isEqualTo(ClassName.get(Integer.class));
+ assertThat(TypeName.VOID.box()).isEqualTo(ClassName.get(Void.class));
+ assertThat(ClassName.get(Integer.class).box()).isEqualTo(ClassName.get(Integer.class));
+ assertThat(ClassName.get(Void.class).box()).isEqualTo(ClassName.get(Void.class));
+ assertThat(TypeName.OBJECT.box()).isEqualTo(TypeName.OBJECT);
+ assertThat(ClassName.get(String.class).box()).isEqualTo(ClassName.get(String.class));
+ }
+
+ @Test public void unbox() throws Exception {
+ assertThat(TypeName.INT).isEqualTo(TypeName.INT.unbox());
+ assertThat(TypeName.VOID).isEqualTo(TypeName.VOID.unbox());
+ assertThat(ClassName.get(Integer.class).unbox()).isEqualTo(TypeName.INT.unbox());
+ assertThat(ClassName.get(Void.class).unbox()).isEqualTo(TypeName.VOID.unbox());
+ try {
+ TypeName.OBJECT.unbox();
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ try {
+ ClassName.get(String.class).unbox();
+ fail();
+ } catch (UnsupportedOperationException expected) {
+ }
+ }
+}
diff --git a/src/test/java/com/squareup/javapoet/AnnotatedTypeNameTest.java b/src/test/java/com/squareup/javapoet/AnnotatedTypeNameTest.java
new file mode 100644
index 0000000..42734ff
--- /dev/null
+++ b/src/test/java/com/squareup/javapoet/AnnotatedTypeNameTest.java
@@ -0,0 +1,217 @@
+/*
+ * Copyright (C) 2015 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+import java.util.List;
+import java.util.Map;
+import org.junit.Test;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
+
+public class AnnotatedTypeNameTest {
+
+ private final static String NN = NeverNull.class.getCanonicalName();
+ private final AnnotationSpec NEVER_NULL = AnnotationSpec.builder(NeverNull.class).build();
+ private final static String TUA = TypeUseAnnotation.class.getCanonicalName();
+ private final AnnotationSpec TYPE_USE_ANNOTATION =
+ AnnotationSpec.builder(TypeUseAnnotation.class).build();
+
+ @Target(ElementType.TYPE_USE)
+ public @interface NeverNull {}
+
+ @Target(ElementType.TYPE_USE)
+ public @interface TypeUseAnnotation {}
+
+
+ @Test(expected=NullPointerException.class) public void nullAnnotationArray() {
+ TypeName.BOOLEAN.annotated((AnnotationSpec[]) null);
+ }
+
+ @Test(expected=NullPointerException.class) public void nullAnnotationList() {
+ TypeName.DOUBLE.annotated((List<AnnotationSpec>) null);
+ }
+
+ @Test public void annotated() {
+ TypeName simpleString = TypeName.get(String.class);
+ assertFalse(simpleString.isAnnotated());
+ assertEquals(simpleString, TypeName.get(String.class));
+
+ TypeName annotated = simpleString.annotated(NEVER_NULL);
+ assertTrue(annotated.isAnnotated());
+ assertEquals(annotated, annotated.annotated());
+ }
+
+ @Test public void annotatedType() {
+ TypeName type = TypeName.get(String.class);
+ TypeName actual = type.annotated(TYPE_USE_ANNOTATION);
+ assertThat(actual.toString()).isEqualTo("java.lang. @" + TUA + " String");
+ }
+
+ @Test public void annotatedTwice() {
+ TypeName type = TypeName.get(String.class);
+ TypeName actual =
+ type.annotated(NEVER_NULL)
+ .annotated(TYPE_USE_ANNOTATION);
+ assertThat(actual.toString())
+ .isEqualTo("java.lang. @" + NN + " @" + TUA + " String");
+ }
+
+ @Test public void annotatedParameterizedType() {
+ TypeName type = ParameterizedTypeName.get(List.class, String.class);
+ TypeName actual = type.annotated(TYPE_USE_ANNOTATION);
+ assertThat(actual.toString()).isEqualTo("java.util. @" + TUA + " List<java.lang.String>");
+ }
+
+ @Test public void annotatedArgumentOfParameterizedType() {
+ TypeName type = TypeName.get(String.class).annotated(TYPE_USE_ANNOTATION);
+ TypeName actual = ParameterizedTypeName.get(ClassName.get(List.class), type);
+ assertThat(actual.toString()).isEqualTo("java.util.List<java.lang. @" + TUA + " String>");
+ }
+
+ @Test public void annotatedWildcardTypeNameWithSuper() {
+ TypeName type = TypeName.get(String.class).annotated(TYPE_USE_ANNOTATION);
+ TypeName actual = WildcardTypeName.supertypeOf(type);
+ assertThat(actual.toString()).isEqualTo("? super java.lang. @" + TUA + " String");
+ }
+
+ @Test public void annotatedWildcardTypeNameWithExtends() {
+ TypeName type = TypeName.get(String.class).annotated(TYPE_USE_ANNOTATION);
+ TypeName actual = WildcardTypeName.subtypeOf(type);
+ assertThat(actual.toString()).isEqualTo("? extends java.lang. @" + TUA + " String");
+ }
+
+ @Test public void annotatedEquivalence() {
+ annotatedEquivalence(TypeName.VOID);
+ annotatedEquivalence(ArrayTypeName.get(Object[].class));
+ annotatedEquivalence(ClassName.get(Object.class));
+ annotatedEquivalence(ParameterizedTypeName.get(List.class, Object.class));
+ annotatedEquivalence(TypeVariableName.get(Object.class));
+ annotatedEquivalence(WildcardTypeName.get(Object.class));
+ }
+
+ private void annotatedEquivalence(TypeName type) {
+ assertFalse(type.isAnnotated());
+ assertEquals(type, type);
+ assertEquals(type.annotated(TYPE_USE_ANNOTATION), type.annotated(TYPE_USE_ANNOTATION));
+ assertNotEquals(type, type.annotated(TYPE_USE_ANNOTATION));
+ assertEquals(type.hashCode(), type.hashCode());
+ assertEquals(type.annotated(TYPE_USE_ANNOTATION).hashCode(),
+ type.annotated(TYPE_USE_ANNOTATION).hashCode());
+ assertNotEquals(type.hashCode(), type.annotated(TYPE_USE_ANNOTATION).hashCode());
+ }
+
+ // https://github.com/square/javapoet/issues/431
+ @Test public void annotatedNestedType() {
+ TypeName type = TypeName.get(Map.Entry.class).annotated(TYPE_USE_ANNOTATION);
+ assertThat(type.toString()).isEqualTo("java.util.Map. @" + TUA + " Entry");
+ }
+
+ @Test public void annotatedEnclosingAndNestedType() {
+ TypeName type = ((ClassName) TypeName.get(Map.class).annotated(TYPE_USE_ANNOTATION))
+ .nestedClass("Entry").annotated(TYPE_USE_ANNOTATION);
+ assertThat(type.toString()).isEqualTo("java.util. @" + TUA + " Map. @" + TUA + " Entry");
+ }
+
+ // https://github.com/square/javapoet/issues/431
+ @Test public void annotatedNestedParameterizedType() {
+ TypeName type = ParameterizedTypeName.get(Map.Entry.class, Byte.class, Byte.class)
+ .annotated(TYPE_USE_ANNOTATION);
+ assertThat(type.toString())
+ .isEqualTo("java.util.Map. @" + TUA + " Entry<java.lang.Byte, java.lang.Byte>");
+ }
+
+ @Test public void withoutAnnotationsOnAnnotatedEnclosingAndNestedType() {
+ TypeName type = ((ClassName) TypeName.get(Map.class).annotated(TYPE_USE_ANNOTATION))
+ .nestedClass("Entry").annotated(TYPE_USE_ANNOTATION);
+ assertThat(type.isAnnotated()).isTrue();
+ assertThat(type.withoutAnnotations()).isEqualTo(TypeName.get(Map.Entry.class));
+ }
+
+ @Test public void withoutAnnotationsOnAnnotatedEnclosingType() {
+ TypeName type = ((ClassName) TypeName.get(Map.class).annotated(TYPE_USE_ANNOTATION))
+ .nestedClass("Entry");
+ assertThat(type.isAnnotated()).isTrue();
+ assertThat(type.withoutAnnotations()).isEqualTo(TypeName.get(Map.Entry.class));
+ }
+
+ @Test public void withoutAnnotationsOnAnnotatedNestedType() {
+ TypeName type = ((ClassName) TypeName.get(Map.class))
+ .nestedClass("Entry").annotated(TYPE_USE_ANNOTATION);
+ assertThat(type.isAnnotated()).isTrue();
+ assertThat(type.withoutAnnotations()).isEqualTo(TypeName.get(Map.Entry.class));
+ }
+
+ // https://github.com/square/javapoet/issues/614
+ @Test public void annotatedArrayType() {
+ TypeName type = ArrayTypeName.of(ClassName.get(Object.class)).annotated(TYPE_USE_ANNOTATION);
+ assertThat(type.toString()).isEqualTo("java.lang.Object @" + TUA + " []");
+ }
+
+ @Test public void annotatedArrayElementType() {
+ TypeName type = ArrayTypeName.of(ClassName.get(Object.class).annotated(TYPE_USE_ANNOTATION));
+ assertThat(type.toString()).isEqualTo("java.lang. @" + TUA + " Object[]");
+ }
+
+ // https://github.com/square/javapoet/issues/614
+ @Test public void annotatedOuterMultidimensionalArrayType() {
+ TypeName type = ArrayTypeName.of(ArrayTypeName.of(ClassName.get(Object.class)))
+ .annotated(TYPE_USE_ANNOTATION);
+ assertThat(type.toString()).isEqualTo("java.lang.Object @" + TUA + " [][]");
+ }
+
+ // https://github.com/square/javapoet/issues/614
+ @Test public void annotatedInnerMultidimensionalArrayType() {
+ TypeName type = ArrayTypeName.of(ArrayTypeName.of(ClassName.get(Object.class))
+ .annotated(TYPE_USE_ANNOTATION));
+ assertThat(type.toString()).isEqualTo("java.lang.Object[] @" + TUA + " []");
+ }
+
+ // https://github.com/square/javapoet/issues/614
+ @Test public void annotatedArrayTypeVarargsParameter() {
+ TypeName type = ArrayTypeName.of(ArrayTypeName.of(ClassName.get(Object.class)))
+ .annotated(TYPE_USE_ANNOTATION);
+ MethodSpec varargsMethod = MethodSpec.methodBuilder("m")
+ .addParameter(
+ ParameterSpec.builder(type, "p")
+ .build())
+ .varargs()
+ .build();
+ assertThat(varargsMethod.toString()).isEqualTo(""
+ + "void m(java.lang.Object @" + TUA + " []... p) {\n"
+ + "}\n");
+ }
+
+ // https://github.com/square/javapoet/issues/614
+ @Test public void annotatedArrayTypeInVarargsParameter() {
+ TypeName type = ArrayTypeName.of(ArrayTypeName.of(ClassName.get(Object.class))
+ .annotated(TYPE_USE_ANNOTATION));
+ MethodSpec varargsMethod = MethodSpec.methodBuilder("m")
+ .addParameter(
+ ParameterSpec.builder(type, "p")
+ .build())
+ .varargs()
+ .build();
+ assertThat(varargsMethod.toString()).isEqualTo(""
+ + "void m(java.lang.Object[] @" + TUA + " ... p) {\n"
+ + "}\n");
+ }
+}
diff --git a/src/test/java/com/squareup/javapoet/AnnotationSpecTest.java b/src/test/java/com/squareup/javapoet/AnnotationSpecTest.java
new file mode 100644
index 0000000..49606c7
--- /dev/null
+++ b/src/test/java/com/squareup/javapoet/AnnotationSpecTest.java
@@ -0,0 +1,377 @@
+/*
+ * Copyright (C) 2015 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import com.google.testing.compile.CompilationRule;
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import javax.lang.model.element.TypeElement;
+import org.junit.Rule;
+import org.junit.Test;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
+public final class AnnotationSpecTest {
+
+ @Retention(RetentionPolicy.RUNTIME)
+ public @interface AnnotationA {
+ }
+
+ @Inherited
+ @Retention(RetentionPolicy.RUNTIME)
+ public @interface AnnotationB {
+ }
+
+ @Retention(RetentionPolicy.RUNTIME)
+ public @interface AnnotationC {
+ String value();
+ }
+
+ public enum Breakfast {
+ WAFFLES, PANCAKES;
+ public String toString() { return name() + " with cherries!"; };
+ }
+
+ @Retention(RetentionPolicy.RUNTIME)
+ public @interface HasDefaultsAnnotation {
+
+ byte a() default 5;
+
+ short b() default 6;
+
+ int c() default 7;
+
+ long d() default 8;
+
+ float e() default 9.0f;
+
+ double f() default 10.0;
+
+ char[] g() default {0, 0xCAFE, 'z', '€', 'ℕ', '"', '\'', '\t', '\n'};
+
+ boolean h() default true;
+
+ Breakfast i() default Breakfast.WAFFLES;
+
+ AnnotationA j() default @AnnotationA();
+
+ String k() default "maple";
+
+ Class<? extends Annotation> l() default AnnotationB.class;
+
+ int[] m() default {1, 2, 3};
+
+ Breakfast[] n() default {Breakfast.WAFFLES, Breakfast.PANCAKES};
+
+ Breakfast o();
+
+ int p();
+
+ AnnotationC q() default @AnnotationC("foo");
+
+ Class<? extends Number>[] r() default {Byte.class, Short.class, Integer.class, Long.class};
+
+ }
+
+ @HasDefaultsAnnotation(
+ o = Breakfast.PANCAKES,
+ p = 1701,
+ f = 11.1,
+ m = {9, 8, 1},
+ l = Override.class,
+ j = @AnnotationA,
+ q = @AnnotationC("bar"),
+ r = {Float.class, Double.class})
+ public class IsAnnotated {
+ // empty
+ }
+
+ @Rule public final CompilationRule compilation = new CompilationRule();
+
+ @Test public void equalsAndHashCode() {
+ AnnotationSpec a = AnnotationSpec.builder(AnnotationC.class).build();
+ AnnotationSpec b = AnnotationSpec.builder(AnnotationC.class).build();
+ assertThat(a.equals(b)).isTrue();
+ assertThat(a.hashCode()).isEqualTo(b.hashCode());
+ a = AnnotationSpec.builder(AnnotationC.class).addMember("value", "$S", "123").build();
+ b = AnnotationSpec.builder(AnnotationC.class).addMember("value", "$S", "123").build();
+ assertThat(a.equals(b)).isTrue();
+ assertThat(a.hashCode()).isEqualTo(b.hashCode());
+ }
+
+ @Test public void defaultAnnotation() {
+ String name = IsAnnotated.class.getCanonicalName();
+ TypeElement element = compilation.getElements().getTypeElement(name);
+ AnnotationSpec annotation = AnnotationSpec.get(element.getAnnotationMirrors().get(0));
+
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addAnnotation(annotation)
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import com.squareup.javapoet.AnnotationSpecTest;\n"
+ + "import java.lang.Double;\n"
+ + "import java.lang.Float;\n"
+ + "import java.lang.Override;\n"
+ + "\n"
+ + "@AnnotationSpecTest.HasDefaultsAnnotation(\n"
+ + " o = AnnotationSpecTest.Breakfast.PANCAKES,\n"
+ + " p = 1701,\n"
+ + " f = 11.1,\n"
+ + " m = {\n"
+ + " 9,\n"
+ + " 8,\n"
+ + " 1\n"
+ + " },\n"
+ + " l = Override.class,\n"
+ + " j = @AnnotationSpecTest.AnnotationA,\n"
+ + " q = @AnnotationSpecTest.AnnotationC(\"bar\"),\n"
+ + " r = {\n"
+ + " Float.class,\n"
+ + " Double.class\n"
+ + " }\n"
+ + ")\n"
+ + "class Taco {\n"
+ + "}\n");
+ }
+
+ @Test public void defaultAnnotationWithImport() {
+ String name = IsAnnotated.class.getCanonicalName();
+ TypeElement element = compilation.getElements().getTypeElement(name);
+ AnnotationSpec annotation = AnnotationSpec.get(element.getAnnotationMirrors().get(0));
+ TypeSpec.Builder typeBuilder = TypeSpec.classBuilder(IsAnnotated.class.getSimpleName());
+ typeBuilder.addAnnotation(annotation);
+ JavaFile file = JavaFile.builder("com.squareup.javapoet", typeBuilder.build()).build();
+ assertThat(file.toString()).isEqualTo(
+ "package com.squareup.javapoet;\n"
+ + "\n"
+ + "import java.lang.Double;\n"
+ + "import java.lang.Float;\n"
+ + "import java.lang.Override;\n"
+ + "\n"
+ + "@AnnotationSpecTest.HasDefaultsAnnotation(\n"
+ + " o = AnnotationSpecTest.Breakfast.PANCAKES,\n"
+ + " p = 1701,\n"
+ + " f = 11.1,\n"
+ + " m = {\n"
+ + " 9,\n"
+ + " 8,\n"
+ + " 1\n"
+ + " },\n"
+ + " l = Override.class,\n"
+ + " j = @AnnotationSpecTest.AnnotationA,\n"
+ + " q = @AnnotationSpecTest.AnnotationC(\"bar\"),\n"
+ + " r = {\n"
+ + " Float.class,\n"
+ + " Double.class\n"
+ + " }\n"
+ + ")\n"
+ + "class IsAnnotated {\n"
+ + "}\n"
+ );
+ }
+
+ @Test public void emptyArray() {
+ AnnotationSpec.Builder builder = AnnotationSpec.builder(HasDefaultsAnnotation.class);
+ builder.addMember("n", "$L", "{}");
+ assertThat(builder.build().toString()).isEqualTo(
+ "@com.squareup.javapoet.AnnotationSpecTest.HasDefaultsAnnotation(" + "n = {}" + ")");
+ builder.addMember("m", "$L", "{}");
+ assertThat(builder.build().toString())
+ .isEqualTo(
+ "@com.squareup.javapoet.AnnotationSpecTest.HasDefaultsAnnotation("
+ + "n = {}, m = {}"
+ + ")");
+ }
+
+ @Test public void dynamicArrayOfEnumConstants() {
+ AnnotationSpec.Builder builder = AnnotationSpec.builder(HasDefaultsAnnotation.class);
+ builder.addMember("n", "$T.$L", Breakfast.class, Breakfast.PANCAKES.name());
+ assertThat(builder.build().toString()).isEqualTo(
+ "@com.squareup.javapoet.AnnotationSpecTest.HasDefaultsAnnotation("
+ + "n = com.squareup.javapoet.AnnotationSpecTest.Breakfast.PANCAKES"
+ + ")");
+
+ // builder = AnnotationSpec.builder(HasDefaultsAnnotation.class);
+ builder.addMember("n", "$T.$L", Breakfast.class, Breakfast.WAFFLES.name());
+ builder.addMember("n", "$T.$L", Breakfast.class, Breakfast.PANCAKES.name());
+ assertThat(builder.build().toString()).isEqualTo(
+ "@com.squareup.javapoet.AnnotationSpecTest.HasDefaultsAnnotation("
+ + "n = {"
+ + "com.squareup.javapoet.AnnotationSpecTest.Breakfast.PANCAKES"
+ + ", com.squareup.javapoet.AnnotationSpecTest.Breakfast.WAFFLES"
+ + ", com.squareup.javapoet.AnnotationSpecTest.Breakfast.PANCAKES"
+ + "})");
+
+ builder = builder.build().toBuilder(); // idempotent
+ assertThat(builder.build().toString()).isEqualTo(
+ "@com.squareup.javapoet.AnnotationSpecTest.HasDefaultsAnnotation("
+ + "n = {"
+ + "com.squareup.javapoet.AnnotationSpecTest.Breakfast.PANCAKES"
+ + ", com.squareup.javapoet.AnnotationSpecTest.Breakfast.WAFFLES"
+ + ", com.squareup.javapoet.AnnotationSpecTest.Breakfast.PANCAKES"
+ + "})");
+
+ builder.addMember("n", "$T.$L", Breakfast.class, Breakfast.WAFFLES.name());
+ assertThat(builder.build().toString()).isEqualTo(
+ "@com.squareup.javapoet.AnnotationSpecTest.HasDefaultsAnnotation("
+ + "n = {"
+ + "com.squareup.javapoet.AnnotationSpecTest.Breakfast.PANCAKES"
+ + ", com.squareup.javapoet.AnnotationSpecTest.Breakfast.WAFFLES"
+ + ", com.squareup.javapoet.AnnotationSpecTest.Breakfast.PANCAKES"
+ + ", com.squareup.javapoet.AnnotationSpecTest.Breakfast.WAFFLES"
+ + "})");
+ }
+
+ @Test public void defaultAnnotationToBuilder() {
+ String name = IsAnnotated.class.getCanonicalName();
+ TypeElement element = compilation.getElements().getTypeElement(name);
+ AnnotationSpec.Builder builder = AnnotationSpec.get(element.getAnnotationMirrors().get(0))
+ .toBuilder();
+ builder.addMember("m", "$L", 123);
+ assertThat(builder.build().toString()).isEqualTo(
+ "@com.squareup.javapoet.AnnotationSpecTest.HasDefaultsAnnotation("
+ + "o = com.squareup.javapoet.AnnotationSpecTest.Breakfast.PANCAKES"
+ + ", p = 1701"
+ + ", f = 11.1"
+ + ", m = {9, 8, 1, 123}"
+ + ", l = java.lang.Override.class"
+ + ", j = @com.squareup.javapoet.AnnotationSpecTest.AnnotationA"
+ + ", q = @com.squareup.javapoet.AnnotationSpecTest.AnnotationC(\"bar\")"
+ + ", r = {java.lang.Float.class, java.lang.Double.class}"
+ + ")");
+ }
+
+ @Test public void reflectAnnotation() {
+ HasDefaultsAnnotation annotation = IsAnnotated.class.getAnnotation(HasDefaultsAnnotation.class);
+ AnnotationSpec spec = AnnotationSpec.get(annotation);
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addAnnotation(spec)
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import com.squareup.javapoet.AnnotationSpecTest;\n"
+ + "import java.lang.Double;\n"
+ + "import java.lang.Float;\n"
+ + "import java.lang.Override;\n"
+ + "\n"
+ + "@AnnotationSpecTest.HasDefaultsAnnotation(\n"
+ + " f = 11.1,\n"
+ + " l = Override.class,\n"
+ + " m = {\n"
+ + " 9,\n"
+ + " 8,\n"
+ + " 1\n"
+ + " },\n"
+ + " o = AnnotationSpecTest.Breakfast.PANCAKES,\n"
+ + " p = 1701,\n"
+ + " q = @AnnotationSpecTest.AnnotationC(\"bar\"),\n"
+ + " r = {\n"
+ + " Float.class,\n"
+ + " Double.class\n"
+ + " }\n"
+ + ")\n"
+ + "class Taco {\n"
+ + "}\n");
+ }
+
+ @Test public void reflectAnnotationWithDefaults() {
+ HasDefaultsAnnotation annotation = IsAnnotated.class.getAnnotation(HasDefaultsAnnotation.class);
+ AnnotationSpec spec = AnnotationSpec.get(annotation, true);
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addAnnotation(spec)
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import com.squareup.javapoet.AnnotationSpecTest;\n"
+ + "import java.lang.Double;\n"
+ + "import java.lang.Float;\n"
+ + "import java.lang.Override;\n"
+ + "\n"
+ + "@AnnotationSpecTest.HasDefaultsAnnotation(\n"
+ + " a = 5,\n"
+ + " b = 6,\n"
+ + " c = 7,\n"
+ + " d = 8,\n"
+ + " e = 9.0f,\n"
+ + " f = 11.1,\n"
+ + " g = {\n"
+ + " '\\u0000',\n"
+ + " '쫾',\n"
+ + " 'z',\n"
+ + " '€',\n"
+ + " 'ℕ',\n"
+ + " '\"',\n"
+ + " '\\'',\n"
+ + " '\\t',\n"
+ + " '\\n'\n"
+ + " },\n"
+ + " h = true,\n"
+ + " i = AnnotationSpecTest.Breakfast.WAFFLES,\n"
+ + " j = @AnnotationSpecTest.AnnotationA,\n"
+ + " k = \"maple\",\n"
+ + " l = Override.class,\n"
+ + " m = {\n"
+ + " 9,\n"
+ + " 8,\n"
+ + " 1\n"
+ + " },\n"
+ + " n = {\n"
+ + " AnnotationSpecTest.Breakfast.WAFFLES,\n"
+ + " AnnotationSpecTest.Breakfast.PANCAKES\n"
+ + " },\n"
+ + " o = AnnotationSpecTest.Breakfast.PANCAKES,\n"
+ + " p = 1701,\n"
+ + " q = @AnnotationSpecTest.AnnotationC(\"bar\"),\n"
+ + " r = {\n"
+ + " Float.class,\n"
+ + " Double.class\n"
+ + " }\n"
+ + ")\n"
+ + "class Taco {\n"
+ + "}\n");
+ }
+
+ @Test public void disallowsNullMemberName() {
+ AnnotationSpec.Builder builder = AnnotationSpec.builder(HasDefaultsAnnotation.class);
+ try {
+ AnnotationSpec.Builder $L = builder.addMember(null, "$L", "");
+ fail($L.build().toString());
+ } catch (NullPointerException e) {
+ assertThat(e).hasMessageThat().isEqualTo("name == null");
+ }
+ }
+
+ @Test public void requiresValidMemberName() {
+ AnnotationSpec.Builder builder = AnnotationSpec.builder(HasDefaultsAnnotation.class);
+ try {
+ AnnotationSpec.Builder $L = builder.addMember("@", "$L", "");
+ fail($L.build().toString());
+ } catch (IllegalArgumentException e) {
+ assertThat(e).hasMessageThat().isEqualTo("not a valid name: @");
+ }
+ }
+
+ private String toString(TypeSpec typeSpec) {
+ return JavaFile.builder("com.squareup.tacos", typeSpec).build().toString();
+ }
+}
diff --git a/src/test/java/com/squareup/javapoet/ClassNameTest.java b/src/test/java/com/squareup/javapoet/ClassNameTest.java
new file mode 100644
index 0000000..e2cc55e
--- /dev/null
+++ b/src/test/java/com/squareup/javapoet/ClassNameTest.java
@@ -0,0 +1,196 @@
+/*
+ * Copyright (C) 2014 Google, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import com.google.testing.compile.CompilationRule;
+import java.util.Map;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.util.Elements;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.Mockito;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.when;
+
+@RunWith(JUnit4.class)
+public final class ClassNameTest {
+ @Rule public CompilationRule compilationRule = new CompilationRule();
+
+ @Test public void bestGuessForString_simpleClass() {
+ assertThat(ClassName.bestGuess(String.class.getName()))
+ .isEqualTo(ClassName.get("java.lang", "String"));
+ }
+
+ @Test public void bestGuessNonAscii() {
+ ClassName className = ClassName.bestGuess(
+ "com.\ud835\udc1andro\ud835\udc22d.\ud835\udc00ctiv\ud835\udc22ty");
+ assertEquals("com.\ud835\udc1andro\ud835\udc22d", className.packageName());
+ assertEquals("\ud835\udc00ctiv\ud835\udc22ty", className.simpleName());
+ }
+
+ static class OuterClass {
+ static class InnerClass {}
+ }
+
+ @Test public void bestGuessForString_nestedClass() {
+ assertThat(ClassName.bestGuess(Map.Entry.class.getCanonicalName()))
+ .isEqualTo(ClassName.get("java.util", "Map", "Entry"));
+ assertThat(ClassName.bestGuess(OuterClass.InnerClass.class.getCanonicalName()))
+ .isEqualTo(ClassName.get("com.squareup.javapoet",
+ "ClassNameTest", "OuterClass", "InnerClass"));
+ }
+
+ @Test public void bestGuessForString_defaultPackage() {
+ assertThat(ClassName.bestGuess("SomeClass"))
+ .isEqualTo(ClassName.get("", "SomeClass"));
+ assertThat(ClassName.bestGuess("SomeClass.Nested"))
+ .isEqualTo(ClassName.get("", "SomeClass", "Nested"));
+ assertThat(ClassName.bestGuess("SomeClass.Nested.EvenMore"))
+ .isEqualTo(ClassName.get("", "SomeClass", "Nested", "EvenMore"));
+ }
+
+ @Test public void bestGuessForString_confusingInput() {
+ assertBestGuessThrows("");
+ assertBestGuessThrows(".");
+ assertBestGuessThrows(".Map");
+ assertBestGuessThrows("java");
+ assertBestGuessThrows("java.util");
+ assertBestGuessThrows("java.util.");
+ assertBestGuessThrows("java..util.Map.Entry");
+ assertBestGuessThrows("java.util..Map.Entry");
+ assertBestGuessThrows("java.util.Map..Entry");
+ assertBestGuessThrows("com.test.$");
+ assertBestGuessThrows("com.test.LooksLikeAClass.pkg");
+ assertBestGuessThrows("!@#$gibberish%^&*");
+ }
+
+ private void assertBestGuessThrows(String s) {
+ try {
+ ClassName.bestGuess(s);
+ fail();
+ } catch (IllegalArgumentException expected) {
+ }
+ }
+
+ @Test public void createNestedClass() {
+ ClassName foo = ClassName.get("com.example", "Foo");
+ ClassName bar = foo.nestedClass("Bar");
+ assertThat(bar).isEqualTo(ClassName.get("com.example", "Foo", "Bar"));
+ ClassName baz = bar.nestedClass("Baz");
+ assertThat(baz).isEqualTo(ClassName.get("com.example", "Foo", "Bar", "Baz"));
+ }
+
+ static class $Outer {
+ static class $Inner {}
+ }
+
+ @Test public void classNameFromTypeElement() {
+ Elements elements = compilationRule.getElements();
+ TypeElement object = elements.getTypeElement(Object.class.getCanonicalName());
+ assertThat(ClassName.get(object).toString()).isEqualTo("java.lang.Object");
+ TypeElement outer = elements.getTypeElement($Outer.class.getCanonicalName());
+ assertThat(ClassName.get(outer).toString()).isEqualTo("com.squareup.javapoet.ClassNameTest.$Outer");
+ TypeElement inner = elements.getTypeElement($Outer.$Inner.class.getCanonicalName());
+ assertThat(ClassName.get(inner).toString()).isEqualTo("com.squareup.javapoet.ClassNameTest.$Outer.$Inner");
+ }
+
+ /**
+ * Buck builds with "source-based ABI generation" and those builds don't support
+ * {@link TypeElement#getKind()}. Test to confirm that we don't use that API.
+ */
+ @Test public void classNameFromTypeElementDoesntUseGetKind() {
+ Elements elements = compilationRule.getElements();
+ TypeElement object = elements.getTypeElement(Object.class.getCanonicalName());
+ assertThat(ClassName.get(preventGetKind(object)).toString())
+ .isEqualTo("java.lang.Object");
+ TypeElement outer = elements.getTypeElement($Outer.class.getCanonicalName());
+ assertThat(ClassName.get(preventGetKind(outer)).toString())
+ .isEqualTo("com.squareup.javapoet.ClassNameTest.$Outer");
+ TypeElement inner = elements.getTypeElement($Outer.$Inner.class.getCanonicalName());
+ assertThat(ClassName.get(preventGetKind(inner)).toString())
+ .isEqualTo("com.squareup.javapoet.ClassNameTest.$Outer.$Inner");
+ }
+
+ /** Returns a new instance like {@code object} that throws on {@code getKind()}. */
+ private TypeElement preventGetKind(TypeElement object) {
+ TypeElement spy = Mockito.spy(object);
+ when(spy.getKind()).thenThrow(new AssertionError());
+ when(spy.getEnclosingElement()).thenAnswer(invocation -> {
+ Object enclosingElement = invocation.callRealMethod();
+ return enclosingElement instanceof TypeElement
+ ? preventGetKind((TypeElement) enclosingElement)
+ : enclosingElement;
+ });
+ return spy;
+ }
+
+ @Test public void classNameFromClass() {
+ assertThat(ClassName.get(Object.class).toString())
+ .isEqualTo("java.lang.Object");
+ assertThat(ClassName.get(OuterClass.InnerClass.class).toString())
+ .isEqualTo("com.squareup.javapoet.ClassNameTest.OuterClass.InnerClass");
+ assertThat((ClassName.get(new Object() {}.getClass())).toString())
+ .isEqualTo("com.squareup.javapoet.ClassNameTest$1");
+ assertThat((ClassName.get(new Object() { Object inner = new Object() {}; }.inner.getClass())).toString())
+ .isEqualTo("com.squareup.javapoet.ClassNameTest$2$1");
+ assertThat((ClassName.get($Outer.class)).toString())
+ .isEqualTo("com.squareup.javapoet.ClassNameTest.$Outer");
+ assertThat((ClassName.get($Outer.$Inner.class)).toString())
+ .isEqualTo("com.squareup.javapoet.ClassNameTest.$Outer.$Inner");
+ }
+
+ @Test public void peerClass() {
+ assertThat(ClassName.get(Double.class).peerClass("Short"))
+ .isEqualTo(ClassName.get(Short.class));
+ assertThat(ClassName.get("", "Double").peerClass("Short"))
+ .isEqualTo(ClassName.get("", "Short"));
+ assertThat(ClassName.get("a.b", "Combo", "Taco").peerClass("Burrito"))
+ .isEqualTo(ClassName.get("a.b", "Combo", "Burrito"));
+ }
+
+ @Test public void fromClassRejectionTypes() {
+ try {
+ ClassName.get(int.class);
+ fail();
+ } catch (IllegalArgumentException ignored) {
+ }
+ try {
+ ClassName.get(void.class);
+ fail();
+ } catch (IllegalArgumentException ignored) {
+ }
+ try {
+ ClassName.get(Object[].class);
+ fail();
+ } catch (IllegalArgumentException ignored) {
+ }
+ }
+
+ @Test
+ public void reflectionName() {
+ assertEquals("java.lang.Object", TypeName.OBJECT.reflectionName());
+ assertEquals("java.lang.Thread$State", ClassName.get(Thread.State.class).reflectionName());
+ assertEquals("java.util.Map$Entry", ClassName.get(Map.Entry.class).reflectionName());
+ assertEquals("Foo", ClassName.get("", "Foo").reflectionName());
+ assertEquals("Foo$Bar$Baz", ClassName.get("", "Foo", "Bar", "Baz").reflectionName());
+ assertEquals("a.b.c.Foo$Bar$Baz", ClassName.get("a.b.c", "Foo", "Bar", "Baz").reflectionName());
+ }
+}
diff --git a/src/test/java/com/squareup/javapoet/CodeBlockTest.java b/src/test/java/com/squareup/javapoet/CodeBlockTest.java
new file mode 100644
index 0000000..2862809
--- /dev/null
+++ b/src/test/java/com/squareup/javapoet/CodeBlockTest.java
@@ -0,0 +1,342 @@
+/*
+ * Copyright (C) 2015 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.Test;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+public final class CodeBlockTest {
+ @Test public void equalsAndHashCode() {
+ CodeBlock a = CodeBlock.builder().build();
+ CodeBlock b = CodeBlock.builder().build();
+ assertThat(a.equals(b)).isTrue();
+ assertThat(a.hashCode()).isEqualTo(b.hashCode());
+ a = CodeBlock.builder().add("$L", "taco").build();
+ b = CodeBlock.builder().add("$L", "taco").build();
+ assertThat(a.equals(b)).isTrue();
+ assertThat(a.hashCode()).isEqualTo(b.hashCode());
+ }
+
+ @Test public void of() {
+ CodeBlock a = CodeBlock.of("$L taco", "delicious");
+ assertThat(a.toString()).isEqualTo("delicious taco");
+ }
+
+ @Test public void isEmpty() {
+ assertTrue(CodeBlock.builder().isEmpty());
+ assertTrue(CodeBlock.builder().add("").isEmpty());
+ assertFalse(CodeBlock.builder().add(" ").isEmpty());
+ }
+
+ @Test public void indentCannotBeIndexed() {
+ try {
+ CodeBlock.builder().add("$1>", "taco").build();
+ fail();
+ } catch (IllegalArgumentException exp) {
+ assertThat(exp)
+ .hasMessageThat()
+ .isEqualTo("$$, $>, $<, $[, $], $W, and $Z may not have an index");
+ }
+ }
+
+ @Test public void deindentCannotBeIndexed() {
+ try {
+ CodeBlock.builder().add("$1<", "taco").build();
+ fail();
+ } catch (IllegalArgumentException exp) {
+ assertThat(exp)
+ .hasMessageThat()
+ .isEqualTo("$$, $>, $<, $[, $], $W, and $Z may not have an index");
+ }
+ }
+
+ @Test public void dollarSignEscapeCannotBeIndexed() {
+ try {
+ CodeBlock.builder().add("$1$", "taco").build();
+ fail();
+ } catch (IllegalArgumentException exp) {
+ assertThat(exp)
+ .hasMessageThat()
+ .isEqualTo("$$, $>, $<, $[, $], $W, and $Z may not have an index");
+ }
+ }
+
+ @Test public void statementBeginningCannotBeIndexed() {
+ try {
+ CodeBlock.builder().add("$1[", "taco").build();
+ fail();
+ } catch (IllegalArgumentException exp) {
+ assertThat(exp)
+ .hasMessageThat()
+ .isEqualTo("$$, $>, $<, $[, $], $W, and $Z may not have an index");
+ }
+ }
+
+ @Test public void statementEndingCannotBeIndexed() {
+ try {
+ CodeBlock.builder().add("$1]", "taco").build();
+ fail();
+ } catch (IllegalArgumentException exp) {
+ assertThat(exp)
+ .hasMessageThat()
+ .isEqualTo("$$, $>, $<, $[, $], $W, and $Z may not have an index");
+ }
+ }
+
+ @Test public void nameFormatCanBeIndexed() {
+ CodeBlock block = CodeBlock.builder().add("$1N", "taco").build();
+ assertThat(block.toString()).isEqualTo("taco");
+ }
+
+ @Test public void literalFormatCanBeIndexed() {
+ CodeBlock block = CodeBlock.builder().add("$1L", "taco").build();
+ assertThat(block.toString()).isEqualTo("taco");
+ }
+
+ @Test public void stringFormatCanBeIndexed() {
+ CodeBlock block = CodeBlock.builder().add("$1S", "taco").build();
+ assertThat(block.toString()).isEqualTo("\"taco\"");
+ }
+
+ @Test public void typeFormatCanBeIndexed() {
+ CodeBlock block = CodeBlock.builder().add("$1T", String.class).build();
+ assertThat(block.toString()).isEqualTo("java.lang.String");
+ }
+
+ @Test public void simpleNamedArgument() {
+ Map<String, Object> map = new LinkedHashMap<>();
+ map.put("text", "taco");
+ CodeBlock block = CodeBlock.builder().addNamed("$text:S", map).build();
+ assertThat(block.toString()).isEqualTo("\"taco\"");
+ }
+
+ @Test public void repeatedNamedArgument() {
+ Map<String, Object> map = new LinkedHashMap<>();
+ map.put("text", "tacos");
+ CodeBlock block = CodeBlock.builder()
+ .addNamed("\"I like \" + $text:S + \". Do you like \" + $text:S + \"?\"", map)
+ .build();
+ assertThat(block.toString()).isEqualTo(
+ "\"I like \" + \"tacos\" + \". Do you like \" + \"tacos\" + \"?\"");
+ }
+
+ @Test public void namedAndNoArgFormat() {
+ Map<String, Object> map = new LinkedHashMap<>();
+ map.put("text", "tacos");
+ CodeBlock block = CodeBlock.builder()
+ .addNamed("$>\n$text:L for $$3.50", map).build();
+ assertThat(block.toString()).isEqualTo("\n tacos for $3.50");
+ }
+
+ @Test public void missingNamedArgument() {
+ try {
+ Map<String, Object> map = new LinkedHashMap<>();
+ CodeBlock.builder().addNamed("$text:S", map).build();
+ fail();
+ } catch(IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("Missing named argument for $text");
+ }
+ }
+
+ @Test public void lowerCaseNamed() {
+ try {
+ Map<String, Object> map = new LinkedHashMap<>();
+ map.put("Text", "tacos");
+ CodeBlock block = CodeBlock.builder().addNamed("$Text:S", map).build();
+ fail();
+ } catch(IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("argument 'Text' must start with a lowercase character");
+ }
+ }
+
+ @Test public void multipleNamedArguments() {
+ Map<String, Object> map = new LinkedHashMap<>();
+ map.put("pipe", System.class);
+ map.put("text", "tacos");
+
+ CodeBlock block = CodeBlock.builder()
+ .addNamed("$pipe:T.out.println(\"Let's eat some $text:L\");", map)
+ .build();
+
+ assertThat(block.toString()).isEqualTo(
+ "java.lang.System.out.println(\"Let's eat some tacos\");");
+ }
+
+ @Test public void namedNewline() {
+ Map<String, Object> map = new LinkedHashMap<>();
+ map.put("clazz", Integer.class);
+ CodeBlock block = CodeBlock.builder().addNamed("$clazz:T\n", map).build();
+ assertThat(block.toString()).isEqualTo("java.lang.Integer\n");
+ }
+
+ @Test public void danglingNamed() {
+ Map<String, Object> map = new LinkedHashMap<>();
+ map.put("clazz", Integer.class);
+ try {
+ CodeBlock.builder().addNamed("$clazz:T$", map).build();
+ fail();
+ } catch(IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("dangling $ at end");
+ }
+ }
+
+ @Test public void indexTooHigh() {
+ try {
+ CodeBlock.builder().add("$2T", String.class).build();
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("index 2 for '$2T' not in range (received 1 arguments)");
+ }
+ }
+
+ @Test public void indexIsZero() {
+ try {
+ CodeBlock.builder().add("$0T", String.class).build();
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("index 0 for '$0T' not in range (received 1 arguments)");
+ }
+ }
+
+ @Test public void indexIsNegative() {
+ try {
+ CodeBlock.builder().add("$-1T", String.class).build();
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("invalid format string: '$-1T'");
+ }
+ }
+
+ @Test public void indexWithoutFormatType() {
+ try {
+ CodeBlock.builder().add("$1", String.class).build();
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("dangling format characters in '$1'");
+ }
+ }
+
+ @Test public void indexWithoutFormatTypeNotAtStringEnd() {
+ try {
+ CodeBlock.builder().add("$1 taco", String.class).build();
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("invalid format string: '$1 taco'");
+ }
+ }
+
+ @Test public void indexButNoArguments() {
+ try {
+ CodeBlock.builder().add("$1T").build();
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("index 1 for '$1T' not in range (received 0 arguments)");
+ }
+ }
+
+ @Test public void formatIndicatorAlone() {
+ try {
+ CodeBlock.builder().add("$", String.class).build();
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("dangling format characters in '$'");
+ }
+ }
+
+ @Test public void formatIndicatorWithoutIndexOrFormatType() {
+ try {
+ CodeBlock.builder().add("$ tacoString", String.class).build();
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("invalid format string: '$ tacoString'");
+ }
+ }
+
+ @Test public void sameIndexCanBeUsedWithDifferentFormats() {
+ CodeBlock block = CodeBlock.builder()
+ .add("$1T.out.println($1S)", ClassName.get(System.class))
+ .build();
+ assertThat(block.toString()).isEqualTo("java.lang.System.out.println(\"java.lang.System\")");
+ }
+
+ @Test public void tooManyStatementEnters() {
+ CodeBlock codeBlock = CodeBlock.builder().add("$[$[").build();
+ try {
+ // We can't report this error until rendering type because code blocks might be composed.
+ codeBlock.toString();
+ fail();
+ } catch (IllegalStateException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("statement enter $[ followed by statement enter $[");
+ }
+ }
+
+ @Test public void statementExitWithoutStatementEnter() {
+ CodeBlock codeBlock = CodeBlock.builder().add("$]").build();
+ try {
+ // We can't report this error until rendering type because code blocks might be composed.
+ codeBlock.toString();
+ fail();
+ } catch (IllegalStateException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("statement exit $] has no matching statement enter $[");
+ }
+ }
+
+ @Test public void join() {
+ List<CodeBlock> codeBlocks = new ArrayList<>();
+ codeBlocks.add(CodeBlock.of("$S", "hello"));
+ codeBlocks.add(CodeBlock.of("$T", ClassName.get("world", "World")));
+ codeBlocks.add(CodeBlock.of("need tacos"));
+
+ CodeBlock joined = CodeBlock.join(codeBlocks, " || ");
+ assertThat(joined.toString()).isEqualTo("\"hello\" || world.World || need tacos");
+ }
+
+ @Test public void joining() {
+ List<CodeBlock> codeBlocks = new ArrayList<>();
+ codeBlocks.add(CodeBlock.of("$S", "hello"));
+ codeBlocks.add(CodeBlock.of("$T", ClassName.get("world", "World")));
+ codeBlocks.add(CodeBlock.of("need tacos"));
+
+ CodeBlock joined = codeBlocks.stream().collect(CodeBlock.joining(" || "));
+ assertThat(joined.toString()).isEqualTo("\"hello\" || world.World || need tacos");
+ }
+
+ @Test public void joiningSingle() {
+ List<CodeBlock> codeBlocks = new ArrayList<>();
+ codeBlocks.add(CodeBlock.of("$S", "hello"));
+
+ CodeBlock joined = codeBlocks.stream().collect(CodeBlock.joining(" || "));
+ assertThat(joined.toString()).isEqualTo("\"hello\"");
+ }
+
+ @Test public void joiningWithPrefixAndSuffix() {
+ List<CodeBlock> codeBlocks = new ArrayList<>();
+ codeBlocks.add(CodeBlock.of("$S", "hello"));
+ codeBlocks.add(CodeBlock.of("$T", ClassName.get("world", "World")));
+ codeBlocks.add(CodeBlock.of("need tacos"));
+
+ CodeBlock joined = codeBlocks.stream().collect(CodeBlock.joining(" || ", "start {", "} end"));
+ assertThat(joined.toString()).isEqualTo("start {\"hello\" || world.World || need tacos} end");
+ }
+}
diff --git a/src/test/java/com/squareup/javapoet/FieldSpecTest.java b/src/test/java/com/squareup/javapoet/FieldSpecTest.java
new file mode 100644
index 0000000..63f7aa8
--- /dev/null
+++ b/src/test/java/com/squareup/javapoet/FieldSpecTest.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2015 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import org.junit.Test;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
+import javax.lang.model.element.Modifier;
+
+public class FieldSpecTest {
+ @Test public void equalsAndHashCode() {
+ FieldSpec a = FieldSpec.builder(int.class, "foo").build();
+ FieldSpec b = FieldSpec.builder(int.class, "foo").build();
+ assertThat(a.equals(b)).isTrue();
+ assertThat(a.hashCode()).isEqualTo(b.hashCode());
+ a = FieldSpec.builder(int.class, "FOO", Modifier.PUBLIC, Modifier.STATIC).build();
+ b = FieldSpec.builder(int.class, "FOO", Modifier.PUBLIC, Modifier.STATIC).build();
+ assertThat(a.equals(b)).isTrue();
+ assertThat(a.hashCode()).isEqualTo(b.hashCode());
+ }
+
+ @Test public void nullAnnotationsAddition() {
+ try {
+ FieldSpec.builder(int.class, "foo").addAnnotations(null);
+ fail();
+ }
+ catch (IllegalArgumentException expected) {
+ assertThat(expected.getMessage())
+ .isEqualTo("annotationSpecs == null");
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/com/squareup/javapoet/FileReadingTest.java b/src/test/java/com/squareup/javapoet/FileReadingTest.java
new file mode 100644
index 0000000..eb19de0
--- /dev/null
+++ b/src/test/java/com/squareup/javapoet/FileReadingTest.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2015 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import com.google.common.io.ByteStreams;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collections;
+import java.util.Locale;
+import java.util.concurrent.Callable;
+import javax.lang.model.element.Modifier;
+import javax.tools.DiagnosticCollector;
+import javax.tools.JavaCompiler;
+import javax.tools.JavaCompiler.CompilationTask;
+import javax.tools.JavaFileObject;
+import javax.tools.JavaFileObject.Kind;
+import javax.tools.StandardJavaFileManager;
+import javax.tools.StandardLocation;
+import javax.tools.ToolProvider;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.nio.charset.StandardCharsets.UTF_8;
+
+@RunWith(JUnit4.class)
+public class FileReadingTest {
+
+ // Used for storing compilation output.
+ @Rule public final TemporaryFolder temporaryFolder = new TemporaryFolder();
+
+ @Test public void javaFileObjectUri() {
+ TypeSpec type = TypeSpec.classBuilder("Test").build();
+ assertThat(JavaFile.builder("", type).build().toJavaFileObject().toUri())
+ .isEqualTo(URI.create("Test.java"));
+ assertThat(JavaFile.builder("foo", type).build().toJavaFileObject().toUri())
+ .isEqualTo(URI.create("foo/Test.java"));
+ assertThat(JavaFile.builder("com.example", type).build().toJavaFileObject().toUri())
+ .isEqualTo(URI.create("com/example/Test.java"));
+ }
+
+ @Test public void javaFileObjectKind() {
+ JavaFile javaFile = JavaFile.builder("", TypeSpec.classBuilder("Test").build()).build();
+ assertThat(javaFile.toJavaFileObject().getKind()).isEqualTo(Kind.SOURCE);
+ }
+
+ @Test public void javaFileObjectCharacterContent() throws IOException {
+ TypeSpec type = TypeSpec.classBuilder("Test")
+ .addJavadoc("Pi\u00f1ata\u00a1")
+ .addMethod(MethodSpec.methodBuilder("fooBar").build())
+ .build();
+ JavaFile javaFile = JavaFile.builder("foo", type).build();
+ JavaFileObject javaFileObject = javaFile.toJavaFileObject();
+
+ // We can never have encoding issues (everything is in process)
+ assertThat(javaFileObject.getCharContent(true)).isEqualTo(javaFile.toString());
+ assertThat(javaFileObject.getCharContent(false)).isEqualTo(javaFile.toString());
+ }
+
+ @Test public void javaFileObjectInputStreamIsUtf8() throws IOException {
+ JavaFile javaFile = JavaFile.builder("foo", TypeSpec.classBuilder("Test").build())
+ .addFileComment("Pi\u00f1ata\u00a1")
+ .build();
+ byte[] bytes = ByteStreams.toByteArray(javaFile.toJavaFileObject().openInputStream());
+
+ // JavaPoet always uses UTF-8.
+ assertThat(bytes).isEqualTo(javaFile.toString().getBytes(UTF_8));
+ }
+
+ @Test public void compileJavaFile() throws Exception {
+ final String value = "Hello World!";
+ TypeSpec type = TypeSpec.classBuilder("Test")
+ .addModifiers(Modifier.PUBLIC)
+ .addSuperinterface(ParameterizedTypeName.get(Callable.class, String.class))
+ .addMethod(MethodSpec.methodBuilder("call")
+ .returns(String.class)
+ .addModifiers(Modifier.PUBLIC)
+ .addStatement("return $S", value)
+ .build())
+ .build();
+ JavaFile javaFile = JavaFile.builder("foo", type).build();
+
+ JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+ DiagnosticCollector<JavaFileObject> diagnosticCollector = new DiagnosticCollector<>();
+ StandardJavaFileManager fileManager = compiler.getStandardFileManager(diagnosticCollector,
+ Locale.getDefault(), UTF_8);
+ fileManager.setLocation(StandardLocation.CLASS_OUTPUT,
+ Collections.singleton(temporaryFolder.newFolder()));
+ CompilationTask task = compiler.getTask(null,
+ fileManager,
+ diagnosticCollector,
+ Collections.emptySet(),
+ Collections.emptySet(),
+ Collections.singleton(javaFile.toJavaFileObject()));
+
+ assertThat(task.call()).isTrue();
+ assertThat(diagnosticCollector.getDiagnostics()).isEmpty();
+
+ ClassLoader loader = fileManager.getClassLoader(StandardLocation.CLASS_OUTPUT);
+ Callable<?> test = Class.forName("foo.Test", true, loader)
+ .asSubclass(Callable.class)
+ .getDeclaredConstructor()
+ .newInstance();
+ assertThat(Callable.class.getMethod("call").invoke(test)).isEqualTo(value);
+ }
+}
diff --git a/src/test/java/com/squareup/javapoet/FileWritingTest.java b/src/test/java/com/squareup/javapoet/FileWritingTest.java
new file mode 100644
index 0000000..f817ddb
--- /dev/null
+++ b/src/test/java/com/squareup/javapoet/FileWritingTest.java
@@ -0,0 +1,219 @@
+/*
+ * Copyright (C) 2014 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import com.google.common.jimfs.Configuration;
+import com.google.common.jimfs.Jimfs;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.FileSystem;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Date;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.Modifier;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.Mockito;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.Assert.fail;
+
+@RunWith(JUnit4.class)
+public final class FileWritingTest {
+ // Used for testing java.io File behavior.
+ @Rule public final TemporaryFolder tmp = new TemporaryFolder();
+
+ // Used for testing java.nio.file Path behavior.
+ private final FileSystem fs = Jimfs.newFileSystem(Configuration.unix());
+ private final Path fsRoot = fs.getRootDirectories().iterator().next();
+
+ // Used for testing annotation processor Filer behavior.
+ private final TestFiler filer = new TestFiler(fs, fsRoot);
+
+ @Test public void pathNotDirectory() throws IOException {
+ TypeSpec type = TypeSpec.classBuilder("Test").build();
+ JavaFile javaFile = JavaFile.builder("example", type).build();
+ Path path = fs.getPath("/foo/bar");
+ Files.createDirectories(path.getParent());
+ Files.createFile(path);
+ try {
+ javaFile.writeTo(path);
+ fail();
+ } catch (IllegalArgumentException e) {
+ assertThat(e.getMessage()).isEqualTo("path /foo/bar exists but is not a directory.");
+ }
+ }
+
+ @Test public void fileNotDirectory() throws IOException {
+ TypeSpec type = TypeSpec.classBuilder("Test").build();
+ JavaFile javaFile = JavaFile.builder("example", type).build();
+ File file = new File(tmp.newFolder("foo"), "bar");
+ file.createNewFile();
+ try {
+ javaFile.writeTo(file);
+ fail();
+ } catch (IllegalArgumentException e) {
+ assertThat(e.getMessage()).isEqualTo(
+ "path " + file.getPath() + " exists but is not a directory.");
+ }
+ }
+
+ @Test public void pathDefaultPackage() throws IOException {
+ TypeSpec type = TypeSpec.classBuilder("Test").build();
+ JavaFile.builder("", type).build().writeTo(fsRoot);
+
+ Path testPath = fsRoot.resolve("Test.java");
+ assertThat(Files.exists(testPath)).isTrue();
+ }
+
+ @Test public void fileDefaultPackage() throws IOException {
+ TypeSpec type = TypeSpec.classBuilder("Test").build();
+ JavaFile.builder("", type).build().writeTo(tmp.getRoot());
+
+ File testFile = new File(tmp.getRoot(), "Test.java");
+ assertThat(testFile.exists()).isTrue();
+ }
+
+ @Test public void filerDefaultPackage() throws IOException {
+ TypeSpec type = TypeSpec.classBuilder("Test").build();
+ JavaFile.builder("", type).build().writeTo(filer);
+
+ Path testPath = fsRoot.resolve("Test.java");
+ assertThat(Files.exists(testPath)).isTrue();
+ }
+
+ @Test public void pathNestedClasses() throws IOException {
+ TypeSpec type = TypeSpec.classBuilder("Test").build();
+ JavaFile.builder("foo", type).build().writeTo(fsRoot);
+ JavaFile.builder("foo.bar", type).build().writeTo(fsRoot);
+ JavaFile.builder("foo.bar.baz", type).build().writeTo(fsRoot);
+
+ Path fooPath = fsRoot.resolve(fs.getPath("foo", "Test.java"));
+ Path barPath = fsRoot.resolve(fs.getPath("foo", "bar", "Test.java"));
+ Path bazPath = fsRoot.resolve(fs.getPath("foo", "bar", "baz", "Test.java"));
+ assertThat(Files.exists(fooPath)).isTrue();
+ assertThat(Files.exists(barPath)).isTrue();
+ assertThat(Files.exists(bazPath)).isTrue();
+ }
+
+ @Test public void fileNestedClasses() throws IOException {
+ TypeSpec type = TypeSpec.classBuilder("Test").build();
+ JavaFile.builder("foo", type).build().writeTo(tmp.getRoot());
+ JavaFile.builder("foo.bar", type).build().writeTo(tmp.getRoot());
+ JavaFile.builder("foo.bar.baz", type).build().writeTo(tmp.getRoot());
+
+ File fooDir = new File(tmp.getRoot(), "foo");
+ File fooFile = new File(fooDir, "Test.java");
+ File barDir = new File(fooDir, "bar");
+ File barFile = new File(barDir, "Test.java");
+ File bazDir = new File(barDir, "baz");
+ File bazFile = new File(bazDir, "Test.java");
+ assertThat(fooFile.exists()).isTrue();
+ assertThat(barFile.exists()).isTrue();
+ assertThat(bazFile.exists()).isTrue();
+ }
+
+ @Test public void filerNestedClasses() throws IOException {
+ TypeSpec type = TypeSpec.classBuilder("Test").build();
+ JavaFile.builder("foo", type).build().writeTo(filer);
+ JavaFile.builder("foo.bar", type).build().writeTo(filer);
+ JavaFile.builder("foo.bar.baz", type).build().writeTo(filer);
+
+ Path fooPath = fsRoot.resolve(fs.getPath("foo", "Test.java"));
+ Path barPath = fsRoot.resolve(fs.getPath("foo", "bar", "Test.java"));
+ Path bazPath = fsRoot.resolve(fs.getPath("foo", "bar", "baz", "Test.java"));
+ assertThat(Files.exists(fooPath)).isTrue();
+ assertThat(Files.exists(barPath)).isTrue();
+ assertThat(Files.exists(bazPath)).isTrue();
+ }
+
+ @Test public void filerPassesOriginatingElements() throws IOException {
+ Element element1_1 = Mockito.mock(Element.class);
+ TypeSpec test1 = TypeSpec.classBuilder("Test1")
+ .addOriginatingElement(element1_1)
+ .build();
+
+ Element element2_1 = Mockito.mock(Element.class);
+ Element element2_2 = Mockito.mock(Element.class);
+ TypeSpec test2 = TypeSpec.classBuilder("Test2")
+ .addOriginatingElement(element2_1)
+ .addOriginatingElement(element2_2)
+ .build();
+
+ JavaFile.builder("example", test1).build().writeTo(filer);
+ JavaFile.builder("example", test2).build().writeTo(filer);
+
+ Path testPath1 = fsRoot.resolve(fs.getPath("example", "Test1.java"));
+ assertThat(filer.getOriginatingElements(testPath1)).containsExactly(element1_1);
+ Path testPath2 = fsRoot.resolve(fs.getPath("example", "Test2.java"));
+ assertThat(filer.getOriginatingElements(testPath2)).containsExactly(element2_1, element2_2);
+ }
+
+ @Test public void filerClassesWithTabIndent() throws IOException {
+ TypeSpec test = TypeSpec.classBuilder("Test")
+ .addField(Date.class, "madeFreshDate")
+ .addMethod(MethodSpec.methodBuilder("main")
+ .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
+ .addParameter(String[].class, "args")
+ .addCode("$T.out.println($S);\n", System.class, "Hello World!")
+ .build())
+ .build();
+ JavaFile.builder("foo", test).indent("\t").build().writeTo(filer);
+
+ Path fooPath = fsRoot.resolve(fs.getPath("foo", "Test.java"));
+ assertThat(Files.exists(fooPath)).isTrue();
+ String source = new String(Files.readAllBytes(fooPath));
+
+ assertThat(source).isEqualTo(""
+ + "package foo;\n"
+ + "\n"
+ + "import java.lang.String;\n"
+ + "import java.lang.System;\n"
+ + "import java.util.Date;\n"
+ + "\n"
+ + "class Test {\n"
+ + "\tDate madeFreshDate;\n"
+ + "\n"
+ + "\tpublic static void main(String[] args) {\n"
+ + "\t\tSystem.out.println(\"Hello World!\");\n"
+ + "\t}\n"
+ + "}\n");
+ }
+
+ /**
+ * This test confirms that JavaPoet ignores the host charset and always uses UTF-8. The host
+ * charset is customized with {@code -Dfile.encoding=ISO-8859-1}.
+ */
+ @Test public void fileIsUtf8() throws IOException {
+ JavaFile javaFile = JavaFile.builder("foo", TypeSpec.classBuilder("Taco").build())
+ .addFileComment("Pi\u00f1ata\u00a1")
+ .build();
+ javaFile.writeTo(fsRoot);
+
+ Path fooPath = fsRoot.resolve(fs.getPath("foo", "Taco.java"));
+ assertThat(new String(Files.readAllBytes(fooPath), UTF_8)).isEqualTo(""
+ + "// Pi\u00f1ata\u00a1\n"
+ + "package foo;\n"
+ + "\n"
+ + "class Taco {\n"
+ + "}\n");
+ }
+}
diff --git a/src/test/java/com/squareup/javapoet/JavaFileTest.java b/src/test/java/com/squareup/javapoet/JavaFileTest.java
new file mode 100644
index 0000000..e056116
--- /dev/null
+++ b/src/test/java/com/squareup/javapoet/JavaFileTest.java
@@ -0,0 +1,692 @@
+/*
+ * Copyright (C) 2015 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import javax.lang.model.element.Modifier;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import static com.google.common.truth.Truth.assertThat;
+
+@RunWith(JUnit4.class)
+public final class JavaFileTest {
+ @Test public void importStaticReadmeExample() {
+ ClassName hoverboard = ClassName.get("com.mattel", "Hoverboard");
+ ClassName namedBoards = ClassName.get("com.mattel", "Hoverboard", "Boards");
+ ClassName list = ClassName.get("java.util", "List");
+ ClassName arrayList = ClassName.get("java.util", "ArrayList");
+ TypeName listOfHoverboards = ParameterizedTypeName.get(list, hoverboard);
+ MethodSpec beyond = MethodSpec.methodBuilder("beyond")
+ .returns(listOfHoverboards)
+ .addStatement("$T result = new $T<>()", listOfHoverboards, arrayList)
+ .addStatement("result.add($T.createNimbus(2000))", hoverboard)
+ .addStatement("result.add($T.createNimbus(\"2001\"))", hoverboard)
+ .addStatement("result.add($T.createNimbus($T.THUNDERBOLT))", hoverboard, namedBoards)
+ .addStatement("$T.sort(result)", Collections.class)
+ .addStatement("return result.isEmpty() ? $T.emptyList() : result", Collections.class)
+ .build();
+ TypeSpec hello = TypeSpec.classBuilder("HelloWorld")
+ .addMethod(beyond)
+ .build();
+ JavaFile example = JavaFile.builder("com.example.helloworld", hello)
+ .addStaticImport(hoverboard, "createNimbus")
+ .addStaticImport(namedBoards, "*")
+ .addStaticImport(Collections.class, "*")
+ .build();
+ assertThat(example.toString()).isEqualTo(""
+ + "package com.example.helloworld;\n"
+ + "\n"
+ + "import static com.mattel.Hoverboard.Boards.*;\n"
+ + "import static com.mattel.Hoverboard.createNimbus;\n"
+ + "import static java.util.Collections.*;\n"
+ + "\n"
+ + "import com.mattel.Hoverboard;\n"
+ + "import java.util.ArrayList;\n"
+ + "import java.util.List;\n"
+ + "\n"
+ + "class HelloWorld {\n"
+ + " List<Hoverboard> beyond() {\n"
+ + " List<Hoverboard> result = new ArrayList<>();\n"
+ + " result.add(createNimbus(2000));\n"
+ + " result.add(createNimbus(\"2001\"));\n"
+ + " result.add(createNimbus(THUNDERBOLT));\n"
+ + " sort(result);\n"
+ + " return result.isEmpty() ? emptyList() : result;\n"
+ + " }\n"
+ + "}\n");
+ }
+ @Test public void importStaticForCrazyFormatsWorks() {
+ MethodSpec method = MethodSpec.methodBuilder("method").build();
+ JavaFile.builder("com.squareup.tacos",
+ TypeSpec.classBuilder("Taco")
+ .addStaticBlock(CodeBlock.builder()
+ .addStatement("$T", Runtime.class)
+ .addStatement("$T.a()", Runtime.class)
+ .addStatement("$T.X", Runtime.class)
+ .addStatement("$T$T", Runtime.class, Runtime.class)
+ .addStatement("$T.$T", Runtime.class, Runtime.class)
+ .addStatement("$1T$1T", Runtime.class)
+ .addStatement("$1T$2L$1T", Runtime.class, "?")
+ .addStatement("$1T$2L$2S$1T", Runtime.class, "?")
+ .addStatement("$1T$2L$2S$1T$3N$1T", Runtime.class, "?", method)
+ .addStatement("$T$L", Runtime.class, "?")
+ .addStatement("$T$S", Runtime.class, "?")
+ .addStatement("$T$N", Runtime.class, method)
+ .build())
+ .build())
+ .addStaticImport(Runtime.class, "*")
+ .build()
+ .toString(); // don't look at the generated code...
+ }
+
+ @Test public void importStaticMixed() {
+ JavaFile source = JavaFile.builder("com.squareup.tacos",
+ TypeSpec.classBuilder("Taco")
+ .addStaticBlock(CodeBlock.builder()
+ .addStatement("assert $1T.valueOf(\"BLOCKED\") == $1T.BLOCKED", Thread.State.class)
+ .addStatement("$T.gc()", System.class)
+ .addStatement("$1T.out.println($1T.nanoTime())", System.class)
+ .build())
+ .addMethod(MethodSpec.constructorBuilder()
+ .addParameter(Thread.State[].class, "states")
+ .varargs(true)
+ .build())
+ .build())
+ .addStaticImport(Thread.State.BLOCKED)
+ .addStaticImport(System.class, "*")
+ .addStaticImport(Thread.State.class, "valueOf")
+ .build();
+ assertThat(source.toString()).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import static java.lang.System.*;\n"
+ + "import static java.lang.Thread.State.BLOCKED;\n"
+ + "import static java.lang.Thread.State.valueOf;\n"
+ + "\n"
+ + "import java.lang.Thread;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " static {\n"
+ + " assert valueOf(\"BLOCKED\") == BLOCKED;\n"
+ + " gc();\n"
+ + " out.println(nanoTime());\n"
+ + " }\n"
+ + "\n"
+ + " Taco(Thread.State... states) {\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Ignore("addStaticImport doesn't support members with $L")
+ @Test public void importStaticDynamic() {
+ JavaFile source = JavaFile.builder("com.squareup.tacos",
+ TypeSpec.classBuilder("Taco")
+ .addMethod(MethodSpec.methodBuilder("main")
+ .addStatement("$T.$L.println($S)", System.class, "out", "hello")
+ .build())
+ .build())
+ .addStaticImport(System.class, "out")
+ .build();
+ assertThat(source.toString()).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import static java.lang.System.out;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " void main() {\n"
+ + " out.println(\"hello\");\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void importStaticNone() {
+ assertThat(JavaFile.builder("readme", importStaticTypeSpec("Util"))
+ .build().toString()).isEqualTo(""
+ + "package readme;\n"
+ + "\n"
+ + "import java.lang.System;\n"
+ + "import java.util.concurrent.TimeUnit;\n"
+ + "\n"
+ + "class Util {\n"
+ + " public static long minutesToSeconds(long minutes) {\n"
+ + " System.gc();\n"
+ + " return TimeUnit.SECONDS.convert(minutes, TimeUnit.MINUTES);\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void importStaticOnce() {
+ assertThat(JavaFile.builder("readme", importStaticTypeSpec("Util"))
+ .addStaticImport(TimeUnit.SECONDS)
+ .build().toString()).isEqualTo(""
+ + "package readme;\n"
+ + "\n"
+ + "import static java.util.concurrent.TimeUnit.SECONDS;\n"
+ + "\n"
+ + "import java.lang.System;\n"
+ + "import java.util.concurrent.TimeUnit;\n"
+ + "\n"
+ + "class Util {\n"
+ + " public static long minutesToSeconds(long minutes) {\n"
+ + " System.gc();\n"
+ + " return SECONDS.convert(minutes, TimeUnit.MINUTES);\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void importStaticTwice() {
+ assertThat(JavaFile.builder("readme", importStaticTypeSpec("Util"))
+ .addStaticImport(TimeUnit.SECONDS)
+ .addStaticImport(TimeUnit.MINUTES)
+ .build().toString()).isEqualTo(""
+ + "package readme;\n"
+ + "\n"
+ + "import static java.util.concurrent.TimeUnit.MINUTES;\n"
+ + "import static java.util.concurrent.TimeUnit.SECONDS;\n"
+ + "\n"
+ + "import java.lang.System;\n"
+ + "\n"
+ + "class Util {\n"
+ + " public static long minutesToSeconds(long minutes) {\n"
+ + " System.gc();\n"
+ + " return SECONDS.convert(minutes, MINUTES);\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void importStaticUsingWildcards() {
+ assertThat(JavaFile.builder("readme", importStaticTypeSpec("Util"))
+ .addStaticImport(TimeUnit.class, "*")
+ .addStaticImport(System.class, "*")
+ .build().toString()).isEqualTo(""
+ + "package readme;\n"
+ + "\n"
+ + "import static java.lang.System.*;\n"
+ + "import static java.util.concurrent.TimeUnit.*;\n"
+ + "\n"
+ + "class Util {\n"
+ + " public static long minutesToSeconds(long minutes) {\n"
+ + " gc();\n"
+ + " return SECONDS.convert(minutes, MINUTES);\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ private TypeSpec importStaticTypeSpec(String name) {
+ MethodSpec method = MethodSpec.methodBuilder("minutesToSeconds")
+ .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
+ .returns(long.class)
+ .addParameter(long.class, "minutes")
+ .addStatement("$T.gc()", System.class)
+ .addStatement("return $1T.SECONDS.convert(minutes, $1T.MINUTES)", TimeUnit.class)
+ .build();
+ return TypeSpec.classBuilder(name).addMethod(method).build();
+
+ }
+ @Test public void noImports() throws Exception {
+ String source = JavaFile.builder("com.squareup.tacos",
+ TypeSpec.classBuilder("Taco").build())
+ .build()
+ .toString();
+ assertThat(source).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "class Taco {\n"
+ + "}\n");
+ }
+
+ @Test public void singleImport() throws Exception {
+ String source = JavaFile.builder("com.squareup.tacos",
+ TypeSpec.classBuilder("Taco")
+ .addField(Date.class, "madeFreshDate")
+ .build())
+ .build()
+ .toString();
+ assertThat(source).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.util.Date;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " Date madeFreshDate;\n"
+ + "}\n");
+ }
+
+ @Test public void conflictingImports() throws Exception {
+ String source = JavaFile.builder("com.squareup.tacos",
+ TypeSpec.classBuilder("Taco")
+ .addField(Date.class, "madeFreshDate")
+ .addField(ClassName.get("java.sql", "Date"), "madeFreshDatabaseDate")
+ .build())
+ .build()
+ .toString();
+ assertThat(source).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.util.Date;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " Date madeFreshDate;\n"
+ + "\n"
+ + " java.sql.Date madeFreshDatabaseDate;\n"
+ + "}\n");
+ }
+
+ @Test public void annotatedTypeParam() throws Exception {
+ String source = JavaFile.builder("com.squareup.tacos",
+ TypeSpec.classBuilder("Taco")
+ .addField(ParameterizedTypeName.get(ClassName.get(List.class),
+ ClassName.get("com.squareup.meat", "Chorizo")
+ .annotated(AnnotationSpec.builder(ClassName.get("com.squareup.tacos", "Spicy"))
+ .build())), "chorizo")
+ .build())
+ .build()
+ .toString();
+ assertThat(source).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import com.squareup.meat.Chorizo;\n"
+ + "import java.util.List;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " List<@Spicy Chorizo> chorizo;\n"
+ + "}\n");
+ }
+
+ @Test public void skipJavaLangImportsWithConflictingClassLast() throws Exception {
+ // Whatever is used first wins! In this case the Float in java.lang is imported.
+ String source = JavaFile.builder("com.squareup.tacos",
+ TypeSpec.classBuilder("Taco")
+ .addField(ClassName.get("java.lang", "Float"), "litres")
+ .addField(ClassName.get("com.squareup.soda", "Float"), "beverage")
+ .build())
+ .skipJavaLangImports(true)
+ .build()
+ .toString();
+ assertThat(source).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " Float litres;\n"
+ + "\n"
+ + " com.squareup.soda.Float beverage;\n" // Second 'Float' is fully qualified.
+ + "}\n");
+ }
+
+ @Test public void skipJavaLangImportsWithConflictingClassFirst() throws Exception {
+ // Whatever is used first wins! In this case the Float in com.squareup.soda is imported.
+ String source = JavaFile.builder("com.squareup.tacos",
+ TypeSpec.classBuilder("Taco")
+ .addField(ClassName.get("com.squareup.soda", "Float"), "beverage")
+ .addField(ClassName.get("java.lang", "Float"), "litres")
+ .build())
+ .skipJavaLangImports(true)
+ .build()
+ .toString();
+ assertThat(source).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import com.squareup.soda.Float;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " Float beverage;\n"
+ + "\n"
+ + " java.lang.Float litres;\n" // Second 'Float' is fully qualified.
+ + "}\n");
+ }
+
+ @Test public void conflictingParentName() throws Exception {
+ String source = JavaFile.builder("com.squareup.tacos",
+ TypeSpec.classBuilder("A")
+ .addType(TypeSpec.classBuilder("B")
+ .addType(TypeSpec.classBuilder("Twin").build())
+ .addType(TypeSpec.classBuilder("C")
+ .addField(ClassName.get("com.squareup.tacos", "A", "Twin", "D"), "d")
+ .build())
+ .build())
+ .addType(TypeSpec.classBuilder("Twin")
+ .addType(TypeSpec.classBuilder("D")
+ .build())
+ .build())
+ .build())
+ .build()
+ .toString();
+ assertThat(source).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "class A {\n"
+ + " class B {\n"
+ + " class Twin {\n"
+ + " }\n"
+ + "\n"
+ + " class C {\n"
+ + " A.Twin.D d;\n"
+ + " }\n"
+ + " }\n"
+ + "\n"
+ + " class Twin {\n"
+ + " class D {\n"
+ + " }\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void conflictingChildName() throws Exception {
+ String source = JavaFile.builder("com.squareup.tacos",
+ TypeSpec.classBuilder("A")
+ .addType(TypeSpec.classBuilder("B")
+ .addType(TypeSpec.classBuilder("C")
+ .addField(ClassName.get("com.squareup.tacos", "A", "Twin", "D"), "d")
+ .addType(TypeSpec.classBuilder("Twin").build())
+ .build())
+ .build())
+ .addType(TypeSpec.classBuilder("Twin")
+ .addType(TypeSpec.classBuilder("D")
+ .build())
+ .build())
+ .build())
+ .build()
+ .toString();
+ assertThat(source).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "class A {\n"
+ + " class B {\n"
+ + " class C {\n"
+ + " A.Twin.D d;\n"
+ + "\n"
+ + " class Twin {\n"
+ + " }\n"
+ + " }\n"
+ + " }\n"
+ + "\n"
+ + " class Twin {\n"
+ + " class D {\n"
+ + " }\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void conflictingNameOutOfScope() throws Exception {
+ String source = JavaFile.builder("com.squareup.tacos",
+ TypeSpec.classBuilder("A")
+ .addType(TypeSpec.classBuilder("B")
+ .addType(TypeSpec.classBuilder("C")
+ .addField(ClassName.get("com.squareup.tacos", "A", "Twin", "D"), "d")
+ .addType(TypeSpec.classBuilder("Nested")
+ .addType(TypeSpec.classBuilder("Twin").build())
+ .build())
+ .build())
+ .build())
+ .addType(TypeSpec.classBuilder("Twin")
+ .addType(TypeSpec.classBuilder("D")
+ .build())
+ .build())
+ .build())
+ .build()
+ .toString();
+ assertThat(source).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "class A {\n"
+ + " class B {\n"
+ + " class C {\n"
+ + " Twin.D d;\n"
+ + "\n"
+ + " class Nested {\n"
+ + " class Twin {\n"
+ + " }\n"
+ + " }\n"
+ + " }\n"
+ + " }\n"
+ + "\n"
+ + " class Twin {\n"
+ + " class D {\n"
+ + " }\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void nestedClassAndSuperclassShareName() throws Exception {
+ String source = JavaFile.builder("com.squareup.tacos",
+ TypeSpec.classBuilder("Taco")
+ .superclass(ClassName.get("com.squareup.wire", "Message"))
+ .addType(TypeSpec.classBuilder("Builder")
+ .superclass(ClassName.get("com.squareup.wire", "Message", "Builder"))
+ .build())
+ .build())
+ .build()
+ .toString();
+ assertThat(source).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import com.squareup.wire.Message;\n"
+ + "\n"
+ + "class Taco extends Message {\n"
+ + " class Builder extends Message.Builder {\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void classAndSuperclassShareName() throws Exception {
+ String source = JavaFile.builder("com.squareup.tacos",
+ TypeSpec.classBuilder("Taco")
+ .superclass(ClassName.get("com.taco.bell", "Taco"))
+ .build())
+ .build()
+ .toString();
+ assertThat(source).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "class Taco extends com.taco.bell.Taco {\n"
+ + "}\n");
+ }
+
+ @Test public void conflictingAnnotation() throws Exception {
+ String source = JavaFile.builder("com.squareup.tacos",
+ TypeSpec.classBuilder("Taco")
+ .addAnnotation(ClassName.get("com.taco.bell", "Taco"))
+ .build())
+ .build()
+ .toString();
+ assertThat(source).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "@com.taco.bell.Taco\n"
+ + "class Taco {\n"
+ + "}\n");
+ }
+
+ @Test public void conflictingAnnotationReferencedClass() throws Exception {
+ String source = JavaFile.builder("com.squareup.tacos",
+ TypeSpec.classBuilder("Taco")
+ .addAnnotation(AnnotationSpec.builder(ClassName.get("com.squareup.tacos", "MyAnno"))
+ .addMember("value", "$T.class", ClassName.get("com.taco.bell", "Taco"))
+ .build())
+ .build())
+ .build()
+ .toString();
+ assertThat(source).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "@MyAnno(com.taco.bell.Taco.class)\n"
+ + "class Taco {\n"
+ + "}\n");
+ }
+
+ @Test public void conflictingTypeVariableBound() throws Exception {
+ String source = JavaFile.builder("com.squareup.tacos",
+ TypeSpec.classBuilder("Taco")
+ .addTypeVariable(
+ TypeVariableName.get("T", ClassName.get("com.taco.bell", "Taco")))
+ .build())
+ .build()
+ .toString();
+ assertThat(source).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "class Taco<T extends com.taco.bell.Taco> {\n"
+ + "}\n");
+ }
+
+ @Test public void superclassReferencesSelf() throws Exception {
+ String source = JavaFile.builder("com.squareup.tacos",
+ TypeSpec.classBuilder("Taco")
+ .superclass(ParameterizedTypeName.get(
+ ClassName.get(Comparable.class), ClassName.get("com.squareup.tacos", "Taco")))
+ .build())
+ .build()
+ .toString();
+ assertThat(source).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.Comparable;\n"
+ + "\n"
+ + "class Taco extends Comparable<Taco> {\n"
+ + "}\n");
+ }
+
+ /** https://github.com/square/javapoet/issues/366 */
+ @Test public void annotationIsNestedClass() throws Exception {
+ String source = JavaFile.builder("com.squareup.tacos",
+ TypeSpec.classBuilder("TestComponent")
+ .addAnnotation(ClassName.get("dagger", "Component"))
+ .addType(TypeSpec.classBuilder("Builder")
+ .addAnnotation(ClassName.get("dagger", "Component", "Builder"))
+ .build())
+ .build())
+ .build()
+ .toString();
+ assertThat(source).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import dagger.Component;\n"
+ + "\n"
+ + "@Component\n"
+ + "class TestComponent {\n"
+ + " @Component.Builder\n"
+ + " class Builder {\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void defaultPackage() throws Exception {
+ String source = JavaFile.builder("",
+ TypeSpec.classBuilder("HelloWorld")
+ .addMethod(MethodSpec.methodBuilder("main")
+ .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
+ .addParameter(String[].class, "args")
+ .addCode("$T.out.println($S);\n", System.class, "Hello World!")
+ .build())
+ .build())
+ .build()
+ .toString();
+ assertThat(source).isEqualTo(""
+ + "import java.lang.String;\n"
+ + "import java.lang.System;\n"
+ + "\n"
+ + "class HelloWorld {\n"
+ + " public static void main(String[] args) {\n"
+ + " System.out.println(\"Hello World!\");\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void defaultPackageTypesAreNotImported() throws Exception {
+ String source = JavaFile.builder("hello",
+ TypeSpec.classBuilder("World").addSuperinterface(ClassName.get("", "Test")).build())
+ .build()
+ .toString();
+ assertThat(source).isEqualTo(""
+ + "package hello;\n"
+ + "\n"
+ + "class World implements Test {\n"
+ + "}\n");
+ }
+
+ @Test public void topOfFileComment() throws Exception {
+ String source = JavaFile.builder("com.squareup.tacos",
+ TypeSpec.classBuilder("Taco").build())
+ .addFileComment("Generated $L by JavaPoet. DO NOT EDIT!", "2015-01-13")
+ .build()
+ .toString();
+ assertThat(source).isEqualTo(""
+ + "// Generated 2015-01-13 by JavaPoet. DO NOT EDIT!\n"
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "class Taco {\n"
+ + "}\n");
+ }
+
+ @Test public void emptyLinesInTopOfFileComment() throws Exception {
+ String source = JavaFile.builder("com.squareup.tacos",
+ TypeSpec.classBuilder("Taco").build())
+ .addFileComment("\nGENERATED FILE:\n\nDO NOT EDIT!\n")
+ .build()
+ .toString();
+ assertThat(source).isEqualTo(""
+ + "//\n"
+ + "// GENERATED FILE:\n"
+ + "//\n"
+ + "// DO NOT EDIT!\n"
+ + "//\n"
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "class Taco {\n"
+ + "}\n");
+ }
+
+ @Test public void packageClassConflictsWithNestedClass() throws Exception {
+ String source = JavaFile.builder("com.squareup.tacos",
+ TypeSpec.classBuilder("Taco")
+ .addField(ClassName.get("com.squareup.tacos", "A"), "a")
+ .addType(TypeSpec.classBuilder("A").build())
+ .build())
+ .build()
+ .toString();
+ assertThat(source).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " com.squareup.tacos.A a;\n"
+ + "\n"
+ + " class A {\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void packageClassConflictsWithSuperlass() throws Exception {
+ String source = JavaFile.builder("com.squareup.tacos",
+ TypeSpec.classBuilder("Taco")
+ .superclass(ClassName.get("com.taco.bell", "A"))
+ .addField(ClassName.get("com.squareup.tacos", "A"), "a")
+ .build())
+ .build()
+ .toString();
+ assertThat(source).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "class Taco extends com.taco.bell.A {\n"
+ + " A a;\n"
+ + "}\n");
+ }
+}
diff --git a/src/test/java/com/squareup/javapoet/LineWrapperTest.java b/src/test/java/com/squareup/javapoet/LineWrapperTest.java
new file mode 100644
index 0000000..ba8472c
--- /dev/null
+++ b/src/test/java/com/squareup/javapoet/LineWrapperTest.java
@@ -0,0 +1,207 @@
+/*
+ * Copyright (C) 2016 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import static com.google.common.truth.Truth.assertThat;
+
+@RunWith(JUnit4.class)
+public final class LineWrapperTest {
+ @Test public void wrap() throws Exception {
+ StringBuffer out = new StringBuffer();
+ LineWrapper lineWrapper = new LineWrapper(out, " ", 10);
+ lineWrapper.append("abcde");
+ lineWrapper.wrappingSpace(2);
+ lineWrapper.append("fghij");
+ lineWrapper.close();
+ assertThat(out.toString()).isEqualTo("abcde\n fghij");
+ }
+
+ @Test public void noWrap() throws Exception {
+ StringBuffer out = new StringBuffer();
+ LineWrapper lineWrapper = new LineWrapper(out, " ", 10);
+ lineWrapper.append("abcde");
+ lineWrapper.wrappingSpace(2);
+ lineWrapper.append("fghi");
+ lineWrapper.close();
+ assertThat(out.toString()).isEqualTo("abcde fghi");
+ }
+
+ @Test public void zeroWidthNoWrap() throws Exception {
+ StringBuffer out = new StringBuffer();
+ LineWrapper lineWrapper = new LineWrapper(out, " ", 10);
+ lineWrapper.append("abcde");
+ lineWrapper.zeroWidthSpace(2);
+ lineWrapper.append("fghij");
+ lineWrapper.close();
+ assertThat(out.toString()).isEqualTo("abcdefghij");
+ }
+
+ @Test public void nospaceWrapMax() throws Exception {
+ StringBuffer out = new StringBuffer();
+ LineWrapper lineWrapper = new LineWrapper(out, " ", 10);
+ lineWrapper.append("abcde");
+ lineWrapper.zeroWidthSpace(2);
+ lineWrapper.append("fghijk");
+ lineWrapper.close();
+ assertThat(out.toString()).isEqualTo("abcde\n fghijk");
+ }
+
+ @Test public void multipleWrite() throws Exception {
+ StringBuffer out = new StringBuffer();
+ LineWrapper lineWrapper = new LineWrapper(out, " ", 10);
+ lineWrapper.append("ab");
+ lineWrapper.wrappingSpace(1);
+ lineWrapper.append("cd");
+ lineWrapper.wrappingSpace(1);
+ lineWrapper.append("ef");
+ lineWrapper.wrappingSpace(1);
+ lineWrapper.append("gh");
+ lineWrapper.wrappingSpace(1);
+ lineWrapper.append("ij");
+ lineWrapper.wrappingSpace(1);
+ lineWrapper.append("kl");
+ lineWrapper.wrappingSpace(1);
+ lineWrapper.append("mn");
+ lineWrapper.wrappingSpace(1);
+ lineWrapper.append("op");
+ lineWrapper.wrappingSpace(1);
+ lineWrapper.append("qr");
+ lineWrapper.close();
+ assertThat(out.toString()).isEqualTo("ab cd ef\n gh ij kl\n mn op qr");
+ }
+
+ @Test public void fencepost() throws Exception {
+ StringBuffer out = new StringBuffer();
+ LineWrapper lineWrapper = new LineWrapper(out, " ", 10);
+ lineWrapper.append("abcde");
+ lineWrapper.append("fghij");
+ lineWrapper.wrappingSpace(2);
+ lineWrapper.append("k");
+ lineWrapper.append("lmnop");
+ lineWrapper.close();
+ assertThat(out.toString()).isEqualTo("abcdefghij\n klmnop");
+ }
+
+ @Test public void fencepostZeroWidth() throws Exception {
+ StringBuffer out = new StringBuffer();
+ LineWrapper lineWrapper = new LineWrapper(out, " ", 10);
+ lineWrapper.append("abcde");
+ lineWrapper.append("fghij");
+ lineWrapper.zeroWidthSpace(2);
+ lineWrapper.append("k");
+ lineWrapper.append("lmnop");
+ lineWrapper.close();
+ assertThat(out.toString()).isEqualTo("abcdefghij\n klmnop");
+ }
+
+ @Test public void overlyLongLinesWithoutLeadingSpace() throws Exception {
+ StringBuffer out = new StringBuffer();
+ LineWrapper lineWrapper = new LineWrapper(out, " ", 10);
+ lineWrapper.append("abcdefghijkl");
+ lineWrapper.close();
+ assertThat(out.toString()).isEqualTo("abcdefghijkl");
+ }
+
+ @Test public void overlyLongLinesWithLeadingSpace() throws Exception {
+ StringBuffer out = new StringBuffer();
+ LineWrapper lineWrapper = new LineWrapper(out, " ", 10);
+ lineWrapper.wrappingSpace(2);
+ lineWrapper.append("abcdefghijkl");
+ lineWrapper.close();
+ assertThat(out.toString()).isEqualTo("\n abcdefghijkl");
+ }
+
+ @Test public void overlyLongLinesWithLeadingZeroWidth() throws Exception {
+ StringBuffer out = new StringBuffer();
+ LineWrapper lineWrapper = new LineWrapper(out, " ", 10);
+ lineWrapper.zeroWidthSpace(2);
+ lineWrapper.append("abcdefghijkl");
+ lineWrapper.close();
+ assertThat(out.toString()).isEqualTo("abcdefghijkl");
+ }
+
+ @Test public void noWrapEmbeddedNewlines() throws Exception {
+ StringBuffer out = new StringBuffer();
+ LineWrapper lineWrapper = new LineWrapper(out, " ", 10);
+ lineWrapper.append("abcde");
+ lineWrapper.wrappingSpace(2);
+ lineWrapper.append("fghi\njklmn");
+ lineWrapper.append("opqrstuvwxy");
+ lineWrapper.close();
+ assertThat(out.toString()).isEqualTo("abcde fghi\njklmnopqrstuvwxy");
+ }
+
+ @Test public void wrapEmbeddedNewlines() throws Exception {
+ StringBuffer out = new StringBuffer();
+ LineWrapper lineWrapper = new LineWrapper(out, " ", 10);
+ lineWrapper.append("abcde");
+ lineWrapper.wrappingSpace(2);
+ lineWrapper.append("fghij\nklmn");
+ lineWrapper.append("opqrstuvwxy");
+ lineWrapper.close();
+ assertThat(out.toString()).isEqualTo("abcde\n fghij\nklmnopqrstuvwxy");
+ }
+
+ @Test public void noWrapEmbeddedNewlines_ZeroWidth() throws Exception {
+ StringBuffer out = new StringBuffer();
+ LineWrapper lineWrapper = new LineWrapper(out, " ", 10);
+ lineWrapper.append("abcde");
+ lineWrapper.zeroWidthSpace(2);
+ lineWrapper.append("fghij\nklmn");
+ lineWrapper.append("opqrstuvwxyz");
+ lineWrapper.close();
+ assertThat(out.toString()).isEqualTo("abcdefghij\nklmnopqrstuvwxyz");
+ }
+
+ @Test public void wrapEmbeddedNewlines_ZeroWidth() throws Exception {
+ StringBuffer out = new StringBuffer();
+ LineWrapper lineWrapper = new LineWrapper(out, " ", 10);
+ lineWrapper.append("abcde");
+ lineWrapper.zeroWidthSpace(2);
+ lineWrapper.append("fghijk\nlmn");
+ lineWrapper.append("opqrstuvwxy");
+ lineWrapper.close();
+ assertThat(out.toString()).isEqualTo("abcde\n fghijk\nlmnopqrstuvwxy");
+ }
+
+ @Test public void noWrapMultipleNewlines() throws Exception {
+ StringBuffer out = new StringBuffer();
+ LineWrapper lineWrapper = new LineWrapper(out, " ", 10);
+ lineWrapper.append("abcde");
+ lineWrapper.wrappingSpace(2);
+ lineWrapper.append("fghi\nklmnopq\nr");
+ lineWrapper.wrappingSpace(2);
+ lineWrapper.append("stuvwxyz");
+ lineWrapper.close();
+ assertThat(out.toString()).isEqualTo("abcde fghi\nklmnopq\nr stuvwxyz");
+ }
+
+ @Test public void wrapMultipleNewlines() throws Exception {
+ StringBuffer out = new StringBuffer();
+ LineWrapper lineWrapper = new LineWrapper(out, " ", 10);
+ lineWrapper.append("abcde");
+ lineWrapper.wrappingSpace(2);
+ lineWrapper.append("fghi\nklmnopq\nrs");
+ lineWrapper.wrappingSpace(2);
+ lineWrapper.append("tuvwxyz1");
+ lineWrapper.close();
+ assertThat(out.toString()).isEqualTo("abcde fghi\nklmnopq\nrs\n tuvwxyz1");
+ }
+}
diff --git a/src/test/java/com/squareup/javapoet/MethodSpecTest.java b/src/test/java/com/squareup/javapoet/MethodSpecTest.java
new file mode 100644
index 0000000..5dfabaa
--- /dev/null
+++ b/src/test/java/com/squareup/javapoet/MethodSpecTest.java
@@ -0,0 +1,305 @@
+/*
+ * Copyright (C) 2015 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import com.google.testing.compile.CompilationRule;
+import java.io.Closeable;
+import java.io.IOException;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.TimeoutException;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.util.Elements;
+import javax.lang.model.util.Types;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static com.google.common.truth.Truth.assertThat;
+import static javax.lang.model.util.ElementFilter.methodsIn;
+import static org.junit.Assert.fail;
+
+public final class MethodSpecTest {
+ @Rule public final CompilationRule compilation = new CompilationRule();
+
+ private Elements elements;
+ private Types types;
+
+ @Before public void setUp() {
+ elements = compilation.getElements();
+ types = compilation.getTypes();
+ }
+
+ private TypeElement getElement(Class<?> clazz) {
+ return elements.getTypeElement(clazz.getCanonicalName());
+ }
+
+ private ExecutableElement findFirst(Collection<ExecutableElement> elements, String name) {
+ for (ExecutableElement executableElement : elements) {
+ if (executableElement.getSimpleName().toString().equals(name)) {
+ return executableElement;
+ }
+ }
+ throw new IllegalArgumentException(name + " not found in " + elements);
+ }
+
+ @Test public void nullAnnotationsAddition() {
+ try {
+ MethodSpec.methodBuilder("doSomething").addAnnotations(null);
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("annotationSpecs == null");
+ }
+ }
+
+ @Test public void nullTypeVariablesAddition() {
+ try {
+ MethodSpec.methodBuilder("doSomething").addTypeVariables(null);
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("typeVariables == null");
+ }
+ }
+
+ @Test public void nullParametersAddition() {
+ try {
+ MethodSpec.methodBuilder("doSomething").addParameters(null);
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("parameterSpecs == null");
+ }
+ }
+
+ @Test public void nullExceptionsAddition() {
+ try {
+ MethodSpec.methodBuilder("doSomething").addExceptions(null);
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("exceptions == null");
+ }
+ }
+
+ @Target(ElementType.PARAMETER)
+ @interface Nullable {
+ }
+
+ abstract static class Everything {
+ @Deprecated protected abstract <T extends Runnable & Closeable> Runnable everything(
+ @Nullable String thing, List<? extends T> things) throws IOException, SecurityException;
+ }
+
+ abstract static class Generics {
+ <T, R, V extends Throwable> T run(R param) throws V {
+ return null;
+ }
+ }
+
+ abstract static class HasAnnotation {
+ @Override public abstract String toString();
+ }
+
+ interface Throws<R extends RuntimeException> {
+ void fail() throws R;
+ }
+
+ interface ExtendsOthers extends Callable<Integer>, Comparable<ExtendsOthers>,
+ Throws<IllegalStateException> {
+ }
+
+ interface ExtendsIterableWithDefaultMethods extends Iterable<Object> {
+ }
+
+ final class FinalClass {
+ void method() {
+ }
+ }
+
+ abstract static class InvalidOverrideMethods {
+ final void finalMethod() {
+ }
+
+ private void privateMethod() {
+ }
+
+ static void staticMethod() {
+ }
+ }
+
+ @Test public void overrideEverything() {
+ TypeElement classElement = getElement(Everything.class);
+ ExecutableElement methodElement = getOnlyElement(methodsIn(classElement.getEnclosedElements()));
+ MethodSpec method = MethodSpec.overriding(methodElement).build();
+ assertThat(method.toString()).isEqualTo(""
+ + "@java.lang.Override\n"
+ + "protected <T extends java.lang.Runnable & java.io.Closeable> java.lang.Runnable "
+ + "everything(\n"
+ + " java.lang.String arg0, java.util.List<? extends T> arg1) throws java.io.IOException,\n"
+ + " java.lang.SecurityException {\n"
+ + "}\n");
+ }
+
+ @Test public void overrideGenerics() {
+ TypeElement classElement = getElement(Generics.class);
+ ExecutableElement methodElement = getOnlyElement(methodsIn(classElement.getEnclosedElements()));
+ MethodSpec method = MethodSpec.overriding(methodElement)
+ .addStatement("return null")
+ .build();
+ assertThat(method.toString()).isEqualTo(""
+ + "@java.lang.Override\n"
+ + "<T, R, V extends java.lang.Throwable> T run(R param) throws V {\n"
+ + " return null;\n"
+ + "}\n");
+ }
+
+ @Test public void overrideDoesNotCopyOverrideAnnotation() {
+ TypeElement classElement = getElement(HasAnnotation.class);
+ ExecutableElement exec = getOnlyElement(methodsIn(classElement.getEnclosedElements()));
+ MethodSpec method = MethodSpec.overriding(exec).build();
+ assertThat(method.toString()).isEqualTo(""
+ + "@java.lang.Override\n"
+ + "public java.lang.String toString() {\n"
+ + "}\n");
+ }
+
+ @Test public void overrideDoesNotCopyDefaultModifier() {
+ TypeElement classElement = getElement(ExtendsIterableWithDefaultMethods.class);
+ DeclaredType classType = (DeclaredType) classElement.asType();
+ List<ExecutableElement> methods = methodsIn(elements.getAllMembers(classElement));
+ ExecutableElement exec = findFirst(methods, "spliterator");
+ MethodSpec method = MethodSpec.overriding(exec, classType, types).build();
+ assertThat(method.toString()).isEqualTo(""
+ + "@java.lang.Override\n"
+ + "public java.util.Spliterator<java.lang.Object> spliterator() {\n"
+ + "}\n");
+ }
+
+ @Test public void overrideExtendsOthersWorksWithActualTypeParameters() {
+ TypeElement classElement = getElement(ExtendsOthers.class);
+ DeclaredType classType = (DeclaredType) classElement.asType();
+ List<ExecutableElement> methods = methodsIn(elements.getAllMembers(classElement));
+ ExecutableElement exec = findFirst(methods, "call");
+ MethodSpec method = MethodSpec.overriding(exec, classType, types).build();
+ assertThat(method.toString()).isEqualTo(""
+ + "@java.lang.Override\n"
+ + "public java.lang.Integer call() throws java.lang.Exception {\n"
+ + "}\n");
+ exec = findFirst(methods, "compareTo");
+ method = MethodSpec.overriding(exec, classType, types).build();
+ assertThat(method.toString()).isEqualTo(""
+ + "@java.lang.Override\n"
+ + "public int compareTo(" + ExtendsOthers.class.getCanonicalName() + " arg0) {\n"
+ + "}\n");
+ exec = findFirst(methods, "fail");
+ method = MethodSpec.overriding(exec, classType, types).build();
+ assertThat(method.toString()).isEqualTo(""
+ + "@java.lang.Override\n"
+ + "public void fail() throws java.lang.IllegalStateException {\n"
+ + "}\n");
+ }
+
+ @Test public void overrideFinalClassMethod() {
+ TypeElement classElement = getElement(FinalClass.class);
+ List<ExecutableElement> methods = methodsIn(elements.getAllMembers(classElement));
+ try {
+ MethodSpec.overriding(findFirst(methods, "method"));
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo(
+ "Cannot override method on final class com.squareup.javapoet.MethodSpecTest.FinalClass");
+ }
+ }
+
+ @Test public void overrideInvalidModifiers() {
+ TypeElement classElement = getElement(InvalidOverrideMethods.class);
+ List<ExecutableElement> methods = methodsIn(elements.getAllMembers(classElement));
+ try {
+ MethodSpec.overriding(findFirst(methods, "finalMethod"));
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("cannot override method with modifiers: [final]");
+ }
+ try {
+ MethodSpec.overriding(findFirst(methods, "privateMethod"));
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("cannot override method with modifiers: [private]");
+ }
+ try {
+ MethodSpec.overriding(findFirst(methods, "staticMethod"));
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("cannot override method with modifiers: [static]");
+ }
+ }
+
+ @Test public void equalsAndHashCode() {
+ MethodSpec a = MethodSpec.constructorBuilder().build();
+ MethodSpec b = MethodSpec.constructorBuilder().build();
+ assertThat(a.equals(b)).isTrue();
+ assertThat(a.hashCode()).isEqualTo(b.hashCode());
+ a = MethodSpec.methodBuilder("taco").build();
+ b = MethodSpec.methodBuilder("taco").build();
+ assertThat(a.equals(b)).isTrue();
+ assertThat(a.hashCode()).isEqualTo(b.hashCode());
+ TypeElement classElement = getElement(Everything.class);
+ ExecutableElement methodElement = getOnlyElement(methodsIn(classElement.getEnclosedElements()));
+ a = MethodSpec.overriding(methodElement).build();
+ b = MethodSpec.overriding(methodElement).build();
+ assertThat(a.equals(b)).isTrue();
+ assertThat(a.hashCode()).isEqualTo(b.hashCode());
+ }
+
+ @Test public void duplicateExceptionsIgnored() {
+ ClassName ioException = ClassName.get(IOException.class);
+ ClassName timeoutException = ClassName.get(TimeoutException.class);
+ MethodSpec methodSpec = MethodSpec.methodBuilder("duplicateExceptions")
+ .addException(ioException)
+ .addException(timeoutException)
+ .addException(timeoutException)
+ .addException(ioException)
+ .build();
+ assertThat(methodSpec.exceptions).isEqualTo(Arrays.asList(ioException, timeoutException));
+ assertThat(methodSpec.toBuilder().addException(ioException).build().exceptions)
+ .isEqualTo(Arrays.asList(ioException, timeoutException));
+ }
+
+ @Test public void nullIsNotAValidMethodName() {
+ try {
+ MethodSpec.methodBuilder(null);
+ fail("NullPointerException expected");
+ } catch (NullPointerException e) {
+ assertThat(e.getMessage()).isEqualTo("name == null");
+ }
+ }
+
+ @Test public void addModifiersVarargsShouldNotBeNull() {
+ try {
+ MethodSpec.methodBuilder("taco")
+ .addModifiers((Modifier[]) null);
+ fail("NullPointerException expected");
+ } catch (NullPointerException e) {
+ assertThat(e.getMessage()).isEqualTo("modifiers == null");
+ }
+ }
+}
diff --git a/src/test/java/com/squareup/javapoet/NameAllocatorTest.java b/src/test/java/com/squareup/javapoet/NameAllocatorTest.java
new file mode 100644
index 0000000..1840107
--- /dev/null
+++ b/src/test/java/com/squareup/javapoet/NameAllocatorTest.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2015 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import org.junit.Test;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
+public final class NameAllocatorTest {
+ @Test public void usage() throws Exception {
+ NameAllocator nameAllocator = new NameAllocator();
+ assertThat(nameAllocator.newName("foo", 1)).isEqualTo("foo");
+ assertThat(nameAllocator.newName("bar", 2)).isEqualTo("bar");
+ assertThat(nameAllocator.get(1)).isEqualTo("foo");
+ assertThat(nameAllocator.get(2)).isEqualTo("bar");
+ }
+
+ @Test public void nameCollision() throws Exception {
+ NameAllocator nameAllocator = new NameAllocator();
+ assertThat(nameAllocator.newName("foo")).isEqualTo("foo");
+ assertThat(nameAllocator.newName("foo")).isEqualTo("foo_");
+ assertThat(nameAllocator.newName("foo")).isEqualTo("foo__");
+ }
+
+ @Test public void nameCollisionWithTag() throws Exception {
+ NameAllocator nameAllocator = new NameAllocator();
+ assertThat(nameAllocator.newName("foo", 1)).isEqualTo("foo");
+ assertThat(nameAllocator.newName("foo", 2)).isEqualTo("foo_");
+ assertThat(nameAllocator.newName("foo", 3)).isEqualTo("foo__");
+ assertThat(nameAllocator.get(1)).isEqualTo("foo");
+ assertThat(nameAllocator.get(2)).isEqualTo("foo_");
+ assertThat(nameAllocator.get(3)).isEqualTo("foo__");
+ }
+
+ @Test public void characterMappingSubstitute() throws Exception {
+ NameAllocator nameAllocator = new NameAllocator();
+ assertThat(nameAllocator.newName("a-b", 1)).isEqualTo("a_b");
+ }
+
+ @Test public void characterMappingSurrogate() throws Exception {
+ NameAllocator nameAllocator = new NameAllocator();
+ assertThat(nameAllocator.newName("a\uD83C\uDF7Ab", 1)).isEqualTo("a_b");
+ }
+
+ @Test public void characterMappingInvalidStartButValidPart() throws Exception {
+ NameAllocator nameAllocator = new NameAllocator();
+ assertThat(nameAllocator.newName("1ab", 1)).isEqualTo("_1ab");
+ }
+
+ @Test public void characterMappingInvalidStartIsInvalidPart() throws Exception {
+ NameAllocator nameAllocator = new NameAllocator();
+ assertThat(nameAllocator.newName("&ab", 1)).isEqualTo("_ab");
+ }
+
+ @Test public void javaKeyword() throws Exception {
+ NameAllocator nameAllocator = new NameAllocator();
+ assertThat(nameAllocator.newName("public", 1)).isEqualTo("public_");
+ assertThat(nameAllocator.get(1)).isEqualTo("public_");
+ }
+
+ @Test public void tagReuseForbidden() throws Exception {
+ NameAllocator nameAllocator = new NameAllocator();
+ nameAllocator.newName("foo", 1);
+ try {
+ nameAllocator.newName("bar", 1);
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("tag 1 cannot be used for both 'foo' and 'bar'");
+ }
+ }
+
+ @Test public void useBeforeAllocateForbidden() throws Exception {
+ NameAllocator nameAllocator = new NameAllocator();
+ try {
+ nameAllocator.get(1);
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("unknown tag: 1");
+ }
+ }
+
+ @Test public void cloneUsage() throws Exception {
+ NameAllocator outterAllocator = new NameAllocator();
+ outterAllocator.newName("foo", 1);
+
+ NameAllocator innerAllocator1 = outterAllocator.clone();
+ assertThat(innerAllocator1.newName("bar", 2)).isEqualTo("bar");
+ assertThat(innerAllocator1.newName("foo", 3)).isEqualTo("foo_");
+
+ NameAllocator innerAllocator2 = outterAllocator.clone();
+ assertThat(innerAllocator2.newName("foo", 2)).isEqualTo("foo_");
+ assertThat(innerAllocator2.newName("bar", 3)).isEqualTo("bar");
+ }
+}
diff --git a/src/test/java/com/squareup/javapoet/ParameterSpecTest.java b/src/test/java/com/squareup/javapoet/ParameterSpecTest.java
new file mode 100644
index 0000000..2f81866
--- /dev/null
+++ b/src/test/java/com/squareup/javapoet/ParameterSpecTest.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2015 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import org.junit.Test;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
+import javax.lang.model.element.Modifier;
+
+public class ParameterSpecTest {
+ @Test public void equalsAndHashCode() {
+ ParameterSpec a = ParameterSpec.builder(int.class, "foo").build();
+ ParameterSpec b = ParameterSpec.builder(int.class, "foo").build();
+ assertThat(a.equals(b)).isTrue();
+ assertThat(a.hashCode()).isEqualTo(b.hashCode());
+ a = ParameterSpec.builder(int.class, "i").addModifiers(Modifier.STATIC).build();
+ b = ParameterSpec.builder(int.class, "i").addModifiers(Modifier.STATIC).build();
+ assertThat(a.equals(b)).isTrue();
+ assertThat(a.hashCode()).isEqualTo(b.hashCode());
+ }
+
+ @Test public void nullAnnotationsAddition() {
+ try {
+ ParameterSpec.builder(int.class, "foo").addAnnotations(null);
+ fail();
+ } catch (Exception e) {
+ assertThat(e.getMessage())
+ .isEqualTo("annotationSpecs == null");
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/com/squareup/javapoet/TestFiler.java b/src/test/java/com/squareup/javapoet/TestFiler.java
new file mode 100644
index 0000000..274877c
--- /dev/null
+++ b/src/test/java/com/squareup/javapoet/TestFiler.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2014 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.file.FileSystem;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.spi.FileSystemProvider;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import javax.annotation.processing.Filer;
+import javax.lang.model.element.Element;
+import javax.tools.FileObject;
+import javax.tools.JavaFileManager;
+import javax.tools.JavaFileObject;
+import javax.tools.SimpleJavaFileObject;
+
+final class TestFiler implements Filer {
+ class Source extends SimpleJavaFileObject {
+ private final Path path;
+ protected Source(Path path) {
+ super(path.toUri(), Kind.SOURCE);
+ this.path = path;
+ }
+ @Override public OutputStream openOutputStream() throws IOException {
+ Path parent = path.getParent();
+ if (!Files.exists(parent)) fileSystemProvider.createDirectory(parent);
+ return fileSystemProvider.newOutputStream(path);
+ }
+ }
+
+ private final String separator;
+ private final Path fileSystemRoot;
+ private final FileSystemProvider fileSystemProvider;
+ private final Map<Path, Set<Element>> originatingElementsMap;
+
+ public TestFiler(FileSystem fileSystem, Path fsRoot) {
+ separator = fileSystem.getSeparator();
+ fileSystemRoot = fsRoot;
+ fileSystemProvider = fileSystem.provider();
+ originatingElementsMap = new LinkedHashMap<>();
+ }
+
+ public Set<Element> getOriginatingElements(Path path) {
+ return originatingElementsMap.get(path);
+ }
+
+ @Override public JavaFileObject createSourceFile(
+ CharSequence name, Element... originatingElements) throws IOException {
+ String relative = name.toString().replace(".", separator) + ".java"; // Assumes well-formed.
+ Path path = fileSystemRoot.resolve(relative);
+ originatingElementsMap.put(path, Util.immutableSet(Arrays.asList(originatingElements)));
+ return new Source(path);
+ }
+
+ @Override public JavaFileObject createClassFile(CharSequence name, Element... originatingElements)
+ throws IOException {
+ throw new UnsupportedOperationException("Not implemented.");
+ }
+
+ @Override public FileObject createResource(JavaFileManager.Location location, CharSequence pkg,
+ CharSequence relativeName, Element... originatingElements) throws IOException {
+ throw new UnsupportedOperationException("Not implemented.");
+ }
+
+ @Override public FileObject getResource(JavaFileManager.Location location, CharSequence pkg,
+ CharSequence relativeName) throws IOException {
+ throw new UnsupportedOperationException("Not implemented.");
+ }
+}
diff --git a/src/test/java/com/squareup/javapoet/TypeNameTest.java b/src/test/java/com/squareup/javapoet/TypeNameTest.java
new file mode 100644
index 0000000..99ed58d
--- /dev/null
+++ b/src/test/java/com/squareup/javapoet/TypeNameTest.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright (C) 2015 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import java.io.Serializable;
+import java.lang.reflect.Method;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.junit.Test;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+
+public class TypeNameTest {
+
+ protected <E extends Enum<E>> E generic(E[] values) {
+ return values[0];
+ }
+
+ protected static class TestGeneric<T> {
+ class Inner {}
+
+ class InnerGeneric<T2> {}
+
+ static class NestedNonGeneric {}
+ }
+
+ protected static TestGeneric<String>.Inner testGenericStringInner() {
+ return null;
+ }
+
+ protected static TestGeneric<Integer>.Inner testGenericIntInner() {
+ return null;
+ }
+
+ protected static TestGeneric<Short>.InnerGeneric<Long> testGenericInnerLong() {
+ return null;
+ }
+
+ protected static TestGeneric<Short>.InnerGeneric<Integer> testGenericInnerInt() {
+ return null;
+ }
+
+ protected static TestGeneric.NestedNonGeneric testNestedNonGeneric() {
+ return null;
+ }
+
+ @Test public void genericType() throws Exception {
+ Method recursiveEnum = getClass().getDeclaredMethod("generic", Enum[].class);
+ TypeName.get(recursiveEnum.getReturnType());
+ TypeName.get(recursiveEnum.getGenericReturnType());
+ TypeName genericTypeName = TypeName.get(recursiveEnum.getParameterTypes()[0]);
+ TypeName.get(recursiveEnum.getGenericParameterTypes()[0]);
+
+ // Make sure the generic argument is present
+ assertThat(genericTypeName.toString()).contains("Enum");
+ }
+
+ @Test public void innerClassInGenericType() throws Exception {
+ Method genericStringInner = getClass().getDeclaredMethod("testGenericStringInner");
+ TypeName.get(genericStringInner.getReturnType());
+ TypeName genericTypeName = TypeName.get(genericStringInner.getGenericReturnType());
+ assertNotEquals(TypeName.get(genericStringInner.getGenericReturnType()),
+ TypeName.get(getClass().getDeclaredMethod("testGenericIntInner").getGenericReturnType()));
+
+ // Make sure the generic argument is present
+ assertThat(genericTypeName.toString()).isEqualTo(
+ TestGeneric.class.getCanonicalName() + "<java.lang.String>.Inner");
+ }
+
+ @Test public void innerGenericInGenericType() throws Exception {
+ Method genericStringInner = getClass().getDeclaredMethod("testGenericInnerLong");
+ TypeName.get(genericStringInner.getReturnType());
+ TypeName genericTypeName = TypeName.get(genericStringInner.getGenericReturnType());
+ assertNotEquals(TypeName.get(genericStringInner.getGenericReturnType()),
+ TypeName.get(getClass().getDeclaredMethod("testGenericInnerInt").getGenericReturnType()));
+
+ // Make sure the generic argument is present
+ assertThat(genericTypeName.toString()).isEqualTo(
+ TestGeneric.class.getCanonicalName() + "<java.lang.Short>.InnerGeneric<java.lang.Long>");
+ }
+
+ @Test public void innerStaticInGenericType() throws Exception {
+ Method staticInGeneric = getClass().getDeclaredMethod("testNestedNonGeneric");
+ TypeName.get(staticInGeneric.getReturnType());
+ TypeName typeName = TypeName.get(staticInGeneric.getGenericReturnType());
+
+ // Make sure there are no generic arguments
+ assertThat(typeName.toString()).isEqualTo(
+ TestGeneric.class.getCanonicalName() + ".NestedNonGeneric");
+ }
+
+ @Test public void equalsAndHashCodePrimitive() {
+ assertEqualsHashCodeAndToString(TypeName.BOOLEAN, TypeName.BOOLEAN);
+ assertEqualsHashCodeAndToString(TypeName.BYTE, TypeName.BYTE);
+ assertEqualsHashCodeAndToString(TypeName.CHAR, TypeName.CHAR);
+ assertEqualsHashCodeAndToString(TypeName.DOUBLE, TypeName.DOUBLE);
+ assertEqualsHashCodeAndToString(TypeName.FLOAT, TypeName.FLOAT);
+ assertEqualsHashCodeAndToString(TypeName.INT, TypeName.INT);
+ assertEqualsHashCodeAndToString(TypeName.LONG, TypeName.LONG);
+ assertEqualsHashCodeAndToString(TypeName.SHORT, TypeName.SHORT);
+ assertEqualsHashCodeAndToString(TypeName.VOID, TypeName.VOID);
+ }
+
+ @Test public void equalsAndHashCodeArrayTypeName() {
+ assertEqualsHashCodeAndToString(ArrayTypeName.of(Object.class),
+ ArrayTypeName.of(Object.class));
+ assertEqualsHashCodeAndToString(TypeName.get(Object[].class),
+ ArrayTypeName.of(Object.class));
+ }
+
+ @Test public void equalsAndHashCodeClassName() {
+ assertEqualsHashCodeAndToString(ClassName.get(Object.class), ClassName.get(Object.class));
+ assertEqualsHashCodeAndToString(TypeName.get(Object.class), ClassName.get(Object.class));
+ assertEqualsHashCodeAndToString(ClassName.bestGuess("java.lang.Object"),
+ ClassName.get(Object.class));
+ }
+
+ @Test public void equalsAndHashCodeParameterizedTypeName() {
+ assertEqualsHashCodeAndToString(ParameterizedTypeName.get(Object.class),
+ ParameterizedTypeName.get(Object.class));
+ assertEqualsHashCodeAndToString(ParameterizedTypeName.get(Set.class, UUID.class),
+ ParameterizedTypeName.get(Set.class, UUID.class));
+ assertNotEquals(ClassName.get(List.class), ParameterizedTypeName.get(List.class,
+ String.class));
+ }
+
+ @Test public void equalsAndHashCodeTypeVariableName() {
+ assertEqualsHashCodeAndToString(TypeVariableName.get(Object.class),
+ TypeVariableName.get(Object.class));
+ TypeVariableName typeVar1 = TypeVariableName.get("T", Comparator.class, Serializable.class);
+ TypeVariableName typeVar2 = TypeVariableName.get("T", Comparator.class, Serializable.class);
+ assertEqualsHashCodeAndToString(typeVar1, typeVar2);
+ }
+
+ @Test public void equalsAndHashCodeWildcardTypeName() {
+ assertEqualsHashCodeAndToString(WildcardTypeName.subtypeOf(Object.class),
+ WildcardTypeName.subtypeOf(Object.class));
+ assertEqualsHashCodeAndToString(WildcardTypeName.subtypeOf(Serializable.class),
+ WildcardTypeName.subtypeOf(Serializable.class));
+ assertEqualsHashCodeAndToString(WildcardTypeName.supertypeOf(String.class),
+ WildcardTypeName.supertypeOf(String.class));
+ }
+
+ @Test public void isPrimitive() throws Exception {
+ assertThat(TypeName.INT.isPrimitive()).isTrue();
+ assertThat(ClassName.get("java.lang", "Integer").isPrimitive()).isFalse();
+ assertThat(ClassName.get("java.lang", "String").isPrimitive()).isFalse();
+ assertThat(TypeName.VOID.isPrimitive()).isFalse();
+ assertThat(ClassName.get("java.lang", "Void").isPrimitive()).isFalse();
+ }
+
+ @Test public void isBoxedPrimitive() throws Exception {
+ assertThat(TypeName.INT.isBoxedPrimitive()).isFalse();
+ assertThat(ClassName.get("java.lang", "Integer").isBoxedPrimitive()).isTrue();
+ assertThat(ClassName.get("java.lang", "String").isBoxedPrimitive()).isFalse();
+ assertThat(TypeName.VOID.isBoxedPrimitive()).isFalse();
+ assertThat(ClassName.get("java.lang", "Void").isBoxedPrimitive()).isFalse();
+ }
+
+ private void assertEqualsHashCodeAndToString(TypeName a, TypeName b) {
+ assertEquals(a.toString(), b.toString());
+ assertThat(a.equals(b)).isTrue();
+ assertThat(a.hashCode()).isEqualTo(b.hashCode());
+ assertFalse(a.equals(null));
+ }
+}
diff --git a/src/test/java/com/squareup/javapoet/TypeSpecTest.java b/src/test/java/com/squareup/javapoet/TypeSpecTest.java
new file mode 100644
index 0000000..9cd22c2
--- /dev/null
+++ b/src/test/java/com/squareup/javapoet/TypeSpecTest.java
@@ -0,0 +1,2359 @@
+/*
+ * Copyright (C) 2015 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.testing.compile.CompilationRule;
+import java.io.IOException;
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.util.AbstractSet;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.EventListener;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Random;
+import java.util.concurrent.Callable;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.TypeMirror;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.Mockito;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+@RunWith(JUnit4.class)
+public final class TypeSpecTest {
+ private final String tacosPackage = "com.squareup.tacos";
+ private static final String donutsPackage = "com.squareup.donuts";
+
+ @Rule public final CompilationRule compilation = new CompilationRule();
+
+ private TypeElement getElement(Class<?> clazz) {
+ return compilation.getElements().getTypeElement(clazz.getCanonicalName());
+ }
+
+ @Test public void basic() throws Exception {
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addMethod(MethodSpec.methodBuilder("toString")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
+ .returns(String.class)
+ .addCode("return $S;\n", "taco")
+ .build())
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.Override;\n"
+ + "import java.lang.String;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " @Override\n"
+ + " public final String toString() {\n"
+ + " return \"taco\";\n"
+ + " }\n"
+ + "}\n");
+ assertEquals(472949424, taco.hashCode()); // update expected number if source changes
+ }
+
+ @Test public void interestingTypes() throws Exception {
+ TypeName listOfAny = ParameterizedTypeName.get(
+ ClassName.get(List.class), WildcardTypeName.subtypeOf(Object.class));
+ TypeName listOfExtends = ParameterizedTypeName.get(
+ ClassName.get(List.class), WildcardTypeName.subtypeOf(Serializable.class));
+ TypeName listOfSuper = ParameterizedTypeName.get(ClassName.get(List.class),
+ WildcardTypeName.supertypeOf(String.class));
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addField(listOfAny, "extendsObject")
+ .addField(listOfExtends, "extendsSerializable")
+ .addField(listOfSuper, "superString")
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.io.Serializable;\n"
+ + "import java.lang.String;\n"
+ + "import java.util.List;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " List<?> extendsObject;\n"
+ + "\n"
+ + " List<? extends Serializable> extendsSerializable;\n"
+ + "\n"
+ + " List<? super String> superString;\n"
+ + "}\n");
+ }
+
+ @Test public void anonymousInnerClass() throws Exception {
+ ClassName foo = ClassName.get(tacosPackage, "Foo");
+ ClassName bar = ClassName.get(tacosPackage, "Bar");
+ ClassName thingThang = ClassName.get(tacosPackage, "Thing", "Thang");
+ TypeName thingThangOfFooBar = ParameterizedTypeName.get(thingThang, foo, bar);
+ ClassName thung = ClassName.get(tacosPackage, "Thung");
+ ClassName simpleThung = ClassName.get(tacosPackage, "SimpleThung");
+ TypeName thungOfSuperBar = ParameterizedTypeName.get(thung, WildcardTypeName.supertypeOf(bar));
+ TypeName thungOfSuperFoo = ParameterizedTypeName.get(thung, WildcardTypeName.supertypeOf(foo));
+ TypeName simpleThungOfBar = ParameterizedTypeName.get(simpleThung, bar);
+
+ ParameterSpec thungParameter = ParameterSpec.builder(thungOfSuperFoo, "thung")
+ .addModifiers(Modifier.FINAL)
+ .build();
+ TypeSpec aSimpleThung = TypeSpec.anonymousClassBuilder(CodeBlock.of("$N", thungParameter))
+ .superclass(simpleThungOfBar)
+ .addMethod(MethodSpec.methodBuilder("doSomething")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC)
+ .addParameter(bar, "bar")
+ .addCode("/* code snippets */\n")
+ .build())
+ .build();
+ TypeSpec aThingThang = TypeSpec.anonymousClassBuilder("")
+ .superclass(thingThangOfFooBar)
+ .addMethod(MethodSpec.methodBuilder("call")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC)
+ .returns(thungOfSuperBar)
+ .addParameter(thungParameter)
+ .addCode("return $L;\n", aSimpleThung)
+ .build())
+ .build();
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addField(FieldSpec.builder(thingThangOfFooBar, "NAME")
+ .addModifiers(Modifier.STATIC, Modifier.FINAL, Modifier.FINAL)
+ .initializer("$L", aThingThang)
+ .build())
+ .build();
+
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.Override;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " static final Thing.Thang<Foo, Bar> NAME = new Thing.Thang<Foo, Bar>() {\n"
+ + " @Override\n"
+ + " public Thung<? super Bar> call(final Thung<? super Foo> thung) {\n"
+ + " return new SimpleThung<Bar>(thung) {\n"
+ + " @Override\n"
+ + " public void doSomething(Bar bar) {\n"
+ + " /* code snippets */\n"
+ + " }\n"
+ + " };\n"
+ + " }\n"
+ + " };\n"
+ + "}\n");
+ }
+
+ @Test public void annotatedParameters() throws Exception {
+ TypeSpec service = TypeSpec.classBuilder("Foo")
+ .addMethod(MethodSpec.constructorBuilder()
+ .addModifiers(Modifier.PUBLIC)
+ .addParameter(long.class, "id")
+ .addParameter(ParameterSpec.builder(String.class, "one")
+ .addAnnotation(ClassName.get(tacosPackage, "Ping"))
+ .build())
+ .addParameter(ParameterSpec.builder(String.class, "two")
+ .addAnnotation(ClassName.get(tacosPackage, "Ping"))
+ .build())
+ .addParameter(ParameterSpec.builder(String.class, "three")
+ .addAnnotation(AnnotationSpec.builder(ClassName.get(tacosPackage, "Pong"))
+ .addMember("value", "$S", "pong")
+ .build())
+ .build())
+ .addParameter(ParameterSpec.builder(String.class, "four")
+ .addAnnotation(ClassName.get(tacosPackage, "Ping"))
+ .build())
+ .addCode("/* code snippets */\n")
+ .build())
+ .build();
+
+ assertThat(toString(service)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.String;\n"
+ + "\n"
+ + "class Foo {\n"
+ + " public Foo(long id, @Ping String one, @Ping String two, @Pong(\"pong\") String three,\n"
+ + " @Ping String four) {\n"
+ + " /* code snippets */\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ /**
+ * We had a bug where annotations were preventing us from doing the right thing when resolving
+ * imports. https://github.com/square/javapoet/issues/422
+ */
+ @Test public void annotationsAndJavaLangTypes() throws Exception {
+ ClassName freeRange = ClassName.get("javax.annotation", "FreeRange");
+ TypeSpec taco = TypeSpec.classBuilder("EthicalTaco")
+ .addField(ClassName.get(String.class)
+ .annotated(AnnotationSpec.builder(freeRange).build()), "meat")
+ .build();
+
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.String;\n"
+ + "import javax.annotation.FreeRange;\n"
+ + "\n"
+ + "class EthicalTaco {\n"
+ + " @FreeRange String meat;\n"
+ + "}\n");
+ }
+
+ @Test public void retrofitStyleInterface() throws Exception {
+ ClassName observable = ClassName.get(tacosPackage, "Observable");
+ ClassName fooBar = ClassName.get(tacosPackage, "FooBar");
+ ClassName thing = ClassName.get(tacosPackage, "Thing");
+ ClassName things = ClassName.get(tacosPackage, "Things");
+ ClassName map = ClassName.get("java.util", "Map");
+ ClassName string = ClassName.get("java.lang", "String");
+ ClassName headers = ClassName.get(tacosPackage, "Headers");
+ ClassName post = ClassName.get(tacosPackage, "POST");
+ ClassName body = ClassName.get(tacosPackage, "Body");
+ ClassName queryMap = ClassName.get(tacosPackage, "QueryMap");
+ ClassName header = ClassName.get(tacosPackage, "Header");
+ TypeSpec service = TypeSpec.interfaceBuilder("Service")
+ .addMethod(MethodSpec.methodBuilder("fooBar")
+ .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
+ .addAnnotation(AnnotationSpec.builder(headers)
+ .addMember("value", "$S", "Accept: application/json")
+ .addMember("value", "$S", "User-Agent: foobar")
+ .build())
+ .addAnnotation(AnnotationSpec.builder(post)
+ .addMember("value", "$S", "/foo/bar")
+ .build())
+ .returns(ParameterizedTypeName.get(observable, fooBar))
+ .addParameter(ParameterSpec.builder(ParameterizedTypeName.get(things, thing), "things")
+ .addAnnotation(body)
+ .build())
+ .addParameter(ParameterSpec.builder(
+ ParameterizedTypeName.get(map, string, string), "query")
+ .addAnnotation(AnnotationSpec.builder(queryMap)
+ .addMember("encodeValues", "false")
+ .build())
+ .build())
+ .addParameter(ParameterSpec.builder(string, "authorization")
+ .addAnnotation(AnnotationSpec.builder(header)
+ .addMember("value", "$S", "Authorization")
+ .build())
+ .build())
+ .build())
+ .build();
+
+ assertThat(toString(service)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.String;\n"
+ + "import java.util.Map;\n"
+ + "\n"
+ + "interface Service {\n"
+ + " @Headers({\n"
+ + " \"Accept: application/json\",\n"
+ + " \"User-Agent: foobar\"\n"
+ + " })\n"
+ + " @POST(\"/foo/bar\")\n"
+ + " Observable<FooBar> fooBar(@Body Things<Thing> things,\n"
+ + " @QueryMap(encodeValues = false) Map<String, String> query,\n"
+ + " @Header(\"Authorization\") String authorization);\n"
+ + "}\n");
+ }
+
+ @Test public void annotatedField() throws Exception {
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addField(FieldSpec.builder(String.class, "thing", Modifier.PRIVATE, Modifier.FINAL)
+ .addAnnotation(AnnotationSpec.builder(ClassName.get(tacosPackage, "JsonAdapter"))
+ .addMember("value", "$T.class", ClassName.get(tacosPackage, "Foo"))
+ .build())
+ .build())
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.String;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " @JsonAdapter(Foo.class)\n"
+ + " private final String thing;\n"
+ + "}\n");
+ }
+
+ @Test public void annotatedClass() throws Exception {
+ ClassName someType = ClassName.get(tacosPackage, "SomeType");
+ TypeSpec taco = TypeSpec.classBuilder("Foo")
+ .addAnnotation(AnnotationSpec.builder(ClassName.get(tacosPackage, "Something"))
+ .addMember("hi", "$T.$N", someType, "FIELD")
+ .addMember("hey", "$L", 12)
+ .addMember("hello", "$S", "goodbye")
+ .build())
+ .addModifiers(Modifier.PUBLIC)
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "@Something(\n"
+ + " hi = SomeType.FIELD,\n"
+ + " hey = 12,\n"
+ + " hello = \"goodbye\"\n"
+ + ")\n"
+ + "public class Foo {\n"
+ + "}\n");
+ }
+
+ @Test public void addAnnotationDisallowsNull() {
+ try {
+ TypeSpec.classBuilder("Foo").addAnnotation((AnnotationSpec) null);
+ fail();
+ } catch (NullPointerException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("annotationSpec == null");
+ }
+ try {
+ TypeSpec.classBuilder("Foo").addAnnotation((ClassName) null);
+ fail();
+ } catch (NullPointerException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("type == null");
+ }
+ try {
+ TypeSpec.classBuilder("Foo").addAnnotation((Class<?>) null);
+ fail();
+ } catch (NullPointerException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("clazz == null");
+ }
+ }
+
+ @Test public void enumWithSubclassing() throws Exception {
+ TypeSpec roshambo = TypeSpec.enumBuilder("Roshambo")
+ .addModifiers(Modifier.PUBLIC)
+ .addEnumConstant("ROCK", TypeSpec.anonymousClassBuilder("")
+ .addJavadoc("Avalanche!\n")
+ .build())
+ .addEnumConstant("PAPER", TypeSpec.anonymousClassBuilder("$S", "flat")
+ .addMethod(MethodSpec.methodBuilder("toString")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC)
+ .returns(String.class)
+ .addCode("return $S;\n", "paper airplane!")
+ .build())
+ .build())
+ .addEnumConstant("SCISSORS", TypeSpec.anonymousClassBuilder("$S", "peace sign")
+ .build())
+ .addField(String.class, "handPosition", Modifier.PRIVATE, Modifier.FINAL)
+ .addMethod(MethodSpec.constructorBuilder()
+ .addParameter(String.class, "handPosition")
+ .addCode("this.handPosition = handPosition;\n")
+ .build())
+ .addMethod(MethodSpec.constructorBuilder()
+ .addCode("this($S);\n", "fist")
+ .build())
+ .build();
+ assertThat(toString(roshambo)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.Override;\n"
+ + "import java.lang.String;\n"
+ + "\n"
+ + "public enum Roshambo {\n"
+ + " /**\n"
+ + " * Avalanche!\n"
+ + " */\n"
+ + " ROCK,\n"
+ + "\n"
+ + " PAPER(\"flat\") {\n"
+ + " @Override\n"
+ + " public String toString() {\n"
+ + " return \"paper airplane!\";\n"
+ + " }\n"
+ + " },\n"
+ + "\n"
+ + " SCISSORS(\"peace sign\");\n"
+ + "\n"
+ + " private final String handPosition;\n"
+ + "\n"
+ + " Roshambo(String handPosition) {\n"
+ + " this.handPosition = handPosition;\n"
+ + " }\n"
+ + "\n"
+ + " Roshambo() {\n"
+ + " this(\"fist\");\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ /** https://github.com/square/javapoet/issues/193 */
+ @Test public void enumsMayDefineAbstractMethods() throws Exception {
+ TypeSpec roshambo = TypeSpec.enumBuilder("Tortilla")
+ .addModifiers(Modifier.PUBLIC)
+ .addEnumConstant("CORN", TypeSpec.anonymousClassBuilder("")
+ .addMethod(MethodSpec.methodBuilder("fold")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC)
+ .build())
+ .build())
+ .addMethod(MethodSpec.methodBuilder("fold")
+ .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
+ .build())
+ .build();
+ assertThat(toString(roshambo)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.Override;\n"
+ + "\n"
+ + "public enum Tortilla {\n"
+ + " CORN {\n"
+ + " @Override\n"
+ + " public void fold() {\n"
+ + " }\n"
+ + " };\n"
+ + "\n"
+ + " public abstract void fold();\n"
+ + "}\n");
+ }
+
+ @Test public void enumConstantsRequired() throws Exception {
+ try {
+ TypeSpec.enumBuilder("Roshambo")
+ .build();
+ fail();
+ } catch (IllegalArgumentException expected) {
+ }
+ }
+
+ @Test public void onlyEnumsMayHaveEnumConstants() throws Exception {
+ try {
+ TypeSpec.classBuilder("Roshambo")
+ .addEnumConstant("ROCK")
+ .build();
+ fail();
+ } catch (IllegalStateException expected) {
+ }
+ }
+
+ @Test public void enumWithMembersButNoConstructorCall() throws Exception {
+ TypeSpec roshambo = TypeSpec.enumBuilder("Roshambo")
+ .addEnumConstant("SPOCK", TypeSpec.anonymousClassBuilder("")
+ .addMethod(MethodSpec.methodBuilder("toString")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC)
+ .returns(String.class)
+ .addCode("return $S;\n", "west side")
+ .build())
+ .build())
+ .build();
+ assertThat(toString(roshambo)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.Override;\n"
+ + "import java.lang.String;\n"
+ + "\n"
+ + "enum Roshambo {\n"
+ + " SPOCK {\n"
+ + " @Override\n"
+ + " public String toString() {\n"
+ + " return \"west side\";\n"
+ + " }\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ /** https://github.com/square/javapoet/issues/253 */
+ @Test public void enumWithAnnotatedValues() throws Exception {
+ TypeSpec roshambo = TypeSpec.enumBuilder("Roshambo")
+ .addModifiers(Modifier.PUBLIC)
+ .addEnumConstant("ROCK", TypeSpec.anonymousClassBuilder("")
+ .addAnnotation(Deprecated.class)
+ .build())
+ .addEnumConstant("PAPER")
+ .addEnumConstant("SCISSORS")
+ .build();
+ assertThat(toString(roshambo)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.Deprecated;\n"
+ + "\n"
+ + "public enum Roshambo {\n"
+ + " @Deprecated\n"
+ + " ROCK,\n"
+ + "\n"
+ + " PAPER,\n"
+ + "\n"
+ + " SCISSORS\n"
+ + "}\n");
+ }
+
+ @Test public void methodThrows() throws Exception {
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addModifiers(Modifier.ABSTRACT)
+ .addMethod(MethodSpec.methodBuilder("throwOne")
+ .addException(IOException.class)
+ .build())
+ .addMethod(MethodSpec.methodBuilder("throwTwo")
+ .addException(IOException.class)
+ .addException(ClassName.get(tacosPackage, "SourCreamException"))
+ .build())
+ .addMethod(MethodSpec.methodBuilder("abstractThrow")
+ .addModifiers(Modifier.ABSTRACT)
+ .addException(IOException.class)
+ .build())
+ .addMethod(MethodSpec.methodBuilder("nativeThrow")
+ .addModifiers(Modifier.NATIVE)
+ .addException(IOException.class)
+ .build())
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.io.IOException;\n"
+ + "\n"
+ + "abstract class Taco {\n"
+ + " void throwOne() throws IOException {\n"
+ + " }\n"
+ + "\n"
+ + " void throwTwo() throws IOException, SourCreamException {\n"
+ + " }\n"
+ + "\n"
+ + " abstract void abstractThrow() throws IOException;\n"
+ + "\n"
+ + " native void nativeThrow() throws IOException;\n"
+ + "}\n");
+ }
+
+ @Test public void typeVariables() throws Exception {
+ TypeVariableName t = TypeVariableName.get("T");
+ TypeVariableName p = TypeVariableName.get("P", Number.class);
+ ClassName location = ClassName.get(tacosPackage, "Location");
+ TypeSpec typeSpec = TypeSpec.classBuilder("Location")
+ .addTypeVariable(t)
+ .addTypeVariable(p)
+ .addSuperinterface(ParameterizedTypeName.get(ClassName.get(Comparable.class), p))
+ .addField(t, "label")
+ .addField(p, "x")
+ .addField(p, "y")
+ .addMethod(MethodSpec.methodBuilder("compareTo")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC)
+ .returns(int.class)
+ .addParameter(p, "p")
+ .addCode("return 0;\n")
+ .build())
+ .addMethod(MethodSpec.methodBuilder("of")
+ .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
+ .addTypeVariable(t)
+ .addTypeVariable(p)
+ .returns(ParameterizedTypeName.get(location, t, p))
+ .addParameter(t, "label")
+ .addParameter(p, "x")
+ .addParameter(p, "y")
+ .addCode("throw new $T($S);\n", UnsupportedOperationException.class, "TODO")
+ .build())
+ .build();
+ assertThat(toString(typeSpec)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.Comparable;\n"
+ + "import java.lang.Number;\n"
+ + "import java.lang.Override;\n"
+ + "import java.lang.UnsupportedOperationException;\n"
+ + "\n"
+ + "class Location<T, P extends Number> implements Comparable<P> {\n"
+ + " T label;\n"
+ + "\n"
+ + " P x;\n"
+ + "\n"
+ + " P y;\n"
+ + "\n"
+ + " @Override\n"
+ + " public int compareTo(P p) {\n"
+ + " return 0;\n"
+ + " }\n"
+ + "\n"
+ + " public static <T, P extends Number> Location<T, P> of(T label, P x, P y) {\n"
+ + " throw new UnsupportedOperationException(\"TODO\");\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void typeVariableWithBounds() {
+ AnnotationSpec a = AnnotationSpec.builder(ClassName.get("com.squareup.tacos", "A")).build();
+ TypeVariableName p = TypeVariableName.get("P", Number.class);
+ TypeVariableName q = (TypeVariableName) TypeVariableName.get("Q", Number.class).annotated(a);
+ TypeSpec typeSpec = TypeSpec.classBuilder("Location")
+ .addTypeVariable(p.withBounds(Comparable.class))
+ .addTypeVariable(q.withBounds(Comparable.class))
+ .addField(p, "x")
+ .addField(q, "y")
+ .build();
+ assertThat(toString(typeSpec)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.Comparable;\n"
+ + "import java.lang.Number;\n"
+ + "\n"
+ + "class Location<P extends Number & Comparable, @A Q extends Number & Comparable> {\n"
+ + " P x;\n"
+ + "\n"
+ + " @A Q y;\n"
+ + "}\n");
+ }
+
+ @Test public void classImplementsExtends() throws Exception {
+ ClassName taco = ClassName.get(tacosPackage, "Taco");
+ ClassName food = ClassName.get("com.squareup.tacos", "Food");
+ TypeSpec typeSpec = TypeSpec.classBuilder("Taco")
+ .addModifiers(Modifier.ABSTRACT)
+ .superclass(ParameterizedTypeName.get(ClassName.get(AbstractSet.class), food))
+ .addSuperinterface(Serializable.class)
+ .addSuperinterface(ParameterizedTypeName.get(ClassName.get(Comparable.class), taco))
+ .build();
+ assertThat(toString(typeSpec)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.io.Serializable;\n"
+ + "import java.lang.Comparable;\n"
+ + "import java.util.AbstractSet;\n"
+ + "\n"
+ + "abstract class Taco extends AbstractSet<Food> "
+ + "implements Serializable, Comparable<Taco> {\n"
+ + "}\n");
+ }
+
+ @Test public void classImplementsNestedClass() throws Exception {
+ ClassName outer = ClassName.get(tacosPackage, "Outer");
+ ClassName inner = outer.nestedClass("Inner");
+ ClassName callable = ClassName.get(Callable.class);
+ TypeSpec typeSpec = TypeSpec.classBuilder("Outer")
+ .superclass(ParameterizedTypeName.get(callable,
+ inner))
+ .addType(TypeSpec.classBuilder("Inner")
+ .addModifiers(Modifier.STATIC)
+ .build())
+ .build();
+
+ assertThat(toString(typeSpec)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.util.concurrent.Callable;\n"
+ + "\n"
+ + "class Outer extends Callable<Outer.Inner> {\n"
+ + " static class Inner {\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void enumImplements() throws Exception {
+ TypeSpec typeSpec = TypeSpec.enumBuilder("Food")
+ .addSuperinterface(Serializable.class)
+ .addSuperinterface(Cloneable.class)
+ .addEnumConstant("LEAN_GROUND_BEEF")
+ .addEnumConstant("SHREDDED_CHEESE")
+ .build();
+ assertThat(toString(typeSpec)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.io.Serializable;\n"
+ + "import java.lang.Cloneable;\n"
+ + "\n"
+ + "enum Food implements Serializable, Cloneable {\n"
+ + " LEAN_GROUND_BEEF,\n"
+ + "\n"
+ + " SHREDDED_CHEESE\n"
+ + "}\n");
+ }
+
+ @Test public void interfaceExtends() throws Exception {
+ ClassName taco = ClassName.get(tacosPackage, "Taco");
+ TypeSpec typeSpec = TypeSpec.interfaceBuilder("Taco")
+ .addSuperinterface(Serializable.class)
+ .addSuperinterface(ParameterizedTypeName.get(ClassName.get(Comparable.class), taco))
+ .build();
+ assertThat(toString(typeSpec)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.io.Serializable;\n"
+ + "import java.lang.Comparable;\n"
+ + "\n"
+ + "interface Taco extends Serializable, Comparable<Taco> {\n"
+ + "}\n");
+ }
+
+ @Test public void nestedClasses() throws Exception {
+ ClassName taco = ClassName.get(tacosPackage, "Combo", "Taco");
+ ClassName topping = ClassName.get(tacosPackage, "Combo", "Taco", "Topping");
+ ClassName chips = ClassName.get(tacosPackage, "Combo", "Chips");
+ ClassName sauce = ClassName.get(tacosPackage, "Combo", "Sauce");
+ TypeSpec typeSpec = TypeSpec.classBuilder("Combo")
+ .addField(taco, "taco")
+ .addField(chips, "chips")
+ .addType(TypeSpec.classBuilder(taco.simpleName())
+ .addModifiers(Modifier.STATIC)
+ .addField(ParameterizedTypeName.get(ClassName.get(List.class), topping), "toppings")
+ .addField(sauce, "sauce")
+ .addType(TypeSpec.enumBuilder(topping.simpleName())
+ .addEnumConstant("SHREDDED_CHEESE")
+ .addEnumConstant("LEAN_GROUND_BEEF")
+ .build())
+ .build())
+ .addType(TypeSpec.classBuilder(chips.simpleName())
+ .addModifiers(Modifier.STATIC)
+ .addField(topping, "topping")
+ .addField(sauce, "dippingSauce")
+ .build())
+ .addType(TypeSpec.enumBuilder(sauce.simpleName())
+ .addEnumConstant("SOUR_CREAM")
+ .addEnumConstant("SALSA")
+ .addEnumConstant("QUESO")
+ .addEnumConstant("MILD")
+ .addEnumConstant("FIRE")
+ .build())
+ .build();
+
+ assertThat(toString(typeSpec)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.util.List;\n"
+ + "\n"
+ + "class Combo {\n"
+ + " Taco taco;\n"
+ + "\n"
+ + " Chips chips;\n"
+ + "\n"
+ + " static class Taco {\n"
+ + " List<Topping> toppings;\n"
+ + "\n"
+ + " Sauce sauce;\n"
+ + "\n"
+ + " enum Topping {\n"
+ + " SHREDDED_CHEESE,\n"
+ + "\n"
+ + " LEAN_GROUND_BEEF\n"
+ + " }\n"
+ + " }\n"
+ + "\n"
+ + " static class Chips {\n"
+ + " Taco.Topping topping;\n"
+ + "\n"
+ + " Sauce dippingSauce;\n"
+ + " }\n"
+ + "\n"
+ + " enum Sauce {\n"
+ + " SOUR_CREAM,\n"
+ + "\n"
+ + " SALSA,\n"
+ + "\n"
+ + " QUESO,\n"
+ + "\n"
+ + " MILD,\n"
+ + "\n"
+ + " FIRE\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void annotation() throws Exception {
+ TypeSpec annotation = TypeSpec.annotationBuilder("MyAnnotation")
+ .addModifiers(Modifier.PUBLIC)
+ .addMethod(MethodSpec.methodBuilder("test")
+ .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
+ .defaultValue("$L", 0)
+ .returns(int.class)
+ .build())
+ .build();
+
+ assertThat(toString(annotation)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "public @interface MyAnnotation {\n"
+ + " int test() default 0;\n"
+ + "}\n"
+ );
+ }
+
+ @Test public void innerAnnotationInAnnotationDeclaration() throws Exception {
+ TypeSpec bar = TypeSpec.annotationBuilder("Bar")
+ .addMethod(MethodSpec.methodBuilder("value")
+ .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
+ .defaultValue("@$T", Deprecated.class)
+ .returns(Deprecated.class)
+ .build())
+ .build();
+
+ assertThat(toString(bar)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.Deprecated;\n"
+ + "\n"
+ + "@interface Bar {\n"
+ + " Deprecated value() default @Deprecated;\n"
+ + "}\n"
+ );
+ }
+
+ @Test public void annotationWithFields() {
+ FieldSpec field = FieldSpec.builder(int.class, "FOO")
+ .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)
+ .initializer("$L", 101)
+ .build();
+
+ TypeSpec anno = TypeSpec.annotationBuilder("Anno")
+ .addField(field)
+ .build();
+
+ assertThat(toString(anno)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "@interface Anno {\n"
+ + " int FOO = 101;\n"
+ + "}\n"
+ );
+ }
+
+ @Test
+ public void classCannotHaveDefaultValueForMethod() throws Exception {
+ try {
+ TypeSpec.classBuilder("Tacos")
+ .addMethod(MethodSpec.methodBuilder("test")
+ .addModifiers(Modifier.PUBLIC)
+ .defaultValue("0")
+ .returns(int.class)
+ .build())
+ .build();
+ fail();
+ } catch (IllegalStateException expected) {
+ }
+ }
+
+ @Test
+ public void classCannotHaveDefaultMethods() throws Exception {
+ try {
+ TypeSpec.classBuilder("Tacos")
+ .addMethod(MethodSpec.methodBuilder("test")
+ .addModifiers(Modifier.PUBLIC, Modifier.DEFAULT)
+ .returns(int.class)
+ .addCode(CodeBlock.builder().addStatement("return 0").build())
+ .build())
+ .build();
+ fail();
+ } catch (IllegalStateException expected) {
+ }
+ }
+
+ @Test
+ public void interfaceStaticMethods() throws Exception {
+ TypeSpec bar = TypeSpec.interfaceBuilder("Tacos")
+ .addMethod(MethodSpec.methodBuilder("test")
+ .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
+ .returns(int.class)
+ .addCode(CodeBlock.builder().addStatement("return 0").build())
+ .build())
+ .build();
+
+ assertThat(toString(bar)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "interface Tacos {\n"
+ + " static int test() {\n"
+ + " return 0;\n"
+ + " }\n"
+ + "}\n"
+ );
+ }
+
+ @Test
+ public void interfaceDefaultMethods() throws Exception {
+ TypeSpec bar = TypeSpec.interfaceBuilder("Tacos")
+ .addMethod(MethodSpec.methodBuilder("test")
+ .addModifiers(Modifier.PUBLIC, Modifier.DEFAULT)
+ .returns(int.class)
+ .addCode(CodeBlock.builder().addStatement("return 0").build())
+ .build())
+ .build();
+
+ assertThat(toString(bar)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "interface Tacos {\n"
+ + " default int test() {\n"
+ + " return 0;\n"
+ + " }\n"
+ + "}\n"
+ );
+ }
+
+ @Test public void referencedAndDeclaredSimpleNamesConflict() throws Exception {
+ FieldSpec internalTop = FieldSpec.builder(
+ ClassName.get(tacosPackage, "Top"), "internalTop").build();
+ FieldSpec internalBottom = FieldSpec.builder(
+ ClassName.get(tacosPackage, "Top", "Middle", "Bottom"), "internalBottom").build();
+ FieldSpec externalTop = FieldSpec.builder(
+ ClassName.get(donutsPackage, "Top"), "externalTop").build();
+ FieldSpec externalBottom = FieldSpec.builder(
+ ClassName.get(donutsPackage, "Bottom"), "externalBottom").build();
+ TypeSpec top = TypeSpec.classBuilder("Top")
+ .addField(internalTop)
+ .addField(internalBottom)
+ .addField(externalTop)
+ .addField(externalBottom)
+ .addType(TypeSpec.classBuilder("Middle")
+ .addField(internalTop)
+ .addField(internalBottom)
+ .addField(externalTop)
+ .addField(externalBottom)
+ .addType(TypeSpec.classBuilder("Bottom")
+ .addField(internalTop)
+ .addField(internalBottom)
+ .addField(externalTop)
+ .addField(externalBottom)
+ .build())
+ .build())
+ .build();
+ assertThat(toString(top)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import com.squareup.donuts.Bottom;\n"
+ + "\n"
+ + "class Top {\n"
+ + " Top internalTop;\n"
+ + "\n"
+ + " Middle.Bottom internalBottom;\n"
+ + "\n"
+ + " com.squareup.donuts.Top externalTop;\n"
+ + "\n"
+ + " Bottom externalBottom;\n"
+ + "\n"
+ + " class Middle {\n"
+ + " Top internalTop;\n"
+ + "\n"
+ + " Bottom internalBottom;\n"
+ + "\n"
+ + " com.squareup.donuts.Top externalTop;\n"
+ + "\n"
+ + " com.squareup.donuts.Bottom externalBottom;\n"
+ + "\n"
+ + " class Bottom {\n"
+ + " Top internalTop;\n"
+ + "\n"
+ + " Bottom internalBottom;\n"
+ + "\n"
+ + " com.squareup.donuts.Top externalTop;\n"
+ + "\n"
+ + " com.squareup.donuts.Bottom externalBottom;\n"
+ + " }\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void simpleNamesConflictInThisAndOtherPackage() throws Exception {
+ FieldSpec internalOther = FieldSpec.builder(
+ ClassName.get(tacosPackage, "Other"), "internalOther").build();
+ FieldSpec externalOther = FieldSpec.builder(
+ ClassName.get(donutsPackage, "Other"), "externalOther").build();
+ TypeSpec gen = TypeSpec.classBuilder("Gen")
+ .addField(internalOther)
+ .addField(externalOther)
+ .build();
+ assertThat(toString(gen)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "class Gen {\n"
+ + " Other internalOther;\n"
+ + "\n"
+ + " com.squareup.donuts.Other externalOther;\n"
+ + "}\n");
+ }
+
+ @Test public void originatingElementsIncludesThoseOfNestedTypes() {
+ Element outerElement = Mockito.mock(Element.class);
+ Element innerElement = Mockito.mock(Element.class);
+ TypeSpec outer = TypeSpec.classBuilder("Outer")
+ .addOriginatingElement(outerElement)
+ .addType(TypeSpec.classBuilder("Inner")
+ .addOriginatingElement(innerElement)
+ .build())
+ .build();
+ assertThat(outer.originatingElements).containsExactly(outerElement, innerElement);
+ }
+
+ @Test public void intersectionType() {
+ TypeVariableName typeVariable = TypeVariableName.get("T", Comparator.class, Serializable.class);
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addMethod(MethodSpec.methodBuilder("getComparator")
+ .addTypeVariable(typeVariable)
+ .returns(typeVariable)
+ .addCode("return null;\n")
+ .build())
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.io.Serializable;\n"
+ + "import java.util.Comparator;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " <T extends Comparator & Serializable> T getComparator() {\n"
+ + " return null;\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void arrayType() {
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addField(int[].class, "ints")
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " int[] ints;\n"
+ + "}\n");
+ }
+
+ @Test public void javadoc() {
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addJavadoc("A hard or soft tortilla, loosely folded and filled with whatever {@link \n")
+ .addJavadoc("{@link $T random} tex-mex stuff we could find in the pantry\n", Random.class)
+ .addJavadoc(CodeBlock.of("and some {@link $T} cheese.\n", String.class))
+ .addField(FieldSpec.builder(boolean.class, "soft")
+ .addJavadoc("True for a soft flour tortilla; false for a crunchy corn tortilla.\n")
+ .build())
+ .addMethod(MethodSpec.methodBuilder("refold")
+ .addJavadoc("Folds the back of this taco to reduce sauce leakage.\n"
+ + "\n"
+ + "<p>For {@link $T#KOREAN}, the front may also be folded.\n", Locale.class)
+ .addParameter(Locale.class, "locale")
+ .build())
+ .build();
+ // Mentioning a type in Javadoc will not cause an import to be added (java.util.Random here),
+ // but the short name will be used if it's already imported (java.util.Locale here).
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.util.Locale;\n"
+ + "\n"
+ + "/**\n"
+ + " * A hard or soft tortilla, loosely folded and filled with whatever {@link \n"
+ + " * {@link java.util.Random random} tex-mex stuff we could find in the pantry\n"
+ + " * and some {@link java.lang.String} cheese.\n"
+ + " */\n"
+ + "class Taco {\n"
+ + " /**\n"
+ + " * True for a soft flour tortilla; false for a crunchy corn tortilla.\n"
+ + " */\n"
+ + " boolean soft;\n"
+ + "\n"
+ + " /**\n"
+ + " * Folds the back of this taco to reduce sauce leakage.\n"
+ + " *\n"
+ + " * <p>For {@link Locale#KOREAN}, the front may also be folded.\n"
+ + " */\n"
+ + " void refold(Locale locale) {\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void annotationsInAnnotations() throws Exception {
+ ClassName beef = ClassName.get(tacosPackage, "Beef");
+ ClassName chicken = ClassName.get(tacosPackage, "Chicken");
+ ClassName option = ClassName.get(tacosPackage, "Option");
+ ClassName mealDeal = ClassName.get(tacosPackage, "MealDeal");
+ TypeSpec menu = TypeSpec.classBuilder("Menu")
+ .addAnnotation(AnnotationSpec.builder(mealDeal)
+ .addMember("price", "$L", 500)
+ .addMember("options", "$L", AnnotationSpec.builder(option)
+ .addMember("name", "$S", "taco")
+ .addMember("meat", "$T.class", beef)
+ .build())
+ .addMember("options", "$L", AnnotationSpec.builder(option)
+ .addMember("name", "$S", "quesadilla")
+ .addMember("meat", "$T.class", chicken)
+ .build())
+ .build())
+ .build();
+ assertThat(toString(menu)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "@MealDeal(\n"
+ + " price = 500,\n"
+ + " options = {\n"
+ + " @Option(name = \"taco\", meat = Beef.class),\n"
+ + " @Option(name = \"quesadilla\", meat = Chicken.class)\n"
+ + " }\n"
+ + ")\n"
+ + "class Menu {\n"
+ + "}\n");
+ }
+
+ @Test public void varargs() throws Exception {
+ TypeSpec taqueria = TypeSpec.classBuilder("Taqueria")
+ .addMethod(MethodSpec.methodBuilder("prepare")
+ .addParameter(int.class, "workers")
+ .addParameter(Runnable[].class, "jobs")
+ .varargs()
+ .build())
+ .build();
+ assertThat(toString(taqueria)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.Runnable;\n"
+ + "\n"
+ + "class Taqueria {\n"
+ + " void prepare(int workers, Runnable... jobs) {\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void codeBlocks() throws Exception {
+ CodeBlock ifBlock = CodeBlock.builder()
+ .beginControlFlow("if (!a.equals(b))")
+ .addStatement("return i")
+ .endControlFlow()
+ .build();
+ CodeBlock methodBody = CodeBlock.builder()
+ .addStatement("$T size = $T.min(listA.size(), listB.size())", int.class, Math.class)
+ .beginControlFlow("for ($T i = 0; i < size; i++)", int.class)
+ .addStatement("$T $N = $N.get(i)", String.class, "a", "listA")
+ .addStatement("$T $N = $N.get(i)", String.class, "b", "listB")
+ .add("$L", ifBlock)
+ .endControlFlow()
+ .addStatement("return size")
+ .build();
+ CodeBlock fieldBlock = CodeBlock.builder()
+ .add("$>$>")
+ .add("\n$T.<$T, $T>builder()$>$>", ImmutableMap.class, String.class, String.class)
+ .add("\n.add($S, $S)", '\'', "'")
+ .add("\n.add($S, $S)", '&', "&")
+ .add("\n.add($S, $S)", '<', "<")
+ .add("\n.add($S, $S)", '>', ">")
+ .add("\n.build()$<$<")
+ .add("$<$<")
+ .build();
+ FieldSpec escapeHtml = FieldSpec.builder(ParameterizedTypeName.get(
+ Map.class, String.class, String.class), "ESCAPE_HTML")
+ .addModifiers(Modifier.PRIVATE, Modifier.STATIC, Modifier.FINAL)
+ .initializer(fieldBlock)
+ .build();
+ TypeSpec util = TypeSpec.classBuilder("Util")
+ .addField(escapeHtml)
+ .addMethod(MethodSpec.methodBuilder("commonPrefixLength")
+ .returns(int.class)
+ .addParameter(ParameterizedTypeName.get(List.class, String.class), "listA")
+ .addParameter(ParameterizedTypeName.get(List.class, String.class), "listB")
+ .addCode(methodBody)
+ .build())
+ .build();
+ assertThat(toString(util)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import com.google.common.collect.ImmutableMap;\n"
+ + "import java.lang.Math;\n"
+ + "import java.lang.String;\n"
+ + "import java.util.List;\n"
+ + "import java.util.Map;\n"
+ + "\n"
+ + "class Util {\n"
+ + " private static final Map<String, String> ESCAPE_HTML = \n"
+ + " ImmutableMap.<String, String>builder()\n"
+ + " .add(\"\'\", \"'\")\n"
+ + " .add(\"&\", \"&\")\n"
+ + " .add(\"<\", \"<\")\n"
+ + " .add(\">\", \">\")\n"
+ + " .build();\n"
+ + "\n"
+ + " int commonPrefixLength(List<String> listA, List<String> listB) {\n"
+ + " int size = Math.min(listA.size(), listB.size());\n"
+ + " for (int i = 0; i < size; i++) {\n"
+ + " String a = listA.get(i);\n"
+ + " String b = listB.get(i);\n"
+ + " if (!a.equals(b)) {\n"
+ + " return i;\n"
+ + " }\n"
+ + " }\n"
+ + " return size;\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void indexedElseIf() throws Exception {
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addMethod(MethodSpec.methodBuilder("choices")
+ .beginControlFlow("if ($1L != null || $1L == $2L)", "taco", "otherTaco")
+ .addStatement("$T.out.println($S)", System.class, "only one taco? NOO!")
+ .nextControlFlow("else if ($1L.$3L && $2L.$3L)", "taco", "otherTaco", "isSupreme()")
+ .addStatement("$T.out.println($S)", System.class, "taco heaven")
+ .endControlFlow()
+ .build())
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.System;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " void choices() {\n"
+ + " if (taco != null || taco == otherTaco) {\n"
+ + " System.out.println(\"only one taco? NOO!\");\n"
+ + " } else if (taco.isSupreme() && otherTaco.isSupreme()) {\n"
+ + " System.out.println(\"taco heaven\");\n"
+ + " }\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void elseIf() throws Exception {
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addMethod(MethodSpec.methodBuilder("choices")
+ .beginControlFlow("if (5 < 4) ")
+ .addStatement("$T.out.println($S)", System.class, "wat")
+ .nextControlFlow("else if (5 < 6)")
+ .addStatement("$T.out.println($S)", System.class, "hello")
+ .endControlFlow()
+ .build())
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.System;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " void choices() {\n"
+ + " if (5 < 4) {\n"
+ + " System.out.println(\"wat\");\n"
+ + " } else if (5 < 6) {\n"
+ + " System.out.println(\"hello\");\n"
+ + " }\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void doWhile() throws Exception {
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addMethod(MethodSpec.methodBuilder("loopForever")
+ .beginControlFlow("do")
+ .addStatement("$T.out.println($S)", System.class, "hello")
+ .endControlFlow("while (5 < 6)")
+ .build())
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.System;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " void loopForever() {\n"
+ + " do {\n"
+ + " System.out.println(\"hello\");\n"
+ + " } while (5 < 6);\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void inlineIndent() throws Exception {
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addMethod(MethodSpec.methodBuilder("inlineIndent")
+ .addCode("if (3 < 4) {\n$>$T.out.println($S);\n$<}\n", System.class, "hello")
+ .build())
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.System;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " void inlineIndent() {\n"
+ + " if (3 < 4) {\n"
+ + " System.out.println(\"hello\");\n"
+ + " }\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void defaultModifiersForInterfaceMembers() throws Exception {
+ TypeSpec taco = TypeSpec.interfaceBuilder("Taco")
+ .addField(FieldSpec.builder(String.class, "SHELL")
+ .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)
+ .initializer("$S", "crunchy corn")
+ .build())
+ .addMethod(MethodSpec.methodBuilder("fold")
+ .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
+ .build())
+ .addType(TypeSpec.classBuilder("Topping")
+ .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
+ .build())
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.String;\n"
+ + "\n"
+ + "interface Taco {\n"
+ + " String SHELL = \"crunchy corn\";\n"
+ + "\n"
+ + " void fold();\n"
+ + "\n"
+ + " class Topping {\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void defaultModifiersForMemberInterfacesAndEnums() throws Exception {
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addType(TypeSpec.classBuilder("Meat")
+ .addModifiers(Modifier.STATIC)
+ .build())
+ .addType(TypeSpec.interfaceBuilder("Tortilla")
+ .addModifiers(Modifier.STATIC)
+ .build())
+ .addType(TypeSpec.enumBuilder("Topping")
+ .addModifiers(Modifier.STATIC)
+ .addEnumConstant("SALSA")
+ .build())
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " static class Meat {\n"
+ + " }\n"
+ + "\n"
+ + " interface Tortilla {\n"
+ + " }\n"
+ + "\n"
+ + " enum Topping {\n"
+ + " SALSA\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void membersOrdering() throws Exception {
+ // Hand out names in reverse-alphabetical order to defend against unexpected sorting.
+ TypeSpec taco = TypeSpec.classBuilder("Members")
+ .addType(TypeSpec.classBuilder("Z").build())
+ .addType(TypeSpec.classBuilder("Y").build())
+ .addField(String.class, "X", Modifier.STATIC)
+ .addField(String.class, "W")
+ .addField(String.class, "V", Modifier.STATIC)
+ .addField(String.class, "U")
+ .addMethod(MethodSpec.methodBuilder("T").addModifiers(Modifier.STATIC).build())
+ .addMethod(MethodSpec.methodBuilder("S").build())
+ .addMethod(MethodSpec.methodBuilder("R").addModifiers(Modifier.STATIC).build())
+ .addMethod(MethodSpec.methodBuilder("Q").build())
+ .addMethod(MethodSpec.constructorBuilder().addParameter(int.class, "p").build())
+ .addMethod(MethodSpec.constructorBuilder().addParameter(long.class, "o").build())
+ .build();
+ // Static fields, instance fields, constructors, methods, classes.
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.String;\n"
+ + "\n"
+ + "class Members {\n"
+ + " static String X;\n"
+ + "\n"
+ + " static String V;\n"
+ + "\n"
+ + " String W;\n"
+ + "\n"
+ + " String U;\n"
+ + "\n"
+ + " Members(int p) {\n"
+ + " }\n"
+ + "\n"
+ + " Members(long o) {\n"
+ + " }\n"
+ + "\n"
+ + " static void T() {\n"
+ + " }\n"
+ + "\n"
+ + " void S() {\n"
+ + " }\n"
+ + "\n"
+ + " static void R() {\n"
+ + " }\n"
+ + "\n"
+ + " void Q() {\n"
+ + " }\n"
+ + "\n"
+ + " class Z {\n"
+ + " }\n"
+ + "\n"
+ + " class Y {\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void nativeMethods() throws Exception {
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addMethod(MethodSpec.methodBuilder("nativeInt")
+ .addModifiers(Modifier.NATIVE)
+ .returns(int.class)
+ .build())
+ // GWT JSNI
+ .addMethod(MethodSpec.methodBuilder("alert")
+ .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.NATIVE)
+ .addParameter(String.class, "msg")
+ .addCode(CodeBlock.builder()
+ .add(" /*-{\n")
+ .indent()
+ .addStatement("$$wnd.alert(msg)")
+ .unindent()
+ .add("}-*/")
+ .build())
+ .build())
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.String;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " native int nativeInt();\n"
+ + "\n"
+ + " public static native void alert(String msg) /*-{\n"
+ + " $wnd.alert(msg);\n"
+ + " }-*/;\n"
+ + "}\n");
+ }
+
+ @Test public void nullStringLiteral() throws Exception {
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addField(FieldSpec.builder(String.class, "NULL")
+ .initializer("$S", (Object) null)
+ .build())
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.String;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " String NULL = null;\n"
+ + "}\n");
+ }
+
+ @Test public void annotationToString() throws Exception {
+ AnnotationSpec annotation = AnnotationSpec.builder(SuppressWarnings.class)
+ .addMember("value", "$S", "unused")
+ .build();
+ assertThat(annotation.toString()).isEqualTo("@java.lang.SuppressWarnings(\"unused\")");
+ }
+
+ @Test public void codeBlockToString() throws Exception {
+ CodeBlock codeBlock = CodeBlock.builder()
+ .addStatement("$T $N = $S.substring(0, 3)", String.class, "s", "taco")
+ .build();
+ assertThat(codeBlock.toString()).isEqualTo("java.lang.String s = \"taco\".substring(0, 3);\n");
+ }
+
+ @Test public void codeBlockAddStatementOfCodeBlockToString() throws Exception {
+ CodeBlock contents = CodeBlock.of("$T $N = $S.substring(0, 3)", String.class, "s", "taco");
+ CodeBlock statement = CodeBlock.builder().addStatement(contents).build();
+ assertThat(statement.toString()).isEqualTo("java.lang.String s = \"taco\".substring(0, 3);\n");
+ }
+
+ @Test public void fieldToString() throws Exception {
+ FieldSpec field = FieldSpec.builder(String.class, "s", Modifier.FINAL)
+ .initializer("$S.substring(0, 3)", "taco")
+ .build();
+ assertThat(field.toString())
+ .isEqualTo("final java.lang.String s = \"taco\".substring(0, 3);\n");
+ }
+
+ @Test public void methodToString() throws Exception {
+ MethodSpec method = MethodSpec.methodBuilder("toString")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC)
+ .returns(String.class)
+ .addStatement("return $S", "taco")
+ .build();
+ assertThat(method.toString()).isEqualTo(""
+ + "@java.lang.Override\n"
+ + "public java.lang.String toString() {\n"
+ + " return \"taco\";\n"
+ + "}\n");
+ }
+
+ @Test public void constructorToString() throws Exception {
+ MethodSpec constructor = MethodSpec.constructorBuilder()
+ .addModifiers(Modifier.PUBLIC)
+ .addParameter(ClassName.get(tacosPackage, "Taco"), "taco")
+ .addStatement("this.$N = $N", "taco", "taco")
+ .build();
+ assertThat(constructor.toString()).isEqualTo(""
+ + "public Constructor(com.squareup.tacos.Taco taco) {\n"
+ + " this.taco = taco;\n"
+ + "}\n");
+ }
+
+ @Test public void parameterToString() throws Exception {
+ ParameterSpec parameter = ParameterSpec.builder(ClassName.get(tacosPackage, "Taco"), "taco")
+ .addModifiers(Modifier.FINAL)
+ .addAnnotation(ClassName.get("javax.annotation", "Nullable"))
+ .build();
+ assertThat(parameter.toString())
+ .isEqualTo("@javax.annotation.Nullable final com.squareup.tacos.Taco taco");
+ }
+
+ @Test public void classToString() throws Exception {
+ TypeSpec type = TypeSpec.classBuilder("Taco")
+ .build();
+ assertThat(type.toString()).isEqualTo(""
+ + "class Taco {\n"
+ + "}\n");
+ }
+
+ @Test public void anonymousClassToString() throws Exception {
+ TypeSpec type = TypeSpec.anonymousClassBuilder("")
+ .addSuperinterface(Runnable.class)
+ .addMethod(MethodSpec.methodBuilder("run")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC)
+ .build())
+ .build();
+ assertThat(type.toString()).isEqualTo(""
+ + "new java.lang.Runnable() {\n"
+ + " @java.lang.Override\n"
+ + " public void run() {\n"
+ + " }\n"
+ + "}");
+ }
+
+ @Test public void interfaceClassToString() throws Exception {
+ TypeSpec type = TypeSpec.interfaceBuilder("Taco")
+ .build();
+ assertThat(type.toString()).isEqualTo(""
+ + "interface Taco {\n"
+ + "}\n");
+ }
+
+ @Test public void annotationDeclarationToString() throws Exception {
+ TypeSpec type = TypeSpec.annotationBuilder("Taco")
+ .build();
+ assertThat(type.toString()).isEqualTo(""
+ + "@interface Taco {\n"
+ + "}\n");
+ }
+
+ private String toString(TypeSpec typeSpec) {
+ return JavaFile.builder(tacosPackage, typeSpec).build().toString();
+ }
+
+ @Test public void multilineStatement() throws Exception {
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addMethod(MethodSpec.methodBuilder("toString")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC)
+ .returns(String.class)
+ .addStatement("return $S\n+ $S\n+ $S\n+ $S\n+ $S",
+ "Taco(", "beef,", "lettuce,", "cheese", ")")
+ .build())
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.Override;\n"
+ + "import java.lang.String;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " @Override\n"
+ + " public String toString() {\n"
+ + " return \"Taco(\"\n"
+ + " + \"beef,\"\n"
+ + " + \"lettuce,\"\n"
+ + " + \"cheese\"\n"
+ + " + \")\";\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void multilineStatementWithAnonymousClass() throws Exception {
+ TypeName stringComparator = ParameterizedTypeName.get(Comparator.class, String.class);
+ TypeName listOfString = ParameterizedTypeName.get(List.class, String.class);
+ TypeSpec prefixComparator = TypeSpec.anonymousClassBuilder("")
+ .addSuperinterface(stringComparator)
+ .addMethod(MethodSpec.methodBuilder("compare")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC)
+ .returns(int.class)
+ .addParameter(String.class, "a")
+ .addParameter(String.class, "b")
+ .addStatement("return a.substring(0, length)\n"
+ + ".compareTo(b.substring(0, length))")
+ .build())
+ .build();
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addMethod(MethodSpec.methodBuilder("comparePrefix")
+ .returns(stringComparator)
+ .addParameter(int.class, "length", Modifier.FINAL)
+ .addStatement("return $L", prefixComparator)
+ .build())
+ .addMethod(MethodSpec.methodBuilder("sortPrefix")
+ .addParameter(listOfString, "list")
+ .addParameter(int.class, "length", Modifier.FINAL)
+ .addStatement("$T.sort(\nlist,\n$L)", Collections.class, prefixComparator)
+ .build())
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.Override;\n"
+ + "import java.lang.String;\n"
+ + "import java.util.Collections;\n"
+ + "import java.util.Comparator;\n"
+ + "import java.util.List;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " Comparator<String> comparePrefix(final int length) {\n"
+ + " return new Comparator<String>() {\n"
+ + " @Override\n"
+ + " public int compare(String a, String b) {\n"
+ + " return a.substring(0, length)\n"
+ + " .compareTo(b.substring(0, length));\n"
+ + " }\n"
+ + " };\n"
+ + " }\n"
+ + "\n"
+ + " void sortPrefix(List<String> list, final int length) {\n"
+ + " Collections.sort(\n"
+ + " list,\n"
+ + " new Comparator<String>() {\n"
+ + " @Override\n"
+ + " public int compare(String a, String b) {\n"
+ + " return a.substring(0, length)\n"
+ + " .compareTo(b.substring(0, length));\n"
+ + " }\n"
+ + " });\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void multilineStrings() throws Exception {
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addField(FieldSpec.builder(String.class, "toppings")
+ .initializer("$S", "shell\nbeef\nlettuce\ncheese\n")
+ .build())
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.String;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " String toppings = \"shell\\n\"\n"
+ + " + \"beef\\n\"\n"
+ + " + \"lettuce\\n\"\n"
+ + " + \"cheese\\n\";\n"
+ + "}\n");
+ }
+
+ @Test public void doubleFieldInitialization() {
+ try {
+ FieldSpec.builder(String.class, "listA")
+ .initializer("foo")
+ .initializer("bar")
+ .build();
+ fail();
+ } catch (IllegalStateException expected) {
+ }
+
+ try {
+ FieldSpec.builder(String.class, "listA")
+ .initializer(CodeBlock.builder().add("foo").build())
+ .initializer(CodeBlock.builder().add("bar").build())
+ .build();
+ fail();
+ } catch (IllegalStateException expected) {
+ }
+ }
+
+ @Test public void nullAnnotationsAddition() {
+ try {
+ TypeSpec.classBuilder("Taco").addAnnotations(null);
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected.getMessage())
+ .isEqualTo("annotationSpecs == null");
+ }
+ }
+
+ @Test public void multipleAnnotationAddition() {
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addAnnotations(Arrays.asList(
+ AnnotationSpec.builder(SuppressWarnings.class)
+ .addMember("value", "$S", "unchecked")
+ .build(),
+ AnnotationSpec.builder(Deprecated.class).build()))
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.Deprecated;\n"
+ + "import java.lang.SuppressWarnings;\n"
+ + "\n"
+ + "@SuppressWarnings(\"unchecked\")\n"
+ + "@Deprecated\n"
+ + "class Taco {\n"
+ + "}\n");
+ }
+
+ @Test public void nullFieldsAddition() {
+ try {
+ TypeSpec.classBuilder("Taco").addFields(null);
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected.getMessage())
+ .isEqualTo("fieldSpecs == null");
+ }
+ }
+
+ @Test public void multipleFieldAddition() {
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addFields(Arrays.asList(
+ FieldSpec.builder(int.class, "ANSWER", Modifier.STATIC, Modifier.FINAL).build(),
+ FieldSpec.builder(BigDecimal.class, "price", Modifier.PRIVATE).build()))
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.math.BigDecimal;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " static final int ANSWER;\n"
+ + "\n"
+ + " private BigDecimal price;\n"
+ + "}\n");
+ }
+
+ @Test public void nullMethodsAddition() {
+ try {
+ TypeSpec.classBuilder("Taco").addMethods(null);
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected.getMessage())
+ .isEqualTo("methodSpecs == null");
+ }
+ }
+
+ @Test public void multipleMethodAddition() {
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addMethods(Arrays.asList(
+ MethodSpec.methodBuilder("getAnswer")
+ .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
+ .returns(int.class)
+ .addStatement("return $L", 42)
+ .build(),
+ MethodSpec.methodBuilder("getRandomQuantity")
+ .addModifiers(Modifier.PUBLIC)
+ .returns(int.class)
+ .addJavadoc("chosen by fair dice roll ;)")
+ .addStatement("return $L", 4)
+ .build()))
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " public static int getAnswer() {\n"
+ + " return 42;\n"
+ + " }\n"
+ + "\n"
+ + " /**\n"
+ + " * chosen by fair dice roll ;) */\n"
+ + " public int getRandomQuantity() {\n"
+ + " return 4;\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void nullSuperinterfacesAddition() {
+ try {
+ TypeSpec.classBuilder("Taco").addSuperinterfaces(null);
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected.getMessage())
+ .isEqualTo("superinterfaces == null");
+ }
+ }
+
+ @Test public void nullSingleSuperinterfaceAddition() {
+ try {
+ TypeSpec.classBuilder("Taco").addSuperinterface((TypeName) null);
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected.getMessage())
+ .isEqualTo("superinterface == null");
+ }
+ }
+
+ @Test public void nullInSuperinterfaceIterableAddition() {
+ List<TypeName> superinterfaces = new ArrayList<>();
+ superinterfaces.add(TypeName.get(List.class));
+ superinterfaces.add(null);
+
+ try {
+ TypeSpec.classBuilder("Taco").addSuperinterfaces(superinterfaces);
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected.getMessage())
+ .isEqualTo("superinterface == null");
+ }
+ }
+
+ @Test public void multipleSuperinterfaceAddition() {
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addSuperinterfaces(Arrays.asList(
+ TypeName.get(Serializable.class),
+ TypeName.get(EventListener.class)))
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.io.Serializable;\n"
+ + "import java.util.EventListener;\n"
+ + "\n"
+ + "class Taco implements Serializable, EventListener {\n"
+ + "}\n");
+ }
+
+ @Test public void nullModifiersAddition() {
+ try {
+ TypeSpec.classBuilder("Taco").addModifiers((Modifier) null);
+ fail();
+ } catch(IllegalArgumentException expected) {
+ assertThat(expected.getMessage())
+ .isEqualTo("modifiers contain null");
+ }
+ }
+
+ @Test public void nullTypeVariablesAddition() {
+ try {
+ TypeSpec.classBuilder("Taco").addTypeVariables(null);
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected.getMessage())
+ .isEqualTo("typeVariables == null");
+ }
+ }
+
+ @Test public void multipleTypeVariableAddition() {
+ TypeSpec location = TypeSpec.classBuilder("Location")
+ .addTypeVariables(Arrays.asList(
+ TypeVariableName.get("T"),
+ TypeVariableName.get("P", Number.class)))
+ .build();
+ assertThat(toString(location)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.Number;\n"
+ + "\n"
+ + "class Location<T, P extends Number> {\n"
+ + "}\n");
+ }
+
+ @Test public void nullTypesAddition() {
+ try {
+ TypeSpec.classBuilder("Taco").addTypes(null);
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected.getMessage())
+ .isEqualTo("typeSpecs == null");
+ }
+ }
+
+ @Test public void multipleTypeAddition() {
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addTypes(Arrays.asList(
+ TypeSpec.classBuilder("Topping").build(),
+ TypeSpec.classBuilder("Sauce").build()))
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " class Topping {\n"
+ + " }\n"
+ + "\n"
+ + " class Sauce {\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void tryCatch() {
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addMethod(MethodSpec.methodBuilder("addTopping")
+ .addParameter(ClassName.get("com.squareup.tacos", "Topping"), "topping")
+ .beginControlFlow("try")
+ .addCode("/* do something tricky with the topping */\n")
+ .nextControlFlow("catch ($T e)",
+ ClassName.get("com.squareup.tacos", "IllegalToppingException"))
+ .endControlFlow()
+ .build())
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " void addTopping(Topping topping) {\n"
+ + " try {\n"
+ + " /* do something tricky with the topping */\n"
+ + " } catch (IllegalToppingException e) {\n"
+ + " }\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void ifElse() {
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addMethod(
+ MethodSpec.methodBuilder("isDelicious")
+ .addParameter(TypeName.INT, "count")
+ .returns(TypeName.BOOLEAN)
+ .beginControlFlow("if (count > 0)")
+ .addStatement("return true")
+ .nextControlFlow("else")
+ .addStatement("return false")
+ .endControlFlow()
+ .build()
+ )
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " boolean isDelicious(int count) {\n"
+ + " if (count > 0) {\n"
+ + " return true;\n"
+ + " } else {\n"
+ + " return false;\n"
+ + " }\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void literalFromAnything() {
+ Object value = new Object() {
+ @Override public String toString() {
+ return "foo";
+ }
+ };
+ assertThat(CodeBlock.of("$L", value).toString()).isEqualTo("foo");
+ }
+
+ @Test public void nameFromCharSequence() {
+ assertThat(CodeBlock.of("$N", "text").toString()).isEqualTo("text");
+ }
+
+ @Test public void nameFromField() {
+ FieldSpec field = FieldSpec.builder(String.class, "field").build();
+ assertThat(CodeBlock.of("$N", field).toString()).isEqualTo("field");
+ }
+
+ @Test public void nameFromParameter() {
+ ParameterSpec parameter = ParameterSpec.builder(String.class, "parameter").build();
+ assertThat(CodeBlock.of("$N", parameter).toString()).isEqualTo("parameter");
+ }
+
+ @Test public void nameFromMethod() {
+ MethodSpec method = MethodSpec.methodBuilder("method")
+ .addModifiers(Modifier.ABSTRACT)
+ .returns(String.class)
+ .build();
+ assertThat(CodeBlock.of("$N", method).toString()).isEqualTo("method");
+ }
+
+ @Test public void nameFromType() {
+ TypeSpec type = TypeSpec.classBuilder("Type").build();
+ assertThat(CodeBlock.of("$N", type).toString()).isEqualTo("Type");
+ }
+
+ @Test public void nameFromUnsupportedType() {
+ try {
+ CodeBlock.builder().add("$N", String.class);
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("expected name but was " + String.class);
+ }
+ }
+
+ @Test public void stringFromAnything() {
+ Object value = new Object() {
+ @Override public String toString() {
+ return "foo";
+ }
+ };
+ assertThat(CodeBlock.of("$S", value).toString()).isEqualTo("\"foo\"");
+ }
+
+ @Test public void stringFromNull() {
+ assertThat(CodeBlock.of("$S", new Object[] {null}).toString()).isEqualTo("null");
+ }
+
+ @Test public void typeFromTypeName() {
+ TypeName typeName = TypeName.get(String.class);
+ assertThat(CodeBlock.of("$T", typeName).toString()).isEqualTo("java.lang.String");
+ }
+
+ @Test public void typeFromTypeMirror() {
+ TypeMirror mirror = getElement(String.class).asType();
+ assertThat(CodeBlock.of("$T", mirror).toString()).isEqualTo("java.lang.String");
+ }
+
+ @Test public void typeFromTypeElement() {
+ TypeElement element = getElement(String.class);
+ assertThat(CodeBlock.of("$T", element).toString()).isEqualTo("java.lang.String");
+ }
+
+ @Test public void typeFromReflectType() {
+ assertThat(CodeBlock.of("$T", String.class).toString()).isEqualTo("java.lang.String");
+ }
+
+ @Test public void typeFromUnsupportedType() {
+ try {
+ CodeBlock.builder().add("$T", "java.lang.String");
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("expected type but was java.lang.String");
+ }
+ }
+
+ @Test public void tooFewArguments() {
+ try {
+ CodeBlock.builder().add("$S");
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("index 1 for '$S' not in range (received 0 arguments)");
+ }
+ }
+
+ @Test public void unusedArgumentsRelative() {
+ try {
+ CodeBlock.builder().add("$L $L", "a", "b", "c");
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("unused arguments: expected 2, received 3");
+ }
+ }
+
+ @Test public void unusedArgumentsIndexed() {
+ try {
+ CodeBlock.builder().add("$1L $2L", "a", "b", "c");
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("unused argument: $3");
+ }
+ try {
+ CodeBlock.builder().add("$1L $1L $1L", "a", "b", "c");
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("unused arguments: $2, $3");
+ }
+ try {
+ CodeBlock.builder().add("$3L $1L $3L $1L $3L", "a", "b", "c", "d");
+ fail();
+ } catch (IllegalArgumentException expected) {
+ assertThat(expected).hasMessageThat().isEqualTo("unused arguments: $2, $4");
+ }
+ }
+
+ @Test public void superClassOnlyValidForClasses() {
+ try {
+ TypeSpec.annotationBuilder("A").superclass(ClassName.get(Object.class));
+ fail();
+ } catch (IllegalStateException expected) {
+ }
+ try {
+ TypeSpec.enumBuilder("E").superclass(ClassName.get(Object.class));
+ fail();
+ } catch (IllegalStateException expected) {
+ }
+ try {
+ TypeSpec.interfaceBuilder("I").superclass(ClassName.get(Object.class));
+ fail();
+ } catch (IllegalStateException expected) {
+ }
+ }
+
+ @Test public void invalidSuperClass() {
+ try {
+ TypeSpec.classBuilder("foo")
+ .superclass(ClassName.get(List.class))
+ .superclass(ClassName.get(Map.class));
+ fail();
+ } catch (IllegalStateException expected) {
+ }
+ try {
+ TypeSpec.classBuilder("foo")
+ .superclass(TypeName.INT);
+ fail();
+ } catch (IllegalArgumentException expected) {
+ }
+ }
+
+ @Test public void staticCodeBlock() {
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addField(String.class, "foo", Modifier.PRIVATE)
+ .addField(String.class, "FOO", Modifier.PRIVATE, Modifier.STATIC, Modifier.FINAL)
+ .addStaticBlock(CodeBlock.builder()
+ .addStatement("FOO = $S", "FOO")
+ .build())
+ .addMethod(MethodSpec.methodBuilder("toString")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC)
+ .returns(String.class)
+ .addCode("return FOO;\n")
+ .build())
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.Override;\n"
+ + "import java.lang.String;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " private static final String FOO;\n"
+ + "\n"
+ + " static {\n"
+ + " FOO = \"FOO\";\n"
+ + " }\n"
+ + "\n"
+ + " private String foo;\n"
+ + "\n"
+ + " @Override\n"
+ + " public String toString() {\n"
+ + " return FOO;\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void initializerBlockInRightPlace() {
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addField(String.class, "foo", Modifier.PRIVATE)
+ .addField(String.class, "FOO", Modifier.PRIVATE, Modifier.STATIC, Modifier.FINAL)
+ .addStaticBlock(CodeBlock.builder()
+ .addStatement("FOO = $S", "FOO")
+ .build())
+ .addMethod(MethodSpec.constructorBuilder().build())
+ .addMethod(MethodSpec.methodBuilder("toString")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC)
+ .returns(String.class)
+ .addCode("return FOO;\n")
+ .build())
+ .addInitializerBlock(CodeBlock.builder()
+ .addStatement("foo = $S", "FOO")
+ .build())
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.Override;\n"
+ + "import java.lang.String;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " private static final String FOO;\n"
+ + "\n"
+ + " static {\n"
+ + " FOO = \"FOO\";\n"
+ + " }\n"
+ + "\n"
+ + " private String foo;\n"
+ + "\n"
+ + " {\n"
+ + " foo = \"FOO\";\n"
+ + " }\n"
+ + "\n"
+ + " Taco() {\n"
+ + " }\n"
+ + "\n"
+ + " @Override\n"
+ + " public String toString() {\n"
+ + " return FOO;\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void initializersToBuilder() {
+ // Tests if toBuilder() contains correct static and instance initializers
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addField(String.class, "foo", Modifier.PRIVATE)
+ .addField(String.class, "FOO", Modifier.PRIVATE, Modifier.STATIC, Modifier.FINAL)
+ .addStaticBlock(CodeBlock.builder()
+ .addStatement("FOO = $S", "FOO")
+ .build())
+ .addMethod(MethodSpec.constructorBuilder().build())
+ .addMethod(MethodSpec.methodBuilder("toString")
+ .addAnnotation(Override.class)
+ .addModifiers(Modifier.PUBLIC)
+ .returns(String.class)
+ .addCode("return FOO;\n")
+ .build())
+ .addInitializerBlock(CodeBlock.builder()
+ .addStatement("foo = $S", "FOO")
+ .build())
+ .build();
+
+ TypeSpec recreatedTaco = taco.toBuilder().build();
+ assertThat(toString(taco)).isEqualTo(toString(recreatedTaco));
+
+ TypeSpec initializersAdded = taco.toBuilder()
+ .addInitializerBlock(CodeBlock.builder()
+ .addStatement("foo = $S", "instanceFoo")
+ .build())
+ .addStaticBlock(CodeBlock.builder()
+ .addStatement("FOO = $S", "staticFoo")
+ .build())
+ .build();
+
+ assertThat(toString(initializersAdded)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.Override;\n"
+ + "import java.lang.String;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " private static final String FOO;\n"
+ + "\n"
+ + " static {\n"
+ + " FOO = \"FOO\";\n"
+ + " }\n"
+ + " static {\n"
+ + " FOO = \"staticFoo\";\n"
+ + " }\n"
+ + "\n"
+ + " private String foo;\n"
+ + "\n"
+ + " {\n"
+ + " foo = \"FOO\";\n"
+ + " }\n"
+ + " {\n"
+ + " foo = \"instanceFoo\";\n"
+ + " }\n"
+ + "\n"
+ + " Taco() {\n"
+ + " }\n"
+ + "\n"
+ + " @Override\n"
+ + " public String toString() {\n"
+ + " return FOO;\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void initializerBlockUnsupportedExceptionOnInterface() {
+ TypeSpec.Builder interfaceBuilder = TypeSpec.interfaceBuilder("Taco");
+ try {
+ interfaceBuilder.addInitializerBlock(CodeBlock.builder().build());
+ fail("Exception expected");
+ } catch (UnsupportedOperationException e) {
+ }
+ }
+
+ @Test public void initializerBlockUnsupportedExceptionOnAnnotation() {
+ TypeSpec.Builder annotationBuilder = TypeSpec.annotationBuilder("Taco");
+ try {
+ annotationBuilder.addInitializerBlock(CodeBlock.builder().build());
+ fail("Exception expected");
+ } catch (UnsupportedOperationException e) {
+ }
+ }
+
+ @Test public void lineWrapping() {
+ MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder("call");
+ methodBuilder.addCode("$[call(");
+ for (int i = 0; i < 32; i++) {
+ methodBuilder.addParameter(String.class, "s" + i);
+ methodBuilder.addCode(i > 0 ? ",$W$S" : "$S", i);
+ }
+ methodBuilder.addCode(");$]\n");
+
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addMethod(methodBuilder.build())
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "import java.lang.String;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " void call(String s0, String s1, String s2, String s3, String s4, String s5, String s6, String s7,\n"
+ + " String s8, String s9, String s10, String s11, String s12, String s13, String s14, String s15,\n"
+ + " String s16, String s17, String s18, String s19, String s20, String s21, String s22,\n"
+ + " String s23, String s24, String s25, String s26, String s27, String s28, String s29,\n"
+ + " String s30, String s31) {\n"
+ + " call(\"0\", \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \"10\", \"11\", \"12\", \"13\", \"14\", \"15\", \"16\",\n"
+ + " \"17\", \"18\", \"19\", \"20\", \"21\", \"22\", \"23\", \"24\", \"25\", \"26\", \"27\", \"28\", \"29\", \"30\", \"31\");\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void lineWrappingWithZeroWidthSpace() {
+ MethodSpec method = MethodSpec.methodBuilder("call")
+ .addCode("$[iAmSickOfWaitingInLine($Z")
+ .addCode("it, has, been, far, too, long, of, a, wait, and, i, would, like, to, eat, ")
+ .addCode("this, is, a, run, on, sentence")
+ .addCode(");$]\n")
+ .build();
+
+ TypeSpec taco = TypeSpec.classBuilder("Taco")
+ .addMethod(method)
+ .build();
+ assertThat(toString(taco)).isEqualTo(""
+ + "package com.squareup.tacos;\n"
+ + "\n"
+ + "class Taco {\n"
+ + " void call() {\n"
+ + " iAmSickOfWaitingInLine(\n"
+ + " it, has, been, far, too, long, of, a, wait, and, i, would, like, to, eat, this, is, a, run, on, sentence);\n"
+ + " }\n"
+ + "}\n");
+ }
+
+ @Test public void equalsAndHashCode() {
+ TypeSpec a = TypeSpec.interfaceBuilder("taco").build();
+ TypeSpec b = TypeSpec.interfaceBuilder("taco").build();
+ assertThat(a.equals(b)).isTrue();
+ assertThat(a.hashCode()).isEqualTo(b.hashCode());
+ a = TypeSpec.classBuilder("taco").build();
+ b = TypeSpec.classBuilder("taco").build();
+ assertThat(a.equals(b)).isTrue();
+ assertThat(a.hashCode()).isEqualTo(b.hashCode());
+ a = TypeSpec.enumBuilder("taco").addEnumConstant("SALSA").build();
+ b = TypeSpec.enumBuilder("taco").addEnumConstant("SALSA").build();
+ assertThat(a.equals(b)).isTrue();
+ assertThat(a.hashCode()).isEqualTo(b.hashCode());
+ a = TypeSpec.annotationBuilder("taco").build();
+ b = TypeSpec.annotationBuilder("taco").build();
+ assertThat(a.equals(b)).isTrue();
+ assertThat(a.hashCode()).isEqualTo(b.hashCode());
+ }
+
+ @Test public void classNameFactories() {
+ ClassName className = ClassName.get("com.example", "Example");
+ assertThat(TypeSpec.classBuilder(className).build().name).isEqualTo("Example");
+ assertThat(TypeSpec.interfaceBuilder(className).build().name).isEqualTo("Example");
+ assertThat(TypeSpec.enumBuilder(className).addEnumConstant("A").build().name).isEqualTo("Example");
+ assertThat(TypeSpec.annotationBuilder(className).build().name).isEqualTo("Example");
+ }
+}
diff --git a/src/test/java/com/squareup/javapoet/TypesEclipseTest.java b/src/test/java/com/squareup/javapoet/TypesEclipseTest.java
new file mode 100644
index 0000000..2759f17
--- /dev/null
+++ b/src/test/java/com/squareup/javapoet/TypesEclipseTest.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2014 Google, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import static com.google.common.base.Charsets.*;
+import static com.google.common.base.Preconditions.*;
+
+import java.util.Locale;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicReference;
+
+import javax.annotation.processing.AbstractProcessor;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.annotation.processing.Processor;
+import javax.annotation.processing.RoundEnvironment;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.util.Elements;
+import javax.lang.model.util.Types;
+import javax.tools.DiagnosticCollector;
+import javax.tools.JavaCompiler;
+import javax.tools.JavaFileManager;
+import javax.tools.JavaFileObject;
+
+import org.eclipse.jdt.internal.compiler.tool.EclipseCompiler;
+import org.junit.Rule;
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.junit.runners.model.Statement;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+
+@RunWith(JUnit4.class)
+public final class TypesEclipseTest extends AbstractTypesTest {
+ /**
+ * A {@link JUnit4} {@link Rule} that executes tests such that a instances of {@link Elements} and
+ * {@link Types} are available during execution.
+ *
+ * <p>To use this rule in a test, just add the following field: <pre> {@code
+ * @Rule public CompilationRule compilationRule = new CompilationRule();}
+ *
+ * @author Gregory Kick
+ */
+ public static final class CompilationRule implements TestRule {
+ private Elements elements;
+ private Types types;
+
+ @Override
+ public Statement apply(final Statement base, Description description) {
+ return new Statement() {
+ @Override public void evaluate() throws Throwable {
+ final AtomicReference<Throwable> thrown = new AtomicReference<>();
+ boolean successful = compile(ImmutableList.of(new AbstractProcessor() {
+ @Override
+ public SourceVersion getSupportedSourceVersion() {
+ return SourceVersion.latest();
+ }
+
+ @Override
+ public Set<String> getSupportedAnnotationTypes() {
+ return ImmutableSet.of("*");
+ }
+
+ @Override
+ public synchronized void init(ProcessingEnvironment processingEnv) {
+ super.init(processingEnv);
+ elements = processingEnv.getElementUtils();
+ types = processingEnv.getTypeUtils();
+ }
+
+ @Override
+ public boolean process(Set<? extends TypeElement> annotations,
+ RoundEnvironment roundEnv) {
+ // just run the test on the last round after compilation is over
+ if (roundEnv.processingOver()) {
+ try {
+ base.evaluate();
+ } catch (Throwable e) {
+ thrown.set(e);
+ }
+ }
+ return false;
+ }
+ }));
+ checkState(successful);
+ Throwable t = thrown.get();
+ if (t != null) {
+ throw t;
+ }
+ }
+ };
+ }
+
+ /**
+ * Returns the {@link Elements} instance associated with the current execution of the rule.
+ *
+ * @throws IllegalStateException if this method is invoked outside the execution of the rule.
+ */
+ public Elements getElements() {
+ checkState(elements != null, "Not running within the rule");
+ return elements;
+ }
+
+ /**
+ * Returns the {@link Types} instance associated with the current execution of the rule.
+ *
+ * @throws IllegalStateException if this method is invoked outside the execution of the rule.
+ */
+ public Types getTypes() {
+ checkState(elements != null, "Not running within the rule");
+ return types;
+ }
+
+ static private boolean compile(Iterable<? extends Processor> processors) {
+ JavaCompiler compiler = new EclipseCompiler();
+ DiagnosticCollector<JavaFileObject> diagnosticCollector =
+ new DiagnosticCollector<>();
+ JavaFileManager fileManager = compiler.getStandardFileManager(diagnosticCollector, Locale.getDefault(), UTF_8);
+ JavaCompiler.CompilationTask task = compiler.getTask(
+ null,
+ fileManager,
+ diagnosticCollector,
+ ImmutableSet.of(),
+ ImmutableSet.of(TypesEclipseTest.class.getCanonicalName()),
+ ImmutableSet.of());
+ task.setProcessors(processors);
+ return task.call();
+ }
+ }
+
+ @Rule public final CompilationRule compilation = new CompilationRule();
+
+ @Override
+ protected Elements getElements() {
+ return compilation.getElements();
+ }
+
+ @Override
+ protected Types getTypes() {
+ return compilation.getTypes();
+ }
+}
diff --git a/src/test/java/com/squareup/javapoet/TypesTest.java b/src/test/java/com/squareup/javapoet/TypesTest.java
new file mode 100644
index 0000000..2455ae5
--- /dev/null
+++ b/src/test/java/com/squareup/javapoet/TypesTest.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2014 Google, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import javax.lang.model.util.Elements;
+import javax.lang.model.util.Types;
+
+import org.junit.Rule;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import com.google.testing.compile.CompilationRule;
+
+@RunWith(JUnit4.class)
+public final class TypesTest extends AbstractTypesTest {
+ @Rule public final CompilationRule compilation = new CompilationRule();
+
+ @Override
+ protected Elements getElements() {
+ return compilation.getElements();
+ }
+
+ @Override
+ protected Types getTypes() {
+ return compilation.getTypes();
+ }
+}
diff --git a/src/test/java/com/squareup/javapoet/UtilTest.java b/src/test/java/com/squareup/javapoet/UtilTest.java
new file mode 100644
index 0000000..d4b9c52
--- /dev/null
+++ b/src/test/java/com/squareup/javapoet/UtilTest.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2016 Square, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.squareup.javapoet;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class UtilTest {
+ @Test public void characterLiteral() {
+ assertEquals("a", Util.characterLiteralWithoutSingleQuotes('a'));
+ assertEquals("b", Util.characterLiteralWithoutSingleQuotes('b'));
+ assertEquals("c", Util.characterLiteralWithoutSingleQuotes('c'));
+ assertEquals("%", Util.characterLiteralWithoutSingleQuotes('%'));
+ // common escapes
+ assertEquals("\\b", Util.characterLiteralWithoutSingleQuotes('\b'));
+ assertEquals("\\t", Util.characterLiteralWithoutSingleQuotes('\t'));
+ assertEquals("\\n", Util.characterLiteralWithoutSingleQuotes('\n'));
+ assertEquals("\\f", Util.characterLiteralWithoutSingleQuotes('\f'));
+ assertEquals("\\r", Util.characterLiteralWithoutSingleQuotes('\r'));
+ assertEquals("\"", Util.characterLiteralWithoutSingleQuotes('"'));
+ assertEquals("\\'", Util.characterLiteralWithoutSingleQuotes('\''));
+ assertEquals("\\\\", Util.characterLiteralWithoutSingleQuotes('\\'));
+ // octal escapes
+ assertEquals("\\u0000", Util.characterLiteralWithoutSingleQuotes('\0'));
+ assertEquals("\\u0007", Util.characterLiteralWithoutSingleQuotes('\7'));
+ assertEquals("?", Util.characterLiteralWithoutSingleQuotes('\77'));
+ assertEquals("\\u007f", Util.characterLiteralWithoutSingleQuotes('\177'));
+ assertEquals("¿", Util.characterLiteralWithoutSingleQuotes('\277'));
+ assertEquals("ÿ", Util.characterLiteralWithoutSingleQuotes('\377'));
+ // unicode escapes
+ assertEquals("\\u0000", Util.characterLiteralWithoutSingleQuotes('\u0000'));
+ assertEquals("\\u0001", Util.characterLiteralWithoutSingleQuotes('\u0001'));
+ assertEquals("\\u0002", Util.characterLiteralWithoutSingleQuotes('\u0002'));
+ assertEquals("€", Util.characterLiteralWithoutSingleQuotes('\u20AC'));
+ assertEquals("☃", Util.characterLiteralWithoutSingleQuotes('\u2603'));
+ assertEquals("♠", Util.characterLiteralWithoutSingleQuotes('\u2660'));
+ assertEquals("♣", Util.characterLiteralWithoutSingleQuotes('\u2663'));
+ assertEquals("♥", Util.characterLiteralWithoutSingleQuotes('\u2665'));
+ assertEquals("♦", Util.characterLiteralWithoutSingleQuotes('\u2666'));
+ assertEquals("✵", Util.characterLiteralWithoutSingleQuotes('\u2735'));
+ assertEquals("✺", Util.characterLiteralWithoutSingleQuotes('\u273A'));
+ assertEquals("／", Util.characterLiteralWithoutSingleQuotes('\uFF0F'));
+ }
+
+ @Test public void stringLiteral() {
+ stringLiteral("abc");
+ stringLiteral("♦♥♠♣");
+ stringLiteral("€\\t@\\t$", "€\t@\t$", " ");
+ stringLiteral("abc();\\n\"\n + \"def();", "abc();\ndef();", " ");
+ stringLiteral("This is \\\"quoted\\\"!", "This is \"quoted\"!", " ");
+ stringLiteral("e^{i\\\\pi}+1=0", "e^{i\\pi}+1=0", " ");
+ }
+
+ void stringLiteral(String string) {
+ stringLiteral(string, string, " ");
+ }
+
+ void stringLiteral(String expected, String value, String indent) {
+ assertEquals("\"" + expected + "\"", Util.stringLiteralWithDoubleQuotes(value, indent));
+ }
+}
