Inconsistency between Remotable rules and InterfaceGuard pattern language

[erights]

(Originally reported at Agoric/agoric-sdk#8231 )

https://github.com/Agoric/agoric-sdk/blob/61b6c39a7c8cedf7c7b11a5f5352d82f351e5657/packages/notifier/src/publish-kit.js#L48-L53

 export const IterableEachTopicI = M.interface('IterableEachTopic', { 
   subscribeAfter: SubscriberI.methodGuards.subscribeAfter, 
   [Symbol.asyncIterator]: M.call().returns( 
     M.remotable('ForkableAsyncIterableIterator'), 
   ), 
 }); 

Remotables are allowed to have symbol-named methods. (The particular case that is already important for us is Symbol.asyncIterator as we see here.)

InterfaceGuards are supposed to be Passable descriptions of the API of an exo, including the guards and methods used do the first level of input validation of the exo's methods. The InterfaceGuard uses a CopyRecord of method guards, where each property name of that CopyRecord is supposed to be the name of the method being described/guarded.

However, a CopyRecord can only have string-named properties. Therefore, there is currently no way for an InterfaceGuard to provide a MethodGuard for describing/guarding a symbol-named method.

[gibson042]

Anticipated fix foundation: update makeInterfaceGuard per Agoric/agoric-sdk#8232 (review)

 export const assertInterfaceGuard = specimen => {
   mustMatch(specimen, InterfaceGuardShape, 'interfaceGuard');
 };
 harden(assertInterfaceGuard);
+
+const { comparator: passableComparator } = makeComparatorKit();
 
 /**
  * @param {string} interfaceName
  * @param {Record<string, MethodGuard>} methodGuards
  * @param {{sloppy?: boolean}} [options]
  * @returns {InterfaceGuard}
  */
 const makeInterfaceGuard = (interfaceName, methodGuards, options = {}) => {
   const { sloppy = false } = options;
+  const stringMethodGuards = {};
+  const symbolMethodGuardsEntries = [];
+  for (const key of ownKeys(methodGuards)) {
+    const value = methodGuards[key];
+    if (typeof key === 'symbol') {
+      symbolMethodGuardsEntries.push([key, value]);
+    } else {
+      stringMethodGuards[key] = value;
+    }
+  }
+  // Ensure a consistent order.
+  symbolMethodGuardsEntries.sort(([k1], [k2]) => passableComparator(k1, k2));
   /** @type {InterfaceGuard} */
   const result = harden({
     klass: 'Interface',
     interfaceName,
-    methodGuards,
+    methodGuards: stringMethodGuards,
+    symbolMethodGuards: symbolMethodGuardsEntries,
     sloppy,
   });
   assertInterfaceGuard(result);
   return result;
 };