Make hashmap keys required unless the key is an enum

macros/src/lib.rs

@@ -30,6 +30,7 @@ struct DerivedTS {
     concrete: HashMap<Ident, Type>,
     bound: Option<Vec<WherePredicate>>,
     ts_enum: Option<Repr>,
+    is_enum: TokenStream,
 
     export: bool,
     export_to: Option<Expr>,
@@ -85,6 +86,7 @@ impl DerivedTS {
         );
         let assoc_type = generate_assoc_type(&rust_ty, &crate_rename, &generics, &self.concrete);
         let name = self.generate_name_fn(&generics);
+        let is_enum = self.is_enum.clone();
         let inline = self.generate_inline_fn();
         let decl = self.generate_decl_fn(&rust_ty, &generics);
         let dependencies = &self.dependencies;
@@ -95,6 +97,8 @@ impl DerivedTS {
                 #assoc_type
                 type OptionInnerType = Self;
 
+                const IS_ENUM: bool = #is_enum;
+
                 fn ident() -> String {
                     (#ident).to_string()
                 }

macros/src/types/enum.rs

@@ -65,6 +65,7 @@ pub(crate) fn r#enum_def(s: &ItemEnum) -> syn::Result<DerivedTS> {
         concrete: enum_attr.concrete,
         bound: enum_attr.bound,
         ts_enum: enum_attr.repr,
+        is_enum: quote!(true),
     })
 }
 
@@ -234,5 +235,6 @@ fn empty_enum(ts_name: Expr, enum_attr: EnumAttr) -> DerivedTS {
         concrete: enum_attr.concrete,
         bound: enum_attr.bound,
         ts_enum: enum_attr.repr,
+        is_enum: quote!(false),
     }
 }

macros/src/types/named.rs

@@ -73,6 +73,7 @@ pub(crate) fn named(attr: &StructAttr, ts_name: Expr, fields: &FieldsNamed) -> R
         concrete: attr.concrete.clone(),
         bound: attr.bound.clone(),
         ts_enum: None,
+        is_enum: quote!(false),
     })
 }
 

macros/src/types/newtype.rs

@@ -40,7 +40,7 @@ pub(crate) fn newtype(
     };
 
     Ok(DerivedTS {
-        crate_rename,
+        crate_rename: crate_rename.clone(),
         inline: inline_def,
         inline_flattened: None,
         docs: attr.docs.clone(),
@@ -51,5 +51,10 @@ pub(crate) fn newtype(
         concrete: attr.concrete.clone(),
         bound: attr.bound.clone(),
         ts_enum: None,
+        is_enum: if field_attr.type_override.is_none() {
+            quote!(<#inner_ty as #crate_rename::TS>::IS_ENUM)
+        } else {
+            quote!(false)
+        },
     })
 }

macros/src/types/tuple.rs

@@ -40,6 +40,7 @@ pub(crate) fn tuple(attr: &StructAttr, ts_name: Expr, fields: &FieldsUnnamed) ->
         concrete: attr.concrete.clone(),
         bound: attr.bound.clone(),
         ts_enum: None,
+        is_enum: quote!(false),
     })
 }
 

macros/src/types/type_as.rs

@@ -29,6 +29,7 @@ pub(crate) fn type_as_struct(
         concrete: attr.concrete.clone(),
         bound: attr.bound.clone(),
         ts_enum: None,
+        is_enum: quote!(<#type_as as #crate_rename::TS>::IS_ENUM),
     })
 }
 
@@ -50,5 +51,6 @@ pub(crate) fn type_as_enum(attr: &EnumAttr, ts_name: Expr, type_as: &Type) -> Re
         concrete: attr.concrete.clone(),
         bound: attr.bound.clone(),
         ts_enum: None,
+        is_enum: quote!(<#type_as as #crate_rename::TS>::IS_ENUM),
     })
 }

macros/src/types/type_override.rs

@@ -26,6 +26,7 @@ pub(crate) fn type_override_struct(
         concrete: attr.concrete.clone(),
         bound: attr.bound.clone(),
         ts_enum: None,
+        is_enum: quote!(false), // we dont know what the override is, so we preserve is_enum
     })
 }
 
@@ -48,5 +49,6 @@ pub(crate) fn type_override_enum(
         concrete: attr.concrete.clone(),
         bound: attr.bound.clone(),
         ts_enum: None,
+        is_enum: quote!(true), // we dont know what the override is, so we preserve is_enum
     })
 }

macros/src/types/unit.rs

@@ -22,6 +22,7 @@ pub(crate) fn empty_object(attr: &StructAttr, ts_name: Expr) -> DerivedTS {
         concrete: attr.concrete.clone(),
         bound: attr.bound.clone(),
         ts_enum: None,
+        is_enum: quote!(false),
     }
 }
 
@@ -40,6 +41,7 @@ pub(crate) fn empty_array(attr: &StructAttr, ts_name: Expr) -> DerivedTS {
         concrete: attr.concrete.clone(),
         bound: attr.bound.clone(),
         ts_enum: None,
+        is_enum: quote!(false),
     }
 }
 
@@ -58,5 +60,6 @@ pub(crate) fn null(attr: &StructAttr, ts_name: Expr) -> DerivedTS {
         concrete: attr.concrete.clone(),
         bound: attr.bound.clone(),
         ts_enum: None,
+        is_enum: quote!(false),
     }
 }

ts-rs/src/lib.rs

@@ -432,6 +432,9 @@ pub trait TS {
     #[doc(hidden)]
     const IS_OPTION: bool = false;
 
+    #[doc(hidden)]
+    const IS_ENUM: bool = false;
+
     /// JSDoc comment to describe this type in TypeScript - when `TS` is derived, docs are
     /// automatically read from your doc comments or `#[doc = ".."]` attributes
     fn docs() -> Option<String> {
@@ -986,17 +989,19 @@ impl<K: TS, V: TS, H> TS for HashMap<K, V, H> {
 
     fn name() -> String {
         format!(
-            "{{ [key in {}]?: {} }}",
+            "{{ [key in {}]{}: {} }}",
             <K as crate::TS>::name(),
-            <V as crate::TS>::name()
+            if <K as crate::TS>::IS_ENUM { "?" } else { "" },
+            <V as crate::TS>::name(),
         )
     }
 
     fn inline() -> String {
         format!(
-            "{{ [key in {}]?: {} }}",
+            "{{ [key in {}]{}: {} }}",
             <K as crate::TS>::inline(),
-            <V as crate::TS>::inline()
+            if <K as crate::TS>::IS_ENUM { "?" } else { "" },
+            <V as crate::TS>::inline(),
         )
     }
 
@@ -1027,11 +1032,7 @@ impl<K: TS, V: TS, H> TS for HashMap<K, V, H> {
     }
 
     fn inline_flattened() -> String {
-        format!(
-            "({{ [key in {}]?: {} }})",
-            <K as crate::TS>::inline(),
-            <V as crate::TS>::inline()
-        )
+        format!("({})", <Self as crate::TS>::inline())
     }
 }
 

ts-rs/tests/integration/flatten.rs

@@ -33,6 +33,6 @@ struct C {
 fn test_def() {
     assert_eq!(
         C::inline(),
-        "{ b: { c: number, a: number, b: number, } & ({ [key in string]?: number }), d: number, }"
+        "{ b: { c: number, a: number, b: number, } & ({ [key in string]: number }), d: number, }"
     );
 }

ts-rs/tests/integration/generics.rs

@@ -84,7 +84,7 @@ fn test() {
 
     assert_eq!(
         Container::decl(),
-        "type Container = { foo: Generic<number>, bar: Array<Generic<number>>, baz: { [key in string]?: Generic<string> }, };"
+        "type Container = { foo: Generic<number>, bar: Array<Generic<number>>, baz: { [key in string]: Generic<string> }, };"
     );
 }
 

ts-rs/tests/integration/hashmap.rs

@@ -15,7 +15,7 @@ struct Hashes {
 fn hashmap() {
     assert_eq!(
         Hashes::decl(),
-        "type Hashes = { map: { [key in string]?: string }, set: Array<string>, };"
+        "type Hashes = { map: { [key in string]: string }, set: Array<string>, };"
     )
 }
 
@@ -35,7 +35,7 @@ struct HashesHasher {
 fn hashmap_with_custom_hasher() {
     assert_eq!(
         HashesHasher::decl(),
-        "type HashesHasher = { map: { [key in string]?: string }, set: Array<string>, };"
+        "type HashesHasher = { map: { [key in string]: string }, set: Array<string>, };"
     )
 }
 
@@ -59,6 +59,13 @@ struct BTreeMapWithCustomTypes {
     map: BTreeMap<CustomKey, CustomValue>,
 }
 
+#[derive(TS)]
+#[ts(export, export_to = "hashmap/")]
+enum EnumKey {
+    Foo,
+    Bar,
+}
+
 #[test]
 fn with_custom_types() {
     assert_eq!(
@@ -67,6 +74,14 @@ fn with_custom_types() {
     );
     assert_eq!(
         HashMapWithCustomTypes::decl(),
-        "type HashMapWithCustomTypes = { map: { [key in CustomKey]?: CustomValue }, };"
+        "type HashMapWithCustomTypes = { map: { [key in CustomKey]: CustomValue }, };"
+    );
+    assert_eq!(
+        HashMap::<EnumKey, String>::name(),
+        "{ [key in EnumKey]?: string }"
+    );
+    assert_eq!(
+        HashMap::<EnumKey, String>::inline(),
+        r#"{ [key in "Foo" | "Bar"]?: string }"#
     );
 }

ts-rs/tests/integration/indexmap.rs

@@ -15,6 +15,6 @@ struct Indexes {
 fn indexmap() {
     assert_eq!(
         Indexes::decl(),
-        "type Indexes = { map: { [key in string]?: string }, set: Array<string>, };"
+        "type Indexes = { map: { [key in string]: string }, set: Array<string>, };"
     )
 }

ts-rs/tests/integration/issue_168.rs

@@ -45,13 +45,13 @@ fn issue_168() {
         FooInlined::export_to_string().unwrap(),
         "// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.\n\
          \n\
-         export type FooInlined = { map: { [key in number]?: { map: { [key in number]?: { map: { [key in number]?: string }, } }, } }, };\n"
+         export type FooInlined = { map: { [key in number]: { map: { [key in number]: { map: { [key in number]: string }, } }, } }, };\n"
     );
     assert_eq!(
         Foo::export_to_string().unwrap(),
         format!("// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.\n\
          import type {{ Bar }} from \"./Bar{extension}\";\n\
          \n\
-         export type Foo = {{ map: {{ [key in number]?: Bar }}, }};\n")
+         export type Foo = {{ map: {{ [key in number]: Bar }}, }};\n")
     );
 }

ts-rs/tests/integration/issue_70.rs

@@ -24,11 +24,11 @@ struct Struct {
 fn issue_70() {
     assert_eq!(
         Enum::decl(),
-        "type Enum = { \"A\": { [key in string]?: string } } | { \"B\": { [key in string]?: string } };"
+        "type Enum = { \"A\": { [key in string]: string } } | { \"B\": { [key in string]: string } };"
     );
     assert_eq!(
         Struct::decl(),
-        "type Struct = { a: { [key in string]?: string }, b: { [key in string]?: string }, };"
+        "type Struct = { a: { [key in string]: string }, b: { [key in string]: string }, };"
     );
 }
 

ts-rs/tests/integration/lifetimes.rs

@@ -31,6 +31,6 @@ fn contains_borrow() {
 fn contains_borrow_type_args() {
     assert_eq!(
         A::decl(),
-        "type A = { a: Array<number>, b: Array<B<number>>, c: { [key in string]?: boolean }, };"
+        "type A = { a: Array<number>, b: Array<B<number>>, c: { [key in string]: boolean }, };"
     );
 }

ts-rs/tests/integration/self_referential.rs

@@ -83,8 +83,8 @@ fn enum_externally_tagged() {
                  { \"C\": E } | \
                  { \"D\": E } | \
                  { \"E\": [E, E, E, E] } | \
-                 { \"F\": { a: E, b: E, c: { [key in string]?: E }, d: E | null, e?: E | null, f?: E, } } | \
-                 { \"G\": [Array<E>, Array<E>, { [key in string]?: E }] };"
+                 { \"F\": { a: E, b: E, c: { [key in string]: E }, d: E | null, e?: E | null, f?: E, } } | \
+                 { \"G\": [Array<E>, Array<E>, { [key in string]: E }] };"
     );
 }
 
@@ -170,7 +170,7 @@ fn enum_adjacently_tagged() {
                      \"content\": { \
                          a: A, \
                          b: A, \
-                         c: { [key in string]?: A }, \
+                         c: { [key in string]: A }, \
                          d: A | null, \
                          e?: A | null, \
                          f?: A, \
@@ -181,7 +181,7 @@ fn enum_adjacently_tagged() {
                      \"content\": [\
                         Array<A>, \
                         [A, A, A, A], \
-                        { [key in string]?: A }\
+                        { [key in string]: A }\
                      ] \
                   };"
     );

ts-rs/tests/integration/serde_json.rs

@@ -20,22 +20,22 @@ fn using_serde_json() {
     assert_eq!(serde_json::Number::inline(), "number");
     assert_eq!(
         serde_json::Map::<String, i32>::inline(),
-        "{ [key in string]?: number }"
+        "{ [key in string]: number }"
     );
     assert_eq!(
         serde_json::Value::decl(),
-        "type JsonValue = number | string | boolean | Array<JsonValue> | { [key in string]?: JsonValue } | null;",
+        "type JsonValue = number | string | boolean | Array<JsonValue> | { [key in string]: JsonValue } | null;",
     );
 
     assert_eq!(
         UsingSerdeJson::decl(),
         "type UsingSerdeJson = { \
             num: number, \
-            map1: { [key in string]?: number }, \
-            map2: { [key in string]?: UsingSerdeJson }, \
-            map3: { [key in string]?: { [key in string]?: number } }, \
-            map4: { [key in string]?: number }, \
-            map5: { [key in string]?: JsonValue }, \
+            map1: { [key in string]: number }, \
+            map2: { [key in string]: UsingSerdeJson }, \
+            map3: { [key in string]: { [key in string]: number } }, \
+            map4: { [key in string]: number }, \
+            map5: { [key in string]: JsonValue }, \
             any: JsonValue, \
          };"
     )
@@ -53,7 +53,7 @@ fn inlined_value() {
     assert_eq!(
         InlinedValue::decl(),
         "type InlinedValue = { \
-            any: number | string | boolean | Array<JsonValue> | { [key in string]?: JsonValue } | null, \
+            any: number | string | boolean | Array<JsonValue> | { [key in string]: JsonValue } | null, \
          };"
     );
 }