Parse typeof-specifier the same way as sizeof/alignof are parsed.

-Makes typeof consistent with sizeof/alignof
-Fixes a bug when '>' is in a typeof expression, inside a template type param:
  A<typeof(x>1)> a;

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@72255 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
index b0fdccbdc9785e29e1ac092ab6b078ac6f02cfb1..fd498d534cbb6a6cb3e6474d746a1b0700cd699c 100644 (file)
--- a/lib/AST/Type.cpp
+++ b/lib/AST/Type.cpp
@@ -1324,7 +1324,7 @@ void TypeOfExprType::getAsStringInternal(std::string &InnerString) const {
   std::string Str;
   llvm::raw_string_ostream s(Str);
   getUnderlyingExpr()->printPretty(s);
-  InnerString = "typeof(" + s.str() + ")" + InnerString;
+  InnerString = "typeof " + s.str() + InnerString;
 }
 
 void TypeOfType::getAsStringInternal(std::string &InnerString) const {

diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp
index 0a33d7daa024fe0fb4e1c034649b992379911541..e4d53dbace066587eb2815d5f0e02862c20c2c44 100644 (file)
--- a/lib/Parse/ParseDecl.cpp
+++ b/lib/Parse/ParseDecl.cpp
@@ -2651,68 +2651,59 @@ void Parser::ParseTypeofSpecifier(DeclSpec &DS) {
   const IdentifierInfo *BuiltinII = Tok.getIdentifierInfo();
   SourceLocation StartLoc = ConsumeToken();
 
+  // If the operand doesn't start with an '(', it must be an expression.
+  OwningExprResult Operand(Actions);
   if (Tok.isNot(tok::l_paren)) {
     if (!getLang().CPlusPlus) {
       Diag(Tok, diag::err_expected_lparen_after_id) << BuiltinII;
       return;
     }
-
-    OwningExprResult Result(ParseCastExpression(true/*isUnaryExpression*/));
-    if (Result.isInvalid()) {
-      DS.SetTypeSpecError();
-      return;
-    }
-
-    const char *PrevSpec = 0;
-    // Check for duplicate type specifiers.
-    if (DS.SetTypeSpecType(DeclSpec::TST_typeofExpr, StartLoc, PrevSpec, 
-                           Result.release()))
-      Diag(StartLoc, diag::err_invalid_decl_spec_combination) << PrevSpec;
-
+    Operand = ParseCastExpression(true/*isUnaryExpression*/);
     // FIXME: Not accurate, the range gets one token more than it should.
     DS.SetRangeEnd(Tok.getLocation());
-    return;
-  }
-
-  SourceLocation LParenLoc = ConsumeParen(), RParenLoc;
-  
-  if (isTypeIdInParens()) {
-    Action::TypeResult Ty = ParseTypeName();
-
-    assert((Ty.isInvalid() || Ty.get()) && 
-           "Parser::ParseTypeofSpecifier(): missing type");
 
-    if (Tok.isNot(tok::r_paren)) {
-      MatchRHSPunctuation(tok::r_paren, LParenLoc);
-      return;
-    }
-    RParenLoc = ConsumeParen();
+  } else {
+    // If it starts with a '(', we know that it is either a parenthesized
+    // type-name, or it is a unary-expression that starts with a compound
+    // literal, or starts with a primary-expression that is a parenthesized
+    // expression.
+    ParenParseOption ExprType = CastExpr;
+    TypeTy *CastTy;
+    SourceLocation LParenLoc = Tok.getLocation(), RParenLoc;
+    Operand = ParseParenExpression(ExprType, CastTy, RParenLoc);
+    DS.SetRangeEnd(RParenLoc);
+
+    // If ParseParenExpression parsed a '(typename)' sequence only, then this is
+    // typeof a type.  Otherwise, it is typeof an expression.
+    if (ExprType == CastExpr) {
+      if (!CastTy) {
+        DS.SetTypeSpecError();
+        return;
+      }
 
-    if (Ty.isInvalid())
-      DS.SetTypeSpecError();
-    else {
       const char *PrevSpec = 0;
       // Check for duplicate type specifiers (e.g. "int typeof(int)").
-      if (DS.SetTypeSpecType(DeclSpec::TST_typeofType, StartLoc, PrevSpec, 
-                             Ty.get()))
+      if (DS.SetTypeSpecType(DeclSpec::TST_typeofType, StartLoc, PrevSpec,
+                             CastTy))
         Diag(StartLoc, diag::err_invalid_decl_spec_combination) << PrevSpec;
-    }
-  } else { // we have an expression.
-    OwningExprResult Result(ParseExpression());
-
-    if (Result.isInvalid() || Tok.isNot(tok::r_paren)) {
-      MatchRHSPunctuation(tok::r_paren, LParenLoc);
-      DS.SetTypeSpecError();
       return;
     }
-    RParenLoc = ConsumeParen();
-    const char *PrevSpec = 0;
-    // Check for duplicate type specifiers (e.g. "int typeof(int)").
-    if (DS.SetTypeSpecType(DeclSpec::TST_typeofExpr, StartLoc, PrevSpec, 
-                           Result.release()))
-      Diag(StartLoc, diag::err_invalid_decl_spec_combination) << PrevSpec;
+
+    // If this is a parenthesized expression, it is the start of a
+    // unary-expression, but doesn't include any postfix pieces.  Parse these
+    // now if present.
+    Operand = ParsePostfixExpressionSuffix(move(Operand));
   }
-  DS.SetRangeEnd(RParenLoc);
-}
 
+  // If we get here, the operand to the typeof was an expresion.
+  if (Operand.isInvalid()) {
+    DS.SetTypeSpecError();
+    return;
+  }
 
+  const char *PrevSpec = 0;
+  // Check for duplicate type specifiers (e.g. "int typeof(int)").
+  if (DS.SetTypeSpecType(DeclSpec::TST_typeofExpr, StartLoc, PrevSpec,
+                         Operand.release()))
+    Diag(StartLoc, diag::err_invalid_decl_spec_combination) << PrevSpec;
+}

diff --git a/test/Parser/cxx-template-decl.cpp b/test/Parser/cxx-template-decl.cpp
index 6a795eeabe49d69986fd98ceb8ca158935d359bc..ae5d8f9e0cce5bb1f088033881b07744f8b34bab 100644 (file)
--- a/test/Parser/cxx-template-decl.cpp
+++ b/test/Parser/cxx-template-decl.cpp
@@ -75,3 +75,8 @@ void f(int& i) {
 
 template<typename T>
 const T& min(const T&, const T&);
+
+void f2() {
+  int x;
+  A< typeof(x>1) > a;
+}

diff --git a/test/Parser/typeof.c b/test/Parser/typeof.c
index 76e8d479fcf6538330047789d46853a4a89e4390..a7c488023ae2e718f1e5f6dc481e0659cdfd15a9 100644 (file)
--- a/test/Parser/typeof.c
+++ b/test/Parser/typeof.c
@@ -11,7 +11,7 @@ static void test() {
   typeof(TInt) anInt; 
   short TInt eee; // expected-error{{expected ';' at end of declaration}}
   void ary[7] fff; // expected-error{{array has incomplete element type 'void'}} expected-error{{expected ';' at end of declaration}}
-  typeof(void ary[7]) anIntError; // expected-error{{expected ')'}} expected-note {{to match this '('}}  expected-warning {{type specifier missing, defaults to 'int'}}
+  typeof(void ary[7]) anIntError; // expected-error{{expected ')'}} expected-note {{to match this '('}}  expected-error {{variable has incomplete type 'typeof(void)' (aka 'void')}}
   typeof(const int) aci; 
   const typeof (*pi) aConstInt; 
   int xx;

diff --git a/test/Sema/exprs.c b/test/Sema/exprs.c
index f85e2fc4141d8cdd8466e9b10e412cf416dcb872..3fd1437da880aa8c30daf8d36bcfd4701092f5f7 100644 (file)
--- a/test/Sema/exprs.c
+++ b/test/Sema/exprs.c
@@ -79,7 +79,7 @@ void test10(int n,...) {
 
 struct mystruct {int A; };
 void test11(struct mystruct P, float F) {
-  MYMAX(P, F);  // expected-error {{invalid operands to binary expression ('typeof(P)' (aka 'struct mystruct') and 'typeof(F)' (aka 'float'))}}
+  MYMAX(P, F);  // expected-error {{invalid operands to binary expression ('typeof (P)' (aka 'struct mystruct') and 'typeof (F)' (aka 'float'))}}
 }
 
 // PR3753