[Git][java-team/google-flogger][master] Initial packaging
Olek Wojnar
gitlab at salsa.debian.org
Wed Jul 15 23:19:34 BST 2020
Olek Wojnar pushed to branch master at Debian Java Maintainers / google-flogger
Commits:
8044d835 by Olek Wojnar at 2020-07-15T15:42:07-04:00
Initial packaging
- - - - -
14 changed files:
- + debian/changelog
- + debian/control
- + debian/copyright
- + debian/libgoogle-flogger-java.lintian-overrides
- + debian/libgoogle-flogger-java.poms
- + debian/maven.properties
- + debian/patches/backend-build.patch
- + debian/patches/maven-build.patch
- + debian/patches/replace-nullable.patch
- + debian/patches/series
- + debian/rules
- + debian/source/format
- + debian/upstream/metadata
- + debian/watch
Changes:
=====================================
debian/changelog
=====================================
@@ -0,0 +1,6 @@
+google-flogger (0.5.1-1) unstable; urgency=medium
+
+ * Initial release (Closes: #959836)
+ * Implement Maven build to avoid circular dependency with Bazel
+
+ -- Olek Wojnar <olek at debian.org> Mon, 22 Jun 2020 18:06:38 -0400
=====================================
debian/control
=====================================
@@ -0,0 +1,28 @@
+Source: google-flogger
+Section: java
+Priority: optional
+Maintainer: Debian Java Maintainers <pkg-java-maintainers at lists.alioth.debian.org>
+Uploaders: Olek Wojnar <olek at debian.org>,
+ Andreas Tille <tille at debian.org>,
+Build-Depends: debhelper-compat (= 13),
+ default-jdk,
+ libasm-java,
+ libchecker-framework-java,
+ liberror-prone-java,
+ libmaven-install-plugin-java,
+ maven-debian-helper,
+ unzip,
+Standards-Version: 4.5.0
+Rules-Requires-Root: no
+Homepage: https://github.com/google/flogger
+Vcs-Browser: https://salsa.debian.org/java-team/google-flogger
+Vcs-Git: https://salsa.debian.org/java-team/google-flogger.git
+
+Package: libgoogle-flogger-java
+Architecture: all
+Multi-Arch: foreign
+Depends: ${misc:Depends}, ${maven:Depends}
+Suggests: ${maven:OptionalDepends}
+Description: Fluent Logging API for Java
+ Many benefits over existing logging APIs including more self-documenting log
+ statements and additional features that help you manage your logging better.
=====================================
debian/copyright
=====================================
@@ -0,0 +1,27 @@
+Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-Name: flogger
+Source: https://github.com/google/flogger
+
+Files: *
+Copyright: 2018-2020 Google Inc.
+License: Apache-2.0
+
+Files: debian/*
+Copyright: 2020 Olek Wojnar <olek at debian.org>
+License: Apache-2.0
+
+License: Apache-2.0
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+ .
+ https://www.apache.org/licenses/LICENSE-2.0
+ .
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ .
+ On Debian systems, the complete text of the Apache version 2.0 license
+ can be found in "/usr/share/common-licenses/Apache-2.0".
=====================================
debian/libgoogle-flogger-java.lintian-overrides
=====================================
@@ -0,0 +1,2 @@
+# Path is correct
+libgoogle-flogger-java: repeated-path-segment
=====================================
debian/libgoogle-flogger-java.poms
=====================================
@@ -0,0 +1,4 @@
+pom.xml --java-lib --no-parent
+api/pom.xml --java-lib
+api/pom-backend.xml --java-lib
+google/pom.xml --java-lib
=====================================
debian/maven.properties
=====================================
@@ -0,0 +1,5 @@
+project.build.sourceEncoding=UTF-8
+maven.test.skip=true
+maven.compiler.verbose=true
+org.slf4j.simpleLogger.defaultLogLevel=debug
+trimStackTrace=false
=====================================
debian/patches/backend-build.patch
=====================================
@@ -0,0 +1,14 @@
+Description: Correctly find PlatformProvider.class
+Author: Olek Wojnar <olek at debian.org>
+Last-Update: 2020-06-29
+
+--- a/api/src/main/java/com/google/common/flogger/backend/Platform.java
++++ b/api/src/main/java/com/google/common/flogger/backend/Platform.java
+@@ -22,6 +22,7 @@
+ import com.google.common.flogger.LogSite;
+ import java.lang.reflect.InvocationTargetException;
+ import java.util.logging.Level;
++import com.google.common.flogger.backend.PlatformProvider;
+
+ /**
+ * Platform abstraction layer required to allow fluent logger implementations to work on differing
=====================================
debian/patches/maven-build.patch
=====================================
@@ -0,0 +1,377 @@
+Description: Build using Maven
+ Temporarily build using Maven to avoid a circular dependency with Bazel
+Author: Yun Peng <pcloudy at google.com>
+Author: Olek Wojnar <olek at debian.org>
+Last-Update: 2020-06-22
+
+--- /dev/null
++++ b/pom.xml
+@@ -0,0 +1,87 @@
++<?xml version="1.0" encoding="UTF-8"?>
++<!--
++ Copyright (C) 2018 The Flogger Authors.
++
++ Licensed under the Apache License, Version 2.0 (the "License");
++ you may not use this file except in compliance with the License.
++ You may obtain a copy of the License at
++
++ http://www.apache.org/licenses/LICENSE-2.0
++
++ Unless required by applicable law or agreed to in writing, software
++ distributed under the License is distributed on an "AS IS" BASIS,
++ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ See the License for the specific language governing permissions and
++ limitations under the License.
++-->
++<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
++ <modelVersion>4.0.0</modelVersion>
++
++ <groupId>com.google.flogger</groupId>
++ <artifactId>flogger-parent</artifactId>
++ <properties>
++ <skipTests>true</skipTests>
++ </properties>
++ <name>Flogger Parent</name>
++ <version>0.5.1</version>
++ <description>A Fluent Logging API for Java</description>
++ <url>https://github.com/google/flogger</url>
++ <packaging>pom</packaging>
++
++ <modules>
++ <module>api</module>
++ <module>api/pom-backend.xml</module>
++ <module>google</module>
++ </modules>
++
++ <scm>
++ <url>https://github.com/google/flogger/</url>
++ <connection>scm:git:git://github.com/google/flogger.git</connection>
++ <developerConnection>scm:git:ssh://git@github.com/google/flogger.git</developerConnection>
++ <tag>HEAD</tag>
++ </scm>
++
++ <issueManagement>
++ <system>GitHub Issues</system>
++ <url>https://github.com/google/flogger/issues</url>
++ </issueManagement>
++
++ <licenses>
++ <license>
++ <name>Apache 2.0</name>
++ <url>https://www.apache.org/licenses/LICENSE-2.0.txt</url>
++ </license>
++ </licenses>
++
++ <organization>
++ <name>Google, Inc.</name>
++ <url>https://www.google.com</url>
++ </organization>
++
++ <dependencyManagement>
++ <dependencies>
++ <dependency>
++ <groupId>org.checkerframework</groupId>
++ <artifactId>checker-qual</artifactId>
++ <version>debian</version>
++ </dependency>
++ <dependency>
++ <groupId>com.google.errorprone</groupId>
++ <artifactId>error_prone_annotations</artifactId>
++ <version>debian</version>
++ </dependency>
++ <dependency>
++ <groupId>com.google.flogger</groupId>
++ <artifactId>platform-provider</artifactId>
++ <version>0.5.1</version>
++ <scope>provided</scope>
++ </dependency>
++ <dependency>
++ <groupId>com.google.flogger</groupId>
++ <artifactId>flogger</artifactId>
++ <version>0.5.1</version>
++ <scope>provided</scope>
++ </dependency>
++ </dependencies>
++ </dependencyManagement>
++</project>
+--- /dev/null
++++ b/api/pom.xml
+@@ -0,0 +1,104 @@
++<?xml version="1.0" encoding="UTF-8"?>
++<!--
++ Copyright (C) 2018 The Flogger Authors.
++
++ Licensed under the Apache License, Version 2.0 (the "License");
++ you may not use this file except in compliance with the License.
++ You may obtain a copy of the License at
++
++ http://www.apache.org/licenses/LICENSE-2.0
++
++ Unless required by applicable law or agreed to in writing, software
++ distributed under the License is distributed on an "AS IS" BASIS,
++ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ See the License for the specific language governing permissions and
++ limitations under the License.
++-->
++<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
++ <modelVersion>4.0.0</modelVersion>
++
++ <parent>
++ <groupId>com.google.flogger</groupId>
++ <artifactId>flogger-parent</artifactId>
++ <version>0.5.1</version>
++ </parent>
++
++ <groupId>com.google.flogger</groupId>
++ <artifactId>flogger</artifactId>
++ <properties>
++ <skipTests>true</skipTests>
++ </properties>
++ <name>Flogger</name>
++ <description>A Fluent Logging API for Java</description>
++ <url>https://github.com/google/flogger</url>
++
++<build>
++<plugins>
++<plugin>
++ <groupId>org.apache.maven.plugins</groupId>
++ <artifactId>maven-compiler-plugin</artifactId>
++ <version>3.1</version>
++ <configuration>
++ <source>1.8</source>
++ <target>1.8</target>
++ <excludes>
++<!-- <exclude>com/google/common/flogger/util/Checks.java</exclude>
++ <exclude>com/google/common/flogger/util/StaticMethodCaller.java</exclude>
++ <exclude>com/google/common/flogger/backend/KeyValueFormatter.java</exclude>
++ <exclude>com/google/common/flogger/backend/KeyValueHandler.java</exclude>
++ <exclude>com/google/common/flogger/backend/Tags.java</exclude>
++ <exclude>com/google/common/flogger/context/*.java</exclude>
++ <exclude>com/google/common/flogger/LazyArg.java</exclude>
++ <exclude>com/google/common/flogger/LazyArgs.java</exclude>
++ <exclude>com/google/common/flogger/LogSiteStackTrace.java</exclude>
++ <exclude>com/google/common/flogger/StackSize.java</exclude>
++ <exclude>com/google/common/flogger/LoggerConfig.java</exclude>
++ <exclude>com/google/common/flogger/LogSite.java</exclude>
++ <exclude>com/google/common/flogger/LogSiteKey.java</exclude>
++ <exclude>com/google/common/flogger/LogSites.java</exclude> -->
++ <exclude>com/google/common/flogger/backend/system/**/*.java</exclude>
++ </excludes>
++ </configuration>
++</plugin>
++</plugins>
++</build>
++
++ <scm>
++ <url>https://github.com/google/flogger/</url>
++ <connection>scm:git:git://github.com/google/flogger.git</connection>
++ <developerConnection>scm:git:ssh://git@github.com/google/flogger.git</developerConnection>
++ <tag>HEAD</tag>
++ </scm>
++
++ <issueManagement>
++ <system>GitHub Issues</system>
++ <url>https://github.com/google/flogger/issues</url>
++ </issueManagement>
++
++ <licenses>
++ <license>
++ <name>Apache 2.0</name>
++ <url>https://www.apache.org/licenses/LICENSE-2.0.txt</url>
++ </license>
++ </licenses>
++
++ <organization>
++ <name>Google, Inc.</name>
++ <url>https://www.google.com</url>
++ </organization>
++
++ <dependencies>
++<dependency>
++ <groupId>org.checkerframework</groupId>
++ <artifactId>checker-qual</artifactId>
++</dependency>
++<dependency>
++ <groupId>com.google.errorprone</groupId>
++ <artifactId>error_prone_annotations</artifactId>
++</dependency>
++<dependency>
++ <groupId>com.google.flogger</groupId>
++ <artifactId>platform-provider</artifactId>
++</dependency>
++ </dependencies>
++</project>
+--- /dev/null
++++ b/api/pom-backend.xml
+@@ -0,0 +1,84 @@
++<?xml version="1.0" encoding="UTF-8"?>
++<!--
++ Copyright (C) 2018 The Flogger Authors.
++
++ Licensed under the Apache License, Version 2.0 (the "License");
++ you may not use this file except in compliance with the License.
++ You may obtain a copy of the License at
++
++ http://www.apache.org/licenses/LICENSE-2.0
++
++ Unless required by applicable law or agreed to in writing, software
++ distributed under the License is distributed on an "AS IS" BASIS,
++ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ See the License for the specific language governing permissions and
++ limitations under the License.
++-->
++<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
++ <modelVersion>4.0.0</modelVersion>
++
++ <parent>
++ <groupId>com.google.flogger</groupId>
++ <artifactId>flogger-parent</artifactId>
++ <version>0.5.1</version>
++ </parent>
++
++ <groupId>com.google.flogger</groupId>
++ <artifactId>flogger-system-backend</artifactId>
++ <name>Flogger System Backend</name>
++ <description>A Fluent Logging API for Java</description>
++ <url>https://github.com/google/flogger</url>
++
++ <build>
++ <plugins>
++ <plugin>
++ <groupId>org.apache.maven.plugins</groupId>
++ <artifactId>maven-compiler-plugin</artifactId>
++ <version>3.1</version>
++ <configuration>
++ <source>1.8</source>
++ <target>1.8</target>
++ <includes>
++ <include>com/google/common/flogger/backend/system/**/*.java</include>
++ </includes>
++ </configuration>
++ </plugin>
++ </plugins>
++ </build>
++
++ <scm>
++ <url>https://github.com/google/flogger/</url>
++ <connection>scm:git:git://github.com/google/flogger.git</connection>
++ <developerConnection>scm:git:ssh://git@github.com/google/flogger.git</developerConnection>
++ <tag>HEAD</tag>
++ </scm>
++
++ <issueManagement>
++ <system>GitHub Issues</system>
++ <url>https://github.com/google/flogger/issues</url>
++ </issueManagement>
++
++ <licenses>
++ <license>
++ <name>Apache 2.0</name>
++ <url>https://www.apache.org/licenses/LICENSE-2.0.txt</url>
++ </license>
++ </licenses>
++
++ <organization>
++ <name>Google, Inc.</name>
++ <url>https://www.google.com</url>
++ </organization>
++
++ <dependencies>
++<dependency>
++ <groupId>com.google.flogger</groupId>
++ <artifactId>flogger</artifactId>
++ <scope>provided</scope>
++</dependency>
++<dependency>
++ <groupId>org.checkerframework</groupId>
++ <artifactId>checker-qual</artifactId>
++</dependency>
++ </dependencies>
++</project>
+--- /dev/null
++++ b/google/pom.xml
+@@ -0,0 +1,84 @@
++<?xml version="1.0" encoding="UTF-8"?>
++<!--
++ Copyright (C) 2018 The Flogger Authors.
++
++ Licensed under the Apache License, Version 2.0 (the "License");
++ you may not use this file except in compliance with the License.
++ You may obtain a copy of the License at
++
++ http://www.apache.org/licenses/LICENSE-2.0
++
++ Unless required by applicable law or agreed to in writing, software
++ distributed under the License is distributed on an "AS IS" BASIS,
++ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ See the License for the specific language governing permissions and
++ limitations under the License.
++-->
++<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
++ <modelVersion>4.0.0</modelVersion>
++
++ <parent>
++ <groupId>com.google.flogger</groupId>
++ <artifactId>flogger-parent</artifactId>
++ <version>0.5.1</version>
++ </parent>
++
++ <groupId>com.google.flogger</groupId>
++ <artifactId>google-extensions</artifactId>
++ <name>Google Logger</name>
++ <description>A Fluent Logging API for Java</description>
++ <url>https://github.com/google/flogger</url>
++
++ <build>
++ <plugins>
++ <plugin>
++ <groupId>org.apache.maven.plugins</groupId>
++ <artifactId>maven-compiler-plugin</artifactId>
++ <version>3.1</version>
++ <configuration>
++ <source>1.8</source>
++ <target>1.8</target>
++ <includes>
++ <include>com/google/common/flogger/*.java</include>
++ </includes>
++ </configuration>
++ </plugin>
++ </plugins>
++ </build>
++
++ <scm>
++ <url>https://github.com/google/flogger/</url>
++ <connection>scm:git:git://github.com/google/flogger.git</connection>
++ <developerConnection>scm:git:ssh://git@github.com/google/flogger.git</developerConnection>
++ <tag>HEAD</tag>
++ </scm>
++
++ <issueManagement>
++ <system>GitHub Issues</system>
++ <url>https://github.com/google/flogger/issues</url>
++ </issueManagement>
++
++ <licenses>
++ <license>
++ <name>Apache 2.0</name>
++ <url>https://www.apache.org/licenses/LICENSE-2.0.txt</url>
++ </license>
++ </licenses>
++
++ <organization>
++ <name>Google, Inc.</name>
++ <url>https://www.google.com</url>
++ </organization>
++
++ <dependencies>
++<dependency>
++ <groupId>com.google.flogger</groupId>
++ <artifactId>flogger</artifactId>
++ <scope>provided</scope>
++</dependency>
++<dependency>
++ <groupId>com.google.errorprone</groupId>
++ <artifactId>error_prone_annotations</artifactId>
++</dependency>
++ </dependencies>
++</project>
=====================================
debian/patches/replace-nullable.patch
=====================================
@@ -0,0 +1,1272 @@
+Description: Replace obsolete @NullableDecl
+ org.checkerframework.checker.nullness.compatqual.NullableDecl replaced with:
+ org.checkerframework.checker.nullness.qual.Nullable thanks to the power of sed
+Author: Olek Wojnar <olek at debian.org>
+Last-Update: 2020-05-29
+
+--- a/api/src/main/java/com/google/common/flogger/LazyArg.java
++++ b/api/src/main/java/com/google/common/flogger/LazyArg.java
+@@ -16,7 +16,7 @@
+
+ package com.google.common.flogger;
+
+-import org.checkerframework.checker.nullness.compatqual.NullableDecl;
++import org.checkerframework.checker.nullness.qual.Nullable;
+
+ /**
+ * Functional interface for allowing lazily evaluated arguments to be supplied to Flogger. This
+@@ -33,6 +33,6 @@
+ * determined that logging will occur, and the returned value is used in place of the {@code
+ * LazyArg} instance that was passed into the log statement.
+ */
+- @NullableDecl
++ @Nullable
+ T evaluate();
+ }
+--- a/api/src/main/java/com/google/common/flogger/LogContext.java
++++ b/api/src/main/java/com/google/common/flogger/LogContext.java
+@@ -31,7 +31,7 @@
+ import java.util.Arrays;
+ import java.util.concurrent.TimeUnit;
+ import java.util.logging.Level;
+-import org.checkerframework.checker.nullness.compatqual.NullableDecl;
++import org.checkerframework.checker.nullness.qual.Nullable;
+
+ /**
+ * The base context for a logging statement, which implements the base logging API.
+@@ -186,7 +186,7 @@
+ }
+
+ @Override
+- @NullableDecl
++ @Nullable
+ public <T> T findValue(MetadataKey<T> key) {
+ int index = indexOf(key);
+ return index != -1 ? key.cast(keyValuePairs[(2 * index) + 1]) : null;
+@@ -452,7 +452,7 @@
+ * <p>Implementations of this method must always call {@code super.postProcess()} first with the
+ * given log site key, such as:
+ *
+- * <pre>{@code protected boolean postProcess(@NullableDecl LogSiteKey logSiteKey) {
++ * <pre>{@code protected boolean postProcess(@Nullable LogSiteKey logSiteKey) {
+ * if (!super.postProcess(logSiteKey)) {
+ * return false;
+ * }
+@@ -472,7 +472,7 @@
+ * @param logSiteKey used to lookup persistent, per log statement, state.
+ * @return true if the logging backend should be invoked to output the current log statement.
+ */
+- protected boolean postProcess(@NullableDecl LogSiteKey logSiteKey) {
++ protected boolean postProcess(@Nullable LogSiteKey logSiteKey) {
+ if (metadata != null && logSiteKey != null) {
+ // This code still gets reached if a "cause" was set, but as that's far more likely than any
+ // other metadata that might suppress logging, it's not worth any more "early out" checks.
+@@ -586,7 +586,7 @@
+ String internalClassName,
+ String methodName,
+ int encodedLineNumber,
+- @NullableDecl String sourceFileName) {
++ @Nullable String sourceFileName) {
+ return withInjectedLogSite(
+ LogSite.injectedLogSite(internalClassName, methodName, encodedLineNumber, sourceFileName));
+ }
+@@ -603,7 +603,7 @@
+ }
+
+ @Override
+- public final <T> API with(MetadataKey<T> key, @NullableDecl T value) {
++ public final <T> API with(MetadataKey<T> key, @Nullable T value) {
+ // Null keys are always bad (even if the value is also null). This is one of the few places
+ // where the logger API will throw a runtime exception (and as such it's important to ensure
+ // the NoOp implementation also does the check). The reasoning for this is that the metadata
+@@ -682,125 +682,125 @@
+ }
+
+ @Override
+- public final void log(String message, @NullableDecl Object p1) {
++ public final void log(String message, @Nullable Object p1) {
+ if (shouldLog()) logImpl(message, p1);
+ }
+
+ @Override
+- public final void log(String message, @NullableDecl Object p1, @NullableDecl Object p2) {
++ public final void log(String message, @Nullable Object p1, @Nullable Object p2) {
+ if (shouldLog()) logImpl(message, p1, p2);
+ }
+
+ @Override
+ public final void log(
+- String message, @NullableDecl Object p1, @NullableDecl Object p2, @NullableDecl Object p3) {
++ String message, @Nullable Object p1, @Nullable Object p2, @Nullable Object p3) {
+ if (shouldLog()) logImpl(message, p1, p2, p3);
+ }
+
+ @Override
+ public final void log(
+ String message,
+- @NullableDecl Object p1,
+- @NullableDecl Object p2,
+- @NullableDecl Object p3,
+- @NullableDecl Object p4) {
++ @Nullable Object p1,
++ @Nullable Object p2,
++ @Nullable Object p3,
++ @Nullable Object p4) {
+ if (shouldLog()) logImpl(message, p1, p2, p3, p4);
+ }
+
+ @Override
+ public final void log(
+ String msg,
+- @NullableDecl Object p1,
+- @NullableDecl Object p2,
+- @NullableDecl Object p3,
+- @NullableDecl Object p4,
+- @NullableDecl Object p5) {
++ @Nullable Object p1,
++ @Nullable Object p2,
++ @Nullable Object p3,
++ @Nullable Object p4,
++ @Nullable Object p5) {
+ if (shouldLog()) logImpl(msg, p1, p2, p3, p4, p5);
+ }
+
+ @Override
+ public final void log(
+ String msg,
+- @NullableDecl Object p1,
+- @NullableDecl Object p2,
+- @NullableDecl Object p3,
+- @NullableDecl Object p4,
+- @NullableDecl Object p5,
+- @NullableDecl Object p6) {
++ @Nullable Object p1,
++ @Nullable Object p2,
++ @Nullable Object p3,
++ @Nullable Object p4,
++ @Nullable Object p5,
++ @Nullable Object p6) {
+ if (shouldLog()) logImpl(msg, p1, p2, p3, p4, p5, p6);
+ }
+
+ @Override
+ public final void log(
+ String msg,
+- @NullableDecl Object p1,
+- @NullableDecl Object p2,
+- @NullableDecl Object p3,
+- @NullableDecl Object p4,
+- @NullableDecl Object p5,
+- @NullableDecl Object p6,
+- @NullableDecl Object p7) {
++ @Nullable Object p1,
++ @Nullable Object p2,
++ @Nullable Object p3,
++ @Nullable Object p4,
++ @Nullable Object p5,
++ @Nullable Object p6,
++ @Nullable Object p7) {
+ if (shouldLog()) logImpl(msg, p1, p2, p3, p4, p5, p6, p7);
+ }
+
+ @Override
+ public final void log(
+ String msg,
+- @NullableDecl Object p1,
+- @NullableDecl Object p2,
+- @NullableDecl Object p3,
+- @NullableDecl Object p4,
+- @NullableDecl Object p5,
+- @NullableDecl Object p6,
+- @NullableDecl Object p7,
+- @NullableDecl Object p8) {
++ @Nullable Object p1,
++ @Nullable Object p2,
++ @Nullable Object p3,
++ @Nullable Object p4,
++ @Nullable Object p5,
++ @Nullable Object p6,
++ @Nullable Object p7,
++ @Nullable Object p8) {
+ if (shouldLog()) logImpl(msg, p1, p2, p3, p4, p5, p6, p7, p8);
+ }
+
+ @Override
+ public final void log(
+ String msg,
+- @NullableDecl Object p1,
+- @NullableDecl Object p2,
+- @NullableDecl Object p3,
+- @NullableDecl Object p4,
+- @NullableDecl Object p5,
+- @NullableDecl Object p6,
+- @NullableDecl Object p7,
+- @NullableDecl Object p8,
+- @NullableDecl Object p9) {
++ @Nullable Object p1,
++ @Nullable Object p2,
++ @Nullable Object p3,
++ @Nullable Object p4,
++ @Nullable Object p5,
++ @Nullable Object p6,
++ @Nullable Object p7,
++ @Nullable Object p8,
++ @Nullable Object p9) {
+ if (shouldLog()) logImpl(msg, p1, p2, p3, p4, p5, p6, p7, p8, p9);
+ }
+
+ @Override
+ public final void log(
+ String msg,
+- @NullableDecl Object p1,
+- @NullableDecl Object p2,
+- @NullableDecl Object p3,
+- @NullableDecl Object p4,
+- @NullableDecl Object p5,
+- @NullableDecl Object p6,
+- @NullableDecl Object p7,
+- @NullableDecl Object p8,
+- @NullableDecl Object p9,
+- @NullableDecl Object p10) {
++ @Nullable Object p1,
++ @Nullable Object p2,
++ @Nullable Object p3,
++ @Nullable Object p4,
++ @Nullable Object p5,
++ @Nullable Object p6,
++ @Nullable Object p7,
++ @Nullable Object p8,
++ @Nullable Object p9,
++ @Nullable Object p10) {
+ if (shouldLog()) logImpl(msg, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
+ }
+
+ @Override
+ public final void log(
+ String msg,
+- @NullableDecl Object p1,
+- @NullableDecl Object p2,
+- @NullableDecl Object p3,
+- @NullableDecl Object p4,
+- @NullableDecl Object p5,
+- @NullableDecl Object p6,
+- @NullableDecl Object p7,
+- @NullableDecl Object p8,
+- @NullableDecl Object p9,
+- @NullableDecl Object p10,
++ @Nullable Object p1,
++ @Nullable Object p2,
++ @Nullable Object p3,
++ @Nullable Object p4,
++ @Nullable Object p5,
++ @Nullable Object p6,
++ @Nullable Object p7,
++ @Nullable Object p8,
++ @Nullable Object p9,
++ @Nullable Object p10,
+ Object... rest) {
+ if (shouldLog()) {
+ // Manually create a new varargs array and copy the parameters in.
+@@ -846,82 +846,82 @@
+ }
+
+ @Override
+- public final void log(String message, @NullableDecl Object p1, boolean p2) {
++ public final void log(String message, @Nullable Object p1, boolean p2) {
+ if (shouldLog()) logImpl(message, p1, p2);
+ }
+
+ @Override
+- public final void log(String message, @NullableDecl Object p1, char p2) {
++ public final void log(String message, @Nullable Object p1, char p2) {
+ if (shouldLog()) logImpl(message, p1, p2);
+ }
+
+ @Override
+- public final void log(String message, @NullableDecl Object p1, byte p2) {
++ public final void log(String message, @Nullable Object p1, byte p2) {
+ if (shouldLog()) logImpl(message, p1, p2);
+ }
+
+ @Override
+- public final void log(String message, @NullableDecl Object p1, short p2) {
++ public final void log(String message, @Nullable Object p1, short p2) {
+ if (shouldLog()) logImpl(message, p1, p2);
+ }
+
+ @Override
+- public final void log(String message, @NullableDecl Object p1, int p2) {
++ public final void log(String message, @Nullable Object p1, int p2) {
+ if (shouldLog()) logImpl(message, p1, p2);
+ }
+
+ @Override
+- public final void log(String message, @NullableDecl Object p1, long p2) {
++ public final void log(String message, @Nullable Object p1, long p2) {
+ if (shouldLog()) logImpl(message, p1, p2);
+ }
+
+ @Override
+- public final void log(String message, @NullableDecl Object p1, float p2) {
++ public final void log(String message, @Nullable Object p1, float p2) {
+ if (shouldLog()) logImpl(message, p1, p2);
+ }
+
+ @Override
+- public final void log(String message, @NullableDecl Object p1, double p2) {
++ public final void log(String message, @Nullable Object p1, double p2) {
+ if (shouldLog()) logImpl(message, p1, p2);
+ }
+
+ @Override
+- public final void log(String message, boolean p1, @NullableDecl Object p2) {
++ public final void log(String message, boolean p1, @Nullable Object p2) {
+ if (shouldLog()) logImpl(message, p1, p2);
+ }
+
+ @Override
+- public final void log(String message, char p1, @NullableDecl Object p2) {
++ public final void log(String message, char p1, @Nullable Object p2) {
+ if (shouldLog()) logImpl(message, p1, p2);
+ }
+
+ @Override
+- public final void log(String message, byte p1, @NullableDecl Object p2) {
++ public final void log(String message, byte p1, @Nullable Object p2) {
+ if (shouldLog()) logImpl(message, p1, p2);
+ }
+
+ @Override
+- public final void log(String message, short p1, @NullableDecl Object p2) {
++ public final void log(String message, short p1, @Nullable Object p2) {
+ if (shouldLog()) logImpl(message, p1, p2);
+ }
+
+ @Override
+- public final void log(String message, int p1, @NullableDecl Object p2) {
++ public final void log(String message, int p1, @Nullable Object p2) {
+ if (shouldLog()) logImpl(message, p1, p2);
+ }
+
+ @Override
+- public final void log(String message, long p1, @NullableDecl Object p2) {
++ public final void log(String message, long p1, @Nullable Object p2) {
+ if (shouldLog()) logImpl(message, p1, p2);
+ }
+
+ @Override
+- public final void log(String message, float p1, @NullableDecl Object p2) {
++ public final void log(String message, float p1, @Nullable Object p2) {
+ if (shouldLog()) logImpl(message, p1, p2);
+ }
+
+ @Override
+- public final void log(String message, double p1, @NullableDecl Object p2) {
++ public final void log(String message, double p1, @Nullable Object p2) {
+ if (shouldLog()) logImpl(message, p1, p2);
+ }
+
+@@ -1246,7 +1246,7 @@
+ }
+
+ @Override
+- public final void logVarargs(String message, @NullableDecl Object[] params) {
++ public final void logVarargs(String message, @Nullable Object[] params) {
+ if (shouldLog()) {
+ // Copy the varargs array (because we didn't create it and this is quite a rare case).
+ logImpl(message, Arrays.copyOf(params, params.length));
+--- a/api/src/main/java/com/google/common/flogger/LogSite.java
++++ b/api/src/main/java/com/google/common/flogger/LogSite.java
+@@ -19,7 +19,7 @@
+ import static com.google.common.flogger.util.Checks.checkNotNull;
+
+ import com.google.errorprone.annotations.CheckReturnValue;
+-import org.checkerframework.checker.nullness.compatqual.NullableDecl;
++import org.checkerframework.checker.nullness.qual.Nullable;
+
+ /**
+ * A value type which representing the location of a single log statement. This class is similar to
+@@ -144,7 +144,7 @@
+ String internalClassName,
+ String methodName,
+ int encodedLineNumber,
+- @NullableDecl String sourceFileName) {
++ @Nullable String sourceFileName) {
+ return new InjectedLogSite(internalClassName, methodName, encodedLineNumber, sourceFileName);
+ }
+
+--- a/api/src/main/java/com/google/common/flogger/LogSiteStackTrace.java
++++ b/api/src/main/java/com/google/common/flogger/LogSiteStackTrace.java
+@@ -16,7 +16,7 @@
+
+ package com.google.common.flogger;
+
+-import org.checkerframework.checker.nullness.compatqual.NullableDecl;
++import org.checkerframework.checker.nullness.qual.Nullable;
+
+ /**
+ * A synthetic exception which can be attached to log statements when additional stack trace
+@@ -36,7 +36,7 @@
+ * @param syntheticStackTrace the synthetic stack trace starting at the log statement.
+ */
+ LogSiteStackTrace(
+- @NullableDecl Throwable cause, StackSize stackSize, StackTraceElement[] syntheticStackTrace) {
++ @Nullable Throwable cause, StackSize stackSize, StackTraceElement[] syntheticStackTrace) {
+ super(stackSize.toString(), cause);
+ // This takes a defensive copy, but there's no way around that. Note that we cannot override
+ // getStackTrace() to avoid a defensive copy because that breaks stack trace formatting
+--- a/api/src/main/java/com/google/common/flogger/LoggerConfig.java
++++ b/api/src/main/java/com/google/common/flogger/LoggerConfig.java
+@@ -27,7 +27,7 @@
+ import java.util.logging.Handler;
+ import java.util.logging.Level;
+ import java.util.logging.Logger;
+-import org.checkerframework.checker.nullness.compatqual.NullableDecl;
++import org.checkerframework.checker.nullness.qual.Nullable;
+
+ /**
+ * An adapter for the configuration specific aspects of a JDK logger which retains a strong
+@@ -142,35 +142,35 @@
+ }
+
+ /** See {@link Logger#getResourceBundle()}. */
+- @NullableDecl
++ @Nullable
+ public ResourceBundle getResourceBundle() {
+ return logger.getResourceBundle();
+ }
+
+ /** See {@link Logger#getResourceBundleName()}. */
+- @NullableDecl
++ @Nullable
+ public String getResourceBundleName() {
+ return logger.getResourceBundleName();
+ }
+
+ /** See {@link Logger#setFilter(Filter)}. */
+- public void setFilter(@NullableDecl Filter newFilter) throws SecurityException {
++ public void setFilter(@Nullable Filter newFilter) throws SecurityException {
+ logger.setFilter(newFilter);
+ }
+
+ /** See {@link Logger#getFilter()}. */
+- @NullableDecl
++ @Nullable
+ public Filter getFilter() {
+ return logger.getFilter();
+ }
+
+ /** See {@link Logger#setLevel(Level)}. */
+- public void setLevel(@NullableDecl Level newLevel) throws SecurityException {
++ public void setLevel(@Nullable Level newLevel) throws SecurityException {
+ logger.setLevel(newLevel);
+ }
+
+ /** See {@link Logger#getLevel()}. */
+- @NullableDecl
++ @Nullable
+ public Level getLevel() {
+ return logger.getLevel();
+ }
+@@ -208,7 +208,7 @@
+ }
+
+ /** See {@link Logger#getParent()}. */
+- @NullableDecl
++ @Nullable
+ public Logger getParent() {
+ return logger.getParent();
+ }
+--- a/api/src/main/java/com/google/common/flogger/LoggingApi.java
++++ b/api/src/main/java/com/google/common/flogger/LoggingApi.java
+@@ -20,7 +20,7 @@
+
+ import com.google.errorprone.annotations.CheckReturnValue;
+ import java.util.concurrent.TimeUnit;
+-import org.checkerframework.checker.nullness.compatqual.NullableDecl;
++import org.checkerframework.checker.nullness.qual.Nullable;
+
+ /**
+ * The basic logging API. An implementation of this API (or an extension of it) will be
+@@ -53,7 +53,7 @@
+ * If this method is called multiple times for a single log statement, the last invocation will
+ * take precedence.
+ */
+- API withCause(@NullableDecl Throwable cause);
++ API withCause(@Nullable Throwable cause);
+
+ /**
+ * Modifies the current log statement to be emitted only one-in-N times that it is invoked. The
+@@ -169,7 +169,7 @@
+ * @throws NullPointerException if the given key is null
+ * @see MetadataKey
+ */
+- <T> API with(MetadataKey<T> key, @NullableDecl T value);
++ <T> API with(MetadataKey<T> key, @Nullable T value);
+
+ /**
+ * Sets the log site for the current log statement. Explicit log site injection is very rarely
+@@ -239,7 +239,7 @@
+ String internalClassName,
+ String methodName,
+ int encodedLineNumber,
+- @NullableDecl String sourceFileName);
++ @Nullable String sourceFileName);
+
+ /**
+ * Returns true if logging is enabled at the level implied for this API, according to the current
+@@ -287,7 +287,7 @@
+ * @param message the message template string containing a single argument placeholder.
+ * @param varargs the non-null array of arguments to be formatted.
+ */
+- void logVarargs(String message, @NullableDecl Object[] varargs);
++ void logVarargs(String message, @Nullable Object[] varargs);
+
+ /**
+ * Terminal log statement when a message is not required. A {@code log} method must terminate all
+@@ -331,94 +331,94 @@
+ *
+ * @param msg the message template string containing a single argument placeholder.
+ */
+- void log(String msg, @NullableDecl Object p1);
++ void log(String msg, @Nullable Object p1);
+ /** Logs a message with formatted arguments (see {@link #log(String, Object)} for details). */
+- void log(String msg, @NullableDecl Object p1, @NullableDecl Object p2);
++ void log(String msg, @Nullable Object p1, @Nullable Object p2);
+ /** Logs a message with formatted arguments (see {@link #log(String, Object)} for details). */
+- void log(String msg, @NullableDecl Object p1, @NullableDecl Object p2, @NullableDecl Object p3);
++ void log(String msg, @Nullable Object p1, @Nullable Object p2, @Nullable Object p3);
+ /** Logs a message with formatted arguments (see {@link #log(String, Object)} for details). */
+ void log(
+ String msg,
+- @NullableDecl Object p1,
+- @NullableDecl Object p2,
+- @NullableDecl Object p3,
+- @NullableDecl Object p4);
++ @Nullable Object p1,
++ @Nullable Object p2,
++ @Nullable Object p3,
++ @Nullable Object p4);
+ /** Logs a message with formatted arguments (see {@link #log(String, Object)} for details). */
+ void log(
+ String msg,
+- @NullableDecl Object p1,
+- @NullableDecl Object p2,
+- @NullableDecl Object p3,
+- @NullableDecl Object p4,
+- @NullableDecl Object p5);
++ @Nullable Object p1,
++ @Nullable Object p2,
++ @Nullable Object p3,
++ @Nullable Object p4,
++ @Nullable Object p5);
+ /** Logs a message with formatted arguments (see {@link #log(String, Object)} for details). */
+ void log(
+ String msg,
+- @NullableDecl Object p1,
+- @NullableDecl Object p2,
+- @NullableDecl Object p3,
+- @NullableDecl Object p4,
+- @NullableDecl Object p5,
+- @NullableDecl Object p6);
++ @Nullable Object p1,
++ @Nullable Object p2,
++ @Nullable Object p3,
++ @Nullable Object p4,
++ @Nullable Object p5,
++ @Nullable Object p6);
+ /** Logs a message with formatted arguments (see {@link #log(String, Object)} for details). */
+ void log(
+ String msg,
+- @NullableDecl Object p1,
+- @NullableDecl Object p2,
+- @NullableDecl Object p3,
+- @NullableDecl Object p4,
+- @NullableDecl Object p5,
+- @NullableDecl Object p6,
+- @NullableDecl Object p7);
++ @Nullable Object p1,
++ @Nullable Object p2,
++ @Nullable Object p3,
++ @Nullable Object p4,
++ @Nullable Object p5,
++ @Nullable Object p6,
++ @Nullable Object p7);
+ /** Logs a message with formatted arguments (see {@link #log(String, Object)} for details). */
+ void log(
+ String msg,
+- @NullableDecl Object p1,
+- @NullableDecl Object p2,
+- @NullableDecl Object p3,
+- @NullableDecl Object p4,
+- @NullableDecl Object p5,
+- @NullableDecl Object p6,
+- @NullableDecl Object p7,
+- @NullableDecl Object p8);
++ @Nullable Object p1,
++ @Nullable Object p2,
++ @Nullable Object p3,
++ @Nullable Object p4,
++ @Nullable Object p5,
++ @Nullable Object p6,
++ @Nullable Object p7,
++ @Nullable Object p8);
+ /** Logs a message with formatted arguments (see {@link #log(String, Object)} for details). */
+ void log(
+ String msg,
+- @NullableDecl Object p1,
+- @NullableDecl Object p2,
+- @NullableDecl Object p3,
+- @NullableDecl Object p4,
+- @NullableDecl Object p5,
+- @NullableDecl Object p6,
+- @NullableDecl Object p7,
+- @NullableDecl Object p8,
+- @NullableDecl Object p9);
++ @Nullable Object p1,
++ @Nullable Object p2,
++ @Nullable Object p3,
++ @Nullable Object p4,
++ @Nullable Object p5,
++ @Nullable Object p6,
++ @Nullable Object p7,
++ @Nullable Object p8,
++ @Nullable Object p9);
+ /** Logs a message with formatted arguments (see {@link #log(String, Object)} for details). */
+ void log(
+ String msg,
+- @NullableDecl Object p1,
+- @NullableDecl Object p2,
+- @NullableDecl Object p3,
+- @NullableDecl Object p4,
+- @NullableDecl Object p5,
+- @NullableDecl Object p6,
+- @NullableDecl Object p7,
+- @NullableDecl Object p8,
+- @NullableDecl Object p9,
+- @NullableDecl Object p10);
++ @Nullable Object p1,
++ @Nullable Object p2,
++ @Nullable Object p3,
++ @Nullable Object p4,
++ @Nullable Object p5,
++ @Nullable Object p6,
++ @Nullable Object p7,
++ @Nullable Object p8,
++ @Nullable Object p9,
++ @Nullable Object p10);
+ /** Logs a message with formatted arguments (see {@link #log(String, Object)} for details). */
+ void log(
+ String msg,
+- @NullableDecl Object p1,
+- @NullableDecl Object p2,
+- @NullableDecl Object p3,
+- @NullableDecl Object p4,
+- @NullableDecl Object p5,
+- @NullableDecl Object p6,
+- @NullableDecl Object p7,
+- @NullableDecl Object p8,
+- @NullableDecl Object p9,
+- @NullableDecl Object p10,
++ @Nullable Object p1,
++ @Nullable Object p2,
++ @Nullable Object p3,
++ @Nullable Object p4,
++ @Nullable Object p5,
++ @Nullable Object p6,
++ @Nullable Object p7,
++ @Nullable Object p8,
++ @Nullable Object p9,
++ @Nullable Object p10,
+ Object... rest);
+
+ // ---- Overloads for a single argument (to avoid auto-boxing and vararg array creation). ----
+@@ -444,38 +444,38 @@
+ */
+
+ /** Logs a message with formatted arguments (see {@link #log(String, Object)} for details). */
+- void log(String msg, @NullableDecl Object p1, boolean p2);
++ void log(String msg, @Nullable Object p1, boolean p2);
+ /** Logs a message with formatted arguments (see {@link #log(String, Object)} for details). */
+- void log(String msg, @NullableDecl Object p1, char p2);
++ void log(String msg, @Nullable Object p1, char p2);
+ /** Logs a message with formatted arguments (see {@link #log(String, Object)} for details). */
+- void log(String msg, @NullableDecl Object p1, byte p2);
++ void log(String msg, @Nullable Object p1, byte p2);
+ /** Logs a message with formatted arguments (see {@link #log(String, Object)} for details). */
+- void log(String msg, @NullableDecl Object p1, short p2);
++ void log(String msg, @Nullable Object p1, short p2);
+ /** Logs a message with formatted arguments (see {@link #log(String, Object)} for details). */
+- void log(String msg, @NullableDecl Object p1, int p2);
++ void log(String msg, @Nullable Object p1, int p2);
+ /** Logs a message with formatted arguments (see {@link #log(String, Object)} for details). */
+- void log(String msg, @NullableDecl Object p1, long p2);
++ void log(String msg, @Nullable Object p1, long p2);
+ /** Logs a message with formatted arguments (see {@link #log(String, Object)} for details). */
+- void log(String msg, @NullableDecl Object p1, float p2);
++ void log(String msg, @Nullable Object p1, float p2);
+ /** Logs a message with formatted arguments (see {@link #log(String, Object)} for details). */
+- void log(String msg, @NullableDecl Object p1, double p2);
++ void log(String msg, @Nullable Object p1, double p2);
+
+ /** Logs a message with formatted arguments (see {@link #log(String, Object)} for details). */
+- void log(String msg, boolean p1, @NullableDecl Object p2);
++ void log(String msg, boolean p1, @Nullable Object p2);
+ /** Logs a message with formatted arguments (see {@link #log(String, Object)} for details). */
+- void log(String msg, char p1, @NullableDecl Object p2);
++ void log(String msg, char p1, @Nullable Object p2);
+ /** Logs a message with formatted arguments (see {@link #log(String, Object)} for details). */
+- void log(String msg, byte p1, @NullableDecl Object p2);
++ void log(String msg, byte p1, @Nullable Object p2);
+ /** Logs a message with formatted arguments (see {@link #log(String, Object)} for details). */
+- void log(String msg, short p1, @NullableDecl Object p2);
++ void log(String msg, short p1, @Nullable Object p2);
+ /** Logs a message with formatted arguments (see {@link #log(String, Object)} for details). */
+- void log(String msg, int p1, @NullableDecl Object p2);
++ void log(String msg, int p1, @Nullable Object p2);
+ /** Logs a message with formatted arguments (see {@link #log(String, Object)} for details). */
+- void log(String msg, long p1, @NullableDecl Object p2);
++ void log(String msg, long p1, @Nullable Object p2);
+ /** Logs a message with formatted arguments (see {@link #log(String, Object)} for details). */
+- void log(String msg, float p1, @NullableDecl Object p2);
++ void log(String msg, float p1, @Nullable Object p2);
+ /** Logs a message with formatted arguments (see {@link #log(String, Object)} for details). */
+- void log(String msg, double p1, @NullableDecl Object p2);
++ void log(String msg, double p1, @Nullable Object p2);
+
+ /** Logs a message with formatted arguments (see {@link #log(String, Object)} for details). */
+ void log(String msg, boolean p1, boolean p2);
+@@ -635,7 +635,7 @@
+ String internalClassName,
+ String methodName,
+ int encodedLineNumber,
+- @NullableDecl String sourceFileName) {
++ @Nullable String sourceFileName) {
+ return noOp();
+ }
+
+@@ -645,14 +645,14 @@
+ }
+
+ @Override
+- public final <T> API with(MetadataKey<T> key, @NullableDecl T value) {
++ public final <T> API with(MetadataKey<T> key, @Nullable T value) {
+ // Identical to the check in LogContext for consistency.
+ checkNotNull(key, "metadata key");
+ return noOp();
+ }
+
+ @Override
+- public final API withCause(@NullableDecl Throwable cause) {
++ public final API withCause(@Nullable Throwable cause) {
+ return noOp();
+ }
+
+@@ -684,105 +684,105 @@
+ public final void log(String msg) {}
+
+ @Override
+- public final void log(String msg, @NullableDecl Object p1) {}
++ public final void log(String msg, @Nullable Object p1) {}
+
+ @Override
+- public final void log(String msg, @NullableDecl Object p1, @NullableDecl Object p2) {}
++ public final void log(String msg, @Nullable Object p1, @Nullable Object p2) {}
+
+ @Override
+ public final void log(
+- String msg, @NullableDecl Object p1, @NullableDecl Object p2, @NullableDecl Object p3) {}
++ String msg, @Nullable Object p1, @Nullable Object p2, @Nullable Object p3) {}
+
+ @Override
+ public final void log(
+ String msg,
+- @NullableDecl Object p1,
+- @NullableDecl Object p2,
+- @NullableDecl Object p3,
+- @NullableDecl Object p4) {}
++ @Nullable Object p1,
++ @Nullable Object p2,
++ @Nullable Object p3,
++ @Nullable Object p4) {}
+
+ @Override
+ public final void log(
+ String msg,
+- @NullableDecl Object p1,
+- @NullableDecl Object p2,
+- @NullableDecl Object p3,
+- @NullableDecl Object p4,
+- @NullableDecl Object p5) {}
++ @Nullable Object p1,
++ @Nullable Object p2,
++ @Nullable Object p3,
++ @Nullable Object p4,
++ @Nullable Object p5) {}
+
+ @Override
+ public final void log(
+ String msg,
+- @NullableDecl Object p1,
+- @NullableDecl Object p2,
+- @NullableDecl Object p3,
+- @NullableDecl Object p4,
+- @NullableDecl Object p5,
+- @NullableDecl Object p6) {}
++ @Nullable Object p1,
++ @Nullable Object p2,
++ @Nullable Object p3,
++ @Nullable Object p4,
++ @Nullable Object p5,
++ @Nullable Object p6) {}
+
+ @Override
+ public final void log(
+ String msg,
+- @NullableDecl Object p1,
+- @NullableDecl Object p2,
+- @NullableDecl Object p3,
+- @NullableDecl Object p4,
+- @NullableDecl Object p5,
+- @NullableDecl Object p6,
+- @NullableDecl Object p7) {}
++ @Nullable Object p1,
++ @Nullable Object p2,
++ @Nullable Object p3,
++ @Nullable Object p4,
++ @Nullable Object p5,
++ @Nullable Object p6,
++ @Nullable Object p7) {}
+
+ @Override
+ public final void log(
+ String msg,
+- @NullableDecl Object p1,
+- @NullableDecl Object p2,
+- @NullableDecl Object p3,
+- @NullableDecl Object p4,
+- @NullableDecl Object p5,
+- @NullableDecl Object p6,
+- @NullableDecl Object p7,
+- @NullableDecl Object p8) {}
++ @Nullable Object p1,
++ @Nullable Object p2,
++ @Nullable Object p3,
++ @Nullable Object p4,
++ @Nullable Object p5,
++ @Nullable Object p6,
++ @Nullable Object p7,
++ @Nullable Object p8) {}
+
+ @Override
+ public final void log(
+ String msg,
+- @NullableDecl Object p1,
+- @NullableDecl Object p2,
+- @NullableDecl Object p3,
+- @NullableDecl Object p4,
+- @NullableDecl Object p5,
+- @NullableDecl Object p6,
+- @NullableDecl Object p7,
+- @NullableDecl Object p8,
+- @NullableDecl Object p9) {}
++ @Nullable Object p1,
++ @Nullable Object p2,
++ @Nullable Object p3,
++ @Nullable Object p4,
++ @Nullable Object p5,
++ @Nullable Object p6,
++ @Nullable Object p7,
++ @Nullable Object p8,
++ @Nullable Object p9) {}
+
+ @Override
+ public final void log(
+ String msg,
+- @NullableDecl Object p1,
+- @NullableDecl Object p2,
+- @NullableDecl Object p3,
+- @NullableDecl Object p4,
+- @NullableDecl Object p5,
+- @NullableDecl Object p6,
+- @NullableDecl Object p7,
+- @NullableDecl Object p8,
+- @NullableDecl Object p9,
+- @NullableDecl Object p10) {}
++ @Nullable Object p1,
++ @Nullable Object p2,
++ @Nullable Object p3,
++ @Nullable Object p4,
++ @Nullable Object p5,
++ @Nullable Object p6,
++ @Nullable Object p7,
++ @Nullable Object p8,
++ @Nullable Object p9,
++ @Nullable Object p10) {}
+
+ @Override
+ public final void log(
+ String msg,
+- @NullableDecl Object p1,
+- @NullableDecl Object p2,
+- @NullableDecl Object p3,
+- @NullableDecl Object p4,
+- @NullableDecl Object p5,
+- @NullableDecl Object p6,
+- @NullableDecl Object p7,
+- @NullableDecl Object p8,
+- @NullableDecl Object p9,
+- @NullableDecl Object p10,
++ @Nullable Object p1,
++ @Nullable Object p2,
++ @Nullable Object p3,
++ @Nullable Object p4,
++ @Nullable Object p5,
++ @Nullable Object p6,
++ @Nullable Object p7,
++ @Nullable Object p8,
++ @Nullable Object p9,
++ @Nullable Object p10,
+ Object... rest) {}
+
+ @Override
+@@ -801,52 +801,52 @@
+ public final void log(String msg, long p1) {}
+
+ @Override
+- public final void log(String msg, @NullableDecl Object p1, boolean p2) {}
++ public final void log(String msg, @Nullable Object p1, boolean p2) {}
+
+ @Override
+- public final void log(String msg, @NullableDecl Object p1, char p2) {}
++ public final void log(String msg, @Nullable Object p1, char p2) {}
+
+ @Override
+- public final void log(String msg, @NullableDecl Object p1, byte p2) {}
++ public final void log(String msg, @Nullable Object p1, byte p2) {}
+
+ @Override
+- public final void log(String msg, @NullableDecl Object p1, short p2) {}
++ public final void log(String msg, @Nullable Object p1, short p2) {}
+
+ @Override
+- public final void log(String msg, @NullableDecl Object p1, int p2) {}
++ public final void log(String msg, @Nullable Object p1, int p2) {}
+
+ @Override
+- public final void log(String msg, @NullableDecl Object p1, long p2) {}
++ public final void log(String msg, @Nullable Object p1, long p2) {}
+
+ @Override
+- public final void log(String msg, @NullableDecl Object p1, float p2) {}
++ public final void log(String msg, @Nullable Object p1, float p2) {}
+
+ @Override
+- public final void log(String msg, @NullableDecl Object p1, double p2) {}
++ public final void log(String msg, @Nullable Object p1, double p2) {}
+
+ @Override
+- public final void log(String msg, boolean p1, @NullableDecl Object p2) {}
++ public final void log(String msg, boolean p1, @Nullable Object p2) {}
+
+ @Override
+- public final void log(String msg, char p1, @NullableDecl Object p2) {}
++ public final void log(String msg, char p1, @Nullable Object p2) {}
+
+ @Override
+- public final void log(String msg, byte p1, @NullableDecl Object p2) {}
++ public final void log(String msg, byte p1, @Nullable Object p2) {}
+
+ @Override
+- public final void log(String msg, short p1, @NullableDecl Object p2) {}
++ public final void log(String msg, short p1, @Nullable Object p2) {}
+
+ @Override
+- public final void log(String msg, int p1, @NullableDecl Object p2) {}
++ public final void log(String msg, int p1, @Nullable Object p2) {}
+
+ @Override
+- public final void log(String msg, long p1, @NullableDecl Object p2) {}
++ public final void log(String msg, long p1, @Nullable Object p2) {}
+
+ @Override
+- public final void log(String msg, float p1, @NullableDecl Object p2) {}
++ public final void log(String msg, float p1, @Nullable Object p2) {}
+
+ @Override
+- public final void log(String msg, double p1, @NullableDecl Object p2) {}
++ public final void log(String msg, double p1, @Nullable Object p2) {}
+
+ @Override
+ public final void log(String msg, boolean p1, boolean p2) {}
+--- a/api/src/main/java/com/google/common/flogger/backend/FormatOptions.java
++++ b/api/src/main/java/com/google/common/flogger/backend/FormatOptions.java
+@@ -17,7 +17,7 @@
+ package com.google.common.flogger.backend;
+
+ import com.google.common.flogger.parser.ParseException;
+-import org.checkerframework.checker.nullness.compatqual.NullableDecl;
++import org.checkerframework.checker.nullness.qual.Nullable;
+
+ /**
+ * A structured representation of formatting options compatible with printf style formatting.
+@@ -490,7 +490,7 @@
+ }
+
+ @Override
+- public boolean equals(@NullableDecl Object o) {
++ public boolean equals(@Nullable Object o) {
+ // Various functions ensure that the same instance gets re-used, so it seems likely that it's
+ // worth optimizing for it here.
+ if (o == this) {
+--- a/api/src/main/java/com/google/common/flogger/backend/KeyValueFormatter.java
++++ b/api/src/main/java/com/google/common/flogger/backend/KeyValueFormatter.java
+@@ -19,7 +19,7 @@
+ import java.util.Arrays;
+ import java.util.HashSet;
+ import java.util.Set;
+-import org.checkerframework.checker.nullness.compatqual.NullableDecl;
++import org.checkerframework.checker.nullness.qual.Nullable;
+
+ /**
+ * Formats key/value pairs as a human readable string on the end of log statements. The format is:
+@@ -88,7 +88,7 @@
+ }
+
+ @Override
+- public KeyValueFormatter handle(String label, @NullableDecl Object value) {
++ public KeyValueFormatter handle(String label, @Nullable Object value) {
+ if (haveSeenValues) {
+ out.append(' ');
+ } else {
+--- a/api/src/main/java/com/google/common/flogger/backend/KeyValueHandler.java
++++ b/api/src/main/java/com/google/common/flogger/backend/KeyValueHandler.java
+@@ -16,7 +16,7 @@
+
+ package com.google.common.flogger.backend;
+
+-import org.checkerframework.checker.nullness.compatqual.NullableDecl;
++import org.checkerframework.checker.nullness.qual.Nullable;
+
+ /**
+ * Callback interface to handle additional contextual key/value pairs with log statements. Used
+@@ -27,5 +27,5 @@
+ * Handle a single key value pair of contextual metadata for a log statement. Note that it is
+ * permitted for the value to be null if a tag was added by name only.
+ */
+- KeyValueHandler handle(String key, @NullableDecl Object value);
++ KeyValueHandler handle(String key, @Nullable Object value);
+ }
+--- a/api/src/main/java/com/google/common/flogger/backend/LoggingException.java
++++ b/api/src/main/java/com/google/common/flogger/backend/LoggingException.java
+@@ -16,7 +16,7 @@
+
+ package com.google.common.flogger.backend;
+
+-import org.checkerframework.checker.nullness.compatqual.NullableDecl;
++import org.checkerframework.checker.nullness.qual.Nullable;
+
+ /**
+ * Exception thrown when a log statement cannot be emitted correctly. This exception should only be
+@@ -30,11 +30,11 @@
+ */
+ public class LoggingException extends RuntimeException {
+
+- public LoggingException(@NullableDecl String message) {
++ public LoggingException(@Nullable String message) {
+ super(message);
+ }
+
+- public LoggingException(@NullableDecl String message, @NullableDecl Throwable cause) {
++ public LoggingException(@Nullable String message, @Nullable Throwable cause) {
+ super(message, cause);
+ }
+ }
+--- a/api/src/main/java/com/google/common/flogger/backend/Metadata.java
++++ b/api/src/main/java/com/google/common/flogger/backend/Metadata.java
+@@ -17,7 +17,7 @@
+ package com.google.common.flogger.backend;
+
+ import com.google.common.flogger.MetadataKey;
+-import org.checkerframework.checker.nullness.compatqual.NullableDecl;
++import org.checkerframework.checker.nullness.qual.Nullable;
+
+ /**
+ * Optional debug information which can be attached to a log statement. Metadata is represented as
+@@ -105,7 +105,7 @@
+ }
+
+ @Override
+- @NullableDecl
++ @Nullable
+ public <T> T findValue(MetadataKey<T> key) {
+ return null;
+ }
+@@ -133,6 +133,6 @@
+ *
+ * @throws NullPointerException if {@code key} is {@code null}.
+ */
+- @NullableDecl
++ @Nullable
+ public abstract <T> T findValue(MetadataKey<T> key);
+ }
+--- a/api/src/main/java/com/google/common/flogger/backend/SimpleMessageFormatter.java
++++ b/api/src/main/java/com/google/common/flogger/backend/SimpleMessageFormatter.java
+@@ -38,7 +38,7 @@
+ import java.util.Formatter;
+ import java.util.Locale;
+ import java.util.logging.Level;
+-import org.checkerframework.checker.nullness.compatqual.NullableDecl;
++import org.checkerframework.checker.nullness.qual.Nullable;
+
+ /**
+ * Helper class for formatting LogData as text. This class is useful for any logging backend which
+@@ -60,7 +60,7 @@
+ * Handles a single formatted log statement with the given level, message and "cause". This is
+ * called back exactly once, from the same thread, for every call made to {@link #format}.
+ */
+- void handleFormattedLogMessage(Level level, String message, @NullableDecl Throwable thrown);
++ void handleFormattedLogMessage(Level level, String message, @Nullable Throwable thrown);
+ }
+
+ /**
+--- a/api/src/main/java/com/google/common/flogger/backend/Tags.java
++++ b/api/src/main/java/com/google/common/flogger/backend/Tags.java
+@@ -28,7 +28,7 @@
+ import java.util.SortedSet;
+ import java.util.TreeMap;
+ import java.util.TreeSet;
+-import org.checkerframework.checker.nullness.compatqual.NullableDecl;
++import org.checkerframework.checker.nullness.qual.Nullable;
+
+ /**
+ * Immutable tags which can be attached to log statements via platform specific injection
+@@ -340,7 +340,7 @@
+ }
+
+ @Override
+- public boolean equals(@NullableDecl Object obj) {
++ public boolean equals(@Nullable Object obj) {
+ return (obj instanceof Tags) && ((Tags) obj).map.equals(map);
+ }
+
+--- a/api/src/main/java/com/google/common/flogger/backend/system/SimpleLogRecord.java
++++ b/api/src/main/java/com/google/common/flogger/backend/system/SimpleLogRecord.java
+@@ -21,7 +21,7 @@
+ import com.google.common.flogger.backend.SimpleMessageFormatter.SimpleLogHandler;
+ import java.util.logging.Level;
+ import java.util.logging.LogRecord;
+-import org.checkerframework.checker.nullness.compatqual.NullableDecl;
++import org.checkerframework.checker.nullness.qual.Nullable;
+
+ /**
+ * An eagerly evaluating {@link LogRecord} which is created by the Fluent Logger frontend and can be
+@@ -54,7 +54,7 @@
+ }
+
+ @Override
+- public void handleFormattedLogMessage(Level level, String message, @NullableDecl Throwable thrown) {
++ public void handleFormattedLogMessage(Level level, String message, @Nullable Throwable thrown) {
+ // Ignore the log level as our parent class already set it (that's used in Android).
+ setMessage(message);
+ setThrown(thrown);
+--- a/api/src/main/java/com/google/common/flogger/context/Tags.java
++++ b/api/src/main/java/com/google/common/flogger/context/Tags.java
+@@ -27,7 +27,7 @@
+ import java.util.SortedSet;
+ import java.util.TreeMap;
+ import java.util.TreeSet;
+-import org.checkerframework.checker.nullness.compatqual.NullableDecl;
++import org.checkerframework.checker.nullness.qual.Nullable;
+
+ /**
+ * Immutable tags which can be attached to log statements via platform specific injection
+@@ -321,7 +321,7 @@
+ }
+
+ @Override
+- public boolean equals(@NullableDecl Object obj) {
++ public boolean equals(@Nullable Object obj) {
+ return (obj instanceof Tags) && ((Tags) obj).map.equals(map);
+ }
+
+--- a/api/src/main/java/com/google/common/flogger/util/CallerFinder.java
++++ b/api/src/main/java/com/google/common/flogger/util/CallerFinder.java
+@@ -19,7 +19,7 @@
+ import static com.google.common.flogger.util.Checks.checkNotNull;
+
+ import com.google.errorprone.annotations.CheckReturnValue;
+-import org.checkerframework.checker.nullness.compatqual.NullableDecl;
++import org.checkerframework.checker.nullness.qual.Nullable;
+
+ /** A helper class for determining callers of a specified class currently on the stack. */
+ @CheckReturnValue
+@@ -40,7 +40,7 @@
+ * @return the stack trace element representing the immediate caller of the specified class, or
+ * null if no caller was found (due to incorrect target, wrong skip count or use of JNI).
+ */
+- @NullableDecl
++ @Nullable
+ public static StackTraceElement findCallerOf(Class<?> target, Throwable throwable, int skip) {
+ checkNotNull(target, "target");
+ checkNotNull(throwable, "throwable");
+--- a/api/src/main/java/com/google/common/flogger/util/FastStackGetter.java
++++ b/api/src/main/java/com/google/common/flogger/util/FastStackGetter.java
+@@ -19,7 +19,7 @@
+ import com.google.errorprone.annotations.CheckReturnValue;
+ import java.lang.reflect.InvocationTargetException;
+ import java.lang.reflect.Method;
+-import org.checkerframework.checker.nullness.compatqual.NullableDecl;
++import org.checkerframework.checker.nullness.qual.Nullable;
+
+ /**
+ * A helper class to abstract the complexities of dynamically invoking the
+@@ -31,7 +31,7 @@
+ * @return a new {@code FastStackGetter} if the {@code getStackTraceElement()} method of
+ * {@code JavaLangAccess} is supported on this platform, or {@code null} otherwise.
+ */
+- @NullableDecl
++ @Nullable
+ public static FastStackGetter createIfSupported() {
+ try {
+ Object javaLangAccess =
+--- a/api/src/main/java/com/google/common/flogger/util/StackBasedLogSite.java
++++ b/api/src/main/java/com/google/common/flogger/util/StackBasedLogSite.java
+@@ -20,7 +20,7 @@
+
+ import com.google.common.flogger.LogSite;
+ import com.google.errorprone.annotations.CheckReturnValue;
+-import org.checkerframework.checker.nullness.compatqual.NullableDecl;
++import org.checkerframework.checker.nullness.qual.Nullable;
+
+ /**
+ * A stack based log site which uses information from a given {@code StackTraceElement}.
+@@ -64,7 +64,7 @@
+ }
+
+ @Override
+- public boolean equals(@NullableDecl Object obj) {
++ public boolean equals(@Nullable Object obj) {
+ return (obj instanceof StackBasedLogSite)
+ && stackElement.equals(((StackBasedLogSite) obj).stackElement);
+ }
+--- a/api/src/main/java/com/google/common/flogger/util/StaticMethodCaller.java
++++ b/api/src/main/java/com/google/common/flogger/util/StaticMethodCaller.java
+@@ -16,7 +16,7 @@
+
+ package com.google.common.flogger.util;
+
+-import org.checkerframework.checker.nullness.compatqual.NullableDecl;
++import org.checkerframework.checker.nullness.qual.Nullable;
+
+ /**
+ * Helper to call a static no-arg getter to obtain an instance of a specified type. This is used
+@@ -36,7 +36,7 @@
+ * @param type the expected type (or supertype) of the returned value (generified types are not
+ * supported).
+ */
+- @NullableDecl
++ @Nullable
+ public static <T> T callGetterFromSystemProperty(String propertyName, Class<T> type) {
+ String getter = readProperty(propertyName);
+ if (getter == null) {
=====================================
debian/patches/series
=====================================
@@ -0,0 +1,3 @@
+maven-build.patch
+replace-nullable.patch
+backend-build.patch
=====================================
debian/rules
=====================================
@@ -0,0 +1,33 @@
+#!/usr/bin/make -f
+
+export DH_VERBOSE = 1
+#export DEB_BUILD_MAINT_OPTIONS = hardening=+all
+
+# Ensure packages build with no Internet access
+export http_proxy=127.0.0.1:9
+export https_proxy=127.0.0.1:9
+
+%:
+ dh $@
+
+override_dh_auto_configure:
+ install -d debian/.debhelper/generated/_source/home debian/.debhelper/generated/_source/xdg-runtime-dir
+ /usr/share/maven-debian-helper/copy-repo.sh debian
+ touch debian/stamp-poms-patched
+ # flogger has a very interesting way to generate the platform_provider.jar directly from a java binary
+ # This is a replacement for //api:gen_platform_provider
+ # This override is only required for the Maven build
+ javac -classpath debian/maven-repo/org/ow2/asm/asm/debian/asm-debian.jar \
+ api/platformprovider/main/java/com/google/common/flogger/backend/PlatformProviderGenerator.java
+ java -classpath api/platformprovider/main/java:debian/maven-repo/org/ow2/asm/asm/debian/asm-debian.jar \
+ com.google.common.flogger.backend.PlatformProviderGenerator api/platform_provider.jar
+ mvn install:install-file -Dfile=api/platform_provider.jar \
+ -DgroupId=com.google.flogger -DartifactId=platform-provider \
+ -Dversion=0.5.1 -Dpackaging=jar -Dmaven.repo.local=debian/maven-repo
+
+override_dh_auto_build:
+ mkdir -p api/target/classes/
+ unzip api/platform_provider.jar */PlatformProvider.class -d api/target/classes/
+ dh_auto_build
+
+override_dh_auto_test:
=====================================
debian/source/format
=====================================
@@ -0,0 +1 @@
+3.0 (quilt)
=====================================
debian/upstream/metadata
=====================================
@@ -0,0 +1,4 @@
+Bug-Database: https://github.com/google/flogger/issues
+Homepage: https://github.com/google/flogger
+Repository: https://github.com/google/flogger.git
+Repository-Browse: https://github.com/google/flogger
=====================================
debian/watch
=====================================
@@ -0,0 +1,8 @@
+version=4
+
+# PGP signature mangle, so foo.tar.gz has foo.tar.gz.sig
+#opts="pgpsigurlmangle=s%$%.sig%"
+
+opts="repack" \
+ https://github.com/google/flogger/tags \
+ .*/flogger-(\d[\d.]*)\.tar\.gz debian uupdate
View it on GitLab: https://salsa.debian.org/java-team/google-flogger/-/commit/8044d8359663be07d16ed5e63e26d100a09cf2ae
--
View it on GitLab: https://salsa.debian.org/java-team/google-flogger/-/commit/8044d8359663be07d16ed5e63e26d100a09cf2ae
You're receiving this email because of your account on salsa.debian.org.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://alioth-lists.debian.net/pipermail/pkg-java-commits/attachments/20200715/00ed12fa/attachment.html>
More information about the pkg-java-commits
mailing list