Add Attribute NoThrow as an Exception Specifier Type

[erichkeane]

Summary

In response to https://bugs.llvm.org/show_bug.cgi?id=33235, it became
clear that the current mechanism of hacking through checks for the
exception specification of a function gets confused really quickly when
there are alternate exception specifiers.

This patch introduces EST_NoThrow, which is the equivilent of
EST_noexcept when caused by EST_noThrow. The existing implementation is
left in place to cover functions with no FunctionProtoType.

[rsmith]

Seems like a nice approach to the problem, but we need to not break the libclang C ABI :)

clang/include/clang-c/Index.h

202–204

This would renumber the later enumerators, resulting in an ABI break for our stable C ABI.

clang/lib/Sema/SemaExprCXX.cpp

6069–6070

I think this should be checked earlier, in the spirit of allowing "real" syntax to be preferred to attributes. (Eg, given a declaration that's __declspec(nothrow) and one that's noexcept, we should keep the noexcept in the merged type.)

[erichkeane]

clang/include/clang-c/Index.h

202–204

Is it alright to just add it to the end then? Or do I need to translate it into one of the others?

clang/lib/Sema/SemaExprCXX.cpp

6069–6070

Ah, right, good point.

Looking above, I'm torn between above or below MSAny. Do you have a thought?

[erichkeane]

Reread @rsmith's comments and surrounding code and found what I believe is the correct answer to these comments :)

[aaron.ballman]

clang/include/clang-c/Index.h

227

__declspec(nothrow)

clang/include/clang/Basic/ExceptionSpecificationType.h

25

__declspec(nothrow)

clang/lib/Sema/SemaType.cpp

6968

Ignores -> ignores

6970

I think we should diagnose that the nothrow is ignored in this case to let users know they've done something in conflict and what wins.

[erichkeane]

clang/lib/Sema/SemaType.cpp

6970

I've been considering that over the weekend, and agree it is a good idea. I am on the fence about the when however. For example, should we warn with throw() or noexcept or noexcept(true)? In these cases, ignoring the attribute is the same as enforcing it.

My concern is that noexcept (expression-evaluating-to-true) gets ignored with a diagnostic, but has the same effect.

Did you have an opinion here?

[aaron.ballman]

clang/lib/Sema/SemaType.cpp

6970

I think the metric should be: if there are conflicting attributes where we need to ignore one of them, we should always diagnose when the attributes specify conflicting semantics, but we don't have to always diagnose when the attributes specify the same semantics. In this case, e.g.,

__declspec(nothrow) void foo1() noexcept; // Don't bother warning
__declspec(nothrow) void foo2() noexcept(true); // Don't bother warning
__declspec(nothrow) void foo3() noexcept(false); // Warn
__declspec(nothrow) void foo4() noexcept(foo1()); // Warning is debatable
__declspec(nothrow) void foo5() noexcept(foo3()); // Warn

[erichkeane]

Added warning + other comments from @aaron.ballman

The exception state was further along than I expected, so I was able to make the warning better than I thought!

[rsmith]

Seems fine to me; please wait for @aaron.ballman's review to conclude as well.

[aaron.ballman]

LGTM aside from some minor nits.

clang/include/clang/Basic/DiagnosticSemaKinds.td

2789 ↗

(On Diff #201673)

Add single quotes around the attribute name: 'nothrow' attribute conflicts...

clang/include/clang/Sema/DeclSpec.h

1547

Not that I dislike this, but is this function being used? It seems to be the only hasAttr in the review.

clang/lib/Sema/SemaType.cpp

6968

How about: MSVC ignores nothrow if it is in conflict with an explicit exception specification.

6971

Will this need a fallthrough attribute because of the statement between the labels?

[erichkeane]

clang/include/clang/Sema/DeclSpec.h

1547

Woops, likely a leftover from a previous iteration, removing it!

clang/lib/Sema/SemaType.cpp

6971

Ah, I think it depends on what llvm_unreachable ends up expanding to (actually, LLVM_ATTRIBUTE_NORETURN).

Basically, here: https://llvm.org/doxygen/Support_2ErrorHandling_8h_source.html

I'm not sure of what compilers has that expand to nothing don't support it (would need !def GNUC and !def _MSC_VER), but an LLVM_FALLTHROUGH is easy enough to add, thanks!

[mstorsjo]

This change broke compiling Qt on MinGW, see https://bugs.llvm.org/show_bug.cgi?id=42089. Trivially reproducible by trying to compile a snippet that looks like this:

class Foo {
public:
        __attribute__((nothrow)) void __attribute__((__stdcall__)) Bar();
};

void Foo::Bar() {
}

Reproducible by compiling the same snippet for a windows-msvc target as well.

[erichkeane]

In D62435#1524824, @mstorsjo wrote:

This change broke compiling Qt on MinGW, see https://bugs.llvm.org/show_bug.cgi?id=42089. Trivially reproducible by trying to compile a snippet that looks like this:

class Foo {
public:
        __attribute__((nothrow)) void __attribute__((__stdcall__)) Bar();
};

void Foo::Bar() {
}

Reproducible by compiling the same snippet for a windows-msvc target as well.

Yikes, thanks for the report! I'll look at it this morning.

[mstorsjo]

This change had another breaking effect as well, for the MinGW target. Code that implements a COM interface easily ends up overriding a __declspec(nothrow) function with a method that in most cases (at least in cases that follow the microsoft sample code) lacks the same attribute. For code with -fms-extensions, this is a warning (as all exception spec mismatches are non-fatal there), but MinGW code doesn't necessarily use this option. See https://bugs.llvm.org/show_bug.cgi?id=42100 for full issue report and discussion.

clang/include/clang-c/Index.h

  * 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 57
+#define CINDEX_VERSION_MINOR 58
 
 #define CINDEX_VERSION_ENCODE(major, minor) ( \
       ((major) * 10000)                       \
     + ((minor) *     1))
 
 #define CINDEX_VERSION CINDEX_VERSION_ENCODE( \
     CINDEX_VERSION_MAJOR,                     \
     CINDEX_VERSION_MINOR )
enum CXCursor_ExceptionSpecificationKind {
   CXCursor_ExceptionSpecificationKind_Dynamic,
 
   /**
    * The cursor has exception specification throw(...).
    */
   CXCursor_ExceptionSpecificationKind_MSAny,
 
   /**
    * The cursor has exception specification basic noexcept.
    */
   CXCursor_ExceptionSpecificationKind_BasicNoexcept,
 
   /**
    * The cursor has exception specification computed noexcept.
    */
   CXCursor_ExceptionSpecificationKind_ComputedNoexcept,
 
   /**
    * The exception specification has not yet been evaluated.
    */
   CXCursor_ExceptionSpecificationKind_Unevaluated,
 
   /**
    * The exception specification has not yet been instantiated.
    */
   CXCursor_ExceptionSpecificationKind_Uninstantiated,
 
   /**
    * The exception specification has not been parsed yet.
    */
-  CXCursor_ExceptionSpecificationKind_Unparsed
+  CXCursor_ExceptionSpecificationKind_Unparsed,
+
+  /**
+   * The cursor has a declspec(nothrow) exception specification.
+   */
+  CXCursor_ExceptionSpecificationKind_NoThrow
 };
 
 /**
  * Provides a shared context for creating translation units.
  *
  * It provides two options:
  *
  * - excludeDeclarationsFromPCH: When non-zero, allows enumeration of "local"

clang/include/clang/AST/Decl.h

public:
   /// Get the declared return type, which may differ from the actual return
   /// type if the return type is deduced.
   QualType getDeclaredReturnType() const {
     auto *TSI = getTypeSourceInfo();
     QualType T = TSI ? TSI->getType() : getType();
     return T->castAs<FunctionType>()->getReturnType();
   }
 
+  /// Gets the ExceptionSpecificationType as declared.
+  ExceptionSpecificationType getExceptionSpecType() const {
+    auto *TSI = getTypeSourceInfo();
+    QualType T = TSI ? TSI->getType() : getType();
+    const auto *FPT = T->getAs<FunctionProtoType>();
+    return FPT ? FPT->getExceptionSpecType() : EST_None;
+  }
+
   /// Attempt to compute an informative source range covering the
   /// function exception specification, if any.
   SourceRange getExceptionSpecSourceRange() const;
 
   /// Determine the type of an expression that calls this function.
   QualType getCallResultType() const {
     return getType()->castAs<FunctionType>()->getCallResultType(
         getASTContext());

clang/include/clang/AST/Type.h

private:
   static ExceptionSpecSizeHolder
   getExceptionSpecSize(ExceptionSpecificationType EST, unsigned NumExceptions) {
     switch (EST) {
     case EST_None:
     case EST_DynamicNone:
     case EST_MSAny:
     case EST_BasicNoexcept:
     case EST_Unparsed:
+    case EST_NoThrow:
       return {0, 0, 0};
 
     case EST_Dynamic:
       return {NumExceptions, 0, 0};
 
     case EST_DependentNoexcept:
     case EST_NoexceptFalse:
     case EST_NoexceptTrue:

clang/include/clang/Basic/ExceptionSpecificationType.h

 namespace clang {
 
 /// The various types of exception specifications that exist in C++11.
 enum ExceptionSpecificationType {
   EST_None,             ///< no exception specification
   EST_DynamicNone,      ///< throw()
   EST_Dynamic,          ///< throw(T1, T2)
   EST_MSAny,            ///< Microsoft throw(...) extension
+  EST_NoThrow,          ///< Microsoft declspec(nothrow) extension
   EST_BasicNoexcept,    ///< noexcept
   EST_DependentNoexcept,///< noexcept(expression), value-dependent
   EST_NoexceptFalse,    ///< noexcept(expression), evals to 'false'
   EST_NoexceptTrue,     ///< noexcept(expression), evals to 'true'
   EST_Unevaluated,      ///< not evaluated yet, for special member function
   EST_Uninstantiated,   ///< not instantiated yet
   EST_Unparsed          ///< not parsed yet
 };
 
 inline bool isDynamicExceptionSpec(ExceptionSpecificationType ESpecType) {
   return ESpecType >= EST_DynamicNone && ESpecType <= EST_MSAny;
 }
 
 inline bool isComputedNoexcept(ExceptionSpecificationType ESpecType) {
   return ESpecType >= EST_DependentNoexcept &&
          ESpecType <= EST_NoexceptTrue;
 }
 
 inline bool isNoexceptExceptionSpec(ExceptionSpecificationType ESpecType) {
-  return ESpecType == EST_BasicNoexcept || isComputedNoexcept(ESpecType);
+  return ESpecType == EST_BasicNoexcept || ESpecType == EST_NoThrow ||
+         isComputedNoexcept(ESpecType);
 }
 
 inline bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType) {
   return ESpecType == EST_Unevaluated || ESpecType == EST_Uninstantiated;
 }
 
 /// Possible results from evaluation of a noexcept expression.
 enum CanThrowResult {

clang/include/clang/Sema/DeclSpec.h

void destroy() {
     }
   }
 
   /// If there are attributes applied to this declaratorchunk, return
   /// them.
   const ParsedAttributesView &getAttrs() const { return AttrList; }
   ParsedAttributesView &getAttrs() { return AttrList; }
 
+  bool hasAttr(ParsedAttr::Kind Kind) const {
+    return llvm::find_if(getAttrs(), [Kind](const ParsedAttr &P) {
+             return P.getKind() == Kind;
+           }) != getAttrs().end();
+  }
+
   /// Return a DeclaratorChunk for a pointer.
   static DeclaratorChunk getPointer(unsigned TypeQuals, SourceLocation Loc,
                                     SourceLocation ConstQualLoc,
                                     SourceLocation VolatileQualLoc,
                                     SourceLocation RestrictQualLoc,
                                     SourceLocation AtomicQualLoc,
                                     SourceLocation UnalignedQualLoc) {
     DeclaratorChunk I;

clang/lib/AST/ASTContext.cpp

if (IsCanonicalExceptionSpec) {
           CanonicalEPI.ExceptionSpec.Type = EST_None;
         else {
           CanonicalEPI.ExceptionSpec.Type = EST_Dynamic;
           CanonicalEPI.ExceptionSpec.Exceptions = ExceptionTypeStorage;
         }
         break;
       }
 
-      case EST_DynamicNone: case EST_BasicNoexcept: case EST_NoexceptTrue:
+      case EST_DynamicNone:
+      case EST_BasicNoexcept:
+      case EST_NoexceptTrue:
+      case EST_NoThrow:
         CanonicalEPI.ExceptionSpec.Type = EST_BasicNoexcept;
         break;
 
       case EST_DependentNoexcept:
         llvm_unreachable("dependent noexcept is already canonical");
       }
     } else {
       CanonicalEPI.ExceptionSpec = FunctionProtoType::ExceptionSpecInfo();

clang/lib/AST/JSONNodeDumper.cpp

void JSONNodeDumper::VisitFunctionProtoType(const FunctionProtoType *T) {
   case EST_NoexceptTrue:
   case EST_NoexceptFalse:
     JOS.attribute("exceptionSpec", "noexcept");
     JOS.attribute("conditionEvaluatesTo",
                 E.ExceptionSpec.Type == EST_NoexceptTrue);
     //JOS.attributeWithCall("exceptionSpecExpr",
     //                    [this, E]() { Visit(E.ExceptionSpec.NoexceptExpr); });
     break;
-
+  case EST_NoThrow:
+    JOS.attribute("exceptionSpec", "nothrow");
+    break;
   // FIXME: I cannot find a way to trigger these cases while dumping the AST. I
   // suspect you can only run into them when executing an AST dump from within
   // the debugger, which is not a use case we worry about for the JSON dumping
   // feature.
   case EST_DependentNoexcept:
   case EST_Unevaluated:
   case EST_Uninstantiated:
   case EST_Unparsed:

clang/lib/AST/Type.cpp

CanThrowResult FunctionProtoType::canThrow() const {
   case EST_Unparsed:
   case EST_Unevaluated:
   case EST_Uninstantiated:
     llvm_unreachable("should not call this with unresolved exception specs");
 
   case EST_DynamicNone:
   case EST_BasicNoexcept:
   case EST_NoexceptTrue:
+  case EST_NoThrow:
     return CT_Cannot;
 
   case EST_None:
   case EST_MSAny:
   case EST_NoexceptFalse:
     return CT_Can;
 
   case EST_Dynamic:

clang/lib/Sema/SemaDeclAttr.cpp

case ParsedAttr::AT_Naked:
     break;
   case ParsedAttr::AT_NoReturn:
     handleNoReturnAttr(S, D, AL);
     break;
   case ParsedAttr::AT_AnyX86NoCfCheck:
     handleNoCfCheckAttr(S, D, AL);
     break;
   case ParsedAttr::AT_NoThrow:
+    if (!AL.isUsedAsTypeAttr())
       handleSimpleAttribute<NoThrowAttr>(S, D, AL);
     break;
   case ParsedAttr::AT_CUDAShared:
     handleSharedAttr(S, D, AL);
     break;
   case ParsedAttr::AT_VecReturn:
     handleVecReturnAttr(S, D, AL);
     break;
   case ParsedAttr::AT_ObjCOwnership:

clang/lib/Sema/SemaDeclCXX.cpp

case EST_NoexceptFalse:
     ClearExceptions();
     ComputedEST = EST_None;
     return;
   // FIXME: If the call to this decl is using any of its default arguments, we
   // need to search them for potentially-throwing calls.
   // If this function has a basic noexcept, it doesn't affect the outcome.
   case EST_BasicNoexcept:
   case EST_NoexceptTrue:
+  case EST_NoThrow:
     return;
   // If we're still at noexcept(true) and there's a throw() callee,
   // change to that specification.
   case EST_DynamicNone:
     if (ComputedEST == EST_BasicNoexcept)
       ComputedEST = EST_DynamicNone;
     return;
   case EST_DependentNoexcept:
bool Sema::checkThisInStaticMemberFunctionExceptionSpec(CXXMethodDecl *Method) {
   const FunctionProtoType *Proto = ProtoTL.getTypePtr();
   FindCXXThisExpr Finder(*this);
 
   switch (Proto->getExceptionSpecType()) {
   case EST_Unparsed:
   case EST_Uninstantiated:
   case EST_Unevaluated:
   case EST_BasicNoexcept:
+  case EST_NoThrow:
   case EST_DynamicNone:
   case EST_MSAny:
   case EST_None:
     break;
 
   case EST_DependentNoexcept:
   case EST_NoexceptFalse:
   case EST_NoexceptTrue:

clang/lib/Sema/SemaExprCXX.cpp

mergeExceptionSpecs(Sema &S, FunctionProtoType::ExceptionSpecInfo ESI1,
   if (EST1 == EST_None) return ESI1;
   if (EST2 == EST_None) return ESI2;
   if (EST1 == EST_MSAny) return ESI1;
   if (EST2 == EST_MSAny) return ESI2;
   if (EST1 == EST_NoexceptFalse) return ESI1;
   if (EST2 == EST_NoexceptFalse) return ESI2;
 
   // If either of them is non-throwing, the result is the other.
+  if (EST1 == EST_NoThrow) return ESI2;
+  if (EST2 == EST_NoThrow) return ESI1;
   if (EST1 == EST_DynamicNone) return ESI2;
   if (EST2 == EST_DynamicNone) return ESI1;
   if (EST1 == EST_BasicNoexcept) return ESI2;
   if (EST2 == EST_BasicNoexcept) return ESI1;
   if (EST1 == EST_NoexceptTrue) return ESI2;
   if (EST2 == EST_NoexceptTrue) return ESI1;
 
   // If we're left with value-dependent computed noexcept expressions, we're
   // stuck. Before C++17, we can just drop the exception specification entirely,
   // since it's not actually part of the canonical type. And this should never
   // happen in C++17, because it would mean we were computing the composite
   // pointer type of dependent types, which should never happen.
   if (EST1 == EST_DependentNoexcept || EST2 == EST_DependentNoexcept) {
     assert(!S.getLangOpts().CPlusPlus17 &&
            "computing composite pointer type of dependent types");
     return FunctionProtoType::ExceptionSpecInfo();
   }
 
   // Switch over the possibilities so that people adding new values know to
   // update this function.
   switch (EST1) {
   case EST_None:
   case EST_DynamicNone:
   case EST_MSAny:
   case EST_BasicNoexcept:
   case EST_DependentNoexcept:
   case EST_NoexceptFalse:
   case EST_NoexceptTrue:
+  case EST_NoThrow:
     llvm_unreachable("handled above");
 
   case EST_Dynamic: {
     // This is the fun case: both exception specifications are dynamic. Form
     // the union of the two lists.
     assert(EST2 == EST_Dynamic && "other cases should already be handled");
     llvm::SmallPtrSet<QualType, 8> Found;
     for (auto &Exceptions : {ESI1.Exceptions, ESI2.Exceptions})

clang/lib/Sema/SemaType.cpp

 
 // Function type attributes.
 #define FUNCTION_TYPE_ATTRS_CASELIST                                           \
   case ParsedAttr::AT_NSReturnsRetained:                                       \
   case ParsedAttr::AT_NoReturn:                                                \
   case ParsedAttr::AT_Regparm:                                                 \
   case ParsedAttr::AT_AnyX86NoCallerSavedRegisters:                            \
   case ParsedAttr::AT_AnyX86NoCfCheck:                                         \
+  case ParsedAttr::AT_NoThrow:                                                 \
     CALLING_CONV_ATTRS_CASELIST
 
 // Microsoft-specific type qualifiers.
 #define MS_TYPE_ATTRS_CASELIST                                                 \
   case ParsedAttr::AT_Ptr32:                                                   \
   case ParsedAttr::AT_Ptr64:                                                   \
   case ParsedAttr::AT_SPtr:                                                    \
   case ParsedAttr::AT_UPtr
case DeclaratorChunk::Array: {
       T = S.BuildArrayType(T, ASM, ArraySize, ATI.TypeQuals,
                            SourceRange(DeclType.Loc, DeclType.EndLoc), Name);
       break;
     }
     case DeclaratorChunk::Function: {
       // If the function declarator has a prototype (i.e. it is not () and
       // does not have a K&R-style identifier list), then the arguments are part
       // of the type, otherwise the argument list is ().
-      const DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun;
+      DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun;
       IsQualifiedFunction =
           FTI.hasMethodTypeQualifiers() || FTI.hasRefQualifier();
 
       // Check for auto functions and trailing return type and adjust the
       // return type accordingly.
       if (!D.isInvalidType()) {
         // trailing-return-type is only required if we're declaring a function,
         // and not, for instance, a pointer to a function.
if (attr.getKind() == ParsedAttr::AT_Regparm) {
     }
 
     FunctionType::ExtInfo EI =
       unwrapped.get()->getExtInfo().withRegParm(value);
     type = unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI));
     return true;
   }
 
+  if (attr.getKind() == ParsedAttr::AT_NoThrow) {
+    if (S.CheckAttrNoArgs(attr))
+      return true;
+
+    // Delay if this is not a function type.
+    if (!unwrapped.isFunctionType())
+      return false;
+
+    // Otherwise we can process right away.
+    auto *Proto = unwrapped.get()->getAs<FunctionProtoType>();
+
+    // In the case where this is a FunctionNoProtoType instead of a
+    // FunctionProtoType, let the existing NoThrowAttr implementation do its
+    // thing.
+    if (!Proto)
+      return false;
+
+    attr.setUsedAsTypeAttr();
+
+    // MSVC Ignores nothrow for exception specification if it is in conflict.
+    if (Proto->hasExceptionSpec())
+      return true;
+
+    type = unwrapped.wrap(
+        S, S.Context
+               .getFunctionTypeWithExceptionSpec(
+                   QualType{Proto, 0},
+                   FunctionProtoType::ExceptionSpecInfo{EST_NoThrow})
+               ->getAs<FunctionType>());
+    return true;
+  }
+
   // Delay if the type didn't work out to a function.
   if (!unwrapped.isFunctionType()) return false;
 
   // Otherwise, a calling convention.
   CallingConv CC;
   if (S.CheckCallingConvAttr(attr, CC))
     return true;
 

clang/test/SemaCXX/nothrow-vs-exception-specs.cpp

+// RUN: %clang_cc1 %s -fcxx-exceptions -fsyntax-only -Wexceptions -verify -std=c++14
+// RUN: %clang_cc1 %s -fcxx-exceptions -fsyntax-only -Wexceptions -verify -std=c++17 -DCPP17
+
+__attribute__((nothrow)) void f1();
+static_assert(noexcept(f1()), "");
+void f1() noexcept;
+// expected-error@+2 {{exception specification in declaration does not match previous declaration}}
+// expected-note@-2 {{previous declaration is here}}
+void f1() noexcept(false);
+
+__attribute__((nothrow)) void f2();
+static_assert(noexcept(f2()), "");
+// expected-error@+2 {{exception specification in declaration does not match previous declaration}}
+// expected-note@-3 {{previous declaration is here}}
+void f2() noexcept(false);
+
+void f3() __attribute__((nothrow));
+static_assert(noexcept(f3()), "");
+void f3() noexcept;
+// expected-error@+2 {{exception specification in declaration does not match previous declaration}}
+// expected-note@-2 {{previous declaration is here}}
+void f3() noexcept(false);
+
+// Still noexcept due to throw()
+__attribute__((nothrow)) void f4() throw();
+static_assert(noexcept(f4()), "");
+
+// Still noexcept due to noexcept
+__attribute__((nothrow)) void f5() noexcept;
+static_assert(noexcept(f5()), "");
+
+// Still noexcept due to noexcept(true)
+__attribute__((nothrow)) void f6() noexcept(true);
+static_assert(noexcept(f6()), "");
+
+#ifndef CPP17
+// Doesn't override C++ implementation.
+__attribute__((nothrow)) void f7() throw(int);
+static_assert(!noexcept(f7()), "");
+#endif
+
+// Doesn't override C++ implementation.
+__attribute__((nothrow)) void f8() noexcept(false);
+static_assert(!noexcept(f8()), "");

clang/tools/libclang/CXType.cpp

getExternalExceptionSpecificationKind(ExceptionSpecificationType EST) {
   case EST_DynamicNone:
     return CXCursor_ExceptionSpecificationKind_DynamicNone;
   case EST_Dynamic:
     return CXCursor_ExceptionSpecificationKind_Dynamic;
   case EST_MSAny:
     return CXCursor_ExceptionSpecificationKind_MSAny;
   case EST_BasicNoexcept:
     return CXCursor_ExceptionSpecificationKind_BasicNoexcept;
+  case EST_NoThrow:
+    return CXCursor_ExceptionSpecificationKind_NoThrow;
   case EST_NoexceptFalse:
   case EST_NoexceptTrue:
   case EST_DependentNoexcept:
     return CXCursor_ExceptionSpecificationKind_ComputedNoexcept;
   case EST_Unevaluated:
     return CXCursor_ExceptionSpecificationKind_Unevaluated;
   case EST_Uninstantiated:
     return CXCursor_ExceptionSpecificationKind_Uninstantiated;