feat(ast): Introduce ParenExpression (#995)

Author: volsa

.vscode/launch.json

@@ -7,7 +7,7 @@
         {
             "type": "lldb",
             "request": "launch",
-            "name": "Debug source 'demo.st'",
+            "name": "Debug source 'target/demo.st'",
             "cargo": {
                 "args": [
                     "build",

compiler/plc_ast/src/ast.rs

@@ -584,7 +584,7 @@ pub struct AstNode {
     pub location: SourceLocation,
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum AstStatement {
     EmptyStatement(EmptyStatement),
     // a placeholder that indicates a default value of a datatype
@@ -601,6 +601,7 @@ pub enum AstStatement {
     BinaryExpression(BinaryExpression),
     UnaryExpression(UnaryExpression),
     ExpressionList(Vec<AstNode>),
+    ParenExpression(Box<AstNode>),
     RangeStatement(RangeStatement),
     VlaRangeStatement,
     // Assignment
@@ -639,6 +640,9 @@ impl Debug for AstNode {
             AstStatement::ExpressionList(expressions) => {
                 f.debug_struct("ExpressionList").field("expressions", expressions).finish()
             }
+            AstStatement::ParenExpression(expression) => {
+                f.debug_struct("ParenExpression").field("expression", expression).finish()
+            }
             AstStatement::RangeStatement(RangeStatement { start, end }) => {
                 f.debug_struct("RangeStatement").field("start", start).field("end", end).finish()
             }
@@ -860,6 +864,10 @@ impl AstNode {
         )
     }
 
+    pub fn is_paren(&self) -> bool {
+        matches!(self.stmt, AstStatement::ParenExpression { .. })
+    }
+
     pub fn is_expression_list(&self) -> bool {
         matches!(self.stmt, AstStatement::ExpressionList { .. })
     }
@@ -1012,6 +1020,7 @@ pub fn flatten_expression_list(list: &AstNode) -> Vec<&AstNode> {
         AstStatement::MultipliedStatement(MultipliedStatement { multiplier, element }, ..) => {
             std::iter::repeat(flatten_expression_list(element)).take(*multiplier as usize).flatten().collect()
         }
+        AstStatement::ParenExpression(expression) => flatten_expression_list(expression),
         _ => vec![list],
     }
 }
@@ -1133,6 +1142,10 @@ impl AstFactory {
         AstNode { stmt: AstStatement::ExpressionList(expressions), location, id }
     }
 
+    pub fn create_paren_expression(expression: AstNode, location: SourceLocation, id: AstId) -> AstNode {
+        AstNode { stmt: AstStatement::ParenExpression(Box::new(expression)), location, id }
+    }
+
     /// creates a new if-statement
     pub fn create_if_statement(
         blocks: Vec<ConditionalBlock>,
@@ -1500,75 +1513,75 @@ impl AstFactory {
         AstNode { stmt: AstStatement::LabelStatement(LabelStatement { name }), location, id }
     }
 }
-#[derive(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct EmptyStatement {}
 
-#[derive(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct DefaultValue {}
 
-#[derive(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct CastStatement {
     pub target: Box<AstNode>,
     pub type_name: String,
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct MultipliedStatement {
     pub multiplier: u32,
     pub element: Box<AstNode>,
 }
-#[derive(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct ReferenceExpr {
     pub access: ReferenceAccess,
     pub base: Option<Box<AstNode>>,
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct DirectAccess {
     pub access: DirectAccessType,
     pub index: Box<AstNode>,
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct HardwareAccess {
     pub direction: HardwareAccessType,
     pub access: DirectAccessType,
     pub address: Vec<AstNode>,
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct BinaryExpression {
     pub operator: Operator,
     pub left: Box<AstNode>,
     pub right: Box<AstNode>,
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct UnaryExpression {
     pub operator: Operator,
     pub value: Box<AstNode>,
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct RangeStatement {
     pub start: Box<AstNode>,
     pub end: Box<AstNode>,
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Assignment {
     pub left: Box<AstNode>,
     pub right: Box<AstNode>,
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct CallStatement {
     pub operator: Box<AstNode>,
     pub parameters: Option<Box<AstNode>>,
 }
 
 /// Represents a conditional jump from current location to a specified label
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct JumpStatement {
     /// The condition based on which the current statement will perform a jump
     pub condition: Box<AstNode>,
@@ -1577,7 +1590,7 @@ pub struct JumpStatement {
 }
 
 /// Represents a location in code that could be jumbed to
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct LabelStatement {
     pub name: String,
 }

compiler/plc_ast/src/control_statements.rs

@@ -1,14 +1,14 @@
-use std::fmt::{Debug, Formatter};
+use std::fmt::Debug;
 
 use crate::ast::AstNode;
 
-#[derive(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct IfStatement {
     pub blocks: Vec<ConditionalBlock>,
     pub else_block: Vec<AstNode>,
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct ForLoopStatement {
     pub counter: Box<AstNode>,
     pub start: Box<AstNode>,
@@ -17,21 +17,21 @@ pub struct ForLoopStatement {
     pub body: Vec<AstNode>,
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 /// used for While and Repeat loops
 pub struct LoopStatement {
     pub condition: Box<AstNode>,
     pub body: Vec<AstNode>,
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct CaseStatement {
     pub selector: Box<AstNode>,
     pub case_blocks: Vec<ConditionalBlock>,
     pub else_block: Vec<AstNode>,
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum AstControlStatement {
     If(IfStatement),
     ForLoop(ForLoopStatement),
@@ -40,24 +40,15 @@ pub enum AstControlStatement {
     Case(CaseStatement),
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct ConditionalBlock {
     pub condition: Box<AstNode>,
     pub body: Vec<AstNode>,
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct ReturnStatement {
     /// Indicates that the given condition must evaluate to true in order for the return to take place.
     /// Only used in CFC where the condition may be [`Some`] and [`None`] otherwise.
     pub condition: Option<Box<AstNode>>,
 }
-
-impl Debug for ConditionalBlock {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("ConditionalBlock")
-            .field("condition", &self.condition)
-            .field("body", &self.body)
-            .finish()
-    }
-}

compiler/plc_source/src/source_location.rs

@@ -56,7 +56,7 @@ impl SourceLocationFactory {
 pub struct TextLocation {
     /// Line in the source code where this location points to
     line: usize,
-    /// Column in the sourcecode where this location points o
+    /// Column in the sourcecode where this location points to
     column: usize,
     /// Raw offset to this location from the start of the file
     offset: usize,

src/codegen/generators/expression_generator.rs

@@ -237,6 +237,7 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
             AstStatement::HardwareAccess { .. } => {
                 Ok(ExpressionValue::RValue(self.llvm.i32_type().const_zero().into()))
             }
+            AstStatement::ParenExpression(expr) => self.generate_expression_value(expr),
             //fallback
             _ => self.generate_literal(expression),
         }

src/lexer.rs

@@ -114,6 +114,7 @@ impl<'a> ParseSession<'a> {
     }
 
     pub fn advance(&mut self) {
+        log::trace!("{}", self.slice());
         self.last_range = self.range();
         self.last_token = std::mem::replace(&mut self.token, self.lexer.next().unwrap_or(Token::End));
         self.parse_progress += 1;

src/parser/expressions_parser.rs

@@ -257,7 +257,11 @@ fn parse_atomic_leaf_expression(lexer: &mut ParseSession<'_>) -> Result<AstNode,
         KeywordParensOpen => {
             parse_any_in_region(lexer, vec![KeywordParensClose], |lexer| {
                 lexer.advance(); // eat KeywordParensOpen
-                Ok(parse_expression(lexer))
+
+                let start = lexer.last_location();
+                let expr = parse_expression(lexer);
+
+                Ok(AstFactory::create_paren_expression(expr, start.span(&lexer.location()), lexer.next_id()))
             })
         }
         Identifier => Ok(parse_identifier(lexer)),

src/parser/tests/expressions_parser_tests.rs

@@ -2,7 +2,9 @@
 use crate::parser::tests::ref_to;
 use crate::test_utils::tests::parse;
 use insta::{assert_debug_snapshot, assert_snapshot};
-use plc_ast::ast::{AstFactory, AstNode, DataType, DataTypeDeclaration, LinkageType, Operator, Pou, PouType};
+use plc_ast::ast::{
+    AstFactory, AstNode, AstStatement, DataType, DataTypeDeclaration, LinkageType, Operator, Pou, PouType,
+};
 use plc_ast::literals::AstLiteral;
 use plc_source::source_location::SourceLocation;
 use pretty_assertions::*;
@@ -145,7 +147,7 @@ fn additon_of_three_variables_parsed() {
 }
 
 #[test]
-fn parenthesis_expressions_should_not_change_the_ast() {
+fn parenthesis_expressions_should_change_the_ast() {
     let src = "PROGRAM exp (x+y); END_PROGRAM";
     let result = parse(src).0;
 
@@ -1765,3 +1767,13 @@ fn direct_access_as_expression_parsed() {
     //THEN the AST contains direct address nodes at the access location
     assert_debug_snapshot!(result);
 }
+
+#[test]
+fn parenthesized_expression_span() {
+    let src = "PROGRAM prg [(1 + 2)] END_PROGRAM";
+
+    let (result, _) = parse(src);
+    let AstStatement::Literal(AstLiteral::Array(array)) = result.implementations[0].statements[0].get_stmt() else { panic!() };
+    let range = array.elements().unwrap().get_location().get_span().to_range().unwrap();
+    assert_eq!(&src[range.start..range.end], "(1 + 2)");
+}

src/parser/tests/initializer_parser_tests.rs

@@ -300,6 +300,22 @@ fn struct_initializer_can_be_parsed() {
     assert_debug_snapshot!(x);
 }
 
+#[test]
+fn parenthesized_expression_within_array() {
+    let (result, _) = parse(
+        "
+        PROGRAM main
+            VAR
+                arr : ARRAY[1..5] OF DINT := [(1, 2, 3, 4, 5)];
+            END_VAR
+        END_PROGRAM
+        ",
+    );
+
+    let member = &result.units[0].variable_blocks[0].variables[0];
+    assert_debug_snapshot!(&member.initializer);
+}
+
 #[test]
 fn array_initializer_in_pou_can_be_parsed() {
     let (result, ..) = parse(