SPM: stop corrupting a one-line array build setting

addArrayStringValues' "already an array" branch assumed the array was
multi-line: it anchored on `lastIndexOf('\n', tokenEnd - 1)`. For a single-line
array there is no newline inside the value, so that lands at the end of the
PREVIOUS line and the new members were spliced above the field — outside the
array, as a bare entry in the dict body:

    {
    		"/new",                             <- invalid pbxproj
    	HEADER_SEARCH_PATHS = ("/vendor", );    <- member never added
    	OTHER = 1;
    }

One `spm add` against such a project produced a file Xcode cannot open, and
because removeArrayStringValues only searches inside the field's value region,
`deinit` could never remove the stray line. Xcode writes multi-line arrays, but
hand-edited projects and other generators (XcodeGen, Tuist) emit compact ones.

Splice the members inline ahead of the `)` instead, matching the separator style
already present and honouring an existing trailing comma. Reformatting to
multi-line would change the user's formatting and would need the old shape
recorded to stay reversible, for no benefit. removeArrayStringValues gains
delimiter-anchored patterns for the shapes `add` can now produce, so the span
removed is exactly the span inserted and every shape round-trips byte-for-byte.

The dedupe parse was also quote-blind: it split members on every `,`, so a
member holding a quoted comma (`"$(FOO(x)),weird"`) parsed as two tokens and
defeated the exact-token short-circuit. It now uses a quote-aware splitter.

The multi-line path is unchanged byte-for-byte, verified by a differential
harness against the previous implementation over 48 add/remove cases, plus a
test pinning its exact output bytes.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: chrfalch

packages/react-native/scripts/spm/__tests__/inject-spm-xcodeproj-test.js

@@ -29,10 +29,10 @@ const PODS = PLAIN.replace(
   'AA0000000000000000000901 /* Debug */ = {\n\t\t\tisa = XCBuildConfiguration;\n\t\t\tbaseConfigurationReference = BB0000000000000000000001 /* Pods-MyApp.debug.xcconfig */;\n\t\t\tbuildSettings = {',
 );
 
-// Derive a variant whose app-target configs already carry HEADER_SEARCH_PATHS
-// as a plain scalar (ordinary, valid pbxproj) — the state injection promotes to
-// an array.
-function withScalarHeaderSearchPaths(value) {
+// Derive a variant whose app-target configs already carry HEADER_SEARCH_PATHS,
+// set to any valid pbxproj value: a plain scalar (which injection promotes to an
+// array) or an array injection appends to.
+function withHeaderSearchPaths(value) {
   return PLAIN.replaceAll(
     'PRODUCT_BUNDLE_IDENTIFIER = com.example.MyApp;',
     `HEADER_SEARCH_PATHS = ${value};\n\t\t\t\tPRODUCT_BUNDLE_IDENTIFIER = com.example.MyApp;`,
@@ -253,7 +253,7 @@ describe('injectSpmIntoPbxproj — Tier 2 (build settings + phase)', () => {
   ])(
     'promotes a pre-existing HEADER_SEARCH_PATHS scalar (%s) to an array, keeping its value and one $(inherited)',
     (scalar, expectedMembers) => {
-      const {text} = inject(withScalarHeaderSearchPaths(scalar));
+      const {text} = inject(withHeaderSearchPaths(scalar));
       const arrays = [
         ...text.matchAll(/HEADER_SEARCH_PATHS = \(\n([\s\S]*?)\t+\);/g),
       ].map(m =>
@@ -267,6 +267,20 @@ describe('injectSpmIntoPbxproj — Tier 2 (build settings + phase)', () => {
     },
   );
 
+  it('appends to a pre-existing ONE-LINE HEADER_SEARCH_PATHS array in place', () => {
+    const {text} = inject(withHeaderSearchPaths('("$(inherited)", )'));
+    expect(isBalanced(text)).toBe(true);
+    const arrays = [
+      ...text.matchAll(/HEADER_SEARCH_PATHS = \(([^\n]*)\);/g),
+    ].map(m => m[1]);
+    // Both app-target configs, each keeping the one-line shape it was written in.
+    expect(arrays).toEqual(
+      Array(2).fill(
+        '"$(inherited)", "$(SRCROOT)/build/generated/autolinking/headers", ',
+      ),
+    );
+  });
+
   it('adds one generated embed phase immediately after Frameworks', () => {
     const {text} = inject(PLAIN);
     expect(text).not.toContain('Fix SPM Embedded Flavor');

packages/react-native/scripts/spm/__tests__/remove-spm-injection-test.js

@@ -42,6 +42,8 @@ const PRE_EXISTING_HEADER_SEARCH_PATHS = {
   'a bare $(inherited) scalar': '"$(inherited)"',
   'a scalar with real content': '"$(inherited) $(SRCROOT)/vendor/include"',
   'an array': '(\n\t\t\t\t"$(inherited)",\n\t\t\t)',
+  // What hand edits and other generators (XcodeGen, Tuist) write.
+  'a one-line array': '("$(inherited)", )',
 };
 
 // Seed a whole `KEY = value;` field (comments and stray whitespace included)

packages/react-native/scripts/spm/__tests__/spm-pbxproj-test.js

@@ -41,6 +41,19 @@ const PLAIN_PBXPROJ = fs.readFileSync(
   'utf8',
 );
 
+// The app target's Debug buildSettings dict, as a body range.
+function targetDebugDict(text) {
+  const cfg = findObjectByUuid(text, 'AA0000000000000000000901');
+  const bs = findField(text, cfg, 'buildSettings');
+  return {uuid: 'x', bodyOpen: bs.valueStart, bodyClose: bs.tokenEnd - 1};
+}
+
+// Delimiter balance, checked with the module's own quote-aware scanner: the
+// outermost `{` must close on the file's last `}`.
+function isBalanced(text) {
+  return scanToClose(text, text.indexOf('{')) === text.lastIndexOf('}');
+}
+
 // ---------------------------------------------------------------------------
 // generateUUID
 // ---------------------------------------------------------------------------
@@ -161,12 +174,6 @@ describe('addArrayMembers', () => {
 });
 
 describe('addArrayStringValues', () => {
-  function targetDebugDict(text) {
-    const cfg = findObjectByUuid(text, 'AA0000000000000000000901');
-    const bs = findField(text, cfg, 'buildSettings');
-    return {uuid: 'x', bodyOpen: bs.valueStart, bodyClose: bs.tokenEnd - 1};
-  }
-
   it('creates an array seeded with $(inherited)', () => {
     const out = addArrayStringValues(
       PLAIN_PBXPROJ,
@@ -270,6 +277,102 @@ describe('addArrayStringValues', () => {
   });
 });
 
+// Xcode writes array build settings multi-line, but hand-edited projects and
+// other generators (XcodeGen, Tuist) emit compact one-line ones. Members must
+// land INSIDE the array whatever its shape, and `deinit` must be able to take
+// them back out again — hence the byte-identical add→remove round trip.
+describe('array build settings of every written shape', () => {
+  const NEW = '"/new"';
+
+  // Seed `OTHER_LDFLAGS = <value>;` into the app target's Debug config.
+  function withValue(value) {
+    return PLAIN_PBXPROJ.replace(
+      '\t\t\t\tPRODUCT_NAME = "$(TARGET_NAME)";',
+      `\t\t\t\tOTHER_LDFLAGS = ${value};\n\t\t\t\tPRODUCT_NAME = "$(TARGET_NAME)";`,
+    );
+  }
+
+  function add(text, values) {
+    return addArrayStringValues(
+      text,
+      targetDebugDict(text),
+      'OTHER_LDFLAGS',
+      values,
+    );
+  }
+
+  function remove(text, values) {
+    return removeArrayStringValues(
+      text,
+      targetDebugDict(text),
+      'OTHER_LDFLAGS',
+      values,
+    );
+  }
+
+  describe.each([
+    ['an empty array', '()'],
+    ['a lone member with no trailing comma', '("/a")'],
+    ['a trailing comma and space', '("/a", )'],
+    ['no space after the comma', '("/a","/b")'],
+    ['a space after the comma', '("/a", "/b")'],
+    ['a member whose quotes hold a comma and parens', '("$(FOO(x)),weird")'],
+    ['the multi-line shape Xcode writes', '(\n\t\t\t\t\t"/a",\n\t\t\t\t)'],
+  ])('%s', (_label, shape) => {
+    const input = withValue(shape);
+
+    it('adds the value inside the array, leaving the file balanced', () => {
+      const out = add(input, [NEW]);
+      const field = findField(out, targetDebugDict(out), 'OTHER_LDFLAGS');
+      expect(field.value.trimStart().startsWith('(')).toBe(true);
+      expect(field.value).toContain(NEW);
+      // Nothing was spliced ahead of the field — i.e. outside the array.
+      expect(out.slice(0, field.matchStart)).toBe(
+        input.slice(0, field.matchStart),
+      );
+      expect(isBalanced(out)).toBe(true);
+    });
+
+    it.each([[[NEW]], [[NEW, '"/new2"']]])(
+      'remove undoes add of %j byte-for-byte',
+      values => {
+        const added = add(input, values);
+        expect(added).not.toBe(input);
+        expect(remove(added, values)).toBe(input);
+      },
+    );
+  });
+
+  it.each([
+    ['a value that is not there', '("/a", )', '"/zzz"'],
+    ['a member stripped of its quotes', '("$(inherited)", )', '$(inherited)'],
+  ])('removes nothing when asked for %s', (_label, shape, value) => {
+    const input = withValue(shape);
+    expect(remove(input, [value])).toBe(input);
+  });
+
+  it('is a no-op when a one-line array already holds the value', () => {
+    const input = withValue(`(${NEW})`);
+    expect(add(input, [NEW])).toBe(input);
+  });
+
+  it('dedupes a member whose quotes hold a comma', () => {
+    const weird = '"$(FOO(x)),weird"';
+    const input = withValue(`(${weird}, )`);
+    expect(add(input, [weird])).toBe(input);
+  });
+
+  it('splices a multi-line array on its own line, before the closing `)`', () => {
+    const input = withValue('(\n\t\t\t\t\t"/a",\n\t\t\t\t)');
+    expect(add(input, [NEW])).toBe(
+      input.replace(
+        '\t\t\t\t\t"/a",\n',
+        `\t\t\t\t\t"/a",\n\t\t\t\t\t${NEW},\n`,
+      ),
+    );
+  });
+});
+
 describe('ensureScalarField', () => {
   it('adds a scalar only when absent', () => {
     const project = findProjectObject(PLAIN_PBXPROJ);

packages/react-native/scripts/spm/spm-pbxproj.js

@@ -367,6 +367,38 @@ function addArrayMembers(
   return text.slice(0, obj.bodyOpen + 1) + block + text.slice(obj.bodyOpen + 1);
 }
 
+/**
+ * Indices of the `,` separators at an array's top level — a comma inside a
+ * quoted member (`"$(FOO),weird"`) separates nothing.
+ */
+function topLevelCommas(inner /*: string */) /*: Array<number> */ {
+  const out = [];
+  for (let i = 0; i < inner.length; i++) {
+    if (inner[i] === '"') {
+      i = scanString(inner, i);
+    } else if (inner[i] === ',') {
+      out.push(i);
+    }
+  }
+  return out;
+}
+
+/**
+ * The members of an array's inner text (what sits between its parens), trimmed
+ * and with empty slots — e.g. the one a trailing comma leaves — dropped. A bare
+ * scalar value parses as its own single member.
+ */
+function arrayMembers(inner /*: string */) /*: Array<string> */ {
+  const members = [];
+  let start = 0;
+  for (const comma of topLevelCommas(inner)) {
+    members.push(inner.slice(start, comma));
+    start = comma + 1;
+  }
+  members.push(inner.slice(start));
+  return members.map(m => m.trim()).filter(m => m !== '');
+}
+
 /**
  * Append raw string values to a `( … )` array build-setting (e.g.
  * OTHER_LDFLAGS), deduping by exact token. Creates the setting seeded with
@@ -385,26 +417,45 @@ function addArrayStringValues(
 
   const field = findField(text, obj, key);
   if (field != null) {
+    const isArray = field.value.trimStart().startsWith('(');
+    const openParen = isArray
+      ? field.valueStart + field.value.indexOf('(')
+      : -1;
+    const closeParen = isArray ? scanToClose(text, openParen) : -1;
+    const inner = isArray ? text.slice(openParen + 1, closeParen) : field.value;
     // Dedup by EXACT existing member, not substring — a substring check would
     // treat `"-ObjC"` as already present when only `"-ObjCFoo"` is there (and
-    // vice-versa). Parse the current members (array `( … )` or bare scalar).
-    const existingMembers = new Set(
-      field.value
-        .replace(/^\s*\(/, '')
-        .replace(/\)\s*$/, '')
-        .split(',')
-        .map(s => s.trim())
-        .filter(s => s.length > 0),
-    );
+    // vice-versa).
+    const existingMembers = new Set(arrayMembers(inner));
     const fresh = values.filter(v => !existingMembers.has(v));
     if (fresh.length === 0) {
       return text;
     }
-    if (field.value.trimStart().startsWith('(')) {
-      // Existing array — splice fresh members before the closing `)`.
-      const lineStart = text.lastIndexOf('\n', field.tokenEnd - 1) + 1;
-      const lines = fresh.map(v => `${memberIndent}${v},\n`).join('');
-      return text.slice(0, lineStart) + lines + text.slice(lineStart);
+    if (isArray) {
+      if (inner.includes('\n')) {
+        // Multi-line array — one member per line, before the closing `)`.
+        const lineStart = text.lastIndexOf('\n', closeParen) + 1;
+        const lines = fresh.map(v => `${memberIndent}${v},\n`).join('');
+        return text.slice(0, lineStart) + lines + text.slice(lineStart);
+      }
+      // One-line array (hand-edited projects, XcodeGen, Tuist) — splice the
+      // members in ahead of the `)`, in the separator style already there.
+      // Reformatting it multi-line instead would have to record the old shape
+      // to stay reversible on deinit.
+      const commas = topLevelCommas(inner);
+      const gapMatch =
+        commas.length > 0 ? /^[\t ]*/.exec(inner.slice(commas[0] + 1)) : null;
+      const gap = gapMatch != null ? gapMatch[0] : ' ';
+      const core = inner.replace(/[\t ]+$/, '');
+      const joined = fresh.join(`,${gap}`);
+      const insertion =
+        core === ''
+          ? joined
+          : core.endsWith(',')
+            ? `${gap}${joined},`
+            : `,${gap}${joined}`;
+      const at = openParen + 1 + core.length;
+      return text.slice(0, at) + insertion + text.slice(at);
     }
     // Existing scalar — promote to an array preserving the prior value. Skip it
     // when it IS the `"$(inherited)"` the array is seeded with (emitted twice),
@@ -537,6 +588,33 @@ function removeField(
   return text.slice(0, f.matchStart) + text.slice(f.tokenEnd + 1);
 }
 
+/**
+ * Drop one member from an array field's value text. The patterns mirror the
+ * forms addArrayStringValues inserts, tried in the order that makes the span
+ * removed exactly the span it added: a line of its own (multi-line array), then
+ * after a comma, before a comma, or alone ahead of the `)` (the one-line
+ * shapes). Each is anchored on a delimiter, so a value that is merely a prefix
+ * of a longer member is never mistaken for it.
+ */
+function removeArrayMember(
+  region /*: string */,
+  value /*: string */,
+) /*: string */ {
+  const v = escapeRegExp(value);
+  for (const pattern of [
+    `\\n[\\t ]*${v},`,
+    `,[\\t ]*${v}(?=[\\t ]*[,)])`,
+    `[\\t ]*${v},[\\t ]*`,
+    `[\\t ]*${v}(?=[\\t ]*\\))`,
+  ]) {
+    const shorter = region.replace(new RegExp(pattern), '');
+    if (shorter !== region) {
+      return shorter;
+    }
+  }
+  return region;
+}
+
 /**
  * Remove specific raw string members from an existing `( … )` array field
  * (inverse of addArrayStringValues' append branch). Leaves the field and any
@@ -554,7 +632,7 @@ function removeArrayStringValues(
   }
   let region = text.slice(f.valueStart, f.tokenEnd);
   for (const val of values) {
-    region = region.replace(new RegExp(`\\n[\\t ]*${escapeRegExp(val)},`), '');
+    region = removeArrayMember(region, val);
   }
   return text.slice(0, f.valueStart) + region + text.slice(f.tokenEnd);
 }