handle invalid identifiers

Author: AlexWaygood

crates/ty_python_semantic/resources/mdtest/narrow/hasattr.md

@@ -0,0 +1,26 @@
+# Narrowing using `hasattr()`
+
+The builtin function `hasattr()` can be used to narrow nominal and structural types. This is
+accomplished using an intersection with a synthesized protocol:
+
+```py
+from typing import final
+
+class Foo: ...
+
+@final
+class Bar: ...
+
+def f(x: Foo):
+    if hasattr(x, "spam"):
+        reveal_type(x)  # revealed: Foo & <Protocol with members 'spam'>
+        reveal_type(x.spam)  # revealed: object
+
+    if hasattr(x, "not-an-identifier"):
+        reveal_type(x)  # revealed: Foo
+
+def y(x: Bar):
+    if hasattr(x, "spam"):
+        reveal_type(x)  # revealed: Never
+        reveal_type(x.spam)  # revealed: Never
+```

crates/ty_python_semantic/src/types/narrow.rs

@@ -11,6 +11,9 @@ use crate::types::{
     UnionBuilder,
 };
 use crate::Db;
+
+use ruff_python_stdlib::identifiers::is_identifier;
+
 use itertools::Itertools;
 use ruff_python_ast as ast;
 use ruff_python_ast::{BoolOp, ExprBoolOp};
@@ -718,11 +721,16 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
                 if function == KnownFunction::HasAttr {
                     let attr = inference
                         .expression_type(second_arg.scoped_expression_id(self.db, scope))
-                        .into_string_literal()?;
+                        .into_string_literal()?
+                        .value(self.db);
+
+                    if !is_identifier(attr) {
+                        return None;
+                    }
 
                     let constraint = Type::synthesized_protocol(
                         self.db,
-                        [(attr.value(self.db), KnownClass::Object.to_instance(self.db))],
+                        [(attr, KnownClass::Object.to_instance(self.db))],
                     );
 
                     return Some(NarrowingConstraints::from_iter([(