fix: avoid linear objectHas scans for large inline imports (#1070)

Motivation:
PR #1061 was closed against the obsolete `fixjson` base, but the issue
still needs a clean PR on the current upstream `master`. PR #1060 added
the `InlineScanMax` fallback for `valueRaw`, yet repeated
`std.objectHas` / `std.objectHasAll` checks over large imported
strict-JSON objects still reached `containsVisibleKey` / `containsKey`
and scanned uncapped inline field arrays. That kept membership-heavy
workloads at O(N^2).

Modification:
- Rebase the PR #1061 follow-up onto current `upstream/master`
(`1db39dde`).
- Apply `Obj.InlineScanMax` to `Val.Obj.containsKey` and
`Val.Obj.containsVisibleKey`, so large inline objects fall through to
the existing lazy `getValue0` `LinkedHashMap` path.
- Reuse `Obj.InlineScanMax` in inline-object producers, keeping
construction and lookup thresholds on one source of truth.
- Add a benchmark regression covering repeated `std.objectHas` /
`std.objectHasAll` calls over imported JSON object fields.

Result:
| Benchmark | Current `master` | This branch | Change |
| --- | ---: | ---: | ---: |
| repeated `std.objectHas` / `std.objectHasAll` over large imported JSON
object fields | `97.942 ms/op` | `21.117 ms/op` | `4.64x` faster
(`-78%`) |

Large inline imported objects now pay one lazy map build above the scan
threshold, then reuse O(1) map probes for repeated membership checks.
Small inline objects keep the cheap linear scan path.

References:
- Replaces #1061.
- Follow-up to #1060.

Author: He-Pin

bench/resources/sjsonnet_suite/json_import_object_has.jsonnet

@@ -0,0 +1,13 @@
+// Regression guard for large imported JSON objects queried repeatedly via objectHas/objectHasAll.
+// Large imported objects may use uncapped inline arrays, so repeated membership checks must use
+// the cached lookup map above the inline scan threshold instead of doing O(N) scans per key.
+local data = import "json_import_merge_data.json";
+std.assertEqual(
+  [
+    std.length([k for k in std.objectFields(d) if std.objectHas(d, k)]) +
+    std.length([k for k in std.objectFieldsAll(d) if std.objectHasAll(d, k)]) +
+    (if std.objectHas(d, "missing") || std.objectHasAll(d, "missing") then 1 else 0)
+    for d in data
+  ],
+  [2000 for d in data]
+)

bench/resources/sjsonnet_suite/json_import_object_has.jsonnet.golden

@@ -0,0 +1 @@
+true

sjsonnet/src/sjsonnet/Evaluator.scala

@@ -1783,7 +1783,7 @@ class Evaluator(
     var inlineKeys: Array[String] = null
     var inlineMembers: Array[Val.Obj.Member] = null
     var fieldCount = 0
-    val maxInlineFields = 8
+    val maxInlineFields = Val.Obj.InlineScanMax
 
     // Shared field-tracking logic: manages singleKey → inlineKeys → builder transitions.
     // Handles duplicate key detection at each tier.

sjsonnet/src/sjsonnet/Val.scala

@@ -1816,12 +1816,11 @@ object Val {
     private[sjsonnet] var currentDebugStats: DebugStats = _
 
     /**
-     * Field count at/below which `valueRaw` resolves an inline-array object by linear scan. Above
-     * it (e.g. large imported strict-JSON objects, whose inline arrays are uncapped — see
-     * Importer), `valueRaw` instead lazily builds the `value0` LinkedHashMap via `getValue0` for
-     * O(1) lookups. This keeps the scan for small objects (and never builds a map for the
-     * import-and-emit path, which materializes via direct inline iteration) while avoiding O(N^2)
-     * when a large imported object gains a `super` and must be resolved per-key.
+     * Field count at/below which inline-array object key lookups use a linear scan. Above it (e.g.
+     * large imported strict-JSON objects, whose inline arrays are uncapped — see Importer), lookups
+     * lazily build the `value0` LinkedHashMap via `getValue0` for O(1) probes. This keeps the scan
+     * for small objects (and never builds a map for the import-and-emit path, which materializes
+     * via direct inline iteration) while avoiding O(N^2) repeated per-key lookups.
      */
     private[sjsonnet] final val InlineScanMax = 8
 
@@ -2301,7 +2300,9 @@ object Val {
 
     @inline def containsKey(k: String): Boolean = {
       if (singleFieldKey != null && `super` == null) singleFieldKey.equals(k)
-      else if (inlineFieldKeys != null && `super` == null) {
+      else if (
+        inlineFieldKeys != null && `super` == null && inlineFieldKeys.length <= Obj.InlineScanMax
+      ) {
         val keys = inlineFieldKeys
         val n = keys.length
         var i = 0
@@ -2319,7 +2320,7 @@ object Val {
     @inline def containsVisibleKey(k: String): Boolean = {
       if (static || `super` != null) {
         getAllKeys.get(k) == java.lang.Boolean.FALSE
-      } else if (inlineFieldKeys != null) {
+      } else if (inlineFieldKeys != null && inlineFieldKeys.length <= Obj.InlineScanMax) {
         val keys = inlineFieldKeys
         val members = inlineFieldMembers
         val n = keys.length

sjsonnet/src/sjsonnet/stdlib/ObjectModule.scala

@@ -209,7 +209,7 @@ object ObjectModule extends AbstractFunctionModule {
           singleFieldKey = keys(0),
           singleFieldMember = new MapWithKeyMember(func, obj, keys(0), pos)
         )
-      } else if (n <= 8) {
+      } else if (n <= Val.Obj.InlineScanMax) {
         val members = new Array[Val.Obj.Member](n)
         var i = 0
         while (i < n) {