From 9d891185ad51c12a9051801464ca95fcb7633c7e Mon Sep 17 00:00:00 2001 From: Tim Northover Date: Wed, 24 May 2017 22:18:35 +0000 Subject: [PATCH] Revert "Sema: allow imaginary constants via GNU extension if UDL overloads not present." This reverts commit r303697. It broke libc++ tests that were specifically checking incompatibility in C++14 mode. llvm-svn: 303813 --- clang/include/clang/Basic/DiagnosticLexKinds.td | 2 ++ clang/include/clang/Basic/DiagnosticSemaKinds.td | 2 -- clang/include/clang/Sema/Sema.h | 5 +-- clang/lib/Lex/LiteralSupport.cpp | 44 +++++++++++++----------- clang/lib/Sema/SemaExpr.cpp | 25 +++++--------- clang/lib/Sema/SemaLookup.cpp | 16 ++++----- clang/test/SemaCXX/imaginary-constants.cpp | 44 ------------------------ 7 files changed, 41 insertions(+), 97 deletions(-) delete mode 100644 clang/test/SemaCXX/imaginary-constants.cpp diff --git a/clang/include/clang/Basic/DiagnosticLexKinds.td b/clang/include/clang/Basic/DiagnosticLexKinds.td index 7e11939..77db899 100644 --- a/clang/include/clang/Basic/DiagnosticLexKinds.td +++ b/clang/include/clang/Basic/DiagnosticLexKinds.td @@ -173,6 +173,8 @@ def warn_char_constant_too_large : Warning< def err_multichar_utf_character_literal : Error< "Unicode character literals may not contain multiple characters">; def err_exponent_has_no_digits : Error<"exponent has no digits">; +def ext_imaginary_constant : Extension< + "imaginary constants are a GNU extension">, InGroup; def err_hex_constant_requires : Error< "hexadecimal floating %select{constant|literal}0 requires " "%select{an exponent|a significand}1">; diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td index 6da5682a..2013036 100644 --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -194,8 +194,6 @@ def warn_duplicate_declspec : Warning<"duplicate '%0' declaration specifier">, InGroup; def ext_plain_complex : ExtWarn< "plain '_Complex' requires a type specifier; assuming '_Complex double'">; -def ext_imaginary_constant : Extension< - "imaginary constants are a GNU extension">, InGroup; def ext_integer_complex : Extension< "complex integer types are a GNU extension">, InGroup; diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h index e18995a..4c69fb6 100644 --- a/clang/include/clang/Sema/Sema.h +++ b/clang/include/clang/Sema/Sema.h @@ -2946,8 +2946,6 @@ public: enum LiteralOperatorLookupResult { /// \brief The lookup resulted in an error. LOLR_Error, - /// \brief The lookup found no match but no diagnostic was issued. - LOLR_ErrorNoDiagnostic, /// \brief The lookup found a single 'cooked' literal operator, which /// expects a normal literal to be built and passed to it. LOLR_Cooked, @@ -3072,8 +3070,7 @@ public: ArrayRef ArgTys, bool AllowRaw, bool AllowTemplate, - bool AllowStringTemplate, - bool DiagnoseMissing); + bool AllowStringTemplate); bool isKnownName(StringRef name); void ArgumentDependentLookup(DeclarationName Name, SourceLocation Loc, diff --git a/clang/lib/Lex/LiteralSupport.cpp b/clang/lib/Lex/LiteralSupport.cpp index 1fead55..1e2cbde 100644 --- a/clang/lib/Lex/LiteralSupport.cpp +++ b/clang/lib/Lex/LiteralSupport.cpp @@ -651,6 +651,9 @@ NumericLiteralParser::NumericLiteralParser(StringRef TokSpelling, break; } } + // "i", "if", and "il" are user-defined suffixes in C++1y. + if (*s == 'i' && PP.getLangOpts().CPlusPlus14) + break; // fall through. case 'j': case 'J': @@ -662,34 +665,35 @@ NumericLiteralParser::NumericLiteralParser(StringRef TokSpelling, break; } - // "i", "if", and "il" are user-defined suffixes in C++1y. - if (s != ThisTokEnd || isImaginary) { + if (s != ThisTokEnd) { // FIXME: Don't bother expanding UCNs if !tok.hasUCN(). expandUCNs(UDSuffixBuf, StringRef(SuffixBegin, ThisTokEnd - SuffixBegin)); if (isValidUDSuffix(PP.getLangOpts(), UDSuffixBuf)) { - if (!isImaginary) { - // Any suffix pieces we might have parsed are actually part of the - // ud-suffix. - isLong = false; - isUnsigned = false; - isLongLong = false; - isFloat = false; - isHalf = false; - isImaginary = false; - MicrosoftInteger = 0; - } + // Any suffix pieces we might have parsed are actually part of the + // ud-suffix. + isLong = false; + isUnsigned = false; + isLongLong = false; + isFloat = false; + isHalf = false; + isImaginary = false; + MicrosoftInteger = 0; saw_ud_suffix = true; return; } - if (s != ThisTokEnd) { - // Report an error if there are any. - PP.Diag(PP.AdvanceToTokenCharacter(TokLoc, SuffixBegin - ThisTokBegin), - diag::err_invalid_suffix_constant) - << StringRef(SuffixBegin, ThisTokEnd - SuffixBegin) << isFPConstant; - hadError = true; - } + // Report an error if there are any. + PP.Diag(PP.AdvanceToTokenCharacter(TokLoc, SuffixBegin - ThisTokBegin), + diag::err_invalid_suffix_constant) + << StringRef(SuffixBegin, ThisTokEnd-SuffixBegin) << isFPConstant; + hadError = true; + return; + } + + if (isImaginary) { + PP.Diag(PP.AdvanceToTokenCharacter(TokLoc, SuffixBegin - ThisTokBegin), + diag::ext_imaginary_constant); } } diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp index 83387c2..759c82e 100644 --- a/clang/lib/Sema/SemaExpr.cpp +++ b/clang/lib/Sema/SemaExpr.cpp @@ -1609,9 +1609,8 @@ static ExprResult BuildCookedLiteralOperatorCall(Sema &S, Scope *Scope, LookupResult R(S, OpName, UDSuffixLoc, Sema::LookupOrdinaryName); if (S.LookupLiteralOperator(Scope, R, llvm::makeArrayRef(ArgTy, Args.size()), - /*AllowRaw*/ false, /*AllowTemplate*/ false, - /*AllowStringTemplate*/ false, - /*DiagnoseMissing*/ true) == Sema::LOLR_Error) + /*AllowRaw*/false, /*AllowTemplate*/false, + /*AllowStringTemplate*/false) == Sema::LOLR_Error) return ExprError(); return S.BuildLiteralOperatorCall(R, OpNameInfo, Args, LitEndLoc); @@ -1702,9 +1701,8 @@ Sema::ActOnStringLiteral(ArrayRef StringToks, Scope *UDLScope) { LookupResult R(*this, OpName, UDSuffixLoc, LookupOrdinaryName); switch (LookupLiteralOperator(UDLScope, R, ArgTy, - /*AllowRaw*/ false, /*AllowTemplate*/ false, - /*AllowStringTemplate*/ true, - /*DiagnoseMissing*/ true)) { + /*AllowRaw*/false, /*AllowTemplate*/false, + /*AllowStringTemplate*/true)) { case LOLR_Cooked: { llvm::APInt Len(Context.getIntWidth(SizeType), Literal.GetNumStringChars()); @@ -1737,7 +1735,6 @@ Sema::ActOnStringLiteral(ArrayRef StringToks, Scope *UDLScope) { } case LOLR_Raw: case LOLR_Template: - case LOLR_ErrorNoDiagnostic: llvm_unreachable("unexpected literal operator lookup result"); case LOLR_Error: return ExprError(); @@ -3360,15 +3357,11 @@ ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) { // literal or a cooked one. LookupResult R(*this, OpName, UDSuffixLoc, LookupOrdinaryName); switch (LookupLiteralOperator(UDLScope, R, CookedTy, - /*AllowRaw*/ true, /*AllowTemplate*/ true, - /*AllowStringTemplate*/ false, - /*DiagnoseMissing*/ !Literal.isImaginary)) { - case LOLR_ErrorNoDiagnostic: - // Lookup failure for imaginary constants isn't fatal, there's still the - // GNU extension producing _Complex types. - break; + /*AllowRaw*/true, /*AllowTemplate*/true, + /*AllowStringTemplate*/false)) { case LOLR_Error: return ExprError(); + case LOLR_Cooked: { Expr *Lit; if (Literal.isFloatingLiteral()) { @@ -3584,12 +3577,10 @@ ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) { } // If this is an imaginary literal, create the ImaginaryLiteral wrapper. - if (Literal.isImaginary) { + if (Literal.isImaginary) Res = new (Context) ImaginaryLiteral(Res, Context.getComplexType(Res->getType())); - Diag(Tok.getLocation(), diag::ext_imaginary_constant); - } return Res; } diff --git a/clang/lib/Sema/SemaLookup.cpp b/clang/lib/Sema/SemaLookup.cpp index 48f4a02..c97da74 100644 --- a/clang/lib/Sema/SemaLookup.cpp +++ b/clang/lib/Sema/SemaLookup.cpp @@ -3066,7 +3066,7 @@ Sema::LiteralOperatorLookupResult Sema::LookupLiteralOperator(Scope *S, LookupResult &R, ArrayRef ArgTys, bool AllowRaw, bool AllowTemplate, - bool AllowStringTemplate, bool DiagnoseMissing) { + bool AllowStringTemplate) { LookupName(R, S); assert(R.getResultKind() != LookupResult::Ambiguous && "literal operator lookup can't be ambiguous"); @@ -3167,15 +3167,11 @@ Sema::LookupLiteralOperator(Scope *S, LookupResult &R, return LOLR_StringTemplate; // Didn't find anything we could use. - if (DiagnoseMissing) { - Diag(R.getNameLoc(), diag::err_ovl_no_viable_literal_operator) - << R.getLookupName() << (int)ArgTys.size() << ArgTys[0] - << (ArgTys.size() == 2 ? ArgTys[1] : QualType()) << AllowRaw - << (AllowTemplate || AllowStringTemplate); - return LOLR_Error; - } - - return LOLR_ErrorNoDiagnostic; + Diag(R.getNameLoc(), diag::err_ovl_no_viable_literal_operator) + << R.getLookupName() << (int)ArgTys.size() << ArgTys[0] + << (ArgTys.size() == 2 ? ArgTys[1] : QualType()) << AllowRaw + << (AllowTemplate || AllowStringTemplate); + return LOLR_Error; } void ADLResult::insert(NamedDecl *New) { diff --git a/clang/test/SemaCXX/imaginary-constants.cpp b/clang/test/SemaCXX/imaginary-constants.cpp deleted file mode 100644 index bbff927..0000000 --- a/clang/test/SemaCXX/imaginary-constants.cpp +++ /dev/null @@ -1,44 +0,0 @@ -// RUN: %clang_cc1 -fsyntax-only -verify %s -include %s -std=gnu++98 -// RUN: %clang_cc1 -fsyntax-only -verify %s -include %s -std=c++11 -// RUN: %clang_cc1 -fsyntax-only -verify %s -include %s -std=c++14 -DCXX14=1 - -// expected-no-diagnostics - -#ifndef HEADER -#define HEADER - -_Complex int val1 = 2i; -_Complex long val2 = 2il; -_Complex long long val3 = 2ill; -_Complex float val4 = 2.0if; -_Complex double val5 = 2.0i; -_Complex long double val6 = 2.0il; - -#if CXX14 - -#pragma clang system_header - -namespace std { - template struct complex {}; - complex operator""if(unsigned long long); - complex operator""if(long double); - - complex operator"" i(unsigned long long); - complex operator"" i(long double); - - complex operator"" il(unsigned long long); - complex operator"" il(long double); -} - -using namespace std; - -complex f1 = 2.0if; -complex f2 = 2if; -complex d1 = 2.0i; -complex d2 = 2i; -complex l1 = 2.0il; -complex l2 = 2il; - -#endif - -#endif -- 2.7.4