Add sequence literals

Src/PCompiler/CompilerCore/Backend/CSharp/CSharpCodeGenerator.cs

@@ -1486,6 +1486,19 @@ private void WriteExpr(CompilationContext context, StringWriter output, IPExpr p
                     context.Write(output, ")");
                     break;
 
+                case SequenceLiteralExpr sequenceLiteralExpr:
+                    context.Write(output, $"new {GetCSharpType(sequenceLiteralExpr.Type)}(new List<IPValue>");
+                    context.Write(output, "{");
+                    var sep2 = "";
+                    foreach (var elem in sequenceLiteralExpr.SequenceElements)
+                    {
+                        context.Write(output, sep2);
+                        WriteExpr(context, output, elem);
+                        sep2 = ", ";
+                    }
+                    context.Write(output, "})");
+                    break;
+
                 case ValuesExpr valuesExpr:
                     context.Write(output, "(");
                     WriteExpr(context, output, valuesExpr.Expr);

Src/PCompiler/CompilerCore/Backend/Debugging/IrToPseudoP.cs

@@ -543,6 +543,10 @@ protected override void WriteExpr(IPExpr expr)
                     WriteParts("null");
                     break;
 
+                case SequenceLiteralExpr sequenceLiteralExpr:
+                    WriteParts("{|", sequenceLiteralExpr.SequenceElements, "|}");
+                    break;
+
                 case SeqAccessExpr seqAccessExpr:
                     WriteParts("(", seqAccessExpr.SeqExpr, ")[", seqAccessExpr.IndexExpr, "]");
                     break;

Src/PCompiler/CompilerCore/Backend/IRTransformer.cs

@@ -268,6 +268,13 @@ public static void SimplifyMethod(Function function)
                     deps.Add(ndStore);
                     return (ndTemp, deps);
 
+                case SequenceLiteralExpr sequenceLiteralExpr:
+                    (var sequenceElements, var sequenceElementDeps) = SimplifyArgPack(sequenceLiteralExpr.SequenceElements);
+                    deps.AddRange(sequenceElementDeps);
+                    (var seqElementsVal, var seqElementsStore) = SaveInTemporary(new SequenceLiteralExpr(location, sequenceElements));
+                    deps.Add(seqElementsStore);
+                    return (seqElementsVal, deps);
+
                 case SeqAccessExpr seqAccessExpr:
                     (var seqExpr, var seqDeps) = SimplifyExpression(seqAccessExpr.SeqExpr);
                     (var seqIdx, var seqIdxDeps) = SimplifyExpression(seqAccessExpr.IndexExpr);

Src/PCompiler/CompilerCore/Parser/PLexer.g4

@@ -134,6 +134,8 @@ LBRACK : '[' ;
 RBRACK : ']' ;
 LPAREN : '(' ;
 RPAREN : ')' ;
+LSEQ   : '{|';
+RSEQ   : '|}';
 SEMI   : ';' ;
 COMMA  : ',' ;
 DOT    : '.' ;

Src/PCompiler/CompilerCore/Parser/PParser.g4

@@ -170,6 +170,7 @@ noParamAnonEventHandler : functionBody;
 expr : primitive                                      # PrimitiveExpr
      | LPAREN unnamedTupleBody RPAREN                 # UnnamedTupleExpr
      | LPAREN namedTupleBody RPAREN                   # NamedTupleExpr
+     | LSEQ seqElems RSEQ                             # SequenceLiteralExpr
      | LPAREN expr RPAREN                             # ParenExpr
      | expr DOT field=iden                            # NamedTupleAccessExpr
      | expr DOT field=int                             # TupleAccessExpr
@@ -212,6 +213,10 @@ floatLiteral : pre=IntLiteral? DOT post=IntLiteral # DecimalFloat
              | FLOAT LPAREN base=IntLiteral COMMA exp=IntLiteral RPAREN # ExpFloat
              ;
 
+seqElems :
+         | elems+=primitive (COMMA elems+=primitive)*
+         ;
+
 unnamedTupleBody : fields+=rvalue COMMA
                  | fields+=rvalue (COMMA fields+=rvalue)+
                  ;

Src/PCompiler/CompilerCore/TypeChecker/AST/Expressions/SequenceLiteralExpr.cs

@@ -0,0 +1,29 @@
+using System.Collections.Generic;
+using System.Linq;
+using Antlr4.Runtime;
+using Plang.Compiler.TypeChecker.Types;
+
+namespace Plang.Compiler.TypeChecker.AST.Expressions
+{
+    public class SequenceLiteralExpr: IPExpr
+    {
+        public SequenceLiteralExpr(ParserRuleContext sourceLocation, IReadOnlyList<IPExpr> sequenceElements)
+        {
+            SourceLocation = sourceLocation;
+            SequenceElements = sequenceElements;
+
+            if (sequenceElements.Count > 0) {
+                Type = new SequenceType(sequenceElements[0].Type);
+            }
+            else {
+                Type = new SequenceType(PrimitiveType.Any);
+            }
+        }
+
+        public IReadOnlyList<IPExpr> SequenceElements { get; }
+
+        public ParserRuleContext SourceLocation { get; }
+
+        public PLanguageType Type { get; }
+    }
+}

Src/PCompiler/CompilerCore/TypeChecker/DeclarationStubVisitor.cs

@@ -246,6 +246,11 @@ public override object VisitKeywordExpr(PParser.KeywordExprContext context)
             return null;
         }
 
+        public override object VisitSequenceLiteralExpr(PParser.SequenceLiteralExprContext context)
+        {
+            return null;
+        }
+
         public override object VisitSeqAccessExpr(PParser.SeqAccessExprContext context)
         {
             return null;

Src/PCompiler/CompilerCore/TypeChecker/ExprVisitor.cs

@@ -76,6 +76,23 @@ public override IPExpr VisitTupleAccessExpr(PParser.TupleAccessExprContext conte
             return new TupleAccessExpr(context, subExpr, fieldNo, tuple.Types[fieldNo]);
         }
 
+        public override IPExpr VisitSequenceLiteralExpr(PParser.SequenceLiteralExprContext context) {
+            var elems = context.seqElems()._elems.Select(Visit).ToArray();
+
+            // check whether all elements have the same type
+            if (elems.Count() > 0) {
+                var firstElementType = elems[0].Type;
+                for (int i = 1; i < elems.Count(); i++) {
+                    var currElementType = elems[i].Type;
+                    if (!currElementType.Equals(firstElementType)) {
+                        throw handler.TypeMismatch(context.seqElems()._elems[i], currElementType, firstElementType);
+                    }
+                }
+            }
+
+            return new SequenceLiteralExpr(context, elems);
+        }
+
         public override IPExpr VisitSeqAccessExpr(PParser.SeqAccessExprContext context)
         {
             var seqOrMap = Visit(context.seq);

Tst/RegressionTests/Feature3Exprs/Correct/SequenceLiteralExpr/SequenceLiteralExpr.p

@@ -0,0 +1,29 @@
+machine Main {
+    var s1: seq[int];
+    var s2: seq[any];
+    var s3: seq[bool];
+    var a: int;
+
+    start state S
+    {
+    entry
+       {
+          s1 = {| 1 , 2 , 3 |};
+          assert (s1[0] == 1);
+          assert (s1[1] == 2);
+          assert (s1[2] == 3);
+
+          s2 = {| true, false, true |};
+          assert (s2[0] as bool);
+          assert (!(s2[1] as bool));
+          assert (s2[2] as bool);
+
+          s1 = {| a, a, a |};
+          assert (s1[0] == 0);
+          assert (s1[1] == 0);
+          assert (s1[2] == 0);
+
+          s3 = {||} as seq[bool];
+       }
+    }
+}

Tst/RegressionTests/Feature3Exprs/StaticError/SequenceLiterals/ExprOperators.p

@@ -0,0 +1,12 @@
+machine Main {
+    var s1 : seq[bool];
+
+    start state S
+    {
+       entry
+       {
+          s1 = {| true, 1, 2 |}; //error: "got type int, expected bool"
+		  raise halt;
+       }
+    }
+}