fix Fix inlining

If a local variable shadows an outer one, inlining using bare blocks breaks currently

Author: fabi321

test/minifier/test_simplify_expressions.py

@@ -81,7 +81,8 @@ def test_has_return(self):
         """
         self.compare_code(code, expected)
 
-    def test_allowed(self):
+    def _test_allowed(self):
+        # disabled due to test_shadowing
         code = """
         function test(a, b)
             foo = a + b
@@ -108,7 +109,8 @@ def test_empty_function(self):
         expected = "; ; ;"
         self.compare_code(code, expected)
 
-    def test_correct_names(self):
+    def _test_correct_names(self):
+        # disabled due to test_shadowing
         code = """
         function test(a, b)
             foo = a.a + b
@@ -140,6 +142,26 @@ def test_not_a_function(self):
         """
         self.compare_code(code, code)
 
+    def test_shadowing(self):
+        # This is the reason why inlining using
+        code = """
+        function test(b)
+            local a = b + 1
+            print(a, b)
+        end
+        a = 1
+        test(a)
+        """
+        expected = """
+        ; -- residual function
+        a = 1
+        (function (b)
+            local a = b + 1
+            print(a, b)
+        end)(a)
+        """
+        self.compare_code(code, expected)
+
 
 class TestUnOp(BaseClass):
     def test_not(self):

tumfl/minifier/simplify_expressions.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from logging import warning
 from typing import Optional
 
 from tumfl.AST import (
@@ -133,9 +132,6 @@ def visit_FunctionCall(self, node: FunctionCall) -> None:
                 definition,
                 (FunctionDefinition, LocalFunctionDefinition, ExpFunctionDefinition),
             ):
-                warning(
-                    f'Function call to "{node.function!s}" is not a function definition'
-                )
                 return
             if (
                 all(
@@ -152,7 +148,9 @@ def visit_FunctionCall(self, node: FunctionCall) -> None:
                 and all(isinstance(arg, Name) for arg in node.arguments)
                 and all(isinstance(arg, Name) for arg in definition.parameters)
                 and not self.has_return(definition.body)
+                and False
             ):
+                # See test_shadowing why this is disabled for now, may be reenabled in the future
                 # Inlining is quite conservative, inlining only functions that have only name arguments,
                 # and no return statements (and for obvious reasons, only if there is only 1 callee)
                 replacements: dict[Name, Name] = {}