added or/and keywords for union/intersection types

in type positions, `A or B` lowers to `A | B` and `A and B` to
`Intersection[A, B]`. forward transform folds boolops into the shared
intersection/union lowering (flatten n-ary, mix with &/|/not, python
precedence: and over or). ty resolves boolop in .by type expressions.
value-position boolops untouched

Author: KotlinIsland

crates/by_transforms/src/transforms/intersection.rs

@@ -11,12 +11,11 @@
 //! `Annotated[T, …]` first arg, `Callable[[P], R]` parameter list + return.
 //! `not x` in non-type contexts (boolean negation) is never affected.
 
-use ruff_python_ast::{
-    AtomicNodeIndex, Expr, ExprContext, ExprName, ExprSubscript, Stmt, UnaryOp, name::Name,
-};
+use ruff_python_ast::{Expr, Stmt, UnaryOp};
 use ruff_text_size::TextRange;
 
 use super::ast_driver::{PassContext, TypeAwarePass, render_expr};
+use super::intersection::{LowerImports, lower};
 use super::type_expr_walker::{Recurse, TypeExprVisitor, TypePos, walk_type_positions};
 use crate::type_info::TypeInfo;
 
@@ -32,42 +31,30 @@ impl TypeAwarePass for NotType {
     fn run(&self, stmts: &[Stmt], types: &dyn TypeInfo, ctx: &mut PassContext) {
         let mut state = State {
             edits: Vec::new(),
-            needs_import: false,
+            needs: LowerImports::default(),
         };
         walk_type_positions(stmts, Some(types), &mut state);
         ctx.text_edits.extend(state.edits);
-        if state.needs_import {
-            ctx.required_imports
-                .push("from ty_extensions import Not".to_owned());
-        }
+        state.needs.push_required(ctx);
     }
 }
 
 struct State {
     edits: Vec<(TextRange, String)>,
-    needs_import: bool,
+    needs: LowerImports,
 }
 
 impl TypeExprVisitor for State {
     fn visit(&mut self, expr: &Expr, _pos: TypePos) -> Recurse {
         if let Expr::UnaryOp(u) = expr
             && matches!(u.op, UnaryOp::Not)
         {
-            let new_node = Expr::Subscript(ExprSubscript {
-                node_index: AtomicNodeIndex::NONE,
-                range: TextRange::default(),
-                value: Box::new(Expr::Name(ExprName {
-                    node_index: AtomicNodeIndex::NONE,
-                    range: TextRange::default(),
-                    id: Name::from("Not"),
-                    ctx: ExprContext::Load,
-                })),
-                slice: Box::new((*u.operand).clone()),
-                ctx: ExprContext::Load,
-                is_typeof: false,
-            });
-            self.needs_import = true;
+            // the shared lowering rewrites the whole `not …` chain, including
+            // `&` / `and` / `or` and nested `not` inside the operand, so the
+            // wide edit can't leak surface operators
+            let new_node = lower(expr, &mut self.needs);
             self.edits.push((u.range, render_expr(&new_node)));
+            return Recurse::Stop;
         }
         Recurse::Descend
     }
@@ -271,6 +258,41 @@ mod tests {
         unchanged("from typing import Literal\na: Literal[True, False]\n");
     }
 
+    #[test]
+    fn not_of_intersection_operand_lowered() {
+        // the operand lowers through the shared intersection/union lowering
+        // so `&` doesn't leak into the emitted python
+        check(
+            "a: not (A & B)\n",
+            indoc! {"
+                from ty_extensions import Intersection, Not
+                a: Not[Intersection[A, B]]
+            "},
+        );
+    }
+
+    #[test]
+    fn not_of_or_keyword_operand_lowered() {
+        check(
+            "a: not (A or B)\n",
+            indoc! {"
+                from ty_extensions import Not
+                a: Not[A | B]
+            "},
+        );
+    }
+
+    #[test]
+    fn nested_not_lowered() {
+        check(
+            "a: not not int\n",
+            indoc! {"
+                from ty_extensions import Not
+                a: Not[Not[int]]
+            "},
+        );
+    }
+
     #[test]
     fn nested_not_in_dict_slice() {
         // unparenthesized tuple inside subscript slice — both elements are

crates/by_transforms/src/transforms/not_type.rs

@@ -140,6 +140,12 @@ impl TypePosWalker<'_> {
                 self.visit_type_expr(&b.left, TypePos::Nested);
                 self.visit_type_expr(&b.right, TypePos::Nested);
             }
+            // `A or B` / `A and B` — keyword spellings of union / intersection
+            Expr::BoolOp(b) => {
+                for value in &b.values {
+                    self.visit_type_expr(value, TypePos::Nested);
+                }
+            }
             // `not T` (negation) and `T?` (optional) both carry a nested type
             // expression in their operand, so descend so sibling transforms
             // (intersection, not, float, …) apply inside `(not A)?`, `(A & B)?`

crates/by_transforms/src/transforms/type_expr_walker.rs

@@ -0,0 +1,123 @@
+# basedpython: `or` / `and` type operators
+
+basedpython accepts the keywords `or` and `and` in type positions as spellings of union and
+intersection — `A or B` is `A | B`, `A and B` is `A & B`.
+
+```toml
+[environment]
+python-version = "3.12"
+```
+
+## `or` is union
+
+```by
+def f(x: int or str) -> None:
+    reveal_type(x)  # revealed: int | str
+```
+
+## `and` is intersection
+
+```by
+class P: ...
+class Q: ...
+
+def f(x: P and Q) -> None:
+    reveal_type(x)  # revealed: P & Q
+```
+
+## n-ary chains flatten
+
+```by
+class A: ...
+class B: ...
+class C: ...
+
+def f(x: A and B and C, y: int or str or None) -> None:
+    reveal_type(x)  # revealed: A & B & C
+    reveal_type(y)  # revealed: int | str | None
+```
+
+## `and` binds tighter than `or`
+
+matching python's boolean precedence, and `&` over `|`:
+
+```by
+class A: ...
+class B: ...
+class C: ...
+
+def f(x: A and B or C) -> None:
+    reveal_type(x)  # revealed: (A & B) | C
+```
+
+## parentheses compose
+
+```by
+class A: ...
+class B: ...
+class C: ...
+
+def f(x: (A or B) and C) -> None:
+    reveal_type(x)  # revealed: (A & C) | (B & C)
+```
+
+## keyword and symbolic forms mix
+
+```by
+class A: ...
+class B: ...
+class C: ...
+
+def f(x: A & B and C, y: int | str or None) -> None:
+    reveal_type(x)  # revealed: A & B & C
+    reveal_type(y)  # revealed: int | str | None
+```
+
+## nested in a generic
+
+```by
+class HasA:
+    a: int
+
+class HasB:
+    b: str
+
+def f(items: list[HasA and HasB], names: list[int or str]) -> None:
+    if items and names:
+        reveal_type(items[0].a)  # revealed: int
+        reveal_type(items[0].b)  # revealed: str
+        reveal_type(names[0])  # revealed: int | str
+```
+
+## intersection of attribute presence
+
+```by
+class HasA:
+    a: int
+
+class HasB:
+    b: str
+
+def f(x: HasA and HasB) -> tuple[int, str]:
+    return (x.a, x.b)
+```
+
+## value positions keep boolean semantics
+
+`or` / `and` outside type positions are ordinary boolean operators:
+
+```by
+def f(a: int, b: int) -> None:
+    reveal_type(bool(a) or bool(b))  # revealed: bool
+    x = True and False
+    reveal_type(x)  # revealed: False
+```
+
+## still rejected in python files
+
+```py
+def f(
+    x: int or str,  # error: [invalid-type-form] "Boolean operations are not allowed in parameter annotations"
+    y: int and str,  # error: [invalid-type-form] "Boolean operations are not allowed in parameter annotations"
+) -> None: ...
+```

crates/ty_python_semantic/resources/mdtest/basedpython_or_and_types.md

@@ -791,6 +791,22 @@ impl<'db> TypeInferenceBuilder<'db, '_> {
             }
 
             ast::Expr::BoolOp(bool_op) => {
+                // basedpython: `A or B` / `A and B` in a type annotation are the
+                // keyword spellings of union / intersection. allowed only in
+                // `.by` / `.byi`
+                if self.is_basedpython_file() {
+                    let elements: Vec<Type<'db>> = bool_op
+                        .values
+                        .iter()
+                        .map(|value| self.infer_type_expression(value))
+                        .collect();
+                    return match bool_op.op {
+                        ast::BoolOp::Or => {
+                            UnionType::from_elements_leave_aliases(self.db(), elements)
+                        }
+                        ast::BoolOp::And => IntersectionType::from_elements(self.db(), elements),
+                    };
+                }
                 if !self.in_string_annotation() {
                     self.infer_boolean_expression(bool_op, TypeContext::default());
                 }

crates/ty_python_semantic/src/types/infer/builder/type_expression.rs

@@ -28,6 +28,9 @@ chains are flattened: `A & B & C` becomes `Intersection[A, B, C]` rather than
 nested. intersections compose with unions by precedence: `&` binds tighter than
 `|`, so `A & B | C` parses as `(A & B) | C`
 
+the keywords `and` / `or` are accepted as alternate spellings of `&` / `|` —
+see [`or` / `and` type operators](or-and-types.md)
+
 ## scope
 
 the `&` operator is recognized only in syntactic type positions: annotations,

docs/basedpython/features/intersection.md

@@ -0,0 +1,60 @@
+# `or` / `and` type operators
+
+basedpython accepts the keywords `or` and `and` in annotation positions as
+spellings of union and intersection — `A or B` means `A | B`, `A and B`
+means `A & B`:
+
+```by
+def parse(raw: str or bytes) -> int or None: ...
+
+handlers: list[HasName and HasId]
+
+cb: A and B or C
+```
+
+transpiles to:
+
+```python
+def parse(raw: str | bytes) -> int | None: ...
+
+handlers: list[Intersection[HasName, HasId]]
+
+cb: Intersection[A, B] | C
+```
+
+## semantics
+
+`A or B` is the union of `A` and `B`; `A and B` is the type of values that
+satisfy both `A` *and* `B` — exactly the semantics of `|` and `&` from
+[intersection types](intersection.md). the keywords follow python's boolean
+precedence, which mirrors the bitwise one: `and` binds tighter than `or`, so
+`A and B or C` is `(A & B) | C`
+
+n-ary chains flatten: `A and B and C` becomes `Intersection[A, B, C]` rather
+than nested, and `A or B or C` becomes one `A | B | C` union. the keyword and
+symbolic spellings mix freely — `A & B and C` is one three-arm intersection,
+`A | B or C` one three-arm union. parentheses compose as usual:
+`(A or B) and C` is `Intersection[A | B, C]`
+
+## scope
+
+the keywords are recognized only in syntactic type positions: annotations,
+return types, type aliases, and subscript slices that are themselves type
+contexts. boolean `or` / `and` in value expressions is untouched:
+
+```by
+x = a or b    # boolean or — unchanged
+a: A or B     # union — rewritten
+```
+
+## polyfill
+
+`or` lowers to the native `|` union, which needs no import. `and` lowers to
+`Intersection` from `ty_extensions`, exactly like the `&` operator — see
+[intersection types](intersection.md)
+
+## round-tripping
+
+`or` / `and` are alternate input spellings, not the canonical surface form.
+reverse transpilation re-sugars `Intersection[…]` to `&` and leaves `|`
+as-is, so a round-trip emits the symbolic operators

docs/basedpython/features/or-and-types.md

@@ -25,6 +25,7 @@ basedpython is a Python-like language that transpiles to pure Python
 - [tuple type literals](features/tuple-types.md)
 - [callable arrow syntax](features/callable.md)
 - [intersection types](features/intersection.md)
+- [`or` / `and` type operators](features/or-and-types.md)
 - [negation types (`not T`)](features/not-type.md)
 - [`typeof` keyword](features/typeof.md)
 - [star projections (`X[*]`)](features/star-projection.md)