[ty] Add Flag and IntFlag support

crates/ty_python_semantic/src/types.rs

@@ -4243,6 +4243,13 @@ impl<'db> Type<'db> {
             }
         }
 
+        if let Some(length) = self
+            .as_enum_literal()
+            .and_then(|literal| enums::flag_literal_len(db, literal))
+        {
+            return Some(Type::int_literal(length));
+        }
+
         let return_ty = match self.try_call_dunder(
             db,
             "__len__",
@@ -5144,6 +5151,7 @@ impl<'db> Type<'db> {
             .to_class_literal(db)
             .to_class_type(db)
             .is_some_and(|enum_class| class.is_subclass_of(db, enum_class))
+            && enums::enum_uses_standard_metaclass_call(db, class_literal)
         {
             return fallback_bindings();
         }

crates/ty_python_semantic/src/types/bool.rs

@@ -7,7 +7,8 @@ use crate::{
         CallArguments, CallDunderError, ClassType, CycleDetector, KnownClass, KnownInstanceType,
         LiteralValueTypeKind, SubclassOfInner, Type, TypeContext, TypeVarBoundOrConstraints,
         UnionType, call::CallErrorKind, constraints::ConstraintSetBuilder, context::InferContext,
-        diagnostic::UNSUPPORTED_BOOL_CONVERSION, typed_dict::TypedDictField,
+        diagnostic::UNSUPPORTED_BOOL_CONVERSION, enums::flag_literal_truthiness,
+        typed_dict::TypedDictField,
     },
 };
 use ty_python_core::Truthiness;
@@ -306,9 +307,17 @@ impl<'db> Type<'db> {
 
             Type::LiteralValue(literal) => match literal.kind() {
                 LiteralValueTypeKind::LiteralString => Truthiness::Ambiguous,
-                LiteralValueTypeKind::Enum(enum_type) => enum_type
-                    .enum_class_instance(db)
-                    .try_bool_impl(db, allow_short_circuit, visitor)?,
+                LiteralValueTypeKind::Enum(enum_type) => {
+                    if let Some(truthiness) = flag_literal_truthiness(db, enum_type) {
+                        Truthiness::from(truthiness)
+                    } else {
+                        enum_type.enum_class_instance(db).try_bool_impl(
+                            db,
+                            allow_short_circuit,
+                            visitor,
+                        )?
+                    }
+                }
 
                 LiteralValueTypeKind::Int(num) => Truthiness::from(num.as_i64() != 0),
                 LiteralValueTypeKind::Bool(bool) => Truthiness::from(bool),

crates/ty_python_semantic/src/types/call/bind.rs

@@ -2065,12 +2065,12 @@ impl<'db> Bindings<'db> {
                             if let [Some(ty)] = overload.parameter_types() {
                                 let return_ty = match ty {
                                     Type::ClassLiteral(class) => {
-                                        if let Some(metadata) = enums::enum_metadata(db, *class) {
+                                        if let Some(metadata) = enums::enum_metadata(db, *class)
+                                            && let Some(members) = metadata.canonical_member_names()
+                                        {
                                             Type::heterogeneous_tuple(
                                                 db,
-                                                metadata
-                                                    .members
-                                                    .keys()
+                                                members
                                                     .map(|member| Type::string_literal(db, member)),
                                             )
                                         } else {

crates/ty_python_semantic/src/types/class.rs

@@ -23,7 +23,7 @@ use crate::types::callable::{CallableFunctionProvenance, CallableTypeKind};
 use crate::types::constraints::{
     ConstraintSet, ConstraintSetBuilder, IteratorConstraintsExtension,
 };
-use crate::types::enums::enum_metadata;
+use crate::types::enums::{enum_metadata, enum_uses_standard_metaclass_call};
 use crate::types::function::{AbstractMethodKind, DataclassTransformerParams};
 use crate::types::generics::{
     GenericContext, InferableTypeVars, Specialization, walk_specialization,
@@ -1985,7 +1985,7 @@ impl<'db> ClassType<'db> {
             // `Color("red")`, instead of the overloaded signature of `EnumMeta.__call__` which also accounts
             // for dynamic Enum creation.
             let is_actual_enum = enum_metadata(db, self.class_literal(db)).is_some();
-            if !is_actual_enum {
+            if !is_actual_enum || !enum_uses_standard_metaclass_call(db, self.class_literal(db)) {
                 return CallableTypes::one(metaclass_dunder_call_function.into_callable_type(db));
             }
         }

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

@@ -10,6 +10,7 @@ use crate::types::Type;
 use crate::types::class::known::KnownClass;
 use crate::types::class::{ClassLiteral, ClassType, MemberLookupPolicy};
 use crate::types::class_base::ClassBase;
+use crate::types::enums::FlagBoundary;
 use crate::types::member::Member;
 use crate::types::mro::{DynamicMroError, Mro};
 use ty_python_core::definition::Definition;
@@ -21,6 +22,7 @@ pub struct EnumSpec<'db> {
     #[returns(deref)]
     pub(crate) members: Box<[(Name, Type<'db>)]>,
     pub(crate) has_known_members: bool,
+    pub(crate) boundary: FlagBoundary,
 }
 
 impl<'db> EnumSpec<'db> {
@@ -40,7 +42,12 @@ impl<'db> EnumSpec<'db> {
             })
             .collect::<Option<Box<_>>>()?;
 
-        Some(Self::new(db, members, self.has_known_members(db)))
+        Some(Self::new(
+            db,
+            members,
+            self.has_known_members(db),
+            self.boundary(db),
+        ))
     }
 }