From d995dc9e67ca40705a992b70c9e00c55fbd8cfa5 Mon Sep 17 00:00:00 2001
From: Scala Steward <scala_steward@virtuslab.com>
Date: Tue, 24 Oct 2023 16:15:32 +0000
Subject: [PATCH 1/3] Update scalafmt-core to 3.7.15

---
 .scalafmt.conf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.scalafmt.conf b/.scalafmt.conf
index 243e75f0e..06ba61376 100644
--- a/.scalafmt.conf
+++ b/.scalafmt.conf
@@ -1,4 +1,4 @@
-version = "3.6.1"
+version = "3.7.15"
 style = default
 
 maxColumn = 100

From 727b154f7e8509332917dac64d7f604b7f772e14 Mon Sep 17 00:00:00 2001
From: Scala Steward <scala_steward@virtuslab.com>
Date: Tue, 24 Oct 2023 16:16:34 +0000
Subject: [PATCH 2/3] Reformat with scalafmt 3.7.15

Executed command: scalafmt --non-interactive
---
 build.sbt                                     |   2 +-
 .../bp/chrono/JapaneseChronology.scala        |  20 +-
 .../org/threeten/bp/chrono/JapaneseDate.scala |  66 +--
 .../org/threeten/bp/chrono/JapaneseEra.scala  |  22 +-
 .../bp/chrono/internal/TTBPJapaneseEra.scala  |   4 +-
 .../scala-2/org/threeten/bp/DayOfWeek.scala   |  95 ++--
 .../main/scala-2/org/threeten/bp/Month.scala  | 106 ++--
 .../org/threeten/bp/chrono/HijrahEra.scala    |   8 +-
 .../org/threeten/bp/chrono/IsoEra.scala       |  16 +-
 .../org/threeten/bp/chrono/MinguoEra.scala    |  18 +-
 .../threeten/bp/chrono/ThaiBuddhistEra.scala  |   2 +-
 .../org/threeten/bp/format/FormatStyle.scala  |   2 +-
 .../org/threeten/bp/format/SignStyle.scala    |   2 +-
 .../TTBPDateTimeFormatterBuilder.scala        |  12 +-
 .../threeten/bp/temporal/ChronoField.scala    |  74 +--
 .../org/threeten/bp/temporal/ChronoUnit.scala |  10 +-
 .../org/threeten/bp/temporal/IsoFields.scala  |   4 +-
 .../threeten/bp/temporal/JulianFields.scala   |  12 +-
 .../org/threeten/bp/zone/ZoneMap.scala        |   4 +-
 .../bp/zone/ZoneOffsetTransitionRule.scala    |  12 +-
 .../scala-3/org/threeten/bp/DayOfWeek.scala   |  95 ++--
 .../main/scala-3/org/threeten/bp/Month.scala  | 106 ++--
 .../org/threeten/bp/chrono/HijrahEra.scala    |   8 +-
 .../org/threeten/bp/chrono/IsoEra.scala       |  16 +-
 .../org/threeten/bp/chrono/MinguoEra.scala    |  18 +-
 .../threeten/bp/chrono/ThaiBuddhistEra.scala  |   2 +-
 .../org/threeten/bp/format/FormatStyle.scala  |   2 +-
 .../org/threeten/bp/format/SignStyle.scala    |   2 +-
 .../TTBPDateTimeFormatterBuilder.scala        |  12 +-
 .../threeten/bp/temporal/ChronoField.scala    |  74 +--
 .../org/threeten/bp/temporal/ChronoUnit.scala |  10 +-
 .../org/threeten/bp/temporal/IsoFields.scala  |   4 +-
 .../threeten/bp/temporal/JulianFields.scala   |  12 +-
 .../bp/zone/ZoneOffsetTransitionRule.scala    |  12 +-
 .../main/scala/org/threeten/bp/Clock.scala    |  54 +-
 .../main/scala/org/threeten/bp/Duration.scala | 171 +++---
 .../main/scala/org/threeten/bp/Instant.scala  | 229 ++++----
 .../scala/org/threeten/bp/LocalDate.scala     | 353 ++++++-------
 .../scala/org/threeten/bp/LocalDateTime.scala | 365 +++++++------
 .../scala/org/threeten/bp/LocalTime.scala     | 290 +++++-----
 .../main/scala/org/threeten/bp/MonthDay.scala | 126 ++---
 .../org/threeten/bp/OffsetDateTime.scala      | 412 +++++++--------
 .../scala/org/threeten/bp/OffsetTime.scala    | 288 +++++-----
 .../main/scala/org/threeten/bp/Period.scala   |  84 +--
 .../src/main/scala/org/threeten/bp/Year.scala | 182 +++----
 .../scala/org/threeten/bp/YearMonth.scala     | 216 ++++----
 .../main/scala/org/threeten/bp/ZoneId.scala   | 126 ++---
 .../scala/org/threeten/bp/ZoneOffset.scala    | 104 ++--
 .../scala/org/threeten/bp/ZoneRegion.scala    |   4 +-
 .../scala/org/threeten/bp/ZonedDateTime.scala | 499 +++++++++---------
 .../bp/chrono/AbstractChronology.scala        |   2 +-
 .../threeten/bp/chrono/ChronoLocalDate.scala  | 100 ++--
 .../bp/chrono/ChronoLocalDateImpl.scala       |  30 +-
 .../bp/chrono/ChronoLocalDateTime.scala       |  42 +-
 .../bp/chrono/ChronoLocalDateTimeImpl.scala   |   6 +-
 .../org/threeten/bp/chrono/ChronoPeriod.scala |  36 +-
 .../threeten/bp/chrono/ChronoPeriodImpl.scala |   2 +-
 .../bp/chrono/ChronoZonedDateTime.scala       |  74 +--
 .../bp/chrono/ChronoZonedDateTimeImpl.scala   |   4 +-
 .../org/threeten/bp/chrono/Chronology.scala   | 145 ++---
 .../scala/org/threeten/bp/chrono/Era.scala    |   6 +-
 .../threeten/bp/chrono/HijrahChronology.scala |   6 +-
 .../org/threeten/bp/chrono/HijrahDate.scala   |  38 +-
 .../threeten/bp/chrono/IsoChronology.scala    |  24 +-
 .../threeten/bp/chrono/MinguoChronology.scala |   8 +-
 .../org/threeten/bp/chrono/MinguoDate.scala   |  32 +-
 .../bp/chrono/ThaiBuddhistChronology.scala    |   8 +-
 .../threeten/bp/chrono/ThaiBuddhistDate.scala |  34 +-
 .../org/threeten/bp/chrono/package.scala      |  10 +-
 .../threeten/bp/format/DateTimeBuilder.scala  |  14 +-
 .../bp/format/DateTimeFormatter.scala         | 278 +++++-----
 .../bp/format/DateTimeFormatterBuilder.scala  | 226 ++++----
 .../SimpleDateTimeFormatStyleProvider.scala   |   2 +-
 .../internal/DateTimePrinterParser.scala      |   4 +-
 .../internal/TTBPDateTimeParseContext.scala   |  12 +-
 .../TTBPSimpleDateTimeTextProvider.scala      |   2 +-
 .../main/scala/org/threeten/bp/package.scala  |  36 +-
 .../org/threeten/bp/temporal/Temporal.scala   |  91 ++--
 .../bp/temporal/TemporalAccessor.scala        |  56 +-
 .../bp/temporal/TemporalAdjuster.scala        |  18 +-
 .../bp/temporal/TemporalAdjusters.scala       |  34 +-
 .../threeten/bp/temporal/TemporalAmount.scala |  27 +-
 .../threeten/bp/temporal/TemporalField.scala  |  50 +-
 .../bp/temporal/TemporalQueries.scala         | 156 +++---
 .../threeten/bp/temporal/TemporalQuery.scala  |  27 +-
 .../threeten/bp/temporal/TemporalUnit.scala   |  29 +-
 .../org/threeten/bp/temporal/ValueRange.scala |  24 +-
 .../org/threeten/bp/temporal/WeekFields.scala | 100 ++--
 .../org/threeten/bp/temporal/package.scala    |  20 +-
 .../bp/zone/ZoneOffsetTransition.scala        |  22 +-
 .../org/threeten/bp/zone/ZoneRules.scala      |  26 +-
 .../threeten/bp/zone/ZoneRulesBuilder.scala   |   6 +-
 .../bp/zone/ZoneRulesInitializer.scala        |  10 +-
 .../threeten/bp/zone/ZoneRulesProvider.scala  |  28 +-
 .../org/threeten/bp/AssertionsHelper.scala    |  22 +-
 .../org/threeten/bp/GenDateTimeTest.scala     |   2 +-
 .../org/threeten/bp/MockSimplePeriod.scala    |   6 +-
 .../scala/org/threeten/bp/TestInstant.scala   |  12 +-
 98 files changed, 3158 insertions(+), 3156 deletions(-)

diff --git a/build.sbt b/build.sbt
index 74fe2a9b7..179837f28 100644
--- a/build.sbt
+++ b/build.sbt
@@ -139,7 +139,7 @@ lazy val core = crossProject(JVMPlatform, JSPlatform, NativePlatform)
   .in(file("core"))
   .settings(commonSettings)
   .settings(
-    name := "scala-java-time",
+    name                                          := "scala-java-time",
     libraryDependencies += ("org.portable-scala" %%% "portable-scala-reflect" % "1.1.2")
       .cross(CrossVersion.for3Use2_13)
   )
diff --git a/core/jvm/src/main/scala/org/threeten/bp/chrono/JapaneseChronology.scala b/core/jvm/src/main/scala/org/threeten/bp/chrono/JapaneseChronology.scala
index 8ac84a894..6e8c76aa8 100644
--- a/core/jvm/src/main/scala/org/threeten/bp/chrono/JapaneseChronology.scala
+++ b/core/jvm/src/main/scala/org/threeten/bp/chrono/JapaneseChronology.scala
@@ -118,7 +118,7 @@ object JapaneseChronology {
  * Japan introduced the Gregorian calendar starting with Meiji 6. Only Meiji and later eras are
  * supported; dates before Meiji 6, January 1 are not supported.
  *
- * The supported {@code ChronoField} instances are: <ul> <li>{@code DAY_OF_WEEK} <li>{@code
+ * The supported {@@codeChronoField} instances are: <ul> <li>{@code DAY_OF_WEEK} <li>{@code
  * DAY_OF_MONTH} <li>{@code DAY_OF_YEAR} <li>{@code EPOCH_DAY} <li>{@code MONTH_OF_YEAR} <li>{@code
  * PROLEPTIC_MONTH} <li>{@code YEAR_OF_ERA} <li>{@code YEAR} <li>{@code ERA} </ul>
  *
@@ -141,8 +141,8 @@ final class JapaneseChronology private () extends Chronology with Serializable {
   /**
    * Gets the ID of the chronology - 'Japanese'.
    *
-   * The ID uniquely identifies the {@code Chronology}. It can be used to lookup the {@code
-   * Chronology} using {@link #of(String)}.
+   * The ID uniquely identifies the {@@codeChronology} . It can be used to lookup the {@code
+   * Chronology} using {@@link#of(String)} .
    *
    * @return
    *   the chronology ID - 'Japanese'
@@ -155,7 +155,7 @@ final class JapaneseChronology private () extends Chronology with Serializable {
    * Gets the calendar type of the underlying calendar system - 'japanese'.
    *
    * The calendar type is an identifier defined by the <em>Unicode Locale Data Markup Language
-   * (LDML)</em> specification. It can be used to lookup the {@code Chronology} using {@link
+   * (LDML)</em> specification. It can be used to lookup the {@@codeChronology} using {@link
    * #of(String)}. It can also be used as part of a locale, accessible via {@link
    * Locale#getUnicodeLocaleType(String)} with the key 'ca'.
    *
@@ -194,7 +194,7 @@ final class JapaneseChronology private () extends Chronology with Serializable {
    * @throws DateTimeException
    *   if unable to create the date
    * @throws ClassCastException
-   *   if the { @code era} is not a { @code JapaneseEra}
+   *   if the {@@codeera} is not a {@@codeJapaneseEra}
    */
   override def dateYearDay(era: Era, yearOfEra: Int, dayOfYear: Int): JapaneseDate =
     if (!era.isInstanceOf[JapaneseEra]) throw new ClassCastException("Era must be JapaneseEra")
@@ -276,16 +276,16 @@ final class JapaneseChronology private () extends Chronology with Serializable {
   /**
    * Returns the calendar system era object from the given numeric value.
    *
-   * See the description of each Era for the numeric values of: {@link JapaneseEra#HEISEI}, {@link
-   * JapaneseEra#SHOWA},{@link JapaneseEra#TAISHO}, {@link JapaneseEra#MEIJI}), only Meiji and later
-   * eras are supported.
+   * See the description of each Era for the numeric values of: {@@linkJapaneseEra#HEISEI} , {@link
+   * JapaneseEra#SHOWA},{@link JapaneseEra#TAISHO}, {@@linkJapaneseEra#MEIJI} ), only Meiji and
+   * later eras are supported.
    *
    * @param eraValue
    *   the era value
    * @return
-   *   the Japanese { @code Era} for the given numeric era value
+   *   the Japanese {@@codeEra} for the given numeric era value
    * @throws DateTimeException
-   *   if { @code eraValue} is invalid
+   *   if {@@codeeraValue} is invalid
    */
   def eraOf(eraValue: Int): JapaneseEra = JapaneseEra.of(eraValue)
 
diff --git a/core/jvm/src/main/scala/org/threeten/bp/chrono/JapaneseDate.scala b/core/jvm/src/main/scala/org/threeten/bp/chrono/JapaneseDate.scala
index 8afc77eaa..d645f513d 100644
--- a/core/jvm/src/main/scala/org/threeten/bp/chrono/JapaneseDate.scala
+++ b/core/jvm/src/main/scala/org/threeten/bp/chrono/JapaneseDate.scala
@@ -55,9 +55,9 @@ object JapaneseDate {
   private[chrono] val MIN_DATE: LocalDate = LocalDate.of(1873, 1, 1)
 
   /**
-   * Obtains the current {@code JapaneseDate} from the system clock in the default time-zone.
+   * Obtains the current {@@codeJapaneseDate} from the system clock in the default time-zone.
    *
-   * This will query the {@link Clock#systemDefaultZone() system clock} in the default time-zone to
+   * This will query the {@@linkClock#systemDefaultZone() system clock} in the default time-zone to
    * obtain the current date.
    *
    * Using this method will prevent the ability to use an alternate clock for testing because the
@@ -69,9 +69,9 @@ object JapaneseDate {
   def now: JapaneseDate = now(Clock.systemDefaultZone)
 
   /**
-   * Obtains the current {@code JapaneseDate} from the system clock in the specified time-zone.
+   * Obtains the current {@@codeJapaneseDate} from the system clock in the specified time-zone.
    *
-   * This will query the {@link Clock#system(ZoneId) system clock} to obtain the current date.
+   * This will query the {@@linkClock#system(ZoneId) system clock} to obtain the current date.
    * Specifying the time-zone avoids dependence on the default time-zone.
    *
    * Using this method will prevent the ability to use an alternate clock for testing because the
@@ -85,11 +85,11 @@ object JapaneseDate {
   def now(zone: ZoneId): JapaneseDate = now(Clock.system(zone))
 
   /**
-   * Obtains the current {@code JapaneseDate} from the specified clock.
+   * Obtains the current {@@codeJapaneseDate} from the specified clock.
    *
    * This will query the specified clock to obtain the current date - today. Using this method
    * allows the use of an alternate clock for testing. The alternate clock may be introduced using
-   * {@linkplain Clock dependency injection}.
+   * {@@linkplainClock dependency injection} .
    *
    * @param clock
    *   the clock to use, not null
@@ -101,10 +101,10 @@ object JapaneseDate {
   def now(clock: Clock): JapaneseDate = new JapaneseDate(LocalDate.now(clock))
 
   /**
-   * Obtains a {@code JapaneseDate} representing a date in the Japanese calendar system from the
+   * Obtains a {@@codeJapaneseDate} representing a date in the Japanese calendar system from the
    * era, year-of-era, month-of-year and day-of-month fields.
    *
-   * This returns a {@code JapaneseDate} with the specified fields. The day must be valid for the
+   * This returns a {@@codeJapaneseDate} with the specified fields. The day must be valid for the
    * year and month, otherwise an exception will be thrown.
    *
    * The Japanese month and day-of-month are the same as those in the ISO calendar system. They are
@@ -140,10 +140,10 @@ object JapaneseDate {
   }
 
   /**
-   * Obtains a {@code JapaneseDate} representing a date in the Japanese calendar system from the
+   * Obtains a {@@codeJapaneseDate} representing a date in the Japanese calendar system from the
    * era, year-of-era and day-of-year fields.
    *
-   * This returns a {@code JapaneseDate} with the specified fields. The day must be valid for the
+   * This returns a {@@codeJapaneseDate} with the specified fields. The day must be valid for the
    * year, otherwise an exception will be thrown. The Japanese day-of-year is reset when the era
    * changes.
    *
@@ -180,10 +180,10 @@ object JapaneseDate {
   }
 
   /**
-   * Obtains a {@code JapaneseDate} representing a date in the Japanese calendar system from the
+   * Obtains a {@@codeJapaneseDate} representing a date in the Japanese calendar system from the
    * proleptic-year, month-of-year and day-of-month fields.
    *
-   * This returns a {@code JapaneseDate} with the specified fields. The day must be valid for the
+   * This returns a {@@codeJapaneseDate} with the specified fields. The day must be valid for the
    * year and month, otherwise an exception will be thrown.
    *
    * The Japanese proleptic year, month and day-of-month are the same as those in the ISO calendar
@@ -205,24 +205,24 @@ object JapaneseDate {
     new JapaneseDate(LocalDate.of(prolepticYear, month, dayOfMonth))
 
   /**
-   * Obtains a {@code JapaneseDate} from a temporal object.
+   * Obtains a {@@codeJapaneseDate} from a temporal object.
    *
    * This obtains a date in the Japanese calendar system based on the specified temporal. A {@code
    * TemporalAccessor} represents an arbitrary set of date and time information, which this factory
-   * converts to an instance of {@code JapaneseDate}.
+   * converts to an instance of {@@codeJapaneseDate} .
    *
-   * The conversion typically uses the {@link ChronoField#EPOCH_DAY EPOCH_DAY} field, which is
+   * The conversion typically uses the {@@linkChronoField#EPOCH_DAY EPOCH_DAY} field, which is
    * standardized across calendar systems.
    *
-   * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used as a query via method reference, {@code JapaneseDate::from}.
+   * This method matches the signature of the functional interface {@@linkTemporalQuery} allowing it
+   * to be used as a query via method reference, {@@codeJapaneseDate::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the date in Japanese calendar system, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code JapaneseDate}
+   *   if unable to convert to a {@@codeJapaneseDate}
    */
   def from(temporal: TemporalAccessor): JapaneseDate = JapaneseChronology.INSTANCE.date(temporal)
 
@@ -231,7 +231,7 @@ object JapaneseDate {
 /**
  * A date in the Japanese Imperial calendar system.
  *
- * This date operates using the {@linkplain JapaneseChronology Japanese Imperial calendar}. This
+ * This date operates using the {@@linkplainJapaneseChronology Japanese Imperial calendar} . This
  * calendar system is primarily used in Japan.
  *
  * The Japanese Imperial calendar system is the same as the ISO calendar system apart from the
@@ -241,17 +241,17 @@ object JapaneseDate {
  * supported.
  *
  * For example, the Japanese year "Heisei 24" corresponds to ISO year "2012".<br> Calling {@code
- * japaneseDate.get(YEAR_OF_ERA)} will return 24.<br> Calling {@code japaneseDate.get(YEAR)} will
- * return 2012.<br> Calling {@code japaneseDate.get(ERA)} will return 2, corresponding to {@code
+ * japaneseDate.get(YEAR_OF_ERA)} will return 24.<br> Calling {@@codejapaneseDate.get(YEAR)} will
+ * return 2012.<br> Calling {@@codejapaneseDate.get(ERA)} will return 2, corresponding to {@code
  * JapaneseChEra.HEISEI}.<br>
  *
  * <h3>Specification for implementors</h3> This class is immutable and thread-safe.
  *
  * @constructor
- *   Constructs a {@code JapaneseDate}.
+ *   Constructs a {@@codeJapaneseDate} .
  *
- * This constructor does NOT validate the given parameters, and {@code era} and {@code year} must
- * agree with {@code isoDate}.
+ * This constructor does NOT validate the given parameters, and {@@codeera} and {@@codeyear} must
+ * agree with {@@codeisoDate} .
  * @param era
  *   the era, validated not null
  * @param yearOfEra
@@ -298,17 +298,17 @@ final class JapaneseDate private[chrono] (
    * Checks if the specified field is supported.
    *
    * This checks if this date can be queried for the specified field. If false, then calling the
-   * {@link #range(TemporalField) range} and {@link #get(TemporalField) get} methods will throw an
+   * {@@link#range(TemporalField) range} and {@@link#get(TemporalField) get} methods will throw an
    * exception.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The supported fields
+   * If the field is a {@@linkChronoField} then the query is implemented here. The supported fields
    * are: <ul> <li>{@code DAY_OF_WEEK} <li>{@code DAY_OF_MONTH} <li>{@code DAY_OF_YEAR} <li>{@code
    * EPOCH_DAY} <li>{@code MONTH_OF_YEAR} <li>{@code PROLEPTIC_MONTH} <li>{@code YEAR_OF_ERA}
-   * <li>{@code YEAR} <li>{@code ERA} </ul> All other {@code ChronoField} instances will return
+   * <li>{@code YEAR} <li>{@code ERA} </ul> All other {@@codeChronoField} instances will return
    * false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.isSupportedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the field is supported is determined by the field.
    *
    * @param field
@@ -418,9 +418,9 @@ final class JapaneseDate private[chrono] (
    * @param yearOfEra
    *   the year-of-era to set in the returned date
    * @return
-   *   a { @code JapaneseDate} based on this date with the requested year, never null
+   *   a {@@codeJapaneseDate} based on this date with the requested year, never null
    * @throws DateTimeException
-   *   if { @code year} is invalid
+   *   if {@@codeyear} is invalid
    */
   private def withYear(era: JapaneseEra, yearOfEra: Int): JapaneseDate = {
     val year: Int = JapaneseChronology.INSTANCE.prolepticYear(era, yearOfEra)
@@ -438,9 +438,9 @@ final class JapaneseDate private[chrono] (
    * @param year
    *   the year to set in the returned date
    * @return
-   *   a { @code JapaneseDate} based on this date with the requested year-of-era, never null
+   *   a {@@codeJapaneseDate} based on this date with the requested year-of-era, never null
    * @throws DateTimeException
-   *   if { @code year} is invalid
+   *   if {@@codeyear} is invalid
    */
   private def withYear(year: Int): JapaneseDate = withYear(getEra, year)
 
diff --git a/core/jvm/src/main/scala/org/threeten/bp/chrono/JapaneseEra.scala b/core/jvm/src/main/scala/org/threeten/bp/chrono/JapaneseEra.scala
index 91f702817..119a6c1b8 100644
--- a/core/jvm/src/main/scala/org/threeten/bp/chrono/JapaneseEra.scala
+++ b/core/jvm/src/main/scala/org/threeten/bp/chrono/JapaneseEra.scala
@@ -83,16 +83,16 @@ object JapaneseEra {
   )
 
   /**
-   * Obtains an instance of {@code JapaneseEra} from an {@code int} value.
+   * Obtains an instance of {@@codeJapaneseEra} from an {@@codeint} value.
    *
-   * The {@link #SHOWA} era that contains 1970-01-01 (ISO calendar system) has the value 1 Later era
-   * is numbered 2 ({@link #HEISEI}). Earlier eras are numbered 0 ({@link #TAISHO}),
-   * -1 ({@link #MEIJI}), only Meiji and later eras are supported.
+   * The {@@link#SHOWA} era that contains 1970-01-01 (ISO calendar system) has the value 1 Later era
+   * is numbered 2 ({@link #HEISEI}). Earlier eras are numbered 0 ({@link #TAISHO}), -1 ({@link
+   * #MEIJI}), only Meiji and later eras are supported.
    *
    * @param japaneseEra
    *   the era to represent
    * @return
-   *   the { @code JapaneseEra} singleton, not null
+   *   the {@@codeJapaneseEra} singleton, not null
    * @throws DateTimeException
    *   if the value is invalid
    */
@@ -104,7 +104,7 @@ object JapaneseEra {
   }
 
   /**
-   * Returns the {@code JapaneseEra} with the name.
+   * Returns the {@@codeJapaneseEra} with the name.
    *
    * The string must match exactly the name of the era. (Extraneous whitespace characters are not
    * permitted.)
@@ -112,7 +112,7 @@ object JapaneseEra {
    * @param japaneseEra
    *   the japaneseEra name; non-null
    * @return
-   *   the { @code JapaneseEra} singleton, never null
+   *   the {@@codeJapaneseEra} singleton, never null
    * @throws IllegalArgumentException
    *   if there is not JapaneseEra with the specified name
    */
@@ -136,7 +136,7 @@ object JapaneseEra {
   def values: Array[JapaneseEra] = Arrays.copyOf(KNOWN_ERAS.get, KNOWN_ERAS.get.length)
 
   /**
-   * Obtains an instance of {@code JapaneseEra} from a date.
+   * Obtains an instance of {@@codeJapaneseEra} from a date.
    *
    * @param date
    *   the date, not null
@@ -174,7 +174,7 @@ object JapaneseEra {
  * This class defines the valid eras for the Japanese chronology. Japan introduced the Gregorian
  * calendar starting with Meiji 6. Only Meiji and later eras are supported; dates before Meiji 6,
  * January 1 are not supported. <p> The four supported eras are hard-coded. A single additional era
- * may be registered using {@link #registerEra(LocalDate, String)}.
+ * may be registered using {@@link#registerEra(LocalDate, String)} .
  *
  * <h3>Specification for implementors</h3> This class is immutable and thread-safe.
  *
@@ -213,9 +213,9 @@ final class JapaneseEra private[chrono] (
   }
 
   /**
-   * Returns the numeric value of this {@code JapaneseEra}.
+   * Returns the numeric value of this {@@codeJapaneseEra} .
    *
-   * The {@link #SHOWA} era that contains 1970-01-01 (ISO calendar system) has the value 1. Later
+   * The {@@link#SHOWA} era that contains 1970-01-01 (ISO calendar system) has the value 1. Later
    * eras are numbered from 2 ({@link #HEISEI}). Earlier eras are numbered 0 ({@link #TAISHO}) and
    * -1 ({@link #MEIJI}).
    *
diff --git a/core/jvm/src/main/scala/org/threeten/bp/chrono/internal/TTBPJapaneseEra.scala b/core/jvm/src/main/scala/org/threeten/bp/chrono/internal/TTBPJapaneseEra.scala
index 0506f526b..0319ed023 100644
--- a/core/jvm/src/main/scala/org/threeten/bp/chrono/internal/TTBPJapaneseEra.scala
+++ b/core/jvm/src/main/scala/org/threeten/bp/chrono/internal/TTBPJapaneseEra.scala
@@ -8,7 +8,7 @@ import java.util.Arrays
 object TTBPJapaneseEra {
 
   /**
-   * Registers an additional instance of {@code JapaneseEra}. <p> A new Japanese era can begin at
+   * Registers an additional instance of {@@codeJapaneseEra} . <p> A new Japanese era can begin at
    * any time. This method allows one new era to be registered without the need for a new library
    * version. If needed, callers should assign the result to a static variable accessible across the
    * application. This must be done once, in early startup code. <p> NOTE: This method does not
@@ -19,7 +19,7 @@ object TTBPJapaneseEra {
    * @param name
    *   the name
    * @return
-   *   the { @code JapaneseEra} singleton, not null
+   *   the {@@codeJapaneseEra} singleton, not null
    * @throws DateTimeException
    *   if an additional era has already been registered
    */
diff --git a/core/shared/src/main/scala-2/org/threeten/bp/DayOfWeek.scala b/core/shared/src/main/scala-2/org/threeten/bp/DayOfWeek.scala
index c77d2bf23..3b208b2fe 100644
--- a/core/shared/src/main/scala-2/org/threeten/bp/DayOfWeek.scala
+++ b/core/shared/src/main/scala-2/org/threeten/bp/DayOfWeek.scala
@@ -49,19 +49,19 @@ import org.threeten.bp.temporal.ValueRange
 /**
  * A day-of-week, such as 'Tuesday'.
  *
- * {@code DayOfWeek} is an enum representing the 7 days of the week - Monday, Tuesday, Wednesday,
+ * {@@codeDayOfWeek} is an enum representing the 7 days of the week - Monday, Tuesday, Wednesday,
  * Thursday, Friday, Saturday and Sunday.
  *
- * In addition to the textual enum name, each day-of-week has an {@code int} value. The {@code int}
+ * In addition to the textual enum name, each day-of-week has an {@@codeint} value. The {@@codeint}
  * value follows the ISO-8601 standard, from 1 (Monday) to 7 (Sunday). It is recommended that
- * applications use the enum rather than the {@code int} value to ensure code clarity.
+ * applications use the enum rather than the {@@codeint} value to ensure code clarity.
  *
  * This enum provides access to the localized textual form of the day-of-week. Some locales also
  * assign different numeric values to the days, declaring Sunday to have the value 1, however this
- * class provides no support for this. See {@link WeekFields} for localized week-numbering.
+ * class provides no support for this. See {@@linkWeekFields} for localized week-numbering.
  *
- * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code DayOfWeek}. Use
- * {@code getValue()} instead.</b>
+ * <b>Do not use {@@codeordinal()} to obtain the numeric representation of {@@codeDayOfWeek} . Use
+ * {@@codegetValue()} instead.</b>
  *
  * This enum represents a common concept that is found in many calendar systems. As such, this enum
  * may be used by any calendar system that has the day-of-week concept defined exactly equivalent to
@@ -72,12 +72,13 @@ import org.threeten.bp.temporal.ValueRange
 object DayOfWeek {
 
   /**
-   * The singleton instance for the day-of-week of Monday. This has the numeric value of {@code 1}.
+   * The singleton instance for the day-of-week of Monday. This has the numeric value of {@@code1} .
    */
   lazy val MONDAY = new DayOfWeek("MONDAY", 0)
 
   /**
-   * The singleton instance for the day-of-week of Tuesday. This has the numeric value of {@code 2}.
+   * The singleton instance for the day-of-week of Tuesday. This has the numeric value of {@@code2}
+   * .
    */
   lazy val TUESDAY = new DayOfWeek("TUESDAY", 1)
 
@@ -94,7 +95,7 @@ object DayOfWeek {
   lazy val THURSDAY = new DayOfWeek("THURSDAY", 3)
 
   /**
-   * The singleton instance for the day-of-week of Friday. This has the numeric value of {@code 5}.
+   * The singleton instance for the day-of-week of Friday. This has the numeric value of {@@code5} .
    */
   lazy val FRIDAY = new DayOfWeek("FRIDAY", 4)
 
@@ -105,7 +106,7 @@ object DayOfWeek {
   lazy val SATURDAY = new DayOfWeek("SATURDAY", 5)
 
   /**
-   * The singleton instance for the day-of-week of Sunday. This has the numeric value of {@code 7}.
+   * The singleton instance for the day-of-week of Sunday. This has the numeric value of {@@code7} .
    */
   lazy val SUNDAY = new DayOfWeek("SUNDAY", 6)
 
@@ -124,10 +125,10 @@ object DayOfWeek {
   private lazy val ENUMS: Array[DayOfWeek] = DayOfWeek.values
 
   /**
-   * Obtains an instance of {@code DayOfWeek} from an {@code int} value.
+   * Obtains an instance of {@@codeDayOfWeek} from an {@@codeint} value.
    *
-   * {@code DayOfWeek} is an enum representing the 7 days of the week. This factory allows the enum
-   * to be obtained from the {@code int} value. The {@code int} value follows the ISO-8601 standard,
+   * {@@codeDayOfWeek} is an enum representing the 7 days of the week. This factory allows the enum
+   * to be obtained from the {@@codeint} value. The {@@codeint} value follows the ISO-8601 standard,
    * from 1 (Monday) to 7 (Sunday).
    *
    * @param dayOfWeek
@@ -144,22 +145,22 @@ object DayOfWeek {
       ENUMS(dayOfWeek - 1)
 
   /**
-   * Obtains an instance of {@code DayOfWeek} from a temporal object.
+   * Obtains an instance of {@@codeDayOfWeek} from a temporal object.
    *
-   * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code DayOfWeek}.
+   * A {@@codeTemporalAccessor} represents some form of date and time information. This factory
+   * converts the arbitrary temporal object to an instance of {@@codeDayOfWeek} .
    *
-   * The conversion extracts the {@link ChronoField#DAY_OF_WEEK DAY_OF_WEEK} field.
+   * The conversion extracts the {@@linkChronoField#DAY_OF_WEEK DAY_OF_WEEK} field.
    *
-   * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used as a query via method reference, {@code DayOfWeek::from}.
+   * This method matches the signature of the functional interface {@@linkTemporalQuery} allowing it
+   * to be used as a query via method reference, {@@codeDayOfWeek::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the day-of-week, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code DayOfWeek}
+   *   if unable to convert to a {@@codeDayOfWeek}
    */
   def from(temporal: TemporalAccessor): DayOfWeek = {
     temporal match {
@@ -183,10 +184,10 @@ final class DayOfWeek(name: String, ordinal: Int)
     with TemporalAdjuster {
 
   /**
-   * Gets the day-of-week {@code int} value.
+   * Gets the day-of-week {@@codeint} value.
    *
    * The values are numbered following the ISO-8601 standard, from 1 (Monday) to 7 (Sunday). See
-   * {@link WeekFields#dayOfWeek} for localized week-numbering.
+   * {@@linkWeekFields#dayOfWeek} for localized week-numbering.
    *
    * @return
    *   the day-of-week, from 1 (Monday) to 7 (Sunday)
@@ -199,7 +200,7 @@ final class DayOfWeek(name: String, ordinal: Int)
    * This returns the textual name used to identify the day-of-week. The parameters control the
    * length of the returned text and the locale.
    *
-   * If no textual mapping is found then the {@link #getValue() numeric value} is returned.
+   * If no textual mapping is found then the {@@link#getValue() numeric value} is returned.
    *
    * @param style
    *   the length of the text required, not null
@@ -215,14 +216,14 @@ final class DayOfWeek(name: String, ordinal: Int)
    * Checks if the specified field is supported.
    *
    * This checks if this day-of-week can be queried for the specified field. If false, then calling
-   * the {@link #range(TemporalField) range} and {@link #get(TemporalField) get} methods will throw
+   * the {@@link#range(TemporalField) range} and {@@link#get(TemporalField) get} methods will throw
    * an exception.
    *
-   * If the field is {@link ChronoField#DAY_OF_WEEK DAY_OF_WEEK} then this method returns true. All
-   * other {@code ChronoField} instances will return false.
+   * If the field is {@@linkChronoField#DAY_OF_WEEK DAY_OF_WEEK} then this method returns true. All
+   * other {@@codeChronoField} instances will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.isSupportedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the field is supported is determined by the field.
    *
    * @param field
@@ -243,12 +244,12 @@ final class DayOfWeek(name: String, ordinal: Int)
    * is used to enhance the accuracy of the returned range. If it is not possible to return the
    * range, because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is {@link ChronoField#DAY_OF_WEEK DAY_OF_WEEK} then the range of the day-of-week,
-   * from 1 to 7, will be returned. All other {@code ChronoField} instances will throw a {@code
+   * If the field is {@@linkChronoField#DAY_OF_WEEK DAY_OF_WEEK} then the range of the day-of-week,
+   * from 1 to 7, will be returned. All other {@@codeChronoField} instances will throw a {@code
    * DateTimeException}.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.rangeRefinedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
    * @param field
@@ -267,18 +268,18 @@ final class DayOfWeek(name: String, ordinal: Int)
       field.rangeRefinedBy(this)
 
   /**
-   * Gets the value of the specified field from this day-of-week as an {@code int}.
+   * Gets the value of the specified field from this day-of-week as an {@@codeint} .
    *
    * This queries this day-of-week for the value for the specified field. The returned value will
    * always be within the valid range of values for the field. If it is not possible to return the
    * value, because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is {@link ChronoField#DAY_OF_WEEK DAY_OF_WEEK} then the value of the day-of-week,
-   * from 1 to 7, will be returned. All other {@code ChronoField} instances will throw a {@code
+   * If the field is {@@linkChronoField#DAY_OF_WEEK DAY_OF_WEEK} then the value of the day-of-week,
+   * from 1 to 7, will be returned. All other {@@codeChronoField} instances will throw a {@code
    * DateTimeException}.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -288,7 +289,7 @@ final class DayOfWeek(name: String, ordinal: Int)
    * @throws DateTimeException
    *   if a value for the field cannot be obtained
    * @throws DateTimeException
-   *   if the range of valid values for the field exceeds an { @code int}
+   *   if the range of valid values for the field exceeds an {@@codeint}
    * @throws DateTimeException
    *   if the value is outside the range of valid values for the field
    * @throws ArithmeticException
@@ -301,18 +302,18 @@ final class DayOfWeek(name: String, ordinal: Int)
       range(field).checkValidIntValue(getLong(field), field)
 
   /**
-   * Gets the value of the specified field from this day-of-week as a {@code long}.
+   * Gets the value of the specified field from this day-of-week as a {@@codelong} .
    *
    * This queries this day-of-week for the value for the specified field. If it is not possible to
    * return the value, because the field is not supported or for some other reason, an exception is
    * thrown.
    *
-   * If the field is {@link ChronoField#DAY_OF_WEEK DAY_OF_WEEK} then the value of the day-of-week,
-   * from 1 to 7, will be returned. All other {@code ChronoField} instances will throw a {@code
+   * If the field is {@@linkChronoField#DAY_OF_WEEK DAY_OF_WEEK} then the value of the day-of-week,
+   * from 1 to 7, will be returned. All other {@@codeChronoField} instances will throw a {@code
    * DateTimeException}.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -373,7 +374,7 @@ final class DayOfWeek(name: String, ordinal: Int)
    * of the query to understand what the result of this method will be.
    *
    * The result of this method is obtained by invoking the {@link
-   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@code this}
+   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@@codethis}
    * as the argument.
    *
    * @tparam R
@@ -403,10 +404,10 @@ final class DayOfWeek(name: String, ordinal: Int)
    * This returns a temporal object of the same observable type as the input with the day-of-week
    * changed to be the same as this.
    *
-   * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)} passing {@link
+   * The adjustment is equivalent to using {@@linkTemporal#with(TemporalField, long)} passing {@link
    * ChronoField#DAY_OF_WEEK} as the field. Note that this adjusts forwards or backwards within a
-   * Monday to Sunday week. See {@link WeekFields#dayOfWeek} for localized week start days. See
-   * {@link TemporalAdjusters} for other adjusters with more control, such as {@code next(MONDAY)}.
+   * Monday to Sunday week. See {@@linkWeekFields#dayOfWeek} for localized week start days. See
+   * {@@linkTemporalAdjusters} for other adjusters with more control, such as {@@codenext(MONDAY)} .
    *
    * In most cases, it is clearer to reverse the calling pattern by using {@link
    * Temporal#with(TemporalAdjuster)}: <pre> // these two lines are equivalent, but the second
diff --git a/core/shared/src/main/scala-2/org/threeten/bp/Month.scala b/core/shared/src/main/scala-2/org/threeten/bp/Month.scala
index f6a778cf7..65a84dbc2 100644
--- a/core/shared/src/main/scala-2/org/threeten/bp/Month.scala
+++ b/core/shared/src/main/scala-2/org/threeten/bp/Month.scala
@@ -52,16 +52,16 @@ import org.threeten.bp.temporal.ValueRange
 /**
  * A month-of-year, such as 'July'.
  *
- * {@code Month} is an enum representing the 12 months of the year - January, February, March,
+ * {@@codeMonth} is an enum representing the 12 months of the year - January, February, March,
  * April, May, June, July, August, September, October, November and December.
  *
- * In addition to the textual enum name, each month-of-year has an {@code int} value. The {@code
+ * In addition to the textual enum name, each month-of-year has an {@@codeint} value. The {@code
  * int} value follows normal usage and the ISO-8601 standard, from 1 (January) to 12 (December). It
- * is recommended that applications use the enum rather than the {@code int} value to ensure code
+ * is recommended that applications use the enum rather than the {@@codeint} value to ensure code
  * clarity.
  *
- * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code Month}. Use {@code
- * getValue()} instead.</b>
+ * <b>Do not use {@@codeordinal()} to obtain the numeric representation of {@@codeMonth} . Use
+ * {@code getValue()} instead.</b>
  *
  * This enum represents a common concept that is found in many calendar systems. As such, this enum
  * may be used by any calendar system that has the month-of-year concept defined exactly equivalent
@@ -73,25 +73,25 @@ object Month {
 
   /**
    * The singleton instance for the month of January with 31 days. This has the numeric value of
-   * {@code 1}.
+   * {@@code1} .
    */
   lazy val JANUARY = new Month("JANUARY", 0)
 
   /**
    * The singleton instance for the month of February with 28 days, or 29 in a leap year. This has
-   * the numeric value of {@code 2}.
+   * the numeric value of {@@code2} .
    */
   lazy val FEBRUARY = new Month("FEBRUARY", 1)
 
   /**
    * The singleton instance for the month of March with 31 days. This has the numeric value of
-   * {@code 3}.
+   * {@@code3} .
    */
   lazy val MARCH = new Month("MARCH", 2)
 
   /**
    * The singleton instance for the month of April with 30 days. This has the numeric value of
-   * {@code 4}.
+   * {@@code4} .
    */
   lazy val APRIL = new Month("APRIL", 3)
 
@@ -115,31 +115,31 @@ object Month {
 
   /**
    * The singleton instance for the month of August with 31 days. This has the numeric value of
-   * {@code 8}.
+   * {@@code8} .
    */
   lazy val AUGUST = new Month("AUGUST", 7)
 
   /**
    * The singleton instance for the month of September with 30 days. This has the numeric value of
-   * {@code 9}.
+   * {@@code9} .
    */
   lazy val SEPTEMBER = new Month("SEPTEMBER", 8)
 
   /**
    * The singleton instance for the month of October with 31 days. This has the numeric value of
-   * {@code 10}.
+   * {@@code10} .
    */
   lazy val OCTOBER = new Month("OCTOBER", 9)
 
   /**
    * The singleton instance for the month of November with 30 days. This has the numeric value of
-   * {@code 11}.
+   * {@@code11} .
    */
   lazy val NOVEMBER = new Month("NOVEMBER", 10)
 
   /**
    * The singleton instance for the month of December with 31 days. This has the numeric value of
-   * {@code 12}.
+   * {@@code12} .
    */
   lazy val DECEMBER = new Month("DECEMBER", 11)
 
@@ -168,10 +168,10 @@ object Month {
   private lazy val ENUMS: Array[Month] = Month.values
 
   /**
-   * Obtains an instance of {@code Month} from an {@code int} value.
+   * Obtains an instance of {@@codeMonth} from an {@@codeint} value.
    *
-   * {@code Month} is an enum representing the 12 months of the year. This factory allows the enum
-   * to be obtained from the {@code int} value. The {@code int} value follows the ISO-8601 standard,
+   * {@@codeMonth} is an enum representing the 12 months of the year. This factory allows the enum
+   * to be obtained from the {@@codeint} value. The {@@codeint} value follows the ISO-8601 standard,
    * from 1 (January) to 12 (December).
    *
    * @param month
@@ -188,24 +188,24 @@ object Month {
       ENUMS(month - 1)
 
   /**
-   * Obtains an instance of {@code Month} from a temporal object.
+   * Obtains an instance of {@@codeMonth} from a temporal object.
    *
-   * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code Month}.
+   * A {@@codeTemporalAccessor} represents some form of date and time information. This factory
+   * converts the arbitrary temporal object to an instance of {@@codeMonth} .
    *
-   * The conversion extracts the {@link ChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} field. The
+   * The conversion extracts the {@@linkChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} field. The
    * extraction is only permitted if the temporal object has an ISO chronology, or can be converted
-   * to a {@code LocalDate}.
+   * to a {@@codeLocalDate} .
    *
-   * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used in queries via method reference, {@code Month::from}.
+   * This method matches the signature of the functional interface {@@linkTemporalQuery} allowing it
+   * to be used in queries via method reference, {@@codeMonth::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the month-of-year, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code Month}
+   *   if unable to convert to a {@@codeMonth}
    */
   def from(temporal: TemporalAccessor): Month = {
     var _temporal = temporal
@@ -234,7 +234,7 @@ final class Month private (name: String, ordinal: Int)
   import Month._
 
   /**
-   * Gets the month-of-year {@code int} value.
+   * Gets the month-of-year {@@codeint} value.
    *
    * The values are numbered following the ISO-8601 standard, from 1 (January) to 12 (December).
    *
@@ -249,7 +249,7 @@ final class Month private (name: String, ordinal: Int)
    * This returns the textual name used to identify the month-of-year. The parameters control the
    * length of the returned text and the locale.
    *
-   * If no textual mapping is found then the {@link #getValue() numeric value} is returned.
+   * If no textual mapping is found then the {@@link#getValue() numeric value} is returned.
    *
    * @param style
    *   the length of the text required, not null
@@ -265,14 +265,14 @@ final class Month private (name: String, ordinal: Int)
    * Checks if the specified field is supported.
    *
    * This checks if this month-of-year can be queried for the specified field. If false, then
-   * calling the {@link #range(TemporalField) range} and {@link #get(TemporalField) get} methods
+   * calling the {@@link#range(TemporalField) range} and {@@link#get(TemporalField) get} methods
    * will throw an exception.
    *
-   * If the field is {@link ChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} then this method returns true.
-   * All other {@code ChronoField} instances will return false.
+   * If the field is {@@linkChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} then this method returns true.
+   * All other {@@codeChronoField} instances will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.isSupportedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the field is supported is determined by the field.
    *
    * @param field
@@ -293,12 +293,12 @@ final class Month private (name: String, ordinal: Int)
    * to enhance the accuracy of the returned range. If it is not possible to return the range,
    * because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is {@link ChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} then the range of the
-   * month-of-year, from 1 to 12, will be returned. All other {@code ChronoField} instances will
-   * throw a {@code DateTimeException}.
+   * If the field is {@@linkChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} then the range of the
+   * month-of-year, from 1 to 12, will be returned. All other {@@codeChronoField} instances will
+   * throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.rangeRefinedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
    * @param field
@@ -317,18 +317,18 @@ final class Month private (name: String, ordinal: Int)
       field.rangeRefinedBy(this)
 
   /**
-   * Gets the value of the specified field from this month-of-year as an {@code int}.
+   * Gets the value of the specified field from this month-of-year as an {@@codeint} .
    *
    * This queries this month for the value for the specified field. The returned value will always
    * be within the valid range of values for the field. If it is not possible to return the value,
    * because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is {@link ChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} then the value of the
-   * month-of-year, from 1 to 12, will be returned. All other {@code ChronoField} instances will
-   * throw a {@code DateTimeException}.
+   * If the field is {@@linkChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} then the value of the
+   * month-of-year, from 1 to 12, will be returned. All other {@@codeChronoField} instances will
+   * throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -338,7 +338,7 @@ final class Month private (name: String, ordinal: Int)
    * @throws DateTimeException
    *   if a value for the field cannot be obtained
    * @throws DateTimeException
-   *   if the range of valid values for the field exceeds an { @code int}
+   *   if the range of valid values for the field exceeds an {@@codeint}
    * @throws DateTimeException
    *   if the value is outside the range of valid values for the field
    * @throws ArithmeticException
@@ -351,17 +351,17 @@ final class Month private (name: String, ordinal: Int)
       range(field).checkValidIntValue(getLong(field), field)
 
   /**
-   * Gets the value of the specified field from this month-of-year as a {@code long}.
+   * Gets the value of the specified field from this month-of-year as a {@@codelong} .
    *
    * This queries this month for the value for the specified field. If it is not possible to return
    * the value, because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is {@link ChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} then the value of the
-   * month-of-year, from 1 to 12, will be returned. All other {@code ChronoField} instances will
-   * throw a {@code DateTimeException}.
+   * If the field is {@@linkChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} then the value of the
+   * month-of-year, from 1 to 12, will be returned. All other {@@codeChronoField} instances will
+   * throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -516,7 +516,7 @@ final class Month private (name: String, ordinal: Int)
    * of the query to understand what the result of this method will be.
    *
    * The result of this method is obtained by invoking the {@link
-   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@code this}
+   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@@codethis}
    * as the argument.
    *
    * @tparam R
@@ -548,9 +548,9 @@ final class Month private (name: String, ordinal: Int)
    * This returns a temporal object of the same observable type as the input with the month-of-year
    * changed to be the same as this.
    *
-   * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)} passing {@link
+   * The adjustment is equivalent to using {@@linkTemporal#with(TemporalField, long)} passing {@link
    * ChronoField#MONTH_OF_YEAR} as the field. If the specified temporal object does not use the ISO
-   * calendar system then a {@code DateTimeException} is thrown.
+   * calendar system then a {@@codeDateTimeException} is thrown.
    *
    * In most cases, it is clearer to reverse the calling pattern by using {@link
    * Temporal#with(TemporalAdjuster)}: <pre> // these two lines are equivalent, but the second
diff --git a/core/shared/src/main/scala-2/org/threeten/bp/chrono/HijrahEra.scala b/core/shared/src/main/scala-2/org/threeten/bp/chrono/HijrahEra.scala
index 12c9e0686..274ebfe0f 100644
--- a/core/shared/src/main/scala-2/org/threeten/bp/chrono/HijrahEra.scala
+++ b/core/shared/src/main/scala-2/org/threeten/bp/chrono/HijrahEra.scala
@@ -52,7 +52,7 @@ object HijrahEra {
   lazy val values: Array[HijrahEra] = Array(BEFORE_AH, AH)
 
   /**
-   * Obtains an instance of {@code HijrahEra} from a value.
+   * Obtains an instance of {@@codeHijrahEra} from a value.
    *
    * The current era (from ISO date 622-06-19 onwards) has the value 1 The previous era has the
    * value 0.
@@ -76,11 +76,11 @@ object HijrahEra {
 /**
  * An era in the Hijrah calendar system.
  *
- * The Hijrah calendar system has two eras. The date {@code 0001-01-01 (Hijrah)} is {@code 622-06-19
+ * The Hijrah calendar system has two eras. The date {@@code0001-01-01 (Hijrah)} is {@code 622-06-19
  * (ISO)}.
  *
- * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code HijrahEra}. Use
- * {@code getValue()} instead.</b>
+ * <b>Do not use {@@codeordinal()} to obtain the numeric representation of {@@codeHijrahEra} . Use
+ * {@@codegetValue()} instead.</b>
  *
  * <h3>Specification for implementors</h3> This is an immutable and thread-safe enum.
  */
diff --git a/core/shared/src/main/scala-2/org/threeten/bp/chrono/IsoEra.scala b/core/shared/src/main/scala-2/org/threeten/bp/chrono/IsoEra.scala
index 985490945..02d3d038f 100644
--- a/core/shared/src/main/scala-2/org/threeten/bp/chrono/IsoEra.scala
+++ b/core/shared/src/main/scala-2/org/threeten/bp/chrono/IsoEra.scala
@@ -38,24 +38,24 @@ object IsoEra {
   /**
    * The singleton instance for the era BCE, 'Before Current Era'. The 'ISO' part of the name
    * emphasizes that this differs from the BCE era in the Gregorian calendar system. This has the
-   * numeric value of {@code 0}.
+   * numeric value of {@@code0} .
    */
   lazy val BCE = new IsoEra("BCE", 0)
 
   /**
    * The singleton instance for the era CE, 'Current Era'. The 'ISO' part of the name emphasizes
    * that this differs from the CE era in the Gregorian calendar system. This has the numeric value
-   * of {@code 1}.
+   * of {@@code1} .
    */
   lazy val CE = new IsoEra("CE", 1)
 
   lazy val values: Array[IsoEra] = Array(BCE, CE)
 
   /**
-   * Obtains an instance of {@code IsoEra} from an {@code int} value.
+   * Obtains an instance of {@@codeIsoEra} from an {@@codeint} value.
    *
-   * {@code IsoEra} is an enum representing the ISO eras of BCE/CE. This factory allows the enum to
-   * be obtained from the {@code int} value.
+   * {@@codeIsoEra} is an enum representing the ISO eras of BCE/CE. This factory allows the enum to
+   * be obtained from the {@@codeint} value.
    *
    * @param era
    *   the BCE/CE value to represent, from 0 (BCE) to 1 (CE)
@@ -79,15 +79,15 @@ object IsoEra {
  *   - 'Current era' (CE) for years from 0001-01-01 (ISO) and 'Before current era' (BCE) for years
  *     before that.
  *
- * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code IsoEra}. Use
- * {@code getValue()} instead.</b>
+ * <b>Do not use {@@codeordinal()} to obtain the numeric representation of {@@codeIsoEra} . Use
+ * {@@codegetValue()} instead.</b>
  *
  * <h3>Specification for implementors</h3> This is an immutable and thread-safe enum.
  */
 final class IsoEra(name: String, ordinal: Int) extends Enum[IsoEra](name, ordinal) with Era {
 
   /**
-   * Gets the numeric era {@code int} value.
+   * Gets the numeric era {@@codeint} value.
    *
    * The era BCE has the value 0, while the era CE has the value 1.
    *
diff --git a/core/shared/src/main/scala-2/org/threeten/bp/chrono/MinguoEra.scala b/core/shared/src/main/scala-2/org/threeten/bp/chrono/MinguoEra.scala
index 6014854ba..4c621f200 100644
--- a/core/shared/src/main/scala-2/org/threeten/bp/chrono/MinguoEra.scala
+++ b/core/shared/src/main/scala-2/org/threeten/bp/chrono/MinguoEra.scala
@@ -37,23 +37,23 @@ object MinguoEra {
 
   /**
    * The singleton instance for the era BEFORE_ROC, 'Before Republic of China'. This has the numeric
-   * value of {@code 0}.
+   * value of {@@code0} .
    */
   lazy val BEFORE_ROC = new MinguoEra("BEFORE_ROC", 0)
 
   /**
    * The singleton instance for the era ROC, 'Republic of China'. This has the numeric value of
-   * {@code 1}.
+   * {@@code1} .
    */
   lazy val ROC = new MinguoEra("ROC", 1)
 
   lazy val values: Array[MinguoEra] = Array(BEFORE_ROC, ROC)
 
   /**
-   * Obtains an instance of {@code MinguoEra} from an {@code int} value.
+   * Obtains an instance of {@@codeMinguoEra} from an {@@codeint} value.
    *
-   * {@code MinguoEra} is an enum representing the Minguo eras of BEFORE_ROC/ROC. This factory
-   * allows the enum to be obtained from the {@code int} value.
+   * {@@codeMinguoEra} is an enum representing the Minguo eras of BEFORE_ROC/ROC. This factory
+   * allows the enum to be obtained from the {@@codeint} value.
    *
    * @param era
    *   the BEFORE_ROC/ROC value to represent, from 0 (BEFORE_ROC) to 1 (ROC)
@@ -74,18 +74,18 @@ object MinguoEra {
 /**
  * An era in the Minguo calendar system.
  *
- * The Minguo calendar system has two eras. The date {@code 0001-01-01 (Minguo)} is equal to {@code
+ * The Minguo calendar system has two eras. The date {@@code0001-01-01 (Minguo)} is equal to {@code
  * 1912-01-01 (ISO)}.
  *
- * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code MinguoEra}. Use
- * {@code getValue()} instead.</b>
+ * <b>Do not use {@@codeordinal()} to obtain the numeric representation of {@@codeMinguoEra} . Use
+ * {@@codegetValue()} instead.</b>
  *
  * <h3>Specification for implementors</h3> This is an immutable and thread-safe enum.
  */
 final class MinguoEra(name: String, ordinal: Int) extends Enum[MinguoEra](name, ordinal) with Era {
 
   /**
-   * Gets the numeric era {@code int} value.
+   * Gets the numeric era {@@codeint} value.
    *
    * The era BEFORE_ROC has the value 0, while the era ROC has the value 1.
    *
diff --git a/core/shared/src/main/scala-2/org/threeten/bp/chrono/ThaiBuddhistEra.scala b/core/shared/src/main/scala-2/org/threeten/bp/chrono/ThaiBuddhistEra.scala
index ea2ad5220..aee0f9f98 100644
--- a/core/shared/src/main/scala-2/org/threeten/bp/chrono/ThaiBuddhistEra.scala
+++ b/core/shared/src/main/scala-2/org/threeten/bp/chrono/ThaiBuddhistEra.scala
@@ -47,7 +47,7 @@ object ThaiBuddhistEra {
   lazy val values: Array[ThaiBuddhistEra] = Array(BEFORE_BE, BE)
 
   /**
-   * Obtains an instance of {@code ThaiBuddhistEra} from a value.
+   * Obtains an instance of {@@codeThaiBuddhistEra} from a value.
    *
    * The current era (from ISO year -543 onwards) has the value 1 The previous era has the value 0.
    *
diff --git a/core/shared/src/main/scala-2/org/threeten/bp/format/FormatStyle.scala b/core/shared/src/main/scala-2/org/threeten/bp/format/FormatStyle.scala
index 56cc0ae98..7767ebc0a 100644
--- a/core/shared/src/main/scala-2/org/threeten/bp/format/FormatStyle.scala
+++ b/core/shared/src/main/scala-2/org/threeten/bp/format/FormatStyle.scala
@@ -35,7 +35,7 @@ package org.threeten.bp.format
  * Enumeration of the style of a localized date, time or date-time formatter.
  *
  * These styles are used when obtaining a date-time style from configuration. See {@link
- * DateTimeFormatter} and {@link DateTimeFormatterBuilder} for usage.
+ * DateTimeFormatter} and {@@linkDateTimeFormatterBuilder} for usage.
  *
  * <h3>Specification for implementors</h3> This is an immutable and thread-safe enum.
  */
diff --git a/core/shared/src/main/scala-2/org/threeten/bp/format/SignStyle.scala b/core/shared/src/main/scala-2/org/threeten/bp/format/SignStyle.scala
index 37c814c8c..8e60065d1 100644
--- a/core/shared/src/main/scala-2/org/threeten/bp/format/SignStyle.scala
+++ b/core/shared/src/main/scala-2/org/threeten/bp/format/SignStyle.scala
@@ -35,7 +35,7 @@ package org.threeten.bp.format
  * Enumeration of ways to handle the positive/negative sign.
  *
  * The formatting engine allows the positive and negative signs of numbers to be controlled using
- * this enum. See {@link DateTimeFormatterBuilder} for usage.
+ * this enum. See {@@linkDateTimeFormatterBuilder} for usage.
  *
  * <h3>Specification for implementors</h3> This is an immutable and thread-safe enum.
  */
diff --git a/core/shared/src/main/scala-2/org/threeten/bp/format/internal/TTBPDateTimeFormatterBuilder.scala b/core/shared/src/main/scala-2/org/threeten/bp/format/internal/TTBPDateTimeFormatterBuilder.scala
index 77d3e484f..8611cc407 100644
--- a/core/shared/src/main/scala-2/org/threeten/bp/format/internal/TTBPDateTimeFormatterBuilder.scala
+++ b/core/shared/src/main/scala-2/org/threeten/bp/format/internal/TTBPDateTimeFormatterBuilder.scala
@@ -282,8 +282,8 @@ object TTBPDateTimeFormatterBuilder {
    * @param signStyle
    *   the positive/negative sign style, not null
    * @param subsequentWidth
-   *   the width of subsequent non-negative numbers, 0 or greater,
-   * -1 if fixed width due to active adjacent parsing
+   *   the width of subsequent non-negative numbers, 0 or greater, -1 if fixed width due to active
+   *   adjacent parsing
    */
   private[format] class NumberPrinterParser private[format] (
     private[format] val field:           TemporalField,
@@ -766,7 +766,7 @@ object TTBPDateTimeFormatterBuilder {
      * Converts a value for this field to a fraction between 0 and 1.
      *
      * The fractional value is between 0 (inclusive) and 1 (exclusive). It can only be returned if
-     * the {@link TemporalField#range() value range} is fixed. The fraction is obtained by
+     * the {@@linkTemporalField#range() value range} is fixed. The fraction is obtained by
      * calculation from the field range using 9 decimal places and a rounding mode of {@link
      * RoundingMode#FLOOR FLOOR}. The calculation is inaccurate if the values do not run
      * continuously from smallest to largest.
@@ -796,9 +796,9 @@ object TTBPDateTimeFormatterBuilder {
      * Converts a fraction from 0 to 1 for this field to a value.
      *
      * The fractional value must be between 0 (inclusive) and 1 (exclusive). It can only be returned
-     * if the {@link TemporalField#range() value range} is fixed. The value is obtained by
-     * calculation from the field range and a rounding mode of {@link RoundingMode#FLOOR FLOOR}. The
-     * calculation is inaccurate if the values do not run continuously from smallest to largest.
+     * if the {@@linkTemporalField#range() value range} is fixed. The value is obtained by
+     * calculation from the field range and a rounding mode of {@@linkRoundingMode#FLOOR FLOOR} .
+     * The calculation is inaccurate if the values do not run continuously from smallest to largest.
      *
      * For example, the fractional second-of-minute of 0.25 would be converted to 15, assuming the
      * standard definition of 60 seconds in a minute.
diff --git a/core/shared/src/main/scala-2/org/threeten/bp/temporal/ChronoField.scala b/core/shared/src/main/scala-2/org/threeten/bp/temporal/ChronoField.scala
index d460583d4..ef37f8b1b 100644
--- a/core/shared/src/main/scala-2/org/threeten/bp/temporal/ChronoField.scala
+++ b/core/shared/src/main/scala-2/org/threeten/bp/temporal/ChronoField.scala
@@ -52,7 +52,7 @@ import org.threeten.bp.format.ResolverStyle
  * A standard set of fields.
  *
  * This set of fields provide field-based access to manipulate a date, time or date-time. The
- * standard set of fields can be extended by implementing {@link TemporalField}.
+ * standard set of fields can be extended by implementing {@@linkTemporalField} .
  *
  * These fields are intended to be applicable in multiple calendar systems. For example, most
  * non-ISO calendar systems define dates as a year, month and day, just with slightly different
@@ -69,8 +69,8 @@ object ChronoField {
    * meaning for all calendar systems.
    *
    * This field is used to represent the nano-of-second handling any fraction of the second.
-   * Implementations of {@code TemporalAccessor} should provide a value for this field if they can
-   * return a value for {@link #SECOND_OF_MINUTE}, {@link #SECOND_OF_DAY} or {@link
+   * Implementations of {@@codeTemporalAccessor} should provide a value for this field if they can
+   * return a value for {@@link#SECOND_OF_MINUTE} , {@@link#SECOND_OF_DAY} or {@link
    * #INSTANT_SECONDS} filling unknown precision with zero.
    *
    * When this field is used for setting a value, it should set as much precision as the object
@@ -88,8 +88,8 @@ object ChronoField {
    * field has the same meaning for all calendar systems.
    *
    * This field is used to represent the nano-of-day handling any fraction of the second.
-   * Implementations of {@code TemporalAccessor} should provide a value for this field if they can
-   * return a value for {@link #SECOND_OF_DAY} filling unknown precision with zero.
+   * Implementations of {@@codeTemporalAccessor} should provide a value for this field if they can
+   * return a value for {@@link#SECOND_OF_DAY} filling unknown precision with zero.
    */
   lazy val NANO_OF_DAY =
     new ChronoField("NanoOfDay", 1, NANOS, DAYS, ValueRange.of(0, 86400L * 1000000000L - 1))
@@ -101,8 +101,8 @@ object ChronoField {
    * meaning for all calendar systems.
    *
    * This field is used to represent the micro-of-second handling any fraction of the second.
-   * Implementations of {@code TemporalAccessor} should provide a value for this field if they can
-   * return a value for {@link #SECOND_OF_MINUTE}, {@link #SECOND_OF_DAY} or {@link
+   * Implementations of {@@codeTemporalAccessor} should provide a value for this field if they can
+   * return a value for {@@link#SECOND_OF_MINUTE} , {@@link#SECOND_OF_DAY} or {@link
    * #INSTANT_SECONDS} filling unknown precision with zero.
    *
    * When this field is used for setting a value, it should behave in the same way as setting {@link
@@ -118,8 +118,8 @@ object ChronoField {
    * field has the same meaning for all calendar systems.
    *
    * This field is used to represent the micro-of-day handling any fraction of the second.
-   * Implementations of {@code TemporalAccessor} should provide a value for this field if they can
-   * return a value for {@link #SECOND_OF_DAY} filling unknown precision with zero.
+   * Implementations of {@@codeTemporalAccessor} should provide a value for this field if they can
+   * return a value for {@@link#SECOND_OF_DAY} filling unknown precision with zero.
    *
    * When this field is used for setting a value, it should behave in the same way as setting {@link
    * #NANO_OF_DAY} with the value multiplied by 1,000.
@@ -134,8 +134,8 @@ object ChronoField {
    * for all calendar systems.
    *
    * This field is used to represent the milli-of-second handling any fraction of the second.
-   * Implementations of {@code TemporalAccessor} should provide a value for this field if they can
-   * return a value for {@link #SECOND_OF_MINUTE}, {@link #SECOND_OF_DAY} or {@link
+   * Implementations of {@@codeTemporalAccessor} should provide a value for this field if they can
+   * return a value for {@@link#SECOND_OF_MINUTE} , {@@link#SECOND_OF_DAY} or {@link
    * #INSTANT_SECONDS} filling unknown precision with zero.
    *
    * When this field is used for setting a value, it should behave in the same way as setting {@link
@@ -151,8 +151,8 @@ object ChronoField {
    * has the same meaning for all calendar systems.
    *
    * This field is used to represent the milli-of-day handling any fraction of the second.
-   * Implementations of {@code TemporalAccessor} should provide a value for this field if they can
-   * return a value for {@link #SECOND_OF_DAY} filling unknown precision with zero.
+   * Implementations of {@@codeTemporalAccessor} should provide a value for this field if they can
+   * return a value for {@@link#SECOND_OF_DAY} filling unknown precision with zero.
    *
    * When this field is used for setting a value, it should behave in the same way as setting {@link
    * #NANO_OF_DAY} with the value multiplied by 1,000,000.
@@ -241,12 +241,12 @@ object ChronoField {
    * The day-of-week, such as Tuesday.
    *
    * This represents the standard concept of the day of the week. In the default ISO calendar
-   * system, this has values from Monday (1) to Sunday (7). The {@link DayOfWeek} class can be used
+   * system, this has values from Monday (1) to Sunday (7). The {@@linkDayOfWeek} class can be used
    * to interpret the result.
    *
    * Most non-ISO calendar systems also define a seven day week that aligns with ISO. Those calendar
    * systems must also use the same numbering system, from Monday (1) to Sunday (7), which allows
-   * {@code DayOfWeek} to be used.
+   * {@@codeDayOfWeek} to be used.
    *
    * Calendar systems that do not have a standard seven day week should implement this field if they
    * have a similar concept of named or numbered days within a period similar to a week. It is
@@ -398,14 +398,14 @@ object ChronoField {
    * The year within the era.
    *
    * This represents the concept of the year within the era. This field is typically used with
-   * {@link #ERA}.
+   * {@@link#ERA} .
    *
    * The standard mental model for a date is based on three concepts - year, month and day. These
-   * map onto the {@code YEAR}, {@code MONTH_OF_YEAR} and {@code DAY_OF_MONTH} fields. Note that
+   * map onto the {@@codeYEAR} , {@@codeMONTH_OF_YEAR} and {@@codeDAY_OF_MONTH} fields. Note that
    * there is no reference to eras. The full model for a date requires four concepts - era, year,
-   * month and day. These map onto the {@code ERA}, {@code YEAR_OF_ERA}, {@code MONTH_OF_YEAR} and
-   * {@code DAY_OF_MONTH} fields. Whether this field or {@code YEAR} is used depends on which mental
-   * model is being used. See {@link ChronoLocalDate} for more discussion on this topic.
+   * month and day. These map onto the {@@codeERA} , {@@codeYEAR_OF_ERA} , {@@codeMONTH_OF_YEAR} and
+   * {@@codeDAY_OF_MONTH} fields. Whether this field or {@@codeYEAR} is used depends on which mental
+   * model is being used. See {@@linkChronoLocalDate} for more discussion on this topic.
    *
    * In the default ISO calendar system, there are two eras defined, 'BCE' and 'CE'. The era 'CE' is
    * the one currently in use and year-of-era runs from 1 to the maximum value. The era 'BCE' is the
@@ -439,15 +439,15 @@ object ChronoField {
    * The proleptic year, such as 2012.
    *
    * This represents the concept of the year, counting sequentially and using negative numbers. The
-   * proleptic year is not interpreted in terms of the era. See {@link #YEAR_OF_ERA} for an example
+   * proleptic year is not interpreted in terms of the era. See {@@link#YEAR_OF_ERA} for an example
    * showing the mapping from proleptic year to year-of-era.
    *
    * The standard mental model for a date is based on three concepts - year, month and day. These
-   * map onto the {@code YEAR}, {@code MONTH_OF_YEAR} and {@code DAY_OF_MONTH} fields. Note that
+   * map onto the {@@codeYEAR} , {@@codeMONTH_OF_YEAR} and {@@codeDAY_OF_MONTH} fields. Note that
    * there is no reference to eras. The full model for a date requires four concepts - era, year,
-   * month and day. These map onto the {@code ERA}, {@code YEAR_OF_ERA}, {@code MONTH_OF_YEAR} and
-   * {@code DAY_OF_MONTH} fields. Whether this field or {@code YEAR_OF_ERA} is used depends on which
-   * mental model is being used. See {@link ChronoLocalDate} for more discussion on this topic.
+   * month and day. These map onto the {@@codeERA} , {@@codeYEAR_OF_ERA} , {@@codeMONTH_OF_YEAR} and
+   * {@@codeDAY_OF_MONTH} fields. Whether this field or {@@codeYEAR_OF_ERA} is used depends on which
+   * mental model is being used. See {@@linkChronoLocalDate} for more discussion on this topic.
    *
    * Non-ISO calendar systems should implement this field as follows. If the calendar system has
    * only two eras, before and after a fixed date, then the proleptic-year value must be the same as
@@ -467,11 +467,11 @@ object ChronoField {
    * The era.
    *
    * This represents the concept of the era, which is the largest division of the time-line. This
-   * field is typically used with {@link #YEAR_OF_ERA}.
+   * field is typically used with {@@link#YEAR_OF_ERA} .
    *
    * In the default ISO calendar system, there are two eras defined, 'BCE' and 'CE'. The era 'CE' is
    * the one currently in use and year-of-era runs from 1 to the maximum value. The era 'BCE' is the
-   * previous era, and the year-of-era runs backwards. See {@link #YEAR_OF_ERA} for a full example.
+   * previous era, and the year-of-era runs backwards. See {@@link#YEAR_OF_ERA} for a full example.
    *
    * Non-ISO calendar systems should implement this field to define eras. The value of the era that
    * was active on 1970-01-01 (ISO) must be assigned the value 1. Earlier eras must have
@@ -483,9 +483,9 @@ object ChronoField {
    * The instant epoch-seconds.
    *
    * This represents the concept of the sequential count of seconds where 1970-01-01T00:00Z (ISO) is
-   * zero. This field may be used with {@link #NANO_OF_DAY} to represent the fraction of the day.
+   * zero. This field may be used with {@@link#NANO_OF_DAY} to represent the fraction of the day.
    *
-   * An {@link Instant} represents an instantaneous point on the time-line. On their own they have
+   * An {@@linkInstant} represents an instantaneous point on the time-line. On their own they have
    * no elements which allow a local date-time to be obtained. Only when paired with an offset or
    * time-zone can the local date or time be found. This field allows the seconds part of the
    * instant to be queried.
@@ -505,10 +505,10 @@ object ChronoField {
    *
    * This represents the concept of the offset in seconds of local time from UTC/Greenwich.
    *
-   * A {@link ZoneOffset} represents the period of time that local time differs from UTC/Greenwich.
+   * A {@@linkZoneOffset} represents the period of time that local time differs from UTC/Greenwich.
    * This is usually a fixed number of hours and minutes. It is equivalent to the {@link
    * ZoneOffset#getTotalSeconds() total amount} of the offset in seconds. For example, during the
-   * winter Paris has an offset of {@code +01:00}, which is 3600 seconds.
+   * winter Paris has an offset of {@@code+01:00} , which is 3600 seconds.
    *
    * This field is strictly defined to have the same meaning in all calendar systems. This is
    * necessary to ensure interoperation between calendars.
@@ -564,11 +564,11 @@ final class ChronoField private (
   /**
    * Gets the range of valid values for the field.
    *
-   * All fields can be expressed as a {@code long} integer. This method returns an object that
+   * All fields can be expressed as a {@@codelong} integer. This method returns an object that
    * describes the valid range for that value.
    *
    * This method returns the range of the field in the ISO-8601 calendar system. This range may be
-   * incorrect for other calendar systems. Use {@link Chronology#range(ChronoField)} to access the
+   * incorrect for other calendar systems. Use {@@linkChronology#range(ChronoField)} to access the
    * correct range for a different calendar system.
    *
    * Note that the result only describes the minimum and maximum valid values and it is important
@@ -608,7 +608,7 @@ final class ChronoField private (
    * #range()}.
    *
    * This method checks against the range of the field in the ISO-8601 calendar system. This range
-   * may be incorrect for other calendar systems. Use {@link Chronology#range(ChronoField)} to
+   * may be incorrect for other calendar systems. Use {@@linkChronology#range(ChronoField)} to
    * access the correct range for a different calendar system.
    *
    * @param value
@@ -619,13 +619,13 @@ final class ChronoField private (
   def checkValidValue(value: Long): Long = _range.checkValidValue(value, this)
 
   /**
-   * Checks that the specified value is valid and fits in an {@code int}.
+   * Checks that the specified value is valid and fits in an {@@codeint} .
    *
    * This validates that the value is within the outer range of valid values returned by {@link
-   * #range()}. It also checks that all valid values are within the bounds of an {@code int}.
+   * #range()}. It also checks that all valid values are within the bounds of an {@@codeint} .
    *
    * This method checks against the range of the field in the ISO-8601 calendar system. This range
-   * may be incorrect for other calendar systems. Use {@link Chronology#range(ChronoField)} to
+   * may be incorrect for other calendar systems. Use {@@linkChronology#range(ChronoField)} to
    * access the correct range for a different calendar system.
    *
    * @param value
diff --git a/core/shared/src/main/scala-2/org/threeten/bp/temporal/ChronoUnit.scala b/core/shared/src/main/scala-2/org/threeten/bp/temporal/ChronoUnit.scala
index cd5121774..ccf579299 100644
--- a/core/shared/src/main/scala-2/org/threeten/bp/temporal/ChronoUnit.scala
+++ b/core/shared/src/main/scala-2/org/threeten/bp/temporal/ChronoUnit.scala
@@ -40,7 +40,7 @@ import org.threeten.bp.chrono.ChronoZonedDateTime
  * A standard set of date periods units.
  *
  * This set of units provide unit-based access to manipulate a date, time or date-time. The standard
- * set of units can be extended by implementing {@link TemporalUnit}.
+ * set of units can be extended by implementing {@@linkTemporalUnit} .
  *
  * These units are intended to be applicable in multiple calendar systems. For example, most non-ISO
  * calendar systems define units of years, months and days, just with slightly different rules. The
@@ -94,7 +94,7 @@ object ChronoUnit {
 
   /**
    * Unit that represents the concept of a day. For the ISO calendar system, it is the standard day
-   * from midnight to midnight. The estimated duration of a day is {@code 24 Hours}.
+   * from midnight to midnight. The estimated duration of a day is {@@code24 Hours} .
    *
    * When used with other calendar systems it must correspond to the day defined by the rising and
    * setting of the Sun on Earth. It is not required that days begin at midnight - when converting
@@ -120,7 +120,7 @@ object ChronoUnit {
 
   /**
    * Unit that represents the concept of a year. For the ISO calendar system, it is equal to 12
-   * months. The estimated duration of a year is {@code 365.2425 Days}.
+   * months. The estimated duration of a year is {@@code365.2425 Days} .
    *
    * When used with other calendar systems it must correspond to an integral number of days or
    * months roughly equal to a year defined by the passage of the Earth around the Sun.
@@ -157,7 +157,7 @@ object ChronoUnit {
   /**
    * Unit that represents the concept of an era. The ISO calendar system doesn't have eras thus it
    * is impossible to add an era to a date or date-time. The estimated duration of the era is
-   * artificially defined as {@code 1,000,000,000 Years}.
+   * artificially defined as {@@code1,000,000,000 Years} .
    *
    * When used with other calendar systems there are no restrictions on the unit.
    */
@@ -166,7 +166,7 @@ object ChronoUnit {
   /**
    * Artificial unit that represents the concept of forever. This is primarily used with {@link
    * TemporalField} to represent unbounded fields such as the year or era. The estimated duration of
-   * the era is artificially defined as the largest duration supported by {@code Duration}.
+   * the era is artificially defined as the largest duration supported by {@@codeDuration} .
    */
   lazy val FOREVER = new ChronoUnit("Forever", 15, Duration.ofSeconds(Long.MaxValue, 999999999))
 
diff --git a/core/shared/src/main/scala-2/org/threeten/bp/temporal/IsoFields.scala b/core/shared/src/main/scala-2/org/threeten/bp/temporal/IsoFields.scala
index 50ac10304..c10322546 100644
--- a/core/shared/src/main/scala-2/org/threeten/bp/temporal/IsoFields.scala
+++ b/core/shared/src/main/scala-2/org/threeten/bp/temporal/IsoFields.scala
@@ -158,7 +158,7 @@ object IsoFields {
    *
    * This allows a number of week-based-years to be added to, or subtracted from, a date. The unit
    * is equal to either 52 or 53 weeks. The estimated duration of a week-based-year is the same as
-   * that of a standard ISO year at {@code 365.2425 Days}.
+   * that of a standard ISO year at {@@code365.2425 Days} .
    *
    * The rules for addition add the number of week-based-years to the existing value for the
    * week-based-year field. If the resulting week-based-year only has 52 weeks, then the date will
@@ -170,7 +170,7 @@ object IsoFields {
 
   /**
    * Unit that represents the concept of a quarter-year. For the ISO calendar system, it is equal to
-   * 3 months. The estimated duration of a quarter-year is one quarter of {@code 365.2425 Days}.
+   * 3 months. The estimated duration of a quarter-year is one quarter of {@@code365.2425 Days} .
    *
    * This unit is an immutable and thread-safe singleton.
    */
diff --git a/core/shared/src/main/scala-2/org/threeten/bp/temporal/JulianFields.scala b/core/shared/src/main/scala-2/org/threeten/bp/temporal/JulianFields.scala
index 0ef1f8628..920d1faad 100644
--- a/core/shared/src/main/scala-2/org/threeten/bp/temporal/JulianFields.scala
+++ b/core/shared/src/main/scala-2/org/threeten/bp/temporal/JulianFields.scala
@@ -62,7 +62,7 @@ object JulianFields {
    * For date-times, 'JULIAN_DAY.getFrom()' assumes the same value from midnight until just before
    * the next midnight. When 'JULIAN_DAY.adjustInto()' is applied to a date-time, the time of day
    * portion remains unaltered. 'JULIAN_DAY.adjustInto()' and 'JULIAN_DAY.getFrom()' only apply to
-   * {@code Temporal} objects that can be converted into {@link ChronoField#EPOCH_DAY}. A {@link
+   * {@@codeTemporal} objects that can be converted into {@@linkChronoField#EPOCH_DAY} . A {@link
    * DateTimeException} is thrown for any other type of object.
    *
    * <h3>Astronomical and Scientific Notes</h3> The standard astronomical definition uses a fraction
@@ -94,15 +94,15 @@ object JulianFields {
    *
    * This is an integer-based version of the Modified Julian Day Number. Modified Julian Day (MJD)
    * is a well-known system that counts days continuously. It is defined relative to astronomical
-   * Julian Day as {@code MJD = JD - 2400000.5}. Each Modified Julian Day runs from midnight to
+   * Julian Day as {@@codeMJD = JD - 2400000.5} . Each Modified Julian Day runs from midnight to
    * midnight. The field always refers to the local date-time, ignoring the offset or zone.
    *
    * For date-times, 'MODIFIED_JULIAN_DAY.getFrom()' assumes the same value from midnight until just
    * before the next midnight. When 'MODIFIED_JULIAN_DAY.adjustInto()' is applied to a date-time,
    * the time of day portion remains unaltered. 'MODIFIED_JULIAN_DAY.adjustInto()' and
-   * 'MODIFIED_JULIAN_DAY.getFrom()' only apply to {@code Temporal} objects that can be converted
-   * into {@link ChronoField#EPOCH_DAY}. A {@link DateTimeException} is thrown for any other type of
-   * object.
+   * 'MODIFIED_JULIAN_DAY.getFrom()' only apply to {@@codeTemporal} objects that can be converted
+   * into {@@linkChronoField#EPOCH_DAY} . A {@@linkDateTimeException} is thrown for any other type
+   * of object.
    *
    * This implementation is an integer version of MJD with the decimal part rounded to floor.
    *
@@ -133,7 +133,7 @@ object JulianFields {
    * For date-times, 'RATA_DIE.getFrom()' assumes the same value from midnight until just before the
    * next midnight. When 'RATA_DIE.adjustInto()' is applied to a date-time, the time of day portion
    * remains unaltered. 'MODIFIED_JULIAN_DAY.adjustInto()' and 'RATA_DIE.getFrom()' only apply to
-   * {@code Temporal} objects that can be converted into {@link ChronoField#EPOCH_DAY}. A {@link
+   * {@@codeTemporal} objects that can be converted into {@@linkChronoField#EPOCH_DAY} . A {@link
    * DateTimeException} is thrown for any other type of object.
    */
   lazy val RATA_DIE: TemporalField = Field.RATA_DIE
diff --git a/core/shared/src/main/scala-2/org/threeten/bp/zone/ZoneMap.scala b/core/shared/src/main/scala-2/org/threeten/bp/zone/ZoneMap.scala
index f4c6aa966..5e5a4267a 100644
--- a/core/shared/src/main/scala-2/org/threeten/bp/zone/ZoneMap.scala
+++ b/core/shared/src/main/scala-2/org/threeten/bp/zone/ZoneMap.scala
@@ -12,7 +12,7 @@ import scala.collection.immutable
 // TreeMap is not available in Scala.js however it is needed for Time Zone support
 // This is a simple implementation of NavigableMap, performance is likely terrible
 private[bp] class ZoneMap[K: ClassTag, V] private[bp] (var map: immutable.TreeMap[K, V])(implicit
-  ordering:                                                     Ordering[K]
+  ordering: Ordering[K]
 ) extends AbstractMap[K, V]
     with java.util.NavigableMap[K, V] {
   def this()(implicit ordering: Ordering[K]) =
@@ -164,6 +164,6 @@ private[bp] class ZoneMap[K: ClassTag, V] private[bp] (var map: immutable.TreeMa
 object ZoneMap {
 
   def apply[K: ClassTag, V](map: immutable.TreeMap[K, V])(implicit
-    ordering:                    Ordering[K]
+    ordering: Ordering[K]
   ): java.util.NavigableMap[K, V] = new ZoneMap[K, V](map)
 }
diff --git a/core/shared/src/main/scala-2/org/threeten/bp/zone/ZoneOffsetTransitionRule.scala b/core/shared/src/main/scala-2/org/threeten/bp/zone/ZoneOffsetTransitionRule.scala
index c0d2defaf..20f002395 100644
--- a/core/shared/src/main/scala-2/org/threeten/bp/zone/ZoneOffsetTransitionRule.scala
+++ b/core/shared/src/main/scala-2/org/threeten/bp/zone/ZoneOffsetTransitionRule.scala
@@ -60,15 +60,15 @@ object ZoneOffsetTransitionRule {
   /**
    * Obtains an instance defining the yearly rule to create transitions between two offsets.
    *
-   * Applications should normally obtain an instance from {@link ZoneRules}. This factory is only
-   * intended for use when creating {@link ZoneRules}.
+   * Applications should normally obtain an instance from {@@linkZoneRules} . This factory is only
+   * intended for use when creating {@@linkZoneRules} .
    *
    * @param month
    *   the month of the month-day of the first day of the cutover week, not null
    * @param dayOfMonthIndicator
    *   the day of the month-day of the cutover week, positive if the week is that day or later,
    *   negative if the week is that day or earlier, counting from the last day of the month, from
-   * -28 to 31 excluding 0
+   *   -28 to 31 excluding 0
    * @param dayOfWeek
    *   the required day-of-week, null if the month-day should not be changed
    * @param time
@@ -268,8 +268,8 @@ final class ZoneOffsetTransitionRule private[zone] (
   /**
    * The day-of-month of the month-day of the cutover week. If positive, it is the start of the week
    * where the cutover can occur. If negative, it represents the end of the week where cutover can
-   * occur. The value is the number of days from the end of the month, such that {@code -1} is the
-   * last day of the month, {@code -2} is the second to last day, and so on.
+   * occur. The value is the number of days from the end of the month, such that {@@code-1} is the
+   * last day of the month, {@@code-2} is the second to last day, and so on.
    */
   private val dom: Byte = dayOfMonthIndicator.toByte
 
@@ -299,7 +299,7 @@ final class ZoneOffsetTransitionRule private[zone] (
    * treated as 1st March in non-leap years.
    *
    * If the value is negative, then it represents the number of days back from the end of the month
-   * where {@code -1} is the last day of the month. In this case, the day identified is the latest
+   * where {@@code-1} is the last day of the month. In this case, the day identified is the latest
    * possible date that the transition can be.
    *
    * @return
diff --git a/core/shared/src/main/scala-3/org/threeten/bp/DayOfWeek.scala b/core/shared/src/main/scala-3/org/threeten/bp/DayOfWeek.scala
index 2c4cc0f56..beaf02bcd 100644
--- a/core/shared/src/main/scala-3/org/threeten/bp/DayOfWeek.scala
+++ b/core/shared/src/main/scala-3/org/threeten/bp/DayOfWeek.scala
@@ -49,19 +49,19 @@ import org.threeten.bp.temporal.ValueRange
 /**
  * A day-of-week, such as 'Tuesday'.
  *
- * {@code DayOfWeek} is an enum representing the 7 days of the week - Monday, Tuesday, Wednesday,
+ * {@@codeDayOfWeek} is an enum representing the 7 days of the week - Monday, Tuesday, Wednesday,
  * Thursday, Friday, Saturday and Sunday.
  *
- * In addition to the textual enum name, each day-of-week has an {@code int} value. The {@code int}
+ * In addition to the textual enum name, each day-of-week has an {@@codeint} value. The {@@codeint}
  * value follows the ISO-8601 standard, from 1 (Monday) to 7 (Sunday). It is recommended that
- * applications use the enum rather than the {@code int} value to ensure code clarity.
+ * applications use the enum rather than the {@@codeint} value to ensure code clarity.
  *
  * This enum provides access to the localized textual form of the day-of-week. Some locales also
  * assign different numeric values to the days, declaring Sunday to have the value 1, however this
- * class provides no support for this. See {@link WeekFields} for localized week-numbering.
+ * class provides no support for this. See {@@linkWeekFields} for localized week-numbering.
  *
- * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code DayOfWeek}. Use
- * {@code getValue()} instead.</b>
+ * <b>Do not use {@@codeordinal()} to obtain the numeric representation of {@@codeDayOfWeek} . Use
+ * {@@codegetValue()} instead.</b>
  *
  * This enum represents a common concept that is found in many calendar systems. As such, this enum
  * may be used by any calendar system that has the day-of-week concept defined exactly equivalent to
@@ -77,10 +77,10 @@ object DayOfWeek {
   private lazy val ENUMS: Array[DayOfWeek] = DayOfWeek.values
 
   /**
-   * Obtains an instance of {@code DayOfWeek} from an {@code int} value.
+   * Obtains an instance of {@@codeDayOfWeek} from an {@@codeint} value.
    *
-   * {@code DayOfWeek} is an enum representing the 7 days of the week. This factory allows the enum
-   * to be obtained from the {@code int} value. The {@code int} value follows the ISO-8601 standard,
+   * {@@codeDayOfWeek} is an enum representing the 7 days of the week. This factory allows the enum
+   * to be obtained from the {@@codeint} value. The {@@codeint} value follows the ISO-8601 standard,
    * from 1 (Monday) to 7 (Sunday).
    *
    * @param dayOfWeek
@@ -97,22 +97,22 @@ object DayOfWeek {
       ENUMS(dayOfWeek - 1)
 
   /**
-   * Obtains an instance of {@code DayOfWeek} from a temporal object.
+   * Obtains an instance of {@@codeDayOfWeek} from a temporal object.
    *
-   * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code DayOfWeek}.
+   * A {@@codeTemporalAccessor} represents some form of date and time information. This factory
+   * converts the arbitrary temporal object to an instance of {@@codeDayOfWeek} .
    *
-   * The conversion extracts the {@link ChronoField#DAY_OF_WEEK DAY_OF_WEEK} field.
+   * The conversion extracts the {@@linkChronoField#DAY_OF_WEEK DAY_OF_WEEK} field.
    *
-   * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used as a query via method reference, {@code DayOfWeek::from}.
+   * This method matches the signature of the functional interface {@@linkTemporalQuery} allowing it
+   * to be used as a query via method reference, {@@codeDayOfWeek::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the day-of-week, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code DayOfWeek}
+   *   if unable to convert to a {@@codeDayOfWeek}
    */
   def from(temporal: TemporalAccessor): DayOfWeek = {
     temporal match {
@@ -136,12 +136,13 @@ enum DayOfWeek(name: String, ordinal: Int)
     with TemporalAdjuster {
 
   /**
-   * The singleton instance for the day-of-week of Monday. This has the numeric value of {@code 1}.
+   * The singleton instance for the day-of-week of Monday. This has the numeric value of {@@code1} .
    */
   case MONDAY extends DayOfWeek("MONDAY", 0)
 
   /**
-   * The singleton instance for the day-of-week of Tuesday. This has the numeric value of {@code 2}.
+   * The singleton instance for the day-of-week of Tuesday. This has the numeric value of {@@code2}
+   * .
    */
   case TUESDAY extends DayOfWeek("TUESDAY", 1)
 
@@ -158,7 +159,7 @@ enum DayOfWeek(name: String, ordinal: Int)
   case THURSDAY extends DayOfWeek("THURSDAY", 3)
 
   /**
-   * The singleton instance for the day-of-week of Friday. This has the numeric value of {@code 5}.
+   * The singleton instance for the day-of-week of Friday. This has the numeric value of {@@code5} .
    */
   case FRIDAY extends DayOfWeek("FRIDAY", 4)
 
@@ -169,15 +170,15 @@ enum DayOfWeek(name: String, ordinal: Int)
   case SATURDAY extends DayOfWeek("SATURDAY", 5)
 
   /**
-   * The singleton instance for the day-of-week of Sunday. This has the numeric value of {@code 7}.
+   * The singleton instance for the day-of-week of Sunday. This has the numeric value of {@@code7} .
    */
   case SUNDAY extends DayOfWeek("SUNDAY", 6)
 
   /**
-   * Gets the day-of-week {@code int} value.
+   * Gets the day-of-week {@@codeint} value.
    *
    * The values are numbered following the ISO-8601 standard, from 1 (Monday) to 7 (Sunday). See
-   * {@link WeekFields#dayOfWeek} for localized week-numbering.
+   * {@@linkWeekFields#dayOfWeek} for localized week-numbering.
    *
    * @return
    *   the day-of-week, from 1 (Monday) to 7 (Sunday)
@@ -190,7 +191,7 @@ enum DayOfWeek(name: String, ordinal: Int)
    * This returns the textual name used to identify the day-of-week. The parameters control the
    * length of the returned text and the locale.
    *
-   * If no textual mapping is found then the {@link #getValue() numeric value} is returned.
+   * If no textual mapping is found then the {@@link#getValue() numeric value} is returned.
    *
    * @param style
    *   the length of the text required, not null
@@ -206,14 +207,14 @@ enum DayOfWeek(name: String, ordinal: Int)
    * Checks if the specified field is supported.
    *
    * This checks if this day-of-week can be queried for the specified field. If false, then calling
-   * the {@link #range(TemporalField) range} and {@link #get(TemporalField) get} methods will throw
+   * the {@@link#range(TemporalField) range} and {@@link#get(TemporalField) get} methods will throw
    * an exception.
    *
-   * If the field is {@link ChronoField#DAY_OF_WEEK DAY_OF_WEEK} then this method returns true. All
-   * other {@code ChronoField} instances will return false.
+   * If the field is {@@linkChronoField#DAY_OF_WEEK DAY_OF_WEEK} then this method returns true. All
+   * other {@@codeChronoField} instances will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.isSupportedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the field is supported is determined by the field.
    *
    * @param field
@@ -234,12 +235,12 @@ enum DayOfWeek(name: String, ordinal: Int)
    * is used to enhance the accuracy of the returned range. If it is not possible to return the
    * range, because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is {@link ChronoField#DAY_OF_WEEK DAY_OF_WEEK} then the range of the day-of-week,
-   * from 1 to 7, will be returned. All other {@code ChronoField} instances will throw a {@code
+   * If the field is {@@linkChronoField#DAY_OF_WEEK DAY_OF_WEEK} then the range of the day-of-week,
+   * from 1 to 7, will be returned. All other {@@codeChronoField} instances will throw a {@code
    * DateTimeException}.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.rangeRefinedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
    * @param field
@@ -258,18 +259,18 @@ enum DayOfWeek(name: String, ordinal: Int)
       field.rangeRefinedBy(this)
 
   /**
-   * Gets the value of the specified field from this day-of-week as an {@code int}.
+   * Gets the value of the specified field from this day-of-week as an {@@codeint} .
    *
    * This queries this day-of-week for the value for the specified field. The returned value will
    * always be within the valid range of values for the field. If it is not possible to return the
    * value, because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is {@link ChronoField#DAY_OF_WEEK DAY_OF_WEEK} then the value of the day-of-week,
-   * from 1 to 7, will be returned. All other {@code ChronoField} instances will throw a {@code
+   * If the field is {@@linkChronoField#DAY_OF_WEEK DAY_OF_WEEK} then the value of the day-of-week,
+   * from 1 to 7, will be returned. All other {@@codeChronoField} instances will throw a {@code
    * DateTimeException}.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -279,7 +280,7 @@ enum DayOfWeek(name: String, ordinal: Int)
    * @throws DateTimeException
    *   if a value for the field cannot be obtained
    * @throws DateTimeException
-   *   if the range of valid values for the field exceeds an { @code int}
+   *   if the range of valid values for the field exceeds an {@@codeint}
    * @throws DateTimeException
    *   if the value is outside the range of valid values for the field
    * @throws ArithmeticException
@@ -292,18 +293,18 @@ enum DayOfWeek(name: String, ordinal: Int)
       range(field).checkValidIntValue(getLong(field), field)
 
   /**
-   * Gets the value of the specified field from this day-of-week as a {@code long}.
+   * Gets the value of the specified field from this day-of-week as a {@@codelong} .
    *
    * This queries this day-of-week for the value for the specified field. If it is not possible to
    * return the value, because the field is not supported or for some other reason, an exception is
    * thrown.
    *
-   * If the field is {@link ChronoField#DAY_OF_WEEK DAY_OF_WEEK} then the value of the day-of-week,
-   * from 1 to 7, will be returned. All other {@code ChronoField} instances will throw a {@code
+   * If the field is {@@linkChronoField#DAY_OF_WEEK DAY_OF_WEEK} then the value of the day-of-week,
+   * from 1 to 7, will be returned. All other {@@codeChronoField} instances will throw a {@code
    * DateTimeException}.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -364,7 +365,7 @@ enum DayOfWeek(name: String, ordinal: Int)
    * of the query to understand what the result of this method will be.
    *
    * The result of this method is obtained by invoking the {@link
-   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@code this}
+   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@@codethis}
    * as the argument.
    *
    * @tparam R
@@ -394,10 +395,10 @@ enum DayOfWeek(name: String, ordinal: Int)
    * This returns a temporal object of the same observable type as the input with the day-of-week
    * changed to be the same as this.
    *
-   * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)} passing {@link
+   * The adjustment is equivalent to using {@@linkTemporal#with(TemporalField, long)} passing {@link
    * ChronoField#DAY_OF_WEEK} as the field. Note that this adjusts forwards or backwards within a
-   * Monday to Sunday week. See {@link WeekFields#dayOfWeek} for localized week start days. See
-   * {@link TemporalAdjusters} for other adjusters with more control, such as {@code next(MONDAY)}.
+   * Monday to Sunday week. See {@@linkWeekFields#dayOfWeek} for localized week start days. See
+   * {@@linkTemporalAdjusters} for other adjusters with more control, such as {@@codenext(MONDAY)} .
    *
    * In most cases, it is clearer to reverse the calling pattern by using {@link
    * Temporal#with(TemporalAdjuster)}: <pre> // these two lines are equivalent, but the second
diff --git a/core/shared/src/main/scala-3/org/threeten/bp/Month.scala b/core/shared/src/main/scala-3/org/threeten/bp/Month.scala
index c46abd64f..7b17fd41f 100644
--- a/core/shared/src/main/scala-3/org/threeten/bp/Month.scala
+++ b/core/shared/src/main/scala-3/org/threeten/bp/Month.scala
@@ -52,16 +52,16 @@ import org.threeten.bp.temporal.ValueRange
 /**
  * A month-of-year, such as 'July'.
  *
- * {@code Month} is an enum representing the 12 months of the year - January, February, March,
+ * {@@codeMonth} is an enum representing the 12 months of the year - January, February, March,
  * April, May, June, July, August, September, October, November and December.
  *
- * In addition to the textual enum name, each month-of-year has an {@code int} value. The {@code
+ * In addition to the textual enum name, each month-of-year has an {@@codeint} value. The {@code
  * int} value follows normal usage and the ISO-8601 standard, from 1 (January) to 12 (December). It
- * is recommended that applications use the enum rather than the {@code int} value to ensure code
+ * is recommended that applications use the enum rather than the {@@codeint} value to ensure code
  * clarity.
  *
- * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code Month}. Use {@code
- * getValue()} instead.</b>
+ * <b>Do not use {@@codeordinal()} to obtain the numeric representation of {@@codeMonth} . Use
+ * {@code getValue()} instead.</b>
  *
  * This enum represents a common concept that is found in many calendar systems. As such, this enum
  * may be used by any calendar system that has the month-of-year concept defined exactly equivalent
@@ -77,10 +77,10 @@ object Month {
   private lazy val ENUMS: Array[Month] = Month.values
 
   /**
-   * Obtains an instance of {@code Month} from an {@code int} value.
+   * Obtains an instance of {@@codeMonth} from an {@@codeint} value.
    *
-   * {@code Month} is an enum representing the 12 months of the year. This factory allows the enum
-   * to be obtained from the {@code int} value. The {@code int} value follows the ISO-8601 standard,
+   * {@@codeMonth} is an enum representing the 12 months of the year. This factory allows the enum
+   * to be obtained from the {@@codeint} value. The {@@codeint} value follows the ISO-8601 standard,
    * from 1 (January) to 12 (December).
    *
    * @param month
@@ -97,24 +97,24 @@ object Month {
       ENUMS(month - 1)
 
   /**
-   * Obtains an instance of {@code Month} from a temporal object.
+   * Obtains an instance of {@@codeMonth} from a temporal object.
    *
-   * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code Month}.
+   * A {@@codeTemporalAccessor} represents some form of date and time information. This factory
+   * converts the arbitrary temporal object to an instance of {@@codeMonth} .
    *
-   * The conversion extracts the {@link ChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} field. The
+   * The conversion extracts the {@@linkChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} field. The
    * extraction is only permitted if the temporal object has an ISO chronology, or can be converted
-   * to a {@code LocalDate}.
+   * to a {@@codeLocalDate} .
    *
-   * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used in queries via method reference, {@code Month::from}.
+   * This method matches the signature of the functional interface {@@linkTemporalQuery} allowing it
+   * to be used in queries via method reference, {@@codeMonth::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the month-of-year, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code Month}
+   *   if unable to convert to a {@@codeMonth}
    */
   def from(temporal: TemporalAccessor): Month = {
     var _temporal = temporal
@@ -143,25 +143,25 @@ enum Month private (name: String, ordinal: Int)
 
   /**
    * The singleton instance for the month of January with 31 days. This has the numeric value of
-   * {@code 1}.
+   * {@@code1} .
    */
   case JANUARY extends Month("JANUARY", 0)
 
   /**
    * The singleton instance for the month of February with 28 days, or 29 in a leap year. This has
-   * the numeric value of {@code 2}.
+   * the numeric value of {@@code2} .
    */
   case FEBRUARY extends Month("FEBRUARY", 1)
 
   /**
    * The singleton instance for the month of March with 31 days. This has the numeric value of
-   * {@code 3}.
+   * {@@code3} .
    */
   case MARCH extends Month("MARCH", 2)
 
   /**
    * The singleton instance for the month of April with 30 days. This has the numeric value of
-   * {@code 4}.
+   * {@@code4} .
    */
   case APRIL extends Month("APRIL", 3)
 
@@ -185,38 +185,38 @@ enum Month private (name: String, ordinal: Int)
 
   /**
    * The singleton instance for the month of August with 31 days. This has the numeric value of
-   * {@code 8}.
+   * {@@code8} .
    */
   case AUGUST extends Month("AUGUST", 7)
 
   /**
    * The singleton instance for the month of September with 30 days. This has the numeric value of
-   * {@code 9}.
+   * {@@code9} .
    */
   case SEPTEMBER extends Month("SEPTEMBER", 8)
 
   /**
    * The singleton instance for the month of October with 31 days. This has the numeric value of
-   * {@code 10}.
+   * {@@code10} .
    */
   case OCTOBER extends Month("OCTOBER", 9)
 
   /**
    * The singleton instance for the month of November with 30 days. This has the numeric value of
-   * {@code 11}.
+   * {@@code11} .
    */
   case NOVEMBER extends Month("NOVEMBER", 10)
 
   /**
    * The singleton instance for the month of December with 31 days. This has the numeric value of
-   * {@code 12}.
+   * {@@code12} .
    */
   case DECEMBER extends Month("DECEMBER", 11)
 
   import Month._
 
   /**
-   * Gets the month-of-year {@code int} value.
+   * Gets the month-of-year {@@codeint} value.
    *
    * The values are numbered following the ISO-8601 standard, from 1 (January) to 12 (December).
    *
@@ -231,7 +231,7 @@ enum Month private (name: String, ordinal: Int)
    * This returns the textual name used to identify the month-of-year. The parameters control the
    * length of the returned text and the locale.
    *
-   * If no textual mapping is found then the {@link #getValue() numeric value} is returned.
+   * If no textual mapping is found then the {@@link#getValue() numeric value} is returned.
    *
    * @param style
    *   the length of the text required, not null
@@ -247,14 +247,14 @@ enum Month private (name: String, ordinal: Int)
    * Checks if the specified field is supported.
    *
    * This checks if this month-of-year can be queried for the specified field. If false, then
-   * calling the {@link #range(TemporalField) range} and {@link #get(TemporalField) get} methods
+   * calling the {@@link#range(TemporalField) range} and {@@link#get(TemporalField) get} methods
    * will throw an exception.
    *
-   * If the field is {@link ChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} then this method returns true.
-   * All other {@code ChronoField} instances will return false.
+   * If the field is {@@linkChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} then this method returns true.
+   * All other {@@codeChronoField} instances will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.isSupportedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the field is supported is determined by the field.
    *
    * @param field
@@ -275,12 +275,12 @@ enum Month private (name: String, ordinal: Int)
    * to enhance the accuracy of the returned range. If it is not possible to return the range,
    * because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is {@link ChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} then the range of the
-   * month-of-year, from 1 to 12, will be returned. All other {@code ChronoField} instances will
-   * throw a {@code DateTimeException}.
+   * If the field is {@@linkChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} then the range of the
+   * month-of-year, from 1 to 12, will be returned. All other {@@codeChronoField} instances will
+   * throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.rangeRefinedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
    * @param field
@@ -299,18 +299,18 @@ enum Month private (name: String, ordinal: Int)
       field.rangeRefinedBy(this)
 
   /**
-   * Gets the value of the specified field from this month-of-year as an {@code int}.
+   * Gets the value of the specified field from this month-of-year as an {@@codeint} .
    *
    * This queries this month for the value for the specified field. The returned value will always
    * be within the valid range of values for the field. If it is not possible to return the value,
    * because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is {@link ChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} then the value of the
-   * month-of-year, from 1 to 12, will be returned. All other {@code ChronoField} instances will
-   * throw a {@code DateTimeException}.
+   * If the field is {@@linkChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} then the value of the
+   * month-of-year, from 1 to 12, will be returned. All other {@@codeChronoField} instances will
+   * throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -320,7 +320,7 @@ enum Month private (name: String, ordinal: Int)
    * @throws DateTimeException
    *   if a value for the field cannot be obtained
    * @throws DateTimeException
-   *   if the range of valid values for the field exceeds an { @code int}
+   *   if the range of valid values for the field exceeds an {@@codeint}
    * @throws DateTimeException
    *   if the value is outside the range of valid values for the field
    * @throws ArithmeticException
@@ -333,17 +333,17 @@ enum Month private (name: String, ordinal: Int)
       range(field).checkValidIntValue(getLong(field), field)
 
   /**
-   * Gets the value of the specified field from this month-of-year as a {@code long}.
+   * Gets the value of the specified field from this month-of-year as a {@@codelong} .
    *
    * This queries this month for the value for the specified field. If it is not possible to return
    * the value, because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is {@link ChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} then the value of the
-   * month-of-year, from 1 to 12, will be returned. All other {@code ChronoField} instances will
-   * throw a {@code DateTimeException}.
+   * If the field is {@@linkChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} then the value of the
+   * month-of-year, from 1 to 12, will be returned. All other {@@codeChronoField} instances will
+   * throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -497,7 +497,7 @@ enum Month private (name: String, ordinal: Int)
    * of the query to understand what the result of this method will be.
    *
    * The result of this method is obtained by invoking the {@link
-   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@code this}
+   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@@codethis}
    * as the argument.
    *
    * @tparam R
@@ -529,9 +529,9 @@ enum Month private (name: String, ordinal: Int)
    * This returns a temporal object of the same observable type as the input with the month-of-year
    * changed to be the same as this.
    *
-   * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)} passing {@link
+   * The adjustment is equivalent to using {@@linkTemporal#with(TemporalField, long)} passing {@link
    * ChronoField#MONTH_OF_YEAR} as the field. If the specified temporal object does not use the ISO
-   * calendar system then a {@code DateTimeException} is thrown.
+   * calendar system then a {@@codeDateTimeException} is thrown.
    *
    * In most cases, it is clearer to reverse the calling pattern by using {@link
    * Temporal#with(TemporalAdjuster)}: <pre> // these two lines are equivalent, but the second
diff --git a/core/shared/src/main/scala-3/org/threeten/bp/chrono/HijrahEra.scala b/core/shared/src/main/scala-3/org/threeten/bp/chrono/HijrahEra.scala
index 1d28e44d9..3d74dbf2c 100644
--- a/core/shared/src/main/scala-3/org/threeten/bp/chrono/HijrahEra.scala
+++ b/core/shared/src/main/scala-3/org/threeten/bp/chrono/HijrahEra.scala
@@ -41,7 +41,7 @@ import org.threeten.bp.temporal.ValueRange
 object HijrahEra {
 
   /**
-   * Obtains an instance of {@code HijrahEra} from a value.
+   * Obtains an instance of {@@codeHijrahEra} from a value.
    *
    * The current era (from ISO date 622-06-19 onwards) has the value 1 The previous era has the
    * value 0.
@@ -65,11 +65,11 @@ object HijrahEra {
 /**
  * An era in the Hijrah calendar system.
  *
- * The Hijrah calendar system has two eras. The date {@code 0001-01-01 (Hijrah)} is {@code 622-06-19
+ * The Hijrah calendar system has two eras. The date {@@code0001-01-01 (Hijrah)} is {@code 622-06-19
  * (ISO)}.
  *
- * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code HijrahEra}. Use
- * {@code getValue()} instead.</b>
+ * <b>Do not use {@@codeordinal()} to obtain the numeric representation of {@@codeHijrahEra} . Use
+ * {@@codegetValue()} instead.</b>
  *
  * <h3>Specification for implementors</h3> This is an immutable and thread-safe enum.
  */
diff --git a/core/shared/src/main/scala-3/org/threeten/bp/chrono/IsoEra.scala b/core/shared/src/main/scala-3/org/threeten/bp/chrono/IsoEra.scala
index 4625e136a..011f49b3f 100644
--- a/core/shared/src/main/scala-3/org/threeten/bp/chrono/IsoEra.scala
+++ b/core/shared/src/main/scala-3/org/threeten/bp/chrono/IsoEra.scala
@@ -36,10 +36,10 @@ import org.threeten.bp.DateTimeException
 object IsoEra {
 
   /**
-   * Obtains an instance of {@code IsoEra} from an {@code int} value.
+   * Obtains an instance of {@@codeIsoEra} from an {@@codeint} value.
    *
-   * {@code IsoEra} is an enum representing the ISO eras of BCE/CE. This factory allows the enum to
-   * be obtained from the {@code int} value.
+   * {@@codeIsoEra} is an enum representing the ISO eras of BCE/CE. This factory allows the enum to
+   * be obtained from the {@@codeint} value.
    *
    * @param era
    *   the BCE/CE value to represent, from 0 (BCE) to 1 (CE)
@@ -63,8 +63,8 @@ object IsoEra {
  * \- 'Current era' (CE) for years from 0001-01-01 (ISO) and 'Before current era' (BCE) for years
  * before that.
  *
- * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code IsoEra}. Use
- * {@code getValue()} instead.</b>
+ * <b>Do not use {@@codeordinal()} to obtain the numeric representation of {@@codeIsoEra} . Use
+ * {@@codegetValue()} instead.</b>
  *
  * <h3>Specification for implementors</h3> This is an immutable and thread-safe enum.
  */
@@ -73,19 +73,19 @@ enum IsoEra(name: String, ordinal: Int) extends java.lang.Enum[IsoEra] with Era
   /**
    * The singleton instance for the era BCE, 'Before Current Era'. The 'ISO' part of the name
    * emphasizes that this differs from the BCE era in the Gregorian calendar system. This has the
-   * numeric value of {@code 0}.
+   * numeric value of {@@code0} .
    */
   case BCE extends IsoEra("BCE", 0)
 
   /**
    * The singleton instance for the era CE, 'Current Era'. The 'ISO' part of the name emphasizes
    * that this differs from the CE era in the Gregorian calendar system. This has the numeric value
-   * of {@code 1}.
+   * of {@@code1} .
    */
   case CE extends IsoEra("CE", 1)
 
   /**
-   * Gets the numeric era {@code int} value.
+   * Gets the numeric era {@@codeint} value.
    *
    * The era BCE has the value 0, while the era CE has the value 1.
    *
diff --git a/core/shared/src/main/scala-3/org/threeten/bp/chrono/MinguoEra.scala b/core/shared/src/main/scala-3/org/threeten/bp/chrono/MinguoEra.scala
index ce3660ba7..caaa82648 100644
--- a/core/shared/src/main/scala-3/org/threeten/bp/chrono/MinguoEra.scala
+++ b/core/shared/src/main/scala-3/org/threeten/bp/chrono/MinguoEra.scala
@@ -36,10 +36,10 @@ import org.threeten.bp.DateTimeException
 object MinguoEra {
 
   /**
-   * Obtains an instance of {@code MinguoEra} from an {@code int} value.
+   * Obtains an instance of {@@codeMinguoEra} from an {@@codeint} value.
    *
-   * {@code MinguoEra} is an enum representing the Minguo eras of BEFORE_ROC/ROC. This factory
-   * allows the enum to be obtained from the {@code int} value.
+   * {@@codeMinguoEra} is an enum representing the Minguo eras of BEFORE_ROC/ROC. This factory
+   * allows the enum to be obtained from the {@@codeint} value.
    *
    * @param era
    *   the BEFORE_ROC/ROC value to represent, from 0 (BEFORE_ROC) to 1 (ROC)
@@ -60,11 +60,11 @@ object MinguoEra {
 /**
  * An era in the Minguo calendar system.
  *
- * The Minguo calendar system has two eras. The date {@code 0001-01-01 (Minguo)} is equal to {@code
+ * The Minguo calendar system has two eras. The date {@@code0001-01-01 (Minguo)} is equal to {@code
  * 1912-01-01 (ISO)}.
  *
- * <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code MinguoEra}. Use
- * {@code getValue()} instead.</b>
+ * <b>Do not use {@@codeordinal()} to obtain the numeric representation of {@@codeMinguoEra} . Use
+ * {@@codegetValue()} instead.</b>
  *
  * <h3>Specification for implementors</h3> This is an immutable and thread-safe enum.
  */
@@ -72,18 +72,18 @@ enum MinguoEra(name: String, ordinal: Int) extends java.lang.Enum[MinguoEra] wit
 
   /**
    * The singleton instance for the era BEFORE_ROC, 'Before Republic of China'. This has the numeric
-   * value of {@code 0}.
+   * value of {@@code0} .
    */
   case BEFORE_ROC extends MinguoEra("BEFORE_ROC", 0)
 
   /**
    * The singleton instance for the era ROC, 'Republic of China'. This has the numeric value of
-   * {@code 1}.
+   * {@@code1} .
    */
   case ROC extends MinguoEra("ROC", 1)
 
   /**
-   * Gets the numeric era {@code int} value.
+   * Gets the numeric era {@@codeint} value.
    *
    * The era BEFORE_ROC has the value 0, while the era ROC has the value 1.
    *
diff --git a/core/shared/src/main/scala-3/org/threeten/bp/chrono/ThaiBuddhistEra.scala b/core/shared/src/main/scala-3/org/threeten/bp/chrono/ThaiBuddhistEra.scala
index 205f7c821..0b01c5494 100644
--- a/core/shared/src/main/scala-3/org/threeten/bp/chrono/ThaiBuddhistEra.scala
+++ b/core/shared/src/main/scala-3/org/threeten/bp/chrono/ThaiBuddhistEra.scala
@@ -36,7 +36,7 @@ import org.threeten.bp.DateTimeException
 object ThaiBuddhistEra {
 
   /**
-   * Obtains an instance of {@code ThaiBuddhistEra} from a value.
+   * Obtains an instance of {@@codeThaiBuddhistEra} from a value.
    *
    * The current era (from ISO year -543 onwards) has the value 1 The previous era has the value 0.
    *
diff --git a/core/shared/src/main/scala-3/org/threeten/bp/format/FormatStyle.scala b/core/shared/src/main/scala-3/org/threeten/bp/format/FormatStyle.scala
index b1b7ff3fe..974259b1c 100644
--- a/core/shared/src/main/scala-3/org/threeten/bp/format/FormatStyle.scala
+++ b/core/shared/src/main/scala-3/org/threeten/bp/format/FormatStyle.scala
@@ -35,7 +35,7 @@ package org.threeten.bp.format
  * Enumeration of the style of a localized date, time or date-time formatter.
  *
  * These styles are used when obtaining a date-time style from configuration. See {@link
- * DateTimeFormatter} and {@link DateTimeFormatterBuilder} for usage.
+ * DateTimeFormatter} and {@@linkDateTimeFormatterBuilder} for usage.
  *
  * <h3>Specification for implementors</h3> This is an immutable and thread-safe enum.
  */
diff --git a/core/shared/src/main/scala-3/org/threeten/bp/format/SignStyle.scala b/core/shared/src/main/scala-3/org/threeten/bp/format/SignStyle.scala
index d2e2585ac..1fb642f3d 100644
--- a/core/shared/src/main/scala-3/org/threeten/bp/format/SignStyle.scala
+++ b/core/shared/src/main/scala-3/org/threeten/bp/format/SignStyle.scala
@@ -35,7 +35,7 @@ package org.threeten.bp.format
  * Enumeration of ways to handle the positive/negative sign.
  *
  * The formatting engine allows the positive and negative signs of numbers to be controlled using
- * this enum. See {@link DateTimeFormatterBuilder} for usage.
+ * this enum. See {@@linkDateTimeFormatterBuilder} for usage.
  *
  * <h3>Specification for implementors</h3> This is an immutable and thread-safe enum.
  */
diff --git a/core/shared/src/main/scala-3/org/threeten/bp/format/internal/TTBPDateTimeFormatterBuilder.scala b/core/shared/src/main/scala-3/org/threeten/bp/format/internal/TTBPDateTimeFormatterBuilder.scala
index 876addf5e..b37ef4441 100644
--- a/core/shared/src/main/scala-3/org/threeten/bp/format/internal/TTBPDateTimeFormatterBuilder.scala
+++ b/core/shared/src/main/scala-3/org/threeten/bp/format/internal/TTBPDateTimeFormatterBuilder.scala
@@ -279,8 +279,8 @@ object TTBPDateTimeFormatterBuilder {
    * @param signStyle
    *   the positive/negative sign style, not null
    * @param subsequentWidth
-   *   the width of subsequent non-negative numbers, 0 or greater,
-   * -1 if fixed width due to active adjacent parsing
+   *   the width of subsequent non-negative numbers, 0 or greater, -1 if fixed width due to active
+   *   adjacent parsing
    */
   private[format] class NumberPrinterParser private[format] (
     private[format] val field:           TemporalField,
@@ -763,7 +763,7 @@ object TTBPDateTimeFormatterBuilder {
      * Converts a value for this field to a fraction between 0 and 1.
      *
      * The fractional value is between 0 (inclusive) and 1 (exclusive). It can only be returned if
-     * the {@link TemporalField#range() value range} is fixed. The fraction is obtained by
+     * the {@@linkTemporalField#range() value range} is fixed. The fraction is obtained by
      * calculation from the field range using 9 decimal places and a rounding mode of {@link
      * RoundingMode#FLOOR FLOOR}. The calculation is inaccurate if the values do not run
      * continuously from smallest to largest.
@@ -793,9 +793,9 @@ object TTBPDateTimeFormatterBuilder {
      * Converts a fraction from 0 to 1 for this field to a value.
      *
      * The fractional value must be between 0 (inclusive) and 1 (exclusive). It can only be returned
-     * if the {@link TemporalField#range() value range} is fixed. The value is obtained by
-     * calculation from the field range and a rounding mode of {@link RoundingMode#FLOOR FLOOR}. The
-     * calculation is inaccurate if the values do not run continuously from smallest to largest.
+     * if the {@@linkTemporalField#range() value range} is fixed. The value is obtained by
+     * calculation from the field range and a rounding mode of {@@linkRoundingMode#FLOOR FLOOR} .
+     * The calculation is inaccurate if the values do not run continuously from smallest to largest.
      *
      * For example, the fractional second-of-minute of 0.25 would be converted to 15, assuming the
      * standard definition of 60 seconds in a minute.
diff --git a/core/shared/src/main/scala-3/org/threeten/bp/temporal/ChronoField.scala b/core/shared/src/main/scala-3/org/threeten/bp/temporal/ChronoField.scala
index 50491e1f9..5b0aa10ae 100644
--- a/core/shared/src/main/scala-3/org/threeten/bp/temporal/ChronoField.scala
+++ b/core/shared/src/main/scala-3/org/threeten/bp/temporal/ChronoField.scala
@@ -52,7 +52,7 @@ import org.threeten.bp.format.ResolverStyle
  * A standard set of fields.
  *
  * This set of fields provide field-based access to manipulate a date, time or date-time. The
- * standard set of fields can be extended by implementing {@link TemporalField}.
+ * standard set of fields can be extended by implementing {@@linkTemporalField} .
  *
  * These fields are intended to be applicable in multiple calendar systems. For example, most
  * non-ISO calendar systems define dates as a year, month and day, just with slightly different
@@ -79,8 +79,8 @@ enum ChronoField private (
    * meaning for all calendar systems.
    *
    * This field is used to represent the nano-of-second handling any fraction of the second.
-   * Implementations of {@code TemporalAccessor} should provide a value for this field if they can
-   * return a value for {@link #SECOND_OF_MINUTE}, {@link #SECOND_OF_DAY} or {@link
+   * Implementations of {@@codeTemporalAccessor} should provide a value for this field if they can
+   * return a value for {@@link#SECOND_OF_MINUTE} , {@@link#SECOND_OF_DAY} or {@link
    * #INSTANT_SECONDS} filling unknown precision with zero.
    *
    * When this field is used for setting a value, it should set as much precision as the object
@@ -98,8 +98,8 @@ enum ChronoField private (
    * field has the same meaning for all calendar systems.
    *
    * This field is used to represent the nano-of-day handling any fraction of the second.
-   * Implementations of {@code TemporalAccessor} should provide a value for this field if they can
-   * return a value for {@link #SECOND_OF_DAY} filling unknown precision with zero.
+   * Implementations of {@@codeTemporalAccessor} should provide a value for this field if they can
+   * return a value for {@@link#SECOND_OF_DAY} filling unknown precision with zero.
    */
   case NANO_OF_DAY
       extends ChronoField("NanoOfDay", 1, NANOS, DAYS, ValueRange.of(0, 86400L * 1000000000L - 1))
@@ -111,8 +111,8 @@ enum ChronoField private (
    * meaning for all calendar systems.
    *
    * This field is used to represent the micro-of-second handling any fraction of the second.
-   * Implementations of {@code TemporalAccessor} should provide a value for this field if they can
-   * return a value for {@link #SECOND_OF_MINUTE}, {@link #SECOND_OF_DAY} or {@link
+   * Implementations of {@@codeTemporalAccessor} should provide a value for this field if they can
+   * return a value for {@@link#SECOND_OF_MINUTE} , {@@link#SECOND_OF_DAY} or {@link
    * #INSTANT_SECONDS} filling unknown precision with zero.
    *
    * When this field is used for setting a value, it should behave in the same way as setting {@link
@@ -128,8 +128,8 @@ enum ChronoField private (
    * field has the same meaning for all calendar systems.
    *
    * This field is used to represent the micro-of-day handling any fraction of the second.
-   * Implementations of {@code TemporalAccessor} should provide a value for this field if they can
-   * return a value for {@link #SECOND_OF_DAY} filling unknown precision with zero.
+   * Implementations of {@@codeTemporalAccessor} should provide a value for this field if they can
+   * return a value for {@@link#SECOND_OF_DAY} filling unknown precision with zero.
    *
    * When this field is used for setting a value, it should behave in the same way as setting {@link
    * #NANO_OF_DAY} with the value multiplied by 1,000.
@@ -144,8 +144,8 @@ enum ChronoField private (
    * for all calendar systems.
    *
    * This field is used to represent the milli-of-second handling any fraction of the second.
-   * Implementations of {@code TemporalAccessor} should provide a value for this field if they can
-   * return a value for {@link #SECOND_OF_MINUTE}, {@link #SECOND_OF_DAY} or {@link
+   * Implementations of {@@codeTemporalAccessor} should provide a value for this field if they can
+   * return a value for {@@link#SECOND_OF_MINUTE} , {@@link#SECOND_OF_DAY} or {@link
    * #INSTANT_SECONDS} filling unknown precision with zero.
    *
    * When this field is used for setting a value, it should behave in the same way as setting {@link
@@ -161,8 +161,8 @@ enum ChronoField private (
    * has the same meaning for all calendar systems.
    *
    * This field is used to represent the milli-of-day handling any fraction of the second.
-   * Implementations of {@code TemporalAccessor} should provide a value for this field if they can
-   * return a value for {@link #SECOND_OF_DAY} filling unknown precision with zero.
+   * Implementations of {@@codeTemporalAccessor} should provide a value for this field if they can
+   * return a value for {@@link#SECOND_OF_DAY} filling unknown precision with zero.
    *
    * When this field is used for setting a value, it should behave in the same way as setting {@link
    * #NANO_OF_DAY} with the value multiplied by 1,000,000.
@@ -251,12 +251,12 @@ enum ChronoField private (
    * The day-of-week, such as Tuesday.
    *
    * This represents the standard concept of the day of the week. In the default ISO calendar
-   * system, this has values from Monday (1) to Sunday (7). The {@link DayOfWeek} class can be used
+   * system, this has values from Monday (1) to Sunday (7). The {@@linkDayOfWeek} class can be used
    * to interpret the result.
    *
    * Most non-ISO calendar systems also define a seven day week that aligns with ISO. Those calendar
    * systems must also use the same numbering system, from Monday (1) to Sunday (7), which allows
-   * {@code DayOfWeek} to be used.
+   * {@@codeDayOfWeek} to be used.
    *
    * Calendar systems that do not have a standard seven day week should implement this field if they
    * have a similar concept of named or numbered days within a period similar to a week. It is
@@ -414,14 +414,14 @@ enum ChronoField private (
    * The year within the era.
    *
    * This represents the concept of the year within the era. This field is typically used with
-   * {@link #ERA}.
+   * {@@link#ERA} .
    *
    * The standard mental model for a date is based on three concepts - year, month and day. These
-   * map onto the {@code YEAR}, {@code MONTH_OF_YEAR} and {@code DAY_OF_MONTH} fields. Note that
+   * map onto the {@@codeYEAR} , {@@codeMONTH_OF_YEAR} and {@@codeDAY_OF_MONTH} fields. Note that
    * there is no reference to eras. The full model for a date requires four concepts - era, year,
-   * month and day. These map onto the {@code ERA}, {@code YEAR_OF_ERA}, {@code MONTH_OF_YEAR} and
-   * {@code DAY_OF_MONTH} fields. Whether this field or {@code YEAR} is used depends on which mental
-   * model is being used. See {@link ChronoLocalDate} for more discussion on this topic.
+   * month and day. These map onto the {@@codeERA} , {@@codeYEAR_OF_ERA} , {@@codeMONTH_OF_YEAR} and
+   * {@@codeDAY_OF_MONTH} fields. Whether this field or {@@codeYEAR} is used depends on which mental
+   * model is being used. See {@@linkChronoLocalDate} for more discussion on this topic.
    *
    * In the default ISO calendar system, there are two eras defined, 'BCE' and 'CE'. The era 'CE' is
    * the one currently in use and year-of-era runs from 1 to the maximum value. The era 'BCE' is the
@@ -456,15 +456,15 @@ enum ChronoField private (
    * The proleptic year, such as 2012.
    *
    * This represents the concept of the year, counting sequentially and using negative numbers. The
-   * proleptic year is not interpreted in terms of the era. See {@link #YEAR_OF_ERA} for an example
+   * proleptic year is not interpreted in terms of the era. See {@@link#YEAR_OF_ERA} for an example
    * showing the mapping from proleptic year to year-of-era.
    *
    * The standard mental model for a date is based on three concepts - year, month and day. These
-   * map onto the {@code YEAR}, {@code MONTH_OF_YEAR} and {@code DAY_OF_MONTH} fields. Note that
+   * map onto the {@@codeYEAR} , {@@codeMONTH_OF_YEAR} and {@@codeDAY_OF_MONTH} fields. Note that
    * there is no reference to eras. The full model for a date requires four concepts - era, year,
-   * month and day. These map onto the {@code ERA}, {@code YEAR_OF_ERA}, {@code MONTH_OF_YEAR} and
-   * {@code DAY_OF_MONTH} fields. Whether this field or {@code YEAR_OF_ERA} is used depends on which
-   * mental model is being used. See {@link ChronoLocalDate} for more discussion on this topic.
+   * month and day. These map onto the {@@codeERA} , {@@codeYEAR_OF_ERA} , {@@codeMONTH_OF_YEAR} and
+   * {@@codeDAY_OF_MONTH} fields. Whether this field or {@@codeYEAR_OF_ERA} is used depends on which
+   * mental model is being used. See {@@linkChronoLocalDate} for more discussion on this topic.
    *
    * Non-ISO calendar systems should implement this field as follows. If the calendar system has
    * only two eras, before and after a fixed date, then the proleptic-year value must be the same as
@@ -484,11 +484,11 @@ enum ChronoField private (
    * The era.
    *
    * This represents the concept of the era, which is the largest division of the time-line. This
-   * field is typically used with {@link #YEAR_OF_ERA}.
+   * field is typically used with {@@link#YEAR_OF_ERA} .
    *
    * In the default ISO calendar system, there are two eras defined, 'BCE' and 'CE'. The era 'CE' is
    * the one currently in use and year-of-era runs from 1 to the maximum value. The era 'BCE' is the
-   * previous era, and the year-of-era runs backwards. See {@link #YEAR_OF_ERA} for a full example.
+   * previous era, and the year-of-era runs backwards. See {@@link#YEAR_OF_ERA} for a full example.
    *
    * Non-ISO calendar systems should implement this field to define eras. The value of the era that
    * was active on 1970-01-01 (ISO) must be assigned the value 1. Earlier eras must have
@@ -500,9 +500,9 @@ enum ChronoField private (
    * The instant epoch-seconds.
    *
    * This represents the concept of the sequential count of seconds where 1970-01-01T00:00Z (ISO) is
-   * zero. This field may be used with {@link #NANO_OF_DAY} to represent the fraction of the day.
+   * zero. This field may be used with {@@link#NANO_OF_DAY} to represent the fraction of the day.
    *
-   * An {@link Instant} represents an instantaneous point on the time-line. On their own they have
+   * An {@@linkInstant} represents an instantaneous point on the time-line. On their own they have
    * no elements which allow a local date-time to be obtained. Only when paired with an offset or
    * time-zone can the local date or time be found. This field allows the seconds part of the
    * instant to be queried.
@@ -523,10 +523,10 @@ enum ChronoField private (
    *
    * This represents the concept of the offset in seconds of local time from UTC/Greenwich.
    *
-   * A {@link ZoneOffset} represents the period of time that local time differs from UTC/Greenwich.
+   * A {@@linkZoneOffset} represents the period of time that local time differs from UTC/Greenwich.
    * This is usually a fixed number of hours and minutes. It is equivalent to the {@link
    * ZoneOffset#getTotalSeconds() total amount} of the offset in seconds. For example, during the
-   * winter Paris has an offset of {@code +01:00}, which is 3600 seconds.
+   * winter Paris has an offset of {@@code+01:00} , which is 3600 seconds.
    *
    * This field is strictly defined to have the same meaning in all calendar systems. This is
    * necessary to ensure interoperation between calendars.
@@ -575,11 +575,11 @@ enum ChronoField private (
   /**
    * Gets the range of valid values for the field.
    *
-   * All fields can be expressed as a {@code long} integer. This method returns an object that
+   * All fields can be expressed as a {@@codelong} integer. This method returns an object that
    * describes the valid range for that value.
    *
    * This method returns the range of the field in the ISO-8601 calendar system. This range may be
-   * incorrect for other calendar systems. Use {@link Chronology#range(ChronoField)} to access the
+   * incorrect for other calendar systems. Use {@@linkChronology#range(ChronoField)} to access the
    * correct range for a different calendar system.
    *
    * Note that the result only describes the minimum and maximum valid values and it is important
@@ -619,7 +619,7 @@ enum ChronoField private (
    * #range()}.
    *
    * This method checks against the range of the field in the ISO-8601 calendar system. This range
-   * may be incorrect for other calendar systems. Use {@link Chronology#range(ChronoField)} to
+   * may be incorrect for other calendar systems. Use {@@linkChronology#range(ChronoField)} to
    * access the correct range for a different calendar system.
    *
    * @param value
@@ -630,13 +630,13 @@ enum ChronoField private (
   def checkValidValue(value: Long): Long = _range.checkValidValue(value, this)
 
   /**
-   * Checks that the specified value is valid and fits in an {@code int}.
+   * Checks that the specified value is valid and fits in an {@@codeint} .
    *
    * This validates that the value is within the outer range of valid values returned by {@link
-   * #range()}. It also checks that all valid values are within the bounds of an {@code int}.
+   * #range()}. It also checks that all valid values are within the bounds of an {@@codeint} .
    *
    * This method checks against the range of the field in the ISO-8601 calendar system. This range
-   * may be incorrect for other calendar systems. Use {@link Chronology#range(ChronoField)} to
+   * may be incorrect for other calendar systems. Use {@@linkChronology#range(ChronoField)} to
    * access the correct range for a different calendar system.
    *
    * @param value
diff --git a/core/shared/src/main/scala-3/org/threeten/bp/temporal/ChronoUnit.scala b/core/shared/src/main/scala-3/org/threeten/bp/temporal/ChronoUnit.scala
index 1dc0d2b79..51c1514ad 100644
--- a/core/shared/src/main/scala-3/org/threeten/bp/temporal/ChronoUnit.scala
+++ b/core/shared/src/main/scala-3/org/threeten/bp/temporal/ChronoUnit.scala
@@ -40,7 +40,7 @@ import org.threeten.bp.chrono.ChronoZonedDateTime
  * A standard set of date periods units.
  *
  * This set of units provide unit-based access to manipulate a date, time or date-time. The standard
- * set of units can be extended by implementing {@link TemporalUnit}.
+ * set of units can be extended by implementing {@@linkTemporalUnit} .
  *
  * These units are intended to be applicable in multiple calendar systems. For example, most non-ISO
  * calendar systems define units of years, months and days, just with slightly different rules. The
@@ -99,7 +99,7 @@ enum ChronoUnit private (name: String, ordinal: Int, private val duration: Durat
 
   /**
    * Unit that represents the concept of a day. For the ISO calendar system, it is the standard day
-   * from midnight to midnight. The estimated duration of a day is {@code 24 Hours}.
+   * from midnight to midnight. The estimated duration of a day is {@@code24 Hours} .
    *
    * When used with other calendar systems it must correspond to the day defined by the rising and
    * setting of the Sun on Earth. It is not required that days begin at midnight - when converting
@@ -125,7 +125,7 @@ enum ChronoUnit private (name: String, ordinal: Int, private val duration: Durat
 
   /**
    * Unit that represents the concept of a year. For the ISO calendar system, it is equal to 12
-   * months. The estimated duration of a year is {@code 365.2425 Days}.
+   * months. The estimated duration of a year is {@@code365.2425 Days} .
    *
    * When used with other calendar systems it must correspond to an integral number of days or
    * months roughly equal to a year defined by the passage of the Earth around the Sun.
@@ -162,7 +162,7 @@ enum ChronoUnit private (name: String, ordinal: Int, private val duration: Durat
   /**
    * Unit that represents the concept of an era. The ISO calendar system doesn't have eras thus it
    * is impossible to add an era to a date or date-time. The estimated duration of the era is
-   * artificially defined as {@code 1,000,000,000 Years}.
+   * artificially defined as {@@code1,000,000,000 Years} .
    *
    * When used with other calendar systems there are no restrictions on the unit.
    */
@@ -171,7 +171,7 @@ enum ChronoUnit private (name: String, ordinal: Int, private val duration: Durat
   /**
    * Artificial unit that represents the concept of forever. This is primarily used with {@link
    * TemporalField} to represent unbounded fields such as the year or era. The estimated duration of
-   * the era is artificially defined as the largest duration supported by {@code Duration}.
+   * the era is artificially defined as the largest duration supported by {@@codeDuration} .
    */
   case FOREVER extends ChronoUnit("Forever", 15, Duration.ofSeconds(Long.MaxValue, 999999999))
 
diff --git a/core/shared/src/main/scala-3/org/threeten/bp/temporal/IsoFields.scala b/core/shared/src/main/scala-3/org/threeten/bp/temporal/IsoFields.scala
index 299e569b5..2f196bc27 100644
--- a/core/shared/src/main/scala-3/org/threeten/bp/temporal/IsoFields.scala
+++ b/core/shared/src/main/scala-3/org/threeten/bp/temporal/IsoFields.scala
@@ -158,7 +158,7 @@ object IsoFields {
    *
    * This allows a number of week-based-years to be added to, or subtracted from, a date. The unit
    * is equal to either 52 or 53 weeks. The estimated duration of a week-based-year is the same as
-   * that of a standard ISO year at {@code 365.2425 Days}.
+   * that of a standard ISO year at {@@code365.2425 Days} .
    *
    * The rules for addition add the number of week-based-years to the existing value for the
    * week-based-year field. If the resulting week-based-year only has 52 weeks, then the date will
@@ -170,7 +170,7 @@ object IsoFields {
 
   /**
    * Unit that represents the concept of a quarter-year. For the ISO calendar system, it is equal to
-   * 3 months. The estimated duration of a quarter-year is one quarter of {@code 365.2425 Days}.
+   * 3 months. The estimated duration of a quarter-year is one quarter of {@@code365.2425 Days} .
    *
    * This unit is an immutable and thread-safe singleton.
    */
diff --git a/core/shared/src/main/scala-3/org/threeten/bp/temporal/JulianFields.scala b/core/shared/src/main/scala-3/org/threeten/bp/temporal/JulianFields.scala
index f647834c2..608ac4619 100644
--- a/core/shared/src/main/scala-3/org/threeten/bp/temporal/JulianFields.scala
+++ b/core/shared/src/main/scala-3/org/threeten/bp/temporal/JulianFields.scala
@@ -62,7 +62,7 @@ object JulianFields {
    * For date-times, 'JULIAN_DAY.getFrom()' assumes the same value from midnight until just before
    * the next midnight. When 'JULIAN_DAY.adjustInto()' is applied to a date-time, the time of day
    * portion remains unaltered. 'JULIAN_DAY.adjustInto()' and 'JULIAN_DAY.getFrom()' only apply to
-   * {@code Temporal} objects that can be converted into {@link ChronoField#EPOCH_DAY}. A {@link
+   * {@@codeTemporal} objects that can be converted into {@@linkChronoField#EPOCH_DAY} . A {@link
    * DateTimeException} is thrown for any other type of object.
    *
    * <h3>Astronomical and Scientific Notes</h3> The standard astronomical definition uses a fraction
@@ -94,15 +94,15 @@ object JulianFields {
    *
    * This is an integer-based version of the Modified Julian Day Number. Modified Julian Day (MJD)
    * is a well-known system that counts days continuously. It is defined relative to astronomical
-   * Julian Day as {@code MJD = JD - 2400000.5}. Each Modified Julian Day runs from midnight to
+   * Julian Day as {@@codeMJD = JD - 2400000.5} . Each Modified Julian Day runs from midnight to
    * midnight. The field always refers to the local date-time, ignoring the offset or zone.
    *
    * For date-times, 'MODIFIED_JULIAN_DAY.getFrom()' assumes the same value from midnight until just
    * before the next midnight. When 'MODIFIED_JULIAN_DAY.adjustInto()' is applied to a date-time,
    * the time of day portion remains unaltered. 'MODIFIED_JULIAN_DAY.adjustInto()' and
-   * 'MODIFIED_JULIAN_DAY.getFrom()' only apply to {@code Temporal} objects that can be converted
-   * into {@link ChronoField#EPOCH_DAY}. A {@link DateTimeException} is thrown for any other type of
-   * object.
+   * 'MODIFIED_JULIAN_DAY.getFrom()' only apply to {@@codeTemporal} objects that can be converted
+   * into {@@linkChronoField#EPOCH_DAY} . A {@@linkDateTimeException} is thrown for any other type
+   * of object.
    *
    * This implementation is an integer version of MJD with the decimal part rounded to floor.
    *
@@ -133,7 +133,7 @@ object JulianFields {
    * For date-times, 'RATA_DIE.getFrom()' assumes the same value from midnight until just before the
    * next midnight. When 'RATA_DIE.adjustInto()' is applied to a date-time, the time of day portion
    * remains unaltered. 'MODIFIED_JULIAN_DAY.adjustInto()' and 'RATA_DIE.getFrom()' only apply to
-   * {@code Temporal} objects that can be converted into {@link ChronoField#EPOCH_DAY}. A {@link
+   * {@@codeTemporal} objects that can be converted into {@@linkChronoField#EPOCH_DAY} . A {@link
    * DateTimeException} is thrown for any other type of object.
    */
   lazy val RATA_DIE: TemporalField = Field.RATA_DIE
diff --git a/core/shared/src/main/scala-3/org/threeten/bp/zone/ZoneOffsetTransitionRule.scala b/core/shared/src/main/scala-3/org/threeten/bp/zone/ZoneOffsetTransitionRule.scala
index b10b69a5b..392cd2b8b 100644
--- a/core/shared/src/main/scala-3/org/threeten/bp/zone/ZoneOffsetTransitionRule.scala
+++ b/core/shared/src/main/scala-3/org/threeten/bp/zone/ZoneOffsetTransitionRule.scala
@@ -60,15 +60,15 @@ object ZoneOffsetTransitionRule {
   /**
    * Obtains an instance defining the yearly rule to create transitions between two offsets.
    *
-   * Applications should normally obtain an instance from {@link ZoneRules}. This factory is only
-   * intended for use when creating {@link ZoneRules}.
+   * Applications should normally obtain an instance from {@@linkZoneRules} . This factory is only
+   * intended for use when creating {@@linkZoneRules} .
    *
    * @param month
    *   the month of the month-day of the first day of the cutover week, not null
    * @param dayOfMonthIndicator
    *   the day of the month-day of the cutover week, positive if the week is that day or later,
    *   negative if the week is that day or earlier, counting from the last day of the month, from
-   * -28 to 31 excluding 0
+   *   -28 to 31 excluding 0
    * @param dayOfWeek
    *   the required day-of-week, null if the month-day should not be changed
    * @param time
@@ -262,8 +262,8 @@ final class ZoneOffsetTransitionRule private[zone] (
   /**
    * The day-of-month of the month-day of the cutover week. If positive, it is the start of the week
    * where the cutover can occur. If negative, it represents the end of the week where cutover can
-   * occur. The value is the number of days from the end of the month, such that {@code -1} is the
-   * last day of the month, {@code -2} is the second to last day, and so on.
+   * occur. The value is the number of days from the end of the month, such that {@@code-1} is the
+   * last day of the month, {@@code-2} is the second to last day, and so on.
    */
   private val dom: Byte = dayOfMonthIndicator.toByte
 
@@ -293,7 +293,7 @@ final class ZoneOffsetTransitionRule private[zone] (
    * treated as 1st March in non-leap years.
    *
    * If the value is negative, then it represents the number of days back from the end of the month
-   * where {@code -1} is the last day of the month. In this case, the day identified is the latest
+   * where {@@code-1} is the last day of the month. In this case, the day identified is the latest
    * possible date that the transition can be.
    *
    * @return
diff --git a/core/shared/src/main/scala/org/threeten/bp/Clock.scala b/core/shared/src/main/scala/org/threeten/bp/Clock.scala
index ab2228149..cf6e21d64 100644
--- a/core/shared/src/main/scala/org/threeten/bp/Clock.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/Clock.scala
@@ -42,16 +42,16 @@ object Clock {
    * Obtains a clock that returns the current instant using the best available system clock,
    * converting to date and time using the UTC time-zone.
    *
-   * This clock, rather than {@link #systemDefaultZone()}, should be used when you need the current
+   * This clock, rather than {@@link#systemDefaultZone()} , should be used when you need the current
    * instant without the date or time.
    *
    * This clock is based on the best available system clock. This may use {@link
    * System#currentTimeMillis()}, or a higher resolution clock if one is available.
    *
-   * Conversion from instant to date or time uses the {@link ZoneOffset#UTC UTC time-zone}.
+   * Conversion from instant to date or time uses the {@@linkZoneOffset#UTC UTC time-zone} .
    *
-   * The returned implementation is immutable, thread-safe and {@code Serializable}. It is
-   * equivalent to {@code system(ZoneOffset.UTC)}.
+   * The returned implementation is immutable, thread-safe and {@@codeSerializable} . It is
+   * equivalent to {@@codesystem(ZoneOffset.UTC)} .
    *
    * @return
    *   a clock that uses the best available system clock in the UTC zone, not null
@@ -70,8 +70,8 @@ object Clock {
    * #systemUTC() UTC clock} should be used when you need the current instant without the date or
    * time.
    *
-   * The returned implementation is immutable, thread-safe and {@code Serializable}. It is
-   * equivalent to {@code system(ZoneId.systemDefault())}.
+   * The returned implementation is immutable, thread-safe and {@@codeSerializable} . It is
+   * equivalent to {@@codesystem(ZoneId.systemDefault())} .
    *
    * @return
    *   a clock that uses the best available system clock in the default zone, not null
@@ -88,7 +88,7 @@ object Clock {
    *
    * Conversion from instant to date or time uses the specified time-zone.
    *
-   * The returned implementation is immutable, thread-safe and {@code Serializable}.
+   * The returned implementation is immutable, thread-safe and {@@codeSerializable} .
    *
    * @param zone
    *   the time-zone to use to convert the instant to date-time, not null
@@ -106,14 +106,14 @@ object Clock {
    *
    * This clock will always have the nano-of-second field set to zero. This ensures that the visible
    * time ticks in whole seconds. The underlying clock is the best available system clock,
-   * equivalent to using {@link #system(ZoneId)}.
+   * equivalent to using {@@link#system(ZoneId)} .
    *
    * Implementations may use a caching strategy for performance reasons. As such, it is possible
    * that the start of the second observed via this clock will be later than that observed directly
    * via the underlying clock.
    *
-   * The returned implementation is immutable, thread-safe and {@code Serializable}. It is
-   * equivalent to {@code tick(system(zone), Duration.ofSeconds(1))}.
+   * The returned implementation is immutable, thread-safe and {@@codeSerializable} . It is
+   * equivalent to {@@codetick(system(zone), Duration.ofSeconds(1))} .
    *
    * @param zone
    *   the time-zone to use to convert the instant to date-time, not null
@@ -128,14 +128,14 @@ object Clock {
    *
    * This clock will always have the nano-of-second and second-of-minute fields set to zero. This
    * ensures that the visible time ticks in whole minutes. The underlying clock is the best
-   * available system clock, equivalent to using {@link #system(ZoneId)}.
+   * available system clock, equivalent to using {@@link#system(ZoneId)} .
    *
    * Implementations may use a caching strategy for performance reasons. As such, it is possible
    * that the start of the minute observed via this clock will be later than that observed directly
    * via the underlying clock.
    *
-   * The returned implementation is immutable, thread-safe and {@code Serializable}. It is
-   * equivalent to {@code tick(system(zone), Duration.ofMinutes(1))}.
+   * The returned implementation is immutable, thread-safe and {@@codeSerializable} . It is
+   * equivalent to {@@codetick(system(zone), Duration.ofMinutes(1))} .
    *
    * @param zone
    *   the time-zone to use to convert the instant to date-time, not null
@@ -163,7 +163,7 @@ object Clock {
    * that the start of the requested duration observed via this clock will be later than that
    * observed directly via the underlying clock.
    *
-   * The returned implementation is immutable, thread-safe and {@code Serializable} providing that
+   * The returned implementation is immutable, thread-safe and {@@codeSerializable} providing that
    * the base clock is.
    *
    * @param baseClock
@@ -198,7 +198,7 @@ object Clock {
    * sense. The main use case for this is in testing, where the fixed clock ensures tests are not
    * dependent on the current clock.
    *
-   * The returned implementation is immutable, thread-safe and {@code Serializable}.
+   * The returned implementation is immutable, thread-safe and {@@codeSerializable} .
    *
    * @param fixedInstant
    *   the instant to use as the clock, not null
@@ -224,7 +224,7 @@ object Clock {
    * A duration of zero would have no offsetting effect. Passing zero will return the underlying
    * clock.
    *
-   * The returned implementation is immutable, thread-safe and {@code Serializable} providing that
+   * The returned implementation is immutable, thread-safe and {@@codeSerializable} providing that
    * the base clock is.
    *
    * @param baseClock
@@ -378,22 +378,22 @@ object Clock {
  *
  * Instances of this class are used to find the current instant, which can be interpreted using the
  * stored time-zone to find the current date and time. As such, a clock can be used instead of
- * {@link System#currentTimeMillis()} and {@link TimeZone#getDefault()}.
+ * {@@linkSystem#currentTimeMillis()} and {@@linkTimeZone#getDefault()} .
  *
- * Use of a {@code Clock} is optional. All key date-time classes also have a {@code now()} factory
+ * Use of a {@@codeClock} is optional. All key date-time classes also have a {@@codenow()} factory
  * method that uses the system clock in the default time zone. The primary purpose of this
  * abstraction is to allow alternate clocks to be plugged in as and when required. Applications use
  * an object to obtain the current time rather than a static method. This can simplify testing.
  *
- * Best practice for applications is to pass a {@code Clock} into any method that requires the
+ * Best practice for applications is to pass a {@@codeClock} into any method that requires the
  * current instant. A dependency injection framework is one way to achieve this: <pre> public class
  * MyBean { private Clock clock; // dependency inject ... public void process(LocalDate eventDate) {
  * if (eventDate.isBefore(LocalDate.now(clock)) { ... } } } </pre> This approach allows an alternate
- * clock, such as {@link #fixed(Instant, ZoneId) fixed} or {@link #offset(Clock, Duration) offset}
+ * clock, such as {@@link#fixed(Instant, ZoneId) fixed} or {@@link#offset(Clock, Duration) offset}
  * to be used during testing.
  *
- * The {@code system} factory methods provide clocks based on the best available system clock This
- * may use {@link System#currentTimeMillis()}, or a higher resolution clock if one is available.
+ * The {@@codesystem} factory methods provide clocks based on the best available system clock This
+ * may use {@@linkSystem#currentTimeMillis()} , or a higher resolution clock if one is available.
  *
  * <h3>Specification for implementors</h3> This abstract class must be implemented with care to
  * ensure other operate correctly. All implementations that can be instantiated must be final,
@@ -404,11 +404,11 @@ object Clock {
  * central time server across the network. Obviously, in this case the lookup could fail, and so the
  * method is permitted to throw an exception.
  *
- * The returned instants from {@code Clock} work on a time-scale that ignores leap seconds. If the
+ * The returned instants from {@@codeClock} work on a time-scale that ignores leap seconds. If the
  * implementation wraps a source that provides leap second information, then a mechanism should be
  * used to "smooth" the leap second, such as UTC-SLS.
  *
- * Implementations should implement {@code Serializable} wherever possible and must document whether
+ * Implementations should implement {@@codeSerializable} wherever possible and must document whether
  * or not they do support serialization.
  */
 abstract class Clock protected () {
@@ -442,12 +442,12 @@ abstract class Clock protected () {
    * Gets the current millisecond instant of the clock.
    *
    * This returns the millisecond-based instant, measured from 1970-01-01T00:00 UTC. This is
-   * equivalent to the definition of {@link System#currentTimeMillis()}.
+   * equivalent to the definition of {@@linkSystem#currentTimeMillis()} .
    *
-   * Most applications should avoid this method and use {@link Instant} to represent an instant on
+   * Most applications should avoid this method and use {@@linkInstant} to represent an instant on
    * the time-line rather than a raw millisecond value. This method is provided to allow the use of
    * the clock in high performance use cases where the creation of an object would be unacceptable.
-   * The default implementation currently calls {@link #instant()}.
+   * The default implementation currently calls {@@link#instant()} .
    *
    * @return
    *   the current millisecond instant from this clock, measured from the Java epoch of
diff --git a/core/shared/src/main/scala/org/threeten/bp/Duration.scala b/core/shared/src/main/scala/org/threeten/bp/Duration.scala
index fc7eda6ad..91498d752 100644
--- a/core/shared/src/main/scala/org/threeten/bp/Duration.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/Duration.scala
@@ -79,7 +79,7 @@ object Duration {
     )
 
   /**
-   * Obtains an instance of {@code Duration} from a number of standard 24 hour days.
+   * Obtains an instance of {@@codeDuration} from a number of standard 24 hour days.
    *
    * The seconds are calculated based on the standard definition of a day, where each day is 86400
    * seconds which implies a 24 hour day. The nanosecond in second field is set to zero.
@@ -87,14 +87,14 @@ object Duration {
    * @param days
    *   the number of days, positive or negative
    * @return
-   *   a { @code Duration}, not null
+   *   a {@@codeDuration} , not null
    * @throws ArithmeticException
-   *   if the input days exceeds the capacity of { @code Duration}
+   *   if the input days exceeds the capacity of {@@codeDuration}
    */
   def ofDays(days: Long): Duration = create(Math.multiplyExact(days, 86400L), 0)
 
   /**
-   * Obtains an instance of {@code Duration} from a number of standard length hours.
+   * Obtains an instance of {@@codeDuration} from a number of standard length hours.
    *
    * The seconds are calculated based on the standard definition of an hour, where each hour is 3600
    * seconds. The nanosecond in second field is set to zero.
@@ -102,14 +102,14 @@ object Duration {
    * @param hours
    *   the number of hours, positive or negative
    * @return
-   *   a { @code Duration}, not null
+   *   a {@@codeDuration} , not null
    * @throws ArithmeticException
-   *   if the input hours exceeds the capacity of { @code Duration}
+   *   if the input hours exceeds the capacity of {@@codeDuration}
    */
   def ofHours(hours: Long): Duration = create(Math.multiplyExact(hours, 3600L), 0)
 
   /**
-   * Obtains an instance of {@code Duration} from a number of standard length minutes.
+   * Obtains an instance of {@@codeDuration} from a number of standard length minutes.
    *
    * The seconds are calculated based on the standard definition of a minute, where each minute is
    * 60 seconds. The nanosecond in second field is set to zero.
@@ -117,26 +117,26 @@ object Duration {
    * @param minutes
    *   the number of minutes, positive or negative
    * @return
-   *   a { @code Duration}, not null
+   *   a {@@codeDuration} , not null
    * @throws ArithmeticException
-   *   if the input minutes exceeds the capacity of { @code Duration}
+   *   if the input minutes exceeds the capacity of {@@codeDuration}
    */
   def ofMinutes(minutes: Long): Duration = create(Math.multiplyExact(minutes, 60L), 0)
 
   /**
-   * Obtains an instance of {@code Duration} from a number of seconds.
+   * Obtains an instance of {@@codeDuration} from a number of seconds.
    *
    * The nanosecond in second field is set to zero.
    *
    * @param seconds
    *   the number of seconds, positive or negative
    * @return
-   *   a { @code Duration}, not null
+   *   a {@@codeDuration} , not null
    */
   def ofSeconds(seconds: Long): Duration = create(seconds, 0)
 
   /**
-   * Obtains an instance of {@code Duration} from a number of seconds and an adjustment in
+   * Obtains an instance of {@@codeDuration} from a number of seconds and an adjustment in
    * nanoseconds.
    *
    * This method allows an arbitrary number of nanoseconds to be passed in. The factory will alter
@@ -150,9 +150,9 @@ object Duration {
    * @param nanoAdjustment
    *   the nanosecond adjustment to the number of seconds, positive or negative
    * @return
-   *   a { @code Duration}, not null
+   *   a {@@codeDuration} , not null
    * @throws ArithmeticException
-   *   if the adjustment causes the seconds to exceed the capacity of { @code Duration}
+   *   if the adjustment causes the seconds to exceed the capacity of {@@codeDuration}
    */
   def ofSeconds(seconds: Long, nanoAdjustment: Long): Duration = {
     val secs: Long = Math.addExact(seconds, Math.floorDiv(nanoAdjustment, NANOS_PER_SECOND.toLong))
@@ -161,14 +161,14 @@ object Duration {
   }
 
   /**
-   * Obtains an instance of {@code Duration} from a number of milliseconds.
+   * Obtains an instance of {@@codeDuration} from a number of milliseconds.
    *
    * The seconds and nanoseconds are extracted from the specified milliseconds.
    *
    * @param millis
    *   the number of milliseconds, positive or negative
    * @return
-   *   a { @code Duration}, not null
+   *   a {@@codeDuration} , not null
    */
   def ofMillis(millis: Long): Duration = {
     var secs: Long = millis / 1000
@@ -181,14 +181,14 @@ object Duration {
   }
 
   /**
-   * Obtains an instance of {@code Duration} from a number of nanoseconds.
+   * Obtains an instance of {@@codeDuration} from a number of nanoseconds.
    *
    * The seconds and nanoseconds are extracted from the specified nanoseconds.
    *
    * @param nanos
    *   the number of nanoseconds, positive or negative
    * @return
-   *   a { @code Duration}, not null
+   *   a {@@codeDuration} , not null
    */
   def ofNanos(nanos: Long): Duration = {
     var secs: Long = nanos / NANOS_PER_SECOND
@@ -201,12 +201,12 @@ object Duration {
   }
 
   /**
-   * Obtains an instance of {@code Duration} from a duration in the specified unit.
+   * Obtains an instance of {@@codeDuration} from a duration in the specified unit.
    *
    * The parameters represent the two parts of a phrase like '6 Hours'. For example: <pre>
    * Duration.of(3, SECONDS); Duration.of(465, HOURS); </pre> Only a subset of units are accepted by
    * this method. The unit must either have an {@link TemporalUnit#isDurationEstimated() exact
-   * duration} or be {@link ChronoUnit#DAYS} which is treated as 24 hours. Other units throw an
+   * duration} or be {@@linkChronoUnit#DAYS} which is treated as 24 hours. Other units throw an
    * exception.
    *
    * @param amount
@@ -214,7 +214,7 @@ object Duration {
    * @param unit
    *   the unit that the duration is measured in, must have an exact duration, not null
    * @return
-   *   a { @code Duration}, not null
+   *   a {@@codeDuration} , not null
    * @throws DateTimeException
    *   if the period unit has an estimated duration
    * @throws ArithmeticException
@@ -223,7 +223,7 @@ object Duration {
   def of(amount: Long, unit: TemporalUnit): Duration = ZERO.plus(amount, unit)
 
   /**
-   * Obtains an instance of {@code Duration} from an amount.
+   * Obtains an instance of {@@codeDuration} from an amount.
    *
    * This obtains a duration based on the specified amount. A TemporalAmount represents an amount of
    * time, which may be date-based or time-based, which this factory extracts to a duration.
@@ -236,7 +236,7 @@ object Duration {
    * @param amount
    *   the amount to convert, not null
    * @return
-   *   a { @code Duration}, not null
+   *   a {@@codeDuration} , not null
    * @throws DateTimeException
    *   if the amount cannot be converted
    * @throws ArithmeticException
@@ -254,12 +254,12 @@ object Duration {
   }
 
   /**
-   * Obtains an instance of {@code Duration} representing the duration between two instants.
+   * Obtains an instance of {@@codeDuration} representing the duration between two instants.
    *
-   * Obtains a {@code Duration} representing the duration between two instants. This calculates the
+   * Obtains a {@@codeDuration} representing the duration between two instants. This calculates the
    * duration between two temporal objects of the same type. The difference in seconds is calculated
-   * using {@link Temporal#until(Temporal, TemporalUnit)}. The difference in nanoseconds is
-   * calculated using by querying the {@link ChronoField#NANO_OF_SECOND NANO_OF_SECOND} field.
+   * using {@@linkTemporal#until(Temporal, TemporalUnit)} . The difference in nanoseconds is
+   * calculated using by querying the {@@linkChronoField#NANO_OF_SECOND NANO_OF_SECOND} field.
    *
    * The result of this method can be a negative period if the end is before the start. To guarantee
    * to obtain a positive duration call abs() on the result.
@@ -269,11 +269,11 @@ object Duration {
    * @param endExclusive
    *   the end instant, exclusive, not null
    * @return
-   *   a { @code Duration}, not null
+   *   a {@@codeDuration} , not null
    * @throws DateTimeException
    *   if the seconds between the temporals cannot be obtained
    * @throws ArithmeticException
-   *   if the calculation exceeds the capacity of { @code Duration}
+   *   if the calculation exceeds the capacity of {@@codeDuration}
    */
   def between(startInclusive: Temporal, endExclusive: Temporal): Duration = {
     var secs: Long  = startInclusive.until(endExclusive, SECONDS)
@@ -298,7 +298,7 @@ object Duration {
   }
 
   /**
-   * Obtains a {@code Duration} from a text string such as {@code PnDTnHnMn.nS}.
+   * Obtains a {@@codeDuration} from a text string such as {@@codePnDTnHnMn.nS} .
    *
    * This will parse a textual representation of a duration, including the string produced by {@code
    * toString()}. The formats accepted are based on the ISO-8601 duration format {@code
@@ -313,7 +313,7 @@ object Duration {
    * sections must be present, and if "T" is present there must be at least one section after the
    * "T". The number part of each section must consist of one or more ASCII digits. The number may
    * be prefixed by the ASCII negative or positive symbol. The number of days, hours and minutes
-   * must parse to a {@code long}. The number of seconds must parse to a {@code long} with optional
+   * must parse to a {@@codelong} . The number of seconds must parse to a {@@codelong} with optional
    * fraction. The decimal point may be either a dot or a comma. The fractional part may have from
    * zero to 9 digits.
    *
@@ -435,7 +435,7 @@ object Duration {
   }
 
   /**
-   * Obtains an instance of {@code Duration} using seconds and nanoseconds.
+   * Obtains an instance of {@@codeDuration} using seconds and nanoseconds.
    *
    * @param seconds
    *   the length of the duration in seconds, positive or negative
@@ -447,12 +447,12 @@ object Duration {
     else new Duration(seconds, nanoAdjustment)
 
   /**
-   * Creates an instance of {@code Duration} from a number of seconds.
+   * Creates an instance of {@@codeDuration} from a number of seconds.
    *
    * @param seconds
    *   the number of seconds, up to scale 9, positive or negative
    * @return
-   *   a { @code Duration}, not null
+   *   a {@@codeDuration} , not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -472,25 +472,25 @@ object Duration {
  * This class models a quantity or amount of time in terms of seconds and nanoseconds. It can be
  * accessed using other duration-based units, such as minutes and hours. In addition, the {@link
  * ChronoUnit#DAYS DAYS} unit can be used and is treated as exactly equal to 24 hours, thus ignoring
- * daylight savings effects. See {@link Period} for the date-based equivalent to this class.
+ * daylight savings effects. See {@@linkPeriod} for the date-based equivalent to this class.
  *
  * A physical duration could be of infinite length. For practicality, the duration is stored with
- * constraints similar to {@link Instant}. The duration uses nanosecond resolution with a maximum
- * value of the seconds that can be held in a {@code long}. This is greater than the current
+ * constraints similar to {@@linkInstant} . The duration uses nanosecond resolution with a maximum
+ * value of the seconds that can be held in a {@@codelong} . This is greater than the current
  * estimated age of the universe.
  *
- * The range of a duration requires the storage of a number larger than a {@code long}. To achieve
- * this, the class stores a {@code long} representing seconds and an {@code int} representing
+ * The range of a duration requires the storage of a number larger than a {@@codelong} . To achieve
+ * this, the class stores a {@@codelong} representing seconds and an {@@codeint} representing
  * nanosecond-of-second, which will always be between 0 and 999,999,999.
  *
  * The duration is measured in "seconds", but these are not necessarily identical to the scientific
  * "SI second" definition based on atomic clocks. This difference only impacts durations measured
- * near a leap-second and should not affect most applications. See {@link Instant} for a discussion
+ * near a leap-second and should not affect most applications. See {@@linkInstant} for a discussion
  * as to the meaning of the second and time-scales.
  *
  * <h3>Specification for implementors</h3> This class is immutable and thread-safe.
  *
- * Constructs an instance of {@code Duration} using seconds and nanoseconds.
+ * Constructs an instance of {@@codeDuration} using seconds and nanoseconds.
  *
  * @param seconds
  *   the length of the duration in seconds, positive or negative
@@ -514,7 +514,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
   /**
    * Checks if this duration is zero length.
    *
-   * A {@code Duration} represents a directed distance between two points on the time-line and can
+   * A {@@codeDuration} represents a directed distance between two points on the time-line and can
    * therefore be positive, zero or negative. This method checks whether the length is zero.
    *
    * @return
@@ -525,7 +525,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
   /**
    * Checks if this duration is negative, excluding zero.
    *
-   * A {@code Duration} represents a directed distance between two points on the time-line and can
+   * A {@@codeDuration} represents a directed distance between two points on the time-line and can
    * therefore be positive, zero or negative. This method checks whether the length is less than
    * zero.
    *
@@ -539,9 +539,9 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    *
    * The length of the duration is stored using two fields - seconds and nanoseconds. The
    * nanoseconds part is a value from 0 to 999,999,999 that is an adjustment to the length in
-   * seconds. The total duration is defined by calling this method and {@link #getNano()}.
+   * seconds. The total duration is defined by calling this method and {@@link#getNano()} .
    *
-   * A {@code Duration} represents a directed distance between two points on the time-line. A
+   * A {@@codeDuration} represents a directed distance between two points on the time-line. A
    * negative duration is expressed by the negative sign of the seconds part. A duration of -1
    * nanosecond is stored as -1 seconds plus 999,999,999 nanoseconds.
    *
@@ -555,9 +555,9 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    *
    * The length of the duration is stored using two fields - seconds and nanoseconds. The
    * nanoseconds part is a value from 0 to 999,999,999 that is an adjustment to the length in
-   * seconds. The total duration is defined by calling this method and {@link #getSeconds()}.
+   * seconds. The total duration is defined by calling this method and {@@link#getSeconds()} .
    *
-   * A {@code Duration} represents a directed distance between two points on the time-line. A
+   * A {@@codeDuration} represents a directed distance between two points on the time-line. A
    * negative duration is expressed by the negative sign of the seconds part. A duration of -1
    * nanosecond is stored as -1 seconds plus 999,999,999 nanoseconds.
    *
@@ -577,7 +577,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param seconds
    *   the seconds to represent, may be negative
    * @return
-   *   a { @code Duration} based on this period with the requested seconds, not null
+   *   a {@@codeDuration} based on this period with the requested seconds, not null
    */
   def withSeconds(seconds: Long): Duration = Duration.create(seconds, nanos)
 
@@ -592,7 +592,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param nanoOfSecond
    *   the nano-of-second to represent, from 0 to 999,999,999
    * @return
-   *   a { @code Duration} based on this period with the requested nano-of-second, not null
+   *   a {@@codeDuration} based on this period with the requested nano-of-second, not null
    * @throws DateTimeException
    *   if the nano-of-second is invalid
    */
@@ -609,7 +609,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param duration
    *   the duration to add, positive or negative, not null
    * @return
-   *   a { @code Duration} based on this duration with the specified duration added, not null
+   *   a {@@codeDuration} based on this duration with the specified duration added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -620,7 +620,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    *
    * The duration amount is measured in terms of the specified unit. Only a subset of units are
    * accepted by this method. The unit must either have an {@link TemporalUnit#isDurationEstimated()
-   * exact duration} or be {@link ChronoUnit#DAYS} which is treated as 24 hours. Other units throw
+   * exact duration} or be {@@linkChronoUnit#DAYS} which is treated as 24 hours. Other units throw
    * an exception.
    *
    * This instance is immutable and unaffected by this method call.
@@ -630,7 +630,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param unit
    *   the unit that the period is measured in, must have an exact duration, not null
    * @return
-   *   a { @code Duration} based on this duration with the specified duration added, not null
+   *   a {@@codeDuration} based on this duration with the specified duration added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -667,7 +667,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param daysToAdd
    *   the days to add, positive or negative
    * @return
-   *   a { @code Duration} based on this duration with the specified days added, not null
+   *   a {@@codeDuration} based on this duration with the specified days added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -682,7 +682,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param hoursToAdd
    *   the hours to add, positive or negative
    * @return
-   *   a { @code Duration} based on this duration with the specified hours added, not null
+   *   a {@@codeDuration} based on this duration with the specified hours added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -697,7 +697,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param minutesToAdd
    *   the minutes to add, positive or negative
    * @return
-   *   a { @code Duration} based on this duration with the specified minutes added, not null
+   *   a {@@codeDuration} based on this duration with the specified minutes added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -712,7 +712,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param secondsToAdd
    *   the seconds to add, positive or negative
    * @return
-   *   a { @code Duration} based on this duration with the specified seconds added, not null
+   *   a {@@codeDuration} based on this duration with the specified seconds added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -726,7 +726,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param millisToAdd
    *   the milliseconds to add, positive or negative
    * @return
-   *   a { @code Duration} based on this duration with the specified milliseconds added, not null
+   *   a {@@codeDuration} based on this duration with the specified milliseconds added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -741,7 +741,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param nanosToAdd
    *   the nanoseconds to add, positive or negative
    * @return
-   *   a { @code Duration} based on this duration with the specified nanoseconds added, not null
+   *   a {@@codeDuration} based on this duration with the specified nanoseconds added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -757,7 +757,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param nanosToAdd
    *   the nanos to add, positive or negative
    * @return
-   *   a { @code Duration} based on this duration with the specified seconds added, not null
+   *   a {@@codeDuration} based on this duration with the specified seconds added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -780,7 +780,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param duration
    *   the duration to subtract, positive or negative, not null
    * @return
-   *   a { @code Duration} based on this duration with the specified duration subtracted, not null
+   *   a {@@codeDuration} based on this duration with the specified duration subtracted, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -796,7 +796,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    *
    * The duration amount is measured in terms of the specified unit. Only a subset of units are
    * accepted by this method. The unit must either have an {@link TemporalUnit#isDurationEstimated()
-   * exact duration} or be {@link ChronoUnit#DAYS} which is treated as 24 hours. Other units throw
+   * exact duration} or be {@@linkChronoUnit#DAYS} which is treated as 24 hours. Other units throw
    * an exception.
    *
    * This instance is immutable and unaffected by this method call.
@@ -806,7 +806,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param unit
    *   the unit that the period is measured in, must have an exact duration, not null
    * @return
-   *   a { @code Duration} based on this duration with the specified duration subtracted, not null
+   *   a {@@codeDuration} based on this duration with the specified duration subtracted, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -822,7 +822,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param daysToSubtract
    *   the days to subtract, positive or negative
    * @return
-   *   a { @code Duration} based on this duration with the specified days subtracted, not null
+   *   a {@@codeDuration} based on this duration with the specified days subtracted, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -838,7 +838,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param hoursToSubtract
    *   the hours to subtract, positive or negative
    * @return
-   *   a { @code Duration} based on this duration with the specified hours subtracted, not null
+   *   a {@@codeDuration} based on this duration with the specified hours subtracted, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -854,7 +854,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param minutesToSubtract
    *   the minutes to subtract, positive or negative
    * @return
-   *   a { @code Duration} based on this duration with the specified minutes subtracted, not null
+   *   a {@@codeDuration} based on this duration with the specified minutes subtracted, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -870,7 +870,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param secondsToSubtract
    *   the seconds to subtract, positive or negative
    * @return
-   *   a { @code Duration} based on this duration with the specified seconds subtracted, not null
+   *   a {@@codeDuration} based on this duration with the specified seconds subtracted, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -886,7 +886,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param millisToSubtract
    *   the milliseconds to subtract, positive or negative
    * @return
-   *   a { @code Duration} based on this duration with the specified milliseconds subtracted, not
+   *   a {@@codeDuration} based on this duration with the specified milliseconds subtracted, not
    *   null
    * @throws ArithmeticException
    *   if numeric overflow occurs
@@ -903,8 +903,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param nanosToSubtract
    *   the nanoseconds to subtract, positive or negative
    * @return
-   *   a { @code Duration} based on this duration with the specified nanoseconds subtracted, not
-   *   null
+   *   a {@@codeDuration} based on this duration with the specified nanoseconds subtracted, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -920,7 +919,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param multiplicand
    *   the value to multiply the duration by, positive or negative
    * @return
-   *   a { @code Duration} based on this duration multiplied by the specified scalar, not null
+   *   a {@@codeDuration} based on this duration multiplied by the specified scalar, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -937,7 +936,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * @param divisor
    *   the value to divide the duration by, positive or negative, not zero
    * @return
-   *   a { @code Duration} based on this duration divided by the specified divisor, not null
+   *   a {@@codeDuration} based on this duration divided by the specified divisor, not null
    * @throws ArithmeticException
    *   if the divisor is zero
    * @throws ArithmeticException
@@ -950,7 +949,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
 
   /**
    * Converts this duration to the total length in seconds and fractional nanoseconds expressed as a
-   * {@code BigDecimal}.
+   * {@@codeBigDecimal} .
    *
    * @return
    *   the total length of the duration in seconds, with a scale of 9, not null
@@ -989,13 +988,13 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
   /**
    * Returns a copy of this duration with the length negated.
    *
-   * This method swaps the sign of the total length of this duration. For example, {@code PT1.3S}
-   * will be returned as {@code PT-1.3S}.
+   * This method swaps the sign of the total length of this duration. For example, {@@codePT1.3S}
+   * will be returned as {@@codePT-1.3S} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @return
-   *   a { @code Duration} based on this duration with the amount negated, not null
+   *   a {@@codeDuration} based on this duration with the amount negated, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -1005,12 +1004,12 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
    * Returns a copy of this duration with a positive length.
    *
    * This method returns a positive duration by effectively removing the sign from any negative
-   * total length. For example, {@code PT-1.3S} will be returned as {@code PT1.3S}.
+   * total length. For example, {@@codePT-1.3S} will be returned as {@@codePT1.3S} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @return
-   *   a { @code Duration} based on this duration with an absolute length, not null
+   *   a {@@codeDuration} based on this duration with an absolute length, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -1166,7 +1165,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
   /**
    * Converts this duration to the total length in milliseconds.
    *
-   * If this duration is too large to fit in a {@code long} milliseconds, then an exception is
+   * If this duration is too large to fit in a {@@codelong} milliseconds, then an exception is
    * thrown.
    *
    * If this duration has greater than millisecond precision, then the conversion will drop any
@@ -1200,9 +1199,9 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
   def toMillisPart: Int = (nanos / Duration.NANOS_PER_MILLI).toInt
 
   /**
-   * Converts this duration to the total length in nanoseconds expressed as a {@code long}.
+   * Converts this duration to the total length in nanoseconds expressed as a {@@codelong} .
    *
-   * If this duration is too large to fit in a {@code long} nanoseconds, then an exception is
+   * If this duration is too large to fit in a {@@codelong} nanoseconds, then an exception is
    * thrown.
    *
    * @return
@@ -1231,10 +1230,10 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
   def toNanosPart: Int = nanos
 
   /**
-   * Compares this duration to the specified {@code Duration}.
+   * Compares this duration to the specified {@@codeDuration} .
    *
    * The comparison is based on the total length of the durations. It is "consistent with equals",
-   * as defined by {@link Comparable}.
+   * as defined by {@@linkComparable} .
    *
    * @param otherDuration
    *   the other duration to compare to, not null
@@ -1250,7 +1249,7 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
   override def compareTo(other: Duration): Int = compare(other)
 
   /**
-   * Checks if this duration is equal to the specified {@code Duration}.
+   * Checks if this duration is equal to the specified {@@codeDuration} .
    *
    * The comparison is based on the total length of the durations.
    *
@@ -1276,16 +1275,16 @@ final class Duration private (private val seconds: Long, private val nanos: Int)
 
   /**
    * A string representation of this duration using ISO-8601 seconds based representation, such as
-   * {@code PT8H6M12.345S}.
+   * {@@codePT8H6M12.345S} .
    *
-   * The format of the returned string will be {@code PTnHnMnS}, where n is the relevant hours,
+   * The format of the returned string will be {@@codePTnHnMnS} , where n is the relevant hours,
    * minutes or seconds part of the duration. Any fractional seconds are placed after a decimal
    * point i the seconds section. If a section has a zero value, it is omitted. The hours, minutes
    * and seconds will all have the same sign.
    *
    * Examples: <pre> "20.345 seconds" -> "PT20.345S "15 minutes" (15 * 60 seconds) -> "PT15M" "10
    * hours" (10 * 3600 seconds) -> "PT10H" "2 days" (2 * 86400 seconds) -> "PT48H" </pre> Note that
-   * multiples of 24 hours are not output as days to avoid confusion with {@code Period}.
+   * multiples of 24 hours are not output as days to avoid confusion with {@@codePeriod} .
    *
    * @return
    *   an ISO-8601 representation of this duration, not null
diff --git a/core/shared/src/main/scala/org/threeten/bp/Instant.scala b/core/shared/src/main/scala/org/threeten/bp/Instant.scala
index 800b33d9e..42bbc4a64 100644
--- a/core/shared/src/main/scala/org/threeten/bp/Instant.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/Instant.scala
@@ -79,30 +79,30 @@ object Instant {
   private def MILLIS_PER_SEC = 1000
 
   /**
-   * The minimum supported {@code Instant}, '-1000000000-01-01T00:00Z'. This could be used by an
+   * The minimum supported {@@codeInstant} , '-1000000000-01-01T00:00Z'. This could be used by an
    * application as a "far past" instant.
    *
-   * This is one year earlier than the minimum {@code LocalDateTime}. This provides sufficient
-   * values to handle the range of {@code ZoneOffset} which affect the instant in addition to the
+   * This is one year earlier than the minimum {@@codeLocalDateTime} . This provides sufficient
+   * values to handle the range of {@@codeZoneOffset} which affect the instant in addition to the
    * local date-time. The value is also chosen such that the value of the year fits in an {@code
    * int}.
    */
   lazy val MIN: Instant = Instant.ofEpochSecond(MIN_SECOND, 0)
 
   /**
-   * The maximum supported {@code Instant}, '1000000000-12-31T23:59:59.999999999Z'. This could be
+   * The maximum supported {@@codeInstant} , '1000000000-12-31T23:59:59.999999999Z'. This could be
    * used by an application as a "far future" instant.
    *
-   * This is one year later than the maximum {@code LocalDateTime}. This provides sufficient values
-   * to handle the range of {@code ZoneOffset} which affect the instant in addition to the local
-   * date-time. The value is also chosen such that the value of the year fits in an {@code int}.
+   * This is one year later than the maximum {@@codeLocalDateTime} . This provides sufficient values
+   * to handle the range of {@@codeZoneOffset} which affect the instant in addition to the local
+   * date-time. The value is also chosen such that the value of the year fits in an {@@codeint} .
    */
   lazy val MAX: Instant = Instant.ofEpochSecond(MAX_SECOND, 999999999)
 
   /**
    * Obtains the current instant from the system clock.
    *
-   * This will query the {@link Clock#systemUTC() system UTC clock} to obtain the current instant.
+   * This will query the {@@linkClock#systemUTC() system UTC clock} to obtain the current instant.
    *
    * Using this method will prevent the ability to use an alternate time-source for testing because
    * the clock is effectively hard-coded.
@@ -118,7 +118,7 @@ object Instant {
    * This will query the specified clock to obtain the current time.
    *
    * Using this method allows the use of an alternate clock for testing. The alternate clock may be
-   * introduced using {@link Clock dependency injection}.
+   * introduced using {@@linkClock dependency injection} .
    *
    * @param clock
    *   the clock to use, not null
@@ -131,7 +131,7 @@ object Instant {
   }
 
   /**
-   * Obtains an instance of {@code Instant} using seconds from the epoch of 1970-01-01T00:00:00Z.
+   * Obtains an instance of {@@codeInstant} using seconds from the epoch of 1970-01-01T00:00:00Z.
    *
    * The nanosecond field is set to zero.
    *
@@ -145,7 +145,7 @@ object Instant {
   def ofEpochSecond(epochSecond: Long): Instant = create(epochSecond, 0)
 
   /**
-   * Obtains an instance of {@code Instant} using seconds from the epoch of 1970-01-01T00:00:00Z and
+   * Obtains an instance of {@@codeInstant} using seconds from the epoch of 1970-01-01T00:00:00Z and
    * nanosecond fraction of second.
    *
    * This method allows an arbitrary number of nanoseconds to be passed in. The factory will alter
@@ -173,7 +173,7 @@ object Instant {
   }
 
   /**
-   * Obtains an instance of {@code Instant} using milliseconds from the epoch of
+   * Obtains an instance of {@@codeInstant} using milliseconds from the epoch of
    * 1970-01-01T00:00:00Z.
    *
    * The seconds and nanoseconds are extracted from the specified milliseconds.
@@ -192,23 +192,23 @@ object Instant {
   }
 
   /**
-   * Obtains an instance of {@code Instant} from a temporal object.
+   * Obtains an instance of {@@codeInstant} from a temporal object.
    *
-   * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code Instant}.
+   * A {@@codeTemporalAccessor} represents some form of date and time information. This factory
+   * converts the arbitrary temporal object to an instance of {@@codeInstant} .
    *
-   * The conversion extracts the {@link ChronoField#INSTANT_SECONDS INSTANT_SECONDS} and {@link
+   * The conversion extracts the {@@linkChronoField#INSTANT_SECONDS INSTANT_SECONDS} and {@link
    * ChronoField#NANO_OF_SECOND NANO_OF_SECOND} fields.
    *
-   * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used as a query via method reference, {@code Instant::from}.
+   * This method matches the signature of the functional interface {@@linkTemporalQuery} allowing it
+   * to be used as a query via method reference, {@@codeInstant::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the instant, not null
    * @throws DateTimeException
-   *   if unable to convert to an { @code Instant}
+   *   if unable to convert to an {@@codeInstant}
    */
   def from(temporal: TemporalAccessor): Instant =
     try {
@@ -224,7 +224,7 @@ object Instant {
     }
 
   /**
-   * Obtains an instance of {@code Instant} from a text string such as {@code
+   * Obtains an instance of {@@codeInstant} from a text string such as {@code
    * 2007-12-03T10:15:30.000Z}.
    *
    * The string must represent a valid instant in UTC and is parsed using {@link
@@ -246,7 +246,7 @@ object Instant {
     )
 
   /**
-   * Obtains an instance of {@code Instant} using seconds and nanoseconds.
+   * Obtains an instance of {@@codeInstant} using seconds and nanoseconds.
    *
    * @param seconds
    *   the length of the duration in seconds
@@ -272,13 +272,13 @@ object Instant {
  * event time-stamps in the application.
  *
  * For practicality, the instant is stored with some constraints. The measurable time-line is
- * restricted to the number of seconds that can be held in a {@code long}. This is greater than the
+ * restricted to the number of seconds that can be held in a {@@codelong} . This is greater than the
  * current estimated age of the universe. The instant is stored to nanosecond resolution.
  *
- * The range of an instant requires the storage of a number larger than a {@code long}. To achieve
- * this, the class stores a {@code long} representing epoch-seconds and an {@code int} representing
+ * The range of an instant requires the storage of a number larger than a {@@codelong} . To achieve
+ * this, the class stores a {@@codelong} representing epoch-seconds and an {@@codeint} representing
  * nanosecond-of-second, which will always be between 0 and 999,999,999. The epoch-seconds are
- * measured from the standard Java epoch of {@code 1970-01-01T00:00:00Z} where instants after the
+ * measured from the standard Java epoch of {@@code1970-01-01T00:00:00Z} where instants after the
  * epoch have positive values, and earlier instants have negative values. For both the epoch-second
  * and nanosecond parts, a larger value is always later on the time-line than a smaller value.
  *
@@ -335,17 +335,17 @@ object Instant {
  * 1/1000th longer or shorter than a real SI second.
  *
  * One final problem is the definition of the agreed international civil time before the
- * introduction of modern UTC in 1972. This includes the Java epoch of {@code 1970-01-01}. It is
+ * introduction of modern UTC in 1972. This includes the Java epoch of {@@code1970-01-01} . It is
  * intended that instants before 1972 be interpreted based on the solar day divided into 86400
  * subdivisions.
  *
- * The Java time-scale is used by all date-time classes. This includes {@code Instant}, {@code
- * LocalDate}, {@code LocalTime}, {@code OffsetDateTime}, {@code ZonedDateTime} and {@code
+ * The Java time-scale is used by all date-time classes. This includes {@@codeInstant} , {@code
+ * LocalDate}, {@@codeLocalTime} , {@@codeOffsetDateTime} , {@@codeZonedDateTime} and {@code
  * Duration}.
  *
  * <h3>Specification for implementors</h3> This class is immutable and thread-safe.
  *
- * Constructs an instance of {@code Instant} using seconds from the epoch of 1970-01-01T00:00:00Z
+ * Constructs an instance of {@@codeInstant} using seconds from the epoch of 1970-01-01T00:00:00Z
  * and nanosecond fraction of second.
  *
  * @param seconds
@@ -365,15 +365,15 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * Checks if the specified field is supported.
    *
    * This checks if this instant can be queried for the specified field. If false, then calling the
-   * {@link #range(TemporalField) range} and {@link #get(TemporalField) get} methods will throw an
+   * {@@link#range(TemporalField) range} and {@@link#get(TemporalField) get} methods will throw an
    * exception.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The supported fields
+   * If the field is a {@@linkChronoField} then the query is implemented here. The supported fields
    * are: <ul> <li>{@code NANO_OF_SECOND} <li>{@code MICRO_OF_SECOND} <li>{@code MILLI_OF_SECOND}
-   * <li>{@code INSTANT_SECONDS} </ul> All other {@code ChronoField} instances will return false.
+   * <li>{@code INSTANT_SECONDS} </ul> All other {@@codeChronoField} instances will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.isSupportedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the field is supported is determined by the field.
    *
    * @param field
@@ -397,12 +397,12 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * used to enhance the accuracy of the returned range. If it is not possible to return the range,
    * because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return appropriate range instances. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.rangeRefinedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
    * @param field
@@ -415,20 +415,20 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
   override def range(field: TemporalField): ValueRange = super.range(field)
 
   /**
-   * Gets the value of the specified field from this instant as an {@code int}.
+   * Gets the value of the specified field from this instant as an {@@codeint} .
    *
    * This queries this instant for the value for the specified field. The returned value will always
    * be within the valid range of values for the field. If it is not possible to return the value,
    * because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this date-time,
-   * except {@code INSTANT_SECONDS} which is too large to fit in an {@code int} and throws a {@code
-   * DateTimeException}. All other {@code ChronoField} instances will throw a {@code
+   * except {@@codeINSTANT_SECONDS} which is too large to fit in an {@@codeint} and throws a {@code
+   * DateTimeException}. All other {@@codeChronoField} instances will throw a {@code
    * DateTimeException}.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -453,18 +453,18 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
     }
 
   /**
-   * Gets the value of the specified field from this instant as a {@code long}.
+   * Gets the value of the specified field from this instant as a {@@codelong} .
    *
    * This queries this instant for the value for the specified field. If it is not possible to
    * return the value, because the field is not supported or for some other reason, an exception is
    * thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this date-time.
-   * All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * All other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -493,7 +493,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * Gets the number of seconds from the Java epoch of 1970-01-01T00:00:00Z.
    *
    * The epoch second count is a simple incrementing count of seconds where second 0 is
-   * 1970-01-01T00:00:00Z. The nanosecond part of the day is returned by {@code getNanosOfSecond}.
+   * 1970-01-01T00:00:00Z. The nanosecond part of the day is returned by {@@codegetNanosOfSecond} .
    *
    * @return
    *   the seconds from the epoch of 1970-01-01T00:00:00Z
@@ -504,7 +504,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * Gets the number of nanoseconds, later along the time-line, from the start of the second.
    *
    * The nanosecond-of-second value measures the total number of nanoseconds from the second
-   * returned by {@code getEpochSecond}.
+   * returned by {@@codegetEpochSecond} .
    *
    * @return
    *   the nanoseconds within the second, always positive, never exceeds 999,999,999
@@ -514,12 +514,12 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
   /**
    * Returns an adjusted copy of this instant.
    *
-   * This returns a new {@code Instant}, based on this one, with the date adjusted. The adjustment
+   * This returns a new {@@codeInstant} , based on this one, with the date adjusted. The adjustment
    * takes place using the specified adjuster strategy object. Read the documentation of the
    * adjuster to understand what adjustment will be made.
    *
    * The result of this method is obtained by invoking the {@link
-   * TemporalAdjuster#adjustInto(Temporal)} method on the specified adjuster passing {@code this} as
+   * TemporalAdjuster#adjustInto(Temporal)} method on the specified adjuster passing {@@codethis} as
    * the argument.
    *
    * This instance is immutable and unaffected by this method call.
@@ -527,7 +527,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * @param adjuster
    *   the adjuster to use, not null
    * @return
-   *   an { @code Instant} based on { @code this} with the adjustment made, not null
+   *   an {@@codeInstant} based on {@@codethis} with the adjustment made, not null
    * @throws DateTimeException
    *   if the adjustment cannot be made
    * @throws ArithmeticException
@@ -539,26 +539,26 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
   /**
    * Returns a copy of this instant with the specified field set to a new value.
    *
-   * This returns a new {@code Instant}, based on this one, with the value for the specified field
+   * This returns a new {@@codeInstant} , based on this one, with the value for the specified field
    * changed. If it is not possible to set the value, because the field is not supported or for some
    * other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the adjustment is implemented here. The supported
-   * fields behave as follows: <ul> <li>{@code NANO_OF_SECOND} - Returns an {@code Instant} with the
+   * If the field is a {@@linkChronoField} then the adjustment is implemented here. The supported
+   * fields behave as follows: <ul> <li>{@code NANO_OF_SECOND} - Returns an {@@codeInstant} with the
    * specified nano-of-second. The epoch-second will be unchanged. <li>{@code MICRO_OF_SECOND} -
-   * Returns an {@code Instant} with the nano-of-second replaced by the specified micro-of-second
+   * Returns an {@@codeInstant} with the nano-of-second replaced by the specified micro-of-second
    * multiplied by 1,000. The epoch-second will be unchanged. <li>{@code MILLI_OF_SECOND} - Returns
-   * an {@code Instant} with the nano-of-second replaced by the specified milli-of-second multiplied
+   * an {@@codeInstant} with the nano-of-second replaced by the specified milli-of-second multiplied
    * by 1,000,000. The epoch-second will be unchanged. <li>{@code INSTANT_SECONDS} - Returns an
-   * {@code Instant} with the specified epoch-second. The nano-of-second will be unchanged. </ul>
+   * {@@codeInstant} with the specified epoch-second. The nano-of-second will be unchanged. </ul>
    *
    * In all cases, if the new value is outside the valid range of values for the field then a {@code
    * DateTimeException} will be thrown.
    *
-   * All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * All other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.adjustInto(Temporal, long)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.adjustInto(Temporal, long)} passing {@@codethis} as the argument.
    * In this case, the field determines whether and how to adjust the instant.
    *
    * This instance is immutable and unaffected by this method call.
@@ -568,7 +568,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * @param newValue
    *   the new value of the field in the result
    * @return
-   *   an { @code Instant} based on { @code this} with the specified field set, not null
+   *   an {@@codeInstant} based on {@@codethis} with the specified field set, not null
    * @throws DateTimeException
    *   if the field cannot be set
    * @throws ArithmeticException
@@ -598,23 +598,23 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
   }
 
   /**
-   * Returns a copy of this {@code Instant} truncated to the specified unit.
+   * Returns a copy of this {@@codeInstant} truncated to the specified unit.
    *
    * Truncating the instant returns a copy of the original with fields smaller than the specified
    * unit set to zero. The fields are calculated on the basis of using a UTC offset as seen in
-   * {@code toString}. For example, truncating with the {@link ChronoUnit#MINUTES MINUTES} unit will
-   * round down to the nearest minute, setting the seconds and nanoseconds to zero.
+   * {@@codetoString} . For example, truncating with the {@@linkChronoUnit#MINUTES MINUTES} unit
+   * will round down to the nearest minute, setting the seconds and nanoseconds to zero.
    *
-   * The unit must have a {@linkplain TemporalUnit#getDuration() duration} that divides into the
+   * The unit must have a {@@linkplainTemporalUnit#getDuration() duration} that divides into the
    * length of a standard day without remainder. This includes all supplied time units on {@link
-   * ChronoUnit} and {@link ChronoUnit#DAYS DAYS}. Other units throw an exception.
+   * ChronoUnit} and {@@linkChronoUnit#DAYS DAYS} . Other units throw an exception.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param unit
    *   the unit to truncate to, not null
    * @return
-   *   an { @code Instant} based on this instant with the time truncated, not null
+   *   an {@@codeInstant} based on this instant with the time truncated, not null
    * @throws DateTimeException
    *   if the unit is invalid for truncation
    */
@@ -634,20 +634,20 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
   }
 
   /**
-   * {@inheritDoc}
+   * {@@inheritDoc}
    * @throws DateTimeException
-   *   { @inheritDoc}
+   *   {@@inheritDoc}
    * @throws ArithmeticException
-   *   { @inheritDoc}
+   *   {@@inheritDoc}
    */
   override def plus(amount: TemporalAmount): Instant = amount.addTo(this).asInstanceOf[Instant]
 
   /**
-   * {@inheritDoc}
+   * {@@inheritDoc}
    * @throws DateTimeException
-   *   { @inheritDoc}
+   *   {@@inheritDoc}
    * @throws ArithmeticException
-   *   { @inheritDoc}
+   *   {@@inheritDoc}
    */
   def plus(amountToAdd: Long, unit: TemporalUnit): Instant = {
     unit match {
@@ -686,7 +686,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * @param secondsToAdd
    *   the seconds to add, positive or negative
    * @return
-   *   an { @code Instant} based on this instant with the specified seconds added, not null
+   *   an {@@codeInstant} based on this instant with the specified seconds added, not null
    * @throws DateTimeException
    *   if the result exceeds the maximum or minimum instant
    * @throws ArithmeticException
@@ -702,7 +702,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * @param millisToAdd
    *   the milliseconds to add, positive or negative
    * @return
-   *   an { @code Instant} based on this instant with the specified milliseconds added, not null
+   *   an {@@codeInstant} based on this instant with the specified milliseconds added, not null
    * @throws DateTimeException
    *   if the result exceeds the maximum or minimum instant
    * @throws ArithmeticException
@@ -719,7 +719,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * @param nanosToAdd
    *   the nanoseconds to add, positive or negative
    * @return
-   *   an { @code Instant} based on this instant with the specified nanoseconds added, not null
+   *   an {@@codeInstant} based on this instant with the specified nanoseconds added, not null
    * @throws DateTimeException
    *   if the result exceeds the maximum or minimum instant
    * @throws ArithmeticException
@@ -737,7 +737,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * @param nanosToAdd
    *   the nanos to add, positive or negative
    * @return
-   *   an { @code Instant} based on this instant with the specified seconds added, not null
+   *   an {@@codeInstant} based on this instant with the specified seconds added, not null
    * @throws DateTimeException
    *   if the result exceeds the maximum or minimum instant
    * @throws ArithmeticException
@@ -755,21 +755,21 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
   }
 
   /**
-   * {@inheritDoc}
+   * {@@inheritDoc}
    * @throws DateTimeException
-   *   { @inheritDoc}
+   *   {@@inheritDoc}
    * @throws ArithmeticException
-   *   { @inheritDoc}
+   *   {@@inheritDoc}
    */
   override def minus(amount: TemporalAmount): Instant =
     amount.subtractFrom(this).asInstanceOf[Instant]
 
   /**
-   * {@inheritDoc}
+   * {@@inheritDoc}
    * @throws DateTimeException
-   *   { @inheritDoc}
+   *   {@@inheritDoc}
    * @throws ArithmeticException
-   *   { @inheritDoc}
+   *   {@@inheritDoc}
    */
   override def minus(amountToSubtract: Long, unit: TemporalUnit): Instant =
     if (amountToSubtract == Long.MinValue) plus(Long.MaxValue, unit).plus(1, unit)
@@ -783,7 +783,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * @param secondsToSubtract
    *   the seconds to subtract, positive or negative
    * @return
-   *   an { @code Instant} based on this instant with the specified seconds subtracted, not null
+   *   an {@@codeInstant} based on this instant with the specified seconds subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the maximum or minimum instant
    * @throws ArithmeticException
@@ -803,8 +803,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * @param millisToSubtract
    *   the milliseconds to subtract, positive or negative
    * @return
-   *   an { @code Instant} based on this instant with the specified milliseconds subtracted, not
-   *   null
+   *   an {@@codeInstant} based on this instant with the specified milliseconds subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the maximum or minimum instant
    * @throws ArithmeticException
@@ -824,7 +823,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * @param nanosToSubtract
    *   the nanoseconds to subtract, positive or negative
    * @return
-   *   an { @code Instant} based on this instant with the specified nanoseconds subtracted, not null
+   *   an {@@codeInstant} based on this instant with the specified nanoseconds subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the maximum or minimum instant
    * @throws ArithmeticException
@@ -839,12 +838,12 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
   /**
    * Queries this instant using the specified query.
    *
-   * This queries this instant using the specified query strategy object. The {@code TemporalQuery}
+   * This queries this instant using the specified query strategy object. The {@@codeTemporalQuery}
    * object defines the logic to be used to obtain the result. Read the documentation of the query
    * to understand what the result of this method will be.
    *
    * The result of this method is obtained by invoking the {@link
-   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@code this}
+   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@@codethis}
    * as the argument.
    *
    * @tparam R
@@ -874,8 +873,8 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * This returns a temporal object of the same observable type as the input with the instant
    * changed to be the same as this.
    *
-   * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)} twice, passing
-   * {@link ChronoField#INSTANT_SECONDS} and {@link ChronoField#NANO_OF_SECOND} as the fields.
+   * The adjustment is equivalent to using {@@linkTemporal#with(TemporalField, long)} twice, passing
+   * {@@linkChronoField#INSTANT_SECONDS} and {@@linkChronoField#NANO_OF_SECOND} as the fields.
    *
    * In most cases, it is clearer to reverse the calling pattern by using {@link
    * Temporal#with(TemporalAdjuster)}: <pre> // these two lines are equivalent, but the second
@@ -900,31 +899,31 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * Calculates the period between this instant and another instant in terms of the specified unit.
    *
    * This calculates the period between two instants in terms of a single unit. The start and end
-   * points are {@code this} and the specified instant. The result will be negative if the end is
+   * points are {@@codethis} and the specified instant. The result will be negative if the end is
    * before the start. The calculation returns a whole number, representing the number of complete
-   * units between the two instants. The {@code Temporal} passed to this method is converted to a
-   * {@code Instant} using {@link #from(TemporalAccessor)}. For example, the period in days between
-   * two dates can be calculated using {@code startInstant.until(endInstant, SECONDS)}.
+   * units between the two instants. The {@@codeTemporal} passed to this method is converted to a
+   * {@@codeInstant} using {@@link#from(TemporalAccessor)} . For example, the period in days between
+   * two dates can be calculated using {@@codestartInstant.until(endInstant, SECONDS)} .
    *
-   * This method operates in association with {@link TemporalUnit#between}. The result of this
-   * method is a {@code long} representing the amount of the specified unit. By contrast, the result
-   * of {@code between} is an object that can be used directly in addition/subtraction: <pre> long
+   * This method operates in association with {@@linkTemporalUnit#between} . The result of this
+   * method is a {@@codelong} representing the amount of the specified unit. By contrast, the result
+   * of {@@codebetween} is an object that can be used directly in addition/subtraction: <pre> long
    * period = start.until(end, SECONDS); // this method dateTime.plus(SECONDS.between(start, end));
    * // use in plus/minus </pre>
    *
-   * The calculation is implemented in this method for {@link ChronoUnit}. The units {@code NANOS},
-   * {@code MICROS}, {@code MILLIS}, {@code SECONDS}, {@code MINUTES}, {@code HOURS}, {@code
-   * HALF_DAYS} and {@code DAYS} are supported. Other {@code ChronoUnit} values will throw an
+   * The calculation is implemented in this method for {@@linkChronoUnit} . The units {@@codeNANOS}
+   * , {@@codeMICROS} , {@@codeMILLIS} , {@@codeSECONDS} , {@@codeMINUTES} , {@@codeHOURS} , {@code
+   * HALF_DAYS} and {@@codeDAYS} are supported. Other {@@codeChronoUnit} values will throw an
    * exception.
    *
-   * If the unit is not a {@code ChronoUnit}, then the result of this method is obtained by invoking
-   * {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first argument and
-   * the input temporal as the second argument.
+   * If the unit is not a {@@codeChronoUnit} , then the result of this method is obtained by
+   * invoking {@@codeTemporalUnit.between(Temporal, Temporal)} passing {@@codethis} as the first
+   * argument and the input temporal as the second argument.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param endExclusive
-   *   the end date, which is converted to an { @code Instant}, not null
+   *   the end date, which is converted to an {@@codeInstant} , not null
    * @param unit
    *   the unit to measure the period in, not null
    * @return
@@ -981,9 +980,9 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
   }
 
   /**
-   * Combines this instant with an offset to create an {@code OffsetDateTime}.
+   * Combines this instant with an offset to create an {@@codeOffsetDateTime} .
    *
-   * This returns an {@code OffsetDateTime} formed from this instant at the specified offset from
+   * This returns an {@@codeOffsetDateTime} formed from this instant at the specified offset from
    * UTC/Greenwich. An exception will be thrown if the instant is too large to fit into an offset
    * date-time.
    *
@@ -1000,9 +999,9 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
   def atOffset(offset: ZoneOffset): OffsetDateTime = OffsetDateTime.ofInstant(this, offset)
 
   /**
-   * Combines this instant with a time-zone to create a {@code ZonedDateTime}.
+   * Combines this instant with a time-zone to create a {@@codeZonedDateTime} .
    *
-   * This returns an {@code ZonedDateTime} formed from this instant at the specified time-zone. An
+   * This returns an {@@codeZonedDateTime} formed from this instant at the specified time-zone. An
    * exception will be thrown if the instant is too large to fit into a zoned date-time.
    *
    * This method is equivalent to {@link ZonedDateTime#ofInstant(Instant, ZoneId)
@@ -1021,7 +1020,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * Converts this instant to the number of milliseconds from the epoch of 1970-01-01T00:00:00Z.
    *
    * If this instant represents a point on the time-line too far in the future or past to fit in a
-   * {@code long} milliseconds, then an exception is thrown.
+   * {@@codelong} milliseconds, then an exception is thrown.
    *
    * If this instant has greater than millisecond precision, then the conversion will drop any
    * excess precision information as though the amount in nanoseconds was subject to integer
@@ -1054,7 +1053,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
    * Compares this instant to the specified instant.
    *
    * The comparison is based on the time-line position of the instants. It is "consistent with
-   * equals", as defined by {@link Comparable}.
+   * equals", as defined by {@@linkComparable} .
    *
    * @param otherInstant
    *   the other instant to compare to, not null
@@ -1127,7 +1126,7 @@ final class Instant private (private val seconds: Long, private val nanos: Int)
   /**
    * A string representation of this instant using ISO-8601 representation.
    *
-   * The format used is the same as {@link DateTimeFormatter#ISO_INSTANT}.
+   * The format used is the same as {@@linkDateTimeFormatter#ISO_INSTANT} .
    *
    * @return
    *   an ISO-8601 representation of this instant, not null
diff --git a/core/shared/src/main/scala/org/threeten/bp/LocalDate.scala b/core/shared/src/main/scala/org/threeten/bp/LocalDate.scala
index c27f26473..376920db7 100644
--- a/core/shared/src/main/scala/org/threeten/bp/LocalDate.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/LocalDate.scala
@@ -69,13 +69,13 @@ import org.threeten.bp.zone.ZoneRules
 object LocalDate {
 
   /**
-   * The minimum supported {@code LocalDate}, '-999999999-01-01'. This could be used by an
+   * The minimum supported {@@codeLocalDate} , '-999999999-01-01'. This could be used by an
    * application as a "far past" date.
    */
   lazy val MIN: LocalDate = LocalDate.of(Year.MIN_VALUE, 1, 1)
 
   /**
-   * The maximum supported {@code LocalDate}, '+999999999-12-31'. This could be used by an
+   * The maximum supported {@@codeLocalDate} , '+999999999-12-31'. This could be used by an
    * application as a "far future" date.
    */
   lazy val MAX: LocalDate = LocalDate.of(Year.MAX_VALUE, 12, 31)
@@ -92,7 +92,7 @@ object LocalDate {
   /**
    * Obtains the current date from the system clock in the default time-zone.
    *
-   * This will query the {@link Clock#systemDefaultZone() system clock} in the default time-zone to
+   * This will query the {@@linkClock#systemDefaultZone() system clock} in the default time-zone to
    * obtain the current date.
    *
    * Using this method will prevent the ability to use an alternate clock for testing because the
@@ -106,7 +106,7 @@ object LocalDate {
   /**
    * Obtains the current date from the system clock in the specified time-zone.
    *
-   * This will query the {@link Clock#system(ZoneId) system clock} to obtain the current date.
+   * This will query the {@@linkClock#system(ZoneId) system clock} to obtain the current date.
    * Specifying the time-zone avoids dependence on the default time-zone.
    *
    * Using this method will prevent the ability to use an alternate clock for testing because the
@@ -124,7 +124,7 @@ object LocalDate {
    *
    * This will query the specified clock to obtain the current date - today. Using this method
    * allows the use of an alternate clock for testing. The alternate clock may be introduced using
-   * {@link Clock dependency injection}.
+   * {@@linkClock dependency injection} .
    *
    * @param clock
    *   the clock to use, not null
@@ -141,7 +141,7 @@ object LocalDate {
   }
 
   /**
-   * Obtains an instance of {@code LocalDate} from a year, month and day.
+   * Obtains an instance of {@@codeLocalDate} from a year, month and day.
    *
    * The day must be valid for the year and month, otherwise an exception will be thrown.
    *
@@ -166,7 +166,7 @@ object LocalDate {
   }
 
   /**
-   * Obtains an instance of {@code LocalDate} from a year, month and day.
+   * Obtains an instance of {@@codeLocalDate} from a year, month and day.
    *
    * The day must be valid for the year and month, otherwise an exception will be thrown.
    *
@@ -191,7 +191,7 @@ object LocalDate {
   }
 
   /**
-   * Obtains an instance of {@code LocalDate} from a year and day-of-year.
+   * Obtains an instance of {@@codeLocalDate} from a year and day-of-year.
    *
    * The day-of-year must be valid for the year, otherwise an exception will be thrown.
    *
@@ -221,7 +221,7 @@ object LocalDate {
   }
 
   /**
-   * Obtains an instance of {@code LocalDate} from the epoch day count.
+   * Obtains an instance of {@@codeLocalDate} from the epoch day count.
    *
    * The Epoch Day count is a simple incrementing count of days where day 0 is 1970-01-01. Negative
    * numbers represent earlier days.
@@ -260,23 +260,23 @@ object LocalDate {
   }
 
   /**
-   * Obtains an instance of {@code LocalDate} from a temporal object.
+   * Obtains an instance of {@@codeLocalDate} from a temporal object.
    *
-   * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code LocalDate}.
+   * A {@@codeTemporalAccessor} represents some form of date and time information. This factory
+   * converts the arbitrary temporal object to an instance of {@@codeLocalDate} .
    *
-   * The conversion uses the {@link TemporalQueries#localDate()} query, which relies on extracting
-   * the {@link ChronoField#EPOCH_DAY EPOCH_DAY} field.
+   * The conversion uses the {@@linkTemporalQueries#localDate()} query, which relies on extracting
+   * the {@@linkChronoField#EPOCH_DAY EPOCH_DAY} field.
    *
-   * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used as a query via method reference, {@code LocalDate::from}.
+   * This method matches the signature of the functional interface {@@linkTemporalQuery} allowing it
+   * to be used as a query via method reference, {@@codeLocalDate::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the local date, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code LocalDate}
+   *   if unable to convert to a {@@codeLocalDate}
    */
   def from(temporal: TemporalAccessor): LocalDate = {
     val date: LocalDate = temporal.query(TemporalQueries.localDate)
@@ -288,7 +288,7 @@ object LocalDate {
   }
 
   /**
-   * Obtains an instance of {@code LocalDate} from a text string such as {@code 2007-12-03}.
+   * Obtains an instance of {@@codeLocalDate} from a text string such as {@@code2007-12-03} .
    *
    * The string must represent a valid date and is parsed using {@link
    * org.threeten.bp.format.DateTimeFormatter#ISO_LOCAL_DATE}.
@@ -303,7 +303,7 @@ object LocalDate {
   def parse(text: CharSequence): LocalDate = parse(text, DateTimeFormatter.ISO_LOCAL_DATE)
 
   /**
-   * Obtains an instance of {@code LocalDate} from a text string using a specific formatter.
+   * Obtains an instance of {@@codeLocalDate} from a text string using a specific formatter.
    *
    * The text is parsed using the formatter, returning a date.
    *
@@ -376,11 +376,11 @@ object LocalDate {
 }
 
 /**
- * A date without a time-zone in the ISO-8601 calendar system, such as {@code 2007-12-03}.
+ * A date without a time-zone in the ISO-8601 calendar system, such as {@@code2007-12-03} .
  *
- * {@code LocalDate} is an immutable date-time object that represents a date, often viewed as
+ * {@@codeLocalDate} is an immutable date-time object that represents a date, often viewed as
  * year-month-day. Other date fields, such as day-of-year, day-of-week and week-of-year, can also be
- * accessed. For example, the value "2nd October 2007" can be stored in a {@code LocalDate}.
+ * accessed. For example, the value "2nd October 2007" can be stored in a {@@codeLocalDate} .
  *
  * This class does not store or represent a time or time-zone. Instead, it is a description of the
  * date, as used for birthdays. It cannot represent an instant on the time-line without additional
@@ -420,19 +420,19 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * Checks if the specified field is supported.
    *
    * This checks if this date can be queried for the specified field. If false, then calling the
-   * {@link #range(TemporalField) range} and {@link #get(TemporalField) get} methods will throw an
+   * {@@link#range(TemporalField) range} and {@@link#get(TemporalField) get} methods will throw an
    * exception.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this date-time.
    * The supported fields are: <ul> <li>{@code DAY_OF_WEEK} <li>{@code ALIGNED_DAY_OF_WEEK_IN_MONTH}
    * <li>{@code ALIGNED_DAY_OF_WEEK_IN_YEAR} <li>{@code DAY_OF_MONTH} <li>{@code DAY_OF_YEAR}
    * <li>{@code EPOCH_DAY} <li>{@code ALIGNED_WEEK_OF_MONTH} <li>{@code ALIGNED_WEEK_OF_YEAR}
    * <li>{@code MONTH_OF_YEAR} <li>{@code EPOCH_MONTH} <li>{@code YEAR_OF_ERA} <li>{@code YEAR}
-   * <li>{@code ERA} </ul> All other {@code ChronoField} instances will return false.
+   * <li>{@code ERA} </ul> All other {@@codeChronoField} instances will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.isSupportedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the field is supported is determined by the field.
    *
    * @param field
@@ -449,12 +449,12 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * to enhance the accuracy of the returned range. If it is not possible to return the range,
    * because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return appropriate range instances. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.rangeRefinedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
    * @param field
@@ -484,20 +484,20 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
       field.rangeRefinedBy(this)
 
   /**
-   * Gets the value of the specified field from this date as an {@code int}.
+   * Gets the value of the specified field from this date as an {@@codeint} .
    *
    * This queries this date for the value for the specified field. The returned value will always be
    * within the valid range of values for the field. If it is not possible to return the value,
    * because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this date,
-   * except {@code EPOCH_DAY} and {@code EPOCH_MONTH} which are too large to fit in an {@code int}
-   * and throw a {@code DateTimeException}. All other {@code ChronoField} instances will throw a
-   * {@code DateTimeException}.
+   * except {@@codeEPOCH_DAY} and {@@codeEPOCH_MONTH} which are too large to fit in an {@@codeint}
+   * and throw a {@@codeDateTimeException} . All other {@@codeChronoField} instances will throw a
+   * {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -514,17 +514,17 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
     else super.get(field)
 
   /**
-   * Gets the value of the specified field from this date as a {@code long}.
+   * Gets the value of the specified field from this date as a {@@codelong} .
    *
    * This queries this date for the value for the specified field. If it is not possible to return
    * the value, because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this date. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -569,7 +569,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
   /**
    * Gets the chronology of this date, which is the ISO calendar system.
    *
-   * The {@code Chronology} represents the calendar system in use. The ISO-8601 calendar system is
+   * The {@@codeChronology} represents the calendar system in use. The ISO-8601 calendar system is
    * the modern civil calendar system used today in most of the world. It is equivalent to the
    * proleptic Gregorian calendar system, in which todays's rules for leap years are applied for all
    * time.
@@ -582,29 +582,29 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
   /**
    * Gets the era applicable at this date.
    *
-   * The official ISO-8601 standard does not define eras, however {@code IsoChronology} does. It
+   * The official ISO-8601 standard does not define eras, however {@@codeIsoChronology} does. It
    * defines two eras, 'CE' from year one onwards and 'BCE' from year zero backwards. Since dates
    * before the Julian-Gregorian cutover are not in line with history, the cutover between 'BCE' and
    * 'CE' is also not aligned with the commonly used eras, often referred to using 'BC' and 'AD'.
    *
    * Users of this class should typically ignore this method as it exists primarily to fulfill the
-   * {@link ChronoLocalDate} contract where it is necessary to support the Japanese calendar system.
+   * {@@linkChronoLocalDate} contract where it is necessary to support the Japanese calendar system.
    *
    * The returned era will be a singleton capable of being compared with the constants in {@link
-   * IsoChronology} using the {@code ==} operator.
+   * IsoChronology} using the {@@code==} operator.
    *
    * @return
-   *   the { @code IsoChronology} era constant applicable at this date, not null
+   *   the {@@codeIsoChronology} era constant applicable at this date, not null
    */
   override def getEra: Era = super.getEra
 
   /**
    * Gets the year field.
    *
-   * This method returns the primitive {@code int} value for the year.
+   * This method returns the primitive {@@codeint} value for the year.
    *
-   * The year returned by this method is proleptic as per {@code get(YEAR)}. To obtain the
-   * year-of-era, use {@code get(YEAR_OF_ERA}.
+   * The year returned by this method is proleptic as per {@@codeget(YEAR)} . To obtain the
+   * year-of-era, use {@@codeget(YEAR_OF_ERA} .
    *
    * @return
    *   the year, from MIN_YEAR to MAX_YEAR
@@ -614,8 +614,8 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
   /**
    * Gets the month-of-year field from 1 to 12.
    *
-   * This method returns the month as an {@code int} from 1 to 12. Application code is frequently
-   * clearer if the enum {@link Month} is used by calling {@link #getMonth()}.
+   * This method returns the month as an {@@codeint} from 1 to 12. Application code is frequently
+   * clearer if the enum {@@linkMonth} is used by calling {@@link#getMonth()} .
    *
    * @return
    *   the month-of-year, from 1 to 12
@@ -625,11 +625,11 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
   def getMonthValue: Int = month.toInt
 
   /**
-   * Gets the month-of-year field using the {@code Month} enum.
+   * Gets the month-of-year field using the {@@codeMonth} enum.
    *
-   * This method returns the enum {@link Month} for the month. This avoids confusion as to what
-   * {@code int} values mean. If you need access to the primitive {@code int} value then the enum
-   * provides the {@link Month#getValue() int value}.
+   * This method returns the enum {@@linkMonth} for the month. This avoids confusion as to what
+   * {@@codeint} values mean. If you need access to the primitive {@@codeint} value then the enum
+   * provides the {@@linkMonth#getValue() int value} .
    *
    * @return
    *   the month-of-year, not null
@@ -641,7 +641,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
   /**
    * Gets the day-of-month field.
    *
-   * This method returns the primitive {@code int} value for the day-of-month.
+   * This method returns the primitive {@@codeint} value for the day-of-month.
    *
    * @return
    *   the day-of-month, from 1 to 31
@@ -651,7 +651,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
   /**
    * Gets the day-of-year field.
    *
-   * This method returns the primitive {@code int} value for the day-of-year.
+   * This method returns the primitive {@@codeint} value for the day-of-year.
    *
    * @return
    *   the day-of-year, from 1 to 365, or 366 in a leap year
@@ -659,13 +659,13 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
   def getDayOfYear: Int = getMonth.firstDayOfYear(isLeapYear) + day - 1
 
   /**
-   * Gets the day-of-week field, which is an enum {@code DayOfWeek}.
+   * Gets the day-of-week field, which is an enum {@@codeDayOfWeek} .
    *
-   * This method returns the enum {@link DayOfWeek} for the day-of-week. This avoids confusion as to
-   * what {@code int} values mean. If you need access to the primitive {@code int} value then the
-   * enum provides the {@link DayOfWeek#getValue() int value}.
+   * This method returns the enum {@@linkDayOfWeek} for the day-of-week. This avoids confusion as to
+   * what {@@codeint} values mean. If you need access to the primitive {@@codeint} value then the
+   * enum provides the {@@linkDayOfWeek#getValue() int value} .
    *
-   * Additional information can be obtained from the {@code DayOfWeek}. This includes textual names
+   * Additional information can be obtained from the {@@codeDayOfWeek} . This includes textual names
    * of the values.
    *
    * @return
@@ -722,15 +722,15 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
   /**
    * Returns an adjusted copy of this date.
    *
-   * This returns a new {@code LocalDate}, based on this one, with the date adjusted. The adjustment
-   * takes place using the specified adjuster strategy object. Read the documentation of the
-   * adjuster to understand what adjustment will be made.
+   * This returns a new {@@codeLocalDate} , based on this one, with the date adjusted. The
+   * adjustment takes place using the specified adjuster strategy object. Read the documentation of
+   * the adjuster to understand what adjustment will be made.
    *
    * A simple adjuster might simply set the one of the fields, such as the year field. A more
    * complex adjuster might set the date to the last day of the month. A selection of common
-   * adjustments is provided in {@link TemporalAdjusters}. These include finding the "last day of
+   * adjustments is provided in {@@linkTemporalAdjusters} . These include finding the "last day of
    * the month" and "next Wednesday". Key date-time classes also implement the {@code
-   * TemporalAdjuster} interface, such as {@link Month} and {@link MonthDay}. The adjuster is
+   * TemporalAdjuster} interface, such as {@@linkMonth} and {@@linkMonthDay} . The adjuster is
    * responsible for handling special cases, such as the varying lengths of month and leap years.
    *
    * For example this code returns a date on the last day of July: <pre> import static
@@ -739,7 +739,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * result = localDate.with(JULY).with(lastDayOfMonth()); </pre>
    *
    * The result of this method is obtained by invoking the {@link
-   * TemporalAdjuster#adjustInto(Temporal)} method on the specified adjuster passing {@code this} as
+   * TemporalAdjuster#adjustInto(Temporal)} method on the specified adjuster passing {@@codethis} as
    * the argument.
    *
    * This instance is immutable and unaffected by this method call.
@@ -747,7 +747,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param adjuster
    *   the adjuster to use, not null
    * @return
-   *   a { @code LocalDate} based on { @code this} with the adjustment made, not null
+   *   a {@@codeLocalDate} based on {@@codethis} with the adjustment made, not null
    * @throws DateTimeException
    *   if the adjustment cannot be made
    * @throws ArithmeticException
@@ -760,8 +760,8 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
   /**
    * Returns a copy of this date with the specified field set to a new value.
    *
-   * This returns a new {@code LocalDate}, based on this one, with the value for the specified field
-   * changed. This can be used to change any supported field, such as the year, month or
+   * This returns a new {@@codeLocalDate} , based on this one, with the value for the specified
+   * field changed. This can be used to change any supported field, such as the year, month or
    * day-of-month. If it is not possible to set the value, because the field is not supported or for
    * some other reason, an exception is thrown.
    *
@@ -770,46 +770,46 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * In cases like this, the field is responsible for resolving the date. Typically it will choose
    * the previous valid date, which would be the last valid day of February in this example.
    *
-   * If the field is a {@link ChronoField} then the adjustment is implemented here. The supported
-   * fields behave as follows: <ul> <li>{@code DAY_OF_WEEK} - Returns a {@code LocalDate} with the
+   * If the field is a {@@linkChronoField} then the adjustment is implemented here. The supported
+   * fields behave as follows: <ul> <li>{@code DAY_OF_WEEK} - Returns a {@@codeLocalDate} with the
    * specified day-of-week. The date is adjusted up to 6 days forward or backward within the
    * boundary of a Monday to Sunday week. <li>{@code ALIGNED_DAY_OF_WEEK_IN_MONTH} - Returns a
-   * {@code LocalDate} with the specified aligned-day-of-week. The date is adjusted to the specified
+   * {@@codeLocalDate} with the specified aligned-day-of-week. The date is adjusted to the specified
    * month-based aligned-day-of-week. Aligned weeks are counted such that the first week of a given
    * month starts on the first day of that month. This may cause the date to be moved up to 6 days
-   * into the following month. <li>{@code ALIGNED_DAY_OF_WEEK_IN_YEAR} - Returns a {@code LocalDate}
+   * into the following month. <li>{@code ALIGNED_DAY_OF_WEEK_IN_YEAR} - Returns a {@@codeLocalDate}
    * with the specified aligned-day-of-week. The date is adjusted to the specified year-based
    * aligned-day-of-week. Aligned weeks are counted such that the first week of a given year starts
    * on the first day of that year. This may cause the date to be moved up to 6 days into the
-   * following year. <li>{@code DAY_OF_MONTH} - Returns a {@code LocalDate} with the specified
+   * following year. <li>{@code DAY_OF_MONTH} - Returns a {@@codeLocalDate} with the specified
    * day-of-month. The month and year will be unchanged. If the day-of-month is invalid for the year
-   * and month, then a {@code DateTimeException} is thrown. <li>{@code DAY_OF_YEAR} - Returns a
-   * {@code LocalDate} with the specified day-of-year. The year will be unchanged. If the
-   * day-of-year is invalid for the year, then a {@code DateTimeException} is thrown. <li>{@code
-   * EPOCH_DAY} - Returns a {@code LocalDate} with the specified epoch-day. This completely replaces
-   * the date and is equivalent to {@link #ofEpochDay(long)}. <li>{@code ALIGNED_WEEK_OF_MONTH} -
-   * Returns a {@code LocalDate} with the specified aligned-week-of-month. Aligned weeks are counted
+   * and month, then a {@@codeDateTimeException} is thrown. <li>{@code DAY_OF_YEAR} - Returns a
+   * {@@codeLocalDate} with the specified day-of-year. The year will be unchanged. If the
+   * day-of-year is invalid for the year, then a {@@codeDateTimeException} is thrown. <li>{@code
+   * EPOCH_DAY} - Returns a {@@codeLocalDate} with the specified epoch-day. This completely replaces
+   * the date and is equivalent to {@@link#ofEpochDay(long)} . <li>{@code ALIGNED_WEEK_OF_MONTH} -
+   * Returns a {@@codeLocalDate} with the specified aligned-week-of-month. Aligned weeks are counted
    * such that the first week of a given month starts on the first day of that month. This
    * adjustment moves the date in whole week chunks to match the specified week. The result will
    * have the same day-of-week as this date. This may cause the date to be moved into the following
-   * month. <li>{@code ALIGNED_WEEK_OF_YEAR} - Returns a {@code LocalDate} with the specified
+   * month. <li>{@code ALIGNED_WEEK_OF_YEAR} - Returns a {@@codeLocalDate} with the specified
    * aligned-week-of-year. Aligned weeks are counted such that the first week of a given year starts
    * on the first day of that year. This adjustment moves the date in whole week chunks to match the
    * specified week. The result will have the same day-of-week as this date. This may cause the date
-   * to be moved into the following year. <li>{@code MONTH_OF_YEAR} - Returns a {@code LocalDate}
+   * to be moved into the following year. <li>{@code MONTH_OF_YEAR} - Returns a {@@codeLocalDate}
    * with the specified month-of-year. The year will be unchanged. The day-of-month will also be
    * unchanged, unless it would be invalid for the new month and year. In that case, the
    * day-of-month is adjusted to the maximum valid value for the new month and year. <li>{@code
-   * PROLEPTIC_MONTH} - Returns a {@code LocalDate} with the specified proleptic-month. The
+   * PROLEPTIC_MONTH} - Returns a {@@codeLocalDate} with the specified proleptic-month. The
    * day-of-month will be unchanged, unless it would be invalid for the new month and year. In that
    * case, the day-of-month is adjusted to the maximum valid value for the new month and year.
-   * <li>{@code YEAR_OF_ERA} - Returns a {@code LocalDate} with the specified year-of-era. The era
+   * <li>{@code YEAR_OF_ERA} - Returns a {@@codeLocalDate} with the specified year-of-era. The era
    * and month will be unchanged. The day-of-month will also be unchanged, unless it would be
    * invalid for the new month and year. In that case, the day-of-month is adjusted to the maximum
-   * valid value for the new month and year. <li>{@code YEAR} - Returns a {@code LocalDate} with the
+   * valid value for the new month and year. <li>{@code YEAR} - Returns a {@@codeLocalDate} with the
    * specified year. The month will be unchanged. The day-of-month will also be unchanged, unless it
    * would be invalid for the new month and year. In that case, the day-of-month is adjusted to the
-   * maximum valid value for the new month and year. <li>{@code ERA} - Returns a {@code LocalDate}
+   * maximum valid value for the new month and year. <li>{@code ERA} - Returns a {@@codeLocalDate}
    * with the specified era. The year-of-era and month will be unchanged. The day-of-month will also
    * be unchanged, unless it would be invalid for the new month and year. In that case, the
    * day-of-month is adjusted to the maximum valid value for the new month and year. </ul>
@@ -817,10 +817,10 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * In all cases, if the new value is outside the valid range of values for the field then a {@code
    * DateTimeException} will be thrown.
    *
-   * All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * All other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.adjustInto(Temporal, long)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.adjustInto(Temporal, long)} passing {@@codethis} as the argument.
    * In this case, the field determines whether and how to adjust the instant.
    *
    * This instance is immutable and unaffected by this method call.
@@ -830,7 +830,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param newValue
    *   the new value of the field in the result
    * @return
-   *   a { @code LocalDate} based on { @code this} with the specified field set, not null
+   *   a {@@codeLocalDate} based on {@@codethis} with the specified field set, not null
    * @throws DateTimeException
    *   if the field cannot be set
    * @throws ArithmeticException
@@ -870,7 +870,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param year
    *   the year to set in the result, from MIN_YEAR to MAX_YEAR
    * @return
-   *   a { @code LocalDate} based on this date with the requested year, not null
+   *   a {@@codeLocalDate} based on this date with the requested year, not null
    * @throws DateTimeException
    *   if the year value is invalid
    */
@@ -891,7 +891,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param month
    *   the month-of-year to set in the result, from 1 (January) to 12 (December)
    * @return
-   *   a { @code LocalDate} based on this date with the requested month, not null
+   *   a {@@codeLocalDate} based on this date with the requested month, not null
    * @throws DateTimeException
    *   if the month-of-year value is invalid
    */
@@ -912,7 +912,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param dayOfMonth
    *   the day-of-month to set in the result, from 1 to 28-31
    * @return
-   *   a { @code LocalDate} based on this date with the requested day, not null
+   *   a {@@codeLocalDate} based on this date with the requested day, not null
    * @throws DateTimeException
    *   if the day-of-month value is invalid
    * @throws DateTimeException
@@ -931,7 +931,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param dayOfYear
    *   the day-of-year to set in the result, from 1 to 365-366
    * @return
-   *   a { @code LocalDate} based on this date with the requested day, not null
+   *   a {@@codeLocalDate} based on this date with the requested day, not null
    * @throws DateTimeException
    *   if the day-of-year value is invalid
    * @throws DateTimeException
@@ -945,16 +945,16 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * Returns a copy of this date with the specified period added.
    *
    * This method returns a new date based on this date with the specified period added. The amount
-   * is typically {@link Period} but may be any other type implementing the {@link TemporalAmount}
+   * is typically {@@linkPeriod} but may be any other type implementing the {@@linkTemporalAmount}
    * interface. The calculation is delegated to the specified adjuster, which typically calls back
-   * to {@link #plus(long, TemporalUnit)}.
+   * to {@@link#plus(long, TemporalUnit)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param amount
    *   the amount to add, not null
    * @return
-   *   a { @code LocalDate} based on this date with the addition made, not null
+   *   a {@@codeLocalDate} based on this date with the addition made, not null
    * @throws DateTimeException
    *   if the addition cannot be made
    * @throws ArithmeticException
@@ -977,7 +977,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param unit
    *   the unit of the period to add, not null
    * @return
-   *   a { @code LocalDate} based on this date with the specified period added, not null
+   *   a {@@codeLocalDate} based on this date with the specified period added, not null
    * @throws DateTimeException
    *   if the unit cannot be added to this type
    */
@@ -1000,7 +1000,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
       unit.addTo(this, amountToAdd)
 
   /**
-   * Returns a copy of this {@code LocalDate} with the specified period in years added.
+   * Returns a copy of this {@@codeLocalDate} with the specified period in years added.
    *
    * This method adds the specified amount to the years field in three steps: <ol> <li>Add the input
    * years to the year field</li> <li>Check if the resulting date would be invalid</li> <li>Adjust
@@ -1015,7 +1015,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param yearsToAdd
    *   the years to add, may be negative
    * @return
-   *   a { @code LocalDate} based on this date with the years added, not null
+   *   a {@@codeLocalDate} based on this date with the years added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1028,7 +1028,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
     }
 
   /**
-   * Returns a copy of this {@code LocalDate} with the specified period in months added.
+   * Returns a copy of this {@@codeLocalDate} with the specified period in months added.
    *
    * This method adds the specified amount to the months field in three steps: <ol> <li>Add the
    * input months to the month-of-year field</li> <li>Check if the resulting date would be
@@ -1042,7 +1042,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param monthsToAdd
    *   the months to add, may be negative
    * @return
-   *   a { @code LocalDate} based on this date with the months added, not null
+   *   a {@@codeLocalDate} based on this date with the months added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1058,7 +1058,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
     }
 
   /**
-   * Returns a copy of this {@code LocalDate} with the specified period in weeks added.
+   * Returns a copy of this {@@codeLocalDate} with the specified period in weeks added.
    *
    * This method adds the specified amount in weeks to the days field incrementing the month and
    * year fields as necessary to ensure the result remains valid. The result is only invalid if the
@@ -1071,14 +1071,14 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param weeksToAdd
    *   the weeks to add, may be negative
    * @return
-   *   a { @code LocalDate} based on this date with the weeks added, not null
+   *   a {@@codeLocalDate} based on this date with the weeks added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
   def plusWeeks(weeksToAdd: Long): LocalDate = plusDays(Math.multiplyExact(weeksToAdd, 7L))
 
   /**
-   * Returns a copy of this {@code LocalDate} with the specified number of days added.
+   * Returns a copy of this {@@codeLocalDate} with the specified number of days added.
    *
    * This method adds the specified amount to the days field incrementing the month and year fields
    * as necessary to ensure the result remains valid. The result is only invalid if the
@@ -1091,7 +1091,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param daysToAdd
    *   the days to add, may be negative
    * @return
-   *   a { @code LocalDate} based on this date with the days added, not null
+   *   a {@@codeLocalDate} based on this date with the days added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1107,16 +1107,16 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * Returns a copy of this date with the specified period subtracted.
    *
    * This method returns a new date based on this date with the specified period subtracted. The
-   * amount is typically {@link Period} but may be any other type implementing the {@link
+   * amount is typically {@@linkPeriod} but may be any other type implementing the {@link
    * TemporalAmount} interface. The calculation is delegated to the specified adjuster, which
-   * typically calls back to {@link #minus(long, TemporalUnit)}.
+   * typically calls back to {@@link#minus(long, TemporalUnit)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param amount
    *   the amount to subtract, not null
    * @return
-   *   a { @code LocalDate} based on this date with the subtraction made, not null
+   *   a {@@codeLocalDate} based on this date with the subtraction made, not null
    * @throws DateTimeException
    *   if the subtraction cannot be made
    * @throws ArithmeticException
@@ -1140,7 +1140,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param unit
    *   the unit of the period to subtract, not null
    * @return
-   *   a { @code LocalDate} based on this date with the specified period subtracted, not null
+   *   a {@@codeLocalDate} based on this date with the specified period subtracted, not null
    * @throws DateTimeException
    *   if the unit cannot be added to this type
    */
@@ -1149,7 +1149,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
     else plus(-amountToSubtract, unit)
 
   /**
-   * Returns a copy of this {@code LocalDate} with the specified period in years subtracted.
+   * Returns a copy of this {@@codeLocalDate} with the specified period in years subtracted.
    *
    * This method subtracts the specified amount from the years field in three steps: <ol>
    * <li>Subtract the input years to the year field</li> <li>Check if the resulting date would be
@@ -1164,7 +1164,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param yearsToSubtract
    *   the years to subtract, may be negative
    * @return
-   *   a { @code LocalDate} based on this date with the years subtracted, not null
+   *   a {@@codeLocalDate} based on this date with the years subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1173,7 +1173,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
     else plusYears(-yearsToSubtract)
 
   /**
-   * Returns a copy of this {@code LocalDate} with the specified period in months subtracted.
+   * Returns a copy of this {@@codeLocalDate} with the specified period in months subtracted.
    *
    * This method subtracts the specified amount from the months field in three steps: <ol>
    * <li>Subtract the input months to the month-of-year field</li> <li>Check if the resulting date
@@ -1187,7 +1187,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param monthsToSubtract
    *   the months to subtract, may be negative
    * @return
-   *   a { @code LocalDate} based on this date with the months subtracted, not null
+   *   a {@@codeLocalDate} based on this date with the months subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1196,7 +1196,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
     else plusMonths(-monthsToSubtract)
 
   /**
-   * Returns a copy of this {@code LocalDate} with the specified period in weeks subtracted.
+   * Returns a copy of this {@@codeLocalDate} with the specified period in weeks subtracted.
    *
    * This method subtracts the specified amount in weeks from the days field decrementing the month
    * and year fields as necessary to ensure the result remains valid. The result is only invalid if
@@ -1209,7 +1209,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param weeksToSubtract
    *   the weeks to subtract, may be negative
    * @return
-   *   a { @code LocalDate} based on this date with the weeks subtracted, not null
+   *   a {@@codeLocalDate} based on this date with the weeks subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1218,7 +1218,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
     else plusWeeks(-weeksToSubtract)
 
   /**
-   * Returns a copy of this {@code LocalDate} with the specified number of days subtracted.
+   * Returns a copy of this {@@codeLocalDate} with the specified number of days subtracted.
    *
    * This method subtracts the specified amount from the days field decrementing the month and year
    * fields as necessary to ensure the result remains valid. The result is only invalid if the
@@ -1231,7 +1231,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * @param daysToSubtract
    *   the days to subtract, may be negative
    * @return
-   *   a { @code LocalDate} based on this date with the days subtracted, not null
+   *   a {@@codeLocalDate} based on this date with the days subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1242,12 +1242,12 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
   /**
    * Queries this date using the specified query.
    *
-   * This queries this date using the specified query strategy object. The {@code TemporalQuery}
+   * This queries this date using the specified query strategy object. The {@@codeTemporalQuery}
    * object defines the logic to be used to obtain the result. Read the documentation of the query
    * to understand what the result of this method will be.
    *
    * The result of this method is obtained by invoking the {@link
-   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@code this}
+   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@@codethis}
    * as the argument.
    *
    * @tparam R
@@ -1271,7 +1271,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * This returns a temporal object of the same observable type as the input with the date changed
    * to be the same as this.
    *
-   * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)} passing {@link
+   * The adjustment is equivalent to using {@@linkTemporal#with(TemporalField, long)} passing {@link
    * ChronoField#EPOCH_DAY} as the field.
    *
    * In most cases, it is clearer to reverse the calling pattern by using {@link
@@ -1296,8 +1296,8 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * Calculates the period between this date and another date in terms of the specified unit.
    *
    * This calculates the period between two dates in terms of a single unit. The start and end
-   * points are {@code this} and the specified date. The result will be negative if the end is
-   * before the start. The {@code Temporal} passed to this method must be a {@code LocalDate}. For
+   * points are {@@codethis} and the specified date. The result will be negative if the end is
+   * before the start. The {@@codeTemporal} passed to this method must be a {@@codeLocalDate} . For
    * example, the period in days between two dates can be calculated using {@code
    * startDate.until(endDate, DAYS)}.
    *
@@ -1305,25 +1305,25 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * two dates. For example, the period in months between 2012-06-15 and 2012-08-14 will only be one
    * month as it is one day short of two months.
    *
-   * This method operates in association with {@link TemporalUnit#between}. The result of this
-   * method is a {@code long} representing the amount of the specified unit. By contrast, the result
-   * of {@code between} is an object that can be used directly in addition/subtraction: <pre> long
+   * This method operates in association with {@@linkTemporalUnit#between} . The result of this
+   * method is a {@@codelong} representing the amount of the specified unit. By contrast, the result
+   * of {@@codebetween} is an object that can be used directly in addition/subtraction: <pre> long
    * period = start.until(end, MONTHS); // this method dateTime.plus(MONTHS.between(start, end)); //
    * use in plus/minus </pre>
    *
-   * The calculation is implemented in this method for {@link ChronoUnit}. The units {@code DAYS},
-   * {@code WEEKS}, {@code MONTHS}, {@code YEARS}, {@code DECADES}, {@code CENTURIES}, {@code
-   * MILLENNIA} and {@code ERAS} are supported. Other {@code ChronoUnit} values will throw an
+   * The calculation is implemented in this method for {@@linkChronoUnit} . The units {@@codeDAYS} ,
+   * {@@codeWEEKS} , {@@codeMONTHS} , {@@codeYEARS} , {@@codeDECADES} , {@@codeCENTURIES} , {@code
+   * MILLENNIA} and {@@codeERAS} are supported. Other {@@codeChronoUnit} values will throw an
    * exception.
    *
-   * If the unit is not a {@code ChronoUnit}, then the result of this method is obtained by invoking
-   * {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first argument and
-   * the input temporal as the second argument.
+   * If the unit is not a {@@codeChronoUnit} , then the result of this method is obtained by
+   * invoking {@@codeTemporalUnit.between(Temporal, Temporal)} passing {@@codethis} as the first
+   * argument and the input temporal as the second argument.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param endExclusive
-   *   the end date, which is converted to a { @code LocalDate}, not null
+   *   the end date, which is converted to a {@@codeLocalDate} , not null
    * @param unit
    *   the unit to measure the period in, not null
    * @return
@@ -1362,10 +1362,10 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
   }
 
   /**
-   * Calculates the period between this date and another date as a {@code Period}.
+   * Calculates the period between this date and another date as a {@@codePeriod} .
    *
    * This calculates the period between two dates in terms of years, months and days. The start and
-   * end points are {@code this} and the specified date. The result will be negative if the end is
+   * end points are {@@codethis} and the specified date. The result will be negative if the end is
    * before the start.
    *
    * The calculation is performed using the ISO calendar system. If necessary, the input date will
@@ -1375,14 +1375,14 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * complete months, then calculating the remaining number of days, adjusting to ensure that both
    * have the same sign. The number of months is then normalized into years and months based on a 12
    * month year. A month is considered to be complete if the end day-of-month is greater than or
-   * equal to the start day-of-month. For example, from {@code 2010-01-15} to {@code 2011-03-18} is
+   * equal to the start day-of-month. For example, from {@@code2010-01-15} to {@@code2011-03-18} is
    * "1 year, 2 months and 3 days".
    *
    * The result of this method can be a negative period if the end is before the start. The negative
    * sign will be the same in each of year, month and day.
    *
    * There are two equivalent ways of using this method. The first is to invoke this method. The
-   * second is to use {@link Period#between(LocalDate, LocalDate)}: <pre> // these two lines are
+   * second is to use {@@linkPeriod#between(LocalDate, LocalDate)} : <pre> // these two lines are
    * equivalent period = start.until(end); period = Period.between(start, end); </pre> The choice
    * should be made based on which makes the code more readable.
    *
@@ -1409,9 +1409,9 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
   }
 
   /**
-   * Combines this date with a time to create a {@code LocalDateTime}.
+   * Combines this date with a time to create a {@@codeLocalDateTime} .
    *
-   * This returns a {@code LocalDateTime} formed from this date at the specified time. All possible
+   * This returns a {@@codeLocalDateTime} formed from this date at the specified time. All possible
    * combinations of date and time are valid.
    *
    * @param time
@@ -1422,9 +1422,9 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
   override def atTime(time: LocalTime): LocalDateTime = LocalDateTime.of(this, time)
 
   /**
-   * Combines this date with a time to create a {@code LocalDateTime}.
+   * Combines this date with a time to create a {@@codeLocalDateTime} .
    *
-   * This returns a {@code LocalDateTime} formed from this date at the specified hour and minute.
+   * This returns a {@@codeLocalDateTime} formed from this date at the specified hour and minute.
    * The seconds and nanosecond fields will be set to zero. The individual time fields must be
    * within their valid range. All possible combinations of date and time are valid.
    *
@@ -1440,9 +1440,9 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
   def atTime(hour: Int, minute: Int): LocalDateTime = atTime(LocalTime.of(hour, minute))
 
   /**
-   * Combines this date with a time to create a {@code LocalDateTime}.
+   * Combines this date with a time to create a {@@codeLocalDateTime} .
    *
-   * This returns a {@code LocalDateTime} formed from this date at the specified hour, minute and
+   * This returns a {@@codeLocalDateTime} formed from this date at the specified hour, minute and
    * second. The nanosecond field will be set to zero. The individual time fields must be within
    * their valid range. All possible combinations of date and time are valid.
    *
@@ -1461,9 +1461,9 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
     atTime(LocalTime.of(hour, minute, second))
 
   /**
-   * Combines this date with a time to create a {@code LocalDateTime}.
+   * Combines this date with a time to create a {@@codeLocalDateTime} .
    *
-   * This returns a {@code LocalDateTime} formed from this date at the specified hour, minute,
+   * This returns a {@@codeLocalDateTime} formed from this date at the specified hour, minute,
    * second and nanosecond. The individual time fields must be within their valid range. All
    * possible combinations of date and time are valid.
    *
@@ -1484,9 +1484,9 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
     atTime(LocalTime.of(hour, minute, second, nanoOfSecond))
 
   /**
-   * Combines this date with an offset time to create an {@code OffsetDateTime}.
+   * Combines this date with an offset time to create an {@@codeOffsetDateTime} .
    *
-   * This returns an {@code OffsetDateTime} formed from this date at the specified time. All
+   * This returns an {@@codeOffsetDateTime} formed from this date at the specified time. All
    * possible combinations of date and time are valid.
    *
    * @param time
@@ -1498,10 +1498,10 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
     OffsetDateTime.of(LocalDateTime.of(this, time.toLocalTime), time.getOffset)
 
   /**
-   * Combines this date with the time of midnight to create a {@code LocalDateTime} at the start of
+   * Combines this date with the time of midnight to create a {@@codeLocalDateTime} at the start of
    * this date.
    *
-   * This returns a {@code LocalDateTime} formed from this date at the time of midnight, 00:00, at
+   * This returns a {@@codeLocalDateTime} formed from this date at the time of midnight, 00:00, at
    * the start of this date.
    *
    * @return
@@ -1510,9 +1510,9 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
   def atStartOfDay: LocalDateTime = LocalDateTime.of(this, LocalTime.MIDNIGHT)
 
   /**
-   * Combines this date with a time-zone to create a {@code ZonedDateTime} at the start of the day
+   * Combines this date with a time-zone to create a {@@codeZonedDateTime} at the start of the day
    *
-   * This returns a {@code ZonedDateTime} formed from this date at the specified zone, with the time
+   * This returns a {@@codeZonedDateTime} formed from this date at the specified zone, with the time
    * set to be the earliest valid time according to the rules in the time-zone.
    *
    * Time-zone rules, such as daylight savings, mean that not every local date-time is valid for the
@@ -1523,10 +1523,10 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * of midnight on the date. In the case of a gap, the zoned date-time will represent the instant
    * just after the gap.
    *
-   * If the zone ID is a {@link ZoneOffset}, then the result always has a time of midnight.
+   * If the zone ID is a {@@linkZoneOffset} , then the result always has a time of midnight.
    *
-   * To convert to a specific time in a given time-zone call {@link #atTime(LocalTime)} followed by
-   * {@link LocalDateTime#atZone(ZoneId)}.
+   * To convert to a specific time in a given time-zone call {@@link#atTime(LocalTime)} followed by
+   * {@@linkLocalDateTime#atZone(ZoneId)} .
    *
    * @param zone
    *   the zone ID to use, not null
@@ -1568,11 +1568,11 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    * Compares this date to another date.
    *
    * The comparison is primarily based on the date, from earliest to latest. It is "consistent with
-   * equals", as defined by {@link Comparable}.
+   * equals", as defined by {@@linkComparable} .
    *
-   * If all the dates being compared are instances of {@code LocalDate}, then the comparison will be
-   * entirely based on the date. If some dates being compared are in different chronologies, then
-   * the chronology is also considered, see {@link ChronoLocalDate#compareTo}.
+   * If all the dates being compared are instances of {@@codeLocalDate} , then the comparison will
+   * be entirely based on the date. If some dates being compared are in different chronologies, then
+   * the chronology is also considered, see {@@linkChronoLocalDate#compareTo} .
    *
    * @param other
    *   the other date to compare to, not null
@@ -1598,12 +1598,11 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    *
    * This checks to see if this date represents a point on the local time-line after the other date.
    * <pre> LocalDate a = LocalDate.of(2012, 6, 30); LocalDate b = LocalDate.of(2012, 7, 1);
-   * a.isAfter(b) == false
-   * a.isAfter(a) == false b.isAfter(a) == true </pre>
+   * a.isAfter(b) == false a.isAfter(a) == false b.isAfter(a) == true </pre>
    *
    * This method only considers the position of the two dates on the local time-line. It does not
    * take into account the chronology, or calendar system. This is different from the comparison in
-   * {@link #compareTo(ChronoLocalDate)}, but is the same approach as {@link #DATE_COMPARATOR}.
+   * {@@link#compareTo(ChronoLocalDate)} , but is the same approach as {@@link#DATE_COMPARATOR} .
    *
    * @param other
    *   the other date to compare to, not null
@@ -1619,12 +1618,11 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    *
    * This checks to see if this date represents a point on the local time-line before the other
    * date. <pre> LocalDate a = LocalDate.of(2012, 6, 30); LocalDate b = LocalDate.of(2012, 7, 1);
-   * a.isBefore(b) == true
-   * a.isBefore(a) == false b.isBefore(a) == false </pre>
+   * a.isBefore(b) == true a.isBefore(a) == false b.isBefore(a) == false </pre>
    *
    * This method only considers the position of the two dates on the local time-line. It does not
    * take into account the chronology, or calendar system. This is different from the comparison in
-   * {@link #compareTo(ChronoLocalDate)}, but is the same approach as {@link #DATE_COMPARATOR}.
+   * {@@link#compareTo(ChronoLocalDate)} , but is the same approach as {@@link#DATE_COMPARATOR} .
    *
    * @param other
    *   the other date to compare to, not null
@@ -1640,12 +1638,11 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
    *
    * This checks to see if this date represents the same point on the local time-line as the other
    * date. <pre> LocalDate a = LocalDate.of(2012, 6, 30); LocalDate b = LocalDate.of(2012, 7, 1);
-   * a.isEqual(b) == false
-   * a.isEqual(a) == true b.isEqual(a) == false </pre>
+   * a.isEqual(b) == false a.isEqual(a) == true b.isEqual(a) == false </pre>
    *
    * This method only considers the position of the two dates on the local time-line. It does not
    * take into account the chronology, or calendar system. This is different from the comparison in
-   * {@link #compareTo(ChronoLocalDate)} but is the same approach as {@link #DATE_COMPARATOR}.
+   * {@@link#compareTo(ChronoLocalDate)} but is the same approach as {@@link#DATE_COMPARATOR} .
    *
    * @param other
    *   the other date to compare to, not null
@@ -1659,11 +1656,11 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
   /**
    * Checks if this date is equal to another date.
    *
-   * Compares this {@code LocalDate} with another ensuring that the date is the same.
+   * Compares this {@@codeLocalDate} with another ensuring that the date is the same.
    *
-   * Only objects of type {@code LocalDate} are compared, other types return false. To compare the
-   * dates of two {@code TemporalAccessor} instances, including dates in two different chronologies,
-   * use {@link ChronoField#EPOCH_DAY} as a comparator.
+   * Only objects of type {@@codeLocalDate} are compared, other types return false. To compare the
+   * dates of two {@@codeTemporalAccessor} instances, including dates in two different chronologies,
+   * use {@@linkChronoField#EPOCH_DAY} as a comparator.
    *
    * @param obj
    *   the object to check, null returns false
@@ -1690,9 +1687,9 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
   }
 
   /**
-   * Outputs this date as a {@code String}, such as {@code 2007-12-03}.
+   * Outputs this date as a {@@codeString} , such as {@@code2007-12-03} .
    *
-   * The output will be in the ISO-8601 format {@code yyyy-MM-dd}.
+   * The output will be in the ISO-8601 format {@@codeyyyy-MM-dd} .
    *
    * @return
    *   a string representation of this date, not null
@@ -1722,7 +1719,7 @@ final class LocalDate private (private val year: Int, monthOfYear: Int, dayOfMon
   }
 
   /**
-   * Outputs this date as a {@code String} using the formatter.
+   * Outputs this date as a {@@codeString} using the formatter.
    *
    * This date will be passed to the formatter {@link DateTimeFormatter#format(TemporalAccessor)
    * print method}.
diff --git a/core/shared/src/main/scala/org/threeten/bp/LocalDateTime.scala b/core/shared/src/main/scala/org/threeten/bp/LocalDateTime.scala
index 8dfff04e3..f973405db 100644
--- a/core/shared/src/main/scala/org/threeten/bp/LocalDateTime.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/LocalDateTime.scala
@@ -63,16 +63,16 @@ import org.threeten.bp.zone.ZoneRules
 object LocalDateTime {
 
   /**
-   * The minimum supported {@code LocalDateTime}, '-999999999-01-01T00:00:00'. This is the local
-   * date-time of midnight at the start of the minimum date. This combines {@link LocalDate#MIN} and
-   * {@link LocalTime#MIN}. This could be used by an application as a "far past" date-time.
+   * The minimum supported {@@codeLocalDateTime} , '-999999999-01-01T00:00:00'. This is the local
+   * date-time of midnight at the start of the minimum date. This combines {@@linkLocalDate#MIN} and
+   * {@@linkLocalTime#MIN} . This could be used by an application as a "far past" date-time.
    */
   lazy val MIN: LocalDateTime = LocalDateTime.of(LocalDate.MIN, LocalTime.MIN)
 
   /**
-   * The maximum supported {@code LocalDateTime}, '+999999999-12-31T23:59:59.999999999'. This is the
-   * local date-time just before midnight at the end of the maximum date. This combines {@link
-   * LocalDate#MAX} and {@link LocalTime#MAX}. This could be used by an application as a "far
+   * The maximum supported {@@codeLocalDateTime} , '+999999999-12-31T23:59:59.999999999'. This is
+   * the local date-time just before midnight at the end of the maximum date. This combines {@link
+   * LocalDate#MAX} and {@@linkLocalTime#MAX} . This could be used by an application as a "far
    * future" date-time.
    */
   lazy val MAX: LocalDateTime = LocalDateTime.of(LocalDate.MAX, LocalTime.MAX)
@@ -80,7 +80,7 @@ object LocalDateTime {
   /**
    * Obtains the current date-time from the system clock in the default time-zone.
    *
-   * This will query the {@link Clock#systemDefaultZone() system clock} in the default time-zone to
+   * This will query the {@@linkClock#systemDefaultZone() system clock} in the default time-zone to
    * obtain the current date-time.
    *
    * Using this method will prevent the ability to use an alternate clock for testing because the
@@ -94,7 +94,7 @@ object LocalDateTime {
   /**
    * Obtains the current date-time from the system clock in the specified time-zone.
    *
-   * This will query the {@link Clock#system(ZoneId) system clock} to obtain the current date-time.
+   * This will query the {@@linkClock#system(ZoneId) system clock} to obtain the current date-time.
    * Specifying the time-zone avoids dependence on the default time-zone.
    *
    * Using this method will prevent the ability to use an alternate clock for testing because the
@@ -127,7 +127,7 @@ object LocalDateTime {
   }
 
   /**
-   * Obtains an instance of {@code LocalDateTime} from year, month, day, hour and minute, setting
+   * Obtains an instance of {@@codeLocalDateTime} from year, month, day, hour and minute, setting
    * the second and nanosecond to zero.
    *
    * The day must be valid for the year and month, otherwise an exception will be thrown. The second
@@ -157,7 +157,7 @@ object LocalDateTime {
   }
 
   /**
-   * Obtains an instance of {@code LocalDateTime} from year, month, day, hour, minute and second,
+   * Obtains an instance of {@@codeLocalDateTime} from year, month, day, hour, minute and second,
    * setting the nanosecond to zero.
    *
    * The day must be valid for the year and month, otherwise an exception will be thrown. The
@@ -196,7 +196,7 @@ object LocalDateTime {
   }
 
   /**
-   * Obtains an instance of {@code LocalDateTime} from year, month, day, hour, minute, second and
+   * Obtains an instance of {@@codeLocalDateTime} from year, month, day, hour, minute, second and
    * nanosecond.
    *
    * The day must be valid for the year and month, otherwise an exception will be thrown.
@@ -237,7 +237,7 @@ object LocalDateTime {
   }
 
   /**
-   * Obtains an instance of {@code LocalDateTime} from year, month, day, hour and minute, setting
+   * Obtains an instance of {@@codeLocalDateTime} from year, month, day, hour and minute, setting
    * the second and nanosecond to zero.
    *
    * The day must be valid for the year and month, otherwise an exception will be thrown. The second
@@ -267,7 +267,7 @@ object LocalDateTime {
   }
 
   /**
-   * Obtains an instance of {@code LocalDateTime} from year, month, day, hour, minute and second,
+   * Obtains an instance of {@@codeLocalDateTime} from year, month, day, hour, minute and second,
    * setting the nanosecond to zero.
    *
    * The day must be valid for the year and month, otherwise an exception will be thrown. The
@@ -306,7 +306,7 @@ object LocalDateTime {
   }
 
   /**
-   * Obtains an instance of {@code LocalDateTime} from year, month, day, hour, minute, second and
+   * Obtains an instance of {@@codeLocalDateTime} from year, month, day, hour, minute, second and
    * nanosecond.
    *
    * The day must be valid for the year and month, otherwise an exception will be thrown.
@@ -347,7 +347,7 @@ object LocalDateTime {
   }
 
   /**
-   * Obtains an instance of {@code LocalDateTime} from a date and time.
+   * Obtains an instance of {@@codeLocalDateTime} from a date and time.
    *
    * @param date
    *   the local date, not null
@@ -363,7 +363,7 @@ object LocalDateTime {
   }
 
   /**
-   * Obtains an instance of {@code LocalDateTime} from an {@code Instant} and zone ID.
+   * Obtains an instance of {@@codeLocalDateTime} from an {@@codeInstant} and zone ID.
    *
    * This creates a local date-time based on the specified instant. First, the offset from
    * UTC/Greenwich is obtained using the zone ID and instant, which is simple as there is only one
@@ -388,10 +388,10 @@ object LocalDateTime {
   }
 
   /**
-   * Obtains an instance of {@code LocalDateTime} using seconds from the epoch of
+   * Obtains an instance of {@@codeLocalDateTime} using seconds from the epoch of
    * 1970-01-01T00:00:00Z.
    *
-   * This allows the {@link ChronoField#INSTANT_SECONDS epoch-second} field to be converted to a
+   * This allows the {@@linkChronoField#INSTANT_SECONDS epoch-second} field to be converted to a
    * local date-time. This is primarily intended for low-level conversions rather than general
    * application usage.
    *
@@ -417,22 +417,22 @@ object LocalDateTime {
   }
 
   /**
-   * Obtains an instance of {@code LocalDateTime} from a temporal object.
+   * Obtains an instance of {@@codeLocalDateTime} from a temporal object.
    *
-   * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code LocalDateTime}.
+   * A {@@codeTemporalAccessor} represents some form of date and time information. This factory
+   * converts the arbitrary temporal object to an instance of {@@codeLocalDateTime} .
    *
-   * The conversion extracts and combines {@code LocalDate} and {@code LocalTime}.
+   * The conversion extracts and combines {@@codeLocalDate} and {@@codeLocalTime} .
    *
-   * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used as a query via method reference, {@code LocalDateTime::from}.
+   * This method matches the signature of the functional interface {@@linkTemporalQuery} allowing it
+   * to be used as a query via method reference, {@@codeLocalDateTime::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the local date-time, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code LocalDateTime}
+   *   if unable to convert to a {@@codeLocalDateTime}
    */
   def from(temporal: TemporalAccessor): LocalDateTime =
     temporal match {
@@ -452,7 +452,7 @@ object LocalDateTime {
     }
 
   /**
-   * Obtains an instance of {@code LocalDateTime} from a text string such as {@code
+   * Obtains an instance of {@@codeLocalDateTime} from a text string such as {@code
    * 2007-12-03T10:15:30}.
    *
    * The string must represent a valid date-time and is parsed using {@link
@@ -468,7 +468,7 @@ object LocalDateTime {
   def parse(text: CharSequence): LocalDateTime = parse(text, DateTimeFormatter.ISO_LOCAL_DATE_TIME)
 
   /**
-   * Obtains an instance of {@code LocalDateTime} from a text string using a specific formatter.
+   * Obtains an instance of {@@codeLocalDateTime} from a text string using a specific formatter.
    *
    * The text is parsed using the formatter, returning a date-time.
    *
@@ -497,7 +497,7 @@ object LocalDateTime {
  * A date-time without a time-zone in the ISO-8601 calendar system, such as {@code
  * 2007-12-03T10:15:30}.
  *
- * {@code LocalDateTime} is an immutable date-time object that represents a date-time, often viewed
+ * {@@codeLocalDateTime} is an immutable date-time object that represents a date-time, often viewed
  * as year-month-day-hour-minute-second. Other date and time fields, such as day-of-year,
  * day-of-week and week-of-year, can also be accessed. Time is represented to nanosecond precision.
  * For example, the value "2nd October 2007 at 13:45.30.123456789" can be stored in a {@code
@@ -548,10 +548,10 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * Checks if the specified field is supported.
    *
    * This checks if this date-time can be queried for the specified field. If false, then calling
-   * the {@link #range(TemporalField) range} and {@link #get(TemporalField) get} methods will throw
+   * the {@@link#range(TemporalField) range} and {@@link#get(TemporalField) get} methods will throw
    * an exception.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The supported fields
+   * If the field is a {@@linkChronoField} then the query is implemented here. The supported fields
    * are: <ul> <li>{@code NANO_OF_SECOND} <li>{@code NANO_OF_DAY} <li>{@code MICRO_OF_SECOND}
    * <li>{@code MICRO_OF_DAY} <li>{@code MILLI_OF_SECOND} <li>{@code MILLI_OF_DAY} <li>{@code
    * SECOND_OF_MINUTE} <li>{@code SECOND_OF_DAY} <li>{@code MINUTE_OF_HOUR} <li>{@code
@@ -560,11 +560,11 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * ALIGNED_DAY_OF_WEEK_IN_MONTH} <li>{@code ALIGNED_DAY_OF_WEEK_IN_YEAR} <li>{@code DAY_OF_MONTH}
    * <li>{@code DAY_OF_YEAR} <li>{@code EPOCH_DAY} <li>{@code ALIGNED_WEEK_OF_MONTH} <li>{@code
    * ALIGNED_WEEK_OF_YEAR} <li>{@code MONTH_OF_YEAR} <li>{@code EPOCH_MONTH} <li>{@code YEAR_OF_ERA}
-   * <li>{@code YEAR} <li>{@code ERA} </ul> All other {@code ChronoField} instances will return
+   * <li>{@code YEAR} <li>{@code ERA} </ul> All other {@@codeChronoField} instances will return
    * false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.isSupportedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the field is supported is determined by the field.
    *
    * @param field
@@ -592,12 +592,12 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * used to enhance the accuracy of the returned range. If it is not possible to return the range,
    * because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return appropriate range instances. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.rangeRefinedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
    * @param field
@@ -617,20 +617,20 @@ final class LocalDateTime private (private val date: LocalDate, private val time
     }
 
   /**
-   * Gets the value of the specified field from this date-time as an {@code int}.
+   * Gets the value of the specified field from this date-time as an {@@codeint} .
    *
    * This queries this date-time for the value for the specified field. The returned value will
    * always be within the valid range of values for the field. If it is not possible to return the
    * value, because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this date-time,
-   * except {@code NANO_OF_DAY}, {@code MICRO_OF_DAY}, {@code EPOCH_DAY} and {@code EPOCH_MONTH}
-   * which are too large to fit in an {@code int} and throw a {@code DateTimeException}. All other
-   * {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * except {@@codeNANO_OF_DAY} , {@@codeMICRO_OF_DAY} , {@@codeEPOCH_DAY} and {@@codeEPOCH_MONTH}
+   * which are too large to fit in an {@@codeint} and throw a {@@codeDateTimeException} . All other
+   * {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -652,18 +652,18 @@ final class LocalDateTime private (private val date: LocalDate, private val time
     }
 
   /**
-   * Gets the value of the specified field from this date-time as a {@code long}.
+   * Gets the value of the specified field from this date-time as a {@@codelong} .
    *
    * This queries this date-time for the value for the specified field. If it is not possible to
    * return the value, because the field is not supported or for some other reason, an exception is
    * thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this date-time.
-   * All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * All other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -687,10 +687,10 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   /**
    * Gets the year field.
    *
-   * This method returns the primitive {@code int} value for the year.
+   * This method returns the primitive {@@codeint} value for the year.
    *
-   * The year returned by this method is proleptic as per {@code get(YEAR)}. To obtain the
-   * year-of-era, use {@code get(YEAR_OF_ERA}.
+   * The year returned by this method is proleptic as per {@@codeget(YEAR)} . To obtain the
+   * year-of-era, use {@@codeget(YEAR_OF_ERA} .
    *
    * @return
    *   the year, from MIN_YEAR to MAX_YEAR
@@ -700,8 +700,8 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   /**
    * Gets the month-of-year field from 1 to 12.
    *
-   * This method returns the month as an {@code int} from 1 to 12. Application code is frequently
-   * clearer if the enum {@link Month} is used by calling {@link #getMonth()}.
+   * This method returns the month as an {@@codeint} from 1 to 12. Application code is frequently
+   * clearer if the enum {@@linkMonth} is used by calling {@@link#getMonth()} .
    *
    * @return
    *   the month-of-year, from 1 to 12
@@ -711,11 +711,11 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   def getMonthValue: Int = date.getMonthValue
 
   /**
-   * Gets the month-of-year field using the {@code Month} enum.
+   * Gets the month-of-year field using the {@@codeMonth} enum.
    *
-   * This method returns the enum {@link Month} for the month. This avoids confusion as to what
-   * {@code int} values mean. If you need access to the primitive {@code int} value then the enum
-   * provides the {@link Month#getValue() int value}.
+   * This method returns the enum {@@linkMonth} for the month. This avoids confusion as to what
+   * {@@codeint} values mean. If you need access to the primitive {@@codeint} value then the enum
+   * provides the {@@linkMonth#getValue() int value} .
    *
    * @return
    *   the month-of-year, not null
@@ -727,7 +727,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   /**
    * Gets the day-of-month field.
    *
-   * This method returns the primitive {@code int} value for the day-of-month.
+   * This method returns the primitive {@@codeint} value for the day-of-month.
    *
    * @return
    *   the day-of-month, from 1 to 31
@@ -737,7 +737,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   /**
    * Gets the day-of-year field.
    *
-   * This method returns the primitive {@code int} value for the day-of-year.
+   * This method returns the primitive {@@codeint} value for the day-of-year.
    *
    * @return
    *   the day-of-year, from 1 to 365, or 366 in a leap year
@@ -745,13 +745,13 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   def getDayOfYear: Int = date.getDayOfYear
 
   /**
-   * Gets the day-of-week field, which is an enum {@code DayOfWeek}.
+   * Gets the day-of-week field, which is an enum {@@codeDayOfWeek} .
    *
-   * This method returns the enum {@link DayOfWeek} for the day-of-week. This avoids confusion as to
-   * what {@code int} values mean. If you need access to the primitive {@code int} value then the
-   * enum provides the {@link DayOfWeek#getValue() int value}.
+   * This method returns the enum {@@linkDayOfWeek} for the day-of-week. This avoids confusion as to
+   * what {@@codeint} values mean. If you need access to the primitive {@@codeint} value then the
+   * enum provides the {@@linkDayOfWeek#getValue() int value} .
    *
-   * Additional information can be obtained from the {@code DayOfWeek}. This includes textual names
+   * Additional information can be obtained from the {@@codeDayOfWeek} . This includes textual names
    * of the values.
    *
    * @return
@@ -794,15 +794,15 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   /**
    * Returns an adjusted copy of this date-time.
    *
-   * This returns a new {@code LocalDateTime}, based on this one, with the date-time adjusted. The
+   * This returns a new {@@codeLocalDateTime} , based on this one, with the date-time adjusted. The
    * adjustment takes place using the specified adjuster strategy object. Read the documentation of
    * the adjuster to understand what adjustment will be made.
    *
    * A simple adjuster might simply set the one of the fields, such as the year field. A more
    * complex adjuster might set the date to the last day of the month. A selection of common
-   * adjustments is provided in {@link TemporalAdjusters}. These include finding the "last day of
+   * adjustments is provided in {@@linkTemporalAdjusters} . These include finding the "last day of
    * the month" and "next Wednesday". Key date-time classes also implement the {@code
-   * TemporalAdjuster} interface, such as {@link Month} and {@link MonthDay MonthDay}. The adjuster
+   * TemporalAdjuster} interface, such as {@@linkMonth} and {@@linkMonthDay MonthDay} . The adjuster
    * is responsible for handling special cases, such as the varying lengths of month and leap years.
    *
    * For example this code returns a date on the last day of July: <pre> import static
@@ -810,12 +810,12 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    *
    * result = localDateTime.with(JULY).with(lastDayOfMonth()); </pre>
    *
-   * The classes {@link LocalDate} and {@link LocalTime} implement {@code TemporalAdjuster}, thus
+   * The classes {@@linkLocalDate} and {@@linkLocalTime} implement {@@codeTemporalAdjuster} , thus
    * this method can be used to change the date, time or offset: <pre> result =
    * localDateTime.with(date); result = localDateTime.with(time); </pre>
    *
    * The result of this method is obtained by invoking the {@link
-   * TemporalAdjuster#adjustInto(Temporal)} method on the specified adjuster passing {@code this} as
+   * TemporalAdjuster#adjustInto(Temporal)} method on the specified adjuster passing {@@codethis} as
    * the argument.
    *
    * This instance is immutable and unaffected by this method call.
@@ -823,7 +823,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param adjuster
    *   the adjuster to use, not null
    * @return
-   *   a { @code LocalDateTime} based on { @code this} with the adjustment made, not null
+   *   a {@@codeLocalDateTime} based on {@@codethis} with the adjustment made, not null
    * @throws DateTimeException
    *   if the adjustment cannot be made
    * @throws ArithmeticException
@@ -841,7 +841,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   /**
    * Returns a copy of this date-time with the specified field set to a new value.
    *
-   * This returns a new {@code LocalDateTime}, based on this one, with the value for the specified
+   * This returns a new {@@codeLocalDateTime} , based on this one, with the value for the specified
    * field changed. This can be used to change any supported field, such as the year, month or
    * day-of-month. If it is not possible to set the value, because the field is not supported or for
    * some other reason, an exception is thrown.
@@ -851,13 +851,13 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * invalid. In cases like this, the field is responsible for resolving the date. Typically it will
    * choose the previous valid date, which would be the last valid day of February in this example.
    *
-   * If the field is a {@link ChronoField} then the adjustment is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the adjustment is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will behave as per the matching method on {@link
    * LocalDate#with(TemporalField, long) LocalDate} or {@link LocalTime#with(TemporalField, long)
-   * LocalTime}. All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * LocalTime}. All other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.adjustInto(Temporal, long)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.adjustInto(Temporal, long)} passing {@@codethis} as the argument.
    * In this case, the field determines whether and how to adjust the instant.
    *
    * This instance is immutable and unaffected by this method call.
@@ -867,7 +867,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param newValue
    *   the new value of the field in the result
    * @return
-   *   a { @code LocalDateTime} based on { @code this} with the specified field set, not null
+   *   a {@@codeLocalDateTime} based on {@@codethis} with the specified field set, not null
    * @throws DateTimeException
    *   if the field cannot be set
    * @throws ArithmeticException
@@ -882,7 +882,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
       field.adjustInto(this, newValue)
 
   /**
-   * Returns a copy of this {@code LocalDateTime} with the year altered. The time does not affect
+   * Returns a copy of this {@@codeLocalDateTime} with the year altered. The time does not affect
    * the calculation and will be the same in the result. If the day-of-month is invalid for the
    * year, it will be changed to the last valid day of the month.
    *
@@ -891,14 +891,14 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param year
    *   the year to set in the result, from MIN_YEAR to MAX_YEAR
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the requested year, not null
+   *   a {@@codeLocalDateTime} based on this date-time with the requested year, not null
    * @throws DateTimeException
    *   if the year value is invalid
    */
   def withYear(year: Int): LocalDateTime = `with`(date.withYear(year), time)
 
   /**
-   * Returns a copy of this {@code LocalDateTime} with the month-of-year altered. The time does not
+   * Returns a copy of this {@@codeLocalDateTime} with the month-of-year altered. The time does not
    * affect the calculation and will be the same in the result. If the day-of-month is invalid for
    * the year, it will be changed to the last valid day of the month.
    *
@@ -907,15 +907,15 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param month
    *   the month-of-year to set in the result, from 1 (January) to 12 (December)
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the requested month, not null
+   *   a {@@codeLocalDateTime} based on this date-time with the requested month, not null
    * @throws DateTimeException
    *   if the month-of-year value is invalid
    */
   def withMonth(month: Int): LocalDateTime = `with`(date.withMonth(month), time)
 
   /**
-   * Returns a copy of this {@code LocalDateTime} with the day-of-month altered. If the resulting
-   * {@code LocalDateTime} is invalid, an exception is thrown. The time does not affect the
+   * Returns a copy of this {@@codeLocalDateTime} with the day-of-month altered. If the resulting
+   * {@@codeLocalDateTime} is invalid, an exception is thrown. The time does not affect the
    * calculation and will be the same in the result.
    *
    * This instance is immutable and unaffected by this method call.
@@ -923,7 +923,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param dayOfMonth
    *   the day-of-month to set in the result, from 1 to 28-31
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the requested day, not null
+   *   a {@@codeLocalDateTime} based on this date-time with the requested day, not null
    * @throws DateTimeException
    *   if the day-of-month value is invalid
    * @throws DateTimeException
@@ -932,15 +932,15 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   def withDayOfMonth(dayOfMonth: Int): LocalDateTime = `with`(date.withDayOfMonth(dayOfMonth), time)
 
   /**
-   * Returns a copy of this {@code LocalDateTime} with the day-of-year altered. If the resulting
-   * {@code LocalDateTime} is invalid, an exception is thrown.
+   * Returns a copy of this {@@codeLocalDateTime} with the day-of-year altered. If the resulting
+   * {@@codeLocalDateTime} is invalid, an exception is thrown.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param dayOfYear
    *   the day-of-year to set in the result, from 1 to 365-366
    * @return
-   *   a { @code LocalDateTime} based on this date with the requested day, not null
+   *   a {@@codeLocalDateTime} based on this date with the requested day, not null
    * @throws DateTimeException
    *   if the day-of-year value is invalid
    * @throws DateTimeException
@@ -949,14 +949,14 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   def withDayOfYear(dayOfYear: Int): LocalDateTime = `with`(date.withDayOfYear(dayOfYear), time)
 
   /**
-   * Returns a copy of this {@code LocalDateTime} with the hour-of-day value altered.
+   * Returns a copy of this {@@codeLocalDateTime} with the hour-of-day value altered.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param hour
    *   the hour-of-day to set in the result, from 0 to 23
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the requested hour, not null
+   *   a {@@codeLocalDateTime} based on this date-time with the requested hour, not null
    * @throws DateTimeException
    *   if the hour value is invalid
    */
@@ -964,14 +964,14 @@ final class LocalDateTime private (private val date: LocalDate, private val time
     `with`(date, time.withHour(hour))
 
   /**
-   * Returns a copy of this {@code LocalDateTime} with the minute-of-hour value altered.
+   * Returns a copy of this {@@codeLocalDateTime} with the minute-of-hour value altered.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param minute
    *   the minute-of-hour to set in the result, from 0 to 59
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the requested minute, not null
+   *   a {@@codeLocalDateTime} based on this date-time with the requested minute, not null
    * @throws DateTimeException
    *   if the minute value is invalid
    */
@@ -981,14 +981,14 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   }
 
   /**
-   * Returns a copy of this {@code LocalDateTime} with the second-of-minute value altered.
+   * Returns a copy of this {@@codeLocalDateTime} with the second-of-minute value altered.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param second
    *   the second-of-minute to set in the result, from 0 to 59
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the requested second, not null
+   *   a {@@codeLocalDateTime} based on this date-time with the requested second, not null
    * @throws DateTimeException
    *   if the second value is invalid
    */
@@ -998,14 +998,14 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   }
 
   /**
-   * Returns a copy of this {@code LocalDateTime} with the nano-of-second value altered.
+   * Returns a copy of this {@@codeLocalDateTime} with the nano-of-second value altered.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param nanoOfSecond
    *   the nano-of-second to set in the result, from 0 to 999,999,999
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the requested nanosecond, not null
+   *   a {@@codeLocalDateTime} based on this date-time with the requested nanosecond, not null
    * @throws DateTimeException
    *   if the nano value is invalid
    */
@@ -1015,22 +1015,22 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   }
 
   /**
-   * Returns a copy of this {@code LocalDateTime} with the time truncated.
+   * Returns a copy of this {@@codeLocalDateTime} with the time truncated.
    *
    * Truncation returns a copy of the original date-time with fields smaller than the specified unit
-   * set to zero. For example, truncating with the {@link ChronoUnit#MINUTES minutes} unit will set
+   * set to zero. For example, truncating with the {@@linkChronoUnit#MINUTES minutes} unit will set
    * the second-of-minute and nano-of-second field to zero.
    *
-   * The unit must have a {@linkplain TemporalUnit#getDuration() duration} that divides into the
+   * The unit must have a {@@linkplainTemporalUnit#getDuration() duration} that divides into the
    * length of a standard day without remainder. This includes all supplied time units on {@link
-   * ChronoUnit} and {@link ChronoUnit#DAYS DAYS}. Other units throw an exception.
+   * ChronoUnit} and {@@linkChronoUnit#DAYS DAYS} . Other units throw an exception.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param unit
    *   the unit to truncate to, not null
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the time truncated, not null
+   *   a {@@codeLocalDateTime} based on this date-time with the time truncated, not null
    * @throws DateTimeException
    *   if unable to truncate
    */
@@ -1040,16 +1040,16 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * Returns a copy of this date-time with the specified period added.
    *
    * This method returns a new date-time based on this time with the specified period added. The
-   * amount is typically {@link Period} but may be any other type implementing the {@link
+   * amount is typically {@@linkPeriod} but may be any other type implementing the {@link
    * TemporalAmount} interface. The calculation is delegated to the specified adjuster, which
-   * typically calls back to {@link #plus(long, TemporalUnit)}.
+   * typically calls back to {@@link#plus(long, TemporalUnit)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param amount
    *   the amount to add, not null
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the addition made, not null
+   *   a {@@codeLocalDateTime} based on this date-time with the addition made, not null
    * @throws DateTimeException
    *   if the addition cannot be made
    * @throws ArithmeticException
@@ -1073,7 +1073,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param unit
    *   the unit of the period to add, not null
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the specified period added, not null
+   *   a {@@codeLocalDateTime} based on this date-time with the specified period added, not null
    * @throws DateTimeException
    *   if the unit cannot be added to this type
    */
@@ -1099,7 +1099,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
     }
 
   /**
-   * Returns a copy of this {@code LocalDateTime} with the specified period in years added.
+   * Returns a copy of this {@@codeLocalDateTime} with the specified period in years added.
    *
    * This method adds the specified amount to the years field in three steps: <ol> <li>Add the input
    * years to the year field</li> <li>Check if the resulting date would be invalid</li> <li>Adjust
@@ -1114,7 +1114,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param years
    *   the years to add, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the years added, not null
+   *   a {@@codeLocalDateTime} based on this date-time with the years added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1124,7 +1124,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   }
 
   /**
-   * Returns a copy of this {@code LocalDateTime} with the specified period in months added.
+   * Returns a copy of this {@@codeLocalDateTime} with the specified period in months added.
    *
    * This method adds the specified amount to the months field in three steps: <ol> <li>Add the
    * input months to the month-of-year field</li> <li>Check if the resulting date would be
@@ -1138,7 +1138,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param months
    *   the months to add, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the months added, not null
+   *   a {@@codeLocalDateTime} based on this date-time with the months added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1148,7 +1148,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   }
 
   /**
-   * Returns a copy of this {@code LocalDateTime} with the specified period in weeks added.
+   * Returns a copy of this {@@codeLocalDateTime} with the specified period in weeks added.
    *
    * This method adds the specified amount in weeks to the days field incrementing the month and
    * year fields as necessary to ensure the result remains valid. The result is only invalid if the
@@ -1161,7 +1161,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param weeks
    *   the weeks to add, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the weeks added, not null
+   *   a {@@codeLocalDateTime} based on this date-time with the weeks added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1171,7 +1171,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   }
 
   /**
-   * Returns a copy of this {@code LocalDateTime} with the specified period in days added.
+   * Returns a copy of this {@@codeLocalDateTime} with the specified period in days added.
    *
    * This method adds the specified amount to the days field incrementing the month and year fields
    * as necessary to ensure the result remains valid. The result is only invalid if the
@@ -1184,7 +1184,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param days
    *   the days to add, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the days added, not null
+   *   a {@@codeLocalDateTime} based on this date-time with the days added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1194,56 +1194,56 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   }
 
   /**
-   * Returns a copy of this {@code LocalDateTime} with the specified period in hours added.
+   * Returns a copy of this {@@codeLocalDateTime} with the specified period in hours added.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param hours
    *   the hours to add, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the hours added, not null
+   *   a {@@codeLocalDateTime} based on this date-time with the hours added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
   def plusHours(hours: Long): LocalDateTime = plusWithOverflow(date, hours, 0, 0, 0, 1)
 
   /**
-   * Returns a copy of this {@code LocalDateTime} with the specified period in minutes added.
+   * Returns a copy of this {@@codeLocalDateTime} with the specified period in minutes added.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param minutes
    *   the minutes to add, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the minutes added, not null
+   *   a {@@codeLocalDateTime} based on this date-time with the minutes added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
   def plusMinutes(minutes: Long): LocalDateTime = plusWithOverflow(date, 0, minutes, 0, 0, 1)
 
   /**
-   * Returns a copy of this {@code LocalDateTime} with the specified period in seconds added.
+   * Returns a copy of this {@@codeLocalDateTime} with the specified period in seconds added.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param seconds
    *   the seconds to add, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the seconds added, not null
+   *   a {@@codeLocalDateTime} based on this date-time with the seconds added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
   def plusSeconds(seconds: Long): LocalDateTime = plusWithOverflow(date, 0, 0, seconds, 0, 1)
 
   /**
-   * Returns a copy of this {@code LocalDateTime} with the specified period in nanoseconds added.
+   * Returns a copy of this {@@codeLocalDateTime} with the specified period in nanoseconds added.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param nanos
    *   the nanos to add, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the nanoseconds added, not null
+   *   a {@@codeLocalDateTime} based on this date-time with the nanoseconds added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1253,16 +1253,16 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * Returns a copy of this date-time with the specified period subtracted.
    *
    * This method returns a new date-time based on this time with the specified period subtracted.
-   * The amount is typically {@link Period} but may be any other type implementing the {@link
+   * The amount is typically {@@linkPeriod} but may be any other type implementing the {@link
    * TemporalAmount} interface. The calculation is delegated to the specified adjuster, which
-   * typically calls back to {@link #minus(long, TemporalUnit)}.
+   * typically calls back to {@@link#minus(long, TemporalUnit)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param amount
    *   the amount to subtract, not null
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the subtraction made, not null
+   *   a {@@codeLocalDateTime} based on this date-time with the subtraction made, not null
    * @throws DateTimeException
    *   if the subtraction cannot be made
    * @throws ArithmeticException
@@ -1286,7 +1286,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param unit
    *   the unit of the period to subtract, not null
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the specified period subtracted, not
+   *   a {@@codeLocalDateTime} based on this date-time with the specified period subtracted, not
    *   null
    * @throws DateTimeException
    *   if the unit cannot be added to this type
@@ -1296,7 +1296,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
     else plus(-amountToSubtract, unit)
 
   /**
-   * Returns a copy of this {@code LocalDateTime} with the specified period in years subtracted.
+   * Returns a copy of this {@@codeLocalDateTime} with the specified period in years subtracted.
    *
    * This method subtracts the specified amount from the years field in three steps: <ol>
    * <li>Subtract the input years from the year field</li> <li>Check if the resulting date would be
@@ -1311,7 +1311,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param years
    *   the years to subtract, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the years subtracted, not null
+   *   a {@@codeLocalDateTime} based on this date-time with the years subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1320,7 +1320,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
     else plusYears(-years)
 
   /**
-   * Returns a copy of this {@code LocalDateTime} with the specified period in months subtracted.
+   * Returns a copy of this {@@codeLocalDateTime} with the specified period in months subtracted.
    *
    * This method subtracts the specified amount from the months field in three steps: <ol>
    * <li>Subtract the input months from the month-of-year field</li> <li>Check if the resulting date
@@ -1334,7 +1334,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param months
    *   the months to subtract, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the months subtracted, not null
+   *   a {@@codeLocalDateTime} based on this date-time with the months subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1343,7 +1343,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
     else plusMonths(-months)
 
   /**
-   * Returns a copy of this {@code LocalDateTime} with the specified period in weeks subtracted.
+   * Returns a copy of this {@@codeLocalDateTime} with the specified period in weeks subtracted.
    *
    * This method subtracts the specified amount in weeks from the days field decrementing the month
    * and year fields as necessary to ensure the result remains valid. The result is only invalid if
@@ -1356,7 +1356,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param weeks
    *   the weeks to subtract, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the weeks subtracted, not null
+   *   a {@@codeLocalDateTime} based on this date-time with the weeks subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1365,7 +1365,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
     else plusWeeks(-weeks)
 
   /**
-   * Returns a copy of this {@code LocalDateTime} with the specified period in days subtracted.
+   * Returns a copy of this {@@codeLocalDateTime} with the specified period in days subtracted.
    *
    * This method subtracts the specified amount from the days field incrementing the month and year
    * fields as necessary to ensure the result remains valid. The result is only invalid if the
@@ -1378,7 +1378,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param days
    *   the days to subtract, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the days subtracted, not null
+   *   a {@@codeLocalDateTime} based on this date-time with the days subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1387,49 +1387,49 @@ final class LocalDateTime private (private val date: LocalDate, private val time
     else plusDays(-days)
 
   /**
-   * Returns a copy of this {@code LocalDateTime} with the specified period in hours subtracted.
+   * Returns a copy of this {@@codeLocalDateTime} with the specified period in hours subtracted.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param hours
    *   the hours to subtract, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the hours subtracted, not null
+   *   a {@@codeLocalDateTime} based on this date-time with the hours subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
   def minusHours(hours: Long): LocalDateTime = plusWithOverflow(date, hours, 0, 0, 0, -1)
 
   /**
-   * Returns a copy of this {@code LocalDateTime} with the specified period in minutes subtracted.
+   * Returns a copy of this {@@codeLocalDateTime} with the specified period in minutes subtracted.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param minutes
    *   the minutes to subtract, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the minutes subtracted, not null
+   *   a {@@codeLocalDateTime} based on this date-time with the minutes subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
   def minusMinutes(minutes: Long): LocalDateTime = plusWithOverflow(date, 0, minutes, 0, 0, -1)
 
   /**
-   * Returns a copy of this {@code LocalDateTime} with the specified period in seconds subtracted.
+   * Returns a copy of this {@@codeLocalDateTime} with the specified period in seconds subtracted.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param seconds
    *   the seconds to subtract, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the seconds subtracted, not null
+   *   a {@@codeLocalDateTime} based on this date-time with the seconds subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
   def minusSeconds(seconds: Long): LocalDateTime = plusWithOverflow(date, 0, 0, seconds, 0, -1)
 
   /**
-   * Returns a copy of this {@code LocalDateTime} with the specified period in nanoseconds
+   * Returns a copy of this {@@codeLocalDateTime} with the specified period in nanoseconds
    * subtracted.
    *
    * This instance is immutable and unaffected by this method call.
@@ -1437,14 +1437,14 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * @param nanos
    *   the nanos to subtract, may be negative
    * @return
-   *   a { @code LocalDateTime} based on this date-time with the nanoseconds subtracted, not null
+   *   a {@@codeLocalDateTime} based on this date-time with the nanoseconds subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
   def minusNanos(nanos: Long): LocalDateTime = plusWithOverflow(date, 0, 0, 0, nanos, -1)
 
   /**
-   * Returns a copy of this {@code LocalDateTime} with the specified period added.
+   * Returns a copy of this {@@codeLocalDateTime} with the specified period added.
    *
    * This instance is immutable and unaffected by this method call.
    *
@@ -1494,7 +1494,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * of the query to understand what the result of this method will be.
    *
    * The result of this method is obtained by invoking the {@link
-   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@code this}
+   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@@codethis}
    * as the argument.
    *
    * @tparam R
@@ -1518,8 +1518,8 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * This returns a temporal object of the same observable type as the input with the date and time
    * changed to be the same as this.
    *
-   * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)} twice, passing
-   * {@link ChronoField#EPOCH_DAY} and {@link ChronoField#NANO_OF_DAY} as the fields.
+   * The adjustment is equivalent to using {@@linkTemporal#with(TemporalField, long)} twice, passing
+   * {@@linkChronoField#EPOCH_DAY} and {@@linkChronoField#NANO_OF_DAY} as the fields.
    *
    * In most cases, it is clearer to reverse the calling pattern by using {@link
    * Temporal#with(TemporalAdjuster)}: <pre> // these two lines are equivalent, but the second
@@ -1544,8 +1544,8 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * unit.
    *
    * This calculates the period between two date-times in terms of a single unit. The start and end
-   * points are {@code this} and the specified date-time. The result will be negative if the end is
-   * before the start. The {@code Temporal} passed to this method must be a {@code LocalDateTime}.
+   * points are {@@codethis} and the specified date-time. The result will be negative if the end is
+   * before the start. The {@@codeTemporal} passed to this method must be a {@@codeLocalDateTime} .
    * For example, the period in days between two date-times can be calculated using {@code
    * startDateTime.until(endDateTime, DAYS)}.
    *
@@ -1553,26 +1553,26 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * two date-times. For example, the period in months between 2012-06-15T00:00 and 2012-08-14T23:59
    * will only be one month as it is one minute short of two months.
    *
-   * This method operates in association with {@link TemporalUnit#between}. The result of this
-   * method is a {@code long} representing the amount of the specified unit. By contrast, the result
-   * of {@code between} is an object that can be used directly in addition/subtraction: <pre> long
+   * This method operates in association with {@@linkTemporalUnit#between} . The result of this
+   * method is a {@@codelong} representing the amount of the specified unit. By contrast, the result
+   * of {@@codebetween} is an object that can be used directly in addition/subtraction: <pre> long
    * period = start.until(end, MONTHS); // this method dateTime.plus(MONTHS.between(start, end)); //
    * use in plus/minus </pre>
    *
-   * The calculation is implemented in this method for {@link ChronoUnit}. The units {@code NANOS},
-   * {@code MICROS}, {@code MILLIS}, {@code SECONDS}, {@code MINUTES}, {@code HOURS} and {@code
-   * HALF_DAYS}, {@code DAYS}, {@code WEEKS}, {@code MONTHS}, {@code YEARS}, {@code DECADES}, {@code
-   * CENTURIES}, {@code MILLENNIA} and {@code ERAS} are supported. Other {@code ChronoUnit} values
-   * will throw an exception.
+   * The calculation is implemented in this method for {@@linkChronoUnit} . The units {@@codeNANOS}
+   * , {@@codeMICROS} , {@@codeMILLIS} , {@@codeSECONDS} , {@@codeMINUTES} , {@@codeHOURS} and
+   * {@code HALF_DAYS}, {@@codeDAYS} , {@@codeWEEKS} , {@@codeMONTHS} , {@@codeYEARS} ,
+   * {@@codeDECADES} , {@code CENTURIES}, {@@codeMILLENNIA} and {@@codeERAS} are supported. Other
+   * {@@codeChronoUnit} values will throw an exception.
    *
-   * If the unit is not a {@code ChronoUnit}, then the result of this method is obtained by invoking
-   * {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first argument and
-   * the input temporal as the second argument.
+   * If the unit is not a {@@codeChronoUnit} , then the result of this method is obtained by
+   * invoking {@@codeTemporalUnit.between(Temporal, Temporal)} passing {@@codethis} as the first
+   * argument and the input temporal as the second argument.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param endExclusive
-   *   the end date-time, which is converted to a { @code LocalDateTime}, not null
+   *   the end date-time, which is converted to a {@@codeLocalDateTime} , not null
    * @param unit
    *   the unit to measure the period in, not null
    * @return
@@ -1641,9 +1641,9 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   }
 
   /**
-   * Combines this date-time with an offset to create an {@code OffsetDateTime}.
+   * Combines this date-time with an offset to create an {@@codeOffsetDateTime} .
    *
-   * This returns an {@code OffsetDateTime} formed from this date-time at the specified offset. All
+   * This returns an {@@codeOffsetDateTime} formed from this date-time at the specified offset. All
    * possible combinations of date-time and offset are valid.
    *
    * @param offset
@@ -1654,9 +1654,9 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   def atOffset(offset: ZoneOffset): OffsetDateTime = OffsetDateTime.of(this, offset)
 
   /**
-   * Combines this date-time with a time-zone to create a {@code ZonedDateTime}.
+   * Combines this date-time with a time-zone to create a {@@codeZonedDateTime} .
    *
-   * This returns a {@code ZonedDateTime} formed from this date-time at the specified time-zone. The
+   * This returns a {@@codeZonedDateTime} formed from this date-time at the specified time-zone. The
    * result will match this date-time as closely as possible. Time-zone rules, such as daylight
    * savings, mean that not every local date-time is valid for the specified zone, thus the local
    * date-time may be adjusted.
@@ -1685,9 +1685,9 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   def atZone(zone: ZoneId): ZonedDateTime = ZonedDateTime.of(this, zone)
 
   /**
-   * Gets the {@code LocalDate} part of this date-time.
+   * Gets the {@@codeLocalDate} part of this date-time.
    *
-   * This returns a {@code LocalDate} with the same year, month and day as this date-time.
+   * This returns a {@@codeLocalDate} with the same year, month and day as this date-time.
    *
    * @return
    *   the date part of this date-time, not null
@@ -1695,9 +1695,9 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   def toLocalDate: LocalDate = date
 
   /**
-   * Gets the {@code LocalTime} part of this date-time.
+   * Gets the {@@codeLocalTime} part of this date-time.
    *
-   * This returns a {@code LocalTime} with the same hour, minute, second and nanosecond as this
+   * This returns a {@@codeLocalTime} with the same hour, minute, second and nanosecond as this
    * date-time.
    *
    * @return
@@ -1709,9 +1709,9 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    * Compares this date-time to another date-time.
    *
    * The comparison is primarily based on the date-time, from earliest to latest. It is "consistent
-   * with equals", as defined by {@link Comparable}.
+   * with equals", as defined by {@@linkComparable} .
    *
-   * If all the date-times being compared are instances of {@code LocalDateTime}, then the
+   * If all the date-times being compared are instances of {@@codeLocalDateTime} , then the
    * comparison will be entirely based on the date-time. If some dates being compared are in
    * different chronologies, then the chronology is also considered, see {@link
    * ChronoLocalDateTime#compareTo}.
@@ -1739,13 +1739,12 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    *
    * This checks to see if this date-time represents a point on the local time-line after the other
    * date-time. <pre> LocalDate a = LocalDateTime.of(2012, 6, 30, 12, 00); LocalDate b =
-   * LocalDateTime.of(2012, 7, 1, 12, 00);
-   * a.isAfter(b) == false
-   * a.isAfter(a) == false b.isAfter(a) == true </pre>
+   * LocalDateTime.of(2012, 7, 1, 12, 00); a.isAfter(b) == false a.isAfter(a) == false b.isAfter(a)
+   * \== true </pre>
    *
    * This method only considers the position of the two date-times on the local time-line. It does
    * not take into account the chronology, or calendar system. This is different from the comparison
-   * in {@link #compareTo(ChronoLocalDateTime)}, but is the same approach as {@link
+   * in {@@link#compareTo(ChronoLocalDateTime)} , but is the same approach as {@link
    * #DATE_TIME_COMPARATOR}.
    *
    * @param other
@@ -1764,13 +1763,12 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    *
    * This checks to see if this date-time represents a point on the local time-line before the other
    * date-time. <pre> LocalDate a = LocalDateTime.of(2012, 6, 30, 12, 00); LocalDate b =
-   * LocalDateTime.of(2012, 7, 1, 12, 00);
-   * a.isBefore(b) == true
-   * a.isBefore(a) == false b.isBefore(a) == false </pre>
+   * LocalDateTime.of(2012, 7, 1, 12, 00); a.isBefore(b) == true a.isBefore(a) == false
+   * b.isBefore(a) == false </pre>
    *
    * This method only considers the position of the two date-times on the local time-line. It does
    * not take into account the chronology, or calendar system. This is different from the comparison
-   * in {@link #compareTo(ChronoLocalDateTime)}, but is the same approach as {@link
+   * in {@@link#compareTo(ChronoLocalDateTime)} , but is the same approach as {@link
    * #DATE_TIME_COMPARATOR}.
    *
    * @param other
@@ -1789,13 +1787,12 @@ final class LocalDateTime private (private val date: LocalDate, private val time
    *
    * This checks to see if this date-time represents the same point on the local time-line as the
    * other date-time. <pre> LocalDate a = LocalDateTime.of(2012, 6, 30, 12, 00); LocalDate b =
-   * LocalDateTime.of(2012, 7, 1, 12, 00);
-   * a.isEqual(b) == false
-   * a.isEqual(a) == true b.isEqual(a) == false </pre>
+   * LocalDateTime.of(2012, 7, 1, 12, 00); a.isEqual(b) == false a.isEqual(a) == true b.isEqual(a)
+   * \== false </pre>
    *
    * This method only considers the position of the two date-times on the local time-line. It does
    * not take into account the chronology, or calendar system. This is different from the comparison
-   * in {@link #compareTo(ChronoLocalDateTime)}, but is the same approach as {@link
+   * in {@@link#compareTo(ChronoLocalDateTime)} , but is the same approach as {@link
    * #DATE_TIME_COMPARATOR}.
    *
    * @param other
@@ -1812,8 +1809,8 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   /**
    * Checks if this date-time is equal to another date-time.
    *
-   * Compares this {@code LocalDateTime} with another ensuring that the date-time is the same. Only
-   * objects of type {@code LocalDateTime} are compared, other types return false.
+   * Compares this {@@codeLocalDateTime} with another ensuring that the date-time is the same. Only
+   * objects of type {@@codeLocalDateTime} are compared, other types return false.
    *
    * @param obj
    *   the object to check, null returns false
@@ -1835,7 +1832,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   override def hashCode: Int = date.hashCode ^ time.hashCode
 
   /**
-   * Outputs this date-time as a {@code String}, such as {@code 2007-12-03T10:15:30}.
+   * Outputs this date-time as a {@@codeString} , such as {@@code2007-12-03T10:15:30} .
    *
    * The output will be one of the following ISO-8601 formats: <ul> <li>{@code
    * yyyy-MM-dd'T'HH:mm}</li> <li>{@code yyyy-MM-dd'T'HH:mm:ss}</li> <li>{@code
@@ -1849,7 +1846,7 @@ final class LocalDateTime private (private val date: LocalDate, private val time
   override def toString: String = date.toString + 'T' + time.toString
 
   /**
-   * Outputs this date-time as a {@code String} using the formatter.
+   * Outputs this date-time as a {@@codeString} using the formatter.
    *
    * This date-time will be passed to the formatter {@link
    * DateTimeFormatter#format(TemporalAccessor) print method}.
diff --git a/core/shared/src/main/scala/org/threeten/bp/LocalTime.scala b/core/shared/src/main/scala/org/threeten/bp/LocalTime.scala
index 987ddb29d..eca7c4510 100644
--- a/core/shared/src/main/scala/org/threeten/bp/LocalTime.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/LocalTime.scala
@@ -69,13 +69,13 @@ object LocalTime {
   }
 
   /**
-   * The minimum supported {@code LocalTime}, '00:00'. This is the time of midnight at the start of
+   * The minimum supported {@@codeLocalTime} , '00:00'. This is the time of midnight at the start of
    * the day.
    */
   lazy val MIN: LocalTime = HOURS(0)
 
   /**
-   * The maximum supported {@code LocalTime}, '23:59:59.999999999'. This is the time just before
+   * The maximum supported {@@codeLocalTime} , '23:59:59.999999999'. This is the time just before
    * midnight at the end of the day.
    */
   lazy val MAX: LocalTime = new LocalTime(23, 59, 59, 999999999)
@@ -125,7 +125,7 @@ object LocalTime {
   /**
    * Obtains the current time from the system clock in the default time-zone.
    *
-   * This will query the {@link Clock#systemDefaultZone() system clock} in the default time-zone to
+   * This will query the {@@linkClock#systemDefaultZone() system clock} in the default time-zone to
    * obtain the current time.
    *
    * Using this method will prevent the ability to use an alternate clock for testing because the
@@ -139,7 +139,7 @@ object LocalTime {
   /**
    * Obtains the current time from the system clock in the specified time-zone.
    *
-   * This will query the {@link Clock#system(ZoneId) system clock} to obtain the current time.
+   * This will query the {@@linkClock#system(ZoneId) system clock} to obtain the current time.
    * Specifying the time-zone avoids dependence on the default time-zone.
    *
    * Using this method will prevent the ability to use an alternate clock for testing because the
@@ -176,7 +176,7 @@ object LocalTime {
   }
 
   /**
-   * Obtains an instance of {@code LocalTime} from an hour and minute.
+   * Obtains an instance of {@@codeLocalTime} from an hour and minute.
    *
    * The second and nanosecond fields will be set to zero by this factory method.
    *
@@ -202,7 +202,7 @@ object LocalTime {
   }
 
   /**
-   * Obtains an instance of {@code LocalTime} from an hour, minute and second.
+   * Obtains an instance of {@@codeLocalTime} from an hour, minute and second.
    *
    * The nanosecond field will be set to zero by this factory method.
    *
@@ -229,7 +229,7 @@ object LocalTime {
   }
 
   /**
-   * Obtains an instance of {@code LocalTime} from an hour, minute, second and nanosecond.
+   * Obtains an instance of {@@codeLocalTime} from an hour, minute, second and nanosecond.
    *
    * This factory may return a cached value, but applications must not rely on this.
    *
@@ -255,12 +255,12 @@ object LocalTime {
   }
 
   /**
-   * Obtains an instance of {@code LocalTime} from a second-of-day value.
+   * Obtains an instance of {@@codeLocalTime} from a second-of-day value.
    *
    * This factory may return a cached value, but applications must not rely on this.
    *
    * @param secondOfDay
-   *   the second-of-day, from { @code 0} to { @code 24 * 60 * 60 - 1}
+   *   the second-of-day, from {@@code0} to {@@code24 * 60 * 60 - 1}
    * @return
    *   the local time, not null
    * @throws DateTimeException
@@ -277,13 +277,13 @@ object LocalTime {
   }
 
   /**
-   * Obtains an instance of {@code LocalTime} from a second-of-day value, with associated nanos of
+   * Obtains an instance of {@@codeLocalTime} from a second-of-day value, with associated nanos of
    * second.
    *
    * This factory may return a cached value, but applications must not rely on this.
    *
    * @param secondOfDay
-   *   the second-of-day, from { @code 0} to { @code 24 * 60 * 60 - 1}
+   *   the second-of-day, from {@@code0} to {@@code24 * 60 * 60 - 1}
    * @param nanoOfSecond
    *   the nano-of-second, from 0 to 999,999,999
    * @return
@@ -303,12 +303,12 @@ object LocalTime {
   }
 
   /**
-   * Obtains an instance of {@code LocalTime} from a nanos-of-day value.
+   * Obtains an instance of {@@codeLocalTime} from a nanos-of-day value.
    *
    * This factory may return a cached value, but applications must not rely on this.
    *
    * @param nanoOfDay
-   *   the nano of day, from { @code 0} to { @code 24 * 60 * 60 * 1,000,000,000 - 1}
+   *   the nano of day, from {@@code0} to {@@code24 * 60 * 60 * 1,000,000,000 - 1}
    * @return
    *   the local time, not null
    * @throws DateTimeException
@@ -327,23 +327,23 @@ object LocalTime {
   }
 
   /**
-   * Obtains an instance of {@code LocalTime} from a temporal object.
+   * Obtains an instance of {@@codeLocalTime} from a temporal object.
    *
-   * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code LocalTime}.
+   * A {@@codeTemporalAccessor} represents some form of date and time information. This factory
+   * converts the arbitrary temporal object to an instance of {@@codeLocalTime} .
    *
-   * The conversion uses the {@link TemporalQueries#localTime()} query, which relies on extracting
-   * the {@link ChronoField#NANO_OF_DAY NANO_OF_DAY} field.
+   * The conversion uses the {@@linkTemporalQueries#localTime()} query, which relies on extracting
+   * the {@@linkChronoField#NANO_OF_DAY NANO_OF_DAY} field.
    *
-   * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used in queries via method reference, {@code LocalTime::from}.
+   * This method matches the signature of the functional interface {@@linkTemporalQuery} allowing it
+   * to be used in queries via method reference, {@@codeLocalTime::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the local time, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code LocalTime}
+   *   if unable to convert to a {@@codeLocalTime}
    */
   def from(temporal: TemporalAccessor): LocalTime = {
     val time: LocalTime = temporal.query(TemporalQueries.localTime)
@@ -356,7 +356,7 @@ object LocalTime {
   }
 
   /**
-   * Obtains an instance of {@code LocalTime} from a text string such as {@code 10:15}.
+   * Obtains an instance of {@@codeLocalTime} from a text string such as {@@code10:15} .
    *
    * The string must represent a valid time and is parsed using {@link
    * org.threeten.bp.format.DateTimeFormatter#ISO_LOCAL_TIME}.
@@ -371,7 +371,7 @@ object LocalTime {
   def parse(text: CharSequence): LocalTime = parse(text, DateTimeFormatter.ISO_LOCAL_TIME)
 
   /**
-   * Obtains an instance of {@code LocalTime} from a text string using a specific formatter.
+   * Obtains an instance of {@@codeLocalTime} from a text string using a specific formatter.
    *
    * The text is parsed using the formatter, returning a time.
    *
@@ -417,11 +417,11 @@ object LocalTime {
 }
 
 /**
- * A time without time-zone in the ISO-8601 calendar system, such as {@code 10:15:30}.
+ * A time without time-zone in the ISO-8601 calendar system, such as {@@code10:15:30} .
  *
- * {@code LocalTime} is an immutable date-time object that represents a time, often viewed as
+ * {@@codeLocalTime} is an immutable date-time object that represents a time, often viewed as
  * hour-minute-second. Time is represented to nanosecond precision. For example, the value
- * "13:45.30.123456789" can be stored in a {@code LocalTime}.
+ * "13:45.30.123456789" can be stored in a {@@codeLocalTime} .
  *
  * It does not store or represent a date or time-zone. Instead, it is a description of the local
  * time as seen on a wall clock. It cannot represent an instant on the time-line without additional
@@ -465,19 +465,19 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * Checks if the specified field is supported.
    *
    * This checks if this time can be queried for the specified field. If false, then calling the
-   * {@link #range(TemporalField) range} and {@link #get(TemporalField) get} methods will throw an
+   * {@@link#range(TemporalField) range} and {@@link#get(TemporalField) get} methods will throw an
    * exception.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The supported fields
+   * If the field is a {@@linkChronoField} then the query is implemented here. The supported fields
    * are: <ul> <li>{@code NANO_OF_SECOND} <li>{@code NANO_OF_DAY} <li>{@code MICRO_OF_SECOND}
    * <li>{@code MICRO_OF_DAY} <li>{@code MILLI_OF_SECOND} <li>{@code MILLI_OF_DAY} <li>{@code
    * SECOND_OF_MINUTE} <li>{@code SECOND_OF_DAY} <li>{@code MINUTE_OF_HOUR} <li>{@code
    * MINUTE_OF_DAY} <li>{@code HOUR_OF_AMPM} <li>{@code CLOCK_HOUR_OF_AMPM} <li>{@code HOUR_OF_DAY}
-   * <li>{@code CLOCK_HOUR_OF_DAY} <li>{@code AMPM_OF_DAY} </ul> All other {@code ChronoField}
+   * <li>{@code CLOCK_HOUR_OF_DAY} <li>{@code AMPM_OF_DAY} </ul> All other {@@codeChronoField}
    * instances will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.isSupportedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the field is supported is determined by the field.
    *
    * @param field
@@ -500,12 +500,12 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * to enhance the accuracy of the returned range. If it is not possible to return the range,
    * because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return appropriate range instances. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.rangeRefinedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
    * @param field
@@ -518,20 +518,20 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
   override def range(field: TemporalField): ValueRange = super.range(field)
 
   /**
-   * Gets the value of the specified field from this time as an {@code int}.
+   * Gets the value of the specified field from this time as an {@@codeint} .
    *
    * This queries this time for the value for the specified field. The returned value will always be
    * within the valid range of values for the field. If it is not possible to return the value,
    * because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this time,
-   * except {@code NANO_OF_DAY} and {@code MICRO_OF_DAY} which are too large to fit in an {@code
-   * int} and throw a {@code DateTimeException}. All other {@code ChronoField} instances will throw
-   * a {@code DateTimeException}.
+   * except {@@codeNANO_OF_DAY} and {@@codeMICRO_OF_DAY} which are too large to fit in an {@code
+   * int} and throw a {@@codeDateTimeException} . All other {@@codeChronoField} instances will throw
+   * a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -548,17 +548,17 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
     else super.get(field)
 
   /**
-   * Gets the value of the specified field from this time as a {@code long}.
+   * Gets the value of the specified field from this time as a {@@codelong} .
    *
    * This queries this time for the value for the specified field. If it is not possible to return
    * the value, because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this time. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -637,15 +637,15 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
   /**
    * Returns an adjusted copy of this time.
    *
-   * This returns a new {@code LocalTime}, based on this one, with the time adjusted. The adjustment
-   * takes place using the specified adjuster strategy object. Read the documentation of the
-   * adjuster to understand what adjustment will be made.
+   * This returns a new {@@codeLocalTime} , based on this one, with the time adjusted. The
+   * adjustment takes place using the specified adjuster strategy object. Read the documentation of
+   * the adjuster to understand what adjustment will be made.
    *
    * A simple adjuster might simply set the one of the fields, such as the hour field. A more
    * complex adjuster might set the time to the last hour of the day.
    *
    * The result of this method is obtained by invoking the {@link
-   * TemporalAdjuster#adjustInto(Temporal)} method on the specified adjuster passing {@code this} as
+   * TemporalAdjuster#adjustInto(Temporal)} method on the specified adjuster passing {@@codethis} as
    * the argument.
    *
    * This instance is immutable and unaffected by this method call.
@@ -653,7 +653,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param adjuster
    *   the adjuster to use, not null
    * @return
-   *   a { @code LocalTime} based on { @code this} with the adjustment made, not null
+   *   a {@@codeLocalTime} based on {@@codethis} with the adjustment made, not null
    * @throws DateTimeException
    *   if the adjustment cannot be made
    * @throws ArithmeticException
@@ -668,51 +668,51 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
   /**
    * Returns a copy of this time with the specified field set to a new value.
    *
-   * This returns a new {@code LocalTime}, based on this one, with the value for the specified field
-   * changed. This can be used to change any supported field, such as the hour, minute or second. If
-   * it is not possible to set the value, because the field is not supported or for some other
-   * reason, an exception is thrown.
+   * This returns a new {@@codeLocalTime} , based on this one, with the value for the specified
+   * field changed. This can be used to change any supported field, such as the hour, minute or
+   * second. If it is not possible to set the value, because the field is not supported or for some
+   * other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the adjustment is implemented here. The supported
-   * fields behave as follows: <ul> <li>{@code NANO_OF_SECOND} - Returns a {@code LocalTime} with
+   * If the field is a {@@linkChronoField} then the adjustment is implemented here. The supported
+   * fields behave as follows: <ul> <li>{@code NANO_OF_SECOND} - Returns a {@@codeLocalTime} with
    * the specified nano-of-second. The hour, minute and second will be unchanged. <li>{@code
-   * NANO_OF_DAY} - Returns a {@code LocalTime} with the specified nano-of-day. This completely
-   * replaces the time and is equivalent to {@link #ofNanoOfDay(long)}. <li>{@code MICRO_OF_SECOND}
-   *   - Returns a {@code LocalTime} with the nano-of-second replaced by the specified
+   * NANO_OF_DAY} - Returns a {@@codeLocalTime} with the specified nano-of-day. This completely
+   * replaces the time and is equivalent to {@@link#ofNanoOfDay(long)} . <li>{@code MICRO_OF_SECOND}
+   *   - Returns a {@@codeLocalTime} with the nano-of-second replaced by the specified
    *     micro-of-second multiplied by 1,000. The hour, minute and second will be unchanged.
-   *     <li>{@code MICRO_OF_DAY} - Returns a {@code LocalTime} with the specified micro-of-day.
-   *     This completely replaces the time and is equivalent to using {@link #ofNanoOfDay(long)}
+   *     <li>{@code MICRO_OF_DAY} - Returns a {@@codeLocalTime} with the specified micro-of-day.
+   *     This completely replaces the time and is equivalent to using {@@link#ofNanoOfDay(long)}
    *     with the micro-of-day multiplied by 1,000. <li>{@code MILLI_OF_SECOND} - Returns a {@code
    *     LocalTime} with the nano-of-second replaced by the specified milli-of-second multiplied by
    *     1,000,000. The hour, minute and second will be unchanged. <li>{@code MILLI_OF_DAY} -
-   *     Returns a {@code LocalTime} with the specified milli-of-day. This completely replaces the
-   *     time and is equivalent to using {@link #ofNanoOfDay(long)} with the milli-of-day multiplied
+   *     Returns a {@@codeLocalTime} with the specified milli-of-day. This completely replaces the
+   *     time and is equivalent to using {@@link#ofNanoOfDay(long)} with the milli-of-day multiplied
    *     by 1,000,000. <li>{@code SECOND_OF_MINUTE}
-   *   - Returns a {@code LocalTime} with the specified second-of-minute. The hour, minute and
-   *     nano-of-second will be unchanged. <li>{@code SECOND_OF_DAY} - Returns a {@code LocalTime}
+   *   - Returns a {@@codeLocalTime} with the specified second-of-minute. The hour, minute and
+   *     nano-of-second will be unchanged. <li>{@code SECOND_OF_DAY} - Returns a {@@codeLocalTime}
    *     with the specified second-of-day. The nano-of-second will be unchanged. <li>{@code
-   *     MINUTE_OF_HOUR} - Returns a {@code LocalTime} with the specified minute-of-hour. The hour,
+   *     MINUTE_OF_HOUR} - Returns a {@@codeLocalTime} with the specified minute-of-hour. The hour,
    *     second-of-minute and nano-of-second will be unchanged. <li>{@code MINUTE_OF_DAY} - Returns
-   *     a {@code LocalTime} with the specified minute-of-day. The second-of-minute and
-   *     nano-of-second will be unchanged. <li>{@code HOUR_OF_AMPM} - Returns a {@code LocalTime}
+   *     a {@@codeLocalTime} with the specified minute-of-day. The second-of-minute and
+   *     nano-of-second will be unchanged. <li>{@code HOUR_OF_AMPM} - Returns a {@@codeLocalTime}
    *     with the specified hour-of-am-pm. The AM/PM, minute-of-hour, second-of-minute and
    *     nano-of-second will be unchanged. <li>{@code CLOCK_HOUR_OF_AMPM} - Returns a {@code
    *     LocalTime} with the specified clock-hour-of-am-pm. The AM/PM, minute-of-hour,
    *     second-of-minute and nano-of-second will be unchanged. <li>{@code HOUR_OF_DAY} - Returns a
-   *     {@code LocalTime} with the specified hour-of-day. The minute-of-hour, second-of-minute and
+   *     {@@codeLocalTime} with the specified hour-of-day. The minute-of-hour, second-of-minute and
    *     nano-of-second will be unchanged. <li>{@code CLOCK_HOUR_OF_DAY} - Returns a {@code
    *     LocalTime} with the specified clock-hour-of-day. The minute-of-hour, second-of-minute and
-   *     nano-of-second will be unchanged. <li>{@code AMPM_OF_DAY} - Returns a {@code LocalTime}
+   *     nano-of-second will be unchanged. <li>{@code AMPM_OF_DAY} - Returns a {@@codeLocalTime}
    *     with the specified AM/PM. The hour-of-am-pm, minute-of-hour, second-of-minute and
    *     nano-of-second will be unchanged. </ul>
    *
    * In all cases, if the new value is outside the valid range of values for the field then a {@code
    * DateTimeException} will be thrown.
    *
-   * All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * All other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.adjustInto(Temporal, long)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.adjustInto(Temporal, long)} passing {@@codethis} as the argument.
    * In this case, the field determines whether and how to adjust the instant.
    *
    * This instance is immutable and unaffected by this method call.
@@ -722,7 +722,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param newValue
    *   the new value of the field in the result
    * @return
-   *   a { @code LocalTime} based on { @code this} with the specified field set, not null
+   *   a {@@codeLocalTime} based on {@@codethis} with the specified field set, not null
    * @throws DateTimeException
    *   if the field cannot be set
    * @throws ArithmeticException
@@ -756,14 +756,14 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
     }
 
   /**
-   * Returns a copy of this {@code LocalTime} with the hour-of-day value altered.
+   * Returns a copy of this {@@codeLocalTime} with the hour-of-day value altered.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param hour
    *   the hour-of-day to set in the result, from 0 to 23
    * @return
-   *   a { @code LocalTime} based on this time with the requested hour, not null
+   *   a {@@codeLocalTime} based on this time with the requested hour, not null
    * @throws DateTimeException
    *   if the hour value is invalid
    */
@@ -776,14 +776,14 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
     }
 
   /**
-   * Returns a copy of this {@code LocalTime} with the minute-of-hour value altered.
+   * Returns a copy of this {@@codeLocalTime} with the minute-of-hour value altered.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param minute
    *   the minute-of-hour to set in the result, from 0 to 59
    * @return
-   *   a { @code LocalTime} based on this time with the requested minute, not null
+   *   a {@@codeLocalTime} based on this time with the requested minute, not null
    * @throws DateTimeException
    *   if the minute value is invalid
    */
@@ -796,14 +796,14 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
     }
 
   /**
-   * Returns a copy of this {@code LocalTime} with the second-of-minute value altered.
+   * Returns a copy of this {@@codeLocalTime} with the second-of-minute value altered.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param second
    *   the second-of-minute to set in the result, from 0 to 59
    * @return
-   *   a { @code LocalTime} based on this time with the requested second, not null
+   *   a {@@codeLocalTime} based on this time with the requested second, not null
    * @throws DateTimeException
    *   if the second value is invalid
    */
@@ -816,14 +816,14 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
     }
 
   /**
-   * Returns a copy of this {@code LocalTime} with the nano-of-second value altered.
+   * Returns a copy of this {@@codeLocalTime} with the nano-of-second value altered.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param nanoOfSecond
    *   the nano-of-second to set in the result, from 0 to 999,999,999
    * @return
-   *   a { @code LocalTime} based on this time with the requested nanosecond, not null
+   *   a {@@codeLocalTime} based on this time with the requested nanosecond, not null
    * @throws DateTimeException
    *   if the nanos value is invalid
    */
@@ -836,22 +836,22 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
     }
 
   /**
-   * Returns a copy of this {@code LocalTime} with the time truncated.
+   * Returns a copy of this {@@codeLocalTime} with the time truncated.
    *
    * Truncating the time returns a copy of the original time with fields smaller than the specified
-   * unit set to zero. For example, truncating with the {@link ChronoUnit#MINUTES minutes} unit will
+   * unit set to zero. For example, truncating with the {@@linkChronoUnit#MINUTES minutes} unit will
    * set the second-of-minute and nano-of-second field to zero.
    *
-   * The unit must have a {@linkplain TemporalUnit#getDuration() duration} that divides into the
+   * The unit must have a {@@linkplainTemporalUnit#getDuration() duration} that divides into the
    * length of a standard day without remainder. This includes all supplied time units on {@link
-   * ChronoUnit} and {@link ChronoUnit#DAYS DAYS}. Other units throw an exception.
+   * ChronoUnit} and {@@linkChronoUnit#DAYS DAYS} . Other units throw an exception.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param unit
    *   the unit to truncate to, not null
    * @return
-   *   a { @code LocalTime} based on this time with the time truncated, not null
+   *   a {@@codeLocalTime} based on this time with the time truncated, not null
    * @throws DateTimeException
    *   if unable to truncate
    */
@@ -872,16 +872,16 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * Returns a copy of this date with the specified period added.
    *
    * This method returns a new time based on this time with the specified period added. The amount
-   * is typically {@link Period} but may be any other type implementing the {@link TemporalAmount}
+   * is typically {@@linkPeriod} but may be any other type implementing the {@@linkTemporalAmount}
    * interface. The calculation is delegated to the specified adjuster, which typically calls back
-   * to {@link #plus(long, TemporalUnit)}.
+   * to {@@link#plus(long, TemporalUnit)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param amount
    *   the amount to add, not null
    * @return
-   *   a { @code LocalTime} based on this time with the addition made, not null
+   *   a {@@codeLocalTime} based on this time with the addition made, not null
    * @throws DateTimeException
    *   if the addition cannot be made
    * @throws ArithmeticException
@@ -904,7 +904,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param unit
    *   the unit of the period to add, not null
    * @return
-   *   a { @code LocalTime} based on this time with the specified period added, not null
+   *   a {@@codeLocalTime} based on this time with the specified period added, not null
    * @throws DateTimeException
    *   if the unit cannot be added to this type
    */
@@ -927,7 +927,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
     }
 
   /**
-   * Returns a copy of this {@code LocalTime} with the specified period in hours added.
+   * Returns a copy of this {@@codeLocalTime} with the specified period in hours added.
    *
    * This adds the specified number of hours to this time, returning a new time. The calculation
    * wraps around midnight.
@@ -937,7 +937,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param hoursToAdd
    *   the hours to add, may be negative
    * @return
-   *   a { @code LocalTime} based on this time with the hours added, not null
+   *   a {@@codeLocalTime} based on this time with the hours added, not null
    */
   def plusHours(hoursToAdd: Long): LocalTime = {
     if (hoursToAdd == 0)
@@ -948,7 +948,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
   }
 
   /**
-   * Returns a copy of this {@code LocalTime} with the specified period in minutes added.
+   * Returns a copy of this {@@codeLocalTime} with the specified period in minutes added.
    *
    * This adds the specified number of minutes to this time, returning a new time. The calculation
    * wraps around midnight.
@@ -958,7 +958,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param minutesToAdd
    *   the minutes to add, may be negative
    * @return
-   *   a { @code LocalTime} based on this time with the minutes added, not null
+   *   a {@@codeLocalTime} based on this time with the minutes added, not null
    */
   def plusMinutes(minutesToAdd: Long): LocalTime = {
     if (minutesToAdd == 0)
@@ -974,7 +974,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
   }
 
   /**
-   * Returns a copy of this {@code LocalTime} with the specified period in seconds added.
+   * Returns a copy of this {@@codeLocalTime} with the specified period in seconds added.
    *
    * This adds the specified number of seconds to this time, returning a new time. The calculation
    * wraps around midnight.
@@ -984,7 +984,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param secondstoAdd
    *   the seconds to add, may be negative
    * @return
-   *   a { @code LocalTime} based on this time with the seconds added, not null
+   *   a {@@codeLocalTime} based on this time with the seconds added, not null
    */
   def plusSeconds(secondstoAdd: Long): LocalTime = {
     if (secondstoAdd == 0)
@@ -1002,7 +1002,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
   }
 
   /**
-   * Returns a copy of this {@code LocalTime} with the specified period in nanoseconds added.
+   * Returns a copy of this {@@codeLocalTime} with the specified period in nanoseconds added.
    *
    * This adds the specified number of nanoseconds to this time, returning a new time. The
    * calculation wraps around midnight.
@@ -1012,7 +1012,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param nanosToAdd
    *   the nanos to add, may be negative
    * @return
-   *   a { @code LocalTime} based on this time with the nanoseconds added, not null
+   *   a {@@codeLocalTime} based on this time with the nanoseconds added, not null
    */
   def plusNanos(nanosToAdd: Long): LocalTime = {
     if (nanosToAdd == 0)
@@ -1034,16 +1034,16 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * Returns a copy of this time with the specified period subtracted.
    *
    * This method returns a new time based on this time with the specified period subtracted. The
-   * amount is typically {@link Period} but may be any other type implementing the {@link
+   * amount is typically {@@linkPeriod} but may be any other type implementing the {@link
    * TemporalAmount} interface. The calculation is delegated to the specified adjuster, which
-   * typically calls back to {@link #minus(long, TemporalUnit)}.
+   * typically calls back to {@@link#minus(long, TemporalUnit)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param amount
    *   the amount to subtract, not null
    * @return
-   *   a { @code LocalTime} based on this time with the subtraction made, not null
+   *   a {@@codeLocalTime} based on this time with the subtraction made, not null
    * @throws DateTimeException
    *   if the subtraction cannot be made
    * @throws ArithmeticException
@@ -1067,7 +1067,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param unit
    *   the unit of the period to subtract, not null
    * @return
-   *   a { @code LocalTime} based on this time with the specified period subtracted, not null
+   *   a {@@codeLocalTime} based on this time with the specified period subtracted, not null
    * @throws DateTimeException
    *   if the unit cannot be added to this type
    */
@@ -1076,7 +1076,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
     else plus(-amountToSubtract, unit)
 
   /**
-   * Returns a copy of this {@code LocalTime} with the specified period in hours subtracted.
+   * Returns a copy of this {@@codeLocalTime} with the specified period in hours subtracted.
    *
    * This subtracts the specified number of hours from this time, returning a new time. The
    * calculation wraps around midnight.
@@ -1086,13 +1086,13 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param hoursToSubtract
    *   the hours to subtract, may be negative
    * @return
-   *   a { @code LocalTime} based on this time with the hours subtracted, not null
+   *   a {@@codeLocalTime} based on this time with the hours subtracted, not null
    */
   def minusHours(hoursToSubtract: Long): LocalTime =
     plusHours(-(hoursToSubtract % LocalTime.HOURS_PER_DAY))
 
   /**
-   * Returns a copy of this {@code LocalTime} with the specified period in minutes subtracted.
+   * Returns a copy of this {@@codeLocalTime} with the specified period in minutes subtracted.
    *
    * This subtracts the specified number of minutes from this time, returning a new time. The
    * calculation wraps around midnight.
@@ -1102,13 +1102,13 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param minutesToSubtract
    *   the minutes to subtract, may be negative
    * @return
-   *   a { @code LocalTime} based on this time with the minutes subtracted, not null
+   *   a {@@codeLocalTime} based on this time with the minutes subtracted, not null
    */
   def minusMinutes(minutesToSubtract: Long): LocalTime =
     plusMinutes(-(minutesToSubtract % LocalTime.MINUTES_PER_DAY))
 
   /**
-   * Returns a copy of this {@code LocalTime} with the specified period in seconds subtracted.
+   * Returns a copy of this {@@codeLocalTime} with the specified period in seconds subtracted.
    *
    * This subtracts the specified number of seconds from this time, returning a new time. The
    * calculation wraps around midnight.
@@ -1118,13 +1118,13 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param secondsToSubtract
    *   the seconds to subtract, may be negative
    * @return
-   *   a { @code LocalTime} based on this time with the seconds subtracted, not null
+   *   a {@@codeLocalTime} based on this time with the seconds subtracted, not null
    */
   def minusSeconds(secondsToSubtract: Long): LocalTime =
     plusSeconds(-(secondsToSubtract % LocalTime.SECONDS_PER_DAY))
 
   /**
-   * Returns a copy of this {@code LocalTime} with the specified period in nanoseconds subtracted.
+   * Returns a copy of this {@@codeLocalTime} with the specified period in nanoseconds subtracted.
    *
    * This subtracts the specified number of nanoseconds from this time, returning a new time. The
    * calculation wraps around midnight.
@@ -1134,7 +1134,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @param nanosToSubtract
    *   the nanos to subtract, may be negative
    * @return
-   *   a { @code LocalTime} based on this time with the nanoseconds subtracted, not null
+   *   a {@@codeLocalTime} based on this time with the nanoseconds subtracted, not null
    */
   def minusNanos(nanosToSubtract: Long): LocalTime =
     plusNanos(-(nanosToSubtract % LocalTime.NANOS_PER_DAY))
@@ -1142,12 +1142,12 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
   /**
    * Queries this time using the specified query.
    *
-   * This queries this time using the specified query strategy object. The {@code TemporalQuery}
+   * This queries this time using the specified query strategy object. The {@@codeTemporalQuery}
    * object defines the logic to be used to obtain the result. Read the documentation of the query
    * to understand what the result of this method will be.
    *
    * The result of this method is obtained by invoking the {@link
-   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@code this}
+   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@@codethis}
    * as the argument.
    *
    * @tparam R
@@ -1177,7 +1177,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * This returns a temporal object of the same observable type as the input with the time changed
    * to be the same as this.
    *
-   * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)} passing {@link
+   * The adjustment is equivalent to using {@@linkTemporal#with(TemporalField, long)} passing {@link
    * ChronoField#NANO_OF_DAY} as the field.
    *
    * In most cases, it is clearer to reverse the calling pattern by using {@link
@@ -1202,8 +1202,8 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * Calculates the period between this time and another time in terms of the specified unit.
    *
    * This calculates the period between two times in terms of a single unit. The start and end
-   * points are {@code this} and the specified time. The result will be negative if the end is
-   * before the start. The {@code Temporal} passed to this method must be a {@code LocalTime}. For
+   * points are {@@codethis} and the specified time. The result will be negative if the end is
+   * before the start. The {@@codeTemporal} passed to this method must be a {@@codeLocalTime} . For
    * example, the period in hours between two times can be calculated using {@code
    * startTime.until(endTime, HOURS)}.
    *
@@ -1211,24 +1211,24 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * two times. For example, the period in hours between 11:30 and 13:29 will only be one hour as it
    * is one minute short of two hours.
    *
-   * This method operates in association with {@link TemporalUnit#between}. The result of this
-   * method is a {@code long} representing the amount of the specified unit. By contrast, the result
-   * of {@code between} is an object that can be used directly in addition/subtraction: <pre> long
+   * This method operates in association with {@@linkTemporalUnit#between} . The result of this
+   * method is a {@@codelong} representing the amount of the specified unit. By contrast, the result
+   * of {@@codebetween} is an object that can be used directly in addition/subtraction: <pre> long
    * period = start.until(end, HOURS); // this method dateTime.plus(HOURS.between(start, end)); //
    * use in plus/minus </pre>
    *
-   * The calculation is implemented in this method for {@link ChronoUnit}. The units {@code NANOS},
-   * {@code MICROS}, {@code MILLIS}, {@code SECONDS}, {@code MINUTES}, {@code HOURS} and {@code
-   * HALF_DAYS} are supported. Other {@code ChronoUnit} values will throw an exception.
+   * The calculation is implemented in this method for {@@linkChronoUnit} . The units {@@codeNANOS}
+   * , {@@codeMICROS} , {@@codeMILLIS} , {@@codeSECONDS} , {@@codeMINUTES} , {@@codeHOURS} and
+   * {@code HALF_DAYS} are supported. Other {@@codeChronoUnit} values will throw an exception.
    *
-   * If the unit is not a {@code ChronoUnit}, then the result of this method is obtained by invoking
-   * {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first argument and
-   * the input temporal as the second argument.
+   * If the unit is not a {@@codeChronoUnit} , then the result of this method is obtained by
+   * invoking {@@codeTemporalUnit.between(Temporal, Temporal)} passing {@@codethis} as the first
+   * argument and the input temporal as the second argument.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param endExclusive
-   *   the end time, which is converted to a { @code LocalTime}, not null
+   *   the end time, which is converted to a {@@codeLocalTime} , not null
    * @param unit
    *   the unit to measure the period in, not null
    * @return
@@ -1260,9 +1260,9 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
   }
 
   /**
-   * Combines this time with a date to create a {@code LocalDateTime}.
+   * Combines this time with a date to create a {@@codeLocalDateTime} .
    *
-   * This returns a {@code LocalDateTime} formed from this time at the specified date. All possible
+   * This returns a {@@codeLocalDateTime} formed from this time at the specified date. All possible
    * combinations of date and time are valid.
    *
    * @param date
@@ -1273,9 +1273,9 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
   def atDate(date: LocalDate): LocalDateTime = LocalDateTime.of(date, this)
 
   /**
-   * Combines this time with an offset to create an {@code OffsetTime}.
+   * Combines this time with an offset to create an {@@codeOffsetTime} .
    *
-   * This returns an {@code OffsetTime} formed from this time at the specified offset. All possible
+   * This returns an {@@codeOffsetTime} formed from this time at the specified offset. All possible
    * combinations of time and offset are valid.
    *
    * @param offset
@@ -1286,7 +1286,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
   def atOffset(offset: ZoneOffset): OffsetTime = OffsetTime.of(this, offset)
 
   /**
-   * Extracts the time as seconds of day, from {@code 0} to {@code 24 * 60 * 60 - 1}.
+   * Extracts the time as seconds of day, from {@@code0} to {@@code24 * 60 * 60 - 1} .
    *
    * @return
    *   the second-of-day equivalent to this time
@@ -1299,7 +1299,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
   }
 
   /**
-   * Extracts the time as nanos of day, from {@code 0} to {@code 24 * 60 * 60 * 1,000,000,000 - 1}.
+   * Extracts the time as nanos of day, from {@@code0} to {@@code24 * 60 * 60 * 1,000,000,000 - 1} .
    *
    * @return
    *   the nano of day equivalent to this time
@@ -1313,17 +1313,17 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
   }
 
   /**
-   * Compares this {@code LocalTime} to another time.
+   * Compares this {@@codeLocalTime} to another time.
    *
    * The comparison is based on the time-line position of the local times within a day. It is
-   * "consistent with equals", as defined by {@link Comparable}.
+   * "consistent with equals", as defined by {@@linkComparable} .
    *
    * @param other
    *   the other time to compare to, not null
    * @return
    *   the comparator value, negative if less, positive if greater
    * @throws NullPointerException
-   *   if { @code other} is null
+   *   if {@@codeother} is null
    */
   def compare(other: LocalTime): Int = {
     var cmp: Int = Integer.compare(hour.toInt, other.hour.toInt)
@@ -1341,7 +1341,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
   override def compareTo(other: LocalTime): Int = compare(other)
 
   /**
-   * Checks if this {@code LocalTime} is after the specified time.
+   * Checks if this {@@codeLocalTime} is after the specified time.
    *
    * The comparison is based on the time-line position of the time within a day.
    *
@@ -1350,12 +1350,12 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @return
    *   true if this is after the specified time
    * @throws NullPointerException
-   *   if { @code other} is null
+   *   if {@@codeother} is null
    */
   def isAfter(other: LocalTime): Boolean = compareTo(other) > 0
 
   /**
-   * Checks if this {@code LocalTime} is before the specified time.
+   * Checks if this {@@codeLocalTime} is before the specified time.
    *
    * The comparison is based on the time-line position of the time within a day.
    *
@@ -1364,7 +1364,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    * @return
    *   true if this point is before the specified time
    * @throws NullPointerException
-   *   if { @code other} is null
+   *   if {@@codeother} is null
    */
   def isBefore(other: LocalTime): Boolean = compareTo(other) < 0
 
@@ -1373,8 +1373,8 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
    *
    * The comparison is based on the time-line position of the time within a day.
    *
-   * Only objects of type {@code LocalTime} are compared, other types return false. To compare the
-   * date of two {@code TemporalAccessor} instances, use {@link ChronoField#NANO_OF_DAY} as a
+   * Only objects of type {@@codeLocalTime} are compared, other types return false. To compare the
+   * date of two {@@codeTemporalAccessor} instances, use {@@linkChronoField#NANO_OF_DAY} as a
    * comparator.
    *
    * @param obj
@@ -1401,7 +1401,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
   }
 
   /**
-   * Outputs this time as a {@code String}, such as {@code 10:15}.
+   * Outputs this time as a {@@codeString} , such as {@@code10:15} .
    *
    * The output will be one of the following ISO-8601 formats: <ul> <li>{@code HH:mm}</li>
    * <li>{@code HH:mm:ss}</li> <li>{@code HH:mm:ss.SSS}</li> <li>{@code HH:mm:ss.SSSSSS}</li>
@@ -1438,7 +1438,7 @@ final class LocalTime(_hour: Int, _minute: Int, _second: Int, private val nano:
   }
 
   /**
-   * Outputs this time as a {@code String} using the formatter.
+   * Outputs this time as a {@@codeString} using the formatter.
    *
    * This time will be passed to the formatter {@link DateTimeFormatter#format(TemporalAccessor)
    * print method}.
diff --git a/core/shared/src/main/scala/org/threeten/bp/MonthDay.scala b/core/shared/src/main/scala/org/threeten/bp/MonthDay.scala
index 3f607d5b3..b72d2a347 100644
--- a/core/shared/src/main/scala/org/threeten/bp/MonthDay.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/MonthDay.scala
@@ -63,7 +63,7 @@ object MonthDay {
   /**
    * Obtains the current month-day from the system clock in the default time-zone.
    *
-   * This will query the {@link Clock#systemDefaultZone() system clock} in the default time-zone to
+   * This will query the {@@linkClock#systemDefaultZone() system clock} in the default time-zone to
    * obtain the current month-day.
    *
    * Using this method will prevent the ability to use an alternate clock for testing because the
@@ -77,7 +77,7 @@ object MonthDay {
   /**
    * Obtains the current month-day from the system clock in the specified time-zone.
    *
-   * This will query the {@link Clock#system(ZoneId) system clock} to obtain the current month-day.
+   * This will query the {@@linkClock#system(ZoneId) system clock} to obtain the current month-day.
    * Specifying the time-zone avoids dependence on the default time-zone.
    *
    * Using this method will prevent the ability to use an alternate clock for testing because the
@@ -108,7 +108,7 @@ object MonthDay {
   }
 
   /**
-   * Obtains an instance of {@code MonthDay}.
+   * Obtains an instance of {@@codeMonthDay} .
    *
    * The day-of-month must be valid for the month within a leap year. Hence, for February, day 29 is
    * valid.
@@ -139,7 +139,7 @@ object MonthDay {
   }
 
   /**
-   * Obtains an instance of {@code MonthDay}.
+   * Obtains an instance of {@@codeMonthDay} .
    *
    * The day-of-month must be valid for the month within a leap year. Hence, for month 2 (February),
    * day 29 is valid.
@@ -162,24 +162,24 @@ object MonthDay {
   def of(month: Int, dayOfMonth: Int): MonthDay = of(Month.of(month), dayOfMonth)
 
   /**
-   * Obtains an instance of {@code MonthDay} from a temporal object.
+   * Obtains an instance of {@@codeMonthDay} from a temporal object.
    *
-   * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code MonthDay}.
+   * A {@@codeTemporalAccessor} represents some form of date and time information. This factory
+   * converts the arbitrary temporal object to an instance of {@@codeMonthDay} .
    *
-   * The conversion extracts the {@link ChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} and {@link
+   * The conversion extracts the {@@linkChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} and {@link
    * ChronoField#DAY_OF_MONTH DAY_OF_MONTH} fields. The extraction is only permitted if the
    * date-time has an ISO chronology.
    *
-   * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used in queries via method reference, {@code MonthDay::from}.
+   * This method matches the signature of the functional interface {@@linkTemporalQuery} allowing it
+   * to be used in queries via method reference, {@@codeMonthDay::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the month-day, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code MonthDay}
+   *   if unable to convert to a {@@codeMonthDay}
    */
   def from(temporal: TemporalAccessor): MonthDay = {
     var _temporal = temporal
@@ -201,9 +201,9 @@ object MonthDay {
   }
 
   /**
-   * Obtains an instance of {@code MonthDay} from a text string such as {@code --12-03}.
+   * Obtains an instance of {@@codeMonthDay} from a text string such as {@@code--12-03} .
    *
-   * The string must represent a valid month-day. The format is {@code --MM-dd}.
+   * The string must represent a valid month-day. The format is {@@code--MM-dd} .
    *
    * @param text
    *   the text to parse such as "--12-03", not null
@@ -215,7 +215,7 @@ object MonthDay {
   def parse(text: CharSequence): MonthDay = parse(text, PARSER)
 
   /**
-   * Obtains an instance of {@code MonthDay} from a text string using a specific formatter.
+   * Obtains an instance of {@@codeMonthDay} from a text string using a specific formatter.
    *
    * The text is parsed using the formatter, returning a month-day.
    *
@@ -241,22 +241,22 @@ object MonthDay {
 }
 
 /**
- * A month-day in the ISO-8601 calendar system, such as {@code --12-03}.
+ * A month-day in the ISO-8601 calendar system, such as {@@code--12-03} .
  *
- * {@code MonthDay} is an immutable date-time object that represents the combination of a year and
+ * {@@codeMonthDay} is an immutable date-time object that represents the combination of a year and
  * month. Any field that can be derived from a month and day, such as quarter-of-year, can be
  * obtained.
  *
  * This class does not store or represent a year, time or time-zone. For example, the value
- * "December 3rd" can be stored in a {@code MonthDay}.
+ * "December 3rd" can be stored in a {@@codeMonthDay} .
  *
- * Since a {@code MonthDay} does not possess a year, the leap day of February 29th is considered
+ * Since a {@@codeMonthDay} does not possess a year, the leap day of February 29th is considered
  * valid.
  *
- * This class implements {@link TemporalAccessor} rather than {@link Temporal}. This is because it
+ * This class implements {@@linkTemporalAccessor} rather than {@@linkTemporal} . This is because it
  * is not possible to define whether February 29th is valid or not without external information,
- * preventing the implementation of plus/minus. Related to this, {@code MonthDay} only provides
- * access to query and set the fields {@code MONTH_OF_YEAR} and {@code DAY_OF_MONTH}.
+ * preventing the implementation of plus/minus. Related to this, {@@codeMonthDay} only provides
+ * access to query and set the fields {@@codeMONTH_OF_YEAR} and {@@codeDAY_OF_MONTH} .
  *
  * The ISO-8601 calendar system is the modern civil calendar system used today in most of the world.
  * It is equivalent to the proleptic Gregorian calendar system, in which today's rules for leap
@@ -285,16 +285,16 @@ final class MonthDay private (private val month: Int, private val day: Int)
    * Checks if the specified field is supported.
    *
    * This checks if this month-day can be queried for the specified field. If false, then calling
-   * the {@link #range(TemporalField) range} and {@link #get(TemporalField) get} methods will throw
+   * the {@@link#range(TemporalField) range} and {@@link#get(TemporalField) get} methods will throw
    * an exception.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this date-time.
    * The supported fields are: <ul> <li>{@code MONTH_OF_YEAR} <li>{@code YEAR} </ul> All other
-   * {@code ChronoField} instances will return false.
+   * {@@codeChronoField} instances will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.isSupportedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the field is supported is determined by the field.
    *
    * @param field
@@ -315,12 +315,12 @@ final class MonthDay private (private val month: Int, private val day: Int)
    * used to enhance the accuracy of the returned range. If it is not possible to return the range,
    * because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return appropriate range instances. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.rangeRefinedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
    * @param field
@@ -342,18 +342,18 @@ final class MonthDay private (private val month: Int, private val day: Int)
       field.rangeRefinedBy(this)
 
   /**
-   * Gets the value of the specified field from this month-day as an {@code int}.
+   * Gets the value of the specified field from this month-day as an {@@codeint} .
    *
    * This queries this month-day for the value for the specified field. The returned value will
    * always be within the valid range of values for the field. If it is not possible to return the
    * value, because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this month-day.
-   * All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * All other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -369,18 +369,18 @@ final class MonthDay private (private val month: Int, private val day: Int)
     range(field).checkValidIntValue(getLong(field), field)
 
   /**
-   * Gets the value of the specified field from this month-day as a {@code long}.
+   * Gets the value of the specified field from this month-day as a {@@codelong} .
    *
    * This queries this month-day for the value for the specified field. If it is not possible to
    * return the value, because the field is not supported or for some other reason, an exception is
    * thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this month-day.
-   * All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * All other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -406,8 +406,8 @@ final class MonthDay private (private val month: Int, private val day: Int)
   /**
    * Gets the month-of-year field from 1 to 12.
    *
-   * This method returns the month as an {@code int} from 1 to 12. Application code is frequently
-   * clearer if the enum {@link Month} is used by calling {@link #getMonth()}.
+   * This method returns the month as an {@@codeint} from 1 to 12. Application code is frequently
+   * clearer if the enum {@@linkMonth} is used by calling {@@link#getMonth()} .
    *
    * @return
    *   the month-of-year, from 1 to 12
@@ -417,11 +417,11 @@ final class MonthDay private (private val month: Int, private val day: Int)
   def getMonthValue: Int = month
 
   /**
-   * Gets the month-of-year field using the {@code Month} enum.
+   * Gets the month-of-year field using the {@@codeMonth} enum.
    *
-   * This method returns the enum {@link Month} for the month. This avoids confusion as to what
-   * {@code int} values mean. If you need access to the primitive {@code int} value then the enum
-   * provides the {@link Month#getValue() int value}.
+   * This method returns the enum {@@linkMonth} for the month. This avoids confusion as to what
+   * {@@codeint} values mean. If you need access to the primitive {@@codeint} value then the enum
+   * provides the {@@linkMonth#getValue() int value} .
    *
    * @return
    *   the month-of-year, not null
@@ -433,7 +433,7 @@ final class MonthDay private (private val month: Int, private val day: Int)
   /**
    * Gets the day-of-month field.
    *
-   * This method returns the primitive {@code int} value for the day-of-month.
+   * This method returns the primitive {@@codeint} value for the day-of-month.
    *
    * @return
    *   the day-of-month, from 1 to 31
@@ -456,7 +456,7 @@ final class MonthDay private (private val month: Int, private val day: Int)
   def isValidYear(year: Int): Boolean = !(day == 29 && month == 2 && !Year.isLeap(year.toLong))
 
   /**
-   * Returns a copy of this {@code MonthDay} with the month-of-year altered.
+   * Returns a copy of this {@@codeMonthDay} with the month-of-year altered.
    *
    * This returns a month-day with the specified month. If the day-of-month is invalid for the
    * specified month, the day will be adjusted to the last valid day-of-month.
@@ -466,14 +466,14 @@ final class MonthDay private (private val month: Int, private val day: Int)
    * @param month
    *   the month-of-year to set in the returned month-day, from 1 (January) to 12 (December)
    * @return
-   *   a { @code MonthDay} based on this month-day with the requested month, not null
+   *   a {@@codeMonthDay} based on this month-day with the requested month, not null
    * @throws DateTimeException
    *   if the month-of-year value is invalid
    */
   def withMonth(month: Int): MonthDay = `with`(Month.of(month))
 
   /**
-   * Returns a copy of this {@code MonthDay} with the month-of-year altered.
+   * Returns a copy of this {@@codeMonthDay} with the month-of-year altered.
    *
    * This returns a month-day with the specified month. If the day-of-month is invalid for the
    * specified month, the day will be adjusted to the last valid day-of-month.
@@ -483,7 +483,7 @@ final class MonthDay private (private val month: Int, private val day: Int)
    * @param month
    *   the month-of-year to set in the returned month-day, not null
    * @return
-   *   a { @code MonthDay} based on this month-day with the requested month, not null
+   *   a {@@codeMonthDay} based on this month-day with the requested month, not null
    */
   def `with`(month: Month): MonthDay = {
     Objects.requireNonNull(month, "month")
@@ -494,7 +494,7 @@ final class MonthDay private (private val month: Int, private val day: Int)
   }
 
   /**
-   * Returns a copy of this {@code MonthDay} with the day-of-month altered.
+   * Returns a copy of this {@@codeMonthDay} with the day-of-month altered.
    *
    * This returns a month-day with the specified day-of-month. If the day-of-month is invalid for
    * the month, an exception is thrown.
@@ -504,7 +504,7 @@ final class MonthDay private (private val month: Int, private val day: Int)
    * @param dayOfMonth
    *   the day-of-month to set in the return month-day, from 1 to 31
    * @return
-   *   a { @code MonthDay} based on this month-day with the requested day, not null
+   *   a {@@codeMonthDay} based on this month-day with the requested day, not null
    * @throws DateTimeException
    *   if the day-of-month value is invalid
    * @throws DateTimeException
@@ -522,7 +522,7 @@ final class MonthDay private (private val month: Int, private val day: Int)
    * of the query to understand what the result of this method will be.
    *
    * The result of this method is obtained by invoking the {@link
-   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@code this}
+   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@@codethis}
    * as the argument.
    *
    * @tparam R
@@ -550,9 +550,9 @@ final class MonthDay private (private val month: Int, private val day: Int)
    * This returns a temporal object of the same observable type as the input with the month and
    * day-of-month changed to be the same as this.
    *
-   * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)} twice, passing
-   * {@link ChronoField#MONTH_OF_YEAR} and {@link ChronoField#DAY_OF_MONTH} as the fields. If the
-   * specified temporal object does not use the ISO calendar system then a {@code DateTimeException}
+   * The adjustment is equivalent to using {@@linkTemporal#with(TemporalField, long)} twice, passing
+   * {@@linkChronoField#MONTH_OF_YEAR} and {@@linkChronoField#DAY_OF_MONTH} as the fields. If the
+   * specified temporal object does not use the ISO calendar system then a {@@codeDateTimeException}
    * is thrown.
    *
    * In most cases, it is clearer to reverse the calling pattern by using {@link
@@ -580,9 +580,9 @@ final class MonthDay private (private val month: Int, private val day: Int)
   }
 
   /**
-   * Combines this month-day with a year to create a {@code LocalDate}.
+   * Combines this month-day with a year to create a {@@codeLocalDate} .
    *
-   * This returns a {@code LocalDate} formed from this month-day and the specified year.
+   * This returns a {@@codeLocalDate} formed from this month-day and the specified year.
    *
    * A month-day of February 29th will be adjusted to February 28th in the resulting date if the
    * year is not a leap year.
@@ -602,7 +602,7 @@ final class MonthDay private (private val month: Int, private val day: Int)
    * Compares this month-day to another month-day.
    *
    * The comparison is based first on value of the month, then on the value of the day. It is
-   * "consistent with equals", as defined by {@link Comparable}.
+   * "consistent with equals", as defined by {@@linkComparable} .
    *
    * @param other
    *   the other month-day to compare to, not null
@@ -663,9 +663,9 @@ final class MonthDay private (private val month: Int, private val day: Int)
   override def hashCode: Int = (month << 6) + day
 
   /**
-   * Outputs this month-day as a {@code String}, such as {@code --12-03}.
+   * Outputs this month-day as a {@@codeString} , such as {@@code--12-03} .
    *
-   * The output will be in the format {@code --MM-dd}:
+   * The output will be in the format {@@code--MM-dd} :
    *
    * @return
    *   a string representation of this month-day, not null
@@ -680,7 +680,7 @@ final class MonthDay private (private val month: Int, private val day: Int)
       .toString
 
   /**
-   * Outputs this month-day as a {@code String} using the formatter.
+   * Outputs this month-day as a {@@codeString} using the formatter.
    *
    * This month-day will be passed to the formatter {@link
    * DateTimeFormatter#format(TemporalAccessor) print method}.
diff --git a/core/shared/src/main/scala/org/threeten/bp/OffsetDateTime.scala b/core/shared/src/main/scala/org/threeten/bp/OffsetDateTime.scala
index 3c8e19955..8c2a60ffe 100644
--- a/core/shared/src/main/scala/org/threeten/bp/OffsetDateTime.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/OffsetDateTime.scala
@@ -57,27 +57,27 @@ import org.threeten.bp.zone.ZoneRules
 object OffsetDateTime {
 
   /**
-   * The minimum supported {@code OffsetDateTime}, '-999999999-01-01T00:00:00+18:00'. This is the
+   * The minimum supported {@@codeOffsetDateTime} , '-999999999-01-01T00:00:00+18:00'. This is the
    * local date-time of midnight at the start of the minimum date in the maximum offset (larger
-   * offsets are earlier on the time-line). This combines {@link LocalDateTime#MIN} and {@link
+   * offsets are earlier on the time-line). This combines {@@linkLocalDateTime#MIN} and {@link
    * ZoneOffset#MAX}. This could be used by an application as a "far past" date-time.
    */
   lazy val MIN: OffsetDateTime = LocalDateTime.MIN.atOffset(ZoneOffset.MAX)
 
   /**
-   * The maximum supported {@code OffsetDateTime}, '+999999999-12-31T23:59:59.999999999-18:00'. This
-   * is the local date-time just before midnight at the end of the maximum date in the minimum
+   * The maximum supported {@@codeOffsetDateTime} , '+999999999-12-31T23:59:59.999999999-18:00'.
+   * This is the local date-time just before midnight at the end of the maximum date in the minimum
    * offset (larger negative offsets are later on the time-line). This combines {@link
-   * LocalDateTime#MAX} and {@link ZoneOffset#MIN}. This could be used by an application as a "far
+   * LocalDateTime#MAX} and {@@linkZoneOffset#MIN} . This could be used by an application as a "far
    * future" date-time.
    */
   lazy val MAX: OffsetDateTime = LocalDateTime.MAX.atOffset(ZoneOffset.MIN)
 
   /**
-   * Gets a comparator that compares two {@code OffsetDateTime} instances based solely on the
+   * Gets a comparator that compares two {@@codeOffsetDateTime} instances based solely on the
    * instant.
    *
-   * This method differs from the comparison in {@link #compareTo} in that it only compares the
+   * This method differs from the comparison in {@@link#compareTo} in that it only compares the
    * underlying instant.
    *
    * @return
@@ -104,7 +104,7 @@ object OffsetDateTime {
   /**
    * Obtains the current date-time from the system clock in the default time-zone.
    *
-   * This will query the {@link Clock#systemDefaultZone() system clock} in the default time-zone to
+   * This will query the {@@linkClock#systemDefaultZone() system clock} in the default time-zone to
    * obtain the current date-time. The offset will be calculated from the time-zone in the clock.
    *
    * Using this method will prevent the ability to use an alternate clock for testing because the
@@ -118,7 +118,7 @@ object OffsetDateTime {
   /**
    * Obtains the current date-time from the system clock in the specified time-zone.
    *
-   * This will query the {@link Clock#system(ZoneId) system clock} to obtain the current date-time.
+   * This will query the {@@linkClock#system(ZoneId) system clock} to obtain the current date-time.
    * Specifying the time-zone avoids dependence on the default time-zone. The offset will be
    * calculated from the specified time-zone.
    *
@@ -139,7 +139,7 @@ object OffsetDateTime {
    * calculated from the time-zone in the clock.
    *
    * Using this method allows the use of an alternate clock for testing. The alternate clock may be
-   * introduced using {@link Clock dependency injection}.
+   * introduced using {@@linkClock dependency injection} .
    *
    * @param clock
    *   the clock to use, not null
@@ -153,7 +153,7 @@ object OffsetDateTime {
   }
 
   /**
-   * Obtains an instance of {@code OffsetDateTime} from a date, time and offset.
+   * Obtains an instance of {@@codeOffsetDateTime} from a date, time and offset.
    *
    * This creates an offset date-time with the specified local date, time and offset.
    *
@@ -172,7 +172,7 @@ object OffsetDateTime {
   }
 
   /**
-   * Obtains an instance of {@code OffsetDateTime} from a date-time and offset.
+   * Obtains an instance of {@@codeOffsetDateTime} from a date-time and offset.
    *
    * This creates an offset date-time with the specified local date-time and offset.
    *
@@ -187,13 +187,13 @@ object OffsetDateTime {
     new OffsetDateTime(dateTime, offset)
 
   /**
-   * Obtains an instance of {@code OffsetDateTime} from a year, month, day, hour, minute, second,
+   * Obtains an instance of {@@codeOffsetDateTime} from a year, month, day, hour, minute, second,
    * nanosecond and offset.
    *
    * This creates an offset date-time with the seven specified fields.
    *
    * This method exists primarily for writing test cases. Non test-code will typically use other
-   * methods to create an offset time. {@code LocalDateTime} has five additional convenience
+   * methods to create an offset time. {@@codeLocalDateTime} has five additional convenience
    * variants of the equivalent factory method taking fewer arguments. They are not provided here to
    * reduce the footprint of the API.
    *
@@ -235,7 +235,7 @@ object OffsetDateTime {
   }
 
   /**
-   * Obtains an instance of {@code OffsetDateTime} from an {@code Instant} and zone ID.
+   * Obtains an instance of {@@codeOffsetDateTime} from an {@@codeInstant} and zone ID.
    *
    * This creates an offset date-time with the same instant as that specified. Finding the offset
    * from UTC/Greenwich is simple as there is only one valid offset for each instant.
@@ -260,23 +260,23 @@ object OffsetDateTime {
   }
 
   /**
-   * Obtains an instance of {@code OffsetDateTime} from a temporal object.
+   * Obtains an instance of {@@codeOffsetDateTime} from a temporal object.
    *
-   * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code OffsetDateTime}.
+   * A {@@codeTemporalAccessor} represents some form of date and time information. This factory
+   * converts the arbitrary temporal object to an instance of {@@codeOffsetDateTime} .
    *
-   * The conversion extracts and combines {@code LocalDateTime} and {@code ZoneOffset}. If that
-   * fails it will try to extract and combine {@code Instant} and {@code ZoneOffset}.
+   * The conversion extracts and combines {@@codeLocalDateTime} and {@@codeZoneOffset} . If that
+   * fails it will try to extract and combine {@@codeInstant} and {@@codeZoneOffset} .
    *
-   * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used in queries via method reference, {@code OffsetDateTime::from}.
+   * This method matches the signature of the functional interface {@@linkTemporalQuery} allowing it
+   * to be used in queries via method reference, {@@codeOffsetDateTime::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the offset date-time, not null
    * @throws DateTimeException
-   *   if unable to convert to an { @code OffsetDateTime}
+   *   if unable to convert to an {@@codeOffsetDateTime}
    */
   def from(temporal: TemporalAccessor): OffsetDateTime =
     temporal match {
@@ -301,7 +301,7 @@ object OffsetDateTime {
     }
 
   /**
-   * Obtains an instance of {@code OffsetDateTime} from a text string such as {@code
+   * Obtains an instance of {@@codeOffsetDateTime} from a text string such as {@code
    * 2007-12-03T10:15:30+01:00}.
    *
    * The string must represent a valid date-time and is parsed using {@link
@@ -318,7 +318,7 @@ object OffsetDateTime {
     parse(text, DateTimeFormatter.ISO_OFFSET_DATE_TIME)
 
   /**
-   * Obtains an instance of {@code OffsetDateTime} from a text string using a specific formatter.
+   * Obtains an instance of {@@codeOffsetDateTime} from a text string using a specific formatter.
    *
    * The text is parsed using the formatter, returning a date-time.
    *
@@ -347,17 +347,17 @@ object OffsetDateTime {
  * A date-time with an offset from UTC/Greenwich in the ISO-8601 calendar system, such as {@code
  * 2007-12-03T10:15:30+01:00}.
  *
- * {@code OffsetDateTime} is an immutable representation of a date-time with an offset. This class
+ * {@@codeOffsetDateTime} is an immutable representation of a date-time with an offset. This class
  * stores all date and time fields, to a precision of nanoseconds, as well as the offset from
  * UTC/Greenwich. For example, the value "2nd October 2007 at 13:45.30.123456789 +02:00" can be
- * stored in an {@code OffsetDateTime}.
+ * stored in an {@@codeOffsetDateTime} .
  *
- * {@code OffsetDateTime}, {@link ZonedDateTime} and {@link Instant} all store an instant on the
- * time-line to nanosecond precision. {@code Instant} is the simplest, simply representing the
- * instant. {@code OffsetDateTime} adds to the instant the offset from UTC/Greenwich, which allows
- * the local date-time to be obtained. {@code ZonedDateTime} adds full time-zone rules.
+ * {@@codeOffsetDateTime} , {@@linkZonedDateTime} and {@@linkInstant} all store an instant on the
+ * time-line to nanosecond precision. {@@codeInstant} is the simplest, simply representing the
+ * instant. {@@codeOffsetDateTime} adds to the instant the offset from UTC/Greenwich, which allows
+ * the local date-time to be obtained. {@@codeZonedDateTime} adds full time-zone rules.
  *
- * It is intended that {@code ZonedDateTime} or {@code Instant} is used to model data in simpler
+ * It is intended that {@@codeZonedDateTime} or {@@codeInstant} is used to model data in simpler
  * applications. This class may be used when modeling date-time concepts in more detail, or when
  * communicating to a database or in a network protocol.
  *
@@ -380,7 +380,7 @@ final class OffsetDateTime private (
   Objects.requireNonNull(offset, "offset")
 
   /**
-   * Returns a new date-time based on this one, returning {@code this} where possible.
+   * Returns a new date-time based on this one, returning {@@codethis} where possible.
    *
    * @param dateTime
    *   the date-time to create with, not null
@@ -395,10 +395,10 @@ final class OffsetDateTime private (
    * Checks if the specified field is supported.
    *
    * This checks if this date-time can be queried for the specified field. If false, then calling
-   * the {@link #range(TemporalField) range} and {@link #get(TemporalField) get} methods will throw
+   * the {@@link#range(TemporalField) range} and {@@link#get(TemporalField) get} methods will throw
    * an exception.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The supported fields
+   * If the field is a {@@linkChronoField} then the query is implemented here. The supported fields
    * are: <ul> <li>{@code NANO_OF_SECOND} <li>{@code NANO_OF_DAY} <li>{@code MICRO_OF_SECOND}
    * <li>{@code MICRO_OF_DAY} <li>{@code MILLI_OF_SECOND} <li>{@code MILLI_OF_DAY} <li>{@code
    * SECOND_OF_MINUTE} <li>{@code SECOND_OF_DAY} <li>{@code MINUTE_OF_HOUR} <li>{@code
@@ -408,10 +408,10 @@ final class OffsetDateTime private (
    * <li>{@code DAY_OF_YEAR} <li>{@code EPOCH_DAY} <li>{@code ALIGNED_WEEK_OF_MONTH} <li>{@code
    * ALIGNED_WEEK_OF_YEAR} <li>{@code MONTH_OF_YEAR} <li>{@code EPOCH_MONTH} <li>{@code YEAR_OF_ERA}
    * <li>{@code YEAR} <li>{@code ERA} <li>{@code INSTANT_SECONDS} <li>{@code OFFSET_SECONDS} </ul>
-   * All other {@code ChronoField} instances will return false.
+   * All other {@@codeChronoField} instances will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.isSupportedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the field is supported is determined by the field.
    *
    * @param field
@@ -433,12 +433,12 @@ final class OffsetDateTime private (
    * used to enhance the accuracy of the returned range. If it is not possible to return the range,
    * because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return appropriate range instances. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.rangeRefinedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
    * @param field
@@ -456,21 +456,21 @@ final class OffsetDateTime private (
       field.rangeRefinedBy(this)
 
   /**
-   * Gets the value of the specified field from this date-time as an {@code int}.
+   * Gets the value of the specified field from this date-time as an {@@codeint} .
    *
    * This queries this date-time for the value for the specified field. The returned value will
    * always be within the valid range of values for the field. If it is not possible to return the
    * value, because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this date-time,
-   * except {@code NANO_OF_DAY}, {@code MICRO_OF_DAY}, {@code EPOCH_DAY}, {@code EPOCH_MONTH} and
-   * {@code INSTANT_SECONDS} which are too large to fit in an {@code int} and throw a {@code
-   * DateTimeException}. All other {@code ChronoField} instances will throw a {@code
+   * except {@@codeNANO_OF_DAY} , {@@codeMICRO_OF_DAY} , {@@codeEPOCH_DAY} , {@@codeEPOCH_MONTH} and
+   * {@@codeINSTANT_SECONDS} which are too large to fit in an {@@codeint} and throw a {@code
+   * DateTimeException}. All other {@@codeChronoField} instances will throw a {@code
    * DateTimeException}.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -495,18 +495,18 @@ final class OffsetDateTime private (
     }
 
   /**
-   * Gets the value of the specified field from this date-time as a {@code long}.
+   * Gets the value of the specified field from this date-time as a {@@codelong} .
    *
    * This queries this date-time for the value for the specified field. If it is not possible to
    * return the value, because the field is not supported or for some other reason, an exception is
    * thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this date-time.
-   * All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * All other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -541,13 +541,13 @@ final class OffsetDateTime private (
   def getOffset: ZoneOffset = offset
 
   /**
-   * Returns a copy of this {@code OffsetDateTime} with the specified offset ensuring that the
+   * Returns a copy of this {@@codeOffsetDateTime} with the specified offset ensuring that the
    * result has the same local date-time.
    *
-   * This method returns an object with the same {@code LocalDateTime} and the specified {@code
+   * This method returns an object with the same {@@codeLocalDateTime} and the specified {@code
    * ZoneOffset}. No calculation is needed or performed. For example, if this time represents {@code
-   * 2007-12-03T10:30+02:00} and the offset specified is {@code +03:00}, then this method will
-   * return {@code 2007-12-03T10:30+03:00}.
+   * 2007-12-03T10:30+02:00} and the offset specified is {@@code+03:00} , then this method will
+   * return {@@code2007-12-03T10:30+03:00} .
    *
    * To take into account the difference between the offsets, and adjust the time fields, use {@link
    * #withOffsetSameInstant}.
@@ -557,28 +557,28 @@ final class OffsetDateTime private (
    * @param offset
    *   the zone offset to change to, not null
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the requested offset, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the requested offset, not null
    */
   def withOffsetSameLocal(offset: ZoneOffset): OffsetDateTime = `with`(dateTime, offset)
 
   /**
-   * Returns a copy of this {@code OffsetDateTime} with the specified offset ensuring that the
+   * Returns a copy of this {@@codeOffsetDateTime} with the specified offset ensuring that the
    * result is at the same instant.
    *
-   * This method returns an object with the specified {@code ZoneOffset} and a {@code LocalDateTime}
+   * This method returns an object with the specified {@@codeZoneOffset} and a {@@codeLocalDateTime}
    * adjusted by the difference between the two offsets. This will result in the old and new objects
    * representing the same instant. This is useful for finding the local time in a different offset.
-   * For example, if this time represents {@code 2007-12-03T10:30+02:00} and the offset specified is
-   * {@code +03:00}, then this method will return {@code 2007-12-03T11:30+03:00}.
+   * For example, if this time represents {@@code2007-12-03T10:30+02:00} and the offset specified is
+   * {@@code+03:00} , then this method will return {@@code2007-12-03T11:30+03:00} .
    *
-   * To change the offset without adjusting the local time use {@link #withOffsetSameLocal}.
+   * To change the offset without adjusting the local time use {@@link#withOffsetSameLocal} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param offset
    *   the zone offset to change to, not null
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the requested offset, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the requested offset, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -593,10 +593,10 @@ final class OffsetDateTime private (
   /**
    * Gets the year field.
    *
-   * This method returns the primitive {@code int} value for the year.
+   * This method returns the primitive {@@codeint} value for the year.
    *
-   * The year returned by this method is proleptic as per {@code get(YEAR)}. To obtain the
-   * year-of-era, use {@code get(YEAR_OF_ERA}.
+   * The year returned by this method is proleptic as per {@@codeget(YEAR)} . To obtain the
+   * year-of-era, use {@@codeget(YEAR_OF_ERA} .
    *
    * @return
    *   the year, from MIN_YEAR to MAX_YEAR
@@ -606,8 +606,8 @@ final class OffsetDateTime private (
   /**
    * Gets the month-of-year field from 1 to 12.
    *
-   * This method returns the month as an {@code int} from 1 to 12. Application code is frequently
-   * clearer if the enum {@link Month} is used by calling {@link #getMonth()}.
+   * This method returns the month as an {@@codeint} from 1 to 12. Application code is frequently
+   * clearer if the enum {@@linkMonth} is used by calling {@@link#getMonth()} .
    *
    * @return
    *   the month-of-year, from 1 to 12
@@ -617,11 +617,11 @@ final class OffsetDateTime private (
   def getMonthValue: Int = dateTime.getMonthValue
 
   /**
-   * Gets the month-of-year field using the {@code Month} enum.
+   * Gets the month-of-year field using the {@@codeMonth} enum.
    *
-   * This method returns the enum {@link Month} for the month. This avoids confusion as to what
-   * {@code int} values mean. If you need access to the primitive {@code int} value then the enum
-   * provides the {@link Month#getValue() int value}.
+   * This method returns the enum {@@linkMonth} for the month. This avoids confusion as to what
+   * {@@codeint} values mean. If you need access to the primitive {@@codeint} value then the enum
+   * provides the {@@linkMonth#getValue() int value} .
    *
    * @return
    *   the month-of-year, not null
@@ -633,7 +633,7 @@ final class OffsetDateTime private (
   /**
    * Gets the day-of-month field.
    *
-   * This method returns the primitive {@code int} value for the day-of-month.
+   * This method returns the primitive {@@codeint} value for the day-of-month.
    *
    * @return
    *   the day-of-month, from 1 to 31
@@ -643,7 +643,7 @@ final class OffsetDateTime private (
   /**
    * Gets the day-of-year field.
    *
-   * This method returns the primitive {@code int} value for the day-of-year.
+   * This method returns the primitive {@@codeint} value for the day-of-year.
    *
    * @return
    *   the day-of-year, from 1 to 365, or 366 in a leap year
@@ -651,13 +651,13 @@ final class OffsetDateTime private (
   def getDayOfYear: Int = dateTime.getDayOfYear
 
   /**
-   * Gets the day-of-week field, which is an enum {@code DayOfWeek}.
+   * Gets the day-of-week field, which is an enum {@@codeDayOfWeek} .
    *
-   * This method returns the enum {@link DayOfWeek} for the day-of-week. This avoids confusion as to
-   * what {@code int} values mean. If you need access to the primitive {@code int} value then the
-   * enum provides the {@link DayOfWeek#getValue() int value}.
+   * This method returns the enum {@@linkDayOfWeek} for the day-of-week. This avoids confusion as to
+   * what {@@codeint} values mean. If you need access to the primitive {@@codeint} value then the
+   * enum provides the {@@linkDayOfWeek#getValue() int value} .
    *
-   * Additional information can be obtained from the {@code DayOfWeek}. This includes textual names
+   * Additional information can be obtained from the {@@codeDayOfWeek} . This includes textual names
    * of the values.
    *
    * @return
@@ -700,15 +700,15 @@ final class OffsetDateTime private (
   /**
    * Returns an adjusted copy of this date-time.
    *
-   * This returns a new {@code OffsetDateTime}, based on this one, with the date-time adjusted. The
+   * This returns a new {@@codeOffsetDateTime} , based on this one, with the date-time adjusted. The
    * adjustment takes place using the specified adjuster strategy object. Read the documentation of
    * the adjuster to understand what adjustment will be made.
    *
    * A simple adjuster might simply set the one of the fields, such as the year field. A more
    * complex adjuster might set the date to the last day of the month. A selection of common
-   * adjustments is provided in {@link TemporalAdjusters}. These include finding the "last day of
+   * adjustments is provided in {@@linkTemporalAdjusters} . These include finding the "last day of
    * the month" and "next Wednesday". Key date-time classes also implement the {@code
-   * TemporalAdjuster} interface, such as {@link Month} and {@link MonthDay}. The adjuster is
+   * TemporalAdjuster} interface, such as {@@linkMonth} and {@@linkMonthDay} . The adjuster is
    * responsible for handling special cases, such as the varying lengths of month and leap years.
    *
    * For example this code returns a date on the last day of July: <pre> import static
@@ -716,13 +716,13 @@ final class OffsetDateTime private (
    *
    * result = offsetDateTime.with(JULY).with(lastDayOfMonth()); </pre>
    *
-   * The classes {@link LocalDate}, {@link LocalTime} and {@link ZoneOffset} implement {@code
+   * The classes {@@linkLocalDate} , {@@linkLocalTime} and {@@linkZoneOffset} implement {@code
    * TemporalAdjuster}, thus this method can be used to change the date, time or offset: <pre>
    * result = offsetDateTime.with(date); result = offsetDateTime.with(time); result =
    * offsetDateTime.with(offset); </pre>
    *
    * The result of this method is obtained by invoking the {@link
-   * TemporalAdjuster#adjustInto(Temporal)} method on the specified adjuster passing {@code this} as
+   * TemporalAdjuster#adjustInto(Temporal)} method on the specified adjuster passing {@@codethis} as
    * the argument.
    *
    * This instance is immutable and unaffected by this method call.
@@ -730,7 +730,7 @@ final class OffsetDateTime private (
    * @param adjuster
    *   the adjuster to use, not null
    * @return
-   *   an { @code OffsetDateTime} based on { @code this} with the adjustment made, not null
+   *   an {@@codeOffsetDateTime} based on {@@codethis} with the adjustment made, not null
    * @throws DateTimeException
    *   if the adjustment cannot be made
    * @throws ArithmeticException
@@ -750,7 +750,7 @@ final class OffsetDateTime private (
   /**
    * Returns a copy of this date-time with the specified field set to a new value.
    *
-   * This returns a new {@code OffsetDateTime}, based on this one, with the value for the specified
+   * This returns a new {@@codeOffsetDateTime} , based on this one, with the value for the specified
    * field changed. This can be used to change any supported field, such as the year, month or
    * day-of-month. If it is not possible to set the value, because the field is not supported or for
    * some other reason, an exception is thrown.
@@ -760,24 +760,24 @@ final class OffsetDateTime private (
    * invalid. In cases like this, the field is responsible for resolving the date. Typically it will
    * choose the previous valid date, which would be the last valid day of February in this example.
    *
-   * If the field is a {@link ChronoField} then the adjustment is implemented here.
+   * If the field is a {@@linkChronoField} then the adjustment is implemented here.
    *
-   * The {@code INSTANT_SECONDS} field will return a date-time with the specified instant. The
+   * The {@@codeINSTANT_SECONDS} field will return a date-time with the specified instant. The
    * offset and nano-of-second are unchanged. If the new instant value is outside the valid range
-   * then a {@code DateTimeException} will be thrown.
+   * then a {@@codeDateTimeException} will be thrown.
    *
-   * The {@code OFFSET_SECONDS} field will return a date-time with the specified offset. The local
+   * The {@@codeOFFSET_SECONDS} field will return a date-time with the specified offset. The local
    * date-time is unaltered. If the new offset value is outside the valid range then a {@code
    * DateTimeException} will be thrown.
    *
-   * The other {@link #isSupported(TemporalField) supported fields} will behave as per the matching
-   * method on {@link LocalDateTime#with(TemporalField, long) LocalDateTime}. In this case, the
+   * The other {@@link#isSupported(TemporalField) supported fields} will behave as per the matching
+   * method on {@@linkLocalDateTime#with(TemporalField, long) LocalDateTime} . In this case, the
    * offset is not part of the calculation and will be unchanged.
    *
-   * All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * All other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.adjustInto(Temporal, long)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.adjustInto(Temporal, long)} passing {@@codethis} as the argument.
    * In this case, the field determines whether and how to adjust the instant.
    *
    * This instance is immutable and unaffected by this method call.
@@ -787,7 +787,7 @@ final class OffsetDateTime private (
    * @param newValue
    *   the new value of the field in the result
    * @return
-   *   an { @code OffsetDateTime} based on { @code this} with the specified field set, not null
+   *   an {@@codeOffsetDateTime} based on {@@codethis} with the specified field set, not null
    * @throws DateTimeException
    *   if the field cannot be set
    * @throws ArithmeticException
@@ -808,7 +808,7 @@ final class OffsetDateTime private (
     }
 
   /**
-   * Returns a copy of this {@code OffsetDateTime} with the year altered. The offset does not affect
+   * Returns a copy of this {@@codeOffsetDateTime} with the year altered. The offset does not affect
    * the calculation and will be the same in the result. If the day-of-month is invalid for the
    * year, it will be changed to the last valid day of the month.
    *
@@ -817,14 +817,14 @@ final class OffsetDateTime private (
    * @param year
    *   the year to set in the result, from MIN_YEAR to MAX_YEAR
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the requested year, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the requested year, not null
    * @throws DateTimeException
    *   if the year value is invalid
    */
   def withYear(year: Int): OffsetDateTime = `with`(dateTime.withYear(year), offset)
 
   /**
-   * Returns a copy of this {@code OffsetDateTime} with the month-of-year altered. The offset does
+   * Returns a copy of this {@@codeOffsetDateTime} with the month-of-year altered. The offset does
    * not affect the calculation and will be the same in the result. If the day-of-month is invalid
    * for the year, it will be changed to the last valid day of the month.
    *
@@ -833,15 +833,15 @@ final class OffsetDateTime private (
    * @param month
    *   the month-of-year to set in the result, from 1 (January) to 12 (December)
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the requested month, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the requested month, not null
    * @throws DateTimeException
    *   if the month-of-year value is invalid
    */
   def withMonth(month: Int): OffsetDateTime = `with`(dateTime.withMonth(month), offset)
 
   /**
-   * Returns a copy of this {@code OffsetDateTime} with the day-of-month altered. If the resulting
-   * {@code OffsetDateTime} is invalid, an exception is thrown. The offset does not affect the
+   * Returns a copy of this {@@codeOffsetDateTime} with the day-of-month altered. If the resulting
+   * {@@codeOffsetDateTime} is invalid, an exception is thrown. The offset does not affect the
    * calculation and will be the same in the result.
    *
    * This instance is immutable and unaffected by this method call.
@@ -849,7 +849,7 @@ final class OffsetDateTime private (
    * @param dayOfMonth
    *   the day-of-month to set in the result, from 1 to 28-31
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the requested day, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the requested day, not null
    * @throws DateTimeException
    *   if the day-of-month value is invalid
    * @throws DateTimeException
@@ -859,15 +859,15 @@ final class OffsetDateTime private (
     `with`(dateTime.withDayOfMonth(dayOfMonth), offset)
 
   /**
-   * Returns a copy of this {@code OffsetDateTime} with the day-of-year altered. If the resulting
-   * {@code OffsetDateTime} is invalid, an exception is thrown.
+   * Returns a copy of this {@@codeOffsetDateTime} with the day-of-year altered. If the resulting
+   * {@@codeOffsetDateTime} is invalid, an exception is thrown.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param dayOfYear
    *   the day-of-year to set in the result, from 1 to 365-366
    * @return
-   *   an { @code OffsetDateTime} based on this date with the requested day, not null
+   *   an {@@codeOffsetDateTime} based on this date with the requested day, not null
    * @throws DateTimeException
    *   if the day-of-year value is invalid
    * @throws DateTimeException
@@ -877,7 +877,7 @@ final class OffsetDateTime private (
     `with`(dateTime.withDayOfYear(dayOfYear), offset)
 
   /**
-   * Returns a copy of this {@code OffsetDateTime} with the hour-of-day value altered.
+   * Returns a copy of this {@@codeOffsetDateTime} with the hour-of-day value altered.
    *
    * The offset does not affect the calculation and will be the same in the result.
    *
@@ -886,14 +886,14 @@ final class OffsetDateTime private (
    * @param hour
    *   the hour-of-day to set in the result, from 0 to 23
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the requested hour, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the requested hour, not null
    * @throws DateTimeException
    *   if the hour value is invalid
    */
   def withHour(hour: Int): OffsetDateTime = `with`(dateTime.withHour(hour), offset)
 
   /**
-   * Returns a copy of this {@code OffsetDateTime} with the minute-of-hour value altered.
+   * Returns a copy of this {@@codeOffsetDateTime} with the minute-of-hour value altered.
    *
    * The offset does not affect the calculation and will be the same in the result.
    *
@@ -902,14 +902,14 @@ final class OffsetDateTime private (
    * @param minute
    *   the minute-of-hour to set in the result, from 0 to 59
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the requested minute, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the requested minute, not null
    * @throws DateTimeException
    *   if the minute value is invalid
    */
   def withMinute(minute: Int): OffsetDateTime = `with`(dateTime.withMinute(minute), offset)
 
   /**
-   * Returns a copy of this {@code OffsetDateTime} with the second-of-minute value altered.
+   * Returns a copy of this {@@codeOffsetDateTime} with the second-of-minute value altered.
    *
    * The offset does not affect the calculation and will be the same in the result.
    *
@@ -918,14 +918,14 @@ final class OffsetDateTime private (
    * @param second
    *   the second-of-minute to set in the result, from 0 to 59
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the requested second, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the requested second, not null
    * @throws DateTimeException
    *   if the second value is invalid
    */
   def withSecond(second: Int): OffsetDateTime = `with`(dateTime.withSecond(second), offset)
 
   /**
-   * Returns a copy of this {@code OffsetDateTime} with the nano-of-second value altered.
+   * Returns a copy of this {@@codeOffsetDateTime} with the nano-of-second value altered.
    *
    * The offset does not affect the calculation and will be the same in the result.
    *
@@ -934,22 +934,22 @@ final class OffsetDateTime private (
    * @param nanoOfSecond
    *   the nano-of-second to set in the result, from 0 to 999,999,999
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the requested nanosecond, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the requested nanosecond, not null
    * @throws DateTimeException
    *   if the nanos value is invalid
    */
   def withNano(nanoOfSecond: Int): OffsetDateTime = `with`(dateTime.withNano(nanoOfSecond), offset)
 
   /**
-   * Returns a copy of this {@code OffsetDateTime} with the time truncated.
+   * Returns a copy of this {@@codeOffsetDateTime} with the time truncated.
    *
    * Truncation returns a copy of the original date-time with fields smaller than the specified unit
-   * set to zero. For example, truncating with the {@link ChronoUnit#MINUTES minutes} unit will set
+   * set to zero. For example, truncating with the {@@linkChronoUnit#MINUTES minutes} unit will set
    * the second-of-minute and nano-of-second field to zero.
    *
-   * The unit must have a {@linkplain TemporalUnit#getDuration() duration} that divides into the
+   * The unit must have a {@@linkplainTemporalUnit#getDuration() duration} that divides into the
    * length of a standard day without remainder. This includes all supplied time units on {@link
-   * ChronoUnit} and {@link ChronoUnit#DAYS DAYS}. Other units throw an exception.
+   * ChronoUnit} and {@@linkChronoUnit#DAYS DAYS} . Other units throw an exception.
    *
    * The offset does not affect the calculation and will be the same in the result.
    *
@@ -958,7 +958,7 @@ final class OffsetDateTime private (
    * @param unit
    *   the unit to truncate to, not null
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the time truncated, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the time truncated, not null
    * @throws DateTimeException
    *   if unable to truncate
    */
@@ -968,9 +968,9 @@ final class OffsetDateTime private (
    * Returns a copy of this date-time with the specified period added.
    *
    * This method returns a new date-time based on this time with the specified period added. The
-   * amount is typically {@link Period} but may be any other type implementing the {@link
+   * amount is typically {@@linkPeriod} but may be any other type implementing the {@link
    * TemporalAmount} interface. The calculation is delegated to the specified adjuster, which
-   * typically calls back to {@link #plus(long, TemporalUnit)}. The offset is not part of the
+   * typically calls back to {@@link#plus(long, TemporalUnit)} . The offset is not part of the
    * calculation and will be unchanged in the result.
    *
    * This instance is immutable and unaffected by this method call.
@@ -978,7 +978,7 @@ final class OffsetDateTime private (
    * @param amount
    *   the amount to add, not null
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the addition made, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the addition made, not null
    * @throws DateTimeException
    *   if the addition cannot be made
    * @throws ArithmeticException
@@ -1003,7 +1003,7 @@ final class OffsetDateTime private (
    * @param unit
    *   the unit of the period to add, not null
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the specified period added, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the specified period added, not null
    * @throws DateTimeException
    *   if the unit cannot be added to this type
    */
@@ -1012,7 +1012,7 @@ final class OffsetDateTime private (
     else unit.addTo(this, amountToAdd)
 
   /**
-   * Returns a copy of this {@code OffsetDateTime} with the specified period in years added.
+   * Returns a copy of this {@@codeOffsetDateTime} with the specified period in years added.
    *
    * This method adds the specified amount to the years field in three steps: <ol> <li>Add the input
    * years to the year field</li> <li>Check if the resulting date would be invalid</li> <li>Adjust
@@ -1027,14 +1027,14 @@ final class OffsetDateTime private (
    * @param years
    *   the years to add, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the years added, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the years added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
   def plusYears(years: Long): OffsetDateTime = `with`(dateTime.plusYears(years), offset)
 
   /**
-   * Returns a copy of this {@code OffsetDateTime} with the specified period in months added.
+   * Returns a copy of this {@@codeOffsetDateTime} with the specified period in months added.
    *
    * This method adds the specified amount to the months field in three steps: <ol> <li>Add the
    * input months to the month-of-year field</li> <li>Check if the resulting date would be
@@ -1048,7 +1048,7 @@ final class OffsetDateTime private (
    * @param months
    *   the months to add, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the months added, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the months added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1068,7 +1068,7 @@ final class OffsetDateTime private (
    * @param weeks
    *   the weeks to add, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the weeks added, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the weeks added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1088,63 +1088,63 @@ final class OffsetDateTime private (
    * @param days
    *   the days to add, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the days added, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the days added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
   def plusDays(days: Long): OffsetDateTime = `with`(dateTime.plusDays(days), offset)
 
   /**
-   * Returns a copy of this {@code OffsetDateTime} with the specified period in hours added.
+   * Returns a copy of this {@@codeOffsetDateTime} with the specified period in hours added.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param hours
    *   the hours to add, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the hours added, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the hours added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
   def plusHours(hours: Long): OffsetDateTime = `with`(dateTime.plusHours(hours), offset)
 
   /**
-   * Returns a copy of this {@code OffsetDateTime} with the specified period in minutes added.
+   * Returns a copy of this {@@codeOffsetDateTime} with the specified period in minutes added.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param minutes
    *   the minutes to add, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the minutes added, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the minutes added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
   def plusMinutes(minutes: Long): OffsetDateTime = `with`(dateTime.plusMinutes(minutes), offset)
 
   /**
-   * Returns a copy of this {@code OffsetDateTime} with the specified period in seconds added.
+   * Returns a copy of this {@@codeOffsetDateTime} with the specified period in seconds added.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param seconds
    *   the seconds to add, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the seconds added, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the seconds added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
   def plusSeconds(seconds: Long): OffsetDateTime = `with`(dateTime.plusSeconds(seconds), offset)
 
   /**
-   * Returns a copy of this {@code OffsetDateTime} with the specified period in nanoseconds added.
+   * Returns a copy of this {@@codeOffsetDateTime} with the specified period in nanoseconds added.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param nanos
    *   the nanos to add, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the nanoseconds added, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the nanoseconds added, not null
    * @throws DateTimeException
    *   if the unit cannot be added to this type
    */
@@ -1154,9 +1154,9 @@ final class OffsetDateTime private (
    * Returns a copy of this date-time with the specified period subtracted.
    *
    * This method returns a new date-time based on this time with the specified period subtracted.
-   * The amount is typically {@link Period} but may be any other type implementing the {@link
+   * The amount is typically {@@linkPeriod} but may be any other type implementing the {@link
    * TemporalAmount} interface. The calculation is delegated to the specified adjuster, which
-   * typically calls back to {@link #minus(long, TemporalUnit)}. The offset is not part of the
+   * typically calls back to {@@link#minus(long, TemporalUnit)} . The offset is not part of the
    * calculation and will be unchanged in the result.
    *
    * This instance is immutable and unaffected by this method call.
@@ -1164,7 +1164,7 @@ final class OffsetDateTime private (
    * @param amount
    *   the amount to subtract, not null
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the subtraction made, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the subtraction made, not null
    * @throws DateTimeException
    *   if the subtraction cannot be made
    * @throws ArithmeticException
@@ -1189,7 +1189,7 @@ final class OffsetDateTime private (
    * @param unit
    *   the unit of the period to subtract, not null
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the specified period subtracted, not
+   *   an {@@codeOffsetDateTime} based on this date-time with the specified period subtracted, not
    *   null
    */
   override def minus(amountToSubtract: Long, unit: TemporalUnit): OffsetDateTime =
@@ -1197,7 +1197,7 @@ final class OffsetDateTime private (
     else plus(-amountToSubtract, unit)
 
   /**
-   * Returns a copy of this {@code OffsetDateTime} with the specified period in years subtracted.
+   * Returns a copy of this {@@codeOffsetDateTime} with the specified period in years subtracted.
    *
    * This method subtracts the specified amount from the years field in three steps: <ol>
    * <li>Subtract the input years to the year field</li> <li>Check if the resulting date would be
@@ -1212,7 +1212,7 @@ final class OffsetDateTime private (
    * @param years
    *   the years to subtract, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the years subtracted, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the years subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1221,7 +1221,7 @@ final class OffsetDateTime private (
     else plusYears(-years)
 
   /**
-   * Returns a copy of this {@code OffsetDateTime} with the specified period in months subtracted.
+   * Returns a copy of this {@@codeOffsetDateTime} with the specified period in months subtracted.
    *
    * This method subtracts the specified amount from the months field in three steps: <ol>
    * <li>Subtract the input months to the month-of-year field</li> <li>Check if the resulting date
@@ -1235,7 +1235,7 @@ final class OffsetDateTime private (
    * @param months
    *   the months to subtract, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the months subtracted, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the months subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1244,7 +1244,7 @@ final class OffsetDateTime private (
     else plusMonths(-months)
 
   /**
-   * Returns a copy of this {@code OffsetDateTime} with the specified period in weeks subtracted.
+   * Returns a copy of this {@@codeOffsetDateTime} with the specified period in weeks subtracted.
    *
    * This method subtracts the specified amount in weeks from the days field decrementing the month
    * and year fields as necessary to ensure the result remains valid. The result is only invalid if
@@ -1257,7 +1257,7 @@ final class OffsetDateTime private (
    * @param weeks
    *   the weeks to subtract, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the weeks subtracted, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the weeks subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1266,7 +1266,7 @@ final class OffsetDateTime private (
     else plusWeeks(-weeks)
 
   /**
-   * Returns a copy of this {@code OffsetDateTime} with the specified period in days subtracted.
+   * Returns a copy of this {@@codeOffsetDateTime} with the specified period in days subtracted.
    *
    * This method subtracts the specified amount from the days field incrementing the month and year
    * fields as necessary to ensure the result remains valid. The result is only invalid if the
@@ -1279,7 +1279,7 @@ final class OffsetDateTime private (
    * @param days
    *   the days to subtract, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the days subtracted, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the days subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1288,14 +1288,14 @@ final class OffsetDateTime private (
     else plusDays(-days)
 
   /**
-   * Returns a copy of this {@code OffsetDateTime} with the specified period in hours subtracted.
+   * Returns a copy of this {@@codeOffsetDateTime} with the specified period in hours subtracted.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param hours
    *   the hours to subtract, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the hours subtracted, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the hours subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1304,14 +1304,14 @@ final class OffsetDateTime private (
     else plusHours(-hours)
 
   /**
-   * Returns a copy of this {@code OffsetDateTime} with the specified period in minutes subtracted.
+   * Returns a copy of this {@@codeOffsetDateTime} with the specified period in minutes subtracted.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param minutes
    *   the minutes to subtract, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the minutes subtracted, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the minutes subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1320,14 +1320,14 @@ final class OffsetDateTime private (
     else plusMinutes(-minutes)
 
   /**
-   * Returns a copy of this {@code OffsetDateTime} with the specified period in seconds subtracted.
+   * Returns a copy of this {@@codeOffsetDateTime} with the specified period in seconds subtracted.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param seconds
    *   the seconds to subtract, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the seconds subtracted, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the seconds subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1336,7 +1336,7 @@ final class OffsetDateTime private (
     else plusSeconds(-seconds)
 
   /**
-   * Returns a copy of this {@code OffsetDateTime} with the specified period in nanoseconds
+   * Returns a copy of this {@@codeOffsetDateTime} with the specified period in nanoseconds
    * subtracted.
    *
    * This instance is immutable and unaffected by this method call.
@@ -1344,7 +1344,7 @@ final class OffsetDateTime private (
    * @param nanos
    *   the nanos to subtract, may be negative
    * @return
-   *   an { @code OffsetDateTime} based on this date-time with the nanoseconds subtracted, not null
+   *   an {@@codeOffsetDateTime} based on this date-time with the nanoseconds subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1360,7 +1360,7 @@ final class OffsetDateTime private (
    * of the query to understand what the result of this method will be.
    *
    * The result of this method is obtained by invoking the {@link
-   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@code this}
+   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@@codethis}
    * as the argument.
    *
    * @tparam R
@@ -1391,8 +1391,8 @@ final class OffsetDateTime private (
    * This returns a temporal object of the same observable type as the input with the offset, date
    * and time changed to be the same as this.
    *
-   * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)} three times,
-   * passing {@link ChronoField#EPOCH_DAY}, {@link ChronoField#NANO_OF_DAY} and {@link
+   * The adjustment is equivalent to using {@@linkTemporal#with(TemporalField, long)} three times,
+   * passing {@@linkChronoField#EPOCH_DAY} , {@@linkChronoField#NANO_OF_DAY} and {@link
    * ChronoField#OFFSET_SECONDS} as the fields.
    *
    * In most cases, it is clearer to reverse the calling pattern by using {@link
@@ -1422,11 +1422,11 @@ final class OffsetDateTime private (
    * unit.
    *
    * This calculates the period between two date-times in terms of a single unit. The start and end
-   * points are {@code this} and the specified date-time. The result will be negative if the end is
+   * points are {@@codethis} and the specified date-time. The result will be negative if the end is
    * before the start. For example, the period in days between two date-times can be calculated
-   * using {@code startDateTime.until(endDateTime, DAYS)}.
+   * using {@@codestartDateTime.until(endDateTime, DAYS)} .
    *
-   * The {@code Temporal} passed to this method must be an {@code OffsetDateTime}. If the offset
+   * The {@@codeTemporal} passed to this method must be an {@@codeOffsetDateTime} . If the offset
    * differs between the two date-times, the specified end date-time is normalized to have the same
    * offset as this date-time.
    *
@@ -1434,26 +1434,26 @@ final class OffsetDateTime private (
    * two date-times. For example, the period in months between 2012-06-15T00:00Z and
    * 2012-08-14T23:59Z will only be one month as it is one minute short of two months.
    *
-   * This method operates in association with {@link TemporalUnit#between}. The result of this
-   * method is a {@code long} representing the amount of the specified unit. By contrast, the result
-   * of {@code between} is an object that can be used directly in addition/subtraction: <pre> long
+   * This method operates in association with {@@linkTemporalUnit#between} . The result of this
+   * method is a {@@codelong} representing the amount of the specified unit. By contrast, the result
+   * of {@@codebetween} is an object that can be used directly in addition/subtraction: <pre> long
    * period = start.until(end, MONTHS); // this method dateTime.plus(MONTHS.between(start, end)); //
    * use in plus/minus </pre>
    *
-   * The calculation is implemented in this method for {@link ChronoUnit}. The units {@code NANOS},
-   * {@code MICROS}, {@code MILLIS}, {@code SECONDS}, {@code MINUTES}, {@code HOURS} and {@code
-   * HALF_DAYS}, {@code DAYS}, {@code WEEKS}, {@code MONTHS}, {@code YEARS}, {@code DECADES}, {@code
-   * CENTURIES}, {@code MILLENNIA} and {@code ERAS} are supported. Other {@code ChronoUnit} values
-   * will throw an exception.
+   * The calculation is implemented in this method for {@@linkChronoUnit} . The units {@@codeNANOS}
+   * , {@@codeMICROS} , {@@codeMILLIS} , {@@codeSECONDS} , {@@codeMINUTES} , {@@codeHOURS} and
+   * {@code HALF_DAYS}, {@@codeDAYS} , {@@codeWEEKS} , {@@codeMONTHS} , {@@codeYEARS} ,
+   * {@@codeDECADES} , {@code CENTURIES}, {@@codeMILLENNIA} and {@@codeERAS} are supported. Other
+   * {@@codeChronoUnit} values will throw an exception.
    *
-   * If the unit is not a {@code ChronoUnit}, then the result of this method is obtained by invoking
-   * {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first argument and
-   * the input temporal as the second argument.
+   * If the unit is not a {@@codeChronoUnit} , then the result of this method is obtained by
+   * invoking {@@codeTemporalUnit.between(Temporal, Temporal)} passing {@@codethis} as the first
+   * argument and the input temporal as the second argument.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param endExclusive
-   *   the end date-time, which is converted to an { @code OffsetDateTime}, not null
+   *   the end date-time, which is converted to an {@@codeOffsetDateTime} , not null
    * @param unit
    *   the unit to measure the period in, not null
    * @return
@@ -1473,16 +1473,16 @@ final class OffsetDateTime private (
   }
 
   /**
-   * Combines this date-time with a time-zone to create a {@code ZonedDateTime} ensuring that the
+   * Combines this date-time with a time-zone to create a {@@codeZonedDateTime} ensuring that the
    * result has the same instant.
    *
-   * This returns a {@code ZonedDateTime} formed from this date-time and the specified time-zone.
+   * This returns a {@@codeZonedDateTime} formed from this date-time and the specified time-zone.
    * This conversion will ignore the visible local date-time and use the underlying instant instead.
    * This avoids any problems with local time-line gaps or overlaps. The result might have different
    * values for fields such as hour, minute an even day.
    *
-   * To attempt to retain the values of the fields, use {@link #atZoneSimilarLocal(ZoneId)}. To use
-   * the offset as the zone ID, use {@link #toZonedDateTime()}.
+   * To attempt to retain the values of the fields, use {@@link#atZoneSimilarLocal(ZoneId)} . To use
+   * the offset as the zone ID, use {@@link#toZonedDateTime()} .
    *
    * @param zone
    *   the time-zone to use, not null
@@ -1493,10 +1493,10 @@ final class OffsetDateTime private (
     ZonedDateTime.ofInstant(dateTime, offset, zone)
 
   /**
-   * Combines this date-time with a time-zone to create a {@code ZonedDateTime} trying to keep the
+   * Combines this date-time with a time-zone to create a {@@codeZonedDateTime} trying to keep the
    * same local date and time.
    *
-   * This returns a {@code ZonedDateTime} formed from this date-time and the specified time-zone.
+   * This returns a {@@codeZonedDateTime} formed from this date-time and the specified time-zone.
    * Where possible, the result will have the same local date-time as this object.
    *
    * Time-zone rules, such as daylight savings, mean that not every time on the local time-line
@@ -1506,11 +1506,11 @@ final class OffsetDateTime private (
    * instance if possible.
    *
    * Finer control over gaps and overlaps is available in two ways. If you simply want to use the
-   * later offset at overlaps then call {@link ZonedDateTime#withLaterOffsetAtOverlap()} immediately
+   * later offset at overlaps then call {@@linkZonedDateTime#withLaterOffsetAtOverlap()} immediately
    * after this method.
    *
    * To create a zoned date-time at the same instant irrespective of the local time-line, use {@link
-   * #atZoneSameInstant(ZoneId)}. To use the offset as the zone ID, use {@link #toZonedDateTime()}.
+   * #atZoneSameInstant(ZoneId)}. To use the offset as the zone ID, use {@@link#toZonedDateTime()} .
    *
    * @param zone
    *   the time-zone to use, not null
@@ -1521,9 +1521,9 @@ final class OffsetDateTime private (
     ZonedDateTime.ofLocal(dateTime, zone, offset)
 
   /**
-   * Gets the {@code LocalDateTime} part of this offset date-time.
+   * Gets the {@@codeLocalDateTime} part of this offset date-time.
    *
-   * This returns a {@code LocalDateTime} with the same year, month, day and time as this date-time.
+   * This returns a {@@codeLocalDateTime} with the same year, month, day and time as this date-time.
    *
    * @return
    *   the local date-time part of this date-time, not null
@@ -1531,9 +1531,9 @@ final class OffsetDateTime private (
   def toLocalDateTime: LocalDateTime = dateTime
 
   /**
-   * Gets the {@code LocalDate} part of this date-time.
+   * Gets the {@@codeLocalDate} part of this date-time.
    *
-   * This returns a {@code LocalDate} with the same year, month and day as this date-time.
+   * This returns a {@@codeLocalDate} with the same year, month and day as this date-time.
    *
    * @return
    *   the date part of this date-time, not null
@@ -1541,9 +1541,9 @@ final class OffsetDateTime private (
   def toLocalDate: LocalDate = dateTime.toLocalDate
 
   /**
-   * Gets the {@code LocalTime} part of this date-time.
+   * Gets the {@@codeLocalTime} part of this date-time.
    *
-   * This returns a {@code LocalTime} with the same hour, minute, second and nanosecond as this
+   * This returns a {@@codeLocalTime} with the same hour, minute, second and nanosecond as this
    * date-time.
    *
    * @return
@@ -1552,7 +1552,7 @@ final class OffsetDateTime private (
   def toLocalTime: LocalTime = dateTime.toLocalTime
 
   /**
-   * Converts this date-time to an {@code OffsetTime}.
+   * Converts this date-time to an {@@codeOffsetTime} .
    *
    * This returns an offset time with the same local time and offset.
    *
@@ -1562,11 +1562,11 @@ final class OffsetDateTime private (
   def toOffsetTime: OffsetTime = OffsetTime.of(dateTime.toLocalTime, offset)
 
   /**
-   * Converts this date-time to a {@code ZonedDateTime} using the offset as the zone ID.
+   * Converts this date-time to a {@@codeZonedDateTime} using the offset as the zone ID.
    *
-   * This creates the simplest possible {@code ZonedDateTime} using the offset as the zone ID.
+   * This creates the simplest possible {@@codeZonedDateTime} using the offset as the zone ID.
    *
-   * To control the time-zone used, see {@link #atZoneSameInstant(ZoneId)} and {@link
+   * To control the time-zone used, see {@@link#atZoneSameInstant(ZoneId)} and {@link
    * #atZoneSimilarLocal(ZoneId)}.
    *
    * @return
@@ -1575,10 +1575,10 @@ final class OffsetDateTime private (
   def toZonedDateTime: ZonedDateTime = ZonedDateTime.of(dateTime, offset)
 
   /**
-   * Converts this date-time to an {@code Instant}.
+   * Converts this date-time to an {@@codeInstant} .
    *
    * @return
-   *   an { @code Instant} representing the same instant, not null
+   *   an {@@codeInstant} representing the same instant, not null
    */
   def toInstant: Instant = dateTime.toInstant(offset)
 
@@ -1595,10 +1595,10 @@ final class OffsetDateTime private (
   def toEpochSecond: Long = dateTime.toEpochSecond(offset)
 
   /**
-   * Compares this {@code OffsetDateTime} to another date-time.
+   * Compares this {@@codeOffsetDateTime} to another date-time.
    *
    * The comparison is based on the instant then on the local date-time. It is "consistent with
-   * equals", as defined by {@link Comparable}.
+   * equals", as defined by {@@linkComparable} .
    *
    * For example, the following is the comparator order: <ol> <li>{@code
    * 2008-12-03T10:30+01:00}</li> <li>{@code 2008-12-03T11:00+01:00}</li> <li>{@code
@@ -1606,7 +1606,7 @@ final class OffsetDateTime private (
    * 2008-12-03T12:00+01:00}</li> <li>{@code 2008-12-03T12:30+01:00}</li> </ol> Values #2 and #3
    * represent the same instant on the time-line. When two values represent the same instant, the
    * local date-time is compared to distinguish them. This step is needed to make the ordering
-   * consistent with {@code equals()}.
+   * consistent with {@@codeequals()} .
    *
    * @param other
    *   the other date-time to compare to, not null
@@ -1630,7 +1630,7 @@ final class OffsetDateTime private (
   /**
    * Checks if the instant of this date-time is after that of the specified date-time.
    *
-   * This method differs from the comparison in {@link #compareTo} and {@link #equals} in that it
+   * This method differs from the comparison in {@@link#compareTo} and {@@link#equals} in that it
    * only compares the instant of the date-time. This is equivalent to using {@code
    * dateTime1.toInstant().isAfter(dateTime2.toInstant());}.
    *
@@ -1648,7 +1648,7 @@ final class OffsetDateTime private (
   /**
    * Checks if the instant of this date-time is before that of the specified date-time.
    *
-   * This method differs from the comparison in {@link #compareTo} in that it only compares the
+   * This method differs from the comparison in {@@link#compareTo} in that it only compares the
    * instant of the date-time. This is equivalent to using {@code
    * dateTime1.toInstant().isBefore(dateTime2.toInstant());}.
    *
@@ -1666,7 +1666,7 @@ final class OffsetDateTime private (
   /**
    * Checks if the instant of this date-time is equal to that of the specified date-time.
    *
-   * This method differs from the comparison in {@link #compareTo} and {@link #equals} in that it
+   * This method differs from the comparison in {@@link#compareTo} and {@@link#equals} in that it
    * only compares the instant of the date-time. This is equivalent to using {@code
    * dateTime1.toInstant().equals(dateTime2.toInstant());}.
    *
@@ -1682,7 +1682,7 @@ final class OffsetDateTime private (
    * Checks if this date-time is equal to another date-time.
    *
    * The comparison is based on the local date-time and the offset. To compare for the same instant
-   * on the time-line, use {@link #isEqual}. Only objects of type {@code OffsetDateTime} are
+   * on the time-line, use {@@link#isEqual} . Only objects of type {@@codeOffsetDateTime} are
    * compared, other types return false.
    *
    * @param obj
@@ -1706,7 +1706,7 @@ final class OffsetDateTime private (
   override def hashCode: Int = dateTime.hashCode ^ offset.hashCode
 
   /**
-   * Outputs this date-time as a {@code String}, such as {@code 2007-12-03T10:15:30+01:00}.
+   * Outputs this date-time as a {@@codeString} , such as {@@code2007-12-03T10:15:30+01:00} .
    *
    * The output will be one of the following ISO-8601 formats: <ul> <li>{@code
    * yyyy-MM-dd'T'HH:mmXXXXX}</li> <li>{@code yyyy-MM-dd'T'HH:mm:ssXXXXX}</li> <li>{@code
@@ -1721,7 +1721,7 @@ final class OffsetDateTime private (
   override def toString: String = dateTime.toString + offset.toString
 
   /**
-   * Outputs this date-time as a {@code String} using the formatter.
+   * Outputs this date-time as a {@@codeString} using the formatter.
    *
    * This date-time will be passed to the formatter {@link
    * DateTimeFormatter#format(TemporalAccessor) print method}.
diff --git a/core/shared/src/main/scala/org/threeten/bp/OffsetTime.scala b/core/shared/src/main/scala/org/threeten/bp/OffsetTime.scala
index 7c1d8ad7c..f782b45ff 100644
--- a/core/shared/src/main/scala/org/threeten/bp/OffsetTime.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/OffsetTime.scala
@@ -59,17 +59,17 @@ import org.threeten.bp.zone.ZoneRules
 object OffsetTime {
 
   /**
-   * The minimum supported {@code OffsetTime}, '00:00:00+18:00'. This is the time of midnight at the
-   * start of the day in the maximum offset (larger offsets are earlier on the time-line). This
-   * combines {@link LocalTime#MIN} and {@link ZoneOffset#MAX}. This could be used by an application
-   * as a "far past" date.
+   * The minimum supported {@@codeOffsetTime} , '00:00:00+18:00'. This is the time of midnight at
+   * the start of the day in the maximum offset (larger offsets are earlier on the time-line). This
+   * combines {@@linkLocalTime#MIN} and {@@linkZoneOffset#MAX} . This could be used by an
+   * application as a "far past" date.
    */
   lazy val MIN: OffsetTime = LocalTime.MIN.atOffset(ZoneOffset.MAX)
 
   /**
-   * The maximum supported {@code OffsetTime}, '23:59:59.999999999-18:00'. This is the time just
+   * The maximum supported {@@codeOffsetTime} , '23:59:59.999999999-18:00'. This is the time just
    * before midnight at the end of the day in the minimum offset (larger negative offsets are later
-   * on the time-line). This combines {@link LocalTime#MAX} and {@link ZoneOffset#MIN}. This could
+   * on the time-line). This combines {@@linkLocalTime#MAX} and {@@linkZoneOffset#MIN} . This could
    * be used by an application as a "far future" date.
    */
   lazy val MAX: OffsetTime = LocalTime.MAX.atOffset(ZoneOffset.MIN)
@@ -77,7 +77,7 @@ object OffsetTime {
   /**
    * Obtains the current time from the system clock in the default time-zone.
    *
-   * This will query the {@link Clock#systemDefaultZone() system clock} in the default time-zone to
+   * This will query the {@@linkClock#systemDefaultZone() system clock} in the default time-zone to
    * obtain the current time. The offset will be calculated from the time-zone in the clock.
    *
    * Using this method will prevent the ability to use an alternate clock for testing because the
@@ -91,7 +91,7 @@ object OffsetTime {
   /**
    * Obtains the current time from the system clock in the specified time-zone.
    *
-   * This will query the {@link Clock#system(ZoneId) system clock} to obtain the current time.
+   * This will query the {@@linkClock#system(ZoneId) system clock} to obtain the current time.
    * Specifying the time-zone avoids dependence on the default time-zone. The offset will be
    * calculated from the specified time-zone.
    *
@@ -112,7 +112,7 @@ object OffsetTime {
    * from the time-zone in the clock.
    *
    * Using this method allows the use of an alternate clock for testing. The alternate clock may be
-   * introduced using {@link Clock dependency injection}.
+   * introduced using {@@linkClock dependency injection} .
    *
    * @param clock
    *   the clock to use, not null
@@ -126,7 +126,7 @@ object OffsetTime {
   }
 
   /**
-   * Obtains an instance of {@code OffsetTime} from a local time and an offset.
+   * Obtains an instance of {@@codeOffsetTime} from a local time and an offset.
    *
    * @param time
    *   the local time, not null
@@ -138,12 +138,12 @@ object OffsetTime {
   def of(time: LocalTime, offset: ZoneOffset): OffsetTime = new OffsetTime(time, offset)
 
   /**
-   * Obtains an instance of {@code OffsetTime} from an hour, minute, second and nanosecond.
+   * Obtains an instance of {@@codeOffsetTime} from an hour, minute, second and nanosecond.
    *
    * This creates an offset time with the four specified fields.
    *
    * This method exists primarily for writing test cases. Non test-code will typically use other
-   * methods to create an offset time. {@code LocalTime} has two additional convenience variants of
+   * methods to create an offset time. {@@codeLocalTime} has two additional convenience variants of
    * the equivalent factory method taking fewer arguments. They are not provided here to reduce the
    * footprint of the API.
    *
@@ -166,7 +166,7 @@ object OffsetTime {
     new OffsetTime(LocalTime.of(hour, minute, second, nanoOfSecond), offset)
 
   /**
-   * Obtains an instance of {@code OffsetTime} from an {@code Instant} and zone ID.
+   * Obtains an instance of {@@codeOffsetTime} from an {@@codeInstant} and zone ID.
    *
    * This creates an offset time with the same instant as that specified. Finding the offset from
    * UTC/Greenwich is simple as there is only one valid offset for each instant.
@@ -195,22 +195,22 @@ object OffsetTime {
   }
 
   /**
-   * Obtains an instance of {@code OffsetTime} from a temporal object.
+   * Obtains an instance of {@@codeOffsetTime} from a temporal object.
    *
-   * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code OffsetTime}.
+   * A {@@codeTemporalAccessor} represents some form of date and time information. This factory
+   * converts the arbitrary temporal object to an instance of {@@codeOffsetTime} .
    *
-   * The conversion extracts and combines {@code LocalTime} and {@code ZoneOffset}.
+   * The conversion extracts and combines {@@codeLocalTime} and {@@codeZoneOffset} .
    *
-   * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used in queries via method reference, {@code OffsetTime::from}.
+   * This method matches the signature of the functional interface {@@linkTemporalQuery} allowing it
+   * to be used in queries via method reference, {@@codeOffsetTime::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the offset time, not null
    * @throws DateTimeException
-   *   if unable to convert to an { @code OffsetTime}
+   *   if unable to convert to an {@@codeOffsetTime}
    */
   def from(temporal: TemporalAccessor): OffsetTime =
     temporal match {
@@ -229,7 +229,7 @@ object OffsetTime {
     }
 
   /**
-   * Obtains an instance of {@code OffsetTime} from a text string such as {@code 10:15:30+01:00}.
+   * Obtains an instance of {@@codeOffsetTime} from a text string such as {@@code10:15:30+01:00} .
    *
    * The string must represent a valid time and is parsed using {@link
    * org.threeten.bp.format.DateTimeFormatter#ISO_OFFSET_TIME}.
@@ -244,7 +244,7 @@ object OffsetTime {
   def parse(text: CharSequence): OffsetTime = parse(text, DateTimeFormatter.ISO_OFFSET_TIME)
 
   /**
-   * Obtains an instance of {@code OffsetTime} from a text string using a specific formatter.
+   * Obtains an instance of {@@codeOffsetTime} from a text string using a specific formatter.
    *
    * The text is parsed using the formatter, returning a time.
    *
@@ -273,10 +273,10 @@ object OffsetTime {
  * A time with an offset from UTC/Greenwich in the ISO-8601 calendar system, such as {@code
  * 10:15:30+01:00}.
  *
- * {@code OffsetTime} is an immutable date-time object that represents a time, often viewed as
+ * {@@codeOffsetTime} is an immutable date-time object that represents a time, often viewed as
  * hour-minute-second-offset. This class stores all time fields, to a precision of nanoseconds, as
  * well as a zone offset. For example, the value "13:45.30.123456789+02:00" can be stored in an
- * {@code OffsetTime}.
+ * {@@codeOffsetTime} .
  *
  * <h3>Specification for implementors</h3> This class is immutable and thread-safe.
  *
@@ -297,7 +297,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
   Objects.requireNonNull(offset, "offset")
 
   /**
-   * Returns a new time based on this one, returning {@code this} where possible.
+   * Returns a new time based on this one, returning {@@codethis} where possible.
    *
    * @param time
    *   the time to create with, not null
@@ -312,19 +312,19 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * Checks if the specified field is supported.
    *
    * This checks if this time can be queried for the specified field. If false, then calling the
-   * {@link #range(TemporalField) range} and {@link #get(TemporalField) get} methods will throw an
+   * {@@link#range(TemporalField) range} and {@@link#get(TemporalField) get} methods will throw an
    * exception.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The supported fields
+   * If the field is a {@@linkChronoField} then the query is implemented here. The supported fields
    * are: <ul> <li>{@code NANO_OF_SECOND} <li>{@code NANO_OF_DAY} <li>{@code MICRO_OF_SECOND}
    * <li>{@code MICRO_OF_DAY} <li>{@code MILLI_OF_SECOND} <li>{@code MILLI_OF_DAY} <li>{@code
    * SECOND_OF_MINUTE} <li>{@code SECOND_OF_DAY} <li>{@code MINUTE_OF_HOUR} <li>{@code
    * MINUTE_OF_DAY} <li>{@code HOUR_OF_AMPM} <li>{@code CLOCK_HOUR_OF_AMPM} <li>{@code HOUR_OF_DAY}
    * <li>{@code CLOCK_HOUR_OF_DAY} <li>{@code AMPM_OF_DAY} <li>{@code OFFSET_SECONDS} </ul> All
-   * other {@code ChronoField} instances will return false.
+   * other {@@codeChronoField} instances will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.isSupportedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the field is supported is determined by the field.
    *
    * @param field
@@ -347,12 +347,12 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * to enhance the accuracy of the returned range. If it is not possible to return the range,
    * because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return appropriate range instances. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.rangeRefinedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
    * @param field
@@ -370,20 +370,20 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
       field.rangeRefinedBy(this)
 
   /**
-   * Gets the value of the specified field from this time as an {@code int}.
+   * Gets the value of the specified field from this time as an {@@codeint} .
    *
    * This queries this time for the value for the specified field. The returned value will always be
    * within the valid range of values for the field. If it is not possible to return the value,
    * because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this time,
-   * except {@code NANO_OF_DAY} and {@code MICRO_OF_DAY} which are too large to fit in an {@code
-   * int} and throw a {@code DateTimeException}. All other {@code ChronoField} instances will throw
-   * a {@code DateTimeException}.
+   * except {@@codeNANO_OF_DAY} and {@@codeMICRO_OF_DAY} which are too large to fit in an {@code
+   * int} and throw a {@@codeDateTimeException} . All other {@@codeChronoField} instances will throw
+   * a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -398,17 +398,17 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
   override def get(field: TemporalField): Int = super.get(field)
 
   /**
-   * Gets the value of the specified field from this time as a {@code long}.
+   * Gets the value of the specified field from this time as a {@@codelong} .
    *
    * This queries this time for the value for the specified field. If it is not possible to return
    * the value, because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this time. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -438,12 +438,12 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
   def getOffset: ZoneOffset = offset
 
   /**
-   * Returns a copy of this {@code OffsetTime} with the specified offset ensuring that the result
+   * Returns a copy of this {@@codeOffsetTime} with the specified offset ensuring that the result
    * has the same local time.
    *
-   * This method returns an object with the same {@code LocalTime} and the specified {@code
+   * This method returns an object with the same {@@codeLocalTime} and the specified {@code
    * ZoneOffset}. No calculation is needed or performed. For example, if this time represents {@code
-   * 10:30+02:00} and the offset specified is {@code +03:00}, then this method will return {@code
+   * 10:30+02:00} and the offset specified is {@@code+03:00} , then this method will return {@code
    * 10:30+03:00}.
    *
    * To take into account the difference between the offsets, and adjust the time fields, use {@link
@@ -454,30 +454,30 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param offset
    *   the zone offset to change to, not null
    * @return
-   *   an { @code OffsetTime} based on this time with the requested offset, not null
+   *   an {@@codeOffsetTime} based on this time with the requested offset, not null
    */
   def withOffsetSameLocal(offset: ZoneOffset): OffsetTime =
     if (offset != null && (offset == this.offset)) this
     else new OffsetTime(time, offset)
 
   /**
-   * Returns a copy of this {@code OffsetTime} with the specified offset ensuring that the result is
+   * Returns a copy of this {@@codeOffsetTime} with the specified offset ensuring that the result is
    * at the same instant on an implied day.
    *
-   * This method returns an object with the specified {@code ZoneOffset} and a {@code LocalTime}
+   * This method returns an object with the specified {@@codeZoneOffset} and a {@@codeLocalTime}
    * adjusted by the difference between the two offsets. This will result in the old and new objects
    * representing the same instant an an implied day. This is useful for finding the local time in a
-   * different offset. For example, if this time represents {@code 10:30+02:00} and the offset
-   * specified is {@code +03:00}, then this method will return {@code 11:30+03:00}.
+   * different offset. For example, if this time represents {@@code10:30+02:00} and the offset
+   * specified is {@@code+03:00} , then this method will return {@@code11:30+03:00} .
    *
-   * To change the offset without adjusting the local time use {@link #withOffsetSameLocal}.
+   * To change the offset without adjusting the local time use {@@link#withOffsetSameLocal} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param offset
    *   the zone offset to change to, not null
    * @return
-   *   an { @code OffsetTime} based on this time with the requested offset, not null
+   *   an {@@codeOffsetTime} based on this time with the requested offset, not null
    */
   def withOffsetSameInstant(offset: ZoneOffset): OffsetTime =
     if (offset == this.offset)
@@ -523,19 +523,19 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
   /**
    * Returns an adjusted copy of this time.
    *
-   * This returns a new {@code OffsetTime}, based on this one, with the time adjusted. The
+   * This returns a new {@@codeOffsetTime} , based on this one, with the time adjusted. The
    * adjustment takes place using the specified adjuster strategy object. Read the documentation of
    * the adjuster to understand what adjustment will be made.
    *
    * A simple adjuster might simply set the one of the fields, such as the hour field. A more
    * complex adjuster might set the time to the last hour of the day.
    *
-   * The classes {@link LocalTime} and {@link ZoneOffset} implement {@code TemporalAdjuster}, thus
+   * The classes {@@linkLocalTime} and {@@linkZoneOffset} implement {@@codeTemporalAdjuster} , thus
    * this method can be used to change the time or offset: <pre> result = offsetTime.with(time);
    * result = offsetTime.with(offset); </pre>
    *
    * The result of this method is obtained by invoking the {@link
-   * TemporalAdjuster#adjustInto(Temporal)} method on the specified adjuster passing {@code this} as
+   * TemporalAdjuster#adjustInto(Temporal)} method on the specified adjuster passing {@@codethis} as
    * the argument.
    *
    * This instance is immutable and unaffected by this method call.
@@ -543,7 +543,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param adjuster
    *   the adjuster to use, not null
    * @return
-   *   an { @code OffsetTime} based on { @code this} with the adjustment made, not null
+   *   an {@@codeOffsetTime} based on {@@codethis} with the adjustment made, not null
    * @throws DateTimeException
    *   if the adjustment cannot be made
    * @throws ArithmeticException
@@ -560,25 +560,25 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
   /**
    * Returns a copy of this time with the specified field set to a new value.
    *
-   * This returns a new {@code OffsetTime}, based on this one, with the value for the specified
+   * This returns a new {@@codeOffsetTime} , based on this one, with the value for the specified
    * field changed. This can be used to change any supported field, such as the hour, minute or
    * second. If it is not possible to set the value, because the field is not supported or for some
    * other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the adjustment is implemented here.
+   * If the field is a {@@linkChronoField} then the adjustment is implemented here.
    *
-   * The {@code OFFSET_SECONDS} field will return a time with the specified offset. The local time
+   * The {@@codeOFFSET_SECONDS} field will return a time with the specified offset. The local time
    * is unaltered. If the new offset value is outside the valid range then a {@code
    * DateTimeException} will be thrown.
    *
-   * The other {@link #isSupported(TemporalField) supported fields} will behave as per the matching
-   * method on {@link LocalTime#with(TemporalField, long)} LocalTime}. In this case, the offset is
+   * The other {@@link#isSupported(TemporalField) supported fields} will behave as per the matching
+   * method on {@@linkLocalTime#with(TemporalField, long)} LocalTime}. In this case, the offset is
    * not part of the calculation and will be unchanged.
    *
-   * All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * All other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.adjustInto(Temporal, long)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.adjustInto(Temporal, long)} passing {@@codethis} as the argument.
    * In this case, the field determines whether and how to adjust the instant.
    *
    * This instance is immutable and unaffected by this method call.
@@ -588,7 +588,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param newValue
    *   the new value of the field in the result
    * @return
-   *   an { @code OffsetTime} based on { @code this} with the specified field set, not null
+   *   an {@@codeOffsetTime} based on {@@codethis} with the specified field set, not null
    * @throws DateTimeException
    *   if the field cannot be set
    * @throws ArithmeticException
@@ -604,7 +604,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
     }
 
   /**
-   * Returns a copy of this {@code OffsetTime} with the hour-of-day value altered.
+   * Returns a copy of this {@@codeOffsetTime} with the hour-of-day value altered.
    *
    * The offset does not affect the calculation and will be the same in the result.
    *
@@ -613,14 +613,14 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param hour
    *   the hour-of-day to set in the result, from 0 to 23
    * @return
-   *   an { @code OffsetTime} based on this time with the requested hour, not null
+   *   an {@@codeOffsetTime} based on this time with the requested hour, not null
    * @throws DateTimeException
    *   if the hour value is invalid
    */
   def withHour(hour: Int): OffsetTime = `with`(time.withHour(hour), offset)
 
   /**
-   * Returns a copy of this {@code OffsetTime} with the minute-of-hour value altered.
+   * Returns a copy of this {@@codeOffsetTime} with the minute-of-hour value altered.
    *
    * The offset does not affect the calculation and will be the same in the result.
    *
@@ -629,14 +629,14 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param minute
    *   the minute-of-hour to set in the result, from 0 to 59
    * @return
-   *   an { @code OffsetTime} based on this time with the requested minute, not null
+   *   an {@@codeOffsetTime} based on this time with the requested minute, not null
    * @throws DateTimeException
    *   if the minute value is invalid
    */
   def withMinute(minute: Int): OffsetTime = `with`(time.withMinute(minute), offset)
 
   /**
-   * Returns a copy of this {@code OffsetTime} with the second-of-minute value altered.
+   * Returns a copy of this {@@codeOffsetTime} with the second-of-minute value altered.
    *
    * The offset does not affect the calculation and will be the same in the result.
    *
@@ -645,14 +645,14 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param second
    *   the second-of-minute to set in the result, from 0 to 59
    * @return
-   *   an { @code OffsetTime} based on this time with the requested second, not null
+   *   an {@@codeOffsetTime} based on this time with the requested second, not null
    * @throws DateTimeException
    *   if the second value is invalid
    */
   def withSecond(second: Int): OffsetTime = `with`(time.withSecond(second), offset)
 
   /**
-   * Returns a copy of this {@code OffsetTime} with the nano-of-second value altered.
+   * Returns a copy of this {@@codeOffsetTime} with the nano-of-second value altered.
    *
    * The offset does not affect the calculation and will be the same in the result.
    *
@@ -661,22 +661,22 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param nanoOfSecond
    *   the nano-of-second to set in the result, from 0 to 999,999,999
    * @return
-   *   an { @code OffsetTime} based on this time with the requested nanosecond, not null
+   *   an {@@codeOffsetTime} based on this time with the requested nanosecond, not null
    * @throws DateTimeException
    *   if the nanos value is invalid
    */
   def withNano(nanoOfSecond: Int): OffsetTime = `with`(time.withNano(nanoOfSecond), offset)
 
   /**
-   * Returns a copy of this {@code OffsetTime} with the time truncated.
+   * Returns a copy of this {@@codeOffsetTime} with the time truncated.
    *
    * Truncation returns a copy of the original time with fields smaller than the specified unit set
-   * to zero. For example, truncating with the {@link ChronoUnit#MINUTES minutes} unit will set the
+   * to zero. For example, truncating with the {@@linkChronoUnit#MINUTES minutes} unit will set the
    * second-of-minute and nano-of-second field to zero.
    *
-   * The unit must have a {@linkplain TemporalUnit#getDuration() duration} that divides into the
+   * The unit must have a {@@linkplainTemporalUnit#getDuration() duration} that divides into the
    * length of a standard day without remainder. This includes all supplied time units on {@link
-   * ChronoUnit} and {@link ChronoUnit#DAYS DAYS}. Other units throw an exception.
+   * ChronoUnit} and {@@linkChronoUnit#DAYS DAYS} . Other units throw an exception.
    *
    * The offset does not affect the calculation and will be the same in the result.
    *
@@ -685,7 +685,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param unit
    *   the unit to truncate to, not null
    * @return
-   *   an { @code OffsetTime} based on this time with the time truncated, not null
+   *   an {@@codeOffsetTime} based on this time with the time truncated, not null
    * @throws DateTimeException
    *   if unable to truncate
    */
@@ -695,9 +695,9 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * Returns a copy of this date with the specified period added.
    *
    * This method returns a new time based on this time with the specified period added. The amount
-   * is typically {@link Period} but may be any other type implementing the {@link TemporalAmount}
+   * is typically {@@linkPeriod} but may be any other type implementing the {@@linkTemporalAmount}
    * interface. The calculation is delegated to the specified adjuster, which typically calls back
-   * to {@link #plus(long, TemporalUnit)}. The offset is not part of the calculation and will be
+   * to {@@link#plus(long, TemporalUnit)} . The offset is not part of the calculation and will be
    * unchanged in the result.
    *
    * This instance is immutable and unaffected by this method call.
@@ -705,7 +705,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param amount
    *   the amount to add, not null
    * @return
-   *   an { @code OffsetTime} based on this time with the addition made, not null
+   *   an {@@codeOffsetTime} based on this time with the addition made, not null
    * @throws DateTimeException
    *   if the addition cannot be made
    * @throws ArithmeticException
@@ -730,7 +730,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param unit
    *   the unit of the period to add, not null
    * @return
-   *   an { @code OffsetTime} based on this time with the specified period added, not null
+   *   an {@@codeOffsetTime} based on this time with the specified period added, not null
    * @throws DateTimeException
    *   if the unit cannot be added to this type
    */
@@ -739,7 +739,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
     else unit.addTo(this, amountToAdd)
 
   /**
-   * Returns a copy of this {@code OffsetTime} with the specified period in hours added.
+   * Returns a copy of this {@@codeOffsetTime} with the specified period in hours added.
    *
    * This adds the specified number of hours to this time, returning a new time. The calculation
    * wraps around midnight.
@@ -749,12 +749,12 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param hours
    *   the hours to add, may be negative
    * @return
-   *   an { @code OffsetTime} based on this time with the hours added, not null
+   *   an {@@codeOffsetTime} based on this time with the hours added, not null
    */
   def plusHours(hours: Long): OffsetTime = `with`(time.plusHours(hours), offset)
 
   /**
-   * Returns a copy of this {@code OffsetTime} with the specified period in minutes added.
+   * Returns a copy of this {@@codeOffsetTime} with the specified period in minutes added.
    *
    * This adds the specified number of minutes to this time, returning a new time. The calculation
    * wraps around midnight.
@@ -764,12 +764,12 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param minutes
    *   the minutes to add, may be negative
    * @return
-   *   an { @code OffsetTime} based on this time with the minutes added, not null
+   *   an {@@codeOffsetTime} based on this time with the minutes added, not null
    */
   def plusMinutes(minutes: Long): OffsetTime = `with`(time.plusMinutes(minutes), offset)
 
   /**
-   * Returns a copy of this {@code OffsetTime} with the specified period in seconds added.
+   * Returns a copy of this {@@codeOffsetTime} with the specified period in seconds added.
    *
    * This adds the specified number of seconds to this time, returning a new time. The calculation
    * wraps around midnight.
@@ -779,12 +779,12 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param seconds
    *   the seconds to add, may be negative
    * @return
-   *   an { @code OffsetTime} based on this time with the seconds added, not null
+   *   an {@@codeOffsetTime} based on this time with the seconds added, not null
    */
   def plusSeconds(seconds: Long): OffsetTime = `with`(time.plusSeconds(seconds), offset)
 
   /**
-   * Returns a copy of this {@code OffsetTime} with the specified period in nanoseconds added.
+   * Returns a copy of this {@@codeOffsetTime} with the specified period in nanoseconds added.
    *
    * This adds the specified number of nanoseconds to this time, returning a new time. The
    * calculation wraps around midnight.
@@ -794,7 +794,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param nanos
    *   the nanos to add, may be negative
    * @return
-   *   an { @code OffsetTime} based on this time with the nanoseconds added, not null
+   *   an {@@codeOffsetTime} based on this time with the nanoseconds added, not null
    */
   def plusNanos(nanos: Long): OffsetTime = `with`(time.plusNanos(nanos), offset)
 
@@ -802,9 +802,9 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * Returns a copy of this time with the specified period subtracted.
    *
    * This method returns a new time based on this time with the specified period subtracted. The
-   * amount is typically {@link Period} but may be any other type implementing the {@link
+   * amount is typically {@@linkPeriod} but may be any other type implementing the {@link
    * TemporalAmount} interface. The calculation is delegated to the specified adjuster, which
-   * typically calls back to {@link #minus(long, TemporalUnit)}. The offset is not part of the
+   * typically calls back to {@@link#minus(long, TemporalUnit)} . The offset is not part of the
    * calculation and will be unchanged in the result.
    *
    * This instance is immutable and unaffected by this method call.
@@ -812,7 +812,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param amount
    *   the amount to subtract, not null
    * @return
-   *   an { @code OffsetTime} based on this time with the subtraction made, not null
+   *   an {@@codeOffsetTime} based on this time with the subtraction made, not null
    * @throws DateTimeException
    *   if the subtraction cannot be made
    * @throws ArithmeticException
@@ -837,7 +837,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param unit
    *   the unit of the period to subtract, not null
    * @return
-   *   an { @code OffsetTime} based on this time with the specified period subtracted, not null
+   *   an {@@codeOffsetTime} based on this time with the specified period subtracted, not null
    * @throws DateTimeException
    *   if the unit cannot be added to this type
    */
@@ -846,7 +846,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
     else plus(-amountToSubtract, unit)
 
   /**
-   * Returns a copy of this {@code OffsetTime} with the specified period in hours subtracted.
+   * Returns a copy of this {@@codeOffsetTime} with the specified period in hours subtracted.
    *
    * This subtracts the specified number of hours from this time, returning a new time. The
    * calculation wraps around midnight.
@@ -856,12 +856,12 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param hours
    *   the hours to subtract, may be negative
    * @return
-   *   an { @code OffsetTime} based on this time with the hours subtracted, not null
+   *   an {@@codeOffsetTime} based on this time with the hours subtracted, not null
    */
   def minusHours(hours: Long): OffsetTime = `with`(time.minusHours(hours), offset)
 
   /**
-   * Returns a copy of this {@code OffsetTime} with the specified period in minutes subtracted.
+   * Returns a copy of this {@@codeOffsetTime} with the specified period in minutes subtracted.
    *
    * This subtracts the specified number of minutes from this time, returning a new time. The
    * calculation wraps around midnight.
@@ -871,12 +871,12 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param minutes
    *   the minutes to subtract, may be negative
    * @return
-   *   an { @code OffsetTime} based on this time with the minutes subtracted, not null
+   *   an {@@codeOffsetTime} based on this time with the minutes subtracted, not null
    */
   def minusMinutes(minutes: Long): OffsetTime = `with`(time.minusMinutes(minutes), offset)
 
   /**
-   * Returns a copy of this {@code OffsetTime} with the specified period in seconds subtracted.
+   * Returns a copy of this {@@codeOffsetTime} with the specified period in seconds subtracted.
    *
    * This subtracts the specified number of seconds from this time, returning a new time. The
    * calculation wraps around midnight.
@@ -886,12 +886,12 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param seconds
    *   the seconds to subtract, may be negative
    * @return
-   *   an { @code OffsetTime} based on this time with the seconds subtracted, not null
+   *   an {@@codeOffsetTime} based on this time with the seconds subtracted, not null
    */
   def minusSeconds(seconds: Long): OffsetTime = `with`(time.minusSeconds(seconds), offset)
 
   /**
-   * Returns a copy of this {@code OffsetTime} with the specified period in nanoseconds subtracted.
+   * Returns a copy of this {@@codeOffsetTime} with the specified period in nanoseconds subtracted.
    *
    * This subtracts the specified number of nanoseconds from this time, returning a new time. The
    * calculation wraps around midnight.
@@ -901,19 +901,19 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @param nanos
    *   the nanos to subtract, may be negative
    * @return
-   *   an { @code OffsetTime} based on this time with the nanoseconds subtracted, not null
+   *   an {@@codeOffsetTime} based on this time with the nanoseconds subtracted, not null
    */
   def minusNanos(nanos: Long): OffsetTime = `with`(time.minusNanos(nanos), offset)
 
   /**
    * Queries this time using the specified query.
    *
-   * This queries this time using the specified query strategy object. The {@code TemporalQuery}
+   * This queries this time using the specified query strategy object. The {@@codeTemporalQuery}
    * object defines the logic to be used to obtain the result. Read the documentation of the query
    * to understand what the result of this method will be.
    *
    * The result of this method is obtained by invoking the {@link
-   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@code this}
+   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@@codethis}
    * as the argument.
    *
    * @tparam R
@@ -943,8 +943,8 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * This returns a temporal object of the same observable type as the input with the offset and
    * time changed to be the same as this.
    *
-   * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)} twice, passing
-   * {@link ChronoField#NANO_OF_DAY} and {@link ChronoField#OFFSET_SECONDS} as the fields.
+   * The adjustment is equivalent to using {@@linkTemporal#with(TemporalField, long)} twice, passing
+   * {@@linkChronoField#NANO_OF_DAY} and {@@linkChronoField#OFFSET_SECONDS} as the fields.
    *
    * In most cases, it is clearer to reverse the calling pattern by using {@link
    * Temporal#with(TemporalAdjuster)}: <pre> // these two lines are equivalent, but the second
@@ -971,36 +971,36 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * Calculates the period between this time and another time in terms of the specified unit.
    *
    * This calculates the period between two times in terms of a single unit. The start and end
-   * points are {@code this} and the specified time. The result will be negative if the end is
+   * points are {@@codethis} and the specified time. The result will be negative if the end is
    * before the start. For example, the period in hours between two times can be calculated using
-   * {@code startTime.until(endTime, HOURS)}.
+   * {@@codestartTime.until(endTime, HOURS)} .
    *
-   * The {@code Temporal} passed to this method must be an {@code OffsetTime}. If the offset differs
-   * between the two times, then the specified end time is normalized to have the same offset as
-   * this time.
+   * The {@@codeTemporal} passed to this method must be an {@@codeOffsetTime} . If the offset
+   * differs between the two times, then the specified end time is normalized to have the same
+   * offset as this time.
    *
    * The calculation returns a whole number, representing the number of complete units between the
    * two times. For example, the period in hours between 11:30Z and 13:29Z will only be one hour as
    * it is one minute short of two hours.
    *
-   * This method operates in association with {@link TemporalUnit#between}. The result of this
-   * method is a {@code long} representing the amount of the specified unit. By contrast, the result
-   * of {@code between} is an object that can be used directly in addition/subtraction: <pre> long
+   * This method operates in association with {@@linkTemporalUnit#between} . The result of this
+   * method is a {@@codelong} representing the amount of the specified unit. By contrast, the result
+   * of {@@codebetween} is an object that can be used directly in addition/subtraction: <pre> long
    * period = start.until(end, HOURS); // this method dateTime.plus(HOURS.between(start, end)); //
    * use in plus/minus </pre>
    *
-   * The calculation is implemented in this method for {@link ChronoUnit}. The units {@code NANOS},
-   * {@code MICROS}, {@code MILLIS}, {@code SECONDS}, {@code MINUTES}, {@code HOURS} and {@code
-   * HALF_DAYS} are supported. Other {@code ChronoUnit} values will throw an exception.
+   * The calculation is implemented in this method for {@@linkChronoUnit} . The units {@@codeNANOS}
+   * , {@@codeMICROS} , {@@codeMILLIS} , {@@codeSECONDS} , {@@codeMINUTES} , {@@codeHOURS} and
+   * {@code HALF_DAYS} are supported. Other {@@codeChronoUnit} values will throw an exception.
    *
-   * If the unit is not a {@code ChronoUnit}, then the result of this method is obtained by invoking
-   * {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first argument and
-   * the input temporal as the second argument.
+   * If the unit is not a {@@codeChronoUnit} , then the result of this method is obtained by
+   * invoking {@@codeTemporalUnit.between(Temporal, Temporal)} passing {@@codethis} as the first
+   * argument and the input temporal as the second argument.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param endExclusive
-   *   the end time, which is converted to an { @code OffsetTime}, not null
+   *   the end time, which is converted to an {@@codeOffsetTime} , not null
    * @param unit
    *   the unit to measure the period in, not null
    * @return
@@ -1032,9 +1032,9 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
   }
 
   /**
-   * Combines this time with a date to create an {@code OffsetDateTime}.
+   * Combines this time with a date to create an {@@codeOffsetDateTime} .
    *
-   * This returns an {@code OffsetDateTime} formed from this time and the specified date. All
+   * This returns an {@@codeOffsetDateTime} formed from this time and the specified date. All
    * possible combinations of date and time are valid.
    *
    * @param date
@@ -1045,9 +1045,9 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
   def atDate(date: LocalDate): OffsetDateTime = OffsetDateTime.of(date, time, offset)
 
   /**
-   * Gets the {@code LocalTime} part of this date-time.
+   * Gets the {@@codeLocalTime} part of this date-time.
    *
-   * This returns a {@code LocalTime} with the same hour, minute, second and nanosecond as this
+   * This returns a {@@codeLocalTime} with the same hour, minute, second and nanosecond as this
    * date-time.
    *
    * @return
@@ -1068,10 +1068,10 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
   }
 
   /**
-   * Compares this {@code OffsetTime} to another time.
+   * Compares this {@@codeOffsetTime} to another time.
    *
    * The comparison is based first on the UTC equivalent instant, then on the local time. It is
-   * "consistent with equals", as defined by {@link Comparable}.
+   * "consistent with equals", as defined by {@@linkComparable} .
    *
    * For example, the following is the comparator order: <ol> <li>{@code 10:30+01:00}</li>
    * <li>{@code 11:00+01:00}</li> <li>{@code 12:00+02:00}</li> <li>{@code 11:30+01:00}</li>
@@ -1080,7 +1080,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * compared to distinguish them. This step is needed to make the ordering consistent with {@code
    * equals()}.
    *
-   * To compare the underlying local time of two {@code TemporalAccessor} instances, use {@link
+   * To compare the underlying local time of two {@@codeTemporalAccessor} instances, use {@link
    * ChronoField#NANO_OF_DAY} as a comparator.
    *
    * @param other
@@ -1088,7 +1088,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * @return
    *   the comparator value, negative if less, positive if greater
    * @throws NullPointerException
-   *   if { @code other} is null
+   *   if {@@codeother} is null
    */
   def compare(other: OffsetTime): Int =
     if (offset == other.offset)
@@ -1103,10 +1103,10 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
   override def compareTo(other: OffsetTime): Int = compare(other)
 
   /**
-   * Checks if the instant of this {@code OffsetTime} is after that of the specified time applying
+   * Checks if the instant of this {@@codeOffsetTime} is after that of the specified time applying
    * both times to a common date.
    *
-   * This method differs from the comparison in {@link #compareTo} in that it only compares the
+   * This method differs from the comparison in {@@link#compareTo} in that it only compares the
    * instant of the time. This is equivalent to converting both times to an instant using the same
    * date and comparing the instants.
    *
@@ -1118,10 +1118,10 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
   def isAfter(other: OffsetTime): Boolean = toEpochNano > other.toEpochNano
 
   /**
-   * Checks if the instant of this {@code OffsetTime} is before that of the specified time applying
+   * Checks if the instant of this {@@codeOffsetTime} is before that of the specified time applying
    * both times to a common date.
    *
-   * This method differs from the comparison in {@link #compareTo} in that it only compares the
+   * This method differs from the comparison in {@@link#compareTo} in that it only compares the
    * instant of the time. This is equivalent to converting both times to an instant using the same
    * date and comparing the instants.
    *
@@ -1133,10 +1133,10 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
   def isBefore(other: OffsetTime): Boolean = toEpochNano < other.toEpochNano
 
   /**
-   * Checks if the instant of this {@code OffsetTime} is equal to that of the specified time
+   * Checks if the instant of this {@@codeOffsetTime} is equal to that of the specified time
    * applying both times to a common date.
    *
-   * This method differs from the comparison in {@link #compareTo} and {@link #equals} in that it
+   * This method differs from the comparison in {@@link#compareTo} and {@@link#equals} in that it
    * only compares the instant of the time. This is equivalent to converting both times to an
    * instant using the same date and comparing the instants.
    *
@@ -1151,10 +1151,10 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
    * Checks if this time is equal to another time.
    *
    * The comparison is based on the local-time and the offset. To compare for the same instant on
-   * the time-line, use {@link #isEqual(OffsetTime)}.
+   * the time-line, use {@@link#isEqual(OffsetTime)} .
    *
-   * Only objects of type {@code OffsetTime} are compared, other types return false. To compare the
-   * underlying local time of two {@code TemporalAccessor} instances, use {@link
+   * Only objects of type {@@codeOffsetTime} are compared, other types return false. To compare the
+   * underlying local time of two {@@codeTemporalAccessor} instances, use {@link
    * ChronoField#NANO_OF_DAY} as a comparator.
    *
    * @param obj
@@ -1177,7 +1177,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
   override def hashCode: Int = time.hashCode ^ offset.hashCode
 
   /**
-   * Outputs this time as a {@code String}, such as {@code 10:15:30+01:00}.
+   * Outputs this time as a {@@codeString} , such as {@@code10:15:30+01:00} .
    *
    * The output will be one of the following ISO-8601 formats: <ul> <li>{@code HH:mmXXXXX}</li>
    * <li>{@code HH:mm:ssXXXXX}</li> <li>{@code HH:mm:ss.SSSXXXXX}</li> <li>{@code
@@ -1191,7 +1191,7 @@ final class OffsetTime(private val time: LocalTime, private val offset: ZoneOffs
   override def toString: String = time.toString + offset.toString
 
   /**
-   * Outputs this time as a {@code String} using the formatter.
+   * Outputs this time as a {@@codeString} using the formatter.
    *
    * This time will be passed to the formatter {@link DateTimeFormatter#format(TemporalAccessor)
    * print method}.
diff --git a/core/shared/src/main/scala/org/threeten/bp/Period.scala b/core/shared/src/main/scala/org/threeten/bp/Period.scala
index 4bbfddc50..85bedb8d2 100644
--- a/core/shared/src/main/scala/org/threeten/bp/Period.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/Period.scala
@@ -61,7 +61,7 @@ object Period {
   )
 
   /**
-   * Obtains a {@code Period} representing a number of years.
+   * Obtains a {@@codePeriod} representing a number of years.
    *
    * The resulting period will have the specified years. The months and days units will be zero.
    *
@@ -73,7 +73,7 @@ object Period {
   def ofYears(years: Int): Period = create(years, 0, 0)
 
   /**
-   * Obtains a {@code Period} representing a number of months.
+   * Obtains a {@@codePeriod} representing a number of months.
    *
    * The resulting period will have the specified months. The years and days units will be zero.
    *
@@ -85,7 +85,7 @@ object Period {
   def ofMonths(months: Int): Period = create(0, months, 0)
 
   /**
-   * Obtains a {@code Period} representing a number of weeks.
+   * Obtains a {@@codePeriod} representing a number of weeks.
    *
    * The resulting period will have days equal to the weeks multiplied by seven. The years and
    * months units will be zero.
@@ -98,7 +98,7 @@ object Period {
   def ofWeeks(weeks: Int): Period = create(0, 0, Math.multiplyExact(weeks, 7))
 
   /**
-   * Obtains a {@code Period} representing a number of days.
+   * Obtains a {@@codePeriod} representing a number of days.
    *
    * The resulting period will have the specified days. The years and months units will be zero.
    *
@@ -110,7 +110,7 @@ object Period {
   def ofDays(days: Int): Period = create(0, 0, days)
 
   /**
-   * Obtains a {@code Period} representing a number of years, months and days.
+   * Obtains a {@@codePeriod} representing a number of years, months and days.
    *
    * This creates an instance based on years, months and days.
    *
@@ -126,24 +126,24 @@ object Period {
   def of(years: Int, months: Int, days: Int): Period = create(years, months, days)
 
   /**
-   * Obtains an instance of {@code Period} from a temporal amount.
+   * Obtains an instance of {@@codePeriod} from a temporal amount.
    *
-   * This obtains a period based on the specified amount. A {@code TemporalAmount} represents an
+   * This obtains a period based on the specified amount. A {@@codeTemporalAmount} represents an
    * amount of time, which may be date-based or time-based, which this factory extracts to a {@code
    * Period}.
    *
    * The conversion loops around the set of units from the amount and uses the {@link
-   * ChronoUnit#YEARS YEARS}, {@link ChronoUnit#MONTHS MONTHS} and {@link ChronoUnit#DAYS DAYS}
+   * ChronoUnit#YEARS YEARS}, {@@linkChronoUnit#MONTHS MONTHS} and {@@linkChronoUnit#DAYS DAYS}
    * units to create a period. If any other units are found then an exception is thrown.
    *
-   * If the amount is a {@code ChronoPeriod} then it must use the ISO chronology.
+   * If the amount is a {@@codeChronoPeriod} then it must use the ISO chronology.
    *
    * @param amount
    *   the temporal amount to convert, not null
    * @return
    *   the equivalent period, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code Period}
+   *   if unable to convert to a {@@codePeriod}
    * @throws ArithmeticException
    *   if the amount of years, months or days exceeds an int
    */
@@ -178,13 +178,13 @@ object Period {
   }
 
   /**
-   * Obtains a {@code Period} consisting of the number of years, months, and days between two dates.
+   * Obtains a {@@codePeriod} consisting of the number of years, months, and days between two dates.
    *
    * The start date is included, but the end date is not. The period is calculated by removing
    * complete months, then calculating the remaining number of days, adjusting to ensure that both
    * have the same sign. The number of months is then split into years and months based on a 12
    * month year. A month is considered if the end day-of-month is greater than or equal to the start
-   * day-of-month. For example, from {@code 2010-01-15} to {@code 2011-03-18} is one year, two
+   * day-of-month. For example, from {@@code2010-01-15} to {@@code2011-03-18} is one year, two
    * months and three days.
    *
    * The result of this method can be a negative period if the end is before the start. The negative
@@ -202,10 +202,10 @@ object Period {
   def between(startDate: LocalDate, endDate: LocalDate): Period = startDate.until(endDate)
 
   /**
-   * Obtains a {@code Period} from a text string such as {@code PnYnMnD}.
+   * Obtains a {@@codePeriod} from a text string such as {@@codePnYnMnD} .
    *
-   * This will parse the string produced by {@code toString()} which is based on the ISO-8601 period
-   * formats {@code PnYnMnD} and {@code PnW}.
+   * This will parse the string produced by {@@codetoString()} which is based on the ISO-8601 period
+   * formats {@@codePnYnMnD} and {@@codePnW} .
    *
    * The string starts with an optional sign, denoted by the ASCII negative or positive symbol. If
    * negative, the whole period is negated. The ASCII letter "P" is next in upper or lower case.
@@ -213,10 +213,10 @@ object Period {
    * four sections must be present. The sections have suffixes in ASCII of "Y", "M", "W" and "D" for
    * years, months, weeks and days, accepted in upper or lower case. The suffixes must occur in
    * order. The number part of each section must consist of ASCII digits. The number may be prefixed
-   * by the ASCII negative or positive symbol. The number must parse to an {@code int}.
+   * by the ASCII negative or positive symbol. The number must parse to an {@@codeint} .
    *
    * The leading plus/minus sign, and negative values for other units are not part of the ISO-8601
-   * standard. In addition, ISO-8601 does not permit mixing between the {@code PnYnMnD} and {@code
+   * standard. In addition, ISO-8601 does not permit mixing between the {@@codePnYnMnD} and {@code
    * PnW} formats. Any week-based input is multiplied by 7 and treated as a number of days.
    *
    * For example, the following are valid inputs: <pre> "P2Y" -- Period.ofYears(2) "P3M" --
@@ -289,18 +289,18 @@ object Period {
  * Duration} for the time-based equivalent to this class.
  *
  * Durations and period differ in their treatment of daylight savings time when added to {@link
- * ZonedDateTime}. A {@code Duration} will add an exact number of seconds, thus a duration of one
- * day is always exactly 24 hours. By contrast, a {@code Period} will add a conceptual day, trying
+ * ZonedDateTime}. A {@@codeDuration} will add an exact number of seconds, thus a duration of one
+ * day is always exactly 24 hours. By contrast, a {@@codePeriod} will add a conceptual day, trying
  * to maintain the local time.
  *
  * For example, consider adding a period of one day and a duration of one day to 18:00 on the
- * evening before a daylight savings gap. The {@code Period} will add the conceptual day and result
- * in a {@code ZonedDateTime} at 18:00 the following day. By contrast, the {@code Duration} will add
- * exactly 24 hours, resulting in a {@code ZonedDateTime} at 19:00 the following day (assuming a one
+ * evening before a daylight savings gap. The {@@codePeriod} will add the conceptual day and result
+ * in a {@@codeZonedDateTime} at 18:00 the following day. By contrast, the {@@codeDuration} will add
+ * exactly 24 hours, resulting in a {@@codeZonedDateTime} at 19:00 the following day (assuming a one
  * hour DST gap).
  *
- * The supported units of a period are {@link ChronoUnit#YEARS YEARS}, {@link ChronoUnit#MONTHS
- * MONTHS} and {@link ChronoUnit#DAYS DAYS}. All three fields are always present, but may be set to
+ * The supported units of a period are {@@linkChronoUnit#YEARS YEARS} , {@link ChronoUnit#MONTHS
+ * MONTHS} and {@@linkChronoUnit#DAYS DAYS} . All three fields are always present, but may be set to
  * zero.
  *
  * The period may be used with any calendar system. The meaning of a "year" or "month" is only
@@ -309,7 +309,7 @@ object Period {
  * The period is modeled as a directed amount of time, meaning that individual parts of the period
  * may be negative.
  *
- * The months and years fields may be {@linkplain #normalized() normalized}. The normalization
+ * The months and years fields may be {@@linkplain#normalized() normalized} . The normalization
  * assumes a 12 month year, so is not appropriate for all calendar systems.
  *
  * <h3>Specification for implementors</h3> This class is immutable and thread-safe.
@@ -418,7 +418,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * @param years
    *   the years to represent, may be negative
    * @return
-   *   a { @code Period} based on this period with the requested years, not null
+   *   a {@@codePeriod} based on this period with the requested years, not null
    */
   def withYears(years: Int): Period =
     if (years == this.years) this
@@ -438,7 +438,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * @param months
    *   the months to represent, may be negative
    * @return
-   *   a { @code Period} based on this period with the requested months, not null
+   *   a {@@codePeriod} based on this period with the requested months, not null
    */
   def withMonths(months: Int): Period =
     if (months == this.months) this
@@ -455,7 +455,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * @param days
    *   the days to represent, may be negative
    * @return
-   *   a { @code Period} based on this period with the requested days, not null
+   *   a {@@codePeriod} based on this period with the requested days, not null
    */
   def withDays(days: Int): Period =
     if (days == this.days) this
@@ -464,7 +464,7 @@ final class Period private (private val years: Int, private val months: Int, pri
   /**
    * Returns a copy of this period with the specified amount added.
    *
-   * This input amount is converted to a {@code Period} using {@code from(TemporalAmount)}. This
+   * This input amount is converted to a {@@codePeriod} using {@@codefrom(TemporalAmount)} . This
    * operates separately on the years, months and days.
    *
    * For example, "1 year, 6 months and 3 days" plus "2 years, 2 months and 2 days" returns "3
@@ -475,7 +475,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * @param amountToAdd
    *   the period to add, not null
    * @return
-   *   a { @code Period} based on this period with the requested period added, not null
+   *   a {@@codePeriod} based on this period with the requested period added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -499,7 +499,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * @param yearsToAdd
    *   the years to add, positive or negative
    * @return
-   *   a { @code Period} based on this period with the specified years added, not null
+   *   a {@@codePeriod} based on this period with the specified years added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -519,7 +519,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * @param monthsToAdd
    *   the months to add, positive or negative
    * @return
-   *   a { @code Period} based on this period with the specified months added, not null
+   *   a {@@codePeriod} based on this period with the specified months added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -539,7 +539,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * @param daysToAdd
    *   the days to add, positive or negative
    * @return
-   *   a { @code Period} based on this period with the specified days added, not null
+   *   a {@@codePeriod} based on this period with the specified days added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -550,7 +550,7 @@ final class Period private (private val years: Int, private val months: Int, pri
   /**
    * Returns a copy of this period with the specified amount subtracted.
    *
-   * This input amount is converted to a {@code Period} using {@code from(TemporalAmount)}. This
+   * This input amount is converted to a {@@codePeriod} using {@@codefrom(TemporalAmount)} . This
    * operates separately on the years, months and days.
    *
    * For example, "1 year, 6 months and 3 days" minus "2 years, 2 months and 2 days" returns "-1
@@ -561,7 +561,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * @param amountToSubtract
    *   the period to subtract, not null
    * @return
-   *   a { @code Period} based on this period with the requested period subtracted, not null
+   *   a {@@codePeriod} based on this period with the requested period subtracted, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -585,7 +585,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * @param yearsToSubtract
    *   the years to subtract, positive or negative
    * @return
-   *   a { @code Period} based on this period with the specified years subtracted, not null
+   *   a {@@codePeriod} based on this period with the specified years subtracted, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -605,7 +605,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * @param monthsToSubtract
    *   the years to subtract, positive or negative
    * @return
-   *   a { @code Period} based on this period with the specified months subtracted, not null
+   *   a {@@codePeriod} based on this period with the specified months subtracted, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -625,7 +625,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * @param daysToSubtract
    *   the months to subtract, positive or negative
    * @return
-   *   a { @code Period} based on this period with the specified days subtracted, not null
+   *   a {@@codePeriod} based on this period with the specified days subtracted, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -642,7 +642,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * @param scalar
    *   the scalar to multiply by, not null
    * @return
-   *   a { @code Period} based on this period with the amounts multiplied by the scalar, not null
+   *   a {@@codePeriod} based on this period with the amounts multiplied by the scalar, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -658,7 +658,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * Returns a new instance with each amount in this period negated.
    *
    * @return
-   *   a { @code Period} based on this period with the amounts negated, not null
+   *   a {@@codePeriod} based on this period with the amounts negated, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -680,7 +680,7 @@ final class Period private (private val years: Int, private val months: Int, pri
    * This instance is immutable and unaffected by this method call.
    *
    * @return
-   *   a { @code Period} based on this period with excess months normalized to years, not null
+   *   a {@@codePeriod} based on this period with excess months normalized to years, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -817,7 +817,7 @@ final class Period private (private val years: Int, private val months: Int, pri
   override def hashCode: Int = years + Integer.rotateLeft(months, 8) + Integer.rotateLeft(days, 16)
 
   /**
-   * Outputs this period as a {@code String}, such as {@code P6Y3M1D}.
+   * Outputs this period as a {@@codeString} , such as {@@codeP6Y3M1D} .
    *
    * The output will be in the ISO-8601 period format. A zero period will be represented as zero
    * days, 'P0D'.
diff --git a/core/shared/src/main/scala/org/threeten/bp/Year.scala b/core/shared/src/main/scala/org/threeten/bp/Year.scala
index da7cb846c..c5c0995f4 100644
--- a/core/shared/src/main/scala/org/threeten/bp/Year.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/Year.scala
@@ -76,7 +76,7 @@ object Year {
   /**
    * Obtains the current year from the system clock in the default time-zone.
    *
-   * This will query the {@link Clock#systemDefaultZone() system clock} in the default time-zone to
+   * This will query the {@@linkClock#systemDefaultZone() system clock} in the default time-zone to
    * obtain the current year.
    *
    * Using this method will prevent the ability to use an alternate clock for testing because the
@@ -90,7 +90,7 @@ object Year {
   /**
    * Obtains the current year from the system clock in the specified time-zone.
    *
-   * This will query the {@link Clock#system(ZoneId) system clock} to obtain the current year.
+   * This will query the {@@linkClock#system(ZoneId) system clock} to obtain the current year.
    * Specifying the time-zone avoids dependence on the default time-zone.
    *
    * Using this method will prevent the ability to use an alternate clock for testing because the
@@ -121,7 +121,7 @@ object Year {
   }
 
   /**
-   * Obtains an instance of {@code Year}.
+   * Obtains an instance of {@@codeYear} .
    *
    * This method accepts a year value from the proleptic ISO calendar system.
    *
@@ -129,7 +129,7 @@ object Year {
    * 1BC/BCE is represented by 0.<br> The year 2BC/BCE is represented by -1.<br>
    *
    * @param isoYear
-   *   the ISO proleptic year to represent, from { @code MIN_VALUE} to { @code MAX_VALUE}
+   *   the ISO proleptic year to represent, from {@@codeMIN_VALUE} to {@@codeMAX_VALUE}
    * @return
    *   the year, not null
    * @throws DateTimeException
@@ -141,24 +141,24 @@ object Year {
   }
 
   /**
-   * Obtains an instance of {@code Year} from a temporal object.
+   * Obtains an instance of {@@codeYear} from a temporal object.
    *
-   * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code Year}.
+   * A {@@codeTemporalAccessor} represents some form of date and time information. This factory
+   * converts the arbitrary temporal object to an instance of {@@codeYear} .
    *
-   * The conversion extracts the {@link ChronoField#YEAR year} field. The extraction is only
+   * The conversion extracts the {@@linkChronoField#YEAR year} field. The extraction is only
    * permitted if the temporal object has an ISO chronology, or can be converted to a {@code
    * LocalDate}.
    *
-   * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used in queries via method reference, {@code Year::from}.
+   * This method matches the signature of the functional interface {@@linkTemporalQuery} allowing it
+   * to be used in queries via method reference, {@@codeYear::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the year, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code Year}
+   *   if unable to convert to a {@@codeYear}
    */
   def from(temporal: TemporalAccessor): Year = {
     var _temporal = temporal
@@ -180,7 +180,7 @@ object Year {
   }
 
   /**
-   * Obtains an instance of {@code Year} from a text string such as {@code 2007}.
+   * Obtains an instance of {@@codeYear} from a text string such as {@@code2007} .
    *
    * The string must represent a valid year. Years outside the range 0000 to 9999 must be prefixed
    * by the plus or minus symbol.
@@ -195,7 +195,7 @@ object Year {
   def parse(text: CharSequence): Year = parse(text, PARSER)
 
   /**
-   * Obtains an instance of {@code Year} from a text string using a specific formatter.
+   * Obtains an instance of {@@codeYear} from a text string using a specific formatter.
    *
    * The text is parsed using the formatter, returning a year.
    *
@@ -240,9 +240,9 @@ object Year {
 }
 
 /**
- * A year in the ISO-8601 calendar system, such as {@code 2007}.
+ * A year in the ISO-8601 calendar system, such as {@@code2007} .
  *
- * {@code Year} is an immutable date-time object that represents a year. Any field that can be
+ * {@@codeYear} is an immutable date-time object that represents a year. Any field that can be
  * derived from a year can be obtained.
  *
  * <b>Note that years in the ISO chronology only align with years in the Gregorian-Julian system for
@@ -250,7 +250,7 @@ object Year {
  * such, historical years must be treated with caution.</b>
  *
  * This class does not store or represent a month, day, time or time-zone. For example, the value
- * "2007" can be stored in a {@code Year}.
+ * "2007" can be stored in a {@@codeYear} .
  *
  * Years represented by this class follow the ISO-8601 standard and use the proleptic numbering
  * system. Year 1 is preceded by year 0, then by year -1.
@@ -278,10 +278,10 @@ final class Year private (private val year: Int)
   /**
    * Gets the year value.
    *
-   * The year returned by this method is proleptic as per {@code get(YEAR)}.
+   * The year returned by this method is proleptic as per {@@codeget(YEAR)} .
    *
    * @return
-   *   the year, { @code MIN_VALUE} to { @code MAX_VALUE}
+   *   the year, {@@codeMIN_VALUE} to {@@codeMAX_VALUE}
    */
   def getValue: Int = year
 
@@ -289,16 +289,16 @@ final class Year private (private val year: Int)
    * Checks if the specified field is supported.
    *
    * This checks if this year can be queried for the specified field. If false, then calling the
-   * {@link #range(TemporalField) range} and {@link #get(TemporalField) get} methods will throw an
+   * {@@link#range(TemporalField) range} and {@@link#get(TemporalField) get} methods will throw an
    * exception.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this date-time.
    * The supported fields are: <ul> <li>{@code YEAR_OF_ERA} <li>{@code YEAR} <li>{@code ERA} </ul>
-   * All other {@code ChronoField} instances will return false.
+   * All other {@@codeChronoField} instances will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.isSupportedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the field is supported is determined by the field.
    *
    * @param field
@@ -325,12 +325,12 @@ final class Year private (private val year: Int)
    * to enhance the accuracy of the returned range. If it is not possible to return the range,
    * because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return appropriate range instances. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.rangeRefinedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
    * @param field
@@ -348,18 +348,18 @@ final class Year private (private val year: Int)
       super.range(field)
 
   /**
-   * Gets the value of the specified field from this year as an {@code int}.
+   * Gets the value of the specified field from this year as an {@@codeint} .
    *
    * This queries this year for the value for the specified field. The returned value will always be
    * within the valid range of values for the field. If it is not possible to return the value,
    * because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this year. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -375,17 +375,17 @@ final class Year private (private val year: Int)
     range(field).checkValidIntValue(getLong(field), field)
 
   /**
-   * Gets the value of the specified field from this year as a {@code long}.
+   * Gets the value of the specified field from this year as a {@@codelong} .
    *
    * This queries this year for the value for the specified field. If it is not possible to return
    * the value, because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this year. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -450,12 +450,12 @@ final class Year private (private val year: Int)
   /**
    * Returns an adjusted copy of this year.
    *
-   * This returns a new {@code Year}, based on this one, with the year adjusted. The adjustment
+   * This returns a new {@@codeYear} , based on this one, with the year adjusted. The adjustment
    * takes place using the specified adjuster strategy object. Read the documentation of the
    * adjuster to understand what adjustment will be made.
    *
    * The result of this method is obtained by invoking the {@link
-   * TemporalAdjuster#adjustInto(Temporal)} method on the specified adjuster passing {@code this} as
+   * TemporalAdjuster#adjustInto(Temporal)} method on the specified adjuster passing {@@codethis} as
    * the argument.
    *
    * This instance is immutable and unaffected by this method call.
@@ -463,7 +463,7 @@ final class Year private (private val year: Int)
    * @param adjuster
    *   the adjuster to use, not null
    * @return
-   *   a { @code Year} based on { @code this} with the adjustment made, not null
+   *   a {@@codeYear} based on {@@codethis} with the adjustment made, not null
    * @throws DateTimeException
    *   if the adjustment cannot be made
    * @throws ArithmeticException
@@ -475,24 +475,24 @@ final class Year private (private val year: Int)
   /**
    * Returns a copy of this year with the specified field set to a new value.
    *
-   * This returns a new {@code Year}, based on this one, with the value for the specified field
+   * This returns a new {@@codeYear} , based on this one, with the value for the specified field
    * changed. If it is not possible to set the value, because the field is not supported or for some
    * other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the adjustment is implemented here. The supported
-   * fields behave as follows: <ul> <li>{@code YEAR_OF_ERA} - Returns a {@code Year} with the
-   * specified year-of-era The era will be unchanged. <li>{@code YEAR} - Returns a {@code Year} with
-   * the specified year. This completely replaces the date and is equivalent to {@link #of(int)}.
-   * <li>{@code ERA} - Returns a {@code Year} with the specified era. The year-of-era will be
+   * If the field is a {@@linkChronoField} then the adjustment is implemented here. The supported
+   * fields behave as follows: <ul> <li>{@code YEAR_OF_ERA} - Returns a {@@codeYear} with the
+   * specified year-of-era The era will be unchanged. <li>{@code YEAR} - Returns a {@@codeYear} with
+   * the specified year. This completely replaces the date and is equivalent to {@@link#of(int)} .
+   * <li>{@code ERA} - Returns a {@@codeYear} with the specified era. The year-of-era will be
    * unchanged. </ul>
    *
    * In all cases, if the new value is outside the valid range of values for the field then a {@code
    * DateTimeException} will be thrown.
    *
-   * All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * All other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.adjustInto(Temporal, long)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.adjustInto(Temporal, long)} passing {@@codethis} as the argument.
    * In this case, the field determines whether and how to adjust the instant.
    *
    * This instance is immutable and unaffected by this method call.
@@ -502,7 +502,7 @@ final class Year private (private val year: Int)
    * @param newValue
    *   the new value of the field in the result
    * @return
-   *   a { @code Year} based on { @code this} with the specified field set, not null
+   *   a {@@codeYear} based on {@@codethis} with the specified field set, not null
    * @throws DateTimeException
    *   if the field cannot be set
    * @throws ArithmeticException
@@ -526,16 +526,16 @@ final class Year private (private val year: Int)
    * Returns a copy of this year with the specified period added.
    *
    * This method returns a new year based on this year with the specified period added. The adder is
-   * typically {@link Period} but may be any other type implementing the {@link TemporalAmount}
+   * typically {@@linkPeriod} but may be any other type implementing the {@@linkTemporalAmount}
    * interface. The calculation is delegated to the specified adjuster, which typically calls back
-   * to {@link #plus(long, TemporalUnit)}.
+   * to {@@link#plus(long, TemporalUnit)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param amount
    *   the amount to add, not null
    * @return
-   *   a { @code Year} based on this year with the addition made, not null
+   *   a {@@codeYear} based on this year with the addition made, not null
    * @throws DateTimeException
    *   if the addition cannot be made
    * @throws ArithmeticException
@@ -544,12 +544,12 @@ final class Year private (private val year: Int)
   override def plus(amount: TemporalAmount): Year = amount.addTo(this).asInstanceOf[Year]
 
   /**
-   * {@inheritDoc}
+   * {@@inheritDoc}
    *
    * @throws DateTimeException
-   *   { @inheritDoc}
+   *   {@@inheritDoc}
    * @throws ArithmeticException
-   *   { @inheritDoc}
+   *   {@@inheritDoc}
    */
   def plus(amountToAdd: Long, unit: TemporalUnit): Year =
     unit match {
@@ -574,7 +574,7 @@ final class Year private (private val year: Int)
    * @param yearsToAdd
    *   the years to add, may be negative
    * @return
-   *   a { @code Year} based on this year with the period added, not null
+   *   a {@@codeYear} based on this year with the period added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported year range
    */
@@ -588,16 +588,16 @@ final class Year private (private val year: Int)
    * Returns a copy of this year with the specified period subtracted.
    *
    * This method returns a new year based on this year with the specified period subtracted. The
-   * subtractor is typically {@link Period} but may be any other type implementing the {@link
+   * subtractor is typically {@@linkPeriod} but may be any other type implementing the {@link
    * TemporalAmount} interface. The calculation is delegated to the specified adjuster, which
-   * typically calls back to {@link #minus(long, TemporalUnit)}.
+   * typically calls back to {@@link#minus(long, TemporalUnit)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param amount
    *   the amount to subtract, not null
    * @return
-   *   a { @code Year} based on this year with the subtraction made, not null
+   *   a {@@codeYear} based on this year with the subtraction made, not null
    * @throws DateTimeException
    *   if the subtraction cannot be made
    * @throws ArithmeticException
@@ -606,12 +606,12 @@ final class Year private (private val year: Int)
   override def minus(amount: TemporalAmount): Year = amount.subtractFrom(this).asInstanceOf[Year]
 
   /**
-   * {@inheritDoc}
+   * {@@inheritDoc}
    *
    * @throws DateTimeException
-   *   { @inheritDoc}
+   *   {@@inheritDoc}
    * @throws ArithmeticException
-   *   { @inheritDoc}
+   *   {@@inheritDoc}
    */
   override def minus(amountToSubtract: Long, unit: TemporalUnit): Year =
     if (amountToSubtract == Long.MinValue) plus(Long.MaxValue, unit).plus(1, unit)
@@ -625,7 +625,7 @@ final class Year private (private val year: Int)
    * @param yearsToSubtract
    *   the years to subtract, may be negative
    * @return
-   *   a { @code Year} based on this year with the period subtracted, not null
+   *   a {@@codeYear} based on this year with the period subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported year range
    */
@@ -636,12 +636,12 @@ final class Year private (private val year: Int)
   /**
    * Queries this year using the specified query.
    *
-   * This queries this year using the specified query strategy object. The {@code TemporalQuery}
+   * This queries this year using the specified query strategy object. The {@@codeTemporalQuery}
    * object defines the logic to be used to obtain the result. Read the documentation of the query
    * to understand what the result of this method will be.
    *
    * The result of this method is obtained by invoking the {@link
-   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@code this}
+   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@@codethis}
    * as the argument.
    *
    * @tparam R
@@ -673,9 +673,9 @@ final class Year private (private val year: Int)
    * This returns a temporal object of the same observable type as the input with the year changed
    * to be the same as this.
    *
-   * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)} passing {@link
+   * The adjustment is equivalent to using {@@linkTemporal#with(TemporalField, long)} passing {@link
    * ChronoField#YEAR} as the field. If the specified temporal object does not use the ISO calendar
-   * system then a {@code DateTimeException} is thrown.
+   * system then a {@@codeDateTimeException} is thrown.
    *
    * In most cases, it is clearer to reverse the calling pattern by using {@link
    * Temporal#with(TemporalAdjuster)}: <pre> // these two lines are equivalent, but the second
@@ -703,8 +703,8 @@ final class Year private (private val year: Int)
    * Calculates the period between this year and another year in terms of the specified unit.
    *
    * This calculates the period between two years in terms of a single unit. The start and end
-   * points are {@code this} and the specified year. The result will be negative if the end is
-   * before the start. The {@code Temporal} passed to this method must be a {@code Year}. For
+   * points are {@@codethis} and the specified year. The result will be negative if the end is
+   * before the start. The {@@codeTemporal} passed to this method must be a {@@codeYear} . For
    * example, the period in decades between two year can be calculated using {@code
    * startYear.until(endYear, DECADES)}.
    *
@@ -712,24 +712,24 @@ final class Year private (private val year: Int)
    * two years. For example, the period in decades between 2012 and 2031 will only be one decade as
    * it is one year short of two decades.
    *
-   * This method operates in association with {@link TemporalUnit#between}. The result of this
-   * method is a {@code long} representing the amount of the specified unit. By contrast, the result
-   * of {@code between} is an object that can be used directly in addition/subtraction: <pre> long
+   * This method operates in association with {@@linkTemporalUnit#between} . The result of this
+   * method is a {@@codelong} representing the amount of the specified unit. By contrast, the result
+   * of {@@codebetween} is an object that can be used directly in addition/subtraction: <pre> long
    * period = start.until(end, YEARS); // this method dateTime.plus(YEARS.between(start, end)); //
    * use in plus/minus </pre>
    *
-   * The calculation is implemented in this method for {@link ChronoUnit}. The units {@code YEARS},
-   * {@code DECADES}, {@code CENTURIES}, {@code MILLENNIA} and {@code ERAS} are supported. Other
-   * {@code ChronoUnit} values will throw an exception.
+   * The calculation is implemented in this method for {@@linkChronoUnit} . The units {@@codeYEARS}
+   * , {@@codeDECADES} , {@@codeCENTURIES} , {@@codeMILLENNIA} and {@@codeERAS} are supported. Other
+   * {@@codeChronoUnit} values will throw an exception.
    *
-   * If the unit is not a {@code ChronoUnit}, then the result of this method is obtained by invoking
-   * {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first argument and
-   * the input temporal as the second argument.
+   * If the unit is not a {@@codeChronoUnit} , then the result of this method is obtained by
+   * invoking {@@codeTemporalUnit.between(Temporal, Temporal)} passing {@@codethis} as the first
+   * argument and the input temporal as the second argument.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param endExclusive
-   *   the end year, which is converted to a { @code Year}, not null
+   *   the end year, which is converted to a {@@codeYear} , not null
    * @param unit
    *   the unit to measure the period in, not null
    * @return
@@ -758,9 +758,9 @@ final class Year private (private val year: Int)
   }
 
   /**
-   * Combines this year with a day-of-year to create a {@code LocalDate}.
+   * Combines this year with a day-of-year to create a {@@codeLocalDate} .
    *
-   * This returns a {@code LocalDate} formed from this year and the specified day-of-year.
+   * This returns a {@@codeLocalDate} formed from this year and the specified day-of-year.
    *
    * The day-of-year value 366 is only valid in a leap year.
    *
@@ -775,9 +775,9 @@ final class Year private (private val year: Int)
   def atDay(dayOfYear: Int): LocalDate = LocalDate.ofYearDay(year, dayOfYear)
 
   /**
-   * Combines this year with a month to create a {@code YearMonth}.
+   * Combines this year with a month to create a {@@codeYearMonth} .
    *
-   * This returns a {@code YearMonth} formed from this year and the specified month. All possible
+   * This returns a {@@codeYearMonth} formed from this year and the specified month. All possible
    * combinations of year and month are valid.
    *
    * This method can be used as part of a chain to produce a date: <pre> LocalDate date =
@@ -791,9 +791,9 @@ final class Year private (private val year: Int)
   def atMonth(month: Month): YearMonth = YearMonth.of(year, month)
 
   /**
-   * Combines this year with a month to create a {@code YearMonth}.
+   * Combines this year with a month to create a {@@codeYearMonth} .
    *
-   * This returns a {@code YearMonth} formed from this year and the specified month. All possible
+   * This returns a {@@codeYearMonth} formed from this year and the specified month. All possible
    * combinations of year and month are valid.
    *
    * This method can be used as part of a chain to produce a date: <pre> LocalDate date =
@@ -809,9 +809,9 @@ final class Year private (private val year: Int)
   def atMonth(month: Int): YearMonth = YearMonth.of(year, month)
 
   /**
-   * Combines this year with a month-day to create a {@code LocalDate}.
+   * Combines this year with a month-day to create a {@@codeLocalDate} .
    *
-   * This returns a {@code LocalDate} formed from this year and the specified month-day.
+   * This returns a {@@codeLocalDate} formed from this year and the specified month-day.
    *
    * A month-day of February 29th will be adjusted to February 28th in the resulting date if the
    * year is not a leap year.
@@ -827,7 +827,7 @@ final class Year private (private val year: Int)
    * Compares this year to another year.
    *
    * The comparison is based on the value of the year. It is "consistent with equals", as defined by
-   * {@link Comparable}.
+   * {@@linkComparable} .
    *
    * @param other
    *   the other year to compare to, not null
@@ -883,7 +883,7 @@ final class Year private (private val year: Int)
   override def hashCode: Int = year
 
   /**
-   * Outputs this year as a {@code String}.
+   * Outputs this year as a {@@codeString} .
    *
    * @return
    *   a string representation of this year, not null
@@ -891,7 +891,7 @@ final class Year private (private val year: Int)
   override def toString: String = Integer.toString(year)
 
   /**
-   * Outputs this year as a {@code String} using the formatter.
+   * Outputs this year as a {@@codeString} using the formatter.
    *
    * This year will be passed to the formatter {@link DateTimeFormatter#format(TemporalAccessor)
    * print method}.
diff --git a/core/shared/src/main/scala/org/threeten/bp/YearMonth.scala b/core/shared/src/main/scala/org/threeten/bp/YearMonth.scala
index b26ae855c..f59407281 100644
--- a/core/shared/src/main/scala/org/threeten/bp/YearMonth.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/YearMonth.scala
@@ -63,14 +63,14 @@ import org.threeten.bp.temporal.UnsupportedTemporalTypeException
 import org.threeten.bp.temporal.ValueRange
 
 /**
- * A year-month in the ISO-8601 calendar system, such as {@code 2007-12}.
+ * A year-month in the ISO-8601 calendar system, such as {@@code2007-12} .
  *
- * {@code YearMonth} is an immutable date-time object that represents the combination of a year and
+ * {@@codeYearMonth} is an immutable date-time object that represents the combination of a year and
  * month. Any field that can be derived from a year and month, such as quarter-of-year, can be
  * obtained.
  *
  * This class does not store or represent a day, time or time-zone. For example, the value "October
- * 2007" can be stored in a {@code YearMonth}.
+ * 2007" can be stored in a {@@codeYearMonth} .
  *
  * The ISO-8601 calendar system is the modern civil calendar system used today in most of the world.
  * It is equivalent to the proleptic Gregorian calendar system, in which today's rules for leap
@@ -92,7 +92,7 @@ object YearMonth {
   /**
    * Obtains the current year-month from the system clock in the default time-zone.
    *
-   * This will query the {@link Clock#systemDefaultZone() system clock} in the default time-zone to
+   * This will query the {@@linkClock#systemDefaultZone() system clock} in the default time-zone to
    * obtain the current year-month. The zone and offset will be set based on the time-zone in the
    * clock.
    *
@@ -107,7 +107,7 @@ object YearMonth {
   /**
    * Obtains the current year-month from the system clock in the specified time-zone.
    *
-   * This will query the {@link Clock#system(ZoneId) system clock} to obtain the current year-month.
+   * This will query the {@@linkClock#system(ZoneId) system clock} to obtain the current year-month.
    * Specifying the time-zone avoids dependence on the default time-zone.
    *
    * Using this method will prevent the ability to use an alternate clock for testing because the
@@ -138,7 +138,7 @@ object YearMonth {
   }
 
   /**
-   * Obtains an instance of {@code YearMonth} from a year and month.
+   * Obtains an instance of {@@codeYearMonth} from a year and month.
    *
    * @param year
    *   the year to represent, from MIN_YEAR to MAX_YEAR
@@ -155,7 +155,7 @@ object YearMonth {
   }
 
   /**
-   * Obtains an instance of {@code YearMonth} from a year and month.
+   * Obtains an instance of {@@codeYearMonth} from a year and month.
    *
    * @param year
    *   the year to represent, from MIN_YEAR to MAX_YEAR
@@ -173,24 +173,24 @@ object YearMonth {
   }
 
   /**
-   * Obtains an instance of {@code YearMonth} from a temporal object.
+   * Obtains an instance of {@@codeYearMonth} from a temporal object.
    *
-   * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code YearMonth}.
+   * A {@@codeTemporalAccessor} represents some form of date and time information. This factory
+   * converts the arbitrary temporal object to an instance of {@@codeYearMonth} .
    *
-   * The conversion extracts the {@link ChronoField#YEAR YEAR} and {@link ChronoField#MONTH_OF_YEAR
+   * The conversion extracts the {@@linkChronoField#YEAR YEAR} and {@link ChronoField#MONTH_OF_YEAR
    * MONTH_OF_YEAR} fields. The extraction is only permitted if the temporal object has an ISO
-   * chronology, or can be converted to a {@code LocalDate}.
+   * chronology, or can be converted to a {@@codeLocalDate} .
    *
-   * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used in queries via method reference, {@code YearMonth::from}.
+   * This method matches the signature of the functional interface {@@linkTemporalQuery} allowing it
+   * to be used in queries via method reference, {@@codeYearMonth::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the year-month, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code YearMonth}
+   *   if unable to convert to a {@@codeYearMonth}
    */
   def from(temporal: TemporalAccessor): YearMonth = {
     var _temporal = temporal
@@ -209,10 +209,10 @@ object YearMonth {
   }
 
   /**
-   * Obtains an instance of {@code YearMonth} from a text string such as {@code 2007-12}.
+   * Obtains an instance of {@@codeYearMonth} from a text string such as {@@code2007-12} .
    *
-   * The string must represent a valid year-month. The format must be {@code yyyy-MM}. Years outside
-   * the range 0000 to 9999 must be prefixed by the plus or minus symbol.
+   * The string must represent a valid year-month. The format must be {@@codeyyyy-MM} . Years
+   * outside the range 0000 to 9999 must be prefixed by the plus or minus symbol.
    *
    * @param text
    *   the text to parse such as "2007-12", not null
@@ -224,7 +224,7 @@ object YearMonth {
   def parse(text: CharSequence): YearMonth = parse(text, PARSER)
 
   /**
-   * Obtains an instance of {@code YearMonth} from a text string using a specific formatter.
+   * Obtains an instance of {@@codeYearMonth} from a text string using a specific formatter.
    *
    * The text is parsed using the formatter, returning a year-month.
    *
@@ -284,17 +284,17 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * Checks if the specified field is supported.
    *
    * This checks if this year-month can be queried for the specified field. If false, then calling
-   * the {@link #range(TemporalField) range} and {@link #get(TemporalField) get} methods will throw
+   * the {@@link#range(TemporalField) range} and {@@link#get(TemporalField) get} methods will throw
    * an exception.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this date-time.
    * The supported fields are: <ul> <li>{@code MONTH_OF_YEAR} <li>{@code EPOCH_MONTH} <li>{@code
-   * YEAR_OF_ERA} <li>{@code YEAR} <li>{@code ERA} </ul> All other {@code ChronoField} instances
+   * YEAR_OF_ERA} <li>{@code YEAR} <li>{@code ERA} </ul> All other {@@codeChronoField} instances
    * will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.isSupportedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the field is supported is determined by the field.
    *
    * @param field
@@ -321,12 +321,12 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * used to enhance the accuracy of the returned range. If it is not possible to return the range,
    * because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return appropriate range instances. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.rangeRefinedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
    * @param field
@@ -347,20 +347,20 @@ final class YearMonth private (private val year: Int, private val month: Int)
       field.rangeRefinedBy(this)
 
   /**
-   * Gets the value of the specified field from this year-month as an {@code int}.
+   * Gets the value of the specified field from this year-month as an {@@codeint} .
    *
    * This queries this year-month for the value for the specified field. The returned value will
    * always be within the valid range of values for the field. If it is not possible to return the
    * value, because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this
-   * year-month, except {@code EPOCH_MONTH} which is too large to fit in an {@code int} and throw a
-   * {@code DateTimeException}. All other {@code ChronoField} instances will throw a {@code
+   * year-month, except {@@codeEPOCH_MONTH} which is too large to fit in an {@@codeint} and throw a
+   * {@@codeDateTimeException} . All other {@@codeChronoField} instances will throw a {@code
    * DateTimeException}.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -376,18 +376,18 @@ final class YearMonth private (private val year: Int, private val month: Int)
     range(field).checkValidIntValue(getLong(field), field)
 
   /**
-   * Gets the value of the specified field from this year-month as a {@code long}.
+   * Gets the value of the specified field from this year-month as a {@@codelong} .
    *
    * This queries this year-month for the value for the specified field. If it is not possible to
    * return the value, because the field is not supported or for some other reason, an exception is
    * thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this
-   * year-month. All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * year-month. All other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -416,9 +416,9 @@ final class YearMonth private (private val year: Int, private val month: Int)
   /**
    * Gets the year field.
    *
-   * This method returns the primitive {@code int} value for the year.
+   * This method returns the primitive {@@codeint} value for the year.
    *
-   * The year returned by this method is proleptic as per {@code get(YEAR)}.
+   * The year returned by this method is proleptic as per {@@codeget(YEAR)} .
    *
    * @return
    *   the year, from MIN_YEAR to MAX_YEAR
@@ -428,8 +428,8 @@ final class YearMonth private (private val year: Int, private val month: Int)
   /**
    * Gets the month-of-year field from 1 to 12.
    *
-   * This method returns the month as an {@code int} from 1 to 12. Application code is frequently
-   * clearer if the enum {@link Month} is used by calling {@link #getMonth()}.
+   * This method returns the month as an {@@codeint} from 1 to 12. Application code is frequently
+   * clearer if the enum {@@linkMonth} is used by calling {@@link#getMonth()} .
    *
    * @return
    *   the month-of-year, from 1 to 12
@@ -439,11 +439,11 @@ final class YearMonth private (private val year: Int, private val month: Int)
   def getMonthValue: Int = month
 
   /**
-   * Gets the month-of-year field using the {@code Month} enum.
+   * Gets the month-of-year field using the {@@codeMonth} enum.
    *
-   * This method returns the enum {@link Month} for the month. This avoids confusion as to what
-   * {@code int} values mean. If you need access to the primitive {@code int} value then the enum
-   * provides the {@link Month#getValue() int value}.
+   * This method returns the enum {@@linkMonth} for the month. This avoids confusion as to what
+   * {@@codeint} values mean. If you need access to the primitive {@@codeint} value then the enum
+   * provides the {@@linkMonth#getValue() int value} .
    *
    * @return
    *   the month-of-year, not null
@@ -503,7 +503,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
   /**
    * Returns an adjusted copy of this year-month.
    *
-   * This returns a new {@code YearMonth}, based on this one, with the year-month adjusted. The
+   * This returns a new {@@codeYearMonth} , based on this one, with the year-month adjusted. The
    * adjustment takes place using the specified adjuster strategy object. Read the documentation of
    * the adjuster to understand what adjustment will be made.
    *
@@ -512,7 +512,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * Earth.
    *
    * The result of this method is obtained by invoking the {@link
-   * TemporalAdjuster#adjustInto(Temporal)} method on the specified adjuster passing {@code this} as
+   * TemporalAdjuster#adjustInto(Temporal)} method on the specified adjuster passing {@@codethis} as
    * the argument.
    *
    * This instance is immutable and unaffected by this method call.
@@ -520,7 +520,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * @param adjuster
    *   the adjuster to use, not null
    * @return
-   *   a { @code YearMonth} based on { @code this} with the adjustment made, not null
+   *   a {@@codeYearMonth} based on {@@codethis} with the adjustment made, not null
    * @throws DateTimeException
    *   if the adjustment cannot be made
    * @throws ArithmeticException
@@ -532,27 +532,27 @@ final class YearMonth private (private val year: Int, private val month: Int)
   /**
    * Returns a copy of this year-month with the specified field set to a new value.
    *
-   * This returns a new {@code YearMonth}, based on this one, with the value for the specified field
-   * changed. This can be used to change any supported field, such as the year or month. If it is
-   * not possible to set the value, because the field is not supported or for some other reason, an
-   * exception is thrown.
+   * This returns a new {@@codeYearMonth} , based on this one, with the value for the specified
+   * field changed. This can be used to change any supported field, such as the year or month. If it
+   * is not possible to set the value, because the field is not supported or for some other reason,
+   * an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the adjustment is implemented here. The supported
-   * fields behave as follows: <ul> <li>{@code MONTH_OF_YEAR} - Returns a {@code YearMonth} with the
+   * If the field is a {@@linkChronoField} then the adjustment is implemented here. The supported
+   * fields behave as follows: <ul> <li>{@code MONTH_OF_YEAR} - Returns a {@@codeYearMonth} with the
    * specified month-of-year. The year will be unchanged. <li>{@code PROLEPTIC_MONTH} - Returns a
-   * {@code YearMonth} with the specified proleptic-month. This completely replaces the year and
-   * month of this object. <li>{@code YEAR_OF_ERA} - Returns a {@code YearMonth} with the specified
-   * year-of-era The month and era will be unchanged. <li>{@code YEAR} - Returns a {@code YearMonth}
+   * {@@codeYearMonth} with the specified proleptic-month. This completely replaces the year and
+   * month of this object. <li>{@code YEAR_OF_ERA} - Returns a {@@codeYearMonth} with the specified
+   * year-of-era The month and era will be unchanged. <li>{@code YEAR} - Returns a {@@codeYearMonth}
    * with the specified year. The month will be unchanged. <li>{@code ERA} - Returns a {@code
    * YearMonth} with the specified era. The month and year-of-era will be unchanged. </ul>
    *
    * In all cases, if the new value is outside the valid range of values for the field then a {@code
    * DateTimeException} will be thrown.
    *
-   * All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * All other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.adjustInto(Temporal, long)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.adjustInto(Temporal, long)} passing {@@codethis} as the argument.
    * In this case, the field determines whether and how to adjust the instant.
    *
    * This instance is immutable and unaffected by this method call.
@@ -562,7 +562,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * @param newValue
    *   the new value of the field in the result
    * @return
-   *   a { @code YearMonth} based on { @code this} with the specified field set, not null
+   *   a {@@codeYearMonth} based on {@@codethis} with the specified field set, not null
    * @throws DateTimeException
    *   if the field cannot be set
    * @throws ArithmeticException
@@ -591,14 +591,14 @@ final class YearMonth private (private val year: Int, private val month: Int)
   }
 
   /**
-   * Returns a copy of this {@code YearMonth} with the year altered.
+   * Returns a copy of this {@@codeYearMonth} with the year altered.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param year
    *   the year to set in the returned year-month, from MIN_YEAR to MAX_YEAR
    * @return
-   *   a { @code YearMonth} based on this year-month with the requested year, not null
+   *   a {@@codeYearMonth} based on this year-month with the requested year, not null
    * @throws DateTimeException
    *   if the year value is invalid
    */
@@ -608,14 +608,14 @@ final class YearMonth private (private val year: Int, private val month: Int)
   }
 
   /**
-   * Returns a copy of this {@code YearMonth} with the month-of-year altered.
+   * Returns a copy of this {@@codeYearMonth} with the month-of-year altered.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param month
    *   the month-of-year to set in the returned year-month, from 1 (January) to 12 (December)
    * @return
-   *   a { @code YearMonth} based on this year-month with the requested month, not null
+   *   a {@@codeYearMonth} based on this year-month with the requested month, not null
    * @throws DateTimeException
    *   if the month-of-year value is invalid
    */
@@ -628,16 +628,16 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * Returns a copy of this year-month with the specified period added.
    *
    * This method returns a new year-month based on this year-month with the specified period added.
-   * The adder is typically {@link org.threeten.bp.Period Period} but may be any other type
-   * implementing the {@link TemporalAmount} interface. The calculation is delegated to the
-   * specified adjuster, which typically calls back to {@link #plus(long, TemporalUnit)}.
+   * The adder is typically {@@linkorg.threeten.bp.Period Period} but may be any other type
+   * implementing the {@@linkTemporalAmount} interface. The calculation is delegated to the
+   * specified adjuster, which typically calls back to {@@link#plus(long, TemporalUnit)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param amount
    *   the amount to add, not null
    * @return
-   *   a { @code YearMonth} based on this year-month with the addition made, not null
+   *   a {@@codeYearMonth} based on this year-month with the addition made, not null
    * @throws DateTimeException
    *   if the addition cannot be made
    * @throws ArithmeticException
@@ -646,12 +646,12 @@ final class YearMonth private (private val year: Int, private val month: Int)
   override def plus(amount: TemporalAmount): YearMonth = amount.addTo(this).asInstanceOf[YearMonth]
 
   /**
-   * {@inheritDoc}
+   * {@@inheritDoc}
    *
    * @throws DateTimeException
-   *   { @inheritDoc}
+   *   {@@inheritDoc}
    * @throws ArithmeticException
-   *   { @inheritDoc}
+   *   {@@inheritDoc}
    */
   def plus(amountToAdd: Long, unit: TemporalUnit): YearMonth =
     if (unit.isInstanceOf[ChronoUnit])
@@ -675,7 +675,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * @param yearsToAdd
    *   the years to add, may be negative
    * @return
-   *   a { @code YearMonth} based on this year-month with the years added, not null
+   *   a {@@codeYearMonth} based on this year-month with the years added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported range
    */
@@ -695,7 +695,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * @param monthsToAdd
    *   the months to add, may be negative
    * @return
-   *   a { @code YearMonth} based on this year-month with the months added, not null
+   *   a {@@codeYearMonth} based on this year-month with the months added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported range
    */
@@ -713,16 +713,16 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * Returns a copy of this year-month with the specified period subtracted.
    *
    * This method returns a new year-month based on this year-month with the specified period
-   * subtracted. The subtractor is typically {@link org.threeten.bp.Period Period} but may be any
-   * other type implementing the {@link TemporalAmount} interface. The calculation is delegated to
-   * the specified adjuster, which typically calls back to {@link #minus(long, TemporalUnit)}.
+   * subtracted. The subtractor is typically {@@linkorg.threeten.bp.Period Period} but may be any
+   * other type implementing the {@@linkTemporalAmount} interface. The calculation is delegated to
+   * the specified adjuster, which typically calls back to {@@link#minus(long, TemporalUnit)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param amount
    *   the amount to aubtract, not null
    * @return
-   *   a { @code YearMonth} based on this year-month with the subtraction made, not null
+   *   a {@@codeYearMonth} based on this year-month with the subtraction made, not null
    * @throws DateTimeException
    *   if the subtraction cannot be made
    * @throws ArithmeticException
@@ -732,12 +732,12 @@ final class YearMonth private (private val year: Int, private val month: Int)
     amount.subtractFrom(this).asInstanceOf[YearMonth]
 
   /**
-   * {@inheritDoc}
+   * {@@inheritDoc}
    *
    * @throws DateTimeException
-   *   { @inheritDoc}
+   *   {@@inheritDoc}
    * @throws ArithmeticException
-   *   { @inheritDoc}
+   *   {@@inheritDoc}
    */
   override def minus(amountToSubtract: Long, unit: TemporalUnit): YearMonth =
     if (amountToSubtract == Long.MinValue) plus(Long.MaxValue, unit).plus(1, unit)
@@ -751,7 +751,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * @param yearsToSubtract
    *   the years to subtract, may be negative
    * @return
-   *   a { @code YearMonth} based on this year-month with the years subtracted, not null
+   *   a {@@codeYearMonth} based on this year-month with the years subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported range
    */
@@ -767,7 +767,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * @param monthsToSubtract
    *   the months to subtract, may be negative
    * @return
-   *   a { @code YearMonth} based on this year-month with the months subtracted, not null
+   *   a {@@codeYearMonth} based on this year-month with the months subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported range
    */
@@ -783,7 +783,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * of the query to understand what the result of this method will be.
    *
    * The result of this method is obtained by invoking the {@link
-   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@code this}
+   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@@codethis}
    * as the argument.
    *
    * @tparam R
@@ -815,9 +815,9 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * This returns a temporal object of the same observable type as the input with the year and month
    * changed to be the same as this.
    *
-   * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)} passing {@link
+   * The adjustment is equivalent to using {@@linkTemporal#with(TemporalField, long)} passing {@link
    * ChronoField#PROLEPTIC_MONTH} as the field. If the specified temporal object does not use the
-   * ISO calendar system then a {@code DateTimeException} is thrown.
+   * ISO calendar system then a {@@codeDateTimeException} is thrown.
    *
    * In most cases, it is clearer to reverse the calling pattern by using {@link
    * Temporal#with(TemporalAdjuster)}: <pre> // these two lines are equivalent, but the second
@@ -846,8 +846,8 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * unit.
    *
    * This calculates the period between two year-months in terms of a single unit. The start and end
-   * points are {@code this} and the specified year-month. The result will be negative if the end is
-   * before the start. The {@code Temporal} passed to this method must be a {@code YearMonth}. For
+   * points are {@@codethis} and the specified year-month. The result will be negative if the end is
+   * before the start. The {@@codeTemporal} passed to this method must be a {@@codeYearMonth} . For
    * example, the period in years between two year-months can be calculated using {@code
    * startYearMonth.until(endYearMonth, YEARS)}.
    *
@@ -855,26 +855,26 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * two year-months. For example, the period in decades between 2012-06 and 2032-05 will only be
    * one decade as it is one month short of two decades.
    *
-   * This method operates in association with {@link TemporalUnit#between}. The result of this
-   * method is a {@code long} representing the amount of the specified unit. By contrast, the result
-   * of {@code between} is an object that can be used directly in addition/subtraction:
+   * This method operates in association with {@@linkTemporalUnit#between} . The result of this
+   * method is a {@@codelong} representing the amount of the specified unit. By contrast, the result
+   * of {@@codebetween} is an object that can be used directly in addition/subtraction:
    * {{{
    * val period: Long = start.until(end, YEARS);   // this method
    * dateTime.plus(YEARS.between(start, end));     // use in plus/minus
    * }}}
    *
-   * The calculation is implemented in this method for {@link ChronoUnit}. The units {@code MONTHS},
-   * {@code YEARS}, {@code DECADES}, {@code CENTURIES}, {@code MILLENNIA} and {@code ERAS} are
-   * supported. Other {@code ChronoUnit} values will throw an exception.
+   * The calculation is implemented in this method for {@@linkChronoUnit} . The units {@@codeMONTHS}
+   * , {@@codeYEARS} , {@@codeDECADES} , {@@codeCENTURIES} , {@@codeMILLENNIA} and {@@codeERAS} are
+   * supported. Other {@@codeChronoUnit} values will throw an exception.
    *
-   * If the unit is not a {@code ChronoUnit}, then the result of this method is obtained by invoking
-   * {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first argument and
-   * the input temporal as the second argument.
+   * If the unit is not a {@@codeChronoUnit} , then the result of this method is obtained by
+   * invoking {@@codeTemporalUnit.between(Temporal, Temporal)} passing {@@codethis} as the first
+   * argument and the input temporal as the second argument.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param endExclusive
-   *   the end year-month, which is converted to a { @code YearMonth}, not null
+   *   the end year-month, which is converted to a {@@codeYearMonth} , not null
    * @param unit
    *   the unit to measure the period in, not null
    * @return
@@ -903,9 +903,9 @@ final class YearMonth private (private val year: Int, private val month: Int)
   }
 
   /**
-   * Combines this year-month with a day-of-month to create a {@code LocalDate}.
+   * Combines this year-month with a day-of-month to create a {@@codeLocalDate} .
    *
-   * This returns a {@code LocalDate} formed from this year-month and the specified day-of-month.
+   * This returns a {@@codeLocalDate} formed from this year-month and the specified day-of-month.
    *
    * The day-of-month value must be valid for the year-month.
    *
@@ -924,9 +924,9 @@ final class YearMonth private (private val year: Int, private val month: Int)
   def atDay(dayOfMonth: Int): LocalDate = LocalDate.of(year, month, dayOfMonth)
 
   /**
-   * Returns a {@code LocalDate} at the end of the month.
+   * Returns a {@@codeLocalDate} at the end of the month.
    *
-   * This returns a {@code LocalDate} based on this year-month. The day-of-month is set to the last
+   * This returns a {@@codeLocalDate} based on this year-month. The day-of-month is set to the last
    * valid day of the month, taking into account leap years.
    *
    * This method can be used as part of a chain to produce a date: <pre> LocalDate date =
@@ -941,7 +941,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
    * Compares this year-month to another year-month.
    *
    * The comparison is based first on the value of the year, then on the value of the month. It is
-   * "consistent with equals", as defined by {@link Comparable}.
+   * "consistent with equals", as defined by {@@linkComparable} .
    *
    * @param other
    *   the other year-month to compare to, not null
@@ -1002,9 +1002,9 @@ final class YearMonth private (private val year: Int, private val month: Int)
   override def hashCode: Int = year ^ (month << 27)
 
   /**
-   * Outputs this year-month as a {@code String}, such as {@code 2007-12}.
+   * Outputs this year-month as a {@@codeString} , such as {@@code2007-12} .
    *
-   * The output will be in the format {@code yyyy-MM}:
+   * The output will be in the format {@@codeyyyy-MM} :
    *
    * @return
    *   a string representation of this year-month, not null
@@ -1023,7 +1023,7 @@ final class YearMonth private (private val year: Int, private val month: Int)
   }
 
   /**
-   * Outputs this year-month as a {@code String} using the formatter.
+   * Outputs this year-month as a {@@codeString} using the formatter.
    *
    * This year-month will be passed to the formatter {@link
    * DateTimeFormatter#format(TemporalAccessor) print method}.
diff --git a/core/shared/src/main/scala/org/threeten/bp/ZoneId.scala b/core/shared/src/main/scala/org/threeten/bp/ZoneId.scala
index 4c24a006f..ace4140b1 100644
--- a/core/shared/src/main/scala/org/threeten/bp/ZoneId.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/ZoneId.scala
@@ -50,8 +50,8 @@ object ZoneId {
   /**
    * A map of zone overrides to enable the short time-zone names to be used.
    *
-   * Use of short zone IDs has been deprecated in {@code java.util.TimeZone}. This map allows the
-   * IDs to continue to be used via the {@link #of(String, Map)} factory method.
+   * Use of short zone IDs has been deprecated in {@@codejava.util.TimeZone} . This map allows the
+   * IDs to continue to be used via the {@@link#of(String, Map)} factory method.
    *
    * This map contains a mapping of the IDs that is in line with TZDB 2005r and later, where 'EST',
    * 'MST' and 'HST' map to IDs which do not include daylight savings.
@@ -104,9 +104,9 @@ object ZoneId {
   /**
    * Gets the system default time-zone.
    *
-   * This queries {@link TimeZone#getDefault()} to find the default time-zone and converts it to a
-   * {@code ZoneId}. If the system default time-zone is changed, then the result of this method will
-   * also change.
+   * This queries {@@linkTimeZone#getDefault()} to find the default time-zone and converts it to a
+   * {@@codeZoneId} . If the system default time-zone is changed, then the result of this method
+   * will also change.
    *
    * @return
    *   the zone ID, not null
@@ -121,8 +121,8 @@ object ZoneId {
    * Gets the set of available zone IDs.
    *
    * This set includes the string form of all available region-based IDs. Offset-based zone IDs are
-   * not included in the returned set. The ID can be passed to {@link #of(String)} to create a
-   * {@code ZoneId}.
+   * not included in the returned set. The ID can be passed to {@@link#of(String)} to create a
+   * {@@codeZoneId} .
    *
    * The set of zone IDs can increase over time, although in a typical application the set of IDs is
    * fixed. Each call to this method is thread-safe.
@@ -134,7 +134,7 @@ object ZoneId {
     new java.util.HashSet(ZoneRulesProvider.getAvailableZoneIds)
 
   /**
-   * Obtains an instance of {@code ZoneId} using its ID using a map of aliases to supplement the
+   * Obtains an instance of {@@codeZoneId} using its ID using a map of aliases to supplement the
    * standard zone IDs.
    *
    * Many users of time-zones use short abbreviations, such as PST for 'Pacific Standard Time' and
@@ -160,31 +160,31 @@ object ZoneId {
     of(aliasMap.get(zoneId).getOrElse(zoneId))
 
   /**
-   * Obtains an instance of {@code ZoneId} from an ID ensuring that the ID is valid and available
+   * Obtains an instance of {@@codeZoneId} from an ID ensuring that the ID is valid and available
    * for use.
    *
-   * This method parses the ID producing a {@code ZoneId} or {@code ZoneOffset}. A {@code
+   * This method parses the ID producing a {@@codeZoneId} or {@@codeZoneOffset} . A {@code
    * ZoneOffset} is returned if the ID is 'Z', or starts with '+' or '-'. The result will always be
-   * a valid ID for which {@link ZoneRules} can be obtained.
+   * a valid ID for which {@@linkZoneRules} can be obtained.
    *
    * Parsing matches the zone ID step by step as follows. <ul> <li>If the zone ID equals 'Z', the
-   * result is {@code ZoneOffset.UTC}. <li>If the zone ID consists of a single letter, the zone ID
-   * is invalid and {@code DateTimeException} is thrown. <li>If the zone ID starts with '+' or '-',
-   * the ID is parsed as a {@code ZoneOffset} using {@link ZoneOffset#of(String)}. <li>If the zone
-   * ID equals 'GMT', 'UTC' or 'UT' then the result is a {@code ZoneId} with the same ID and rules
-   * equivalent to {@code ZoneOffset.UTC}. <li>If the zone ID starts with 'UTC+', 'UTC-', 'GMT+',
+   * result is {@@codeZoneOffset.UTC} . <li>If the zone ID consists of a single letter, the zone ID
+   * is invalid and {@@codeDateTimeException} is thrown. <li>If the zone ID starts with '+' or '-',
+   * the ID is parsed as a {@@codeZoneOffset} using {@@linkZoneOffset#of(String)} . <li>If the zone
+   * ID equals 'GMT', 'UTC' or 'UT' then the result is a {@@codeZoneId} with the same ID and rules
+   * equivalent to {@@codeZoneOffset.UTC} . <li>If the zone ID starts with 'UTC+', 'UTC-', 'GMT+',
    * 'GMT-', 'UT+' or 'UT-' then the ID is a prefixed offset-based ID. The ID is split in two, with
    * a two or three letter prefix and a suffix starting with the sign. The suffix is parsed as a
-   * {@link ZoneOffset#of(String) ZoneOffset}. The result will be a {@code ZoneId} with the
-   * specified UTC/GMT/UT prefix and the normalized offset ID as per {@link ZoneOffset#getId()}. The
-   * rules of the returned {@code ZoneId} will be equivalent to the parsed {@code ZoneOffset}.
+   * {@@linkZoneOffset#of(String) ZoneOffset} . The result will be a {@@codeZoneId} with the
+   * specified UTC/GMT/UT prefix and the normalized offset ID as per {@@linkZoneOffset#getId()} .
+   * The rules of the returned {@@codeZoneId} will be equivalent to the parsed {@@codeZoneOffset} .
    * <li>All other IDs are parsed as region-based zone IDs. Region IDs must match the regular
-   * expression <code>[A-Za-z][A-Za-z0-9~/._+-]+</code> otherwise a {@code DateTimeException} is
-   * thrown. If the zone ID is not in the configured set of IDs, {@code ZoneRulesException} is
+   * expression <code>[A-Za-z][A-Za-z0-9~/._+-]+</code> otherwise a {@@codeDateTimeException} is
+   * thrown. If the zone ID is not in the configured set of IDs, {@@codeZoneRulesException} is
    * thrown. The detailed format of the region ID depends on the group supplying the data. The
    * default set of data is supplied by the IANA Time Zone Database (TZDB). This has region IDs of
    * the form '{area}/{city}', such as 'Europe/Paris' or 'America/New_York'. This is compatible with
-   * most IDs from {@link java.util.TimeZone}. </ul>
+   * most IDs from {@@linkjava.util.TimeZone} . </ul>
    *
    * @param zoneId
    *   the time-zone ID, not null
@@ -225,10 +225,10 @@ object ZoneId {
   }
 
   /**
-   * Obtains an instance of {@code ZoneId} wrapping an offset.
+   * Obtains an instance of {@@codeZoneId} wrapping an offset.
    *
-   * If the prefix is "GMT", "UTC", or "UT" a {@code ZoneId} with the prefix and the non-zero offset
-   * is returned. If the prefix is empty {@code ""} the {@code ZoneOffset} is returned.
+   * If the prefix is "GMT", "UTC", or "UT" a {@@codeZoneId} with the prefix and the non-zero offset
+   * is returned. If the prefix is empty {@@code""} the {@@codeZoneOffset} is returned.
    *
    * @param prefix
    *   the time-zone ID, not null
@@ -253,23 +253,23 @@ object ZoneId {
   }
 
   /**
-   * Obtains an instance of {@code ZoneId} from a temporal object.
+   * Obtains an instance of {@@codeZoneId} from a temporal object.
    *
-   * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code ZoneId}.
+   * A {@@codeTemporalAccessor} represents some form of date and time information. This factory
+   * converts the arbitrary temporal object to an instance of {@@codeZoneId} .
    *
    * The conversion will try to obtain the zone in a way that favours region-based zones over
-   * offset-based zones using {@link TemporalQueries#zone()}.
+   * offset-based zones using {@@linkTemporalQueries#zone()} .
    *
-   * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used in queries via method reference, {@code ZoneId::from}.
+   * This method matches the signature of the functional interface {@@linkTemporalQuery} allowing it
+   * to be used in queries via method reference, {@@codeZoneId::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the zone ID, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code ZoneId}
+   *   if unable to convert to a {@@codeZoneId}
    */
   def from(temporal: TemporalAccessor): ZoneId = {
     val obj: ZoneId = temporal.query(TemporalQueries.zone)
@@ -282,38 +282,38 @@ object ZoneId {
 }
 
 /**
- * A time-zone ID, such as {@code Europe/Paris}.
+ * A time-zone ID, such as {@@codeEurope/Paris} .
  *
- * A {@code ZoneId} is used to identify the rules used to convert between an {@link Instant} and a
- * {@link LocalDateTime}. There are two distinct types of ID: <ul> <li>Fixed offsets - a fully
+ * A {@@codeZoneId} is used to identify the rules used to convert between an {@@linkInstant} and a
+ * {@@linkLocalDateTime} . There are two distinct types of ID: <ul> <li>Fixed offsets - a fully
  * resolved offset from UTC/Greenwich, that uses the same offset for all local date-times
  * <li>Geographical regions - an area where a specific set of rules for finding the offset from
- * UTC/Greenwich apply </ul> Most fixed offsets are represented by {@link ZoneOffset}. Calling
- * {@link #normalized()} on any {@code ZoneId} will ensure that a fixed offset ID will be
- * represented as a {@code ZoneOffset}.
+ * UTC/Greenwich apply </ul> Most fixed offsets are represented by {@@linkZoneOffset} . Calling
+ * {@@link#normalized()} on any {@@codeZoneId} will ensure that a fixed offset ID will be
+ * represented as a {@@codeZoneOffset} .
  *
- * The actual rules, describing when and how the offset changes, are defined by {@link ZoneRules}.
+ * The actual rules, describing when and how the offset changes, are defined by {@@linkZoneRules} .
  * This class is simply an ID used to obtain the underlying rules. This approach is taken because
  * rules are defined by governments and change frequently, whereas the ID is stable.
  *
- * The distinction has other effects. Serializing the {@code ZoneId} will only send the ID, whereas
+ * The distinction has other effects. Serializing the {@@codeZoneId} will only send the ID, whereas
  * serializing the rules sends the entire data set. Similarly, a comparison of two IDs only examines
  * the ID, whereas a comparison of two rules examines the entire data set.
  *
  * <h3>Time-zone IDs</h3> The ID is unique within the system. There are three types of ID.
  *
- * The simplest type of ID is that from {@code ZoneOffset}. This consists of 'Z' and IDs starting
+ * The simplest type of ID is that from {@@codeZoneOffset} . This consists of 'Z' and IDs starting
  * with '+' or '-'.
  *
  * The next type of ID are offset-style IDs with some form of prefix, such as 'GMT+2' or
  * 'UTC+01:00'. The recognised prefixes are 'UTC', 'GMT' and 'UT'. The offset is the suffix and will
- * be normalized during creation. These IDs can be normalized to a {@code ZoneOffset} using {@code
+ * be normalized during creation. These IDs can be normalized to a {@@codeZoneOffset} using {@code
  * normalized()}.
  *
  * The third type of ID are region-based IDs. A region-based ID must be of two or more characters,
  * and not start with 'UTC', 'GMT', 'UT' '+' or '-'. Region-based IDs are defined by configuration,
- * see {@link ZoneRulesProvider}. The configuration focuses on providing the lookup from the ID to
- * the underlying {@code ZoneRules}.
+ * see {@@linkZoneRulesProvider} . The configuration focuses on providing the lookup from the ID to
+ * the underlying {@@codeZoneRules} .
  *
  * Time-zone rules are defined by governments and change frequently. There are a number of
  * organizations, known here as groups, that monitor time-zone changes and collate them. The default
@@ -330,20 +330,20 @@ object ZoneId {
  * 'group~region'. Thus if IATA data were defined, Utrecht airport would be 'IATA~UTC'.
  *
  * <h3>Serialization</h3> This class can be serialized and stores the string zone ID in the external
- * form. The {@code ZoneOffset} subclass uses a dedicated format that only stores the offset from
+ * form. The {@@codeZoneOffset} subclass uses a dedicated format that only stores the offset from
  * UTC/Greenwich.
  *
- * A {@code ZoneId} can be deserialized in a Java Runtime where the ID is unknown. For example, if a
+ * A {@@codeZoneId} can be deserialized in a Java Runtime where the ID is unknown. For example, if a
  * server-side Java Runtime has been updated with a new zone ID, but the client-side Java Runtime
- * has not been updated. In this case, the {@code ZoneId} object will exist, and can be queried
- * using {@code getId}, {@code equals}, {@code hashCode}, {@code toString}, {@code getDisplayName}
- * and {@code normalized}. However, any call to {@code getRules} will fail with {@code
- * ZoneRulesException}. This approach is designed to allow a {@link ZonedDateTime} to be loaded and
- * queried, but not modified, on a Java Runtime with incomplete time-zone information.
+ * has not been updated. In this case, the {@@codeZoneId} object will exist, and can be queried
+ * using {@@codegetId} , {@@codeequals} , {@@codehashCode} , {@@codetoString} ,
+ * {@@codegetDisplayName} and {@@codenormalized} . However, any call to {@@codegetRules} will fail
+ * with {@code ZoneRulesException}. This approach is designed to allow a {@@linkZonedDateTime} to be
+ * loaded and queried, but not modified, on a Java Runtime with incomplete time-zone information.
  *
  * <h3>Specification for implementors</h3> This abstract class has two implementations, both of
  * which are immutable and thread-safe. One implementation models region-based IDs, the other is
- * {@code ZoneOffset} modelling offset-based IDs. This difference is visible in serialization.
+ * {@@codeZoneOffset} modelling offset-based IDs. This difference is visible in serialization.
  *
  * @constructor
  *   Constructor only accessible within the package.
@@ -372,13 +372,13 @@ abstract class ZoneId private[bp] () extends Serializable {
    *
    * A time-zone can be invalid if it is deserialized in a Java Runtime which does not have the same
    * rules loaded as the Java Runtime that stored it. In this case, calling this method will throw a
-   * {@code ZoneRulesException}.
+   * {@@codeZoneRulesException} .
    *
-   * The rules are supplied by {@link ZoneRulesProvider}. An advanced provider may support dynamic
+   * The rules are supplied by {@@linkZoneRulesProvider} . An advanced provider may support dynamic
    * updates to the rules without restarting the Java Runtime. If so, then the result of this method
    * may change over time. Each individual call will be still remain thread-safe.
    *
-   * {@link ZoneOffset} will always return a set of rules where the offset never changes.
+   * {@@linkZoneOffset} will always return a set of rules where the offset never changes.
    *
    * @return
    *   the rules, not null
@@ -393,7 +393,7 @@ abstract class ZoneId private[bp] () extends Serializable {
    * This returns the textual name used to identify the time-zone ID, suitable for presentation to
    * the user. The parameters control the style of the returned text and the locale.
    *
-   * If no textual mapping is found then the {@link #getId() full ID} is returned.
+   * If no textual mapping is found then the {@@link#getId() full ID} is returned.
    *
    * @param style
    *   the length of the text required, not null
@@ -418,14 +418,14 @@ abstract class ZoneId private[bp] () extends Serializable {
       })
 
   /**
-   * Normalizes the time-zone ID, returning a {@code ZoneOffset} where possible.
+   * Normalizes the time-zone ID, returning a {@@codeZoneOffset} where possible.
    *
-   * The returns a normalized {@code ZoneId} that can be used in place of this ID. The result will
-   * have {@code ZoneRules} equivalent to those returned by this object, however the ID returned by
-   * {@code getId()} may be different.
+   * The returns a normalized {@@codeZoneId} that can be used in place of this ID. The result will
+   * have {@@codeZoneRules} equivalent to those returned by this object, however the ID returned by
+   * {@@codegetId()} may be different.
    *
-   * The normalization checks if the rules of this {@code ZoneId} have a fixed offset. If they do,
-   * then the {@code ZoneOffset} equal to that offset is returned. Otherwise {@code this} is
+   * The normalization checks if the rules of this {@@codeZoneId} have a fixed offset. If they do,
+   * then the {@@codeZoneOffset} equal to that offset is returned. Otherwise {@@codethis} is
    * returned.
    *
    * @return
@@ -467,7 +467,7 @@ abstract class ZoneId private[bp] () extends Serializable {
   override def hashCode: Int = getId.hashCode
 
   /**
-   * Outputs this zone as a {@code String}, using the ID.
+   * Outputs this zone as a {@@codeString} , using the ID.
    *
    * @return
    *   a string representation of this time-zone ID, not null
diff --git a/core/shared/src/main/scala/org/threeten/bp/ZoneOffset.scala b/core/shared/src/main/scala/org/threeten/bp/ZoneOffset.scala
index a091cfa96..c47358e29 100644
--- a/core/shared/src/main/scala/org/threeten/bp/ZoneOffset.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/ZoneOffset.scala
@@ -79,10 +79,10 @@ object ZoneOffset {
   lazy val MAX: ZoneOffset = ZoneOffset.ofTotalSeconds(MAX_SECONDS)
 
   /**
-   * Obtains an instance of {@code ZoneOffset} using the ID.
+   * Obtains an instance of {@@codeZoneOffset} using the ID.
    *
-   * This method parses the string ID of a {@code ZoneOffset} to return an instance. The parsing
-   * accepts all the formats generated by {@link #getId()}, plus some additional formats: <ul>
+   * This method parses the string ID of a {@@codeZoneOffset} to return an instance. The parsing
+   * accepts all the formats generated by {@@link#getId()} , plus some additional formats: <ul>
    * <li>{@code Z} - for UTC <li>{@code +h} <li>{@code +hh} <li>{@code +hh:mm} <li>{@code -hh:mm}
    * <li>{@code +hhmm} <li>{@code -hhmm} <li>{@code +hh:mm:ss} <li>{@code -hh:mm:ss} <li>{@code
    * +hhmmss} <li>{@code -hhmmss} </ul><p> Note that &plusmn; means either the plus or minus symbol.
@@ -175,7 +175,7 @@ object ZoneOffset {
   }
 
   /**
-   * Obtains an instance of {@code ZoneOffset} using an offset in hours.
+   * Obtains an instance of {@@codeZoneOffset} using an offset in hours.
    *
    * @param hours
    *   the time-zone offset in hours, from -18 to +18
@@ -187,7 +187,7 @@ object ZoneOffset {
   def ofHours(hours: Int): ZoneOffset = ofHoursMinutesSeconds(hours, 0, 0)
 
   /**
-   * Obtains an instance of {@code ZoneOffset} using an offset in hours and minutes.
+   * Obtains an instance of {@@codeZoneOffset} using an offset in hours and minutes.
    *
    * The sign of the hours and minutes components must match. Thus, if the hours is negative, the
    * minutes must be negative or zero. If the hours is zero, the minutes may be positive, negative
@@ -206,7 +206,7 @@ object ZoneOffset {
     ofHoursMinutesSeconds(hours, minutes, 0)
 
   /**
-   * Obtains an instance of {@code ZoneOffset} using an offset in hours, minutes and seconds.
+   * Obtains an instance of {@@codeZoneOffset} using an offset in hours, minutes and seconds.
    *
    * The sign of the hours, minutes and seconds components must match. Thus, if the hours is
    * negative, the minutes and seconds must be negative or zero.
@@ -229,23 +229,23 @@ object ZoneOffset {
   }
 
   /**
-   * Obtains an instance of {@code ZoneOffset} from a temporal object.
+   * Obtains an instance of {@@codeZoneOffset} from a temporal object.
    *
-   * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code ZoneOffset}.
+   * A {@@codeTemporalAccessor} represents some form of date and time information. This factory
+   * converts the arbitrary temporal object to an instance of {@@codeZoneOffset} .
    *
-   * The conversion uses the {@link TemporalQueries#offset()} query, which relies on extracting the
-   * {@link ChronoField#OFFSET_SECONDS OFFSET_SECONDS} field.
+   * The conversion uses the {@@linkTemporalQueries#offset()} query, which relies on extracting the
+   * {@@linkChronoField#OFFSET_SECONDS OFFSET_SECONDS} field.
    *
-   * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used in queries via method reference, {@code ZoneOffset::from}.
+   * This method matches the signature of the functional interface {@@linkTemporalQuery} allowing it
+   * to be used in queries via method reference, {@@codeZoneOffset::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the zone-offset, not null
    * @throws DateTimeException
-   *   if unable to convert to an { @code ZoneOffset}
+   *   if unable to convert to an {@@codeZoneOffset}
    */
   def from(temporal: TemporalAccessor): ZoneOffset = {
     val offset: ZoneOffset = temporal.query(TemporalQueries.offset)
@@ -318,9 +318,9 @@ object ZoneOffset {
     hours * SECONDS_PER_HOUR + minutes * SECONDS_PER_MINUTE + seconds
 
   /**
-   * Obtains an instance of {@code ZoneOffset} specifying the total offset in seconds
+   * Obtains an instance of {@@codeZoneOffset} specifying the total offset in seconds
    *
-   * The offset must be in the range {@code -18:00} to {@code +18:00}, which corresponds to -64800
+   * The offset must be in the range {@@code-18:00} to {@@code+18:00} , which corresponds to -64800
    * to +64800.
    *
    * @param totalSeconds
@@ -369,17 +369,17 @@ object ZoneOffset {
 }
 
 /**
- * A time-zone offset from Greenwich/UTC, such as {@code +02:00}.
+ * A time-zone offset from Greenwich/UTC, such as {@@code+02:00} .
  *
  * A time-zone offset is the period of time that a time-zone differs from Greenwich/UTC. This is
  * usually a fixed number of hours and minutes.
  *
  * Different parts of the world have different time-zone offsets. The rules for how offsets vary by
- * place and time of year are captured in the {@link ZoneId} class.
+ * place and time of year are captured in the {@@linkZoneId} class.
  *
  * For example, Paris is one hour ahead of Greenwich/UTC in winter and two hours ahead in summer.
- * The {@code ZoneId} instance for Paris will reference two {@code ZoneOffset} instances - a {@code
- * +01:00} instance for winter, and a {@code +02:00} instance for summer.
+ * The {@@codeZoneId} instance for Paris will reference two {@@codeZoneOffset} instances - a {@code
+ * +01:00} instance for winter, and a {@@code+02:00} instance for summer.
  *
  * In 2008, time-zone offsets around the world extended from -12:00 to +14:00. To prevent any
  * problems with that range being extended, yet still provide validation, the range of offsets is
@@ -390,7 +390,7 @@ object ZoneOffset {
  * class may be used with other calendar systems providing the definition of the time fields matches
  * those of the ISO calendar system.
  *
- * Instances of {@code ZoneOffset} must be compared using {@link #equals}. Implementations may
+ * Instances of {@@codeZoneOffset} must be compared using {@@link#equals} . Implementations may
  * choose to cache certain common offsets, however applications must not rely on such caching.
  *
  * <h3>Specification for implementors</h3> This class is immutable and thread-safe.
@@ -425,8 +425,8 @@ final class ZoneOffset private (private val totalSeconds: Int)
    * Gets the normalized zone offset ID.
    *
    * The ID is minor variation to the standard ISO-8601 formatted string for the offset. There are
-   * three formats: <ul> <li>{@code Z} - for UTC (ISO-8601) <li>{@code +hh:mm} or {@code -hh:mm} -
-   * if the seconds are zero (ISO-8601) <li>{@code +hh:mm:ss} or {@code -hh:mm:ss} - if the seconds
+   * three formats: <ul> <li>{@code Z} - for UTC (ISO-8601) <li>{@code +hh:mm} or {@@code-hh:mm} -
+   * if the seconds are zero (ISO-8601) <li>{@code +hh:mm:ss} or {@@code-hh:mm:ss} - if the seconds
    * are non-zero (not ISO-8601) </ul><p>
    *
    * @return
@@ -449,14 +449,14 @@ final class ZoneOffset private (private val totalSeconds: Int)
    * Checks if the specified field is supported.
    *
    * This checks if this offset can be queried for the specified field. If false, then calling the
-   * {@link #range(TemporalField) range} and {@link #get(TemporalField) get} methods will throw an
+   * {@@link#range(TemporalField) range} and {@@link#get(TemporalField) get} methods will throw an
    * exception.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@code
-   * OFFSET_SECONDS} field returns true. All other {@code ChronoField} instances will return false.
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@code
+   * OFFSET_SECONDS} field returns true. All other {@@codeChronoField} instances will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.isSupportedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the field is supported is determined by the field.
    *
    * @param field
@@ -475,12 +475,12 @@ final class ZoneOffset private (private val totalSeconds: Int)
    * used to enhance the accuracy of the returned range. If it is not possible to return the range,
    * because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return appropriate range instances. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.rangeRefinedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
    * @param field
@@ -499,18 +499,18 @@ final class ZoneOffset private (private val totalSeconds: Int)
       field.rangeRefinedBy(this)
 
   /**
-   * Gets the value of the specified field from this offset as an {@code int}.
+   * Gets the value of the specified field from this offset as an {@@codeint} .
    *
    * This queries this offset for the value for the specified field. The returned value will always
    * be within the valid range of values for the field. If it is not possible to return the value,
    * because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@code
-   * OFFSET_SECONDS} field returns the value of the offset. All other {@code ChronoField} instances
-   * will throw a {@code DateTimeException}.
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@code
+   * OFFSET_SECONDS} field returns the value of the offset. All other {@@codeChronoField} instances
+   * will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -531,17 +531,17 @@ final class ZoneOffset private (private val totalSeconds: Int)
       range(field).checkValidIntValue(getLong(field), field)
 
   /**
-   * Gets the value of the specified field from this offset as a {@code long}.
+   * Gets the value of the specified field from this offset as a {@@codelong} .
    *
    * This queries this offset for the value for the specified field. If it is not possible to return
    * the value, because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@code
-   * OFFSET_SECONDS} field returns the value of the offset. All other {@code ChronoField} instances
-   * will throw a {@code DateTimeException}.
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@code
+   * OFFSET_SECONDS} field returns the value of the offset. All other {@@codeChronoField} instances
+   * will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -564,12 +564,12 @@ final class ZoneOffset private (private val totalSeconds: Int)
   /**
    * Queries this offset using the specified query.
    *
-   * This queries this offset using the specified query strategy object. The {@code TemporalQuery}
+   * This queries this offset using the specified query strategy object. The {@@codeTemporalQuery}
    * object defines the logic to be used to obtain the result. Read the documentation of the query
    * to understand what the result of this method will be.
    *
    * The result of this method is obtained by invoking the {@link
-   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@code this}
+   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@@codethis}
    * as the argument.
    *
    * @tparam R
@@ -599,7 +599,7 @@ final class ZoneOffset private (private val totalSeconds: Int)
    * This returns a temporal object of the same observable type as the input with the offset changed
    * to be the same as this.
    *
-   * The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)} passing {@link
+   * The adjustment is equivalent to using {@@linkTemporal#with(TemporalField, long)} passing {@link
    * ChronoField#OFFSET_SECONDS} as the field.
    *
    * In most cases, it is clearer to reverse the calling pattern by using {@link
@@ -625,17 +625,17 @@ final class ZoneOffset private (private val totalSeconds: Int)
    * Compares this offset to another offset in descending order.
    *
    * The offsets are compared in the order that they occur for the same time of day around the
-   * world. Thus, an offset of {@code +10:00} comes before an offset of {@code +09:00} and so on
-   * down to {@code -18:00}.
+   * world. Thus, an offset of {@@code+10:00} comes before an offset of {@@code+09:00} and so on
+   * down to {@@code-18:00} .
    *
-   * The comparison is "consistent with equals", as defined by {@link Comparable}.
+   * The comparison is "consistent with equals", as defined by {@@linkComparable} .
    *
    * @param other
    *   the other date to compare to, not null
    * @return
    *   the comparator value, negative if less, postive if greater
    * @throws NullPointerException
-   *   if { @code other} is null
+   *   if {@@codeother} is null
    */
   def compare(other: ZoneOffset): Int = other.totalSeconds - totalSeconds
 
@@ -667,7 +667,7 @@ final class ZoneOffset private (private val totalSeconds: Int)
   override def hashCode: Int = totalSeconds
 
   /**
-   * Outputs this offset as a {@code String}, using the normalized ID.
+   * Outputs this offset as a {@@codeString} , using the normalized ID.
    *
    * @return
    *   a string representation of this offset, not null
diff --git a/core/shared/src/main/scala/org/threeten/bp/ZoneRegion.scala b/core/shared/src/main/scala/org/threeten/bp/ZoneRegion.scala
index b5a6544c8..9b24e6565 100644
--- a/core/shared/src/main/scala/org/threeten/bp/ZoneRegion.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/ZoneRegion.scala
@@ -45,7 +45,7 @@ private object ZoneRegion {
   private lazy val PATTERN: Pattern = Pattern.compile("[A-Za-z][A-Za-z0-9~/._+-]+")
 
   /**
-   * Obtains an instance of {@code ZoneId} from an identifier.
+   * Obtains an instance of {@@codeZoneId} from an identifier.
    *
    * @param zoneId
    *   the time-zone ID, not null
@@ -85,7 +85,7 @@ private object ZoneRegion {
  * (TZDB), which defines regions such as 'Europe/Paris' and 'Asia/Tokyo'.
  *
  * The region identifier, modeled by this class, is distinct from the underlying rules, modeled by
- * {@link ZoneRules}. The rules are defined by governments and change frequently. By contrast, the
+ * {@@linkZoneRules} . The rules are defined by governments and change frequently. By contrast, the
  * region identifier is well-defined and long-lived. This separation also allows rules to be shared
  * between regions if appropriate.
  *
diff --git a/core/shared/src/main/scala/org/threeten/bp/ZonedDateTime.scala b/core/shared/src/main/scala/org/threeten/bp/ZonedDateTime.scala
index 60cfe322c..65fadbc08 100644
--- a/core/shared/src/main/scala/org/threeten/bp/ZonedDateTime.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/ZonedDateTime.scala
@@ -57,7 +57,7 @@ object ZonedDateTime {
   /**
    * Obtains the current date-time from the system clock in the default time-zone.
    *
-   * This will query the {@link Clock#systemDefaultZone() system clock} in the default time-zone to
+   * This will query the {@@linkClock#systemDefaultZone() system clock} in the default time-zone to
    * obtain the current date-time. The zone and offset will be set based on the time-zone in the
    * clock.
    *
@@ -72,7 +72,7 @@ object ZonedDateTime {
   /**
    * Obtains the current date-time from the system clock in the specified time-zone.
    *
-   * This will query the {@link Clock#system(ZoneId) system clock} to obtain the current date-time.
+   * This will query the {@@linkClock#system(ZoneId) system clock} to obtain the current date-time.
    * Specifying the time-zone avoids dependence on the default time-zone. The offset will be
    * calculated from the specified time-zone.
    *
@@ -93,7 +93,7 @@ object ZonedDateTime {
    * be set based on the time-zone in the clock.
    *
    * Using this method allows the use of an alternate clock for testing. The alternate clock may be
-   * introduced using {@link Clock dependency injection}.
+   * introduced using {@@linkClock dependency injection} .
    *
    * @param clock
    *   the clock to use, not null
@@ -107,7 +107,7 @@ object ZonedDateTime {
   }
 
   /**
-   * Obtains an instance of {@code ZonedDateTime} from a local date and time.
+   * Obtains an instance of {@@codeZonedDateTime} from a local date and time.
    *
    * This creates a zoned date-time matching the input local date and time as closely as possible.
    * Time-zone rules, such as daylight savings, mean that not every local date-time is valid for the
@@ -115,7 +115,7 @@ object ZonedDateTime {
    *
    * The local date time and first combined to form a local date-time. The local date-time is then
    * resolved to a single instant on the time-line. This is achieved by finding a valid offset from
-   * UTC/Greenwich for the local date-time as defined by the {@link ZoneRules rules} of the zone ID.
+   * UTC/Greenwich for the local date-time as defined by the {@@linkZoneRules rules} of the zone ID.
    *
    * In most cases, there is only one valid offset for a local date-time. In the case of an overlap,
    * when clocks are set back, there are two valid offsets. This method uses the earlier offset
@@ -139,7 +139,7 @@ object ZonedDateTime {
     of(LocalDateTime.of(date, time), zone)
 
   /**
-   * Obtains an instance of {@code ZonedDateTime} from a local date-time.
+   * Obtains an instance of {@@codeZonedDateTime} from a local date-time.
    *
    * This creates a zoned date-time matching the input local date-time as closely as possible.
    * Time-zone rules, such as daylight savings, mean that not every local date-time is valid for the
@@ -169,7 +169,7 @@ object ZonedDateTime {
     ofLocal(localDateTime, zone, null)
 
   /**
-   * Obtains an instance of {@code ZonedDateTime} from a year, month, day, hour, minute, second,
+   * Obtains an instance of {@@codeZonedDateTime} from a year, month, day, hour, minute, second,
    * nanosecond and time-zone.
    *
    * This creates a zoned date-time matching the local date-time of the seven specified fields as
@@ -190,7 +190,7 @@ object ZonedDateTime {
    * corresponding to "summer".
    *
    * This method exists primarily for writing test cases. Non test-code will typically use other
-   * methods to create an offset time. {@code LocalDateTime} has five additional convenience
+   * methods to create an offset time. {@@codeLocalDateTime} has five additional convenience
    * variants of the equivalent factory method taking fewer arguments. They are not provided here to
    * reduce the footprint of the API.
    *
@@ -232,7 +232,7 @@ object ZonedDateTime {
   }
 
   /**
-   * Obtains an instance of {@code ZonedDateTime} from a local date-time using the preferred offset
+   * Obtains an instance of {@@codeZonedDateTime} from a local date-time using the preferred offset
    * if possible.
    *
    * The local date-time is resolved to a single instant on the time-line. This is achieved by
@@ -287,7 +287,7 @@ object ZonedDateTime {
   }
 
   /**
-   * Obtains an instance of {@code ZonedDateTime} from an {@code Instant}.
+   * Obtains an instance of {@@codeZonedDateTime} from an {@@codeInstant} .
    *
    * This creates a zoned date-time with the same instant as that specified. Calling {@link
    * #toInstant()} will return an instant equal to the one used here.
@@ -311,18 +311,18 @@ object ZonedDateTime {
   }
 
   /**
-   * Obtains an instance of {@code ZonedDateTime} from the instant formed by combining the local
+   * Obtains an instance of {@@codeZonedDateTime} from the instant formed by combining the local
    * date-time and offset.
    *
-   * This creates a zoned date-time by {@link LocalDateTime#toInstant(ZoneOffset) combining} the
-   * {@code LocalDateTime} and {@code ZoneOffset}. This combination uniquely specifies an instant
+   * This creates a zoned date-time by {@@linkLocalDateTime#toInstant(ZoneOffset) combining} the
+   * {@@codeLocalDateTime} and {@@codeZoneOffset} . This combination uniquely specifies an instant
    * without ambiguity.
    *
    * Converting an instant to a zoned date-time is simple as there is only one valid offset for each
    * instant. If the valid offset is different to the offset specified, the the date-time and offset
    * of the zoned date-time will differ from those specified.
    *
-   * If the {@code ZoneId} to be used is a {@code ZoneOffset}, this method is equivalent to {@link
+   * If the {@@codeZoneId} to be used is a {@@codeZoneOffset} , this method is equivalent to {@link
    * #of(LocalDateTime, ZoneId)}.
    *
    * @param localDateTime
@@ -342,7 +342,7 @@ object ZonedDateTime {
   }
 
   /**
-   * Obtains an instance of {@code ZonedDateTime} using seconds from the epoch of
+   * Obtains an instance of {@@codeZonedDateTime} using seconds from the epoch of
    * 1970-01-01T00:00:00Z.
    *
    * @param epochSecond
@@ -364,7 +364,7 @@ object ZonedDateTime {
   }
 
   /**
-   * Obtains an instance of {@code ZonedDateTime} strictly validating the combination of local
+   * Obtains an instance of {@@codeZonedDateTime} strictly validating the combination of local
    * date-time, offset and zone ID.
    *
    * This creates a zoned date-time ensuring that the offset is valid for the local date-time
@@ -398,24 +398,24 @@ object ZonedDateTime {
   }
 
   /**
-   * Obtains an instance of {@code ZonedDateTime} from a temporal object.
+   * Obtains an instance of {@@codeZonedDateTime} from a temporal object.
    *
-   * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code ZonedDateTime}.
+   * A {@@codeTemporalAccessor} represents some form of date and time information. This factory
+   * converts the arbitrary temporal object to an instance of {@@codeZonedDateTime} .
    *
-   * The conversion will first obtain a {@code ZoneId}. It will then try to obtain an instant. If
+   * The conversion will first obtain a {@@codeZoneId} . It will then try to obtain an instant. If
    * that fails it will try to obtain a local date-time. The zoned date time will either be a
-   * combination of {@code ZoneId} and instant, or {@code ZoneId} and local date-time.
+   * combination of {@@codeZoneId} and instant, or {@@codeZoneId} and local date-time.
    *
-   * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used in queries via method reference, {@code ZonedDateTime::from}.
+   * This method matches the signature of the functional interface {@@linkTemporalQuery} allowing it
+   * to be used in queries via method reference, {@@codeZonedDateTime::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the zoned date-time, not null
    * @throws DateTimeException
-   *   if unable to convert to an { @code ZonedDateTime}
+   *   if unable to convert to an {@@codeZonedDateTime}
    */
   def from(temporal: TemporalAccessor): ZonedDateTime =
     temporal match {
@@ -442,7 +442,7 @@ object ZonedDateTime {
     }
 
   /**
-   * Obtains an instance of {@code ZonedDateTime} from a text string such as {@code
+   * Obtains an instance of {@@codeZonedDateTime} from a text string such as {@code
    * 2007-12-03T10:15:30+01:00[Europe/Paris]}.
    *
    * The string must represent a valid date-time and is parsed using {@link
@@ -458,7 +458,7 @@ object ZonedDateTime {
   def parse(text: CharSequence): ZonedDateTime = parse(text, DateTimeFormatter.ISO_ZONED_DATE_TIME)
 
   /**
-   * Obtains an instance of {@code ZonedDateTime} from a text string using a specific formatter.
+   * Obtains an instance of {@@codeZonedDateTime} from a text string using a specific formatter.
    *
    * The text is parsed using the formatter, returning a date-time.
    *
@@ -487,18 +487,18 @@ object ZonedDateTime {
  * A date-time with a time-zone in the ISO-8601 calendar system, such as {@code
  * 2007-12-03T10:15:30+01:00 Europe/Paris}.
  *
- * {@code ZonedDateTime} is an immutable representation of a date-time with a time-zone. This class
+ * {@@codeZonedDateTime} is an immutable representation of a date-time with a time-zone. This class
  * stores all date and time fields, to a precision of nanoseconds, and a time-zone, with a zone
  * offset used to handle ambiguous local date-times. For example, the value "2nd October 2007 at
  * 13:45.30.123456789 +02:00 in the Europe/Paris time-zone" can be stored in a {@code
  * ZonedDateTime}.
  *
- * This class handles conversion from the local time-line of {@code LocalDateTime} to the instant
- * time-line of {@code Instant}. The difference between the two time-lines is the offset from
- * UTC/Greenwich, represented by a {@code ZoneOffset}.
+ * This class handles conversion from the local time-line of {@@codeLocalDateTime} to the instant
+ * time-line of {@@codeInstant} . The difference between the two time-lines is the offset from
+ * UTC/Greenwich, represented by a {@@codeZoneOffset} .
  *
  * Converting between the two time-lines involves calculating the offset using the {@link ZoneRules
- * rules} accessed from the {@code ZoneId}. Obtaining the offset for an instant is simple, as there
+ * rules} accessed from the {@@codeZoneId} . Obtaining the offset for an instant is simple, as there
  * is exactly one valid offset for each instant. By contrast, obtaining the offset for a local
  * date-time is not straightforward. There are three cases: <ul> <li>Normal, with one valid offset.
  * For the vast majority of the year, the normal case applies, where there is a single valid offset
@@ -518,14 +518,14 @@ object ZonedDateTime {
  * For Overlaps, the general strategy is that if the local date-time falls in the middle of an
  * Overlap, then the previous offset will be retained. If there is no previous offset, or the
  * previous offset is invalid, then the earlier offset is used, typically "summer" time.. Two
- * additional methods, {@link #withEarlierOffsetAtOverlap()} and {@link
+ * additional methods, {@@link#withEarlierOffsetAtOverlap()} and {@link
  * #withLaterOffsetAtOverlap()}, help manage the case of an overlap.
  *
- * <h3>Specification for implementors</h3> A {@code ZonedDateTime} holds state equivalent to three
- * separate objects, a {@code LocalDateTime}, a {@code ZoneId} and the resolved {@code ZoneOffset}.
- * The offset and local date-time are used to define an instant when necessary. The zone ID is used
- * to obtain the rules for how and when the offset changes. The offset cannot be freely set, as the
- * zone controls which offsets are valid.
+ * <h3>Specification for implementors</h3> A {@@codeZonedDateTime} holds state equivalent to three
+ * separate objects, a {@@codeLocalDateTime} , a {@@codeZoneId} and the resolved {@@codeZoneOffset}
+ * . The offset and local date-time are used to define an instant when necessary. The zone ID is
+ * used to obtain the rules for how and when the offset changes. The offset cannot be freely set, as
+ * the zone controls which offsets are valid.
  *
  * This class is immutable and thread-safe.
  *
@@ -587,10 +587,10 @@ final class ZonedDateTime(
    * Checks if the specified field is supported.
    *
    * This checks if this date-time can be queried for the specified field. If false, then calling
-   * the {@link #range(TemporalField) range} and {@link #get(TemporalField) get} methods will throw
+   * the {@@link#range(TemporalField) range} and {@@link#get(TemporalField) get} methods will throw
    * an exception.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The supported fields
+   * If the field is a {@@linkChronoField} then the query is implemented here. The supported fields
    * are: <ul> <li>{@code NANO_OF_SECOND} <li>{@code NANO_OF_DAY} <li>{@code MICRO_OF_SECOND}
    * <li>{@code MICRO_OF_DAY} <li>{@code MILLI_OF_SECOND} <li>{@code MILLI_OF_DAY} <li>{@code
    * SECOND_OF_MINUTE} <li>{@code SECOND_OF_DAY} <li>{@code MINUTE_OF_HOUR} <li>{@code
@@ -600,10 +600,10 @@ final class ZonedDateTime(
    * <li>{@code DAY_OF_YEAR} <li>{@code EPOCH_DAY} <li>{@code ALIGNED_WEEK_OF_MONTH} <li>{@code
    * ALIGNED_WEEK_OF_YEAR} <li>{@code MONTH_OF_YEAR} <li>{@code EPOCH_MONTH} <li>{@code YEAR_OF_ERA}
    * <li>{@code YEAR} <li>{@code ERA} <li>{@code INSTANT_SECONDS} <li>{@code OFFSET_SECONDS} </ul>
-   * All other {@code ChronoField} instances will return false.
+   * All other {@@codeChronoField} instances will return false.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.isSupportedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the field is supported is determined by the field.
    *
    * @param field
@@ -633,12 +633,12 @@ final class ZonedDateTime(
    * used to enhance the accuracy of the returned range. If it is not possible to return the range,
    * because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return appropriate range instances. All
-   * other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.rangeRefinedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument. Whether the range can be obtained is determined by the field.
    *
    * @param field
@@ -658,21 +658,21 @@ final class ZonedDateTime(
       field.rangeRefinedBy(this)
 
   /**
-   * Gets the value of the specified field from this date-time as an {@code int}.
+   * Gets the value of the specified field from this date-time as an {@@codeint} .
    *
    * This queries this date-time for the value for the specified field. The returned value will
    * always be within the valid range of values for the field. If it is not possible to return the
    * value, because the field is not supported or for some other reason, an exception is thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this date-time,
-   * except {@code NANO_OF_DAY}, {@code MICRO_OF_DAY}, {@code EPOCH_DAY}, {@code EPOCH_MONTH} and
-   * {@code INSTANT_SECONDS} which are too large to fit in an {@code int} and throw a {@code
-   * DateTimeException}. All other {@code ChronoField} instances will throw a {@code
+   * except {@@codeNANO_OF_DAY} , {@@codeMICRO_OF_DAY} , {@@codeEPOCH_DAY} , {@@codeEPOCH_MONTH} and
+   * {@@codeINSTANT_SECONDS} which are too large to fit in an {@@codeint} and throw a {@code
+   * DateTimeException}. All other {@@codeChronoField} instances will throw a {@code
    * DateTimeException}.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -697,18 +697,18 @@ final class ZonedDateTime(
     }
 
   /**
-   * Gets the value of the specified field from this date-time as a {@code long}.
+   * Gets the value of the specified field from this date-time as a {@@codelong} .
    *
    * This queries this date-time for the value for the specified field. If it is not possible to
    * return the value, because the field is not supported or for some other reason, an exception is
    * thrown.
    *
-   * If the field is a {@link ChronoField} then the query is implemented here. The {@link
+   * If the field is a {@@linkChronoField} then the query is implemented here. The {@link
    * #isSupported(TemporalField) supported fields} will return valid values based on this date-time.
-   * All other {@code ChronoField} instances will throw a {@code DateTimeException}.
+   * All other {@@codeChronoField} instances will throw a {@@codeDateTimeException} .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    * Whether the value can be obtained, and what the value represents, is determined by the field.
    *
    * @param field
@@ -751,12 +751,12 @@ final class ZonedDateTime(
    * date-time. Calling this method will return a zoned date-time with the earlier of the two
    * selected.
    *
-   * If this method is called when it is not an overlap, {@code this} is returned.
+   * If this method is called when it is not an overlap, {@@codethis} is returned.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the earlier offset, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the earlier offset, not null
    */
   def withEarlierOffsetAtOverlap: ZonedDateTime = {
     val trans: ZoneOffsetTransition = getZone.getRules.getTransition(dateTime)
@@ -777,12 +777,12 @@ final class ZonedDateTime(
    * date-time. Calling this method will return a zoned date-time with the later of the two
    * selected.
    *
-   * If this method is called when it is not an overlap, {@code this} is returned.
+   * If this method is called when it is not an overlap, {@@codethis} is returned.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the later offset, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the later offset, not null
    */
   def withLaterOffsetAtOverlap: ZonedDateTime = {
     val trans: ZoneOffsetTransition = getZone.getRules.getTransition(toLocalDateTime)
@@ -799,12 +799,12 @@ final class ZonedDateTime(
   /**
    * Gets the time-zone, such as 'Europe/Paris'.
    *
-   * This returns the zone ID. This identifies the time-zone {@link ZoneRules rules} that determine
+   * This returns the zone ID. This identifies the time-zone {@@linkZoneRules rules} that determine
    * when and how the offset from UTC/Greenwich changes.
    *
-   * The zone ID may be same as the {@link #getOffset() offset}. If this is true, then any future
+   * The zone ID may be same as the {@@link#getOffset() offset} . If this is true, then any future
    * calculations, such as addition or subtraction, have no complex edge cases due to time-zone
-   * rules. See also {@link #withFixedOffsetZone()}.
+   * rules. See also {@@link#withFixedOffsetZone()} .
    *
    * @return
    *   the time-zone, not null
@@ -819,14 +819,14 @@ final class ZonedDateTime(
    * changed if it is invalid for the new zone, determined using the same approach as {@link
    * #ofLocal(LocalDateTime, ZoneId, ZoneOffset)}.
    *
-   * To change the zone and adjust the local date-time, use {@link #withZoneSameInstant(ZoneId)}.
+   * To change the zone and adjust the local date-time, use {@@link#withZoneSameInstant(ZoneId)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param zone
    *   the time-zone to change to, not null
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the requested zone, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the requested zone, not null
    */
   def withZoneSameLocal(zone: ZoneId): ZonedDateTime = {
     Objects.requireNonNull(zone, "zone")
@@ -842,12 +842,12 @@ final class ZonedDateTime(
    * This method is based on retaining the same instant, thus gaps and overlaps in the local
    * time-line have no effect on the result.
    *
-   * To change the offset while keeping the local time, use {@link #withZoneSameLocal(ZoneId)}.
+   * To change the offset while keeping the local time, use {@@link#withZoneSameLocal(ZoneId)} .
    *
    * @param zone
    *   the time-zone to change to, not null
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the requested zone, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the requested zone, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -860,18 +860,18 @@ final class ZonedDateTime(
   /**
    * Returns a copy of this date-time with the zone ID set to the offset.
    *
-   * This returns a zoned date-time where the zone ID is the same as {@link #getOffset()}. The local
-   * date-time, offset and instant of the result will be the same as in this date-time.
+   * This returns a zoned date-time where the zone ID is the same as {@@link#getOffset()} . The
+   * local date-time, offset and instant of the result will be the same as in this date-time.
    *
    * Setting the date-time to a fixed single offset means that any future calculations, such as
    * addition or subtraction, have no complex edge cases due to time-zone rules. This might also be
    * useful when sending a zoned date-time across a network, as most protocols, such as ISO-8601,
    * only handle offsets, and not region-based zone IDs.
    *
-   * This is equivalent to {@code ZonedDateTime.of(zdt.getDateTime(), zdt.getOffset())}.
+   * This is equivalent to {@@codeZonedDateTime.of(zdt.getDateTime(), zdt.getOffset())} .
    *
    * @return
-   *   a { @code ZonedDateTime} with the zone ID set to the offset, not null
+   *   a {@@codeZonedDateTime} with the zone ID set to the offset, not null
    */
   def withFixedOffsetZone: ZonedDateTime =
     if (this.zone == offset) this
@@ -880,10 +880,10 @@ final class ZonedDateTime(
   /**
    * Gets the year field.
    *
-   * This method returns the primitive {@code int} value for the year.
+   * This method returns the primitive {@@codeint} value for the year.
    *
-   * The year returned by this method is proleptic as per {@code get(YEAR)}. To obtain the
-   * year-of-era, use {@code get(YEAR_OF_ERA}.
+   * The year returned by this method is proleptic as per {@@codeget(YEAR)} . To obtain the
+   * year-of-era, use {@@codeget(YEAR_OF_ERA} .
    *
    * @return
    *   the year, from MIN_YEAR to MAX_YEAR
@@ -893,8 +893,8 @@ final class ZonedDateTime(
   /**
    * Gets the month-of-year field from 1 to 12.
    *
-   * This method returns the month as an {@code int} from 1 to 12. Application code is frequently
-   * clearer if the enum {@link Month} is used by calling {@link #getMonth()}.
+   * This method returns the month as an {@@codeint} from 1 to 12. Application code is frequently
+   * clearer if the enum {@@linkMonth} is used by calling {@@link#getMonth()} .
    *
    * @return
    *   the month-of-year, from 1 to 12
@@ -904,11 +904,11 @@ final class ZonedDateTime(
   def getMonthValue: Int = dateTime.getMonthValue
 
   /**
-   * Gets the month-of-year field using the {@code Month} enum.
+   * Gets the month-of-year field using the {@@codeMonth} enum.
    *
-   * This method returns the enum {@link Month} for the month. This avoids confusion as to what
-   * {@code int} values mean. If you need access to the primitive {@code int} value then the enum
-   * provides the {@link Month#getValue() int value}.
+   * This method returns the enum {@@linkMonth} for the month. This avoids confusion as to what
+   * {@@codeint} values mean. If you need access to the primitive {@@codeint} value then the enum
+   * provides the {@@linkMonth#getValue() int value} .
    *
    * @return
    *   the month-of-year, not null
@@ -920,7 +920,7 @@ final class ZonedDateTime(
   /**
    * Gets the day-of-month field.
    *
-   * This method returns the primitive {@code int} value for the day-of-month.
+   * This method returns the primitive {@@codeint} value for the day-of-month.
    *
    * @return
    *   the day-of-month, from 1 to 31
@@ -930,7 +930,7 @@ final class ZonedDateTime(
   /**
    * Gets the day-of-year field.
    *
-   * This method returns the primitive {@code int} value for the day-of-year.
+   * This method returns the primitive {@@codeint} value for the day-of-year.
    *
    * @return
    *   the day-of-year, from 1 to 365, or 366 in a leap year
@@ -938,13 +938,13 @@ final class ZonedDateTime(
   def getDayOfYear: Int = dateTime.getDayOfYear
 
   /**
-   * Gets the day-of-week field, which is an enum {@code DayOfWeek}.
+   * Gets the day-of-week field, which is an enum {@@codeDayOfWeek} .
    *
-   * This method returns the enum {@link DayOfWeek} for the day-of-week. This avoids confusion as to
-   * what {@code int} values mean. If you need access to the primitive {@code int} value then the
-   * enum provides the {@link DayOfWeek#getValue() int value}.
+   * This method returns the enum {@@linkDayOfWeek} for the day-of-week. This avoids confusion as to
+   * what {@@codeint} values mean. If you need access to the primitive {@@codeint} value then the
+   * enum provides the {@@linkDayOfWeek#getValue() int value} .
    *
-   * Additional information can be obtained from the {@code DayOfWeek}. This includes textual names
+   * Additional information can be obtained from the {@@codeDayOfWeek} . This includes textual names
    * of the values.
    *
    * @return
@@ -987,15 +987,15 @@ final class ZonedDateTime(
   /**
    * Returns an adjusted copy of this date-time.
    *
-   * This returns a new {@code ZonedDateTime}, based on this one, with the date-time adjusted. The
+   * This returns a new {@@codeZonedDateTime} , based on this one, with the date-time adjusted. The
    * adjustment takes place using the specified adjuster strategy object. Read the documentation of
    * the adjuster to understand what adjustment will be made.
    *
    * A simple adjuster might simply set the one of the fields, such as the year field. A more
    * complex adjuster might set the date to the last day of the month. A selection of common
-   * adjustments is provided in {@link TemporalAdjusters}. These include finding the "last day of
+   * adjustments is provided in {@@linkTemporalAdjusters} . These include finding the "last day of
    * the month" and "next Wednesday". Key date-time classes also implement the {@code
-   * TemporalAdjuster} interface, such as {@link Month} and {@link MonthDay}. The adjuster is
+   * TemporalAdjuster} interface, such as {@@linkMonth} and {@@linkMonthDay} . The adjuster is
    * responsible for handling special cases, such as the varying lengths of month and leap years.
    *
    * For example this code returns a date on the last day of July: <pre> import static
@@ -1003,13 +1003,13 @@ final class ZonedDateTime(
    *
    * result = zonedDateTime.with(JULY).with(lastDayOfMonth()); </pre>
    *
-   * The classes {@link LocalDate} and {@link LocalTime} implement {@code TemporalAdjuster}, thus
+   * The classes {@@linkLocalDate} and {@@linkLocalTime} implement {@@codeTemporalAdjuster} , thus
    * this method can be used to change the date, time or offset: <pre> result =
    * zonedDateTime.with(date); result = zonedDateTime.with(time); </pre>
    *
-   * {@link ZoneOffset} also implements {@code TemporalAdjuster} however it is less likely that
+   * {@@linkZoneOffset} also implements {@@codeTemporalAdjuster} however it is less likely that
    * setting the offset will have the effect you expect. When an offset is passed in, the local
-   * date-time is combined with the new offset to form an {@code Instant}. The instant and original
+   * date-time is combined with the new offset to form an {@@codeInstant} . The instant and original
    * zone are then used to create the result. This algorithm means that it is quite likely that the
    * output has a different offset to the specified offset. It will however work correctly when
    * passing in the offset applicable for the instant of the zoned date-time, and will work
@@ -1017,7 +1017,7 @@ final class ZonedDateTime(
    * same local time occurs twice.
    *
    * The result of this method is obtained by invoking the {@link
-   * TemporalAdjuster#adjustInto(Temporal)} method on the specified adjuster passing {@code this} as
+   * TemporalAdjuster#adjustInto(Temporal)} method on the specified adjuster passing {@@codethis} as
    * the argument.
    *
    * This instance is immutable and unaffected by this method call.
@@ -1025,7 +1025,7 @@ final class ZonedDateTime(
    * @param adjuster
    *   the adjuster to use, not null
    * @return
-   *   a { @code ZonedDateTime} based on { @code this} with the adjustment made, not null
+   *   a {@@codeZonedDateTime} based on {@@codethis} with the adjustment made, not null
    * @throws DateTimeException
    *   if the adjustment cannot be made
    * @throws ArithmeticException
@@ -1044,8 +1044,8 @@ final class ZonedDateTime(
   /**
    * Returns a copy of this date-time with the specified field set to a new value.
    *
-   * This returns a {@code ZonedDateTime}, based on this one, with the value for the specified field
-   * changed. This can be used to change any supported field, such as the year, month or
+   * This returns a {@@codeZonedDateTime} , based on this one, with the value for the specified
+   * field changed. This can be used to change any supported field, such as the year, month or
    * day-of-month. If it is not possible to set the value, because the field is not supported or for
    * some other reason, an exception is thrown.
    *
@@ -1054,31 +1054,32 @@ final class ZonedDateTime(
    * invalid. In cases like this, the field is responsible for resolving the date. Typically it will
    * choose the previous valid date, which would be the last valid day of February in this example.
    *
-   * If the field is a {@link ChronoField} then the adjustment is implemented here.
+   * If the field is a {@@linkChronoField} then the adjustment is implemented here.
    *
-   * The {@code INSTANT_SECONDS} field will return a date-time with the specified instant. The zone
+   * The {@@codeINSTANT_SECONDS} field will return a date-time with the specified instant. The zone
    * and nano-of-second are unchanged. The result will have an offset derived from the new instant
    * and original zone. If the new instant value is outside the valid range then a {@code
    * DateTimeException} will be thrown.
    *
-   * The {@code OFFSET_SECONDS} field will typically be ignored. The offset of a {@code
+   * The {@@codeOFFSET_SECONDS} field will typically be ignored. The offset of a {@code
    * ZonedDateTime} is controlled primarily by the time-zone. As such, changing the offset does not
    * generally make sense, because there is only one valid offset for the local date-time and zone.
    * If the zoned date-time is in a daylight savings overlap, then the offset is used to switch
    * between the two valid offsets. In all other cases, the offset is ignored. If the new offset
-   * value is outside the valid range then a {@code DateTimeException} will be thrown.
+   * value is outside the valid range then a {@@codeDateTimeException} will be thrown.
    *
-   * The other {@link #isSupported(TemporalField) supported fields} will behave as per the matching
-   * method on {@link LocalDateTime#with(TemporalField, long) LocalDateTime}. The zone is not part
-   * of the calculation and will be unchanged. When converting back to {@code ZonedDateTime}, if the
-   * local date-time is in an overlap, then the offset will be retained if possible, otherwise the
-   * earlier offset will be used. If in a gap, the local date-time will be adjusted forward by the
-   * length of the gap.
+   * The other {@@link#isSupported(TemporalField) supported fields} will behave as per the matching
+   * method on {@@linkLocalDateTime#with(TemporalField, long) LocalDateTime} . The zone is not part
+   * of the calculation and will be unchanged. When converting back to {@@codeZonedDateTime} , if
+   * the local date-time is in an overlap, then the offset will be retained if possible, otherwise
+   * the earlier offset will be used. If in a gap, the local date-time will be adjusted forward by
+   * the length of the gap.
    *
-   * All other {@code ChronoField} instances will throw an {@code UnsupportedTemporalTypeException}.
+   * All other {@@codeChronoField} instances will throw an {@@codeUnsupportedTemporalTypeException}
+   * .
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.adjustInto(Temporal, long)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.adjustInto(Temporal, long)} passing {@@codethis} as the argument.
    * In this case, the field determines whether and how to adjust the instant.
    *
    * This instance is immutable and unaffected by this method call.
@@ -1088,7 +1089,7 @@ final class ZonedDateTime(
    * @param newValue
    *   the new value of the field in the result
    * @return
-   *   a { @code ZonedDateTime} based on { @code this} with the specified field set, not null
+   *   a {@@codeZonedDateTime} based on {@@codethis} with the specified field set, not null
    * @throws DateTimeException
    *   if the field cannot be set
    * @throws UnsupportedTemporalTypeException
@@ -1110,13 +1111,13 @@ final class ZonedDateTime(
     }
 
   /**
-   * Returns a copy of this {@code ZonedDateTime} with the year value altered.
+   * Returns a copy of this {@@codeZonedDateTime} with the year value altered.
    *
-   * This operates on the local time-line, {@link LocalDateTime#withYear(int) changing the year} of
-   * the local date-time. This is then converted back to a {@code ZonedDateTime}, using the zone ID
+   * This operates on the local time-line, {@@linkLocalDateTime#withYear(int) changing the year} of
+   * the local date-time. This is then converted back to a {@@codeZonedDateTime} , using the zone ID
    * to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@@codeZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1125,20 +1126,20 @@ final class ZonedDateTime(
    * @param year
    *   the year to set in the result, from MIN_YEAR to MAX_YEAR
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the requested year, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the requested year, not null
    * @throws DateTimeException
    *   if the year value is invalid
    */
   def withYear(year: Int): ZonedDateTime = resolveLocal(dateTime.withYear(year))
 
   /**
-   * Returns a copy of this {@code ZonedDateTime} with the month-of-year value altered.
+   * Returns a copy of this {@@codeZonedDateTime} with the month-of-year value altered.
    *
-   * This operates on the local time-line, {@link LocalDateTime#withMonth(int) changing the month}
-   * of the local date-time. This is then converted back to a {@code ZonedDateTime}, using the zone
+   * This operates on the local time-line, {@@linkLocalDateTime#withMonth(int) changing the month}
+   * of the local date-time. This is then converted back to a {@@codeZonedDateTime} , using the zone
    * ID to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@@codeZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1147,20 +1148,20 @@ final class ZonedDateTime(
    * @param month
    *   the month-of-year to set in the result, from 1 (January) to 12 (December)
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the requested month, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the requested month, not null
    * @throws DateTimeException
    *   if the month-of-year value is invalid
    */
   def withMonth(month: Int): ZonedDateTime = resolveLocal(dateTime.withMonth(month))
 
   /**
-   * Returns a copy of this {@code ZonedDateTime} with the day-of-month value altered.
+   * Returns a copy of this {@@codeZonedDateTime} with the day-of-month value altered.
    *
    * This operates on the local time-line, {@link LocalDateTime#withDayOfMonth(int) changing the
-   * day-of-month} of the local date-time. This is then converted back to a {@code ZonedDateTime},
+   * day-of-month} of the local date-time. This is then converted back to a {@@codeZonedDateTime} ,
    * using the zone ID to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@@codeZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1169,7 +1170,7 @@ final class ZonedDateTime(
    * @param dayOfMonth
    *   the day-of-month to set in the result, from 1 to 28-31
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the requested day, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the requested day, not null
    * @throws DateTimeException
    *   if the day-of-month value is invalid
    * @throws DateTimeException
@@ -1179,13 +1180,13 @@ final class ZonedDateTime(
     resolveLocal(dateTime.withDayOfMonth(dayOfMonth))
 
   /**
-   * Returns a copy of this {@code ZonedDateTime} with the day-of-year altered.
+   * Returns a copy of this {@@codeZonedDateTime} with the day-of-year altered.
    *
    * This operates on the local time-line, {@link LocalDateTime#withDayOfYear(int) changing the
-   * day-of-year} of the local date-time. This is then converted back to a {@code ZonedDateTime},
+   * day-of-year} of the local date-time. This is then converted back to a {@@codeZonedDateTime} ,
    * using the zone ID to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@@codeZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1194,7 +1195,7 @@ final class ZonedDateTime(
    * @param dayOfYear
    *   the day-of-year to set in the result, from 1 to 365-366
    * @return
-   *   a { @code ZonedDateTime} based on this date with the requested day, not null
+   *   a {@@codeZonedDateTime} based on this date with the requested day, not null
    * @throws DateTimeException
    *   if the day-of-year value is invalid
    * @throws DateTimeException
@@ -1203,13 +1204,13 @@ final class ZonedDateTime(
   def withDayOfYear(dayOfYear: Int): ZonedDateTime = resolveLocal(dateTime.withDayOfYear(dayOfYear))
 
   /**
-   * Returns a copy of this {@code ZonedDateTime} with the hour-of-day value altered.
+   * Returns a copy of this {@@codeZonedDateTime} with the hour-of-day value altered.
    *
-   * This operates on the local time-line, {@link LocalDateTime#withHour(int) changing the time} of
-   * the local date-time. This is then converted back to a {@code ZonedDateTime}, using the zone ID
+   * This operates on the local time-line, {@@linkLocalDateTime#withHour(int) changing the time} of
+   * the local date-time. This is then converted back to a {@@codeZonedDateTime} , using the zone ID
    * to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@@codeZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1218,20 +1219,20 @@ final class ZonedDateTime(
    * @param hour
    *   the hour-of-day to set in the result, from 0 to 23
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the requested hour, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the requested hour, not null
    * @throws DateTimeException
    *   if the hour value is invalid
    */
   def withHour(hour: Int): ZonedDateTime = resolveLocal(dateTime.withHour(hour))
 
   /**
-   * Returns a copy of this {@code ZonedDateTime} with the minute-of-hour value altered.
+   * Returns a copy of this {@@codeZonedDateTime} with the minute-of-hour value altered.
    *
-   * This operates on the local time-line, {@link LocalDateTime#withMinute(int) changing the time}
-   * of the local date-time. This is then converted back to a {@code ZonedDateTime}, using the zone
+   * This operates on the local time-line, {@@linkLocalDateTime#withMinute(int) changing the time}
+   * of the local date-time. This is then converted back to a {@@codeZonedDateTime} , using the zone
    * ID to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@@codeZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1240,20 +1241,20 @@ final class ZonedDateTime(
    * @param minute
    *   the minute-of-hour to set in the result, from 0 to 59
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the requested minute, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the requested minute, not null
    * @throws DateTimeException
    *   if the minute value is invalid
    */
   def withMinute(minute: Int): ZonedDateTime = resolveLocal(dateTime.withMinute(minute))
 
   /**
-   * Returns a copy of this {@code ZonedDateTime} with the second-of-minute value altered.
+   * Returns a copy of this {@@codeZonedDateTime} with the second-of-minute value altered.
    *
-   * This operates on the local time-line, {@link LocalDateTime#withSecond(int) changing the time}
-   * of the local date-time. This is then converted back to a {@code ZonedDateTime}, using the zone
+   * This operates on the local time-line, {@@linkLocalDateTime#withSecond(int) changing the time}
+   * of the local date-time. This is then converted back to a {@@codeZonedDateTime} , using the zone
    * ID to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@@codeZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1262,20 +1263,20 @@ final class ZonedDateTime(
    * @param second
    *   the second-of-minute to set in the result, from 0 to 59
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the requested second, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the requested second, not null
    * @throws DateTimeException
    *   if the second value is invalid
    */
   def withSecond(second: Int): ZonedDateTime = resolveLocal(dateTime.withSecond(second))
 
   /**
-   * Returns a copy of this {@code ZonedDateTime} with the nano-of-second value altered.
+   * Returns a copy of this {@@codeZonedDateTime} with the nano-of-second value altered.
    *
-   * This operates on the local time-line, {@link LocalDateTime#withNano(int) changing the time} of
-   * the local date-time. This is then converted back to a {@code ZonedDateTime}, using the zone ID
+   * This operates on the local time-line, {@@linkLocalDateTime#withNano(int) changing the time} of
+   * the local date-time. This is then converted back to a {@@codeZonedDateTime} , using the zone ID
    * to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@@codeZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1284,28 +1285,28 @@ final class ZonedDateTime(
    * @param nanoOfSecond
    *   the nano-of-second to set in the result, from 0 to 999,999,999
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the requested nanosecond, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the requested nanosecond, not null
    * @throws DateTimeException
    *   if the nano value is invalid
    */
   def withNano(nanoOfSecond: Int): ZonedDateTime = resolveLocal(dateTime.withNano(nanoOfSecond))
 
   /**
-   * Returns a copy of this {@code ZonedDateTime} with the time truncated.
+   * Returns a copy of this {@@codeZonedDateTime} with the time truncated.
    *
    * Truncation returns a copy of the original date-time with fields smaller than the specified unit
-   * set to zero. For example, truncating with the {@link ChronoUnit#MINUTES minutes} unit will set
+   * set to zero. For example, truncating with the {@@linkChronoUnit#MINUTES minutes} unit will set
    * the second-of-minute and nano-of-second field to zero.
    *
-   * The unit must have a {@linkplain TemporalUnit#getDuration() duration} that divides into the
+   * The unit must have a {@@linkplainTemporalUnit#getDuration() duration} that divides into the
    * length of a standard day without remainder. This includes all supplied time units on {@link
-   * ChronoUnit} and {@link ChronoUnit#DAYS DAYS}. Other units throw an exception.
+   * ChronoUnit} and {@@linkChronoUnit#DAYS DAYS} . Other units throw an exception.
    *
    * This operates on the local time-line, {@link LocalDateTime#truncatedTo(TemporalUnit)
    * truncating} the underlying local date-time. This is then converted back to a {@code
    * ZonedDateTime}, using the zone ID to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@@codeZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1314,7 +1315,7 @@ final class ZonedDateTime(
    * @param unit
    *   the unit to truncate to, not null
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the time truncated, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the time truncated, not null
    * @throws DateTimeException
    *   if unable to truncate
    */
@@ -1324,16 +1325,16 @@ final class ZonedDateTime(
    * Returns a copy of this date-time with the specified period added.
    *
    * This method returns a new date-time based on this time with the specified period added. The
-   * amount is typically {@link Period} but may be any other type implementing the {@link
+   * amount is typically {@@linkPeriod} but may be any other type implementing the {@link
    * TemporalAmount} interface. The calculation is delegated to the specified adjuster, which
-   * typically calls back to {@link #plus(long, TemporalUnit)}.
+   * typically calls back to {@@link#plus(long, TemporalUnit)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param amount
    *   the amount to add, not null
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the addition made, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the addition made, not null
    * @throws DateTimeException
    *   if the addition cannot be made
    * @throws ArithmeticException
@@ -1367,7 +1368,7 @@ final class ZonedDateTime(
    * @param unit
    *   the unit of the period to add, not null
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the specified period added, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the specified period added, not null
    * @throws DateTimeException
    *   if the unit cannot be added to this type
    */
@@ -1379,13 +1380,13 @@ final class ZonedDateTime(
       unit.addTo(this, amountToAdd)
 
   /**
-   * Returns a copy of this {@code ZonedDateTime} with the specified period in years added.
+   * Returns a copy of this {@@codeZonedDateTime} with the specified period in years added.
    *
-   * This operates on the local time-line, {@link LocalDateTime#plusYears(long) adding years} to the
-   * local date-time. This is then converted back to a {@code ZonedDateTime}, using the zone ID to
+   * This operates on the local time-line, {@@linkLocalDateTime#plusYears(long) adding years} to the
+   * local date-time. This is then converted back to a {@@codeZonedDateTime} , using the zone ID to
    * obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@@codeZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1394,20 +1395,20 @@ final class ZonedDateTime(
    * @param years
    *   the years to add, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the years added, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the years added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
   def plusYears(years: Long): ZonedDateTime = resolveLocal(dateTime.plusYears(years))
 
   /**
-   * Returns a copy of this {@code ZonedDateTime} with the specified period in months added.
+   * Returns a copy of this {@@codeZonedDateTime} with the specified period in months added.
    *
-   * This operates on the local time-line, {@link LocalDateTime#plusMonths(long) adding months} to
-   * the local date-time. This is then converted back to a {@code ZonedDateTime}, using the zone ID
+   * This operates on the local time-line, {@@linkLocalDateTime#plusMonths(long) adding months} to
+   * the local date-time. This is then converted back to a {@@codeZonedDateTime} , using the zone ID
    * to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@@codeZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1416,20 +1417,20 @@ final class ZonedDateTime(
    * @param months
    *   the months to add, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the months added, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the months added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
   def plusMonths(months: Long): ZonedDateTime = resolveLocal(dateTime.plusMonths(months))
 
   /**
-   * Returns a copy of this {@code ZonedDateTime} with the specified period in weeks added.
+   * Returns a copy of this {@@codeZonedDateTime} with the specified period in weeks added.
    *
-   * This operates on the local time-line, {@link LocalDateTime#plusWeeks(long) adding weeks} to the
-   * local date-time. This is then converted back to a {@code ZonedDateTime}, using the zone ID to
+   * This operates on the local time-line, {@@linkLocalDateTime#plusWeeks(long) adding weeks} to the
+   * local date-time. This is then converted back to a {@@codeZonedDateTime} , using the zone ID to
    * obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@@codeZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1438,20 +1439,20 @@ final class ZonedDateTime(
    * @param weeks
    *   the weeks to add, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the weeks added, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the weeks added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
   def plusWeeks(weeks: Long): ZonedDateTime = resolveLocal(dateTime.plusWeeks(weeks))
 
   /**
-   * Returns a copy of this {@code ZonedDateTime} with the specified period in days added.
+   * Returns a copy of this {@@codeZonedDateTime} with the specified period in days added.
    *
-   * This operates on the local time-line, {@link LocalDateTime#plusDays(long) adding days} to the
-   * local date-time. This is then converted back to a {@code ZonedDateTime}, using the zone ID to
+   * This operates on the local time-line, {@@linkLocalDateTime#plusDays(long) adding days} to the
+   * local date-time. This is then converted back to a {@@codeZonedDateTime} , using the zone ID to
    * obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@@codeZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1460,14 +1461,14 @@ final class ZonedDateTime(
    * @param days
    *   the days to add, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the days added, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the days added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
   def plusDays(days: Long): ZonedDateTime = resolveLocal(dateTime.plusDays(days))
 
   /**
-   * Returns a copy of this {@code ZonedDateTime} with the specified period in hours added.
+   * Returns a copy of this {@@codeZonedDateTime} with the specified period in hours added.
    *
    * This operates on the instant time-line, such that adding one hour will always be a duration of
    * one hour later. This may cause the local date-time to change by an amount other than one hour.
@@ -1485,14 +1486,14 @@ final class ZonedDateTime(
    * @param hours
    *   the hours to add, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the hours added, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the hours added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
   def plusHours(hours: Long): ZonedDateTime = resolveInstant(dateTime.plusHours(hours))
 
   /**
-   * Returns a copy of this {@code ZonedDateTime} with the specified period in minutes added.
+   * Returns a copy of this {@@codeZonedDateTime} with the specified period in minutes added.
    *
    * This operates on the instant time-line, such that adding one minute will always be a duration
    * of one minute later. This may cause the local date-time to change by an amount other than one
@@ -1503,14 +1504,14 @@ final class ZonedDateTime(
    * @param minutes
    *   the minutes to add, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the minutes added, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the minutes added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
   def plusMinutes(minutes: Long): ZonedDateTime = resolveInstant(dateTime.plusMinutes(minutes))
 
   /**
-   * Returns a copy of this {@code ZonedDateTime} with the specified period in seconds added.
+   * Returns a copy of this {@@codeZonedDateTime} with the specified period in seconds added.
    *
    * This operates on the instant time-line, such that adding one second will always be a duration
    * of one second later. This may cause the local date-time to change by an amount other than one
@@ -1521,14 +1522,14 @@ final class ZonedDateTime(
    * @param seconds
    *   the seconds to add, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the seconds added, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the seconds added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
   def plusSeconds(seconds: Long): ZonedDateTime = resolveInstant(dateTime.plusSeconds(seconds))
 
   /**
-   * Returns a copy of this {@code ZonedDateTime} with the specified period in nanoseconds added.
+   * Returns a copy of this {@@codeZonedDateTime} with the specified period in nanoseconds added.
    *
    * This operates on the instant time-line, such that adding one nano will always be a duration of
    * one nano later. This may cause the local date-time to change by an amount other than one nano.
@@ -1539,7 +1540,7 @@ final class ZonedDateTime(
    * @param nanos
    *   the nanos to add, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the nanoseconds added, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the nanoseconds added, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1549,16 +1550,16 @@ final class ZonedDateTime(
    * Returns a copy of this date-time with the specified period subtracted.
    *
    * This method returns a new date-time based on this time with the specified period subtracted.
-   * The amount is typically {@link Period} but may be any other type implementing the {@link
+   * The amount is typically {@@linkPeriod} but may be any other type implementing the {@link
    * TemporalAmount} interface. The calculation is delegated to the specified adjuster, which
-   * typically calls back to {@link #minus(long, TemporalUnit)}.
+   * typically calls back to {@@link#minus(long, TemporalUnit)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param amount
    *   the amount to subtract, not null
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the subtraction made, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the subtraction made, not null
    * @throws DateTimeException
    *   if the subtraction cannot be made
    * @throws ArithmeticException
@@ -1579,11 +1580,11 @@ final class ZonedDateTime(
    *
    * Date units operate on the local time-line. The period is first subtracted from the local
    * date-time, then converted back to a zoned date-time using the zone ID. The conversion uses
-   * {@link #ofLocal(LocalDateTime, ZoneId, ZoneOffset)} with the offset before the subtraction.
+   * {@@link#ofLocal(LocalDateTime, ZoneId, ZoneOffset)} with the offset before the subtraction.
    *
    * Time units operate on the instant time-line. The period is first subtracted from the local
    * date-time, then converted back to a zoned date-time using the zone ID. The conversion uses
-   * {@link #ofInstant(LocalDateTime, ZoneOffset, ZoneId)} with the offset before the subtraction.
+   * {@@link#ofInstant(LocalDateTime, ZoneOffset, ZoneId)} with the offset before the subtraction.
    *
    * This instance is immutable and unaffected by this method call.
    *
@@ -1592,7 +1593,7 @@ final class ZonedDateTime(
    * @param unit
    *   the unit of the period to subtract, not null
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the specified period subtracted, not
+   *   a {@@codeZonedDateTime} based on this date-time with the specified period subtracted, not
    *   null
    * @throws DateTimeException
    *   if the unit cannot be added to this type
@@ -1602,13 +1603,13 @@ final class ZonedDateTime(
     else plus(-amountToSubtract, unit)
 
   /**
-   * Returns a copy of this {@code ZonedDateTime} with the specified period in years subtracted.
+   * Returns a copy of this {@@codeZonedDateTime} with the specified period in years subtracted.
    *
-   * This operates on the local time-line, {@link LocalDateTime#minusYears(long) subtracting years}
-   * to the local date-time. This is then converted back to a {@code ZonedDateTime}, using the zone
+   * This operates on the local time-line, {@@linkLocalDateTime#minusYears(long) subtracting years}
+   * to the local date-time. This is then converted back to a {@@codeZonedDateTime} , using the zone
    * ID to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@@codeZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1617,7 +1618,7 @@ final class ZonedDateTime(
    * @param years
    *   the years to subtract, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the years subtracted, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the years subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1626,13 +1627,13 @@ final class ZonedDateTime(
     else plusYears(-years)
 
   /**
-   * Returns a copy of this {@code ZonedDateTime} with the specified period in months subtracted.
+   * Returns a copy of this {@@codeZonedDateTime} with the specified period in months subtracted.
    *
    * This operates on the local time-line, {@link LocalDateTime#minusMonths(long) subtracting
-   * months} to the local date-time. This is then converted back to a {@code ZonedDateTime}, using
+   * months} to the local date-time. This is then converted back to a {@@codeZonedDateTime} , using
    * the zone ID to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@@codeZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1641,7 +1642,7 @@ final class ZonedDateTime(
    * @param months
    *   the months to subtract, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the months subtracted, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the months subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1650,13 +1651,13 @@ final class ZonedDateTime(
     else plusMonths(-months)
 
   /**
-   * Returns a copy of this {@code ZonedDateTime} with the specified period in weeks subtracted.
+   * Returns a copy of this {@@codeZonedDateTime} with the specified period in weeks subtracted.
    *
-   * This operates on the local time-line, {@link LocalDateTime#minusWeeks(long) subtracting weeks}
-   * to the local date-time. This is then converted back to a {@code ZonedDateTime}, using the zone
+   * This operates on the local time-line, {@@linkLocalDateTime#minusWeeks(long) subtracting weeks}
+   * to the local date-time. This is then converted back to a {@@codeZonedDateTime} , using the zone
    * ID to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@@codeZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1665,7 +1666,7 @@ final class ZonedDateTime(
    * @param weeks
    *   the weeks to subtract, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the weeks subtracted, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the weeks subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1674,13 +1675,13 @@ final class ZonedDateTime(
     else plusWeeks(-weeks)
 
   /**
-   * Returns a copy of this {@code ZonedDateTime} with the specified period in days subtracted.
+   * Returns a copy of this {@@codeZonedDateTime} with the specified period in days subtracted.
    *
-   * This operates on the local time-line, {@link LocalDateTime#minusDays(long) subtracting days} to
-   * the local date-time. This is then converted back to a {@code ZonedDateTime}, using the zone ID
+   * This operates on the local time-line, {@@linkLocalDateTime#minusDays(long) subtracting days} to
+   * the local date-time. This is then converted back to a {@@codeZonedDateTime} , using the zone ID
    * to obtain the offset.
    *
-   * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, then
+   * When converting back to {@@codeZonedDateTime} , if the local date-time is in an overlap, then
    * the offset will be retained if possible, otherwise the earlier offset will be used. If in a
    * gap, the local date-time will be adjusted forward by the length of the gap.
    *
@@ -1689,7 +1690,7 @@ final class ZonedDateTime(
    * @param days
    *   the days to subtract, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the days subtracted, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the days subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1698,7 +1699,7 @@ final class ZonedDateTime(
     else plusDays(-days)
 
   /**
-   * Returns a copy of this {@code ZonedDateTime} with the specified period in hours subtracted.
+   * Returns a copy of this {@@codeZonedDateTime} with the specified period in hours subtracted.
    *
    * This operates on the instant time-line, such that subtracting one hour will always be a
    * duration of one hour earlier. This may cause the local date-time to change by an amount other
@@ -1716,7 +1717,7 @@ final class ZonedDateTime(
    * @param hours
    *   the hours to subtract, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the hours subtracted, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the hours subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1725,7 +1726,7 @@ final class ZonedDateTime(
     else plusHours(-hours)
 
   /**
-   * Returns a copy of this {@code ZonedDateTime} with the specified period in minutes subtracted.
+   * Returns a copy of this {@@codeZonedDateTime} with the specified period in minutes subtracted.
    *
    * This operates on the instant time-line, such that subtracting one minute will always be a
    * duration of one minute earlier. This may cause the local date-time to change by an amount other
@@ -1736,7 +1737,7 @@ final class ZonedDateTime(
    * @param minutes
    *   the minutes to subtract, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the minutes subtracted, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the minutes subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1745,7 +1746,7 @@ final class ZonedDateTime(
     else plusMinutes(-minutes)
 
   /**
-   * Returns a copy of this {@code ZonedDateTime} with the specified period in seconds subtracted.
+   * Returns a copy of this {@@codeZonedDateTime} with the specified period in seconds subtracted.
    *
    * This operates on the instant time-line, such that subtracting one second will always be a
    * duration of one second earlier. This may cause the local date-time to change by an amount other
@@ -1756,7 +1757,7 @@ final class ZonedDateTime(
    * @param seconds
    *   the seconds to subtract, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the seconds subtracted, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the seconds subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1765,7 +1766,7 @@ final class ZonedDateTime(
     else plusSeconds(-seconds)
 
   /**
-   * Returns a copy of this {@code ZonedDateTime} with the specified period in nanoseconds
+   * Returns a copy of this {@@codeZonedDateTime} with the specified period in nanoseconds
    * subtracted.
    *
    * This operates on the instant time-line, such that subtracting one nano will always be a
@@ -1777,7 +1778,7 @@ final class ZonedDateTime(
    * @param nanos
    *   the nanos to subtract, may be negative
    * @return
-   *   a { @code ZonedDateTime} based on this date-time with the nanoseconds subtracted, not null
+   *   a {@@codeZonedDateTime} based on this date-time with the nanoseconds subtracted, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -1793,7 +1794,7 @@ final class ZonedDateTime(
    * of the query to understand what the result of this method will be.
    *
    * The result of this method is obtained by invoking the {@link
-   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@code this}
+   * TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@@codethis}
    * as the argument.
    *
    * @tparam R
@@ -1816,11 +1817,11 @@ final class ZonedDateTime(
    * unit.
    *
    * This calculates the period between two date-times in terms of a single unit. The start and end
-   * points are {@code this} and the specified date-time. The result will be negative if the end is
+   * points are {@@codethis} and the specified date-time. The result will be negative if the end is
    * before the start. For example, the period in days between two date-times can be calculated
-   * using {@code startDateTime.until(endDateTime, DAYS)}.
+   * using {@@codestartDateTime.until(endDateTime, DAYS)} .
    *
-   * The {@code Temporal} passed to this method must be a {@code ZonedDateTime}. If the time-zone
+   * The {@@codeTemporal} passed to this method must be a {@@codeZonedDateTime} . If the time-zone
    * differs between the two zoned date-times, the specified end date-time is normalized to have the
    * same zone as this date-time.
    *
@@ -1828,17 +1829,17 @@ final class ZonedDateTime(
    * two date-times. For example, the period in months between 2012-06-15T00:00Z and
    * 2012-08-14T23:59Z will only be one month as it is one minute short of two months.
    *
-   * This method operates in association with {@link TemporalUnit#between}. The result of this
-   * method is a {@code long} representing the amount of the specified unit. By contrast, the result
-   * of {@code between} is an object that can be used directly in addition/subtraction: <pre> long
+   * This method operates in association with {@@linkTemporalUnit#between} . The result of this
+   * method is a {@@codelong} representing the amount of the specified unit. By contrast, the result
+   * of {@@codebetween} is an object that can be used directly in addition/subtraction: <pre> long
    * period = start.until(end, MONTHS); // this method dateTime.plus(MONTHS.between(start, end)); //
    * use in plus/minus </pre>
    *
-   * The calculation is implemented in this method for {@link ChronoUnit}. The units {@code NANOS},
-   * {@code MICROS}, {@code MILLIS}, {@code SECONDS}, {@code MINUTES}, {@code HOURS} and {@code
-   * HALF_DAYS}, {@code DAYS}, {@code WEEKS}, {@code MONTHS}, {@code YEARS}, {@code DECADES}, {@code
-   * CENTURIES}, {@code MILLENNIA} and {@code ERAS} are supported. Other {@code ChronoUnit} values
-   * will throw an exception.
+   * The calculation is implemented in this method for {@@linkChronoUnit} . The units {@@codeNANOS}
+   * , {@@codeMICROS} , {@@codeMILLIS} , {@@codeSECONDS} , {@@codeMINUTES} , {@@codeHOURS} and
+   * {@code HALF_DAYS}, {@@codeDAYS} , {@@codeWEEKS} , {@@codeMONTHS} , {@@codeYEARS} ,
+   * {@@codeDECADES} , {@code CENTURIES}, {@@codeMILLENNIA} and {@@codeERAS} are supported. Other
+   * {@@codeChronoUnit} values will throw an exception.
    *
    * The calculation for date and time units differ.
    *
@@ -1851,14 +1852,14 @@ final class ZonedDateTime(
    * period from noon on day 1 to noon the following day in hours may be 23, 24 or 25 hours (or some
    * other amount) depending on whether there was a daylight savings change or not.
    *
-   * If the unit is not a {@code ChronoUnit}, then the result of this method is obtained by invoking
-   * {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first argument and
-   * the input temporal as the second argument.
+   * If the unit is not a {@@codeChronoUnit} , then the result of this method is obtained by
+   * invoking {@@codeTemporalUnit.between(Temporal, Temporal)} passing {@@codethis} as the first
+   * argument and the input temporal as the second argument.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param endExclusive
-   *   the end date-time, which is converted to a { @code ZonedDateTime}, not null
+   *   the end date-time, which is converted to a {@@codeZonedDateTime} , not null
    * @param unit
    *   the unit to measure the period in, not null
    * @return
@@ -1881,9 +1882,9 @@ final class ZonedDateTime(
   }
 
   /**
-   * Gets the {@code LocalDateTime} part of this date-time.
+   * Gets the {@@codeLocalDateTime} part of this date-time.
    *
-   * This returns a {@code LocalDateTime} with the same year, month, day and time as this date-time.
+   * This returns a {@@codeLocalDateTime} with the same year, month, day and time as this date-time.
    *
    * @return
    *   the local date-time part of this date-time, not null
@@ -1891,9 +1892,9 @@ final class ZonedDateTime(
   def toLocalDateTime: LocalDateTime = dateTime
 
   /**
-   * Gets the {@code LocalDate} part of this date-time.
+   * Gets the {@@codeLocalDate} part of this date-time.
    *
-   * This returns a {@code LocalDate} with the same year, month and day as this date-time.
+   * This returns a {@@codeLocalDate} with the same year, month and day as this date-time.
    *
    * @return
    *   the date part of this date-time, not null
@@ -1901,9 +1902,9 @@ final class ZonedDateTime(
   override def toLocalDate: LocalDate = dateTime.toLocalDate
 
   /**
-   * Gets the {@code LocalTime} part of this date-time.
+   * Gets the {@@codeLocalTime} part of this date-time.
    *
-   * This returns a {@code LocalTime} with the same hour, minute, second and nanosecond as this
+   * This returns a {@@codeLocalTime} with the same hour, minute, second and nanosecond as this
    * date-time.
    *
    * @return
@@ -1912,7 +1913,7 @@ final class ZonedDateTime(
   override def toLocalTime: LocalTime = dateTime.toLocalTime
 
   /**
-   * Converts this date-time to an {@code OffsetDateTime}.
+   * Converts this date-time to an {@@codeOffsetDateTime} .
    *
    * This creates an offset date-time using the local date-time and offset. The zone ID is ignored.
    *
@@ -1949,11 +1950,11 @@ final class ZonedDateTime(
     dateTime.hashCode ^ offset.hashCode ^ Integer.rotateLeft(zone.hashCode, 3)
 
   /**
-   * Outputs this date-time as a {@code String}, such as {@code
+   * Outputs this date-time as a {@@codeString} , such as {@code
    * 2007-12-03T10:15:30+01:00[Europe/Paris]}.
    *
-   * The format consists of the {@code LocalDateTime} followed by the {@code ZoneOffset}. If the
-   * {@code ZoneId} is not the same as the offset, then the ID is output. The output is compatible
+   * The format consists of the {@@codeLocalDateTime} followed by the {@@codeZoneOffset} . If the
+   * {@@codeZoneId} is not the same as the offset, then the ID is output. The output is compatible
    * with ISO-8601 if the offset and ID are the same.
    *
    * @return
@@ -1967,7 +1968,7 @@ final class ZonedDateTime(
   }
 
   /**
-   * Outputs this date-time as a {@code String} using the formatter.
+   * Outputs this date-time as a {@@codeString} using the formatter.
    *
    * This date will be passed to the formatter {@link DateTimeFormatter#format(TemporalAccessor)
    * print method}.
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/AbstractChronology.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/AbstractChronology.scala
index c3ce9a08b..a3e329bf6 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/AbstractChronology.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/AbstractChronology.scala
@@ -32,7 +32,7 @@
 package org.threeten.bp.chrono
 
 /**
- * An abstract implementation of {@code Chronology}.
+ * An abstract implementation of {@@codeChronology} .
  *
  * <h3>Specification for implementors</h3> This class must be implemented with care to ensure other
  * classes operate correctly. All implementations that can be instantiated must be final, immutable
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDate.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDate.scala
index 897d6880f..f097cb652 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDate.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDate.scala
@@ -56,10 +56,10 @@ import org.threeten.bp.temporal.TemporalUnit
 object ChronoLocalDate {
 
   /**
-   * Gets a comparator that compares {@code ChronoLocalDate} in time-line order ignoring the
+   * Gets a comparator that compares {@@codeChronoLocalDate} in time-line order ignoring the
    * chronology.
    *
-   * This comparator differs from the comparison in {@link #compareTo} in that it only compares the
+   * This comparator differs from the comparison in {@@link#compareTo} in that it only compares the
    * underlying date and not the chronology. This allows dates in different calendar systems to be
    * compared based on the position of the date on the local time-line. The underlying comparison is
    * equivalent to comparing the epoch-day.
@@ -82,26 +82,26 @@ object ChronoLocalDate {
     }
 
   /**
-   * Obtains an instance of {@code ChronoLocalDate} from a temporal object.
+   * Obtains an instance of {@@codeChronoLocalDate} from a temporal object.
    *
-   * This obtains a local date based on the specified temporal. A {@code TemporalAccessor}
+   * This obtains a local date based on the specified temporal. A {@@codeTemporalAccessor}
    * represents an arbitrary set of date and time information, which this factory converts to an
-   * instance of {@code ChronoLocalDate}.
+   * instance of {@@codeChronoLocalDate} .
    *
    * The conversion extracts and combines the chronology and the date from the temporal object. The
-   * behavior is equivalent to using {@link Chronology#date(TemporalAccessor)} with the extracted
+   * behavior is equivalent to using {@@linkChronology#date(TemporalAccessor)} with the extracted
    * chronology. Implementations are permitted to perform optimizations such as accessing those
    * fields that are equivalent to the relevant objects.
    *
-   * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used as a query via method reference, {@code ChronoLocalDate::from}.
+   * This method matches the signature of the functional interface {@@linkTemporalQuery} allowing it
+   * to be used as a query via method reference, {@@codeChronoLocalDate::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the date, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code ChronoLocalDate}
+   *   if unable to convert to a {@@codeChronoLocalDate}
    * @see
    *   Chronology#date(TemporalAccessor)
    */
@@ -122,20 +122,20 @@ object ChronoLocalDate {
  * A date without time-of-day or time-zone in an arbitrary chronology, intended for advanced
  * globalization use cases.
  *
- * <b>Most applications should declare method signatures, fields and variables as {@link LocalDate},
- * not this interface.</b>
+ * <b>Most applications should declare method signatures, fields and variables as {@@linkLocalDate}
+ * , not this interface.</b>
  *
- * A {@code ChronoLocalDate} is the abstract representation of a date where the {@code Chronology
+ * A {@@codeChronoLocalDate} is the abstract representation of a date where the {@code Chronology
  * chronology}, or calendar system, is pluggable. The date is defined in terms of fields expressed
- * by {@link TemporalField}, where most common implementations are defined in {@link ChronoField}.
+ * by {@@linkTemporalField} , where most common implementations are defined in {@@linkChronoField} .
  * The chronology defines how the calendar system operates and the meaning of the standard fields.
  *
- * <h4>When to use this interface</h4> The design of the API encourages the use of {@code LocalDate}
+ * <h4>When to use this interface</h4> The design of the API encourages the use of {@@codeLocalDate}
  * rather than this interface, even in the case where the application needs to deal with multiple
  * calendar systems. The rationale for this is explored in the following documentation.
  *
  * The primary use case where this interface should be used is where the generic type parameter
- * {@code <C>} is fully defined as a specific chronology. In that case, the assumptions of that
+ * {@@code<C>} is fully defined as a specific chronology. In that case, the assumptions of that
  * chronology are known at development time and specified in the code.
  *
  * When the chronology is defined in the generic type parameter as ? or otherwise unknown at
@@ -144,12 +144,12 @@ object ChronoLocalDate {
  * To emphasize the point, declaring a method signature, field or variable as this interface type
  * can initially seem like the sensible way to globalize an application, however it is usually the
  * wrong approach. As such, it should be considered an application-wide architectural decision to
- * choose to use this interface as opposed to {@code LocalDate}.
+ * choose to use this interface as opposed to {@@codeLocalDate} .
  *
  * <h4>Architectural issues to consider</h4> These are some of the points that must be considered
  * before using this interface throughout an application.
  *
- * 1) Applications using this interface, as opposed to using just {@code LocalDate}, face a
+ * 1) Applications using this interface, as opposed to using just {@@codeLocalDate} , face a
  * significantly higher probability of bugs. This is because the calendar system in use is not known
  * at development time. A key cause of bugs is where the developer applies assumptions from their
  * day-to-day knowledge of the ISO calendar system to code that is intended to deal with any
@@ -159,12 +159,12 @@ object ChronoLocalDate {
  *
  * 2) This interface does not enforce immutability of implementations. While the implementation
  * notes indicate that all implementations must be immutable there is nothing in the code or type
- * system to enforce this. Any method declared to accept a {@code ChronoLocalDate} could therefore
+ * system to enforce this. Any method declared to accept a {@@codeChronoLocalDate} could therefore
  * be passed a poorly or maliciously written mutable implementation.
  *
- * 3) Applications using this interface must consider the impact of eras. {@code LocalDate} shields
- * users from the concept of eras, by ensuring that {@code getYear()} returns the proleptic year.
- * That decision ensures that developers can think of {@code LocalDate} instances as consisting of
+ * 3) Applications using this interface must consider the impact of eras. {@@codeLocalDate} shields
+ * users from the concept of eras, by ensuring that {@@codegetYear()} returns the proleptic year.
+ * That decision ensures that developers can think of {@@codeLocalDate} instances as consisting of
  * three fields - year, month-of-year and day-of-month. By contrast, users of this interface must
  * think of dates as consisting of four fields - era, year-of-era, month-of-year and day-of-month.
  * The extra era field is frequently forgotten, yet it is of vital importance to dates in an
@@ -180,7 +180,7 @@ object ChronoLocalDate {
  * ISO-8601 calendar system (or the related Julian-Gregorian). Passing around dates in other
  * calendar systems increases the complications of interacting with persistence.
  *
- * 6) Most of the time, passing a {@code ChronoLocalDate} throughout an application is unnecessary,
+ * 6) Most of the time, passing a {@@codeChronoLocalDate} throughout an application is unnecessary,
  * as discussed in the last section below.
  *
  * <h4>False assumptions causing bugs in multi-calendar system code</h4> As indicated above, there
@@ -205,8 +205,8 @@ object ChronoLocalDate {
  * Code that adds seven days and assumes that a week has been added is invalid. Some calendar
  * systems have weeks of other than seven days, such as the French Revolutionary.
  *
- * Code that assumes that because the year of {@code date1} is greater than the year of {@code
- * date2} then {@code date1} is after {@code date2} is invalid. This is invalid for all calendar
+ * Code that assumes that because the year of {@@codedate1} is greater than the year of {@code
+ * date2} then {@@codedate1} is after {@@codedate2} is invalid. This is invalid for all calendar
  * systems when referring to the year-of-era, and especially untrue of the Japanese calendar system
  * where the year-of-era restarts with the reign of every new Emperor.
  *
@@ -220,8 +220,8 @@ object ChronoLocalDate {
  *
  * <h4>Using LocalDate instead</h4> The primary alternative to using this interface throughout your
  * application is as follows. <ul> <li>Declare all method signatures referring to dates in terms of
- * {@code LocalDate}. <li>Either store the chronology (calendar system) in the user profile or
- * lookup the chronology from the user locale <li>Convert the ISO {@code LocalDate} to and from the
+ * {@@codeLocalDate} . <li>Either store the chronology (calendar system) in the user profile or
+ * lookup the chronology from the user locale <li>Convert the ISO {@@codeLocalDate} to and from the
  * user's preferred calendar system during printing and parsing </ul><p> This approach treats the
  * problem of globalized calendar systems as a localization issue and confines it to the UI layer.
  * This approach is in keeping with other localization issues in the java platform.
@@ -239,27 +239,27 @@ object ChronoLocalDate {
  * In any other part of the system, where a date must be manipulated in a calendar system other than
  * ISO, the use case will generally specify the calendar system to use. For example, an application
  * may need to calculate the next Islamic or Hebrew holiday which may require manipulating the date.
- * This kind of use case can be handled as follows: <ul> <li>start from the ISO {@code LocalDate}
+ * This kind of use case can be handled as follows: <ul> <li>start from the ISO {@@codeLocalDate}
  * being passed to the method <li>convert the date to the alternate calendar system, which for this
  * use case is known rather than arbitrary <li>perform the calculation <li>convert back to {@code
  * LocalDate} </ul><p> Developers writing low-level frameworks or libraries should also avoid this
  * interface. Instead, one of the two general purpose access interfaces should be used. Use {@link
- * TemporalAccessor} if read-only access is required, or use {@link Temporal} if read-write access
+ * TemporalAccessor} if read-only access is required, or use {@@linkTemporal} if read-write access
  * is required.
  *
  * <h3>Specification for implementors</h3> This interface must be implemented with care to ensure
  * other classes operate correctly. All implementations that can be instantiated must be final,
  * immutable and thread-safe. Subclasses should be Serializable wherever possible.
  *
- * Additional calendar systems may be added to the system. See {@link Chronology} for more details.
+ * Additional calendar systems may be added to the system. See {@@linkChronology} for more details.
  */
 trait ChronoLocalDate extends Temporal with TemporalAdjuster with Ordered[ChronoLocalDate] {
 
   /**
    * Gets the chronology of this date.
    *
-   * The {@code Chronology} represents the calendar system in use. The era and other fields in
-   * {@link ChronoField} are defined by the chronology.
+   * The {@@codeChronology} represents the calendar system in use. The era and other fields in
+   * {@@linkChronoField} are defined by the chronology.
    *
    * @return
    *   the chronology, not null
@@ -271,10 +271,10 @@ trait ChronoLocalDate extends Temporal with TemporalAdjuster with Ordered[Chrono
    *
    * The era is, conceptually, the largest division of the time-line. Most calendar systems have a
    * single epoch dividing the time-line into two eras. However, some have multiple eras, such as
-   * one for the reign of each leader. The exact meaning is determined by the {@code Chronology}.
+   * one for the reign of each leader. The exact meaning is determined by the {@@codeChronology} .
    *
-   * All correctly implemented {@code Era} classes are singletons, thus it is valid code to write
-   * {@code date.getEra() == SomeEra.NAME)}.
+   * All correctly implemented {@@codeEra} classes are singletons, thus it is valid code to write
+   * {@@codedate.getEra() == SomeEra.NAME)} .
    *
    * @return
    *   the chronology specific era constant applicable at this date, not null
@@ -288,7 +288,7 @@ trait ChronoLocalDate extends Temporal with TemporalAdjuster with Ordered[Chrono
    * chronology with the constraint that a leap-year must imply a year-length longer than a non
    * leap-year.
    *
-   * The default implementation uses {@link Chronology#isLeapYear(long)}.
+   * The default implementation uses {@@linkChronology#isLeapYear(long)} .
    *
    * @return
    *   true if this date is in a leap year, false otherwise
@@ -310,7 +310,7 @@ trait ChronoLocalDate extends Temporal with TemporalAdjuster with Ordered[Chrono
    *
    * This returns the length of the year in days.
    *
-   * The default implementation uses {@link #isLeapYear()} and returns 365 or 366.
+   * The default implementation uses {@@link#isLeapYear()} and returns 365 or 366.
    *
    * @return
    *   the length of the year in days
@@ -355,13 +355,13 @@ trait ChronoLocalDate extends Temporal with TemporalAdjuster with Ordered[Chrono
   def adjustInto(temporal: Temporal): Temporal = temporal.`with`(EPOCH_DAY, toEpochDay)
 
   /**
-   * Calculates the period between this date and another date as a {@code ChronoPeriod}.
+   * Calculates the period between this date and another date as a {@@codeChronoPeriod} .
    *
    * This calculates the period between two dates. All supplied chronologies calculate the period
-   * using years, months and days, however the {@code ChronoPeriod} API allows the period to be
+   * using years, months and days, however the {@@codeChronoPeriod} API allows the period to be
    * represented using other units.
    *
-   * The start and end points are {@code this} and the specified date. The result will be negative
+   * The start and end points are {@@codethis} and the specified date. The result will be negative
    * if the end is before the start. The negative sign will be the same in each of year, month and
    * day.
    *
@@ -401,9 +401,9 @@ trait ChronoLocalDate extends Temporal with TemporalAdjuster with Ordered[Chrono
   }
 
   /**
-   * Combines this date with a time to create a {@code ChronoLocalDateTime}.
+   * Combines this date with a time to create a {@@codeChronoLocalDateTime} .
    *
-   * This returns a {@code ChronoLocalDateTime} formed from this date at the specified time. All
+   * This returns a {@@codeChronoLocalDateTime} formed from this date at the specified time. All
    * possible combinations of date and time are valid.
    *
    * @param localTime
@@ -417,7 +417,7 @@ trait ChronoLocalDate extends Temporal with TemporalAdjuster with Ordered[Chrono
   /**
    * Converts this date to the Epoch Day.
    *
-   * The {@link ChronoField#EPOCH_DAY Epoch Day count} is a simple incrementing count of days where
+   * The {@@linkChronoField#EPOCH_DAY Epoch Day count} is a simple incrementing count of days where
    * day 0 is 1970-01-01 (ISO). This definition is the same for all chronologies, enabling
    * conversion.
    *
@@ -430,7 +430,7 @@ trait ChronoLocalDate extends Temporal with TemporalAdjuster with Ordered[Chrono
    * Compares this date to another date, including the chronology.
    *
    * The comparison is based first on the underlying time-line date, then on the chronology. It is
-   * "consistent with equals", as defined by {@link Comparable}.
+   * "consistent with equals", as defined by {@@linkComparable} .
    *
    * For example, the following is the comparator order: <ol> <li>{@code 2012-12-03 (ISO)}</li>
    * <li>{@code 2012-12-04 (ISO)}</li> <li>{@code 2555-12-04 (ThaiBuddhist)}</li> <li>{@code
@@ -440,7 +440,7 @@ trait ChronoLocalDate extends Temporal with TemporalAdjuster with Ordered[Chrono
    *
    * If all the date objects being compared are in the same chronology, then the additional
    * chronology stage is not required and only the local date is used. To compare the dates of two
-   * {@code TemporalAccessor} instances, including dates in two different chronologies, use {@link
+   * {@@codeTemporalAccessor} instances, including dates in two different chronologies, use {@link
    * ChronoField#EPOCH_DAY} as a comparator.
    *
    * @param other
@@ -458,7 +458,7 @@ trait ChronoLocalDate extends Temporal with TemporalAdjuster with Ordered[Chrono
   /**
    * Checks if this date is after the specified date ignoring the chronology.
    *
-   * This method differs from the comparison in {@link #compareTo} in that it only compares the
+   * This method differs from the comparison in {@@link#compareTo} in that it only compares the
    * underlying date and not the chronology. This allows dates in different calendar systems to be
    * compared based on the time-line position. This is equivalent to using {@code date1.toEpochDay()
    * &gt; date2.toEpochDay()}.
@@ -473,7 +473,7 @@ trait ChronoLocalDate extends Temporal with TemporalAdjuster with Ordered[Chrono
   /**
    * Checks if this date is before the specified date ignoring the chronology.
    *
-   * This method differs from the comparison in {@link #compareTo} in that it only compares the
+   * This method differs from the comparison in {@@link#compareTo} in that it only compares the
    * underlying date and not the chronology. This allows dates in different calendar systems to be
    * compared based on the time-line position. This is equivalent to using {@code date1.toEpochDay()
    * &lt; date2.toEpochDay()}.
@@ -488,7 +488,7 @@ trait ChronoLocalDate extends Temporal with TemporalAdjuster with Ordered[Chrono
   /**
    * Checks if this date is equal to the specified date ignoring the chronology.
    *
-   * This method differs from the comparison in {@link #compareTo} in that it only compares the
+   * This method differs from the comparison in {@@link#compareTo} in that it only compares the
    * underlying date and not the chronology. This allows dates in different calendar systems to be
    * compared based on the time-line position. This is equivalent to using {@code date1.toEpochDay()
    * \== date2.toEpochDay()}.
@@ -505,8 +505,8 @@ trait ChronoLocalDate extends Temporal with TemporalAdjuster with Ordered[Chrono
    *
    * Compares this date with another ensuring that the date and chronology are the same.
    *
-   * To compare the dates of two {@code TemporalAccessor} instances, including dates in two
-   * different chronologies, use {@link ChronoField#EPOCH_DAY} as a comparator.
+   * To compare the dates of two {@@codeTemporalAccessor} instances, including dates in two
+   * different chronologies, use {@@linkChronoField#EPOCH_DAY} as a comparator.
    *
    * @param obj
    *   the object to check, null returns false
@@ -531,7 +531,7 @@ trait ChronoLocalDate extends Temporal with TemporalAdjuster with Ordered[Chrono
   }
 
   /**
-   * Outputs this date as a {@code String}.
+   * Outputs this date as a {@@codeString} .
    *
    * The output will include the full local date and the chronology ID.
    *
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDateImpl.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDateImpl.scala
index 8025dc5f6..59d021ca5 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDateImpl.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDateImpl.scala
@@ -46,16 +46,16 @@ import org.threeten.bp.temporal.TemporalUnit
  * This class is used by applications seeking to handle dates in non-ISO calendar systems. For
  * example, the Japanese, Minguo, Thai Buddhist and others.
  *
- * {@code ChronoLocalDate} is built on the generic concepts of year, month and day. The calendar
- * system, represented by a {@link Chronology}, expresses the relationship between the fields and
+ * {@@codeChronoLocalDate} is built on the generic concepts of year, month and day. The calendar
+ * system, represented by a {@@linkChronology} , expresses the relationship between the fields and
  * this class allows the resulting date to be manipulated.
  *
  * Note that not all calendar systems are suitable for use with this class. For example, the Mayan
  * calendar uses a system that bears no relation to years, months and days.
  *
- * The API design encourages the use of {@code LocalDate} for the majority of the application. This
+ * The API design encourages the use of {@@codeLocalDate} for the majority of the application. This
  * includes code to read and write from a persistent data store, such as a database, and to send
- * dates and times across a network. The {@code ChronoLocalDate} instance is then used at the user
+ * dates and times across a network. The {@@codeChronoLocalDate} instance is then used at the user
  * interface level to deal with localized input/output.
  *
  * Example: </p> <pre> System.out.printf("Example()%n"); // Enumerate the list of available
@@ -75,13 +75,13 @@ import org.threeten.bp.temporal.TemporalUnit
  * last.getChrono().getID(), first, last); </pre>
  *
  * <h4>Adding Calendars</h4> The set of calendars is extensible by defining a subclass of {@link
- * ChronoLocalDate} to represent a date instance and an implementation of {@code Chronology} to be
+ * ChronoLocalDate} to represent a date instance and an implementation of {@@codeChronology} to be
  * the factory for the ChronoLocalDate subclass. </p> To permit the discovery of the additional
- * calendar types the implementation of {@code Chronology} must be registered as a Service
- * implementing the {@code Chronology} interface in the {@code META-INF/Services} file as per the
- * specification of {@link java.util.ServiceLoader}. The subclass must function according to the
- * {@code Chronology} class description and must provide its {@link Chronology#getID calendar name}
- * and {@link Chronology#getCalendarType() calendar type}. </p>
+ * calendar types the implementation of {@@codeChronology} must be registered as a Service
+ * implementing the {@@codeChronology} interface in the {@@codeMETA-INF/Services} file as per the
+ * specification of {@@linkjava.util.ServiceLoader} . The subclass must function according to the
+ * {@@codeChronology} class description and must provide its {@@linkChronology#getID calendar name}
+ * and {@@linkChronology#getCalendarType() calendar type} . </p>
  *
  * <h3>Specification for implementors</h3> This abstract class must be implemented with care to
  * ensure other classes operate correctly. All implementations that can be instantiated must be
@@ -164,7 +164,7 @@ abstract class ChronoLocalDateImpl[D <: ChronoLocalDate] private[chrono] ()
    * resulting date to become invalid. If this occurs, then other fields will be adjusted to ensure
    * that the result is valid.
    *
-   * The default implementation uses {@link #plusDays(long)} using a 7 day week.
+   * The default implementation uses {@@link#plusDays(long)} using a 7 day week.
    *
    * This instance is immutable and unaffected by this method call.
    *
@@ -202,7 +202,7 @@ abstract class ChronoLocalDateImpl[D <: ChronoLocalDate] private[chrono] ()
    * day-of-month, will be adjusted to ensure that the result is valid. Typically this will select
    * the last valid day of the month.
    *
-   * The default implementation uses {@link #plusYears(long)}.
+   * The default implementation uses {@@link#plusYears(long)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
@@ -225,7 +225,7 @@ abstract class ChronoLocalDateImpl[D <: ChronoLocalDate] private[chrono] ()
    * the day-of-month, will be adjusted to ensure that the result is valid. Typically this will
    * select the last valid day of the month.
    *
-   * The default implementation uses {@link #plusMonths(long)}.
+   * The default implementation uses {@@link#plusMonths(long)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
@@ -247,7 +247,7 @@ abstract class ChronoLocalDateImpl[D <: ChronoLocalDate] private[chrono] ()
    * cause the resulting date to become invalid. If this occurs, then other fields will be adjusted
    * to ensure that the result is valid.
    *
-   * The default implementation uses {@link #plusWeeks(long)}.
+   * The default implementation uses {@@link#plusWeeks(long)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
@@ -267,7 +267,7 @@ abstract class ChronoLocalDateImpl[D <: ChronoLocalDate] private[chrono] ()
    *
    * This subtracts the specified period in days to the date.
    *
-   * The default implementation uses {@link #plusDays(long)}.
+   * The default implementation uses {@@link#plusDays(long)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDateTime.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDateTime.scala
index 5c8143de3..40722407f 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDateTime.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDateTime.scala
@@ -54,10 +54,10 @@ import org.threeten.bp.temporal.TemporalUnit
 object ChronoLocalDateTime {
 
   /**
-   * Gets a comparator that compares {@code ChronoLocalDateTime} in time-line order ignoring the
+   * Gets a comparator that compares {@@codeChronoLocalDateTime} in time-line order ignoring the
    * chronology.
    *
-   * This comparator differs from the comparison in {@link #compareTo} in that it only compares the
+   * This comparator differs from the comparison in {@@link#compareTo} in that it only compares the
    * underlying date-time and not the chronology. This allows dates in different calendar systems to
    * be compared based on the position of the date-time on the local time-line. The underlying
    * comparison is equivalent to comparing the epoch-day and nano-of-day.
@@ -89,26 +89,26 @@ object ChronoLocalDateTime {
     }
 
   /**
-   * Obtains an instance of {@code ChronoLocalDateTime} from a temporal object.
+   * Obtains an instance of {@@codeChronoLocalDateTime} from a temporal object.
    *
-   * This obtains a local date-time based on the specified temporal. A {@code TemporalAccessor}
+   * This obtains a local date-time based on the specified temporal. A {@@codeTemporalAccessor}
    * represents an arbitrary set of date and time information, which this factory converts to an
-   * instance of {@code ChronoLocalDateTime}.
+   * instance of {@@codeChronoLocalDateTime} .
    *
    * The conversion extracts and combines the chronology and the date-time from the temporal object.
-   * The behavior is equivalent to using {@link Chronology#localDateTime(TemporalAccessor)} with the
+   * The behavior is equivalent to using {@@linkChronology#localDateTime(TemporalAccessor)} with the
    * extracted chronology. Implementations are permitted to perform optimizations such as accessing
    * those fields that are equivalent to the relevant objects.
    *
-   * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used as a query via method reference, {@code ChronoLocalDateTime::from}.
+   * This method matches the signature of the functional interface {@@linkTemporalQuery} allowing it
+   * to be used as a query via method reference, {@@codeChronoLocalDateTime::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the date-time, not null
    * @throws DateTimeException
-   *   if unable to convert to a {@code ChronoLocalDateTime}
+   *   if unable to convert to a {@@codeChronoLocalDateTime}
    * @see
    *   Chronology#localDateTime(TemporalAccessor)
    */
@@ -133,8 +133,8 @@ abstract class ChronoLocalDateTime[D <: ChronoLocalDate]
   /**
    * Gets the chronology of this date-time.
    *
-   * The {@code Chronology} represents the calendar system in use. The era and other fields in
-   * {@link ChronoField} are defined by the chronology.
+   * The {@@codeChronology} represents the calendar system in use. The era and other fields in
+   * {@@linkChronoField} are defined by the chronology.
    *
    * @return
    *   the chronology, not null
@@ -211,9 +211,9 @@ abstract class ChronoLocalDateTime[D <: ChronoLocalDate]
   }
 
   /**
-   * Combines this time with a time-zone to create a {@code ChronoZonedDateTime}.
+   * Combines this time with a time-zone to create a {@@codeChronoZonedDateTime} .
    *
-   * This returns a {@code ChronoZonedDateTime} formed from this date-time at the specified
+   * This returns a {@@codeChronoZonedDateTime} formed from this date-time at the specified
    * time-zone. The result will match this date-time as closely as possible. Time-zone rules, such
    * as daylight savings, mean that not every local date-time is valid for the specified zone, thus
    * the local date-time may be adjusted.
@@ -240,14 +240,14 @@ abstract class ChronoLocalDateTime[D <: ChronoLocalDate]
   def atZone(zone: ZoneId): ChronoZonedDateTime[D]
 
   /**
-   * Converts this date-time to an {@code Instant}.
+   * Converts this date-time to an {@@codeInstant} .
    *
-   * This combines this local date-time and the specified offset to form an {@code Instant}.
+   * This combines this local date-time and the specified offset to form an {@@codeInstant} .
    *
    * @param offset
    *   the offset to use for the conversion, not null
    * @return
-   *   an {@code Instant} representing the same instant, not null
+   *   an {@@codeInstant} representing the same instant, not null
    */
   def toInstant(offset: ZoneOffset): Instant =
     Instant.ofEpochSecond(toEpochSecond(offset), toLocalTime.getNano.toLong)
@@ -276,7 +276,7 @@ abstract class ChronoLocalDateTime[D <: ChronoLocalDate]
    * Compares this date-time to another date-time, including the chronology.
    *
    * The comparison is based first on the underlying time-line date-time, then on the chronology. It
-   * is "consistent with equals", as defined by {@link Comparable}.
+   * is "consistent with equals", as defined by {@@linkComparable} .
    *
    * For example, the following is the comparator order: <ol> <li>{@code 2012-12-03T12:00
    * (ISO)}</li> <li>{@code 2012-12-04T12:00 (ISO)}</li> <li>{@code 2555-12-04T12:00
@@ -306,7 +306,7 @@ abstract class ChronoLocalDateTime[D <: ChronoLocalDate]
   /**
    * Checks if this date-time is after the specified date-time ignoring the chronology.
    *
-   * This method differs from the comparison in {@link #compareTo} in that it only compares the
+   * This method differs from the comparison in {@@link#compareTo} in that it only compares the
    * underlying date-time and not the chronology. This allows dates in different calendar systems to
    * be compared based on the time-line position.
    *
@@ -324,7 +324,7 @@ abstract class ChronoLocalDateTime[D <: ChronoLocalDate]
   /**
    * Checks if this date-time is before the specified date-time ignoring the chronology.
    *
-   * This method differs from the comparison in {@link #compareTo} in that it only compares the
+   * This method differs from the comparison in {@@link#compareTo} in that it only compares the
    * underlying date-time and not the chronology. This allows dates in different calendar systems to
    * be compared based on the time-line position.
    *
@@ -342,7 +342,7 @@ abstract class ChronoLocalDateTime[D <: ChronoLocalDate]
   /**
    * Checks if this date-time is equal to the specified date-time ignoring the chronology.
    *
-   * This method differs from the comparison in {@link #compareTo} in that it only compares the
+   * This method differs from the comparison in {@@link#compareTo} in that it only compares the
    * underlying date and time and not the chronology. This allows date-times in different calendar
    * systems to be compared based on the time-line position.
    *
@@ -379,7 +379,7 @@ abstract class ChronoLocalDateTime[D <: ChronoLocalDate]
   override def hashCode: Int = toLocalDate.hashCode ^ toLocalTime.hashCode
 
   /**
-   * Outputs this date-time as a {@code String}.
+   * Outputs this date-time as a {@@codeString} .
    *
    * The output will include the full local date-time and the chronology ID.
    *
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDateTimeImpl.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDateTimeImpl.scala
index f44fb9e6f..8cd012e22 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDateTimeImpl.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoLocalDateTimeImpl.scala
@@ -85,7 +85,7 @@ private[chrono] object ChronoLocalDateTimeImpl {
   private final val NANOS_PER_DAY = NANOS_PER_HOUR * HOURS_PER_DAY
 
   /**
-   * Obtains an instance of {@code ChronoLocalDateTime} from a date and time.
+   * Obtains an instance of {@@codeChronoLocalDateTime} from a date and time.
    *
    * @param date
    *   the local date, not null
@@ -105,13 +105,13 @@ private[chrono] object ChronoLocalDateTimeImpl {
 /**
  * A date-time without a time-zone for the calendar neutral API.
  *
- * {@code ChronoLocalDateTime} is an immutable date-time object that represents a date-time, often
+ * {@@codeChronoLocalDateTime} is an immutable date-time object that represents a date-time, often
  * viewed as year-month-day-hour-minute-second. This object can also access other fields such as
  * day-of-year, day-of-week and week-of-year.
  *
  * This class stores all date and time fields, to a precision of nanoseconds. It does not store or
  * represent a time-zone. For example, the value "2nd October 2007 at 13:45.30.123456789" can be
- * stored in an {@code ChronoLocalDateTime}.
+ * stored in an {@@codeChronoLocalDateTime} .
  *
  * <h3>Specification for implementors</h3> This class is immutable and thread-safe.
  *
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoPeriod.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoPeriod.scala
index 585246818..2eec5c53b 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoPeriod.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoPeriod.scala
@@ -40,7 +40,7 @@ import org.threeten.bp.temporal.TemporalUnit
 object ChronoPeriod {
 
   /**
-   * Obtains a {@code ChronoPeriod} consisting of amount of time between two dates.
+   * Obtains a {@@codeChronoPeriod} consisting of amount of time between two dates.
    *
    * The start date is included, but the end date is not. The period is calculated using {@link
    * ChronoLocalDate#until(ChronoLocalDate)}. As such, the calculation is chronology specific.
@@ -76,7 +76,7 @@ object ChronoPeriod {
  *
  * This interface models a date-based amount of time in a calendar system. While most calendar
  * systems use years, months and days, some do not. Therefore, this interface operates solely in
- * terms of a set of supported units that are defined by the {@code Chronology}. The set of
+ * terms of a set of supported units that are defined by the {@@codeChronology} . The set of
  * supported units is fixed for a given chronology. The amount of a supported unit may be set to
  * zero.
  *
@@ -93,11 +93,11 @@ trait ChronoPeriod extends TemporalAmount {
    * Gets the value of the requested unit.
    *
    * The supported units are chronology specific. They will typically be {@link ChronoUnit#YEARS
-   * YEARS}, {@link ChronoUnit#MONTHS MONTHS} and {@link ChronoUnit#DAYS DAYS}. Requesting an
+   * YEARS}, {@@linkChronoUnit#MONTHS MONTHS} and {@@linkChronoUnit#DAYS DAYS} . Requesting an
    * unsupported unit will throw an exception.
    *
    * @param unit
-   *   the { @code TemporalUnit} for which to return the value
+   *   the {@@codeTemporalUnit} for which to return the value
    * @return
    *   the long value of the unit
    * @throws DateTimeException
@@ -111,10 +111,10 @@ trait ChronoPeriod extends TemporalAmount {
    * Gets the set of units supported by this period.
    *
    * The supported units are chronology specific. They will typically be {@link ChronoUnit#YEARS
-   * YEARS}, {@link ChronoUnit#MONTHS MONTHS} and {@link ChronoUnit#DAYS DAYS}. They are returned in
-   * order from largest to smallest.
+   * YEARS}, {@@linkChronoUnit#MONTHS MONTHS} and {@@linkChronoUnit#DAYS DAYS} . They are returned
+   * in order from largest to smallest.
    *
-   * This set can be used in conjunction with {@link #get(TemporalUnit)} to access the entire state
+   * This set can be used in conjunction with {@@link#get(TemporalUnit)} to access the entire state
    * of the period.
    *
    * @return
@@ -126,7 +126,7 @@ trait ChronoPeriod extends TemporalAmount {
    * Gets the chronology that defines the meaning of the supported units.
    *
    * The period is defined by the chronology. It controls the supported units and restricts
-   * addition/subtraction to {@code ChronoLocalDate} instances of the same chronology.
+   * addition/subtraction to {@@codeChronoLocalDate} instances of the same chronology.
    *
    * @return
    *   the chronology defining the period, not null
@@ -168,8 +168,8 @@ trait ChronoPeriod extends TemporalAmount {
   /**
    * Returns a copy of this period with the specified period added.
    *
-   * If the specified amount is a {@code ChronoPeriod} then it must have the same chronology as this
-   * period. Implementations may choose to accept or reject other {@code TemporalAmount}
+   * If the specified amount is a {@@codeChronoPeriod} then it must have the same chronology as this
+   * period. Implementations may choose to accept or reject other {@@codeTemporalAmount}
    * implementations.
    *
    * This instance is immutable and unaffected by this method call.
@@ -177,7 +177,7 @@ trait ChronoPeriod extends TemporalAmount {
    * @param amountToAdd
    *   the period to add, not null
    * @return
-   *   a { @code ChronoPeriod} based on this period with the requested period added, not null
+   *   a {@@codeChronoPeriod} based on this period with the requested period added, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -186,8 +186,8 @@ trait ChronoPeriod extends TemporalAmount {
   /**
    * Returns a copy of this period with the specified period subtracted.
    *
-   * If the specified amount is a {@code ChronoPeriod} then it must have the same chronology as this
-   * period. Implementations may choose to accept or reject other {@code TemporalAmount}
+   * If the specified amount is a {@@codeChronoPeriod} then it must have the same chronology as this
+   * period. Implementations may choose to accept or reject other {@@codeTemporalAmount}
    * implementations.
    *
    * This instance is immutable and unaffected by this method call.
@@ -195,7 +195,7 @@ trait ChronoPeriod extends TemporalAmount {
    * @param amountToSubtract
    *   the period to subtract, not null
    * @return
-   *   a { @code ChronoPeriod} based on this period with the requested period subtracted, not null
+   *   a {@@codeChronoPeriod} based on this period with the requested period subtracted, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs
    */
@@ -212,7 +212,7 @@ trait ChronoPeriod extends TemporalAmount {
    * @param scalar
    *   the scalar to multiply by, not null
    * @return
-   *   a { @code ChronoPeriod} based on this period with the amounts multiplied by the scalar, not
+   *   a {@@codeChronoPeriod} based on this period with the amounts multiplied by the scalar, not
    *   null
    * @throws ArithmeticException
    *   if numeric overflow occurs
@@ -227,7 +227,7 @@ trait ChronoPeriod extends TemporalAmount {
    * normalization is performed.
    *
    * @return
-   *   a { @code ChronoPeriod} based on this period with the amounts negated, not null
+   *   a {@@codeChronoPeriod} based on this period with the amounts negated, not null
    * @throws ArithmeticException
    *   if numeric overflow occurs, which only happens if one of the units has the value { @code
    *   Long.MIN_VALUE}
@@ -244,7 +244,7 @@ trait ChronoPeriod extends TemporalAmount {
    * This instance is immutable and unaffected by this method call.
    *
    * @return
-   *   a { @code ChronoPeriod} based on this period with the amounts of each unit normalized, not
+   *   a {@@codeChronoPeriod} based on this period with the amounts of each unit normalized, not
    *   null
    * @throws ArithmeticException
    *   if numeric overflow occurs
@@ -327,7 +327,7 @@ trait ChronoPeriod extends TemporalAmount {
   override def hashCode: Int
 
   /**
-   * Outputs this period as a {@code String}.
+   * Outputs this period as a {@@codeString} .
    *
    * The output will include the period amounts and chronology.
    *
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoPeriodImpl.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoPeriodImpl.scala
index 86342a2bc..6a985f316 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoPeriodImpl.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoPeriodImpl.scala
@@ -45,7 +45,7 @@ import org.threeten.bp.temporal.TemporalUnit
 import org.threeten.bp.temporal.UnsupportedTemporalTypeException
 
 /**
- * An implementation of {@code ChronoPeriod}.
+ * An implementation of {@@codeChronoPeriod} .
  */
 @SerialVersionUID(275618735781L)
 final class ChronoPeriodImpl(
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoZonedDateTime.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoZonedDateTime.scala
index 7923a2049..2c5c656c7 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoZonedDateTime.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoZonedDateTime.scala
@@ -57,10 +57,10 @@ import org.threeten.bp.temporal.ValueRange
 object ChronoZonedDateTime {
 
   /**
-   * Gets a comparator that compares {@code ChronoZonedDateTime} in time-line order ignoring the
+   * Gets a comparator that compares {@@codeChronoZonedDateTime} in time-line order ignoring the
    * chronology.
    *
-   * This comparator differs from the comparison in {@link #compareTo} in that it only compares the
+   * This comparator differs from the comparison in {@@link#compareTo} in that it only compares the
    * underlying instant and not the chronology. This allows dates in different calendar systems to
    * be compared based on the position of the date-time on the instant time-line. The underlying
    * comparison is equivalent to comparing the epoch-second and nano-of-second.
@@ -91,26 +91,26 @@ object ChronoZonedDateTime {
     }
 
   /**
-   * Obtains an instance of {@code ChronoZonedDateTime} from a temporal object.
+   * Obtains an instance of {@@codeChronoZonedDateTime} from a temporal object.
    *
-   * This creates a zoned date-time based on the specified temporal. A {@code TemporalAccessor}
+   * This creates a zoned date-time based on the specified temporal. A {@@codeTemporalAccessor}
    * represents an arbitrary set of date and time information, which this factory converts to an
-   * instance of {@code ChronoZonedDateTime}.
+   * instance of {@@codeChronoZonedDateTime} .
    *
    * The conversion extracts and combines the chronology, date, time and zone from the temporal
-   * object. The behavior is equivalent to using {@link Chronology#zonedDateTime(TemporalAccessor)}
+   * object. The behavior is equivalent to using {@@linkChronology#zonedDateTime(TemporalAccessor)}
    * with the extracted chronology. Implementations are permitted to perform optimizations such as
    * accessing those fields that are equivalent to the relevant objects.
    *
-   * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used as a query via method reference, {@code ChronoZonedDateTime::from}.
+   * This method matches the signature of the functional interface {@@linkTemporalQuery} allowing it
+   * to be used as a query via method reference, {@@codeChronoZonedDateTime::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the date-time, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code ChronoZonedDateTime}
+   *   if unable to convert to a {@@codeChronoZonedDateTime}
    * @see
    *   Chronology#zonedDateTime(TemporalAccessor)
    */
@@ -136,18 +136,18 @@ object ChronoZonedDateTime {
  * <b>Most applications should declare method signatures, fields and variables as {@link
  * ZonedDateTime}, not this interface.</b>
  *
- * A {@code ChronoZonedDateTime} is the abstract representation of an offset date-time where the
- * {@code Chronology chronology}, or calendar system, is pluggable. The date-time is defined in
- * terms of fields expressed by {@link TemporalField}, where most common implementations are defined
- * in {@link ChronoField}. The chronology defines how the calendar system operates and the meaning
- * of the standard fields.
+ * A {@@codeChronoZonedDateTime} is the abstract representation of an offset date-time where the
+ * {@@codeChronology chronology} , or calendar system, is pluggable. The date-time is defined in
+ * terms of fields expressed by {@@linkTemporalField} , where most common implementations are
+ * defined in {@@linkChronoField} . The chronology defines how the calendar system operates and the
+ * meaning of the standard fields.
  *
  * <h4>When to use this interface</h4> The design of the API encourages the use of {@code
  * ZonedDateTime} rather than this interface, even in the case where the application needs to deal
  * with multiple calendar systems. The rationale for this is explored in detail in {@link
  * ChronoLocalDate}.
  *
- * Ensure that the discussion in {@code ChronoLocalDate} has been read and understood before using
+ * Ensure that the discussion in {@@codeChronoLocalDate} has been read and understood before using
  * this interface.
  *
  * <h3>Specification for implementors</h3> This interface must be implemented with care to ensure
@@ -217,8 +217,8 @@ trait ChronoZonedDateTime[D <: ChronoLocalDate]
   /**
    * Gets the chronology of this date-time.
    *
-   * The {@code Chronology} represents the calendar system in use. The era and other fields in
-   * {@link ChronoField} are defined by the chronology.
+   * The {@@codeChronology} represents the calendar system in use. The era and other fields in
+   * {@@linkChronoField} are defined by the chronology.
    *
    * @return
    *   the chronology, not null
@@ -254,12 +254,12 @@ trait ChronoZonedDateTime[D <: ChronoLocalDate]
    * date-time. Calling this method will return a zoned date-time with the earlier of the two
    * selected.
    *
-   * If this method is called when it is not an overlap, {@code this} is returned.
+   * If this method is called when it is not an overlap, {@@codethis} is returned.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @return
-   *   a { @code ZoneChronoDateTime} based on this date-time with the earlier offset, not null
+   *   a {@@codeZoneChronoDateTime} based on this date-time with the earlier offset, not null
    * @throws DateTimeException
    *   if no rules can be found for the zone
    * @throws DateTimeException
@@ -276,12 +276,12 @@ trait ChronoZonedDateTime[D <: ChronoLocalDate]
    * date-time. Calling this method will return a zoned date-time with the later of the two
    * selected.
    *
-   * If this method is called when it is not an overlap, {@code this} is returned.
+   * If this method is called when it is not an overlap, {@@codethis} is returned.
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @return
-   *   a { @code ChronoZonedDateTime} based on this date-time with the later offset, not null
+   *   a {@@codeChronoZonedDateTime} based on this date-time with the later offset, not null
    * @throws DateTimeException
    *   if no rules can be found for the zone
    * @throws DateTimeException
@@ -296,14 +296,14 @@ trait ChronoZonedDateTime[D <: ChronoLocalDate]
    * This method changes the time-zone and retains the local date-time. The local date-time is only
    * changed if it is invalid for the new zone.
    *
-   * To change the zone and adjust the local date-time, use {@link #withZoneSameInstant(ZoneId)}.
+   * To change the zone and adjust the local date-time, use {@@link#withZoneSameInstant(ZoneId)} .
    *
    * This instance is immutable and unaffected by this method call.
    *
    * @param zoneId
    *   the time-zone to change to, not null
    * @return
-   *   a { @code ChronoZonedDateTime} based on this date-time with the requested zone, not null
+   *   a {@@codeChronoZonedDateTime} based on this date-time with the requested zone, not null
    */
   def withZoneSameLocal(zoneId: ZoneId): ChronoZonedDateTime[D]
 
@@ -316,12 +316,12 @@ trait ChronoZonedDateTime[D <: ChronoLocalDate]
    * This method is based on retaining the same instant, thus gaps and overlaps in the local
    * time-line have no effect on the result.
    *
-   * To change the offset while keeping the local time, use {@link #withZoneSameLocal(ZoneId)}.
+   * To change the offset while keeping the local time, use {@@link#withZoneSameLocal(ZoneId)} .
    *
    * @param zoneId
    *   the time-zone to change to, not null
    * @return
-   *   a { @code ChronoZonedDateTime} based on this date-time with the requested zone, not null
+   *   a {@@codeChronoZonedDateTime} based on this date-time with the requested zone, not null
    * @throws DateTimeException
    *   if the result exceeds the supported date range
    */
@@ -355,7 +355,7 @@ trait ChronoZonedDateTime[D <: ChronoLocalDate]
     }
 
   /**
-   * Outputs this date-time as a {@code String} using the formatter.
+   * Outputs this date-time as a {@@codeString} using the formatter.
    *
    * @param formatter
    *   the formatter to use, not null
@@ -370,21 +370,21 @@ trait ChronoZonedDateTime[D <: ChronoLocalDate]
   }
 
   /**
-   * Converts this date-time to an {@code Instant}.
+   * Converts this date-time to an {@@codeInstant} .
    *
-   * This returns an {@code Instant} representing the same point on the time-line as this date-time.
-   * The calculation combines the {@linkplain #toLocalDateTime() local date-time} and {@linkplain
+   * This returns an {@@codeInstant} representing the same point on the time-line as this date-time.
+   * The calculation combines the {@@linkplain#toLocalDateTime() local date-time} and {@linkplain
    * #getOffset() offset}.
    *
    * @return
-   *   an { @code Instant} representing the same instant, not null
+   *   an {@@codeInstant} representing the same instant, not null
    */
   def toInstant: Instant = Instant.ofEpochSecond(toEpochSecond, toLocalTime.getNano.toLong)
 
   /**
    * Converts this date-time to the number of seconds from the epoch of 1970-01-01T00:00:00Z.
    *
-   * This uses the {@linkplain #toLocalDateTime() local date-time} and {@linkplain #getOffset()
+   * This uses the {@@linkplain#toLocalDateTime() local date-time} and {@linkplain #getOffset()
    * offset} to calculate the epoch-second value, which is the number of elapsed seconds from
    * 1970-01-01T00:00:00Z. Instants on the time-line after the epoch are positive, earlier are
    * negative.
@@ -403,7 +403,7 @@ trait ChronoZonedDateTime[D <: ChronoLocalDate]
    * Compares this date-time to another date-time, including the chronology.
    *
    * The comparison is based first on the instant, then on the local date-time, then on the zone ID,
-   * then on the chronology. It is "consistent with equals", as defined by {@link Comparable}.
+   * then on the chronology. It is "consistent with equals", as defined by {@@linkComparable} .
    *
    * If all the date-time objects being compared are in the same chronology, then the additional
    * chronology stage is not required.
@@ -434,7 +434,7 @@ trait ChronoZonedDateTime[D <: ChronoLocalDate]
   /**
    * Checks if the instant of this date-time is after that of the specified date-time.
    *
-   * This method differs from the comparison in {@link #compareTo} in that it only compares the
+   * This method differs from the comparison in {@@link#compareTo} in that it only compares the
    * instant of the date-time. This is equivalent to using {@code
    * dateTime1.toInstant().isAfter(dateTime2.toInstant());}.
    *
@@ -452,7 +452,7 @@ trait ChronoZonedDateTime[D <: ChronoLocalDate]
   /**
    * Checks if the instant of this date-time is before that of the specified date-time.
    *
-   * This method differs from the comparison in {@link #compareTo} in that it only compares the
+   * This method differs from the comparison in {@@link#compareTo} in that it only compares the
    * instant of the date-time. This is equivalent to using {@code
    * dateTime1.toInstant().isBefore(dateTime2.toInstant());}.
    *
@@ -470,7 +470,7 @@ trait ChronoZonedDateTime[D <: ChronoLocalDate]
   /**
    * Checks if the instant of this date-time is equal to that of the specified date-time.
    *
-   * This method differs from the comparison in {@link #compareTo} and {@link #equals} in that it
+   * This method differs from the comparison in {@@link#compareTo} and {@@link#equals} in that it
    * only compares the instant of the date-time. This is equivalent to using {@code
    * dateTime1.toInstant().equals(dateTime2.toInstant());}.
    *
@@ -486,7 +486,7 @@ trait ChronoZonedDateTime[D <: ChronoLocalDate]
    * Checks if this date-time is equal to another date-time.
    *
    * The comparison is based on the offset date-time and the zone. To compare for the same instant
-   * on the time-line, use {@link #compareTo}. Only objects of type {@code ChronoZoneDateTime} are
+   * on the time-line, use {@@link#compareTo} . Only objects of type {@@codeChronoZoneDateTime} are
    * compared, other types return false.
    *
    * @param obj
@@ -510,7 +510,7 @@ trait ChronoZonedDateTime[D <: ChronoLocalDate]
     toLocalDateTime.hashCode ^ getOffset.hashCode ^ Integer.rotateLeft(getZone.hashCode, 3)
 
   /**
-   * Outputs this date-time as a {@code String}.
+   * Outputs this date-time as a {@@codeString} .
    *
    * The output will include the full zoned date-time and the chronology ID.
    *
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoZonedDateTimeImpl.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoZonedDateTimeImpl.scala
index a209665ba..92851f3bc 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoZonedDateTimeImpl.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/ChronoZonedDateTimeImpl.scala
@@ -122,7 +122,7 @@ private[chrono] object ChronoZonedDateTimeImpl {
 /**
  * A date-time with a time-zone in the calendar neutral API.
  *
- * {@code ZoneChronoDateTime} is an immutable representation of a date-time with a time-zone. This
+ * {@@codeZoneChronoDateTime} is an immutable representation of a date-time with a time-zone. This
  * class stores all date and time fields, to a precision of nanoseconds, as well as a time-zone and
  * zone offset.
  *
@@ -154,7 +154,7 @@ final class ChronoZonedDateTimeImpl[D <: ChronoLocalDate] private (
   Objects.requireNonNull(zone, "zone")
 
   /**
-   * Obtains an instance from an {@code Instant}.
+   * Obtains an instance from an {@@codeInstant} .
    *
    * @param instant
    *   the instant to create the date-time from, not null
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/Chronology.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/Chronology.scala
index cc9f29793..3b3f49044 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/Chronology.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/Chronology.scala
@@ -65,23 +65,23 @@ object Chronology {
     new HashMap[String, Chronology]()
 
   /**
-   * Obtains an instance of {@code Chronology} from a temporal object.
+   * Obtains an instance of {@@codeChronology} from a temporal object.
    *
-   * A {@code TemporalAccessor} represents some form of date and time information. This factory
-   * converts the arbitrary temporal object to an instance of {@code Chronology}. If the specified
-   * temporal object does not have a chronology, {@link IsoChronology} is returned.
+   * A {@@codeTemporalAccessor} represents some form of date and time information. This factory
+   * converts the arbitrary temporal object to an instance of {@@codeChronology} . If the specified
+   * temporal object does not have a chronology, {@@linkIsoChronology} is returned.
    *
-   * The conversion will obtain the chronology using {@link TemporalQueries#chronology()}.
+   * The conversion will obtain the chronology using {@@linkTemporalQueries#chronology()} .
    *
-   * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used in queries via method reference, {@code Chrono::from}.
+   * This method matches the signature of the functional interface {@@linkTemporalQuery} allowing it
+   * to be used in queries via method reference, {@@codeChrono::from} .
    *
    * @param temporal
    *   the temporal to convert, not null
    * @return
    *   the chronology, not null
    * @throws DateTimeException
-   *   if unable to convert to an { @code Chronology}
+   *   if unable to convert to an {@@codeChronology}
    */
   def from(temporal: TemporalAccessor): Chronology = {
     Objects.requireNonNull(temporal, "temporal")
@@ -91,35 +91,35 @@ object Chronology {
   }
 
   /**
-   * Obtains an instance of {@code Chronology} from a locale.
+   * Obtains an instance of {@@codeChronology} from a locale.
    *
-   * This returns a {@code Chronology} based on the specified locale, typically returning {@code
+   * This returns a {@@codeChronology} based on the specified locale, typically returning {@code
    * IsoChronology}. Other calendar systems are only returned if they are explicitly selected within
    * the locale.
    *
-   * The {@link Locale} class provide access to a range of information useful for localizing an
+   * The {@@linkLocale} class provide access to a range of information useful for localizing an
    * application. This includes the language and region, such as "en-GB" for English as used in
    * Great Britain.
    *
-   * The {@code Locale} class also supports an extension mechanism that can be used to identify a
+   * The {@@codeLocale} class also supports an extension mechanism that can be used to identify a
    * calendar system. The mechanism is a form of key-value pairs, where the calendar system has the
    * key "ca". For example, the locale "en-JP-u-ca-japanese" represents the English language as used
    * in Japan with the Japanese calendar system.
    *
    * This method finds the desired calendar system by in a manner equivalent to passing "ca" to
-   * {@link Locale#getUnicodeLocaleType(String)}. If the "ca" key is not present, then {@code
+   * {@@linkLocale#getUnicodeLocaleType(String)} . If the "ca" key is not present, then {@code
    * IsoChronology} is returned.
    *
    * Note that the behavior of this method differs from the older {@link
    * java.util.Calendar#getInstance(Locale)} method. If that method receives a locale of "th_TH" it
-   * will return {@code BuddhistCalendar}. By contrast, this method will return {@code
+   * will return {@@codeBuddhistCalendar} . By contrast, this method will return {@code
    * IsoChronology}. Passing the locale "th-TH-u-ca-buddhist" into either method will result in the
    * Thai Buddhist calendar system and is therefore the recommended approach going forward for Thai
    * calendar system localization.
    *
    * A similar, but simpler, situation occurs for the Japanese calendar system. The locale
    * "jp_JP_JP" has previously been used to access the calendar. However, unlike the Thai locale,
-   * "ja_JP_JP" is automatically converted by {@code Locale} to the modern and recommended form of
+   * "ja_JP_JP" is automatically converted by {@@codeLocale} to the modern and recommended form of
    * "ja-JP-u-ca-japanese". Thus, there is no difference in behavior between this method and {@code
    * Calendar#getInstance(Locale)}.
    *
@@ -145,10 +145,10 @@ object Chronology {
   }
 
   /**
-   * Obtains an instance of {@code Chronology} from a chronology ID or calendar system type.
+   * Obtains an instance of {@@codeChronology} from a chronology ID or calendar system type.
    *
    * This returns a chronology based on either the ID or the type. The {@link #getId() chronology
-   * ID} uniquely identifies the chronology. The {@link #getCalendarType() calendar system type} is
+   * ID} uniquely identifies the chronology. The {@@link#getCalendarType() calendar system type} is
    * defined by the LDML specification.
    *
    * The chronology may be a system chronology or a chronology provided by the application via
@@ -179,7 +179,7 @@ object Chronology {
   /**
    * Returns the available chronologies.
    *
-   * Each returned {@code Chronology} is available for use in the system.
+   * Each returned {@@codeChronology} is available for use in the system.
    *
    * @return
    *   the independent, modifiable set of the available chronology IDs, not null
@@ -228,7 +228,7 @@ object Chronology {
  *
  * Most other calendar systems also operate on the shared concepts of year, month and day, linked to
  * the cycles of the Earth around the Sun, and the Moon around the Earth. These shared concepts are
- * defined by {@link ChronoField} and are availalbe for use by any {@code Chronology}
+ * defined by {@@linkChronoField} and are availalbe for use by any {@@codeChronology}
  * implementation:
  * {{{
  * val isoDate: LocalDate = ...
@@ -237,39 +237,40 @@ object Chronology {
  * val thaiYear: Int = thaiDate.get(ChronoField.YEAR);
  * }}}
  * As shown, although the date objects are in different calendar systems, represented by different
- * {@code Chronology} instances, both can be queried using the same constant on {@code ChronoField}.
- * For a full discussion of the implications of this, see {@link ChronoLocalDate}. In general, the
- * advice is to use the known ISO-based {@code LocalDate}, rather than {@code ChronoLocalDate}.
+ * {@@codeChronology} instances, both can be queried using the same constant on {@@codeChronoField}
+ * . For a full discussion of the implications of this, see {@@linkChronoLocalDate} . In general,
+ * the advice is to use the known ISO-based {@@codeLocalDate} , rather than {@@codeChronoLocalDate}
+ * .
  *
- * While a {@code Chronology} object typically uses {@code ChronoField} and is based on an era,
+ * While a {@@codeChronology} object typically uses {@@codeChronoField} and is based on an era,
  * year-of-era, month-of-year, day-of-month model of a date, this is not required. A {@code
  * Chronology} instance may represent a totally different kind of calendar system, such as the
  * Mayan.
  *
- * In practical terms, the {@code Chronology} instance also acts as a factory. The {@link
+ * In practical terms, the {@@codeChronology} instance also acts as a factory. The {@link
  * #of(String)} method allows an instance to be looked up by identifier, while the {@link
  * #ofLocale(Locale)} method allows lookup by locale.
  *
- * The {@code Chronology} instance provides a set of methods to create {@code ChronoLocalDate}
+ * The {@@codeChronology} instance provides a set of methods to create {@@codeChronoLocalDate}
  * instances. The date classes are used to manipulate specific dates.
  *
- *   - {@link #dateNow() dateNow()}
- *   - {@link #dateNow(Clock) dateNow(clock)}
- *   - {@link #dateNow(ZoneId) dateNow(zone)}
- *   - {@link #date(int, int, int) date(yearProleptic, month, day)}
- *   - {@link #date(Era, int, int, int) date(era, yearOfEra, month, day)}
- *   - {@link #dateYearDay(int, int) dateYearDay(yearProleptic, dayOfYear)}
- *   - {@link #dateYearDay(Era, int, int) dateYearDay(era, yearOfEra, dayOfYear)}
- *   - {@link #date(TemporalAccessor) date(TemporalAccessor)}
+ *   - {@@link#dateNow() dateNow()}
+ *   - {@@link#dateNow(Clock) dateNow(clock)}
+ *   - {@@link#dateNow(ZoneId) dateNow(zone)}
+ *   - {@@link#date(int, int, int) date(yearProleptic, month, day)}
+ *   - {@@link#date(Era, int, int, int) date(era, yearOfEra, month, day)}
+ *   - {@@link#dateYearDay(int, int) dateYearDay(yearProleptic, dayOfYear)}
+ *   - {@@link#dateYearDay(Era, int, int) dateYearDay(era, yearOfEra, dayOfYear)}
+ *   - {@@link#date(TemporalAccessor) date(TemporalAccessor)}
  *
  * <p id="addcalendars">Adding New Calendars</p> The set of available chronologies can be extended
  * by applications. Adding a new calendar system requires the writing of an implementation of {@code
- * Chronology}, {@code ChronoLocalDate} and {@code Era}. The majority of the logic specific to the
- * calendar system will be in {@code ChronoLocalDate}. The {@code Chronology} subclass acts as a
+ * Chronology}, {@@codeChronoLocalDate} and {@@codeEra} . The majority of the logic specific to the
+ * calendar system will be in {@@codeChronoLocalDate} . The {@@codeChronology} subclass acts as a
  * factory.
  *
  * To permit the discovery of additional chronologies, the {@link java.util.ServiceLoader
- * ServiceLoader} is used. A file must be added to the {@code META-INF/services} directory with the
+ * ServiceLoader} is used. A file must be added to the {@@codeMETA-INF/services} directory with the
  * name 'org.threeten.bp.chrono.Chrono' listing the implementation classes. See the ServiceLoader
  * for more details on service loading. For lookup by id or calendarType, the system provided
  * calendars are found first followed by application provided calendars.
@@ -285,12 +286,12 @@ object Chronology {
 trait Chronology extends Ordered[Chronology] {
 
   /**
-   * Casts the {@code Temporal} to {@code ChronoLocalDate} with the same chronology.
+   * Casts the {@@codeTemporal} to {@@codeChronoLocalDate} with the same chronology.
    *
    * @param temporal
    *   a date-time to cast, not null
    * @return
-   *   the date-time checked and cast to { @code ChronoLocalDate}, not null
+   *   the date-time checked and cast to {@@codeChronoLocalDate} , not null
    * @throws ClassCastException
    *   if the date-time cannot be cast to ChronoLocalDate or the chronology is not equal this Chrono
    */
@@ -304,12 +305,12 @@ trait Chronology extends Ordered[Chronology] {
   }
 
   /**
-   * Casts the {@code Temporal} to {@code ChronoLocalDateTime} with the same chronology.
+   * Casts the {@@codeTemporal} to {@@codeChronoLocalDateTime} with the same chronology.
    *
    * @param temporal
    *   a date-time to cast, not null
    * @return
-   *   the date-time checked and cast to { @code ChronoLocalDateTime}, not null
+   *   the date-time checked and cast to {@@codeChronoLocalDateTime} , not null
    * @throws ClassCastException
    *   if the date-time cannot be cast to ChronoLocalDateTimeImpl or the chronology is not equal
    *   this Chrono
@@ -326,12 +327,12 @@ trait Chronology extends Ordered[Chronology] {
   }
 
   /**
-   * Casts the {@code Temporal} to {@code ChronoZonedDateTimeImpl} with the same chronology.
+   * Casts the {@@codeTemporal} to {@@codeChronoZonedDateTimeImpl} with the same chronology.
    *
    * @param temporal
    *   a date-time to cast, not null
    * @return
-   *   the date-time checked and cast to { @code ChronoZonedDateTimeImpl}, not null
+   *   the date-time checked and cast to {@@codeChronoZonedDateTimeImpl} , not null
    * @throws ClassCastException
    *   if the date-time cannot be cast to ChronoZonedDateTimeImpl or the chronology is not equal
    *   this Chrono
@@ -350,8 +351,8 @@ trait Chronology extends Ordered[Chronology] {
   /**
    * Gets the ID of the chronology.
    *
-   * The ID uniquely identifies the {@code Chronology}. It can be used to lookup the {@code
-   * Chronology} using {@link #of(String)}.
+   * The ID uniquely identifies the {@@codeChronology} . It can be used to lookup the {@code
+   * Chronology} using {@@link#of(String)} .
    *
    * @return
    *   the chronology ID, not null
@@ -364,7 +365,7 @@ trait Chronology extends Ordered[Chronology] {
    * Gets the calendar type of the underlying calendar system.
    *
    * The calendar type is an identifier defined by the <em>Unicode Locale Data Markup Language
-   * (LDML)</em> specification. It can be used to lookup the {@code Chronology} using {@link
+   * (LDML)</em> specification. It can be used to lookup the {@@codeChronology} using {@link
    * #of(String)}. It can also be used as part of a locale, accessible via {@link
    * Locale#getUnicodeLocaleType(String)} with the key 'ca'.
    *
@@ -392,7 +393,7 @@ trait Chronology extends Ordered[Chronology] {
    * @throws DateTimeException
    *   if unable to create the date
    * @throws ClassCastException
-   *   if the { @code era} is not of the correct type for the chronology
+   *   if the {@@codeera} is not of the correct type for the chronology
    */
   def date(era: Era, yearOfEra: Int, month: Int, dayOfMonth: Int): ChronoLocalDate =
     date(prolepticYear(era, yearOfEra), month, dayOfMonth)
@@ -428,7 +429,7 @@ trait Chronology extends Ordered[Chronology] {
    * @throws DateTimeException
    *   if unable to create the date
    * @throws ClassCastException
-   *   if the { @code era} is not of the correct type for the chronology
+   *   if the {@@codeera} is not of the correct type for the chronology
    */
   def dateYearDay(era: Era, yearOfEra: Int, dayOfYear: Int): ChronoLocalDate =
     dateYearDay(prolepticYear(era, yearOfEra), dayOfYear)
@@ -450,7 +451,7 @@ trait Chronology extends Ordered[Chronology] {
   /**
    * Obtains a local date in this chronology from the epoch-day.
    *
-   * The definition of {@link ChronoField#EPOCH_DAY EPOCH_DAY} is the same for all calendar systems,
+   * The definition of {@@linkChronoField#EPOCH_DAY EPOCH_DAY} is the same for all calendar systems,
    * thus it can be used for conversion.
    *
    * @param epochDay
@@ -465,7 +466,7 @@ trait Chronology extends Ordered[Chronology] {
   /**
    * Obtains a local date in this chronology from another temporal object.
    *
-   * This creates a date in this chronology based on the specified {@code TemporalAccessor}.
+   * This creates a date in this chronology based on the specified {@@codeTemporalAccessor} .
    *
    * The standard mechanism for conversion between date types is the {@link ChronoField#EPOCH_DAY
    * local epoch-day} field.
@@ -483,13 +484,13 @@ trait Chronology extends Ordered[Chronology] {
    * Obtains the current local date in this chronology from the system clock in the default
    * time-zone.
    *
-   * This will query the {@link Clock#systemDefaultZone() system clock} in the default time-zone to
+   * This will query the {@@linkClock#systemDefaultZone() system clock} in the default time-zone to
    * obtain the current date.
    *
    * Using this method will prevent the ability to use an alternate clock for testing because the
    * clock is hard-coded.
    *
-   * This implementation uses {@link #dateNow(Clock)}.
+   * This implementation uses {@@link#dateNow(Clock)} .
    *
    * @return
    *   the current local date using the system clock and default time-zone, not null
@@ -502,7 +503,7 @@ trait Chronology extends Ordered[Chronology] {
    * Obtains the current local date in this chronology from the system clock in the specified
    * time-zone.
    *
-   * This will query the {@link Clock#system(ZoneId) system clock} to obtain the current date.
+   * This will query the {@@linkClock#system(ZoneId) system clock} to obtain the current date.
    * Specifying the time-zone avoids dependence on the default time-zone.
    *
    * Using this method will prevent the ability to use an alternate clock for testing because the
@@ -522,7 +523,7 @@ trait Chronology extends Ordered[Chronology] {
    *
    * This will query the specified clock to obtain the current date - today. Using this method
    * allows the use of an alternate clock for testing. The alternate clock may be introduced using
-   * {@link Clock dependency injection}.
+   * {@@linkClock dependency injection} .
    *
    * @param clock
    *   the clock to use, not null
@@ -539,11 +540,11 @@ trait Chronology extends Ordered[Chronology] {
   /**
    * Obtains a local date-time in this chronology from another temporal object.
    *
-   * This creates a date-time in this chronology based on the specified {@code TemporalAccessor}.
+   * This creates a date-time in this chronology based on the specified {@@codeTemporalAccessor} .
    *
    * The date of the date-time should be equivalent to that obtained by calling {@link
    * #date(TemporalAccessor)}. The standard mechanism for conversion between time types is the
-   * {@link ChronoField#NANO_OF_DAY nano-of-day} field.
+   * {@@linkChronoField#NANO_OF_DAY nano-of-day} field.
    *
    * @param temporal
    *   the temporal object to convert, not null
@@ -567,10 +568,10 @@ trait Chronology extends Ordered[Chronology] {
   /**
    * Obtains a zoned date-time in this chronology from another temporal object.
    *
-   * This creates a date-time in this chronology based on the specified {@code TemporalAccessor}.
+   * This creates a date-time in this chronology based on the specified {@@codeTemporalAccessor} .
    *
-   * This should obtain a {@code ZoneId} using {@link ZoneId#from(TemporalAccessor)}. The date-time
-   * should be obtained by obtaining an {@code Instant}. If that fails, the local date-time should
+   * This should obtain a {@@codeZoneId} using {@@linkZoneId#from(TemporalAccessor)} . The date-time
+   * should be obtained by obtaining an {@@codeInstant} . If that fails, the local date-time should
    * be used.
    *
    * @param temporal
@@ -604,7 +605,7 @@ trait Chronology extends Ordered[Chronology] {
     }
 
   /**
-   * Obtains a zoned date-time in this chronology from an {@code Instant}.
+   * Obtains a zoned date-time in this chronology from an {@@codeInstant} .
    *
    * This creates a zoned date-time with the same instant as that specified.
    *
@@ -629,12 +630,12 @@ trait Chronology extends Ordered[Chronology] {
    *
    * The default implementation returns an implementation class suitable for most calendar systems.
    * It is based solely on the three units. Normalization, addition and subtraction derive the
-   * number of months in a year from the {@link #range(ChronoField)}. If the number of months within
-   * a year is fixed, then the calculation approach for addition, subtraction and normalization is
-   * slightly different.
+   * number of months in a year from the {@@link#range(ChronoField)} . If the number of months
+   * within a year is fixed, then the calculation approach for addition, subtraction and
+   * normalization is slightly different.
    *
    * If implementing an unusual calendar system that is not based on years, months and days, or
-   * where you want direct control, then the {@code ChronoPeriod} interface must be directly
+   * where you want direct control, then the {@@codeChronoPeriod} interface must be directly
    * implemented.
    *
    * The returned period is immutable and thread-safe.
@@ -681,7 +682,7 @@ trait Chronology extends Ordered[Chronology] {
    * @throws DateTimeException
    *   if unable to convert
    * @throws ClassCastException
-   *   if the { @code era} is not of the correct type for the chronology
+   *   if the {@@codeera} is not of the correct type for the chronology
    */
   def prolepticYear(era: Era, yearOfEra: Int): Int
 
@@ -722,7 +723,7 @@ trait Chronology extends Ordered[Chronology] {
   /**
    * Gets the range of valid values for the specified field.
    *
-   * All fields can be expressed as a {@code long} integer. This method returns an object that
+   * All fields can be expressed as a {@@codelong} integer. This method returns an object that
    * describes the valid range for that value.
    *
    * Note that the result only describes the minimum and maximum valid values and it is important
@@ -769,11 +770,11 @@ trait Chronology extends Ordered[Chronology] {
       })
 
   /**
-   * Resolves parsed {@code ChronoField} values into a date during parsing.
+   * Resolves parsed {@@codeChronoField} values into a date during parsing.
    *
-   * Most {@code TemporalField} implementations are resolved using the resolve method on the field.
-   * By contrast, the {@code ChronoField} class defines fields that only have meaning relative to
-   * the chronology. As such, {@code ChronoField} date fields are resolved here in the context of a
+   * Most {@@codeTemporalField} implementations are resolved using the resolve method on the field.
+   * By contrast, the {@@codeChronoField} class defines fields that only have meaning relative to
+   * the chronology. As such, {@@codeChronoField} date fields are resolved here in the context of a
    * specific chronology.
    *
    * The default implementation, which explains typical resolve behaviour, is provided in {@link
@@ -823,7 +824,7 @@ trait Chronology extends Ordered[Chronology] {
    * Compares this chronology to another chronology.
    *
    * The comparison order first by the chronology ID string, then by any additional information
-   * specific to the subclass. It is "consistent with equals", as defined by {@link Comparable}.
+   * specific to the subclass. It is "consistent with equals", as defined by {@@linkComparable} .
    *
    * The default implementation compares the chronology ID. Subclasses must compare any additional
    * state that they store.
@@ -840,7 +841,7 @@ trait Chronology extends Ordered[Chronology] {
    *
    * The comparison is based on the entire state of the object.
    *
-   * The default implementation checks the type and calls {@link #compareTo(Chronology)}.
+   * The default implementation checks the type and calls {@@link#compareTo(Chronology)} .
    *
    * @param obj
    *   the object to check, null returns false
@@ -865,7 +866,7 @@ trait Chronology extends Ordered[Chronology] {
   override def hashCode: Int = getClass.hashCode ^ getId.hashCode
 
   /**
-   * Outputs this chronology as a {@code String}, using the ID.
+   * Outputs this chronology as a {@@codeString} , using the ID.
    *
    * @return
    *   a string representation of this chronology, not null
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/Era.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/Era.scala
index b3d1842e8..0ee7b70ee 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/Era.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/Era.scala
@@ -51,12 +51,12 @@ import org.threeten.bp.temporal.UnsupportedTemporalTypeException
  * Most calendar systems have a single epoch dividing the time-line into two eras. However, some
  * calendar systems, have multiple eras, such as one for the reign of each leader. In all cases, the
  * era is conceptually the largest division of the time-line. Each chronology defines the Era's that
- * are known Eras and a {@link Chronology#eras Chrono.eras} to get the valid eras.
+ * are known Eras and a {@@linkChronology#eras Chrono.eras} to get the valid eras.
  *
  * For example, the Thai Buddhist calendar system divides time into two eras, before and after a
  * single date. By contrast, the Japanese calendar system has one era for the reign of each Emperor.
  *
- * Instances of {@code Era} may be compared using the {@code ==} operator.
+ * Instances of {@@codeEra} may be compared using the {@@code==} operator.
  *
  * <h3>Specification for implementors</h3> This interface must be implemented with care to ensure
  * other classes operate correctly. All implementations must be singletons - final, immutable and
@@ -84,7 +84,7 @@ trait Era extends TemporalAccessor with TemporalAdjuster {
    * This returns the textual name used to identify the era. The parameters control the style of the
    * returned text and the locale.
    *
-   * If no textual mapping is found then the {@link #getValue() numeric value} is returned.
+   * If no textual mapping is found then the {@@link#getValue() numeric value} is returned.
    *
    * @param style
    *   the style of the text required, not null
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/HijrahChronology.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/HijrahChronology.scala
index b89a806bd..216bfcdb5 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/HijrahChronology.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/HijrahChronology.scala
@@ -138,8 +138,8 @@ final class HijrahChronology private () extends Chronology with Serializable {
   /**
    * Gets the ID of the chronology - 'Hijrah-umalqura'.
    *
-   * The ID uniquely identifies the {@code Chronology}. It can be used to lookup the {@code
-   * Chronology} using {@link #of(String)}.
+   * The ID uniquely identifies the {@@codeChronology} . It can be used to lookup the {@code
+   * Chronology} using {@@link#of(String)} .
    *
    * @return
    *   the chronology ID - 'Hijrah-umalqura'
@@ -152,7 +152,7 @@ final class HijrahChronology private () extends Chronology with Serializable {
    * Gets the calendar type of the underlying calendar system - 'islamic-umalqura'.
    *
    * The calendar type is an identifier defined by the <em>Unicode Locale Data Markup Language
-   * (LDML)</em> specification. It can be used to lookup the {@code Chronology} using {@link
+   * (LDML)</em> specification. It can be used to lookup the {@@codeChronology} using {@link
    * #of(String)}. It can also be used as part of a locale, accessible via {@link
    * Locale#getUnicodeLocaleType(String)} with the key 'ca'.
    *
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/HijrahDate.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/HijrahDate.scala
index 5a882f5bd..1507a3ea3 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/HijrahDate.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/HijrahDate.scala
@@ -89,9 +89,9 @@ object HijrahDate {
     Array(30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 30)
 
   /**
-   * <pre> Greatest Least Field name Minimum Minimum Maximum Maximum
-   * ---------- ------- ------- ------- ------- ERA 0 0 1 1 YEAR_OF_ERA 1 1 9999 9999 MONTH_OF_YEAR
-   * 1 1 12 12 DAY_OF_MONTH 1 1 29 30 DAY_OF_YEAR 1 1 354 355 </pre>
+   * <pre> Greatest Least Field name Minimum Minimum Maximum Maximum ---------- ------- -------
+   * ------- ------- ERA 0 0 1 1 YEAR_OF_ERA 1 1 9999 9999 MONTH_OF_YEAR 1 1 12 12 DAY_OF_MONTH 1 1
+   * 29 30 DAY_OF_YEAR 1 1 354 355 </pre>
    *
    * Minimum values.
    */
@@ -256,10 +256,10 @@ object HijrahDate {
   }
 
   /**
-   * Obtains the current {@code HijrahDate} of the Islamic Umm Al-Qura calendar in the default
+   * Obtains the current {@@codeHijrahDate} of the Islamic Umm Al-Qura calendar in the default
    * time-zone.
    *
-   * This will query the {@link Clock#systemDefaultZone() system clock} in the default time-zone to
+   * This will query the {@@linkClock#systemDefaultZone() system clock} in the default time-zone to
    * obtain the current date.
    *
    * Using this method will prevent the ability to use an alternate clock for testing because the
@@ -271,10 +271,10 @@ object HijrahDate {
   def now: HijrahDate = now(Clock.systemDefaultZone)
 
   /**
-   * Obtains the current {@code HijrahDate} of the Islamic Umm Al-Qura calendar in the specified
+   * Obtains the current {@@codeHijrahDate} of the Islamic Umm Al-Qura calendar in the specified
    * time-zone.
    *
-   * This will query the {@link Clock#system(ZoneId) system clock} to obtain the current date.
+   * This will query the {@@linkClock#system(ZoneId) system clock} to obtain the current date.
    * Specifying the time-zone avoids dependence on the default time-zone.
    *
    * Using this method will prevent the ability to use an alternate clock for testing because the
@@ -288,12 +288,12 @@ object HijrahDate {
   def now(zone: ZoneId): HijrahDate = now(Clock.system(zone))
 
   /**
-   * Obtains the current {@code HijrahDate} of the Islamic Umm Al-Qura calendar from the specified
+   * Obtains the current {@@codeHijrahDate} of the Islamic Umm Al-Qura calendar from the specified
    * clock.
    *
    * This will query the specified clock to obtain the current date - today. Using this method
    * allows the use of an alternate clock for testing. The alternate clock may be introduced using
-   * {@linkplain Clock dependency injection}.
+   * {@@linkplainClock dependency injection} .
    *
    * @param clock
    *   the clock to use, not null
@@ -305,7 +305,7 @@ object HijrahDate {
   def now(clock: Clock): HijrahDate = HijrahChronology.INSTANCE.dateNow(clock)
 
   /**
-   * Obtains an instance of {@code HijrahDate} from the Hijrah era year, month-of-year and
+   * Obtains an instance of {@@codeHijrahDate} from the Hijrah era year, month-of-year and
    * day-of-month. This uses the Hijrah era.
    *
    * @param prolepticYear
@@ -326,7 +326,7 @@ object HijrahDate {
     else HijrahDate.of(HijrahEra.of(0), 1 - prolepticYear, monthOfYear, dayOfMonth)
 
   /**
-   * Obtains an instance of {@code HijrahDate} from the era, year-of-era month-of-year and
+   * Obtains an instance of {@@codeHijrahDate} from the era, year-of-era month-of-year and
    * day-of-month.
    *
    * @param era
@@ -386,7 +386,7 @@ object HijrahDate {
       )
 
   /**
-   * Obtains an instance of {@code HijrahDate} from a date.
+   * Obtains an instance of {@@codeHijrahDate} from a date.
    *
    * @param date
    *   the date to use, not null
@@ -403,24 +403,24 @@ object HijrahDate {
   private[chrono] def ofEpochDay(epochDay: Long): HijrahDate = new HijrahDate(epochDay)
 
   /**
-   * Obtains a {@code HijrahDate} of the Islamic Umm Al-Qura calendar from a temporal object.
+   * Obtains a {@@codeHijrahDate} of the Islamic Umm Al-Qura calendar from a temporal object.
    *
    * This obtains a date in the Hijrah calendar system based on the specified temporal. A {@code
    * TemporalAccessor} represents an arbitrary set of date and time information, which this factory
-   * converts to an instance of {@code HijrahDate}.
+   * converts to an instance of {@@codeHijrahDate} .
    *
-   * The conversion typically uses the {@link ChronoField#EPOCH_DAY EPOCH_DAY} field, which is
+   * The conversion typically uses the {@@linkChronoField#EPOCH_DAY EPOCH_DAY} field, which is
    * standardized across calendar systems.
    *
-   * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used as a query via method reference, {@code HijrahDate::from}.
+   * This method matches the signature of the functional interface {@@linkTemporalQuery} allowing it
+   * to be used as a query via method reference, {@@codeHijrahDate::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the date in Hijrah calendar system, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code HijrahDate}
+   *   if unable to convert to a {@@codeHijrahDate}
    */
   def from(temporal: TemporalAccessor): HijrahDate = HijrahChronology.INSTANCE.date(temporal)
 
@@ -1144,7 +1144,7 @@ object HijrahDate {
 /**
  * A date in the Hijrah calendar system.
  *
- * This implements {@code ChronoLocalDate} for the {@link HijrahChronology Hijrah calendar}.
+ * This implements {@@codeChronoLocalDate} for the {@@linkHijrahChronology Hijrah calendar} .
  *
  * The Hijrah calendar has a different total of days in a year than Gregorian calendar, and a month
  * is based on the period of a complete revolution of the moon around the earth (as between
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/IsoChronology.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/IsoChronology.scala
index 1d3fc11f2..ab537cbb4 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/IsoChronology.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/IsoChronology.scala
@@ -107,8 +107,8 @@ final class IsoChronology private () extends Chronology with Serializable {
   /**
    * Gets the ID of the chronology - 'ISO'.
    *
-   * The ID uniquely identifies the {@code Chronology}. It can be used to lookup the {@code
-   * Chronology} using {@link #of(String)}.
+   * The ID uniquely identifies the {@@codeChronology} . It can be used to lookup the {@code
+   * Chronology} using {@@link#of(String)} .
    *
    * @return
    *   the chronology ID - 'ISO'
@@ -121,7 +121,7 @@ final class IsoChronology private () extends Chronology with Serializable {
    * Gets the calendar type of the underlying calendar system - 'iso8601'.
    *
    * The calendar type is an identifier defined by the <em>Unicode Locale Data Markup Language
-   * (LDML)</em> specification. It can be used to lookup the {@code Chronology} using {@link
+   * (LDML)</em> specification. It can be used to lookup the {@@codeChronology} using {@link
    * #of(String)}. It can also be used as part of a locale, accessible via {@link
    * Locale#getUnicodeLocaleType(String)} with the key 'ca'.
    *
@@ -154,7 +154,7 @@ final class IsoChronology private () extends Chronology with Serializable {
   /**
    * Obtains an ISO local date from the proleptic-year, month-of-year and day-of-month fields.
    *
-   * This is equivalent to {@link LocalDate#of(int, int, int)}.
+   * This is equivalent to {@@linkLocalDate#of(int, int, int)} .
    *
    * @param prolepticYear
    *   the ISO proleptic-year
@@ -190,7 +190,7 @@ final class IsoChronology private () extends Chronology with Serializable {
   /**
    * Obtains an ISO local date from the proleptic-year and day-of-year fields.
    *
-   * This is equivalent to {@link LocalDate#ofYearDay(int, int)}.
+   * This is equivalent to {@@linkLocalDate#ofYearDay(int, int)} .
    *
    * @param prolepticYear
    *   the ISO proleptic-year
@@ -209,7 +209,7 @@ final class IsoChronology private () extends Chronology with Serializable {
   /**
    * Obtains an ISO local date from another date-time object.
    *
-   * This is equivalent to {@link LocalDate#from(TemporalAccessor)}.
+   * This is equivalent to {@@linkLocalDate#from(TemporalAccessor)} .
    *
    * @param temporal
    *   the date-time object to convert, not null
@@ -223,7 +223,7 @@ final class IsoChronology private () extends Chronology with Serializable {
   /**
    * Obtains an ISO local date-time from another date-time object.
    *
-   * This is equivalent to {@link LocalDateTime#from(TemporalAccessor)}.
+   * This is equivalent to {@@linkLocalDateTime#from(TemporalAccessor)} .
    *
    * @param temporal
    *   the date-time object to convert, not null
@@ -238,7 +238,7 @@ final class IsoChronology private () extends Chronology with Serializable {
   /**
    * Obtains an ISO zoned date-time from another date-time object.
    *
-   * This is equivalent to {@link ZonedDateTime#from(TemporalAccessor)}.
+   * This is equivalent to {@@linkZonedDateTime#from(TemporalAccessor)} .
    *
    * @param temporal
    *   the date-time object to convert, not null
@@ -253,7 +253,7 @@ final class IsoChronology private () extends Chronology with Serializable {
   /**
    * Obtains an ISO zoned date-time from an instant.
    *
-   * This is equivalent to {@link ZonedDateTime#ofInstant(Instant, ZoneId)}.
+   * This is equivalent to {@@linkZonedDateTime#ofInstant(Instant, ZoneId)} .
    *
    * @param instant
    *   the instant to convert, not null
@@ -270,7 +270,7 @@ final class IsoChronology private () extends Chronology with Serializable {
   /**
    * Obtains the current ISO local date from the system clock in the default time-zone.
    *
-   * This will query the {@link Clock#systemDefaultZone() system clock} in the default time-zone to
+   * This will query the {@@linkClock#systemDefaultZone() system clock} in the default time-zone to
    * obtain the current date.
    *
    * Using this method will prevent the ability to use an alternate clock for testing because the
@@ -286,7 +286,7 @@ final class IsoChronology private () extends Chronology with Serializable {
   /**
    * Obtains the current ISO local date from the system clock in the specified time-zone.
    *
-   * This will query the {@link Clock#system(ZoneId) system clock} to obtain the current date.
+   * This will query the {@@linkClock#system(ZoneId) system clock} to obtain the current date.
    * Specifying the time-zone avoids dependence on the default time-zone.
    *
    * Using this method will prevent the ability to use an alternate clock for testing because the
@@ -304,7 +304,7 @@ final class IsoChronology private () extends Chronology with Serializable {
    *
    * This will query the specified clock to obtain the current date - today. Using this method
    * allows the use of an alternate clock for testing. The alternate clock may be introduced using
-   * {@link Clock dependency injection}.
+   * {@@linkClock dependency injection} .
    *
    * @param clock
    *   the clock to use, not null
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/MinguoChronology.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/MinguoChronology.scala
index e41849f7e..84dfd06b8 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/MinguoChronology.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/MinguoChronology.scala
@@ -77,7 +77,7 @@ object MinguoChronology {
  *
  * This chronology defines the rules of the Minguo calendar system. This calendar system is
  * primarily used in the Republic of China, often known as Taiwan. Dates are aligned such that
- * {@code 0001-01-01 (Minguo)} is {@code 1912-01-01 (ISO)}.
+ * {@@code0001-01-01 (Minguo)} is {@@code1912-01-01 (ISO)} .
  *
  * The fields are defined as follows: <ul> <li>era - There are two eras, the current 'Republic'
  * (ROC) and the previous era (BEFORE_ROC). <li>year-of-era - The year-of-era for the current era
@@ -106,8 +106,8 @@ final class MinguoChronology private () extends Chronology with Serializable {
   /**
    * Gets the ID of the chronology - 'Minguo'.
    *
-   * The ID uniquely identifies the {@code Chronology}. It can be used to lookup the {@code
-   * Chronology} using {@link #of(String)}.
+   * The ID uniquely identifies the {@@codeChronology} . It can be used to lookup the {@code
+   * Chronology} using {@@link#of(String)} .
    *
    * @return
    *   the chronology ID - 'Minguo'
@@ -120,7 +120,7 @@ final class MinguoChronology private () extends Chronology with Serializable {
    * Gets the calendar type of the underlying calendar system - 'roc'.
    *
    * The calendar type is an identifier defined by the <em>Unicode Locale Data Markup Language
-   * (LDML)</em> specification. It can be used to lookup the {@code Chronology} using {@link
+   * (LDML)</em> specification. It can be used to lookup the {@@codeChronology} using {@link
    * #of(String)}. It can also be used as part of a locale, accessible via {@link
    * Locale#getUnicodeLocaleType(String)} with the key 'ca'.
    *
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/MinguoDate.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/MinguoDate.scala
index b986b4538..d2a4d9f3f 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/MinguoDate.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/MinguoDate.scala
@@ -53,9 +53,9 @@ import org.threeten.bp.temporal.ValueRange
 object MinguoDate {
 
   /**
-   * Obtains the current {@code MinguoDate} from the system clock in the default time-zone.
+   * Obtains the current {@@codeMinguoDate} from the system clock in the default time-zone.
    *
-   * This will query the {@link Clock#systemDefaultZone() system clock} in the default time-zone to
+   * This will query the {@@linkClock#systemDefaultZone() system clock} in the default time-zone to
    * obtain the current date.
    *
    * Using this method will prevent the ability to use an alternate clock for testing because the
@@ -67,9 +67,9 @@ object MinguoDate {
   def now: MinguoDate = now(Clock.systemDefaultZone)
 
   /**
-   * Obtains the current {@code MinguoDate} from the system clock in the specified time-zone.
+   * Obtains the current {@@codeMinguoDate} from the system clock in the specified time-zone.
    *
-   * This will query the {@link Clock#system(ZoneId) system clock} to obtain the current date.
+   * This will query the {@@linkClock#system(ZoneId) system clock} to obtain the current date.
    * Specifying the time-zone avoids dependence on the default time-zone.
    *
    * Using this method will prevent the ability to use an alternate clock for testing because the
@@ -83,11 +83,11 @@ object MinguoDate {
   def now(zone: ZoneId): MinguoDate = now(Clock.system(zone))
 
   /**
-   * Obtains the current {@code MinguoDate} from the specified clock.
+   * Obtains the current {@@codeMinguoDate} from the specified clock.
    *
    * This will query the specified clock to obtain the current date - today. Using this method
    * allows the use of an alternate clock for testing. The alternate clock may be introduced using
-   * {@linkplain Clock dependency injection}.
+   * {@@linkplainClock dependency injection} .
    *
    * @param clock
    *   the clock to use, not null
@@ -99,10 +99,10 @@ object MinguoDate {
   def now(clock: Clock): MinguoDate = new MinguoDate(LocalDate.now(clock))
 
   /**
-   * Obtains a {@code MinguoDate} representing a date in the Minguo calendar system from the
+   * Obtains a {@@codeMinguoDate} representing a date in the Minguo calendar system from the
    * proleptic-year, month-of-year and day-of-month fields.
    *
-   * This returns a {@code MinguoDate} with the specified fields. The day must be valid for the year
+   * This returns a {@@codeMinguoDate} with the specified fields. The day must be valid for the year
    * and month, otherwise an exception will be thrown.
    *
    * @param prolepticYear
@@ -121,24 +121,24 @@ object MinguoDate {
     MinguoChronology.INSTANCE.date(prolepticYear, month, dayOfMonth)
 
   /**
-   * Obtains a {@code MinguoDate} from a temporal object.
+   * Obtains a {@@codeMinguoDate} from a temporal object.
    *
    * This obtains a date in the Minguo calendar system based on the specified temporal. A {@code
    * TemporalAccessor} represents an arbitrary set of date and time information, which this factory
-   * converts to an instance of {@code MinguoDate}.
+   * converts to an instance of {@@codeMinguoDate} .
    *
-   * The conversion typically uses the {@link ChronoField#EPOCH_DAY EPOCH_DAY} field, which is
+   * The conversion typically uses the {@@linkChronoField#EPOCH_DAY EPOCH_DAY} field, which is
    * standardized across calendar systems.
    *
-   * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used as a query via method reference, {@code MinguoDate::from}.
+   * This method matches the signature of the functional interface {@@linkTemporalQuery} allowing it
+   * to be used as a query via method reference, {@@codeMinguoDate::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the date in Minguo calendar system, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code MinguoDate}
+   *   if unable to convert to a {@@codeMinguoDate}
    */
   def from(temporal: TemporalAccessor): MinguoDate = MinguoChronology.INSTANCE.date(temporal)
 
@@ -147,9 +147,9 @@ object MinguoDate {
 /**
  * A date in the Minguo calendar system.
  *
- * This date operates using the {@linkplain MinguoChronology Minguo calendar}. This calendar system
+ * This date operates using the {@@linkplainMinguoChronology Minguo calendar} . This calendar system
  * is primarily used in the Republic of China, often known as Taiwan. Dates are aligned such that
- * {@code 0001-01-01 (Minguo)} is {@code 1912-01-01 (ISO)}.
+ * {@@code0001-01-01 (Minguo)} is {@@code1912-01-01 (ISO)} .
  *
  * <h3>Specification for implementors</h3> This class is immutable and thread-safe.
  *
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/ThaiBuddhistChronology.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/ThaiBuddhistChronology.scala
index 908f6dac2..5b9a7c502 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/ThaiBuddhistChronology.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/ThaiBuddhistChronology.scala
@@ -106,7 +106,7 @@ object ThaiBuddhistChronology {
  * The Thai Buddhist calendar system.
  *
  * This chronology defines the rules of the Thai Buddhist calendar system. This calendar system is
- * primarily used in Thailand. Dates are aligned such that {@code 2484-01-01 (Buddhist)} is {@code
+ * primarily used in Thailand. Dates are aligned such that {@@code2484-01-01 (Buddhist)} is {@code
  * 1941-01-01 (ISO)}.
  *
  * The fields are defined as follows: <ul> <li>era - There are two eras, the current 'Buddhist' (BE)
@@ -136,8 +136,8 @@ final class ThaiBuddhistChronology private () extends Chronology with Serializab
   /**
    * Gets the ID of the chronology - 'ThaiBuddhist'.
    *
-   * The ID uniquely identifies the {@code Chronology}. It can be used to lookup the {@code
-   * Chronology} using {@link #of(String)}.
+   * The ID uniquely identifies the {@@codeChronology} . It can be used to lookup the {@code
+   * Chronology} using {@@link#of(String)} .
    *
    * @return
    *   the chronology ID - 'ThaiBuddhist'
@@ -150,7 +150,7 @@ final class ThaiBuddhistChronology private () extends Chronology with Serializab
    * Gets the calendar type of the underlying calendar system - 'buddhist'.
    *
    * The calendar type is an identifier defined by the <em>Unicode Locale Data Markup Language
-   * (LDML)</em> specification. It can be used to lookup the {@code Chronology} using {@link
+   * (LDML)</em> specification. It can be used to lookup the {@@codeChronology} using {@link
    * #of(String)}. It can also be used as part of a locale, accessible via {@link
    * Locale#getUnicodeLocaleType(String)} with the key 'ca'.
    *
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/ThaiBuddhistDate.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/ThaiBuddhistDate.scala
index cdc167df6..52ce36a80 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/ThaiBuddhistDate.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/ThaiBuddhistDate.scala
@@ -53,9 +53,9 @@ import org.threeten.bp.temporal.ValueRange
 object ThaiBuddhistDate {
 
   /**
-   * Obtains the current {@code ThaiBuddhistDate} from the system clock in the default time-zone.
+   * Obtains the current {@@codeThaiBuddhistDate} from the system clock in the default time-zone.
    *
-   * This will query the {@link Clock#systemDefaultZone() system clock} in the default time-zone to
+   * This will query the {@@linkClock#systemDefaultZone() system clock} in the default time-zone to
    * obtain the current date.
    *
    * Using this method will prevent the ability to use an alternate clock for testing because the
@@ -67,9 +67,9 @@ object ThaiBuddhistDate {
   def now: ThaiBuddhistDate = now(Clock.systemDefaultZone)
 
   /**
-   * Obtains the current {@code ThaiBuddhistDate} from the system clock in the specified time-zone.
+   * Obtains the current {@@codeThaiBuddhistDate} from the system clock in the specified time-zone.
    *
-   * This will query the {@link Clock#system(ZoneId) system clock} to obtain the current date.
+   * This will query the {@@linkClock#system(ZoneId) system clock} to obtain the current date.
    * Specifying the time-zone avoids dependence on the default time-zone.
    *
    * Using this method will prevent the ability to use an alternate clock for testing because the
@@ -83,11 +83,11 @@ object ThaiBuddhistDate {
   def now(zone: ZoneId): ThaiBuddhistDate = now(Clock.system(zone))
 
   /**
-   * Obtains the current {@code ThaiBuddhistDate} from the specified clock.
+   * Obtains the current {@@codeThaiBuddhistDate} from the specified clock.
    *
    * This will query the specified clock to obtain the current date - today. Using this method
    * allows the use of an alternate clock for testing. The alternate clock may be introduced using
-   * {@linkplain Clock dependency injection}.
+   * {@@linkplainClock dependency injection} .
    *
    * @param clock
    *   the clock to use, not null
@@ -99,10 +99,10 @@ object ThaiBuddhistDate {
   def now(clock: Clock): ThaiBuddhistDate = new ThaiBuddhistDate(LocalDate.now(clock))
 
   /**
-   * Obtains a {@code ThaiBuddhistDate} representing a date in the Thai Buddhist calendar system
+   * Obtains a {@@codeThaiBuddhistDate} representing a date in the Thai Buddhist calendar system
    * from the proleptic-year, month-of-year and day-of-month fields.
    *
-   * This returns a {@code ThaiBuddhistDate} with the specified fields. The day must be valid for
+   * This returns a {@@codeThaiBuddhistDate} with the specified fields. The day must be valid for
    * the year and month, otherwise an exception will be thrown.
    *
    * @param prolepticYear
@@ -121,24 +121,24 @@ object ThaiBuddhistDate {
     ThaiBuddhistChronology.INSTANCE.date(prolepticYear, month, dayOfMonth)
 
   /**
-   * Obtains a {@code ThaiBuddhistDate} from a temporal object.
+   * Obtains a {@@codeThaiBuddhistDate} from a temporal object.
    *
    * This obtains a date in the Thai Buddhist calendar system based on the specified temporal. A
-   * {@code TemporalAccessor} represents an arbitrary set of date and time information, which this
-   * factory converts to an instance of {@code ThaiBuddhistDate}.
+   * {@@codeTemporalAccessor} represents an arbitrary set of date and time information, which this
+   * factory converts to an instance of {@@codeThaiBuddhistDate} .
    *
-   * The conversion typically uses the {@link ChronoField#EPOCH_DAY EPOCH_DAY} field, which is
+   * The conversion typically uses the {@@linkChronoField#EPOCH_DAY EPOCH_DAY} field, which is
    * standardized across calendar systems.
    *
-   * This method matches the signature of the functional interface {@link TemporalQuery} allowing it
-   * to be used as a query via method reference, {@code ThaiBuddhistDate::from}.
+   * This method matches the signature of the functional interface {@@linkTemporalQuery} allowing it
+   * to be used as a query via method reference, {@@codeThaiBuddhistDate::from} .
    *
    * @param temporal
    *   the temporal object to convert, not null
    * @return
    *   the date in Thai Buddhist calendar system, not null
    * @throws DateTimeException
-   *   if unable to convert to a { @code ThaiBuddhistDate}
+   *   if unable to convert to a {@@codeThaiBuddhistDate}
    */
   def from(temporal: TemporalAccessor): ThaiBuddhistDate =
     ThaiBuddhistChronology.INSTANCE.date(temporal)
@@ -148,9 +148,9 @@ object ThaiBuddhistDate {
 /**
  * A date in the Thai Buddhist calendar system.
  *
- * This date operates using the {@linkplain ThaiBuddhistChronology Thai Buddhist calendar}. This
+ * This date operates using the {@@linkplainThaiBuddhistChronology Thai Buddhist calendar} . This
  * calendar system is primarily used in Thailand. Dates are aligned such that {@code 2484-01-01
- * (Buddhist)} is {@code 1941-01-01 (ISO)}.
+ * (Buddhist)} is {@@code1941-01-01 (ISO)} .
  *
  * <h3>Specification for implementors</h3> This class is immutable and thread-safe.
  *
diff --git a/core/shared/src/main/scala/org/threeten/bp/chrono/package.scala b/core/shared/src/main/scala/org/threeten/bp/chrono/package.scala
index e891fabde..78a13ff24 100644
--- a/core/shared/src/main/scala/org/threeten/bp/chrono/package.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/chrono/package.scala
@@ -39,15 +39,15 @@ package org.threeten.bp
  *
  * The supported calendar systems includes:
  *
- * -{@linkplain org.threeten.bp.chrono.HijrahChronology Hijrah calendar}
- * -{@linkplain org.threeten.bp.chrono.JapaneseChronology Japanese calendar}
- * -{@linkplain org.threeten.bp.chrono.MinguoChronology Minguo calendar}
- * -{@linkplain org.threeten.bp.chrono.ThaiBuddhistChronology Thai Buddhist calendar}
+ * -{@linkplain org.threeten.bp.chrono.HijrahChronology Hijrah calendar} -{@linkplain
+ * org.threeten.bp.chrono.JapaneseChronology Japanese calendar} -{@linkplain
+ * org.threeten.bp.chrono.MinguoChronology Minguo calendar} -{@linkplain
+ * org.threeten.bp.chrono.ThaiBuddhistChronology Thai Buddhist calendar}
  *
  * It is intended that applications use the main API whenever possible, including code to read and
  * write from a persistent data store, such as a database, and to send dates and times across a
  * network. This package is then used at the user interface level to deal with localized
- * input/output. See {@link org.threeten.bp.chrono.ChronoLocalDate ChronoLocalDate} for a full
+ * input/output. See {@@linkorg.threeten.bp.chrono.ChronoLocalDate ChronoLocalDate} for a full
  * discussion of the issues.
  *
  * ==Example==
diff --git a/core/shared/src/main/scala/org/threeten/bp/format/DateTimeBuilder.scala b/core/shared/src/main/scala/org/threeten/bp/format/DateTimeBuilder.scala
index d32e08bc1..5867cb2a0 100644
--- a/core/shared/src/main/scala/org/threeten/bp/format/DateTimeBuilder.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/format/DateTimeBuilder.scala
@@ -56,9 +56,9 @@ import org.threeten.bp.temporal.TemporalQuery
  * Builder that can holds date and time fields and related date and time objects.
  *
  * The builder is used to hold onto different elements of date and time. It is designed as two
- * separate maps: <ul> <li>from {@link TemporalField} to {@code long} value, where the value may be
- * outside the valid range for the field <li>from {@code Class} to {@link TemporalAccessor}, holding
- * larger scale objects like {@code LocalDateTime}. </ul><p>
+ * separate maps: <ul> <li>from {@@linkTemporalField} to {@@codelong} value, where the value may be
+ * outside the valid range for the field <li>from {@@codeClass} to {@@linkTemporalAccessor} ,
+ * holding larger scale objects like {@@codeLocalDateTime} . </ul><p>
  *
  * <h3>Specification for implementors</h3> This class is mutable and not thread-safe. It should only
  * be used from a single thread.
@@ -106,7 +106,7 @@ final class DateTimeBuilder() extends TemporalAccessor with Cloneable {
   /**
    * Creates a new instance of the builder with a single field-value.
    *
-   * This is equivalent to using {@link #addFieldValue(TemporalField, long)} on an empty builder.
+   * This is equivalent to using {@@link#addFieldValue(TemporalField, long)} on an empty builder.
    *
    * @param field
    *   the field to add, not null
@@ -134,7 +134,7 @@ final class DateTimeBuilder() extends TemporalAccessor with Cloneable {
    * @param value
    *   the value to add, not null
    * @return
-   *   { @code this}, for method chaining
+   *   {@@codethis} , for method chaining
    * @throws DateTimeException
    *   if the field is already present with a different value
    */
@@ -166,7 +166,7 @@ final class DateTimeBuilder() extends TemporalAccessor with Cloneable {
    * @param resolverStyle
    *   how to resolve
    * @return
-   *   { @code this}, for method chaining
+   *   {@@codethis} , for method chaining
    */
   def resolve(
     resolverStyle:  ResolverStyle,
@@ -554,7 +554,7 @@ final class DateTimeBuilder() extends TemporalAccessor with Cloneable {
    * @tparam R
    *   the type to return
    * @param type
-   *   the type to invoke { @code from} on, not null
+   *   the type to invoke {@@codefrom} on, not null
    * @return
    *   the extracted value, not null
    * @throws DateTimeException
diff --git a/core/shared/src/main/scala/org/threeten/bp/format/DateTimeFormatter.scala b/core/shared/src/main/scala/org/threeten/bp/format/DateTimeFormatter.scala
index b3ddb6f53..0ff0debb9 100644
--- a/core/shared/src/main/scala/org/threeten/bp/format/DateTimeFormatter.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/format/DateTimeFormatter.scala
@@ -72,9 +72,10 @@ object DateTimeFormatter {
    * date format. The format consists of: <ul> <li>Four digits or more for the {@link
    * ChronoField#YEAR year}. Years in the range 0000 to 9999 will be pre-padded by zero to ensure
    * four digits. Years outside that range will have a prefixed positive or negative symbol. <li>A
-   * dash <li>Two digits for the {@link ChronoField#MONTH_OF_YEAR month-of-year}. This is pre-padded
-   * by zero to ensure two digits. <li>A dash <li>Two digits for the {@link ChronoField#DAY_OF_MONTH
-   * day-of-month}. This is pre-padded by zero to ensure two digits. </ul><p>
+   * dash <li>Two digits for the {@@linkChronoField#MONTH_OF_YEAR month-of-year} . This is
+   * pre-padded by zero to ensure two digits. <li>A dash <li>Two digits for the {@link
+   * ChronoField#DAY_OF_MONTH day-of-month}. This is pre-padded by zero to ensure two digits.
+   * </ul><p>
    */
   lazy val ISO_LOCAL_DATE: DateTimeFormatter = new DateTimeFormatterBuilder()
     .appendValue(YEAR, 4, 10, SignStyle.EXCEEDS_PAD)
@@ -90,7 +91,7 @@ object DateTimeFormatter {
    * '2011-12-03+01:00'.
    *
    * This returns an immutable formatter capable of printing and parsing the ISO-8601 extended
-   * offset date format. The format consists of: <ul> <li>The {@link #ISO_LOCAL_DATE} <li>The {@link
+   * offset date format. The format consists of: <ul> <li>The {@@link#ISO_LOCAL_DATE} <li>The {@link
    * ZoneOffset#getId() offset ID}. If the offset has seconds then they will be handled even though
    * this is not part of the ISO-8601 standard. Parsing is case insensitive. </ul><p>
    */
@@ -105,11 +106,11 @@ object DateTimeFormatter {
    * '2011-12-03' or '2011-12-03+01:00'.
    *
    * This returns an immutable formatter capable of printing and parsing the ISO-8601 extended date
-   * format. The format consists of: <ul> <li>The {@link #ISO_LOCAL_DATE} <li>If the offset is not
+   * format. The format consists of: <ul> <li>The {@@link#ISO_LOCAL_DATE} <li>If the offset is not
    * available to print/parse then the format is complete. <li>The {@link ZoneOffset#getId() offset
    * ID}. If the offset has seconds then they will be handled even though this is not part of the
    * ISO-8601 standard. Parsing is case insensitive. </ul><p> As this formatter has an optional
-   * element, it may be necessary to parse using {@link DateTimeFormatter#parseBest}.
+   * element, it may be necessary to parse using {@@linkDateTimeFormatter#parseBest} .
    */
   lazy val ISO_DATE: DateTimeFormatter = new DateTimeFormatterBuilder().parseCaseInsensitive
     .append(ISO_LOCAL_DATE)
@@ -125,12 +126,12 @@ object DateTimeFormatter {
    * This returns an immutable formatter capable of printing and parsing the ISO-8601 extended local
    * time format. The format consists of: <ul> <li>Two digits for the {@link ChronoField#HOUR_OF_DAY
    * hour-of-day}. This is pre-padded by zero to ensure two digits. <li>A colon <li>Two digits for
-   * the {@link ChronoField#MINUTE_OF_HOUR minute-of-hour}. This is pre-padded by zero to ensure two
-   * digits. <li>If the second-of-minute is not available to print/parse then the format is
+   * the {@@linkChronoField#MINUTE_OF_HOUR minute-of-hour} . This is pre-padded by zero to ensure
+   * two digits. <li>If the second-of-minute is not available to print/parse then the format is
    * complete. <li>A colon <li>Two digits for the {@link ChronoField#SECOND_OF_MINUTE
    * second-of-minute}. This is pre-padded by zero to ensure two digits. <li>If the nano-of-second
    * is zero or not available to print/parse then the format is complete. <li>A decimal point
-   * <li>One to nine digits for the {@link ChronoField#NANO_OF_SECOND nano-of-second}. As many
+   * <li>One to nine digits for the {@@linkChronoField#NANO_OF_SECOND nano-of-second} . As many
    * digits will be printed as required. </ul><p>
    */
   lazy val ISO_LOCAL_TIME: DateTimeFormatter = new DateTimeFormatterBuilder()
@@ -149,7 +150,7 @@ object DateTimeFormatter {
    * or '10:15:30+01:00'.
    *
    * This returns an immutable formatter capable of printing and parsing the ISO-8601 extended
-   * offset time format. The format consists of: <ul> <li>The {@link #ISO_LOCAL_TIME} <li>The {@link
+   * offset time format. The format consists of: <ul> <li>The {@@link#ISO_LOCAL_TIME} <li>The {@link
    * ZoneOffset#getId() offset ID}. If the offset has seconds then they will be handled even though
    * this is not part of the ISO-8601 standard. Parsing is case insensitive. </ul><p>
    */
@@ -163,7 +164,7 @@ object DateTimeFormatter {
    * '10:15', '10:15:30' or '10:15:30+01:00'.
    *
    * This returns an immutable formatter capable of printing and parsing the ISO-8601 extended
-   * offset time format. The format consists of: <ul> <li>The {@link #ISO_LOCAL_TIME} <li>If the
+   * offset time format. The format consists of: <ul> <li>The {@@link#ISO_LOCAL_TIME} <li>If the
    * offset is not available to print/parse then the format is complete. <li>The {@link
    * ZoneOffset#getId() offset ID}. If the offset has seconds then they will be handled even though
    * this is not part of the ISO-8601 standard. Parsing is case insensitive. </ul><p> As this
@@ -181,8 +182,8 @@ object DateTimeFormatter {
    * '2011-12-03T10:15:30'.
    *
    * This returns an immutable formatter capable of printing and parsing the ISO-8601 extended
-   * offset date-time format. The format consists of: <ul> <li>The {@link #ISO_LOCAL_DATE} <li>The
-   * letter 'T'. Parsing is case insensitive. <li>The {@link #ISO_LOCAL_TIME} </ul><p>
+   * offset date-time format. The format consists of: <ul> <li>The {@@link#ISO_LOCAL_DATE} <li>The
+   * letter 'T'. Parsing is case insensitive. <li>The {@@link#ISO_LOCAL_TIME} </ul><p>
    */
   lazy val ISO_LOCAL_DATE_TIME: DateTimeFormatter =
     new DateTimeFormatterBuilder().parseCaseInsensitive
@@ -197,8 +198,8 @@ object DateTimeFormatter {
    * '2011-12-03T10:15:30+01:00'.
    *
    * This returns an immutable formatter capable of printing and parsing the ISO-8601 extended
-   * offset date-time format. The format consists of: <ul> <li>The {@link #ISO_LOCAL_DATE_TIME}
-   * <li>The {@link ZoneOffset#getId() offset ID}. If the offset has seconds then they will be
+   * offset date-time format. The format consists of: <ul> <li>The {@@link#ISO_LOCAL_DATE_TIME}
+   * <li>The {@@linkZoneOffset#getId() offset ID} . If the offset has seconds then they will be
    * handled even though this is not part of the ISO-8601 standard. Parsing is case insensitive.
    * </ul><p>
    */
@@ -215,7 +216,7 @@ object DateTimeFormatter {
    *
    * This returns an immutable formatter capable of printing and parsing a format that extends the
    * ISO-8601 extended offset date-time format to add the time-zone. The format consists of: <ul>
-   * <li>The {@link #ISO_OFFSET_DATE_TIME} <li>If the zone ID is not available or is a {@code
+   * <li>The {@@link#ISO_OFFSET_DATE_TIME} <li>If the zone ID is not available or is a {@code
    * ZoneOffset} then the format is complete. <li>An open square bracket '['. <li>The {@link
    * ZoneId#getId() zone ID}. This is not part of the ISO-8601 standard. Parsing is case sensitive.
    * <li>A close square bracket ']'. </ul><p>
@@ -236,14 +237,14 @@ object DateTimeFormatter {
    * '2011-12-03T10:15:30+01:00[Europe/Paris]'.
    *
    * This returns an immutable formatter capable of printing and parsing the ISO-8601 extended
-   * offset date-time format. The format consists of: <ul> <li>The {@link #ISO_LOCAL_DATE_TIME}
+   * offset date-time format. The format consists of: <ul> <li>The {@@link#ISO_LOCAL_DATE_TIME}
    * <li>If the offset is not available to print/parse then the format is complete. <li>The {@link
    * ZoneOffset#getId() offset ID}. If the offset has seconds then they will be handled even though
    * this is not part of the ISO-8601 standard. <li>If the zone ID is not available or is a {@code
    * ZoneOffset} then the format is complete. <li>An open square bracket '['. <li>The {@link
    * ZoneId#getId() zone ID}. This is not part of the ISO-8601 standard. Parsing is case sensitive.
    * <li>A close square bracket ']'. </ul><p> As this formatter has an optional element, it may be
-   * necessary to parse using {@link DateTimeFormatter#parseBest}.
+   * necessary to parse using {@@linkDateTimeFormatter#parseBest} .
    */
   lazy val ISO_DATE_TIME: DateTimeFormatter = new DateTimeFormatterBuilder()
     .append(ISO_LOCAL_DATE_TIME)
@@ -265,12 +266,12 @@ object DateTimeFormatter {
    * ordinal date format. The format consists of: <ul> <li>Four digits or more for the {@link
    * ChronoField#YEAR year}. Years in the range 0000 to 9999 will be pre-padded by zero to ensure
    * four digits. Years outside that range will have a prefixed positive or negative symbol. <li>A
-   * dash <li>Three digits for the {@link ChronoField#DAY_OF_YEAR day-of-year}. This is pre-padded
+   * dash <li>Three digits for the {@@linkChronoField#DAY_OF_YEAR day-of-year} . This is pre-padded
    * by zero to ensure three digits. <li>If the offset is not available to print/parse then the
-   * format is complete. <li>The {@link ZoneOffset#getId() offset ID}. If the offset has seconds
+   * format is complete. <li>The {@@linkZoneOffset#getId() offset ID} . If the offset has seconds
    * then they will be handled even though this is not part of the ISO-8601 standard. Parsing is
    * case insensitive. </ul><p> As this formatter has an optional element, it may be necessary to
-   * parse using {@link DateTimeFormatter#parseBest}.
+   * parse using {@@linkDateTimeFormatter#parseBest} .
    */
   lazy val ISO_ORDINAL_DATE: DateTimeFormatter = new DateTimeFormatterBuilder().parseCaseInsensitive
     .appendValue(YEAR, 4, 10, SignStyle.EXCEEDS_PAD)
@@ -290,13 +291,13 @@ object DateTimeFormatter {
    * IsoFields#WEEK_BASED_YEAR week-based-year}. Years in the range 0000 to 9999 will be pre-padded
    * by zero to ensure four digits. Years outside that range will have a prefixed positive or
    * negative symbol. <li>A dash <li>The letter 'W'. Parsing is case insensitive. <li>Two digits for
-   * the {@link IsoFields#WEEK_OF_WEEK_BASED_YEAR week-of-week-based-year}. This is pre-padded by
+   * the {@@linkIsoFields#WEEK_OF_WEEK_BASED_YEAR week-of-week-based-year} . This is pre-padded by
    * zero to ensure three digits. <li>A dash <li>One digit for the {@link ChronoField#DAY_OF_WEEK
    * day-of-week}. The value run from Monday (1) to Sunday (7). <li>If the offset is not available
-   * to print/parse then the format is complete. <li>The {@link ZoneOffset#getId() offset ID}. If
+   * to print/parse then the format is complete. <li>The {@@linkZoneOffset#getId() offset ID} . If
    * the offset has seconds then they will be handled even though this is not part of the ISO-8601
    * standard. Parsing is case insensitive. </ul><p> As this formatter has an optional element, it
-   * may be necessary to parse using {@link DateTimeFormatter#parseBest}.
+   * may be necessary to parse using {@@linkDateTimeFormatter#parseBest} .
    */
   lazy val ISO_WEEK_DATE: DateTimeFormatter = new DateTimeFormatterBuilder().parseCaseInsensitive
     .appendValue(IsoFields.WEEK_BASED_YEAR, 4, 10, SignStyle.EXCEEDS_PAD)
@@ -320,15 +321,15 @@ object DateTimeFormatter {
    * is not used.
    *
    * This is a special case formatter intended to allow a human readable form of an {@link
-   * org.threeten.bp.Instant Instant}. The {@code Instant} class is designed to only represent a
+   * org.threeten.bp.Instant Instant}. The {@@codeInstant} class is designed to only represent a
    * point in time and internally stores a value in nanoseconds from a fixed epoch of 1970-01-01Z.
-   * As such, an {@code Instant} cannot be formatted as a date or time without providing some form
-   * of time-zone. This formatter allows the {@code Instant} to be formatted, by providing a
-   * suitable conversion using {@code ZoneOffset.UTC}.
+   * As such, an {@@codeInstant} cannot be formatted as a date or time without providing some form
+   * of time-zone. This formatter allows the {@@codeInstant} to be formatted, by providing a
+   * suitable conversion using {@@codeZoneOffset.UTC} .
    *
-   * The format consists of: <ul> <li>The {@link #ISO_OFFSET_DATE_TIME} where the instant is
-   * converted from {@link ChronoField#INSTANT_SECONDS} and {@link ChronoField#NANO_OF_SECOND} using
-   * the {@code UTC} offset. Parsing is case insensitive. </ul>
+   * The format consists of: <ul> <li>The {@@link#ISO_OFFSET_DATE_TIME} where the instant is
+   * converted from {@@linkChronoField#INSTANT_SECONDS} and {@@linkChronoField#NANO_OF_SECOND} using
+   * the {@@codeUTC} offset. Parsing is case insensitive. </ul>
    *
    * The returned formatter has no override chronology or zone. It uses the {@link
    * ResolverStyle#STRICT STRICT} resolver style.
@@ -344,12 +345,12 @@ object DateTimeFormatter {
    * date format. The format consists of: <ul> <li>Four digits for the {@link ChronoField#YEAR
    * year}. Only years in the range 0000 to 9999 are supported. <li>Two digits for the {@link
    * ChronoField#MONTH_OF_YEAR month-of-year}. This is pre-padded by zero to ensure two digits.
-   * <li>Two digits for the {@link ChronoField#DAY_OF_MONTH day-of-month}. This is pre-padded by
+   * <li>Two digits for the {@@linkChronoField#DAY_OF_MONTH day-of-month} . This is pre-padded by
    * zero to ensure two digits. <li>If the offset is not available to print/parse then the format is
-   * complete. <li>The {@link ZoneOffset#getId() offset ID} without colons. If the offset has
+   * complete. <li>The {@@linkZoneOffset#getId() offset ID} without colons. If the offset has
    * seconds then they will be handled even though this is not part of the ISO-8601 standard.
    * Parsing is case insensitive. </ul><p> As this formatter has an optional element, it may be
-   * necessary to parse using {@link DateTimeFormatter#parseBest}.
+   * necessary to parse using {@@linkDateTimeFormatter#parseBest} .
    */
   lazy val BASIC_ISO_DATE: DateTimeFormatter = new DateTimeFormatterBuilder().parseCaseInsensitive
     .appendValue(YEAR, 4)
@@ -369,14 +370,14 @@ object DateTimeFormatter {
    * zone names, only 'GMT' and offset amounts.
    *
    * The format consists of: <ul> <li>If the day-of-week is not available to print/parse then jump
-   * to day-of-month. <li>Three letter {@link ChronoField#DAY_OF_WEEK day-of-week} in English. <li>A
-   * comma <li>A space <li>One or two digits for the {@link ChronoField#DAY_OF_MONTH day-of-month}.
-   * <li>A space <li>Three letter {@link ChronoField#MONTH_OF_YEAR month-of-year} in English. <li>A
-   * space <li>Four digits for the {@link ChronoField#YEAR year}. Only years in the range 0000 to
+   * to day-of-month. <li>Three letter {@@linkChronoField#DAY_OF_WEEK day-of-week} in English. <li>A
+   * comma <li>A space <li>One or two digits for the {@@linkChronoField#DAY_OF_MONTH day-of-month} .
+   * <li>A space <li>Three letter {@@linkChronoField#MONTH_OF_YEAR month-of-year} in English. <li>A
+   * space <li>Four digits for the {@@linkChronoField#YEAR year} . Only years in the range 0000 to
    * 9999 are supported. <li>A space <li>Two digits for the {@link ChronoField#HOUR_OF_DAY
    * hour-of-day}. This is pre-padded by zero to ensure two digits. <li>A colon <li>Two digits for
-   * the {@link ChronoField#MINUTE_OF_HOUR minute-of-hour}. This is pre-padded by zero to ensure two
-   * digits. <li>If the second-of-minute is not available to print/parse then jump to the next
+   * the {@@linkChronoField#MINUTE_OF_HOUR minute-of-hour} . This is pre-padded by zero to ensure
+   * two digits. <li>If the second-of-minute is not available to print/parse then jump to the next
    * space. <li>A colon <li>Two digits for the {@link ChronoField#SECOND_OF_MINUTE
    * second-of-minute}. This is pre-padded by zero to ensure two digits. <li>A space <li>The {@link
    * ZoneOffset#getId() offset ID} without colons or seconds. An offset of zero uses "GMT". North
@@ -434,16 +435,15 @@ object DateTimeFormatter {
    * Creates a formatter using the specified pattern.
    *
    * This method will create a formatter based on a simple pattern of letters and symbols. For
-   * example, {@code d MMM yyyy} will format 2011-12-03 as '3 Dec 2011'.
+   * example, {@@coded MMM yyyy} will format 2011-12-03 as '3 Dec 2011'.
    *
    * The returned formatter will use the default locale, but this can be changed using {@link
    * DateTimeFormatter#withLocale(Locale)}.
    *
    * All letters 'A' to 'Z' and 'a' to 'z' are reserved as pattern letters. The following pattern
-   * letters are defined: <pre> Symbol Meaning Presentation Examples
-   * ------ ------- ------------ ------- G era number/text 1; 01; AD; Anno Domini y year year 2004;
-   * 04 D day-of-year number 189 M month-of-year number/text 7; 07; Jul; July; J d day-of-month
-   * number 10
+   * letters are defined: <pre> Symbol Meaning Presentation Examples ------ ------- ------------
+   * ------- G era number/text 1; 01; AD; Anno Domini y year year 2004; 04 D day-of-year number 189
+   * M month-of-year number/text 7; 07; Jul; July; J d day-of-month number 10
    *
    * Q quarter-of-year number/text 3; 03; Q3 Y week-based-year year 1996; 96 w week-of-year number
    * 27 W week-of-month number 27 e localized day-of-week number 2; Tue; Tuesday; T E day-of-week
@@ -469,9 +469,9 @@ object DateTimeFormatter {
    * The count of pattern letters determine the format.
    *
    * <b>Text</b>: The text style is determined based on the number of pattern letters used. Less
-   * than 4 pattern letters will use the {@link TextStyle#SHORT short form}. Exactly 4 pattern
-   * letters will use the {@link TextStyle#FULL full form}. Exactly 5 pattern letters will use the
-   * {@link TextStyle#NARROW narrow form}.
+   * than 4 pattern letters will use the {@@linkTextStyle#SHORT short form} . Exactly 4 pattern
+   * letters will use the {@@linkTextStyle#FULL full form} . Exactly 5 pattern letters will use the
+   * {@@linkTextStyle#NARROW narrow form} .
    *
    * <b>Number</b>: If the count of letters is one, then the value is printed using the minimum
    * number of digits and without padding as per {@link
@@ -494,8 +494,8 @@ object DateTimeFormatter {
    * reduced} two digit form is used. For printing, this outputs the rightmost two digits. For
    * parsing, this will parse using the base value of 2000, resulting in a year within the range
    * 2000 to 2099 inclusive. If the count of letters is less than four (but not two), then the sign
-   * is only output for negative years as per {@link SignStyle#NORMAL}. Otherwise, the sign is
-   * output if the pad width is exceeded, as per {@link SignStyle#EXCEEDS_PAD}
+   * is only output for negative years as per {@@linkSignStyle#NORMAL} . Otherwise, the sign is
+   * output if the pad width is exceeded, as per {@@linkSignStyle#EXCEEDS_PAD}
    *
    * <b>ZoneId</b>: This outputs the time-zone ID, such as 'Europe/Paris'. If the count of letters
    * is two, then the time-zone ID is output. Any other count of letters throws {@code
@@ -503,7 +503,7 @@ object DateTimeFormatter {
    *
    * <b>Zone names</b>: This outputs the display name of the time-zone ID. If the count of letters
    * is one, two or three, then the short name is output. If the count of letters is four, then the
-   * full name is output. Five or more letters throws {@code IllegalArgumentException}.
+   * full name is output. Five or more letters throws {@@codeIllegalArgumentException} .
    *
    * <b>Offset X and x</b>: This formats the offset based on the number of pattern letters. One
    * letter outputs just the hour', such as '+01', unless the minute is non-zero in which case the
@@ -511,21 +511,21 @@ object DateTimeFormatter {
    * colon, such as '+0130'. Three letters outputs the hour and minute, with a colon, such as
    * '+01:30'. Four letters outputs the hour and minute and optional second, without a colon, such
    * as '+013015'. Five letters outputs the hour and minute and optional second, with a colon, such
-   * as '+01:30:15'. Six or more letters throws {@code IllegalArgumentException}. Pattern letter 'X'
-   * (upper case) will output 'Z' when the offset to be output would be zero, whereas pattern letter
-   * 'x' (lower case) will output '+00', '+0000', or '+00:00'.
+   * as '+01:30:15'. Six or more letters throws {@@codeIllegalArgumentException} . Pattern letter
+   * 'X' (upper case) will output 'Z' when the offset to be output would be zero, whereas pattern
+   * letter 'x' (lower case) will output '+00', '+0000', or '+00:00'.
    *
    * <b>Offset Z</b>: This formats the offset based on the number of pattern letters. One, two or
    * three letters outputs the hour and minute, without a colon, such as '+0130'. Four or more
-   * letters throws {@code IllegalArgumentException}. The output will be '+0000' when the offset is
+   * letters throws {@@codeIllegalArgumentException} . The output will be '+0000' when the offset is
    * zero.
    *
    * <b>Optional section</b>: The optional section markers work exactly like calling {@link
-   * DateTimeFormatterBuilder#optionalStart()} and {@link DateTimeFormatterBuilder#optionalEnd()}.
+   * DateTimeFormatterBuilder#optionalStart()} and {@@linkDateTimeFormatterBuilder#optionalEnd()} .
    *
    * <b>Pad modifier</b>: Modifies the pattern that immediately follows to be padded with spaces.
    * The pad width is determined by the number of pattern letters. This is the same as calling
-   * {@link DateTimeFormatterBuilder#padNext(int)}.
+   * {@@linkDateTimeFormatterBuilder#padNext(int)} .
    *
    * For example, 'ppH' outputs the hour-of-day padded on the left with spaces to a width of 2.
    *
@@ -550,9 +550,9 @@ object DateTimeFormatter {
    * Creates a formatter using the specified pattern.
    *
    * This method will create a formatter based on a simple pattern of letters and symbols. For
-   * example, {@code d MMM yyyy} will format 2011-12-03 as '3 Dec 2011'.
+   * example, {@@coded MMM yyyy} will format 2011-12-03 as '3 Dec 2011'.
    *
-   * See {@link #ofPattern(String)} for details of the pattern.
+   * See {@@link#ofPattern(String)} for details of the pattern.
    *
    * The returned formatter will use the specified locale, but this can be changed using {@link
    * DateTimeFormatter#withLocale(Locale)}.
@@ -578,10 +578,10 @@ object DateTimeFormatter {
    * locale.
    *
    * The locale is determined from the formatter. The formatter returned directly by this method
-   * will use the {@link Locale#getDefault() default locale}. The locale can be controlled using
-   * {@link DateTimeFormatter#withLocale(Locale) withLocale(Locale)} on the result of this method.
+   * will use the {@@linkLocale#getDefault() default locale} . The locale can be controlled using
+   * {@@linkDateTimeFormatter#withLocale(Locale) withLocale(Locale)} on the result of this method.
    *
-   * Note that the localized pattern is looked up lazily. This {@code DateTimeFormatter} holds the
+   * Note that the localized pattern is looked up lazily. This {@@codeDateTimeFormatter} holds the
    * style required and the locale, looking up the pattern required on demand.
    *
    * @param dateStyle
@@ -604,10 +604,10 @@ object DateTimeFormatter {
    * locale.
    *
    * The locale is determined from the formatter. The formatter returned directly by this method
-   * will use the {@link Locale#getDefault() default locale}. The locale can be controlled using
-   * {@link DateTimeFormatter#withLocale(Locale) withLocale(Locale)} on the result of this method.
+   * will use the {@@linkLocale#getDefault() default locale} . The locale can be controlled using
+   * {@@linkDateTimeFormatter#withLocale(Locale) withLocale(Locale)} on the result of this method.
    *
-   * Note that the localized pattern is looked up lazily. This {@code DateTimeFormatter} holds the
+   * Note that the localized pattern is looked up lazily. This {@@codeDateTimeFormatter} holds the
    * style required and the locale, looking up the pattern required on demand.
    *
    * @param timeStyle
@@ -630,10 +630,10 @@ object DateTimeFormatter {
    * varies by locale.
    *
    * The locale is determined from the formatter. The formatter returned directly by this method
-   * will use the {@link Locale#getDefault() default locale}. The locale can be controlled using
-   * {@link DateTimeFormatter#withLocale(Locale) withLocale(Locale)} on the result of this method.
+   * will use the {@@linkLocale#getDefault() default locale} . The locale can be controlled using
+   * {@@linkDateTimeFormatter#withLocale(Locale) withLocale(Locale)} on the result of this method.
    *
-   * Note that the localized pattern is looked up lazily. This {@code DateTimeFormatter} holds the
+   * Note that the localized pattern is looked up lazily. This {@@codeDateTimeFormatter} holds the
    * style required and the locale, looking up the pattern required on demand.
    *
    * @param dateTimeStyle
@@ -656,10 +656,10 @@ object DateTimeFormatter {
    * varies by locale.
    *
    * The locale is determined from the formatter. The formatter returned directly by this method
-   * will use the {@link Locale#getDefault() default locale}. The locale can be controlled using
-   * {@link DateTimeFormatter#withLocale(Locale) withLocale(Locale)} on the result of this method.
+   * will use the {@@linkLocale#getDefault() default locale} . The locale can be controlled using
+   * {@@linkDateTimeFormatter#withLocale(Locale) withLocale(Locale)} on the result of this method.
    *
-   * Note that the localized pattern is looked up lazily. This {@code DateTimeFormatter} holds the
+   * Note that the localized pattern is looked up lazily. This {@@codeDateTimeFormatter} holds the
    * style required and the locale, looking up the pattern required on demand.
    *
    * @param dateStyle
@@ -681,22 +681,22 @@ object DateTimeFormatter {
   /**
    * A query that provides access to the excess days that were parsed.
    *
-   * This returns a singleton {@linkplain TemporalQuery query} that provides access to additional
+   * This returns a singleton {@@linkplainTemporalQuery query} that provides access to additional
    * information from the parse. The query always returns a non-null period, with a zero period
    * returned instead of null.
    *
    * There are two situations where this query may return a non-zero period. <ul> <li>If the {@code
-   * ResolverStyle} is {@code LENIENT} and a time is parsed without a date, then the complete result
-   * of the parse consists of a {@code LocalTime} and an excess {@code Period} in days.
+   * ResolverStyle} is {@@codeLENIENT} and a time is parsed without a date, then the complete result
+   * of the parse consists of a {@@codeLocalTime} and an excess {@@codePeriod} in days.
    *
-   * <li>If the {@code ResolverStyle} is {@code SMART} and a time is parsed without a date where the
-   * time is 24:00:00, then the complete result of the parse consists of a {@code LocalTime} of
-   * 00:00:00 and an excess {@code Period} of one day. </ul>
+   * <li>If the {@@codeResolverStyle} is {@@codeSMART} and a time is parsed without a date where the
+   * time is 24:00:00, then the complete result of the parse consists of a {@@codeLocalTime} of
+   * 00:00:00 and an excess {@@codePeriod} of one day. </ul>
    *
-   * In both cases, if a complete {@code ChronoLocalDateTime} or {@code Instant} is parsed, then the
+   * In both cases, if a complete {@@codeChronoLocalDateTime} or {@@codeInstant} is parsed, then the
    * excess days are added to the date part. As a result, this query will return a zero period.
    *
-   * The {@code SMART} behaviour handles the common "end of day" 24:00 value. Processing in {@code
+   * The {@@codeSMART} behaviour handles the common "end of day" 24:00 value. Processing in {@code
    * LENIENT} mode also produces the same result: <pre> Text to parse Parsed object Excess days
    * "2012-12-03T00:00" LocalDateTime.of(2012, 12, 3, 0, 0) ZERO "2012-12-03T24:00"
    * LocalDateTime.of(2012, 12, 4, 0, 0) ZERO "00:00" LocalTime.of(0, 0) ZERO "24:00"
@@ -720,7 +720,7 @@ object DateTimeFormatter {
   /**
    * A query that provides access to whether a leap-second was parsed.
    *
-   * This returns a singleton {@linkplain TemporalQuery query} that provides access to additional
+   * This returns a singleton {@@linkplainTemporalQuery query} that provides access to additional
    * information from the parse. The query always returns a non-null boolean, true if parsing saw a
    * leap-second, false if not.
    *
@@ -832,20 +832,20 @@ object DateTimeFormatter {
  * Formatter for printing and parsing date-time objects.
  *
  * This class provides the main application entry point for printing and parsing. Common instances
- * of {@code DateTimeFormatter} are provided: <ul> <li>Using pattern letters, such as {@code
- * yyyy-MMM-dd} <li>Using localized styles, such as {@code long} or {@code medium} <li>Using
- * predefined constants, such as {@link #ISO_LOCAL_DATE} </ul><p>
+ * of {@@codeDateTimeFormatter} are provided: <ul> <li>Using pattern letters, such as {@code
+ * yyyy-MMM-dd} <li>Using localized styles, such as {@@codelong} or {@@codemedium} <li>Using
+ * predefined constants, such as {@@link#ISO_LOCAL_DATE} </ul><p>
  *
- * For more complex formatters, a {@link DateTimeFormatterBuilder builder} is provided.
+ * For more complex formatters, a {@@linkDateTimeFormatterBuilder builder} is provided.
  *
  * In most cases, it is not necessary to use this class directly when formatting. The main date-time
- * classes provide two methods - one for formatting, {@code format(DateTimeFormatter formatter)},
+ * classes provide two methods - one for formatting, {@@codeformat(DateTimeFormatter formatter)} ,
  * and one for parsing, For example: <pre> String text = date.format(formatter); LocalDate date =
  * LocalDate.parse(text, formatter); </pre> Some aspects of printing and parsing are dependent on
- * the locale. The locale can be changed using the {@link #withLocale(Locale)} method which returns
+ * the locale. The locale can be changed using the {@@link#withLocale(Locale)} method which returns
  * a new formatter in the requested locale.
  *
- * Some applications may need to use the older {@link Format} class for formatting. The {@link
+ * Some applications may need to use the older {@@linkFormat} class for formatting. The {@link
  * #toFormat()} method returns an implementation of the old API.
  *
  * <h3>Specification for implementors</h3> This class is immutable and thread-safe.
@@ -954,7 +954,7 @@ final class DateTimeFormatter private[format] (
    * Gets the overriding chronology to be used during formatting.
    *
    * This returns the override chronology, used to convert dates. By default, a formatter has no
-   * override chronology, returning null. See {@link #withChronology(Chronology)} for more details
+   * override chronology, returning null. See {@@link#withChronology(Chronology)} for more details
    * on overriding.
    *
    * @return
@@ -970,10 +970,10 @@ final class DateTimeFormatter private[format] (
    *
    * If an override is added, then any date that is printed or parsed will be affected.
    *
-   * When printing, if the {@code Temporal} object contains a date then it will be converted to a
+   * When printing, if the {@@codeTemporal} object contains a date then it will be converted to a
    * date in the override chronology. Any time or zone will be retained unless overridden. The
    * converted result will behave in a manner equivalent to an implementation of {@code
-   * ChronoLocalDate},{@code ChronoLocalDateTime} or {@code ChronoZonedDateTime}.
+   * ChronoLocalDate},{@code ChronoLocalDateTime} or {@@codeChronoZonedDateTime} .
    *
    * When parsing, the override chronology will be used to interpret the {@linkplain ChronoField
    * fields} into a date unless the formatter directly parses a valid chronology.
@@ -1002,7 +1002,7 @@ final class DateTimeFormatter private[format] (
    * Gets the overriding zone to be used during formatting.
    *
    * This returns the override zone, used to convert instants. By default, a formatter has no
-   * override zone, returning null. See {@link #withZone(ZoneId)} for more details on overriding.
+   * override zone, returning null. See {@@link#withZone(ZoneId)} for more details on overriding.
    *
    * @return
    *   the chronology of this formatter, null if no override
@@ -1017,13 +1017,13 @@ final class DateTimeFormatter private[format] (
    *
    * If an override is added, then any instant that is printed or parsed will be affected.
    *
-   * When printing, if the {@code Temporal} object contains an instant then it will be converted to
+   * When printing, if the {@@codeTemporal} object contains an instant then it will be converted to
    * a zoned date-time using the override zone. If the input has a chronology then it will be
-   * retained unless overridden. If the input does not have a chronology, such as {@code Instant},
+   * retained unless overridden. If the input does not have a chronology, such as {@@codeInstant} ,
    * then the ISO chronology will be used. The converted result will behave in a manner equivalent
-   * to an implementation of {@code ChronoZonedDateTime}.
+   * to an implementation of {@@codeChronoZonedDateTime} .
    *
-   * When parsing, the override zone will be used to interpret the {@linkplain ChronoField fields}
+   * When parsing, the override zone will be used to interpret the {@@linkplainChronoField fields}
    * into an instant unless the formatter directly parses a valid zone.
    *
    * This instance is immutable and unaffected by this method call.
@@ -1051,7 +1051,7 @@ final class DateTimeFormatter private[format] (
    *
    * This returns the resolver style, used during the second phase of parsing when fields are
    * resolved into dates and times. By default, a formatter has the {@link ResolverStyle#SMART
-   * SMART} resolver style. See {@link #withResolverStyle(ResolverStyle)} for more details.
+   * SMART} resolver style. See {@@link#withResolverStyle(ResolverStyle)} for more details.
    *
    * @return
    *   the resolver style of this formatter, not null
@@ -1062,12 +1062,12 @@ final class DateTimeFormatter private[format] (
    * Returns a copy of this formatter with a new resolver style.
    *
    * This returns a formatter with similar state to this formatter but with the resolver style set.
-   * By default, a formatter has the {@link ResolverStyle#SMART SMART} resolver style.
+   * By default, a formatter has the {@@linkResolverStyle#SMART SMART} resolver style.
    *
    * Changing the resolver style only has an effect during parsing. Parsing a text string occurs in
    * two phases. Phase 1 is a basic text parse according to the fields added to the builder. Phase 2
    * resolves the parsed field-value pairs into date and/or time objects. The resolver style is used
-   * to control how phase 2, resolving, happens. See {@code ResolverStyle} for more information on
+   * to control how phase 2, resolving, happens. See {@@codeResolverStyle} for more information on
    * the options available.
    *
    * This instance is immutable and unaffected by this method call.
@@ -1097,7 +1097,7 @@ final class DateTimeFormatter private[format] (
    *
    * This returns the resolver fields, used during the second phase of parsing when fields are
    * resolved into dates and times. By default, a formatter has no resolver fields, and thus returns
-   * null. See {@link #withResolverFields(Set)} for more details.
+   * null. See {@@link#withResolverFields(Set)} for more details.
    *
    * @return
    *   the immutable set of resolver fields of this formatter, null if no fields
@@ -1118,7 +1118,7 @@ final class DateTimeFormatter private[format] (
    * This can be used to select between two or more ways that a date or time might be resolved. For
    * example, if the formatter consists of year, month, day-of-month and day-of-year, then there are
    * two ways to resolve a date. Calling this method with the arguments {@link ChronoField#YEAR
-   * YEAR} and {@link ChronoField#DAY_OF_YEAR DAY_OF_YEAR} will ensure that the date is resolved
+   * YEAR} and {@@linkChronoField#DAY_OF_YEAR DAY_OF_YEAR} will ensure that the date is resolved
    * using the year and day-of-year, effectively meaning that the month and day-of-month are ignored
    * during the resolving phase.
    *
@@ -1126,7 +1126,7 @@ final class DateTimeFormatter private[format] (
    * cross-checked. For example, if the formatter consists of year, month, day-of-month and
    * day-of-week, then there is only one way to resolve a date, but the parsed value for day-of-week
    * will be cross-checked against the resolved date. Calling this method with the arguments {@link
-   * ChronoField#YEAR YEAR}, {@link ChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} and {@link
+   * ChronoField#YEAR YEAR}, {@@linkChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} and {@link
    * ChronoField#DAY_OF_MONTH DAY_OF_MONTH} will ensure that the date is resolved correctly, but
    * without any cross-check for the day-of-week.
    *
@@ -1175,7 +1175,7 @@ final class DateTimeFormatter private[format] (
    * This can be used to select between two or more ways that a date or time might be resolved. For
    * example, if the formatter consists of year, month, day-of-month and day-of-year, then there are
    * two ways to resolve a date. Calling this method with the arguments {@link ChronoField#YEAR
-   * YEAR} and {@link ChronoField#DAY_OF_YEAR DAY_OF_YEAR} will ensure that the date is resolved
+   * YEAR} and {@@linkChronoField#DAY_OF_YEAR DAY_OF_YEAR} will ensure that the date is resolved
    * using the year and day-of-year, effectively meaning that the month and day-of-month are ignored
    * during the resolving phase.
    *
@@ -1183,7 +1183,7 @@ final class DateTimeFormatter private[format] (
    * cross-checked. For example, if the formatter consists of year, month, day-of-month and
    * day-of-week, then there is only one way to resolve a date, but the parsed value for day-of-week
    * will be cross-checked against the resolved date. Calling this method with the arguments {@link
-   * ChronoField#YEAR YEAR}, {@link ChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} and {@link
+   * ChronoField#YEAR YEAR}, {@@linkChronoField#MONTH_OF_YEAR MONTH_OF_YEAR} and {@link
    * ChronoField#DAY_OF_MONTH DAY_OF_MONTH} will ensure that the date is resolved correctly, but
    * without any cross-check for the day-of-week.
    *
@@ -1236,14 +1236,14 @@ final class DateTimeFormatter private[format] (
   }
 
   /**
-   * Formats a date-time object to an {@code Appendable} using this formatter.
+   * Formats a date-time object to an {@@codeAppendable} using this formatter.
    *
-   * This formats the date-time to the specified destination. {@link Appendable} is a general
+   * This formats the date-time to the specified destination. {@@linkAppendable} is a general
    * purpose interface that is implemented by all key character output classes including {@code
-   * StringBuffer}, {@code StringBuilder}, {@code PrintStream} and {@code Writer}.
+   * StringBuffer}, {@@codeStringBuilder} , {@@codePrintStream} and {@@codeWriter} .
    *
-   * Although {@code Appendable} methods throw an {@code IOException}, this method does not.
-   * Instead, any {@code IOException} is wrapped in a runtime exception.
+   * Although {@@codeAppendable} methods throw an {@@codeIOException} , this method does not.
+   * Instead, any {@@codeIOException} is wrapped in a runtime exception.
    *
    * @param temporal
    *   the temporal object to print, not null
@@ -1276,7 +1276,7 @@ final class DateTimeFormatter private[format] (
    * Fully parses the text producing a temporal object.
    *
    * This parses the entire text producing a temporal object. It is typically more useful to use
-   * {@link #parse(CharSequence, TemporalQuery)}. The result of this method is {@code
+   * {@@link#parse(CharSequence, TemporalQuery)} . The result of this method is {@code
    * TemporalAccessor} which has been resolved, applying basic validation checks to help ensure a
    * valid date-time.
    *
@@ -1303,16 +1303,16 @@ final class DateTimeFormatter private[format] (
    * Parses the text using this formatter, providing control over the text position.
    *
    * This parses the text without requiring the parse to start from the beginning of the string or
-   * finish at the end. The result of this method is {@code TemporalAccessor} which has been
+   * finish at the end. The result of this method is {@@codeTemporalAccessor} which has been
    * resolved, applying basic validation checks to help ensure a valid date-time.
    *
-   * The text will be parsed from the specified start {@code ParsePosition}. The entire length of
-   * the text does not have to be parsed, the {@code ParsePosition} will be updated with the index
+   * The text will be parsed from the specified start {@@codeParsePosition} . The entire length of
+   * the text does not have to be parsed, the {@@codeParsePosition} will be updated with the index
    * at the end of parsing.
    *
    * The operation of this method is slightly different to similar methods using {@code
-   * ParsePosition} on {@code java.text.Format}. That class will return errors using the error index
-   * on the {@code ParsePosition}. By contrast, this method will throw a {@link
+   * ParsePosition} on {@@codejava.text.Format} . That class will return errors using the error
+   * index on the {@@codeParsePosition} . By contrast, this method will throw a {@link
    * DateTimeParseException} if an error occurs, with the exception containing the error index. This
    * change in behavior is necessary due to the increased complexity of parsing and resolving
    * dates/times in this API.
@@ -1378,13 +1378,13 @@ final class DateTimeFormatter private[format] (
    * Fully parses the text producing an object of one of the specified types.
    *
    * This parse method is convenient for use when the parser can handle optional elements. For
-   * example, a pattern of 'yyyy[-MM[-dd]]' can be fully parsed to a {@code LocalDate}, or partially
-   * parsed to a {@code YearMonth} or a {@code Year}. The types must be specified in order, starting
-   * from the best matching full-parse option and ending with the worst matching minimal parse
-   * option.
+   * example, a pattern of 'yyyy[-MM[-dd]]' can be fully parsed to a {@@codeLocalDate} , or
+   * partially parsed to a {@@codeYearMonth} or a {@@codeYear} . The types must be specified in
+   * order, starting from the best matching full-parse option and ending with the worst matching
+   * minimal parse option.
    *
    * The result is associated with the first type that successfully parses. Normally, applications
-   * will use {@code instanceof} to check the result. For example: <pre> TemporalAccessor dt =
+   * will use {@@codeinstanceof} to check the result. For example: <pre> TemporalAccessor dt =
    * parser.parseBest(str, LocalDate.FROM, YearMonth.FROM); if (dt instanceof LocalDate) { ... }
    * else { ... } </pre> If the parse completes without reading the entire length of the text, or a
    * problem occurs during parsing or merging, then an exception is thrown.
@@ -1392,7 +1392,7 @@ final class DateTimeFormatter private[format] (
    * @param text
    *   the text to parse, not null
    * @param types
-   *   the types to attempt to parse to, which must implement { @code TemporalAccessor}, not null
+   *   the types to attempt to parse to, which must implement {@@codeTemporalAccessor} , not null
    * @return
    *   the parsed date-time, not null
    * @throws IllegalArgumentException
@@ -1435,8 +1435,8 @@ final class DateTimeFormatter private[format] (
   /**
    * Parses the text to a builder.
    *
-   * This parses to a {@code DateTimeBuilder} ensuring that the text is fully parsed. This method
-   * throws {@link DateTimeParseException} if unable to parse, or some other {@code
+   * This parses to a {@@codeDateTimeBuilder} ensuring that the text is fully parsed. This method
+   * throws {@@linkDateTimeParseException} if unable to parse, or some other {@code
    * DateTimeException} if another date/time problem occurs.
    *
    * @param text
@@ -1481,20 +1481,20 @@ final class DateTimeFormatter private[format] (
    * cases.
    *
    * Parsing is implemented as a two-phase operation. First, the text is parsed using the layout
-   * defined by the formatter, producing a {@code Map} of field to value, a {@code ZoneId} and a
-   * {@code Chronology}. Second, the parsed data is <em>resolved</em>, by validating, combining and
+   * defined by the formatter, producing a {@@codeMap} of field to value, a {@@codeZoneId} and a
+   * {@@codeChronology} . Second, the parsed data is <em>resolved</em>, by validating, combining and
    * simplifying the various fields into more useful ones. This method performs the parsing stage
    * but not the resolving stage.
    *
-   * The result of this method is {@code TemporalAccessor} which represents the data as seen in the
+   * The result of this method is {@@codeTemporalAccessor} which represents the data as seen in the
    * input. Values are not validated, thus parsing a date string of '2012-00-65' would result in a
    * temporal with three fields - year of '2012', month of '0' and day-of-month of '65'.
    *
-   * The text will be parsed from the specified start {@code ParsePosition}. The entire length of
-   * the text does not have to be parsed, the {@code ParsePosition} will be updated with the index
+   * The text will be parsed from the specified start {@@codeParsePosition} . The entire length of
+   * the text does not have to be parsed, the {@@codeParsePosition} will be updated with the index
    * at the end of parsing.
    *
-   * Errors are returned using the error index field of the {@code ParsePosition} instead of {@code
+   * Errors are returned using the error index field of the {@@codeParsePosition} instead of {@code
    * DateTimeParseException}. The returned error index will be set to an index indicative of the
    * error. Callers must check for errors before using the context.
    *
@@ -1502,7 +1502,7 @@ final class DateTimeFormatter private[format] (
    * an error.
    *
    * This method is intended for advanced use cases that need access to the internal state during
-   * parsing. Typical application code should use {@link #parse(CharSequence, TemporalQuery)} or the
+   * parsing. Typical application code should use {@@link#parse(CharSequence, TemporalQuery)} or the
    * parse method on the target type.
    *
    * @param text
@@ -1548,13 +1548,13 @@ final class DateTimeFormatter private[format] (
     printerParser.withOptional(optional)
 
   /**
-   * Returns this formatter as a {@code java.text.Format} instance.
+   * Returns this formatter as a {@@codejava.text.Format} instance.
    *
-   * The returned {@link Format} instance will print any {@link TemporalAccessor} and parses to a
-   * resolved {@link TemporalAccessor}.
+   * The returned {@@linkFormat} instance will print any {@@linkTemporalAccessor} and parses to a
+   * resolved {@@linkTemporalAccessor} .
    *
-   * Exceptions will follow the definitions of {@code Format}, see those methods for details about
-   * {@code IllegalArgumentException} during formatting and {@code ParseException} or null during
+   * Exceptions will follow the definitions of {@@codeFormat} , see those methods for details about
+   * {@@codeIllegalArgumentException} during formatting and {@@codeParseException} or null during
    * parsing. The format does not support attributing of the returned format string.
    *
    * @return
@@ -1563,14 +1563,14 @@ final class DateTimeFormatter private[format] (
   def toFormat: Format = new DateTimeFormatter.ClassicFormat(this, null)
 
   /**
-   * Returns this formatter as a {@code java.text.Format} instance that will parse to the specified
+   * Returns this formatter as a {@@codejava.text.Format} instance that will parse to the specified
    * type.
    *
-   * The returned {@link Format} instance will print any {@link TemporalAccessor} and parses to the
-   * type specified. The type must be one that is supported by {@link #parse}.
+   * The returned {@@linkFormat} instance will print any {@@linkTemporalAccessor} and parses to the
+   * type specified. The type must be one that is supported by {@@link#parse} .
    *
-   * Exceptions will follow the definitions of {@code Format}, see those methods for details about
-   * {@code IllegalArgumentException} during formatting and {@code ParseException} or null during
+   * Exceptions will follow the definitions of {@@codeFormat} , see those methods for details about
+   * {@@codeIllegalArgumentException} during formatting and {@@codeParseException} or null during
    * parsing. The format does not support attributing of the returned format string.
    *
    * @param query
diff --git a/core/shared/src/main/scala/org/threeten/bp/format/DateTimeFormatterBuilder.scala b/core/shared/src/main/scala/org/threeten/bp/format/DateTimeFormatterBuilder.scala
index b5066dfe9..0c325177f 100644
--- a/core/shared/src/main/scala/org/threeten/bp/format/DateTimeFormatterBuilder.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/format/DateTimeFormatterBuilder.scala
@@ -146,21 +146,21 @@ object DateTimeFormatterBuilder {
 /**
  * Builder to create date-time formatters.
  *
- * This allows a {@code DateTimeFormatter} to be created. All date-time formatters are created
+ * This allows a {@@codeDateTimeFormatter} to be created. All date-time formatters are created
  * ultimately using this builder.
  *
  * The basic elements of date-time can all be added: <ul> <li>Value - a numeric value</li>
  * <li>Fraction - a fractional value including the decimal place. Always use this when outputting
  * fractions to ensure that the fraction is parsed correctly</li> <li>Text - the textual equivalent
- * for the value</li> <li>OffsetId/Offset - the {@linkplain ZoneOffset zone offset}</li> <li>ZoneId
- *   - the {@linkplain ZoneId time-zone} id</li> <li>ZoneText - the name of the time-zone</li>
+ * for the value</li> <li>OffsetId/Offset - the {@@linkplainZoneOffset zone offset} </li> <li>ZoneId
+ *   - the {@@linkplainZoneId time-zone} id</li> <li>ZoneText - the name of the time-zone</li>
  *     <li>Literal - a text literal</li> <li>Nested and Optional - formats can be nested or made
  *     optional</li> <li>Other - the printer and parser interfaces can be used to add user supplied
  *     formatting</li> </ul><p> In addition, any of the elements may be decorated by padding, either
  *     with spaces or any other character.
  *
  * Finally, a shorthand pattern, mostly compatible with {@code java.text.SimpleDateFormat
- * SimpleDateFormat} can be used, see {@link #appendPattern(String)}. In practice, this simply
+ * SimpleDateFormat} can be used, see {@@link#appendPattern(String)} . In practice, this simply
  * parses the pattern and calls other methods on the builder.
  *
  * <h3>Specification for implementors</h3> This class is a mutable builder intended for use from a
@@ -205,13 +205,13 @@ final class DateTimeFormatterBuilder private (
    * allows the case sensitivity setting of parsing to be changed.
    *
    * Calling this method changes the state of the builder such that all subsequent builder method
-   * calls will parse text in case sensitive mode. See {@link #parseCaseInsensitive} for the
+   * calls will parse text in case sensitive mode. See {@@link#parseCaseInsensitive} for the
    * opposite setting. The parse case sensitive/insensitive methods may be called at any point in
    * the builder, thus the parser can swap between case parsing modes multiple times during the
    * parse.
    *
    * Since the default is case sensitive, this method should only be used after a previous call to
-   * {@code #parseCaseInsensitive}.
+   * {@@code#parseCaseInsensitive} .
    *
    * @return
    *   this, for chaining, not null
@@ -228,7 +228,7 @@ final class DateTimeFormatterBuilder private (
    * allows the case sensitivity setting of parsing to be changed.
    *
    * Calling this method changes the state of the builder such that all subsequent builder method
-   * calls will parse text in case sensitive mode. See {@link #parseCaseSensitive()} for the
+   * calls will parse text in case sensitive mode. See {@@link#parseCaseSensitive()} for the
    * opposite setting. The parse case sensitive/insensitive methods may be called at any point in
    * the builder, thus the parser can swap between case parsing modes multiple times during the
    * parse.
@@ -248,9 +248,9 @@ final class DateTimeFormatterBuilder private (
    * flexibility in matching the text and sign styles.
    *
    * When used, this method changes the parsing to be strict from this point onwards. As strict is
-   * the default, this is normally only needed after calling {@link #parseLenient()}. The change
+   * the default, this is normally only needed after calling {@@link#parseLenient()} . The change
    * will remain in force until the end of the formatter that is eventually constructed or until
-   * {@code parseLenient} is called.
+   * {@@codeparseLenient} is called.
    *
    * @return
    *   this, for chaining, not null
@@ -266,11 +266,11 @@ final class DateTimeFormatterBuilder private (
    *
    * Parsing can be strict or lenient - by default its strict. This controls the degree of
    * flexibility in matching the text and sign styles. Applications calling this method should
-   * typically also call {@link #parseCaseInsensitive()}.
+   * typically also call {@@link#parseCaseInsensitive()} .
    *
    * When used, this method changes the parsing to be strict from this point onwards. The change
    * will remain in force until the end of the formatter that is eventually constructed or until
-   * {@code parseStrict} is called.
+   * {@@codeparseStrict} is called.
    *
    * @return
    *   this, for chaining, not null
@@ -324,7 +324,7 @@ final class DateTimeFormatterBuilder private (
    *
    * The parser for a variable width value such as this normally behaves greedily, requiring one
    * digit, but accepting as many digits as possible. This behavior can be affected by 'adjacent
-   * value parsing'. See {@link #appendValue(TemporalField, int)} for full details.
+   * value parsing'. See {@@link#appendValue(TemporalField, int)} for full details.
    *
    * @param field
    *   the field to append, not null
@@ -355,12 +355,12 @@ final class DateTimeFormatterBuilder private (
    * length values. The standard parser is greedy, and thus it would normally steal the digits that
    * are needed by the fixed width value parsers that follow the variable width one.
    *
-   * No action is required to initiate 'adjacent value parsing'. When a call to {@code appendValue}
+   * No action is required to initiate 'adjacent value parsing'. When a call to {@@codeappendValue}
    * with a variable width is made, the builder enters adjacent value parsing setup mode. If the
    * immediately subsequent method call or calls on the same builder are to this method, then the
    * parser will reserve space so that the fixed width values can be parsed.
    *
-   * For example, consider {@code builder.appendValue(YEAR).appendValue(MONTH_OF_YEAR, 2);} The year
+   * For example, consider {@@codebuilder.appendValue(YEAR).appendValue(MONTH_OF_YEAR, 2);} The year
    * is a variable width parse of between 1 and 19 digits. The month is a fixed width parse of 2
    * digits. Because these were appended to the same builder immediately after one another, the year
    * parser will reserve two digits for the month to parse. Thus, the text '201106' will correctly
@@ -370,7 +370,7 @@ final class DateTimeFormatterBuilder private (
    * Adjacent value parsing applies to each set of fixed width not-negative values in the parser
    * that immediately follow any kind of variable width value. Calling any other append method will
    * end the setup of adjacent value parsing. Thus, in the unlikely event that you need to avoid
-   * adjacent value parsing behavior, simply add the {@code appendValue} to another {@code
+   * adjacent value parsing behavior, simply add the {@@codeappendValue} to another {@code
    * DateTimeFormatterBuilder. and add that to this builder.
    *
    * If adjacent parsing is active, then parsing must match exactly the specified number of digits
@@ -412,11 +412,11 @@ final class DateTimeFormatterBuilder private (
    * digits as possible. This behavior can be affected by 'adjacent value parsing'. See {@link
    * #appendValue(TemporalField, int)} for full details.
    *
-   * In strict parsing mode, the minimum number of parsed digits is {@code minWidth}. In lenient
+   * In strict parsing mode, the minimum number of parsed digits is {@@codeminWidth} . In lenient
    * parsing mode, the minimum number of parsed digits is one.
    *
    * If this method is invoked with equal minimum and maximum widths and a sign style of {@code
-   * NOT_NEGATIVE} then it delegates to {@code appendValue(TemporalField,int)}. In this scenario,
+   * NOT_NEGATIVE} then it delegates to {@@codeappendValue(TemporalField,int)} . In this scenario,
    * the printing and parsing behavior described there occur.
    *
    * @param field
@@ -467,24 +467,24 @@ final class DateTimeFormatterBuilder private (
    * #appendValueReduced(TemporalField, int, int, ChronoLocalDate)} date} variant of this method in
    * most cases. This variant is suitable for simple fields or working with only the ISO chronology.
    *
-   * For formatting, the {@code width} and {@code maxWidth} are used to determine the number of
+   * For formatting, the {@@codewidth} and {@@codemaxWidth} are used to determine the number of
    * characters to format. If they are equal then the format is fixed width. If the value of the
-   * field is within the range of the {@code baseValue} using {@code width} characters then the
-   * reduced value is formatted otherwise the value is truncated to fit {@code maxWidth}. The
+   * field is within the range of the {@@codebaseValue} using {@@codewidth} characters then the
+   * reduced value is formatted otherwise the value is truncated to fit {@@codemaxWidth} . The
    * rightmost characters are output to match the width, left padding with zero.
    *
-   * For strict parsing, the number of characters allowed by {@code width} to {@code maxWidth} are
+   * For strict parsing, the number of characters allowed by {@@codewidth} to {@@codemaxWidth} are
    * parsed. For lenient parsing, the number of characters must be at least 1 and less than 10. If
-   * the number of digits parsed is equal to {@code width} and the value is positive, the value of
-   * the field is computed to be the first number greater than or equal to the {@code baseValue}
+   * the number of digits parsed is equal to {@@codewidth} and the value is positive, the value of
+   * the field is computed to be the first number greater than or equal to the {@@codebaseValue}
    * with the same least significant characters, otherwise the value parsed is the field value. This
    * allows a reduced value to be entered for values in range of the baseValue and width and
    * absolute values can be entered for values outside the range.
    *
-   * For example, a base value of {@code 1980} and a width of {@code 2} will have valid values from
-   * {@code 1980} to {@code 2079}. During parsing, the text {@code "12"} will result in the value
-   * {@code 2012} as that is the value within the range where the last two characters are "12". By
-   * contrast, parsing the text {@code "1915"} will result in the value {@code 1915}.
+   * For example, a base value of {@@code1980} and a width of {@@code2} will have valid values from
+   * {@@code1980} to {@@code2079} . During parsing, the text {@@code"12"} will result in the value
+   * {@@code2012} as that is the value within the range where the last two characters are "12". By
+   * contrast, parsing the text {@@code"1915"} will result in the value {@@code1915} .
    *
    * @param field
    *   the field to append, not null
@@ -527,26 +527,26 @@ final class DateTimeFormatterBuilder private (
    * The exact behavior is as follows. Parse the full set of fields and determine the effective
    * chronology using the last chronology if it appears more than once. Then convert the base date
    * to the effective chronology. Then extract the specified field from the chronology-specific base
-   * date and use it to determine the {@code baseValue} used below.
+   * date and use it to determine the {@@codebaseValue} used below.
    *
-   * For formatting, the {@code width} and {@code maxWidth} are used to determine the number of
+   * For formatting, the {@@codewidth} and {@@codemaxWidth} are used to determine the number of
    * characters to format. If they are equal then the format is fixed width. If the value of the
-   * field is within the range of the {@code baseValue} using {@code width} characters then the
-   * reduced value is formatted otherwise the value is truncated to fit {@code maxWidth}. The
+   * field is within the range of the {@@codebaseValue} using {@@codewidth} characters then the
+   * reduced value is formatted otherwise the value is truncated to fit {@@codemaxWidth} . The
    * rightmost characters are output to match the width, left padding with zero.
    *
-   * For strict parsing, the number of characters allowed by {@code width} to {@code maxWidth} are
+   * For strict parsing, the number of characters allowed by {@@codewidth} to {@@codemaxWidth} are
    * parsed. For lenient parsing, the number of characters must be at least 1 and less than 10. If
-   * the number of digits parsed is equal to {@code width} and the value is positive, the value of
-   * the field is computed to be the first number greater than or equal to the {@code baseValue}
+   * the number of digits parsed is equal to {@@codewidth} and the value is positive, the value of
+   * the field is computed to be the first number greater than or equal to the {@@codebaseValue}
    * with the same least significant characters, otherwise the value parsed is the field value. This
    * allows a reduced value to be entered for values in range of the baseValue and width and
    * absolute values can be entered for values outside the range.
    *
-   * For example, a base value of {@code 1980} and a width of {@code 2} will have valid values from
-   * {@code 1980} to {@code 2079}. During parsing, the text {@code "12"} will result in the value
-   * {@code 2012} as that is the value within the range where the last two characters are "12". By
-   * contrast, parsing the text {@code "1915"} will result in the value {@code 1915}.
+   * For example, a base value of {@@code1980} and a width of {@@code2} will have valid values from
+   * {@@code1980} to {@@code2079} . During parsing, the text {@@code"12"} will result in the value
+   * {@@code2012} as that is the value within the range where the last two characters are "12". By
+   * contrast, parsing the text {@@code"1915"} will result in the value {@@code1915} .
    *
    * @param field
    *   the field to append, not null
@@ -616,7 +616,7 @@ final class DateTimeFormatterBuilder private (
    *
    * The fractional value of the field will be output including the preceding decimal point. The
    * preceding value is not output. For example, the second-of-minute value of 15 would be output as
-   * {@code .25}.
+   * {@@code.25} .
    *
    * The width of the printed fraction can be controlled. Setting the minimum width to zero will
    * cause no output to be generated. The printed fraction will have the minimum width necessary
@@ -780,17 +780,17 @@ final class DateTimeFormatterBuilder private (
    * nano-of-second outputs zero, three, six or nine digits digits as necessary. The localized
    * decimal style is not used.
    *
-   * The instant is obtained using {@link ChronoField#INSTANT_SECONDS INSTANT_SECONDS} and
-   * optionally (@code NANO_OF_SECOND). The value of {@code INSTANT_SECONDS} may be outside the
-   * maximum range of {@code LocalDateTime}.
+   * The instant is obtained using {@@linkChronoField#INSTANT_SECONDS INSTANT_SECONDS} and
+   * optionally (@code NANO_OF_SECOND). The value of {@@codeINSTANT_SECONDS} may be outside the
+   * maximum range of {@@codeLocalDateTime} .
    *
-   * The {@linkplain ResolverStyle resolver style} has no effect on instant parsing. The end-of-day
+   * The {@@linkplainResolverStyle resolver style} has no effect on instant parsing. The end-of-day
    * time of '24:00' is handled as midnight at the start of the following day. The leap-second time
-   * of '23:59:59' is handled to some degree, see {@link DateTimeFormatter#parsedLeapSecond()} for
+   * of '23:59:59' is handled to some degree, see {@@linkDateTimeFormatter#parsedLeapSecond()} for
    * full details.
    *
    * An alternative to this method is to format/parse the instant as a single epoch-seconds value.
-   * That is achieved using {@code appendValue(INSTANT_SECONDS)}.
+   * That is achieved using {@@codeappendValue(INSTANT_SECONDS)} .
    *
    * @return
    *   this, for chaining, not null
@@ -808,7 +808,7 @@ final class DateTimeFormatterBuilder private (
    * fractional digits. They are converted to a date-time with a zone-offset of UTC and printed
    * using the standard ISO-8601 format. The localized decimal style is not used.
    *
-   * The {@code fractionalDigits} parameter allows the output of the fractional second to be
+   * The {@@codefractionalDigits} parameter allows the output of the fractional second to be
    * controlled. Specifying zero will cause no fractional digits to be output. From 1 to 9 will
    * output an increasing number of digits, using zero right-padding if necessary. The special value
    * -1 is used to output as many digits as necessary to avoid any trailing zeroes.
@@ -816,17 +816,17 @@ final class DateTimeFormatterBuilder private (
    * When parsing in strict mode, the number of parsed digits must match the fractional digits. When
    * parsing in lenient mode, any number of fractional digits from zero to nine are accepted.
    *
-   * The instant is obtained using {@link ChronoField#INSTANT_SECONDS INSTANT_SECONDS} and
-   * optionally (@code NANO_OF_SECOND). The value of {@code INSTANT_SECONDS} may be outside the
-   * maximum range of {@code LocalDateTime}.
+   * The instant is obtained using {@@linkChronoField#INSTANT_SECONDS INSTANT_SECONDS} and
+   * optionally (@code NANO_OF_SECOND). The value of {@@codeINSTANT_SECONDS} may be outside the
+   * maximum range of {@@codeLocalDateTime} .
    *
-   * The {@linkplain ResolverStyle resolver style} has no effect on instant parsing. The end-of-day
+   * The {@@linkplainResolverStyle resolver style} has no effect on instant parsing. The end-of-day
    * time of '24:00' is handled as midnight at the start of the following day. The leap-second time
-   * of '23:59:59' is handled to some degree, see {@link DateTimeFormatter#parsedLeapSecond()} for
+   * of '23:59:59' is handled to some degree, see {@@linkDateTimeFormatter#parsedLeapSecond()} for
    * full details.
    *
    * An alternative to this method is to format/parse the instant as a single epoch-seconds value.
-   * That is achieved using {@code appendValue(INSTANT_SECONDS)}.
+   * That is achieved using {@@codeappendValue(INSTANT_SECONDS)} .
    *
    * @param fractionalDigits
    *   the number of fractional second digits to format with, from 0 to 9, or -1 to use as many
@@ -846,7 +846,7 @@ final class DateTimeFormatterBuilder private (
    * Appends the zone offset, such as '+01:00', to the formatter.
    *
    * This appends an instruction to print/parse the offset ID to the builder. This is equivalent to
-   * calling {@code appendOffset("HH:MM:ss", "Z")}.
+   * calling {@@codeappendOffset("HH:MM:ss", "Z")} .
    *
    * @return
    *   this, for chaining, not null
@@ -862,7 +862,7 @@ final class DateTimeFormatterBuilder private (
    * This appends an instruction to print/parse the offset ID to the builder.
    *
    * During printing, the offset is obtained using a mechanism equivalent to querying the temporal
-   * with {@link TemporalQueries#offset()}. It will be printed using the format defined below. If
+   * with {@@linkTemporalQueries#offset()} . It will be printed using the format defined below. If
    * the offset cannot be obtained then an exception is thrown unless the section of the formatter
    * is optional.
    *
@@ -897,14 +897,14 @@ final class DateTimeFormatterBuilder private (
    * Appends the localized zone offset, such as 'GMT+01:00', to the formatter.
    *
    * This appends a localized zone offset to the builder, the format of the localized offset is
-   * controlled by the specified {@link FormatStyle style} to this method: <ul> <li>{@link
+   * controlled by the specified {@@linkFormatStyle style} to this method: <ul> <li>{@link
    * TextStyle#FULL full} - formats with localized offset text, such as 'GMT, 2-digit hour and
    * minute field, optional second field if non-zero, and colon. <li>{@link TextStyle#SHORT short} -
    * formats with localized offset text, such as 'GMT, hour without leading zero, optional 2-digit
    * minute and second if non-zero, and colon. </ul>
    *
    * During formatting, the offset is obtained using a mechanism equivalent to querying the temporal
-   * with {@link TemporalQueries#offset()}. If the offset cannot be obtained then an exception is
+   * with {@@linkTemporalQueries#offset()} . If the offset cannot be obtained then an exception is
    * thrown unless the section of the formatter is optional.
    *
    * During parsing, the offset is parsed using the format defined above. If the offset cannot be
@@ -915,7 +915,7 @@ final class DateTimeFormatterBuilder private (
    * @return
    *   this, for chaining, not null
    * @throws IllegalArgumentException
-   *   if style is neither { @link TextStyle#FULL full} nor { @link TextStyle#SHORT short}
+   *   if style is neither {@@linkTextStyle#FULL full} nor {@@linkTextStyle#SHORT short}
    */
   def appendLocalizedOffset(style: TextStyle): DateTimeFormatterBuilder = {
     Objects.requireNonNull(style, "style")
@@ -929,11 +929,12 @@ final class DateTimeFormatterBuilder private (
    * Appends the time-zone ID, such as 'Europe/Paris' or '+02:00', to the formatter.
    *
    * This appends an instruction to print/parse the zone ID to the builder. The zone ID is obtained
-   * in a strict manner suitable for {@code ZonedDateTime}. By contrast, {@code OffsetDateTime} does
-   * not have a zone ID suitable for use with this method, see {@link #appendZoneOrOffsetId()}.
+   * in a strict manner suitable for {@@codeZonedDateTime} . By contrast, {@@codeOffsetDateTime}
+   * does not have a zone ID suitable for use with this method, see {@@link#appendZoneOrOffsetId()}
+   * .
    *
    * During printing, the zone is obtained using a mechanism equivalent to querying the temporal
-   * with {@link TemporalQueries#zoneId()}. It will be printed using the result of {@link
+   * with {@@linkTemporalQueries#zoneId()} . It will be printed using the result of {@link
    * ZoneId#getId()}. If the zone cannot be obtained then an exception is thrown unless the section
    * of the formatter is optional.
    *
@@ -954,13 +955,13 @@ final class DateTimeFormatterBuilder private (
 
   /**
    * Appends the time-zone region ID, such as 'Europe/Paris', to the formatter, rejecting the zone
-   * ID if it is a {@code ZoneOffset}.
+   * ID if it is a {@@codeZoneOffset} .
    *
    * This appends an instruction to print/parse the zone ID to the builder only if it is a
    * region-based ID.
    *
    * During printing, the zone is obtained using a mechanism equivalent to querying the temporal
-   * with {@link TemporalQueries#zoneId()}. If the zone is a {@code ZoneOffset} or it cannot be
+   * with {@@linkTemporalQueries#zoneId()} . If the zone is a {@@codeZoneOffset} or it cannot be
    * obtained then an exception is thrown unless the section of the formatter is optional. If the
    * zone is not an offset, then the zone will be printed using the zone ID from {@link
    * ZoneId#getId()}.
@@ -968,7 +969,7 @@ final class DateTimeFormatterBuilder private (
    * During parsing, the zone is parsed and must match a known zone or offset. If the zone cannot be
    * parsed then an exception is thrown unless the section of the formatter is optional. Note that
    * parsing accepts offsets, whereas printing will never produce one, thus parsing is equivalent to
-   * {@code appendZoneId}.
+   * {@@codeappendZoneId} .
    *
    * @return
    *   this, for chaining, not null
@@ -991,18 +992,18 @@ final class DateTimeFormatterBuilder private (
    *
    * This appends an instruction to print/parse the best available zone or offset ID to the builder.
    * The zone ID is obtained in a lenient manner that first attempts to find a true zone ID, such as
-   * that on {@code ZonedDateTime}, and then attempts to find an offset, such as that on {@code
+   * that on {@@codeZonedDateTime} , and then attempts to find an offset, such as that on {@code
    * OffsetDateTime}.
    *
    * During printing, the zone is obtained using a mechanism equivalent to querying the temporal
-   * with {@link TemporalQueries#zone()}. It will be printed using the result of {@link
+   * with {@@linkTemporalQueries#zone()} . It will be printed using the result of {@link
    * ZoneId#getId()}. If the zone cannot be obtained then an exception is thrown unless the section
    * of the formatter is optional.
    *
    * During parsing, the zone is parsed and must match a known zone or offset. If the zone cannot be
    * parsed then an exception is thrown unless the section of the formatter is optional.
    *
-   * This method is is identical to {@code appendZoneId()} except in the mechanism used to obtain
+   * This method is is identical to {@@codeappendZoneId()} except in the mechanism used to obtain
    * the zone.
    *
    * @return
@@ -1023,9 +1024,9 @@ final class DateTimeFormatterBuilder private (
    * This appends an instruction to print the textual name of the zone to the builder.
    *
    * During printing, the zone is obtained using a mechanism equivalent to querying the temporal
-   * with {@link TemporalQueries#zoneId()}. If the zone is a {@code ZoneOffset} it will be printed
-   * using the result of {@link ZoneOffset#getId()}. If the zone is not an offset, the textual name
-   * will be looked up for the locale set in the {@link DateTimeFormatter}. If the temporal object
+   * with {@@linkTemporalQueries#zoneId()} . If the zone is a {@@codeZoneOffset} it will be printed
+   * using the result of {@@linkZoneOffset#getId()} . If the zone is not an offset, the textual name
+   * will be looked up for the locale set in the {@@linkDateTimeFormatter} . If the temporal object
    * being printed represents an instant, then the text will be the summer or winter time text as
    * appropriate. If the lookup for text does not find any suitable reuslt, then the {@link
    * ZoneId#getId() ID} will be printed instead. If the zone cannot be obtained then an exception is
@@ -1049,9 +1050,9 @@ final class DateTimeFormatterBuilder private (
    * This appends an instruction to format/parse the textual name of the zone to the builder.
    *
    * During formatting, the zone is obtained using a mechanism equivalent to querying the temporal
-   * with {@link TemporalQueries#zoneId()}. If the zone is a {@code ZoneOffset} it will be printed
-   * using the result of {@link ZoneOffset#getId()}. If the zone is not an offset, the textual name
-   * will be looked up for the locale set in the {@link DateTimeFormatter}. If the temporal object
+   * with {@@linkTemporalQueries#zoneId()} . If the zone is a {@@codeZoneOffset} it will be printed
+   * using the result of {@@linkZoneOffset#getId()} . If the zone is not an offset, the textual name
+   * will be looked up for the locale set in the {@@linkDateTimeFormatter} . If the temporal object
    * being printed represents an instant, then the text will be the summer or winter time text as
    * appropriate. If the lookup for text does not find any suitable result, then the {@link
    * ZoneId#getId() ID} will be printed instead. If the zone cannot be obtained then an exception is
@@ -1060,9 +1061,9 @@ final class DateTimeFormatterBuilder private (
    * During parsing, either the textual zone name, the zone ID or the offset is accepted. Many
    * textual zone names are not unique, such as CST can be for both "Central Standard Time" and
    * "China Standard Time". In this situation, the zone id will be determined by the region
-   * information from formatter's {@link DateTimeFormatter#getLocale() locale} and the standard zone
+   * information from formatter's {@@linkDateTimeFormatter#getLocale() locale} and the standard zone
    * id for that area, for example, America/New_York for the America Eastern zone. This method also
-   * allows a set of preferred {@link ZoneId} to be specified for parsing. The matched preferred
+   * allows a set of preferred {@@linkZoneId} to be specified for parsing. The matched preferred
    * zone id will be used if the textual zone name being parsed is not unique.
    *
    * If the zone cannot be parsed then an exception is thrown unless the section of the formatter is
@@ -1104,8 +1105,8 @@ final class DateTimeFormatterBuilder private (
    * This appends an instruction to format/parse the chronology ID to the builder.
    *
    * During printing, the chronology is obtained using a mechanism equivalent to querying the
-   * temporal with {@link TemporalQueries#chronology()}. It will be printed using the result of
-   * {@link Chronology#getId()}. If the chronology cannot be obtained then an exception is thrown
+   * temporal with {@@linkTemporalQueries#chronology()} . It will be printed using the result of
+   * {@@linkChronology#getId()} . If the chronology cannot be obtained then an exception is thrown
    * unless the section of the formatter is optional.
    *
    * During parsing, the chronology is parsed and must match one of the chronologies in {@link
@@ -1127,18 +1128,18 @@ final class DateTimeFormatterBuilder private (
    *
    * This appends a localized section to the builder, suitable for outputting a date, time or
    * date-time combination. The format of the localized section is lazily looked up based on four
-   * items: <ul> <li>the {@code dateStyle} specified to this method <li>the {@code timeStyle}
-   * specified to this method <li>the {@code Locale} of the {@code DateTimeFormatter} <li>the {@code
+   * items: <ul> <li>the {@@codedateStyle} specified to this method <li>the {@@codetimeStyle}
+   * specified to this method <li>the {@@codeLocale} of the {@@codeDateTimeFormatter} <li>the {@code
    * Chronology}, selecting the best available </ul><p> During formatting, the chronology is
    * obtained from the temporal object being formatted, which may have been overridden by {@link
    * DateTimeFormatter#withChronology(Chronology)}.
    *
    * During parsing, if a chronology has already been parsed, then it is used. Otherwise the default
-   * from {@code DateTimeFormatter.withChronology(Chronology)} is used, with {@code IsoChronology}
+   * from {@@codeDateTimeFormatter.withChronology(Chronology)} is used, with {@@codeIsoChronology}
    * as the fallback.
    *
-   * Note that this method provides similar functionality to methods on {@code DateFormat} such as
-   * {@link DateFormat#getDateTimeInstance(int, int)}.
+   * Note that this method provides similar functionality to methods on {@@codeDateFormat} such as
+   * {@@linkDateFormat#getDateTimeInstance(int, int)} .
    *
    * @param dateStyle
    *   the date style to use, null means no date required
@@ -1214,7 +1215,7 @@ final class DateTimeFormatterBuilder private (
    * Appends a formatter to the builder which will optionally print/parse.
    *
    * This method has the same effect as appending each of the constituent parts directly to this
-   * builder surrounded by an {@link #optionalStart()} and {@link #optionalEnd()}.
+   * builder surrounded by an {@@link#optionalStart()} and {@@link#optionalEnd()} .
    *
    * The formatter will print if data is available for all the fields contained within it. The
    * formatter will parse if the string matches, otherwise no error is returned.
@@ -1235,10 +1236,9 @@ final class DateTimeFormatterBuilder private (
    *
    * All letters 'A' to 'Z' and 'a' to 'z' are reserved as pattern letters. The characters '{' and
    * '}' are reserved for future use. The characters '[' and ']' indicate optional patterns. The
-   * following pattern letters are defined: <pre> Symbol Meaning Presentation Examples
-   * ------ ------- ------------ ------- G era number/text 1; 01; AD; Anno Domini y year year 2004;
-   * 04 D day-of-year number 189 M month-of-year number/text 7; 07; Jul; July; J d day-of-month
-   * number 10
+   * following pattern letters are defined: <pre> Symbol Meaning Presentation Examples ------
+   * ------- ------------ ------- G era number/text 1; 01; AD; Anno Domini y year year 2004; 04 D
+   * day-of-year number 189 M month-of-year number/text 7; 07; Jul; July; J d day-of-month number 10
    *
    * Q quarter-of-year number/text 3; 03; Q3 Y week-based-year year 1996; 96 w week-of-year number
    * 27 W week-of-month number 27 e localized day-of-week number 2; Tue; Tuesday; T E day-of-week
@@ -1264,13 +1264,13 @@ final class DateTimeFormatterBuilder private (
    * The count of pattern letters determine the format.
    *
    * <b>Text</b>: The text style is determined based on the number of pattern letters used. Less
-   * than 4 pattern letters will use the {@link TextStyle#SHORT short form}. Exactly 4 pattern
-   * letters will use the {@link TextStyle#FULL full form}. Exactly 5 pattern letters will use the
-   * {@link TextStyle#NARROW narrow form}.
+   * than 4 pattern letters will use the {@@linkTextStyle#SHORT short form} . Exactly 4 pattern
+   * letters will use the {@@linkTextStyle#FULL full form} . Exactly 5 pattern letters will use the
+   * {@@linkTextStyle#NARROW narrow form} .
    *
    * <b>Number</b>: If the count of letters is one, then the value is printed using the minimum
-   * number of digits and without padding as per {@link #appendValue(TemporalField)}. Otherwise, the
-   * count of digits is used as the width of the output field as per {@link
+   * number of digits and without padding as per {@@link#appendValue(TemporalField)} . Otherwise,
+   * the count of digits is used as the width of the output field as per {@link
    * #appendValue(TemporalField, int)}.
    *
    * <b>Number/Text</b>: If the count of pattern letters is 3 or greater, use the Text rules above.
@@ -1284,12 +1284,12 @@ final class DateTimeFormatterBuilder private (
    * of pattern letters, up to 9 digits.
    *
    * <b>Year</b>: The count of letters determines the minimum field width below which padding is
-   * used. If the count of letters is two, then a {@link #appendValueReduced reduced} two digit form
+   * used. If the count of letters is two, then a {@@link#appendValueReduced reduced} two digit form
    * is used. For printing, this outputs the rightmost two digits. For parsing, this will parse
    * using the base value of 2000, resulting in a year within the range 2000 to 2099 inclusive. If
    * the count of letters is less than four (but not two), then the sign is only output for negative
-   * years as per {@link SignStyle#NORMAL}. Otherwise, the sign is output if the pad width is
-   * exceeded, as per {@link SignStyle#EXCEEDS_PAD}
+   * years as per {@@linkSignStyle#NORMAL} . Otherwise, the sign is output if the pad width is
+   * exceeded, as per {@@linkSignStyle#EXCEEDS_PAD}
    *
    * <b>ZoneId</b>: This outputs the time-zone ID, such as 'Europe/Paris'. If the count of letters
    * is two, then the time-zone ID is output. Any other count of letters throws {@code
@@ -1297,7 +1297,7 @@ final class DateTimeFormatterBuilder private (
    *
    * <b>Zone names</b>: This outputs the display name of the time-zone ID. If the count of letters
    * is one, two or three, then the short name is output. If the count of letters is four, then the
-   * full name is output. Five or more letters throws {@code IllegalArgumentException}. <pre>
+   * full name is output. Five or more letters throws {@@codeIllegalArgumentException} . <pre>
    * Pattern Equivalent builder methods z appendZoneText(TextStyle.SHORT) zz
    * appendZoneText(TextStyle.SHORT) zzz appendZoneText(TextStyle.SHORT) zzzz
    * appendZoneText(TextStyle.FULL) </pre>
@@ -1308,27 +1308,27 @@ final class DateTimeFormatterBuilder private (
    * colon, such as '+0130'. Three letters outputs the hour and minute, with a colon, such as
    * '+01:30'. Four letters outputs the hour and minute and optional second, without a colon, such
    * as '+013015'. Five letters outputs the hour and minute and optional second, with a colon, such
-   * as '+01:30:15'. Six or more letters throws {@code IllegalArgumentException}. Pattern letter 'X'
-   * (upper case) will output 'Z' when the offset to be output would be zero, whereas pattern letter
-   * 'x' (lower case) will output '+00', '+0000', or '+00:00'. <pre> Pattern Equivalent builder
-   * methods X appendOffset("+HHmm","Z") XX appendOffset("+HHMM","Z") XXX appendOffset("+HH:MM","Z")
-   * XXXX appendOffset("+HHMMss","Z") XXXXX appendOffset("+HH:MM:ss","Z") x
-   * appendOffset("+HHmm","+00") xx appendOffset("+HHMM","+0000") xxx
+   * as '+01:30:15'. Six or more letters throws {@@codeIllegalArgumentException} . Pattern letter
+   * 'X' (upper case) will output 'Z' when the offset to be output would be zero, whereas pattern
+   * letter 'x' (lower case) will output '+00', '+0000', or '+00:00'. <pre> Pattern Equivalent
+   * builder methods X appendOffset("+HHmm","Z") XX appendOffset("+HHMM","Z") XXX
+   * appendOffset("+HH:MM","Z") XXXX appendOffset("+HHMMss","Z") XXXXX appendOffset("+HH:MM:ss","Z")
+   * x appendOffset("+HHmm","+00") xx appendOffset("+HHMM","+0000") xxx
    * appendOffset("+HH:MM","+00:00") xxxx appendOffset("+HHMMss","+0000") xxxxx
    * appendOffset("+HH:MM:ss","+00:00") </pre>
    *
    * <b>Offset Z</b>: This formats the offset based on the number of pattern letters. One, two or
    * three letters outputs the hour and minute, without a colon, such as '+0130'. Four or more
-   * letters throws {@code IllegalArgumentException}. The output will be '+0000' when the offset is
+   * letters throws {@@codeIllegalArgumentException} . The output will be '+0000' when the offset is
    * zero. <pre> Pattern Equivalent builder methods Z appendOffset("+HHMM","+0000") ZZ
    * appendOffset("+HHMM","+0000") ZZZ appendOffset("+HHMM","+0000") </pre>
    *
    * <b>Optional section</b>: The optional section markers work exactly like calling {@link
-   * #optionalStart()} and {@link #optionalEnd()}.
+   * #optionalStart()} and {@@link#optionalEnd()} .
    *
    * <b>Pad modifier</b>: Modifies the pattern that immediately follows to be padded with spaces.
    * The pad width is determined by the number of pattern letters. This is the same as calling
-   * {@link #padNext(int)}.
+   * {@@link#padNext(int)} .
    *
    * For example, 'ppH' outputs the hour-of-day padded on the left with spaces to a width of 2.
    *
@@ -1659,11 +1659,11 @@ final class DateTimeFormatterBuilder private (
    * Mark the start of an optional section.
    *
    * The output of printing can include optional sections, which may be nested. An optional section
-   * is started by calling this method and ended by calling {@link #optionalEnd()} or by ending the
+   * is started by calling this method and ended by calling {@@link#optionalEnd()} or by ending the
    * build process.
    *
    * All elements in the optional section are treated as optional. During printing, the section is
-   * only output if data is available in the {@code TemporalAccessor} for all the elements in the
+   * only output if data is available in the {@@codeTemporalAccessor} for all the elements in the
    * section. During parsing, the whole section may be missing from the parsed string.
    *
    * For example, consider a builder setup as {@code
@@ -1685,15 +1685,15 @@ final class DateTimeFormatterBuilder private (
    * Ends an optional section.
    *
    * The output of printing can include optional sections, which may be nested. An optional section
-   * is started by calling {@link #optionalStart()} and ended using this method (or at the end of
+   * is started by calling {@@link#optionalStart()} and ended using this method (or at the end of
    * the builder).
    *
-   * Calling this method without having previously called {@code optionalStart} will throw an
-   * exception. Calling this method immediately after calling {@code optionalStart} has no effect on
+   * Calling this method without having previously called {@@codeoptionalStart} will throw an
+   * exception. Calling this method immediately after calling {@@codeoptionalStart} has no effect on
    * the formatter other than ending the (empty) optional section.
    *
    * All elements in the optional section are treated as optional. During printing, the section is
-   * only output if data is available in the {@code TemporalAccessor} for all the elements in the
+   * only output if data is available in the {@@codeTemporalAccessor} for all the elements in the
    * section. During parsing, the whole section may be missing from the parsed string.
    *
    * For example, consider a builder setup as {@code
@@ -1705,7 +1705,7 @@ final class DateTimeFormatterBuilder private (
    * @return
    *   this, for chaining, not null
    * @throws IllegalStateException
-   *   if there was no previous call to { @code optionalStart}
+   *   if there was no previous call to {@@codeoptionalStart}
    */
   def optionalEnd(): DateTimeFormatterBuilder = {
     if (active.parent == null)
@@ -1759,7 +1759,7 @@ final class DateTimeFormatterBuilder private (
    * #optionalEnd()} before creating the formatter.
    *
    * This builder can still be used after creating the formatter if desired, although the state may
-   * have been changed by calls to {@code optionalEnd}.
+   * have been changed by calls to {@@codeoptionalEnd} .
    *
    * @return
    *   the created formatter, not null
@@ -1776,7 +1776,7 @@ final class DateTimeFormatterBuilder private (
    * #optionalEnd()} before creating the formatter.
    *
    * This builder can still be used after creating the formatter if desired, although the state may
-   * have been changed by calls to {@code optionalEnd}.
+   * have been changed by calls to {@@codeoptionalEnd} .
    *
    * @param locale
    *   the locale to use for formatting, not null
diff --git a/core/shared/src/main/scala/org/threeten/bp/format/SimpleDateTimeFormatStyleProvider.scala b/core/shared/src/main/scala/org/threeten/bp/format/SimpleDateTimeFormatStyleProvider.scala
index 9c240e7e2..7aef956db 100644
--- a/core/shared/src/main/scala/org/threeten/bp/format/SimpleDateTimeFormatStyleProvider.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/format/SimpleDateTimeFormatStyleProvider.scala
@@ -48,7 +48,7 @@ private object SimpleDateTimeFormatStyleProvider {
 /**
  * The Service Provider Implementation to obtain date-time formatters for a style.
  *
- * This implementation is based on extraction of data from a {@link SimpleDateFormat}.
+ * This implementation is based on extraction of data from a {@@linkSimpleDateFormat} .
  *
  * <h3>Specification for implementors</h3> This class is immutable and thread-safe.
  */
diff --git a/core/shared/src/main/scala/org/threeten/bp/format/internal/DateTimePrinterParser.scala b/core/shared/src/main/scala/org/threeten/bp/format/internal/DateTimePrinterParser.scala
index 7b5cf17c3..0093521f8 100644
--- a/core/shared/src/main/scala/org/threeten/bp/format/internal/DateTimePrinterParser.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/format/internal/DateTimePrinterParser.scala
@@ -11,8 +11,8 @@ import java.lang.StringBuilder
  * The parser may parse any piece of text from the input, storing the result in the context.
  * Typically, each individual parser will just parse one field, such as the day-of-month, storing
  * the value in the context. Once the parse is complete, the caller will then convert the context to
- * a {@link DateTimeBuilder} to merge the parsed values to create the desired object, such as a
- * {@code LocalDate}.
+ * a {@@linkDateTimeBuilder} to merge the parsed values to create the desired object, such as a
+ * {@@codeLocalDate} .
  *
  * The parse position will be updated during the parse. Parsing will start at the specified index
  * and the return value specifies the new parse position for the next parser. If an error occurs,
diff --git a/core/shared/src/main/scala/org/threeten/bp/format/internal/TTBPDateTimeParseContext.scala b/core/shared/src/main/scala/org/threeten/bp/format/internal/TTBPDateTimeParseContext.scala
index e4e1cd950..d590f892d 100644
--- a/core/shared/src/main/scala/org/threeten/bp/format/internal/TTBPDateTimeParseContext.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/format/internal/TTBPDateTimeParseContext.scala
@@ -73,7 +73,7 @@ object TTBPDateTimeParseContext {
  * the parsed values and manage optional segments. It also provides key information to the parsing
  * methods.
  *
- * Once parsing is complete, the {@link #toBuilder()} is typically used to obtain a builder that can
+ * Once parsing is complete, the {@@link#toBuilder()} is typically used to obtain a builder that can
  * combine the separate parsed fields into meaningful values.
  *
  * <h3>Specification for implementors</h3> This class is a mutable context intended for use from a
@@ -178,7 +178,7 @@ final class TTBPDateTimeParseContext(
   def setCaseSensitive(caseSensitive: Boolean): Unit = this.caseSensitive = caseSensitive
 
   /**
-   * Helper to compare two {@code CharSequence} instances. This uses {@link #isCaseSensitive()}.
+   * Helper to compare two {@@codeCharSequence} instances. This uses {@@link#isCaseSensitive()} .
    *
    * @param cs1
    *   the first character sequence, not null
@@ -228,7 +228,7 @@ final class TTBPDateTimeParseContext(
   }
 
   /**
-   * Helper to compare two {@code char}. This uses {@link #isCaseSensitive()}.
+   * Helper to compare two {@@codechar} . This uses {@@link#isCaseSensitive()} .
    *
    * @param ch1
    *   the first character
@@ -397,7 +397,7 @@ final class TTBPDateTimeParseContext(
   def setParsedLeapSecond(): Unit = currentParsed.leapSecond = true
 
   /**
-   * Returns a {@code TemporalAccessor} that can be used to interpret the results of the parse.
+   * Returns a {@@codeTemporalAccessor} that can be used to interpret the results of the parse.
    *
    * @return
    *   an accessor with the results of the parse, not null
@@ -459,11 +459,11 @@ final class TTBPDateTimeParseContext(
         super.query(query)
 
     /**
-     * Returns a {@code DateTimeBuilder} that can be used to interpret the results of the parse.
+     * Returns a {@@codeDateTimeBuilder} that can be used to interpret the results of the parse.
      *
      * This method is typically used once parsing is complete to obtain the parsed data. Parsing
      * will typically result in separate fields, such as year, month and day. The returned builder
-     * can be used to combine the parsed data into meaningful objects such as {@code LocalDate},
+     * can be used to combine the parsed data into meaningful objects such as {@@codeLocalDate} ,
      * potentially applying complex processing to handle invalid parsed data.
      *
      * @return
diff --git a/core/shared/src/main/scala/org/threeten/bp/format/internal/TTBPSimpleDateTimeTextProvider.scala b/core/shared/src/main/scala/org/threeten/bp/format/internal/TTBPSimpleDateTimeTextProvider.scala
index ef645bee8..1aca3041f 100644
--- a/core/shared/src/main/scala/org/threeten/bp/format/internal/TTBPSimpleDateTimeTextProvider.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/format/internal/TTBPSimpleDateTimeTextProvider.scala
@@ -133,7 +133,7 @@ object TTBPSimpleDateTimeTextProvider {
 /**
  * The Service Provider Implementation to obtain date-time text for a field.
  *
- * This implementation is based on extraction of data from a {@link DateFormatSymbols}.
+ * This implementation is based on extraction of data from a {@@linkDateFormatSymbols} .
  *
  * <h3>Specification for implementors</h3> This class is immutable and thread-safe.
  */
diff --git a/core/shared/src/main/scala/org/threeten/bp/package.scala b/core/shared/src/main/scala/org/threeten/bp/package.scala
index d5fd8f3ce..e10febd43 100644
--- a/core/shared/src/main/scala/org/threeten/bp/package.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/package.scala
@@ -40,11 +40,11 @@ package org.threeten
  * are immutable and thread-safe.
  *
  * Each date time instance is composed of fields that are conveniently made available by the APIs.
- * For lower level access to the fields refer to the {@link org.threeten.bp.temporal} package. Each
+ * For lower level access to the fields refer to the {@@linkorg.threeten.bp.temporal} package. Each
  * class includes support for printing and parsing all manner of dates and times. Refer to the
- * {@link org.threeten.bp.format} package for customization options.
+ * {@@linkorg.threeten.bp.format} package for customization options.
  *
- * The {@link org.threeten.bp.chrono} package contains the calendar neutral API. This is intended
+ * The {@@linkorg.threeten.bp.chrono} package contains the calendar neutral API. This is intended
  * for use by applications that need to use localized calendars. It is recommended that applications
  * use the ISO-8601 dates and time classes from this package across system boundaries, such as to
  * the database or across the network. The calendar neutral API should be reserved for interactions
@@ -52,29 +52,29 @@ package org.threeten
  *
  * ==Dates and Times==
  *
- * {@link org.threeten.bp.Instant} is essentially a numeric timestamp. The current Instant can be
- * retrieved from a {@link org.threeten.bp.Clock}. This is useful for logging and persistence of a
+ * {@@linkorg.threeten.bp.Instant} is essentially a numeric timestamp. The current Instant can be
+ * retrieved from a {@@linkorg.threeten.bp.Clock} . This is useful for logging and persistence of a
  * point in time and has in the past been associated with storing the result from {@link
  * java.lang.System#currentTimeMillis()}.
  *
- * {@link org.threeten.bp.LocalDate} stores a date without a time. This stores a date like
+ * {@@linkorg.threeten.bp.LocalDate} stores a date without a time. This stores a date like
  * '2010-12-03' and could be used to store a birthday.
  *
- * {@link org.threeten.bp.LocalTime} stores a time without a date. This stores a time like '11:30'
+ * {@@linkorg.threeten.bp.LocalTime} stores a time without a date. This stores a time like '11:30'
  * and could be used to store an opening or closing time.
  *
- * {@link org.threeten.bp.LocalDateTime} stores a date and time. This stores a date-time like
+ * {@@linkorg.threeten.bp.LocalDateTime} stores a date and time. This stores a date-time like
  * '2010-12-03T11:30'.
  *
- * {@link org.threeten.bp.OffsetTime} stores a time and offset from UTC without a date. This stores
- * a date like '11:30+01:00'. The {@link org.threeten.bp.ZoneOffset ZoneOffset} is of the form
+ * {@@linkorg.threeten.bp.OffsetTime} stores a time and offset from UTC without a date. This stores
+ * a date like '11:30+01:00'. The {@@linkorg.threeten.bp.ZoneOffset ZoneOffset} is of the form
  * '+01:00'.
  *
- * {@link org.threeten.bp.OffsetDateTime} stores a date and time and offset from UTC. This stores a
+ * {@@linkorg.threeten.bp.OffsetDateTime} stores a date and time and offset from UTC. This stores a
  * date-time like '2010-12-03T11:30+01:00'. This is sometimes found in XML messages and other forms
  * of persistence, but contains less information than a full time-zone.
  *
- * {@link org.threeten.bp.ZonedDateTime} stores a date and time with a time-zone. This is useful if
+ * {@@linkorg.threeten.bp.ZonedDateTime} stores a date and time with a time-zone. This is useful if
  * you want to perform accurate calculations of dates and times taking into account the {@link
  * org.threeten.bp.ZoneId}, such as 'Europe/Paris'. Where possible, it is recommended to use a
  * simpler class. The widespread use of time-zones tends to add considerable complexity to an
@@ -84,25 +84,25 @@ package org.threeten
  *
  * Beyond dates and times, the API also allows the storage of period and durations of time. A {@link
  * org.threeten.bp.Duration} is a simple measure of time along the time-line in nanoseconds. A
- * {@link org.threeten.bp.Period} expresses an amount of time in units meaningful to humans, such as
+ * {@@linkorg.threeten.bp.Period} expresses an amount of time in units meaningful to humans, such as
  * years or hours.
  *
  * ==Additional value types==
  *
- * {@link org.threeten.bp.Year} stores a year on its own. This stores a single year in isolation,
+ * {@@linkorg.threeten.bp.Year} stores a year on its own. This stores a single year in isolation,
  * such as '2010'.
  *
- * {@link org.threeten.bp.YearMonth} stores a year and month without a day or time. This stores a
+ * {@@linkorg.threeten.bp.YearMonth} stores a year and month without a day or time. This stores a
  * year and month, such as '2010-12' and could be used for a credit card expiry.
  *
- * {@link org.threeten.bp.MonthDay} stores a month and day without a year or time. This stores a
+ * {@@linkorg.threeten.bp.MonthDay} stores a month and day without a year or time. This stores a
  * month and day-of-month, such as '--12-03' and could be used to store an annual event like a
  * birthday without storing the year.
  *
- * {@link org.threeten.bp.Month} stores a month on its own. This stores a single month-of-year in
+ * {@@linkorg.threeten.bp.Month} stores a month on its own. This stores a single month-of-year in
  * isolation, such as 'DECEMBER'.
  *
- * {@link org.threeten.bp.DayOfWeek} stores a day-of-week on its own. This stores a single
+ * {@@linkorg.threeten.bp.DayOfWeek} stores a day-of-week on its own. This stores a single
  * day-of-week in isolation, such as 'TUESDAY'.
  */
 package object bp
diff --git a/core/shared/src/main/scala/org/threeten/bp/temporal/Temporal.scala b/core/shared/src/main/scala/org/threeten/bp/temporal/Temporal.scala
index 37011c101..f5630fe12 100644
--- a/core/shared/src/main/scala/org/threeten/bp/temporal/Temporal.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/temporal/Temporal.scala
@@ -37,28 +37,28 @@ package org.threeten.bp.temporal
  *
  * This is the base interface type for date, time and offset objects that are complete enough to be
  * manipulated using plus and minus. It is implemented by those classes that can provide and
- * manipulate information as {@link TemporalField fields} or {@link TemporalQuery queries}. See
- * {@link TemporalAccessor} for the read-only version of this interface.
+ * manipulate information as {@@linkTemporalField fields} or {@@linkTemporalQuery queries} . See
+ * {@@linkTemporalAccessor} for the read-only version of this interface.
  *
  * Most date and time information can be represented as a number. These are modeled using {@code
- * TemporalField} with the number held using a {@code long} to handle large values. Year, month and
+ * TemporalField} with the number held using a {@@codelong} to handle large values. Year, month and
  * day-of-month are simple examples of fields, but they also include instant and offsets. See {@link
  * ChronoField} for the standard set of fields.
  *
  * Two pieces of date/time information cannot be represented by numbers, the {@link Chronology
- * chronology} and the {@link ZoneId time-zone}. These can be accessed via {@link
- * #query(TemporalQuery) queries} using the static methods defined on {@link TemporalQueries}.
+ * chronology} and the {@@linkZoneId time-zone} . These can be accessed via {@link
+ * #query(TemporalQuery) queries} using the static methods defined on {@@linkTemporalQueries} .
  *
  * This interface is a framework-level interface that should not be widely used in application code.
  * Instead, applications should create and pass around instances of concrete types, such as {@code
  * LocalDate}. There are many reasons for this, part of which is that implementations of this
- * interface may be in calendar systems other than ISO. See {@link ChronoLocalDate} for a fuller
+ * interface may be in calendar systems other than ISO. See {@@linkChronoLocalDate} for a fuller
  * discussion of the issues.
  *
  * <h3>When to implement</h3>
  *
  * A class should implement this interface if it meets three criteria: <ul> <li>it provides access
- * to date/time/offset information, as per {@code TemporalAccessor} <li>the set of fields are
+ * to date/time/offset information, as per {@@codeTemporalAccessor} <li>the set of fields are
  * contiguous from the largest to the smallest <li>the set of fields are complete, such that no
  * other field is needed to define the valid range of values for the fields that are represented
  * </ul><p>
@@ -78,7 +78,7 @@ package org.threeten.bp.temporal
  *
  * <h3>Specification for implementors</h3> This interface places no restrictions on the mutability
  * of implementations, however immutability is strongly recommended. All implementations must be
- * {@link Comparable}.
+ * {@@linkComparable} .
  */
 trait Temporal extends TemporalAccessor {
 
@@ -86,15 +86,15 @@ trait Temporal extends TemporalAccessor {
    * Checks if the specified unit is supported.
    *
    * This checks if the date-time can be queried for the specified unit. If false, then calling the
-   * {@link #plus(TemporalAmount) plus} and {@link #minus(TemporalAmount) minus} methods will throw
+   * {@@link#plus(TemporalAmount) plus} and {@@link#minus(TemporalAmount) minus} methods will throw
    * an exception.
    *
    * <h3>Specification for implementors</h3> Implementations must check and handle all fields
-   * defined in {@link ChronoUnit}. If the field is supported, then true is returned, otherwise
+   * defined in {@@linkChronoUnit} . If the field is supported, then true is returned, otherwise
    * false
    *
-   * If the field is not a {@code ChronoUnit}, then the result of this method is obtained by
-   * invoking {@code TemporalUnit.isSupportedBy(Temporal)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoUnit} , then the result of this method is obtained by
+   * invoking {@@codeTemporalUnit.isSupportedBy(Temporal)} passing {@@codethis} as the argument.
    *
    * Implementations must not alter this object.
    *
@@ -111,7 +111,7 @@ trait Temporal extends TemporalAccessor {
    * This adjusts this date-time according to the rules of the specified adjuster. A simple adjuster
    * might simply set the one of the fields, such as the year field. A more complex adjuster might
    * set the date to the last day of the month. A selection of common adjustments is provided in
-   * {@link TemporalAdjusters}. These include finding the "last day of the month" and "next
+   * {@@linkTemporalAdjusters} . These include finding the "last day of the month" and "next
    * Wednesday". The adjuster is responsible for handling special cases, such as the varying lengths
    * of month and leap years.
    *
@@ -139,8 +139,8 @@ trait Temporal extends TemporalAccessor {
    * Returns an object of the same type as this object with the specified field altered.
    *
    * This returns a new object based on this one with the value for the specified field changed. For
-   * example, on a {@code LocalDate}, this could be used to set the year, month or day-of-month. The
-   * returned object will have the same observable type as this object.
+   * example, on a {@@codeLocalDate} , this could be used to set the year, month or day-of-month.
+   * The returned object will have the same observable type as this object.
    *
    * In some cases, changing a field is not fully defined. For example, if the target object is a
    * date representing the 31st January, then changing the month to February would be unclear. In
@@ -148,11 +148,11 @@ trait Temporal extends TemporalAccessor {
    * the previous valid date, which would be the last valid day of February in this example.
    *
    * <h3>Specification for implementors</h3> Implementations must check and handle all fields
-   * defined in {@link ChronoField}. If the field is supported, then the adjustment must be
-   * performed. If unsupported, then a {@code DateTimeException} must be thrown.
+   * defined in {@@linkChronoField} . If the field is supported, then the adjustment must be
+   * performed. If unsupported, then a {@@codeDateTimeException} must be thrown.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.adjustInto(Temporal, long)} passing {@code this} as the first
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.adjustInto(Temporal, long)} passing {@@codethis} as the first
    * argument.
    *
    * Implementations must not alter either this object or the specified temporal object. Instead, an
@@ -176,14 +176,14 @@ trait Temporal extends TemporalAccessor {
    * Returns an object of the same type as this object with an amount added.
    *
    * This adjusts this temporal, adding according to the rules of the specified amount. The amount
-   * is typically a {@link Period} but may be any other type implementing the {@link TemporalAmount}
-   * interface, such as {@link Duration}.
+   * is typically a {@@linkPeriod} but may be any other type implementing the {@@linkTemporalAmount}
+   * interface, such as {@@linkDuration} .
    *
    * Some example code indicating how and why this method is used: <pre> date = date.plus(period);
    * // add a Period instance date = date.plus(duration); // add a Duration instance date =
    * date.plus(workingDays(6)); // example user-written workingDays method </pre>
    *
-   * Note that calling {@code plus} followed by {@code minus} is not guaranteed to return the same
+   * Note that calling {@@codeplus} followed by {@@codeminus} is not guaranteed to return the same
    * date-time.
    *
    * <h3>Specification for implementors</h3> Implementations must not alter either this object.
@@ -205,7 +205,7 @@ trait Temporal extends TemporalAccessor {
    * Returns an object of the same type as this object with the specified period added.
    *
    * This method returns a new object based on this one with the specified period added. For
-   * example, on a {@code LocalDate}, this could be used to add a number of years, months or days.
+   * example, on a {@@codeLocalDate} , this could be used to add a number of years, months or days.
    * The returned object will have the same observable type as this object.
    *
    * In some cases, changing a field is not fully defined. For example, if the target object is a
@@ -213,17 +213,17 @@ trait Temporal extends TemporalAccessor {
    * the field is responsible for resolving the result. Typically it will choose the previous valid
    * date, which would be the last valid day of February in this example.
    *
-   * If the implementation represents a date-time that has boundaries, such as {@code LocalTime},
+   * If the implementation represents a date-time that has boundaries, such as {@@codeLocalTime} ,
    * then the permitted units must include the boundary unit, but no multiples of the boundary unit.
-   * For example, {@code LocalTime} must accept {@code DAYS} but not {@code WEEKS} or {@code
+   * For example, {@@codeLocalTime} must accept {@@codeDAYS} but not {@@codeWEEKS} or {@code
    * MONTHS}.
    *
    * <h3>Specification for implementors</h3> Implementations must check and handle all units defined
-   * in {@link ChronoUnit}. If the unit is supported, then the addition must be performed. If
-   * unsupported, then a {@code DateTimeException} must be thrown.
+   * in {@@linkChronoUnit} . If the unit is supported, then the addition must be performed. If
+   * unsupported, then a {@@codeDateTimeException} must be thrown.
    *
-   * If the unit is not a {@code ChronoUnit}, then the result of this method is obtained by invoking
-   * {@code TemporalUnit.addTo(Temporal, long)} passing {@code this} as the first argument.
+   * If the unit is not a {@@codeChronoUnit} , then the result of this method is obtained by
+   * invoking {@@codeTemporalUnit.addTo(Temporal, long)} passing {@@codethis} as the first argument.
    *
    * Implementations must not alter either this object or the specified temporal object. Instead, an
    * adjusted copy of the original must be returned. This provides equivalent, safe behavior for
@@ -246,14 +246,14 @@ trait Temporal extends TemporalAccessor {
    * Returns an object of the same type as this object with an amount subtracted.
    *
    * This adjusts this temporal, subtracting according to the rules of the specified amount. The
-   * amount is typically a {@link Period} but may be any other type implementing the {@link
-   * TemporalAmount} interface, such as {@link Duration}.
+   * amount is typically a {@@linkPeriod} but may be any other type implementing the {@link
+   * TemporalAmount} interface, such as {@@linkDuration} .
    *
    * Some example code indicating how and why this method is used: <pre> date = date.minus(period);
    * // subtract a Period instance date = date.minus(duration); // subtract a Duration instance date
    * \= date.minus(workingDays(6)); // example user-written workingDays method </pre>
    *
-   * Note that calling {@code plus} followed by {@code minus} is not guaranteed to return the same
+   * Note that calling {@@codeplus} followed by {@@codeminus} is not guaranteed to return the same
    * date-time.
    *
    * <h3>Specification for implementors</h3> Implementations must not alter either this object.
@@ -275,7 +275,7 @@ trait Temporal extends TemporalAccessor {
    * Returns an object of the same type as this object with the specified period subtracted.
    *
    * This method returns a new object based on this one with the specified period subtracted. For
-   * example, on a {@code LocalDate}, this could be used to subtract a number of years, months or
+   * example, on a {@@codeLocalDate} , this could be used to subtract a number of years, months or
    * days. The returned object will have the same observable type as this object.
    *
    * In some cases, changing a field is not fully defined. For example, if the target object is a
@@ -283,9 +283,9 @@ trait Temporal extends TemporalAccessor {
    * this, the field is responsible for resolving the result. Typically it will choose the previous
    * valid date, which would be the last valid day of February in this example.
    *
-   * If the implementation represents a date-time that has boundaries, such as {@code LocalTime},
+   * If the implementation represents a date-time that has boundaries, such as {@@codeLocalTime} ,
    * then the permitted units must include the boundary unit, but no multiples of the boundary unit.
-   * For example, {@code LocalTime} must accept {@code DAYS} but not {@code WEEKS} or {@code
+   * For example, {@@codeLocalTime} must accept {@@codeDAYS} but not {@@codeWEEKS} or {@code
    * MONTHS}.
    *
    * <h3>Specification for implementors</h3> Implementations must behave in a manor equivalent to
@@ -315,18 +315,19 @@ trait Temporal extends TemporalAccessor {
    * unit.
    *
    * This calculates the period between two temporals in terms of a single unit. The start and end
-   * points are {@code this} and the specified temporal. The result will be negative if the end is
+   * points are {@@codethis} and the specified temporal. The result will be negative if the end is
    * before the start. For example, the period in hours between two temporal objects can be
-   * calculated using {@code startTime.until(endTime, HOURS)}.
+   * calculated using {@@codestartTime.until(endTime, HOURS)} .
    *
    * The calculation returns a whole number, representing the number of complete units between the
    * two temporals. For example, the period in hours between the times 11:30 and 13:29 will only be
    * one hour as it is one minute short of two hours.
    *
    * There are two equivalent ways of using this method. The first is to invoke this method
-   * directly. The second is to use {@link TemporalUnit#between(Temporal, Temporal)}: <pre> // these
-   * two lines are equivalent between = thisUnit.between(start, end); between = start.until(end,
-   * thisUnit); </pre> The choice should be made based on which makes the code more readable.
+   * directly. The second is to use {@@linkTemporalUnit#between(Temporal, Temporal)} : <pre> //
+   * these two lines are equivalent between = thisUnit.between(start, end); between =
+   * start.until(end, thisUnit); </pre> The choice should be made based on which makes the code more
+   * readable.
    *
    * For example, this method allows the number of days between two dates to be calculated: <pre>
    * val daysBetween: Long = DAYS.between(start, end); // or alternatively val daysBetween: Long =
@@ -334,12 +335,12 @@ trait Temporal extends TemporalAccessor {
    *
    * <h3>Specification for implementors</h3> Implementations must begin by checking to ensure that
    * the input temporal object is of the same observable type as the implementation. They must then
-   * perform the calculation for all instances of {@link ChronoUnit}. A {@code DateTimeException}
-   * must be thrown for {@code ChronoUnit} instances that are unsupported.
+   * perform the calculation for all instances of {@@linkChronoUnit} . A {@@codeDateTimeException}
+   * must be thrown for {@@codeChronoUnit} instances that are unsupported.
    *
-   * If the unit is not a {@code ChronoUnit}, then the result of this method is obtained by invoking
-   * {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first argument and
-   * the input temporal as the second argument.
+   * If the unit is not a {@@codeChronoUnit} , then the result of this method is obtained by
+   * invoking {@@codeTemporalUnit.between(Temporal, Temporal)} passing {@@codethis} as the first
+   * argument and the input temporal as the second argument.
    *
    * In summary, implementations must behave in a manner equivalent to this code: <pre> // check
    * input temporal is the same type as this class if (unit instanceof ChronoUnit) { // if unit is
diff --git a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAccessor.scala b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAccessor.scala
index 5d3791093..7ae57a394 100644
--- a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAccessor.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAccessor.scala
@@ -36,25 +36,25 @@ package org.threeten.bp.temporal
  * offset or some combination of these.
  *
  * This is the base interface type for date, time and offset objects. It is implemented by those
- * classes that can provide information as {@link TemporalField fields} or {@link TemporalQuery
+ * classes that can provide information as {@@linkTemporalField fields} or {@link TemporalQuery
  * queries}.
  *
  * Most date and time information can be represented as a number. These are modeled using {@code
- * TemporalField} with the number held using a {@code long} to handle large values. Year, month and
+ * TemporalField} with the number held using a {@@codelong} to handle large values. Year, month and
  * day-of-month are simple examples of fields, but they also include instant and offsets. See {@link
  * ChronoField} for the standard set of fields.
  *
  * Two pieces of date/time information cannot be represented by numbers, the {@link Chronology
- * chronology} and the {@link ZoneId time-zone}. These can be accessed via {@link
- * #query(TemporalQuery) queries} using the static methods defined on {@link TemporalQueries}.
+ * chronology} and the {@@linkZoneId time-zone} . These can be accessed via {@link
+ * #query(TemporalQuery) queries} using the static methods defined on {@@linkTemporalQueries} .
  *
- * A sub-interface, {@link Temporal}, extends this definition to one that also supports adjustment
+ * A sub-interface, {@@linkTemporal} , extends this definition to one that also supports adjustment
  * and manipulation on more complete temporal objects.
  *
  * This interface is a framework-level interface that should not be widely used in application code.
  * Instead, applications should create and pass around instances of concrete types, such as {@code
  * LocalDate}. There are many reasons for this, part of which is that implementations of this
- * interface may be in calendar systems other than ISO. See {@link ChronoLocalDate} for a fuller
+ * interface may be in calendar systems other than ISO. See {@@linkChronoLocalDate} for a fuller
  * discussion of the issues.
  *
  * <h3>Specification for implementors</h3> This interface places no restrictions on the mutability
@@ -66,15 +66,15 @@ trait TemporalAccessor {
    * Checks if the specified field is supported.
    *
    * This checks if the date-time can be queried for the specified field. If false, then calling the
-   * {@link #range(TemporalField) range} and {@link #get(TemporalField) get} methods will throw an
+   * {@@link#range(TemporalField) range} and {@@link#get(TemporalField) get} methods will throw an
    * exception.
    *
    * <h3>Specification for implementors</h3> Implementations must check and handle all fields
-   * defined in {@link ChronoField}. If the field is supported, then true is returned, otherwise
+   * defined in {@@linkChronoField} . If the field is supported, then true is returned, otherwise
    * false
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.isSupportedBy(TemporalAccessor)} passing {@@codethis} as the
    * argument.
    *
    * Implementations must not alter this object.
@@ -89,7 +89,7 @@ trait TemporalAccessor {
   /**
    * Gets the range of valid values for the specified field.
    *
-   * All fields can be expressed as a {@code long} integer. This method returns an object that
+   * All fields can be expressed as a {@@codelong} integer. This method returns an object that
    * describes the valid range for that value. The value of this temporal object is used to enhance
    * the accuracy of the returned range. If the date-time cannot return the range, because the field
    * is unsupported or for some other reason, an exception will be thrown.
@@ -99,11 +99,11 @@ trait TemporalAccessor {
    * invalid for the field.
    *
    * <h3>Specification for implementors</h3> Implementations must check and handle all fields
-   * defined in {@link ChronoField}. If the field is supported, then the range of the field must be
-   * returned. If unsupported, then a {@code DateTimeException} must be thrown.
+   * defined in {@@linkChronoField} . If the field is supported, then the range of the field must be
+   * returned. If unsupported, then a {@@codeDateTimeException} must be thrown.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.rangeRefinedBy(TemporalAccessorl)} passing {@code this} as the
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.rangeRefinedBy(TemporalAccessorl)} passing {@@codethis} as the
    * argument.
    *
    * Implementations must not alter either this object.
@@ -123,19 +123,19 @@ trait TemporalAccessor {
       field.rangeRefinedBy(this)
 
   /**
-   * Gets the value of the specified field as an {@code int}.
+   * Gets the value of the specified field as an {@@codeint} .
    *
    * This queries the date-time for the value for the specified field. The returned value will
    * always be within the valid range of values for the field. If the date-time cannot return the
    * value, because the field is unsupported or for some other reason, an exception will be thrown.
    *
    * <h3>Specification for implementors</h3> Implementations must check and handle all fields
-   * defined in {@link ChronoField}. If the field is supported and has an {@code int} range, then
-   * the value of the field must be returned. If unsupported, then a {@code DateTimeException} must
+   * defined in {@@linkChronoField} . If the field is supported and has an {@@codeint} range, then
+   * the value of the field must be returned. If unsupported, then a {@@codeDateTimeException} must
    * be thrown.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    *
    * Implementations must not alter either this object.
    *
@@ -146,7 +146,7 @@ trait TemporalAccessor {
    * @throws DateTimeException
    *   if a value for the field cannot be obtained
    * @throws DateTimeException
-   *   if the range of valid values for the field exceeds an { @code int}
+   *   if the range of valid values for the field exceeds an {@@codeint}
    * @throws DateTimeException
    *   if the value is outside the range of valid values for the field
    * @throws ArithmeticException
@@ -155,18 +155,18 @@ trait TemporalAccessor {
   def get(field: TemporalField): Int = range(field).checkValidIntValue(getLong(field), field)
 
   /**
-   * Gets the value of the specified field as a {@code long}.
+   * Gets the value of the specified field as a {@@codelong} .
    *
    * This queries the date-time for the value for the specified field. The returned value may be
    * outside the valid range of values for the field. If the date-time cannot return the value,
    * because the field is unsupported or for some other reason, an exception will be thrown.
    *
    * <h3>Specification for implementors</h3> Implementations must check and handle all fields
-   * defined in {@link ChronoField}. If the field is supported, then the value of the field must be
-   * returned. If unsupported, then a {@code DateTimeException} must be thrown.
+   * defined in {@@linkChronoField} . If the field is supported, then the value of the field must be
+   * returned. If unsupported, then a {@@codeDateTimeException} must be thrown.
    *
-   * If the field is not a {@code ChronoField}, then the result of this method is obtained by
-   * invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument.
+   * If the field is not a {@@codeChronoField} , then the result of this method is obtained by
+   * invoking {@@codeTemporalField.getFrom(TemporalAccessor)} passing {@@codethis} as the argument.
    *
    * Implementations must not alter either this object.
    *
@@ -191,8 +191,8 @@ trait TemporalAccessor {
    * Examples might be a query that checks if the date is the day before February 29th in a leap
    * year, or calculates the number of days to your next birthday.
    *
-   * The most common query implementations are method references, such as {@code LocalDate::from}
-   * and {@code ZoneId::from}. Further implementations are on {@link TemporalQueries}. Queries may
+   * The most common query implementations are method references, such as {@@codeLocalDate::from}
+   * and {@@codeZoneId::from} . Further implementations are on {@@linkTemporalQueries} . Queries may
    * also be defined by applications.
    *
    * <h3>Specification for implementors</h3> Implementations of this method must behave as follows:
diff --git a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAdjuster.scala b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAdjuster.scala
index c9ef184d2..c7c6e6d43 100644
--- a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAdjuster.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAdjuster.scala
@@ -39,14 +39,14 @@ package org.threeten.bp.temporal
  * be an adjuster that sets the date avoiding weekends, or one that sets the date to the last day of
  * the month.
  *
- * There are two equivalent ways of using a {@code TemporalAdjuster}. The first is to invoke the
- * method on this interface directly. The second is to use {@link Temporal#with(TemporalAdjuster)}:
+ * There are two equivalent ways of using a {@@codeTemporalAdjuster} . The first is to invoke the
+ * method on this interface directly. The second is to use {@@linkTemporal#with(TemporalAdjuster)} :
  * <pre> // these two lines are equivalent, but the second approach is recommended temporal =
  * thisAdjuster.adjustInto(temporal); temporal = temporal.with(thisAdjuster); </pre> It is
- * recommended to use the second approach, {@code with(TemporalAdjuster)}, as it is a lot clearer to
- * read in code.
+ * recommended to use the second approach, {@@codewith(TemporalAdjuster)} , as it is a lot clearer
+ * to read in code.
  *
- * See {@link TemporalAdjusters} for a standard set of adjusters, including finding the last day of
+ * See {@@linkTemporalAdjusters} for a standard set of adjusters, including finding the last day of
  * the month. Adjusters may also be defined by applications.
  *
  * <h3>Specification for implementors</h3> This interface places no restrictions on the mutability
@@ -62,15 +62,15 @@ trait TemporalAdjuster {
    * date to the last day of the month.
    *
    * There are two equivalent ways of using this method. The first is to invoke this method
-   * directly. The second is to use {@link Temporal#with(TemporalAdjuster)}: <pre> // these two
+   * directly. The second is to use {@@linkTemporal#with(TemporalAdjuster)} : <pre> // these two
    * lines are equivalent, but the second approach is recommended temporal =
    * thisAdjuster.adjustInto(temporal); temporal = temporal.with(thisAdjuster); </pre> It is
-   * recommended to use the second approach, {@code with(TemporalAdjuster)}, as it is a lot clearer
+   * recommended to use the second approach, {@@codewith(TemporalAdjuster)} , as it is a lot clearer
    * to read in code.
    *
    * <h3>Specification for implementors</h3> The implementation must take the input object and
    * adjust it. The implementation defines the logic of the adjustment and is responsible for
-   * documenting that logic. It may use any method on {@code Temporal} to query the temporal object
+   * documenting that logic. It may use any method on {@@codeTemporal} to query the temporal object
    * and perform the adjustment. The returned object must have the same observable type as the input
    * object
    *
@@ -79,7 +79,7 @@ trait TemporalAdjuster {
    *
    * The input temporal object may be in a calendar system other than ISO. Implementations may
    * choose to document compatibility with other calendar systems, or reject non-ISO temporal
-   * objects by {@link TemporalQueries#chronology() querying the chronology}.
+   * objects by {@@linkTemporalQueries#chronology() querying the chronology} .
    *
    * This method may be called from multiple threads in parallel. It must be thread-safe when
    * invoked.
diff --git a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAdjusters.scala b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAdjusters.scala
index 8c0e4fb28..432d55456 100644
--- a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAdjusters.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAdjusters.scala
@@ -42,16 +42,16 @@ import org.threeten.bp.LocalDate
 import org.threeten.bp.DayOfWeek
 
 /**
- * Common implementations of {@code TemporalAdjuster}.
+ * Common implementations of {@@codeTemporalAdjuster} .
  *
- * This class provides common implementations of {@link TemporalAdjuster}. They are especially
+ * This class provides common implementations of {@@linkTemporalAdjuster} . They are especially
  * useful to document the intent of business logic and often link well to requirements. For example,
  * these two pieces of code do the same thing, but the second one is clearer (assuming that there is
  * a static import of this class): <pre> // direct manipulation
  * date.withDayOfMonth(1).plusMonths(1).minusDays(1); // use of an adjuster from this class
  * date.with(lastDayOfMonth()); </pre> There are two equivalent ways of using a {@code
  * TemporalAdjuster}. The first is to invoke the method on the interface directly. The second is to
- * use {@link Temporal#with(TemporalAdjuster)}: <pre> // these two lines are equivalent, but the
+ * use {@@linkTemporal#with(TemporalAdjuster)} : <pre> // these two lines are equivalent, but the
  * second approach is recommended dateTime = adjuster.adjustInto(dateTime); dateTime =
  * dateTime.with(adjuster); </pre> It is recommended to use the second approach, {@code
  * with(TemporalAdjuster)}, as it is a lot clearer to read in code.
@@ -206,8 +206,8 @@ object TemporalAdjusters {
    * The ISO calendar system behaves as follows:<br> The input 2011-12-15 for (MONDAY) will return
    * 2011-12-05.<br> The input 2011-12-15 for (FRIDAY) will return 2011-12-02.<br>
    *
-   * The behavior is suitable for use with most calendar systems. It uses the {@code DAY_OF_WEEK}
-   * and {@code DAY_OF_MONTH} fields and the {@code DAYS} unit, and assumes a seven day week.
+   * The behavior is suitable for use with most calendar systems. It uses the {@@codeDAY_OF_WEEK}
+   * and {@@codeDAY_OF_MONTH} fields and the {@@codeDAYS} unit, and assumes a seven day week.
    *
    * @param dayOfWeek
    *   the day-of-week, not null
@@ -226,8 +226,8 @@ object TemporalAdjusters {
    * The ISO calendar system behaves as follows:<br> The input 2011-12-15 for (MONDAY) will return
    * 2011-12-26.<br> The input 2011-12-15 for (FRIDAY) will return 2011-12-30.<br>
    *
-   * The behavior is suitable for use with most calendar systems. It uses the {@code DAY_OF_WEEK}
-   * and {@code DAY_OF_MONTH} fields and the {@code DAYS} unit, and assumes a seven day week.
+   * The behavior is suitable for use with most calendar systems. It uses the {@@codeDAY_OF_WEEK}
+   * and {@@codeDAY_OF_MONTH} fields and the {@@codeDAYS} unit, and assumes a seven day week.
    *
    * @param dayOfWeek
    *   the day-of-week, not null
@@ -260,8 +260,8 @@ object TemporalAdjusters {
    * interpreted leniently according to this algorithm. This definition means that an ordinal of
    * zero finds the last matching day-of-week in the previous month.
    *
-   * The behavior is suitable for use with most calendar systems. It uses the {@code DAY_OF_WEEK}
-   * and {@code DAY_OF_MONTH} fields and the {@code DAYS} unit, and assumes a seven day week.
+   * The behavior is suitable for use with most calendar systems. It uses the {@@codeDAY_OF_WEEK}
+   * and {@@codeDAY_OF_MONTH} fields and the {@@codeDAYS} unit, and assumes a seven day week.
    *
    * @param ordinal
    *   the week within the month, unbounded but typically from -5 to 5
@@ -310,8 +310,8 @@ object TemporalAdjusters {
    * parameter (WEDNESDAY) will return 2011-01-19 (four days later).<br> The input 2011-01-15 (a
    * Saturday) for parameter (SATURDAY) will return 2011-01-22 (seven days later).
    *
-   * The behavior is suitable for use with most calendar systems. It uses the {@code DAY_OF_WEEK}
-   * field and the {@code DAYS} unit, and assumes a seven day week.
+   * The behavior is suitable for use with most calendar systems. It uses the {@@codeDAY_OF_WEEK}
+   * field and the {@@codeDAYS} unit, and assumes a seven day week.
    *
    * @param dayOfWeek
    *   the day-of-week to move the date to, not null
@@ -331,8 +331,8 @@ object TemporalAdjusters {
    * parameter (WEDNESDAY) will return 2011-01-19 (four days later).<br> The input 2011-01-15 (a
    * Saturday) for parameter (SATURDAY) will return 2011-01-15 (same as input).
    *
-   * The behavior is suitable for use with most calendar systems. It uses the {@code DAY_OF_WEEK}
-   * field and the {@code DAYS} unit, and assumes a seven day week.
+   * The behavior is suitable for use with most calendar systems. It uses the {@@codeDAY_OF_WEEK}
+   * field and the {@@codeDAYS} unit, and assumes a seven day week.
    *
    * @param dayOfWeek
    *   the day-of-week to check for or move the date to, not null
@@ -351,8 +351,8 @@ object TemporalAdjusters {
    * parameter (WEDNESDAY) will return 2011-01-12 (three days earlier).<br> The input 2011-01-15 (a
    * Saturday) for parameter (SATURDAY) will return 2011-01-08 (seven days earlier).
    *
-   * The behavior is suitable for use with most calendar systems. It uses the {@code DAY_OF_WEEK}
-   * field and the {@code DAYS} unit, and assumes a seven day week.
+   * The behavior is suitable for use with most calendar systems. It uses the {@@codeDAY_OF_WEEK}
+   * field and the {@@codeDAYS} unit, and assumes a seven day week.
    *
    * @param dayOfWeek
    *   the day-of-week to move the date to, not null
@@ -372,8 +372,8 @@ object TemporalAdjusters {
    * parameter (WEDNESDAY) will return 2011-01-12 (three days earlier).<br> The input 2011-01-15 (a
    * Saturday) for parameter (SATURDAY) will return 2011-01-15 (same as input).
    *
-   * The behavior is suitable for use with most calendar systems. It uses the {@code DAY_OF_WEEK}
-   * field and the {@code DAYS} unit, and assumes a seven day week.
+   * The behavior is suitable for use with most calendar systems. It uses the {@@codeDAY_OF_WEEK}
+   * field and the {@@codeDAYS} unit, and assumes a seven day week.
    *
    * @param dayOfWeek
    *   the day-of-week to check for or move the date to, not null
diff --git a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAmount.scala b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAmount.scala
index 930784614..b118f347f 100644
--- a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAmount.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalAmount.scala
@@ -38,19 +38,19 @@ package org.threeten.bp.temporal
  * This is the base interface type for amounts of time. An amount is distinct from a date or
  * time-of-day in that it is not tied to any specific point on the time-line.
  *
- * The amount can be thought of as a Map of {@code TemporalUnit} to long, exposed via {@link
- * #getUnits()} and {@link #get(TemporalUnit)}. A simple case might have a single unit-value pair,
+ * The amount can be thought of as a Map of {@@codeTemporalUnit} to long, exposed via {@link
+ * #getUnits()} and {@@link#get(TemporalUnit)} . A simple case might have a single unit-value pair,
  * such as "6 hours". A more complex case may have multiple unit-value pairs, such as "7 years, 3
  * months and 5 days".
  *
- * There are two common implementations. {@link Period} is a date-based implementation, storing
- * years, months and days. {@link Duration} is a time-based implementation, storing seconds and
+ * There are two common implementations. {@@linkPeriod} is a date-based implementation, storing
+ * years, months and days. {@@linkDuration} is a time-based implementation, storing seconds and
  * nanoseconds, but providing some access using other duration based units such as minutes, hours
  * and fixed 24-hour days.
  *
  * This interface is a framework-level interface that should not be widely used in application code.
  * Instead, applications should create and pass around instances of concrete types, such as {@code
- * Period} and {@code Duration}.
+ * Period} and {@@codeDuration} .
  *
  * <h3>Specification for implementors</h3> This interface places no restrictions on the mutability
  * of implementations, however immutability is strongly recommended.
@@ -84,14 +84,14 @@ trait TemporalAmount {
    * class.
    *
    * There are two equivalent ways of using this method. The first is to invoke this method
-   * directly. The second is to use {@link Temporal#plus(TemporalAmount)}: <pre> // these two lines
+   * directly. The second is to use {@@linkTemporal#plus(TemporalAmount)} : <pre> // these two lines
    * are equivalent, but the second approach is recommended dateTime = amount.addTo(dateTime);
    * dateTime = dateTime.plus(amount); </pre> It is recommended to use the second approach, {@code
    * plus(TemporalAmount)}, as it is a lot clearer to read in code.
    *
    * <h3>Specification for implementors</h3> The implementation must take the input object and add
    * to it. The implementation defines the logic of the addition and is responsible for documenting
-   * that logic. It may use any method on {@code Temporal} to query the temporal object and perform
+   * that logic. It may use any method on {@@codeTemporal} to query the temporal object and perform
    * the addition. The returned object must have the same observable type as the input object
    *
    * The input object must not be altered. Instead, an adjusted copy of the original must be
@@ -99,7 +99,7 @@ trait TemporalAmount {
    *
    * The input temporal object may be in a calendar system other than ISO. Implementations may
    * choose to document compatibility with other calendar systems, or reject non-ISO temporal
-   * objects by {@link TemporalQueries#chronology() querying the chronology}.
+   * objects by {@@linkTemporalQueries#chronology() querying the chronology} .
    *
    * This method may be called from multiple threads in parallel. It must be thread-safe when
    * invoked.
@@ -122,14 +122,15 @@ trait TemporalAmount {
    * class.
    *
    * There are two equivalent ways of using this method. The first is to invoke this method
-   * directly. The second is to use {@link Temporal#minus(TemporalAmount)}: <pre> // these two lines
-   * are equivalent, but the second approach is recommended dateTime =
+   * directly. The second is to use {@@linkTemporal#minus(TemporalAmount)} : <pre> // these two
+   * lines are equivalent, but the second approach is recommended dateTime =
    * amount.subtractFrom(dateTime); dateTime = dateTime.minus(amount); </pre> It is recommended to
-   * use the second approach, {@code minus(TemporalAmount)}, as it is a lot clearer to read in code.
+   * use the second approach, {@@codeminus(TemporalAmount)} , as it is a lot clearer to read in
+   * code.
    *
    * <h3>Specification for implementors</h3> The implementation must take the input object and
    * subtract from it. The implementation defines the logic of the subtraction and is responsible
-   * for documenting that logic. It may use any method on {@code Temporal} to query the temporal
+   * for documenting that logic. It may use any method on {@@codeTemporal} to query the temporal
    * object and perform the subtraction. The returned object must have the same observable type as
    * the input object
    *
@@ -138,7 +139,7 @@ trait TemporalAmount {
    *
    * The input temporal object may be in a calendar system other than ISO. Implementations may
    * choose to document compatibility with other calendar systems, or reject non-ISO temporal
-   * objects by {@link TemporalQueries#chronology() querying the chronology}.
+   * objects by {@@linkTemporalQueries#chronology() querying the chronology} .
    *
    * This method may be called from multiple threads in parallel. It must be thread-safe when
    * invoked.
diff --git a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalField.scala b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalField.scala
index a88843563..c30af2424 100644
--- a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalField.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalField.scala
@@ -40,18 +40,18 @@ import org.threeten.bp.format.ResolverStyle
  * Date and time is expressed using fields which partition the time-line into something meaningful
  * for humans. Implementations of this interface represent those fields.
  *
- * The most commonly used units are defined in {@link ChronoField}. Further fields are supplied in
- * {@link IsoFields}, {@link WeekFields} and {@link JulianFields}. Fields can also be written by
+ * The most commonly used units are defined in {@@linkChronoField} . Further fields are supplied in
+ * {@@linkIsoFields} , {@@linkWeekFields} and {@@linkJulianFields} . Fields can also be written by
  * application code by implementing this interface.
  *
  * The field works using double dispatch. Client code calls methods on a date-time like {@code
- * LocalDateTime} which check if the field is a {@code ChronoField}. If it is, then the date-time
+ * LocalDateTime} which check if the field is a {@@codeChronoField} . If it is, then the date-time
  * must handle it. Otherwise, the method call is re-dispatched to the matching method in this
  * interface.
  *
  * <h3>Specification for implementors</h3> This interface must be implemented with care to ensure
  * other classes operate correctly. All implementations that can be instantiated must be final,
- * immutable and thread-safe. Implementations should be {@code Serializable} where possible. An enum
+ * immutable and thread-safe. Implementations should be {@@codeSerializable} where possible. An enum
  * is as effective implementation choice.
  */
 trait TemporalField {
@@ -60,7 +60,7 @@ trait TemporalField {
    * Gets the unit that the field is measured in.
    *
    * The unit of the field is the period that varies within the range. For example, in the field
-   * 'MonthOfYear', the unit is 'Months'. See also {@link #getRangeUnit()}.
+   * 'MonthOfYear', the unit is 'Months'. See also {@@link#getRangeUnit()} .
    *
    * @return
    *   the period unit defining the base unit of the field, not null
@@ -71,7 +71,7 @@ trait TemporalField {
    * Gets the range that the field is bound by.
    *
    * The range of the field is the period that the field varies within. For example, in the field
-   * 'MonthOfYear', the range is 'Years'. See also {@link #getBaseUnit()}.
+   * 'MonthOfYear', the range is 'Years'. See also {@@link#getBaseUnit()} .
    *
    * The range is never null. For example, the 'Year' field is shorthand for 'YearOfForever'. It
    * therefore has a unit of 'Years' and a range of 'Forever'.
@@ -84,7 +84,7 @@ trait TemporalField {
   /**
    * Gets the range of valid values for the field.
    *
-   * All fields can be expressed as a {@code long} integer. This method returns an object that
+   * All fields can be expressed as a {@@codelong} integer. This method returns an object that
    * describes the valid range for that value. This method is generally only applicable to the
    * ISO-8601 calendar system.
    *
@@ -124,14 +124,14 @@ trait TemporalField {
    * the temporal cannot be queried for this field.
    *
    * There are two equivalent ways of using this method. The first is to invoke this method
-   * directly. The second is to use {@link TemporalAccessor#isSupported(TemporalField)}: <pre> //
+   * directly. The second is to use {@@linkTemporalAccessor#isSupported(TemporalField)} : <pre> //
    * these two lines are equivalent, but the second approach is recommended temporal =
    * thisField.isSupportedBy(temporal); temporal = temporal.isSupported(thisField); </pre> It is
-   * recommended to use the second approach, {@code isSupported(TemporalField)}, as it is a lot
+   * recommended to use the second approach, {@@codeisSupported(TemporalField)} , as it is a lot
    * clearer to read in code.
    *
    * Implementations should determine whether they are supported using the fields available in
-   * {@link ChronoField}.
+   * {@@linkChronoField} .
    *
    * @param temporal
    *   the temporal object to query, not null
@@ -144,20 +144,20 @@ trait TemporalField {
    * Get the range of valid values for this field using the temporal object to refine the result.
    *
    * This uses the temporal object to find the range of valid values for the field. This is similar
-   * to {@link #range()}, however this method refines the result using the temporal. For example, if
-   * the field is {@code DAY_OF_MONTH} the {@code range} method is not accurate as there are four
+   * to {@@link#range()} , however this method refines the result using the temporal. For example,
+   * if the field is {@@codeDAY_OF_MONTH} the {@@coderange} method is not accurate as there are four
    * possible month lengths, 28, 29, 30 and 31 days. Using this method with a date allows the range
    * to be accurate, returning just one of those four options.
    *
    * There are two equivalent ways of using this method. The first is to invoke this method
-   * directly. The second is to use {@link TemporalAccessor#range(TemporalField)}: <pre> // these
+   * directly. The second is to use {@@linkTemporalAccessor#range(TemporalField)} : <pre> // these
    * two lines are equivalent, but the second approach is recommended temporal =
    * thisField.rangeRefinedBy(temporal); temporal = temporal.range(thisField); </pre> It is
-   * recommended to use the second approach, {@code range(TemporalField)}, as it is a lot clearer to
-   * read in code.
+   * recommended to use the second approach, {@@coderange(TemporalField)} , as it is a lot clearer
+   * to read in code.
    *
    * Implementations should perform any queries or calculations using the fields available in {@link
-   * ChronoField}. If the field is not supported a {@code DateTimeException} must be thrown.
+   * ChronoField}. If the field is not supported a {@@codeDateTimeException} must be thrown.
    *
    * @param temporal
    *   the temporal object used to refine the result, not null
@@ -174,14 +174,14 @@ trait TemporalField {
    * This queries the temporal object for the value of this field.
    *
    * There are two equivalent ways of using this method. The first is to invoke this method
-   * directly. The second is to use {@link TemporalAccessor#getLong(TemporalField)} (or {@link
+   * directly. The second is to use {@@linkTemporalAccessor#getLong(TemporalField)} (or {@link
    * TemporalAccessor#get(TemporalField)}): <pre> // these two lines are equivalent, but the second
    * approach is recommended temporal = thisField.getFrom(temporal); temporal =
    * temporal.getLong(thisField); </pre> It is recommended to use the second approach, {@code
    * getLong(TemporalField)}, as it is a lot clearer to read in code.
    *
    * Implementations should perform any queries or calculations using the fields available in {@link
-   * ChronoField}. If the field is not supported a {@code DateTimeException} must be thrown.
+   * ChronoField}. If the field is not supported a {@@codeDateTimeException} must be thrown.
    *
    * @param temporal
    *   the temporal object to query, not null
@@ -197,7 +197,7 @@ trait TemporalField {
    *
    * If there is no display name for the locale then a suitable default must be returned.
    *
-   * The default implementation must check the locale is not null and return {@code toString()}.
+   * The default implementation must check the locale is not null and return {@@codetoString()} .
    *
    * @param locale
    *   the locale to use, not null
@@ -210,7 +210,7 @@ trait TemporalField {
    * Returns a copy of the specified temporal object with the value of this field set.
    *
    * This returns a new temporal object based on the specified one with the value for this field
-   * changed. For example, on a {@code LocalDate}, this could be used to set the year, month or
+   * changed. For example, on a {@@codeLocalDate} , this could be used to set the year, month or
    * day-of-month. The returned object has the same observable type as the specified object.
    *
    * In some cases, changing a field is not fully defined. For example, if the target object is a
@@ -219,14 +219,14 @@ trait TemporalField {
    * choose the previous valid date, which would be the last valid day of February in this example.
    *
    * There are two equivalent ways of using this method. The first is to invoke this method
-   * directly. The second is to use {@link Temporal#with(TemporalField, long)}: <pre> // these two
+   * directly. The second is to use {@@linkTemporal#with(TemporalField, long)} : <pre> // these two
    * lines are equivalent, but the second approach is recommended temporal =
    * thisField.adjustInto(temporal); temporal = temporal.with(thisField); </pre> It is recommended
-   * to use the second approach, {@code with(TemporalField)}, as it is a lot clearer to read in
+   * to use the second approach, {@@codewith(TemporalField)} , as it is a lot clearer to read in
    * code.
    *
    * Implementations should perform any queries or calculations using the fields available in {@link
-   * ChronoField}. If the field is not supported a {@code DateTimeException} must be thrown.
+   * ChronoField}. If the field is not supported a {@@codeDateTimeException} must be thrown.
    *
    * Implementations must not alter the specified temporal object. Instead, an adjusted copy of the
    * original must be returned. This provides equivalent, safe behavior for immutable and mutable
@@ -249,8 +249,8 @@ trait TemporalField {
    * Resolves the date/time information in the builder
    *
    * This method is invoked during the resolve of the builder. Implementations should combine the
-   * associated field with others to form objects like {@code LocalDate}, {@code LocalTime} and
-   * {@code LocalDateTime}
+   * associated field with others to form objects like {@@codeLocalDate} , {@@codeLocalTime} and
+   * {@@codeLocalDateTime}
    *
    * @param fieldValues
    *   the map of fields to values, which can be updated, not null
diff --git a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalQueries.scala b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalQueries.scala
index a301cc11d..2b5ac4147 100644
--- a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalQueries.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalQueries.scala
@@ -41,19 +41,20 @@ import org.threeten.bp.ZoneOffset
 import org.threeten.bp.chrono.Chronology
 
 /**
- * Common implementations of {@code TemporalQuery}.
+ * Common implementations of {@@codeTemporalQuery} .
  *
- * This class provides common implementations of {@link TemporalQuery}. These queries are primarily
+ * This class provides common implementations of {@@linkTemporalQuery} . These queries are primarily
  * used as optimizations, allowing the internals of other objects to be extracted effectively. Note
- * that application code can also use the {@code from(TemporalAccessor)} method on most temporal
- * objects as a method reference matching the query interface, such as {@code LocalDate::from} and
- * {@code ZoneId::from}.
+ * that application code can also use the {@@codefrom(TemporalAccessor)} method on most temporal
+ * objects as a method reference matching the query interface, such as {@@codeLocalDate::from} and
+ * {@@codeZoneId::from} .
  *
- * There are two equivalent ways of using a {@code TemporalQuery}. The first is to invoke the method
- * on the interface directly. The second is to use {@link TemporalAccessor#query(TemporalQuery)}:
- * <pre> // these two lines are equivalent, but the second approach is recommended dateTime =
- * query.queryFrom(dateTime); dateTime = dateTime.query(query); </pre> It is recommended to use the
- * second approach, {@code query(TemporalQuery)}, as it is a lot clearer to read in code.
+ * There are two equivalent ways of using a {@@codeTemporalQuery} . The first is to invoke the
+ * method on the interface directly. The second is to use
+ * {@@linkTemporalAccessor#query(TemporalQuery)} : <pre> // these two lines are equivalent, but the
+ * second approach is recommended dateTime = query.queryFrom(dateTime); dateTime =
+ * dateTime.query(query); </pre> It is recommended to use the second approach,
+ * {@@codequery(TemporalQuery)} , as it is a lot clearer to read in code.
  *
  * <h3>Specification for implementors</h3> This is a thread-safe utility class. All returned
  * adjusters are immutable and thread-safe.
@@ -61,23 +62,23 @@ import org.threeten.bp.chrono.Chronology
 object TemporalQueries {
 
   /**
-   * A strict query for the {@code ZoneId}.
+   * A strict query for the {@@codeZoneId} .
    *
-   * This queries a {@code TemporalAccessor} for the zone. The zone is only returned if the
-   * date-time conceptually contains a {@code ZoneId}. It will not be returned if the date-time only
-   * conceptually has an {@code ZoneOffset}. Thus a {@link ZonedDateTime} will return the result of
-   * {@code getZone()}, but an {@link OffsetDateTime} will return null.
+   * This queries a {@@codeTemporalAccessor} for the zone. The zone is only returned if the
+   * date-time conceptually contains a {@@codeZoneId} . It will not be returned if the date-time
+   * only conceptually has an {@@codeZoneOffset} . Thus a {@@linkZonedDateTime} will return the
+   * result of {@@codegetZone()} , but an {@@linkOffsetDateTime} will return null.
    *
-   * In most cases, applications should use {@link #ZONE} as this query is too strict.
+   * In most cases, applications should use {@@link#ZONE} as this query is too strict.
    *
-   * The result from JDK classes implementing {@code TemporalAccessor} is as follows:<br> {@code
-   * LocalDate} returns null<br> {@code LocalTime} returns null<br> {@code LocalDateTime} returns
-   * null<br> {@code ZonedDateTime} returns the associated zone<br> {@code OffsetTime} returns
-   * null<br> {@code OffsetDateTime} returns null<br> {@code ChronoLocalDate} returns null<br>
-   * {@code ChronoLocalDateTime} returns null<br> {@code ChronoZonedDateTime} returns the associated
-   * zone<br> {@code Era} returns null<br> {@code DayOfWeek} returns null<br> {@code Month} returns
-   * null<br> {@code Year} returns null<br> {@code YearMonth} returns null<br> {@code MonthDay}
-   * returns null<br> {@code ZoneOffset} returns null<br> {@code Instant} returns null<br>
+   * The result from JDK classes implementing {@@codeTemporalAccessor} is as follows:<br> {@code
+   * LocalDate} returns null<br> {@@codeLocalTime} returns null<br> {@@codeLocalDateTime} returns
+   * null<br> {@@codeZonedDateTime} returns the associated zone<br> {@@codeOffsetTime} returns
+   * null<br> {@@codeOffsetDateTime} returns null<br> {@@codeChronoLocalDate} returns null<br>
+   * {@@codeChronoLocalDateTime} returns null<br> {@@codeChronoZonedDateTime} returns the associated
+   * zone<br> {@@codeEra} returns null<br> {@@codeDayOfWeek} returns null<br> {@@codeMonth} returns
+   * null<br> {@@codeYear} returns null<br> {@@codeYearMonth} returns null<br> {@@codeMonthDay}
+   * returns null<br> {@@codeZoneOffset} returns null<br> {@@codeInstant} returns null<br>
    *
    * @return
    *   a query that can obtain the zone ID of a temporal, not null
@@ -87,29 +88,29 @@ object TemporalQueries {
   }
 
   /**
-   * A query for the {@code Chronology}.
+   * A query for the {@@codeChronology} .
    *
-   * This queries a {@code TemporalAccessor} for the chronology. If the target {@code
+   * This queries a {@@codeTemporalAccessor} for the chronology. If the target {@code
    * TemporalAccessor} represents a date, or part of a date, then it should return the chronology
    * that the date is expressed in. As a result of this definition, objects only representing time,
-   * such as {@code LocalTime}, will return null.
-   *
-   * The result from JDK classes implementing {@code TemporalAccessor} is as follows:<br> {@code
-   * LocalDate} returns {@code IsoChronology.INSTANCE}<br> {@code LocalTime} returns null (does not
-   * represent a date)<br> {@code LocalDateTime} returns {@code IsoChronology.INSTANCE}<br> {@code
-   * ZonedDateTime} returns {@code IsoChronology.INSTANCE}<br> {@code OffsetTime} returns null (does
-   * not represent a date)<br> {@code OffsetDateTime} returns {@code IsoChronology.INSTANCE}<br>
-   * {@code ChronoLocalDate} returns the associated chronology<br> {@code ChronoLocalDateTime}
-   * returns the associated chronology<br> {@code ChronoZonedDateTime} returns the associated
-   * chronology<br> {@code Era} returns the associated chronology<br> {@code DayOfWeek} returns null
-   * (shared across chronologies)<br> {@code Month} returns {@code IsoChronology.INSTANCE}<br>
-   * {@code Year} returns {@code IsoChronology.INSTANCE}<br> {@code YearMonth} returns {@code
-   * IsoChronology.INSTANCE}<br> {@code MonthDay} returns null {@code IsoChronology.INSTANCE}<br>
-   * {@code ZoneOffset} returns null (does not represent a date)<br> {@code Instant} returns null
+   * such as {@@codeLocalTime} , will return null.
+   *
+   * The result from JDK classes implementing {@@codeTemporalAccessor} is as follows:<br> {@code
+   * LocalDate} returns {@@codeIsoChronology.INSTANCE} <br> {@@codeLocalTime} returns null (does not
+   * represent a date)<br> {@@codeLocalDateTime} returns {@@codeIsoChronology.INSTANCE} <br> {@code
+   * ZonedDateTime} returns {@@codeIsoChronology.INSTANCE} <br> {@@codeOffsetTime} returns null
+   * (does not represent a date)<br> {@@codeOffsetDateTime} returns {@@codeIsoChronology.INSTANCE}
+   * <br> {@@codeChronoLocalDate} returns the associated chronology<br> {@@codeChronoLocalDateTime}
+   * returns the associated chronology<br> {@@codeChronoZonedDateTime} returns the associated
+   * chronology<br> {@@codeEra} returns the associated chronology<br> {@@codeDayOfWeek} returns null
+   * (shared across chronologies)<br> {@@codeMonth} returns {@@codeIsoChronology.INSTANCE} <br>
+   * {@@codeYear} returns {@@codeIsoChronology.INSTANCE} <br> {@@codeYearMonth} returns {@code
+   * IsoChronology.INSTANCE}<br> {@@codeMonthDay} returns null {@@codeIsoChronology.INSTANCE} <br>
+   * {@@codeZoneOffset} returns null (does not represent a date)<br> {@@codeInstant} returns null
    * (does not represent a date)<br>
    *
-   * The method {@link Chronology#from(TemporalAccessor)} can be used as a {@code TemporalQuery} via
-   * a method reference, {@code Chrono::from}. That method is equivalent to this query, except that
+   * The method {@@linkChronology#from(TemporalAccessor)} can be used as a {@@codeTemporalQuery} via
+   * a method reference, {@@codeChrono::from} . That method is equivalent to this query, except that
    * it throws an exception if a chronology cannot be obtained.
    *
    * @return
@@ -122,24 +123,25 @@ object TemporalQueries {
   /**
    * A query for the smallest supported unit.
    *
-   * This queries a {@code TemporalAccessor} for the time precision. If the target {@code
+   * This queries a {@@codeTemporalAccessor} for the time precision. If the target {@code
    * TemporalAccessor} represents a consistent or complete date-time, date or time then this must
-   * return the smallest precision actually supported. Note that fields such as {@code NANO_OF_DAY}
-   * and {@code NANO_OF_SECOND} are defined to always return ignoring the precision, thus this is
+   * return the smallest precision actually supported. Note that fields such as {@@codeNANO_OF_DAY}
+   * and {@@codeNANO_OF_SECOND} are defined to always return ignoring the precision, thus this is
    * the only way to find the actual smallest supported unit. For example, were {@code
-   * GregorianCalendar} to implement {@code TemporalAccessor} it would return a precision of {@code
+   * GregorianCalendar} to implement {@@codeTemporalAccessor} it would return a precision of {@code
    * MILLIS}.
    *
-   * The result from JDK classes implementing {@code TemporalAccessor} is as follows:<br> {@code
-   * LocalDate} returns {@code DAYS}<br> {@code LocalTime} returns {@code NANOS}<br> {@code
-   * LocalDateTime} returns {@code NANOS}<br> {@code ZonedDateTime} returns {@code NANOS}<br> {@code
-   * OffsetTime} returns {@code NANOS}<br> {@code OffsetDateTime} returns {@code NANOS}<br> {@code
-   * ChronoLocalDate} returns {@code DAYS}<br> {@code ChronoLocalDateTime} returns {@code NANOS}<br>
-   * {@code ChronoZonedDateTime} returns {@code NANOS}<br> {@code Era} returns {@code ERAS}<br>
-   * {@code DayOfWeek} returns {@code DAYS}<br> {@code Month} returns {@code MONTHS}<br> {@code
-   * Year} returns {@code YEARS}<br> {@code YearMonth} returns {@code MONTHS}<br> {@code MonthDay}
-   * returns null (does not represent a complete date or time)<br> {@code ZoneOffset} returns null
-   * (does not represent a date or time)<br> {@code Instant} returns {@code NANOS}<br>
+   * The result from JDK classes implementing {@@codeTemporalAccessor} is as follows:<br> {@code
+   * LocalDate} returns {@@codeDAYS} <br> {@@codeLocalTime} returns {@@codeNANOS} <br> {@code
+   * LocalDateTime} returns {@@codeNANOS} <br> {@@codeZonedDateTime} returns {@@codeNANOS} <br>
+   * {@code OffsetTime} returns {@@codeNANOS} <br> {@@codeOffsetDateTime} returns {@@codeNANOS} <br>
+   * {@code ChronoLocalDate} returns {@@codeDAYS} <br> {@@codeChronoLocalDateTime} returns
+   * {@@codeNANOS} <br> {@@codeChronoZonedDateTime} returns {@@codeNANOS} <br> {@@codeEra} returns
+   * {@@codeERAS} <br> {@@codeDayOfWeek} returns {@@codeDAYS} <br> {@@codeMonth} returns
+   * {@@codeMONTHS} <br> {@code Year} returns {@@codeYEARS} <br> {@@codeYearMonth} returns
+   * {@@codeMONTHS} <br> {@@codeMonthDay} returns null (does not represent a complete date or
+   * time)<br> {@@codeZoneOffset} returns null (does not represent a date or time)<br>
+   * {@@codeInstant} returns {@@codeNANOS} <br>
    *
    * @return
    *   a query that can obtain the precision of a temporal, not null
@@ -149,13 +151,13 @@ object TemporalQueries {
   }
 
   /**
-   * A query for {@code ZoneOffset} returning null if not found.
+   * A query for {@@codeZoneOffset} returning null if not found.
    *
-   * This returns a {@code TemporalQuery} that can be used to query a temporal object for the
+   * This returns a {@@codeTemporalQuery} that can be used to query a temporal object for the
    * offset. The query will return null if the temporal object cannot supply an offset.
    *
-   * The query implementation examines the {@link ChronoField#OFFSET_SECONDS OFFSET_SECONDS} field
-   * and uses it to create a {@code ZoneOffset}.
+   * The query implementation examines the {@@linkChronoField#OFFSET_SECONDS OFFSET_SECONDS} field
+   * and uses it to create a {@@codeZoneOffset} .
    *
    * @return
    *   a query that can obtain the offset of a temporal, not null
@@ -168,19 +170,19 @@ object TemporalQueries {
   }
 
   /**
-   * A lenient query for the {@code ZoneId}, falling back to the {@code ZoneOffset}.
+   * A lenient query for the {@@codeZoneId} , falling back to the {@@codeZoneOffset} .
    *
-   * This queries a {@code TemporalAccessor} for the zone. It first tries to obtain the zone, using
-   * {@link #zoneId()}. If that is not found it tries to obtain the {@link #offset()}.
+   * This queries a {@@codeTemporalAccessor} for the zone. It first tries to obtain the zone, using
+   * {@@link#zoneId()} . If that is not found it tries to obtain the {@@link#offset()} .
    *
-   * In most cases, applications should use this query rather than {@code #zoneId()}.
+   * In most cases, applications should use this query rather than {@@code#zoneId()} .
    *
-   * This query examines the {@link ChronoField#OFFSET_SECONDS offset-seconds} field and uses it to
-   * create a {@code ZoneOffset}.
+   * This query examines the {@@linkChronoField#OFFSET_SECONDS offset-seconds} field and uses it to
+   * create a {@@codeZoneOffset} .
    *
-   * The method {@link ZoneId#from(TemporalAccessor)} can be used as a {@code TemporalQuery} via a
-   * method reference, {@code ZoneId::from}. That method is equivalent to this query, except that it
-   * throws an exception if a zone cannot be obtained.
+   * The method {@@linkZoneId#from(TemporalAccessor)} can be used as a {@@codeTemporalQuery} via a
+   * method reference, {@@codeZoneId::from} . That method is equivalent to this query, except that
+   * it throws an exception if a zone cannot be obtained.
    *
    * @return
    *   a query that can obtain the zone ID or offset of a temporal, not null
@@ -193,13 +195,13 @@ object TemporalQueries {
   }
 
   /**
-   * A query for {@code LocalDate} returning null if not found.
+   * A query for {@@codeLocalDate} returning null if not found.
    *
-   * This returns a {@code TemporalQuery} that can be used to query a temporal object for the local
+   * This returns a {@@codeTemporalQuery} that can be used to query a temporal object for the local
    * date. The query will return null if the temporal object cannot supply a local date.
    *
-   * The query implementation examines the {@link ChronoField#EPOCH_DAY EPOCH_DAY} field and uses it
-   * to create a {@code LocalDate}.
+   * The query implementation examines the {@@linkChronoField#EPOCH_DAY EPOCH_DAY} field and uses it
+   * to create a {@@codeLocalDate} .
    *
    * @return
    *   a query that can obtain the date of a temporal, not null
@@ -211,13 +213,13 @@ object TemporalQueries {
   }
 
   /**
-   * A query for {@code LocalTime} returning null if not found.
+   * A query for {@@codeLocalTime} returning null if not found.
    *
-   * This returns a {@code TemporalQuery} that can be used to query a temporal object for the local
+   * This returns a {@@codeTemporalQuery} that can be used to query a temporal object for the local
    * time. The query will return null if the temporal object cannot supply a local time.
    *
-   * The query implementation examines the {@link ChronoField#NANO_OF_DAY NANO_OF_DAY} field and
-   * uses it to create a {@code LocalTime}.
+   * The query implementation examines the {@@linkChronoField#NANO_OF_DAY NANO_OF_DAY} field and
+   * uses it to create a {@@codeLocalTime} .
    *
    * @return
    *   a query that can obtain the date of a temporal, not null
diff --git a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalQuery.scala b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalQuery.scala
index b31046027..16670d12f 100644
--- a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalQuery.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalQuery.scala
@@ -39,17 +39,18 @@ package org.threeten.bp.temporal
  * pattern. Examples might be a query that checks if the date is the day before February 29th in a
  * leap year, or calculates the number of days to your next birthday.
  *
- * The {@link TemporalField} interface provides another mechanism for querying temporal objects.
- * That interface is limited to returning a {@code long}. By contrast, queries can return any type.
+ * The {@@linkTemporalField} interface provides another mechanism for querying temporal objects.
+ * That interface is limited to returning a {@@codelong} . By contrast, queries can return any type.
  *
- * There are two equivalent ways of using a {@code TemporalQuery}. The first is to invoke the method
- * on this interface directly. The second is to use {@link TemporalAccessor#query(TemporalQuery)}:
- * <pre> // these two lines are equivalent, but the second approach is recommended temporal =
- * thisQuery.queryFrom(temporal); temporal = temporal.query(thisQuery); </pre> It is recommended to
- * use the second approach, {@code query(TemporalQuery)}, as it is a lot clearer to read in code.
+ * There are two equivalent ways of using a {@@codeTemporalQuery} . The first is to invoke the
+ * method on this interface directly. The second is to use
+ * {@@linkTemporalAccessor#query(TemporalQuery)} : <pre> // these two lines are equivalent, but the
+ * second approach is recommended temporal = thisQuery.queryFrom(temporal); temporal =
+ * temporal.query(thisQuery); </pre> It is recommended to use the second approach,
+ * {@@codequery(TemporalQuery)} , as it is a lot clearer to read in code.
  *
- * The most common implementations are method references, such as {@code LocalDate::from} and {@code
- * ZoneId::from}. Further implementations are on {@link TemporalQueries}. Queries may also be
+ * The most common implementations are method references, such as {@@codeLocalDate::from} and {@code
+ * ZoneId::from}. Further implementations are on {@@linkTemporalQueries} . Queries may also be
  * defined by applications.
  *
  * <h3>Specification for implementors</h3> This interface places no restrictions on the mutability
@@ -65,20 +66,20 @@ trait TemporalQuery[+R] {
    * February 29th in a leap year, or calculates the number of days to your next birthday.
    *
    * There are two equivalent ways of using this method. The first is to invoke this method
-   * directly. The second is to use {@link TemporalAccessor#query(TemporalQuery)}: <pre> // these
+   * directly. The second is to use {@@linkTemporalAccessor#query(TemporalQuery)} : <pre> // these
    * two lines are equivalent, but the second approach is recommended temporal =
    * thisQuery.queryFrom(temporal); temporal = temporal.query(thisQuery); </pre> It is recommended
-   * to use the second approach, {@code query(TemporalQuery)}, as it is a lot clearer to read in
+   * to use the second approach, {@@codequery(TemporalQuery)} , as it is a lot clearer to read in
    * code.
    *
    * <h3>Specification for implementors</h3> The implementation must take the input object and query
    * it. The implementation defines the logic of the query and is responsible for documenting that
-   * logic. It may use any method on {@code TemporalAccessor} to determine the result. The input
+   * logic. It may use any method on {@@codeTemporalAccessor} to determine the result. The input
    * object must not be altered.
    *
    * The input temporal object may be in a calendar system other than ISO. Implementations may
    * choose to document compatibility with other calendar systems, or reject non-ISO temporal
-   * objects by {@link TemporalQueries#chronology() querying the chronology}.
+   * objects by {@@linkTemporalQueries#chronology() querying the chronology} .
    *
    * This method may be called from multiple threads in parallel. It must be thread-safe when
    * invoked.
diff --git a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalUnit.scala b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalUnit.scala
index f7cd1668d..9a72ec262 100644
--- a/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalUnit.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/temporal/TemporalUnit.scala
@@ -40,14 +40,15 @@ import org.threeten.bp.Duration
  * Implementations of this interface represent those units.
  *
  * An instance of this interface represents the unit itself, rather than an amount of the unit. See
- * {@link Period} for a class that represents an amount in terms of the common units.
+ * {@@linkPeriod} for a class that represents an amount in terms of the common units.
  *
- * The most commonly used units are defined in {@link ChronoUnit}. Further units are supplied in
- * {@link IsoFields}. Units can also be written by application code by implementing this interface.
+ * The most commonly used units are defined in {@@linkChronoUnit} . Further units are supplied in
+ * {@@linkIsoFields} . Units can also be written by application code by implementing this interface.
  *
  * The unit works using double dispatch. Client code calls methods on a date-time like {@code
- * LocalDateTime} which check if the unit is a {@code ChronoUnit}. If it is, then the date-time must
- * handle it. Otherwise, the method call is re-dispatched to the matching method in this interface.
+ * LocalDateTime} which check if the unit is a {@@codeChronoUnit} . If it is, then the date-time
+ * must handle it. Otherwise, the method call is re-dispatched to the matching method in this
+ * interface.
  *
  * <h3>Specification for implementors</h3> This interface must be implemented with care to ensure
  * other classes operate correctly. All implementations that can be instantiated must be final,
@@ -64,7 +65,7 @@ trait TemporalUnit {
    *
    * Some units may return an accurate duration while others return an estimate. For example, days
    * have an estimated duration due to the possibility of daylight saving time changes. To determine
-   * if the duration is an estimate, use {@link #isDurationEstimated()}.
+   * if the duration is an estimate, use {@@link#isDurationEstimated()} .
    *
    * @return
    *   the duration of this unit, which may be an estimate, not null
@@ -121,14 +122,14 @@ trait TemporalUnit {
    * and the period "3". The period to be added may be negative, which is equivalent to subtraction.
    *
    * There are two equivalent ways of using this method. The first is to invoke this method
-   * directly. The second is to use {@link Temporal#plus(long, TemporalUnit)}: <pre> // these two
+   * directly. The second is to use {@@linkTemporal#plus(long, TemporalUnit)} : <pre> // these two
    * lines are equivalent, but the second approach is recommended temporal =
    * thisUnit.doPlus(temporal); temporal = temporal.plus(thisUnit); </pre> It is recommended to use
-   * the second approach, {@code plus(TemporalUnit)}, as it is a lot clearer to read in code.
+   * the second approach, {@@codeplus(TemporalUnit)} , as it is a lot clearer to read in code.
    *
    * Implementations should perform any queries or calculations using the units available in {@link
-   * ChronoUnit} or the fields available in {@link ChronoField}. If the field is not supported a
-   * {@code DateTimeException} must be thrown.
+   * ChronoUnit} or the fields available in {@@linkChronoField} . If the field is not supported a
+   * {@@codeDateTimeException} must be thrown.
    *
    * Implementations must not alter the specified temporal object. Instead, an adjusted copy of the
    * original must be returned. This provides equivalent, safe behavior for immutable and mutable
@@ -153,21 +154,21 @@ trait TemporalUnit {
    * This calculates the period between two temporals in terms of this unit. The start and end
    * points are supplied as temporal objects and must be of the same type. The result will be
    * negative if the end is before the start. For example, the period in hours between two temporal
-   * objects can be calculated using {@code HOURS.between(startTime, endTime)}.
+   * objects can be calculated using {@@codeHOURS.between(startTime, endTime)} .
    *
    * The calculation returns a whole number, representing the number of complete units between the
    * two temporals. For example, the period in hours between the times 11:30 and 13:29 will only b
    * one hour as it is one minute short of two hours.
    *
    * There are two equivalent ways of using this method. The first is to invoke this method
-   * directly. The second is to use {@link Temporal#until(Temporal, TemporalUnit)}: <pre> // these
+   * directly. The second is to use {@@linkTemporal#until(Temporal, TemporalUnit)} : <pre> // these
    * two lines are equivalent between = thisUnit.between(start, end); between = start.until(end,
    * thisUnit); </pre> The choice should be made based on which makes the code more readable.
    *
    * For example, this method allows the number of days between two dates to be calculated: <pre>
    * long daysBetween = DAYS.between(start, end); // or alternatively long daysBetween =
    * start.until(end, DAYS); </pre> Implementations should perform any queries or calculations using
-   * the units available in {@link ChronoUnit} or the fields available in {@link ChronoField}. If
+   * the units available in {@@linkChronoUnit} or the fields available in {@@linkChronoField} . If
    * the unit is not supported a DateTimeException must be thrown. Implementations must not alter
    * the specified temporal objects.
    *
@@ -186,7 +187,7 @@ trait TemporalUnit {
   def between(temporal1: Temporal, temporal2: Temporal): Long
 
   /**
-   * Outputs this unit as a {@code String} using the name.
+   * Outputs this unit as a {@@codeString} using the name.
    *
    * @return
    *   the name of this unit, not null
diff --git a/core/shared/src/main/scala/org/threeten/bp/temporal/ValueRange.scala b/core/shared/src/main/scala/org/threeten/bp/temporal/ValueRange.scala
index 826ee97c1..00b0cb8af 100644
--- a/core/shared/src/main/scala/org/threeten/bp/temporal/ValueRange.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/temporal/ValueRange.scala
@@ -114,7 +114,7 @@ object ValueRange {
 /**
  * The range of valid values for a date-time field.
  *
- * All {@link TemporalField} instances have a valid range of values. For example, the ISO
+ * All {@@linkTemporalField} instances have a valid range of values. For example, the ISO
  * day-of-month runs from 1 to somewhere between 28 and 31. This class captures that valid range.
  *
  * It is important to be aware of the limitations of this class. Only the minimum and maximum values
@@ -199,18 +199,18 @@ final class ValueRange private (
   def getMaximum: Long = maxLargest
 
   /**
-   * Checks if all values in the range fit in an {@code int}.
+   * Checks if all values in the range fit in an {@@codeint} .
    *
-   * This checks that all valid values are within the bounds of an {@code int}.
+   * This checks that all valid values are within the bounds of an {@@codeint} .
    *
-   * For example, the ISO month-of-year has values from 1 to 12, which fits in an {@code int}. By
+   * For example, the ISO month-of-year has values from 1 to 12, which fits in an {@@codeint} . By
    * comparison, ISO nano-of-day runs from 1 to 86,400,000,000,000 which does not fit in an {@code
    * int}.
    *
-   * This implementation uses {@link #getMinimum()} and {@link #getMaximum()}.
+   * This implementation uses {@@link#getMinimum()} and {@@link#getMaximum()} .
    *
    * @return
-   *   true if a valid value always fits in an { @code int}
+   *   true if a valid value always fits in an {@@codeint}
    */
   def isIntValue: Boolean = getMinimum >= Int.MinValue && getMaximum <= Int.MaxValue
 
@@ -230,12 +230,12 @@ final class ValueRange private (
    * Checks if the value is within the valid range and that all values in the range fit in an {@code
    * int}.
    *
-   * This method combines {@link #isIntValue()} and {@link #isValidValue(long)}.
+   * This method combines {@@link#isIntValue()} and {@@link#isValidValue(long)} .
    *
    * @param value
    *   the value to check
    * @return
-   *   true if the value is valid and fits in an { @code int}
+   *   true if the value is valid and fits in an {@@codeint}
    */
   def isValidIntValue(value: Long): Boolean = isIntValue && isValidValue(value)
 
@@ -263,10 +263,10 @@ final class ValueRange private (
       value
 
   /**
-   * Checks that the specified value is valid and fits in an {@code int}.
+   * Checks that the specified value is valid and fits in an {@@codeint} .
    *
    * This validates that the value is within the valid range of values and that all valid values are
-   * within the bounds of an {@code int}. The field is only used to improve the error message.
+   * within the bounds of an {@@codeint} . The field is only used to improve the error message.
    *
    * @param value
    *   the value to check
@@ -286,7 +286,7 @@ final class ValueRange private (
    * Checks if this range is equal to another range.
    *
    * The comparison is based on the four values, minimum, largest minimum, smallest maximum and
-   * maximum. Only objects of type {@code ValueRange} are compared, other types return false.
+   * maximum. Only objects of type {@@codeValueRange} are compared, other types return false.
    *
    * @param obj
    *   the object to check, null returns false
@@ -314,7 +314,7 @@ final class ValueRange private (
   }
 
   /**
-   * Outputs this range as a {@code String}.
+   * Outputs this range as a {@@codeString} .
    *
    * The format will be '{min}/{largestMin} - {smallestMax}/{max}', where the largestMin or
    * smallestMax sections may be omitted, together with associated slash, if they are the same as
diff --git a/core/shared/src/main/scala/org/threeten/bp/temporal/WeekFields.scala b/core/shared/src/main/scala/org/threeten/bp/temporal/WeekFields.scala
index 4d9c4acb1..bdc0f5b61 100644
--- a/core/shared/src/main/scala/org/threeten/bp/temporal/WeekFields.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/temporal/WeekFields.scala
@@ -84,7 +84,7 @@ object WeekFields {
   lazy val SUNDAY_START: WeekFields = WeekFields.of(DayOfWeek.SUNDAY, 1)
 
   /**
-   * Obtains an instance of {@code WeekFields} appropriate for a locale.
+   * Obtains an instance of {@@codeWeekFields} appropriate for a locale.
    *
    * This will look up appropriate values from the provider of localization data.
    *
@@ -104,16 +104,16 @@ object WeekFields {
   }
 
   /**
-   * Obtains an instance of {@code WeekFields} from the first day-of-week and minimal days.
+   * Obtains an instance of {@@codeWeekFields} from the first day-of-week and minimal days.
    *
-   * The first day-of-week defines the ISO {@code DayOfWeek} that is day 1 of the week. The minimal
+   * The first day-of-week defines the ISO {@@codeDayOfWeek} that is day 1 of the week. The minimal
    * number of days in the first week defines how many days must be present in a month or year,
    * starting from the first day-of-week, before the week is counted as the first week. A value of 1
    * will count the first day of the month or year as part of the first week, whereas a value of 7
    * will require the whole seven days to be in the new month or year.
    *
-   * WeekFields instances are singletons; for each unique combination of {@code firstDayOfWeek} and
-   * {@code minimalDaysInFirstWeek} the the same instance will be returned.
+   * WeekFields instances are singletons; for each unique combination of {@@codefirstDayOfWeek} and
+   * {@@codeminimalDaysInFirstWeek} the the same instance will be returned.
    *
    * @param firstDayOfWeek
    *   the first day of the week, not null
@@ -327,7 +327,7 @@ object WeekFields {
      * Returns the week number computed from the reference day and reference dayOfWeek.
      *
      * @param offset
-     *   the offset to align a date with the start of week from { @link #startOfWeekOffset}.
+     *   the offset to align a date with the start of week from {@@link#startOfWeekOffset} .
      * @param day
      *   the day for which to compute the week number
      * @return
@@ -555,16 +555,16 @@ object WeekFields {
  *
  * A standard week is seven days long, but cultures have different definitions for some other
  * aspects of a week. This class represents the definition of the week, for the purpose of providing
- * {@link TemporalField} instances.
+ * {@@linkTemporalField} instances.
  *
- * WeekFields provides three fields, {@link #dayOfWeek()}, {@link #weekOfMonth()}, and {@link
- * #weekOfYear()} that provide access to the values from any {@link Temporal temporal object}.
+ * WeekFields provides three fields, {@@link#dayOfWeek()} , {@@link#weekOfMonth()} , and {@link
+ * #weekOfYear()} that provide access to the values from any {@@linkTemporal temporal object} .
  *
  * The computations for day-of-week, week-of-month, and week-of-year are based on the {@link
- * ChronoField#YEAR proleptic-year}, {@link ChronoField#MONTH_OF_YEAR month-of-year}, {@link
- * ChronoField#DAY_OF_MONTH day-of-month}, and {@link ChronoField#DAY_OF_WEEK ISO day-of-week} which
- * are based on the {@link ChronoField#EPOCH_DAY epoch-day} and the chronology. The values may not
- * be aligned with the {@link ChronoField#YEAR_OF_ERA year-of-Era} depending on the Chronology. A
+ * ChronoField#YEAR proleptic-year}, {@@linkChronoField#MONTH_OF_YEAR month-of-year} , {@link
+ * ChronoField#DAY_OF_MONTH day-of-month}, and {@@linkChronoField#DAY_OF_WEEK ISO day-of-week} which
+ * are based on the {@@linkChronoField#EPOCH_DAY epoch-day} and the chronology. The values may not
+ * be aligned with the {@@linkChronoField#YEAR_OF_ERA year-of-Era} depending on the Chronology. A
  * week is defined by: <ul> <li>The first day-of-week. For example, the ISO-8601 standard considers
  * Monday to be the first day-of-week. <li>The minimal number of days in the first week. For
  * example, the ISO-8601 standard counts the first week as needing at least 4 days. </ul><p>
@@ -609,17 +609,17 @@ final class WeekFields private (private val firstDayOfWeek: DayOfWeek, private v
     throw new IllegalArgumentException("Minimal number of days is invalid")
 
   /**
-   * Returns a field to access the day of week based on this {@code WeekFields}.
+   * Returns a field to access the day of week based on this {@@codeWeekFields} .
    *
-   * This is similar to {@link ChronoField#DAY_OF_WEEK} but uses values for the day-of-week based on
-   * this {@code WeekFields}. The days are numbered from 1 to 7 where the {@link
+   * This is similar to {@@linkChronoField#DAY_OF_WEEK} but uses values for the day-of-week based on
+   * this {@@codeWeekFields} . The days are numbered from 1 to 7 where the {@link
    * #getFirstDayOfWeek() first day-of-week} is assigned the value 1.
    *
    * For example, if the first day-of-week is Sunday, then that will have the value 1, with other
    * days ranging from Monday as 2 to Saturday as 7.
    *
    * In the resolving phase of parsing, a localized day-of-week will be converted to a standardized
-   * {@code ChronoField} day-of-week. The day-of-week must be in the valid range 1 to 7. Other
+   * {@@codeChronoField} day-of-week. The day-of-week must be in the valid range 1 to 7. Other
    * fields in this class build dates using the standardized day-of-week.
    *
    * @return
@@ -629,14 +629,14 @@ final class WeekFields private (private val firstDayOfWeek: DayOfWeek, private v
   val dayOfWeek: TemporalField = WeekFields.ComputedDayOfField.ofDayOfWeekField(this)
 
   /**
-   * Returns a field to access the week of month based on this {@code WeekFields}.
+   * Returns a field to access the week of month based on this {@@codeWeekFields} .
    *
    * This represents the concept of the count of weeks within the month where weeks start on a fixed
-   * day-of-week, such as Monday. This field is typically used with {@link WeekFields#dayOfWeek()}.
+   * day-of-week, such as Monday. This field is typically used with {@@linkWeekFields#dayOfWeek()} .
    *
-   * Week one (1) is the week starting on the {@link WeekFields#getFirstDayOfWeek} where there are
-   * at least {@link WeekFields#getMinimalDaysInFirstWeek()} days in the month. Thus, week one may
-   * start up to {@code minDays} days before the start of the month. If the first week starts after
+   * Week one (1) is the week starting on the {@@linkWeekFields#getFirstDayOfWeek} where there are
+   * at least {@@linkWeekFields#getMinimalDaysInFirstWeek()} days in the month. Thus, week one may
+   * start up to {@@codeminDays} days before the start of the month. If the first week starts after
    * the start of the month then the period before is week zero (0).
    *
    * For example:<br>
@@ -654,15 +654,15 @@ final class WeekFields private (private val firstDayOfWeek: DayOfWeek, private v
    * In the resolving phase of parsing, a date can be created from a year, week-of-month,
    * month-of-year and day-of-week.
    *
-   * In {@linkplain ResolverStyle#STRICT strict mode}, all four fields are validated against their
+   * In {@@linkplainResolverStyle#STRICT strict mode} , all four fields are validated against their
    * range of valid values. The week-of-month field is validated to ensure that the resulting month
    * is the month requested.
    *
-   * In {@linkplain ResolverStyle#SMART smart mode}, all four fields are validated against their
+   * In {@@linkplainResolverStyle#SMART smart mode} , all four fields are validated against their
    * range of valid values. The week-of-month field is validated from 0 to 6, meaning that the
    * resulting date can be in a different month to that specified.
    *
-   * In {@linkplain ResolverStyle#LENIENT lenient mode}, the year and day-of-week are validated
+   * In {@@linkplainResolverStyle#LENIENT lenient mode} , the year and day-of-week are validated
    * against the range of valid values. The resulting date is calculated equivalent to the following
    * four stage approach. First, create a date on the first day of the first week of January in the
    * requested year. Then take the month-of-year, subtract one, and add the amount in months to the
@@ -676,14 +676,14 @@ final class WeekFields private (private val firstDayOfWeek: DayOfWeek, private v
   val weekOfMonth: TemporalField = WeekFields.ComputedDayOfField.ofWeekOfMonthField(this)
 
   /**
-   * Returns a field to access the week of year based on this {@code WeekFields}.
+   * Returns a field to access the week of year based on this {@@codeWeekFields} .
    *
    * This represents the concept of the count of weeks within the year where weeks start on a fixed
-   * day-of-week, such as Monday. This field is typically used with {@link WeekFields#dayOfWeek()}.
+   * day-of-week, such as Monday. This field is typically used with {@@linkWeekFields#dayOfWeek()} .
    *
-   * Week one(1) is the week starting on the {@link WeekFields#getFirstDayOfWeek} where there are at
-   * least {@link WeekFields#getMinimalDaysInFirstWeek()} days in the year. Thus, week one may start
-   * up to {@code minDays} days before the start of the year. If the first week starts after the
+   * Week one(1) is the week starting on the {@@linkWeekFields#getFirstDayOfWeek} where there are at
+   * least {@@linkWeekFields#getMinimalDaysInFirstWeek()} days in the year. Thus, week one may start
+   * up to {@@codeminDays} days before the start of the year. If the first week starts after the
    * start of the year then the period before is week zero (0).
    *
    * For example:<br>
@@ -701,15 +701,15 @@ final class WeekFields private (private val firstDayOfWeek: DayOfWeek, private v
    * In the resolving phase of parsing, a date can be created from a year, week-of-year and
    * day-of-week.
    *
-   * In {@linkplain ResolverStyle#STRICT strict mode}, all three fields are validated against their
+   * In {@@linkplainResolverStyle#STRICT strict mode} , all three fields are validated against their
    * range of valid values. The week-of-year field is validated to ensure that the resulting year is
    * the year requested.
    *
-   * In {@linkplain ResolverStyle#SMART smart mode}, all three fields are validated against their
+   * In {@@linkplainResolverStyle#SMART smart mode} , all three fields are validated against their
    * range of valid values. The week-of-year field is validated from 0 to 54, meaning that the
    * resulting date can be in a different year to that specified.
    *
-   * In {@linkplain ResolverStyle#LENIENT lenient mode}, the year and day-of-week are validated
+   * In {@@linkplainResolverStyle#LENIENT lenient mode} , the year and day-of-week are validated
    * against the range of valid values. The resulting date is calculated equivalent to the following
    * three stage approach. First, create a date on the first day of the first week in the requested
    * year. Then take the week-of-year, subtract one, and add the amount in weeks to the date.
@@ -722,14 +722,14 @@ final class WeekFields private (private val firstDayOfWeek: DayOfWeek, private v
   val weekOfYear: TemporalField = WeekFields.ComputedDayOfField.ofWeekOfYearField(this)
 
   /**
-   * Returns a field to access the week of a week-based-year based on this {@code WeekFields}.
+   * Returns a field to access the week of a week-based-year based on this {@@codeWeekFields} .
    *
    * This represents the concept of the count of weeks within the year where weeks start on a fixed
    * day-of-week, such as Monday and each week belongs to exactly one year. This field is typically
-   * used with {@link WeekFields#dayOfWeek()} and {@link WeekFields#weekBasedYear()}.
+   * used with {@@linkWeekFields#dayOfWeek()} and {@@linkWeekFields#weekBasedYear()} .
    *
-   * Week one(1) is the week starting on the {@link WeekFields#getFirstDayOfWeek} where there are at
-   * least {@link WeekFields#getMinimalDaysInFirstWeek()} days in the year. If the first week starts
+   * Week one(1) is the week starting on the {@@linkWeekFields#getFirstDayOfWeek} where there are at
+   * least {@@linkWeekFields#getMinimalDaysInFirstWeek()} days in the year. If the first week starts
    * after the start of the year then the period before is in the last week of the previous year.
    *
    * For example:<br>
@@ -746,15 +746,15 @@ final class WeekFields private (private val firstDayOfWeek: DayOfWeek, private v
    * In the resolving phase of parsing, a date can be created from a week-based-year, week-of-year
    * and day-of-week.
    *
-   * In {@linkplain ResolverStyle#STRICT strict mode}, all three fields are validated against their
+   * In {@@linkplainResolverStyle#STRICT strict mode} , all three fields are validated against their
    * range of valid values. The week-of-year field is validated to ensure that the resulting
    * week-based-year is the week-based-year requested.
    *
-   * In {@linkplain ResolverStyle#SMART smart mode}, all three fields are validated against their
+   * In {@@linkplainResolverStyle#SMART smart mode} , all three fields are validated against their
    * range of valid values. The week-of-week-based-year field is validated from 1 to 53, meaning
    * that the resulting date can be in the following week-based-year to that specified.
    *
-   * In {@linkplain ResolverStyle#LENIENT lenient mode}, the year and day-of-week are validated
+   * In {@@linkplainResolverStyle#LENIENT lenient mode} , the year and day-of-week are validated
    * against the range of valid values. The resulting date is calculated equivalent to the following
    * three stage approach. First, create a date on the first day of the first week in the requested
    * week-based-year. Then take the week-of-week-based-year, subtract one, and add the amount in
@@ -768,14 +768,14 @@ final class WeekFields private (private val firstDayOfWeek: DayOfWeek, private v
     WeekFields.ComputedDayOfField.ofWeekOfWeekBasedYearField(this)
 
   /**
-   * Returns a field to access the year of a week-based-year based on this {@code WeekFields}.
+   * Returns a field to access the year of a week-based-year based on this {@@codeWeekFields} .
    *
    * This represents the concept of the year where weeks start on a fixed day-of-week, such as
    * Monday and each week belongs to exactly one year. This field is typically used with {@link
-   * WeekFields#dayOfWeek()} and {@link WeekFields#weekOfWeekBasedYear()}.
+   * WeekFields#dayOfWeek()} and {@@linkWeekFields#weekOfWeekBasedYear()} .
    *
-   * Week one(1) is the week starting on the {@link WeekFields#getFirstDayOfWeek} where there are at
-   * least {@link WeekFields#getMinimalDaysInFirstWeek()} days in the year. Thus, week one may start
+   * Week one(1) is the week starting on the {@@linkWeekFields#getFirstDayOfWeek} where there are at
+   * least {@@linkWeekFields#getMinimalDaysInFirstWeek()} days in the year. Thus, week one may start
    * before the start of the year. If the first week starts after the start of the year then the
    * period before is in the last week of the previous year.
    *
@@ -784,15 +784,15 @@ final class WeekFields private (private val firstDayOfWeek: DayOfWeek, private v
    * In the resolving phase of parsing, a date can be created from a week-based-year, week-of-year
    * and day-of-week.
    *
-   * In {@linkplain ResolverStyle#STRICT strict mode}, all three fields are validated against their
+   * In {@@linkplainResolverStyle#STRICT strict mode} , all three fields are validated against their
    * range of valid values. The week-of-year field is validated to ensure that the resulting
    * week-based-year is the week-based-year requested.
    *
-   * In {@linkplain ResolverStyle#SMART smart mode}, all three fields are validated against their
+   * In {@@linkplainResolverStyle#SMART smart mode} , all three fields are validated against their
    * range of valid values. The week-of-week-based-year field is validated from 1 to 53, meaning
    * that the resulting date can be in the following week-based-year to that specified.
    *
-   * In {@linkplain ResolverStyle#LENIENT lenient mode}, the year and day-of-week are validated
+   * In {@@linkplainResolverStyle#LENIENT lenient mode} , the year and day-of-week are validated
    * against the range of valid values. The resulting date is calculated equivalent to the following
    * three stage approach. First, create a date on the first day of the first week in the requested
    * week-based-year. Then take the week-of-week-based-year, subtract one, and add the amount in
@@ -829,7 +829,7 @@ final class WeekFields private (private val firstDayOfWeek: DayOfWeek, private v
   def getMinimalDaysInFirstWeek: Int = minimalDays
 
   /**
-   * Checks if this {@code WeekFields} is equal to the specified object.
+   * Checks if this {@@codeWeekFields} is equal to the specified object.
    *
    * The comparison is based on the entire state of the rules, which is the first day-of-week and
    * minimal days.
@@ -846,7 +846,7 @@ final class WeekFields private (private val firstDayOfWeek: DayOfWeek, private v
     }
 
   /**
-   * A hash code for this {@code WeekFields}.
+   * A hash code for this {@@codeWeekFields} .
    *
    * @return
    *   a suitable hash code
@@ -854,7 +854,7 @@ final class WeekFields private (private val firstDayOfWeek: DayOfWeek, private v
   override def hashCode: Int = firstDayOfWeek.ordinal * 7 + minimalDays
 
   /**
-   * A string representation of this {@code WeekFields} instance.
+   * A string representation of this {@@codeWeekFields} instance.
    *
    * @return
    *   the string representation, not null
diff --git a/core/shared/src/main/scala/org/threeten/bp/temporal/package.scala b/core/shared/src/main/scala/org/threeten/bp/temporal/package.scala
index 9c35a1235..40c17df4e 100644
--- a/core/shared/src/main/scala/org/threeten/bp/temporal/package.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/temporal/package.scala
@@ -52,31 +52,31 @@ package org.threeten.bp
  * to add their own units.
  *
  * A field is used to express part of a larger date-time, such as year, month-of-year or
- * second-of-minute. All fields implement {@link org.threeten.bp.temporal.TemporalField}. The set of
- * well known fields are defined in {@link org.threeten.bp.temporal.ChronoField}, for example,
- * {@link org.threeten.bp.temporal.ChronoField#HOUR_OF_DAY}. An additional fields are defined by
- * {@link org.threeten.bp.temporal.JulianFields}. The field interface is designed to allow
+ * second-of-minute. All fields implement {@@linkorg.threeten.bp.temporal.TemporalField} . The set
+ * of well known fields are defined in {@@linkorg.threeten.bp.temporal.ChronoField} , for example,
+ * {@@linkorg.threeten.bp.temporal.ChronoField#HOUR_OF_DAY} . An additional fields are defined by
+ * {@@linkorg.threeten.bp.temporal.JulianFields} . The field interface is designed to allow
  * applications to add their own fields.
  *
  * This package provides tools that allow the units and fields of date and time to be accessed in a
- * general way most suited for frameworks. {@link org.threeten.bp.temporal.Temporal} provides the
+ * general way most suited for frameworks. {@@linkorg.threeten.bp.temporal.Temporal} provides the
  * abstraction for date time types that support fields. Its methods support getting the value of a
  * field, creating a new date time with the value of a field modified, and extracting another date
  * time type, typically used to extract the offset or time-zone.
  *
  * One use of fields in application code is to retrieve fields for which there is no convenience
  * method. For example, getting the day-of-month is common enough that there is a method on {@code
- * LocalDate} called {@code getDayOfMonth()}. However for more unusual fields it is necessary to use
- * the field. For example, {@code date.get(ChronoField.ALIGNED_WEEK_OF_MONTH)}. The fields also
+ * LocalDate} called {@@codegetDayOfMonth()} . However for more unusual fields it is necessary to
+ * use the field. For example, {@@codedate.get(ChronoField.ALIGNED_WEEK_OF_MONTH)} . The fields also
  * provide access to the range of valid values.
  *
  * ==Adjustment==
  *
  * A key part of the date-time problem space is adjusting a date to a new, related value, such as
  * the "last day of the month", or "next Wednesday". These are modeled as functions that adjust a
- * base date-time. The functions implement {@link org.threeten.bp.temporal.TemporalAdjuster} and
- * operate on {@link org.threeten.bp.temporal.Temporal}. A set of common functions are provided in
- * {@link org.threeten.bp.temporal.TemporalAdjusters}. For example, to find the first occurrence of
+ * base date-time. The functions implement {@@linkorg.threeten.bp.temporal.TemporalAdjuster} and
+ * operate on {@@linkorg.threeten.bp.temporal.Temporal} . A set of common functions are provided in
+ * {@@linkorg.threeten.bp.temporal.TemporalAdjusters} . For example, to find the first occurrence of
  * a day-of-week after a given date, use {@link
  * org.threeten.bp.temporal.TemporalAdjusters#next(DayOfWeek)}, such as {@code
  * date.with(next(MONDAY))}.
diff --git a/core/shared/src/main/scala/org/threeten/bp/zone/ZoneOffsetTransition.scala b/core/shared/src/main/scala/org/threeten/bp/zone/ZoneOffsetTransition.scala
index 0db7ee578..e86ca764f 100644
--- a/core/shared/src/main/scala/org/threeten/bp/zone/ZoneOffsetTransition.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/zone/ZoneOffsetTransition.scala
@@ -42,16 +42,16 @@ import org.threeten.bp.ZoneOffset
  * A transition between two offsets caused by a discontinuity in the local time-line.
  *
  * A transition between two offsets is normally the result of a daylight savings cutover. The
- * discontinuity is normally a gap in spring and an overlap in autumn. {@code ZoneOffsetTransition}
+ * discontinuity is normally a gap in spring and an overlap in autumn. {@@codeZoneOffsetTransition}
  * models the transition between the two offsets.
  *
  * Gaps occur where there are local date-times that simply do not not exist. An example would be
- * when the offset changes from {@code +03:00} to {@code +04:00}. This might be described as 'the
+ * when the offset changes from {@@code+03:00} to {@@code+04:00} . This might be described as 'the
  * clocks will move forward one hour tonight at 1am'.
  *
  * Overlaps occur where there are local date-times that exist twice. An example would be when the
- * offset changes from {@code +04:00} to {@code +03:00}. This might be described as 'the clocks will
- * move back one hour tonight at 2am'.
+ * offset changes from {@@code+04:00} to {@@code+03:00} . This might be described as 'the clocks
+ * will move back one hour tonight at 2am'.
  *
  * <h3>Specification for implementors</h3> This class is immutable and thread-safe.
  */
@@ -60,8 +60,8 @@ object ZoneOffsetTransition {
   /**
    * Obtains an instance defining a transition between two offsets.
    *
-   * Applications should normally obtain an instance from {@link ZoneRules}. This factory is only
-   * intended for use when creating {@link ZoneRules}.
+   * Applications should normally obtain an instance from {@@linkZoneRules} . This factory is only
+   * intended for use when creating {@@linkZoneRules} .
    *
    * @param transition
    *   the transition date-time at the transition, which never actually occurs, expressed local to
@@ -73,7 +73,7 @@ object ZoneOffsetTransition {
    * @return
    *   the transition, not null
    * @throws IllegalArgumentException
-   *   if { @code offsetBefore} and { @code offsetAfter} are equal, or { @code transition.getNano()}
+   *   if {@@codeoffsetBefore} and {@@codeoffsetAfter} are equal, or {@@codetransition.getNano()}
    *   returns non-zero value
    */
   def of(
@@ -129,8 +129,8 @@ final class ZoneOffsetTransition private[zone] (
    * This is the instant of the discontinuity, which is defined as the first instant that the
    * 'after' offset applies.
    *
-   * The methods {@link #getInstant()}, {@link #getDateTimeBefore()} and {@link #getDateTimeAfter()}
-   * all represent the same instant.
+   * The methods {@@link#getInstant()} , {@@link#getDateTimeBefore()} and
+   * {@@link#getDateTimeAfter()} all represent the same instant.
    *
    * @return
    *   the transition instant, not null
@@ -218,7 +218,7 @@ final class ZoneOffsetTransition private[zone] (
    * Does this transition represent a gap in the local time-line.
    *
    * Gaps occur where there are local date-times that simply do not not exist. An example would be
-   * when the offset changes from {@code +01:00} to {@code +02:00}. This might be described as 'the
+   * when the offset changes from {@@code+01:00} to {@@code+02:00} . This might be described as 'the
    * clocks will move forward one hour tonight at 1am'.
    *
    * @return
@@ -230,7 +230,7 @@ final class ZoneOffsetTransition private[zone] (
    * Does this transition represent a gap in the local time-line.
    *
    * Overlaps occur where there are local date-times that exist twice. An example would be when the
-   * offset changes from {@code +02:00} to {@code +01:00}. This might be described as 'the clocks
+   * offset changes from {@@code+02:00} to {@@code+01:00} . This might be described as 'the clocks
    * will move back one hour tonight at 2am'.
    *
    * @return
diff --git a/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRules.scala b/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRules.scala
index f5bd3dc8b..f81da311c 100644
--- a/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRules.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRules.scala
@@ -46,10 +46,10 @@ import org.threeten.bp.ZoneOffset
  * ZoneOffsetTransitionRule} is used for future transitions that are based on the result of an
  * algorithm.
  *
- * The rules are loaded via {@link ZoneRulesProvider} using a {@link ZoneId}. The same rules may be
+ * The rules are loaded via {@@linkZoneRulesProvider} using a {@@linkZoneId} . The same rules may be
  * shared internally between multiple zone IDs.
  *
- * Serializing an instance of {@code ZoneRules} will store the entire set of rules. It does not
+ * Serializing an instance of {@@codeZoneRules} will store the entire set of rules. It does not
  * store the zone ID as it is not part of the state of this object.
  *
  * A rule implementation may or may not store full information about historic and future
@@ -63,7 +63,7 @@ import org.threeten.bp.ZoneOffset
 object ZoneRules {
 
   /**
-   * Obtains an instance of {@code ZoneRules} with full transition rules.
+   * Obtains an instance of {@@codeZoneRules} with full transition rules.
    *
    * @param baseStandardOffset
    *   the standard offset to use before legal rules were set, not null
@@ -99,7 +99,7 @@ object ZoneRules {
   }
 
   /**
-   * Obtains an instance of {@code ZoneRules} that always uses the same offset.
+   * Obtains an instance of {@@codeZoneRules} that always uses the same offset.
    *
    * The returned rules always have the same offset.
    *
@@ -211,8 +211,8 @@ abstract class ZoneRules private[zone] () {
    *
    * Since, in the case of Gap and Overlap, the offset returned is a "best" value, rather than the
    * "correct" value, it should be treated with care. Applications that care about the correct
-   * offset should use a combination of this method, {@link #getValidOffsets(LocalDateTime)} and
-   * {@link #getTransition(LocalDateTime)}.
+   * offset should use a combination of this method, {@@link#getValidOffsets(LocalDateTime)} and
+   * {@@link#getTransition(LocalDateTime)} .
    *
    * @param localDateTime
    *   the local date-time to query, not null, but null may be ignored if the rules have a single
@@ -237,7 +237,7 @@ abstract class ZoneRules private[zone] () {
    * offsets, which is a list of size 0, 1 or 2. In the case where there are two offsets, the
    * earlier offset is returned at index 0 and the later offset at index 1.
    *
-   * There are various ways to handle the conversion from a {@code LocalDateTime}. One technique,
+   * There are various ways to handle the conversion from a {@@codeLocalDateTime} . One technique,
    * using this method, would be: <pre> List<ZoneOffset> validOffsets = rules.getOffset(localDT); if
    * (validOffsets.size() == 1) { // Normal case: only one valid offset zoneOffset =
    * validOffsets.get(0); } else { // Gap or Overlap: determine what to do from transition (which
@@ -269,7 +269,7 @@ abstract class ZoneRules private[zone] () {
    * local date-time values with two valid offsets.</li> </ul><p> A transition is used to model the
    * cases of a Gap or Overlap. The Normal case will return null.
    *
-   * There are various ways to handle the conversion from a {@code LocalDateTime}. One technique,
+   * There are various ways to handle the conversion from a {@@codeLocalDateTime} . One technique,
    * using this method, would be: <pre> ZoneOffsetTransition trans = rules.getTransition(localDT);
    * if (trans == null) { // Gap or Overlap: determine what to do from transition } else { // Normal
    * case: only one valid offset zoneOffset = rule.getOffset(localDT); } </pre>
@@ -392,12 +392,12 @@ abstract class ZoneRules private[zone] () {
    * Gets the list of transition rules for years beyond those defined in the transition list.
    *
    * The complete set of transitions for this rules instance is defined by this method and {@link
-   * #getTransitions()}. This method returns instances of {@link ZoneOffsetTransitionRule} that
+   * #getTransitions()}. This method returns instances of {@@linkZoneOffsetTransitionRule} that
    * define an algorithm for when transitions will occur.
    *
-   * For any given {@code ZoneRules}, this list contains the transition rules for years beyond those
-   * years that have been fully defined. These rules typically refer to future daylight saving time
-   * rule changes.
+   * For any given {@@codeZoneRules} , this list contains the transition rules for years beyond
+   * those years that have been fully defined. These rules typically refer to future daylight saving
+   * time rule changes.
    *
    * If the zone defines daylight savings into the future, then the list will normally be of size
    * two and hold information about entering and exiting daylight savings. If the zone does not have
@@ -429,7 +429,7 @@ abstract class ZoneRules private[zone] () {
   override def equals(otherRules: Any): Boolean
 
   /**
-   * Returns a suitable hash code given the definition of {@code #equals}.
+   * Returns a suitable hash code given the definition of {@@code#equals} .
    *
    * @return
    *   the hash code
diff --git a/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRulesBuilder.scala b/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRulesBuilder.scala
index 91cbd3db2..fc0d6c018 100644
--- a/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRulesBuilder.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRulesBuilder.scala
@@ -63,8 +63,8 @@ import org.threeten.bp.chrono.IsoChronology
  * standard offset from UTC/Greenwich will be constant within a window, although two adjacent
  * windows can have the same standard offset.
  *
- * Within each window, there can either be a {@link #setFixedSavingsToWindow fixed savings amount}
- * or a {@link #addRuleToWindow list of rules}.
+ * Within each window, there can either be a {@@link#setFixedSavingsToWindow fixed savings amount}
+ * or a {@@link#addRuleToWindow list of rules} .
  */
 class ZoneRulesBuilder() {
 
@@ -553,7 +553,7 @@ class ZoneRulesBuilder() {
      *   the month of the transition, not null
      * @param dayOfMonthIndicator
      *   the day-of-month of the transition, adjusted by dayOfWeek, from 1 to 31 adjusted later, or
-     * -1 to -28 adjusted earlier from the last day of the month
+     *   -1 to -28 adjusted earlier from the last day of the month
      * @param dayOfWeek
      *   the day-of-week to adjust to, null if day-of-month should not be adjusted
      * @param time
diff --git a/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRulesInitializer.scala b/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRulesInitializer.scala
index 5a40c806c..8dce8f855 100644
--- a/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRulesInitializer.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRulesInitializer.scala
@@ -36,9 +36,9 @@ import java.util.concurrent.atomic.AtomicReference
 
 /**
  * Controls how the time-zone rules are initialized. <p> The default behavior is to use {@link
- * ServiceLoader} to find instances of {@link ZoneRulesProvider}. Use the {@link
+ * ServiceLoader} to find instances of {@@linkZoneRulesProvider} . Use the {@link
  * #setInitializer(ZoneRulesInitializer)} method to replace this behavior. The initializer instance
- * must perform the work of creating the {@code ZoneRulesProvider} within the {@link
+ * must perform the work of creating the {@@codeZoneRulesProvider} within the {@link
  * #initializeProviders()} method to ensure that the provider is not initialized too early. <p>
  * <b>The initializer must be set before class loading of any other ThreeTen-Backport class to have
  * any effect!</b> <p> This class has been added primarily for the benefit of Android.
@@ -49,7 +49,7 @@ abstract class ZoneRulesInitializer {
    * Initialize the providers. <p> The implementation should perform whatever work is necessary to
    * initialize the providers. This will result in one or more calls to {@link
    * ZoneRulesProvider#registerProvider(ZoneRulesProvider)}. <p> It is vital that the instance of
-   * {@link ZoneRulesProvider} is not created until this method is invoked. <p> It is guaranteed
+   * {@@linkZoneRulesProvider} is not created until this method is invoked. <p> It is guaranteed
    * that this method will be invoked once and only once.
    */
   protected def initializeProviders(): Unit
@@ -59,7 +59,7 @@ abstract class ZoneRulesInitializer {
 object ZoneRulesInitializer {
 
   /**
-   * An instance that does nothing. Call {@link #setInitializer(ZoneRulesInitializer)} with this
+   * An instance that does nothing. Call {@@link#setInitializer(ZoneRulesInitializer)} with this
    * instance to block the service loader search. This will leave the system with no providers.
    */
   lazy val DO_NOTHING: ZoneRulesInitializer = new DoNothingZoneRulesInitializer()
@@ -79,7 +79,7 @@ object ZoneRulesInitializer {
   }
 
   /**
-   * Sets the initializer to use. <p> This can only be invoked before the {@link ZoneRulesProvider}
+   * Sets the initializer to use. <p> This can only be invoked before the {@@linkZoneRulesProvider}
    * class is loaded. Invoking this method at a later point will throw an exception.
    *
    * @param initializer
diff --git a/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRulesProvider.scala b/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRulesProvider.scala
index 5aca943c8..9c17cc503 100644
--- a/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRulesProvider.scala
+++ b/core/shared/src/main/scala/org/threeten/bp/zone/ZoneRulesProvider.scala
@@ -49,7 +49,7 @@ object ZoneRulesProvider {
   /**
    * Gets the set of available zone IDs.
    *
-   * These zone IDs are loaded and available for use by {@code ZoneId}.
+   * These zone IDs are loaded and available for use by {@@codeZoneId} .
    *
    * @return
    *   the unmodifiable copy of the set of zone IDs, not null
@@ -62,22 +62,22 @@ object ZoneRulesProvider {
    * This returns the latest available rules for the zone ID.
    *
    * This method relies on time-zone data provider files that are configured. These are loaded using
-   * a {@code ServiceLoader}.
+   * a {@@codeServiceLoader} .
    *
    * The caching flag is designed to allow provider implementations to prevent the rules being
-   * cached in {@code ZoneId}. Under normal circumstances, the caching of zone rules is highly
+   * cached in {@@codeZoneId} . Under normal circumstances, the caching of zone rules is highly
    * desirable as it will provide greater performance. However, there is a use case where the
-   * caching would not be desirable, see {@link #provideRules}.
+   * caching would not be desirable, see {@@link#provideRules} .
    *
    * @param zoneId
-   *   the zone ID as defined by { @code ZoneId}, not null
+   *   the zone ID as defined by {@@codeZoneId} , not null
    * @param forCaching
    *   whether the rules are being queried for caching, true if the returned rules will be cached by
-   *   { @code ZoneId}, false if they will be returned to the user without being cached in { @code
+   *   {@@codeZoneId} , false if they will be returned to the user without being cached in { @code
    *   ZoneId}
    * @return
-   *   the rules, null if { @code forCaching} is true and this is a dynamic provider that wants to
-   *   prevent caching in { @code ZoneId}, otherwise not null
+   *   the rules, null if {@@codeforCaching} is true and this is a dynamic provider that wants to
+   *   prevent caching in {@@codeZoneId} , otherwise not null
    * @throws ZoneRulesException
    *   if rules cannot be obtained for the zone ID
    */
@@ -103,7 +103,7 @@ object ZoneRulesProvider {
    * more than one element if historical rule information is available.
    *
    * @param zoneId
-   *   the zone region ID as used by { @code ZoneId}, not null
+   *   the zone region ID as used by {@@codeZoneId} , not null
    * @return
    *   a modifiable copy of the history of the rules for the ID, sorted from oldest to newest, not
    *   null
@@ -119,7 +119,7 @@ object ZoneRulesProvider {
    * Gets the provider for the zone ID.
    *
    * @param zoneId
-   *   the zone region ID as used by { @code ZoneId}, not null
+   *   the zone region ID as used by {@@codeZoneId} , not null
    * @return
    *   the provider, not null
    * @throws ZoneRulesException
@@ -141,7 +141,7 @@ object ZoneRulesProvider {
    *
    * This adds a new provider to those currently available. A provider supplies rules for one or
    * more zone IDs. A provider cannot be registered if it supplies a zone ID that has already been
-   * registered. See the notes on time-zone IDs in {@link ZoneId}, especially the section on using
+   * registered. See the notes on time-zone IDs in {@@linkZoneId} , especially the section on using
    * the concept of a "group" to make IDs unique.
    *
    * To ensure the integrity of time-zones already created, there is no way to deregister providers.
@@ -214,7 +214,7 @@ object ZoneRulesProvider {
  * API that can be used to manage the providers. The abstract methods provide the SPI that allows
  * rules to be provided.
  *
- * Rules are looked up primarily by zone ID, as used by {@link ZoneId}. Only zone region IDs may be
+ * Rules are looked up primarily by zone ID, as used by {@@linkZoneId} . Only zone region IDs may be
  * used, zone offset IDs are not used here.
  *
  * Time-zone rules are political, thus the data can change at any time. Each provider will provide
@@ -236,7 +236,7 @@ abstract class ZoneRulesProvider protected () {
   /**
    * SPI method to get the available zone IDs.
    *
-   * This obtains the IDs that this {@code ZoneRulesProvider} provides. A provider should provide
+   * This obtains the IDs that this {@@codeZoneRulesProvider} provides. A provider should provide
    * data for at least one region.
    *
    * The returned regions remain available and valid for the lifetime of the application. A dynamic
@@ -281,7 +281,7 @@ abstract class ZoneRulesProvider protected () {
    * provider may increase the set of versions as more data becomes available.
    *
    * @param zoneId
-   *   the zone region ID as used by { @code ZoneId}, not null
+   *   the zone region ID as used by {@@codeZoneId} , not null
    * @return
    *   a modifiable copy of the history of the rules for the ID, sorted from oldest to newest, not
    *   null
diff --git a/tests/shared/src/test/scala/org/threeten/bp/AssertionsHelper.scala b/tests/shared/src/test/scala/org/threeten/bp/AssertionsHelper.scala
index 2961d4963..0b62baf4e 100644
--- a/tests/shared/src/test/scala/org/threeten/bp/AssertionsHelper.scala
+++ b/tests/shared/src/test/scala/org/threeten/bp/AssertionsHelper.scala
@@ -17,27 +17,27 @@ trait AssertionsHelper { this: AnyFunSuite =>
       true
 
   def assertEquals[A, B](
-    o1:                  A,
-    o2:                  B,
-    msg:                 String
+    o1:  A,
+    o2:  B,
+    msg: String
   )(implicit prettifier: Prettifier, pos: source.Position): Assertion =
     assert(o1 == o2, msg)
 
   def assertEquals[A, B](
-    o1:                  A,
-    o2:                  B
+    o1: A,
+    o2: B
   )(implicit prettifier: Prettifier, pos: source.Position): Assertion =
     assert(o1 == o2)
 
   def assertSame[A <: AnyRef, B <: AnyRef](
-    o1:                  A,
-    o2:                  B
+    o1: A,
+    o2: B
   )(implicit prettifier: Prettifier, pos: source.Position): Assertion =
     assert(o1 eq o2)
 
   def assertNotEquals[A, B](
-    o1:                  A,
-    o2:                  B
+    o1: A,
+    o2: B
   )(implicit prettifier: Prettifier, pos: source.Position): Assertion =
     assert(o1 != o2)
 
@@ -51,8 +51,8 @@ trait AssertionsHelper { this: AnyFunSuite =>
     assert(a == null)
 
   def assertNotNull[A](
-    a:                   A,
-    msg:                 String
+    a:   A,
+    msg: String
   )(implicit prettifier: Prettifier, pos: source.Position): Assertion =
     assert(a != null, msg)
 
diff --git a/tests/shared/src/test/scala/org/threeten/bp/GenDateTimeTest.scala b/tests/shared/src/test/scala/org/threeten/bp/GenDateTimeTest.scala
index 06399a4c6..d8de59fa2 100644
--- a/tests/shared/src/test/scala/org/threeten/bp/GenDateTimeTest.scala
+++ b/tests/shared/src/test/scala/org/threeten/bp/GenDateTimeTest.scala
@@ -38,7 +38,7 @@ import org.threeten.bp.temporal.{ TemporalAccessor, TemporalField, TemporalQuery
 trait GenDateTimeTest extends AnyFunSuite with AssertionsHelper {
 
   /**
-   * Sample {@code DateTime} objects.
+   * Sample {@@codeDateTime} objects.
    *
    * @return
    *   the objects, not null
diff --git a/tests/shared/src/test/scala/org/threeten/bp/MockSimplePeriod.scala b/tests/shared/src/test/scala/org/threeten/bp/MockSimplePeriod.scala
index fb35fbcfe..521df8fa4 100644
--- a/tests/shared/src/test/scala/org/threeten/bp/MockSimplePeriod.scala
+++ b/tests/shared/src/test/scala/org/threeten/bp/MockSimplePeriod.scala
@@ -46,7 +46,7 @@ object MockSimplePeriod {
   val ZERO_SECONDS: MockSimplePeriod = new MockSimplePeriod(0, SECONDS)
 
   /**
-   * Obtains a {@code MockSimplePeriod} from an amount and unit. <p> The parameters represent the
+   * Obtains a {@@codeMockSimplePeriod} from an amount and unit. <p> The parameters represent the
    * two parts of a phrase like '6 Days'.
    *
    * @param amount
@@ -54,9 +54,9 @@ object MockSimplePeriod {
    * @param unit
    *   the unit that the period is measured in, must not be the 'Forever' unit, not null
    * @return
-   *   the { @code MockSimplePeriod} instance, not null
+   *   the {@@codeMockSimplePeriod} instance, not null
    * @throws DateTimeException
-   *   if the period unit is { @link org.threeten.bp.temporal.ChronoUnit#FOREVER}.
+   *   if the period unit is {@@linkorg.threeten.bp.temporal.ChronoUnit#FOREVER} .
    */
   def of(amount: Long, unit: TemporalUnit): MockSimplePeriod = new MockSimplePeriod(amount, unit)
 }
diff --git a/tests/shared/src/test/scala/org/threeten/bp/TestInstant.scala b/tests/shared/src/test/scala/org/threeten/bp/TestInstant.scala
index b263dbb18..f7ba88da0 100644
--- a/tests/shared/src/test/scala/org/threeten/bp/TestInstant.scala
+++ b/tests/shared/src/test/scala/org/threeten/bp/TestInstant.scala
@@ -244,27 +244,27 @@ class TestInstant
       List[Long](Long.MaxValue - 1,
                  0,
                  (Long.MaxValue - 1) / 1000,
-                 ((Long.MaxValue - 1) % 1000).toInt * 1000000
+                 ((Long.MaxValue - 1)                                   % 1000).toInt * 1000000
       ),
       List[Long](Long.MinValue,
                  0,
                  (Long.MinValue / 1000) - 1,
-                 (Long.MinValue % 1000).toInt * 1000000 + 1000000000
+                 (Long.MinValue                                         % 1000).toInt * 1000000 + 1000000000
       ),
       List[Long](Long.MinValue,
                  1,
                  (Long.MinValue / 1000) - 1,
-                 (Long.MinValue % 1000).toInt * 1000000 + 1000000000 + 1
+                 (Long.MinValue                                         % 1000).toInt * 1000000 + 1000000000 + 1
       ),
       List[Long](Long.MinValue + 1,
                  0,
                  ((Long.MinValue + 1) / 1000) - 1,
-                 ((Long.MinValue + 1) % 1000).toInt * 1000000 + 1000000000
+                 ((Long.MinValue + 1)                                   % 1000).toInt * 1000000 + 1000000000
       ),
       List[Long](Long.MinValue + 1,
                  1,
                  ((Long.MinValue + 1) / 1000) - 1,
-                 ((Long.MinValue + 1) % 1000).toInt * 1000000 + 1000000000 + 1
+                 ((Long.MinValue + 1)                                   % 1000).toInt * 1000000 + 1000000000 + 1
       )
     )
 
@@ -730,7 +730,7 @@ class TestInstant
            0,
            Long.MinValue,
            Long.MinValue / 1000 - 1,
-           (Long.MinValue % 1000).toInt * 1000000 + 1000000000
+           (Long.MinValue                                            % 1000).toInt * 1000000 + 1000000000
       )
     )
 

From 42d0b70940e479d2bc69369d7e8cf0f9cf119516 Mon Sep 17 00:00:00 2001
From: Scala Steward <scala_steward@virtuslab.com>
Date: Tue, 24 Oct 2023 16:16:34 +0000
Subject: [PATCH 3/3] Add 'Reformat with scalafmt 3.7.15' to
 .git-blame-ignore-revs

---
 .git-blame-ignore-revs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
index f6f1e649e..436f7582c 100644
--- a/.git-blame-ignore-revs
+++ b/.git-blame-ignore-revs
@@ -3,3 +3,6 @@ aa7db3a42121f78a5b3bed3658786c1cef83efe8
 
 # Enable scalafmt for Scala 3
 64df4ae51873593a789af5848bd225c14d0baf8a
+
+# Scala Steward: Reformat with scalafmt 3.7.15
+727b154f7e8509332917dac64d7f604b7f772e14