6cdfa29574
**Summary**
In a program such as:
```
namespace A {
namespace B {
struct Bar {};
}
}
namespace B {
struct Foo {};
}
```
...LLDB would run into issues such as:
```
(lldb) expr ::B::Foo f
error: expression failed to parse:
error: <user expression 0>:1:6: no type named 'Foo' in namespace 'A::B'
::B::Foo f
~~~~~^
```
This is because the `SymbolFileDWARF::FindNamespace` implementation
will return *any* namespace it finds if the `parent_decl_ctx` provided
is empty. In `FindExternalVisibleDecls` we use this API to find the
namespace that symbol `B` refers to. If `A::B` happened to be the one
that `SymbolFileDWARF::FindNamespace` looked at first, we would try
to find `struct Foo` in `A::B`. Hence the error.
This patch proposes a new `SymbolFileDWARF::FindNamespace` API that
will only find a match for top-level namespaces, which is what
`FindExternalVisibleDecls` is attempting anyway; it just never
accounted for multiple namespaces of the same name.
**Testing**
* Added API test-case
Differential Revision: https://reviews.llvm.org/D147436
145 lines
2.8 KiB
C++
145 lines
2.8 KiB
C++
#include <cstdarg>
|
|
#include <cstdlib>
|
|
#include "ns.h"
|
|
|
|
namespace {
|
|
typedef unsigned int my_uint_t;
|
|
int i; // Find the line number for anonymous namespace variable i.
|
|
|
|
int myanonfunc (int a)
|
|
{
|
|
return a + a;
|
|
}
|
|
|
|
int
|
|
variadic_sum (int arg_count...)
|
|
{
|
|
int sum = 0;
|
|
std::va_list args;
|
|
va_start(args, arg_count);
|
|
|
|
for (int i = 0; i < arg_count; i++)
|
|
sum += va_arg(args, int);
|
|
|
|
va_end(args);
|
|
return sum;
|
|
}
|
|
}
|
|
|
|
namespace A {
|
|
typedef unsigned int uint_t;
|
|
namespace B {
|
|
typedef unsigned int uint_t;
|
|
int j; // Find the line number for named namespace variable j.
|
|
int myfunc (int a);
|
|
int myfunc2(int a)
|
|
{
|
|
return a + 2;
|
|
}
|
|
float myfunc (float f)
|
|
{
|
|
return f - 2.0;
|
|
}
|
|
}
|
|
}
|
|
|
|
namespace Y
|
|
{
|
|
typedef unsigned int uint_t;
|
|
using A::B::j;
|
|
int foo;
|
|
}
|
|
|
|
using A::B::j; // using declaration
|
|
|
|
namespace Foo = A::B; // namespace alias
|
|
|
|
using Foo::myfunc; // using declaration
|
|
|
|
using namespace Foo; // using directive
|
|
|
|
namespace A {
|
|
namespace B {
|
|
using namespace Y;
|
|
int k;
|
|
}
|
|
}
|
|
|
|
namespace ns1 {
|
|
int value = 100;
|
|
}
|
|
|
|
namespace ns2 {
|
|
int value = 200;
|
|
}
|
|
|
|
void test_namespace_scopes() {
|
|
do {
|
|
using namespace ns1;
|
|
printf("ns1::value = %d\n", value); // Evaluate ns1::value
|
|
} while(0);
|
|
|
|
do {
|
|
using namespace ns2;
|
|
printf("ns2::value = %d\n", value); // Evaluate ns2::value
|
|
} while(0);
|
|
}
|
|
|
|
int Foo::myfunc(int a)
|
|
{
|
|
test_namespace_scopes();
|
|
|
|
::my_uint_t anon_uint = 0;
|
|
A::uint_t a_uint = 1;
|
|
B::uint_t b_uint = 2;
|
|
Y::uint_t y_uint = 3;
|
|
i = 3;
|
|
j = 4;
|
|
printf("::i=%d\n", ::i);
|
|
printf("A::B::j=%d\n", A::B::j);
|
|
printf("variadic_sum=%d\n", variadic_sum(3, 1, 2, 3));
|
|
myanonfunc(3);
|
|
return myfunc2(3) + j + i + a + 2 + anon_uint + a_uint + b_uint + y_uint; // Set break point at this line.
|
|
}
|
|
|
|
namespace B {
|
|
struct Bar {
|
|
int x() { return 42; }
|
|
};
|
|
Bar bar;
|
|
} // namespace B
|
|
|
|
namespace A::B {
|
|
struct Bar {
|
|
int y() { return 137; }
|
|
};
|
|
} // namespace A::B
|
|
|
|
namespace NS1::NS2 {
|
|
struct Foo {
|
|
int bar() { return -2; }
|
|
};
|
|
} // namespace NS1::NS2
|
|
|
|
namespace NS2 {
|
|
struct Foo {
|
|
int bar() { return -3; }
|
|
};
|
|
} // namespace NS2
|
|
|
|
int
|
|
main (int argc, char const *argv[])
|
|
{
|
|
test_lookup_at_global_scope();
|
|
test_lookup_at_file_scope();
|
|
A::test_lookup_at_ns_scope();
|
|
A::B::test_lookup_at_nested_ns_scope();
|
|
A::B::test_lookup_at_nested_ns_scope_after_using();
|
|
test_lookup_before_using_directive();
|
|
test_lookup_after_using_directive();
|
|
::B::Bar bb;
|
|
A::B::Bar ab;
|
|
return Foo::myfunc(12) + bb.x() + ab.y() + NS1::NS2::Foo{}.bar() +
|
|
NS2::Foo{}.bar();
|
|
}
|