@sdeverywhere/compile 0.7.9 → 0.7.11

package/package.json

@@ -1,14 +1,11 @@
 {
   "name": "@sdeverywhere/compile",
-  "version": "0.7.9",
+  "version": "0.7.11",
   "description": "The core Vensim to C compiler for the SDEverywhere tool suite.",
   "type": "module",
-  "files": [
-    "src/**",
-    "!.DS_Store"
-  ],
   "main": "./src/index.js",
   "dependencies": {
+    "@sdeverywhere/parse": "^0.1.0",
     "antlr4": "4.12.0",
     "antlr4-vensim": "0.6.2",
     "bufx": "^1.0.5",
@@ -35,6 +32,10 @@
     "prettier:check": "prettier --check .",
     "prettier:fix": "prettier --write .",
     "precommit": "../../scripts/precommit",
-    "ci:build": "run-s lint prettier:check"
+    "type-check": "tsc --noEmit -p tsconfig-test.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ci": "vitest run",
+    "ci:build": "run-s lint prettier:check type-check test:ci"
   }
 }

package/src/_shared/helpers.js

@@ -22,8 +22,17 @@ let nextLevelVarSeq = 1
 let nextAuxVarSeq = 1
 // parsed csv data cache
 let csvData = new Map()
-// string table for web apps
-export let strings = []
+
+// XXX: This is needed for tests due to sequence numbers being in module-level storage
+export function resetHelperState() {
+  nextTmpVarSeq = 1
+  nextLookupVarSeq = 1
+  nextFixedDelayVarSeq = 1
+  nextDepreciationVarSeq = 1
+  nextLevelVarSeq = 1
+  nextAuxVarSeq = 1
+  csvData.clear()
+}
 
 export let canonicalName = name => {
   // Format a model variable name into a valid C identifier.
@@ -200,15 +209,6 @@ export let isIterable = obj => {
   }
   return typeof obj[Symbol.iterator] === 'function'
 }
-export let stringToId = str => {
-  // Look up a string id. Create the id from the string if it is not found.
-  let stringIndex = R.indexOf(str, strings)
-  if (stringIndex < 0) {
-    stringIndex = strings.length
-    strings.push(str)
-  }
-  return `id${stringIndex}`
-}
 // Command helpers
 export let readXlsx = pathname => {
   return XLSX.readFile(pathname, { cellDates: true })

package/src/_shared/subscript.js

@@ -49,6 +49,11 @@ import { canonicalName, asort, vlog } from './helpers.js'
 // subscript name as the key and a subscript object as the value.
 let subscripts = new Map()
 
+// XXX: This is needed for tests due to subs/dims being in module-level storage
+export function resetSubscriptsAndDimensions() {
+  subscripts.clear()
+}
+
 export function Subscript(modelName, modelValue = null, modelFamily = null, modelMappings = null) {
   let name = canonicalName(modelName)
   if (modelValue === null) {

package/src/generate/code-gen.js

@@ -4,15 +4,16 @@ import { asort, lines, strlist, abend, mapIndexed } from '../_shared/helpers.js'
 import { sub, allDimensions, allMappings, subscriptFamilies } from '../_shared/subscript.js'
 import Model from '../model/model.js'
 
+import { generateEquation } from './gen-equation.js'
 import EquationGen from './equation-gen.js'
-import ModelLHSReader from './model-lhs-reader.js'
+import { expandVarNames } from './expand-var-names.js'
 
-export function generateCode(parseTree, opts) {
-  return codeGenerator(parseTree, opts).generate()
+export function generateCode(parsedModel, opts) {
+  return codeGenerator(parsedModel, opts).generate()
 }
 
-let codeGenerator = (parseTree, opts) => {
-  const { spec, operation, extData, directData, modelDirname } = opts
+let codeGenerator = (parsedModel, opts) => {
+  const { spec, operations, extData, directData, modelDirname } = opts
   // Set to 'decl', 'init-lookups', 'eval', etc depending on the section being generated.
   let mode = ''
   // Set to true to output all variables when there is no model run spec.
@@ -25,21 +26,30 @@ let codeGenerator = (parseTree, opts) => {
     outputAllVars = true
   }
   // Function to generate a section of the code
-  let generateSection = R.map(v => new EquationGen(v, extData, directData, mode, modelDirname).generate())
+  let generateSection = R.map(v => {
+    if (parsedModel.kind === 'vensim-legacy') {
+      return new EquationGen(v, extData, directData, mode, modelDirname).generate()
+    } else {
+      return generateEquation(v, mode, extData, directData, modelDirname)
+    }
+  })
   let section = R.pipe(generateSection, R.flatten, lines)
   function generate() {
     // Read variables and subscript ranges from the model parse tree.
     // This is the main entry point for code generation and is called just once.
     try {
-      Model.read(parseTree, spec, extData, directData, modelDirname)
+      Model.read(parsedModel, spec, extData, directData, modelDirname)
       // In list mode, print variables to the console instead of generating code.
-      if (operation === 'printRefIdTest') {
+      if (operations.includes('printRefIdTest')) {
         Model.printRefIdTest()
-      } else if (operation === 'printRefGraph') {
+      }
+      if (operations.includes('printRefGraph')) {
         Model.printRefGraph(opts.varname)
-      } else if (operation === 'convertNames') {
+      }
+      if (operations.includes('convertNames')) {
         // Do not generate output, but leave the results of model analysis.
-      } else if (operation === 'generateC') {
+      }
+      if (operations.includes('generateC')) {
         // Generate code for each variable in the proper order.
         let code = emitDeclCode()
         code += emitInitLookupsCode()
@@ -198,10 +208,21 @@ void ${name}${idx}() {
     }
     let funcCalls = R.pipe(mapIndexed(funcCall), lines)
 
-    // Break the vars into chunks of 30; this number was empirically
-    // determined by looking at runtime performance and memory usage
-    // of the En-ROADS model on various devices
-    let chunks = R.splitEvery(30, vars)
+    // Break the vars into chunks.  The default value of 30 was empirically
+    // determined by looking at runtime performance and memory usage of the
+    // En-ROADS model on various devices.
+    let chunkSize
+    if (process.env.SDE_CODE_GEN_CHUNK_SIZE) {
+      chunkSize = parseInt(process.env.SDE_CODE_GEN_CHUNK_SIZE)
+    } else {
+      chunkSize = 30
+    }
+    let chunks
+    if (chunkSize > 0) {
+      chunks = R.splitEvery(chunkSize, vars)
+    } else {
+      chunks = [vars]
+    }
 
     if (!preStep) {
       preStep = ''
@@ -296,33 +317,8 @@ ${postStep}
     // Return a list of var names for all variables except lookups and data variables.
     // The names are in Vensim format if vensimNames is true, otherwise they are in C format.
     // Expand subscripted vars into separate var names with each index.
-    function sortedVars() {
-      // Return a list of all vars sorted by the model LHS var name (without subscripts), case insensitive.
-      return R.sortBy(v => {
-        let modelLHSReader = new ModelLHSReader()
-        modelLHSReader.read(v.modelLHS)
-        return modelLHSReader.varName.toUpperCase()
-      }, Model.variables)
-    }
-    return R.uniq(
-      R.reduce(
-        (a, v) => {
-          if (v.varType !== 'lookup' && v.varType !== 'data' && v.includeInOutput) {
-            let modelLHSReader = new ModelLHSReader()
-            modelLHSReader.read(v.modelLHS)
-            if (vensimNames) {
-              return R.concat(a, modelLHSReader.names())
-            } else {
-              return R.concat(a, R.map(Model.cName, modelLHSReader.names()))
-            }
-          } else {
-            return a
-          }
-        },
-        [],
-        sortedVars()
-      )
-    )
+    const canonicalNames = !vensimNames
+    return expandVarNames(canonicalNames)
   }
   //
   // Input/output section helpers

package/src/generate/direct-data-helpers.js

@@ -0,0 +1,86 @@
+import path from 'node:path'
+
+import XLSX from 'xlsx'
+
+import { cdbl, readCsv, readXlsx } from '../_shared/helpers.js'
+
+/**
+ * Return a `getCellValue` function that reads the CSV or XLS[X] content.
+ *
+ * @param {string} fileOrTag The filename (e.g., 'data.xlsx') or tag name (e.g., '?data').
+ * @param {string} tabOrDelimiter
+ * @param {'data' | 'constants'} dataKind The kind of `GET DIRECT ...` being used.
+ * @param {Map<string, any>} directData The mapping of dataset name used in a `GET DIRECT DATA` call (e.g.,
+ * `?data`) to the tabular data contained in the loaded data file.
+ * @param {string} modelDir The path to the directory containing the model (used for resolving data files).
+ * @returns A `getCellValue` function.
+ */
+export function handleExcelOrCsvFile(fileOrTag, tabOrDelimiter, dataKind, directData, modelDir) {
+  if (fileOrTag.startsWith('?')) {
+    // The file is a tag for an Excel file with data in the directData map.
+    const workbook = directData.get(fileOrTag)
+    return handleExcelWorkbook(fileOrTag, workbook, tabOrDelimiter, dataKind, 'tagged')
+  } else {
+    // The file is a CSV or XLS[X] pathname. Read it now.
+    const dataPathname = path.resolve(modelDir, fileOrTag)
+    if (dataPathname.toLowerCase().endsWith('csv')) {
+      return handleCsvFile(fileOrTag, dataPathname, tabOrDelimiter, dataKind)
+    } else {
+      const workbook = readXlsx(dataPathname)
+      return handleExcelWorkbook(fileOrTag, workbook, tabOrDelimiter, dataKind, 'file')
+    }
+  }
+}
+
+/**
+ * Return a `getCellValue` function for the given Excel workbook parsed from an XLS[X] file.
+ *
+ * @param {string} fileOrTag The filename (e.g., 'data.xlsx') or tag name (e.g., '?data').
+ * @param {*} workbook The workbook data loaded from the file.
+ * @param {string} tab The name of the tab within the workbook.
+ * @param {'data' | 'constants'} dataKind The kind of `GET DIRECT ...` being used.
+ * @param {'file' | 'tagged'} dataSource The reference kind, either 'file' or 'tagged'.
+ * @returns A `getCellValue` function.
+ */
+function handleExcelWorkbook(fileOrTag, workbook, tab, dataKind, dataSource) {
+  if (workbook) {
+    let sheet = workbook.Sheets[tab]
+    if (sheet) {
+      return (c, r) => {
+        let cell = sheet[XLSX.utils.encode_cell({ c, r })]
+        return cell != null ? cdbl(cell.v) : null
+      }
+    } else {
+      throw new Error(`Direct ${dataKind} worksheet ${tab} in ${dataSource} ${fileOrTag} not found`)
+    }
+  } else {
+    throw new Error(`Direct ${dataKind} workbook ${dataSource} ${fileOrTag} not found`)
+  }
+}
+
+/**
+ * Return a `getCellValue` function for the given CSV file.
+ *
+ * @param {string} file The filename of the data file.
+ * @param {string} dataFilename The full path to the data file.
+ * @param {string} delimiter The delimiter for the tabular data.
+ * @param {'data' | 'constants'} dataKind The kind of `GET DIRECT ...` being used.
+ * @returns A `getCellValue` function.
+ */
+function handleCsvFile(file, dataPathname, delimiter, dataKind) {
+  // Return a `getCellValue` function for the given CSV file.
+  let data = readCsv(dataPathname, delimiter)
+  if (data) {
+    return (c, r) => {
+      let value = '0.0'
+      try {
+        value = data[r] != null && data[r][c] != null ? cdbl(data[r][c]) : null
+      } catch (error) {
+        console.error(`${error.message} in ${dataPathname}`)
+      }
+      return value
+    }
+  } else {
+    throw new Error(`Direct ${dataKind} file ${file} could not be read`)
+  }
+}

package/src/generate/equation-gen.js

@@ -17,6 +17,7 @@ import {
   newTmpVarName,
   permutationsOf,
   readCsv,
+  readXlsx,
   strToConst,
   vlog
 } from '../_shared/helpers.js'
@@ -208,6 +209,56 @@ export default class EquationGen extends ModelReader {
     }
     return value
   }
+  handleExcelWorkbook(fileOrTag, workbook, tab, dataKind, dataSource) {
+    // Return a `getCellValue` function for the given Excel workbook parsed from an XLS[X] file.
+    if (workbook) {
+      let sheet = workbook.Sheets[tab]
+      if (sheet) {
+        return (c, r) => {
+          let cell = sheet[XLSX.utils.encode_cell({ c, r })]
+          return cell != null ? cdbl(cell.v) : null
+        }
+      } else {
+        throw new Error(`Direct ${dataKind} worksheet ${tab} in ${dataSource} ${fileOrTag} not found`)
+      }
+    } else {
+      throw new Error(`Direct ${dataKind} workbook ${dataSource} ${fileOrTag} not found`)
+    }
+  }
+  handleCsvFile(file, dataPathname, tab, dataKind) {
+    // Return a `getCellValue` function for the given CSV file.
+    let data = readCsv(dataPathname, tab)
+    if (data) {
+      return (c, r) => {
+        let value = '0.0'
+        try {
+          value = data[r] != null && data[r][c] != null ? cdbl(data[r][c]) : null
+        } catch (error) {
+          console.error(`${error.message} in ${dataPathname}`)
+        }
+        return value
+      }
+    } else {
+      throw new Error(`Direct ${dataKind} file ${file} could not be read`)
+    }
+  }
+  handleExcelOrCsvFile(fileOrTag, tab, dataKind) {
+    // Return a `getCellValue` function that reads the CSV or XLS[X] content.
+    if (fileOrTag.startsWith('?')) {
+      // The file is a tag for an Excel file with data in the directData map.
+      let workbook = this.directData.get(fileOrTag)
+      return this.handleExcelWorkbook(fileOrTag, workbook, tab, dataKind, 'tagged')
+    } else {
+      // The file is a CSV or XLS[X] pathname. Read it now.
+      let dataPathname = path.resolve(this.modelDirname, fileOrTag)
+      if (dataPathname.toLowerCase().endsWith('csv')) {
+        return this.handleCsvFile(fileOrTag, dataPathname, tab, dataKind)
+      } else {
+        let workbook = readXlsx(dataPathname)
+        return this.handleExcelWorkbook(fileOrTag, workbook, tab, dataKind, 'file')
+      }
+    }
+  }
   lookupDataNameGen(subscripts) {
     // Construct a name for the static data array associated with a lookup variable.
     return R.map(subscript => {
@@ -360,40 +411,11 @@ export default class EquationGen extends ModelReader {
     // If direct data exists for this variable, copy it from the workbook into one or more lookups.
     let result = []
     if (this.mode === 'init-lookups') {
-      let getCellValue
       let { file, tab, timeRowOrCol, startCell } = this.var.directDataArgs
-      if (file.startsWith('?')) {
-        // The file is a tag for an Excel file with data in the directData map.
-        let workbook = this.directData.get(file)
-        if (workbook) {
-          let sheet = workbook.Sheets[tab]
-          if (sheet) {
-            getCellValue = (c, r) => {
-              let cell = sheet[XLSX.utils.encode_cell({ c, r })]
-              return cell != null ? cdbl(cell.v) : null
-            }
-          } else {
-            throw new Error(`ERROR: Direct data worksheet ${tab} tagged ${file} not found`)
-          }
-        } else {
-          throw new Error(`ERROR: Direct data workbook tagged ${file} not found`)
-        }
-      } else {
-        // The file is a CSV pathname. Read it now.
-        let csvPathname = path.resolve(this.modelDirname, file)
-        let data = readCsv(csvPathname, tab)
-        if (data) {
-          getCellValue = (c, r) => {
-            let value = '0.0'
-            try {
-              value = data[r] != null && data[r][c] != null ? cdbl(data[r][c]) : null
-            } catch (error) {
-              console.error(`${error.message} in ${csvPathname}`)
-            }
-            return value
-          }
-        }
-      }
+
+      // Create a function that reads the CSV or XLS[X] content
+      let getCellValue = this.handleExcelOrCsvFile(file, tab, 'data')
+
       // If the data was found, convert it to a lookup.
       if (getCellValue) {
         let indexNum = 0
@@ -427,12 +449,17 @@ export default class EquationGen extends ModelReader {
     let dataCol, dataRow, dataValue, timeCol, timeRow, timeValue, nextCell
     let lookupData = ''
     let lookupSize = 0
-    let dataAddress = XLSX.utils.decode_cell(startCell)
+    let dataAddress = XLSX.utils.decode_cell(startCell.toUpperCase())
     dataCol = dataAddress.c
     dataRow = dataAddress.r
+    if (dataCol < 0 || dataRow < 0) {
+      throw new Error(
+        `Failed to parse 'cell' argument for GET DIRECT {DATA,LOOKUPS} call for ${this.lhs}: ${startCell}`
+      )
+    }
     if (isNaN(parseInt(timeRowOrCol))) {
       // Time values are in a column.
-      timeCol = XLSX.utils.decode_col(timeRowOrCol)
+      timeCol = XLSX.utils.decode_col(timeRowOrCol.toUpperCase())
       timeRow = dataRow
       dataCol += indexNum
       nextCell = () => {
@@ -468,18 +495,10 @@ export default class EquationGen extends ModelReader {
     // The subscripts may be indices to pick out a subset of the data.
     let result = this.comments
     let { file, tab, startCell } = this.var.directConstArgs
-    let csvPathname = path.resolve(this.modelDirname, file)
-    let data = readCsv(csvPathname, tab)
-    if (data) {
-      let getCellValue = (c, r) => {
-        let value = '0.0'
-        try {
-          value = data[r] != null && data[r][c] != null ? cdbl(data[r][c]) : null
-        } catch (error) {
-          console.error(`${error.message} in ${csvPathname}`)
-        }
-        return value
-      }
+
+    // Create a function that reads the CSV or XLS[X] content
+    let getCellValue = this.handleExcelOrCsvFile(file, tab, 'constants')
+    if (getCellValue) {
       // Get C subscripts in text form for the LHS in normal order.
       let modelLHSReader = new ModelLHSReader()
       modelLHSReader.read(this.var.modelLHS)
@@ -526,12 +545,15 @@ export default class EquationGen extends ModelReader {
         }
         cellOffsets.push(entry)
       }
-      // Read CSV data into an indexed variable for each cell.
+      // Read tabular data into an indexed variable for each cell.
       let numericSubscripts = lhsIndexSubscripts.map(idx => idx.map(s => sub(s).value))
       let lhsSubscripts = numericSubscripts.map(s => s.reduce((a, v) => a.concat(`[${v}]`), ''))
-      let dataAddress = XLSX.utils.decode_cell(startCell)
+      let dataAddress = XLSX.utils.decode_cell(startCell.toUpperCase())
       let startCol = dataAddress.c
       let startRow = dataAddress.r
+      if (startCol < 0 || startRow < 0) {
+        throw new Error(`Failed to parse 'cell' argument for GET DIRECT CONSTANTS call for ${this.lhs}: ${startCell}`)
+      }
       for (let i = 0; i < cellOffsets.length; i++) {
         let rowOffset = cellOffsets[i][0] ? cellOffsets[i][0] : 0
         let colOffset = cellOffsets[i][1] ? cellOffsets[i][1] : 0
@@ -651,7 +673,7 @@ export default class EquationGen extends ModelReader {
           throw new Error(`ERROR: lookup size = ${this.var.points.length} in ${this.var.refId}`)
         }
         let lookupData = R.reduce((a, p) => listConcat(a, `${cdbl(p[0])}, ${cdbl(p[1])}`, true), '', this.var.points)
-        this.emit(`__new_lookup(${this.var.points.length}, /*copy=*/true, (double[]){ ${lookupData} });`)
+        this.emit(`__new_lookup(${this.var.points.length}, /*copy=*/true, (double[]){ ${lookupData} })`)
       }
     } else {
       super.visitEquation(ctx)
@@ -989,13 +1011,18 @@ export default class EquationGen extends ModelReader {
         // Emit the size of the dimension in place of the dimension name.
         this.emit(`${sub(varName).size}`)
       } else {
-        // A subscript masquerading as a variable takes the value of the loop index var plus one
-        // (since Vensim indices are one-based).
+        // A dimension masquerading as a variable (i.e., in expression position) takes the
+        // value of the loop index var plus one (since Vensim indices are one-based).
         let s = this.rhsSubscriptGen([varName])
         // Remove the brackets around the C subscript expression.
         s = s.slice(1, s.length - 1)
         this.emit(`(${s} + 1)`)
       }
+    } else if (isIndex(varName)) {
+      // A subscript masquerading as a variable (i.e., in expression position) takes the
+      // numeric index value plus one (since Vensim indices are one-based).
+      const index = sub(varName).value
+      this.emit(`${index + 1}`)
     } else {
       this.varNames.push(varName)
       if (functionName === '_VECTOR_SELECT') {

package/src/generate/expand-var-names.js

@@ -0,0 +1,115 @@
+import * as R from 'ramda'
+
+import { cartesianProductOf, canonicalName } from '../_shared/helpers.js'
+import { sub, isDimension } from '../_shared/subscript.js'
+
+import Model from '../model/model.js'
+
+import ModelLHSReader from './model-lhs-reader.js'
+
+/**
+ * Return an array of names for all variable in the model, sorted alphabetically and expanded to
+ * include the full set of subscripted variants for variables that include subscripts.
+ *
+ * @param canonical If true, convert names to canonical representation (variable identifiers), otherwise
+ * return the original name of each variable as it appears in the model.
+ * @returns {string[]} An array of variable names or identifiers.
+ */
+export function expandVarNames(canonical) {
+  const sortedVars = R.sortBy(v => v.varName, Model.variables)
+  return R.uniq(
+    R.reduce(
+      (a, v) => {
+        if (v.varType !== 'lookup' && v.varType !== 'data' && v.includeInOutput) {
+          if (canonical) {
+            return R.concat(a, R.map(Model.cName, namesForVar(v)))
+          } else {
+            return R.concat(a, namesForVar(v))
+          }
+        } else {
+          return a
+        }
+      },
+      [],
+      sortedVars
+    )
+  )
+}
+
+/**
+ * Return an array of names for the given variable including all subscript variants.
+ *
+ * @param {*} v A `Variable` instance.
+ * @returns {string[]} An array of expanded names for the given variable.
+ */
+function namesForVar(v) {
+  if (process.env.SDE_NONPUBLIC_USE_NEW_PARSE !== '1') {
+    // TODO: When the old parsing code is active, use the old ModelLHSReader.  This code path
+    // will be removed when the old parsing code is removed.
+    let modelLHSReader = new ModelLHSReader()
+    modelLHSReader.read(v.modelLHS)
+    return modelLHSReader.names()
+  }
+
+  if (v.parsedEqn === undefined) {
+    // XXX: The special `Time` variable does not have a `parsedEqn`, so use the raw LHS
+    return [v.modelLHS]
+  }
+
+  // Expand each variable to get the names of all subscripted variants
+  const lhsVarDef = v.parsedEqn.lhs.varDef
+  const lhsSubRefs = lhsVarDef.subscriptRefs
+  if (lhsSubRefs?.length > 0) {
+    // At each position, expand any dimensions or use a subscript (index) directly
+    const subOrDimNames = lhsSubRefs.map(subRef => subRef.subName)
+    return expandDims(lhsVarDef.varName, subOrDimNames)
+  } else {
+    // No subscripts, so include a single variable name
+    return [lhsVarDef.varName]
+  }
+}
+
+/**
+ * Return an array of all expanded subscript combinations.
+ *
+ * @param {string} baseVarName The base name of the variable.
+ * @param {string[]} subOrDimNames The array of subscript or dimension names.
+ * @returns {string[]} An array of string representations of subscripted references,
+ * e.g., `'x[A1,B1]' ,'x[A1,B2]', ...]`.
+ */
+function expandDims(baseVarName, subOrDimNames) {
+  // Expand the dimension for each position
+  const expanded = subOrDimNames.map(name => expandDim(name).flat(Infinity))
+
+  // Expand these into the set of all combinations of subscripts for the variable
+  const origCombos = cartesianProductOf(expanded)
+  return origCombos.map(combo => {
+    const subs = combo.join(',')
+    return `${baseVarName}[${subs}]`
+  })
+}
+
+/**
+ * Return an array containing all subscript (index) names in the given dimension.  If
+ * the given name is a subscript, it will return a single-element array with that
+ * subscript name.
+ *
+ * @param {string} subOrDimName A subscript or dimension name.
+ * @returns {string[]} A (possibly nested) array of subscript names.
+ */
+function expandDim(subOrDimName) {
+  // Convert the name to an ID
+  const subOrDimId = canonicalName(subOrDimName)
+
+  if (isDimension(subOrDimId)) {
+    // Get the object for the dimension
+    const dimObj = sub(subOrDimId)
+
+    // The dimension may contain a mix of individual subscripts (indices) and/or subdimensions,
+    // so recursively expand them
+    return dimObj.modelValue.map(expandDim)
+  } else {
+    // This is an individual subscript (index), so return it directly
+    return [subOrDimName]
+  }
+}