* Update to Kotlin 1.4.0
* Remove moshi-kotlin rules in favor of Kotlin's
* Ignore tests for now
* Update to OptIn
* Update test for kotlin 1.4 behavior
* Extract target constructor signature into TargetConstructor.kt
We'll need this to know what the runtime types are for proguard rules
* Add ProguardConfig
* Wire in proguard config
* Write proguard configs out with adapters
* Add full tests
* Now remove the rules!
* Ignore on inline classes for now
* Pass adapter constructor params correctly
* Update to Kotlin compile testing 1.2.4
This allows us to un-toe-hold a test from before
* Fix trailing newline
* Add class-based alternative
* Use updated test API
* Update to 1.2.5
* Update to Kotlin 1.3.60
* Unwrap typealiases
This was a change in 1.4.2 left over from moshi's prior metadata logic. We need the unwrapped type for class references
* Add toe-hold for testing shared adapter behavior
* Add regression test for abstractSuperProperties
* Kotlinpoet 1.4.2
* KotlinPoet 1.4.1 & Kotlin 1.3.50
KotlinPoet uses 1.3.50, so this just matches that now
* Remove now-unnecessary custom shade
This uses the same common package prefix in kotlinpoet now
* Add backwardReferencingTypeVars() regression test
Coverage for #955
* Add kotlinpoet version to properties
* Swap in kotlinpoet-metadata for kotlin-metadata in dependencies
* Don't use KotlinMetadataUtils and KotlinAbstractProcessor anymore
* Upcast to TypeElement
* Temporarily add direct kotlinx-metadata dependency
Something is wrong with packaging in my local kotlinpoet, will remove before
* Remove tags API from TargetParameter
No longer needed
* Add PropertySpec directly to TargetProperty, remove holder funs
Simplifies some things!
* Move generated annotation gen into type callback
Removes JsonClassCodegenProcessor completely from codegen API
* Remove unstable autocommon dependency
Won't be using this anymore after this change
* Manually put quotes jsonName in AdapterGenerator
Otherwise we could incur double escaping from kotlinpoet since we directly reuse possible-escaped parsed `@Json` name values
* Opt in to use `@UseExperimental` annotation for preview
* Rework and simplify metadata to just use kotlinpoet-metadata
This is hard to do in broken down 1:1 steps, but the net result is a much smaller implementation footprint, better error messages, and a simpler API interaction with the code gen API. There is some raw parsing of kotlinpoet types required (mostly around annotations), but otherwise it's pretty smooth sailing and a good test of the upcoming kotlinpoet-metadata support
* Declare KotlinPoetMetadataPreview directly
* Try to point to snapshots for CI build
* Update to classinspector API
* Remove TypeResolver API
No longer needed
* Kotlinpoet 1.4.0 final
* Fix missing import from rebase
* Remove old kotlin-metadata version
* Add kotlin-compile-testing dependency
* Add Okio dependency to tests to match kotlin-compile-testing
Without this, Okio.sink() fails to resolve at runtime
* Try converting privateConstructor() to kotlin-compile-testing
* Space
* Update to 1.2.2
* Use new kotlin source file API
* Use temporaryFolder as workingDir
* Extract prepareCompilation helper method
This allows for modifying the compilation with extra bits as needed
* Migrate tests entirely to new API
* Remove incorrect error message
This passed before, but was picked up in https://github.com/square/moshi/pull/903 before and observed to be incorrect.
* Remove custom kotlin compiler implementations
* Add an OK exit code test
This wasn't possible before!
* Remove jitpack dependency now that it's on mavencentral
* Move versions to parent pom
* Fix new test from rebase
* Support gradle incremental processing in code gen
This adds support for incremental compilation in gradle via incap helper and marking the code gen as `ISOLATING`.
Depends on a newer version of KotlinPoet that has https://github.com/square/kotlinpoet/pull/647Resolves#589
* Opportunistically update to auto-service 1.0-rc5
Supports incremental compilation and moves annotations to a separate artifact
* 1.2.0 final!
* Mark compiler embeddales as test only
Rename @MoshiSerializable to @JsonClass. Like @Json, I'm anticipating
a future where there are other interesting properties on this annotation.
Perhaps a future feature where Moshi is strict and only adapts types that
have a '@JsonClass' annotation.
Also rename MoshiKotlinCodeGenProcessor to JsonClassCodeGenProcessor. We
may later support other ways of generating code here; perhaps for regular
Java types.
* Add kotlin code gen modules
* Update kotlin to 1.2
* Add a serializable dummy class
* Try using kapt configuration from kotlin-examples repo
Still no luck!
* Use proper allocated name for assignment too
* Use selectName() API
* Clean up constructor parameter annotations & plumbing for qualifiers
* Updates poms and kotlin code gen processor to support tests.
* Ignore kotlin code gen tests for now
None of these are data classes tests right now, which is the only thing this supports right now
* Replace $ with _ in class names for consistency
* Shortcut Array types to arrayOf
* Add DataClassTest
* Try generated option first, fall back to maven after
* More idiomatic handling
* Only use nonnullable types for adapter properties
* Code dump of kotshi tests
* Comment out specifics to get compiling
* Generics support!
* Fix double primitive default
* Pick up temporary snapshot for Any fix
* Invariance should just be null
* Better handling of nullably-bound variance
* Just assume the first jvm constructor for now as jvmMethodSig is flaky
* Specify types param if needed
* Don't do lazy delegation
* Clean up nullable typevariablename boundaries
* Add type variables to extension function on companion object
* Use properties instead of allocated names for more robustness
Since we're already on a snapshot
* If there are no type variables, make it null for simpler handling
* Fix generics and Type[] handling
* Fix unnecessary as casts on primitive defaults
* Reference spec directly for possible bangs
* Use nullSafe() adapters for anything nullable or with default values
* Use object type in makeType()
Types.java cares
* Make TestPrimitiveDefaultValues work
* Re-enable TestClassWithJavaKeyword
* Ignore remaining tests that are pending decisions or JsonQualifier support
* Remove customnames test as we're just going to stick with simple @Json
* Add toString() implementations
* Reenable default values testing, adapt to kotlin lang support
* Remove primitive adapters bits since we're not using it
* Clean up a bunch of leftover comments
* Switch to only nullable handling, report missing properties
This makes all nullable handling for local properties the same, and removes defaults for primitives in the process. It simplifies the handling a lot, and leans on kotlin language features to take care of null handling (null checking and then throwing the lazily evaluated list of missing properties).
One minor change from what kotshi does - this reports the serialized name in the missing properties, not the property name. We could look at supporting this though if we want.
* Implement JsonQualifier support
* Use Kapt for AutoService/processor declaration
* Checkstyle
* Remove unused primite type checks
* Add test verifying mutable and immutable collections work
* Fix test name
* Standardize isRequired checks
* Add more nullability and mutability tests
* Kotlinpoet 0.7.0 final
* Switch to new vararg overload for annotation class adapter()
* Make suffix just JsonAdapter without underscore
* Switch to just a regular constructor for MoshiSerializableFactory
* Remove constructor caching
* Remove unnecessary framework class checks
* Nix unnecessary superclass lookups, inline constructor lookup
* Nix null token check in reads
* Nix null check in writes, do !! on first value use
* Nix null checks in favor of serializeNulls
* Inline null checks and fail eagerly
* Fix double _Adapter
* First pass at simplifying adapter names
* Inline names to options property, life into class and rm companion
* Differentiate between absent and null, use nullSafe() as needed
* Group together compile and test dependencies
* Remove incorrect comment
* Revert formatting
* Set, not mutable set
* Collapse else-if nesting to one when
* Cleaner formatting test code
* Collapse more to locals
* Collapse more
* Return a nonnullable type in fromJson
* Remove redundant out variance
* Use KClass where appropriate
* End comment in period
* Remove redundant comment
* Throw on unrecognized type in simplified name
* Use illegalargumentexception instead
* Emit a nullcheck at the beginning of toJson instead
* Remove extra newline
* Simplify processing to be less abusive
* Skip using asClassName() when possible
* Use addComment()
* Switch to declared constructors
Technically more correct since we're defining these
* Unmodifiable set
* return adapter(type, annotationTypes[0])
* Slight optimization - check if the type is parameterized first
If the type is a parameterized type, then we know they'll have the two-arg constructor. This way we don't always try and fail the single arg constructor on parameterized types
* Add test for type aliases, optimize to reuse adapters if possible
This is a tiny optimization to make type aliases (which did already work) reuse adapter properties if they already exist for the backing type. What this means is that if you have:
typealias Foo = String
and properties
foo: Foo
bar: String
you'll only get one adapter property field for String, and both will use it
* Use string templating where possible
* Remove all the kotshi tests
