Expand tests

crates/ruff_python_parser/src/parser.rs

@@ -863,10 +863,17 @@ type (
 type = 1
 type = x = 1
 x = type = 1
+lambda x: type
 ";
         insta::assert_debug_snapshot!(parse_suite(source, "<test>").unwrap());
     }
 
+    #[test]
+    fn test_invalid_type() {
+        assert!(parse_suite("a: type X = int", "<test>").is_err());
+        assert!(parse_suite("lambda: type X = int", "<test>").is_err());
+    }
+
     #[test]
     fn numeric_literals() {
         let source = r"x = 123456789

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__invalid_type.snap

@@ -0,0 +1,14 @@
+---
+source: crates/ruff_python_parser/src/parser.rs
+expression: "parse_suite(source, \"<test>\")"
+---
+Err(
+    ParseError {
+        error: UnrecognizedToken(
+            Type,
+            None,
+        ),
+        offset: 5,
+        source_path: "<test>",
+    },
+)

crates/ruff_python_parser/src/snapshots/ruff_python_parser__parser__tests__type_as_identifier.snap

@@ -988,4 +988,44 @@ expression: "parse_suite(source, \"<test>\").unwrap()"
             ),
         },
     ),
+    Expr(
+        StmtExpr {
+            range: 652..666,
+            value: Lambda(
+                ExprLambda {
+                    range: 652..666,
+                    parameters: Some(
+                        Parameters {
+                            range: 659..660,
+                            posonlyargs: [],
+                            args: [
+                                ParameterWithDefault {
+                                    range: 659..660,
+                                    parameter: Parameter {
+                                        range: 659..660,
+                                        name: Identifier {
+                                            id: "x",
+                                            range: 659..660,
+                                        },
+                                        annotation: None,
+                                    },
+                                    default: None,
+                                },
+                            ],
+                            vararg: None,
+                            kwonlyargs: [],
+                            kwarg: None,
+                        },
+                    ),
+                    body: Name(
+                        ExprName {
+                            range: 662..666,
+                            id: "type",
+                            ctx: Load,
+                        },
+                    ),
+                },
+            ),
+        },
+    ),
 ]

crates/ruff_python_parser/src/soft_keywords.rs

@@ -54,15 +54,14 @@ where
             // If the token is a soft keyword e.g. `type`, `match`, or `case`, check if it's
             // used as an identifier. We assume every soft keyword use is an identifier unless
             // a heuristic is met.
-
             match tok {
                 // For `match` and `case`, all of the following conditions must be met:
                 // 1. The token is at the start of a logical line.
                 // 2. The logical line contains a top-level colon (that is, a colon that is not nested
                 //    inside a parenthesized expression, list, or dictionary).
                 // 3. The top-level colon is not the immediate sibling of a `match` or `case` token.
                 //    (This is to avoid treating `match` or `case` as identifiers when annotated with
-                //    type hints.)   type hints.)
+                //    type hints.)
                 Tok::Match | Tok::Case => {
                     if matches!(self.position, Position::Statement) {
                         let mut nesting = 0;