Avoid crash if default argument parsed with errors.

[sepavloff]

Summary

If function parameters have default values, and that of the second
parameter is parsed with errors, function declaration would have
a parameter without default value that follows a parameter with
that. Such declaration breaks logic of selecting overloaded
function.

As a solution, erase default value of all parameters that precedes
the erroneous parameter.

This patch fixes PR20055.

[sepavloff]

Changed treatment of erroneous default value.

Indeed, using OpaqueValueExpr make code more readable. Thank you!

[rsmith]

LGTM

[sepavloff]

Thank you!

--Serge

2014-07-22 3:13 GMT+07:00 Richard Smith <[e-mail]>:

LGTM

http://reviews.llvm.org/D4378

[sepavloff]

Closed by commit rL213594 (authored by @sepavloff).

cfe/trunk/include/clang/Sema/Sema.h

ParmVarDecl *CheckParameter(DeclContext *DC, SourceLocation StartLoc,
                               QualType T, TypeSourceInfo *TSInfo,
                               StorageClass SC);
   void ActOnParamDefaultArgument(Decl *param,
                                  SourceLocation EqualLoc,
                                  Expr *defarg);
   void ActOnParamUnparsedDefaultArgument(Decl *param,
                                          SourceLocation EqualLoc,
                                          SourceLocation ArgLoc);
-  void ActOnParamDefaultArgumentError(Decl *param);
+  void ActOnParamDefaultArgumentError(Decl *param, SourceLocation EqualLoc);
   bool SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg,
                                SourceLocation EqualLoc);
 
   void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit,
                             bool TypeMayContainAuto);
   void ActOnUninitializedDecl(Decl *dcl, bool TypeMayContainAuto);
   void ActOnInitializerError(Decl *Dcl);
   void ActOnCXXForRangeDecl(Decl *D);

cfe/trunk/lib/Parse/ParseCXXInlineMethods.cpp

if (CachedTokens *Toks = LM.DefaultArgs[I].Toks) {
 
       ExprResult DefArgResult;
       if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
         Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
         DefArgResult = ParseBraceInitializer();
       } else
         DefArgResult = ParseAssignmentExpression();
       if (DefArgResult.isInvalid())
-        Actions.ActOnParamDefaultArgumentError(LM.DefaultArgs[I].Param);
+        Actions.ActOnParamDefaultArgumentError(LM.DefaultArgs[I].Param,
+                                               EqualLoc);
       else {
         if (!TryConsumeToken(tok::cxx_defaultarg_end)) {
           // The last two tokens are the terminator and the saved value of
           // Tok; the last token in the default argument is the one before
           // those.
           assert(Toks->size() >= 3 && "expected a token in default arg");
           Diag(Tok.getLocation(), diag::err_default_arg_unparsed)
             << SourceRange(Tok.getLocation(),

cfe/trunk/lib/Parse/ParseDecl.cpp

if (DS.isEmpty() && ParmDeclarator.getIdentifier() == nullptr &&
           // corresponding to the default argument. We'll actually parse
           // them when we see the end of the class definition.
           // FIXME: Can we use a smart pointer for Toks?
           DefArgToks = new CachedTokens;
 
           if (!ConsumeAndStoreInitializer(*DefArgToks, CIK_DefaultArgument)) {
             delete DefArgToks;
             DefArgToks = nullptr;
-            Actions.ActOnParamDefaultArgumentError(Param);
+            Actions.ActOnParamDefaultArgumentError(Param, EqualLoc);
           } else {
             // Mark the end of the default argument so that we know when to
             // stop when we parse it later on.
             Token DefArgEnd;
             DefArgEnd.startToken();
             DefArgEnd.setKind(tok::cxx_defaultarg_end);
             DefArgEnd.setLocation(Tok.getLocation());
             DefArgToks->push_back(DefArgEnd);
if (DS.isEmpty() && ParmDeclarator.getIdentifier() == nullptr &&
 
           ExprResult DefArgResult;
           if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
             Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
             DefArgResult = ParseBraceInitializer();
           } else
             DefArgResult = ParseAssignmentExpression();
           if (DefArgResult.isInvalid()) {
-            Actions.ActOnParamDefaultArgumentError(Param);
+            Actions.ActOnParamDefaultArgumentError(Param, EqualLoc);
             SkipUntil(tok::comma, tok::r_paren, StopAtSemi | StopBeforeMatch);
           } else {
             // Inform the actions module about the default argument
             Actions.ActOnParamDefaultArgument(Param, EqualLoc,
                                               DefArgResult.get());
           }
         }
       }

cfe/trunk/lib/Sema/SemaDeclCXX.cpp

void Sema::ActOnParamUnparsedDefaultArgument(Decl *param,
 
   ParmVarDecl *Param = cast<ParmVarDecl>(param);
   Param->setUnparsedDefaultArg();
   UnparsedDefaultArgLocs[Param] = ArgLoc;
 }
 
 /// ActOnParamDefaultArgumentError - Parsing or semantic analysis of
 /// the default argument for the parameter param failed.
-void Sema::ActOnParamDefaultArgumentError(Decl *param) {
+void Sema::ActOnParamDefaultArgumentError(Decl *param,
+                                          SourceLocation EqualLoc) {
   if (!param)
     return;
 
   ParmVarDecl *Param = cast<ParmVarDecl>(param);
   Param->setInvalidDecl();
   UnparsedDefaultArgLocs.erase(Param);
+  Param->setDefaultArg(new(Context)
+                       OpaqueValueExpr(EqualLoc, Param->getType(), VK_RValue));
 }
 
 /// CheckExtraCXXDefaultArguments - Check for any extra default
 /// arguments in the declarator, which is not a function declaration
 /// or definition and therefore is not permitted to have default
 /// arguments. This routine should be invoked for every declarator
 /// that is not a function declaration or definition.
 void Sema::CheckExtraCXXDefaultArguments(Declarator &D) {

cfe/trunk/test/SemaCXX/default1.cpp

 }
 
 int i2() {
   void j(int f = 4); // expected-note{{'j' declared here}}
   {
     j(2, 3); // expected-error{{too many arguments to function call, expected at most single argument 'f', have 2}}
   }
 }
+
+int pr20055_f(int x = 0, int y = UNDEFINED); // expected-error{{use of undeclared identifier}}
+int pr20055_v = pr20055_f(0);