Merge pull request #358 from boriel/feature/dependency_propagation

Feature/dependency propagation

Author: boriel

README.md

@@ -1,6 +1,6 @@
 ![Boriel ZX Basic](img/zxbasic_logo.png)
 
-[![Build Status](https://travis-ci.org/boriel/zxbasic.svg?branch=master)](https://travis-ci.org/boriel/zxbasic)
+[![Build Status](https://travis-ci.com/boriel/zxbasic.svg?branch=master)](https://travis-ci.org/boriel/zxbasic)
 [![license](https://img.shields.io/badge/License-GPLv3-blue.svg)](./LICENSE.txt)
 [![pyversions](https://img.shields.io/pypi/pyversions/zxbasic.svg)](https://pypi.python.org/pypi/zxbasic)
 

api/check.py

@@ -115,17 +115,18 @@ def check_call_arguments(lineno, id_, args):
         if param.byref:
             from symbols.var import SymbolVAR
             if not isinstance(arg.value, SymbolVAR):
-                syntax_error(lineno, "Expected a variable name, not an "
-                                     "expression (parameter By Reference)")
+                syntax_error(lineno, "Expected a variable name, not an expression (parameter By Reference)")
                 return False
 
             if arg.class_ not in (CLASS.var, CLASS.array):
-                syntax_error(lineno, "Expected a variable or array name "
-                                     "(parameter By Reference)")
+                syntax_error(lineno, "Expected a variable or array name (parameter By Reference)")
                 return False
 
             arg.byref = True
 
+        if arg.value is not None:
+            arg.value.add_required_symbol(param)
+
     if entry.forwarded:  # The function / sub was DECLARED but not implemented
         syntax_error(lineno, "%s '%s' declared but not implemented" % (CLASS.to_string(entry.class_), entry.name))
         return False
@@ -139,7 +140,7 @@ def check_pending_calls():
     """
     result = True
 
-    # Check for functions defined after calls (parametres, etc)
+    # Check for functions defined after calls (parameters, etc)
     for id_, params, lineno in global_.FUNCTION_CALLS:
         result = result and check_call_arguments(lineno, id_, params)
 

api/optimize.py

@@ -69,8 +69,6 @@ def _visit(self, node):
             return None
 
         __DEBUG__("Optimizer: Visiting node {}".format(str(node.obj)), 1)
-
-        # print node.obj.token, node.obj.__repr__()
         methname = 'visit_' + node.obj.token
         meth = getattr(self, methname, None)
         if meth is None:
@@ -267,13 +265,15 @@ def _check_if_any_arg_is_an_array_and_needs_lbound_or_ubound(self, params: symbo
             if arg.value.lbound_used and arg.value.ubound_used:
                 continue
 
-            self._update_bound_status(arg.value, param, params.parent)
+            self._update_bound_status(arg.value)
 
-    def _update_bound_status(self, arg: symbols.VARARRAY, param: symbols.PARAMDECL, func: symbols.FUNCTION):
+    def _update_bound_status(self, arg: symbols.VARARRAY):
         old_lbound_used = arg.lbound_used
         old_ubound_used = arg.ubound_used
-        arg.lbound_used = arg.lbound_used or param.lbound_used
-        arg.ubound_used = arg.ubound_used or param.ubound_used
+
+        for p in arg.requires:
+            arg.lbound_used = arg.lbound_used or p.lbound_used
+            arg.ubound_used = arg.ubound_used or p.ubound_used
 
         if old_lbound_used != arg.lbound_used or old_ubound_used != arg.ubound_used:
             if arg.scope == SCOPE.global_:

symbols/symbol_.py

@@ -10,8 +10,7 @@
 # ----------------------------------------------------------------------
 
 import re
-from functools import reduce
-from typing import Set, Optional
+from collections import Counter
 
 from ast_ import Ast
 import api.global_
@@ -27,33 +26,36 @@ def __init__(self, *children):
             assert isinstance(child, Symbol)
             self.appendChild(child)
 
-        self._required_by: Set['Symbol'] = set()  # Symbols that depends on this one
-        self._requires: Set['Symbol'] = set()  # Symbols this one depends on
-        self._cached_required_by: Optional[Set['Symbol']] = set()
+        self._required_by: Counter = Counter()  # Symbols that depends on this one
+        self._requires: Counter = Counter()  # Symbols this one depends on
 
     @property
-    def required_by(self) -> Set['Symbol']:
-        if self._cached_required_by is not None:
-            return self._cached_required_by
-
-        self._cached_required_by = reduce(lambda x: x.union, (x.required_by for x in self.children),
-                                          set(self._required_by))
-        return self._cached_required_by
+    def required_by(self) -> Counter:
+        return self._required_by
 
     @property
-    def requires(self) -> Set['Symbol']:
-        return set(self._requires)
+    def requires(self) -> Counter:
+        return Counter(self._requires)
 
     def mark_as_required_by(self, other: 'Symbol'):
-        self._required_by.add(other)
-        self._cached_required_by.add(other)
-        if self.parent is not None:
-            assert isinstance(self.parent, Symbol)
-            self.parent.mark_as_required_by(other)
+        if self is other:
+            return
+
+        self._required_by.update([other])
+        other._requires.update([self])
+
+        for sym in other.required_by:
+            sym.add_required_symbol(self)
 
     def add_required_symbol(self, other: 'Symbol'):
-        self._requires.add(other)
-        other.mark_as_required_by(self)
+        if self is other:
+            return
+
+        self._requires.update([other])
+        other._required_by.update([self])
+
+        for sym in other.requires:
+            sym.mark_as_required_by(self)
 
     @property
     def token(self):