fix: refuse type parameters a resource reaches through a proto record

Before planning, a proto-backed record is named by its proto type, so the walk for a resource's
type parameters stopped there. nexgen then wrote generic models for a resource class that isn't
generic, and the code didn't compile. The checks of the resource and of the operations that its
methods bind both walk through protos.

Author: moetemp

advanced/samples/invalid/type-parameters/generic-proto-resource-operation/expected.toml

@@ -0,0 +1,6 @@
+inputs = ["input.wit", "../../../inputs/deps"]
+descriptors = "temporal"
+
+[error]
+kind = "invalid-wit"
+contains = ["resource-bound operation `UpdateProvider` cannot use generic type parameters"]

advanced/samples/invalid/type-parameters/generic-proto-resource-operation/input.wit

@@ -0,0 +1,28 @@
+package temporal:nexus@1.0.0;
+
+world system { export compute-service; }
+
+// Only the operation that the method binds reaches the type parameter, through a proto record.
+/// @nexus.endpoint "compute"
+interface compute-service {
+  use nexus:temporal-types/model@1.0.0.{placeholder};
+
+  /// @nexus.type-parameter
+  type output-t = placeholder;
+
+  /// @nexus.proto "temporal.api.compute.v1.ComputeProvider"
+  record provider {
+    %type: string,
+    details: option<output-t>,
+    nexus-endpoint: string,
+  }
+
+  resource holder {
+    constructor(%type: string, nexus-endpoint: string);
+
+    /// @nexus.operation name="UpdateProvider"
+    update: func();
+  }
+
+  update-provider: func(request: provider);
+}

advanced/samples/invalid/type-parameters/generic-proto-resource/expected.toml

@@ -0,0 +1,6 @@
+inputs = ["input.wit", "../../../inputs/deps"]
+descriptors = "temporal"
+
+[error]
+kind = "invalid-wit"
+contains = ["resource `holder`", "cannot contain generic type parameters"]

advanced/samples/invalid/type-parameters/generic-proto-resource/input.wit

@@ -0,0 +1,27 @@
+package temporal:nexus@1.0.0;
+
+world system { export compute-service; }
+
+// The resource reaches the type parameter only through a proto-backed record.
+/// @nexus.endpoint "compute"
+interface compute-service {
+  use nexus:temporal-types/model@1.0.0.{placeholder};
+
+  /// @nexus.type-parameter
+  type output-t = placeholder;
+
+  /// @nexus.proto "temporal.api.compute.v1.ComputeProvider"
+  record provider {
+    /// @nexus.omit
+    %type: placeholder,
+    details: output-t,
+    /// @nexus.omit
+    nexus-endpoint: placeholder,
+  }
+
+  resource holder {
+    constructor(id: string);
+
+    update: func(provider: provider);
+  }
+}

changelog/fixed/marmalade-meerkat.md

@@ -0,0 +1 @@
+A resource that reaches a type parameter through a proto-backed record is refused, as one that reaches it through a plain record is.

src/planning/selected_validation.rs

@@ -106,18 +106,20 @@ fn validate_generic_model_semantics(spec: &ApiSpec<SelectedFamily>, path: &Path)
             }
         }
         for resource in &service.resources {
+            let is_generic = |value| !spec.type_parameters_through_protos(value).is_empty();
             let resource_is_generic = resource
                 .fields
                 .iter()
-                .any(|field| !spec.type_parameters(&field.field_type).is_empty())
+                .any(|field| is_generic(&field.field_type))
                 || resource.methods.iter().any(|method| {
                     method
                         .params
                         .iter()
-                        .any(|param| !spec.type_parameters(&param.field_type).is_empty())
-                        || method.result.as_ref().is_some_and(|result| {
-                            !spec.type_parameters(&result.result_type).is_empty()
-                        })
+                        .any(|param| is_generic(&param.field_type))
+                        || method
+                            .result
+                            .as_ref()
+                            .is_some_and(|result| is_generic(&result.result_type))
                 });
             if resource_is_generic {
                 return Err(invalid(format!(
@@ -133,12 +135,8 @@ fn validate_generic_model_semantics(spec: &ApiSpec<SelectedFamily>, path: &Path)
                 let Some(operation) = service.operation(operation_name) else {
                     continue;
                 };
-                let operation_is_generic = operation
-                    .input_type()
-                    .is_some_and(|input| !spec.type_parameters(input).is_empty())
-                    || operation
-                        .output_type()
-                        .is_some_and(|output| !spec.type_parameters(output).is_empty());
+                let operation_is_generic = operation.input_type().is_some_and(is_generic)
+                    || operation.output_type().is_some_and(is_generic);
                 if operation_is_generic {
                     return Err(invalid(format!(
                         "resource-bound operation `{operation_name}` cannot use generic type parameters"

src/spec.rs

@@ -1712,7 +1712,7 @@ where
     pub(crate) fn record_type_parameters(&self, record_name: &str) -> Vec<TypeParameterUsage> {
         let mut parameters = IndexMap::<String, TypeParameterUsage>::new();
         let mut visiting = std::collections::BTreeSet::new();
-        self.collect_record_type_parameters(record_name, &mut visiting, &mut parameters);
+        self.collect_record_type_parameters(record_name, &mut visiting, &mut parameters, &|_| None);
         parameters.into_values().collect()
     }
 
@@ -1721,14 +1721,16 @@ where
     pub(crate) fn variant_type_parameters(&self, variant_name: &str) -> Vec<TypeParameterUsage> {
         let mut parameters = IndexMap::<String, TypeParameterUsage>::new();
         let mut visiting = std::collections::BTreeSet::new();
-        self.collect_variant_type_parameters(variant_name, &mut visiting, &mut parameters);
+        self.collect_variant_type_parameters(variant_name, &mut visiting, &mut parameters, &|_| {
+            None
+        });
         parameters.into_values().collect()
     }
 
     pub(crate) fn type_parameters(&self, value: &TypeSpec<F>) -> Vec<TypeParameterUsage> {
         let mut parameters = IndexMap::<String, TypeParameterUsage>::new();
         let mut visiting = std::collections::BTreeSet::new();
-        self.collect_type_parameters(value, &mut visiting, &mut parameters);
+        self.collect_type_parameters(value, &mut visiting, &mut parameters, &|_| None);
         parameters.into_values().collect()
     }
 
@@ -1737,6 +1739,7 @@ where
         record_name: &str,
         visiting: &mut std::collections::BTreeSet<String>,
         parameters: &mut IndexMap<String, TypeParameterUsage>,
+        proto_record: &dyn Fn(&F::Proto) -> Option<String>,
     ) {
         if !visiting.insert(record_name.to_string()) {
             return;
@@ -1751,7 +1754,7 @@ where
                 {
                     continue;
                 }
-                self.collect_type_parameters(&field.field_type, visiting, parameters);
+                self.collect_type_parameters(&field.field_type, visiting, parameters, proto_record);
             }
         }
         visiting.remove(record_name);
@@ -1762,14 +1765,15 @@ where
         variant_name: &str,
         visiting: &mut std::collections::BTreeSet<String>,
         parameters: &mut IndexMap<String, TypeParameterUsage>,
+        proto_record: &dyn Fn(&F::Proto) -> Option<String>,
     ) {
         if !visiting.insert(variant_name.to_string()) {
             return;
         }
         if let Some(variant) = self.variant(variant_name) {
             for case in &variant.cases {
                 if let Some(payload) = &case.payload {
-                    self.collect_type_parameters(payload, visiting, parameters);
+                    self.collect_type_parameters(payload, visiting, parameters, proto_record);
                 }
             }
         }
@@ -1781,6 +1785,7 @@ where
         value: &TypeSpec<F>,
         visiting: &mut std::collections::BTreeSet<String>,
         parameters: &mut IndexMap<String, TypeParameterUsage>,
+        proto_record: &dyn Fn(&F::Proto) -> Option<String>,
     ) {
         match value {
             TypeSpec::TypeParameter(parameter) => {
@@ -1794,33 +1799,49 @@ where
                 }
             }
             TypeSpec::Option(inner) | TypeSpec::List(inner) => {
-                self.collect_type_parameters(inner, visiting, parameters)
+                self.collect_type_parameters(inner, visiting, parameters, proto_record)
             }
             TypeSpec::Tuple(items) => {
                 for item in items {
-                    self.collect_type_parameters(item, visiting, parameters);
+                    self.collect_type_parameters(item, visiting, parameters, proto_record);
                 }
             }
             TypeSpec::Map(key, value) => {
-                self.collect_type_parameters(key, visiting, parameters);
-                self.collect_type_parameters(value, visiting, parameters);
+                self.collect_type_parameters(key, visiting, parameters, proto_record);
+                self.collect_type_parameters(value, visiting, parameters, proto_record);
             }
             TypeSpec::Result { ok, err } => {
                 if let Some(ok) = ok {
-                    self.collect_type_parameters(ok, visiting, parameters);
+                    self.collect_type_parameters(ok, visiting, parameters, proto_record);
                 }
                 if let Some(err) = err {
-                    self.collect_type_parameters(err, visiting, parameters);
+                    self.collect_type_parameters(err, visiting, parameters, proto_record);
                 }
             }
-            TypeSpec::Record(record) => {
-                self.collect_record_type_parameters(record.as_ref(), visiting, parameters)
-            }
-            TypeSpec::Variant(variant) => {
-                self.collect_variant_type_parameters(variant.as_ref(), visiting, parameters)
-            }
+            TypeSpec::Record(record) => self.collect_record_type_parameters(
+                record.as_ref(),
+                visiting,
+                parameters,
+                proto_record,
+            ),
+            TypeSpec::Variant(variant) => self.collect_variant_type_parameters(
+                variant.as_ref(),
+                visiting,
+                parameters,
+                proto_record,
+            ),
             TypeSpec::External(ExternalTypeSpec::Alias(alias)) => {
-                self.collect_type_parameters(&alias.target, visiting, parameters)
+                self.collect_type_parameters(&alias.target, visiting, parameters, proto_record)
+            }
+            TypeSpec::External(ExternalTypeSpec::Proto(proto)) => {
+                if let Some(record_name) = proto_record(proto) {
+                    self.collect_record_type_parameters(
+                        &record_name,
+                        visiting,
+                        parameters,
+                        proto_record,
+                    );
+                }
             }
             TypeSpec::Bool
             | TypeSpec::Int(_)
@@ -1830,12 +1851,35 @@ where
             | TypeSpec::Enum(_)
             | TypeSpec::Flags(_)
             | TypeSpec::Resource(_)
-            | TypeSpec::External(ExternalTypeSpec::Proto(_))
             | TypeSpec::External(ExternalTypeSpec::Json(_)) => {}
         }
     }
 }
 
+impl<F> ApiSpec<F>
+where
+    F: TypeFamily,
+    F::Proto: AsRef<str>,
+    F::Record: AsRef<str>,
+    F::Variant: AsRef<str>,
+{
+    /// Like `type_parameters`, but also walks the record behind each proto type. Before planning, a
+    /// proto-backed record is named by its proto type, so the plain walk stops there.
+    pub(crate) fn type_parameters_through_protos(
+        &self,
+        value: &TypeSpec<F>,
+    ) -> Vec<TypeParameterUsage> {
+        let mut parameters = IndexMap::<String, TypeParameterUsage>::new();
+        let mut visiting = std::collections::BTreeSet::new();
+        let proto_record = |proto: &F::Proto| {
+            self.record_for_proto(proto.as_ref())
+                .map(|record| record.full_name.clone())
+        };
+        self.collect_type_parameters(value, &mut visiting, &mut parameters, &proto_record);
+        parameters.into_values().collect()
+    }
+}
+
 #[derive(Debug, Clone, PartialEq)]
 pub struct FunctionFieldSpec<F: TypeFamily = AuthoredFamily> {
     pub primary: bool,