[ty] Detect illegal non-enum attribute accesses in Literal annotation

crates/ty_python_semantic/resources/mdtest/annotations/literal.md

@@ -51,6 +51,13 @@ invalid4: Literal[
     hello,  # error: [invalid-type-form]
     (1, 2, 3),  # error: [invalid-type-form]
 ]
+
+class NotAnEnum:
+    x: int = 1
+
+# error: [invalid-type-form]
+def _(invalid: Literal[NotAnEnum.x]) -> None:
+    reveal_type(invalid)  # revealed: Unknown
 ```
 
 ## Shortening unions of literals

crates/ty_python_semantic/src/types/enums.rs

@@ -240,3 +240,10 @@ pub(crate) fn enum_member_literals<'a, 'db: 'a>(
 pub(crate) fn is_single_member_enum<'db>(db: &'db dyn Db, class: ClassLiteral<'db>) -> bool {
     enum_metadata(db, class).is_some_and(|metadata| metadata.members.len() == 1)
 }
+
+pub(crate) fn is_enum_class<'db>(db: &'db dyn Db, ty: Type<'db>) -> bool {
+    match ty {
+        Type::ClassLiteral(class_literal) => enum_metadata(db, class_literal).is_some(),
+        _ => false,
+    }
+}

crates/ty_python_semantic/src/types/infer.rs

@@ -102,6 +102,7 @@ use crate::types::diagnostic::{
     report_invalid_generator_function_return_type, report_invalid_return_type,
     report_possibly_unbound_attribute,
 };
+use crate::types::enums::{enum_metadata, is_enum_class};
 use crate::types::function::{
     FunctionDecorators, FunctionLiteral, FunctionType, KnownFunction, OverloadLiteral,
 };
@@ -10033,7 +10034,8 @@ impl<'db> TypeInferenceBuilder<'db, '_> {
             // For enum values
             ast::Expr::Attribute(ast::ExprAttribute { value, attr, .. }) => {
                 let value_ty = self.infer_expression(value);
-                // TODO: Check that value type is enum otherwise return None
+
+                if is_enum_class(self.db(), value_ty) {
                     let ty = value_ty
                         .member(self.db(), &attr.id)
                         .place
@@ -10041,6 +10043,10 @@ impl<'db> TypeInferenceBuilder<'db, '_> {
                         .unwrap_or(Type::unknown());
                     self.store_expression_type(parameters, ty);
                     ty
+                } else {
+                    self.store_expression_type(parameters, Type::unknown());
+                    return Err(vec![parameters]);
+                }
             }
             // for negative and positive numbers
             ast::Expr::UnaryOp(u)