noexcept isn't finished just yet:

--- Reverse-merging r127118 into '.':
D    include/clang/Basic/ExceptionSpecificationType.h
U    include/clang/Sema/DeclSpec.h
U    include/clang/AST/Type.h
U    lib/Sema/SemaDeclCXX.cpp
U    lib/Sema/SemaExprCXX.cpp
U    lib/Sema/SemaTemplateInstantiateDecl.cpp
U    lib/Sema/SemaType.cpp
U    lib/Sema/SemaExceptionSpec.cpp
U    lib/Sema/SemaLookup.cpp
U    lib/AST/Type.cpp
U    lib/AST/ASTContext.cpp
U    lib/Serialization/ASTReader.cpp

--- Reverse-merging r127111 into '.':
G    include/clang/Sema/DeclSpec.h
U    lib/Sema/SemaDecl.cpp
U    lib/Sema/DeclSpec.cpp
G    lib/Sema/SemaType.cpp
U    lib/Parse/ParseDecl.cpp
U    lib/Parse/ParseExpr.cpp

--- Reverse-merging r127086 into '.':
A    test/Parser/cxx-exception-spec.cpp
D    test/CXX/except/except.spec/p1.cpp
U    include/clang/Basic/DiagnosticParseKinds.td
G    include/clang/Sema/DeclSpec.h
U    include/clang/Parse/Parser.h
G    lib/Parse/ParseDecl.cpp
U    lib/Parse/ParseDeclCXX.cpp

llvm-svn: 127611

Author: isanbard

clang/include/clang/AST/Type.h

@@ -15,7 +15,6 @@
 #define LLVM_CLANG_AST_TYPE_H
 
 #include "clang/Basic/Diagnostic.h"
-#include "clang/Basic/ExceptionSpecificationType.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/Linkage.h"
 #include "clang/Basic/PartialDiagnostic.h"
@@ -2404,17 +2403,17 @@ class FunctionProtoType : public FunctionType, public llvm::FoldingSetNode {
   /// ExtProtoInfo - Extra information about a function prototype.
   struct ExtProtoInfo {
     ExtProtoInfo() :
-      Variadic(false), ExceptionSpecType(EST_None), TypeQuals(0),
-      RefQualifier(RQ_None), NumExceptions(0), Exceptions(0), NoexceptExpr(0) {}
+      Variadic(false), HasExceptionSpec(false), HasAnyExceptionSpec(false),
+      TypeQuals(0), RefQualifier(RQ_None), NumExceptions(0), Exceptions(0) {}
 
     FunctionType::ExtInfo ExtInfo;
     bool Variadic;
-    ExceptionSpecificationType ExceptionSpecType;
+    bool HasExceptionSpec;
+    bool HasAnyExceptionSpec;
     unsigned char TypeQuals;
     RefQualifierKind RefQualifier;
     unsigned NumExceptions;
     const QualType *Exceptions;
-    Expr *NoexceptExpr;
   };
 
 private:
@@ -2463,8 +2462,8 @@ class FunctionProtoType : public FunctionType, public llvm::FoldingSetNode {
     ExtProtoInfo EPI;
     EPI.ExtInfo = getExtInfo();
     EPI.Variadic = isVariadic();
-    EPI.ExceptionSpecType = hasExceptionSpec() ?
-        (hasAnyExceptionSpec() ? EST_DynamicAny : EST_Dynamic) : EST_None;
+    EPI.HasExceptionSpec = hasExceptionSpec();
+    EPI.HasAnyExceptionSpec = hasAnyExceptionSpec();
     EPI.TypeQuals = static_cast<unsigned char>(getTypeQuals());
     EPI.RefQualifier = getRefQualifier();
     EPI.NumExceptions = NumExceptions;

clang/include/clang/Basic/DiagnosticParseKinds.td

@@ -300,8 +300,6 @@ def err_expected_lbrace_after_base_specifiers : Error<
   "expected '{' after base class list">;
 def ext_ellipsis_exception_spec : Extension<
   "exception specification of '...' is a Microsoft extension">;
-def err_dynamic_and_noexcept_specification : Error<
-  "cannot have both throw() and noexcept() clause on the same function">;
 def err_expected_catch : Error<"expected catch">;
 def err_expected_lbrace_or_comma : Error<"expected '{' or ','">;
 def err_using_namespace_in_class : Error<

clang/include/clang/Basic/ExceptionSpecificationType.h

@@ -1114,18 +1114,11 @@ class Parser : public CodeCompletionHandler {
   //===--------------------------------------------------------------------===//
   // C++ 15: C++ Throw Expression
   ExprResult ParseThrowExpression();
-
-  ExceptionSpecificationType MaybeParseExceptionSpecification(
-                    SourceRange &SpecificationRange,
-                    llvm::SmallVectorImpl<ParsedType> &DynamicExceptions,
-                    llvm::SmallVectorImpl<SourceRange> &DynamicExceptionRanges,
-                    ExprResult &NoexceptExpr);
-
   // EndLoc is filled with the ___location of the last token of the specification.
-  ExceptionSpecificationType ParseDynamicExceptionSpecification(
-                                  SourceRange &SpecificationRange,
-                                  llvm::SmallVectorImpl<ParsedType> &Exceptions,
-                                  llvm::SmallVectorImpl<SourceRange> &Ranges);
+  bool ParseExceptionSpecification(SourceLocation &EndLoc,
+                                   llvm::SmallVectorImpl<ParsedType> &Exns,
+                                   llvm::SmallVectorImpl<SourceRange> &Ranges,
+                                   bool &hasAnyExceptionSpec);
 
   //===--------------------------------------------------------------------===//
   // C++0x 8: Function declaration trailing-return-type

clang/include/clang/Parse/Parser.h

@@ -24,7 +24,6 @@
 #include "clang/Sema/Ownership.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/Lex/Token.h"
-#include "clang/Basic/ExceptionSpecificationType.h"
 #include "clang/Basic/OperatorKinds.h"
 #include "clang/Basic/Specifiers.h"
 #include "llvm/ADT/SmallVector.h"
@@ -1020,8 +1019,11 @@ struct DeclaratorChunk {
     /// The qualifier bitmask values are the same as in QualType.
     unsigned TypeQuals : 3;
 
-    /// ExceptionSpecType - An ExceptionSpecificationType value.
-    unsigned ExceptionSpecType : 3;
+    /// hasExceptionSpec - True if the function has an exception specification.
+    unsigned hasExceptionSpec : 1;
+
+    /// hasAnyExceptionSpec - True if the function has a throw(...) specifier.
+    unsigned hasAnyExceptionSpec : 1;
 
     /// DeleteArgInfo - If this is true, we need to delete[] ArgInfo.
     unsigned DeleteArgInfo : 1;
@@ -1033,34 +1035,28 @@ struct DeclaratorChunk {
     /// declarator.
     unsigned NumArgs;
 
-    /// NumExceptions - This is the number of types in the dynamic-exception-
-    /// decl, if the function has one.
+    /// NumExceptions - This is the number of types in the exception-decl, if
+    /// the function has one.
     unsigned NumExceptions;
 
     /// \brief The ___location of the ref-qualifier, if any.
     ///
     /// If this is an invalid ___location, there is no ref-qualifier.
     unsigned RefQualifierLoc;
-
-    /// \brief When ExceptionSpecType isn't EST_None, the ___location of the
+    
+    /// ThrowLoc - When hasExceptionSpec is true, the ___location of the throw
     /// keyword introducing the spec.
-    unsigned ExceptionSpecLoc;
+    unsigned ThrowLoc;
 
     /// ArgInfo - This is a pointer to a new[]'d array of ParamInfo objects that
     /// describe the arguments for this function declarator.  This is null if
     /// there are no arguments specified.
     ParamInfo *ArgInfo;
 
-    union {
-      /// \brief Pointer to a new[]'d array of TypeAndRange objects that
-      /// contain the types in the function's dynamic exception specification
-      /// and their locations, if there is one.
-      TypeAndRange *Exceptions;
-
-      /// \brief Pointer to the expression in the noexcept-specifier of this
-      /// function, if it has one.
-      Expr *NoexceptExpr;
-    };
+    /// Exceptions - This is a pointer to a new[]'d array of TypeAndRange
+    /// objects that contain the types in the function's exception
+    /// specification and their locations.
+    TypeAndRange *Exceptions;
 
     /// TrailingReturnType - If this isn't null, it's the trailing return type
     /// specified. This is actually a ParsedType, but stored as void* to
@@ -1080,8 +1076,7 @@ struct DeclaratorChunk {
     void destroy() {
       if (DeleteArgInfo)
         delete[] ArgInfo;
-      if (getExceptionSpecType() == EST_Dynamic)
-        delete[] Exceptions;
+      delete[] Exceptions;
     }
 
     /// isKNRPrototype - Return true if this is a K&R style identifier list,
@@ -1094,23 +1089,18 @@ struct DeclaratorChunk {
     SourceLocation getEllipsisLoc() const {
       return SourceLocation::getFromRawEncoding(EllipsisLoc);
     }
-    SourceLocation getExceptionSpecLoc() const {
-      return SourceLocation::getFromRawEncoding(ExceptionSpecLoc);
+    SourceLocation getThrowLoc() const {
+      return SourceLocation::getFromRawEncoding(ThrowLoc);
     }
-
+    
     /// \brief Retrieve the ___location of the ref-qualifier, if any.
     SourceLocation getRefQualifierLoc() const {
       return SourceLocation::getFromRawEncoding(RefQualifierLoc);
     }
-
+    
     /// \brief Determine whether this function declaration contains a 
     /// ref-qualifier.
     bool hasRefQualifier() const { return getRefQualifierLoc().isValid(); }
-
-    /// \brief Get the type of exception specification this function has.
-    ExceptionSpecificationType getExceptionSpecType() const {
-      return static_cast<ExceptionSpecificationType>(ExceptionSpecType);
-    }
   };
 
   struct BlockPointerTypeInfo : TypeInfoCommon {
@@ -1234,16 +1224,15 @@ struct DeclaratorChunk {
                                      unsigned TypeQuals, 
                                      bool RefQualifierIsLvalueRef,
                                      SourceLocation RefQualifierLoc,
-                                     ExceptionSpecificationType ESpecType,
-                                     SourceLocation ESpecLoc,
+                                     bool hasExceptionSpec,
+                                     SourceLocation ThrowLoc,
+                                     bool hasAnyExceptionSpec,
                                      ParsedType *Exceptions,
                                      SourceRange *ExceptionRanges,
                                      unsigned NumExceptions,
-                                     Expr *NoexceptExpr,
                                      SourceLocation LPLoc, SourceLocation RPLoc,
                                      Declarator &TheDeclarator,
-                                     ParsedType TrailingReturnType =
-                                                    ParsedType());
+                                     ParsedType TrailingReturnType = ParsedType());
 
   /// getBlockPointer - Return a DeclaratorChunk for a block.
   ///

clang/include/clang/Sema/DeclSpec.h

@@ -1915,7 +1915,7 @@ ASTContext::getFunctionType(QualType ResultTy,
     return QualType(FTP, 0);
 
   // Determine whether the type being created is already canonical or not.
-  bool isCanonical= EPI.ExceptionSpecType == EST_None && ResultTy.isCanonical();
+  bool isCanonical = !EPI.HasExceptionSpec && ResultTy.isCanonical();
   for (unsigned i = 0; i != NumArgs && isCanonical; ++i)
     if (!ArgArray[i].isCanonicalAsParam())
       isCanonical = false;
@@ -1934,8 +1934,11 @@ ASTContext::getFunctionType(QualType ResultTy,
       CanonicalArgs.push_back(getCanonicalParamType(ArgArray[i]));
 
     FunctionProtoType::ExtProtoInfo CanonicalEPI = EPI;
-    CanonicalEPI.ExceptionSpecType = EST_None;
-    CanonicalEPI.NumExceptions = 0;
+    if (CanonicalEPI.HasExceptionSpec) {
+      CanonicalEPI.HasExceptionSpec = false;
+      CanonicalEPI.HasAnyExceptionSpec = false;
+      CanonicalEPI.NumExceptions = 0;
+    }
     CanonicalEPI.ExtInfo
       = CanonicalEPI.ExtInfo.withCallingConv(getCanonicalCallConv(CallConv));
 

clang/lib/AST/ASTContext.cpp

@@ -1173,8 +1173,8 @@ FunctionProtoType::FunctionProtoType(QualType result, const QualType *args,
                  result->containsUnexpandedParameterPack(),
                  epi.ExtInfo),
     NumArgs(numArgs), NumExceptions(epi.NumExceptions),
-    HasExceptionSpec(isDynamicExceptionSpec(epi.ExceptionSpecType)),
-    HasAnyExceptionSpec(epi.ExceptionSpecType == EST_DynamicAny)
+    HasExceptionSpec(epi.HasExceptionSpec),
+    HasAnyExceptionSpec(epi.HasAnyExceptionSpec)
 {
   // Fill in the trailing argument array.
   QualType *argSlot = reinterpret_cast<QualType*>(this+1);
@@ -1218,8 +1218,8 @@ void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID, QualType Result,
   ID.AddBoolean(epi.Variadic);
   ID.AddInteger(epi.TypeQuals);
   ID.AddInteger(epi.RefQualifier);
-  if (isDynamicExceptionSpec(epi.ExceptionSpecType)) {
-    ID.AddBoolean(epi.ExceptionSpecType == EST_DynamicAny);
+  if (epi.HasExceptionSpec) {
+    ID.AddBoolean(epi.HasAnyExceptionSpec);
     for (unsigned i = 0; i != epi.NumExceptions; ++i)
       ID.AddPointer(epi.Exceptions[i].getAsOpaquePtr());
   }