[rust] [rust-server] More abstract functions including integer fitting (OpenAPITools#13503)

* [rust] [rust-server] Abstract Rust Integer fitting

* Add docstrings

Author: jacob-pro

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/AbstractRustCodegen.java

@@ -1,13 +1,17 @@
 package org.openapitools.codegen.languages;
 
+import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Strings;
 import org.openapitools.codegen.CodegenConfig;
 import org.openapitools.codegen.CodegenProperty;
 import org.openapitools.codegen.DefaultCodegen;
+import org.openapitools.codegen.GeneratorLanguage;
 import org.openapitools.codegen.utils.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import javax.annotation.Nullable;
+import java.math.BigInteger;
 import java.util.*;
 import java.util.function.Function;
 
@@ -37,12 +41,106 @@ public AbstractRustCodegen() {
         );
     }
 
+    @Override
+    public GeneratorLanguage generatorLanguage() { return GeneratorLanguage.RUST; }
+
+    @Override
+    public String escapeQuotationMark(String input) {
+        // remove " to avoid code injection
+        return input.replace("\"", "");
+    }
+
+    @Override
+    public String escapeUnsafeCharacters(String input) {
+        return input.replace("*/", "*_/").replace("/*", "/_*");
+    }
+
     @Override
     public boolean isReservedWord(String word) {
         // This is overridden to take account of Rust reserved words being case-sensitive.
         return word != null && reservedWords.contains(word);
     }
 
+    /**
+     * Determine the best fitting Rust type for an integer property. This is intended for use when a specific format
+     * has not been defined in the specification. Where the minimum or maximum is not known then the returned type
+     * will default to having at least 32 bits.
+     * @param minimum The minimum value as set in the specification.
+     * @param exclusiveMinimum If the minimum value itself is excluded by the specification.
+     * @param maximum The maximum value as set in the specification.
+     * @param exclusiveMaximum If the maximum value itself is excluded by the specification.
+     * @param preferUnsigned Use unsigned types where the effective minimum is greater than or equal to zero.
+     * @return The Rust data type name.
+     */
+    @VisibleForTesting
+    public String bestFittingIntegerType(@Nullable BigInteger minimum,
+                                  boolean exclusiveMinimum,
+                                  @Nullable BigInteger maximum,
+                                  boolean exclusiveMaximum,
+                                  boolean preferUnsigned) {
+        if (exclusiveMinimum) {
+            minimum = Optional.ofNullable(minimum).map(min -> min.add(BigInteger.ONE)).orElse(null);
+        }
+        if (exclusiveMaximum) {
+            maximum = Optional.ofNullable(maximum).map(max -> max.subtract(BigInteger.ONE)).orElse(null);
+        }
+
+        // If the minimum value is greater than or equal to zero, then it is safe to use an unsigned type
+        boolean guaranteedPositive = Optional.ofNullable(minimum).map(min -> min.signum() >= 0).orElse(false);
+
+        int requiredBits = Math.max(
+                Optional.ofNullable(minimum).map(BigInteger::bitLength).orElse(0),
+                Optional.ofNullable(maximum).map(BigInteger::bitLength).orElse(0)
+        );
+
+        // We will only enable the smaller types (less than 32 bits) if we know both the minimum and maximum
+        boolean knownRange = !(Objects.isNull(minimum) || Objects.isNull(maximum));
+
+        if (guaranteedPositive && preferUnsigned) {
+            if (requiredBits <= 8 && knownRange) {
+                return "u8";
+            } else if (requiredBits <= 16 && knownRange) {
+                return "u16";
+            } else if (requiredBits <= 32) {
+                return "u32";
+            } else if (requiredBits <= 64) {
+                return "u64";
+            } else if (requiredBits <= 128) {
+                return "u128";
+            }
+        } else {
+            if (requiredBits <= 7 && knownRange) {
+                return "i8";
+            } else if (requiredBits <= 15 && knownRange) {
+                return "i16";
+            } else if (requiredBits <= 31) {
+                return "i32";
+            } else if (requiredBits <= 63) {
+                return "i64";
+            } else if (requiredBits <= 127) {
+                return "i128";
+            }
+        }
+
+        throw new RuntimeException("Number is too large to fit into i128");
+    }
+
+    /**
+     * Determine if an integer property can be guaranteed to fit into an unsigned data type.
+     * @param minimum The minimum value as set in the specification.
+     * @param exclusiveMinimum If boundary values are excluded by the specification.
+     * @return True if the effective minimum is greater than or equal to zero.
+     */
+    @VisibleForTesting
+    public boolean canFitIntoUnsigned(@Nullable BigInteger minimum, boolean exclusiveMinimum) {
+        return Optional.ofNullable(minimum).map(min -> {
+            if (exclusiveMinimum) {
+                min = min.add(BigInteger.ONE);
+            }
+            return min.signum() >= 0;
+        }).orElse(false);
+    }
+
     public enum CasingType {CAMEL_CASE, SNAKE_CASE};
 
     /**

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/RustClientCodegen.java

@@ -23,6 +23,7 @@
 import io.swagger.v3.oas.models.media.Schema;
 import io.swagger.v3.oas.models.media.StringSchema;
 import io.swagger.v3.parser.util.SchemaTypeUtil;
+import joptsimple.internal.Strings;
 import org.openapitools.codegen.*;
 import org.openapitools.codegen.meta.features.*;
 import org.openapitools.codegen.model.ModelMap;
@@ -38,6 +39,7 @@
 import java.io.IOException;
 import java.io.Writer;
 import java.math.BigDecimal;
+import java.math.BigInteger;
 import java.util.*;
 
 import static org.openapitools.codegen.utils.StringUtils.camelize;
@@ -66,7 +68,6 @@ public class RustClientCodegen extends AbstractRustCodegen implements CodegenCon
     protected String modelDocPath = "docs/";
     protected String apiFolder = "src/apis";
     protected String modelFolder = "src/models";
-    protected Map<String, String> unsignedMapping;
 
     public CodegenType getTag() {
         return CodegenType.CLIENT;
@@ -160,12 +161,6 @@ public RustClientCodegen() {
         typeMapping.put("object", "serde_json::Value");
         typeMapping.put("AnyType", "serde_json::Value");
 
-        unsignedMapping = new HashMap<>();
-        unsignedMapping.put("i8", "u8");
-        unsignedMapping.put("i16", "u16");
-        unsignedMapping.put("i32", "u32");
-        unsignedMapping.put("i64", "u64");
-
         // no need for rust
         //importMapping = new HashMap<String, String>();
 
@@ -455,38 +450,33 @@ public String getSchemaType(Schema p) {
         String schemaType = super.getSchemaType(p);
         String type = typeMapping.getOrDefault(schemaType, schemaType);
 
-        boolean bestFit = convertPropertyToBoolean(BEST_FIT_INT);
-        boolean unsigned = convertPropertyToBoolean(PREFER_UNSIGNED_INT);
-
-        if (bestFit || unsigned) {
-            BigDecimal maximum = p.getMaximum();
-            BigDecimal minimum = p.getMinimum();
-
-            try {
-              if (maximum != null && minimum != null) {
-                  long max = maximum.longValueExact();
-                  long min = minimum.longValueExact();
-
-                  if (unsigned && bestFit && max <= (Byte.MAX_VALUE * 2) + 1 && min >= 0) {
-                      type = "u8";
-                  } else if (bestFit && max <= Byte.MAX_VALUE && min >= Byte.MIN_VALUE) {
-                      type = "i8";
-                  } else if (unsigned && bestFit && max <= (Short.MAX_VALUE * 2) + 1 && min >= 0) {
-                      type = "u16";
-                  } else if (bestFit && max <= Short.MAX_VALUE && min >= Short.MIN_VALUE) {
-                      type = "i16";
-                  } else if (unsigned && bestFit && max <= (Integer.MAX_VALUE * 2L) + 1 && min >= 0) {
-                      type = "u32";
-                  } else if (bestFit && max <= Integer.MAX_VALUE && min >= Integer.MIN_VALUE) {
-                      type = "i32";
-                  }
-              }
-            } catch (ArithmeticException a) {
-                // no-op; case will be handled in the next if block
-            }
+        if (Objects.equals(p.getType(), "integer")) {
+            boolean bestFit = convertPropertyToBoolean(BEST_FIT_INT);
+            boolean preferUnsigned = convertPropertyToBoolean(PREFER_UNSIGNED_INT);
+
+            BigInteger minimum = Optional.ofNullable(p.getMinimum()).map(BigDecimal::toBigInteger).orElse(null);
+            boolean exclusiveMinimum = Optional.ofNullable(p.getExclusiveMinimum()).orElse(false);
 
-            if (unsigned && minimum != null && minimum.compareTo(BigDecimal.ZERO) >= 0 && unsignedMapping.containsKey(type)) {
-                type = unsignedMapping.get(type);
+            boolean unsigned = preferUnsigned && canFitIntoUnsigned(minimum, exclusiveMinimum);
+
+            if (Strings.isNullOrEmpty(p.getFormat())) {
+                if (bestFit) {
+                    return bestFittingIntegerType(
+                            minimum,
+                            exclusiveMinimum,
+                            Optional.ofNullable(p.getMaximum()).map(BigDecimal::toBigInteger).orElse(null),
+                            Optional.ofNullable(p.getExclusiveMaximum()).orElse(false),
+                            preferUnsigned);
+                } else {
+                    return unsigned ? "u32" : "i32";
+                }
+            } else {
+                switch (p.getFormat()) {
+                    case "int32":
+                        return unsigned ? "u32" : "i32";
+                    case "int64":
+                        return unsigned ? "u64" : "i64";
+                }
             }
         }
 
@@ -564,12 +554,6 @@ public OperationsMap postProcessOperationsWithModels(OperationsMap objs, List<Mo
         return objs;
     }
 
-    @Override
-    protected boolean needToImport(String type) {
-        return !defaultIncludes.contains(type)
-                && !languageSpecificPrimitives.contains(type);
-    }
-
     public void setPackageName(String packageName) {
         this.packageName = packageName;
     }
@@ -578,17 +562,6 @@ public void setPackageVersion(String packageVersion) {
         this.packageVersion = packageVersion;
     }
 
-    @Override
-    public String escapeQuotationMark(String input) {
-        // remove " to avoid code injection
-        return input.replace("\"", "");
-    }
-
-    @Override
-    public String escapeUnsafeCharacters(String input) {
-        return input.replace("*/", "*_/").replace("/*", "/_*");
-    }
-
     @Override
     public String toDefaultValue(Schema p) {
         if (p.getDefault() != null) {
@@ -598,6 +571,4 @@ public String toDefaultValue(Schema p) {
         }
     }
 
-    @Override
-    public GeneratorLanguage generatorLanguage() { return GeneratorLanguage.RUST; }
 }