Fix rendering of variables (#105)

Fixes the rendering of variables, which after
#103 would
always have extra colons being inserted, due to how variables are
parsed. This PR makes similar transformations as #103 did to separate
types and default values to solve this problem

Author: jabraham17

doc-test/index.rst

@@ -22,6 +22,7 @@ Module 'Foo'
    foo
    cpp_test
    nested
+   variables
 
 **Does it work???**
 

doc-test/variables.rst

@@ -0,0 +1,20 @@
+Variables
+=========
+
+
+
+Chapel variables
+----------------
+
+.. default-domain:: chpl
+
+.. module:: Variables
+    :synopsis: Variables, constants, and configuration parameters.
+
+.. data:: param e = 2.7182818284590452354
+
+    This is a constant.
+
+.. data:: param pi: real = 3.1415926535897932385
+
+    This is another constant.

sphinxcontrib/chapeldomain/__init__.py

@@ -125,10 +125,38 @@ def match_chpl_sig_pattern(sig: str):
     r"""^ ((?:\w+\s+)*)?          # optional: prefixes
           ([\w$.]*\.)?            # class name(s)
           ([\w$]+)                # const, var, param, etc name
-          (\s* [:={] \s* .+)?     # optional: type, default value
+          (\s*:\s*[^=]+)?         # optional: return type
+          (\s*[={]\s*.+)?         # optional: value
           $""", re.VERBOSE)
 
 
+def match_chpl_attr_sig_pattern(sig: str):
+    """
+    Match a Chapel signature against the regex pattern defined in
+    chpl_attr_sig_pattern.
+
+    This function cleans up the whitespace on the type (and removes ':'!)
+    and default value to make testing more consistent.
+    """
+    sig_match = chpl_attr_sig_pattern.match(sig)
+    if not sig_match:
+        return None
+    (
+        func_prefix,
+        name_prefix,
+        name,
+        return_type,
+        default_value,
+    ) = sig_match.groups()
+
+    if return_type:
+        return_type = return_type.strip().removeprefix(':').lstrip()
+    if default_value:
+        default_value = default_value.strip()
+
+    return (func_prefix, name_prefix, name, return_type, default_value)
+
+
 # This would be the ideal way to create a chapelerific desc_returns similar to
 # addnodes.desc_returns. However, due to some update issue, the
 # nodes._add_node_class_names() call does not seem to make chapel_desc_returns
@@ -267,7 +295,13 @@ def _pseudo_parse_arglist(signode, arglist):
 
     @staticmethod
     def _handle_signature_suffix(
-        signode, return_intent, return_type, throws, anno, where_clause
+        signode,
+        return_intent,
+        return_type,
+        default_value,
+        throws,
+        anno,
+        where_clause,
     ):
         """
         handle the signature suffix items like return intent, return type,
@@ -282,6 +316,10 @@ def _handle_signature_suffix(
             signode += addnodes.desc_sig_space(' ', ' ')
             signode += addnodes.desc_annotation(' : ' + return_type,
                                                 ' : ' + return_type)
+        if default_value:
+            signode += addnodes.desc_sig_space(' ', ' ')
+            signode += addnodes.desc_annotation(default_value,
+                                                default_value)
         if throws:
             signode += addnodes.desc_sig_space(' ', ' ')
             signode += addnodes.desc_annotation(' throws', ' throws')
@@ -293,11 +331,11 @@ def _handle_signature_suffix(
 
     def _get_attr_like_prefix(self, sig):
         """Return prefix text for attribute or data directive."""
-        sig_match = chpl_attr_sig_pattern.match(sig)
+        sig_match = match_chpl_attr_sig_pattern(sig)
         if sig_match is None:
             return ChapelObject.get_signature_prefix(self, sig)
 
-        prefixes, _, _, _ = sig_match.groups()
+        prefixes = sig_match[0]
         if prefixes:
             return prefixes.strip() + ' '
         elif self.objtype == 'type':
@@ -374,10 +412,17 @@ def handle_signature(self, sig, signode):
         class(es)) and the classes. See also :py:meth:`add_target_and_index`.
         """
         if self._is_attr_like():
-            sig_match = chpl_attr_sig_pattern.match(sig)
+            sig_match = match_chpl_attr_sig_pattern(sig)
             if sig_match is None:
                 raise ValueError('Signature does not parse: {0}'.format(sig))
-            func_prefix, name_prefix, name, return_type = sig_match.groups()
+            (
+                func_prefix,
+                name_prefix,
+                name,
+                return_type,
+                default_value,
+            ) = sig_match
+
             return_intent = None
             throws = None
             arglist = None
@@ -397,6 +442,7 @@ def handle_signature(self, sig, signode):
                 throws,
                 where_clause,
             ) = sig_match
+            default_value = None
 
             # check if where clause is valid
             if where_clause is not None and not self._is_proc_like():
@@ -453,13 +499,25 @@ def handle_signature(self, sig, signode):
                 # for callables, add an empty parameter list
                 signode += addnodes.desc_parameterlist()
             self._handle_signature_suffix(
-                signode, return_intent, return_type, throws, anno, where_clause
+                signode,
+                return_intent,
+                return_type,
+                default_value,
+                throws,
+                anno,
+                where_clause,
             )
             return fullname, name_prefix
 
         self._pseudo_parse_arglist(signode, arglist)
         self._handle_signature_suffix(
-            signode, return_intent, return_type, throws, anno, where_clause
+            signode,
+            return_intent,
+            return_type,
+            default_value,
+            throws,
+            anno,
+            where_clause,
         )
 
         return fullname, name_prefix

test/test_chapeldomain.py

@@ -11,7 +11,8 @@
 from sphinxcontrib.chapeldomain import (
     ChapelDomain, ChapelModuleIndex, ChapelClassObject, ChapelModuleLevel, ChapelObject,
     ChapelTypedField, ChapelClassMember,
-    chpl_sig_pattern, match_chpl_sig_pattern, chpl_attr_sig_pattern,
+    chpl_sig_pattern, match_chpl_sig_pattern,
+    chpl_attr_sig_pattern, match_chpl_attr_sig_pattern
 )
 
 
@@ -892,16 +893,23 @@ class AttrSigPatternTests(PatternTestCase):
 
     pattern = chpl_attr_sig_pattern
 
-    def check_sig(self, sig, func_prefix, name_prefix, name, retann):
+    def check_sig(self, sig, func_prefix, name_prefix, name, type_, default_value):
         """Verify signature results in appropriate matches."""
-        match = self.pattern.match(sig)
+        match = match_chpl_attr_sig_pattern(sig)
         self.assertIsNotNone(match)
 
-        (actual_func_prefix, actual_name_prefix, actual_name, actual_retann) = match.groups()
+        (
+            actual_func_prefix,
+            actual_name_prefix,
+            actual_name,
+            actual_type,
+            actual_default_value,
+        ) = match
         self.assertEqual(func_prefix, actual_func_prefix)
         self.assertEqual(name_prefix, actual_name_prefix)
         self.assertEqual(name, actual_name)
-        self.assertEqual(retann, actual_retann)
+        self.assertEqual(type_, actual_type)
+        self.assertEqual(default_value, actual_default_value)
 
     def test_does_not_match(self):
         """Verify various signatures that should not match."""
@@ -927,7 +935,7 @@ def test_simple_label(self):
             '1',
         ]
         for sig in test_cases:
-            self.check_sig(sig, '', None, sig, None)
+            self.check_sig(sig, '', None, sig, None, None)
 
     def test_with_class_names(self):
         """Verify symbols with class names match pattern."""
@@ -937,7 +945,7 @@ def test_with_class_names(self):
             ('BigNum.fromInt', 'BigNum.', 'fromInt'),
         ]
         for sig, class_name, attr in test_cases:
-            self.check_sig(sig, '', class_name, attr, None)
+            self.check_sig(sig, '', class_name, attr, None, None)
 
     def test_with_prefixes(self):
         """Verify type, config, etc prefixes work."""
@@ -949,51 +957,62 @@ def test_with_prefixes(self):
             ('const baz', 'const ', 'baz'),
         ]
         for sig, prefix, attr in test_cases:
-            self.check_sig(sig, prefix, None, attr, None)
+            self.check_sig(sig, prefix, None, attr, None, None)
 
     def test_with_types(self):
         """Verify types parse correctly."""
         test_cases = [
-            ('foo: int', 'foo', ': int'),
-            ('bar: real', 'bar', ': real'),
-            ('baz: int(32)', 'baz', ': int(32)'),
-            ('D: domain(9)', 'D', ': domain(9)'),
-            ('A: [{1..n}] BigNum', 'A', ': [{1..n}] BigNum'),
-            ('x: MyModule.MyClass', 'x', ': MyModule.MyClass'),
-            ('x  :  sync real', 'x', '  :  sync real'),
+            ('foo: int', 'foo', 'int', None),
+            ('bar: real', 'bar', 'real', None),
+            ('baz: int(32)', 'baz', 'int(32)', None),
+            ('D: domain(9)', 'D', 'domain(9)', None),
+            ('A: [{1..n}] BigNum', 'A', '[{1..n}] BigNum', None),
+            ('x: MyModule.MyClass', 'x', 'MyModule.MyClass', None),
+            ('x  :  sync real', 'x', 'sync real', None),
+        ]
+        for sig, attr, type_name, default_val in test_cases:
+            self.check_sig(sig, '', None, attr, type_name, default_val)
+
+    def test_with_defaults(self):
+        """Verify default values parse correctly."""
+        test_cases = [
+            ('x = 5', 'x', None, '= 5'),
+            ('y = [i in 1..10] i == 1', 'y', None, '= [i in 1..10] i == 1'),
+            ('z { A=1, B}', 'z', None, '{ A=1, B}'),
         ]
-        for sig, attr, type_name in test_cases:
-            self.check_sig(sig, '', None, attr, type_name)
+        for sig, attr, type_name, default_val in test_cases:
+            self.check_sig(sig, '', None, attr, type_name, default_val)
 
     def test_with_all(self):
         """Verify full specified signatures parse correctly."""
         test_cases = [
-            ('config const MyModule.MyClass.n: int', 'config const ', 'MyModule.MyClass.', 'n', ': int'),
-            ('var X.n: MyMod.MyClass', 'var ', 'X.', 'n', ': MyMod.MyClass'),
-            ('config param debugAdvancedIters:bool', 'config param ', None, 'debugAdvancedIters', ':bool'),
-            ('config param MyMod.DEBUG: bool', 'config param ', 'MyMod.', 'DEBUG', ': bool'),
-            ('var RandomStreamPrivate_lock$: _syncvar(bool)', 'var ', None, 'RandomStreamPrivate_lock$', ': _syncvar(bool)'),
-            ('var RandomStreamPrivate_lock$: sync bool', 'var ', None, 'RandomStreamPrivate_lock$', ': sync bool'),
-            ('const RS$.lock$: sync MyMod$.MyClass$.bool', 'const ', 'RS$.', 'lock$', ': sync MyMod$.MyClass$.bool'),
-            ('type commDiagnostics = chpl_commDiagnostics', 'type ', None, 'commDiagnostics', ' = chpl_commDiagnostics'),
-            ('type age = int(64)', 'type ', None, 'age', ' = int(64)'),
-            ('type MyMod.BigAge=BigNum.BigInt', 'type ', 'MyMod.', 'BigAge', '=BigNum.BigInt'),
-            ('const x = false', 'const ', None, 'x', ' = false'),
-            ('config const MyC.x: int(64) = 5', 'config const ', 'MyC.', 'x', ': int(64) = 5'),
-            ('config param n: uint(64) = 5: uint(64)', 'config param ', None, 'n', ': uint(64) = 5: uint(64)'),
-            ('var MyM.MyC.x = 4: uint(64)', 'var ', 'MyM.MyC.', 'x', ' = 4: uint(64)'),
-            ('type MyT = 2*real(64)', 'type ', None, 'MyT', ' = 2*real(64)'),
-            ('type myFloats = 2*(real(64))', 'type ', None, 'myFloats', ' = 2*(real(64))'),
-            ('enum Color { Red, Yellow, Blue }', 'enum ', None, 'Color', ' { Red, Yellow, Blue }'),
-            ('enum Month { January=1, February }', 'enum ', None, 'Month', ' { January=1, February }'),
-            ('enum One { Neo }', 'enum ', None, 'One', ' { Neo }'),
-            ('enum constant Pink', 'enum constant ', None, 'Pink', None),
-            ('enum constant December', 'enum constant ', None, 'December', None),
-            ('enum constant Hibiscus', 'enum constant ', None, 'Hibiscus', None),
-            ('enum constant Aquarius', 'enum constant ', None, 'Aquarius', None)
+            ('config const MyModule.MyClass.n: int', 'config const ', 'MyModule.MyClass.', 'n', 'int', None),
+            ('var X.n: MyMod.MyClass', 'var ', 'X.', 'n', 'MyMod.MyClass', None),
+            ('config param debugAdvancedIters:bool', 'config param ', None, 'debugAdvancedIters', 'bool', None),
+            ('config param MyMod.DEBUG: bool', 'config param ', 'MyMod.', 'DEBUG', 'bool', None),
+            ('var RandomStreamPrivate_lock$: _syncvar(bool)', 'var ', None, 'RandomStreamPrivate_lock$', '_syncvar(bool)', None),
+            ('var RandomStreamPrivate_lock$: sync bool', 'var ', None, 'RandomStreamPrivate_lock$', 'sync bool', None),
+            ('const RS$.lock$: sync MyMod$.MyClass$.bool', 'const ', 'RS$.', 'lock$', 'sync MyMod$.MyClass$.bool', None),
+            ('var arr: [{1..10}] real(64) = [i in 1..10] i:real(64)', 'var ', None, 'arr', '[{1..10}] real(64)', '= [i in 1..10] i:real(64)'),
+            ('type commDiagnostics = chpl_commDiagnostics', 'type ', None, 'commDiagnostics', None, '= chpl_commDiagnostics'),
+            ('type age = int(64)', 'type ', None, 'age', None, '= int(64)'),
+            ('type MyMod.BigAge=BigNum.BigInt', 'type ', 'MyMod.', 'BigAge', None, '=BigNum.BigInt'),
+            ('const x = false', 'const ', None, 'x', None, '= false'),
+            ('config const MyC.x: int(64) = 5', 'config const ', 'MyC.', 'x', 'int(64)', '= 5'),
+            ('config param n: uint(64) = 5: uint(64)', 'config param ', None, 'n', 'uint(64)', '= 5: uint(64)'),
+            ('var MyM.MyC.x = 4: uint(64)', 'var ', 'MyM.MyC.', 'x', None, '= 4: uint(64)'),
+            ('type MyT = 2*real(64)', 'type ', None, 'MyT', None, '= 2*real(64)'),
+            ('type myFloats = 2*(real(64))', 'type ', None, 'myFloats', None, '= 2*(real(64))'),
+            ('enum Color { Red, Yellow, Blue }', 'enum ', None, 'Color', None, '{ Red, Yellow, Blue }'),
+            ('enum Month { January=1, February }', 'enum ', None, 'Month', None, '{ January=1, February }'),
+            ('enum One { Neo }', 'enum ', None, 'One', None, '{ Neo }'),
+            ('enum constant Pink', 'enum constant ', None, 'Pink', None, None),
+            ('enum constant December', 'enum constant ', None, 'December', None, None),
+            ('enum constant Hibiscus', 'enum constant ', None, 'Hibiscus', None, None),
+            ('enum constant Aquarius', 'enum constant ', None, 'Aquarius', None, None)
         ]
-        for sig, prefix, class_name, attr, type_name in test_cases:
-            self.check_sig(sig, prefix, class_name, attr, type_name)
+        for sig, prefix, class_name, attr, type_name, default_value in test_cases:
+            self.check_sig(sig, prefix, class_name, attr, type_name, default_value)
 
 
 if __name__ == '__main__':