feat: Global Namespace Operator (#1442)

Introduces the global namespace operator to access global variables directly when they would otherwise be shadowed by a local variable. The operator is a simple dot that is prefixed before the variable name, for example `.foo` would access the global variable `foo`.

This feature is achieved by introducing a `ReferenceAccess::Global(AstNode)` variant and a new resolving strategy to annotate such nodes accordingly.

Author: volsa

compiler/plc_ast/src/ast.rs

@@ -784,25 +784,22 @@ fn replace_reference(
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum ReferenceAccess {
-    /**
-     * a, a.b
-     */
+    /// `.foo`
+    Global(Box<AstNode>),
+
+    /// a, a.b
     Member(Box<AstNode>),
-    /**
-     * a[3]
-     */
+
+    /// a[3]
     Index(Box<AstNode>),
-    /**
-     * Color#Red
-     */
+
+    /// Color#Red
     Cast(Box<AstNode>),
-    /**
-     * a^
-     */
+
+    /// a^
     Deref,
-    /**
-     * &a
-     */
+
+    /// &a
     Address,
 }
 
@@ -1101,11 +1098,11 @@ impl AstNode {
     /// Returns the reference-name if this is a flat reference like `a`, or None if this is no flat reference
     pub fn get_flat_reference_name(&self) -> Option<&str> {
         match &self.stmt {
-            AstStatement::ReferenceExpr(
-                ReferenceExpr { access: ReferenceAccess::Member(reference), .. },
-                ..,
-            ) => reference.as_ref().get_flat_reference_name(),
             AstStatement::Identifier(name, ..) => Some(name),
+            AstStatement::ReferenceExpr(ReferenceExpr {
+                access: ReferenceAccess::Member(reference) | ReferenceAccess::Global(reference),
+                ..
+            }) => reference.as_ref().get_flat_reference_name(),
             _ => None,
         }
     }
@@ -1586,6 +1583,17 @@ impl AstFactory {
         }
     }
 
+    pub fn create_global_reference(id: AstId, member: AstNode, location: SourceLocation) -> AstNode {
+        AstNode {
+            stmt: AstStatement::ReferenceExpr(ReferenceExpr {
+                access: ReferenceAccess::Global(Box::new(member)),
+                base: None,
+            }),
+            id,
+            location,
+        }
+    }
+
     pub fn create_index_reference(
         index: AstNode,
         base: Option<AstNode>,

src/codegen/generators/expression_generator.rs

@@ -2539,7 +2539,18 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
         original_expression: &AstNode,
     ) -> Result<ExpressionValue<'ink>, Diagnostic> {
         match (access, base) {
-            // expressions like `base.member`, or just `member`
+            // `.foo`
+            (ReferenceAccess::Global(node), _) => {
+                let name = node.get_flat_reference_name().unwrap_or("unknown");
+
+                self.create_llvm_pointer_value_for_reference(
+                    None,
+                    self.get_load_name(node).as_deref().unwrap_or(name),
+                    node,
+                ).map(ExpressionValue::LValue)
+            }
+
+            // `base.member` or just `member`
             (ReferenceAccess::Member(member), base) => {
                 let base_value = base.map(|it| self.generate_expression_value(it)).transpose()?;
 
@@ -2550,16 +2561,16 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
                     self.generate_direct_access_expression(base, &base_value, member, &data.access, &data.index)
                 } else {
                     let member_name = member.get_flat_reference_name().unwrap_or("unknown");
+
                     self.create_llvm_pointer_value_for_reference(
                         base_value.map(|it| it.get_basic_value_enum().into_pointer_value()).as_ref(),
                         self.get_load_name(member).as_deref().unwrap_or(member_name),
                         original_expression,
-                    )
-                        .map(ExpressionValue::LValue)
+                    ).map(ExpressionValue::LValue)
                 }
             }
 
-            // expressions like: base[idx]
+            // `base[idx]`
             (ReferenceAccess::Index(array_idx), Some(base)) => {
                 if self.annotations.get_type_or_void(base, self.index).is_vla() {
                     // vla array needs special handling
@@ -2576,7 +2587,7 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
                 }
             }
 
-            // INT#target (INT = base)
+            // `INT#target` (INT = base)
             (ReferenceAccess::Cast(target), Some(_base)) => {
                 if target.as_ref().is_identifier() {
                     let mr =
@@ -2587,7 +2598,7 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
                 }
             }
 
-            // base^
+            // `base^`
             (ReferenceAccess::Deref, Some(base)) => {
                 let ptr = self.generate_expression_value(base)?;
                 Ok(ExpressionValue::LValue(
@@ -2597,20 +2608,20 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
                 ))
             }
 
-            // &base
+            // `&base`
             (ReferenceAccess::Address, Some(base)) => {
                 let lvalue = self.generate_expression_value(base)?;
                 Ok(ExpressionValue::RValue(lvalue.get_basic_value_enum()))
             }
 
-            (ReferenceAccess::Index(_), None) // [idx];
-            | (ReferenceAccess::Cast(_), None) // INT#;
-            | (ReferenceAccess::Deref, None)  // ^;
-            | (ReferenceAccess::Address, None) // &;
+            (ReferenceAccess::Index(_), None)   // [idx];
+            | (ReferenceAccess::Cast(_), None)  // INT#;
+            | (ReferenceAccess::Deref, None)    // ^;
+            | (ReferenceAccess::Address, None)  // &;
             => Err(Diagnostic::codegen_error(
-                "Expected a base-expressions, but found none.",
+                "Expected a base expression, but found none",
                 original_expression,
-            )),
+            ))
         }
     }
 

src/codegen/tests/expression_tests.rs

@@ -747,3 +747,87 @@ fn builtin_div_mixed() {
 
     insta::assert_snapshot!(res);
 }
+
+#[test]
+fn global_namespace_operator() {
+    let src = r#"
+    VAR_GLOBAL
+        foo : DINT;
+    END_VAR
+
+    PROGRAM main
+    VAR
+        foo : DINT;
+    END_VAR
+        foo := .foo;
+        foo := .foo + 1;
+        foo := .foo + .foo;
+
+        .foo := foo;
+        .foo := .foo + 1;
+    END_PROGRAM
+    "#;
+
+    let res = codegen(src);
+    insta::assert_snapshot!(res, @r#"
+    ; ModuleID = '<internal>'
+    source_filename = "<internal>"
+
+    %main = type { i32 }
+
+    @foo = global i32 0
+    @main_instance = global %main zeroinitializer
+
+    define void @main(%main* %0) {
+    entry:
+      %foo = getelementptr inbounds %main, %main* %0, i32 0, i32 0
+      %load_foo = load i32, i32* @foo, align 4
+      store i32 %load_foo, i32* %foo, align 4
+      %load_foo1 = load i32, i32* @foo, align 4
+      %tmpVar = add i32 %load_foo1, 1
+      store i32 %tmpVar, i32* %foo, align 4
+      %load_foo2 = load i32, i32* @foo, align 4
+      %load_foo3 = load i32, i32* @foo, align 4
+      %tmpVar4 = add i32 %load_foo2, %load_foo3
+      store i32 %tmpVar4, i32* %foo, align 4
+      %load_foo5 = load i32, i32* %foo, align 4
+      store i32 %load_foo5, i32* @foo, align 4
+      %load_foo6 = load i32, i32* @foo, align 4
+      %tmpVar7 = add i32 %load_foo6, 1
+      store i32 %tmpVar7, i32* @foo, align 4
+      ret void
+    }
+    ; ModuleID = '__initializers'
+    source_filename = "__initializers"
+
+    %main = type { i32 }
+
+    @main_instance = external global %main
+
+    define void @__init_main(%main* %0) {
+    entry:
+      %self = alloca %main*, align 8
+      store %main* %0, %main** %self, align 8
+      ret void
+    }
+
+    declare void @main(%main*)
+    ; ModuleID = '__init___testproject'
+    source_filename = "__init___testproject"
+
+    %main = type { i32 }
+
+    @main_instance = external global %main
+    @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 0, void ()* @__init___testproject, i8* null }]
+
+    define void @__init___testproject() {
+    entry:
+      call void @__init_main(%main* @main_instance)
+      ret void
+    }
+
+    declare void @__init_main(%main*)
+
+    declare void @main(%main*)
+    "#);
+}

src/parser/expressions_parser.rs

@@ -424,6 +424,16 @@ pub fn parse_qualified_reference(lexer: &mut ParseSession) -> Option<AstNode> {
                     Some(exp)
                 };
             }
+            // Global Namespace Operator, e.g. `.foo`
+            (None, Some(KeywordDot)) => {
+                let location_dot = lexer.location();
+                lexer.advance();
+
+                let expr = parse_atomic_leaf_expression(lexer)?;
+                let location = location_dot.span(&expr.location);
+
+                current = Some(AstFactory::create_global_reference(lexer.next_id(), expr, location));
+            }
             // base._ -> a segment of a qualified reference, we stand right after the dot
             (Some(base), Some(KeywordDot)) => {
                 lexer.advance();

src/parser/tests/expressions_parser_tests.rs

@@ -1756,3 +1756,25 @@ fn function_call_array_index() {
     let parse_result = parse(src).0;
     assert_debug_snapshot!(parse_result.implementations[0].statements);
 }
+
+#[test]
+fn global_namespace_operator() {
+    let src = r#"
+    FUNCTION main
+        .foo;
+        .foo := 1;
+        .foo := .foo + 1;
+
+        foo := 1 + .foo + foo();
+        foo := 1 + .foo + 2 + .foo;
+
+        someFunc(.foo);
+        printf("%d$N", .foo);
+    END_FUNCTION
+    "#;
+
+    let result = parse(src).0;
+
+    assert_eq!(&src[result.implementations[0].statements[0].get_location().to_range().unwrap()], ".foo");
+    assert_debug_snapshot!(result.implementations[0].statements);
+}