Introduce the metarecord concept to the language.

Author: alexrp

doc/language/expressions.md

@@ -8,6 +8,7 @@ prefix-expression ::= unary-expression |
 primary-expression ::= parenthesized-expression |
                        block-expression |
                        this-expression |
+                       meta-expression |
                        identifier-expression |
                        literal-expression |
                        module-expression |

doc/language/expressions/meta-expression.md

@@ -0,0 +1,5 @@
+# Meta Expression
+
+```ebnf
+meta-expression ::= 'meta' expression
+```

doc/language/expressions/values/record-expression.md

@@ -3,5 +3,6 @@
 ```ebnf
 record-expression ::= 'rec' record-expression-with? '{' (record-expression-field (',' record-expression-field)* ','?)? '}'
 record-expression-with ::= 'with' expression
+record-expression-meta ::= 'meta' expression
 record-expression-field ::= 'mut'? code-identifier ':' expression
 ```

doc/language/lexical-structure/keywords.md

@@ -27,6 +27,7 @@ normal-keyword ::= 'and' |
                    'in' |
                    'let' |
                    'match' |
+                   'meta' |
                    'mod' |
                    'mut' |
                    'next' |
@@ -71,7 +72,6 @@ type-keyword ::= 'agent' |
 ```ebnf
 reserved-keyword ::= 'friend' |
                      'macro' |
-                     'meta' |
                      'quote' |
                      'unquote' |
                      'yield'

doc/language/types/record-type.md

@@ -1,6 +1,7 @@
 # Record Type
 
 ```ebnf
-record-type ::= 'rec' '{' (record-type-field (',' record-type-field)* ','?)? '}'
+record-type ::= 'rec' '{' (record-type-field (',' record-type-field)* ','?)? '}' record-type-meta?
+record-type-meta ::= 'meta' type
 record-type-field ::= 'mut'? code-identifier ':' type
 ```

doc/toc.md

@@ -95,6 +95,7 @@
     * [Parenthesized Expression](language/expressions/parenthesized-expression.md)
     * [Block Expression](language/expressions/block-expression.md)
     * [This Expression](language/expressions/this-expression.md)
+    * [Meta Expression](language/expressions/meta-expression.md)
     * [Identifier Expression](language/expressions/identifier-expression.md)
     * [Assignment Expression](language/expressions/assignment-expression.md)
     * [Field Expression](language/expressions/field-expression.md)

src/extensions/vscode/syntaxes/celerity.tmLanguage.yml

@@ -38,13 +38,13 @@ patterns:
     - name: keyword.declaration.celerity
       match: \b(const|ext|fn|mod|opaque|pub|test|type|use)\b
     - name: keyword.control.celerity
-      match: \b(as|assert|break|catch|cond|defer|else|for|if|in|let|match|mut|next|raise|recv|ret|tail|try|while)\b
+      match: \b(as|assert|break|catch|cond|defer|else|for|if|in|let|match|meta|mut|next|raise|recv|ret|tail|try|while)\b
     - name: keyword.expression.celerity
       match: \b(and|err|not|or|rec|this|with)\b
     - name: keyword.type.celerity
       match: \b(agent|any|atom|bool|handle|int|none|real|ref|str|unk)\b
     - name: keyword.other.celerity
-      match: \b(friend|macro|meta|quote|unquote|yield)\b
+      match: \b(friend|macro|quote|unquote|yield)\b
     # Identifiers
     - name: support.type.celerity
       match: '[A-Z][0-9a-zA-Z]*'

src/language/core/Semantics/LanguageAnalyzer.cs

@@ -381,12 +381,16 @@ public SubmissionSemantics VisitSubmission(SubmissionSyntax node)
 
         public override DeclarationSubmissionSemantics VisitDeclarationSubmission(DeclarationSubmissionSyntax node)
         {
-            return new(node, VisitDeclaration(node.Declaration));
+            var decl = VisitDeclaration(node.Declaration);
+
+            return new(node, decl);
         }
 
         public override StatementSubmissionSemantics VisitStatementSubmission(StatementSubmissionSyntax node)
         {
-            return new(node, VisitStatement(node.Statement));
+            var stmt = VisitStatement(node.Statement);
+
+            return new(node, stmt);
         }
 
         // Declarations
@@ -580,26 +584,30 @@ public override ModuleExpressionSemantics VisitModuleExpression(ModuleExpression
         public override AggregateExpressionFieldSemantics VisitAggregateExpressionField(
             AggregateExpressionFieldSyntax node)
         {
-            return new(node, VisitExpression(node.Value));
+            var field = VisitExpression(node.Value);
+
+            return new(node, field);
         }
 
         public override RecordExpressionSemantics VisitRecordExpression(RecordExpressionSyntax node)
         {
+            var with = node.With?.Operand is { } w ? VisitExpression(w) : null;
             var fields = ConvertList(node.Fields, static (@this, field) => @this.VisitAggregateExpressionField(field));
+            var meta = node.Meta?.Operand is { } m ? VisitExpression(m) : null;
 
             CheckDuplicateFields(fields, static field => field.Syntax.NameToken, "Record", "assigned");
 
-            return new(node, node.With?.Operand is { } with ? VisitExpression(with) : null, fields);
+            return new(node, with, fields, meta);
         }
 
         public override ErrorExpressionSemantics VisitErrorExpression(ErrorExpressionSyntax node)
         {
-            var fields = ConvertList(
-                node.Fields, static (@this, field) => @this.VisitAggregateExpressionField(field));
+            var with = node.With?.Operand is { } w ? VisitExpression(w) : null;
+            var fields = ConvertList(node.Fields, static (@this, field) => @this.VisitAggregateExpressionField(field));
 
             CheckDuplicateFields(fields, static field => field.Syntax.NameToken, "Error", "assigned");
 
-            return new(node, node.With?.Operand is { } with ? VisitExpression(with) : null, fields);
+            return new(node, with, fields);
         }
 
         public override TupleExpressionSemantics VisitTupleExpression(TupleExpressionSyntax node)
@@ -982,7 +990,9 @@ public override BreakExpressionSemantics VisitBreakExpression(BreakExpressionSyn
         public override ParenthesizedExpressionSemantics VisitParenthesizedExpression(
             ParenthesizedExpressionSyntax node)
         {
-            return new(node, VisitExpression(node.Expression));
+            var expr = VisitExpression(node.Expression);
+
+            return new(node, expr);
         }
 
         public override BlockExpressionSemantics VisitBlockExpression(BlockExpressionSyntax node)
@@ -1065,6 +1075,13 @@ public override ThisExpressionSemantics VisitThisExpression(ThisExpressionSyntax
             return sema;
         }
 
+        public override MetaExpressionSemantics VisitMetaExpression(MetaExpressionSyntax node)
+        {
+            var oper = VisitExpression(node.Operand);
+
+            return new(node, oper);
+        }
+
         public override AssignmentExpressionSemantics VisitAssignmentExpression(AssignmentExpressionSyntax node)
         {
             var left = VisitExpression(node.LeftOperand);
@@ -1101,7 +1118,9 @@ public override AssignmentExpressionSemantics VisitAssignmentExpression(Assignme
 
         public override FieldExpressionSemantics VisitFieldExpression(FieldExpressionSyntax node)
         {
-            return new(node, VisitExpression(node.Subject));
+            var subject = VisitExpression(node.Subject);
+
+            return new(node, subject);
         }
 
         public override IndexExpressionSemantics VisitIndexExpression(IndexExpressionSyntax node)

src/language/core/Semantics/Tree/SemanticTree.xml

@@ -141,6 +141,7 @@
     <Type Name="RecordExpression" Base="AggregateExpression">
         <Node Name="With" Type="Expression" Optional="true" Override="true" />
         <Nodes Name="Field" Type="AggregateExpressionField" Separated="true" Override="true" />
+        <Node Name="Meta" Type="Expression" Optional="true" />
     </Type>
 
     <Type Name="ErrorExpression" Base="AggregateExpression">
@@ -341,6 +342,10 @@
 
     <Type Name="ThisExpression" Base="Expression" />
 
+    <Type Name="MetaExpression">
+        <Node Name="Operand" Type="Expression" />
+    </Type>
+
     <Type Name="IdentifierExpression" Base="Expression">
         <Value Name="Symbol" Type="Symbol?" />
     </Type>

src/language/core/Syntax/LanguageParser.cs

@@ -866,8 +866,17 @@ private RecordTypeSyntax ParseRecordType()
             allowEmpty: true,
             allowTrailing: true);
         var close = Expect(SyntaxTokenKind.CloseBrace);
+        var meta = ParseOptional(SyntaxTokenKind.MetaKeyword, static @this => @this.ParseRecordTypeMeta());
 
-        return new(rec, open, List(fields, seps), close);
+        return new(rec, open, List(fields, seps), close, meta);
+    }
+
+    private RecordTypeMetaSyntax ParseRecordTypeMeta()
+    {
+        var meta = Read();
+        var type = ParseType();
+
+        return new(meta, type);
     }
 
     private ErrorTypeSyntax ParseErrorType()
@@ -1284,6 +1293,7 @@ private ExpressionSyntax ParsePrimaryExpression()
             (var ident, _, _) when SyntaxFacts.IsBindingIdentifier(ident) => ParseIdentifierExpression(),
             (var literal, _, _) when SyntaxFacts.IsLiteral(literal) => ParseLiteralExpression(),
             (SyntaxTokenKind.ThisKeyword, _, _) => ParseThisExpression(),
+            (SyntaxTokenKind.MetaKeyword, _, _) => ParseMetaExpression(),
             (SyntaxTokenKind.UpperIdentifier, _, _) => ParseModuleExpression(),
             (SyntaxTokenKind.FnKeyword, _, _) or
             (SyntaxTokenKind.ErrKeyword, SyntaxTokenKind.FnKeyword, _) => ParseLambdaExpression(),
@@ -1389,6 +1399,14 @@ private ThisExpressionSyntax ParseThisExpression()
         return new(@this);
     }
 
+    private MetaExpressionSyntax ParseMetaExpression()
+    {
+        var meta = Read();
+        var oper = ParseExpression();
+
+        return new(meta, oper);
+    }
+
     private LiteralExpressionSyntax ParseLiteralExpression()
     {
         var literal = Read();
@@ -1415,8 +1433,17 @@ private RecordExpressionSyntax ParseRecordExpression()
             allowEmpty: true,
             allowTrailing: true);
         var close = Expect(SyntaxTokenKind.CloseBrace);
+        var meta = ParseOptional(SyntaxTokenKind.MetaKeyword, static @this => @this.ParseRecordExpressionMeta());
+
+        return new(rec, with, open, List(fields, seps), close, meta);
+    }
+
+    private RecordExpressionMetaSyntax ParseRecordExpressionMeta()
+    {
+        var meta = Read();
+        var operand = ParseExpression();
 
-        return new(rec, with, open, List(fields, seps), close);
+        return new(meta, operand);
     }
 
     private ErrorExpressionSyntax ParseErrorExpression()