Parsing of pseudo-destructors.

llvm-svn: 80055

clang/include/clang/Parse/Action.h

@@ -1263,7 +1263,16 @@ public:
     return ExprEmpty();
   }
 
-
+  virtual OwningExprResult
+  ActOnPseudoDtorReferenceExpr(Scope *S, ExprArg Base,
+                               SourceLocation OpLoc,
+                               tok::TokenKind OpKind,
+                               SourceLocation ClassNameLoc,
+                               IdentifierInfo *ClassName,
+                               const CXXScopeSpec *SS = 0) {
+    return ExprEmpty();
+  }
+  
   /// ActOnFinishFullExpr - Called whenever a full expression has been parsed.
   /// (C++ [intro.execution]p12).
   virtual OwningExprResult ActOnFinishFullExpr(ExprArg Expr) {

clang/lib/Parse/ParseExpr.cpp

@@ -933,18 +933,34 @@ Parser::ParsePostfixExpressionSuffix(OwningExprResult LHS) {
         ParseOptionalCXXScopeSpecifier(SS);
       }
 
-      if (Tok.isNot(tok::identifier)) {
+      if (Tok.is(tok::identifier)) {
+        if (!LHS.isInvalid())
+          LHS = Actions.ActOnMemberReferenceExpr(CurScope, move(LHS), OpLoc,
+                                                 OpKind, Tok.getLocation(),
+                                                 *Tok.getIdentifierInfo(),
+                                                 ObjCImpDecl, &SS);
+      } else if (getLang().CPlusPlus && Tok.is(tok::tilde)) {
+        // We have a C++ pseudo-destructor.
+        
+        // Consume the tilde.
+        ConsumeToken();
+        
+        if (!Tok.is(tok::identifier)) {
+          Diag(Tok, diag::err_expected_ident);
+          return ExprError();
+        }
+        
+        if (!LHS.isInvalid())
+          LHS = Actions.ActOnPseudoDtorReferenceExpr(CurScope, move(LHS), 
+                                                     OpLoc, OpKind,
+                                                     Tok.getLocation(), 
+                                                     Tok.getIdentifierInfo(),
+                                                     &SS);
+      } else {
         Diag(Tok, diag::err_expected_ident);
         return ExprError();
       }
 
-      if (!LHS.isInvalid()) {
-        LHS = Actions.ActOnMemberReferenceExpr(CurScope, move(LHS), OpLoc,
-                                               OpKind, Tok.getLocation(),
-                                               *Tok.getIdentifierInfo(),
-                                               ObjCImpDecl, &SS);
-      }
-
       if (getLang().CPlusPlus)
         Actions.ActOnCXXExitMemberScope(CurScope, MemberSS);
 

clang/lib/Sema/Sema.h

@@ -1921,6 +1921,14 @@ public:
                                                TypeTy *Ty,
                                                SourceLocation RParen);
 
+  virtual OwningExprResult
+  ActOnPseudoDtorReferenceExpr(Scope *S, ExprArg Base,
+                               SourceLocation OpLoc,
+                               tok::TokenKind OpKind,
+                               SourceLocation ClassNameLoc,
+                               IdentifierInfo *ClassName,
+                               const CXXScopeSpec *SS = 0);
+  
   /// MaybeCreateCXXExprWithTemporaries - If the list of temporaries is 
   /// non-empty, will create a new CXXExprWithTemporaries expression.
   /// Otherwise, just returs the passed in expression.

clang/lib/Sema/SemaExpr.cpp

@@ -1958,7 +1958,6 @@ Sema::ActOnMemberReferenceExpr(Scope *S, ExprArg Base, SourceLocation OpLoc,
                                tok::TokenKind OpKind, SourceLocation MemberLoc,
                                IdentifierInfo &Member,
                                DeclPtrTy ObjCImpDecl, const CXXScopeSpec *SS) {
-  // FIXME: handle the CXXScopeSpec for proper lookup of qualified-ids
   if (SS && SS->isInvalid())
     return ExprError();
 

clang/lib/Sema/SemaExprCXX.cpp

@@ -1682,11 +1682,35 @@ Expr *Sema::MaybeCreateCXXExprWithTemporaries(Expr *SubExpr,
   return E;
 }
 
+Sema::OwningExprResult
+Sema::ActOnPseudoDtorReferenceExpr(Scope *S, ExprArg Base,
+                                   SourceLocation OpLoc,
+                                   tok::TokenKind OpKind,
+                                   SourceLocation ClassNameLoc,
+                                   IdentifierInfo *ClassName,
+                                   const CXXScopeSpec *SS) {
+  if (SS && SS->isInvalid())
+    return ExprError();
+  
+  // Since this might be a postfix expression, get rid of ParenListExprs.
+  Base = MaybeConvertParenListExprToParenExpr(S, move(Base));
+  
+  Expr *BaseExpr = Base.takeAs<Expr>();
+  assert(BaseExpr && "no record expression");
+  
+  // Perform default conversions.
+  DefaultFunctionArrayConversion(BaseExpr);
+  
+  QualType BaseType = BaseExpr->getType();
+  return ExprError();
+}
+
 Sema::OwningExprResult Sema::ActOnFinishFullExpr(ExprArg Arg) {
   Expr *FullExpr = Arg.takeAs<Expr>();
   if (FullExpr)
     FullExpr = MaybeCreateCXXExprWithTemporaries(FullExpr, 
                                                  /*ShouldDestroyTemps=*/true);
 
+
   return Owned(FullExpr);
 }