fix issue where parenthetical annotations would not bubble up

d20/expression.py

@@ -283,10 +283,11 @@ def set(self):
 
     @property
     def children(self):
-        return self.value.children
+        return [self.value]
 
     def set_child(self, index, value):
-        self.value.set_child(index, value)
+        self._child_set_check(index)
+        self.value = value
 
     def __repr__(self):
         return f"<Parenthetical value={self.value} operations={self.operations}>"

d20/utils.py

@@ -74,7 +74,7 @@ def simplify_expr_annotations(expr, ambig_inherit=None):
     :type expr: d20.Number
     :param ambig_inherit: When encountering a child node with no annotation and the parent has ambiguous types, which \
     to inherit. Can be ``None`` for no inherit, ``'left'`` for leftmost, or ``'right'`` for rightmost.
-    :type ambig_inherit: str
+    :type ambig_inherit: Optional[str]
     """
     if ambig_inherit not in ('left', 'right', None):
         raise ValueError("ambig_inherit must be 'left', 'right', or None.")

tests/test_utils.py

@@ -40,18 +40,28 @@ def test_copy(self):
             assert str(parse(expr)) == str(tree)
 
 
-def test_annotation_simplify():
-    expr = roll("1 [a] + 2 + 3 [b] + 4").expr
-    utils.simplify_expr_annotations(expr, None)
-    assert SimpleStringifier().stringify(expr) == "1 + 2 [a] + 3 [b] + 4 = 10"
-
-    expr = roll("1 [a] + 2 + 3 [b] + 4").expr
-    utils.simplify_expr_annotations(expr, 'left')
-    assert SimpleStringifier().stringify(expr) == "1 + 2 [a] + 3 [b] + 4 [a] = 10"
-
-    expr = roll("1 [a] + 2 + 3 [b] + 4").expr
-    utils.simplify_expr_annotations(expr, 'right')
-    assert SimpleStringifier().stringify(expr) == "1 + 2 [a] + 3 [b] + 4 [b] = 10"
+class TestAnnotationSimplify:
+    def test_annotation_simplify(self):
+        expr = roll("1 [a] + 2 + 3 [b] + 4").expr
+        utils.simplify_expr_annotations(expr, None)
+        assert SimpleStringifier().stringify(expr) == "1 + 2 [a] + 3 [b] + 4 = 10"
+
+        expr = roll("1 [a] + 2 + 3 [b] + 4").expr
+        utils.simplify_expr_annotations(expr, 'left')
+        assert SimpleStringifier().stringify(expr) == "1 + 2 [a] + 3 [b] + 4 [a] = 10"
+
+        expr = roll("1 [a] + 2 + 3 [b] + 4").expr
+        utils.simplify_expr_annotations(expr, 'right')
+        assert SimpleStringifier().stringify(expr) == "1 + 2 [a] + 3 [b] + 4 [b] = 10"
+
+        expr = roll("1 [a] + 2 + 3 [a] + 4").expr
+        utils.simplify_expr_annotations(expr.roll)
+        assert SimpleStringifier().stringify(expr) == "1 + 2 + 3 + 4 [a] = 10"
+
+    def test_parenthetical_annotation(self):
+        expr = roll("(1 [a])").expr
+        utils.simplify_expr_annotations(expr.roll)
+        assert SimpleStringifier().stringify(expr) == "(1) [a] = 1"
 
 
 def test_simplify():