@sdeverywhere/compile 0.7.20 → 0.7.22

package/package.json

@@ -1,17 +1,16 @@
 {
   "name": "@sdeverywhere/compile",
-  "version": "0.7.20",
+  "version": "0.7.22",
   "description": "The core Vensim to C compiler for the SDEverywhere tool suite.",
   "type": "module",
   "main": "./src/index.js",
   "dependencies": {
-    "@sdeverywhere/parse": "^0.1.1",
+    "@sdeverywhere/parse": "^0.1.2",
     "bufx": "^1.0.5",
     "byline": "^5.0.0",
     "csv-parse": "^5.3.3",
     "js-yaml": "^3.13.1",
     "ramda": "^0.27.0",
-    "split-string": "^6.0.0",
     "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.2/xlsx-0.20.2.tgz"
   },
   "author": "Climate Interactive",
@@ -32,7 +31,7 @@
     "precommit": "../../scripts/precommit",
     "type-check": "tsc --noEmit -p tsconfig-test.json",
     "test": "vitest run",
-    "test:watch": "vitest",
+    "test:watch": "vitest --hideSkippedTests",
     "test:ci": "vitest run",
     "ci:build": "run-s lint prettier:check type-check test:ci"
   }

package/src/_shared/helpers.js

@@ -3,9 +3,10 @@ import util from 'util'
 import B from 'bufx'
 import { parse as parseCsv } from 'csv-parse/sync'
 import * as R from 'ramda'
-import split from 'split-string'
 import XLSX from 'xlsx'
 
+import { canonicalId, canonicalVarId } from '@sdeverywhere/parse'
+
 // Set true to print a stack trace in vlog
 export const PRINT_VLOG_TRACE = false
 
@@ -40,25 +41,11 @@ export function resetHelperState() {
 }
 
 export let canonicalName = name => {
-  // Format a model variable name into a valid C identifier.
-  return (
-    '_' +
-    name
-      .trim()
-      .replace(/"/g, '_')
-      .replace(/\s+!$/g, '!')
-      .replace(/\s/g, '_')
-      .replace(/,/g, '_')
-      .replace(/-/g, '_')
-      .replace(/\./g, '_')
-      .replace(/\$/g, '_')
-      .replace(/'/g, '_')
-      .replace(/&/g, '_')
-      .replace(/%/g, '_')
-      .replace(/\//g, '_')
-      .replace(/\|/g, '_')
-      .toLowerCase()
-  )
+  // Format a model variable or subscript/dimension name into a valid C identifier.
+  // In the case where you have a full variable name that includes subscripts/dimensions
+  // (e.g., 'Variable name[DimA,B2]'), use `canonicalVensimName` to convert the
+  // base variable name and subscript/dimension parts to canonical form indepdendently.
+  return canonicalId(name)
 }
 export let decanonicalize = name => {
   // Decanonicalize the var name.
@@ -71,9 +58,6 @@ export let decanonicalize = name => {
   }
   return name
 }
-export let cFunctionName = name => {
-  return canonicalName(name).toUpperCase()
-}
 export let isSeparatedVar = v => {
   return v.separationDims.length > 0
 }
@@ -244,22 +228,7 @@ export let readCsv = (pathname, delimiter = ',') => {
 }
 // Convert the var name and subscript names to canonical form separately.
 export let canonicalVensimName = vname => {
-  let result = vname
-  let m = vname.match(/([^[]+)(?:\[([^\]]+)\])?/)
-  if (m) {
-    result = canonicalName(m[1])
-    if (m[2]) {
-      let subscripts = m[2].split(',').map(x => canonicalName(x))
-      result += `[${subscripts.join(',')}]`
-    }
-  }
-  return result
-}
-// Split a model string into an array of equations without the "|" terminator.
-// Allow "|" to occur in quoted variable names across line breaks.
-// Retain the backslash character.
-export let splitEquations = mdl => {
-  return split(mdl, { separator: '|', quotes: ['"'], keep: () => true })
+  return canonicalVarId(vname)
 }
 // Function to map over lists's value and index
 export let mapIndexed = R.addIndex(R.map)

package/src/_shared/subscript.js

@@ -2,7 +2,7 @@ import util from 'util'
 import B from 'bufx'
 import yaml from 'js-yaml'
 import * as R from 'ramda'
-import { canonicalName, asort, vlog } from './helpers.js'
+import { canonicalName, vlog } from './helpers.js'
 
 // A subscript is a dimension or an index.
 // Both have the same properties: model name, canonical name, family, values.
@@ -233,18 +233,6 @@ export function loadSubscriptsFromYaml(yamlSubs) {
     subscripts.set(k, subs[k])
   }
 }
-export function normalizeSubscripts(subscripts) {
-  // Sort a list of subscript names already in canonical form according to the subscript family.
-  let subs = R.map(name => sub(name), subscripts)
-  subs = R.sortBy(R.prop('family'), subs)
-  let normalizedSubs
-  try {
-    normalizedSubs = R.map(R.prop('name'), subs)
-  } catch (e) {
-    console.error(`normalizeSubscripts fails for ${subscripts}`)
-  }
-  return normalizedSubs
-}
 export function extractMarkedDims(subscripts) {
   // Extract all marked dimensions and update subscripts.
   let dims = []
@@ -366,13 +354,3 @@ export function separatedVariableIndex(rhsSub, variable, rhsSubscripts) {
   }
   return null
 }
-// Function to filter canonical dimension names from a list of names
-export let dimensionNames = R.pipe(
-  R.filter(subscript => isDimension(subscript)),
-  asort
-)
-// Function to filter canonical index names from a list of names
-export let indexNames = R.pipe(
-  R.filter(subscript => isIndex(subscript)),
-  asort
-)

package/src/generate/gen-code-c.js

@@ -153,11 +153,19 @@ ${chunkedFunctions('evalLevels', Model.levelVars(), '  // Evaluate levels.')}`
     let setLookupBody
     if (spec.customLookups === true || Array.isArray(spec.customLookups)) {
       setLookupBody = `\
+  Lookup** pLookup = NULL;
   switch (varIndex) {
 ${setLookupImpl(Model.varIndexInfo(), spec.customLookups)}
     default:
       fprintf(stderr, "No lookup found for var index %zu in setLookup\\n", varIndex);
       break;
+  }
+  if (pLookup != NULL) {
+    if (*pLookup == NULL) {
+      *pLookup = __new_lookup(numPoints, /*copy=*/true, points);
+    } else {
+      __set_lookup(*pLookup, numPoints, points);
+    }
   }`
     } else {
       let msg = 'The setLookup function was not enabled for the generated model. '
@@ -200,19 +208,6 @@ void setInputsFromBuffer(double* inputData) {
 ${inputsFromBufferImpl()}
 }
 
-void replaceLookup(Lookup** lookup, double* points, size_t numPoints) {
-  if (lookup == NULL) {
-    return;
-  }
-  if (*lookup != NULL) {
-    __delete_lookup(*lookup);
-    *lookup = NULL;
-  }
-  if (points != NULL) {
-    *lookup = __new_lookup(numPoints, /*copy=*/true, points);
-  }
-}
-
 void setLookup(size_t varIndex, size_t* subIndices, double* points, size_t numPoints) {
 ${setLookupBody}
 }
@@ -441,7 +436,7 @@ ${section(chunk)}
     return inputVars.join('\n')
   }
   function setLookupImpl(varIndexInfo, customLookups) {
-    // Emit `replaceLookup` calls for all lookups and data variables that can be overridden
+    // Emit case statements for all lookups and data variables that can be overridden
     // at runtime
     let includeCase
     if (Array.isArray(customLookups)) {
@@ -467,7 +462,7 @@ ${section(chunk)}
       }
       let c = ''
       c += `    case ${info.varIndex}:\n`
-      c += `      replaceLookup(&${lookupVar}, points, numPoints);\n`
+      c += `      pLookup = &${lookupVar};\n`
       c += `      break;`
       return c
     })

package/src/generate/gen-code-js.js

@@ -251,10 +251,15 @@ ${chunkedFunctions('evalLevels', true, Model.levelVars(), '  // Evaluate levels'
   }
   const varIndex = varSpec.varIndex;
   const subs = varSpec.subscriptIndices;
+  let lookup;
   switch (varIndex) {
 ${setLookupImpl(Model.varIndexInfo(), spec.customLookups)}
     default:
       throw new Error(\`No lookup found for var index \${varIndex} in setLookup\`);
+  }
+  if (lookup) {
+    const size = points ? points.length / 2 : 0;
+    lookup.setData(size, points);
   }`
     } else {
       let msg = 'The setLookup function was not enabled for the generated model. '
@@ -307,7 +312,7 @@ ${customOutputSection(Model.varIndexInfo(), spec.customOutputs)}
     return `\
 /*export*/ function setInputs(valueAtIndex /*: (index: number) => number*/) {${inputsFromBufferImpl()}}
 
-/*export*/ function setLookup(varSpec /*: VarSpec*/, points /*: Float64Array*/) {
+/*export*/ function setLookup(varSpec /*: VarSpec*/, points /*: Float64Array | undefined*/) {
 ${setLookupBody}
 }
 
@@ -517,7 +522,7 @@ ${section(chunk)}
     return inputVars
   }
   function setLookupImpl(varIndexInfo, customLookups) {
-    // Emit `createLookup` calls for all lookups and data variables that can be overridden
+    // Emit case statements for all lookups and data variables that can be overridden
     // at runtime
     let overrideAllowed
     if (Array.isArray(customLookups)) {
@@ -543,7 +548,7 @@ ${section(chunk)}
       }
       let c = ''
       c += `    case ${info.varIndex}:\n`
-      c += `      ${lookupVar} = fns.createLookup(points.length / 2, points);\n`
+      c += `      lookup = ${lookupVar};\n`
       c += `      break;`
       return c
     })

package/src/generate/gen-const-list.js

@@ -1,5 +1,5 @@
 import { cartesianProductOf, cdbl } from '../_shared/helpers.js'
-import { isDimension, normalizeSubscripts, sub } from '../_shared/subscript.js'
+import { isDimension, sub } from '../_shared/subscript.js'
 
 /**
  * Generate code for a single element in a const list definition.
@@ -12,12 +12,10 @@ import { isDimension, normalizeSubscripts, sub } from '../_shared/subscript.js'
 export function generateConstListElement(variable, parsedEqn) {
   // In the "read variables" phase, const lists are expanded into separated variable
   // definitions, so `variable` here will have `subscripts` that represent specific
-  // subscript indices in normalized order (alphabetized by parent dimension/family
-  // name).  However, we need to consult the LHS subscripts/dimensions, which will
-  // be in the original order from the model equation.
+  // subscript indices that are ordered according to the dimension positions from the
+  // variable definition.
   //
-  // In the following example,
-  // we have a 2D variable whose original dimensions are not in normal order:
+  // In the following example, we have a 2D variable whose original dimensions are:
   //   DimA: A1, A2 ~~|
   //   DimB: B1, B2, B3 ~~|
   //   x[DimB, DimA] = 1, 2; 3, 4; 5, 6; ~~|
@@ -53,25 +51,17 @@ export function generateConstListElement(variable, parsedEqn) {
   // order of the dimensions from the equation LHS.
   const origCombos = cartesianProductOf(subIdArrays)
 
-  // Now we have the combinations in original order:
+  // Convert to strings to make matching easier.  Now we have the combinations in
+  // original order.
   //   [_b1,_a1]
   //   [_b1,_a2]
   //   [_b2,_a1]
   //   ...
-  // But we need to put them into normalized order so that we can find the index of
-  // `variable.subscripts` (which is already in normalized order).
-  const normalizedCombos = origCombos.map(normalizeSubscripts)
-
-  // Convert to strings to make matching easier.  Now we have the strings in normalized order:
-  //   [_a1,_b1]
-  //   [_a2,_b1]
-  //   [_a1,_b2]
-  //   ...
-  const comboStrings = normalizedCombos.map(combo => combo.map(subId => `[${subId}]`).join(''))
+  const comboStrings = origCombos.map(combo => combo.map(subId => `[${subId}]`).join(''))
 
   // Convert `variable.subscripts` into the same format so that we can do an array lookup,
-  // for example if this separated variable instance is x[_a2,_b1], this will be:
-  //   [_a2,_b1]
+  // for example if this separated variable instance is x[_b1,_a2], this will be:
+  //   [_b1,_a2]
   const lhsComboString = variable.subscripts.map(subId => `[${subId}]`).join('')
 
   // Find the index of the combination that matches `variable.subscripts`

package/src/generate/gen-equation.js

@@ -1,13 +1,4 @@
-import {
-  dimensionNames,
-  hasMapping,
-  isDimension,
-  isIndex,
-  isTrivialDimension,
-  normalizeSubscripts,
-  separatedVariableIndex,
-  sub
-} from '../_shared/subscript.js'
+import { hasMapping, isDimension, isIndex, isTrivialDimension, sub } from '../_shared/subscript.js'
 import { generateConstListElement } from './gen-const-list.js'
 
 import { generateDirectConstInit } from './gen-direct-const.js'
@@ -18,6 +9,9 @@ import { generateLookupFromPoints } from './gen-lookup-from-points.js'
 
 import LoopIndexVars from './loop-index-vars.js'
 
+const loopIndexVarNames = ['i', 'j', 'k', 'l', 'm']
+const arrayIndexVarNames = ['u', 'v', 'w', 's', 't', 'f', 'g', 'h', 'o', 'p', 'q', 'r']
+
 /**
  * Generate C code for the given model equation.
  *
@@ -36,8 +30,22 @@ import LoopIndexVars from './loop-index-vars.js'
  */
 export function generateEquation(variable, mode, extData, directData, modelDir, outFormat) {
   // Maps of LHS subscript families to loop index vars for lookup on the RHS
-  const loopIndexVars = new LoopIndexVars(['i', 'j', 'k', 'l', 'm'])
-  const arrayIndexVars = new LoopIndexVars(['u', 'v', 'w', 's', 't', 'f', 'g', 'h', 'o', 'p', 'q', 'r'])
+  const loopIndexVars = new LoopIndexVars(loopIndexVarNames)
+  const arrayIndexVars = new LoopIndexVars(arrayIndexVarNames)
+
+  // Make the generated loops easier to follow by eagerly determining the order of index
+  // variables based on the order of the LHS dimension names.  For example, if we have:
+  //   x[DimA, DimC, DimB] = y[DimB, DimC, DimA] ~~|
+  // This will generate loop index variable mappings in the following order:
+  //   DimA -> i
+  //   DimC -> j
+  //   DimB -> k
+  const lhsDimIds = variable.subscripts.filter(isDimension)
+  for (const lhsDimId of lhsDimIds) {
+    // We ignore the return value here.  Calling `index` will make `LoopIndexVars` eagerly
+    // set up a mapping from the dimension ID to the loop index variable name.
+    loopIndexVars.index(lhsDimId)
+  }
 
   // Generate the LHS variable reference code
   const parsedEqn = variable.parsedEqn
@@ -64,17 +72,14 @@ export function generateEquation(variable, mode, extData, directData, modelDir,
     return [comment, ...initCode]
   }
 
-  // Get the dimension IDs for the LHS variable
-  const dimIds = dimensionNames(variable.subscripts)
-
   // Turn each dimension ID into a loop with a loop index variable.
   // If the variable has no subscripts, nothing will be emitted here.
   const indexDecl = outFormat === 'js' ? 'let' : 'size_t'
   const openLoops = []
   const closeLoops = []
-  for (const dimId of dimIds) {
-    const indexName = loopIndexVars.index(dimId)
-    const dimLength = sub(dimId).size
+  for (const lhsDimId of lhsDimIds) {
+    const indexName = loopIndexVars.index(lhsDimId)
+    const dimLength = sub(lhsDimId).size
     openLoops.push(`  for (${indexDecl} ${indexName} = 0; ${indexName} < ${dimLength}; ${indexName}++) {`)
     closeLoops.push('  }')
   }
@@ -108,13 +113,12 @@ export function generateEquation(variable, mode, extData, directData, modelDir,
   // Apply special handling for lookup variables.  The data for lookup variables is already
   // defined as a set of explicit data points (stored in the `Variable` instance).
   if (variable.isLookup()) {
-    if (variable.varSubtype === 'gameInputs') {
-      // For a synthesized game inputs lookup, there is no data array (the data is expected
-      // to be supplied at runtime), so don't emit decl or init code for these
-      return []
+    // Emit decl/init code for the lookup
+    const lookupDef = generateLookupFromPoints(variable, mode, /*copy=*/ false, cLhs, loopIndexVars, outFormat)
+    if (lookupDef.length > 0) {
+      return [...openLoops, ...lookupDef, ...closeLoops]
     } else {
-      // For all other lookups, emit decl/init code for the lookup
-      return generateLookupFromPoints(variable, mode, /*copy=*/ false, cLhs, loopIndexVars, outFormat)
+      return []
     }
   }
 
@@ -127,9 +131,6 @@ export function generateEquation(variable, mode, extData, directData, modelDir,
   // Keep a buffer of code that will be included after the generated primary formula
   const postFormulaLines = []
 
-  // Keep track of marked dimensions
-  const markedDimIds = new Set()
-
   // Generate code for an equation with an expression on the RHS
   const genExprCtx = {
     variable,
@@ -138,14 +139,12 @@ export function generateEquation(variable, mode, extData, directData, modelDir,
     cLhs,
     loopIndexVars,
     arrayIndexVars,
-    resetMarkedDims: () => markedDimIds.clear(),
-    addMarkedDim: dimId => markedDimIds.add(dimId),
     emitPreInnerLoop: s => preInnerLoopLines.push(s),
     emitPreFormula: s => preFormulaLines.push(s),
     emitPostFormula: s => postFormulaLines.push(s),
-    cVarRef: varRef => cVarRef(variable, varRef, markedDimIds, loopIndexVars, arrayIndexVars),
+    cVarRef: varRef => cVarRef(variable, varRef, loopIndexVars, arrayIndexVars),
     cVarRefWithLhsSubscripts: baseVarId => cVarRefWithLhsSubscripts(variable, baseVarId, loopIndexVars),
-    cVarIndex: subOrDimId => cVarIndex(variable, [subOrDimId], subOrDimId, markedDimIds, loopIndexVars, arrayIndexVars)
+    cVarIndex: subOrDimId => cVarIndex(variable, subOrDimId, loopIndexVars, arrayIndexVars)
   }
   const cRhs = generateExpr(parsedEqn.rhs.expr, genExprCtx)
   const formula = `  ${cLhs} = ${cRhs};`
@@ -177,9 +176,12 @@ function cVarRefWithLhsSubscripts(lhsVariable, baseVarId, loopIndexVars) {
         // When the dimension is trivial, we can simply emit e.g. `[i]` instead of `[_dim[i]]`
         return `[${i}]`
       } else {
-        return `[${subId}][${i}]`
+        // Otherwise, emit e.g. `[_dim[i]]`
+        return `[${subId}[${i}]]`
       }
     } else {
+      // This is a specific subscript (i.e., an index); dereference the array using the index
+      // number of the subscript
       return `[${sub(subId).value}]`
     }
   })
@@ -191,33 +193,26 @@ function cVarRefWithLhsSubscripts(lhsVariable, baseVarId, loopIndexVars) {
  *
  * @param {*} lhsVariable The LHS `Variable` instance.
  * @param {*} rhsVarRef The `VariableRef` used in a RHS expression.
- * @param {Set<string>} markedDimIds The set of dimension IDs that are marked for use
- * in an array function, for example `SUM(x[DimA!])`.
  * @param {LoopIndexVars} loopIndexVars The loop index state.
  * @param {LoopIndexVars} arrayIndexVars The loop index state used for array functions
  * (that use marked dimensions).
  * @returns {string} The C variable reference.
  */
-function cVarRef(lhsVariable, rhsVarRef, markedDimIds, loopIndexVars, arrayIndexVars) {
+function cVarRef(lhsVariable, rhsVarRef, loopIndexVars, arrayIndexVars) {
   if (rhsVarRef.subscriptRefs === undefined) {
     // No subscripts, so return the base variable ID
     return rhsVarRef.varId
   }
 
-  // Normalize the RHS subscripts
-  let rhsSubIds
-  try {
-    // XXX: For now, strip the mark here (need to revisit this)
-    rhsSubIds = normalizeSubscripts(rhsVarRef.subscriptRefs.map(subRef => subRef.subId.replace('!', '')))
-  } catch (e) {
-    throw new Error(`normalizeSubscripts failed in rhsVarRef: refId=${lhsVariable.refId} error=${e}`)
-  }
+  // Get the RHS subscript IDs.  Note that we leave the "!" in place in the case of
+  // marked dimensions; they will be handled specially in `cVarIndex`.
+  const rhsSubIds = rhsVarRef.subscriptRefs.map(subRef => subRef.subId)
 
   // Determine the subscript code (array lookup) for each dimension.  For example, if
   // the RHS variable reference in the model looks like `x[DimA]`, this will convert the
   // `[DimA]` part to `[_dima[i]]` (or simply `[i]` if it is a "trivial" dimension).
   const cSubParts = rhsSubIds.map(rhsSubId => {
-    return cVarIndex(lhsVariable, rhsSubIds, rhsSubId, markedDimIds, loopIndexVars, arrayIndexVars)
+    return cVarIndex(lhsVariable, rhsSubId, loopIndexVars, arrayIndexVars)
   })
 
   return `${rhsVarRef.varId}${cSubParts.map(part => `[${part}]`).join('')}`
@@ -227,57 +222,97 @@ function cVarRef(lhsVariable, rhsVarRef, markedDimIds, loopIndexVars, arrayIndex
  * Return the C code for indexing into a subscripted variable.
  *
  * @param {*} lhsVariable The LHS `Variable` instance.
- * @param {string[]} rhsSubIds The set of all subscript or dimension IDs used on the RHS.
  * @param {string} rhsSubId The specific subscript or dimension ID being evaluated.
- * @param {Set<string>} markedDimIds The set of dimension IDs that are marked for use
- * in an array function, for example `SUM(x[DimA!])`.
  * @param {LoopIndexVars} loopIndexVars The loop index state.
  * @param {LoopIndexVars} arrayIndexVars The loop index state used for array functions
  * (that use marked dimensions).
  * @returns {string} The C variable reference.
  */
-function cVarIndex(lhsVariable, rhsSubIds, rhsSubId, markedDimIds, loopIndexVars, arrayIndexVars) {
+function cVarIndex(lhsVariable, rhsSubId, loopIndexVars, arrayIndexVars) {
+  // NOTE: The code in this function follows basically the same steps that are used in
+  // the `resolveRhsSubOrDim` function in the `readEquation` phase.
+  // TODO: Since these two functions are so similar, it would be better to write a
+  // single function that has the common logic, and then write a wrapper function
+  // that converts the resulting subscript or dimension ID to an index
+
+  // Helper function that returns either `indexVarName` or `dimId[indexVarName]` depending
+  // on whether `dimId` is considered "trivial".
+  function optimalIndex(indexVars, dimId) {
+    const indexVarName = indexVars.index(dimId)
+    if (isTrivialDimension(dimId)) {
+      // When the dimension is trivial, we can emit e.g. `[i]` instead of `[_dim[i]]`
+      return `${indexVarName}`
+    } else {
+      // Otherwise, emit e.g. `[_dim[i]]`
+      return `${dimId}[${indexVarName}]`
+    }
+  }
+
+  if (rhsSubId.endsWith('!')) {
+    // The dimension ID at this position is "marked", indicating that the vector function
+    // (e.g., `SUM`) should operate over the elements in this dimension.  Strip the "!"
+    // to get the actual dimension ID, then get the associated array loop index variable.
+    const rhsDimId = rhsSubId.replace('!', '')
+    return optimalIndex(arrayIndexVars, rhsDimId)
+  }
+
   if (isIndex(rhsSubId)) {
     // This is a specific subscript (i.e., an index); dereference the array using the index
     // number of the subscript
     return `${sub(rhsSubId).value}`
   }
 
-  // Otherwise, this is a dimension. Get the corresponding loop index variable used
-  // in the "for" loop.
-  let indexName
-  if (markedDimIds.has(rhsSubId)) {
-    // This is a marked dimension as used in an array function (e.g., `SUM`), so use
-    // the name of the array loop index variable
-    indexName = arrayIndexVars.index(rhsSubId)
-  } else {
-    // Use the single index name for a separated variable if it exists
-    const separatedIndexName = separatedVariableIndex(rhsSubId, lhsVariable, rhsSubIds)
-    if (separatedIndexName) {
-      return `${sub(separatedIndexName).value}`
+  // At this point we know that it is a dimension ID.  Figure out which LHS subscript or
+  // dimension is a match.  First see if there is an exact match.
+  const lhsSubRefs = lhsVariable.parsedEqn.lhs.varDef.subscriptRefs
+  const lhsSubIds = lhsSubRefs?.map(subRef => subRef.subId) || []
+  const lhsDimIndex = lhsSubIds.findIndex(lhsSubId => lhsSubId === rhsSubId)
+  if (lhsDimIndex >= 0) {
+    // There is a match.  If the LHS variable is separated, use the separated subscript
+    // ID at this position (i.e., the value from the `subscripts` array), otherwise we
+    // use the dimension ID at this position.
+    const lhsSubOrDimId = lhsVariable.subscripts[lhsDimIndex]
+    if (isIndex(lhsSubOrDimId)) {
+      // This is a specific subscript (i.e., an index); dereference the array using the index
+      // number of the subscript
+      return `${sub(lhsSubOrDimId).value}`
+    } else {
+      // This is a dimension; use the associated loop index variable
+      return optimalIndex(loopIndexVars, lhsSubOrDimId)
     }
+  }
 
-    // See if we need to apply a mapping because the RHS dim is not found on the LHS
-    const found = lhsVariable.subscripts.findIndex(lhsSubId => sub(lhsSubId).family === sub(rhsSubId).family)
-    if (found < 0) {
-      // Find the mapping from the RHS subscript to a LHS subscript
-      for (const lhsSubId of lhsVariable.subscripts) {
-        if (hasMapping(rhsSubId, lhsSubId)) {
-          indexName = loopIndexVars.index(lhsSubId)
-          return `__map${rhsSubId}${lhsSubId}[${indexName}]`
-        }
+  // There wasn't an exact match by dimension ID.  Find the position of the LHS dimension
+  // that has a mapping to the RHS dimension.
+  const mappedLhsDimIndex = lhsSubIds.findIndex(lhsSubId => hasMapping(rhsSubId, lhsSubId))
+  if (mappedLhsDimIndex >= 0) {
+    // There is a match.  If the LHS variable is separated, use the _mapped_ separated
+    // subscript ID at this position (i.e., the value from the `subscripts` array),
+    // otherwise we use the _mapped_ dimension ID at this position.
+    const mappedLhsSubOrDimId = lhsVariable.subscripts[mappedLhsDimIndex]
+    if (isIndex(mappedLhsSubOrDimId)) {
+      // This is a specific subscript (i.e., an index); dereference the array using the index
+      // number of the _mapped_ subscript
+      const mappedLhsSubId = mappedLhsSubOrDimId
+      const mappedLhsDimId = lhsSubIds[mappedLhsDimIndex]
+      const lhsDim = sub(mappedLhsDimId)
+      const rhsDim = sub(rhsSubId)
+      const lhsSubIndex = lhsDim.value.indexOf(mappedLhsSubId)
+      if (lhsSubIndex >= 0) {
+        const mappedSubId = rhsDim.mappings[mappedLhsDimId][lhsSubIndex]
+        return `${sub(mappedSubId).value}`
+      } else {
+        throw new Error(
+          `Failed to find mapped LHS subscript ${mappedLhsSubId} for RHS dimension ${rhsSubId} in lhs=${lhsVariable.refId}`
+        )
       }
+    } else {
+      // Determine the dimension mapping
+      const mappedLhsDimId = lhsSubIds[mappedLhsDimIndex]
+      const indexVarName = loopIndexVars.index(mappedLhsDimId)
+      return `__map${rhsSubId}${mappedLhsDimId}[${indexVarName}]`
     }
-
-    // There is no mapping, so use the loop index for this dim family on the LHS
-    indexName = loopIndexVars.index(rhsSubId)
-  }
-
-  // Dereference the array using the corresponding loop index variable
-  if (isTrivialDimension(rhsSubId)) {
-    // When the dimension is trivial, we can emit e.g. `[i]` instead of `[_dim[i]]`
-    return `${indexName}`
   } else {
-    return `${rhsSubId}[${indexName}]`
+    throw new Error(`Failed to find LHS dimension for RHS dimension ${rhsSubId} in lhs=${lhsVariable.refId}`)
   }
 }