Merge branch '26-generate-code' into 35-add-builtin-methods

packages/ttsl-lang/src/language/generation/ttsl-python-generator.ts

@@ -971,8 +971,15 @@ while ${this.generateExpression((statement.condition), frame)}:`.appendNewLine()
                     (value) => this.generateExpression(value, frame),
                     { separator: ', ' },
                 )}]`;
-            } else if (isTslInt(expression) || isTslFloat(expression) || isTslBoolean(expression)){
+            } else if (isTslInt(expression) || isTslFloat(expression)){
                 return expandTracedToNode(expression)`${expression.value}`
+            } else if(isTslBoolean(expression)){
+                if(expression.value.valueOf().toString() == "true"){
+                    return expandTracedToNode(expression)`True`
+                } else{
+                    return expandTracedToNode(expression)`False`
+                }
+
             } else if (isTslString(expression)){
                 return expandTracedToNode(expression)`"${expression.value}"`
             } else if (isTslNull(expression)){

packages/ttsl-lang/src/language/grammar/ttsl.langium

@@ -147,16 +147,16 @@ fragment TslFunctionFragment:
 
 interface TslConstant extends TslModuleMember, TslDeclaration {
     timespanValueEntries?: TslTimespanValueEntry[]
-    ^type: TslType
+    ^type: TslType[]
     value?: TslExpression
 }
 
 fragment TslConstantFragment:
     (visibility=TslVisibility)?
     'constant'
     name=ID
-    (':' ^type=TslType ('{' (timespanValueEntries+=TslTimespanValueEntry)* '}' |
-    '=' value=TslExpression ';'?) | '{' (timespanValueEntries+=TslTimespanValueEntry)* '}')
+    (':' ^type+=TslType ('{' (timespanValueEntries+=TslTimespanValueEntry)* '}' |
+    '=' value=TslExpression ';'?) | '{' ((timespanValueEntries+=TslTimespanValueEntry)* | (^type+=TslType '{' (timespanValueEntries+=TslTimespanValueEntry)* '}')*)'}')
 
 ;
 

packages/ttsl-lang/src/language/typing/ttsl-type-computer.ts

@@ -140,8 +140,8 @@ export class TTSLTypeComputer {
         } else if (isTslResult(node)) {
             return this.computeType(node.type);
         } else if (isTslConstant(node)){
-            if(node.type){
-                return this.computeType(node.type);
+            if(node.type.length == 1){
+                return this.computeType(node.type.at(0));
             }else{
                 return UnknownType;
             }
@@ -331,10 +331,11 @@ export class TTSLTypeComputer {
         const target = node.target.ref;
 
         // Compute Type of Constant with different Types for different Timespans
-        if(isTslConstant(target) && !target.type){
+        if(isTslConstant(target) && (!target.type.at(0) || target.type.length >= 2)){
 
             const containingTimespan = this.computeContainingTimespan(node);
             const constantTimespans = this.fillinTimespans(target.timespanValueEntries)
+            console.log(constantTimespans)
 
             if(containingTimespan && constantTimespans){
                 let indexOfCorrectConstant = constantTimespans.indexOf(constantTimespans.filter(timespan => 

packages/ttsl-lang/src/language/validation/names.ts

@@ -124,7 +124,7 @@ const nameShouldBeLowerCamelCase = (node: TslDeclaration, nodeName: string, acce
 };
 
 const isLowerCamelCase = (name: string): boolean => {
-    return /^[a-z][a-zA-Z0-9]*$/gu.test(name);
+    return /^[a-zäöüß][a-zA-Z0-9äöüß]*$/gu.test(name);
 };
 
 const acceptCasingWarning = (

packages/ttsl-lang/tests/resources/generation/modifier/timespan/generated/tests/generator/timespan/gen_input.py

@@ -26,5 +26,11 @@ def getValue(self, date = None):
 
 # Constants --------------------------------------------------------------------
 
-testDict = {"s2000-01-01": 1, "s2001-01-01": 2}
-test = __gen_ClassConstants(testDict)
+myConstantDict = {"s2000-01-01": 1, "s2001-01-01": 2}
+myConstant = __gen_ClassConstants(myConstantDict)
+
+myConstant2Dict = {"s1999-01-01": 0, "s2001-01-01": 0, "s2003-01-01": True}
+myConstant2 = __gen_ClassConstants(myConstant2Dict)
+
+myConstant3Dict = {"s1999-01-01": 0, "s2001-01-01": "a", "s2003-01-01": "b", "s2004-01-01": 2}
+myConstant3 = __gen_ClassConstants(myConstant3Dict)

packages/ttsl-lang/tests/resources/generation/modifier/timespan/input.ttsl

@@ -1,6 +1,25 @@
 package tests.generator.timespan
 
-constant test: Int {
+constant myConstant: Int {
     from 2000-01-01 = 1;
     from 2001-01-01 = 2;
+}
+
+constant myConstant2 {
+    from 1999-01-01: Int = 0;
+    from 2001-01-01: Float = 0.0;
+    from 2003-01-01: Boolean = true;
+}
+
+constant myConstant3 {
+    Int {
+        from 1999-01-01 = 0;
+    }
+    String{
+        from 2001-01-01 = "a";
+        from 2003-01-01 = "b";
+    }
+    Int{
+        from 2004-01-01 = 2;
+    }
 }

packages/ttsl-lang/tests/resources/grammar/modifier/timespan/good.ttsl

@@ -9,3 +9,16 @@ constant test1 {
     from 1999-01-01: Int = 0;
     from 2000-01-01: Float = 1.0;
 }
+
+constant test2 {
+    Int {
+        from 1999-01-01 = 0;
+        from 2000-01-01 = 1;
+    }
+    String{
+        from 2001-01-01 = "a";
+    }
+    Int{
+        from 2003-01-01 = 2;
+    }
+}

packages/ttsl-lang/tests/resources/typing/declarations/constants/main.ttsl

@@ -9,15 +9,37 @@ constant myConstant2 {
     from 2003-01-01: Boolean = false;
 }
 
+constant myConstant3 {
+    Int {
+        from 1999-01-01 = 0;
+    }
+    String{
+        from 2001-01-01 = "a";
+        from 2003-01-01 = "b";
+    }
+    Int{
+        from 2004-01-01 = 2;
+    }
+}
+
 function myFunction() {
     from 1999-05-05{
         # $TEST$ serialization Int
         var »myData« = myConstant2
+        # $TEST$ serialization Int
+        var »myData2« = myConstant3
     } from 2001-09-09{
         # $TEST$ serialization Float
         var »myData« = myConstant2
+        # $TEST$ serialization String
+        var »myData2« = myConstant3
     } from 2003-01-01{
         # $TEST$ serialization Boolean
         var »myData« = myConstant2
+        # $TEST$ serialization String
+        var »myData2« = myConstant3
+    } from 2004-01-01{
+        # $TEST$ serialization Int
+        var »myData« = myConstant3
     }
 }