import Guava primitives

Author: ktoso

NOTICE.txt

@@ -26,11 +26,13 @@ components that this product depends on.
 
 -------------------------------------------------------------------------------
 
-This product contains a unsigned numerics support which is derived from Google Guava's 'UnsignedLong' and related types.
+This product contains a unsigned numerics support which is derived from Google Guava library (Version 33.4.8).
+Specifically, types from the 'com.google.common.primitives.*' package.
 
   * LICENSE (Apache License 2.0):
     * https://www.apache.org/licenses/LICENSE-2.0
   * HOMEPAGE:
     * https://github.com/google/guava/
+    * https://github.com/google/guava/blob/master/guava/src/com/google/common/primitives/
     * https://github.com/google/guava/blob/master/guava/src/com/google/common/primitives/UnsignedLong.java
     * https://github.com/google/guava/blob/master/guava/src/com/google/common/primitives/UnsignedInts.java

Package.swift

@@ -210,7 +210,6 @@ let package = Package(
   ],
   targets: [
     .target(
-      name: "Documentation",
       name: "SwiftJavaDocumentation",
       dependencies: [
         "JavaKit",

Samples/SwiftKitSampleApp/Sources/MySwiftLibrary/MySwiftClass.swift

@@ -61,12 +61,11 @@ public class MySwiftClass {
     return Int.random(in: 1..<256)
   }
 
-  public func takeUnsignedByte(arg: UInt8) -> UInt8 {
+  public func takeUnsignedInt(arg: UInt32) {
     p("\(UInt32.self) = \(arg)")
-    return arg
   }
 
-  public func takeUnsignedInt(arg: UInt32) {
-    p("\(UInt32.self) = \(arg)")
+  public func takeUnsignedLong(arg: UInt64) {
+    p("\(UInt64.self) = \(arg)")
   }
 }

Samples/SwiftKitSampleApp/src/test/java/com/example/swift/UnsignedTest.java renamed to Samples/SwiftKitSampleApp/src/test/java/com/example/swift/UnsignedNumbersTest.java

@@ -18,23 +18,20 @@
 import org.swift.swiftkit.core.primitives.*;
 import org.swift.swiftkit.ffm.AllocatingSwiftArena;
 
-import static org.junit.jupiter.api.Assertions.*;
-
-public class UnsignedTest {
+public class UnsignedNumbersTest {
     @Test
-    void take_unsigned_int32() {
+    void take_uint32() {
         try (var arena = AllocatingSwiftArena.ofConfined()) {
             var c = MySwiftClass.init(1, 2, arena);
             c.takeUnsignedInt(UnsignedInteger.valueOf(128));
         }
     }
 
     @Test
-    void take_uint8() {
+    void take_uint64() {
         try (var arena = AllocatingSwiftArena.ofConfined()) {
             var c = MySwiftClass.init(1, 2, arena);
-            byte got = c.takeUnsignedByte(UnsignedByte.valueOf(200)); // FIXME: should return UnsignedByte
-            assertEquals(UnsignedByte.representedByBitsOf(got).intValue(), got);
+            c.takeUnsignedLong(UnsignedLong.MAX_VALUE);
         }
     }
 }

SwiftKitCore/src/main/java/org/swift/swiftkit/core/Preconditions.java

@@ -0,0 +1,153 @@
+/*
+ * Copyright (C) 2007 The Guava 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.
+ */
+
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2024 Apple Inc. and the Swift.org project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of Swift.org project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+package org.swift.swiftkit.core;
+
+import org.swift.swiftkit.core.annotations.Nullable;
+
+/**
+ * Collection of convenience functions to check argument preconditions.
+ * <p/>
+ * Partially based on {@code com.google.common.base.Preconditions}.
+ */
+public final class Preconditions {
+    private Preconditions() {
+    }
+
+    public static void checkArgument(boolean expression) {
+        if (!expression) {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    public static void checkArgument(boolean expression, @Nullable String format) {
+        if (!expression) {
+            throw new IllegalArgumentException(format);
+        }
+    }
+
+    public static void checkArgument(boolean expression, @Nullable String format,
+                                     @Nullable Object arg1) {
+        if (!expression) {
+            throw new IllegalArgumentException(String.format(format, arg1));
+        }
+    }
+
+    public static void checkArgument(boolean expression, @Nullable String format,
+                                     @Nullable Object arg1,
+                                     @Nullable Object arg2) {
+        if (!expression) {
+            throw new IllegalArgumentException(String.format(format, arg1, arg2));
+        }
+    }
+
+    public static <T> T checkNotNull(@Nullable T reference) {
+        if (reference == null) {
+            throw new NullPointerException();
+        }
+
+        return reference;
+    }
+
+    public static <T> T checkNotNull(@Nullable T reference, @Nullable String message) {
+        if (reference == null) {
+            throw new NullPointerException(message);
+        }
+
+        return reference;
+    }
+
+    /*
+     * All recent hotspots (as of 2009) *really* like to have the natural code
+     *
+     * if (guardExpression) {
+     *    throw new BadException(messageExpression);
+     * }
+     *
+     * refactored so that messageExpression is moved to a separate String-returning method.
+     *
+     * if (guardExpression) {
+     *    throw new BadException(badMsg(...));
+     * }
+     *
+     * The alternative natural refactorings into void or Exception-returning methods are much slower.
+     * This is a big deal - we're talking factors of 2-8 in microbenchmarks, not just 10-20%. (This is
+     * a hotspot optimizer bug, which should be fixed, but that's a separate, big project).
+     *
+     * The coding pattern above is heavily used in java.util, e.g. in ArrayList. There is a
+     * RangeCheckMicroBenchmark in the JDK that was used to test this.
+     *
+     * But the methods in this class want to throw different exceptions, depending on the args, so it
+     * appears that this pattern is not directly applicable. But we can use the ridiculous, devious
+     * trick of throwing an exception in the middle of the construction of another exception. Hotspot
+     * is fine with that.
+     */
+
+    /**
+     * Ensures that {@code index} specifies a valid <i>element</i> in an array, list or string of size
+     * {@code size}. An element index may range from zero, inclusive, to {@code size}, exclusive.
+     *
+     * @param index a user-supplied index identifying an element of an array, list or string
+     * @param size the size of that array, list or string
+     * @return the value of {@code index}
+     * @throws IndexOutOfBoundsException if {@code index} is negative or is not less than {@code size}
+     * @throws IllegalArgumentException if {@code size} is negative
+     */
+    public static int checkElementIndex(int index, int size) {
+        return checkElementIndex(index, size, "index");
+    }
+
+    /**
+     * Ensures that {@code index} specifies a valid <i>element</i> in an array, list or string of size
+     * {@code size}. An element index may range from zero, inclusive, to {@code size}, exclusive.
+     *
+     * @param index a user-supplied index identifying an element of an array, list or string
+     * @param size the size of that array, list or string
+     * @param desc the text to use to describe this index in an error message
+     * @return the value of {@code index}
+     * @throws IndexOutOfBoundsException if {@code index} is negative or is not less than {@code size}
+     * @throws IllegalArgumentException if {@code size} is negative
+     */
+    public static int checkElementIndex(int index, int size, String desc) {
+        // Carefully optimized for execution by hotspot (explanatory comment above)
+        if (index < 0 || index >= size) {
+            throw new IndexOutOfBoundsException(
+                    String.format("%s, index:%d, size:%d", desc, index, size));
+        }
+        return index;
+    }
+
+    public static void checkPositionIndexes(int start, int end, int size) {
+        // Carefully optimized for execution by hotspot (explanatory comment above)
+        if (start < 0 || end < start || end > size) {
+            throw new IndexOutOfBoundsException(
+                    String.format("Start index:%d, end index:%d, size: %d", start, end, size));
+        }
+    }
+
+}

SwiftKitCore/src/main/java/org/swift/swiftkit/core/annotations/NonNull.java

@@ -0,0 +1,15 @@
+package org.swift.swiftkit.core.annotations;
+
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.ElementType.TYPE_USE;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+// TODO: Consider depending on jspecify instead
+@Documented
+@Target(TYPE_USE)
+@Retention(RUNTIME)
+public @interface NonNull {}

SwiftKitCore/src/main/java/org/swift/swiftkit/core/annotations/Nullable.java

@@ -0,0 +1,15 @@
+package org.swift.swiftkit.core.annotations;
+
+
+import static java.lang.annotation.ElementType.TYPE_USE;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+// TODO: Consider depending on jspecify instead
+@Documented
+@Target(TYPE_USE)
+@Retention(RUNTIME)
+public @interface Nullable {}