[ty] Implement the legacy PEP-484 convention for indicating positional-only parameters (#20248)

Co-authored-by: Carl Meyer <carl@astral.sh>

crates/ty_python_semantic/src/semantic_index/builder.rs

@@ -2644,7 +2644,7 @@ impl SemanticSyntaxContext for SemanticIndexBuilder<'_, '_> {
             match scope.kind() {
                 ScopeKind::Class | ScopeKind::Lambda => return false,
                 ScopeKind::Function => {
-                    return scope.node().expect_function(self.module).is_async;
+                    return scope.node().expect_function().node(self.module).is_async;
                 }
                 ScopeKind::Comprehension
                 | ScopeKind::Module

crates/ty_python_semantic/src/semantic_index/definition.rs

@@ -1227,3 +1227,12 @@ impl From<&ast::TypeParamTypeVarTuple> for DefinitionNodeKey {
         Self(NodeKey::from_node(value))
     }
 }
+
+impl<T> From<&AstNodeRef<T>> for DefinitionNodeKey
+where
+    for<'a> &'a T: Into<DefinitionNodeKey>,
+{
+    fn from(value: &AstNodeRef<T>) -> Self {
+        Self(NodeKey::from_node_ref(value))
+    }
+}

crates/ty_python_semantic/src/semantic_index/scope.rs

@@ -397,52 +397,38 @@ impl NodeWithScopeKind {
         }
     }
 
-    pub(crate) fn expect_class<'ast>(
-        &self,
-        module: &'ast ParsedModuleRef,
-    ) -> &'ast ast::StmtClassDef {
+    pub(crate) fn as_class(&self) -> Option<&AstNodeRef<ast::StmtClassDef>> {
         match self {
-            Self::Class(class) => class.node(module),
-            _ => panic!("expected class"),
-        }
-    }
-
-    pub(crate) fn as_class<'ast>(
-        &self,
-        module: &'ast ParsedModuleRef,
-    ) -> Option<&'ast ast::StmtClassDef> {
-        match self {
-            Self::Class(class) => Some(class.node(module)),
+            Self::Class(class) => Some(class),
             _ => None,
         }
     }
 
-    pub(crate) fn expect_function<'ast>(
-        &self,
-        module: &'ast ParsedModuleRef,
-    ) -> &'ast ast::StmtFunctionDef {
-        self.as_function(module).expect("expected function")
+    pub(crate) fn expect_class(&self) -> &AstNodeRef<ast::StmtClassDef> {
+        self.as_class().expect("expected class")
     }
 
-    pub(crate) fn expect_type_alias<'ast>(
-        &self,
-        module: &'ast ParsedModuleRef,
-    ) -> &'ast ast::StmtTypeAlias {
+    pub(crate) fn as_function(&self) -> Option<&AstNodeRef<ast::StmtFunctionDef>> {
         match self {
-            Self::TypeAlias(type_alias) => type_alias.node(module),
-            _ => panic!("expected type alias"),
-        }
-    }
-
-    pub(crate) fn as_function<'ast>(
-        &self,
-        module: &'ast ParsedModuleRef,
-    ) -> Option<&'ast ast::StmtFunctionDef> {
-        match self {
-            Self::Function(function) => Some(function.node(module)),
+            Self::Function(function) => Some(function),
             _ => None,
         }
     }
+
+    pub(crate) fn expect_function(&self) -> &AstNodeRef<ast::StmtFunctionDef> {
+        self.as_function().expect("expected function")
+    }
+
+    pub(crate) fn as_type_alias(&self) -> Option<&AstNodeRef<ast::StmtTypeAlias>> {
+        match self {
+            Self::TypeAlias(type_alias) => Some(type_alias),
+            _ => None,
+        }
+    }
+
+    pub(crate) fn expect_type_alias(&self) -> &AstNodeRef<ast::StmtTypeAlias> {
+        self.as_type_alias().expect("expected type alias")
+    }
 }
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, get_size2::GetSize)]