[clangd] Add include-fixer fixit for field_incomplete_or_sizeless diagnostic.

[kadircet]

clang-tools-extra/clangd/IncludeFixer.cpp

81

what about the sizless case ? we'll attach a fixit, but it is not going to fix the issue :(

clang-tools-extra/clangd/unittests/DiagnosticsTests.cpp

787–804

nit: add a using decl instead

[hokein]

address comments.

[hokein]

clang-tools-extra/clangd/IncludeFixer.cpp

81

The sizeless type is a clang extension, I think our indexer doesn't index this kind of symbols, so we will not attach a fixit for them.

And I think sizeless case is rare in practice, I would not too worry about it.

[kadircet]

LGTM!

clang-tools-extra/clangd/IncludeFixer.cpp

81

ah ok, i thought this was something more common like a recorddecl without any members and with a specific attribute. thanks for the link!

clang-tools-extra/clangd/IncludeFixer.cpp

std::vector<Fix> IncludeFixer::fix(DiagnosticsEngine::Level DiagLevel,
   case diag::err_incomplete_member_access:
   case diag::err_incomplete_type:
   case diag::err_typecheck_decl_incomplete_type:
   case diag::err_typecheck_incomplete_tag:
   case diag::err_invalid_incomplete_type_use:
   case diag::err_sizeof_alignof_incomplete_or_sizeless_type:
   case diag::err_for_range_incomplete_type:
   case diag::err_func_def_incomplete_result:
+  case diag::err_field_incomplete_or_sizeless:
     // Incomplete type diagnostics should have a QualType argument for the
     // incomplete type.
     for (unsigned Idx = 0; Idx < Info.getNumArgs(); ++Idx) {
       if (Info.getArgKind(Idx) == DiagnosticsEngine::ak_qualtype) {
         auto QT = QualType::getFromOpaquePtr((void *)Info.getRawArg(Idx));
         if (const Type *T = QT.getTypePtrOrNull())
           if (T->isIncompleteType())
             return fixIncompleteType(*T);

clang-tools-extra/clangd/unittests/DiagnosticsTests.cpp

 
 using ::testing::_;
 using ::testing::AllOf;
 using ::testing::Contains;
 using ::testing::ElementsAre;
 using ::testing::Field;
 using ::testing::IsEmpty;
 using ::testing::Pair;
-using testing::SizeIs;
+using ::testing::SizeIs;
 using ::testing::UnorderedElementsAre;
+using testing::UnorderedElementsAreArray;
 
 ::testing::Matcher<const Diag &> WithFix(::testing::Matcher<Fix> FixMatcher) {
   return Field(&Diag::Fixes, ElementsAre(FixMatcher));
 }
 
 ::testing::Matcher<const Diag &> WithFix(::testing::Matcher<Fix> FixMatcher1,
                                          ::testing::Matcher<Fix> FixMatcher2) {
   return Field(&Diag::Fixes, UnorderedElementsAre(FixMatcher1, FixMatcher2));
void test(ns::X *x, ns::X& ref_x) {
   ns::X $incomplete[[var]];
   $tag[[ref_x]]->f();
   $use[[ns::X()]];
   $sizeof[[sizeof]](ns::X);
   for (auto it : $for[[ref_x]]);
 }
 
 ns::X $return[[func]]() {}
+
+class T {
+  ns::X $field[[x]];
+};
   )cpp");
   auto TU = TestTU::withCode(Test.code());
   TU.ExtraArgs.push_back("-std=c++17");
   auto Index = buildIndexWithSymbol(
       {SymbolWithHeader{"ns::X", "unittest:///x.h", "\"x.h\""}});
   TU.ExternalIndex = Index.get();
 
   EXPECT_THAT(
       TU.build().getDiagnostics(),
-      UnorderedElementsAre(
-          AllOf(Diag(Test.range("nested"),
+      UnorderedElementsAreArray(
+          {AllOf(Diag(Test.range("nested"),
                       "incomplete type 'ns::X' named in nested name specifier"),
                  DiagName("incomplete_nested_name_spec"),
                  WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                              "Add include \"x.h\" for symbol ns::X"))),
            AllOf(Diag(Test.range("base"), "base class has incomplete type"),
                  DiagName("incomplete_base_class"),
                  WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                              "Add include \"x.h\" for symbol ns::X"))),
            AllOf(Diag(Test.range("access"),
                       "member access into incomplete type 'ns::X'"),
                  DiagName("incomplete_member_access"),
                  WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                              "Add include \"x.h\" for symbol ns::X"))),
            AllOf(
-              Diag(Test.range("type"),
+               Diag(
+                   Test.range("type"),
                    "incomplete type 'ns::X' where a complete type is required"),
                DiagName("incomplete_type"),
                WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                            "Add include \"x.h\" for symbol ns::X"))),
            AllOf(Diag(Test.range("incomplete"),
                       "variable has incomplete type 'ns::X'"),
                  DiagName("typecheck_decl_incomplete_type"),
                  WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                              "Add include \"x.h\" for symbol ns::X"))),
            AllOf(
                Diag(Test.range("tag"), "incomplete definition of type 'ns::X'"),
                DiagName("typecheck_incomplete_tag"),
                WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                            "Add include \"x.h\" for symbol ns::X"))),
-          AllOf(
-              Diag(Test.range("use"), "invalid use of incomplete type 'ns::X'"),
+           AllOf(Diag(Test.range("use"),
+                      "invalid use of incomplete type 'ns::X'"),
                  DiagName("invalid_incomplete_type_use"),
                  WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                              "Add include \"x.h\" for symbol ns::X"))),
-          AllOf(Diag(Test.range("sizeof"), "invalid application of 'sizeof' to "
-                                           "an incomplete type 'ns::X'"),
+           AllOf(Diag(Test.range("sizeof"),
+                      "invalid application of 'sizeof' to "
                  DiagName("sizeof_alignof_incomplete_or_sizeless_type"),
                  WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                              "Add include \"x.h\" for symbol ns::X"))),
            AllOf(Diag(Test.range("for"),
                       "cannot use incomplete type 'ns::X' as a range"),
                  DiagName("for_range_incomplete_type"),
                  WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                              "Add include \"x.h\" for symbol ns::X"))),
            AllOf(Diag(Test.range("return"),
                       "incomplete result type 'ns::X' in function definition"),
                  DiagName("func_def_incomplete_result"),
                  WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
-                            "Add include \"x.h\" for symbol ns::X")))));
+                             "Add include \"x.h\" for symbol ns::X"))),
+           AllOf(Diag(Test.range("field"), "field has incomplete type 'ns::X'"),
+                 DiagName("field_incomplete_or_sizeless"),
+                 WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+                             "Add include \"x.h\" for symbol ns::X")))}))
+      << Test.code();
 }
 
 TEST(IncludeFixerTest, NoSuggestIncludeWhenNoDefinitionInHeader) {
   Annotations Test(R"cpp(// error-ok
 $insert[[]]namespace ns {
   class X;
 }
 class Y : $base[[public ns::X]] {};