NativeImageSize constants are more visible, and platform specific

Author: Akirathan

project/GraalVM.scala

@@ -72,6 +72,40 @@ object GraalVM {
     def release               = native && !test && !debug && !fast && !disableLanguageServer
   }
 
+  case class NativeImageSize(
+    minMb: Int,
+    maxMb: Int
+  )
+
+  object NativeImageSize {
+    def expectedSizeForCurrentPlatform(): NativeImageSize = {
+      if (EnsoLauncher.release) {
+        if (Platform.isWindows) {
+          windowsX64Release
+        } else if (Platform.isLinux) {
+          linuxX64Release
+        } else if (Platform.isMacOS && Platform.isAmd64) {
+          macX64Release
+        } else if (Platform.isMacOS && Platform.isArm64) {
+          macARM64Release
+        } else {
+          throw new IllegalArgumentException("Unexpected platform")
+        }
+      } else {
+        testNISize
+      }
+    }
+
+    // Expected production NI sizes deduced from sizes on latest
+    // nightly builds: https://github.com/enso-org/enso/pull/12996#discussion_r2073742680
+    // With maximal size relaxed by 30 MB.
+    private val windowsX64Release = NativeImageSize(200, 420)
+    private val linuxX64Release   = NativeImageSize(200, 463)
+    private val macX64Release     = NativeImageSize(200, 408)
+    private val macARM64Release   = NativeImageSize(200, 423)
+    private val testNISize        = NativeImageSize(100, 550)
+  }
+
   /** Has the user requested to use Espresso for Java interop? */
   private def isEspressoMode(): Boolean =
     "espresso".equals(System.getenv("ENSO_JAVA"))

project/NativeImage.scala

@@ -332,27 +332,21 @@ object NativeImage {
         "Ensure that the dependency on `buildNativeImage` is properly set."
       )
     }
-    val bytes              = generatedBin.attributes.size()
-    val productionNIBounds = (150, 450)
-    val testNIBounds       = (110, 550)
-    val mb                 = bytes / (1024 * 1024)
-    val bounds = if (GraalVM.EnsoLauncher.release) {
-      productionNIBounds
-    } else {
-      testNIBounds
-    }
+    val bytes        = generatedBin.attributes.size()
+    val mb           = bytes / (1024 * 1024)
+    val expectedSize = GraalVM.NativeImageSize.expectedSizeForCurrentPlatform()
     val isInBounds =
-      bounds._1 <= mb && mb <= bounds._2
+      expectedSize.minMb <= mb && mb <= expectedSize.maxMb
     if (!isInBounds) {
       logger.error(
         s"Generated binary $generatedBin has unexpected size: $mb MB. " +
-        s"Expected size is between ${bounds._1} and ${bounds._2} MB."
+        s"Expected size is between ${expectedSize.minMb} and ${expectedSize.maxMb} MB."
       )
       throw new RuntimeException(s"Generated binary $generatedBin is too large")
     } else {
       logger.info(
         s"Generated binary $generatedBin size ($mb MB) " +
-        s"is within the expected size: [${bounds._1}, ${bounds._2}] MB."
+        s"is within the expected size: [${expectedSize.minMb}, ${expectedSize.maxMb}] MB."
       )
     }
   }