commit b2f03c74e7f68fa0ebda65c18338ed2e39c6cdcb
author Søren Gjesse <sgjesse@google.com> Wed Mar 19 15:10:23 2025 +0100
committer Søren Gjesse <sgjesse@google.com> Wed Mar 19 15:10:23 2025 +0100
tree 35398969465446bff7083bcfc395ac69361506e8
parent 8e4b20bb006c7af3a888db038223540286df0980

Format Kotlin code in keep annotations with --kotlinlang-style

Keep using --google-style for the rest of the Kotlin code.

Also update the tool for copying keep annotations to androidx with new
source locations.

Bug: b/392865072
Change-Id: I8324255b7aa7a80b60c53d52d740ca9a7ff63dcb

PRESUBMIT.py

diff --git a/PRESUBMIT.py b/PRESUBMIT.py
index 8e1d1bd..c5c1e88 100644
--- a/PRESUBMIT.py
+++ b/PRESUBMIT.py
@@ -95,26 +95,37 @@
 
 
 def CheckKotlinFormatting(paths, output_api, results):
-  cmd = [GetJavaExecutable(), '-jar', KOTLIN_FMT_JAR, '--google-style', '-n']
-  cmd.extend(paths)
-  result = check_output(cmd)
-  if len(result) > 0:
-    with_format_error = result.splitlines()
-    for path in with_format_error:
-      results.append(
-        output_api.PresubmitError(
-          "File {path} needs formatting".format(path=path.decode('utf-8'))))
-  return len(result) > 0
+  paths_to_format = {
+      '--kotlinlang-style': [path for path in paths if path.startswith('src/keepanno/')],
+      '--google-style': [path for path in paths if not path.startswith('src/keepanno/')]
+  }
+  needs_formatting_count = 0
+  for format in ['--kotlinlang-style', '--google-style']:
+    cmd = [GetJavaExecutable(), '-jar', KOTLIN_FMT_JAR, format, '-n']
+    to_format = paths_to_format[format]
+    if len(to_format) > 0:
+      cmd.extend(to_format)
+      result = check_output(cmd)
+      if len(result) > 0:
+        with_format_error = result.splitlines()
+        for path in with_format_error:
+          results.append(
+            output_api.PresubmitError(
+              "File {path} needs formatting".format(path=path.decode('utf-8'))))
+    needs_formatting_count += len(result)
+  return needs_formatting_count > 0
 
 
 def KotlinFormatPresubmitMessage():
   return """Please fix the Kotlin formatting by running:
 
-  git diff $(git cl upstream) --name-only "*.kt" | xargs {java} -jar {fmt_jar} --google-style
+  git diff $(git cl upstream) --name-only "*.kt" | grep -v "^src/keepanno/" | xargs {java} -jar {fmt_jar} --google-style
+  git diff $(git cl upstream) --name-only "*.kt" | grep "^src/keepanno/" | xargs {java} -jar {fmt_jar} --kotlinlang-style
 
 or fix formatting, commit and upload:
 
-  git diff $(git cl upstream) --name-only "*.kt" | xargs {java} -jar {fmt_jar} --google-style && git commit -a --amend --no-edit && git cl upload
+  git diff $(git cl upstream) --name-only "*.kt" | grep -v "^src/keepanno/" | xargs {java} -jar {fmt_jar} --google-style && git commit -a --amend --no-edit && git cl upload
+  git diff $(git cl upstream) --name-only "*.kt" | grep "^src/keepanno/" | xargs {java} -jar {fmt_jar} --kotlinlang-style && git commit -a --amend --no-edit && git cl upload
 
 or bypass the checks with:
 

src/keepanno/java/androidx/annotation/keep/AnnotationPattern.kt

diff --git a/src/keepanno/java/androidx/annotation/keep/AnnotationPattern.kt b/src/keepanno/java/androidx/annotation/keep/AnnotationPattern.kt
index a6c1ced..9ff9f61 100644
--- a/src/keepanno/java/androidx/annotation/keep/AnnotationPattern.kt
+++ b/src/keepanno/java/androidx/annotation/keep/AnnotationPattern.kt
@@ -40,64 +40,64 @@
 @Target(AnnotationTarget.ANNOTATION_CLASS)
 public annotation class AnnotationPattern(
 
-  /**
-   * Define the annotation-name pattern by fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining annotation-name:
-   * <ul>
-   * <li>constant
-   * <li>namePattern
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any annotation name.
-   *
-   * @return The qualified class name that defines the annotation.
-   */
-  val name: String = "",
+    /**
+     * Define the annotation-name pattern by fully qualified class name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining annotation-name:
+     * <ul>
+     * <li>constant
+     * <li>namePattern
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any annotation name.
+     *
+     * @return The qualified class name that defines the annotation.
+     */
+    val name: String = "",
 
-  /**
-   * Define the annotation-name pattern by reference to a {@code Class} constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining annotation-name:
-   * <ul>
-   * <li>name
-   * <li>namePattern
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any annotation name.
-   *
-   * @return The Class constant that defines the annotation.
-   */
-  val constant: KClass<*> = Object::class,
+    /**
+     * Define the annotation-name pattern by reference to a {@code Class} constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining annotation-name:
+     * <ul>
+     * <li>name
+     * <li>namePattern
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any annotation name.
+     *
+     * @return The Class constant that defines the annotation.
+     */
+    val constant: KClass<*> = Object::class,
 
-  /**
-   * Define the annotation-name pattern by reference to a class-name pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining annotation-name:
-   * <ul>
-   * <li>name
-   * <li>constant
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any annotation name.
-   *
-   * @return The class-name pattern that defines the annotation.
-   */
-  val namePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
+    /**
+     * Define the annotation-name pattern by reference to a class-name pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining annotation-name:
+     * <ul>
+     * <li>name
+     * <li>constant
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any annotation name.
+     *
+     * @return The class-name pattern that defines the annotation.
+     */
+    val namePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
 
-  /**
-   * Specify which retention policies must be set for the annotations.
-   *
-   * <p>
-   * Matches annotations with matching retention policies
-   *
-   * @return Retention policies. By default {@code RetentionPolicy.RUNTIME}.
-   */
-  val retention: Array<RetentionPolicy> = [RetentionPolicy.RUNTIME],
+    /**
+     * Specify which retention policies must be set for the annotations.
+     *
+     * <p>
+     * Matches annotations with matching retention policies
+     *
+     * @return Retention policies. By default {@code RetentionPolicy.RUNTIME}.
+     */
+    val retention: Array<RetentionPolicy> = [RetentionPolicy.RUNTIME],
 )

src/keepanno/java/androidx/annotation/keep/CheckOptimizedOut.kt

diff --git a/src/keepanno/java/androidx/annotation/keep/CheckOptimizedOut.kt b/src/keepanno/java/androidx/annotation/keep/CheckOptimizedOut.kt
index 75f69d6..e6e5b98 100644
--- a/src/keepanno/java/androidx/annotation/keep/CheckOptimizedOut.kt
+++ b/src/keepanno/java/androidx/annotation/keep/CheckOptimizedOut.kt
@@ -38,9 +38,9 @@
  */
 @Retention(AnnotationRetention.BINARY)
 @Target(
-  AnnotationTarget.TYPE,
-  AnnotationTarget.FIELD,
-  AnnotationTarget.FUNCTION,
-  AnnotationTarget.CONSTRUCTOR,
+    AnnotationTarget.TYPE,
+    AnnotationTarget.FIELD,
+    AnnotationTarget.FUNCTION,
+    AnnotationTarget.CONSTRUCTOR,
 )
 public annotation class CheckOptimizedOut(val description: String = "")

src/keepanno/java/androidx/annotation/keep/CheckRemoved.kt

diff --git a/src/keepanno/java/androidx/annotation/keep/CheckRemoved.kt b/src/keepanno/java/androidx/annotation/keep/CheckRemoved.kt
index 66117a2..00923ed 100644
--- a/src/keepanno/java/androidx/annotation/keep/CheckRemoved.kt
+++ b/src/keepanno/java/androidx/annotation/keep/CheckRemoved.kt
@@ -34,9 +34,9 @@
  */
 @Retention(AnnotationRetention.BINARY)
 @Target(
-  AnnotationTarget.TYPE,
-  AnnotationTarget.FIELD,
-  AnnotationTarget.FUNCTION,
-  AnnotationTarget.CONSTRUCTOR,
+    AnnotationTarget.TYPE,
+    AnnotationTarget.FIELD,
+    AnnotationTarget.FUNCTION,
+    AnnotationTarget.CONSTRUCTOR,
 )
 public annotation class CheckRemoved(val description: String = "")

src/keepanno/java/androidx/annotation/keep/ClassAccessFlags.kt

diff --git a/src/keepanno/java/androidx/annotation/keep/ClassAccessFlags.kt b/src/keepanno/java/androidx/annotation/keep/ClassAccessFlags.kt
index fb5a082..32971aa 100644
--- a/src/keepanno/java/androidx/annotation/keep/ClassAccessFlags.kt
+++ b/src/keepanno/java/androidx/annotation/keep/ClassAccessFlags.kt
@@ -27,20 +27,20 @@
  * operation syntactically.
  */
 public enum class ClassAccessFlags {
-  PUBLIC,
-  NON_PUBLIC,
-  PACKAGE_PRIVATE,
-  NON_PACKAGE_PRIVATE,
-  FINAL,
-  NON_FINAL,
-  INTERFACE,
-  NON_INTERFACE,
-  ABSTRACT,
-  NON_ABSTRACT,
-  SYNTHETIC,
-  NON_SYNTHETIC,
-  ANNOTATION,
-  NON_ANNOTATION,
-  ENUM,
-  NON_ENUM,
+    PUBLIC,
+    NON_PUBLIC,
+    PACKAGE_PRIVATE,
+    NON_PACKAGE_PRIVATE,
+    FINAL,
+    NON_FINAL,
+    INTERFACE,
+    NON_INTERFACE,
+    ABSTRACT,
+    NON_ABSTRACT,
+    SYNTHETIC,
+    NON_SYNTHETIC,
+    ANNOTATION,
+    NON_ANNOTATION,
+    ENUM,
+    NON_ENUM,
 }

src/keepanno/java/androidx/annotation/keep/ClassNamePattern.kt

diff --git a/src/keepanno/java/androidx/annotation/keep/ClassNamePattern.kt b/src/keepanno/java/androidx/annotation/keep/ClassNamePattern.kt
index 44738b1..b5c312c 100644
--- a/src/keepanno/java/androidx/annotation/keep/ClassNamePattern.kt
+++ b/src/keepanno/java/androidx/annotation/keep/ClassNamePattern.kt
@@ -38,92 +38,92 @@
 @Target(AnnotationTarget.ANNOTATION_CLASS)
 public annotation class ClassNamePattern(
 
-  /**
-   * Define the class-name pattern by fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining class-name:
-   * <ul>
-   * <li>constant
-   * <li>unqualifiedName
-   * <li>unqualifiedNamePattern
-   * <li>packageName
-   * </ul>
-   *
-   * @return The qualified class name that defines the class.
-   */
-  val name: String = "",
+    /**
+     * Define the class-name pattern by fully qualified class name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining class-name:
+     * <ul>
+     * <li>constant
+     * <li>unqualifiedName
+     * <li>unqualifiedNamePattern
+     * <li>packageName
+     * </ul>
+     *
+     * @return The qualified class name that defines the class.
+     */
+    val name: String = "",
 
-  /**
-   * Define the class-name pattern by reference to a Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining class-name:
-   * <ul>
-   * <li>name
-   * <li>unqualifiedName
-   * <li>unqualifiedNamePattern
-   * <li>packageName
-   * </ul>
-   *
-   * @return The class-constant that defines the class.
-   */
-  val constant: KClass<*> = Object::class,
+    /**
+     * Define the class-name pattern by reference to a Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining class-name:
+     * <ul>
+     * <li>name
+     * <li>unqualifiedName
+     * <li>unqualifiedNamePattern
+     * <li>packageName
+     * </ul>
+     *
+     * @return The class-constant that defines the class.
+     */
+    val constant: KClass<*> = Object::class,
 
-  /**
-   * Exact and unqualified name of the class or interface.
-   *
-   * <p>
-   * For example, the unqualified name of {@code com.example.MyClass} is {@code MyClass}. Note that
-   * for inner classes a `$` will appear in the unqualified name,such as, {@code
-   * MyClass$MyInnerClass}.
-   *
-   * <p>
-   * The default matches any unqualified name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining class-unqualified-name:
-   * <ul>
-   * <li>unqualifiedNamePattern
-   * <li>name
-   * <li>constant
-   * </ul>
-   */
-  val unqualifiedName: String = "",
+    /**
+     * Exact and unqualified name of the class or interface.
+     *
+     * <p>
+     * For example, the unqualified name of {@code com.example.MyClass} is {@code MyClass}. Note
+     * that for inner classes a `$` will appear in the unqualified name,such as, {@code
+     * MyClass$MyInnerClass}.
+     *
+     * <p>
+     * The default matches any unqualified name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining class-unqualified-name:
+     * <ul>
+     * <li>unqualifiedNamePattern
+     * <li>name
+     * <li>constant
+     * </ul>
+     */
+    val unqualifiedName: String = "",
 
-  /**
-   * Define the unqualified class-name pattern by a string pattern.
-   *
-   * <p>
-   * The default matches any unqualified name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining class-unqualified-name:
-   * <ul>
-   * <li>unqualifiedName
-   * <li>name
-   * <li>constant
-   * </ul>
-   *
-   * @return The string pattern of the unqualified class name.
-   */
-  val unqualifiedNamePattern: StringPattern = StringPattern(exact = ""),
+    /**
+     * Define the unqualified class-name pattern by a string pattern.
+     *
+     * <p>
+     * The default matches any unqualified name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining class-unqualified-name:
+     * <ul>
+     * <li>unqualifiedName
+     * <li>name
+     * <li>constant
+     * </ul>
+     *
+     * @return The string pattern of the unqualified class name.
+     */
+    val unqualifiedNamePattern: StringPattern = StringPattern(exact = ""),
 
-  /**
-   * Exact package name of the class or interface.
-   *
-   * <p>
-   * For example, the package of {@code com.example.MyClass} is {@code com.example}.
-   *
-   * <p>
-   * The default matches any package.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining class-package-name:
-   * <ul>
-   * <li>name
-   * <li>constant
-   * </ul>
-   */
-  val packageName: String = "",
+    /**
+     * Exact package name of the class or interface.
+     *
+     * <p>
+     * For example, the package of {@code com.example.MyClass} is {@code com.example}.
+     *
+     * <p>
+     * The default matches any package.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining class-package-name:
+     * <ul>
+     * <li>name
+     * <li>constant
+     * </ul>
+     */
+    val packageName: String = "",
 )

src/keepanno/java/androidx/annotation/keep/FieldAccessFlags.kt

diff --git a/src/keepanno/java/androidx/annotation/keep/FieldAccessFlags.kt b/src/keepanno/java/androidx/annotation/keep/FieldAccessFlags.kt
index 37c763c..7dac709 100644
--- a/src/keepanno/java/androidx/annotation/keep/FieldAccessFlags.kt
+++ b/src/keepanno/java/androidx/annotation/keep/FieldAccessFlags.kt
@@ -27,25 +27,25 @@
  * operation syntactically.
  */
 public enum class FieldAccessFlags {
-  // General member flags.
-  PUBLIC,
-  NON_PUBLIC,
-  PRIVATE,
-  NON_PRIVATE,
-  PROTECTED,
-  NON_PROTECTED,
-  PACKAGE_PRIVATE,
-  NON_PACKAGE_PRIVATE,
-  STATIC,
-  NON_STATIC,
-  FINAL,
-  NON_FINAL,
-  SYNTHETIC,
-  NON_SYNTHETIC,
-  // Field specific flags.
-  VOLATILE,
-  NON_VOLATILE,
-  TRANSIENT,
-  NON_TRANSIENT,
-  // ENUM - No PG parser support.
+    // General member flags.
+    PUBLIC,
+    NON_PUBLIC,
+    PRIVATE,
+    NON_PRIVATE,
+    PROTECTED,
+    NON_PROTECTED,
+    PACKAGE_PRIVATE,
+    NON_PACKAGE_PRIVATE,
+    STATIC,
+    NON_STATIC,
+    FINAL,
+    NON_FINAL,
+    SYNTHETIC,
+    NON_SYNTHETIC,
+    // Field specific flags.
+    VOLATILE,
+    NON_VOLATILE,
+    TRANSIENT,
+    NON_TRANSIENT,
+    // ENUM - No PG parser support.
 }

src/keepanno/java/androidx/annotation/keep/InstanceOfPattern.kt

diff --git a/src/keepanno/java/androidx/annotation/keep/InstanceOfPattern.kt b/src/keepanno/java/androidx/annotation/keep/InstanceOfPattern.kt
index b1c84b1..01a1e51 100644
--- a/src/keepanno/java/androidx/annotation/keep/InstanceOfPattern.kt
+++ b/src/keepanno/java/androidx/annotation/keep/InstanceOfPattern.kt
@@ -37,15 +37,15 @@
 @Target(AnnotationTarget.ANNOTATION_CLASS)
 public annotation class InstanceOfPattern(
 
-  /**
-   * True if the pattern should include the directly matched classes.
-   *
-   * <p>
-   * If false, the pattern is exclusive and only matches classes that are strict subclasses of the
-   * pattern.
-   */
-  val isInclusive: Boolean = true,
+    /**
+     * True if the pattern should include the directly matched classes.
+     *
+     * <p>
+     * If false, the pattern is exclusive and only matches classes that are strict subclasses of the
+     * pattern.
+     */
+    val isInclusive: Boolean = true,
 
-  /** Instances of classes matching the class-name pattern. */
-  val classNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
+    /** Instances of classes matching the class-name pattern. */
+    val classNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
 )

src/keepanno/java/androidx/annotation/keep/KeepBinding.kt

diff --git a/src/keepanno/java/androidx/annotation/keep/KeepBinding.kt b/src/keepanno/java/androidx/annotation/keep/KeepBinding.kt
index 7d9730b..aa8de9a 100644
--- a/src/keepanno/java/androidx/annotation/keep/KeepBinding.kt
+++ b/src/keepanno/java/androidx/annotation/keep/KeepBinding.kt
@@ -47,735 +47,743 @@
 @Target(AnnotationTarget.ANNOTATION_CLASS)
 public annotation class KeepBinding(
 
-  /**
-   * Name with which other bindings, conditions or targets can reference the bound item pattern.
-   *
-   * @return Name of the binding.
-   */
-  val bindingName: String,
+    /**
+     * Name with which other bindings, conditions or targets can reference the bound item pattern.
+     *
+     * @return Name of the binding.
+     */
+    val bindingName: String,
 
-  /**
-   * Specify the kind of this item pattern.
-   *
-   * <p>
-   * Possible values are:
-   * <ul>
-   * <li>{@link KeepItemKind#ONLY_CLASS}
-   * <li>{@link KeepItemKind#ONLY_MEMBERS}
-   * <li>{@link KeepItemKind#ONLY_METHODS}
-   * <li>{@link KeepItemKind#ONLY_FIELDS}
-   * <li>{@link KeepItemKind#CLASS_AND_MEMBERS}
-   * <li>{@link KeepItemKind#CLASS_AND_METHODS}
-   * <li>{@link KeepItemKind#CLASS_AND_FIELDS}
-   * </ul>
-   *
-   * <p>
-   * If unspecified the default kind for an item depends on its member patterns:
-   * <ul>
-   * <li>{@link KeepItemKind#ONLY_CLASS} if no member patterns are defined
-   * <li>{@link KeepItemKind#ONLY_METHODS} if method patterns are defined
-   * <li>{@link KeepItemKind#ONLY_FIELDS} if field patterns are defined
-   * <li>{@link KeepItemKind#ONLY_MEMBERS} otherwise.
-   * </ul>
-   *
-   * @return The kind for this pattern.
-   */
-  val kind: KeepItemKind = KeepItemKind.DEFAULT,
+    /**
+     * Specify the kind of this item pattern.
+     *
+     * <p>
+     * Possible values are:
+     * <ul>
+     * <li>{@link KeepItemKind#ONLY_CLASS}
+     * <li>{@link KeepItemKind#ONLY_MEMBERS}
+     * <li>{@link KeepItemKind#ONLY_METHODS}
+     * <li>{@link KeepItemKind#ONLY_FIELDS}
+     * <li>{@link KeepItemKind#CLASS_AND_MEMBERS}
+     * <li>{@link KeepItemKind#CLASS_AND_METHODS}
+     * <li>{@link KeepItemKind#CLASS_AND_FIELDS}
+     * </ul>
+     *
+     * <p>
+     * If unspecified the default kind for an item depends on its member patterns:
+     * <ul>
+     * <li>{@link KeepItemKind#ONLY_CLASS} if no member patterns are defined
+     * <li>{@link KeepItemKind#ONLY_METHODS} if method patterns are defined
+     * <li>{@link KeepItemKind#ONLY_FIELDS} if field patterns are defined
+     * <li>{@link KeepItemKind#ONLY_MEMBERS} otherwise.
+     * </ul>
+     *
+     * @return The kind for this pattern.
+     */
+    val kind: KeepItemKind = KeepItemKind.DEFAULT,
 
-  /**
-   * Define the class pattern by reference to a binding.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining class:
-   * <ul>
-   * <li>className
-   * <li>classConstant
-   * <li>classNamePattern
-   * <li>instanceOfClassName
-   * <li>instanceOfClassNameExclusive
-   * <li>instanceOfClassConstant
-   * <li>instanceOfClassConstantExclusive
-   * <li>instanceOfPattern
-   * <li>classAnnotatedByClassName
-   * <li>classAnnotatedByClassConstant
-   * <li>classAnnotatedByClassNamePattern
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class.
-   *
-   * @return The name of the binding that defines the class.
-   */
-  val classFromBinding: String = "",
+    /**
+     * Define the class pattern by reference to a binding.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining class:
+     * <ul>
+     * <li>className
+     * <li>classConstant
+     * <li>classNamePattern
+     * <li>instanceOfClassName
+     * <li>instanceOfClassNameExclusive
+     * <li>instanceOfClassConstant
+     * <li>instanceOfClassConstantExclusive
+     * <li>instanceOfPattern
+     * <li>classAnnotatedByClassName
+     * <li>classAnnotatedByClassConstant
+     * <li>classAnnotatedByClassNamePattern
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class.
+     *
+     * @return The name of the binding that defines the class.
+     */
+    val classFromBinding: String = "",
 
-  /**
-   * Define the class-name pattern by fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining class-name:
-   * <ul>
-   * <li>classConstant
-   * <li>classNamePattern
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class name.
-   *
-   * @return The qualified class name that defines the class.
-   */
-  val className: String = "",
+    /**
+     * Define the class-name pattern by fully qualified class name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining class-name:
+     * <ul>
+     * <li>classConstant
+     * <li>classNamePattern
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class name.
+     *
+     * @return The qualified class name that defines the class.
+     */
+    val className: String = "",
 
-  /**
-   * Define the class-name pattern by reference to a Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining class-name:
-   * <ul>
-   * <li>className
-   * <li>classNamePattern
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class name.
-   *
-   * @return The class-constant that defines the class.
-   */
-  val classConstant: KClass<*> = Object::class,
+    /**
+     * Define the class-name pattern by reference to a Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining class-name:
+     * <ul>
+     * <li>className
+     * <li>classNamePattern
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class name.
+     *
+     * @return The class-constant that defines the class.
+     */
+    val classConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the class-name pattern by reference to a class-name pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining class-name:
-   * <ul>
-   * <li>className
-   * <li>classConstant
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class name.
-   *
-   * @return The class-name pattern that defines the class.
-   */
-  val classNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
+    /**
+     * Define the class-name pattern by reference to a class-name pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining class-name:
+     * <ul>
+     * <li>className
+     * <li>classConstant
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class name.
+     *
+     * @return The class-name pattern that defines the class.
+     */
+    val classNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
 
-  /**
-   * Define the instance-of pattern as classes that are instances of the fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining instance-of:
-   * <ul>
-   * <li>instanceOfClassNameExclusive
-   * <li>instanceOfClassConstant
-   * <li>instanceOfClassConstantExclusive
-   * <li>instanceOfPattern
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class instance.
-   *
-   * @return The qualified class name that defines what instance-of the class must be.
-   */
-  val instanceOfClassName: String = "",
+    /**
+     * Define the instance-of pattern as classes that are instances of the fully qualified class
+     * name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining instance-of:
+     * <ul>
+     * <li>instanceOfClassNameExclusive
+     * <li>instanceOfClassConstant
+     * <li>instanceOfClassConstantExclusive
+     * <li>instanceOfPattern
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class instance.
+     *
+     * @return The qualified class name that defines what instance-of the class must be.
+     */
+    val instanceOfClassName: String = "",
 
-  /**
-   * Define the instance-of pattern as classes that are instances of the fully qualified class name.
-   *
-   * <p>
-   * The pattern is exclusive in that it does not match classes that are instances of the pattern,
-   * but only those that are instances of classes that are subclasses of the pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining instance-of:
-   * <ul>
-   * <li>instanceOfClassName
-   * <li>instanceOfClassConstant
-   * <li>instanceOfClassConstantExclusive
-   * <li>instanceOfPattern
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class instance.
-   *
-   * @return The qualified class name that defines what instance-of the class must be.
-   */
-  val instanceOfClassNameExclusive: String = "",
+    /**
+     * Define the instance-of pattern as classes that are instances of the fully qualified class
+     * name.
+     *
+     * <p>
+     * The pattern is exclusive in that it does not match classes that are instances of the pattern,
+     * but only those that are instances of classes that are subclasses of the pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining instance-of:
+     * <ul>
+     * <li>instanceOfClassName
+     * <li>instanceOfClassConstant
+     * <li>instanceOfClassConstantExclusive
+     * <li>instanceOfPattern
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class instance.
+     *
+     * @return The qualified class name that defines what instance-of the class must be.
+     */
+    val instanceOfClassNameExclusive: String = "",
 
-  /**
-   * Define the instance-of pattern as classes that are instances the referenced Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining instance-of:
-   * <ul>
-   * <li>instanceOfClassName
-   * <li>instanceOfClassNameExclusive
-   * <li>instanceOfClassConstantExclusive
-   * <li>instanceOfPattern
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class instance.
-   *
-   * @return The class constant that defines what instance-of the class must be.
-   */
-  val instanceOfClassConstant: KClass<*> = Object::class,
+    /**
+     * Define the instance-of pattern as classes that are instances the referenced Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining instance-of:
+     * <ul>
+     * <li>instanceOfClassName
+     * <li>instanceOfClassNameExclusive
+     * <li>instanceOfClassConstantExclusive
+     * <li>instanceOfPattern
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class instance.
+     *
+     * @return The class constant that defines what instance-of the class must be.
+     */
+    val instanceOfClassConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the instance-of pattern as classes that are instances the referenced Class constant.
-   *
-   * <p>
-   * The pattern is exclusive in that it does not match classes that are instances of the pattern,
-   * but only those that are instances of classes that are subclasses of the pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining instance-of:
-   * <ul>
-   * <li>instanceOfClassName
-   * <li>instanceOfClassNameExclusive
-   * <li>instanceOfClassConstant
-   * <li>instanceOfPattern
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class instance.
-   *
-   * @return The class constant that defines what instance-of the class must be.
-   */
-  val instanceOfClassConstantExclusive: KClass<*> = Object::class,
+    /**
+     * Define the instance-of pattern as classes that are instances the referenced Class constant.
+     *
+     * <p>
+     * The pattern is exclusive in that it does not match classes that are instances of the pattern,
+     * but only those that are instances of classes that are subclasses of the pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining instance-of:
+     * <ul>
+     * <li>instanceOfClassName
+     * <li>instanceOfClassNameExclusive
+     * <li>instanceOfClassConstant
+     * <li>instanceOfPattern
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class instance.
+     *
+     * @return The class constant that defines what instance-of the class must be.
+     */
+    val instanceOfClassConstantExclusive: KClass<*> = Object::class,
 
-  /**
-   * Define the instance-of with a pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining instance-of:
-   * <ul>
-   * <li>instanceOfClassName
-   * <li>instanceOfClassNameExclusive
-   * <li>instanceOfClassConstant
-   * <li>instanceOfClassConstantExclusive
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class instance.
-   *
-   * @return The pattern that defines what instance-of the class must be.
-   */
-  val instanceOfPattern: InstanceOfPattern = InstanceOfPattern(),
+    /**
+     * Define the instance-of with a pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining instance-of:
+     * <ul>
+     * <li>instanceOfClassName
+     * <li>instanceOfClassNameExclusive
+     * <li>instanceOfClassConstant
+     * <li>instanceOfClassConstantExclusive
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class instance.
+     *
+     * @return The pattern that defines what instance-of the class must be.
+     */
+    val instanceOfPattern: InstanceOfPattern = InstanceOfPattern(),
 
-  /**
-   * Define the class-annotated-by pattern by fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining class-annotated-by:
-   * <ul>
-   * <li>classAnnotatedByClassConstant
-   * <li>classAnnotatedByClassNamePattern
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class regardless of what the class is
-   * annotated by.
-   *
-   * @return The qualified class name that defines the annotation.
-   */
-  val classAnnotatedByClassName: String = "",
+    /**
+     * Define the class-annotated-by pattern by fully qualified class name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining class-annotated-by:
+     * <ul>
+     * <li>classAnnotatedByClassConstant
+     * <li>classAnnotatedByClassNamePattern
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class regardless of what the class is
+     * annotated by.
+     *
+     * @return The qualified class name that defines the annotation.
+     */
+    val classAnnotatedByClassName: String = "",
 
-  /**
-   * Define the class-annotated-by pattern by reference to a Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining class-annotated-by:
-   * <ul>
-   * <li>classAnnotatedByClassName
-   * <li>classAnnotatedByClassNamePattern
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class regardless of what the class is
-   * annotated by.
-   *
-   * @return The class-constant that defines the annotation.
-   */
-  val classAnnotatedByClassConstant: KClass<*> = Object::class,
+    /**
+     * Define the class-annotated-by pattern by reference to a Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining class-annotated-by:
+     * <ul>
+     * <li>classAnnotatedByClassName
+     * <li>classAnnotatedByClassNamePattern
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class regardless of what the class is
+     * annotated by.
+     *
+     * @return The class-constant that defines the annotation.
+     */
+    val classAnnotatedByClassConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the class-annotated-by pattern by reference to a class-name pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining class-annotated-by:
-   * <ul>
-   * <li>classAnnotatedByClassName
-   * <li>classAnnotatedByClassConstant
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class regardless of what the class is
-   * annotated by.
-   *
-   * @return The class-name pattern that defines the annotation.
-   */
-  val classAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
+    /**
+     * Define the class-annotated-by pattern by reference to a class-name pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining class-annotated-by:
+     * <ul>
+     * <li>classAnnotatedByClassName
+     * <li>classAnnotatedByClassConstant
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class regardless of what the class is
+     * annotated by.
+     *
+     * @return The class-name pattern that defines the annotation.
+     */
+    val classAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
 
-  /**
-   * Define the member-annotated-by pattern by fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining member-annotated-by:
-   * <ul>
-   * <li>memberAnnotatedByClassConstant
-   * <li>memberAnnotatedByClassNamePattern
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field and method properties as use restricts the match to both
-   * types of members.
-   *
-   * <p>
-   * If none are specified the default is to match any member regardless of what the member is
-   * annotated by.
-   *
-   * @return The qualified class name that defines the annotation.
-   */
-  val memberAnnotatedByClassName: String = "",
+    /**
+     * Define the member-annotated-by pattern by fully qualified class name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining member-annotated-by:
+     * <ul>
+     * <li>memberAnnotatedByClassConstant
+     * <li>memberAnnotatedByClassNamePattern
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field and method properties as use restricts the match to both
+     * types of members.
+     *
+     * <p>
+     * If none are specified the default is to match any member regardless of what the member is
+     * annotated by.
+     *
+     * @return The qualified class name that defines the annotation.
+     */
+    val memberAnnotatedByClassName: String = "",
 
-  /**
-   * Define the member-annotated-by pattern by reference to a Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining member-annotated-by:
-   * <ul>
-   * <li>memberAnnotatedByClassName
-   * <li>memberAnnotatedByClassNamePattern
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field and method properties as use restricts the match to both
-   * types of members.
-   *
-   * <p>
-   * If none are specified the default is to match any member regardless of what the member is
-   * annotated by.
-   *
-   * @return The class-constant that defines the annotation.
-   */
-  val memberAnnotatedByClassConstant: KClass<*> = Object::class,
+    /**
+     * Define the member-annotated-by pattern by reference to a Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining member-annotated-by:
+     * <ul>
+     * <li>memberAnnotatedByClassName
+     * <li>memberAnnotatedByClassNamePattern
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field and method properties as use restricts the match to both
+     * types of members.
+     *
+     * <p>
+     * If none are specified the default is to match any member regardless of what the member is
+     * annotated by.
+     *
+     * @return The class-constant that defines the annotation.
+     */
+    val memberAnnotatedByClassConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the member-annotated-by pattern by reference to a class-name pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining member-annotated-by:
-   * <ul>
-   * <li>memberAnnotatedByClassName
-   * <li>memberAnnotatedByClassConstant
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field and method properties as use restricts the match to both
-   * types of members.
-   *
-   * <p>
-   * If none are specified the default is to match any member regardless of what the member is
-   * annotated by.
-   *
-   * @return The class-name pattern that defines the annotation.
-   */
-  val memberAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
+    /**
+     * Define the member-annotated-by pattern by reference to a class-name pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining member-annotated-by:
+     * <ul>
+     * <li>memberAnnotatedByClassName
+     * <li>memberAnnotatedByClassConstant
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field and method properties as use restricts the match to both
+     * types of members.
+     *
+     * <p>
+     * If none are specified the default is to match any member regardless of what the member is
+     * annotated by.
+     *
+     * @return The class-name pattern that defines the annotation.
+     */
+    val memberAnnotatedByClassNamePattern: ClassNamePattern =
+        ClassNamePattern(unqualifiedName = ""),
 
-  /**
-   * Define the member-access pattern by matching on access flags.
-   *
-   * <p>
-   * Mutually exclusive with all field and method properties as use restricts the match to both
-   * types of members.
-   *
-   * @return The member access-flag constraints that must be met.
-   */
-  val memberAccess: Array<MemberAccessFlags> = [],
+    /**
+     * Define the member-access pattern by matching on access flags.
+     *
+     * <p>
+     * Mutually exclusive with all field and method properties as use restricts the match to both
+     * types of members.
+     *
+     * @return The member access-flag constraints that must be met.
+     */
+    val memberAccess: Array<MemberAccessFlags> = [],
 
-  /**
-   * Define the method-annotated-by pattern by fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining method-annotated-by:
-   * <ul>
-   * <li>methodAnnotatedByClassConstant
-   * <li>methodAnnotatedByClassNamePattern
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none are specified the default is to match any method regardless of what the method is
-   * annotated by.
-   *
-   * @return The qualified class name that defines the annotation.
-   */
-  val methodAnnotatedByClassName: String = "",
+    /**
+     * Define the method-annotated-by pattern by fully qualified class name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining method-annotated-by:
+     * <ul>
+     * <li>methodAnnotatedByClassConstant
+     * <li>methodAnnotatedByClassNamePattern
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none are specified the default is to match any method regardless of what the method is
+     * annotated by.
+     *
+     * @return The qualified class name that defines the annotation.
+     */
+    val methodAnnotatedByClassName: String = "",
 
-  /**
-   * Define the method-annotated-by pattern by reference to a Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining method-annotated-by:
-   * <ul>
-   * <li>methodAnnotatedByClassName
-   * <li>methodAnnotatedByClassNamePattern
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none are specified the default is to match any method regardless of what the method is
-   * annotated by.
-   *
-   * @return The class-constant that defines the annotation.
-   */
-  val methodAnnotatedByClassConstant: KClass<*> = Object::class,
+    /**
+     * Define the method-annotated-by pattern by reference to a Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining method-annotated-by:
+     * <ul>
+     * <li>methodAnnotatedByClassName
+     * <li>methodAnnotatedByClassNamePattern
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none are specified the default is to match any method regardless of what the method is
+     * annotated by.
+     *
+     * @return The class-constant that defines the annotation.
+     */
+    val methodAnnotatedByClassConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the method-annotated-by pattern by reference to a class-name pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining method-annotated-by:
-   * <ul>
-   * <li>methodAnnotatedByClassName
-   * <li>methodAnnotatedByClassConstant
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none are specified the default is to match any method regardless of what the method is
-   * annotated by.
-   *
-   * @return The class-name pattern that defines the annotation.
-   */
-  val methodAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
+    /**
+     * Define the method-annotated-by pattern by reference to a class-name pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining method-annotated-by:
+     * <ul>
+     * <li>methodAnnotatedByClassName
+     * <li>methodAnnotatedByClassConstant
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none are specified the default is to match any method regardless of what the method is
+     * annotated by.
+     *
+     * @return The class-name pattern that defines the annotation.
+     */
+    val methodAnnotatedByClassNamePattern: ClassNamePattern =
+        ClassNamePattern(unqualifiedName = ""),
 
-  /**
-   * Define the method-access pattern by matching on access flags.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any
-   * method-access flags.
-   *
-   * @return The method access-flag constraints that must be met.
-   */
-  val methodAccess: Array<MethodAccessFlags> = [],
+    /**
+     * Define the method-access pattern by matching on access flags.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any
+     * method-access flags.
+     *
+     * @return The method access-flag constraints that must be met.
+     */
+    val methodAccess: Array<MethodAccessFlags> = [],
 
-  /**
-   * Define the method-name pattern by an exact method name.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any method
-   * name.
-   *
-   * <p>
-   * Mutually exclusive with the property `methodNamePattern` also defining method-name.
-   *
-   * @return The exact method name of the method.
-   */
-  val methodName: String = "",
+    /**
+     * Define the method-name pattern by an exact method name.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any method
+     * name.
+     *
+     * <p>
+     * Mutually exclusive with the property `methodNamePattern` also defining method-name.
+     *
+     * @return The exact method name of the method.
+     */
+    val methodName: String = "",
 
-  /**
-   * Define the method-name pattern by a string pattern.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any method
-   * name.
-   *
-   * <p>
-   * Mutually exclusive with the property `methodName` also defining method-name.
-   *
-   * @return The string pattern of the method name.
-   */
-  val methodNamePattern: StringPattern = StringPattern(exact = ""),
+    /**
+     * Define the method-name pattern by a string pattern.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any method
+     * name.
+     *
+     * <p>
+     * Mutually exclusive with the property `methodName` also defining method-name.
+     *
+     * @return The string pattern of the method name.
+     */
+    val methodNamePattern: StringPattern = StringPattern(exact = ""),
 
-  /**
-   * Define the method return-type pattern by a fully qualified type or 'void'.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any return
-   * type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining return-type:
-   * <ul>
-   * <li>methodReturnTypeConstant
-   * <li>methodReturnTypePattern
-   * </ul>
-   *
-   * @return The qualified type name of the method return type.
-   */
-  val methodReturnType: String = "",
+    /**
+     * Define the method return-type pattern by a fully qualified type or 'void'.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any return
+     * type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining return-type:
+     * <ul>
+     * <li>methodReturnTypeConstant
+     * <li>methodReturnTypePattern
+     * </ul>
+     *
+     * @return The qualified type name of the method return type.
+     */
+    val methodReturnType: String = "",
 
-  /**
-   * Define the method return-type pattern by a class constant.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any return
-   * type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining return-type:
-   * <ul>
-   * <li>methodReturnType
-   * <li>methodReturnTypePattern
-   * </ul>
-   *
-   * @return A class constant denoting the type of the method return type.
-   */
-  val methodReturnTypeConstant: KClass<*> = Object::class,
+    /**
+     * Define the method return-type pattern by a class constant.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any return
+     * type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining return-type:
+     * <ul>
+     * <li>methodReturnType
+     * <li>methodReturnTypePattern
+     * </ul>
+     *
+     * @return A class constant denoting the type of the method return type.
+     */
+    val methodReturnTypeConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the method return-type pattern by a type pattern.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any return
-   * type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining return-type:
-   * <ul>
-   * <li>methodReturnType
-   * <li>methodReturnTypeConstant
-   * </ul>
-   *
-   * @return The pattern of the method return type.
-   */
-  val methodReturnTypePattern: TypePattern = TypePattern(name = ""),
+    /**
+     * Define the method return-type pattern by a type pattern.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any return
+     * type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining return-type:
+     * <ul>
+     * <li>methodReturnType
+     * <li>methodReturnTypeConstant
+     * </ul>
+     *
+     * @return The pattern of the method return type.
+     */
+    val methodReturnTypePattern: TypePattern = TypePattern(name = ""),
 
-  /**
-   * Define the method parameters pattern by a list of fully qualified types.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any parameters.
-   *
-   * <p>
-   * Mutually exclusive with the property `methodParameterTypePatterns` also defining parameters.
-   *
-   * @return The list of qualified type names of the method parameters.
-   */
-  val methodParameters: Array<String> = [""],
+    /**
+     * Define the method parameters pattern by a list of fully qualified types.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any
+     * parameters.
+     *
+     * <p>
+     * Mutually exclusive with the property `methodParameterTypePatterns` also defining parameters.
+     *
+     * @return The list of qualified type names of the method parameters.
+     */
+    val methodParameters: Array<String> = [""],
 
-  /**
-   * Define the method parameters pattern by a list of patterns on types.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any parameters.
-   *
-   * <p>
-   * Mutually exclusive with the property `methodParameters` also defining parameters.
-   *
-   * @return The list of type patterns for the method parameters.
-   */
-  val methodParameterTypePatterns: Array<TypePattern> = [TypePattern(name = "")],
+    /**
+     * Define the method parameters pattern by a list of patterns on types.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any
+     * parameters.
+     *
+     * <p>
+     * Mutually exclusive with the property `methodParameters` also defining parameters.
+     *
+     * @return The list of type patterns for the method parameters.
+     */
+    val methodParameterTypePatterns: Array<TypePattern> = [TypePattern(name = "")],
 
-  /**
-   * Define the field-annotated-by pattern by fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-annotated-by:
-   * <ul>
-   * <li>fieldAnnotatedByClassConstant
-   * <li>fieldAnnotatedByClassNamePattern
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none are specified the default is to match any field regardless of what the field is
-   * annotated by.
-   *
-   * @return The qualified class name that defines the annotation.
-   */
-  val fieldAnnotatedByClassName: String = "",
+    /**
+     * Define the field-annotated-by pattern by fully qualified class name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-annotated-by:
+     * <ul>
+     * <li>fieldAnnotatedByClassConstant
+     * <li>fieldAnnotatedByClassNamePattern
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none are specified the default is to match any field regardless of what the field is
+     * annotated by.
+     *
+     * @return The qualified class name that defines the annotation.
+     */
+    val fieldAnnotatedByClassName: String = "",
 
-  /**
-   * Define the field-annotated-by pattern by reference to a Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-annotated-by:
-   * <ul>
-   * <li>fieldAnnotatedByClassName
-   * <li>fieldAnnotatedByClassNamePattern
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none are specified the default is to match any field regardless of what the field is
-   * annotated by.
-   *
-   * @return The class-constant that defines the annotation.
-   */
-  val fieldAnnotatedByClassConstant: KClass<*> = Object::class,
+    /**
+     * Define the field-annotated-by pattern by reference to a Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-annotated-by:
+     * <ul>
+     * <li>fieldAnnotatedByClassName
+     * <li>fieldAnnotatedByClassNamePattern
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none are specified the default is to match any field regardless of what the field is
+     * annotated by.
+     *
+     * @return The class-constant that defines the annotation.
+     */
+    val fieldAnnotatedByClassConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the field-annotated-by pattern by reference to a class-name pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-annotated-by:
-   * <ul>
-   * <li>fieldAnnotatedByClassName
-   * <li>fieldAnnotatedByClassConstant
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none are specified the default is to match any field regardless of what the field is
-   * annotated by.
-   *
-   * @return The class-name pattern that defines the annotation.
-   */
-  val fieldAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
+    /**
+     * Define the field-annotated-by pattern by reference to a class-name pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-annotated-by:
+     * <ul>
+     * <li>fieldAnnotatedByClassName
+     * <li>fieldAnnotatedByClassConstant
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none are specified the default is to match any field regardless of what the field is
+     * annotated by.
+     *
+     * @return The class-name pattern that defines the annotation.
+     */
+    val fieldAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
 
-  /**
-   * Define the field-access pattern by matching on access flags.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any field-access
-   * flags.
-   *
-   * @return The field access-flag constraints that must be met.
-   */
-  val fieldAccess: Array<FieldAccessFlags> = [],
+    /**
+     * Define the field-access pattern by matching on access flags.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any
+     * field-access flags.
+     *
+     * @return The field access-flag constraints that must be met.
+     */
+    val fieldAccess: Array<FieldAccessFlags> = [],
 
-  /**
-   * Define the field-name pattern by an exact field name.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any field name.
-   *
-   * <p>
-   * Mutually exclusive with the property `fieldNamePattern` also defining field-name.
-   *
-   * @return The exact field name of the field.
-   */
-  val fieldName: String = "",
+    /**
+     * Define the field-name pattern by an exact field name.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any field
+     * name.
+     *
+     * <p>
+     * Mutually exclusive with the property `fieldNamePattern` also defining field-name.
+     *
+     * @return The exact field name of the field.
+     */
+    val fieldName: String = "",
 
-  /**
-   * Define the field-name pattern by a string pattern.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any field name.
-   *
-   * <p>
-   * Mutually exclusive with the property `fieldName` also defining field-name.
-   *
-   * @return The string pattern of the field name.
-   */
-  val fieldNamePattern: StringPattern = StringPattern(exact = ""),
+    /**
+     * Define the field-name pattern by a string pattern.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any field
+     * name.
+     *
+     * <p>
+     * Mutually exclusive with the property `fieldName` also defining field-name.
+     *
+     * @return The string pattern of the field name.
+     */
+    val fieldNamePattern: StringPattern = StringPattern(exact = ""),
 
-  /**
-   * Define the field-type pattern by a fully qualified type.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-type:
-   * <ul>
-   * <li>fieldTypeConstant
-   * <li>fieldTypePattern
-   * </ul>
-   *
-   * @return The qualified type name for the field type.
-   */
-  val fieldType: String = "",
+    /**
+     * Define the field-type pattern by a fully qualified type.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-type:
+     * <ul>
+     * <li>fieldTypeConstant
+     * <li>fieldTypePattern
+     * </ul>
+     *
+     * @return The qualified type name for the field type.
+     */
+    val fieldType: String = "",
 
-  /**
-   * Define the field-type pattern by a class constant.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-type:
-   * <ul>
-   * <li>fieldType
-   * <li>fieldTypePattern
-   * </ul>
-   *
-   * @return The class constant for the field type.
-   */
-  val fieldTypeConstant: KClass<*> = Object::class,
+    /**
+     * Define the field-type pattern by a class constant.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-type:
+     * <ul>
+     * <li>fieldType
+     * <li>fieldTypePattern
+     * </ul>
+     *
+     * @return The class constant for the field type.
+     */
+    val fieldTypeConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the field-type pattern by a pattern on types.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-type:
-   * <ul>
-   * <li>fieldType
-   * <li>fieldTypeConstant
-   * </ul>
-   *
-   * @return The type pattern for the field type.
-   */
-  val fieldTypePattern: TypePattern = TypePattern(name = ""),
+    /**
+     * Define the field-type pattern by a pattern on types.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-type:
+     * <ul>
+     * <li>fieldType
+     * <li>fieldTypeConstant
+     * </ul>
+     *
+     * @return The type pattern for the field type.
+     */
+    val fieldTypePattern: TypePattern = TypePattern(name = ""),
 )

src/keepanno/java/androidx/annotation/keep/KeepCondition.kt

diff --git a/src/keepanno/java/androidx/annotation/keep/KeepCondition.kt b/src/keepanno/java/androidx/annotation/keep/KeepCondition.kt
index e149232..58a127e 100644
--- a/src/keepanno/java/androidx/annotation/keep/KeepCondition.kt
+++ b/src/keepanno/java/androidx/annotation/keep/KeepCondition.kt
@@ -43,759 +43,767 @@
 @Target(AnnotationTarget.ANNOTATION_CLASS)
 public annotation class KeepCondition(
 
-  /**
-   * Define the class pattern by reference to a binding.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining class:
-   * <ul>
-   * <li>className
-   * <li>classConstant
-   * <li>classNamePattern
-   * <li>instanceOfClassName
-   * <li>instanceOfClassNameExclusive
-   * <li>instanceOfClassConstant
-   * <li>instanceOfClassConstantExclusive
-   * <li>instanceOfPattern
-   * <li>classAnnotatedByClassName
-   * <li>classAnnotatedByClassConstant
-   * <li>classAnnotatedByClassNamePattern
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class.
-   *
-   * @return The name of the binding that defines the class.
-   */
-  val classFromBinding: String = "",
+    /**
+     * Define the class pattern by reference to a binding.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining class:
+     * <ul>
+     * <li>className
+     * <li>classConstant
+     * <li>classNamePattern
+     * <li>instanceOfClassName
+     * <li>instanceOfClassNameExclusive
+     * <li>instanceOfClassConstant
+     * <li>instanceOfClassConstantExclusive
+     * <li>instanceOfPattern
+     * <li>classAnnotatedByClassName
+     * <li>classAnnotatedByClassConstant
+     * <li>classAnnotatedByClassNamePattern
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class.
+     *
+     * @return The name of the binding that defines the class.
+     */
+    val classFromBinding: String = "",
 
-  /**
-   * Define the class-name pattern by fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining class-name:
-   * <ul>
-   * <li>classConstant
-   * <li>classNamePattern
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class name.
-   *
-   * @return The qualified class name that defines the class.
-   */
-  val className: String = "",
+    /**
+     * Define the class-name pattern by fully qualified class name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining class-name:
+     * <ul>
+     * <li>classConstant
+     * <li>classNamePattern
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class name.
+     *
+     * @return The qualified class name that defines the class.
+     */
+    val className: String = "",
 
-  /**
-   * Define the class-name pattern by reference to a Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining class-name:
-   * <ul>
-   * <li>className
-   * <li>classNamePattern
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class name.
-   *
-   * @return The class-constant that defines the class.
-   */
-  val classConstant: KClass<*> = Object::class,
+    /**
+     * Define the class-name pattern by reference to a Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining class-name:
+     * <ul>
+     * <li>className
+     * <li>classNamePattern
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class name.
+     *
+     * @return The class-constant that defines the class.
+     */
+    val classConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the class-name pattern by reference to a class-name pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining class-name:
-   * <ul>
-   * <li>className
-   * <li>classConstant
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class name.
-   *
-   * @return The class-name pattern that defines the class.
-   */
-  val classNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
+    /**
+     * Define the class-name pattern by reference to a class-name pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining class-name:
+     * <ul>
+     * <li>className
+     * <li>classConstant
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class name.
+     *
+     * @return The class-name pattern that defines the class.
+     */
+    val classNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
 
-  /**
-   * Define the instance-of pattern as classes that are instances of the fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining instance-of:
-   * <ul>
-   * <li>instanceOfClassNameExclusive
-   * <li>instanceOfClassConstant
-   * <li>instanceOfClassConstantExclusive
-   * <li>instanceOfPattern
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class instance.
-   *
-   * @return The qualified class name that defines what instance-of the class must be.
-   */
-  val instanceOfClassName: String = "",
+    /**
+     * Define the instance-of pattern as classes that are instances of the fully qualified class
+     * name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining instance-of:
+     * <ul>
+     * <li>instanceOfClassNameExclusive
+     * <li>instanceOfClassConstant
+     * <li>instanceOfClassConstantExclusive
+     * <li>instanceOfPattern
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class instance.
+     *
+     * @return The qualified class name that defines what instance-of the class must be.
+     */
+    val instanceOfClassName: String = "",
 
-  /**
-   * Define the instance-of pattern as classes that are instances of the fully qualified class name.
-   *
-   * <p>
-   * The pattern is exclusive in that it does not match classes that are instances of the pattern,
-   * but only those that are instances of classes that are subclasses of the pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining instance-of:
-   * <ul>
-   * <li>instanceOfClassName
-   * <li>instanceOfClassConstant
-   * <li>instanceOfClassConstantExclusive
-   * <li>instanceOfPattern
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class instance.
-   *
-   * @return The qualified class name that defines what instance-of the class must be.
-   */
-  val instanceOfClassNameExclusive: String = "",
+    /**
+     * Define the instance-of pattern as classes that are instances of the fully qualified class
+     * name.
+     *
+     * <p>
+     * The pattern is exclusive in that it does not match classes that are instances of the pattern,
+     * but only those that are instances of classes that are subclasses of the pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining instance-of:
+     * <ul>
+     * <li>instanceOfClassName
+     * <li>instanceOfClassConstant
+     * <li>instanceOfClassConstantExclusive
+     * <li>instanceOfPattern
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class instance.
+     *
+     * @return The qualified class name that defines what instance-of the class must be.
+     */
+    val instanceOfClassNameExclusive: String = "",
 
-  /**
-   * Define the instance-of pattern as classes that are instances the referenced Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining instance-of:
-   * <ul>
-   * <li>instanceOfClassName
-   * <li>instanceOfClassNameExclusive
-   * <li>instanceOfClassConstantExclusive
-   * <li>instanceOfPattern
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class instance.
-   *
-   * @return The class constant that defines what instance-of the class must be.
-   */
-  val instanceOfClassConstant: KClass<*> = Object::class,
+    /**
+     * Define the instance-of pattern as classes that are instances the referenced Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining instance-of:
+     * <ul>
+     * <li>instanceOfClassName
+     * <li>instanceOfClassNameExclusive
+     * <li>instanceOfClassConstantExclusive
+     * <li>instanceOfPattern
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class instance.
+     *
+     * @return The class constant that defines what instance-of the class must be.
+     */
+    val instanceOfClassConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the instance-of pattern as classes that are instances the referenced Class constant.
-   *
-   * <p>
-   * The pattern is exclusive in that it does not match classes that are instances of the pattern,
-   * but only those that are instances of classes that are subclasses of the pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining instance-of:
-   * <ul>
-   * <li>instanceOfClassName
-   * <li>instanceOfClassNameExclusive
-   * <li>instanceOfClassConstant
-   * <li>instanceOfPattern
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class instance.
-   *
-   * @return The class constant that defines what instance-of the class must be.
-   */
-  val instanceOfClassConstantExclusive: KClass<*> = Object::class,
+    /**
+     * Define the instance-of pattern as classes that are instances the referenced Class constant.
+     *
+     * <p>
+     * The pattern is exclusive in that it does not match classes that are instances of the pattern,
+     * but only those that are instances of classes that are subclasses of the pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining instance-of:
+     * <ul>
+     * <li>instanceOfClassName
+     * <li>instanceOfClassNameExclusive
+     * <li>instanceOfClassConstant
+     * <li>instanceOfPattern
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class instance.
+     *
+     * @return The class constant that defines what instance-of the class must be.
+     */
+    val instanceOfClassConstantExclusive: KClass<*> = Object::class,
 
-  /**
-   * Define the instance-of with a pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining instance-of:
-   * <ul>
-   * <li>instanceOfClassName
-   * <li>instanceOfClassNameExclusive
-   * <li>instanceOfClassConstant
-   * <li>instanceOfClassConstantExclusive
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class instance.
-   *
-   * @return The pattern that defines what instance-of the class must be.
-   */
-  val instanceOfPattern: InstanceOfPattern = InstanceOfPattern(),
+    /**
+     * Define the instance-of with a pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining instance-of:
+     * <ul>
+     * <li>instanceOfClassName
+     * <li>instanceOfClassNameExclusive
+     * <li>instanceOfClassConstant
+     * <li>instanceOfClassConstantExclusive
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class instance.
+     *
+     * @return The pattern that defines what instance-of the class must be.
+     */
+    val instanceOfPattern: InstanceOfPattern = InstanceOfPattern(),
 
-  /**
-   * Define the class-annotated-by pattern by fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining class-annotated-by:
-   * <ul>
-   * <li>classAnnotatedByClassConstant
-   * <li>classAnnotatedByClassNamePattern
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class regardless of what the class is
-   * annotated by.
-   *
-   * @return The qualified class name that defines the annotation.
-   */
-  val classAnnotatedByClassName: String = "",
+    /**
+     * Define the class-annotated-by pattern by fully qualified class name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining class-annotated-by:
+     * <ul>
+     * <li>classAnnotatedByClassConstant
+     * <li>classAnnotatedByClassNamePattern
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class regardless of what the class is
+     * annotated by.
+     *
+     * @return The qualified class name that defines the annotation.
+     */
+    val classAnnotatedByClassName: String = "",
 
-  /**
-   * Define the class-annotated-by pattern by reference to a Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining class-annotated-by:
-   * <ul>
-   * <li>classAnnotatedByClassName
-   * <li>classAnnotatedByClassNamePattern
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class regardless of what the class is
-   * annotated by.
-   *
-   * @return The class-constant that defines the annotation.
-   */
-  val classAnnotatedByClassConstant: KClass<*> = Object::class,
+    /**
+     * Define the class-annotated-by pattern by reference to a Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining class-annotated-by:
+     * <ul>
+     * <li>classAnnotatedByClassName
+     * <li>classAnnotatedByClassNamePattern
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class regardless of what the class is
+     * annotated by.
+     *
+     * @return The class-constant that defines the annotation.
+     */
+    val classAnnotatedByClassConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the class-annotated-by pattern by reference to a class-name pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining class-annotated-by:
-   * <ul>
-   * <li>classAnnotatedByClassName
-   * <li>classAnnotatedByClassConstant
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class regardless of what the class is
-   * annotated by.
-   *
-   * @return The class-name pattern that defines the annotation.
-   */
-  val classAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
+    /**
+     * Define the class-annotated-by pattern by reference to a class-name pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining class-annotated-by:
+     * <ul>
+     * <li>classAnnotatedByClassName
+     * <li>classAnnotatedByClassConstant
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class regardless of what the class is
+     * annotated by.
+     *
+     * @return The class-name pattern that defines the annotation.
+     */
+    val classAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
 
-  /**
-   * Define the member pattern in full by a reference to a binding.
-   *
-   * <p>
-   * Mutually exclusive with all other class and member pattern properties. When a member binding is
-   * referenced this item is defined to be that item, including its class and member patterns.
-   *
-   * @return The binding name that defines the member.
-   */
-  val memberFromBinding: String = "",
+    /**
+     * Define the member pattern in full by a reference to a binding.
+     *
+     * <p>
+     * Mutually exclusive with all other class and member pattern properties. When a member binding
+     * is referenced this item is defined to be that item, including its class and member patterns.
+     *
+     * @return The binding name that defines the member.
+     */
+    val memberFromBinding: String = "",
 
-  /**
-   * Define the member-annotated-by pattern by fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining member-annotated-by:
-   * <ul>
-   * <li>memberAnnotatedByClassConstant
-   * <li>memberAnnotatedByClassNamePattern
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field and method properties as use restricts the match to both
-   * types of members.
-   *
-   * <p>
-   * If none are specified the default is to match any member regardless of what the member is
-   * annotated by.
-   *
-   * @return The qualified class name that defines the annotation.
-   */
-  val memberAnnotatedByClassName: String = "",
+    /**
+     * Define the member-annotated-by pattern by fully qualified class name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining member-annotated-by:
+     * <ul>
+     * <li>memberAnnotatedByClassConstant
+     * <li>memberAnnotatedByClassNamePattern
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field and method properties as use restricts the match to both
+     * types of members.
+     *
+     * <p>
+     * If none are specified the default is to match any member regardless of what the member is
+     * annotated by.
+     *
+     * @return The qualified class name that defines the annotation.
+     */
+    val memberAnnotatedByClassName: String = "",
 
-  /**
-   * Define the member-annotated-by pattern by reference to a Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining member-annotated-by:
-   * <ul>
-   * <li>memberAnnotatedByClassName
-   * <li>memberAnnotatedByClassNamePattern
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field and method properties as use restricts the match to both
-   * types of members.
-   *
-   * <p>
-   * If none are specified the default is to match any member regardless of what the member is
-   * annotated by.
-   *
-   * @return The class-constant that defines the annotation.
-   */
-  val memberAnnotatedByClassConstant: KClass<*> = Object::class,
+    /**
+     * Define the member-annotated-by pattern by reference to a Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining member-annotated-by:
+     * <ul>
+     * <li>memberAnnotatedByClassName
+     * <li>memberAnnotatedByClassNamePattern
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field and method properties as use restricts the match to both
+     * types of members.
+     *
+     * <p>
+     * If none are specified the default is to match any member regardless of what the member is
+     * annotated by.
+     *
+     * @return The class-constant that defines the annotation.
+     */
+    val memberAnnotatedByClassConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the member-annotated-by pattern by reference to a class-name pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining member-annotated-by:
-   * <ul>
-   * <li>memberAnnotatedByClassName
-   * <li>memberAnnotatedByClassConstant
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field and method properties as use restricts the match to both
-   * types of members.
-   *
-   * <p>
-   * If none are specified the default is to match any member regardless of what the member is
-   * annotated by.
-   *
-   * @return The class-name pattern that defines the annotation.
-   */
-  val memberAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
+    /**
+     * Define the member-annotated-by pattern by reference to a class-name pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining member-annotated-by:
+     * <ul>
+     * <li>memberAnnotatedByClassName
+     * <li>memberAnnotatedByClassConstant
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field and method properties as use restricts the match to both
+     * types of members.
+     *
+     * <p>
+     * If none are specified the default is to match any member regardless of what the member is
+     * annotated by.
+     *
+     * @return The class-name pattern that defines the annotation.
+     */
+    val memberAnnotatedByClassNamePattern: ClassNamePattern =
+        ClassNamePattern(unqualifiedName = ""),
 
-  /**
-   * Define the member-access pattern by matching on access flags.
-   *
-   * <p>
-   * Mutually exclusive with all field and method properties as use restricts the match to both
-   * types of members.
-   *
-   * <p>
-   * Mutually exclusive with the property `memberFromBinding` also defining member-access.
-   *
-   * @return The member access-flag constraints that must be met.
-   */
-  val memberAccess: Array<MemberAccessFlags> = [],
+    /**
+     * Define the member-access pattern by matching on access flags.
+     *
+     * <p>
+     * Mutually exclusive with all field and method properties as use restricts the match to both
+     * types of members.
+     *
+     * <p>
+     * Mutually exclusive with the property `memberFromBinding` also defining member-access.
+     *
+     * @return The member access-flag constraints that must be met.
+     */
+    val memberAccess: Array<MemberAccessFlags> = [],
 
-  /**
-   * Define the method-annotated-by pattern by fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining method-annotated-by:
-   * <ul>
-   * <li>methodAnnotatedByClassConstant
-   * <li>methodAnnotatedByClassNamePattern
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none are specified the default is to match any method regardless of what the method is
-   * annotated by.
-   *
-   * @return The qualified class name that defines the annotation.
-   */
-  val methodAnnotatedByClassName: String = "",
+    /**
+     * Define the method-annotated-by pattern by fully qualified class name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining method-annotated-by:
+     * <ul>
+     * <li>methodAnnotatedByClassConstant
+     * <li>methodAnnotatedByClassNamePattern
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none are specified the default is to match any method regardless of what the method is
+     * annotated by.
+     *
+     * @return The qualified class name that defines the annotation.
+     */
+    val methodAnnotatedByClassName: String = "",
 
-  /**
-   * Define the method-annotated-by pattern by reference to a Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining method-annotated-by:
-   * <ul>
-   * <li>methodAnnotatedByClassName
-   * <li>methodAnnotatedByClassNamePattern
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none are specified the default is to match any method regardless of what the method is
-   * annotated by.
-   *
-   * @return The class-constant that defines the annotation.
-   */
-  val methodAnnotatedByClassConstant: KClass<*> = Object::class,
+    /**
+     * Define the method-annotated-by pattern by reference to a Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining method-annotated-by:
+     * <ul>
+     * <li>methodAnnotatedByClassName
+     * <li>methodAnnotatedByClassNamePattern
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none are specified the default is to match any method regardless of what the method is
+     * annotated by.
+     *
+     * @return The class-constant that defines the annotation.
+     */
+    val methodAnnotatedByClassConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the method-annotated-by pattern by reference to a class-name pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining method-annotated-by:
-   * <ul>
-   * <li>methodAnnotatedByClassName
-   * <li>methodAnnotatedByClassConstant
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none are specified the default is to match any method regardless of what the method is
-   * annotated by.
-   *
-   * @return The class-name pattern that defines the annotation.
-   */
-  val methodAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
+    /**
+     * Define the method-annotated-by pattern by reference to a class-name pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining method-annotated-by:
+     * <ul>
+     * <li>methodAnnotatedByClassName
+     * <li>methodAnnotatedByClassConstant
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none are specified the default is to match any method regardless of what the method is
+     * annotated by.
+     *
+     * @return The class-name pattern that defines the annotation.
+     */
+    val methodAnnotatedByClassNamePattern: ClassNamePattern =
+        ClassNamePattern(unqualifiedName = ""),
 
-  /**
-   * Define the method-access pattern by matching on access flags.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any
-   * method-access flags.
-   *
-   * <p>
-   * Mutually exclusive with the property `memberFromBinding` also defining method-access.
-   *
-   * @return The method access-flag constraints that must be met.
-   */
-  val methodAccess: Array<MethodAccessFlags> = [],
+    /**
+     * Define the method-access pattern by matching on access flags.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any
+     * method-access flags.
+     *
+     * <p>
+     * Mutually exclusive with the property `memberFromBinding` also defining method-access.
+     *
+     * @return The method access-flag constraints that must be met.
+     */
+    val methodAccess: Array<MethodAccessFlags> = [],
 
-  /**
-   * Define the method-name pattern by an exact method name.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any method
-   * name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining method-name:
-   * <ul>
-   * <li>methodNamePattern
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * @return The exact method name of the method.
-   */
-  val methodName: String = "",
+    /**
+     * Define the method-name pattern by an exact method name.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any method
+     * name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining method-name:
+     * <ul>
+     * <li>methodNamePattern
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * @return The exact method name of the method.
+     */
+    val methodName: String = "",
 
-  /**
-   * Define the method-name pattern by a string pattern.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any method
-   * name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining method-name:
-   * <ul>
-   * <li>methodName
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * @return The string pattern of the method name.
-   */
-  val methodNamePattern: StringPattern = StringPattern(exact = ""),
+    /**
+     * Define the method-name pattern by a string pattern.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any method
+     * name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining method-name:
+     * <ul>
+     * <li>methodName
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * @return The string pattern of the method name.
+     */
+    val methodNamePattern: StringPattern = StringPattern(exact = ""),
 
-  /**
-   * Define the method return-type pattern by a fully qualified type or 'void'.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any return
-   * type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining return-type:
-   * <ul>
-   * <li>methodReturnTypeConstant
-   * <li>methodReturnTypePattern
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * @return The qualified type name of the method return type.
-   */
-  val methodReturnType: String = "",
+    /**
+     * Define the method return-type pattern by a fully qualified type or 'void'.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any return
+     * type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining return-type:
+     * <ul>
+     * <li>methodReturnTypeConstant
+     * <li>methodReturnTypePattern
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * @return The qualified type name of the method return type.
+     */
+    val methodReturnType: String = "",
 
-  /**
-   * Define the method return-type pattern by a class constant.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any return
-   * type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining return-type:
-   * <ul>
-   * <li>methodReturnType
-   * <li>methodReturnTypePattern
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * @return A class constant denoting the type of the method return type.
-   */
-  val methodReturnTypeConstant: KClass<*> = Object::class,
+    /**
+     * Define the method return-type pattern by a class constant.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any return
+     * type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining return-type:
+     * <ul>
+     * <li>methodReturnType
+     * <li>methodReturnTypePattern
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * @return A class constant denoting the type of the method return type.
+     */
+    val methodReturnTypeConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the method return-type pattern by a type pattern.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any return
-   * type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining return-type:
-   * <ul>
-   * <li>methodReturnType
-   * <li>methodReturnTypeConstant
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * @return The pattern of the method return type.
-   */
-  val methodReturnTypePattern: TypePattern = TypePattern(name = ""),
+    /**
+     * Define the method return-type pattern by a type pattern.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any return
+     * type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining return-type:
+     * <ul>
+     * <li>methodReturnType
+     * <li>methodReturnTypeConstant
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * @return The pattern of the method return type.
+     */
+    val methodReturnTypePattern: TypePattern = TypePattern(name = ""),
 
-  /**
-   * Define the method parameters pattern by a list of fully qualified types.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any parameters.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining parameters:
-   * <ul>
-   * <li>methodParameterTypePatterns
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * @return The list of qualified type names of the method parameters.
-   */
-  val methodParameters: Array<String> = [""],
+    /**
+     * Define the method parameters pattern by a list of fully qualified types.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any
+     * parameters.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining parameters:
+     * <ul>
+     * <li>methodParameterTypePatterns
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * @return The list of qualified type names of the method parameters.
+     */
+    val methodParameters: Array<String> = [""],
 
-  /**
-   * Define the method parameters pattern by a list of patterns on types.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any parameters.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining parameters:
-   * <ul>
-   * <li>methodParameters
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * @return The list of type patterns for the method parameters.
-   */
-  val methodParameterTypePatterns: Array<TypePattern> = [TypePattern(name = "")],
+    /**
+     * Define the method parameters pattern by a list of patterns on types.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any
+     * parameters.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining parameters:
+     * <ul>
+     * <li>methodParameters
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * @return The list of type patterns for the method parameters.
+     */
+    val methodParameterTypePatterns: Array<TypePattern> = [TypePattern(name = "")],
 
-  /**
-   * Define the field-annotated-by pattern by fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-annotated-by:
-   * <ul>
-   * <li>fieldAnnotatedByClassConstant
-   * <li>fieldAnnotatedByClassNamePattern
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none are specified the default is to match any field regardless of what the field is
-   * annotated by.
-   *
-   * @return The qualified class name that defines the annotation.
-   */
-  val fieldAnnotatedByClassName: String = "",
+    /**
+     * Define the field-annotated-by pattern by fully qualified class name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-annotated-by:
+     * <ul>
+     * <li>fieldAnnotatedByClassConstant
+     * <li>fieldAnnotatedByClassNamePattern
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none are specified the default is to match any field regardless of what the field is
+     * annotated by.
+     *
+     * @return The qualified class name that defines the annotation.
+     */
+    val fieldAnnotatedByClassName: String = "",
 
-  /**
-   * Define the field-annotated-by pattern by reference to a Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-annotated-by:
-   * <ul>
-   * <li>fieldAnnotatedByClassName
-   * <li>fieldAnnotatedByClassNamePattern
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none are specified the default is to match any field regardless of what the field is
-   * annotated by.
-   *
-   * @return The class-constant that defines the annotation.
-   */
-  val fieldAnnotatedByClassConstant: KClass<*> = Object::class,
+    /**
+     * Define the field-annotated-by pattern by reference to a Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-annotated-by:
+     * <ul>
+     * <li>fieldAnnotatedByClassName
+     * <li>fieldAnnotatedByClassNamePattern
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none are specified the default is to match any field regardless of what the field is
+     * annotated by.
+     *
+     * @return The class-constant that defines the annotation.
+     */
+    val fieldAnnotatedByClassConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the field-annotated-by pattern by reference to a class-name pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-annotated-by:
-   * <ul>
-   * <li>fieldAnnotatedByClassName
-   * <li>fieldAnnotatedByClassConstant
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none are specified the default is to match any field regardless of what the field is
-   * annotated by.
-   *
-   * @return The class-name pattern that defines the annotation.
-   */
-  val fieldAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
+    /**
+     * Define the field-annotated-by pattern by reference to a class-name pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-annotated-by:
+     * <ul>
+     * <li>fieldAnnotatedByClassName
+     * <li>fieldAnnotatedByClassConstant
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none are specified the default is to match any field regardless of what the field is
+     * annotated by.
+     *
+     * @return The class-name pattern that defines the annotation.
+     */
+    val fieldAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
 
-  /**
-   * Define the field-access pattern by matching on access flags.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any field-access
-   * flags.
-   *
-   * <p>
-   * Mutually exclusive with the property `memberFromBinding` also defining field-access.
-   *
-   * @return The field access-flag constraints that must be met.
-   */
-  val fieldAccess: Array<FieldAccessFlags> = [],
+    /**
+     * Define the field-access pattern by matching on access flags.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any
+     * field-access flags.
+     *
+     * <p>
+     * Mutually exclusive with the property `memberFromBinding` also defining field-access.
+     *
+     * @return The field access-flag constraints that must be met.
+     */
+    val fieldAccess: Array<FieldAccessFlags> = [],
 
-  /**
-   * Define the field-name pattern by an exact field name.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any field name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-name:
-   * <ul>
-   * <li>fieldNamePattern
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * @return The exact field name of the field.
-   */
-  val fieldName: String = "",
+    /**
+     * Define the field-name pattern by an exact field name.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any field
+     * name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-name:
+     * <ul>
+     * <li>fieldNamePattern
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * @return The exact field name of the field.
+     */
+    val fieldName: String = "",
 
-  /**
-   * Define the field-name pattern by a string pattern.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any field name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-name:
-   * <ul>
-   * <li>fieldName
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * @return The string pattern of the field name.
-   */
-  val fieldNamePattern: StringPattern = StringPattern(exact = ""),
+    /**
+     * Define the field-name pattern by a string pattern.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any field
+     * name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-name:
+     * <ul>
+     * <li>fieldName
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * @return The string pattern of the field name.
+     */
+    val fieldNamePattern: StringPattern = StringPattern(exact = ""),
 
-  /**
-   * Define the field-type pattern by a fully qualified type.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-type:
-   * <ul>
-   * <li>fieldTypeConstant
-   * <li>fieldTypePattern
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * @return The qualified type name for the field type.
-   */
-  val fieldType: String = "",
+    /**
+     * Define the field-type pattern by a fully qualified type.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-type:
+     * <ul>
+     * <li>fieldTypeConstant
+     * <li>fieldTypePattern
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * @return The qualified type name for the field type.
+     */
+    val fieldType: String = "",
 
-  /**
-   * Define the field-type pattern by a class constant.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-type:
-   * <ul>
-   * <li>fieldType
-   * <li>fieldTypePattern
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * @return The class constant for the field type.
-   */
-  val fieldTypeConstant: KClass<*> = Object::class,
+    /**
+     * Define the field-type pattern by a class constant.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-type:
+     * <ul>
+     * <li>fieldType
+     * <li>fieldTypePattern
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * @return The class constant for the field type.
+     */
+    val fieldTypeConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the field-type pattern by a pattern on types.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-type:
-   * <ul>
-   * <li>fieldType
-   * <li>fieldTypeConstant
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * @return The type pattern for the field type.
-   */
-  val fieldTypePattern: TypePattern = TypePattern(name = ""),
+    /**
+     * Define the field-type pattern by a pattern on types.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-type:
+     * <ul>
+     * <li>fieldType
+     * <li>fieldTypeConstant
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * @return The type pattern for the field type.
+     */
+    val fieldTypePattern: TypePattern = TypePattern(name = ""),
 )

src/keepanno/java/androidx/annotation/keep/KeepConstraint.kt

diff --git a/src/keepanno/java/androidx/annotation/keep/KeepConstraint.kt b/src/keepanno/java/androidx/annotation/keep/KeepConstraint.kt
index f98d91b..a1aef00 100644
--- a/src/keepanno/java/androidx/annotation/keep/KeepConstraint.kt
+++ b/src/keepanno/java/androidx/annotation/keep/KeepConstraint.kt
@@ -31,210 +31,211 @@
  * method.
  */
 public enum class KeepConstraint {
-  /**
-   * Indicates that the target item is being looked up reflectively.
-   *
-   * <p>Looking up an item reflectively requires that it remains on its expected context, which for
-   * a method or field means it must remain on its defining class. In other words, the item cannot
-   * be removed or moved.
-   *
-   * <p>Note that looking up a member does not imply that the holder class of the member can be
-   * looked up. If both the class and the member need to be looked, make sure to have a target for
-   * both.
-   *
-   * <p>Note also that the item can be looked up within its context but no constraint is placed on
-   * its name, accessibility or any other properties of the item.
-   *
-   * <p>If assumptions are being made about other aspects, additional constraints and targets should
-   * be added to the keep annotation.
-   */
-  LOOKUP,
+    /**
+     * Indicates that the target item is being looked up reflectively.
+     *
+     * <p>Looking up an item reflectively requires that it remains on its expected context, which
+     * for a method or field means it must remain on its defining class. In other words, the item
+     * cannot be removed or moved.
+     *
+     * <p>Note that looking up a member does not imply that the holder class of the member can be
+     * looked up. If both the class and the member need to be looked, make sure to have a target for
+     * both.
+     *
+     * <p>Note also that the item can be looked up within its context but no constraint is placed on
+     * its name, accessibility or any other properties of the item.
+     *
+     * <p>If assumptions are being made about other aspects, additional constraints and targets
+     * should be added to the keep annotation.
+     */
+    LOOKUP,
 
-  /**
-   * Indicates that the name of the target item is being used.
-   *
-   * <p>This usage constraint is needed if the target is being looked up reflectively by using its
-   * name. Setting it will prohibit renaming of the target item.
-   *
-   * <p>Note that preserving the name of a member does not imply that the holder class of the member
-   * will preserve its qualified or simple name. If both the class and the member need to preserve
-   * their names, make sure to have a target for both.
-   *
-   * <p>Note that preserving the name of a member does not preserve the types of its parameters or
-   * its return type for methods or the type for fields.
-   */
-  NAME,
+    /**
+     * Indicates that the name of the target item is being used.
+     *
+     * <p>This usage constraint is needed if the target is being looked up reflectively by using its
+     * name. Setting it will prohibit renaming of the target item.
+     *
+     * <p>Note that preserving the name of a member does not imply that the holder class of the
+     * member will preserve its qualified or simple name. If both the class and the member need to
+     * preserve their names, make sure to have a target for both.
+     *
+     * <p>Note that preserving the name of a member does not preserve the types of its parameters or
+     * its return type for methods or the type for fields.
+     */
+    NAME,
 
-  /**
-   * Indicates that the visibility of the target must be at least as visible as declared.
-   *
-   * <p>Setting this constraint ensures that any (reflective) access to the target that is allowed
-   * remains valid. In other words, a public class, field or method must remain public. For a
-   * non-public target its visibility may be relaxed in the direction: {@code private ->
-   * package-private -> protected -> public}.
-   *
-   * <p>Note that this constraint does not place any restrictions on any other accesses flags than
-   * visibility. In particular, flags such a static, final and abstract may change.
-   *
-   * <p>Used together with {@link #VISIBILITY_RESTRICT} the visibility will remain invariant.
-   */
-  VISIBILITY_RELAX,
+    /**
+     * Indicates that the visibility of the target must be at least as visible as declared.
+     *
+     * <p>Setting this constraint ensures that any (reflective) access to the target that is allowed
+     * remains valid. In other words, a public class, field or method must remain public. For a
+     * non-public target its visibility may be relaxed in the direction: {@code private ->
+     * package-private -> protected -> public}.
+     *
+     * <p>Note that this constraint does not place any restrictions on any other accesses flags than
+     * visibility. In particular, flags such a static, final and abstract may change.
+     *
+     * <p>Used together with {@link #VISIBILITY_RESTRICT} the visibility will remain invariant.
+     */
+    VISIBILITY_RELAX,
 
-  /**
-   * Indicates that the visibility of the target must be at most as visible as declared.
-   *
-   * <p>Setting this constraint ensures that any (reflective) access to the target that would fail
-   * will continue to fail. In other words, a private class, field or method must remain private.
-   * Concretely the visibility of the target item may be restricted in the direction: {@code public
-   * -> protected -> package-private -> private}.
-   *
-   * <p>Note that this constraint does not place any restrictions on any other accesses flags than
-   * visibility. In particular, flags such a static, final and abstract may change.
-   *
-   * <p>Used together with {@link #VISIBILITY_RELAX} the visibility will remain invariant.
-   */
-  VISIBILITY_RESTRICT,
+    /**
+     * Indicates that the visibility of the target must be at most as visible as declared.
+     *
+     * <p>Setting this constraint ensures that any (reflective) access to the target that would fail
+     * will continue to fail. In other words, a private class, field or method must remain private.
+     * Concretely the visibility of the target item may be restricted in the direction: {@code
+     * public -> protected -> package-private -> private}.
+     *
+     * <p>Note that this constraint does not place any restrictions on any other accesses flags than
+     * visibility. In particular, flags such a static, final and abstract may change.
+     *
+     * <p>Used together with {@link #VISIBILITY_RELAX} the visibility will remain invariant.
+     */
+    VISIBILITY_RESTRICT,
 
-  /**
-   * Indicates that the visibility of the target must remain as declared.
-   *
-   * <p>Note that this constraint does not place any restrictions on any other accesses flags than
-   * visibility. In particular, flags such a static, final and abstract may change.
-   *
-   * <p>This is equivalent to using both {@link #VISIBILITY_RELAX} and {@link #VISIBILITY_RESTRICT}.
-   */
-  VISIBILITY_INVARIANT,
+    /**
+     * Indicates that the visibility of the target must remain as declared.
+     *
+     * <p>Note that this constraint does not place any restrictions on any other accesses flags than
+     * visibility. In particular, flags such a static, final and abstract may change.
+     *
+     * <p>This is equivalent to using both {@link #VISIBILITY_RELAX} and
+     * {@link #VISIBILITY_RESTRICT}.
+     */
+    VISIBILITY_INVARIANT,
 
-  /**
-   * Indicates that the class target is being instantiated reflectively.
-   *
-   * <p>This usage constraint is only valid on class targets.
-   *
-   * <p>Being instantiated prohibits reasoning about the class instances at compile time. In other
-   * words, the compiler must assume the class to be possibly instantiated at all times.
-   *
-   * <p>Note that the constraint {@link KeepConstraint#LOOKUP} is needed to reflectively obtain a
-   * class. This constraint only implies that if the class is referenced in the program it may be
-   * instantiated.
-   */
-  CLASS_INSTANTIATE,
+    /**
+     * Indicates that the class target is being instantiated reflectively.
+     *
+     * <p>This usage constraint is only valid on class targets.
+     *
+     * <p>Being instantiated prohibits reasoning about the class instances at compile time. In other
+     * words, the compiler must assume the class to be possibly instantiated at all times.
+     *
+     * <p>Note that the constraint {@link KeepConstraint#LOOKUP} is needed to reflectively obtain a
+     * class. This constraint only implies that if the class is referenced in the program it may be
+     * instantiated.
+     */
+    CLASS_INSTANTIATE,
 
-  /**
-   * Indicates that the method target is being invoked reflectively.
-   *
-   * <p>This usage constraint is only valid on method targets.
-   *
-   * <p>To be invoked reflectively the method must retain the structure of the method. Thus, unused
-   * arguments cannot be removed. However, it does not imply preserving the types of its parameters
-   * or its return type. If the parameter types are being obtained reflectively then those need a
-   * keep target independent of the method.
-   *
-   * <p>Note that the constraint {@link KeepConstraint#LOOKUP} is needed to reflectively obtain a
-   * method reference. This constraint only implies that if the method is referenced in the program
-   * it may be reflectively invoked.
-   */
-  METHOD_INVOKE,
+    /**
+     * Indicates that the method target is being invoked reflectively.
+     *
+     * <p>This usage constraint is only valid on method targets.
+     *
+     * <p>To be invoked reflectively the method must retain the structure of the method. Thus,
+     * unused arguments cannot be removed. However, it does not imply preserving the types of its
+     * parameters or its return type. If the parameter types are being obtained reflectively then
+     * those need a keep target independent of the method.
+     *
+     * <p>Note that the constraint {@link KeepConstraint#LOOKUP} is needed to reflectively obtain a
+     * method reference. This constraint only implies that if the method is referenced in the
+     * program it may be reflectively invoked.
+     */
+    METHOD_INVOKE,
 
-  /**
-   * Indicates that the field target is reflectively read from.
-   *
-   * <p>This usage constraint is only valid on field targets.
-   *
-   * <p>A field that has its value read from, requires that the field value must remain. Thus, if
-   * field remains, its value cannot be replaced. It can still be removed in full, be inlined and
-   * its value reasoned about at compile time.
-   *
-   * <p>Note that the constraint {@link KeepConstraint#LOOKUP} is needed to reflectively obtain
-   * access to the field. This constraint only implies that if a field is referenced then it may be
-   * reflectively read.
-   */
-  FIELD_GET,
+    /**
+     * Indicates that the field target is reflectively read from.
+     *
+     * <p>This usage constraint is only valid on field targets.
+     *
+     * <p>A field that has its value read from, requires that the field value must remain. Thus, if
+     * field remains, its value cannot be replaced. It can still be removed in full, be inlined and
+     * its value reasoned about at compile time.
+     *
+     * <p>Note that the constraint {@link KeepConstraint#LOOKUP} is needed to reflectively obtain
+     * access to the field. This constraint only implies that if a field is referenced then it may
+     * be reflectively read.
+     */
+    FIELD_GET,
 
-  /**
-   * Indicates that the field target is reflectively written to.
-   *
-   * <p>This usage constraint is only valid on field targets.
-   *
-   * <p>A field that has its value written to, requires that the field value must be treated as
-   * unknown.
-   *
-   * <p>Note that the constraint {@link KeepConstraint#LOOKUP} is needed to reflectively obtain
-   * access to the field. This constraint only implies that if a field is referenced then it may be
-   * reflectively written.
-   */
-  FIELD_SET,
+    /**
+     * Indicates that the field target is reflectively written to.
+     *
+     * <p>This usage constraint is only valid on field targets.
+     *
+     * <p>A field that has its value written to, requires that the field value must be treated as
+     * unknown.
+     *
+     * <p>Note that the constraint {@link KeepConstraint#LOOKUP} is needed to reflectively obtain
+     * access to the field. This constraint only implies that if a field is referenced then it may
+     * be reflectively written.
+     */
+    FIELD_SET,
 
-  /**
-   * Indicates that the target method can be replaced by an alternative definition at runtime.
-   *
-   * <p>This usage constraint is only valid on method targets.
-   *
-   * <p>Replacing a method implies that the concrete implementation of the target cannot be known at
-   * compile time. Thus, it cannot be moved or otherwise assumed to have particular properties.
-   * Being able to replace the method still allows the compiler to fully remove it if it is
-   * statically found to be unused.
-   *
-   * <p>Note also that no restriction is placed on the method name. To ensure the same name add
-   * {@link #NAME} to the constraint set.
-   */
-  METHOD_REPLACE,
+    /**
+     * Indicates that the target method can be replaced by an alternative definition at runtime.
+     *
+     * <p>This usage constraint is only valid on method targets.
+     *
+     * <p>Replacing a method implies that the concrete implementation of the target cannot be known
+     * at compile time. Thus, it cannot be moved or otherwise assumed to have particular properties.
+     * Being able to replace the method still allows the compiler to fully remove it if it is
+     * statically found to be unused.
+     *
+     * <p>Note also that no restriction is placed on the method name. To ensure the same name add
+     * {@link #NAME} to the constraint set.
+     */
+    METHOD_REPLACE,
 
-  /**
-   * Indicates that the target field can be replaced by an alternative definition at runtime.
-   *
-   * <p>This usage constraint is only valid on field targets.
-   *
-   * <p>Replacing a field implies that the concrete implementation of the target cannot be known at
-   * compile time. Thus, it cannot be moved or otherwise assumed to have particular properties.
-   * Being able to replace the method still allows the compiler to fully remove it if it is
-   * statically found to be unused.
-   *
-   * <p>Note also that no restriction is placed on the field name. To ensure the same name add
-   * {@link #NAME} to the constraint set.
-   */
-  FIELD_REPLACE,
+    /**
+     * Indicates that the target field can be replaced by an alternative definition at runtime.
+     *
+     * <p>This usage constraint is only valid on field targets.
+     *
+     * <p>Replacing a field implies that the concrete implementation of the target cannot be known
+     * at compile time. Thus, it cannot be moved or otherwise assumed to have particular properties.
+     * Being able to replace the method still allows the compiler to fully remove it if it is
+     * statically found to be unused.
+     *
+     * <p>Note also that no restriction is placed on the field name. To ensure the same name add
+     * {@link #NAME} to the constraint set.
+     */
+    FIELD_REPLACE,
 
-  /**
-   * Indicates that the target item must never be inlined or merged.
-   *
-   * <p>This ensures that if the item is actually used in the program it will remain in some form.
-   * For example, a method may still be renamed, but it will be present as a frame in stack traces
-   * produced by the runtime (before potentially being retraced). For classes, they too may be
-   * renamed, but will not have been merged with other classes or have their allocations fully
-   * eliminated (aka class inlining).
-   *
-   * <p>For members this also ensures that the field value or method body cannot be reasoned about
-   * outside the item itself. For example, a field value cannot be assumed to be a particular value,
-   * and a method cannot be assumed to have particular properties for callers, such as always
-   * throwing or a constant return value.
-   */
-  NEVER_INLINE,
+    /**
+     * Indicates that the target item must never be inlined or merged.
+     *
+     * <p>This ensures that if the item is actually used in the program it will remain in some form.
+     * For example, a method may still be renamed, but it will be present as a frame in stack traces
+     * produced by the runtime (before potentially being retraced). For classes, they too may be
+     * renamed, but will not have been merged with other classes or have their allocations fully
+     * eliminated (aka class inlining).
+     *
+     * <p>For members this also ensures that the field value or method body cannot be reasoned about
+     * outside the item itself. For example, a field value cannot be assumed to be a particular
+     * value, and a method cannot be assumed to have particular properties for callers, such as
+     * always throwing or a constant return value.
+     */
+    NEVER_INLINE,
 
-  /**
-   * Indicates that the class hierarchy below the target class may be extended at runtime.
-   *
-   * <p>This ensures that new subtypes of the target class can later be linked and/or class loaded
-   * at runtime.
-   *
-   * <p>This does not ensure that the class remains if it is otherwise dead code and can be fully
-   * removed.
-   *
-   * <p>Note that this constraint does not ensure that particular methods remain on the target
-   * class. If methods or fields of the target class are being targeted by a subclass that was
-   * classloaded or linked later, then keep annotations are needed for those targets too. Such
-   * non-visible uses requires the same annotations to preserve as for reflective uses.
-   */
-  CLASS_OPEN_HIERARCHY,
+    /**
+     * Indicates that the class hierarchy below the target class may be extended at runtime.
+     *
+     * <p>This ensures that new subtypes of the target class can later be linked and/or class loaded
+     * at runtime.
+     *
+     * <p>This does not ensure that the class remains if it is otherwise dead code and can be fully
+     * removed.
+     *
+     * <p>Note that this constraint does not ensure that particular methods remain on the target
+     * class. If methods or fields of the target class are being targeted by a subclass that was
+     * classloaded or linked later, then keep annotations are needed for those targets too. Such
+     * non-visible uses requires the same annotations to preserve as for reflective uses.
+     */
+    CLASS_OPEN_HIERARCHY,
 
-  /**
-   * Indicates that the target item must retain its generic signature if present.
-   *
-   * <p>This ensures that the generic signature remains, but does not prohibit rewriting of the
-   * generic signature. For example, if a type present in the generic signature is renamed, the
-   * generic signature will also be updated to now refer to the type by its renamed name.
-   *
-   * <p>Note that this constraint does not otherwise restrict what can be done to the target, such
-   * as removing the target completely, inlining it, etc.
-   */
-  GENERIC_SIGNATURE,
+    /**
+     * Indicates that the target item must retain its generic signature if present.
+     *
+     * <p>This ensures that the generic signature remains, but does not prohibit rewriting of the
+     * generic signature. For example, if a type present in the generic signature is renamed, the
+     * generic signature will also be updated to now refer to the type by its renamed name.
+     *
+     * <p>Note that this constraint does not otherwise restrict what can be done to the target, such
+     * as removing the target completely, inlining it, etc.
+     */
+    GENERIC_SIGNATURE,
 }

src/keepanno/java/androidx/annotation/keep/KeepEdge.kt

diff --git a/src/keepanno/java/androidx/annotation/keep/KeepEdge.kt b/src/keepanno/java/androidx/annotation/keep/KeepEdge.kt
index dc30799..1f3af1f 100644
--- a/src/keepanno/java/androidx/annotation/keep/KeepEdge.kt
+++ b/src/keepanno/java/androidx/annotation/keep/KeepEdge.kt
@@ -25,16 +25,16 @@
 
 @Retention(AnnotationRetention.BINARY)
 @Target(
-  AnnotationTarget.TYPE,
-  AnnotationTarget.FIELD,
-  AnnotationTarget.FUNCTION,
-  AnnotationTarget.CONSTRUCTOR,
+    AnnotationTarget.TYPE,
+    AnnotationTarget.FIELD,
+    AnnotationTarget.FUNCTION,
+    AnnotationTarget.CONSTRUCTOR,
 )
 public annotation class KeepEdge(
-  val description: String = "",
+    val description: String = "",
 
-  //   val retention : Array<RetentionPolicy> = [RetentionPolicy.RUNTIME]
-  val bindings: Array<KeepBinding> = [],
-  val preconditions: Array<KeepCondition> = [],
-  val consequences: Array<KeepTarget> = [],
+    //   val retention : Array<RetentionPolicy> = [RetentionPolicy.RUNTIME]
+    val bindings: Array<KeepBinding> = [],
+    val preconditions: Array<KeepCondition> = [],
+    val consequences: Array<KeepTarget> = [],
 )

src/keepanno/java/androidx/annotation/keep/KeepForApi.kt

diff --git a/src/keepanno/java/androidx/annotation/keep/KeepForApi.kt b/src/keepanno/java/androidx/annotation/keep/KeepForApi.kt
index aecd426..1c27695 100644
--- a/src/keepanno/java/androidx/annotation/keep/KeepForApi.kt
+++ b/src/keepanno/java/androidx/annotation/keep/KeepForApi.kt
@@ -42,494 +42,501 @@
  */
 @Retention(AnnotationRetention.BINARY)
 @Target(
-  AnnotationTarget.CLASS,
-  AnnotationTarget.FIELD,
-  AnnotationTarget.FUNCTION,
-  AnnotationTarget.CONSTRUCTOR,
+    AnnotationTarget.CLASS,
+    AnnotationTarget.FIELD,
+    AnnotationTarget.FUNCTION,
+    AnnotationTarget.CONSTRUCTOR,
 )
 public annotation class KeepForApi(
 
-  /**
-   * Optional description to document the reason for this annotation.
-   *
-   * @return The descriptive message. Defaults to no description.
-   */
-  val description: String = "",
+    /**
+     * Optional description to document the reason for this annotation.
+     *
+     * @return The descriptive message. Defaults to no description.
+     */
+    val description: String = "",
 
-  /**
-   * Additional targets to be kept as part of the API surface.
-   *
-   * @return List of additional target consequences. Defaults to no additional target consequences.
-   */
-  val additionalTargets: Array<KeepTarget> = [],
+    /**
+     * Additional targets to be kept as part of the API surface.
+     *
+     * @return List of additional target consequences. Defaults to no additional target
+     *   consequences.
+     */
+    val additionalTargets: Array<KeepTarget> = [],
 
-  /**
-   * Specify the kind of this item pattern.
-   *
-   * <p>
-   * Default kind is {@link KeepItemKind#CLASS_AND_MEMBERS}, meaning the annotated class and/or
-   * member is to be kept. When annotating a class this can be set to {@link
-   * KeepItemKind#ONLY_CLASS} to avoid patterns on any members. That can be useful when the API
-   * members are themselves explicitly annotated.
-   *
-   * <p>
-   * It is not possible to use {@link KeepItemKind#ONLY_CLASS} if annotating a member. Also, it is
-   * never valid to use kind {@link KeepItemKind#ONLY_MEMBERS} as the API surface must keep the
-   * class if any member is to be accessible.
-   *
-   * @return The kind for this pattern.
-   */
-  val kind: KeepItemKind = KeepItemKind.DEFAULT,
+    /**
+     * Specify the kind of this item pattern.
+     *
+     * <p>
+     * Default kind is {@link KeepItemKind#CLASS_AND_MEMBERS}, meaning the annotated class and/or
+     * member is to be kept. When annotating a class this can be set to {@link
+     * KeepItemKind#ONLY_CLASS} to avoid patterns on any members. That can be useful when the API
+     * members are themselves explicitly annotated.
+     *
+     * <p>
+     * It is not possible to use {@link KeepItemKind#ONLY_CLASS} if annotating a member. Also, it is
+     * never valid to use kind {@link KeepItemKind#ONLY_MEMBERS} as the API surface must keep the
+     * class if any member is to be accessible.
+     *
+     * @return The kind for this pattern.
+     */
+    val kind: KeepItemKind = KeepItemKind.DEFAULT,
 
-  /**
-   * Define the member-annotated-by pattern by fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining member-annotated-by:
-   * <ul>
-   * <li>memberAnnotatedByClassConstant
-   * <li>memberAnnotatedByClassNamePattern
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field and method properties as use restricts the match to both
-   * types of members.
-   *
-   * <p>
-   * If none are specified the default is to match any member regardless of what the member is
-   * annotated by.
-   *
-   * @return The qualified class name that defines the annotation.
-   */
-  val memberAnnotatedByClassName: String = "",
+    /**
+     * Define the member-annotated-by pattern by fully qualified class name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining member-annotated-by:
+     * <ul>
+     * <li>memberAnnotatedByClassConstant
+     * <li>memberAnnotatedByClassNamePattern
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field and method properties as use restricts the match to both
+     * types of members.
+     *
+     * <p>
+     * If none are specified the default is to match any member regardless of what the member is
+     * annotated by.
+     *
+     * @return The qualified class name that defines the annotation.
+     */
+    val memberAnnotatedByClassName: String = "",
 
-  /**
-   * Define the member-annotated-by pattern by reference to a Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining member-annotated-by:
-   * <ul>
-   * <li>memberAnnotatedByClassName
-   * <li>memberAnnotatedByClassNamePattern
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field and method properties as use restricts the match to both
-   * types of members.
-   *
-   * <p>
-   * If none are specified the default is to match any member regardless of what the member is
-   * annotated by.
-   *
-   * @return The class-constant that defines the annotation.
-   */
-  val memberAnnotatedByClassConstant: KClass<*> = Object::class,
+    /**
+     * Define the member-annotated-by pattern by reference to a Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining member-annotated-by:
+     * <ul>
+     * <li>memberAnnotatedByClassName
+     * <li>memberAnnotatedByClassNamePattern
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field and method properties as use restricts the match to both
+     * types of members.
+     *
+     * <p>
+     * If none are specified the default is to match any member regardless of what the member is
+     * annotated by.
+     *
+     * @return The class-constant that defines the annotation.
+     */
+    val memberAnnotatedByClassConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the member-annotated-by pattern by reference to a class-name pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining member-annotated-by:
-   * <ul>
-   * <li>memberAnnotatedByClassName
-   * <li>memberAnnotatedByClassConstant
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field and method properties as use restricts the match to both
-   * types of members.
-   *
-   * <p>
-   * If none are specified the default is to match any member regardless of what the member is
-   * annotated by.
-   *
-   * @return The class-name pattern that defines the annotation.
-   */
-  val memberAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
+    /**
+     * Define the member-annotated-by pattern by reference to a class-name pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining member-annotated-by:
+     * <ul>
+     * <li>memberAnnotatedByClassName
+     * <li>memberAnnotatedByClassConstant
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field and method properties as use restricts the match to both
+     * types of members.
+     *
+     * <p>
+     * If none are specified the default is to match any member regardless of what the member is
+     * annotated by.
+     *
+     * @return The class-name pattern that defines the annotation.
+     */
+    val memberAnnotatedByClassNamePattern: ClassNamePattern =
+        ClassNamePattern(unqualifiedName = ""),
 
-  /**
-   * Define the member-access pattern by matching on access flags.
-   *
-   * <p>
-   * Mutually exclusive with all field and method properties as use restricts the match to both
-   * types of members.
-   *
-   * @return The member access-flag constraints that must be met.
-   */
-  val memberAccess: Array<MemberAccessFlags> = [],
+    /**
+     * Define the member-access pattern by matching on access flags.
+     *
+     * <p>
+     * Mutually exclusive with all field and method properties as use restricts the match to both
+     * types of members.
+     *
+     * @return The member access-flag constraints that must be met.
+     */
+    val memberAccess: Array<MemberAccessFlags> = [],
 
-  /**
-   * Define the method-annotated-by pattern by fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining method-annotated-by:
-   * <ul>
-   * <li>methodAnnotatedByClassConstant
-   * <li>methodAnnotatedByClassNamePattern
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none are specified the default is to match any method regardless of what the method is
-   * annotated by.
-   *
-   * @return The qualified class name that defines the annotation.
-   */
-  val methodAnnotatedByClassName: String = "",
+    /**
+     * Define the method-annotated-by pattern by fully qualified class name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining method-annotated-by:
+     * <ul>
+     * <li>methodAnnotatedByClassConstant
+     * <li>methodAnnotatedByClassNamePattern
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none are specified the default is to match any method regardless of what the method is
+     * annotated by.
+     *
+     * @return The qualified class name that defines the annotation.
+     */
+    val methodAnnotatedByClassName: String = "",
 
-  /**
-   * Define the method-annotated-by pattern by reference to a Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining method-annotated-by:
-   * <ul>
-   * <li>methodAnnotatedByClassName
-   * <li>methodAnnotatedByClassNamePattern
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none are specified the default is to match any method regardless of what the method is
-   * annotated by.
-   *
-   * @return The class-constant that defines the annotation.
-   */
-  val methodAnnotatedByClassConstant: KClass<*> = Object::class,
+    /**
+     * Define the method-annotated-by pattern by reference to a Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining method-annotated-by:
+     * <ul>
+     * <li>methodAnnotatedByClassName
+     * <li>methodAnnotatedByClassNamePattern
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none are specified the default is to match any method regardless of what the method is
+     * annotated by.
+     *
+     * @return The class-constant that defines the annotation.
+     */
+    val methodAnnotatedByClassConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the method-annotated-by pattern by reference to a class-name pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining method-annotated-by:
-   * <ul>
-   * <li>methodAnnotatedByClassName
-   * <li>methodAnnotatedByClassConstant
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none are specified the default is to match any method regardless of what the method is
-   * annotated by.
-   *
-   * @return The class-name pattern that defines the annotation.
-   */
-  val methodAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
+    /**
+     * Define the method-annotated-by pattern by reference to a class-name pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining method-annotated-by:
+     * <ul>
+     * <li>methodAnnotatedByClassName
+     * <li>methodAnnotatedByClassConstant
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none are specified the default is to match any method regardless of what the method is
+     * annotated by.
+     *
+     * @return The class-name pattern that defines the annotation.
+     */
+    val methodAnnotatedByClassNamePattern: ClassNamePattern =
+        ClassNamePattern(unqualifiedName = ""),
 
-  /**
-   * Define the method-access pattern by matching on access flags.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any
-   * method-access flags.
-   *
-   * @return The method access-flag constraints that must be met.
-   */
-  val methodAccess: Array<MethodAccessFlags> = [],
+    /**
+     * Define the method-access pattern by matching on access flags.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any
+     * method-access flags.
+     *
+     * @return The method access-flag constraints that must be met.
+     */
+    val methodAccess: Array<MethodAccessFlags> = [],
 
-  /**
-   * Define the method-name pattern by an exact method name.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any method
-   * name.
-   *
-   * <p>
-   * Mutually exclusive with the property `methodNamePattern` also defining method-name.
-   *
-   * @return The exact method name of the method.
-   */
-  val methodName: String = "",
+    /**
+     * Define the method-name pattern by an exact method name.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any method
+     * name.
+     *
+     * <p>
+     * Mutually exclusive with the property `methodNamePattern` also defining method-name.
+     *
+     * @return The exact method name of the method.
+     */
+    val methodName: String = "",
 
-  /**
-   * Define the method-name pattern by a string pattern.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any method
-   * name.
-   *
-   * <p>
-   * Mutually exclusive with the property `methodName` also defining method-name.
-   *
-   * @return The string pattern of the method name.
-   */
-  val methodNamePattern: StringPattern = StringPattern(exact = ""),
+    /**
+     * Define the method-name pattern by a string pattern.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any method
+     * name.
+     *
+     * <p>
+     * Mutually exclusive with the property `methodName` also defining method-name.
+     *
+     * @return The string pattern of the method name.
+     */
+    val methodNamePattern: StringPattern = StringPattern(exact = ""),
 
-  /**
-   * Define the method return-type pattern by a fully qualified type or 'void'.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any return
-   * type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining return-type:
-   * <ul>
-   * <li>methodReturnTypeConstant
-   * <li>methodReturnTypePattern
-   * </ul>
-   *
-   * @return The qualified type name of the method return type.
-   */
-  val methodReturnType: String = "",
+    /**
+     * Define the method return-type pattern by a fully qualified type or 'void'.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any return
+     * type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining return-type:
+     * <ul>
+     * <li>methodReturnTypeConstant
+     * <li>methodReturnTypePattern
+     * </ul>
+     *
+     * @return The qualified type name of the method return type.
+     */
+    val methodReturnType: String = "",
 
-  /**
-   * Define the method return-type pattern by a class constant.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any return
-   * type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining return-type:
-   * <ul>
-   * <li>methodReturnType
-   * <li>methodReturnTypePattern
-   * </ul>
-   *
-   * @return A class constant denoting the type of the method return type.
-   */
-  val methodReturnTypeConstant: KClass<*> = Object::class,
+    /**
+     * Define the method return-type pattern by a class constant.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any return
+     * type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining return-type:
+     * <ul>
+     * <li>methodReturnType
+     * <li>methodReturnTypePattern
+     * </ul>
+     *
+     * @return A class constant denoting the type of the method return type.
+     */
+    val methodReturnTypeConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the method return-type pattern by a type pattern.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any return
-   * type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining return-type:
-   * <ul>
-   * <li>methodReturnType
-   * <li>methodReturnTypeConstant
-   * </ul>
-   *
-   * @return The pattern of the method return type.
-   */
-  val methodReturnTypePattern: TypePattern = TypePattern(name = ""),
+    /**
+     * Define the method return-type pattern by a type pattern.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any return
+     * type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining return-type:
+     * <ul>
+     * <li>methodReturnType
+     * <li>methodReturnTypeConstant
+     * </ul>
+     *
+     * @return The pattern of the method return type.
+     */
+    val methodReturnTypePattern: TypePattern = TypePattern(name = ""),
 
-  /**
-   * Define the method parameters pattern by a list of fully qualified types.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any parameters.
-   *
-   * <p>
-   * Mutually exclusive with the property `methodParameterTypePatterns` also defining parameters.
-   *
-   * @return The list of qualified type names of the method parameters.
-   */
-  val methodParameters: Array<String> = [""],
+    /**
+     * Define the method parameters pattern by a list of fully qualified types.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any
+     * parameters.
+     *
+     * <p>
+     * Mutually exclusive with the property `methodParameterTypePatterns` also defining parameters.
+     *
+     * @return The list of qualified type names of the method parameters.
+     */
+    val methodParameters: Array<String> = [""],
 
-  /**
-   * Define the method parameters pattern by a list of patterns on types.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any parameters.
-   *
-   * <p>
-   * Mutually exclusive with the property `methodParameters` also defining parameters.
-   *
-   * @return The list of type patterns for the method parameters.
-   */
-  val methodParameterTypePatterns: Array<TypePattern> = [TypePattern(name = "")],
+    /**
+     * Define the method parameters pattern by a list of patterns on types.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any
+     * parameters.
+     *
+     * <p>
+     * Mutually exclusive with the property `methodParameters` also defining parameters.
+     *
+     * @return The list of type patterns for the method parameters.
+     */
+    val methodParameterTypePatterns: Array<TypePattern> = [TypePattern(name = "")],
 
-  /**
-   * Define the field-annotated-by pattern by fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-annotated-by:
-   * <ul>
-   * <li>fieldAnnotatedByClassConstant
-   * <li>fieldAnnotatedByClassNamePattern
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none are specified the default is to match any field regardless of what the field is
-   * annotated by.
-   *
-   * @return The qualified class name that defines the annotation.
-   */
-  val fieldAnnotatedByClassName: String = "",
+    /**
+     * Define the field-annotated-by pattern by fully qualified class name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-annotated-by:
+     * <ul>
+     * <li>fieldAnnotatedByClassConstant
+     * <li>fieldAnnotatedByClassNamePattern
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none are specified the default is to match any field regardless of what the field is
+     * annotated by.
+     *
+     * @return The qualified class name that defines the annotation.
+     */
+    val fieldAnnotatedByClassName: String = "",
 
-  /**
-   * Define the field-annotated-by pattern by reference to a Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-annotated-by:
-   * <ul>
-   * <li>fieldAnnotatedByClassName
-   * <li>fieldAnnotatedByClassNamePattern
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none are specified the default is to match any field regardless of what the field is
-   * annotated by.
-   *
-   * @return The class-constant that defines the annotation.
-   */
-  val fieldAnnotatedByClassConstant: KClass<*> = Object::class,
+    /**
+     * Define the field-annotated-by pattern by reference to a Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-annotated-by:
+     * <ul>
+     * <li>fieldAnnotatedByClassName
+     * <li>fieldAnnotatedByClassNamePattern
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none are specified the default is to match any field regardless of what the field is
+     * annotated by.
+     *
+     * @return The class-constant that defines the annotation.
+     */
+    val fieldAnnotatedByClassConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the field-annotated-by pattern by reference to a class-name pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-annotated-by:
-   * <ul>
-   * <li>fieldAnnotatedByClassName
-   * <li>fieldAnnotatedByClassConstant
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none are specified the default is to match any field regardless of what the field is
-   * annotated by.
-   *
-   * @return The class-name pattern that defines the annotation.
-   */
-  val fieldAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
+    /**
+     * Define the field-annotated-by pattern by reference to a class-name pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-annotated-by:
+     * <ul>
+     * <li>fieldAnnotatedByClassName
+     * <li>fieldAnnotatedByClassConstant
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none are specified the default is to match any field regardless of what the field is
+     * annotated by.
+     *
+     * @return The class-name pattern that defines the annotation.
+     */
+    val fieldAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
 
-  /**
-   * Define the field-access pattern by matching on access flags.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any field-access
-   * flags.
-   *
-   * @return The field access-flag constraints that must be met.
-   */
-  val fieldAccess: Array<FieldAccessFlags> = [],
+    /**
+     * Define the field-access pattern by matching on access flags.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any
+     * field-access flags.
+     *
+     * @return The field access-flag constraints that must be met.
+     */
+    val fieldAccess: Array<FieldAccessFlags> = [],
 
-  /**
-   * Define the field-name pattern by an exact field name.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any field name.
-   *
-   * <p>
-   * Mutually exclusive with the property `fieldNamePattern` also defining field-name.
-   *
-   * @return The exact field name of the field.
-   */
-  val fieldName: String = "",
+    /**
+     * Define the field-name pattern by an exact field name.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any field
+     * name.
+     *
+     * <p>
+     * Mutually exclusive with the property `fieldNamePattern` also defining field-name.
+     *
+     * @return The exact field name of the field.
+     */
+    val fieldName: String = "",
 
-  /**
-   * Define the field-name pattern by a string pattern.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any field name.
-   *
-   * <p>
-   * Mutually exclusive with the property `fieldName` also defining field-name.
-   *
-   * @return The string pattern of the field name.
-   */
-  val fieldNamePattern: StringPattern = StringPattern(exact = ""),
+    /**
+     * Define the field-name pattern by a string pattern.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any field
+     * name.
+     *
+     * <p>
+     * Mutually exclusive with the property `fieldName` also defining field-name.
+     *
+     * @return The string pattern of the field name.
+     */
+    val fieldNamePattern: StringPattern = StringPattern(exact = ""),
 
-  /**
-   * Define the field-type pattern by a fully qualified type.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-type:
-   * <ul>
-   * <li>fieldTypeConstant
-   * <li>fieldTypePattern
-   * </ul>
-   *
-   * @return The qualified type name for the field type.
-   */
-  val fieldType: String = "",
+    /**
+     * Define the field-type pattern by a fully qualified type.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-type:
+     * <ul>
+     * <li>fieldTypeConstant
+     * <li>fieldTypePattern
+     * </ul>
+     *
+     * @return The qualified type name for the field type.
+     */
+    val fieldType: String = "",
 
-  /**
-   * Define the field-type pattern by a class constant.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-type:
-   * <ul>
-   * <li>fieldType
-   * <li>fieldTypePattern
-   * </ul>
-   *
-   * @return The class constant for the field type.
-   */
-  val fieldTypeConstant: KClass<*> = Object::class,
+    /**
+     * Define the field-type pattern by a class constant.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-type:
+     * <ul>
+     * <li>fieldType
+     * <li>fieldTypePattern
+     * </ul>
+     *
+     * @return The class constant for the field type.
+     */
+    val fieldTypeConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the field-type pattern by a pattern on types.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-type:
-   * <ul>
-   * <li>fieldType
-   * <li>fieldTypeConstant
-   * </ul>
-   *
-   * @return The type pattern for the field type.
-   */
-  val fieldTypePattern: TypePattern = TypePattern(name = ""),
+    /**
+     * Define the field-type pattern by a pattern on types.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-type:
+     * <ul>
+     * <li>fieldType
+     * <li>fieldTypeConstant
+     * </ul>
+     *
+     * @return The type pattern for the field type.
+     */
+    val fieldTypePattern: TypePattern = TypePattern(name = ""),
 )

src/keepanno/java/androidx/annotation/keep/KeepItemKind.kt

diff --git a/src/keepanno/java/androidx/annotation/keep/KeepItemKind.kt b/src/keepanno/java/androidx/annotation/keep/KeepItemKind.kt
index e30bd45..3dd9bad 100644
--- a/src/keepanno/java/androidx/annotation/keep/KeepItemKind.kt
+++ b/src/keepanno/java/androidx/annotation/keep/KeepItemKind.kt
@@ -21,12 +21,12 @@
 package androidx.annotation.keep
 
 public enum class KeepItemKind {
-  ONLY_CLASS,
-  ONLY_MEMBERS,
-  ONLY_METHODS,
-  ONLY_FIELDS,
-  CLASS_AND_MEMBERS,
-  CLASS_AND_METHODS,
-  CLASS_AND_FIELDS,
-  DEFAULT,
+    ONLY_CLASS,
+    ONLY_MEMBERS,
+    ONLY_METHODS,
+    ONLY_FIELDS,
+    CLASS_AND_MEMBERS,
+    CLASS_AND_METHODS,
+    CLASS_AND_FIELDS,
+    DEFAULT,
 }

src/keepanno/java/androidx/annotation/keep/KeepOption.kt

diff --git a/src/keepanno/java/androidx/annotation/keep/KeepOption.kt b/src/keepanno/java/androidx/annotation/keep/KeepOption.kt
index 64035a7..3642e74 100644
--- a/src/keepanno/java/androidx/annotation/keep/KeepOption.kt
+++ b/src/keepanno/java/androidx/annotation/keep/KeepOption.kt
@@ -21,9 +21,9 @@
 package androidx.annotation.keep
 
 public enum class KeepOption {
-  SHRINKING,
-  OPTIMIZATION,
-  OBFUSCATION,
-  ACCESS_MODIFICATION,
-  ANNOTATION_REMOVAL,
+    SHRINKING,
+    OPTIMIZATION,
+    OBFUSCATION,
+    ACCESS_MODIFICATION,
+    ANNOTATION_REMOVAL,
 }

src/keepanno/java/androidx/annotation/keep/KeepTarget.kt

diff --git a/src/keepanno/java/androidx/annotation/keep/KeepTarget.kt b/src/keepanno/java/androidx/annotation/keep/KeepTarget.kt
index 6164c7e..c86993f 100644
--- a/src/keepanno/java/androidx/annotation/keep/KeepTarget.kt
+++ b/src/keepanno/java/androidx/annotation/keep/KeepTarget.kt
@@ -43,864 +43,872 @@
 @Target(AnnotationTarget.ANNOTATION_CLASS)
 public annotation class KeepTarget(
 
-  /**
-   * Specify the kind of this item pattern.
-   *
-   * <p>
-   * Possible values are:
-   * <ul>
-   * <li>{@link KeepItemKind#ONLY_CLASS}
-   * <li>{@link KeepItemKind#ONLY_MEMBERS}
-   * <li>{@link KeepItemKind#ONLY_METHODS}
-   * <li>{@link KeepItemKind#ONLY_FIELDS}
-   * <li>{@link KeepItemKind#CLASS_AND_MEMBERS}
-   * <li>{@link KeepItemKind#CLASS_AND_METHODS}
-   * <li>{@link KeepItemKind#CLASS_AND_FIELDS}
-   * </ul>
-   *
-   * <p>
-   * If unspecified the default kind for an item depends on its member patterns:
-   * <ul>
-   * <li>{@link KeepItemKind#ONLY_CLASS} if no member patterns are defined
-   * <li>{@link KeepItemKind#ONLY_METHODS} if method patterns are defined
-   * <li>{@link KeepItemKind#ONLY_FIELDS} if field patterns are defined
-   * <li>{@link KeepItemKind#ONLY_MEMBERS} otherwise.
-   * </ul>
-   *
-   * @return The kind for this pattern.
-   */
-  val kind: KeepItemKind = KeepItemKind.DEFAULT,
+    /**
+     * Specify the kind of this item pattern.
+     *
+     * <p>
+     * Possible values are:
+     * <ul>
+     * <li>{@link KeepItemKind#ONLY_CLASS}
+     * <li>{@link KeepItemKind#ONLY_MEMBERS}
+     * <li>{@link KeepItemKind#ONLY_METHODS}
+     * <li>{@link KeepItemKind#ONLY_FIELDS}
+     * <li>{@link KeepItemKind#CLASS_AND_MEMBERS}
+     * <li>{@link KeepItemKind#CLASS_AND_METHODS}
+     * <li>{@link KeepItemKind#CLASS_AND_FIELDS}
+     * </ul>
+     *
+     * <p>
+     * If unspecified the default kind for an item depends on its member patterns:
+     * <ul>
+     * <li>{@link KeepItemKind#ONLY_CLASS} if no member patterns are defined
+     * <li>{@link KeepItemKind#ONLY_METHODS} if method patterns are defined
+     * <li>{@link KeepItemKind#ONLY_FIELDS} if field patterns are defined
+     * <li>{@link KeepItemKind#ONLY_MEMBERS} otherwise.
+     * </ul>
+     *
+     * @return The kind for this pattern.
+     */
+    val kind: KeepItemKind = KeepItemKind.DEFAULT,
 
-  /**
-   * Define the usage constraints of the target.
-   *
-   * <p>
-   * The specified constraints must remain valid for the target.
-   *
-   * <p>
-   * The default constraints depend on the kind of the target. For all targets the default
-   * constraints include:
-   * <ul>
-   * <li>{@link KeepConstraint#LOOKUP}
-   * <li>{@link KeepConstraint#NAME}
-   * <li>{@link KeepConstraint#VISIBILITY_RELAX}
-   * </ul>
-   *
-   * <p>
-   * For classes the default constraints also include:
-   * <ul>
-   * <li>{@link KeepConstraint#CLASS_INSTANTIATE}
-   * </ul>
-   *
-   * <p>
-   * For methods the default constraints also include:
-   * <ul>
-   * <li>{@link KeepConstraint#METHOD_INVOKE}
-   * </ul>
-   *
-   * <p>
-   * For fields the default constraints also include:
-   * <ul>
-   * <li>{@link KeepConstraint#FIELD_GET}
-   * <li>{@link KeepConstraint#FIELD_SET}
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with the property `constraintAdditions` also defining constraints.
-   *
-   * @return Usage constraints for the target.
-   */
-  val constraints: Array<KeepConstraint> = [],
+    /**
+     * Define the usage constraints of the target.
+     *
+     * <p>
+     * The specified constraints must remain valid for the target.
+     *
+     * <p>
+     * The default constraints depend on the kind of the target. For all targets the default
+     * constraints include:
+     * <ul>
+     * <li>{@link KeepConstraint#LOOKUP}
+     * <li>{@link KeepConstraint#NAME}
+     * <li>{@link KeepConstraint#VISIBILITY_RELAX}
+     * </ul>
+     *
+     * <p>
+     * For classes the default constraints also include:
+     * <ul>
+     * <li>{@link KeepConstraint#CLASS_INSTANTIATE}
+     * </ul>
+     *
+     * <p>
+     * For methods the default constraints also include:
+     * <ul>
+     * <li>{@link KeepConstraint#METHOD_INVOKE}
+     * </ul>
+     *
+     * <p>
+     * For fields the default constraints also include:
+     * <ul>
+     * <li>{@link KeepConstraint#FIELD_GET}
+     * <li>{@link KeepConstraint#FIELD_SET}
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with the property `constraintAdditions` also defining constraints.
+     *
+     * @return Usage constraints for the target.
+     */
+    val constraints: Array<KeepConstraint> = [],
 
-  /**
-   * Add additional usage constraints of the target.
-   *
-   * <p>
-   * The specified constraints must remain valid for the target in addition to the default
-   * constraints.
-   *
-   * <p>
-   * The default constraints are documented in {@link #constraints}
-   *
-   * <p>
-   * Mutually exclusive with the property `constraints` also defining constraints.
-   *
-   * @return Additional usage constraints for the target.
-   */
-  val constraintAdditions: Array<KeepConstraint> = [],
+    /**
+     * Add additional usage constraints of the target.
+     *
+     * <p>
+     * The specified constraints must remain valid for the target in addition to the default
+     * constraints.
+     *
+     * <p>
+     * The default constraints are documented in {@link #constraints}
+     *
+     * <p>
+     * Mutually exclusive with the property `constraints` also defining constraints.
+     *
+     * @return Additional usage constraints for the target.
+     */
+    val constraintAdditions: Array<KeepConstraint> = [],
 
-  /**
-   * Patterns for annotations that must remain on the item.
-   *
-   * <p>
-   * The annotations matching any of the patterns must remain on the item if the annotation types
-   * remain in the program.
-   *
-   * <p>
-   * Note that if the annotation types themselves are unused/removed, then their references on the
-   * item will be removed too. If the annotation types themselves are used reflectively then they
-   * too need a keep annotation or rule to ensure they remain in the program.
-   *
-   * <p>
-   * By default no annotation patterns are defined and no annotations are required to remain.
-   *
-   * @return Annotation patterns
-   */
-  val constrainAnnotations: Array<AnnotationPattern> = [],
+    /**
+     * Patterns for annotations that must remain on the item.
+     *
+     * <p>
+     * The annotations matching any of the patterns must remain on the item if the annotation types
+     * remain in the program.
+     *
+     * <p>
+     * Note that if the annotation types themselves are unused/removed, then their references on the
+     * item will be removed too. If the annotation types themselves are used reflectively then they
+     * too need a keep annotation or rule to ensure they remain in the program.
+     *
+     * <p>
+     * By default no annotation patterns are defined and no annotations are required to remain.
+     *
+     * @return Annotation patterns
+     */
+    val constrainAnnotations: Array<AnnotationPattern> = [],
 
-  /**
-   * Define the class pattern by reference to a binding.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining class:
-   * <ul>
-   * <li>className
-   * <li>classConstant
-   * <li>classNamePattern
-   * <li>instanceOfClassName
-   * <li>instanceOfClassNameExclusive
-   * <li>instanceOfClassConstant
-   * <li>instanceOfClassConstantExclusive
-   * <li>instanceOfPattern
-   * <li>classAnnotatedByClassName
-   * <li>classAnnotatedByClassConstant
-   * <li>classAnnotatedByClassNamePattern
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class.
-   *
-   * @return The name of the binding that defines the class.
-   */
-  val classFromBinding: String = "",
+    /**
+     * Define the class pattern by reference to a binding.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining class:
+     * <ul>
+     * <li>className
+     * <li>classConstant
+     * <li>classNamePattern
+     * <li>instanceOfClassName
+     * <li>instanceOfClassNameExclusive
+     * <li>instanceOfClassConstant
+     * <li>instanceOfClassConstantExclusive
+     * <li>instanceOfPattern
+     * <li>classAnnotatedByClassName
+     * <li>classAnnotatedByClassConstant
+     * <li>classAnnotatedByClassNamePattern
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class.
+     *
+     * @return The name of the binding that defines the class.
+     */
+    val classFromBinding: String = "",
 
-  /**
-   * Define the class-name pattern by fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining class-name:
-   * <ul>
-   * <li>classConstant
-   * <li>classNamePattern
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class name.
-   *
-   * @return The qualified class name that defines the class.
-   */
-  val className: String = "",
+    /**
+     * Define the class-name pattern by fully qualified class name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining class-name:
+     * <ul>
+     * <li>classConstant
+     * <li>classNamePattern
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class name.
+     *
+     * @return The qualified class name that defines the class.
+     */
+    val className: String = "",
 
-  /**
-   * Define the class-name pattern by reference to a Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining class-name:
-   * <ul>
-   * <li>className
-   * <li>classNamePattern
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class name.
-   *
-   * @return The class-constant that defines the class.
-   */
-  val classConstant: KClass<*> = Object::class,
+    /**
+     * Define the class-name pattern by reference to a Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining class-name:
+     * <ul>
+     * <li>className
+     * <li>classNamePattern
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class name.
+     *
+     * @return The class-constant that defines the class.
+     */
+    val classConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the class-name pattern by reference to a class-name pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining class-name:
-   * <ul>
-   * <li>className
-   * <li>classConstant
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class name.
-   *
-   * @return The class-name pattern that defines the class.
-   */
-  val classNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
+    /**
+     * Define the class-name pattern by reference to a class-name pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining class-name:
+     * <ul>
+     * <li>className
+     * <li>classConstant
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class name.
+     *
+     * @return The class-name pattern that defines the class.
+     */
+    val classNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
 
-  /**
-   * Define the instance-of pattern as classes that are instances of the fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining instance-of:
-   * <ul>
-   * <li>instanceOfClassNameExclusive
-   * <li>instanceOfClassConstant
-   * <li>instanceOfClassConstantExclusive
-   * <li>instanceOfPattern
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class instance.
-   *
-   * @return The qualified class name that defines what instance-of the class must be.
-   */
-  val instanceOfClassName: String = "",
+    /**
+     * Define the instance-of pattern as classes that are instances of the fully qualified class
+     * name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining instance-of:
+     * <ul>
+     * <li>instanceOfClassNameExclusive
+     * <li>instanceOfClassConstant
+     * <li>instanceOfClassConstantExclusive
+     * <li>instanceOfPattern
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class instance.
+     *
+     * @return The qualified class name that defines what instance-of the class must be.
+     */
+    val instanceOfClassName: String = "",
 
-  /**
-   * Define the instance-of pattern as classes that are instances of the fully qualified class name.
-   *
-   * <p>
-   * The pattern is exclusive in that it does not match classes that are instances of the pattern,
-   * but only those that are instances of classes that are subclasses of the pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining instance-of:
-   * <ul>
-   * <li>instanceOfClassName
-   * <li>instanceOfClassConstant
-   * <li>instanceOfClassConstantExclusive
-   * <li>instanceOfPattern
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class instance.
-   *
-   * @return The qualified class name that defines what instance-of the class must be.
-   */
-  val instanceOfClassNameExclusive: String = "",
+    /**
+     * Define the instance-of pattern as classes that are instances of the fully qualified class
+     * name.
+     *
+     * <p>
+     * The pattern is exclusive in that it does not match classes that are instances of the pattern,
+     * but only those that are instances of classes that are subclasses of the pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining instance-of:
+     * <ul>
+     * <li>instanceOfClassName
+     * <li>instanceOfClassConstant
+     * <li>instanceOfClassConstantExclusive
+     * <li>instanceOfPattern
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class instance.
+     *
+     * @return The qualified class name that defines what instance-of the class must be.
+     */
+    val instanceOfClassNameExclusive: String = "",
 
-  /**
-   * Define the instance-of pattern as classes that are instances the referenced Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining instance-of:
-   * <ul>
-   * <li>instanceOfClassName
-   * <li>instanceOfClassNameExclusive
-   * <li>instanceOfClassConstantExclusive
-   * <li>instanceOfPattern
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class instance.
-   *
-   * @return The class constant that defines what instance-of the class must be.
-   */
-  val instanceOfClassConstant: KClass<*> = Object::class,
+    /**
+     * Define the instance-of pattern as classes that are instances the referenced Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining instance-of:
+     * <ul>
+     * <li>instanceOfClassName
+     * <li>instanceOfClassNameExclusive
+     * <li>instanceOfClassConstantExclusive
+     * <li>instanceOfPattern
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class instance.
+     *
+     * @return The class constant that defines what instance-of the class must be.
+     */
+    val instanceOfClassConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the instance-of pattern as classes that are instances the referenced Class constant.
-   *
-   * <p>
-   * The pattern is exclusive in that it does not match classes that are instances of the pattern,
-   * but only those that are instances of classes that are subclasses of the pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining instance-of:
-   * <ul>
-   * <li>instanceOfClassName
-   * <li>instanceOfClassNameExclusive
-   * <li>instanceOfClassConstant
-   * <li>instanceOfPattern
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class instance.
-   *
-   * @return The class constant that defines what instance-of the class must be.
-   */
-  val instanceOfClassConstantExclusive: KClass<*> = Object::class,
+    /**
+     * Define the instance-of pattern as classes that are instances the referenced Class constant.
+     *
+     * <p>
+     * The pattern is exclusive in that it does not match classes that are instances of the pattern,
+     * but only those that are instances of classes that are subclasses of the pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining instance-of:
+     * <ul>
+     * <li>instanceOfClassName
+     * <li>instanceOfClassNameExclusive
+     * <li>instanceOfClassConstant
+     * <li>instanceOfPattern
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class instance.
+     *
+     * @return The class constant that defines what instance-of the class must be.
+     */
+    val instanceOfClassConstantExclusive: KClass<*> = Object::class,
 
-  /**
-   * Define the instance-of with a pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining instance-of:
-   * <ul>
-   * <li>instanceOfClassName
-   * <li>instanceOfClassNameExclusive
-   * <li>instanceOfClassConstant
-   * <li>instanceOfClassConstantExclusive
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class instance.
-   *
-   * @return The pattern that defines what instance-of the class must be.
-   */
-  val instanceOfPattern: InstanceOfPattern = InstanceOfPattern(),
+    /**
+     * Define the instance-of with a pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining instance-of:
+     * <ul>
+     * <li>instanceOfClassName
+     * <li>instanceOfClassNameExclusive
+     * <li>instanceOfClassConstant
+     * <li>instanceOfClassConstantExclusive
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class instance.
+     *
+     * @return The pattern that defines what instance-of the class must be.
+     */
+    val instanceOfPattern: InstanceOfPattern = InstanceOfPattern(),
 
-  /**
-   * Define the class-annotated-by pattern by fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining class-annotated-by:
-   * <ul>
-   * <li>classAnnotatedByClassConstant
-   * <li>classAnnotatedByClassNamePattern
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class regardless of what the class is
-   * annotated by.
-   *
-   * @return The qualified class name that defines the annotation.
-   */
-  val classAnnotatedByClassName: String = "",
+    /**
+     * Define the class-annotated-by pattern by fully qualified class name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining class-annotated-by:
+     * <ul>
+     * <li>classAnnotatedByClassConstant
+     * <li>classAnnotatedByClassNamePattern
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class regardless of what the class is
+     * annotated by.
+     *
+     * @return The qualified class name that defines the annotation.
+     */
+    val classAnnotatedByClassName: String = "",
 
-  /**
-   * Define the class-annotated-by pattern by reference to a Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining class-annotated-by:
-   * <ul>
-   * <li>classAnnotatedByClassName
-   * <li>classAnnotatedByClassNamePattern
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class regardless of what the class is
-   * annotated by.
-   *
-   * @return The class-constant that defines the annotation.
-   */
-  val classAnnotatedByClassConstant: KClass<*> = Object::class,
+    /**
+     * Define the class-annotated-by pattern by reference to a Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining class-annotated-by:
+     * <ul>
+     * <li>classAnnotatedByClassName
+     * <li>classAnnotatedByClassNamePattern
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class regardless of what the class is
+     * annotated by.
+     *
+     * @return The class-constant that defines the annotation.
+     */
+    val classAnnotatedByClassConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the class-annotated-by pattern by reference to a class-name pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining class-annotated-by:
-   * <ul>
-   * <li>classAnnotatedByClassName
-   * <li>classAnnotatedByClassConstant
-   * <li>classFromBinding
-   * </ul>
-   *
-   * <p>
-   * If none are specified the default is to match any class regardless of what the class is
-   * annotated by.
-   *
-   * @return The class-name pattern that defines the annotation.
-   */
-  val classAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
+    /**
+     * Define the class-annotated-by pattern by reference to a class-name pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining class-annotated-by:
+     * <ul>
+     * <li>classAnnotatedByClassName
+     * <li>classAnnotatedByClassConstant
+     * <li>classFromBinding
+     * </ul>
+     *
+     * <p>
+     * If none are specified the default is to match any class regardless of what the class is
+     * annotated by.
+     *
+     * @return The class-name pattern that defines the annotation.
+     */
+    val classAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
 
-  /**
-   * Define the member pattern in full by a reference to a binding.
-   *
-   * <p>
-   * Mutually exclusive with all other class and member pattern properties. When a member binding is
-   * referenced this item is defined to be that item, including its class and member patterns.
-   *
-   * @return The binding name that defines the member.
-   */
-  val memberFromBinding: String = "",
+    /**
+     * Define the member pattern in full by a reference to a binding.
+     *
+     * <p>
+     * Mutually exclusive with all other class and member pattern properties. When a member binding
+     * is referenced this item is defined to be that item, including its class and member patterns.
+     *
+     * @return The binding name that defines the member.
+     */
+    val memberFromBinding: String = "",
 
-  /**
-   * Define the member-annotated-by pattern by fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining member-annotated-by:
-   * <ul>
-   * <li>memberAnnotatedByClassConstant
-   * <li>memberAnnotatedByClassNamePattern
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field and method properties as use restricts the match to both
-   * types of members.
-   *
-   * <p>
-   * If none are specified the default is to match any member regardless of what the member is
-   * annotated by.
-   *
-   * @return The qualified class name that defines the annotation.
-   */
-  val memberAnnotatedByClassName: String = "",
+    /**
+     * Define the member-annotated-by pattern by fully qualified class name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining member-annotated-by:
+     * <ul>
+     * <li>memberAnnotatedByClassConstant
+     * <li>memberAnnotatedByClassNamePattern
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field and method properties as use restricts the match to both
+     * types of members.
+     *
+     * <p>
+     * If none are specified the default is to match any member regardless of what the member is
+     * annotated by.
+     *
+     * @return The qualified class name that defines the annotation.
+     */
+    val memberAnnotatedByClassName: String = "",
 
-  /**
-   * Define the member-annotated-by pattern by reference to a Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining member-annotated-by:
-   * <ul>
-   * <li>memberAnnotatedByClassName
-   * <li>memberAnnotatedByClassNamePattern
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field and method properties as use restricts the match to both
-   * types of members.
-   *
-   * <p>
-   * If none are specified the default is to match any member regardless of what the member is
-   * annotated by.
-   *
-   * @return The class-constant that defines the annotation.
-   */
-  val memberAnnotatedByClassConstant: KClass<*> = Object::class,
+    /**
+     * Define the member-annotated-by pattern by reference to a Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining member-annotated-by:
+     * <ul>
+     * <li>memberAnnotatedByClassName
+     * <li>memberAnnotatedByClassNamePattern
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field and method properties as use restricts the match to both
+     * types of members.
+     *
+     * <p>
+     * If none are specified the default is to match any member regardless of what the member is
+     * annotated by.
+     *
+     * @return The class-constant that defines the annotation.
+     */
+    val memberAnnotatedByClassConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the member-annotated-by pattern by reference to a class-name pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining member-annotated-by:
-   * <ul>
-   * <li>memberAnnotatedByClassName
-   * <li>memberAnnotatedByClassConstant
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field and method properties as use restricts the match to both
-   * types of members.
-   *
-   * <p>
-   * If none are specified the default is to match any member regardless of what the member is
-   * annotated by.
-   *
-   * @return The class-name pattern that defines the annotation.
-   */
-  val memberAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
+    /**
+     * Define the member-annotated-by pattern by reference to a class-name pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining member-annotated-by:
+     * <ul>
+     * <li>memberAnnotatedByClassName
+     * <li>memberAnnotatedByClassConstant
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field and method properties as use restricts the match to both
+     * types of members.
+     *
+     * <p>
+     * If none are specified the default is to match any member regardless of what the member is
+     * annotated by.
+     *
+     * @return The class-name pattern that defines the annotation.
+     */
+    val memberAnnotatedByClassNamePattern: ClassNamePattern =
+        ClassNamePattern(unqualifiedName = ""),
 
-  /**
-   * Define the member-access pattern by matching on access flags.
-   *
-   * <p>
-   * Mutually exclusive with all field and method properties as use restricts the match to both
-   * types of members.
-   *
-   * <p>
-   * Mutually exclusive with the property `memberFromBinding` also defining member-access.
-   *
-   * @return The member access-flag constraints that must be met.
-   */
-  val memberAccess: Array<MemberAccessFlags> = [],
+    /**
+     * Define the member-access pattern by matching on access flags.
+     *
+     * <p>
+     * Mutually exclusive with all field and method properties as use restricts the match to both
+     * types of members.
+     *
+     * <p>
+     * Mutually exclusive with the property `memberFromBinding` also defining member-access.
+     *
+     * @return The member access-flag constraints that must be met.
+     */
+    val memberAccess: Array<MemberAccessFlags> = [],
 
-  /**
-   * Define the method-annotated-by pattern by fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining method-annotated-by:
-   * <ul>
-   * <li>methodAnnotatedByClassConstant
-   * <li>methodAnnotatedByClassNamePattern
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none are specified the default is to match any method regardless of what the method is
-   * annotated by.
-   *
-   * @return The qualified class name that defines the annotation.
-   */
-  val methodAnnotatedByClassName: String = "",
+    /**
+     * Define the method-annotated-by pattern by fully qualified class name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining method-annotated-by:
+     * <ul>
+     * <li>methodAnnotatedByClassConstant
+     * <li>methodAnnotatedByClassNamePattern
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none are specified the default is to match any method regardless of what the method is
+     * annotated by.
+     *
+     * @return The qualified class name that defines the annotation.
+     */
+    val methodAnnotatedByClassName: String = "",
 
-  /**
-   * Define the method-annotated-by pattern by reference to a Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining method-annotated-by:
-   * <ul>
-   * <li>methodAnnotatedByClassName
-   * <li>methodAnnotatedByClassNamePattern
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none are specified the default is to match any method regardless of what the method is
-   * annotated by.
-   *
-   * @return The class-constant that defines the annotation.
-   */
-  val methodAnnotatedByClassConstant: KClass<*> = Object::class,
+    /**
+     * Define the method-annotated-by pattern by reference to a Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining method-annotated-by:
+     * <ul>
+     * <li>methodAnnotatedByClassName
+     * <li>methodAnnotatedByClassNamePattern
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none are specified the default is to match any method regardless of what the method is
+     * annotated by.
+     *
+     * @return The class-constant that defines the annotation.
+     */
+    val methodAnnotatedByClassConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the method-annotated-by pattern by reference to a class-name pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining method-annotated-by:
-   * <ul>
-   * <li>methodAnnotatedByClassName
-   * <li>methodAnnotatedByClassConstant
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none are specified the default is to match any method regardless of what the method is
-   * annotated by.
-   *
-   * @return The class-name pattern that defines the annotation.
-   */
-  val methodAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
+    /**
+     * Define the method-annotated-by pattern by reference to a class-name pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining method-annotated-by:
+     * <ul>
+     * <li>methodAnnotatedByClassName
+     * <li>methodAnnotatedByClassConstant
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none are specified the default is to match any method regardless of what the method is
+     * annotated by.
+     *
+     * @return The class-name pattern that defines the annotation.
+     */
+    val methodAnnotatedByClassNamePattern: ClassNamePattern =
+        ClassNamePattern(unqualifiedName = ""),
 
-  /**
-   * Define the method-access pattern by matching on access flags.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any
-   * method-access flags.
-   *
-   * <p>
-   * Mutually exclusive with the property `memberFromBinding` also defining method-access.
-   *
-   * @return The method access-flag constraints that must be met.
-   */
-  val methodAccess: Array<MethodAccessFlags> = [],
+    /**
+     * Define the method-access pattern by matching on access flags.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any
+     * method-access flags.
+     *
+     * <p>
+     * Mutually exclusive with the property `memberFromBinding` also defining method-access.
+     *
+     * @return The method access-flag constraints that must be met.
+     */
+    val methodAccess: Array<MethodAccessFlags> = [],
 
-  /**
-   * Define the method-name pattern by an exact method name.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any method
-   * name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining method-name:
-   * <ul>
-   * <li>methodNamePattern
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * @return The exact method name of the method.
-   */
-  val methodName: String = "",
+    /**
+     * Define the method-name pattern by an exact method name.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any method
+     * name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining method-name:
+     * <ul>
+     * <li>methodNamePattern
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * @return The exact method name of the method.
+     */
+    val methodName: String = "",
 
-  /**
-   * Define the method-name pattern by a string pattern.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any method
-   * name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining method-name:
-   * <ul>
-   * <li>methodName
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * @return The string pattern of the method name.
-   */
-  val methodNamePattern: StringPattern = StringPattern(exact = ""),
+    /**
+     * Define the method-name pattern by a string pattern.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any method
+     * name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining method-name:
+     * <ul>
+     * <li>methodName
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * @return The string pattern of the method name.
+     */
+    val methodNamePattern: StringPattern = StringPattern(exact = ""),
 
-  /**
-   * Define the method return-type pattern by a fully qualified type or 'void'.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any return
-   * type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining return-type:
-   * <ul>
-   * <li>methodReturnTypeConstant
-   * <li>methodReturnTypePattern
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * @return The qualified type name of the method return type.
-   */
-  val methodReturnType: String = "",
+    /**
+     * Define the method return-type pattern by a fully qualified type or 'void'.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any return
+     * type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining return-type:
+     * <ul>
+     * <li>methodReturnTypeConstant
+     * <li>methodReturnTypePattern
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * @return The qualified type name of the method return type.
+     */
+    val methodReturnType: String = "",
 
-  /**
-   * Define the method return-type pattern by a class constant.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any return
-   * type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining return-type:
-   * <ul>
-   * <li>methodReturnType
-   * <li>methodReturnTypePattern
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * @return A class constant denoting the type of the method return type.
-   */
-  val methodReturnTypeConstant: KClass<*> = Object::class,
+    /**
+     * Define the method return-type pattern by a class constant.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any return
+     * type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining return-type:
+     * <ul>
+     * <li>methodReturnType
+     * <li>methodReturnTypePattern
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * @return A class constant denoting the type of the method return type.
+     */
+    val methodReturnTypeConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the method return-type pattern by a type pattern.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any return
-   * type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining return-type:
-   * <ul>
-   * <li>methodReturnType
-   * <li>methodReturnTypeConstant
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * @return The pattern of the method return type.
-   */
-  val methodReturnTypePattern: TypePattern = TypePattern(name = ""),
+    /**
+     * Define the method return-type pattern by a type pattern.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any return
+     * type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining return-type:
+     * <ul>
+     * <li>methodReturnType
+     * <li>methodReturnTypeConstant
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * @return The pattern of the method return type.
+     */
+    val methodReturnTypePattern: TypePattern = TypePattern(name = ""),
 
-  /**
-   * Define the method parameters pattern by a list of fully qualified types.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any parameters.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining parameters:
-   * <ul>
-   * <li>methodParameterTypePatterns
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * @return The list of qualified type names of the method parameters.
-   */
-  val methodParameters: Array<String> = [""],
+    /**
+     * Define the method parameters pattern by a list of fully qualified types.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any
+     * parameters.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining parameters:
+     * <ul>
+     * <li>methodParameterTypePatterns
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * @return The list of qualified type names of the method parameters.
+     */
+    val methodParameters: Array<String> = [""],
 
-  /**
-   * Define the method parameters pattern by a list of patterns on types.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any parameters.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining parameters:
-   * <ul>
-   * <li>methodParameters
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * @return The list of type patterns for the method parameters.
-   */
-  val methodParameterTypePatterns: Array<TypePattern> = [TypePattern(name = "")],
+    /**
+     * Define the method parameters pattern by a list of patterns on types.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any
+     * parameters.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining parameters:
+     * <ul>
+     * <li>methodParameters
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * @return The list of type patterns for the method parameters.
+     */
+    val methodParameterTypePatterns: Array<TypePattern> = [TypePattern(name = "")],
 
-  /**
-   * Define the field-annotated-by pattern by fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-annotated-by:
-   * <ul>
-   * <li>fieldAnnotatedByClassConstant
-   * <li>fieldAnnotatedByClassNamePattern
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none are specified the default is to match any field regardless of what the field is
-   * annotated by.
-   *
-   * @return The qualified class name that defines the annotation.
-   */
-  val fieldAnnotatedByClassName: String = "",
+    /**
+     * Define the field-annotated-by pattern by fully qualified class name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-annotated-by:
+     * <ul>
+     * <li>fieldAnnotatedByClassConstant
+     * <li>fieldAnnotatedByClassNamePattern
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none are specified the default is to match any field regardless of what the field is
+     * annotated by.
+     *
+     * @return The qualified class name that defines the annotation.
+     */
+    val fieldAnnotatedByClassName: String = "",
 
-  /**
-   * Define the field-annotated-by pattern by reference to a Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-annotated-by:
-   * <ul>
-   * <li>fieldAnnotatedByClassName
-   * <li>fieldAnnotatedByClassNamePattern
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none are specified the default is to match any field regardless of what the field is
-   * annotated by.
-   *
-   * @return The class-constant that defines the annotation.
-   */
-  val fieldAnnotatedByClassConstant: KClass<*> = Object::class,
+    /**
+     * Define the field-annotated-by pattern by reference to a Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-annotated-by:
+     * <ul>
+     * <li>fieldAnnotatedByClassName
+     * <li>fieldAnnotatedByClassNamePattern
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none are specified the default is to match any field regardless of what the field is
+     * annotated by.
+     *
+     * @return The class-constant that defines the annotation.
+     */
+    val fieldAnnotatedByClassConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the field-annotated-by pattern by reference to a class-name pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-annotated-by:
-   * <ul>
-   * <li>fieldAnnotatedByClassName
-   * <li>fieldAnnotatedByClassConstant
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none are specified the default is to match any field regardless of what the field is
-   * annotated by.
-   *
-   * @return The class-name pattern that defines the annotation.
-   */
-  val fieldAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
+    /**
+     * Define the field-annotated-by pattern by reference to a class-name pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-annotated-by:
+     * <ul>
+     * <li>fieldAnnotatedByClassName
+     * <li>fieldAnnotatedByClassConstant
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none are specified the default is to match any field regardless of what the field is
+     * annotated by.
+     *
+     * @return The class-name pattern that defines the annotation.
+     */
+    val fieldAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
 
-  /**
-   * Define the field-access pattern by matching on access flags.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any field-access
-   * flags.
-   *
-   * <p>
-   * Mutually exclusive with the property `memberFromBinding` also defining field-access.
-   *
-   * @return The field access-flag constraints that must be met.
-   */
-  val fieldAccess: Array<FieldAccessFlags> = [],
+    /**
+     * Define the field-access pattern by matching on access flags.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any
+     * field-access flags.
+     *
+     * <p>
+     * Mutually exclusive with the property `memberFromBinding` also defining field-access.
+     *
+     * @return The field access-flag constraints that must be met.
+     */
+    val fieldAccess: Array<FieldAccessFlags> = [],
 
-  /**
-   * Define the field-name pattern by an exact field name.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any field name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-name:
-   * <ul>
-   * <li>fieldNamePattern
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * @return The exact field name of the field.
-   */
-  val fieldName: String = "",
+    /**
+     * Define the field-name pattern by an exact field name.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any field
+     * name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-name:
+     * <ul>
+     * <li>fieldNamePattern
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * @return The exact field name of the field.
+     */
+    val fieldName: String = "",
 
-  /**
-   * Define the field-name pattern by a string pattern.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any field name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-name:
-   * <ul>
-   * <li>fieldName
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * @return The string pattern of the field name.
-   */
-  val fieldNamePattern: StringPattern = StringPattern(exact = ""),
+    /**
+     * Define the field-name pattern by a string pattern.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any field
+     * name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-name:
+     * <ul>
+     * <li>fieldName
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * @return The string pattern of the field name.
+     */
+    val fieldNamePattern: StringPattern = StringPattern(exact = ""),
 
-  /**
-   * Define the field-type pattern by a fully qualified type.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-type:
-   * <ul>
-   * <li>fieldTypeConstant
-   * <li>fieldTypePattern
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * @return The qualified type name for the field type.
-   */
-  val fieldType: String = "",
+    /**
+     * Define the field-type pattern by a fully qualified type.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-type:
+     * <ul>
+     * <li>fieldTypeConstant
+     * <li>fieldTypePattern
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * @return The qualified type name for the field type.
+     */
+    val fieldType: String = "",
 
-  /**
-   * Define the field-type pattern by a class constant.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-type:
-   * <ul>
-   * <li>fieldType
-   * <li>fieldTypePattern
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * @return The class constant for the field type.
-   */
-  val fieldTypeConstant: KClass<*> = Object::class,
+    /**
+     * Define the field-type pattern by a class constant.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-type:
+     * <ul>
+     * <li>fieldType
+     * <li>fieldTypePattern
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * @return The class constant for the field type.
+     */
+    val fieldTypeConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the field-type pattern by a pattern on types.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-type:
-   * <ul>
-   * <li>fieldType
-   * <li>fieldTypeConstant
-   * <li>memberFromBinding
-   * </ul>
-   *
-   * @return The type pattern for the field type.
-   */
-  val fieldTypePattern: TypePattern = TypePattern(name = ""),
+    /**
+     * Define the field-type pattern by a pattern on types.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-type:
+     * <ul>
+     * <li>fieldType
+     * <li>fieldTypeConstant
+     * <li>memberFromBinding
+     * </ul>
+     *
+     * @return The type pattern for the field type.
+     */
+    val fieldTypePattern: TypePattern = TypePattern(name = ""),
 )

src/keepanno/java/androidx/annotation/keep/MemberAccessFlags.kt

diff --git a/src/keepanno/java/androidx/annotation/keep/MemberAccessFlags.kt b/src/keepanno/java/androidx/annotation/keep/MemberAccessFlags.kt
index 949a641..f855eee 100644
--- a/src/keepanno/java/androidx/annotation/keep/MemberAccessFlags.kt
+++ b/src/keepanno/java/androidx/annotation/keep/MemberAccessFlags.kt
@@ -27,18 +27,18 @@
  * operation syntactically.
  */
 public enum class MemberAccessFlags {
-  PUBLIC,
-  NON_PUBLIC,
-  PROTECTED,
-  NON_PROTECTED,
-  PACKAGE_PRIVATE,
-  NON_PACKAGE_PRIVATE,
-  PRIVATE,
-  NON_PRIVATE,
-  STATIC,
-  NON_STATIC,
-  FINAL,
-  NON_FINAL,
-  SYNTHETIC,
-  NON_SYNTHETIC,
+    PUBLIC,
+    NON_PUBLIC,
+    PROTECTED,
+    NON_PROTECTED,
+    PACKAGE_PRIVATE,
+    NON_PACKAGE_PRIVATE,
+    PRIVATE,
+    NON_PRIVATE,
+    STATIC,
+    NON_STATIC,
+    FINAL,
+    NON_FINAL,
+    SYNTHETIC,
+    NON_SYNTHETIC,
 }

src/keepanno/java/androidx/annotation/keep/MethodAccessFlags.kt

diff --git a/src/keepanno/java/androidx/annotation/keep/MethodAccessFlags.kt b/src/keepanno/java/androidx/annotation/keep/MethodAccessFlags.kt
index 3760256..4bb9a82 100644
--- a/src/keepanno/java/androidx/annotation/keep/MethodAccessFlags.kt
+++ b/src/keepanno/java/androidx/annotation/keep/MethodAccessFlags.kt
@@ -27,31 +27,31 @@
  * operation syntactically.
  */
 public enum class MethodAccessFlags {
-  // General member flags.
-  PUBLIC,
-  NON_PUBLIC,
-  PRIVATE,
-  NON_PRIVATE,
-  PROTECTED,
-  NON_PROTECTED,
-  PACKAGE_PRIVATE,
-  NON_PACKAGE_PRIVATE,
-  STATIC,
-  NON_STATIC,
-  FINAL,
-  NON_FINAL,
-  SYNTHETIC,
-  NON_SYNTHETIC,
-  // Method specific flags.
-  SYNCHRONIZED,
-  NON_SYNCHRONIZED,
-  BRIDGE,
-  NON_BRIDGE,
-  // VARARGS - No PG parser support
-  NATIVE,
-  NON_NATIVE,
-  ABSTRACT,
-  NON_ABSTRACT,
-  STRICT_FP,
-  NON_STRICT_FP,
+    // General member flags.
+    PUBLIC,
+    NON_PUBLIC,
+    PRIVATE,
+    NON_PRIVATE,
+    PROTECTED,
+    NON_PROTECTED,
+    PACKAGE_PRIVATE,
+    NON_PACKAGE_PRIVATE,
+    STATIC,
+    NON_STATIC,
+    FINAL,
+    NON_FINAL,
+    SYNTHETIC,
+    NON_SYNTHETIC,
+    // Method specific flags.
+    SYNCHRONIZED,
+    NON_SYNCHRONIZED,
+    BRIDGE,
+    NON_BRIDGE,
+    // VARARGS - No PG parser support
+    NATIVE,
+    NON_NATIVE,
+    ABSTRACT,
+    NON_ABSTRACT,
+    STRICT_FP,
+    NON_STRICT_FP,
 }

src/keepanno/java/androidx/annotation/keep/StringPattern.kt

diff --git a/src/keepanno/java/androidx/annotation/keep/StringPattern.kt b/src/keepanno/java/androidx/annotation/keep/StringPattern.kt
index 15979fd..a81c2b0 100644
--- a/src/keepanno/java/androidx/annotation/keep/StringPattern.kt
+++ b/src/keepanno/java/androidx/annotation/keep/StringPattern.kt
@@ -37,40 +37,40 @@
 @Target(AnnotationTarget.ANNOTATION_CLASS)
 public annotation class StringPattern(
 
-  /**
-   * Exact string content.
-   *
-   * <p>
-   * For example, {@code "foo"} or {@code "java.lang.String"}.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining string-exact-pattern:
-   * <ul>
-   * <li>startsWith
-   * <li>endsWith
-   * </ul>
-   */
-  val exact: String = "",
+    /**
+     * Exact string content.
+     *
+     * <p>
+     * For example, {@code "foo"} or {@code "java.lang.String"}.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining string-exact-pattern:
+     * <ul>
+     * <li>startsWith
+     * <li>endsWith
+     * </ul>
+     */
+    val exact: String = "",
 
-  /**
-   * Matches strings beginning with the given prefix.
-   *
-   * <p>
-   * For example, {@code "get"} to match strings such as {@code "getMyValue"}.
-   *
-   * <p>
-   * Mutually exclusive with the property `exact` also defining string-prefix-pattern.
-   */
-  val startsWith: String = "",
+    /**
+     * Matches strings beginning with the given prefix.
+     *
+     * <p>
+     * For example, {@code "get"} to match strings such as {@code "getMyValue"}.
+     *
+     * <p>
+     * Mutually exclusive with the property `exact` also defining string-prefix-pattern.
+     */
+    val startsWith: String = "",
 
-  /**
-   * Matches strings ending with the given suffix.
-   *
-   * <p>
-   * For example, {@code "Setter"} to match strings such as {@code "myValueSetter"}.
-   *
-   * <p>
-   * Mutually exclusive with the property `exact` also defining string-suffix-pattern.
-   */
-  val endsWith: String = "",
+    /**
+     * Matches strings ending with the given suffix.
+     *
+     * <p>
+     * For example, {@code "Setter"} to match strings such as {@code "myValueSetter"}.
+     *
+     * <p>
+     * Mutually exclusive with the property `exact` also defining string-suffix-pattern.
+     */
+    val endsWith: String = "",
 )

src/keepanno/java/androidx/annotation/keep/TypePattern.kt

diff --git a/src/keepanno/java/androidx/annotation/keep/TypePattern.kt b/src/keepanno/java/androidx/annotation/keep/TypePattern.kt
index 5e42220..6f9b9ee 100644
--- a/src/keepanno/java/androidx/annotation/keep/TypePattern.kt
+++ b/src/keepanno/java/androidx/annotation/keep/TypePattern.kt
@@ -41,63 +41,63 @@
 @Target(AnnotationTarget.ANNOTATION_CLASS)
 public annotation class TypePattern(
 
-  /**
-   * Exact type name as a string.
-   *
-   * <p>
-   * For example, {@code "long"} or {@code "java.lang.String"}.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining type-pattern:
-   * <ul>
-   * <li>constant
-   * <li>classNamePattern
-   * <li>instanceOfPattern
-   * </ul>
-   */
-  val name: String = "",
+    /**
+     * Exact type name as a string.
+     *
+     * <p>
+     * For example, {@code "long"} or {@code "java.lang.String"}.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining type-pattern:
+     * <ul>
+     * <li>constant
+     * <li>classNamePattern
+     * <li>instanceOfPattern
+     * </ul>
+     */
+    val name: String = "",
 
-  /**
-   * Exact type from a class constant.
-   *
-   * <p>
-   * For example, {@code String.class}.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining type-pattern:
-   * <ul>
-   * <li>name
-   * <li>classNamePattern
-   * <li>instanceOfPattern
-   * </ul>
-   */
-  val constant: KClass<*> = Object::class,
+    /**
+     * Exact type from a class constant.
+     *
+     * <p>
+     * For example, {@code String.class}.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining type-pattern:
+     * <ul>
+     * <li>name
+     * <li>classNamePattern
+     * <li>instanceOfPattern
+     * </ul>
+     */
+    val constant: KClass<*> = Object::class,
 
-  /**
-   * Classes matching the class-name pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining type-pattern:
-   * <ul>
-   * <li>name
-   * <li>constant
-   * <li>instanceOfPattern
-   * </ul>
-   */
-  val classNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
+    /**
+     * Classes matching the class-name pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining type-pattern:
+     * <ul>
+     * <li>name
+     * <li>constant
+     * <li>instanceOfPattern
+     * </ul>
+     */
+    val classNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
 
-  /**
-   * Define the instance-of with a pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining type-pattern:
-   * <ul>
-   * <li>name
-   * <li>constant
-   * <li>classNamePattern
-   * </ul>
-   *
-   * @return The pattern that defines what instance-of the class must be.
-   */
-  val instanceOfPattern: InstanceOfPattern = InstanceOfPattern(),
+    /**
+     * Define the instance-of with a pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining type-pattern:
+     * <ul>
+     * <li>name
+     * <li>constant
+     * <li>classNamePattern
+     * </ul>
+     *
+     * @return The pattern that defines what instance-of the class must be.
+     */
+    val instanceOfPattern: InstanceOfPattern = InstanceOfPattern(),
 )

src/keepanno/java/androidx/annotation/keep/UsedByNative.kt

diff --git a/src/keepanno/java/androidx/annotation/keep/UsedByNative.kt b/src/keepanno/java/androidx/annotation/keep/UsedByNative.kt
index 5c5ab2c..9c170e0 100644
--- a/src/keepanno/java/androidx/annotation/keep/UsedByNative.kt
+++ b/src/keepanno/java/androidx/annotation/keep/UsedByNative.kt
@@ -48,589 +48,596 @@
  */
 @Retention(AnnotationRetention.BINARY)
 @Target(
-  AnnotationTarget.CLASS,
-  AnnotationTarget.FIELD,
-  AnnotationTarget.FUNCTION,
-  AnnotationTarget.CONSTRUCTOR,
+    AnnotationTarget.CLASS,
+    AnnotationTarget.FIELD,
+    AnnotationTarget.FUNCTION,
+    AnnotationTarget.CONSTRUCTOR,
 )
 public annotation class UsedByNative(
 
-  /**
-   * Optional description to document the reason for this annotation.
-   *
-   * @return The descriptive message. Defaults to no description.
-   */
-  val description: String = "",
+    /**
+     * Optional description to document the reason for this annotation.
+     *
+     * @return The descriptive message. Defaults to no description.
+     */
+    val description: String = "",
 
-  /**
-   * Conditions that should be satisfied for the annotation to be in effect.
-   *
-   * @return The list of preconditions. Defaults to no conditions, thus trivially/unconditionally
-   *   satisfied.
-   */
-  val preconditions: Array<KeepCondition> = [],
+    /**
+     * Conditions that should be satisfied for the annotation to be in effect.
+     *
+     * @return The list of preconditions. Defaults to no conditions, thus trivially/unconditionally
+     *   satisfied.
+     */
+    val preconditions: Array<KeepCondition> = [],
 
-  /**
-   * Additional targets to be kept in addition to the annotated class/members.
-   *
-   * @return List of additional target consequences. Defaults to no additional target consequences.
-   */
-  val additionalTargets: Array<KeepTarget> = [],
+    /**
+     * Additional targets to be kept in addition to the annotated class/members.
+     *
+     * @return List of additional target consequences. Defaults to no additional target
+     *   consequences.
+     */
+    val additionalTargets: Array<KeepTarget> = [],
 
-  /**
-   * Specify the kind of this item pattern.
-   *
-   * <p>
-   * If unspecified the default kind depends on the annotated item.
-   *
-   * <p>
-   * When annotating a class the default kind is:
-   * <ul>
-   * <li>{@link KeepItemKind#ONLY_CLASS} if no member patterns are defined;
-   * <li>{@link KeepItemKind#CLASS_AND_METHODS} if method patterns are defined;
-   * <li>{@link KeepItemKind#CLASS_AND_FIELDS} if field patterns are defined;
-   * <li>{@link KeepItemKind#CLASS_AND_MEMBERS} otherwise.
-   * </ul>
-   *
-   * <p>
-   * When annotating a method the default kind is: {@link KeepItemKind#ONLY_METHODS}
-   *
-   * <p>
-   * When annotating a field the default kind is: {@link KeepItemKind#ONLY_FIELDS}
-   *
-   * <p>
-   * It is not possible to use {@link KeepItemKind#ONLY_CLASS} if annotating a member.
-   *
-   * @return The kind for this pattern.
-   */
-  val kind: KeepItemKind = KeepItemKind.DEFAULT,
+    /**
+     * Specify the kind of this item pattern.
+     *
+     * <p>
+     * If unspecified the default kind depends on the annotated item.
+     *
+     * <p>
+     * When annotating a class the default kind is:
+     * <ul>
+     * <li>{@link KeepItemKind#ONLY_CLASS} if no member patterns are defined;
+     * <li>{@link KeepItemKind#CLASS_AND_METHODS} if method patterns are defined;
+     * <li>{@link KeepItemKind#CLASS_AND_FIELDS} if field patterns are defined;
+     * <li>{@link KeepItemKind#CLASS_AND_MEMBERS} otherwise.
+     * </ul>
+     *
+     * <p>
+     * When annotating a method the default kind is: {@link KeepItemKind#ONLY_METHODS}
+     *
+     * <p>
+     * When annotating a field the default kind is: {@link KeepItemKind#ONLY_FIELDS}
+     *
+     * <p>
+     * It is not possible to use {@link KeepItemKind#ONLY_CLASS} if annotating a member.
+     *
+     * @return The kind for this pattern.
+     */
+    val kind: KeepItemKind = KeepItemKind.DEFAULT,
 
-  /**
-   * Define the usage constraints of the target.
-   *
-   * <p>
-   * The specified constraints must remain valid for the target.
-   *
-   * <p>
-   * The default constraints depend on the kind of the target. For all targets the default
-   * constraints include:
-   * <ul>
-   * <li>{@link KeepConstraint#LOOKUP}
-   * <li>{@link KeepConstraint#NAME}
-   * <li>{@link KeepConstraint#VISIBILITY_RELAX}
-   * </ul>
-   *
-   * <p>
-   * For classes the default constraints also include:
-   * <ul>
-   * <li>{@link KeepConstraint#CLASS_INSTANTIATE}
-   * </ul>
-   *
-   * <p>
-   * For methods the default constraints also include:
-   * <ul>
-   * <li>{@link KeepConstraint#METHOD_INVOKE}
-   * </ul>
-   *
-   * <p>
-   * For fields the default constraints also include:
-   * <ul>
-   * <li>{@link KeepConstraint#FIELD_GET}
-   * <li>{@link KeepConstraint#FIELD_SET}
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with the property `constraintAdditions` also defining constraints.
-   *
-   * @return Usage constraints for the target.
-   */
-  val constraints: Array<KeepConstraint> = [],
+    /**
+     * Define the usage constraints of the target.
+     *
+     * <p>
+     * The specified constraints must remain valid for the target.
+     *
+     * <p>
+     * The default constraints depend on the kind of the target. For all targets the default
+     * constraints include:
+     * <ul>
+     * <li>{@link KeepConstraint#LOOKUP}
+     * <li>{@link KeepConstraint#NAME}
+     * <li>{@link KeepConstraint#VISIBILITY_RELAX}
+     * </ul>
+     *
+     * <p>
+     * For classes the default constraints also include:
+     * <ul>
+     * <li>{@link KeepConstraint#CLASS_INSTANTIATE}
+     * </ul>
+     *
+     * <p>
+     * For methods the default constraints also include:
+     * <ul>
+     * <li>{@link KeepConstraint#METHOD_INVOKE}
+     * </ul>
+     *
+     * <p>
+     * For fields the default constraints also include:
+     * <ul>
+     * <li>{@link KeepConstraint#FIELD_GET}
+     * <li>{@link KeepConstraint#FIELD_SET}
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with the property `constraintAdditions` also defining constraints.
+     *
+     * @return Usage constraints for the target.
+     */
+    val constraints: Array<KeepConstraint> = [],
 
-  /**
-   * Add additional usage constraints of the target.
-   *
-   * <p>
-   * The specified constraints must remain valid for the target in addition to the default
-   * constraints.
-   *
-   * <p>
-   * The default constraints are documented in {@link #constraints}
-   *
-   * <p>
-   * Mutually exclusive with the property `constraints` also defining constraints.
-   *
-   * @return Additional usage constraints for the target.
-   */
-  val constraintAdditions: Array<KeepConstraint> = [],
+    /**
+     * Add additional usage constraints of the target.
+     *
+     * <p>
+     * The specified constraints must remain valid for the target in addition to the default
+     * constraints.
+     *
+     * <p>
+     * The default constraints are documented in {@link #constraints}
+     *
+     * <p>
+     * Mutually exclusive with the property `constraints` also defining constraints.
+     *
+     * @return Additional usage constraints for the target.
+     */
+    val constraintAdditions: Array<KeepConstraint> = [],
 
-  /**
-   * Patterns for annotations that must remain on the item.
-   *
-   * <p>
-   * The annotations matching any of the patterns must remain on the item if the annotation types
-   * remain in the program.
-   *
-   * <p>
-   * Note that if the annotation types themselves are unused/removed, then their references on the
-   * item will be removed too. If the annotation types themselves are used reflectively then they
-   * too need a keep annotation or rule to ensure they remain in the program.
-   *
-   * <p>
-   * By default no annotation patterns are defined and no annotations are required to remain.
-   *
-   * @return Annotation patterns
-   */
-  val constrainAnnotations: Array<AnnotationPattern> = [],
+    /**
+     * Patterns for annotations that must remain on the item.
+     *
+     * <p>
+     * The annotations matching any of the patterns must remain on the item if the annotation types
+     * remain in the program.
+     *
+     * <p>
+     * Note that if the annotation types themselves are unused/removed, then their references on the
+     * item will be removed too. If the annotation types themselves are used reflectively then they
+     * too need a keep annotation or rule to ensure they remain in the program.
+     *
+     * <p>
+     * By default no annotation patterns are defined and no annotations are required to remain.
+     *
+     * @return Annotation patterns
+     */
+    val constrainAnnotations: Array<AnnotationPattern> = [],
 
-  /**
-   * Define the member-annotated-by pattern by fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining member-annotated-by:
-   * <ul>
-   * <li>memberAnnotatedByClassConstant
-   * <li>memberAnnotatedByClassNamePattern
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field and method properties as use restricts the match to both
-   * types of members.
-   *
-   * <p>
-   * If none are specified the default is to match any member regardless of what the member is
-   * annotated by.
-   *
-   * @return The qualified class name that defines the annotation.
-   */
-  val memberAnnotatedByClassName: String = "",
+    /**
+     * Define the member-annotated-by pattern by fully qualified class name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining member-annotated-by:
+     * <ul>
+     * <li>memberAnnotatedByClassConstant
+     * <li>memberAnnotatedByClassNamePattern
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field and method properties as use restricts the match to both
+     * types of members.
+     *
+     * <p>
+     * If none are specified the default is to match any member regardless of what the member is
+     * annotated by.
+     *
+     * @return The qualified class name that defines the annotation.
+     */
+    val memberAnnotatedByClassName: String = "",
 
-  /**
-   * Define the member-annotated-by pattern by reference to a Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining member-annotated-by:
-   * <ul>
-   * <li>memberAnnotatedByClassName
-   * <li>memberAnnotatedByClassNamePattern
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field and method properties as use restricts the match to both
-   * types of members.
-   *
-   * <p>
-   * If none are specified the default is to match any member regardless of what the member is
-   * annotated by.
-   *
-   * @return The class-constant that defines the annotation.
-   */
-  val memberAnnotatedByClassConstant: KClass<*> = Object::class,
+    /**
+     * Define the member-annotated-by pattern by reference to a Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining member-annotated-by:
+     * <ul>
+     * <li>memberAnnotatedByClassName
+     * <li>memberAnnotatedByClassNamePattern
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field and method properties as use restricts the match to both
+     * types of members.
+     *
+     * <p>
+     * If none are specified the default is to match any member regardless of what the member is
+     * annotated by.
+     *
+     * @return The class-constant that defines the annotation.
+     */
+    val memberAnnotatedByClassConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the member-annotated-by pattern by reference to a class-name pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining member-annotated-by:
-   * <ul>
-   * <li>memberAnnotatedByClassName
-   * <li>memberAnnotatedByClassConstant
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field and method properties as use restricts the match to both
-   * types of members.
-   *
-   * <p>
-   * If none are specified the default is to match any member regardless of what the member is
-   * annotated by.
-   *
-   * @return The class-name pattern that defines the annotation.
-   */
-  val memberAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
+    /**
+     * Define the member-annotated-by pattern by reference to a class-name pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining member-annotated-by:
+     * <ul>
+     * <li>memberAnnotatedByClassName
+     * <li>memberAnnotatedByClassConstant
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field and method properties as use restricts the match to both
+     * types of members.
+     *
+     * <p>
+     * If none are specified the default is to match any member regardless of what the member is
+     * annotated by.
+     *
+     * @return The class-name pattern that defines the annotation.
+     */
+    val memberAnnotatedByClassNamePattern: ClassNamePattern =
+        ClassNamePattern(unqualifiedName = ""),
 
-  /**
-   * Define the member-access pattern by matching on access flags.
-   *
-   * <p>
-   * Mutually exclusive with all field and method properties as use restricts the match to both
-   * types of members.
-   *
-   * @return The member access-flag constraints that must be met.
-   */
-  val memberAccess: Array<MemberAccessFlags> = [],
+    /**
+     * Define the member-access pattern by matching on access flags.
+     *
+     * <p>
+     * Mutually exclusive with all field and method properties as use restricts the match to both
+     * types of members.
+     *
+     * @return The member access-flag constraints that must be met.
+     */
+    val memberAccess: Array<MemberAccessFlags> = [],
 
-  /**
-   * Define the method-annotated-by pattern by fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining method-annotated-by:
-   * <ul>
-   * <li>methodAnnotatedByClassConstant
-   * <li>methodAnnotatedByClassNamePattern
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none are specified the default is to match any method regardless of what the method is
-   * annotated by.
-   *
-   * @return The qualified class name that defines the annotation.
-   */
-  val methodAnnotatedByClassName: String = "",
+    /**
+     * Define the method-annotated-by pattern by fully qualified class name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining method-annotated-by:
+     * <ul>
+     * <li>methodAnnotatedByClassConstant
+     * <li>methodAnnotatedByClassNamePattern
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none are specified the default is to match any method regardless of what the method is
+     * annotated by.
+     *
+     * @return The qualified class name that defines the annotation.
+     */
+    val methodAnnotatedByClassName: String = "",
 
-  /**
-   * Define the method-annotated-by pattern by reference to a Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining method-annotated-by:
-   * <ul>
-   * <li>methodAnnotatedByClassName
-   * <li>methodAnnotatedByClassNamePattern
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none are specified the default is to match any method regardless of what the method is
-   * annotated by.
-   *
-   * @return The class-constant that defines the annotation.
-   */
-  val methodAnnotatedByClassConstant: KClass<*> = Object::class,
+    /**
+     * Define the method-annotated-by pattern by reference to a Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining method-annotated-by:
+     * <ul>
+     * <li>methodAnnotatedByClassName
+     * <li>methodAnnotatedByClassNamePattern
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none are specified the default is to match any method regardless of what the method is
+     * annotated by.
+     *
+     * @return The class-constant that defines the annotation.
+     */
+    val methodAnnotatedByClassConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the method-annotated-by pattern by reference to a class-name pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining method-annotated-by:
-   * <ul>
-   * <li>methodAnnotatedByClassName
-   * <li>methodAnnotatedByClassConstant
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none are specified the default is to match any method regardless of what the method is
-   * annotated by.
-   *
-   * @return The class-name pattern that defines the annotation.
-   */
-  val methodAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
+    /**
+     * Define the method-annotated-by pattern by reference to a class-name pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining method-annotated-by:
+     * <ul>
+     * <li>methodAnnotatedByClassName
+     * <li>methodAnnotatedByClassConstant
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none are specified the default is to match any method regardless of what the method is
+     * annotated by.
+     *
+     * @return The class-name pattern that defines the annotation.
+     */
+    val methodAnnotatedByClassNamePattern: ClassNamePattern =
+        ClassNamePattern(unqualifiedName = ""),
 
-  /**
-   * Define the method-access pattern by matching on access flags.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any
-   * method-access flags.
-   *
-   * @return The method access-flag constraints that must be met.
-   */
-  val methodAccess: Array<MethodAccessFlags> = [],
+    /**
+     * Define the method-access pattern by matching on access flags.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any
+     * method-access flags.
+     *
+     * @return The method access-flag constraints that must be met.
+     */
+    val methodAccess: Array<MethodAccessFlags> = [],
 
-  /**
-   * Define the method-name pattern by an exact method name.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any method
-   * name.
-   *
-   * <p>
-   * Mutually exclusive with the property `methodNamePattern` also defining method-name.
-   *
-   * @return The exact method name of the method.
-   */
-  val methodName: String = "",
+    /**
+     * Define the method-name pattern by an exact method name.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any method
+     * name.
+     *
+     * <p>
+     * Mutually exclusive with the property `methodNamePattern` also defining method-name.
+     *
+     * @return The exact method name of the method.
+     */
+    val methodName: String = "",
 
-  /**
-   * Define the method-name pattern by a string pattern.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any method
-   * name.
-   *
-   * <p>
-   * Mutually exclusive with the property `methodName` also defining method-name.
-   *
-   * @return The string pattern of the method name.
-   */
-  val methodNamePattern: StringPattern = StringPattern(exact = ""),
+    /**
+     * Define the method-name pattern by a string pattern.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any method
+     * name.
+     *
+     * <p>
+     * Mutually exclusive with the property `methodName` also defining method-name.
+     *
+     * @return The string pattern of the method name.
+     */
+    val methodNamePattern: StringPattern = StringPattern(exact = ""),
 
-  /**
-   * Define the method return-type pattern by a fully qualified type or 'void'.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any return
-   * type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining return-type:
-   * <ul>
-   * <li>methodReturnTypeConstant
-   * <li>methodReturnTypePattern
-   * </ul>
-   *
-   * @return The qualified type name of the method return type.
-   */
-  val methodReturnType: String = "",
+    /**
+     * Define the method return-type pattern by a fully qualified type or 'void'.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any return
+     * type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining return-type:
+     * <ul>
+     * <li>methodReturnTypeConstant
+     * <li>methodReturnTypePattern
+     * </ul>
+     *
+     * @return The qualified type name of the method return type.
+     */
+    val methodReturnType: String = "",
 
-  /**
-   * Define the method return-type pattern by a class constant.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any return
-   * type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining return-type:
-   * <ul>
-   * <li>methodReturnType
-   * <li>methodReturnTypePattern
-   * </ul>
-   *
-   * @return A class constant denoting the type of the method return type.
-   */
-  val methodReturnTypeConstant: KClass<*> = Object::class,
+    /**
+     * Define the method return-type pattern by a class constant.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any return
+     * type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining return-type:
+     * <ul>
+     * <li>methodReturnType
+     * <li>methodReturnTypePattern
+     * </ul>
+     *
+     * @return A class constant denoting the type of the method return type.
+     */
+    val methodReturnTypeConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the method return-type pattern by a type pattern.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any return
-   * type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining return-type:
-   * <ul>
-   * <li>methodReturnType
-   * <li>methodReturnTypeConstant
-   * </ul>
-   *
-   * @return The pattern of the method return type.
-   */
-  val methodReturnTypePattern: TypePattern = TypePattern(name = ""),
+    /**
+     * Define the method return-type pattern by a type pattern.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any return
+     * type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining return-type:
+     * <ul>
+     * <li>methodReturnType
+     * <li>methodReturnTypeConstant
+     * </ul>
+     *
+     * @return The pattern of the method return type.
+     */
+    val methodReturnTypePattern: TypePattern = TypePattern(name = ""),
 
-  /**
-   * Define the method parameters pattern by a list of fully qualified types.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any parameters.
-   *
-   * <p>
-   * Mutually exclusive with the property `methodParameterTypePatterns` also defining parameters.
-   *
-   * @return The list of qualified type names of the method parameters.
-   */
-  val methodParameters: Array<String> = [""],
+    /**
+     * Define the method parameters pattern by a list of fully qualified types.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any
+     * parameters.
+     *
+     * <p>
+     * Mutually exclusive with the property `methodParameterTypePatterns` also defining parameters.
+     *
+     * @return The list of qualified type names of the method parameters.
+     */
+    val methodParameters: Array<String> = [""],
 
-  /**
-   * Define the method parameters pattern by a list of patterns on types.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any parameters.
-   *
-   * <p>
-   * Mutually exclusive with the property `methodParameters` also defining parameters.
-   *
-   * @return The list of type patterns for the method parameters.
-   */
-  val methodParameterTypePatterns: Array<TypePattern> = [TypePattern(name = "")],
+    /**
+     * Define the method parameters pattern by a list of patterns on types.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any
+     * parameters.
+     *
+     * <p>
+     * Mutually exclusive with the property `methodParameters` also defining parameters.
+     *
+     * @return The list of type patterns for the method parameters.
+     */
+    val methodParameterTypePatterns: Array<TypePattern> = [TypePattern(name = "")],
 
-  /**
-   * Define the field-annotated-by pattern by fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-annotated-by:
-   * <ul>
-   * <li>fieldAnnotatedByClassConstant
-   * <li>fieldAnnotatedByClassNamePattern
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none are specified the default is to match any field regardless of what the field is
-   * annotated by.
-   *
-   * @return The qualified class name that defines the annotation.
-   */
-  val fieldAnnotatedByClassName: String = "",
+    /**
+     * Define the field-annotated-by pattern by fully qualified class name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-annotated-by:
+     * <ul>
+     * <li>fieldAnnotatedByClassConstant
+     * <li>fieldAnnotatedByClassNamePattern
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none are specified the default is to match any field regardless of what the field is
+     * annotated by.
+     *
+     * @return The qualified class name that defines the annotation.
+     */
+    val fieldAnnotatedByClassName: String = "",
 
-  /**
-   * Define the field-annotated-by pattern by reference to a Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-annotated-by:
-   * <ul>
-   * <li>fieldAnnotatedByClassName
-   * <li>fieldAnnotatedByClassNamePattern
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none are specified the default is to match any field regardless of what the field is
-   * annotated by.
-   *
-   * @return The class-constant that defines the annotation.
-   */
-  val fieldAnnotatedByClassConstant: KClass<*> = Object::class,
+    /**
+     * Define the field-annotated-by pattern by reference to a Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-annotated-by:
+     * <ul>
+     * <li>fieldAnnotatedByClassName
+     * <li>fieldAnnotatedByClassNamePattern
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none are specified the default is to match any field regardless of what the field is
+     * annotated by.
+     *
+     * @return The class-constant that defines the annotation.
+     */
+    val fieldAnnotatedByClassConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the field-annotated-by pattern by reference to a class-name pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-annotated-by:
-   * <ul>
-   * <li>fieldAnnotatedByClassName
-   * <li>fieldAnnotatedByClassConstant
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none are specified the default is to match any field regardless of what the field is
-   * annotated by.
-   *
-   * @return The class-name pattern that defines the annotation.
-   */
-  val fieldAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
+    /**
+     * Define the field-annotated-by pattern by reference to a class-name pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-annotated-by:
+     * <ul>
+     * <li>fieldAnnotatedByClassName
+     * <li>fieldAnnotatedByClassConstant
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none are specified the default is to match any field regardless of what the field is
+     * annotated by.
+     *
+     * @return The class-name pattern that defines the annotation.
+     */
+    val fieldAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
 
-  /**
-   * Define the field-access pattern by matching on access flags.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any field-access
-   * flags.
-   *
-   * @return The field access-flag constraints that must be met.
-   */
-  val fieldAccess: Array<FieldAccessFlags> = [],
+    /**
+     * Define the field-access pattern by matching on access flags.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any
+     * field-access flags.
+     *
+     * @return The field access-flag constraints that must be met.
+     */
+    val fieldAccess: Array<FieldAccessFlags> = [],
 
-  /**
-   * Define the field-name pattern by an exact field name.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any field name.
-   *
-   * <p>
-   * Mutually exclusive with the property `fieldNamePattern` also defining field-name.
-   *
-   * @return The exact field name of the field.
-   */
-  val fieldName: String = "",
+    /**
+     * Define the field-name pattern by an exact field name.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any field
+     * name.
+     *
+     * <p>
+     * Mutually exclusive with the property `fieldNamePattern` also defining field-name.
+     *
+     * @return The exact field name of the field.
+     */
+    val fieldName: String = "",
 
-  /**
-   * Define the field-name pattern by a string pattern.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any field name.
-   *
-   * <p>
-   * Mutually exclusive with the property `fieldName` also defining field-name.
-   *
-   * @return The string pattern of the field name.
-   */
-  val fieldNamePattern: StringPattern = StringPattern(exact = ""),
+    /**
+     * Define the field-name pattern by a string pattern.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any field
+     * name.
+     *
+     * <p>
+     * Mutually exclusive with the property `fieldName` also defining field-name.
+     *
+     * @return The string pattern of the field name.
+     */
+    val fieldNamePattern: StringPattern = StringPattern(exact = ""),
 
-  /**
-   * Define the field-type pattern by a fully qualified type.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-type:
-   * <ul>
-   * <li>fieldTypeConstant
-   * <li>fieldTypePattern
-   * </ul>
-   *
-   * @return The qualified type name for the field type.
-   */
-  val fieldType: String = "",
+    /**
+     * Define the field-type pattern by a fully qualified type.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-type:
+     * <ul>
+     * <li>fieldTypeConstant
+     * <li>fieldTypePattern
+     * </ul>
+     *
+     * @return The qualified type name for the field type.
+     */
+    val fieldType: String = "",
 
-  /**
-   * Define the field-type pattern by a class constant.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-type:
-   * <ul>
-   * <li>fieldType
-   * <li>fieldTypePattern
-   * </ul>
-   *
-   * @return The class constant for the field type.
-   */
-  val fieldTypeConstant: KClass<*> = Object::class,
+    /**
+     * Define the field-type pattern by a class constant.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-type:
+     * <ul>
+     * <li>fieldType
+     * <li>fieldTypePattern
+     * </ul>
+     *
+     * @return The class constant for the field type.
+     */
+    val fieldTypeConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the field-type pattern by a pattern on types.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-type:
-   * <ul>
-   * <li>fieldType
-   * <li>fieldTypeConstant
-   * </ul>
-   *
-   * @return The type pattern for the field type.
-   */
-  val fieldTypePattern: TypePattern = TypePattern(name = ""),
+    /**
+     * Define the field-type pattern by a pattern on types.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-type:
+     * <ul>
+     * <li>fieldType
+     * <li>fieldTypeConstant
+     * </ul>
+     *
+     * @return The type pattern for the field type.
+     */
+    val fieldTypePattern: TypePattern = TypePattern(name = ""),
 )

src/keepanno/java/androidx/annotation/keep/UsedByReflection.kt

diff --git a/src/keepanno/java/androidx/annotation/keep/UsedByReflection.kt b/src/keepanno/java/androidx/annotation/keep/UsedByReflection.kt
index 8f4c8db..c617f77 100644
--- a/src/keepanno/java/androidx/annotation/keep/UsedByReflection.kt
+++ b/src/keepanno/java/androidx/annotation/keep/UsedByReflection.kt
@@ -48,589 +48,596 @@
  */
 @Retention(AnnotationRetention.BINARY)
 @Target(
-  AnnotationTarget.CLASS,
-  AnnotationTarget.FIELD,
-  AnnotationTarget.FUNCTION,
-  AnnotationTarget.CONSTRUCTOR,
+    AnnotationTarget.CLASS,
+    AnnotationTarget.FIELD,
+    AnnotationTarget.FUNCTION,
+    AnnotationTarget.CONSTRUCTOR,
 )
 public annotation class UsedByReflection(
 
-  /**
-   * Optional description to document the reason for this annotation.
-   *
-   * @return The descriptive message. Defaults to no description.
-   */
-  val description: String = "",
+    /**
+     * Optional description to document the reason for this annotation.
+     *
+     * @return The descriptive message. Defaults to no description.
+     */
+    val description: String = "",
 
-  /**
-   * Conditions that should be satisfied for the annotation to be in effect.
-   *
-   * @return The list of preconditions. Defaults to no conditions, thus trivially/unconditionally
-   *   satisfied.
-   */
-  val preconditions: Array<KeepCondition> = [],
+    /**
+     * Conditions that should be satisfied for the annotation to be in effect.
+     *
+     * @return The list of preconditions. Defaults to no conditions, thus trivially/unconditionally
+     *   satisfied.
+     */
+    val preconditions: Array<KeepCondition> = [],
 
-  /**
-   * Additional targets to be kept in addition to the annotated class/members.
-   *
-   * @return List of additional target consequences. Defaults to no additional target consequences.
-   */
-  val additionalTargets: Array<KeepTarget> = [],
+    /**
+     * Additional targets to be kept in addition to the annotated class/members.
+     *
+     * @return List of additional target consequences. Defaults to no additional target
+     *   consequences.
+     */
+    val additionalTargets: Array<KeepTarget> = [],
 
-  /**
-   * Specify the kind of this item pattern.
-   *
-   * <p>
-   * If unspecified the default kind depends on the annotated item.
-   *
-   * <p>
-   * When annotating a class the default kind is:
-   * <ul>
-   * <li>{@link KeepItemKind#ONLY_CLASS} if no member patterns are defined;
-   * <li>{@link KeepItemKind#CLASS_AND_METHODS} if method patterns are defined;
-   * <li>{@link KeepItemKind#CLASS_AND_FIELDS} if field patterns are defined;
-   * <li>{@link KeepItemKind#CLASS_AND_MEMBERS} otherwise.
-   * </ul>
-   *
-   * <p>
-   * When annotating a method the default kind is: {@link KeepItemKind#ONLY_METHODS}
-   *
-   * <p>
-   * When annotating a field the default kind is: {@link KeepItemKind#ONLY_FIELDS}
-   *
-   * <p>
-   * It is not possible to use {@link KeepItemKind#ONLY_CLASS} if annotating a member.
-   *
-   * @return The kind for this pattern.
-   */
-  val kind: KeepItemKind = KeepItemKind.DEFAULT,
+    /**
+     * Specify the kind of this item pattern.
+     *
+     * <p>
+     * If unspecified the default kind depends on the annotated item.
+     *
+     * <p>
+     * When annotating a class the default kind is:
+     * <ul>
+     * <li>{@link KeepItemKind#ONLY_CLASS} if no member patterns are defined;
+     * <li>{@link KeepItemKind#CLASS_AND_METHODS} if method patterns are defined;
+     * <li>{@link KeepItemKind#CLASS_AND_FIELDS} if field patterns are defined;
+     * <li>{@link KeepItemKind#CLASS_AND_MEMBERS} otherwise.
+     * </ul>
+     *
+     * <p>
+     * When annotating a method the default kind is: {@link KeepItemKind#ONLY_METHODS}
+     *
+     * <p>
+     * When annotating a field the default kind is: {@link KeepItemKind#ONLY_FIELDS}
+     *
+     * <p>
+     * It is not possible to use {@link KeepItemKind#ONLY_CLASS} if annotating a member.
+     *
+     * @return The kind for this pattern.
+     */
+    val kind: KeepItemKind = KeepItemKind.DEFAULT,
 
-  /**
-   * Define the usage constraints of the target.
-   *
-   * <p>
-   * The specified constraints must remain valid for the target.
-   *
-   * <p>
-   * The default constraints depend on the kind of the target. For all targets the default
-   * constraints include:
-   * <ul>
-   * <li>{@link KeepConstraint#LOOKUP}
-   * <li>{@link KeepConstraint#NAME}
-   * <li>{@link KeepConstraint#VISIBILITY_RELAX}
-   * </ul>
-   *
-   * <p>
-   * For classes the default constraints also include:
-   * <ul>
-   * <li>{@link KeepConstraint#CLASS_INSTANTIATE}
-   * </ul>
-   *
-   * <p>
-   * For methods the default constraints also include:
-   * <ul>
-   * <li>{@link KeepConstraint#METHOD_INVOKE}
-   * </ul>
-   *
-   * <p>
-   * For fields the default constraints also include:
-   * <ul>
-   * <li>{@link KeepConstraint#FIELD_GET}
-   * <li>{@link KeepConstraint#FIELD_SET}
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with the property `constraintAdditions` also defining constraints.
-   *
-   * @return Usage constraints for the target.
-   */
-  val constraints: Array<KeepConstraint> = [],
+    /**
+     * Define the usage constraints of the target.
+     *
+     * <p>
+     * The specified constraints must remain valid for the target.
+     *
+     * <p>
+     * The default constraints depend on the kind of the target. For all targets the default
+     * constraints include:
+     * <ul>
+     * <li>{@link KeepConstraint#LOOKUP}
+     * <li>{@link KeepConstraint#NAME}
+     * <li>{@link KeepConstraint#VISIBILITY_RELAX}
+     * </ul>
+     *
+     * <p>
+     * For classes the default constraints also include:
+     * <ul>
+     * <li>{@link KeepConstraint#CLASS_INSTANTIATE}
+     * </ul>
+     *
+     * <p>
+     * For methods the default constraints also include:
+     * <ul>
+     * <li>{@link KeepConstraint#METHOD_INVOKE}
+     * </ul>
+     *
+     * <p>
+     * For fields the default constraints also include:
+     * <ul>
+     * <li>{@link KeepConstraint#FIELD_GET}
+     * <li>{@link KeepConstraint#FIELD_SET}
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with the property `constraintAdditions` also defining constraints.
+     *
+     * @return Usage constraints for the target.
+     */
+    val constraints: Array<KeepConstraint> = [],
 
-  /**
-   * Add additional usage constraints of the target.
-   *
-   * <p>
-   * The specified constraints must remain valid for the target in addition to the default
-   * constraints.
-   *
-   * <p>
-   * The default constraints are documented in {@link #constraints}
-   *
-   * <p>
-   * Mutually exclusive with the property `constraints` also defining constraints.
-   *
-   * @return Additional usage constraints for the target.
-   */
-  val constraintAdditions: Array<KeepConstraint> = [],
+    /**
+     * Add additional usage constraints of the target.
+     *
+     * <p>
+     * The specified constraints must remain valid for the target in addition to the default
+     * constraints.
+     *
+     * <p>
+     * The default constraints are documented in {@link #constraints}
+     *
+     * <p>
+     * Mutually exclusive with the property `constraints` also defining constraints.
+     *
+     * @return Additional usage constraints for the target.
+     */
+    val constraintAdditions: Array<KeepConstraint> = [],
 
-  /**
-   * Patterns for annotations that must remain on the item.
-   *
-   * <p>
-   * The annotations matching any of the patterns must remain on the item if the annotation types
-   * remain in the program.
-   *
-   * <p>
-   * Note that if the annotation types themselves are unused/removed, then their references on the
-   * item will be removed too. If the annotation types themselves are used reflectively then they
-   * too need a keep annotation or rule to ensure they remain in the program.
-   *
-   * <p>
-   * By default no annotation patterns are defined and no annotations are required to remain.
-   *
-   * @return Annotation patterns
-   */
-  val constrainAnnotations: Array<AnnotationPattern> = [],
+    /**
+     * Patterns for annotations that must remain on the item.
+     *
+     * <p>
+     * The annotations matching any of the patterns must remain on the item if the annotation types
+     * remain in the program.
+     *
+     * <p>
+     * Note that if the annotation types themselves are unused/removed, then their references on the
+     * item will be removed too. If the annotation types themselves are used reflectively then they
+     * too need a keep annotation or rule to ensure they remain in the program.
+     *
+     * <p>
+     * By default no annotation patterns are defined and no annotations are required to remain.
+     *
+     * @return Annotation patterns
+     */
+    val constrainAnnotations: Array<AnnotationPattern> = [],
 
-  /**
-   * Define the member-annotated-by pattern by fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining member-annotated-by:
-   * <ul>
-   * <li>memberAnnotatedByClassConstant
-   * <li>memberAnnotatedByClassNamePattern
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field and method properties as use restricts the match to both
-   * types of members.
-   *
-   * <p>
-   * If none are specified the default is to match any member regardless of what the member is
-   * annotated by.
-   *
-   * @return The qualified class name that defines the annotation.
-   */
-  val memberAnnotatedByClassName: String = "",
+    /**
+     * Define the member-annotated-by pattern by fully qualified class name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining member-annotated-by:
+     * <ul>
+     * <li>memberAnnotatedByClassConstant
+     * <li>memberAnnotatedByClassNamePattern
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field and method properties as use restricts the match to both
+     * types of members.
+     *
+     * <p>
+     * If none are specified the default is to match any member regardless of what the member is
+     * annotated by.
+     *
+     * @return The qualified class name that defines the annotation.
+     */
+    val memberAnnotatedByClassName: String = "",
 
-  /**
-   * Define the member-annotated-by pattern by reference to a Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining member-annotated-by:
-   * <ul>
-   * <li>memberAnnotatedByClassName
-   * <li>memberAnnotatedByClassNamePattern
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field and method properties as use restricts the match to both
-   * types of members.
-   *
-   * <p>
-   * If none are specified the default is to match any member regardless of what the member is
-   * annotated by.
-   *
-   * @return The class-constant that defines the annotation.
-   */
-  val memberAnnotatedByClassConstant: KClass<*> = Object::class,
+    /**
+     * Define the member-annotated-by pattern by reference to a Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining member-annotated-by:
+     * <ul>
+     * <li>memberAnnotatedByClassName
+     * <li>memberAnnotatedByClassNamePattern
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field and method properties as use restricts the match to both
+     * types of members.
+     *
+     * <p>
+     * If none are specified the default is to match any member regardless of what the member is
+     * annotated by.
+     *
+     * @return The class-constant that defines the annotation.
+     */
+    val memberAnnotatedByClassConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the member-annotated-by pattern by reference to a class-name pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining member-annotated-by:
-   * <ul>
-   * <li>memberAnnotatedByClassName
-   * <li>memberAnnotatedByClassConstant
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field and method properties as use restricts the match to both
-   * types of members.
-   *
-   * <p>
-   * If none are specified the default is to match any member regardless of what the member is
-   * annotated by.
-   *
-   * @return The class-name pattern that defines the annotation.
-   */
-  val memberAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
+    /**
+     * Define the member-annotated-by pattern by reference to a class-name pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining member-annotated-by:
+     * <ul>
+     * <li>memberAnnotatedByClassName
+     * <li>memberAnnotatedByClassConstant
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field and method properties as use restricts the match to both
+     * types of members.
+     *
+     * <p>
+     * If none are specified the default is to match any member regardless of what the member is
+     * annotated by.
+     *
+     * @return The class-name pattern that defines the annotation.
+     */
+    val memberAnnotatedByClassNamePattern: ClassNamePattern =
+        ClassNamePattern(unqualifiedName = ""),
 
-  /**
-   * Define the member-access pattern by matching on access flags.
-   *
-   * <p>
-   * Mutually exclusive with all field and method properties as use restricts the match to both
-   * types of members.
-   *
-   * @return The member access-flag constraints that must be met.
-   */
-  val memberAccess: Array<MemberAccessFlags> = [],
+    /**
+     * Define the member-access pattern by matching on access flags.
+     *
+     * <p>
+     * Mutually exclusive with all field and method properties as use restricts the match to both
+     * types of members.
+     *
+     * @return The member access-flag constraints that must be met.
+     */
+    val memberAccess: Array<MemberAccessFlags> = [],
 
-  /**
-   * Define the method-annotated-by pattern by fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining method-annotated-by:
-   * <ul>
-   * <li>methodAnnotatedByClassConstant
-   * <li>methodAnnotatedByClassNamePattern
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none are specified the default is to match any method regardless of what the method is
-   * annotated by.
-   *
-   * @return The qualified class name that defines the annotation.
-   */
-  val methodAnnotatedByClassName: String = "",
+    /**
+     * Define the method-annotated-by pattern by fully qualified class name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining method-annotated-by:
+     * <ul>
+     * <li>methodAnnotatedByClassConstant
+     * <li>methodAnnotatedByClassNamePattern
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none are specified the default is to match any method regardless of what the method is
+     * annotated by.
+     *
+     * @return The qualified class name that defines the annotation.
+     */
+    val methodAnnotatedByClassName: String = "",
 
-  /**
-   * Define the method-annotated-by pattern by reference to a Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining method-annotated-by:
-   * <ul>
-   * <li>methodAnnotatedByClassName
-   * <li>methodAnnotatedByClassNamePattern
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none are specified the default is to match any method regardless of what the method is
-   * annotated by.
-   *
-   * @return The class-constant that defines the annotation.
-   */
-  val methodAnnotatedByClassConstant: KClass<*> = Object::class,
+    /**
+     * Define the method-annotated-by pattern by reference to a Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining method-annotated-by:
+     * <ul>
+     * <li>methodAnnotatedByClassName
+     * <li>methodAnnotatedByClassNamePattern
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none are specified the default is to match any method regardless of what the method is
+     * annotated by.
+     *
+     * @return The class-constant that defines the annotation.
+     */
+    val methodAnnotatedByClassConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the method-annotated-by pattern by reference to a class-name pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining method-annotated-by:
-   * <ul>
-   * <li>methodAnnotatedByClassName
-   * <li>methodAnnotatedByClassConstant
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none are specified the default is to match any method regardless of what the method is
-   * annotated by.
-   *
-   * @return The class-name pattern that defines the annotation.
-   */
-  val methodAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
+    /**
+     * Define the method-annotated-by pattern by reference to a class-name pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining method-annotated-by:
+     * <ul>
+     * <li>methodAnnotatedByClassName
+     * <li>methodAnnotatedByClassConstant
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none are specified the default is to match any method regardless of what the method is
+     * annotated by.
+     *
+     * @return The class-name pattern that defines the annotation.
+     */
+    val methodAnnotatedByClassNamePattern: ClassNamePattern =
+        ClassNamePattern(unqualifiedName = ""),
 
-  /**
-   * Define the method-access pattern by matching on access flags.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any
-   * method-access flags.
-   *
-   * @return The method access-flag constraints that must be met.
-   */
-  val methodAccess: Array<MethodAccessFlags> = [],
+    /**
+     * Define the method-access pattern by matching on access flags.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any
+     * method-access flags.
+     *
+     * @return The method access-flag constraints that must be met.
+     */
+    val methodAccess: Array<MethodAccessFlags> = [],
 
-  /**
-   * Define the method-name pattern by an exact method name.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any method
-   * name.
-   *
-   * <p>
-   * Mutually exclusive with the property `methodNamePattern` also defining method-name.
-   *
-   * @return The exact method name of the method.
-   */
-  val methodName: String = "",
+    /**
+     * Define the method-name pattern by an exact method name.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any method
+     * name.
+     *
+     * <p>
+     * Mutually exclusive with the property `methodNamePattern` also defining method-name.
+     *
+     * @return The exact method name of the method.
+     */
+    val methodName: String = "",
 
-  /**
-   * Define the method-name pattern by a string pattern.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any method
-   * name.
-   *
-   * <p>
-   * Mutually exclusive with the property `methodName` also defining method-name.
-   *
-   * @return The string pattern of the method name.
-   */
-  val methodNamePattern: StringPattern = StringPattern(exact = ""),
+    /**
+     * Define the method-name pattern by a string pattern.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any method
+     * name.
+     *
+     * <p>
+     * Mutually exclusive with the property `methodName` also defining method-name.
+     *
+     * @return The string pattern of the method name.
+     */
+    val methodNamePattern: StringPattern = StringPattern(exact = ""),
 
-  /**
-   * Define the method return-type pattern by a fully qualified type or 'void'.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any return
-   * type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining return-type:
-   * <ul>
-   * <li>methodReturnTypeConstant
-   * <li>methodReturnTypePattern
-   * </ul>
-   *
-   * @return The qualified type name of the method return type.
-   */
-  val methodReturnType: String = "",
+    /**
+     * Define the method return-type pattern by a fully qualified type or 'void'.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any return
+     * type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining return-type:
+     * <ul>
+     * <li>methodReturnTypeConstant
+     * <li>methodReturnTypePattern
+     * </ul>
+     *
+     * @return The qualified type name of the method return type.
+     */
+    val methodReturnType: String = "",
 
-  /**
-   * Define the method return-type pattern by a class constant.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any return
-   * type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining return-type:
-   * <ul>
-   * <li>methodReturnType
-   * <li>methodReturnTypePattern
-   * </ul>
-   *
-   * @return A class constant denoting the type of the method return type.
-   */
-  val methodReturnTypeConstant: KClass<*> = Object::class,
+    /**
+     * Define the method return-type pattern by a class constant.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any return
+     * type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining return-type:
+     * <ul>
+     * <li>methodReturnType
+     * <li>methodReturnTypePattern
+     * </ul>
+     *
+     * @return A class constant denoting the type of the method return type.
+     */
+    val methodReturnTypeConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the method return-type pattern by a type pattern.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any return
-   * type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining return-type:
-   * <ul>
-   * <li>methodReturnType
-   * <li>methodReturnTypeConstant
-   * </ul>
-   *
-   * @return The pattern of the method return type.
-   */
-  val methodReturnTypePattern: TypePattern = TypePattern(name = ""),
+    /**
+     * Define the method return-type pattern by a type pattern.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any return
+     * type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining return-type:
+     * <ul>
+     * <li>methodReturnType
+     * <li>methodReturnTypeConstant
+     * </ul>
+     *
+     * @return The pattern of the method return type.
+     */
+    val methodReturnTypePattern: TypePattern = TypePattern(name = ""),
 
-  /**
-   * Define the method parameters pattern by a list of fully qualified types.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any parameters.
-   *
-   * <p>
-   * Mutually exclusive with the property `methodParameterTypePatterns` also defining parameters.
-   *
-   * @return The list of qualified type names of the method parameters.
-   */
-  val methodParameters: Array<String> = [""],
+    /**
+     * Define the method parameters pattern by a list of fully qualified types.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any
+     * parameters.
+     *
+     * <p>
+     * Mutually exclusive with the property `methodParameterTypePatterns` also defining parameters.
+     *
+     * @return The list of qualified type names of the method parameters.
+     */
+    val methodParameters: Array<String> = [""],
 
-  /**
-   * Define the method parameters pattern by a list of patterns on types.
-   *
-   * <p>
-   * Mutually exclusive with all field properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a method, the default matches any parameters.
-   *
-   * <p>
-   * Mutually exclusive with the property `methodParameters` also defining parameters.
-   *
-   * @return The list of type patterns for the method parameters.
-   */
-  val methodParameterTypePatterns: Array<TypePattern> = [TypePattern(name = "")],
+    /**
+     * Define the method parameters pattern by a list of patterns on types.
+     *
+     * <p>
+     * Mutually exclusive with all field properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a method, the default matches any
+     * parameters.
+     *
+     * <p>
+     * Mutually exclusive with the property `methodParameters` also defining parameters.
+     *
+     * @return The list of type patterns for the method parameters.
+     */
+    val methodParameterTypePatterns: Array<TypePattern> = [TypePattern(name = "")],
 
-  /**
-   * Define the field-annotated-by pattern by fully qualified class name.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-annotated-by:
-   * <ul>
-   * <li>fieldAnnotatedByClassConstant
-   * <li>fieldAnnotatedByClassNamePattern
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none are specified the default is to match any field regardless of what the field is
-   * annotated by.
-   *
-   * @return The qualified class name that defines the annotation.
-   */
-  val fieldAnnotatedByClassName: String = "",
+    /**
+     * Define the field-annotated-by pattern by fully qualified class name.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-annotated-by:
+     * <ul>
+     * <li>fieldAnnotatedByClassConstant
+     * <li>fieldAnnotatedByClassNamePattern
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none are specified the default is to match any field regardless of what the field is
+     * annotated by.
+     *
+     * @return The qualified class name that defines the annotation.
+     */
+    val fieldAnnotatedByClassName: String = "",
 
-  /**
-   * Define the field-annotated-by pattern by reference to a Class constant.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-annotated-by:
-   * <ul>
-   * <li>fieldAnnotatedByClassName
-   * <li>fieldAnnotatedByClassNamePattern
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none are specified the default is to match any field regardless of what the field is
-   * annotated by.
-   *
-   * @return The class-constant that defines the annotation.
-   */
-  val fieldAnnotatedByClassConstant: KClass<*> = Object::class,
+    /**
+     * Define the field-annotated-by pattern by reference to a Class constant.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-annotated-by:
+     * <ul>
+     * <li>fieldAnnotatedByClassName
+     * <li>fieldAnnotatedByClassNamePattern
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none are specified the default is to match any field regardless of what the field is
+     * annotated by.
+     *
+     * @return The class-constant that defines the annotation.
+     */
+    val fieldAnnotatedByClassConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the field-annotated-by pattern by reference to a class-name pattern.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-annotated-by:
-   * <ul>
-   * <li>fieldAnnotatedByClassName
-   * <li>fieldAnnotatedByClassConstant
-   * </ul>
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none are specified the default is to match any field regardless of what the field is
-   * annotated by.
-   *
-   * @return The class-name pattern that defines the annotation.
-   */
-  val fieldAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
+    /**
+     * Define the field-annotated-by pattern by reference to a class-name pattern.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-annotated-by:
+     * <ul>
+     * <li>fieldAnnotatedByClassName
+     * <li>fieldAnnotatedByClassConstant
+     * </ul>
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none are specified the default is to match any field regardless of what the field is
+     * annotated by.
+     *
+     * @return The class-name pattern that defines the annotation.
+     */
+    val fieldAnnotatedByClassNamePattern: ClassNamePattern = ClassNamePattern(unqualifiedName = ""),
 
-  /**
-   * Define the field-access pattern by matching on access flags.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any field-access
-   * flags.
-   *
-   * @return The field access-flag constraints that must be met.
-   */
-  val fieldAccess: Array<FieldAccessFlags> = [],
+    /**
+     * Define the field-access pattern by matching on access flags.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any
+     * field-access flags.
+     *
+     * @return The field access-flag constraints that must be met.
+     */
+    val fieldAccess: Array<FieldAccessFlags> = [],
 
-  /**
-   * Define the field-name pattern by an exact field name.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any field name.
-   *
-   * <p>
-   * Mutually exclusive with the property `fieldNamePattern` also defining field-name.
-   *
-   * @return The exact field name of the field.
-   */
-  val fieldName: String = "",
+    /**
+     * Define the field-name pattern by an exact field name.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any field
+     * name.
+     *
+     * <p>
+     * Mutually exclusive with the property `fieldNamePattern` also defining field-name.
+     *
+     * @return The exact field name of the field.
+     */
+    val fieldName: String = "",
 
-  /**
-   * Define the field-name pattern by a string pattern.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any field name.
-   *
-   * <p>
-   * Mutually exclusive with the property `fieldName` also defining field-name.
-   *
-   * @return The string pattern of the field name.
-   */
-  val fieldNamePattern: StringPattern = StringPattern(exact = ""),
+    /**
+     * Define the field-name pattern by a string pattern.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any field
+     * name.
+     *
+     * <p>
+     * Mutually exclusive with the property `fieldName` also defining field-name.
+     *
+     * @return The string pattern of the field name.
+     */
+    val fieldNamePattern: StringPattern = StringPattern(exact = ""),
 
-  /**
-   * Define the field-type pattern by a fully qualified type.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-type:
-   * <ul>
-   * <li>fieldTypeConstant
-   * <li>fieldTypePattern
-   * </ul>
-   *
-   * @return The qualified type name for the field type.
-   */
-  val fieldType: String = "",
+    /**
+     * Define the field-type pattern by a fully qualified type.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-type:
+     * <ul>
+     * <li>fieldTypeConstant
+     * <li>fieldTypePattern
+     * </ul>
+     *
+     * @return The qualified type name for the field type.
+     */
+    val fieldType: String = "",
 
-  /**
-   * Define the field-type pattern by a class constant.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-type:
-   * <ul>
-   * <li>fieldType
-   * <li>fieldTypePattern
-   * </ul>
-   *
-   * @return The class constant for the field type.
-   */
-  val fieldTypeConstant: KClass<*> = Object::class,
+    /**
+     * Define the field-type pattern by a class constant.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-type:
+     * <ul>
+     * <li>fieldType
+     * <li>fieldTypePattern
+     * </ul>
+     *
+     * @return The class constant for the field type.
+     */
+    val fieldTypeConstant: KClass<*> = Object::class,
 
-  /**
-   * Define the field-type pattern by a pattern on types.
-   *
-   * <p>
-   * Mutually exclusive with all method properties.
-   *
-   * <p>
-   * If none, and other properties define this item as a field, the default matches any type.
-   *
-   * <p>
-   * Mutually exclusive with the following other properties defining field-type:
-   * <ul>
-   * <li>fieldType
-   * <li>fieldTypeConstant
-   * </ul>
-   *
-   * @return The type pattern for the field type.
-   */
-  val fieldTypePattern: TypePattern = TypePattern(name = ""),
+    /**
+     * Define the field-type pattern by a pattern on types.
+     *
+     * <p>
+     * Mutually exclusive with all method properties.
+     *
+     * <p>
+     * If none, and other properties define this item as a field, the default matches any type.
+     *
+     * <p>
+     * Mutually exclusive with the following other properties defining field-type:
+     * <ul>
+     * <li>fieldType
+     * <li>fieldTypeConstant
+     * </ul>
+     *
+     * @return The type pattern for the field type.
+     */
+    val fieldTypePattern: TypePattern = TypePattern(name = ""),
 )

src/keepanno/java/androidx/annotation/keep/UsesReflection.kt

diff --git a/src/keepanno/java/androidx/annotation/keep/UsesReflection.kt b/src/keepanno/java/androidx/annotation/keep/UsesReflection.kt
index 021b186..102fe77 100644
--- a/src/keepanno/java/androidx/annotation/keep/UsesReflection.kt
+++ b/src/keepanno/java/androidx/annotation/keep/UsesReflection.kt
@@ -77,31 +77,31 @@
  */
 @Retention(AnnotationRetention.BINARY)
 @Target(
-  AnnotationTarget.CLASS,
-  AnnotationTarget.FIELD,
-  AnnotationTarget.FUNCTION,
-  AnnotationTarget.CONSTRUCTOR,
+    AnnotationTarget.CLASS,
+    AnnotationTarget.FIELD,
+    AnnotationTarget.FUNCTION,
+    AnnotationTarget.CONSTRUCTOR,
 )
 public annotation class UsesReflection(
 
-  /**
-   * Optional description to document the reason for this annotation.
-   *
-   * @return The descriptive message. Defaults to no description.
-   */
-  val description: String = "",
+    /**
+     * Optional description to document the reason for this annotation.
+     *
+     * @return The descriptive message. Defaults to no description.
+     */
+    val description: String = "",
 
-  /**
-   * Consequences that must be kept if the annotation is in effect.
-   *
-   * @return The list of target consequences.
-   */
-  val value: Array<KeepTarget>,
+    /**
+     * Consequences that must be kept if the annotation is in effect.
+     *
+     * @return The list of target consequences.
+     */
+    val value: Array<KeepTarget>,
 
-  /**
-   * Additional preconditions for the annotation to be in effect.
-   *
-   * @return The list of additional preconditions. Defaults to no additional preconditions.
-   */
-  val additionalPreconditions: Array<KeepCondition> = [],
+    /**
+     * Additional preconditions for the annotation to be in effect.
+     *
+     * @return The list of additional preconditions. Defaults to no additional preconditions.
+     */
+    val additionalPreconditions: Array<KeepCondition> = [],
 )

src/test/java/com/android/tools/r8/cfmethodgeneration/CodeGenerationBase.java

diff --git a/src/test/java/com/android/tools/r8/cfmethodgeneration/CodeGenerationBase.java b/src/test/java/com/android/tools/r8/cfmethodgeneration/CodeGenerationBase.java
index 0bf9bd4..ddaa213 100644
--- a/src/test/java/com/android/tools/r8/cfmethodgeneration/CodeGenerationBase.java
+++ b/src/test/java/com/android/tools/r8/cfmethodgeneration/CodeGenerationBase.java
@@ -29,12 +29,17 @@
   private static final Path GOOGLE_JAVA_FORMAT_JAR =
       GOOGLE_JAVA_FORMAT_DIR.resolve("google-java-format-1.24.0-all-deps.jar");
 
+  private enum KOTLIN_FORMAT_STYLE {
+    GOOGLE,
+    KOTLINLANG
+  }
+
   protected final DexItemFactory factory = new DexItemFactory();
 
   public static String kotlinFormatRawOutput(String rawOutput) throws IOException {
     Path temporaryFile = File.createTempFile("output-", ".kt").toPath();
     Files.write(temporaryFile, rawOutput.getBytes());
-    kotlinFormatRawOutput(temporaryFile);
+    kotlinFormatRawOutput(temporaryFile, KOTLIN_FORMAT_STYLE.KOTLINLANG);
     String result = FileUtils.readTextFile(temporaryFile);
     temporaryFile.toFile().deleteOnExit();
     return result;
@@ -48,30 +53,24 @@
     return result;
   }
 
-  public static String kotlinFormatRawOutput(Path tempFile) throws IOException {
-    // Apply google format.
+  public static void kotlinFormatRawOutput(Path tempFile, KOTLIN_FORMAT_STYLE formatStyle)
+      throws IOException {
     ProcessBuilder builder =
         new ProcessBuilder(
             ImmutableList.of(
                 getJavaExecutable(),
                 "-jar",
                 GOOGLE_KOTLIN_FORMAT_JAR.toString(),
-                "--google-style",
+                formatStyle == KOTLIN_FORMAT_STYLE.GOOGLE ? "--google-style" : "--kotlinlang-style",
                 tempFile.toAbsolutePath().toString()));
     String commandString = String.join(" ", builder.command());
     System.out.println(commandString);
     Process process = builder.start();
     ProcessResult result = ToolHelper.drainProcessOutputStreams(process, commandString);
-    // Kotlin formatter will write "Done formatting..." to stderr.
+    // Kotlin formatter formats file directly and writes "Done formatting..." to stderr.
     if (result.exitCode != 0) {
       throw new IllegalStateException(result.toString());
     }
-    // Fix line separators.
-    String content = result.stdout;
-    if (!StringUtils.LINE_SEPARATOR.equals("\n")) {
-      return content.replace(StringUtils.LINE_SEPARATOR, "\n");
-    }
-    return content;
   }
 
   public static String javaFormatRawOutput(Path tempFile) throws IOException {

tools/update-androidx-keep-annotations.py

diff --git a/tools/update-androidx-keep-annotations.py b/tools/update-androidx-keep-annotations.py
index 91fffa0..29bf464 100755
--- a/tools/update-androidx-keep-annotations.py
+++ b/tools/update-androidx-keep-annotations.py
@@ -11,9 +11,6 @@
 
 
 KOTLIN_EXTENSION = '.kt'
-# Extension used by androidx KMP libraries for Kotlin files with code
-# targeting the JVM.
-JVM_KOTLIN_EXTENSION = '.jvm.kt'
 
 
 def parse_options():
@@ -43,7 +40,7 @@
         'annotation',
         'annotation-keep',
         'src',
-        'jvmMain',
+        'commonMain',
         'kotlin',
         'androidx',
         'annotation',
@@ -61,11 +58,10 @@
                 print('Unexpected non Kotlin file {filename}.'
                     .format(filename=os.path.join(root, filename)))
                 sys.exit(1)
-            new_filename = filename[0:len(filename) - len(KOTLIN_EXTENSION)] + JVM_KOTLIN_EXTENSION
 
             shutil.copyfile(
                 os.path.join(root, filename),
-                os.path.join(dest_dir, new_filename))
+                os.path.join(dest_dir, filename))
 
 
 if __name__ == '__main__':