using directives in a class are slightly different from global using

virtuald · virtuald · commit a1f5eae8f1d9 · 2019-12-29T17:09:20.000-05:00
diff --git a/CppHeaderParser/CppHeaderParser.py b/CppHeaderParser/CppHeaderParser.py
@@ -589,6 +589,8 @@ class CppClass(dict):
         * ``nested_classes`` - Classes and structs defined within this class
         * ``final`` - True if final
         * ``abstract`` - True if abstract
+        * ``using`` - Using directives in this class scope: key is name for lookup,
+          value is :class:`.CppVariable`
         * ``parent`` - If not None, the class that this class is nested in
         
         An example of how this could look is as follows::
@@ -654,6 +656,7 @@ def __init__(self, nameStack, curTemplate, doxygen, location):
         self._public_typedefs = {}
         self._public_forward_declares = []
         self["namespace"] = ""
+        self["using"] = {}
 
         debug_print("Class:    %s", nameStack)
         debug_print("Template: %s", curTemplate)
@@ -1124,12 +1127,14 @@ class CppVariable(_CppVariable):
         * ``default`` - Default value of the variable, this key will only
           exist if there is a default value
         * ``extern`` - True if its an extern, False if not
+        * ``parent`` - If not None, either the class this is a property of, or the
+          method this variable is a parameter in
     """
 
     Vars = []
 
     def __init__(self, nameStack, doxygen, location, **kwargs):
-        debug_print("trace %s", nameStack)
+        debug_print("var trace %s", nameStack)
         if len(nameStack) and nameStack[0] == "extern":
             self["extern"] = True
             del nameStack[0]
@@ -1497,21 +1502,33 @@ def resolve_type(self, string, result):  # recursive
                 result["fundamental"] = False
                 result["class"] = klass
                 result["unresolved"] = False
-            elif self.using:
-                # search for type in all enclosing namespaces
-                for ns in _iter_ns_str_reversed(result.get("namespace", "")):
-                    nsalias = ns + alias
-                    used = self.using.get(nsalias)
-                    if used:
-                        for i in ("type", "namespace", "ctypes_type", "raw_type"):
-                            if i in used:
-                                result[i] = used[i]
-                        result["unresolved"] = False
-                        break
-                else:
-                    result["unresolved"] = True
             else:
-                result["unresolved"] = True
+                used = None
+
+                # Search for using directives in parents
+                parent = result["parent"]
+                while parent:
+                    p_using = parent.get("using")
+                    if p_using:
+                        used = p_using.get(alias)
+                        if used:
+                            break
+                    parent = parent["parent"]
+
+                if not used and self.using:
+                    # search for type in all enclosing namespaces
+                    # TODO: would be nice if namespaces were an object?
+                    for ns in _iter_ns_str_reversed(result.get("namespace", "")):
+                        nsalias = ns + alias
+                        used = self.using.get(nsalias)
+                        if used:
+                            break
+
+                if used:
+                    for i in ("type", "namespace", "ctypes_type", "raw_type"):
+                        if i in used:
+                            result[i] = used[i]
+                    result["unresolved"] = False
         else:
             result["fundamental"] = True
             result["unresolved"] = False
@@ -2544,8 +2561,8 @@ def __init__(self, headerFileName, argType="file", encoding=None, **kwargs):
         self.anon_struct_counter = 0
         self.anon_union_counter = [-1, 0]
 
-        #: Using directives in this header: key is full name for lookup, value
-        #: is :class:`.CppVariable`
+        #: Using directives in this header outside of class scope: key is
+        #: full name for lookup, value is :class:`.CppVariable`
         self.using = {}
 
         if len(self.headerFileName):
@@ -3116,23 +3133,40 @@ def _evaluate_stack(self, token=None):
             else:
                 if len(self.nameStack) > 3 and self.nameStack[2] == "=":
                     # using foo = ns::bar
+                    # -> type alias: same behavior in all scopes
                     alias = self.nameStack[1]
                     ns, stack = _split_namespace(self.nameStack[3:])
                     atype = CppVariable(
                         stack, self._get_stmt_doxygen(), self._get_location(stack)
                     )
+
+                    # namespace refers to the embedded type
+                    atype["namespace"] = ns
                 else:
                     # using foo::bar
+                    # -> in global scope this is bringing in something
+                    #    from a different namespace
+                    # -> in class scope this is bringing in a member
+                    #    from a base class
                     ns, stack = _split_namespace(self.nameStack[1:])
                     atype = CppVariable(
                         stack, self._get_stmt_doxygen(), self._get_location(stack)
                     )
                     alias = atype["type"]
+                    if self.curClass:
+                        atype["baseclass"] = ns
+                    else:
+                        atype["namespace"] = ns
 
-                atype["namespace"] = ns
                 atype["raw_type"] = ns + atype["type"]
-                alias = self.current_namespace() + alias
-                self.using[alias] = atype
+
+                if self.curClass:
+                    klass = self.classes[self.curClass]
+                    klass["using"][alias] = atype
+                else:
+                    # lookup is done
+                    alias = self.current_namespace() + alias
+                    self.using[alias] = atype
         elif is_method_namestack(self.stack) and "(" in self.nameStack:
             debug_print("trace")
             self._evaluate_method_stack()
diff --git a/test/test_CppHeaderParser.py b/test/test_CppHeaderParser.py
@@ -2787,18 +2787,26 @@ def setUp(self):
     using VoidFunction = std::function<void()>;
 
     void fn(string &s, VoidFunction fn, thing * t);
+
+    class A : public B {
+    public:
+        using B::B;
+        using IntFunction = std::function<int()>;
+
+        void a(string &s, IntFunction fn, thing * t);
+    };
 }
 """,
             "string",
         )
 
     def test_using(self):
+        self.assertEqual(len(self.cppHeader.using), 3)
         self.assertIn("a::string", self.cppHeader.using)
         self.assertIn("a::VoidFunction", self.cppHeader.using)
         self.assertIn("thing", self.cppHeader.using)
 
     def test_fn(self):
-        self.maxDiff = None
         self.assertEqual(len(self.cppHeader.functions), 1)
         fn = self.cppHeader.functions[0]
         self.assertEqual(fn["name"], "fn")
@@ -2829,6 +2837,43 @@ def test_fn(self):
             ],
         )
 
+    def test_class(self):
+        c = self.cppHeader.classes["A"]
+
+        self.assertEqual(len(c["using"]), 2)
+        self.assertIn("B", c["using"])
+        self.assertIn("IntFunction", c["using"])
+
+        self.assertEqual(len(c["methods"]["public"]), 1)
+        fn = c["methods"]["public"][0]
+        self.assertEqual(fn["name"], "a")
+        self.assertEqual(
+            filter_pameters(fn["parameters"], ["namespace", "raw_type"]),
+            [
+                {
+                    "type": "string",
+                    "name": "s",
+                    "desc": None,
+                    "namespace": "std::",
+                    "raw_type": "std::string",
+                },
+                {
+                    "type": "function<int ( )>",
+                    "name": "fn",
+                    "desc": None,
+                    "namespace": "std::",
+                    "raw_type": "std::function<int ( )>",
+                },
+                {
+                    "type": "thing",
+                    "name": "t",
+                    "desc": None,
+                    "namespace": "std::",
+                    "raw_type": "std::thing",
+                },
+            ],
+        )
+
 
 class StaticFn_TestCase(unittest.TestCase):
     def setUp(self):
