Add bank & multiport support in TypeScript code generator with > 30 multiport tests.

org.lflang/src/lib/ts/package.json

@@ -12,7 +12,8 @@
         "command-line-usage": "^6.1.0",
         "microtime": "^3.0.0",
         "ulog": "^2.0.0-beta.7",
-        "google-protobuf": "^3.7.4"
+        "google-protobuf": "^3.7.4",
+        "uuid": "^8.3.2"
     },
     "devDependencies": {
         "@babel/cli": "^7.8.4",
@@ -26,6 +27,7 @@
         "@babel/preset-typescript": "^7.8.3",
         "@types/google-protobuf": "^3.7.4",
         "@types/node": "^13.9.2",
+        "@types/uuid": "^8.3.4",
         "@typescript-eslint/eslint-plugin": "^5.8.1",
         "@typescript-eslint/parser": "^5.8.1",
         "eslint": "^8.5.0",

org.lflang/src/org/lflang/AstExtensions.kt

@@ -373,6 +373,11 @@ val Action.isPhysical get() = this.origin == ActionOrigin.PHYSICAL
  */
 val Port.isMultiport get() = ASTUtils.isMultiport(this)
 
+/**
+ * Return true if the receiving Variable is a port and a multiport.
+ */
+val Variable.isMultiport get() = (this is Port) && this.isMultiport
+
 /** Get the reactor that is instantiated in the receiving instantiation. */
 val Instantiation.reactor get() = this.reactorClass.toDefinition()
 

org.lflang/src/org/lflang/Target.java

@@ -473,6 +473,7 @@ public boolean supportsMultiports() {
         case CPP:
         case Python:
         case Rust:
+        case TS:
             return true;
         }
         return false;
@@ -491,6 +492,7 @@ public boolean supportsParameterizedWidths() {
         case CPP:
         case Python:
         case Rust:
+        case TS:
             return true;
         }
         return false;

org.lflang/src/org/lflang/generator/ts/TSConnectionGenerator.kt

@@ -1,7 +1,15 @@
 package org.lflang.generator.ts
 
 import org.lflang.ErrorReporter
+import org.lflang.hasMultipleConnections
+import org.lflang.isBank
+import org.lflang.isInput
+import org.lflang.isMultiport
 import org.lflang.lf.Connection
+import org.lflang.lf.Port
+import org.lflang.lf.Reactor
+import org.lflang.lf.VarRef
+import org.lflang.toText
 import java.util.*
 
 /**
@@ -14,30 +22,70 @@ class TSConnectionGenerator (
 ) {
     // There is no generateClassProperties() for connections
 
+    private fun getPortTypeName(port: Port, genericTypeMap: HashMap<String, String>): String {
+        var portType = getPortType(port)
+        portType = genericTypeMap[portType]?: portType
+        return (if(port.isInput) "__In" else "__Out") +
+                "${if(port.isMultiport) "Multi" else ""}Port<$portType>"
+    }
+
+    private fun getPortName(port: VarRef, genericTypeMap: HashMap<String, String>): String {
+        var portName = ""
+        if (port.container != null) {
+            if (port.container.isBank) {
+                portName += "...this.${port.container.name}.all().reduce(" +
+                        "(__acc, __val) => __acc.concat(__val.${port.variable.name}), " +
+                        "new Array<${getPortTypeName(port.variable as Port, genericTypeMap)}>(0))"
+                return portName
+            }
+            portName += port.container.name + "."
+        }
+        portName += port.variable.name
+        return "this.$portName"
+    }
+
+    private fun getPortNames(ports: List<VarRef>): List<String> {
+        var portNames = LinkedList<String>()
+        var genericTypeMap: HashMap<String, String>? = null
+        for (varRef in ports) {
+            if (genericTypeMap == null) {
+                genericTypeMap = HashMap<String, String>()
+            }
+            if (varRef.container != null) {
+                for ((index, typeParam) in (varRef.container.reactorClass as Reactor).typeParms.withIndex()) {
+                    genericTypeMap[typeParam.toText().split(" ")[0]] = varRef.container.typeParms[index].toText()
+                }
+            }
+            portNames.add(getPortName(varRef, genericTypeMap))
+        }
+        return portNames
+    }
+
     fun generateInstantiations(): String {
         val connectionInstantiations = LinkedList<String>()
         for (connection in connections) {
-            var leftPortName = ""
-            // FIXME: Add support for multiports.
-            if (connection.leftPorts.size > 1) {
-                errorReporter.reportError(connection, "Multiports are not yet supported in the TypeScript target.")
+            if (connection.hasMultipleConnections) {
+                var leftPortNames = getPortNames(connection.leftPorts)
+                var rightPortNames = getPortNames(connection.rightPorts)
+                val leftPortName = leftPortNames.joinToString(prefix = "[", separator = ", ", postfix = "]")
+                val rightPortName = rightPortNames.joinToString(prefix = "[", separator = ", ", postfix = "]")
+                connectionInstantiations.add("this._connectMulti($leftPortName, $rightPortName, ${connection.isIterated});")
             } else {
+                var leftPortName = ""
+
                 if (connection.leftPorts[0].container != null) {
                     leftPortName += connection.leftPorts[0].container.name + "."
                 }
                 leftPortName += connection.leftPorts[0].variable.name
-            }
-            var rightPortName = ""
-            if (connection.leftPorts.size > 1) {
-                errorReporter.reportError(connection, "Multiports are not yet supported in the TypeScript target.")
-            } else {
+                var rightPortName = ""
+
                 if (connection.rightPorts[0].container != null) {
                     rightPortName += connection.rightPorts[0].container.name + "."
                 }
                 rightPortName += connection.rightPorts[0].variable.name
-            }
-            if (leftPortName != "" && rightPortName != "") {
-                connectionInstantiations.add("this._connect(this.$leftPortName, this.$rightPortName);")
+                if (leftPortName != "" && rightPortName != "") {
+                    connectionInstantiations.add("this._connect(this.$leftPortName, this.$rightPortName);")
+                }
             }
         }
         return connectionInstantiations.joinToString("\n")

org.lflang/src/org/lflang/generator/ts/TSConstructorGenerator.kt

@@ -25,8 +25,6 @@ class TSConstructorGenerator (
     private fun getInitializerList(param: Parameter): List<String> =
         tsGenerator.getInitializerListW(param)
 
-    private fun Parameter.getTargetType(): String = tsGenerator.getTargetTypeW(this)
-
     // Initializer functions
     private fun getTargetInitializerHelper(param: Parameter,
                                    list: List<String>): String {

org.lflang/src/org/lflang/generator/ts/TSExtensions.kt

@@ -0,0 +1,50 @@
+package org.lflang.generator.ts
+
+import org.lflang.isBank
+import org.lflang.isMultiport
+import org.lflang.lf.Parameter
+import org.lflang.lf.Port
+import org.lflang.lf.Type
+import org.lflang.lf.WidthSpec
+import org.lflang.toText
+
+/**
+ * The following definition provide extension that are useful for TypeScript target.
+ *
+ *  @author {Hokeun Kim <[email protected]>}
+ */
+fun WidthSpec.toTSCode(): String = terms.joinToString(" + ") {
+    when {
+        it.parameter != null -> "${it.parameter.name}"
+        it.port != null -> with(it.port) {
+            if (container?.isBank == true) {
+                if ((variable as Port).isMultiport) "this.${container.name}.all().length * this.${container.name}.all()[0].${variable.name}.width()"
+                else "this.${container.name}.all().length"
+            } else {
+                if ((variable as Port).isMultiport) "this.${container.name}.${variable.name}.width()"
+                else "1"
+            }
+        }
+        it.code != null -> it.code.toText()
+        else -> it.width.toString()
+    }
+}
+
+private fun Type.getTargetType(): String = TSTypes.getTargetType(this)
+
+/**
+ * Return a TS type for the specified port.
+ * If the type has not been specified, return
+ * "Present" which is the base type for ports.
+ * @param port The port
+ * @return The TS type.
+ */
+fun getPortType(port: Port): String {
+    if (port.type != null) {
+        return port.type.getTargetType()
+    } else {
+        return "Present"
+    }
+}
+
+fun Parameter.getTargetType(): String = TSTypes.getTargetType(this)

org.lflang/src/org/lflang/generator/ts/TSGenerator.kt

@@ -95,10 +95,10 @@ class TSGenerator(
          * Files to be copied from the reactor-ts submodule into the generated
          * source directory.
          */
-        val RUNTIME_FILES = arrayOf("cli.ts", "command-line-args.d.ts",
-            "command-line-usage.d.ts", "component.ts", "federation.ts", "reaction.ts",
-            "reactor.ts", "microtime.d.ts", "nanotimer.d.ts", "time.ts", "ulog.d.ts",
-            "util.ts")
+        val RUNTIME_FILES = arrayOf("action.ts", "bank.ts", "cli.ts", "command-line-args.d.ts",
+            "command-line-usage.d.ts", "component.ts", "event.ts", "federation.ts", "internal.ts",
+            "reaction.ts", "reactor.ts", "microtime.d.ts", "multiport.ts", "nanotimer.d.ts", "port.ts",
+            "state.ts", "strings.ts", "time.ts", "trigger.ts", "types.ts", "ulog.d.ts", "util.ts")
 
         private val VG = ValueGenerator(::timeInTargetLanguage) { param -> "this.${param.name}.get()" }
 
@@ -654,4 +654,6 @@ class TSGenerator(
     override fun getTarget(): Target {
         return Target.TS
     }
+
+    override fun generateAfterDelaysWithVariableWidth() = false
 }

org.lflang/src/org/lflang/generator/ts/TSImportPreambleGenerator.kt

@@ -51,10 +51,16 @@ class TSImportPreambleGenerator(
         const val DEFAULT_IMPORTS =  """
             |import commandLineArgs from 'command-line-args'
             |import commandLineUsage from 'command-line-usage'
-            |import {Args as __Args, Present, Parameter as __Parameter, State as __State, Variable as __Variable, Read, Triggers as __Triggers, ReadWrite, Write, Action as __Action, Startup as __Startup, Sched, Timer as __Timer, Reactor as __Reactor, Port as __Port, OutPort as __OutPort, InPort as __InPort, App as __App} from './core/reactor'
-            |import {Reaction as __Reaction} from './core/reaction'
+            |import {Parameter as __Parameter, Timer as __Timer, Reactor as __Reactor, App as __App} from './core/reactor'
+            |import {Action as __Action, Startup as __Startup} from './core/action'
+            |import {Bank as __Bank} from './core/bank'
             |import {FederatedApp as __FederatedApp} from './core/federation'
+            |import {InPort as __InPort, OutPort as __OutPort, Port as __Port} from './core/port'
+            |import {InMultiPort as __InMultiPort, OutMultiPort as __OutMultiPort} from './core/multiport'
+            |import {Reaction as __Reaction} from './core/reaction'
+            |import {State as __State} from './core/state'
             |import {TimeUnit, TimeValue, Tag as __Tag, Origin as __Origin} from './core/time'
+            |import {Args as __Args, Variable as __Variable, Triggers as __Triggers, Present, Read, Write, ReadWrite, MultiReadWrite, Sched} from './core/types'
             |import {Log} from './core/util'
             |import {ProcessedCommandLineArgs as __ProcessedCommandLineArgs, CommandLineOptionDefs as __CommandLineOptionDefs, CommandLineUsageDefs as __CommandLineUsageDefs, CommandLineOptionSpec as __CommandLineOptionSpec, unitBasedTimeValueCLAType as __unitBasedTimeValueCLAType, booleanCLAType as __booleanCLAType} from './core/cli'
             |"""

org.lflang/src/org/lflang/generator/ts/TSInstanceGenerator.kt

@@ -1,9 +1,13 @@
 package org.lflang.generator.ts
 
+import org.lflang.ErrorReporter
 import org.lflang.federated.FederateInstance
+import org.lflang.isBank
 import org.lflang.lf.Instantiation
 import org.lflang.lf.Parameter
 import org.lflang.lf.Reactor
+import org.lflang.lf.TypeParm
+import org.lflang.reactor
 import org.lflang.toDefinition
 import org.lflang.toText
 import java.util.*
@@ -14,6 +18,7 @@ import java.util.*
 class TSInstanceGenerator (
     // TODO(hokeun): Remove dependency on TSGenerator.
     private val tsGenerator: TSGenerator,
+    private val errorReporter: ErrorReporter,
     private val tsReactorGenerator: TSReactorGenerator,
     reactor: Reactor,
     federate: FederateInstance
@@ -39,12 +44,26 @@ class TSInstanceGenerator (
         return tsReactorGenerator.getTargetInitializerHelper(param, getInitializerList(param, i))
     }
 
+    private fun getTypeParams(typeParms: List<TypeParm>): String =
+        if (typeParms.isEmpty()) {""} else {
+            typeParms.joinToString(", ", "<", ">") { it.toText() }}
+
+    private fun getReactorParameterList(parameters: List<Parameter>): String =
+        if (parameters.isEmpty()) { "[__Reactor]" } else {
+            parameters.joinToString(", ", "[__Reactor, ", "]") { it.getTargetType() }}
+
+
     fun generateClassProperties(): String {
         val childReactorClassProperties = LinkedList<String>()
         for (childReactor in childReactors) {
-            val childReactorParams = if (childReactor.typeParms.isEmpty()) {""} else {
-                childReactor.typeParms.joinToString(", ", "<", ">") { it.toText() }}
-            childReactorClassProperties.add("${childReactor.name}: ${childReactor.reactorClass.name}$childReactorParams")
+            if (childReactor.isBank) {
+                childReactorClassProperties.add("${childReactor.name}: " +
+                        "__Bank<${childReactor.reactorClass.name}${getTypeParams(childReactor.typeParms)}, " +
+                        "${getReactorParameterList(childReactor.reactor.parameters)}>")
+            } else {
+                childReactorClassProperties.add("${childReactor.name}: " +
+                        "${childReactor.reactorClass.name}${getTypeParams(childReactor.typeParms)}")
+            }
         }
         return childReactorClassProperties.joinToString("\n")
     }
@@ -55,16 +74,22 @@ class TSInstanceGenerator (
             val childReactorArguments = StringJoiner(", ");
             childReactorArguments.add("this")
 
-            // Iterate through parameters in the order they appear in the
-            // reactor class, find the matching parameter assignments in
-            // the reactor instance, and write the corresponding parameter
-            // value as an argument for the TypeScript constructor
             for (parameter in childReactor.reactorClass.toDefinition().parameters) {
                 childReactorArguments.add(getTargetInitializer(parameter, childReactor))
             }
-
-            childReactorInstantiations.add(
-                "this.${childReactor.name} = new ${childReactor.reactorClass.name}($childReactorArguments)")
+            if (childReactor.isBank) {
+                childReactorInstantiations.add(
+                    "this.${childReactor.name} = " +
+                            "new __Bank<${childReactor.reactorClass.name}${getTypeParams(childReactor.typeParms)}, " +
+                            "${getReactorParameterList(childReactor.reactor.parameters)}>" +
+                            "(this, ${childReactor.widthSpec.toTSCode()}, " +
+                            "${childReactor.reactorClass.name}, " +
+                            "$childReactorArguments)")
+            } else {
+                childReactorInstantiations.add(
+                    "this.${childReactor.name} = " +
+                            "new ${childReactor.reactorClass.name}($childReactorArguments)")
+            }
         }
         return childReactorInstantiations.joinToString("\n")
     }