[TypeSystem] Handle Clang AttributedTypes

[spyffe]

Summary

When parsing types originating in modules, it is possible to encounter AttributedTypes (such as the type generated for NSString *_Nonnull). Some of LLDB's ClangASTContext methods deal with them; others do not. In particular, one function that did not was GetTypeInfo, causing TestObjCNewSyntax to fail.

This fixes that, treating AttributedType as essentially transparent and getting the information for the modified type.

In addition, however, TestObjCNewSyntax is a monolithic test that verifies a bunch of different things, all of which can break independently of one another. I broke it apart into smaller tests so that we get more precise failures when something (like this) breaks.

[jingham]

That seems correct since we aren't recording the attributes in the type flags.

The only question I have is that you're assuming something that has a TypeClass of Attributed will always convert to an AttributedType successfully, and that attributed types can always fetch the type they are an attribute-modified type of. Those both seem reasonable assumptions, do you know they are true?

[spyffe]

ModifiedType gets assigned during construction and getModifiedType() is just an accessor, so if that is nullptr something very bad is happening. We should not expect that except in case of a parser bug of some sort.

AttributedType checks that a Type* is an AttributedType in the following way (Type.h):

static bool classof(const Type *T) {
  return T->getTypeClass() == Attributed;
}

So our use of the type class is canonical.

[jingham]

Okay. If the attributed types were hand-built types from DWARF, I would still worry a bit about the getModifiedType() call. But these only come from modules, and those are built by orthodox methods so they should be self-consistent.

lldb/trunk/packages/Python/lldbsuite/test/lang/objc/objc-new-syntax/TestObjCNewSyntax.py

class ObjCNewSyntaxTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.line = line_number('main.m', '// Set breakpoint 0 here.')
 
-    @skipUnlessDarwin
-    @expectedFailureAll(
-        oslist=['macosx'],
-        compiler='clang',
-        compiler_version=[
-            '<',
-            '7.0.0'])
-    @skipIf(macos_version=["<", "10.12"])
-    @expectedFailureAll(archs=["i[3-6]86"])
-    def test_expr(self):
+    def runToBreakpoint(self):
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Break inside the foo function which takes a bar_ptr argument.
         lldbutil.run_break_set_by_file_and_line(
             self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
         self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
                     substrs=[' resolved, hit count = 1'])
 
+    @skipUnlessDarwin
+    @expectedFailureAll(
+        oslist=['macosx'],
+        compiler='clang',
+        compiler_version=[
+            '<',
+            '7.0.0'])
+    @skipIf(macos_version=["<", "10.12"])
+    @expectedFailureAll(archs=["i[3-6]86"])
+    def test_read_array(self):
+        self.runToBreakpoint()
+
         self.expect(
             "expr --object-description -- immutable_array[0]",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=["foo"])
 
         self.expect(
             "expr --object-description -- mutable_array[0]",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=["foo"])
 
+    @skipUnlessDarwin
+    @expectedFailureAll(
+        oslist=['macosx'],
+        compiler='clang',
+        compiler_version=[
+            '<',
+            '7.0.0'])
+    @skipIf(macos_version=["<", "10.12"])
+    @expectedFailureAll(archs=["i[3-6]86"])
+    def test_update_array(self):
+        self.runToBreakpoint()
+
         self.expect(
             "expr --object-description -- mutable_array[0] = @\"bar\"",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=["bar"])
 
         self.expect(
             "expr --object-description -- mutable_array[0]",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=["bar"])
 
+    @skipUnlessDarwin
+    @expectedFailureAll(
+        oslist=['macosx'],
+        compiler='clang',
+        compiler_version=[
+            '<',
+            '7.0.0'])
+    @skipIf(macos_version=["<", "10.12"])
+    @expectedFailureAll(archs=["i[3-6]86"])
+    def test_read_dictionary(self):
+        self.runToBreakpoint()
+
         self.expect(
             "expr --object-description -- immutable_dictionary[@\"key\"]",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=["value"])
 
         self.expect(
             "expr --object-description -- mutable_dictionary[@\"key\"]",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=["value"])
 
+    @skipUnlessDarwin
+    @expectedFailureAll(
+        oslist=['macosx'],
+        compiler='clang',
+        compiler_version=[
+            '<',
+            '7.0.0'])
+    @skipIf(macos_version=["<", "10.12"])
+    @expectedFailureAll(archs=["i[3-6]86"])
+    def test_update_dictionary(self):
+        self.runToBreakpoint()
+
         self.expect(
             "expr --object-description -- mutable_dictionary[@\"key\"] = @\"object\"",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=["object"])
 
         self.expect(
             "expr --object-description -- mutable_dictionary[@\"key\"]",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=["object"])
 
+    @skipUnlessDarwin
+    @expectedFailureAll(
+        oslist=['macosx'],
+        compiler='clang',
+        compiler_version=[
+            '<',
+            '7.0.0'])
+    @skipIf(macos_version=["<", "10.12"])
+    @expectedFailureAll(archs=["i[3-6]86"])
+    def test_array_literal(self):
+        self.runToBreakpoint()
+
         self.expect(
             "expr --object-description -- @[ @\"foo\", @\"bar\" ]",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=[
                 "NSArray",
                 "foo",
                 "bar"])
 
+    @skipUnlessDarwin
+    @expectedFailureAll(
+        oslist=['macosx'],
+        compiler='clang',
+        compiler_version=[
+            '<',
+            '7.0.0'])
+    @skipIf(macos_version=["<", "10.12"])
+    @expectedFailureAll(archs=["i[3-6]86"])
+    def test_dictionary_literal(self):
+        self.runToBreakpoint()
+
         self.expect(
             "expr --object-description -- @{ @\"key\" : @\"object\" }",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=[
                 "key",
                 "object"])
 
+    @skipUnlessDarwin
+    @expectedFailureAll(
+        oslist=['macosx'],
+        compiler='clang',
+        compiler_version=[
+            '<',
+            '7.0.0'])
+    @skipIf(macos_version=["<", "10.12"])
+    @expectedFailureAll(archs=["i[3-6]86"])
+    def test_char_literal(self):
+        self.runToBreakpoint()
+
         self.expect("expr --object-description -- @'a'",
                     VARIABLES_DISPLAYED_CORRECTLY, substrs=[str(ord('a'))])
 
+    @skipUnlessDarwin
+    @expectedFailureAll(
+        oslist=['macosx'],
+        compiler='clang',
+        compiler_version=[
+            '<',
+            '7.0.0'])
+    @skipIf(macos_version=["<", "10.12"])
+    @expectedFailureAll(archs=["i[3-6]86"])
+    def test_integer_literals(self):
+        self.runToBreakpoint()
+
         self.expect(
             "expr --object-description -- @1",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=["1"])
 
         self.expect(
             "expr --object-description -- @1l",
             VARIABLES_DISPLAYED_CORRECTLY,
def test_integer_literals(self):
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=["1"])
 
         self.expect(
             "expr --object-description -- @1ull",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=["1"])
 
+    @skipUnlessDarwin
+    @expectedFailureAll(
+        oslist=['macosx'],
+        compiler='clang',
+        compiler_version=[
+            '<',
+            '7.0.0'])
+    @skipIf(macos_version=["<", "10.12"])
+    @expectedFailureAll(archs=["i[3-6]86"])
+    def test_float_literal(self):
+        self.runToBreakpoint()
+
         self.expect("expr -- @123.45", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=["NSNumber", "123.45"])
 
+    @skipUnlessDarwin
+    @expectedFailureAll(
+        oslist=['macosx'],
+        compiler='clang',
+        compiler_version=[
+            '<',
+            '7.0.0'])
+    @skipIf(macos_version=["<", "10.12"])
+    @expectedFailureAll(archs=["i[3-6]86"])
+    def test_expressions_in_literals(self):
+        self.runToBreakpoint()
+
         self.expect(
             "expr --object-description -- @( 1 + 3 )",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=["4"])
         self.expect(
             "expr -- @((char*)\"Hello world\" + 6)",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=[
                 "NSString",
                 "world"])

lldb/trunk/source/Symbol/ClangASTContext.cpp

ClangASTContext::GetTypeInfo(lldb::opaque_compiler_type_t type,
 
   if (pointee_or_element_clang_type)
     pointee_or_element_clang_type->Clear();
 
   clang::QualType qual_type(GetQualType(type));
 
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
+  case clang::Type::Attributed:
+    return GetTypeInfo(
+        qual_type->getAs<clang::AttributedType>()
+            ->getModifiedType().getAsOpaquePtr(),
+        pointee_or_element_clang_type);
   case clang::Type::Builtin: {
     const clang::BuiltinType *builtin_type = llvm::dyn_cast<clang::BuiltinType>(
         qual_type->getCanonicalTypeInternal());
 
     uint32_t builtin_type_flags = eTypeIsBuiltIn | eTypeHasValue;
     switch (builtin_type->getKind()) {
     case clang::BuiltinType::ObjCId:
     case clang::BuiltinType::ObjCClass: