Merge pull request #1457 from lf-lang/ts-cleanups

TypeScript generator cleanups

org.lflang/src/org/lflang/CommonExtensions.kt

@@ -158,6 +158,16 @@ fun <T> Iterable<T>.joinWithCommasLn(
     transform: (T) -> CharSequence = { it.toString() }
 ): String = joinWithCommas(prefix, postfix, skipLines = true, trailing, transform)
 
+/**
+ * Join the elements of [this] sequence with newlines. The
+ * [prefix] and [postfix] are added even if this iterable is empty.
+ */
+fun <T> Iterable<T>.joinWithLn(
+    prefix: CharSequence = "",
+    postfix: CharSequence = "",
+    transform: (T) -> CharSequence
+): String = joinToString(separator = "\n", prefix = prefix, postfix = postfix, transform = transform)
+
 /**
  * Join this list with commas, surrounding it with angled brackets (`<...>`).
  * If this list is empty, returns an empty string.

org.lflang/src/org/lflang/generator/GeneratorUtils.kt

@@ -2,11 +2,16 @@ package org.lflang.generator
 
 import org.eclipse.emf.ecore.EObject
 import org.eclipse.xtext.nodemodel.util.NodeModelUtils
-import org.lflang.ErrorReporter
+import org.lflang.InferredType
+import org.lflang.isInitWithBraces
+import org.lflang.lf.Expression
+import org.lflang.lf.Instantiation
+import org.lflang.lf.LfFactory
+import org.lflang.lf.Parameter
+import org.lflang.lf.StateVar
 import org.lflang.toPath
-import org.lflang.toUnixString
 import org.lflang.toTextTokenBased
-import org.lflang.lf.Instantiation
+import org.lflang.toUnixString
 
 /** A transparent type alias to document when a string contains target code. */
 typealias TargetCode = String
@@ -42,3 +47,48 @@ fun EObject.locationInfo(): LocationInfo {
         lfText = toTextTokenBased() ?: ""
     )
 }
+
+
+/**
+ * Returns the target code for the initial value of [sv].
+ */
+fun TargetTypes.getTargetInitializer(sv: StateVar): TargetCode =
+    this.getTargetInitializer(sv.init, sv.type, sv.braces.isNotEmpty())
+
+/**
+ * Returns the target code for the default value of the [param].
+ */
+fun TargetTypes.getTargetInitializer(param: Parameter): TargetCode =
+    this.getTargetInitializer(param.init, param.type, param.isInitWithBraces)
+
+/**
+ * Returns the target code for the [getActualValue] of the
+ * param for this instantiation.
+ */
+fun TargetTypes.getTargetInitializer(param: Parameter, inst: Instantiation): TargetCode {
+    val init = inst.getActualValue(param)
+    return getTargetInitializer(init, param.type, param.isInitWithBraces)
+}
+
+/**
+ * Return the actual value of a parameter for the given instantiation.
+ * The value is defaulted to the default value for the parameter if
+ * there is no explicit assignment. If there is no default value, the
+ * source code is invalid (param is required)
+ */
+fun Instantiation.getActualValue(param: Parameter): List<Expression> =
+    parameters.firstOrNull { it.lhs == param }?.rhs
+        ?: param.init
+        ?: throw InvalidLfSourceException(this, "No value for parameter ${param.name}")
+
+
+/**
+ * Return the target code for the given expression, given
+ * that it's a time expression.
+ */
+fun TargetTypes.getTargetTimeExpr(v: Expression): TargetCode =
+    this.getTargetExpr(v, InferredType.time())
+
+/** If this is null, return the literal 0. */
+fun Expression?.orZero(): Expression =
+    this ?: LfFactory.eINSTANCE.createLiteral().apply { literal = "0" }

org.lflang/src/org/lflang/generator/TargetTypes.java

@@ -6,7 +6,6 @@
 
 import org.lflang.ASTUtils;
 import org.lflang.InferredType;
-import org.lflang.TimeUnit;
 import org.lflang.TimeValue;
 import org.lflang.lf.Action;
 import org.lflang.lf.Code;
@@ -64,6 +63,10 @@ public interface TargetTypes {
     String getTargetVariableSizeListType(String baseType);
 
 
+    default String getTargetParamRef(ParameterReference expr, InferredType typeOrNull) {
+        return escapeIdentifier(expr.getParameter().getName());
+    }
+
     /**
      * Return an "undefined" type which is used as a default
      * when a type cannot be inferred.
@@ -232,7 +235,7 @@ default String getTargetExpr(Expression expr, InferredType type) {
         if (ASTUtils.isZero(expr) && type != null && type.isTime) {
             return getTargetTimeExpr(TimeValue.ZERO);
         } else if (expr instanceof ParameterReference) {
-            return escapeIdentifier(((ParameterReference) expr).getParameter().getName());
+            return getTargetParamRef((ParameterReference) expr, type);
         } else if (expr instanceof Time) {
             return getTargetTimeExpr((Time) expr);
         } else if (expr instanceof Literal) {
@@ -249,6 +252,6 @@ default String getTargetExpr(Expression expr, InferredType type) {
      * target code.
      */
     default String getTargetTimeExpr(Time t) {
-        return getTargetTimeExpr(new TimeValue(t.getInterval(), TimeUnit.fromName(t.getUnit())));
+        return getTargetTimeExpr(ASTUtils.toTimeValue(t));
     }
 }

org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt

@@ -28,6 +28,7 @@ import org.lflang.generator.PrependOperator
 import org.lflang.isBank
 import org.lflang.isMultiport
 import org.lflang.hasMultipleConnections
+import org.lflang.joinWithLn
 import org.lflang.lf.*
 
 /**
@@ -175,9 +176,9 @@ class CppAssembleMethodGenerator(private val reactor: Reactor) {
             """
                 |// connection $idx
                 |std::vector<$portType> __lf_left_ports_$idx;
-            ${" |"..c.leftPorts.joinToString("\n") { addAllPortsToVector(it, "__lf_left_ports_$idx") }}
+            ${" |"..c.leftPorts.joinWithLn { addAllPortsToVector(it, "__lf_left_ports_$idx") }}
                 |std::vector<$portType> __lf_right_ports_$idx;
-            ${" |"..c.rightPorts.joinToString("\n") { addAllPortsToVector(it, "__lf_right_ports_$idx") }}
+            ${" |"..c.rightPorts.joinWithLn { addAllPortsToVector(it, "__lf_right_ports_$idx") }}
                 |lfutil::bind_multiple_ports(__lf_left_ports_$idx, __lf_right_ports_$idx, ${c.isIterated});
             """.trimMargin()
         }

org.lflang/src/org/lflang/generator/cpp/CppInstanceGenerator.kt

@@ -132,7 +132,7 @@ class CppInstanceGenerator(
     }
 
     fun generateConstructorInitializers() =
-        reactor.instantiations.filter { it.isBank }.joinToString("\n") { generateConstructorInitializer(it) }
+        reactor.instantiations.filter { it.isBank }.joinWithLn { generateConstructorInitializer(it) }
 
     /** Generate constructor initializers for all reactor instantiations */
     fun generateInitializers(): String =

org.lflang/src/org/lflang/generator/cpp/CppPortGenerator.kt

@@ -26,6 +26,7 @@ package org.lflang.generator.cpp
 
 import org.lflang.inferredType
 import org.lflang.isMultiport
+import org.lflang.joinWithLn
 import org.lflang.lf.Input
 import org.lflang.lf.Output
 import org.lflang.lf.Port
@@ -89,8 +90,8 @@ class CppPortGenerator(private val reactor: Reactor) {
     }
 
     fun generateConstructorInitializers() =
-        reactor.inputs.filter { it.isMultiport }.joinToString("\n") { generateConstructorInitializer(it) } +
-                reactor.outputs.filter { it.isMultiport }.joinToString("\n") { generateConstructorInitializer(it) }
+        reactor.inputs.filter { it.isMultiport }.joinWithLn { generateConstructorInitializer(it) } +
+                reactor.outputs.filter { it.isMultiport }.joinWithLn { generateConstructorInitializer(it) }
 
     fun generateDeclarations() =
         reactor.inputs.joinToString("\n", "// input ports\n", postfix = "\n") { generateDeclaration(it) } +

org.lflang/src/org/lflang/generator/cpp/CppReactionGenerator.kt

@@ -26,6 +26,7 @@ package org.lflang.generator.cpp
 
 import org.lflang.generator.PrependOperator
 import org.lflang.isBank
+import org.lflang.joinWithLn
 import org.lflang.label
 import org.lflang.lf.*
 import org.lflang.priority
@@ -193,15 +194,15 @@ class CppReactionGenerator(
     }
 
     private fun generateViews(r: Reaction) =
-        r.allReferencedContainers.joinToString("\n") { generateViewForContainer(r, it) }
+        r.allReferencedContainers.joinWithLn { generateViewForContainer(r, it) }
 
     private fun generateViewInitializers(r: Reaction) =
         r.allReferencedContainers.filterNot { it.isBank }
-            .joinToString("\n") { ", ${r.getViewInstanceName(it)}(${it.name}.get()) " }
+            .joinWithLn { ", ${r.getViewInstanceName(it)}(${it.name}.get()) " }
 
     private fun generateViewConstructorInitializers(r: Reaction) =
         r.allReferencedContainers.filter { it.isBank }
-            .joinToString("\n") {
+            .joinWithLn {
                 val viewInstance = r.getViewInstanceName(it)
                 """
                     $viewInstance.reserve(${it.name}.size());