feat(core): implement FMI 3.0 multi-dimensional array vectorization and slicing

Author: nachawati

packages/core/src/compiler/context.ts

@@ -16,6 +16,11 @@ import { ModelicaPoParser, ModelicaTranslation } from "./modelica/po.js";
 import { ModelicaStoredDefinitionSyntaxNode } from "./modelica/syntax.js";
 import { Scope } from "./scope.js";
 
+export interface ModelicaCompilerOptions {
+  arrayMode?: "scalarize" | "preserve";
+  fmiVersion?: "2.0" | "3.0";
+}
+
 /**
  * The compiler context managing file system resources, translations, plugins, and loaded Modelica code.
  */
@@ -95,15 +100,15 @@ export class Context extends Scope {
    * @param name - The fully qualified name of the Modelica class to flatten.
    * @returns The flattened DAE (Differential Algebraic Equation) output as a string, or null if the class is not found or has errors.
    */
-  flatten(name: string): string | null {
-    const dae = this.flattenDAE(name);
+  flatten(name: string, options?: ModelicaCompilerOptions): string | null {
+    const dae = this.flattenDAE(name, options);
     if (!dae) return null;
     const out = new StringWriter();
     dae.accept(new ModelicaDAEPrinter(out));
     return out.toString();
   }
 
-  flattenDAE(name: string): ModelicaDAE | null {
+  flattenDAE(name: string, options?: ModelicaCompilerOptions): ModelicaDAE | null {
     const instance = this.query(name);
     if (!instance) return null;
     const dae = new ModelicaDAE(name ?? instance.name ?? "DAE", instance.description);
@@ -114,7 +119,7 @@ export class Context extends Scope {
     ) {
       dae.classKind = instance.classKind;
     }
-    const flattener = new ModelicaFlattener();
+    const flattener = new ModelicaFlattener(options);
     instance.accept(flattener, ["", dae]);
     flattener.generateFlowBalanceEquations(dae);
     flattener.foldDAEConstants(dae);

packages/core/src/compiler/modelica/dae.ts

@@ -259,6 +259,49 @@ export class ModelicaSimpleEquation extends ModelicaEquation {
   }
 }
 
+export class ModelicaArrayEquation extends ModelicaEquation {
+  expression1: ModelicaExpression;
+  expression2: ModelicaExpression;
+
+  constructor(expression1: ModelicaExpression, expression2: ModelicaExpression, description?: string | null) {
+    super(description);
+    this.expression1 = expression1;
+    this.expression2 = expression2;
+  }
+
+  override accept<R, A>(visitor: IModelicaDAEVisitor<R, A>, argument?: A): R {
+    return visitor.visitArrayEquation(this, argument);
+  }
+
+  override get hash(): string {
+    const hash = createHash("sha256");
+    hash.update(this.expression1.hash);
+    hash.update("=array=");
+    hash.update(this.expression2.hash);
+    return hash.digest("hex");
+  }
+
+  override get toJSON(): JSONValue {
+    return {
+      "@type": "ArrayEquation",
+      expression1: this.expression1.toJSON,
+      expression2: this.expression2.toJSON,
+      description: this.description,
+    };
+  }
+
+  override get toRDF(): Triple[] {
+    const id = `_:eq_${this.hash.substring(0, 8)}`;
+    return [
+      { s: id, p: "rdf:type", o: "modelica:ArrayEquation" },
+      { s: id, p: "modelica:expression1", o: `_:expr_${this.expression1.hash.substring(0, 8)}` },
+      { s: id, p: "modelica:expression2", o: `_:expr_${this.expression2.hash.substring(0, 8)}` },
+      ...this.expression1.toRDF,
+      ...this.expression2.toRDF,
+    ];
+  }
+}
+
 /** Represents a standalone function call as an equation (e.g., `assert(...)`, `Func(2)`). */
 export class ModelicaFunctionCallEquation extends ModelicaEquation {
   call: ModelicaFunctionCallExpression;
@@ -3604,6 +3647,8 @@ export interface IModelicaDAEVisitor<R, A> {
 
   visitSimpleEquation(node: ModelicaSimpleEquation, argument?: A): R;
 
+  visitArrayEquation(node: ModelicaArrayEquation, argument?: A): R;
+
   visitSubscriptedExpression(node: ModelicaSubscriptedExpression, argument?: A): R;
 
   visitTupleExpression(node: ModelicaTupleExpression, argument?: A): R;
@@ -3794,6 +3839,11 @@ export abstract class ModelicaDAEVisitor<A> implements IModelicaDAEVisitor<void,
     node.expression2.accept(this, argument);
   }
 
+  visitArrayEquation(node: ModelicaArrayEquation, argument?: A): void {
+    node.expression1.accept(this, argument);
+    node.expression2.accept(this, argument);
+  }
+
   visitStringLiteral(node: ModelicaStringLiteral, argument?: A): void {
     /* no-op */
   }
@@ -3890,6 +3940,14 @@ export class ModelicaDAEPrinter extends ModelicaDAEVisitor<never> {
     this.out.write(";\n");
   }
 
+  visitArrayEquation(node: ModelicaArrayEquation): void {
+    this.out.write(this.indent());
+    node.expression1.accept(this);
+    this.out.write(" = ");
+    node.expression2.accept(this);
+    this.out.write(";\n");
+  }
+
   visitBreakStatement(node: ModelicaBreakStatement): void {
     this.out.write(this.indent() + "break;\n");
   }