Simplify the creation of type variables in populate_table_visitor.cc

This buries the mechanics of creating type variables behind some helper functions without changing the logic, except that we now have more descriptive variable names generated.

This change also exposed a type_info_to_proto test case with an internal variable erroneously in the output, which is fixed here.

PiperOrigin-RevId: 809151498

Author: richmckeever

xls/dslx/frontend/ast.cc

@@ -1069,9 +1069,10 @@ std::string TypeRefTypeAnnotation::ToString() const {
 // -- class TypeVariableTypeAnnotation
 
 TypeVariableTypeAnnotation::TypeVariableTypeAnnotation(
-    Module* owner, const NameRef* type_variable)
+    Module* owner, const NameRef* type_variable, bool internal)
     : TypeAnnotation(owner, type_variable->span(), kAnnotationKind),
-      type_variable_(type_variable) {}
+      type_variable_(type_variable),
+      internal_(internal) {}
 
 std::string TypeVariableTypeAnnotation::ToString() const {
   return absl::StrCat("TypeVariableTypeAnnotation: ",

xls/dslx/frontend/ast.h

@@ -513,15 +513,17 @@ class TypeVariableTypeAnnotation : public TypeAnnotation {
   static constexpr TypeAnnotationKind kAnnotationKind =
       TypeAnnotationKind::kTypeVariable;
 
-  explicit TypeVariableTypeAnnotation(Module* owner,
-                                      const NameRef* type_variable);
+  TypeVariableTypeAnnotation(Module* owner, const NameRef* type_variable,
+                             bool internal = true);
 
   // Returns a `NameRef` for the type variable indicated by this annotation. The
   // variable may be a type parametric or an internally-defined type variable.
   const NameRef* type_variable() const { return type_variable_; }
 
   std::string ToString() const override;
 
+  bool internal() const { return internal_; }
+
   std::string_view GetNodeTypeName() const override {
     return "TypeVariableTypeAnnotation";
   }
@@ -538,6 +540,7 @@ class TypeVariableTypeAnnotation : public TypeAnnotation {
 
  private:
   const NameRef* const type_variable_;
+  bool internal_;
 };
 
 // Represents the type of a member of a struct, like

xls/dslx/frontend/module.h

@@ -36,6 +36,7 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_split.h"
 #include "absl/types/span.h"
+#include "xls/common/casts.h"
 #include "xls/dslx/frontend/ast.h"
 #include "xls/dslx/frontend/pos.h"
 #include "xls/dslx/frontend/proc.h"
@@ -198,11 +199,22 @@ class Module : public AstNode {
   // internal nodes in some contexts, e.g. in language server adapter
   // functionality.
   bool IsSyntheticNode(const AstNode* node) const {
-    // Note that ColonRef is a special case here, because when it's the
-    // definition in a `TypeRef`, the parser actually creates it as a
-    // disconnected node.
-    return node->parent() == nullptr &&
-           node->kind() != AstNodeKind::kColonRef && !top_set_.contains(node);
+    // It's synthetic if it's a top-level node that is not in the top set (the
+    // set is populated by the parser). Note that ColonRef is a special case
+    // here, because when it's the definition in a `TypeRef`, the parser
+    // actually creates it as a disconnected node.
+    if (node->parent() == nullptr && node->kind() != AstNodeKind::kColonRef &&
+        !top_set_.contains(node)) {
+      return true;
+    }
+
+    // It's synthetic if it's an internally-generated TVTA. Note that there are
+    // user-written TVTAs, which are entities whose type is a `T: type` kind of
+    // parametric, and these are not marked internal.
+    return node->kind() == AstNodeKind::kTypeAnnotation &&
+           down_cast<const TypeAnnotation*>(node)->annotation_kind() ==
+               TypeAnnotationKind::kTypeVariable &&
+           down_cast<const TypeVariableTypeAnnotation*>(node)->internal();
   }
 
   // Finds the first top-level member in top() with the given "target" name as

xls/dslx/frontend/parser.cc

@@ -1096,7 +1096,8 @@ absl::StatusOr<TypeRefOrAnnotation> Parser::ParseTypeRef(Bindings& bindings,
               << name_def->definer()->ToString();
 
       return module_->Make<TypeVariableTypeAnnotation>(
-          module_->Make<NameRef>(tok.span(), name_def->identifier(), name_def));
+          module_->Make<NameRef>(tok.span(), name_def->identifier(), name_def),
+          /*internal=*/false);
     }
   }
   if (!IsOneOf<TypeAlias, EnumDef, StructDef, ProcDef, UseTreeEntry>(

xls/dslx/type_system/testdata/type_info_to_proto_test_v2_BitsConstructorTypeProto.txt

@@ -26,8 +26,8 @@
 5:23-5:28: TYPE_ANNOTATION :: `u2[2]` :: typeof(uN[2][2])
 5:26-5:27: NUMBER :: `2` :: uN[32]
 5:29-5:35: ARRAY :: `u2[2]:[1, 1]` :: uN[2][2]
-5:29-5:35: TYPE_ANNOTATION :: `TypeVariableTypeAnnotation: internal_type_expr_at_fake.x:6:30-6:36_in_fake_actual_arg_0` :: typeof(uN[2])
-5:29-5:35: TYPE_ANNOTATION :: `TypeVariableTypeAnnotation: internal_type_expr_at_fake.x:6:30-6:36_in_fake_actual_arg_0` :: typeof(uN[2])
+5:29-5:35: TYPE_ANNOTATION :: `u2` :: typeof(uN[2])
+5:29-5:35: TYPE_ANNOTATION :: `u2` :: typeof(uN[2])
 5:30-5:31: NUMBER :: `1` :: uN[2]
 5:33-5:34: NUMBER :: `1` :: uN[2]
 5:37-5:41: TYPE_ANNOTATION :: `bool` :: typeof(uN[1])