diff --git a/gdb/ada-lex.l b/gdb/ada-lex.l
index 17ac7e5d3d5..6163405545d 100644
--- a/gdb/ada-lex.l
+++ b/gdb/ada-lex.l
@@ -84,6 +84,9 @@ static void rewind_to_char (int);
 
 static int find_dot_all (const char *);
 
+/* Depth of parentheses.  */
+static int paren_depth;
+
 %}
 
 %option case-insensitive interactive nodefault
@@ -305,6 +308,7 @@ static void
 lexer_init (FILE *inp)
 {
   BEGIN INITIAL;
+  paren_depth = 0;
   yyrestart (inp);
 }
 
diff --git a/gdb/c-exp.y b/gdb/c-exp.y
index e6d6c208f15..cb9e9e002c7 100644
--- a/gdb/c-exp.y
+++ b/gdb/c-exp.y
@@ -2527,6 +2527,9 @@ static int saw_name_at_eof;
    operator -- either '.' or ARROW.  */
 static bool last_was_structop;
 
+/* Depth of parentheses.  */
+static int paren_depth;
+
 /* Read one token, getting characters through lexptr.  */
 
 static int
@@ -3315,6 +3318,7 @@ c_parse (struct parser_state *par_state)
   /* Initialize some state used by the lexer.  */
   last_was_structop = false;
   saw_name_at_eof = 0;
+  paren_depth = 0;
 
   token_fifo.clear ();
   popping = 0;
diff --git a/gdb/d-exp.y b/gdb/d-exp.y
index a701c2541d3..c1519953521 100644
--- a/gdb/d-exp.y
+++ b/gdb/d-exp.y
@@ -1020,6 +1020,9 @@ static int saw_name_at_eof;
    This is used only when parsing to do field name completion.  */
 static int last_was_structop;
 
+/* Depth of parentheses.  */
+static int paren_depth;
+
 /* Read one token, getting characters through lexptr.  */
 
 static int
@@ -1619,6 +1622,7 @@ d_parse (struct parser_state *par_state)
   /* Initialize some state used by the lexer.  */
   last_was_structop = 0;
   saw_name_at_eof = 0;
+  paren_depth = 0;
 
   token_fifo.clear ();
   popping = 0;
diff --git a/gdb/f-exp.y b/gdb/f-exp.y
index 5670136b2a6..100a3bbec14 100644
--- a/gdb/f-exp.y
+++ b/gdb/f-exp.y
@@ -68,6 +68,9 @@
 
 static struct parser_state *pstate = NULL;
 
+/* Depth of parentheses.  */
+static int paren_depth;
+
 int yyparse (void);
 
 static int yylex (void);
@@ -1328,6 +1331,7 @@ f_parse (struct parser_state *par_state)
 							parser_debug);
   gdb_assert (par_state != NULL);
   pstate = par_state;
+  paren_depth = 0;
 
   return yyparse ();
 }
diff --git a/gdb/go-exp.y b/gdb/go-exp.y
index d112a73f21a..aaffe3d45a0 100644
--- a/gdb/go-exp.y
+++ b/gdb/go-exp.y
@@ -1001,6 +1001,9 @@ static int saw_name_at_eof;
    do field name completion.  */
 static int last_was_structop;
 
+/* Depth of parentheses.  */
+static int paren_depth;
+
 /* Read one token, getting characters through lexptr.  */
 
 static int
@@ -1566,6 +1569,7 @@ go_parse (struct parser_state *par_state)
   /* Initialize some state used by the lexer.  */
   last_was_structop = 0;
   saw_name_at_eof = 0;
+  paren_depth = 0;
 
   token_fifo.clear ();
   popping = 0;
diff --git a/gdb/m2-exp.y b/gdb/m2-exp.y
index c1418c751f1..c0f5e75be2a 100644
--- a/gdb/m2-exp.y
+++ b/gdb/m2-exp.y
@@ -763,6 +763,9 @@ static struct keyword keytab[] =
 };
 
 
+/* Depth of parentheses.  */
+static int paren_depth;
+
 /* Read one token, getting characters through lexptr.  */
 
 /* This is where we will check to make sure that the language and the
@@ -1039,6 +1042,7 @@ m2_parse (struct parser_state *par_state)
   scoped_restore pstate_restore = make_scoped_restore (&pstate);
   gdb_assert (par_state != NULL);
   pstate = par_state;
+  paren_depth = 0;
 
   return yyparse ();
 }
diff --git a/gdb/p-exp.y b/gdb/p-exp.y
index dbccf358d5c..768f3025921 100644
--- a/gdb/p-exp.y
+++ b/gdb/p-exp.y
@@ -68,6 +68,9 @@
 
 static struct parser_state *pstate = NULL;
 
+/* Depth of parentheses.  */
+static int paren_depth;
+
 int yyparse (void);
 
 static int yylex (void);
@@ -1723,6 +1726,7 @@ pascal_parse (struct parser_state *par_state)
   scoped_restore pstate_restore = make_scoped_restore (&pstate);
   gdb_assert (par_state != NULL);
   pstate = par_state;
+  paren_depth = 0;
 
   return yyparse ();
 }
diff --git a/gdb/parse.c b/gdb/parse.c
index d76aeb1d853..4ac79faaeae 100644
--- a/gdb/parse.c
+++ b/gdb/parse.c
@@ -71,7 +71,6 @@ int arglist_len;
 static struct type_stack type_stack;
 const char *lexptr;
 const char *prev_lexptr;
-int paren_depth;
 int comma_terminates;
 
 /* True if parsing an expression to attempt completion.  */
@@ -1117,7 +1116,6 @@ parse_exp_in_context (const char **stringptr, CORE_ADDR pc,
   lexptr = *stringptr;
   prev_lexptr = NULL;
 
-  paren_depth = 0;
   type_stack.elements.clear ();
   expout_last_struct = -1;
   expout_tag_completion_type = TYPE_CODE_UNDEF;
diff --git a/gdb/parser-defs.h b/gdb/parser-defs.h
index f895a552879..6fb0f8e5533 100644
--- a/gdb/parser-defs.h
+++ b/gdb/parser-defs.h
@@ -356,10 +356,6 @@ extern const char *lexptr;
    Currently used only for error reporting.  */
 extern const char *prev_lexptr;
 
-/* Current depth in parentheses within the expression.  */
-
-extern int paren_depth;
-
 /* Nonzero means stop parsing on first comma (if not within parentheses).  */
 
 extern int comma_terminates;
diff --git a/gdb/rust-exp.y b/gdb/rust-exp.y
index 1b7e33e6172..9d3083ead92 100644
--- a/gdb/rust-exp.y
+++ b/gdb/rust-exp.y
@@ -300,6 +300,9 @@ struct rust_parser
 
   /* The parser state gdb gave us.  */
   struct parser_state *pstate;
+
+  /* Depth of parentheses.  */
+  int paren_depth = 0;
 };
 
 /* Rust AST operations.  We build a tree of these; then lower them to
@@ -1664,14 +1667,14 @@ rustyylex (YYSTYPE *lvalp, rust_parser *parser)
   else if (lexptr[0] == '}' || lexptr[0] == ']')
     {
       /* Falls through to lex_operator.  */
-      --paren_depth;
+      --parser->paren_depth;
     }
   else if (lexptr[0] == '(' || lexptr[0] == '{')
     {
       /* Falls through to lex_operator.  */
-      ++paren_depth;
+      ++parser->paren_depth;
     }
-  else if (lexptr[0] == ',' && comma_terminates && paren_depth == 0)
+  else if (lexptr[0] == ',' && comma_terminates && parser->paren_depth == 0)
     return 0;
 
   return lex_operator (lvalp);
@@ -2552,11 +2555,11 @@ rustyyerror (rust_parser *parser, const char *msg)
 /* Initialize the lexer for testing.  */
 
 static void
-rust_lex_test_init (const char *input)
+rust_lex_test_init (rust_parser *parser, const char *input)
 {
   prev_lexptr = NULL;
   lexptr = input;
-  paren_depth = 0;
+  parser->paren_depth = 0;
 }
 
 /* A test helper that lexes a string, expecting a single token.  It
@@ -2568,7 +2571,7 @@ rust_lex_test_one (rust_parser *parser, const char *input, int expected)
   int token;
   RUSTSTYPE result;
 
-  rust_lex_test_init (input);
+  rust_lex_test_init (parser, input);
 
   token = rustyylex (&result, parser);
   SELF_CHECK (token == expected);
@@ -2632,7 +2635,7 @@ rust_lex_test_sequence (rust_parser *parser, const char *input, int len,
   int i;
 
   lexptr = input;
-  paren_depth = 0;
+  parser->paren_depth = 0;
 
   for (i = 0; i < len; ++i)
     {
@@ -2686,7 +2689,7 @@ rust_lex_test_push_back (rust_parser *parser)
   int token;
   RUSTSTYPE lval;
 
-  rust_lex_test_init (">>=");
+  rust_lex_test_init (parser, ">>=");
 
   token = rustyylex (&lval, parser);
   SELF_CHECK (token == COMPOUND_ASSIGN);
