Block scoping

examples/voting/ballot.v.py

@@ -132,6 +132,7 @@ def vote(proposal: num):
 @constant
 def winning_proposal() -> num:
     winning_vote_count = 0
+    winning_proposal = 0
     for i in range(2):
         if self.proposals[i].vote_count > winning_vote_count:
             winning_vote_count = self.proposals[i].vote_count

tests/parser/syntax/test_blockscope.py

@@ -0,0 +1,81 @@
+
+import pytest
+from pytest import raises
+
+from viper import compiler
+from viper.exceptions import VariableDeclarationException
+
+
+fail_list = [
+    """
+@public
+def foo(choice: bool):
+    if (choice):
+        a = 1
+    a += 1
+    """,
+    """
+@public
+def foo(choice: bool):
+    if (choice):
+        a = 0
+    else:
+        a = 1
+    a += 1
+    """,
+    """
+@public
+def foo(choice: bool):
+    if (choice):
+        a = 0
+    else:
+        a += 1
+    """,
+    """
+@public
+def foo(choice: bool):
+
+    for i in range(4):
+        a = 0
+    a += 1
+    """,
+    """
+@public
+def foo(choice: bool):
+
+    for i in range(4):
+        a = 0
+    a += 1
+    """,
+    """
+a: num
+
+@public
+def foo():
+    a = 5
+    """,
+]
+
+
+@pytest.mark.parametrize('bad_code', fail_list)
+def test_fail_(bad_code):
+
+    with raises(VariableDeclarationException):
+        compiler.compile(bad_code)
+
+
+valid_list = [
+    """
+@public
+def foo(choice: bool, choice2: bool):
+    if (choice):
+        a = 11
+        if choice2 and a > 1:
+            a -= 1  # should be visible here.
+    """
+]
+
+
+@pytest.mark.parametrize('good_code', valid_list)
+def test_valid_blockscope(good_code):
+    assert compiler.compile(good_code) is not None

viper/function_signature.py

@@ -21,11 +21,12 @@
 
 # Function argument
 class VariableRecord():
-    def __init__(self, name, pos, typ, mutable):
+    def __init__(self, name, pos, typ, mutable, blockscopes=[]):
         self.name = name
         self.pos = pos
         self.typ = typ
         self.mutable = mutable
+        self.blockscopes = blockscopes
 
     @property
     def size(self):

viper/parser/parser.py

@@ -277,13 +277,31 @@ def __init__(self, vars=None, globals=None, sigs=None, forvars=None, return_type
         self.in_for_loop = set()
         # Count returns in function
         self.function_return_count = 0
+        # Current blockscope
+        self.blockscopes = []
 
     def set_in_for_loop(self, name_of_list):
         self.in_for_loop.add(name_of_list)
 
     def remove_in_for_loop(self, name_of_list):
         self.in_for_loop.remove(name_of_list)
 
+    def start_blockscope(self, blockscope_id):
+        if blockscope_id not in self.blockscopes:
+            self.blockscopes.append(blockscope_id)
+
+    def end_blockscope(self, blockscope_id):
+        if blockscope_id not in self.blockscopes:
+            return
+        # Remove all variables that have specific blockscope_id attached.
+        poplist = []
+        for name, var_record in self.vars.items():
+            if blockscope_id in var_record.blockscopes:
+                poplist.append(name)
+        for name in poplist: self.vars.pop(name)
+        # Remove blockscopes
+        self.blockscopes = self.blockscopes[self.blockscopes.index(blockscope_id):]
+
     def increment_return_counter(self):
         self.function_return_count += 1
 
@@ -293,7 +311,7 @@ def new_variable(self, name, typ):
             raise VariableDeclarationException("Variable name invalid or reserved: " + name)
         if name in self.vars or name in self.globals:
             raise VariableDeclarationException("Duplicate variable name: %s" % name)
-        self.vars[name] = VariableRecord(name, self.next_mem, typ, True)
+        self.vars[name] = VariableRecord(name, self.next_mem, typ, True, self.blockscopes.copy())
         pos = self.next_mem
         self.next_mem += 32 * get_size_of_type(typ)
         return pos

viper/parser/stmt.py

@@ -100,11 +100,23 @@ def parse_if(self):
         from .parser import (
             parse_body,
         )
+
         if self.stmt.orelse:
+            block_scope_id = id(self.stmt.orelse)
+            self.context.start_blockscope(block_scope_id)
             add_on = [parse_body(self.stmt.orelse, self.context)]
+            self.context.end_blockscope(block_scope_id)
         else:
             add_on = []
-        return LLLnode.from_list(['if', Expr.parse_value_expr(self.stmt.test, self.context), parse_body(self.stmt.body, self.context)] + add_on, typ=None, pos=getpos(self.stmt))
+
+        block_scope_id = id(self.stmt)
+        self.context.start_blockscope(block_scope_id)
+        o = LLLnode.from_list(
+            ['if', Expr.parse_value_expr(self.stmt.test, self.context), parse_body(self.stmt.body, self.context)] + add_on,
+            typ=None, pos=getpos(self.stmt)
+        )
+        self.context.end_blockscope(block_scope_id)
+        return o
 
     def call(self):
         from .parser import (
@@ -179,6 +191,8 @@ def parse_for(self):
                         len(self.stmt.iter.args) not in (1, 2):
             raise StructureException("For statements must be of the form `for i in range(rounds): ..` or `for i in range(start, start + rounds): ..`", self.stmt.iter)  # noqa
 
+        block_scope_id = id(self.stmt.orelse)
+        self.context.start_blockscope(block_scope_id)
         # Type 1 for, eg. for i in range(10): ...
         if len(self.stmt.iter.args) == 1:
             if not isinstance(self.stmt.iter.args[0], ast.Num):
@@ -206,6 +220,7 @@ def parse_for(self):
         o = LLLnode.from_list(['repeat', pos, start, rounds, parse_body(self.stmt.body, self.context)], typ=None, pos=getpos(self.stmt))
         del self.context.vars[varname]
         del self.context.forvars[varname]
+        self.context.end_blockscope(block_scope_id)
         return o
 
     def _is_list_iter(self):