Expose NoReturn attribute to libclang

[harlanhaskins]

Summary

There's currently no way to get this information from libclang. This patch adds a small function to see if a given CXCursor representing a FunctionDecl is marked with __attribute__((noreturn)), [[gnu::noreturn]], or [[noreturn]] to libclang as CXCursor_NoReturnAttr.

[milianw]

lgtm in general, but this patch is missing a unit test

[harlanhaskins]

Add test for clang_Cursor_isFunctionNoReturn

[harlanhaskins]

This fails to link when I compile it locally, and I have absolutely no idea why. So this is still untested.

[skalinichev]

Patch lacking changes in tools/libclang/libclang.exports

include/clang-c/Index.h

3320

I assume that you already tried something like:
r246931: Index: expose visibility attribute

But it doesn't work (no attributes in AST?), right?

unittests/libclang/LibclangTest.cpp

463 ↗

(On Diff #95980)

Please add tests to test/Index/* it's easier to read/modify. (see e.g. before-mentioned commit for the reference)

[harlanhaskins]

include/clang-c/Index.h

3320

The main issue is that there are several different attributes (NoReturn, C11NoReturn, CXX11NoReturn, AnalyzerNoReturn) and I'm not sure whether to expose them all (meaning clients need to check for all of them) or roll them into one exposed attribute.

[skalinichev]

include/clang-c/Index.h

3320

One attribute should suffice I think, and you still can distinguish them if needed, e.g. via clang_getCursorSpelling. Again see how it's done in r246931

[harlanhaskins]

• Change noreturn interface to expose NoReturn as an attribute

[skalinichev]

test/Index/noreturn.c

3

Please make sure to test all noreturn attributes (c11/cxx11, noretun). And verify that the test case actually passes!

tools/libclang/CXCursor.cpp

62–64

Ok, I've just tried a couple of test cases with different noreturn attributes:

1. There are no attributes in the ast-dump for NoReturn
2. There are attributes for CXX11NoReturn/C11NoReturn in the ast-dump

Therefore this code will only work with CXX11NoReturn/C11NoReturn attributes. And the test case you provided shouldn't work at all (as you're using NoReturn there)

So let's use clang_Cursor_isFunctionNoReturn after all, as it should cover all cases (or so I think)

[harlanhaskins]

tools/libclang/CXCursor.cpp

62–64

How should I unit test clang_Cursor_isFunctionNoReturn? I can't seem to find any tests for, say, clang_Cursor_isFunctionInlined...

[skalinichev]

tools/libclang/CXCursor.cpp

62–64

I guess something like this: https://reviews.llvm.org/D13388

include/clang-c/Index.h

  * \brief The version constants for the libclang API.
  * CINDEX_VERSION_MINOR should increase when there are API additions.
  * CINDEX_VERSION_MAJOR is intended for "major" source/ABI breaking changes.
  *
  * The policy about the libclang API was always to keep it source and ABI
  * compatible, thus CINDEX_VERSION_MAJOR is expected to remain stable.
  */
 #define CINDEX_VERSION_MAJOR 0
-#define CINDEX_VERSION_MINOR 37
+#define CINDEX_VERSION_MINOR 38
 
 #define CINDEX_VERSION_ENCODE(major, minor) ( \
       ((major) * 10000)                       \
     + ((minor) *     1))
 
 #define CINDEX_VERSION CINDEX_VERSION_ENCODE( \
     CINDEX_VERSION_MAJOR,                     \
     CINDEX_VERSION_MINOR )
enum CXCursorKind {
   CXCursor_CUDAConstantAttr              = 412,
   CXCursor_CUDADeviceAttr                = 413,
   CXCursor_CUDAGlobalAttr                = 414,
   CXCursor_CUDAHostAttr                  = 415,
   CXCursor_CUDASharedAttr                = 416,
   CXCursor_VisibilityAttr                = 417,
   CXCursor_DLLExport                     = 418,
   CXCursor_DLLImport                     = 419,
-  CXCursor_LastAttr                      = CXCursor_DLLImport,
+  CXCursor_NoReturnAttr                  = 420,
+  CXCursor_LastAttr                      = CXCursor_NoReturnAttr,
 
   /* Preprocessing */
   CXCursor_PreprocessingDirective        = 500,
   CXCursor_MacroDefinition               = 501,
   CXCursor_MacroExpansion                = 502,
   CXCursor_MacroInstantiation            = CXCursor_MacroExpansion,
   CXCursor_InclusionDirective            = 503,
   CXCursor_FirstPreprocessing            = CXCursor_PreprocessingDirective,

  * inline declaration.
  */
 CINDEX_LINKAGE unsigned clang_Cursor_isFunctionInlined(CXCursor C);
 
 /**
  * \brief Determine whether a CXType has the "volatile" qualifier set,
  * without looking through typedefs that may have added "volatile" at
  * a different level.
  */
 CINDEX_LINKAGE unsigned clang_isVolatileQualifiedType(CXType T);
 
 /**
  * \brief Determine whether a CXType has the "restrict" qualifier set,
  * without looking through typedefs that may have added "restrict" at a
  * different level.
  */
 CINDEX_LINKAGE unsigned clang_isRestrictQualifiedType(CXType T);

test/Index/noreturn.c

+// RUN: c-index-test -index-file %s | FileCheck %s -check-prefix CHECK
+
+void __attribute__ (( noreturn )) noreturn_function();
+// CHECK:      <attribute>: attribute(noreturn)
+

tools/libclang/CIndex.cpp

if (C.kind == CXCursor_AsmLabelAttr) {
     const AsmLabelAttr *AA = cast<AsmLabelAttr>(cxcursor::getCursorAttr(C));
     return cxstring::createDup(AA->getLabel());
   }
 
   if (C.kind == CXCursor_PackedAttr) {
     return cxstring::createRef("packed");
   }
 
+  if (C.kind == CXCursor_NoReturnAttr) {
+    return cxstring::createRef("noreturn");
+  }
+
   if (C.kind == CXCursor_VisibilityAttr) {
     const VisibilityAttr *AA = cast<VisibilityAttr>(cxcursor::getCursorAttr(C));
     switch (AA->getVisibility()) {
     case VisibilityAttr::VisibilityType::Default:
       return cxstring::createRef("default");
     case VisibilityAttr::VisibilityType::Hidden:
       return cxstring::createRef("hidden");
     case VisibilityAttr::VisibilityType::Protected:
CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) {
   case CXCursor_CUDASharedAttr:
     return cxstring::createRef("attribute(shared)");
   case CXCursor_VisibilityAttr:
     return cxstring::createRef("attribute(visibility)");
   case CXCursor_DLLExport:
     return cxstring::createRef("attribute(dllexport)");
   case CXCursor_DLLImport:
     return cxstring::createRef("attribute(dllimport)");
+  case CXCursor_NoReturnAttr:
+    return cxstring::createRef("attribute(noreturn)");
   case CXCursor_PreprocessingDirective:
     return cxstring::createRef("preprocessing directive");
   case CXCursor_MacroDefinition:
     return cxstring::createRef("macro definition");
   case CXCursor_MacroExpansion:
     return cxstring::createRef("macro expansion");
   case CXCursor_InclusionDirective:
     return cxstring::createRef("inclusion directive");

tools/libclang/CXCursor.cpp

switch (A->getKind()) {
     case attr::Const: return CXCursor_ConstAttr;
     case attr::NoDuplicate: return CXCursor_NoDuplicateAttr;
     case attr::CUDAConstant: return CXCursor_CUDAConstantAttr;
     case attr::CUDADevice: return CXCursor_CUDADeviceAttr;
     case attr::CUDAGlobal: return CXCursor_CUDAGlobalAttr;
     case attr::CUDAHost: return CXCursor_CUDAHostAttr;
     case attr::CUDAShared: return CXCursor_CUDASharedAttr;
     case attr::Visibility: return CXCursor_VisibilityAttr;
+    case attr::NoReturn: return CXCursor_NoReturnAttr;
+    case attr::C11NoReturn: return CXCursor_NoReturnAttr;
+    case attr::CXX11NoReturn: return CXCursor_NoReturnAttr;
     case attr::DLLExport: return CXCursor_DLLExport;
     case attr::DLLImport: return CXCursor_DLLImport;
   }
 
   return CXCursor_UnexposedAttr;
 }
 
 CXCursor cxcursor::MakeCXCursor(const Attr *A, const Decl *Parent,