https://github.com/clayborg commented:
My main questions is do we actually use wildcards a lot? In normal type query
matches, we can ask for exact matches where everything is specified, or the
user types some string like `a::b::iterator` where we don't know what any of
the items are. If exact match is specified then all levels need to match the
type we found, but if exact match is not specified, then we accept anything
that ends with the specified compiler context. There are no wildcards specified
in any of these kinds of queries from a type lookup perspective right? Where
are these actual wildcard searches happening?
When searching for a type in anonymous namespaces, are you expecting the
compiler context that gets created for such types is doing to include the
anonymous namespace in the context? So for:
```
namespace {
struct Foo {};
}
```
The compiler context will end up being:
```
namespace ""
struct "Foo"
```
We might need to notion of a declaration context barrier item in our
CompilerContext arrays that say "the type below this is fully qualified on its
own, but this barrier can help disambiguate searches if the user fully
specifies things. For example a type in a function right now:
```
namespace a {
void func1() {
namespace b {
struct foo{};
};
}
```
Currently will produce a compiler contenxt of:
```
namespace "b"
struct "foo"
```
But could it could include "func1"'s context in the future:
```
namespace "a"
function "func1" <<<< barrier entry (for lack of a better term)
namespace "b"
struct "foo"
```
Then a search for an exact type name `"b::foo"` could match the above compiler
context as it matches fully up to a barrier `CompilerContext`. But if the users
knows they want this exact type they could ask for `"a::func1::b::foo"` and get
the right one if they were other `"b::foo"` types.
I mention this because for anonynmous namespace types, we might not want to
have to type `"(anonymous namespace)::Foo"` to find the type from my first
example, users probably just want to type `"Foo"` and still find the type and
the anonymous namespace could be one of these new decl context root barriers.
Any clarification on what you plan to do for anonymous types would be great to
hear.
https://github.com/llvm/llvm-project/pull/99305
_______________________________________________
lldb-commits mailing list
lldb-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
