add initial implementation of conditional indexer operator

vddCore · vddCore · commit a3a9ec7d6baf · 2025-02-28T10:41:12.000+01:00
diff --git a/Core/EVIL.Grammar/AST/Expressions/IndexerExpression.cs b/Core/EVIL.Grammar/AST/Expressions/IndexerExpression.cs
@@ -10,13 +10,19 @@ public sealed class IndexerExpression : Expression
     public Expression Indexable { get; }
     public Expression KeyExpression { get; }
 
+    public bool IsConditional { get; }
     public bool WillBeAssigned { get; }
 
-    public IndexerExpression(Expression indexable, Expression keyExpression, bool willBeAssigned)
+    public IndexerExpression(
+        Expression indexable, 
+        Expression keyExpression, 
+        bool isConditional, 
+        bool willBeAssigned)
     {
         Indexable = indexable;
         KeyExpression = keyExpression;
             
+        IsConditional = isConditional;
         WillBeAssigned = willBeAssigned;
 
         Reparent(Indexable, KeyExpression);
diff --git a/Core/EVIL.Grammar/Parsing/Expressions/Parser.IndexerExpression.cs b/Core/EVIL.Grammar/Parsing/Expressions/Parser.IndexerExpression.cs
@@ -11,10 +11,26 @@ private IndexerExpression IndexerExpression(Expression indexable)
     {
         int line, col;
         Expression indexer;
+        var isConditional = false;
 
-        if (CurrentToken.Type == TokenType.Dot)
+        if (CurrentToken.Type == TokenType.Dot || CurrentToken.Type == TokenType.Elvis)
         {
-            (line, col) = Match(Token.Dot);
+            if (CurrentToken.Type == TokenType.Dot)
+            {
+                (line, col) = Match(Token.Dot);
+            }
+            else if (CurrentToken.Type == TokenType.Elvis)
+            {
+                (line, col) = Match(Token.Elvis);
+                isConditional = true;
+            }
+            else
+            {
+                throw new ParserException(
+                    $"Unexpected token '{CurrentToken}'.",
+                    (CurrentToken.Line, CurrentToken.Column)
+                );
+            }
 
             var identifier = Identifier();
             indexer = new StringConstant(identifier.Name, false)
@@ -40,7 +56,11 @@ private IndexerExpression IndexerExpression(Expression indexable)
             Match(Token.RBracket);
         }
 
-        return new IndexerExpression(indexable, indexer, CurrentToken.Type == TokenType.Assign)
+        return new IndexerExpression(
+                indexable, 
+                indexer, 
+                isConditional,
+                CurrentToken.Type == TokenType.Assign)
             { Line = line, Column = col };
     }
 }
diff --git a/Core/EVIL.Grammar/Parsing/Expressions/Parser.PostfixExpression.cs b/Core/EVIL.Grammar/Parsing/Expressions/Parser.PostfixExpression.cs
@@ -12,6 +12,7 @@ public partial class Parser
         TokenType.LParenthesis,
         TokenType.LBracket,
         TokenType.Dot,
+        TokenType.Elvis,
         TokenType.DoubleColon,
         TokenType.Increment,
         TokenType.Decrement,
@@ -47,7 +48,7 @@ private Expression PostfixExpression()
             {
                 node = InvocationExpression(node);
             }
-            else if (token.Type == TokenType.LBracket || token.Type == TokenType.Dot)
+            else if (token.Type == TokenType.LBracket || token.Type == TokenType.Dot || token.Type == TokenType.Elvis)
             {
                 node = IndexerExpression(node);
             }
diff --git a/Core/EVIL.Grammar/Parsing/Statements/Parser.EnsureStatement.cs b/Core/EVIL.Grammar/Parsing/Statements/Parser.EnsureStatement.cs
diff --git a/Core/EVIL.Lexical/Lexer.cs b/Core/EVIL.Lexical/Lexer.cs
@@ -119,6 +119,10 @@ public void NextToken()
                 Advance();
                 State.CurrentToken = Token.DoubleQuestionMark with { Line = line, Column = col };
                 break;
+            case '?' when Peek() == '.':
+                Advance();
+                State.CurrentToken = Token.Elvis with { Line = line, Column = col };
+                break;
             case '?':
                 State.CurrentToken = Token.QuestionMark with { Line = line, Column = col };
                 break;
diff --git a/Core/EVIL.Lexical/Token.cs b/Core/EVIL.Lexical/Token.cs
@@ -94,6 +94,7 @@ public override int GetHashCode()
     public static readonly Token AsNumber = new(TokenType.AsNumber, TokenClass.Operator, "$");
     public static readonly Token AsString = new(TokenType.AsString, TokenClass.Operator, "@");
     public static readonly Token QuestionMark = new(TokenType.QuestionMark, TokenClass.Operator, "?");
+    public static readonly Token Elvis = new(TokenType.Elvis, TokenClass.Operator, "?.");
     public static readonly Token DoubleQuestionMark = new(TokenType.DoubleQuestionMark, TokenClass.Operator, "??");
     public static readonly Token Colon = new(TokenType.Colon, TokenClass.Operator, ":");
     public static readonly Token DoubleColon = new(TokenType.DoubleColon, TokenClass.Operator, "::");
diff --git a/Core/EVIL.Lexical/TokenType.cs b/Core/EVIL.Lexical/TokenType.cs
@@ -57,6 +57,7 @@ public enum TokenType
 
     Comma,
     Colon,
+    Elvis,
     DoubleColon,
     Semicolon,
     LParenthesis,
diff --git a/VirtualMachine/EVIL.Ceres.Runtime/ScriptBuiltins/dofile.vil b/VirtualMachine/EVIL.Ceres.Runtime/ScriptBuiltins/dofile.vil
@@ -1,11 +1,10 @@
-val fail = core.fail;
-val get_text = fs.file.get_text;
-val file_exists = fs.file.exists;
-val dname = fs.path.get_dname;
-val fname = fs.path.get_fname;
-val strace = debug.strace;
-val path_cmb = fs.path.cmb;
-val evil_compile = evil.compile;
+val get_text = fs?.file?.get_text ?? throw("dofile: fs.file.get_text missing");
+val file_exists = fs?.file?.exists ?? throw("dofile: fs.file.exists missing");
+val dname = fs?.path?.get_dname ?? throw("dofile: fs.path.get_dname missing");
+val fname = fs?.path?.get_fname ?? throw("dofile: fs.path.get_fname missing");
+val strace = debug?.strace ?? throw("dofile: debug.strace missing");
+val path_cmb = fs?.path?.cmb ?? throw("dofile: fs.path.cmb missing");
+val evil_compile = evil?.compile ?? throw("dofile: evil.compile missing");
 
 val attempted_imports = array { };
 
diff --git a/VirtualMachine/EVIL.Ceres.Runtime/ScriptBuiltins/require.vil b/VirtualMachine/EVIL.Ceres.Runtime/ScriptBuiltins/require.vil
@@ -1,11 +1,11 @@
-val get_text = fs.file.get_text;
-val file_exists = fs.file.exists;
-val dir_exists = fs.dir.exists;
-val dname = fs.path.get_dname;
-val fname = fs.path.get_fname;
-val strace = debug.strace;
-val path_cmb = fs.path.cmb;
-val evil_compile = evil.compile;
+val get_text = fs?.file?.get_text ?? throw("require: fs.file.get_text missing");
+val file_exists = fs?.file?.exists ?? throw("require: fs.file.exists missing");
+val dir_exists = fs?.dir?.exists ?? throw("require: fs.sue.exists missing");
+val dname = fs?.path?.get_dname ?? throw("require: fs.path.get_dname missing");
+val fname = fs?.path?.get_fname ?? throw("require: fs.path.get_fname missing");
+val strace = debug?.strace ?? throw("require: debug.strace missing");
+val path_cmb = fs?.path?.cmb ?? throw("require: fs.path.cmb missing");
+val evil_compile = evil?.compile ?? throw("require: evil.compile missing");
 
 val attempted_imports = array { };
 
diff --git a/VirtualMachine/EVIL.Ceres/TranslationEngine/Compiler.Expression.Indexer.cs b/VirtualMachine/EVIL.Ceres/TranslationEngine/Compiler.Expression.Indexer.cs
@@ -7,8 +7,28 @@ public partial class Compiler
 {
     public override void Visit(IndexerExpression indexerExpression)
     {
-        Visit(indexerExpression.Indexable);
-        Visit(indexerExpression.KeyExpression);
-        Chunk.CodeGenerator.Emit(OpCode.INDEX);
+        if (indexerExpression.IsConditional)
+        {
+            var endIndexerLabel = Chunk.CreateLabel();
+            var indexLabel = Chunk.CreateLabel();
+            
+            Visit(indexerExpression.Indexable);
+            Chunk.CodeGenerator.Emit(OpCode.DUP);
+            Chunk.CodeGenerator.Emit(OpCode.LDNIL);
+            Chunk.CodeGenerator.Emit(OpCode.CEQ);
+            Chunk.CodeGenerator.Emit(OpCode.FJMP, indexLabel);
+            Chunk.CodeGenerator.Emit(OpCode.LDNIL);
+            Chunk.CodeGenerator.Emit(OpCode.JUMP, endIndexerLabel);
+            Chunk.UpdateLabel(indexLabel, Chunk.CodeGenerator.IP);
+            Visit(indexerExpression.KeyExpression);
+            Chunk.CodeGenerator.Emit(OpCode.INDEX);
+            Chunk.UpdateLabel(endIndexerLabel, Chunk.CodeGenerator.IP);
+        }
+        else
+        {
+            Visit(indexerExpression.Indexable);
+            Visit(indexerExpression.KeyExpression);
+            Chunk.CodeGenerator.Emit(OpCode.INDEX);
+        }
     }
 }
diff --git a/VirtualMachine/Tests/EVIL.Ceres.LanguageTests/EVIL.Ceres.LanguageTests.csproj b/VirtualMachine/Tests/EVIL.Ceres.LanguageTests/EVIL.Ceres.LanguageTests.csproj
@@ -121,6 +121,9 @@
     <None Update="tests\00_regression.vil">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </None>
+    <None Update="tests\0_conditional_indexer.vil">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
   </ItemGroup>
 
 </Project>
diff --git a/VirtualMachine/Tests/EVIL.Ceres.LanguageTests/tests/0_conditional_indexer.vil b/VirtualMachine/Tests/EVIL.Ceres.LanguageTests/tests/0_conditional_indexer.vil
@@ -0,0 +1,30 @@
+﻿#[test]
+fn elvis_single_target_is_nil {
+  val a = nil;
+  val b = a?.nope;
+  
+  assert.equal(b, nil);
+}
+
+#[test]
+fn elvis_multiple_targets_last_is_nil {
+  val a = { 
+    b: { 
+      c: { d: nil }
+    }
+  };
+  
+  val v = a?.b?.c?.d?.e;
+  assert.equal(v, nil);
+}
+
+#[test]
+fn elvis_multiple_targets_nil_throw {
+  val a = {
+    b: {
+      c: { d: nil }
+    }
+  };
+  
+  assert.throws(fn -> a?.b?.c?.d?.e ?? throw("yep. that's a throw.")); 
+}

Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@ public partial class Parser`
`12`	`12`	`TokenType.LParenthesis,`
`13`	`13`	`TokenType.LBracket,`
`14`	`14`	`TokenType.Dot,`
	`15`	`+ TokenType.Elvis,`
`15`	`16`	`TokenType.DoubleColon,`
`16`	`17`	`TokenType.Increment,`
`17`	`18`	`TokenType.Decrement,`
`@@ -47,7 +48,7 @@ private Expression PostfixExpression()`
`47`	`48`	`{`
`48`	`49`	`node = InvocationExpression(node);`
`49`	`50`	`}`
`50`		`- else if (token.Type == TokenType.LBracket \|\| token.Type == TokenType.Dot)`
	`51`	`+ else if (token.Type == TokenType.LBracket \|\| token.Type == TokenType.Dot \|\| token.Type == TokenType.Elvis)`
`51`	`52`	`{`
`52`	`53`	`node = IndexerExpression(node);`
`53`	`54`	`}`