actually use EnumValueId instead of bare u32s / usizes

psl/parser-database/src/attributes.rs

@@ -81,14 +81,13 @@ fn resolve_composite_type_attributes<'db>(
 fn resolve_enum_attributes<'db>(enum_id: crate::EnumId, ast_enum: &'db ast::Enum, ctx: &mut Context<'db>) {
     let mut enum_attributes = EnumAttributes::default();
 
-    for value_idx in 0..ast_enum.values.len() {
-        ctx.visit_attributes((enum_id.0, (enum_id.1, value_idx as u32)));
+    for (value_id, _) in ast_enum.iter_values() {
+        ctx.visit_attributes((enum_id.0, (enum_id.1, value_id)));
         // @map
         if ctx.visit_optional_single_attr("map") {
             if let Some(mapped_name) = map::visit_map_attribute(ctx) {
-                enum_attributes.mapped_values.insert(value_idx as u32, mapped_name);
-                ctx.mapped_enum_value_names
-                    .insert((enum_id, mapped_name), value_idx as u32);
+                enum_attributes.mapped_values.insert(value_id, mapped_name);
+                ctx.mapped_enum_value_names.insert((enum_id, mapped_name), value_id);
             }
             ctx.validate_visited_arguments();
         }

psl/parser-database/src/context.rs

@@ -5,7 +5,7 @@ use crate::{
     ast, interner::StringInterner, names::Names, relations::Relations, types::Types, DatamodelError, Diagnostics,
     InFile, StringId,
 };
-use schema_ast::ast::{Expression, WithName};
+use schema_ast::ast::{EnumValueId, Expression, WithName};
 use std::collections::{HashMap, HashSet};
 
 /// Validation context. This is an implementation detail of ParserDatabase. It
@@ -33,7 +33,7 @@ pub(crate) struct Context<'db> {
     pub(super) mapped_model_scalar_field_names: HashMap<(crate::ModelId, StringId), ast::FieldId>,
     pub(super) mapped_composite_type_names: HashMap<(crate::CompositeTypeId, StringId), ast::FieldId>,
     pub(super) mapped_enum_names: HashMap<StringId, crate::EnumId>,
-    pub(super) mapped_enum_value_names: HashMap<(crate::EnumId, StringId), u32>,
+    pub(super) mapped_enum_value_names: HashMap<(crate::EnumId, StringId), EnumValueId>,
 }
 
 impl<'db> Context<'db> {

psl/parser-database/src/types.rs

@@ -4,7 +4,7 @@ use crate::{context::Context, interner::StringId, walkers::IndexFieldWalker, Dat
 use either::Either;
 use enumflags2::bitflags;
 use rustc_hash::FxHashMap as HashMap;
-use schema_ast::ast::{self, WithName};
+use schema_ast::ast::{self, EnumValueId, WithName};
 use std::{collections::BTreeMap, fmt};
 
 pub(super) fn resolve_types(ctx: &mut Context<'_>) {
@@ -623,7 +623,7 @@ pub struct FieldWithArgs {
 pub(super) struct EnumAttributes {
     pub(super) mapped_name: Option<StringId>,
     /// @map on enum values.
-    pub(super) mapped_values: HashMap<u32, StringId>,
+    pub(super) mapped_values: HashMap<EnumValueId, StringId>,
     /// ```ignore
     /// @@schema("public")
     ///          ^^^^^^^^

psl/parser-database/src/walkers/enum.rs

@@ -7,7 +7,7 @@ use crate::{
 /// An `enum` declaration in the schema.
 pub type EnumWalker<'db> = Walker<'db, crate::EnumId>;
 /// One value in an `enum` declaration in the schema.
-pub type EnumValueWalker<'db> = Walker<'db, (crate::EnumId, usize)>;
+pub type EnumValueWalker<'db> = Walker<'db, (crate::EnumId, ast::EnumValueId)>;
 
 impl<'db> EnumWalker<'db> {
     fn attributes(self) -> &'db types::EnumAttributes {
@@ -45,9 +45,16 @@ impl<'db> EnumWalker<'db> {
         self.attributes().mapped_name.map(|id| &self.db[id])
     }
 
+    /// Returns the specific value from the model.
+    pub fn value(self, value_id: ast::EnumValueId) -> EnumValueWalker<'db> {
+        self.walk((self.id, value_id.into()))
+    }
+
     /// The values of the enum.
     pub fn values(self) -> impl ExactSizeIterator<Item = EnumValueWalker<'db>> {
-        (0..self.ast_enum().values.len()).map(move |idx| self.walk((self.id, idx)))
+        self.ast_enum()
+            .iter_values()
+            .map(move |(value_id, _)| self.walk((self.id, value_id)))
     }
 
     /// How fields are indented in the enum.
@@ -79,18 +86,19 @@ impl<'db> EnumWalker<'db> {
 }
 
 impl<'db> EnumValueWalker<'db> {
-    fn r#enum(self) -> EnumWalker<'db> {
-        self.walk(self.id.0)
+    /// The AST node.
+    pub fn ast_value(self) -> &'db ast::EnumValue {
+        &self.db.asts[self.id.0][self.id.1]
     }
 
     /// The enum documentation
     pub fn documentation(self) -> Option<&'db str> {
-        self.r#enum().ast_enum().values[self.id.1].documentation()
+        self.ast_value().documentation()
     }
 
     /// The name of the value.
     pub fn name(self) -> &'db str {
-        &self.r#enum().ast_enum().values[self.id.1].name.name
+        self.ast_value().name()
     }
 
     /// The database name of the enum.
@@ -111,7 +119,7 @@ impl<'db> EnumValueWalker<'db> {
     pub fn mapped_name(self) -> Option<&'db str> {
         self.db.types.enum_attributes[&self.id.0]
             .mapped_values
-            .get(&(self.id.1 as u32))
+            .get(&(self.id.1))
             .map(|id| &self.db[*id])
     }
 }

psl/schema-ast/src/ast/attribute.rs

@@ -1,4 +1,4 @@
-use super::{ArgumentsList, Identifier, Span, WithIdentifier, WithSpan};
+use super::{ArgumentsList, EnumValueId, Identifier, Span, WithIdentifier, WithSpan};
 use std::ops::Index;
 
 /// An attribute (following `@` or `@@``) on a model, model field, enum, enum value or composite
@@ -51,7 +51,7 @@ pub enum AttributeContainer {
     Model(super::ModelId),
     ModelField(super::ModelId, super::FieldId),
     Enum(super::EnumId),
-    EnumValue(super::EnumId, u32),
+    EnumValue(super::EnumId, super::EnumValueId),
     CompositeTypeField(super::CompositeTypeId, super::FieldId),
 }
 
@@ -79,8 +79,8 @@ impl From<(super::CompositeTypeId, super::FieldId)> for AttributeContainer {
     }
 }
 
-impl From<(super::EnumId, u32)> for AttributeContainer {
-    fn from((enm, val): (super::EnumId, u32)) -> Self {
+impl From<(super::EnumId, EnumValueId)> for AttributeContainer {
+    fn from((enm, val): (super::EnumId, super::EnumValueId)) -> Self {
         Self::EnumValue(enm, val)
     }
 }
@@ -103,7 +103,7 @@ impl Index<AttributeContainer> for super::SchemaAst {
             AttributeContainer::Model(model_id) => &self[model_id].attributes,
             AttributeContainer::ModelField(model_id, field_id) => &self[model_id][field_id].attributes,
             AttributeContainer::Enum(enum_id) => &self[enum_id].attributes,
-            AttributeContainer::EnumValue(enum_id, value_idx) => &self[enum_id].values[value_idx as usize].attributes,
+            AttributeContainer::EnumValue(enum_id, value_idx) => &self[enum_id][value_idx].attributes,
             AttributeContainer::CompositeTypeField(ctid, field_id) => &self[ctid][field_id].attributes,
         }
     }