diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc
index 5fa743b5a8e..dd51b3a7b79 100644
--- a/gcc/cp/parser.cc
+++ b/gcc/cp/parser.cc
@@ -2391,9 +2391,9 @@ static void cp_parser_type_specifier_seq
 static tree cp_parser_parameter_declaration_clause
   (cp_parser *, cp_parser_flags);
 static tree cp_parser_parameter_declaration_list
-  (cp_parser *, cp_parser_flags);
+  (cp_parser *, cp_parser_flags, auto_vec<tree> *);
 static cp_parameter_declarator *cp_parser_parameter_declaration
-  (cp_parser *, cp_parser_flags, bool, bool *);
+  (cp_parser *, cp_parser_flags, bool, bool *, auto_vec<tree> * = nullptr);
 static tree cp_parser_default_argument
   (cp_parser *, bool);
 static void cp_parser_function_body
@@ -24438,6 +24438,27 @@ function_being_declared_is_template_p (cp_parser* parser)
 	  (current_class_type));
 }
 
+/* Push any pending named parameters we have seen in this function declaration
+   and stashed into PENDING_DECLS.  This mechanism is used for cases like
+
+     S foo(int(x), int(x), int{x});
+
+   where it's not clear if we're dealing with a constructor call or a function
+   declaration until we've seen the last argument which breaks it up.  Pushing
+   immediately would result in the redefinition error on the second 'x'.
+
+   We only have to do this if the first parameter is parenthesized.  */
+
+static void
+push_pending_decls (auto_vec<tree> *pending_decls)
+{
+  if (!pending_decls)
+    return;
+  for (tree p : pending_decls)
+    pushdecl (p);
+  pending_decls->truncate (0);
+}
+
 /* Parse a parameter-declaration-clause.
 
    parameter-declaration-clause:
@@ -24494,8 +24515,12 @@ cp_parser_parameter_declaration_clause (cp_parser* parser,
       return explicit_void_list_node;
     }
 
+  /* A vector of parameters that haven't been pushed yet.  */
+  auto_vec<tree> pending_decls;
+
   /* Parse the parameter-declaration-list.  */
-  parameters = cp_parser_parameter_declaration_list (parser, flags);
+  parameters = cp_parser_parameter_declaration_list (parser, flags,
+						     &pending_decls);
   /* If a parse error occurred while parsing the
      parameter-declaration-list, then the entire
      parameter-declaration-clause is erroneous.  */
@@ -24525,6 +24550,14 @@ cp_parser_parameter_declaration_clause (cp_parser* parser,
   else
     ellipsis_p = false;
 
+  /* A valid parameter-declaration-clause can only be followed by a ')'.
+     So it's time to push all the parameters we have seen now that we
+     know we have a valid declaration.  Note that here we may not have
+     committed yet, nor should we.  Pushing here will detect the error
+     of redefining a parameter.  */
+  if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
+    push_pending_decls (&pending_decls);
+
   /* Finish the parameter list.  */
   if (!ellipsis_p)
     parameters = chainon (parameters, void_list_node);
@@ -24539,23 +24572,25 @@ cp_parser_parameter_declaration_clause (cp_parser* parser,
      parameter-declaration-list , parameter-declaration
 
    The parser flags FLAGS is used to control type-specifier parsing.
+   PENDING_DECLS is a vector of parameters that haven't been pushed yet.
 
    Returns a representation of the parameter-declaration-list, as for
    cp_parser_parameter_declaration_clause.  However, the
    `void_list_node' is never appended to the list.  */
 
 static tree
-cp_parser_parameter_declaration_list (cp_parser* parser, cp_parser_flags flags)
+cp_parser_parameter_declaration_list (cp_parser* parser,
+				      cp_parser_flags flags,
+				      auto_vec<tree> *pending_decls)
 {
   tree parameters = NULL_TREE;
   tree *tail = &parameters;
-  bool saved_in_unbraced_linkage_specification_p;
   int index = 0;
 
   /* The special considerations that apply to a function within an
      unbraced linkage specifications do not apply to the parameters
      to the function.  */
-  saved_in_unbraced_linkage_specification_p
+  bool saved_in_unbraced_linkage_specification_p
     = parser->in_unbraced_linkage_specification_p;
   parser->in_unbraced_linkage_specification_p = false;
 
@@ -24570,7 +24605,8 @@ cp_parser_parameter_declaration_list (cp_parser* parser, cp_parser_flags flags)
       parameter
 	= cp_parser_parameter_declaration (parser, flags,
 					   /*template_parm_p=*/false,
-					   &parenthesized_p);
+					   &parenthesized_p,
+					   pending_decls);
 
       /* We don't know yet if the enclosing context is unavailable or deprecated,
 	 so wait and deal with it in grokparms if appropriate.  */
@@ -24602,7 +24638,16 @@ cp_parser_parameter_declaration_list (cp_parser* parser, cp_parser_flags flags)
 			       parameter->decl_specifiers.attributes,
 			       0);
       if (DECL_NAME (decl))
-	decl = pushdecl (decl);
+	{
+	  /* We cannot pushdecl while parsing tentatively because that may
+	     have side effects and we cannot be sure yet if we are parsing
+	     a declaration.  */
+	  if (pending_decls
+	      && cp_parser_uncommitted_to_tentative_parse_p (parser))
+	    pending_decls->safe_push (decl);
+	  else
+	    decl = pushdecl (decl);
+	}
 
       if (decl != error_mark_node)
 	{
@@ -24713,6 +24758,8 @@ cp_parser_parameter_declaration_list (cp_parser* parser, cp_parser_flags flags)
    token encountered during the parsing of the assignment-expression
    is not interpreted as a greater-than operator.)
 
+   PENDING_DECLS is a vector of parameters that haven't been pushed yet.
+
    Returns a representation of the parameter, or NULL if an error
    occurs.  If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to
    true iff the declarator is of the form "(p)".  */
@@ -24721,7 +24768,8 @@ static cp_parameter_declarator *
 cp_parser_parameter_declaration (cp_parser *parser,
 				 cp_parser_flags flags,
 				 bool template_parm_p,
-				 bool *parenthesized_p)
+				 bool *parenthesized_p,
+				 auto_vec<tree> *pending_decls)
 {
   int declares_class_or_enum;
   cp_decl_specifier_seq decl_specifiers;
@@ -24823,7 +24871,12 @@ cp_parser_parameter_declaration (cp_parser *parser,
 		cp_parser_simulate_error (parser);
 	    }
 	  else
-	    cp_parser_commit_to_tentative_parse (parser);
+	    {
+	      /* OK, so this *is* a declaration.  Push any parameters we have
+		 seen; they may be used in default arguments, noexcept, etc.  */
+	      push_pending_decls (pending_decls);
+	      cp_parser_commit_to_tentative_parse (parser);
+	    }
 	}
       /* Parse the declarator.  */
       declarator_token_start = token;
@@ -34049,7 +34102,8 @@ cp_parser_cache_defarg (cp_parser *parser, bool nsdmi)
 		  cp_lexer_consume_token (parser->lexer);
 		  begin_scope (sk_function_parms, NULL_TREE);
 		  tree t = cp_parser_parameter_declaration_list
-			    (parser, CP_PARSER_FLAGS_NONE);
+			    (parser, CP_PARSER_FLAGS_NONE,
+			     /*pending_decls*/nullptr);
 		  if (t == error_mark_node)
 		    error = true;
 		  pop_bindings_and_leave_scope ();
diff --git a/gcc/testsuite/g++.dg/parse/ambig11.C b/gcc/testsuite/g++.dg/parse/ambig11.C
new file mode 100644
index 00000000000..51a586f40b0
--- /dev/null
+++ b/gcc/testsuite/g++.dg/parse/ambig11.C
@@ -0,0 +1,39 @@
+// PR c++/64679
+// { dg-do run { target c++11 } }
+
+struct Bar {
+  int a, b, c;
+  Bar(int a, int b, int c) : a(a), b(b), c(c) { }
+};
+
+void
+f ()
+{
+  Bar fn1(int(a), int(b), int c = sizeof(a));
+  Bar fn2(int(x), int(y), int(z)); // { dg-warning "function declaration" }
+  Bar fn3(int(x), int(y), int);
+  Bar fn4(int (*p)(int(x), int(y))); // { dg-warning "function declaration" }
+  Bar fn5(int (x), int (*p)(int(x), int(y)), int);
+}
+
+int
+main ()
+{
+  int x = 1;
+  // This ain't a decl.
+  Bar v1(int(x), int(x), int{x});
+  if (v1.a != 1 || v1.b != v1.a || v1.c != v1.a)
+    __builtin_abort ();
+  Bar v2(int(x), int(x), 1);
+  if (v2.a != 1 || v2.b != v2.a || v2.c != 1)
+    __builtin_abort ();
+  Bar v3(int(x), int(x), int(1));
+  if (v3.a != 1 || v3.b != v3.a || v3.c != 1)
+    __builtin_abort ();
+  Bar v4(int(1), int(x), int{x});
+  if (v4.a != 1 || v4.b != 1 || v4.c != 1)
+    __builtin_abort ();
+  Bar v5(int{x}, int(x), int{x});
+  if (v5.a != 1 || v5.b != v5.a || v5.c != v5.a)
+    __builtin_abort ();
+}
diff --git a/gcc/testsuite/g++.dg/parse/ambig12.C b/gcc/testsuite/g++.dg/parse/ambig12.C
new file mode 100644
index 00000000000..981f35f32a2
--- /dev/null
+++ b/gcc/testsuite/g++.dg/parse/ambig12.C
@@ -0,0 +1,12 @@
+// PR c++/64679
+
+struct Bar {
+  Bar (int, int, int);
+};
+
+void
+g ()
+{
+  Bar e1(int(x), int(x), int); // { dg-error "redefinition" }
+  Bar e2(int (*p)(int(x), int(x)), int); // { dg-error "redefinition" }
+}
diff --git a/gcc/testsuite/g++.dg/parse/ambig13.C b/gcc/testsuite/g++.dg/parse/ambig13.C
new file mode 100644
index 00000000000..5f6a3b934c2
--- /dev/null
+++ b/gcc/testsuite/g++.dg/parse/ambig13.C
@@ -0,0 +1,32 @@
+// PR c++/64679
+// { dg-do compile { target c++11 } }
+
+struct Bar {
+  Bar (int, int, int);
+};
+
+template<typename T>
+void
+g ()
+{
+  int x = 1;
+  Bar v1(T(x), T(x), T{x});
+  Bar v2(T(x), T(x), T(1));
+}
+
+void
+invoke (Bar (*p)) noexcept(noexcept(*p))
+{
+}
+
+auto
+pmf (int (Bar::*p)) -> decltype(p)
+{
+  return nullptr;
+}
+
+void
+f ()
+{
+  g<int>();
+}
