Improve organization of and add comments to class_metadata_of.

Summary: This is my last change (for now) to `class_metadata_of` - now that it's smaller and easier to understand, organize it into commented sections.

Reviewed By: grievejia

Differential Revision: D80373735

fbshipit-source-id: 911753c99e40a8ab4203fff4bcb998cd5c5977b5

Author: rchen152

pyrefly/lib/alt/class/class_metadata.rs

@@ -102,9 +102,13 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         pydantic_metadata_binding: &PydanticMetadataBinding,
         errors: &ErrorCollector,
     ) -> ClassMetadata {
+        // Get class decorators.
         let decorators = decorators.map(|(decorator_key, decorator_range)| {
             (self.get_idx(*decorator_key), *decorator_range)
         });
+
+        // Get full base class list and compute data that depends on the `BaseClass` representation
+        // of base classes.
         let bases = if let Some(special_base) = special_base {
             bases
                 .iter()
@@ -118,6 +122,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         let has_generic_base_class = bases.iter().any(|x| x.is_generic());
         let has_typed_dict_base_class = bases.iter().any(|x| x.is_typed_dict());
 
+        // Parse base classes and compute data that depends on the `BaseClassParseResult`
+        // representation of base classes.
         let parsed_results = bases
             .into_iter()
             .map(|x| self.parse_base_class(x, is_new_type))
@@ -129,44 +135,16 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             &parsed_results,
             errors,
         );
+
+        // Compute base classes with metadata.
         let bases_with_metadata = self.bases_with_metadata(parsed_results, is_new_type, errors);
-        let has_base_any = contains_base_class_any
-            || bases_with_metadata
-                .iter()
-                .any(|(_, metadata)| metadata.has_base_any());
 
-        let named_tuple_metadata = self.named_tuple_metadata(cls, &bases_with_metadata, errors);
-        if named_tuple_metadata.is_some() && bases_with_metadata.len() > 1 {
-            self.error(
-                errors,
-                cls.range(),
-                ErrorInfo::Kind(ErrorKind::InvalidInheritance),
-                "Named tuples do not support multiple inheritance".to_owned(),
-            );
-        }
+        // Compute class keywords, including the metaclass.
         let (metaclasses, keywords): (Vec<_>, Vec<(_, _)>) =
             keywords.iter().partition_map(|(n, x)| match n.as_str() {
                 "metaclass" => Either::Left(x),
                 _ => Either::Right((n.clone(), self.expr_infer(x, errors))),
             });
-        let pydantic_metadata =
-            self.pydantic_metadata(&bases_with_metadata, pydantic_metadata_binding);
-
-        let is_typed_dict = has_typed_dict_base_class
-            || bases_with_metadata
-                .iter()
-                .any(|(_, metadata)| metadata.is_typed_dict());
-        if is_typed_dict
-            && let Some(bad) = bases_with_metadata.iter().find(|x| !x.1.is_typed_dict())
-        {
-            self.error(errors,
-                cls.range(),
-                ErrorInfo::Kind(ErrorKind::InvalidInheritance),
-                format!("`{}` is not a typed dictionary. Typed dictionary definitions may only extend other typed dictionaries.", bad.0.name()),
-            );
-        }
-        let typed_dict_metadata =
-            self.typed_dict_metadata(cls, &bases_with_metadata, &keywords, is_typed_dict, errors);
         let base_metaclasses = bases_with_metadata
             .iter()
             .filter_map(|(b, metadata)| metadata.metaclass().map(|m| (b.name(), m)))
@@ -177,18 +155,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             &base_metaclasses,
             errors,
         );
-        let enum_metadata =
-            self.enum_metadata(cls, metaclass.as_ref(), &bases_with_metadata, errors);
         if let Some(metaclass) = &metaclass {
             self.check_base_class_metaclasses(cls, metaclass, &base_metaclasses, errors);
-            if is_typed_dict {
-                self.error(
-                    errors,
-                    cls.range(),
-                    ErrorInfo::Kind(ErrorKind::InvalidInheritance),
-                    "Typed dictionary definitions may not specify a metaclass".to_owned(),
-                );
-            }
             if metaclass.targs().as_slice().iter().any(|targ| {
                 targ.any(|ty| {
                     matches!(
@@ -205,9 +173,57 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 );
             }
         }
+
+        // Compute various pieces of special metadata.
+        let has_base_any = contains_base_class_any
+            || bases_with_metadata
+                .iter()
+                .any(|(_, metadata)| metadata.has_base_any());
+
+        let named_tuple_metadata = self.named_tuple_metadata(cls, &bases_with_metadata, errors);
+        if named_tuple_metadata.is_some() && bases_with_metadata.len() > 1 {
+            self.error(
+                errors,
+                cls.range(),
+                ErrorInfo::Kind(ErrorKind::InvalidInheritance),
+                "Named tuples do not support multiple inheritance".to_owned(),
+            );
+        }
+
+        let pydantic_metadata =
+            self.pydantic_metadata(&bases_with_metadata, pydantic_metadata_binding);
+
+        let is_typed_dict = has_typed_dict_base_class
+            || bases_with_metadata
+                .iter()
+                .any(|(_, metadata)| metadata.is_typed_dict());
+        if is_typed_dict
+            && let Some(bad) = bases_with_metadata.iter().find(|x| !x.1.is_typed_dict())
+        {
+            self.error(errors,
+                cls.range(),
+                ErrorInfo::Kind(ErrorKind::InvalidInheritance),
+                format!("`{}` is not a typed dictionary. Typed dictionary definitions may only extend other typed dictionaries.", bad.0.name()),
+            );
+        }
+        let typed_dict_metadata =
+            self.typed_dict_metadata(cls, &bases_with_metadata, &keywords, is_typed_dict, errors);
+        if metaclass.is_some() && is_typed_dict {
+            self.error(
+                errors,
+                cls.range(),
+                ErrorInfo::Kind(ErrorKind::InvalidInheritance),
+                "Typed dictionary definitions may not specify a metaclass".to_owned(),
+            );
+        }
+
+        let enum_metadata =
+            self.enum_metadata(cls, metaclass.as_ref(), &bases_with_metadata, errors);
+
         let is_final = decorators.iter().any(|(decorator, _)| {
             decorator.ty().callee_kind() == Some(CalleeKind::Function(FunctionKind::Final))
         });
+
         let total_ordering_metadata = decorators.iter().find_map(|(decorator, decorator_range)| {
             decorator.ty().callee_kind().and_then(|kind| {
                 if kind == CalleeKind::Function(FunctionKind::TotalOrdering) {
@@ -219,6 +235,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 }
             })
         });
+
         // If this class inherits from a dataclass_transform-ed class, record the defaults that we
         // should use for dataclass parameters.
         let dataclass_defaults_from_base_class = bases_with_metadata
@@ -245,6 +262,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             self.validate_frozen_dataclass_inheritance(cls, dm, &bases_with_metadata, errors);
         }
 
+        // Compute final base class list.
         let bases = if is_typed_dict && bases_with_metadata.is_empty() {
             // This is a "fallback" class that contains attributes that are available on all TypedDict subclasses.
             // Note that this also makes those attributes available on *instances* of said subclasses; this is