fix: codegen succeeds for error type args that reference objects

changelog/@unreleased/pr-264.v2.yml

@@ -0,0 +1,5 @@
+type: fix
+fix:
+  description: Codegen succeeds for error type args that reference objects
+  links:
+  - https://github.com/palantir/conjure-rust/pull/264

conjure-codegen/src/context.rs

@@ -83,6 +83,18 @@ impl Context {
             );
         }
 
+        for def in defs.errors() {
+            context.types.insert(
+                def.error_name().clone(),
+                TypeContext {
+                    def: TypeDefinition::Object(def.object_definition()),
+                    has_double: Cell::new(None),
+                    is_copy: Cell::new(None),
+                    log_safety: RefCell::new(CachedLogSafety::Uncomputed),
+                },
+            );
+        }
+
         context
     }
 

conjure-codegen/src/errors.rs

@@ -18,12 +18,18 @@ use crate::context::Context;
 use crate::objects;
 use crate::types::{ErrorDefinition, ObjectDefinition};
 
+impl ErrorDefinition {
+    pub fn object_definition(&self) -> ObjectDefinition {
+        ObjectDefinition::builder()
+            .type_name(self.error_name().clone())
+            .fields(self.safe_args().iter().chain(self.unsafe_args()).cloned())
+            .docs(self.docs().cloned())
+            .build()
+    }
+}
+
 pub fn generate(ctx: &Context, def: &ErrorDefinition) -> TokenStream {
-    let object = ObjectDefinition::builder()
-        .type_name(def.error_name().clone())
-        .fields(def.safe_args().iter().chain(def.unsafe_args()).cloned())
-        .docs(def.docs().cloned())
-        .build();
+    let object = def.object_definition();
     let object_def = objects::generate(ctx, &object);
     let error_type = generate_error_type(ctx, def);
 

conjure-test/src/test/errors.rs

@@ -19,11 +19,16 @@ use crate::types::*;
 
 #[test]
 fn error_serialization() {
-    let error = SimpleError::new("hello", 15, false);
+    let error = SimpleError::builder()
+        .foo("hello")
+        .bar(15)
+        .baz(EmptyObject::new())
+        .unsafe_foo(false)
+        .build();
 
     assert_eq!(error.code(), ErrorCode::Internal);
     assert_eq!(error.name(), "Test:SimpleError");
-    assert_eq!(error.safe_args(), &["bar", "foo"]);
+    assert_eq!(error.safe_args(), &["bar", "baz", "foo"]);
 
     let encoded = conjure_error::encode(&error);
 

conjure-test/test.yml

@@ -156,6 +156,7 @@ types:
         safe-args:
           foo: string
           bar: integer
+          baz: EmptyObject
         unsafe-args:
           unsafeFoo: boolean