[lldb] Add SubstTemplateTypeParm to RemoveWrappingTypes

[teemperor]

Summary

Like the other type sugar removed by RemoveWrappingTypes, SubstTemplateTypeParm is just
pure sugar that should be ignored. If we don't ignore it (as we do now), LLDB will fail to
read values from record fields that have a SubstTemplateTypeParm type.

Only way to produce such a type in LLDB is to either use the import-std-module setting
to get a template into the expression parser or just create your own template directly
in the expression parser which is what we do in the test.

[jarin]

Looks good.

I did not realize that types propagate from one evaluation to another. This is not possible to reproduce without introducing the template in the evaluation right? (Or could it repro with simple expressions if the debuggee contained modules with the templates?)

lldb/test/API/lang/cpp/subst_template_type_param/TestSubstTemplateTypeParam.py

5

Typos in the comment: produces -> produced, parameter -> parameters

32

Non-actionable comment: Interesting, I did not know you can use types from previous evaluations.

[teemperor]

In D85132#2209354, @jarin wrote:

Looks good.

I did not realize that types propagate from one evaluation to another. This is not possible to reproduce without introducing the template in the evaluation right? (Or could it repro with simple expressions if the debuggee contained modules with the templates?)

If you mean with modules = normal debug-info modules, then yes, it's to my knowledge not possible to reproduce this with just normal debug info. We don't manually create SubstTemplateTypeParm types within LLDB and they are only created by Clang during template instantiation (and we never create real templates in LLDB, so we don't use Clang's template instantiation logic). But maybe if we have better template support in the future we might encounter these types even with debug info.

if you mean modules = Clang modules, then it's straightforward to reproduce (pretty much by just copying the expression we have here into the Clang module). But C++ Clang modules are really just supported by accident at the moment.

lldb/test/API/lang/cpp/subst_template_type_param/TestSubstTemplateTypeParam.py

5

Thanks!

32

Declarations from 'top-level' expressions will be exported to the scratch AST (that's actually the only use case of top-level expressions). You can also prefix the name of most declarations with a $ and then you can use them in follow-up expressions:

(lldb) expr struct $Foo { int i; }
(lldb) expr $Foo f; f
($Foo) $0 = (i = 0)

That feature is also the fastest way to break the expression evaluator :p

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

while (true) {
     // sufficient for the purposes we care about.
     case clang::Type::Atomic:
       type = cast<clang::AtomicType>(type)->getValueType();
       break;
     case clang::Type::Auto:
     case clang::Type::Decltype:
     case clang::Type::Elaborated:
     case clang::Type::Paren:
+    case clang::Type::SubstTemplateTypeParm:
     case clang::Type::TemplateSpecialization:
     case clang::Type::Typedef:
     case clang::Type::TypeOf:
     case clang::Type::TypeOfExpr:
       type = type->getLocallyUnqualifiedSingleStepDesugaredType();
       break;
     default:
       return type;

lldb/test/API/lang/cpp/subst_template_type_param/TestSubstTemplateTypeParam.py

+"""
+Test SubstTemplateTypeParam types which are produced as type sugar
+when template type parameters are used for example as field types.
+"""
+
+import lldb
+import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import decorators
+
+class TestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def test_typedef(self):
+        target = self.dbg.GetDummyTarget()
+
+        # Declare a template class with a field that uses the template type
+        # parameter.
+        opts = lldb.SBExpressionOptions()
+        opts.SetTopLevel(True)
+        result = target.EvaluateExpression("template <typename T> struct X { T f; };", opts)
+        # FIXME: This fails with "Couldn't find $__lldb_expr() in the module"
+        # but it should succeed. The fact that this code has nothing to run
+        # shouldn't be an error.
+        # self.assertSuccess(result.GetError())
+
+        # Instantiate and produce a value with that template as the type.
+        # The field in the value will have a SubstTemplateTypeParam that
+        # should behave like a normal field.
+        result = target.EvaluateExpression("X<int> x; x.f = 123; x")
+        self.assertEqual(result.GetNumChildren(), 1)
+        self.assertEqual(result.GetChildAtIndex(0).GetTypeName(), "int")
+        self.assertEqual(result.GetChildAtIndex(0).GetValue(), "123")