@@ -46,14 +46,15 @@ pub fn parse_params(
     Ok((posonly, names, defaults))
 }
 
-type FunctionArgument = (Option<(ast::Location, Option<String>)>, ast::Expr);
+type FunctionArgument = (Option<(ast::Location, Option<String>)>, ast::Expr, bool);
 
 pub fn parse_args(func_args: Vec<FunctionArgument>) -> Result<ArgumentList, LexicalError> {
     let mut args = vec![];
     let mut keywords = vec![];
+    let len = func_args.len();
 
     let mut keyword_names = HashSet::with_capacity_and_hasher(func_args.len(), RandomState::new());
-    for (name, value) in func_args {
+    for (name, value, parenthesized) in func_args {
         match name {
             Some((location, name)) => {
                 if let Some(keyword_name) = &name {
@@ -84,6 +85,17 @@ pub fn parse_args(func_args: Vec<FunctionArgument>) -> Result<ArgumentList, Lexi
                     });
                 }
 
+                if let ast::ExprKind::GeneratorExp { elt: e, .. } = &value.node {
+                    if len != 1 && !parenthesized {
+                        return Err(LexicalError {
+                            error: LexicalErrorType::OtherError(
+                                "Generator expression must be parenthesized".to_string(),
+                            ),
+                            location: e.location,
+                        });
+                    }
+                }
+
                 args.push(value);
             }
         }
 
@@ -1165,30 +1165,34 @@ ArgumentList: ArgumentList = {
     }
 };
 
-FunctionArgument: (Option<(ast::Location, Option<String>)>, ast::Expr) = {
+FunctionArgument: (Option<(ast::Location, Option<String>)>, ast::Expr, bool) = {
     <e:NamedExpressionTest> <c:CompFor?> => {
+        let mut parenthesized = true;
         let expr = match c {
-            Some(c) => ast::Expr {
-                location: e.location,
-                custom: (),
-                node: ast::ExprKind::GeneratorExp {
-                    elt: Box::new(e),
-                    generators: c,
+            Some(c) => {
+                parenthesized = false;
+                ast::Expr {
+                    location: e.location,
+                    custom: (),
+                    node: ast::ExprKind::GeneratorExp {
+                        elt: Box::new(e),
+                        generators: c,
+                    }
                 }
             },
             None => e,
         };
-        (None, expr)
+        (None, expr, parenthesized)
     },
-    <location:@L> <i:Identifier> "=" <e:Test> => (Some((location, Some(i))), e),
+    <location:@L> <i:Identifier> "=" <e:Test> => (Some((location, Some(i))), e, false),
     <location:@L> "*" <e:Test> => {
         let expr = ast::Expr::new(
             location,
             ast::ExprKind::Starred { value: Box::new(e), ctx: ast::ExprContext::Load },
         );
-        (None, expr)
+        (None, expr, false)
     },
-    <location:@L> "**" <e:Test> => (Some((location, None)), e),
+    <location:@L> "**" <e:Test> => (Some((location, None)), e, false),
 };
 
 #[inline]