Merge ast and parser from forward

probably/pgcl/__init__.py

@@ -31,7 +31,7 @@
     ...     {c := unif(1,10)} [0.8] {f:=true}
     ... }'''
     >>> compile_pgcl(code)
-    Program(variables={'f': BoolType(), 'c': NatType(bounds=None)}, constants={}, parameters={}, instructions=[SkipInstr(), WhileInstr(cond=BinopExpr(operator=Binop.AND, lhs=BinopExpr(operator=Binop.LE, lhs=VarExpr('c'), rhs=NatLitExpr(10)), rhs=VarExpr('f')), body=[ChoiceInstr(prob=RealLitExpr("0.8"), lhs=[AsgnInstr(lhs='c', rhs=DUniformExpr(start=NatLitExpr(1), end=NatLitExpr(10)))], rhs=[AsgnInstr(lhs='f', rhs=BoolLitExpr(True))])])])
+    Program(variables={'f': BoolType(), 'c': NatType(bounds=None)}, constants={}, parameters={}, instructions=[SkipInstr(), WhileInstr(cond=BinopExpr(operator=Binop.AND, lhs=BinopExpr(operator=Binop.LT, lhs=VarExpr('c'), rhs=NatLitExpr(10)), rhs=VarExpr('f')), body=[ChoiceInstr(prob=RealLitExpr("0.8"), lhs=[AsgnInstr(lhs='c', rhs=DUniformExpr(start=NatLitExpr(1), end=NatLitExpr(10)))], rhs=[AsgnInstr(lhs='f', rhs=BoolLitExpr(True))])])])
 
 For more details on what syntax is accepted for pGCL programs, you can view the :ref:`formal grammar used for the pGCL parser <pgcl_grammar>`.
 

probably/pgcl/check.py

@@ -18,7 +18,7 @@
                   ExpectationInstr, PrintInstr, OptimizationQuery, PlotInstr,
                   LoopInstr, CUniformExpr, GeometricExpr, BernoulliExpr,PoissonExpr,
                   LogDistExpr, BinomialExpr, IidSampleExpr, DistrExpr)
-from .ast.walk import Walk, walk_expr
+from .ast.walk import Walk, mut_expr_children, walk_expr
 
 _T = TypeVar('_T')
 
@@ -198,8 +198,23 @@ def get_type(program: Program,
 
 
 def _check_distribution_arguments(prog: Program, expected_type: Type, *parameters: Tuple[Type, Expr]) -> Union[Type, CheckFail]:
+    # this function is copied from the syntax module, which is not pretty, but prevents cyclic imports
+    # also, it works only if constant substitution has been performed
+    # pylint: disable=duplicate-code
+    def _has_variable(expr: Expr) -> bool:
+        if isinstance(expr, UnopExpr) and expr.operator == Unop.IVERSON:
+            return False
+        if isinstance(expr, VarExpr) and expr.var not in prog.parameters:
+            return True
+        for child_ref in mut_expr_children(Mut.alloc(expr)):
+            if _has_variable(child_ref.val):
+                return True
+        return False
+
     for expected_param_type, param_expr in parameters:
-        # Check for variables in parameters here
+        if _has_variable(param_expr):
+            return CheckFail(param_expr, "In distribution parameter expressions, no variables are allowed. - Forgot parameter declaration?")
+
         param_type = get_type(prog, param_expr)
         if isinstance(param_type, CheckFail):
             return param_type

probably/pgcl/compiler.py

@@ -41,11 +41,11 @@ def compile_pgcl(code: str,
         substitute_constants: Whether constant substitution is done on the program, defaults to `True`.
     """
     program = parse_pgcl(code)
+    if substitute_constants:
+        substitute.substitute_constants(program)
     check_result = check_program(program)
     if check_result is not None:
         return check_result
-    if substitute_constants:
-        substitute.substitute_constants(program)
     return program
 
 

probably/pgcl/parser.py

@@ -485,7 +485,7 @@ def parse_expr(code: str) -> Expr:
     .. doctest::
 
         >>> parse_expr("x < y & z")
-        BinopExpr(operator=Binop.AND, lhs=BinopExpr(operator=Binop.LE, lhs=VarExpr('x'), rhs=VarExpr('y')), rhs=VarExpr('z'))
+        BinopExpr(operator=Binop.AND, lhs=BinopExpr(operator=Binop.LT, lhs=VarExpr('x'), rhs=VarExpr('y')), rhs=VarExpr('z'))
 
         >>> parse_expr("[x]")
         Traceback (most recent call last):

probably/pgcl/syntax.py

@@ -90,12 +90,11 @@
 """
 
 from typing import Optional, Sequence
-from collections.abc import Container
 
 from probably.util.ref import Mut
 
 from .ast import (AsgnInstr, Binop, BinopExpr, Expr, Instr, Program, Unop,
-                  UnopExpr, Var, VarExpr, WhileInstr)
+                  UnopExpr, VarExpr, WhileInstr)
 from .check import CheckFail
 from .ast.walk import Walk, instr_exprs, mut_expr_children, walk_expr, walk_instrs
 
@@ -120,42 +119,42 @@ def check_is_linear_program(program: Program) -> Optional[CheckFail]:
     """
     for instr_ref in walk_instrs(Walk.DOWN, program.instructions):
         for expr in instr_exprs(instr_ref.val):
-            res = check_is_linear_expr(expr, {*program.parameters.keys()})
+            res = check_is_linear_expr(expr, program)
             if isinstance(res, CheckFail):
                 return res
     return None
 
 
-def check_is_linear_expr(expr: Expr, not_a_variable: Container[Var] = frozenset()) -> Optional[CheckFail]:
+def check_is_linear_expr(expr: Expr, context: Program) -> Optional[CheckFail]:
     """
     Linear expressions do not multiply variables with each other.
     However, they may contain multiplication with constants or Iverson brackets.
     Division is also not allowed in linear expressions.
 
     :param expr:
-    :param not_a_variable: A collection of literals that are not to be considered variables, for example the
-        parameters of a program
+    :param not_a_variable: The context in which the expression is to be evaluated. Literals that are
+            parameters according to this context not considered variables.
 
     .. doctest::
 
         >>> from .ast import *
         >>> from .parser import parse_expectation
         >>> nat = NatLitExpr(10)
-        >>> check_is_linear_expr(BinopExpr(Binop.TIMES, nat, nat))
-        >>> check_is_linear_expr(BinopExpr(Binop.TIMES, nat, VarExpr('x')))
-        >>> check_is_linear_expr(BinopExpr(Binop.TIMES, VarExpr('x'), VarExpr('x')))
+        >>> check_is_linear_expr(BinopExpr(Binop.TIMES, nat, nat), None)
+        >>> check_is_linear_expr(BinopExpr(Binop.TIMES, nat, VarExpr('x')), None)
+        >>> check_is_linear_expr(BinopExpr(Binop.TIMES, VarExpr('x'), VarExpr('x')), None)
         CheckFail(location=..., message='Is not a linear expression')
-        >>> check_is_linear_expr(parse_expectation("[x < 6] * x"))
-        >>> check_is_linear_expr(parse_expectation("[x * x]"))
+        >>> check_is_linear_expr(parse_expectation("[x < 6] * x"), None)
+        >>> check_is_linear_expr(parse_expectation("[x * x]"), None)
         CheckFail(location=..., message='Is not a linear expression')
-        >>> check_is_linear_expr(parse_expectation("x/x"))
+        >>> check_is_linear_expr(parse_expectation("x/x"), None)
         CheckFail(location=..., message='General division is not linear (division of constants is)')
     """
 
     def _has_variable(expr: Expr) -> bool:
         if isinstance(expr, UnopExpr) and expr.operator == Unop.IVERSON:
             return False
-        if isinstance(expr, VarExpr) and not expr.var in not_a_variable:
+        if isinstance(expr, VarExpr) and (context is None or expr.var not in context.parameters):
             return True
         for child_ref in mut_expr_children(Mut.alloc(expr)):
             if _has_variable(child_ref.val):

tests/test_typechecking.py

@@ -123,3 +123,13 @@ def test_for_instr_errors():
         x := 5
     """)
     assert isinstance(check_program(program), CheckFail)
+
+    program = parse_pgcl("""
+        nat x
+        nat y
+        x := 5
+        y := unif(10, x * 5 + 3)
+    """)
+    res = check_program(program)
+    assert isinstance(res, CheckFail)
+    assert "In distribution parameter expressions, no variables are allowed. - Forgot parameter declaration?" in res.message