Minor bug fixes

TheCavaco · Sep 21, 2022 · d90cf6b · d90cf6b
1 parent af9c2a8
commit d90cf6b
Show file tree

Hide file tree

Showing 5 changed files with 34 additions and 28 deletions.
diff --git a/py2many/rewriters.py b/py2many/rewriters.py
@@ -12,7 +12,7 @@
 from typing import Any, cast, Optional
 
 from py2many.scope import ScopeList
-from py2many.tracer import find_node_by_name_and_type, find_node_by_type
+from py2many.tracer import find_node_by_name_and_type, find_node_by_type, find_parent_of_type
 
 
 class InferredAnnAssignRewriter(ast.NodeTransformer):
@@ -612,11 +612,10 @@ def _generic_loop_visit(self, node):
         if len(node.orelse) > 0:
             lineno = node.orelse[0].lineno
             if_expr = ast.If(
-                test=ast.Compare(
-                    left=ast.Name(id=self._has_break_var_name),
-                    ops=[ast.NotEq()],
-                    comparators=[ast.Constant(value=True, scopes=node.scopes)],
-                    scopes=node.scopes,
+                test= ast.UnaryOp(
+                    op = ast.Not(),
+                    operand=ast.Name(id=self._has_break_var_name),
+                    scopes=node.scopes
                 ),
                 body=[oe for oe in node.orelse],
                 orelse=[],
@@ -627,20 +626,28 @@ def _generic_loop_visit(self, node):
 
     def _visit_Scope(self, node) -> Any:
         self.generic_visit(node)
+        parent_loop = find_parent_of_type(ast.For, node.scopes)
+        is_local = False
+        if parent_loop and \
+                getattr(parent_loop, "orelse", None):
+            # Check if the node is a local assignment
+            is_local = True
         assign = ast.Assign(
             targets=[ast.Name(id=self._has_break_var_name)],
             value=None,
-            scopes=node.scopes,
+            scopes=node.scopes
         )
         ast.fix_missing_locations(assign)
         body = []
         for n in node.body:
             if hasattr(n, "if_expr"):
                 assign.value = ast.Constant(value=False, scopes=ScopeList())
+                assign.local = is_local
                 body.append(assign)
                 body.append(n)
                 body.append(n.if_expr)
             elif isinstance(n, ast.Break):
+                # assign.local = False
                 for_node = find_node_by_type(ast.For, node.scopes)
                 if hasattr(for_node, "if_expr"):
                     assign.value = ast.Constant(value=True, scopes=ScopeList())

diff --git a/pyjl/external/modules/ctypes.py b/pyjl/external/modules/ctypes.py
@@ -8,7 +8,7 @@
 from typing import Callable, Dict, Optional, Tuple, Union
 
 from py2many.ast_helpers import get_id
-from pyjl.helpers import get_python_dll_path, pycall_import
+from pyjl.helpers import pycall_import
 
 class JuliaExternalModulePlugins():
     def visit_load_library(self, node: ast.Call, vargs: list[str], kwargs: list[tuple[str,str]]):

diff --git a/pyjl/helpers.py b/pyjl/helpers.py
@@ -1,7 +1,5 @@
 # Gets range from for loop
 import ast
-import subprocess
-import os
 import random
 from typing import Optional
 

diff --git a/pyjl/rewriters.py b/pyjl/rewriters.py
@@ -196,21 +196,12 @@ def visit_AugAssign(self, node: ast.AugAssign) -> Any:
                         right = ast.Constant(value=1)
                     )
                 ast.fix_missing_locations(value)
-                if isinstance(node.target, ast.List) and \
-                        len(node.target.elts) == 1:
-                    repeat_arg = ast.Call(
-                        func = ast.Name(id="fill"),
-                        args = [node.target.elts[0], value],
-                        keywords = [],
-                        scopes = node.scopes
-                    )
-                else:
-                    repeat_arg = ast.Call(
-                            func = ast.Name(id="repeat"),
-                            args = [node.target, value],
-                            keywords = [],
-                            scopes = node.scopes
-                        )
+                repeat_arg = ast.Call(
+                    func = ast.Name(id="repeat"),
+                    args = [node.target, value],
+                    keywords = [],
+                    scopes = node.scopes
+                )
                 ast.fix_missing_locations(repeat_arg)
                 call.args.append(node.target)
                 call.args.append(repeat_arg)

diff --git a/pyjl/transpiler.py b/pyjl/transpiler.py
@@ -520,14 +520,20 @@ def visit_BinOp(self, node: ast.BinOp) -> str:
         if isinstance(node.op, ast.Mult):
             # Cover multiplication between List/Tuple and Int
             if isinstance(node.right, ast.Num) or is_num(right_jl_ann):
-                if ((isinstance(node.left, ast.List) or is_list(left_jl_ann))  or
+                if isinstance(node.left, ast.List) and \
+                        len(node.left.elts) == 1:
+                    return f"fill({self.visit(node.left.elts[0])},{right})"
+                elif ((isinstance(node.left, ast.List) or is_list(left_jl_ann))  or
                         (isinstance(node.left, ast.Str) or left_jl_ann == "String")):
                     return f"repeat({left},{right})"
                 elif isinstance(node.left, ast.Tuple) or is_tuple(left_jl_ann):
                     return f"repeat([{left}...],{right})"
 
             if isinstance(node.left, ast.Num) or is_num(left_jl_ann):
-                if ((isinstance(node.right, ast.List) or is_list(right_jl_ann)) or
+                if isinstance(node.right, ast.List) and \
+                        len(node.right.elts) == 1:
+                    return f"fill({self.visit(node.right.elts[0])},{left})"
+                elif ((isinstance(node.right, ast.List) or is_list(right_jl_ann)) or
                         (isinstance(node.right, ast.Str) or right_jl_ann == "String")):
                     return f"repeat({right},{left})"
                 elif isinstance(node.right, ast.Tuple) or is_tuple(right_jl_ann):
@@ -1095,7 +1101,11 @@ def visit_Assign(self, node: ast.Assign) -> str:
         # Optimization to use global constants
         if getattr(node, "use_constant", None):
             return f"const {targets[0]} {op} {value}"
-
+
+        # Support for local variables
+        if getattr(node, "local", None):
+            return f"local {'='.join(targets)} {op} {value}"
+
         return f"{'='.join(targets)} {op} {value}"
 
     def visit_Delete(self, node: ast.Delete) -> str: