diagnostics

Author: thejchap

crates/ty_python_semantic/resources/mdtest/enums.md

@@ -1437,7 +1437,7 @@ reveal_type(enum_members(E3))  # revealed: Unknown
 from enum import Enum
 from ty_extensions import enum_members
 
-# this is invalid at runtime: TypeError
+# error: [too-many-positional-arguments]
 Color = Enum("Color", "RED", "GREEN", "BLUE")
 
 reveal_type(enum_members(Color))  # revealed: Unknown
@@ -1467,6 +1467,53 @@ def make_enum(name: str, labels: tuple[str, ...]) -> type[Enum]:
     return result
 ```
 
+### Non-string name
+
+```py
+from enum import Enum
+
+# error: [invalid-argument-type]
+Color = Enum(123, "RED GREEN BLUE")
+```
+
+### Unknown keyword arguments
+
+```py
+from enum import Enum
+
+# error: [unknown-argument]
+Color = Enum("Color", "RED GREEN BLUE", bad_kwarg=True)
+```
+
+### `boundary` keyword (Python 3.11+)
+
+#### Available on 3.11+
+
+```toml
+[environment]
+python-version = "3.11"
+```
+
+```py
+from enum import Flag
+
+Perm = Flag("Perm", "READ WRITE EXECUTE", boundary=None)
+```
+
+#### Rejected before 3.11
+
+```toml
+[environment]
+python-version = "3.10"
+```
+
+```py
+from enum import Flag
+
+# error: [unknown-argument]
+Perm = Flag("Perm", "READ WRITE EXECUTE", boundary=None)
+```
+
 ### StrEnum function syntax
 
 ```toml
@@ -1555,6 +1602,24 @@ reveal_type(Perm.WRITE.value)  # revealed: Literal[2]
 reveal_type(Perm.EXECUTE.value)  # revealed: Literal[4]
 ```
 
+### Large start value (overflow guard)
+
+Values that would overflow `i64` should gracefully widen to `int`.
+
+```py
+from enum import Enum, Flag
+
+Big = Enum("Big", "A B", start=9223372036854775807)
+
+reveal_type(Big.A.value)  # revealed: Literal[9223372036854775807]
+reveal_type(Big.B.value)  # revealed: int
+
+BigFlag = Flag("BigFlag", "X Y", start=4611686018427387904)
+
+reveal_type(BigFlag.X.value)  # revealed: Literal[4611686018427387904]
+reveal_type(BigFlag.Y.value)  # revealed: int
+```
+
 ## Exhaustiveness checking
 
 ## `if` statements

crates/ty_python_semantic/src/types/class/enum_literal.rs

@@ -102,8 +102,8 @@ impl<'db> DynamicEnumLiteral<'db> {
         Span::from(self.scope(db).file(db)).with_range(self.header_range(db))
     }
 
+    #[expect(clippy::unused_self)]
     pub(crate) fn metaclass(self, db: &'db dyn Db) -> Type<'db> {
-        let _ = self;
         KnownClass::EnumType.to_class_literal(db)
     }
 

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

@@ -1,12 +1,13 @@
 use ruff_python_ast::name::Name;
-use ruff_python_ast::{self as ast, NodeIndex};
+use ruff_python_ast::{self as ast, NodeIndex, PythonVersion};
 
 use crate::{
-    Db,
+    Db, Program,
     semantic_index::definition::Definition,
     types::{
         ClassLiteral, KnownClass, Type, TypeContext,
         class::{DynamicEnumAnchor, DynamicEnumLiteral, EnumSpec},
+        diagnostic::{INVALID_ARGUMENT_TYPE, TOO_MANY_POSITIONAL_ARGUMENTS, UNKNOWN_ARGUMENT},
         infer::TypeInferenceBuilder,
         subclass_of::SubclassOfType,
     },
@@ -43,9 +44,24 @@ fn enum_auto_value<'db>(
     match base_class {
         KnownClass::StrEnum => Type::string_literal(db, &name.to_lowercase()),
         KnownClass::Flag | KnownClass::IntFlag => {
-            Type::int_literal(start << i64::try_from(index).unwrap_or(0))
+            let shift = i64::try_from(index).ok();
+            let headroom = if start >= 0 {
+                start.leading_zeros().saturating_sub(1)
+            } else {
+                start.leading_ones().saturating_sub(1)
+            };
+            shift
+                .and_then(|s| u32::try_from(s).ok())
+                .filter(|&s| s <= headroom)
+                .and_then(|s| start.checked_shl(s))
+                .map(Type::int_literal)
+                .unwrap_or_else(|| KnownClass::Int.to_instance(db))
         }
-        _ => Type::int_literal(start + i64::try_from(index).unwrap_or(0)),
+        _ => i64::try_from(index)
+            .ok()
+            .and_then(|i| start.checked_add(i))
+            .map(Type::int_literal)
+            .unwrap_or_else(|| KnownClass::Int.to_instance(db)),
     }
 }
 
@@ -69,10 +85,17 @@ fn dict_auto_value<'db>(
             if last_int_value <= 0 {
                 Type::int_literal(1)
             } else {
-                Type::int_literal(1 << (i64::BITS - last_int_value.leading_zeros()))
+                let shift = i64::BITS - last_int_value.leading_zeros();
+                1_i64
+                    .checked_shl(shift)
+                    .map(Type::int_literal)
+                    .unwrap_or_else(|| KnownClass::Int.to_instance(db))
             }
         }
-        _ => Type::int_literal(last_int_value + 1),
+        _ => last_int_value
+            .checked_add(1)
+            .map(Type::int_literal)
+            .unwrap_or_else(|| KnownClass::Int.to_instance(db)),
     }
 }
 
@@ -87,17 +110,24 @@ impl<'db> TypeInferenceBuilder<'db, '_> {
         let args = &call_expr.arguments.args;
         let keywords = &call_expr.arguments.keywords;
 
-        // bail out on unknown keywords so normal overload resolution can diagnose them
-        let has_unknown_keyword = keywords.iter().any(|kw| {
-            kw.arg.as_ref().is_some_and(|name| {
-                !matches!(
+        let base_name = base_class.name(db);
+        let python_version = Program::get(db).python_version(db);
+
+        for kw in keywords {
+            if let Some(name) = &kw.arg {
+                let is_valid_keyword = matches!(
                     name.as_str(),
-                    "value" | "names" | "start" | "type" | "module" | "qualname" | "boundary"
-                )
-            })
-        });
-        if has_unknown_keyword {
-            return None;
+                    "value" | "names" | "start" | "type" | "module" | "qualname"
+                ) || (name.as_str() == "boundary"
+                    && python_version >= PythonVersion::PY311);
+                if !is_valid_keyword {
+                    if let Some(builder) = self.context.report_lint(&UNKNOWN_ARGUMENT, kw) {
+                        builder.into_diagnostic(format_args!(
+                            "Argument `{name}` does not match any known parameter of function `{base_name}`",
+                        ));
+                    }
+                }
+            }
         }
 
         let value_kw = call_expr.arguments.find_keyword("value");
@@ -131,6 +161,18 @@ impl<'db> TypeInferenceBuilder<'db, '_> {
         // Non-literal name: return type[base_class] without creating a
         // DynamicEnumLiteral. This matches the typeshed overload return type.
         if !name_arg.is_string_literal_expr() {
+            let name_type = self.expression_type(name_arg);
+            if !name_type.is_assignable_to(db, KnownClass::Str.to_instance(db))
+                && let Some(builder) = self.context.report_lint(&INVALID_ARGUMENT_TYPE, name_arg)
+            {
+                let mut diagnostic = builder.into_diagnostic(format_args!(
+                    "Invalid argument to parameter `value` of `{base_name}()`"
+                ));
+                diagnostic.set_primary_message(format_args!(
+                    "Expected `str`, found `{}`",
+                    name_type.display(db)
+                ));
+            }
             return SubclassOfType::try_from_type(db, base_class.to_class_literal(db));
         }
 
@@ -151,6 +193,17 @@ impl<'db> TypeInferenceBuilder<'db, '_> {
         // Only 1 extra positional arg is allowed (the `names` parameter).
         // `Enum("Color", "RED", "GREEN")` is invalid at runtime.
         let has_too_many_positional = args.len() > 2;
+        if has_too_many_positional {
+            if let Some(builder) = self
+                .context
+                .report_lint(&TOO_MANY_POSITIONAL_ARGUMENTS, &args[2])
+            {
+                builder.into_diagnostic(format_args!(
+                    "Too many positional arguments to function `{base_name}`: expected 2, got {}",
+                    args.len(),
+                ));
+            }
+        }
 
         // without `names`, this is a value-lookup call, not functional enum creation
         let names_arg = names_arg?;