lang, ts: decamelize idl

lang/syn/src/idl/file.rs

@@ -4,7 +4,6 @@ use crate::parser::{self, accounts, error, program};
 use crate::Ty;
 use crate::{AccountField, AccountsStruct, StateIx};
 use anyhow::Result;
-use heck::MixedCase;
 use quote::ToTokens;
 use std::collections::{HashMap, HashSet};
 use std::path::Path;
@@ -44,7 +43,7 @@ pub fn parse(
                         methods
                             .iter()
                             .map(|method: &StateIx| {
-                                let name = method.ident.to_string().to_mixed_case();
+                                let name = method.ident.to_string();
                                 let args = method
                                     .args
                                     .iter()
@@ -53,7 +52,7 @@ pub fn parse(
                                         arg.raw_arg.ty.to_tokens(&mut tts);
                                         let ty = tts.to_string().parse().unwrap();
                                         IdlField {
-                                            name: arg.name.to_string().to_mixed_case(),
+                                            name: arg.name.to_string(),
                                             ty,
                                         }
                                     })
@@ -93,7 +92,7 @@ pub fn parse(
                                 arg_typed.ty.to_tokens(&mut tts);
                                 let ty = tts.to_string().parse().unwrap();
                                 IdlField {
-                                    name: parser::tts_to_string(&arg_typed.pat).to_mixed_case(),
+                                    name: parser::tts_to_string(&arg_typed.pat),
                                     ty,
                                 }
                             }
@@ -122,7 +121,7 @@ pub fn parse(
                                 f.ty.to_tokens(&mut tts);
                                 let ty = tts.to_string().parse().unwrap();
                                 IdlField {
-                                    name: f.ident.as_ref().unwrap().to_string().to_mixed_case(),
+                                    name: f.ident.as_ref().unwrap().to_string(),
                                     ty,
                                 }
                             })
@@ -159,7 +158,7 @@ pub fn parse(
                 .args
                 .iter()
                 .map(|arg| IdlField {
-                    name: arg.name.to_string().to_mixed_case(),
+                    name: arg.name.to_string(),
                     ty: to_idl_type(&ctx, &arg.raw_arg.ty),
                 })
                 .collect::<Vec<_>>();
@@ -172,7 +171,7 @@ pub fn parse(
                 _ => Some(ret_type_str.parse().unwrap()),
             };
             IdlInstruction {
-                name: ix.ident.to_string().to_mixed_case(),
+                name: ix.ident.to_string(),
                 accounts,
                 args,
                 returns,
@@ -196,7 +195,7 @@ pub fn parse(
                         Some(i) => parser::tts_to_string(&i.path) == "index",
                     };
                     IdlEventField {
-                        name: f.ident.clone().unwrap().to_string().to_mixed_case(),
+                        name: f.ident.clone().unwrap().to_string(),
                         ty: to_idl_type(&ctx, &f.ty),
                         index,
                     }
@@ -413,7 +412,7 @@ fn parse_ty_defs(ctx: &CrateContext) -> Result<Vec<IdlTypeDefinition>> {
                     .iter()
                     .map(|f: &syn::Field| {
                         Ok(IdlField {
-                            name: f.ident.as_ref().unwrap().to_string().to_mixed_case(),
+                            name: f.ident.as_ref().unwrap().to_string(),
                             ty: to_idl_type(ctx, &f.ty),
                         })
                     })
@@ -552,12 +551,12 @@ fn idl_accounts(
                 });
                 let accounts = idl_accounts(ctx, accs_strct, global_accs, seeds_feature);
                 IdlAccountItem::IdlAccounts(IdlAccounts {
-                    name: comp_f.ident.to_string().to_mixed_case(),
+                    name: comp_f.ident.to_string(),
                     accounts,
                 })
             }
             AccountField::Field(acc) => IdlAccountItem::IdlAccount(IdlAccount {
-                name: acc.ident.to_string().to_mixed_case(),
+                name: acc.ident.to_string(),
                 is_mut: acc.constraints.is_mutable(),
                 is_signer: match acc.ty {
                     Ty::Signer => true,

lang/syn/src/idl/mod.rs

@@ -50,7 +50,7 @@ pub struct IdlInstruction {
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase")]
+
 pub struct IdlAccounts {
     pub name: String,
     pub accounts: Vec<IdlAccountItem>,
@@ -64,7 +64,7 @@ pub enum IdlAccountItem {
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase")]
+
 pub struct IdlAccount {
     pub name: String,
     pub is_mut: bool,
@@ -74,23 +74,20 @@ pub struct IdlAccount {
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase")]
 pub struct IdlPda {
     pub seeds: Vec<IdlSeed>,
     #[serde(skip_serializing_if = "Option::is_none", default)]
     pub program_id: Option<IdlSeed>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase", tag = "kind")]
 pub enum IdlSeed {
     Const(IdlSeedConst),
     Arg(IdlSeedArg),
     Account(IdlSeedAccount),
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase")]
 pub struct IdlSeedAccount {
     #[serde(rename = "type")]
     pub ty: IdlType,
@@ -102,15 +99,13 @@ pub struct IdlSeedAccount {
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase")]
 pub struct IdlSeedArg {
     #[serde(rename = "type")]
     pub ty: IdlType,
     pub path: String,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase")]
 pub struct IdlSeedConst {
     #[serde(rename = "type")]
     pub ty: IdlType,
@@ -167,7 +162,7 @@ pub enum EnumFields {
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "camelCase")]
+
 pub enum IdlType {
     Bool,
     U8,

tests/misc/tests/misc/misc.ts

@@ -30,6 +30,7 @@ describe("misc", () => {
   const wallet = provider.wallet as Wallet;
   anchor.setProvider(provider);
   const program = anchor.workspace.Misc as Program<Misc>;
+  const miscIdl = program.idl;
   const misc2Program = anchor.workspace.Misc2 as Program<Misc2>;
 
   it("Can allocate extra space for a state constructor", async () => {
@@ -965,6 +966,10 @@ describe("misc", () => {
   });
 
   it("Should not include NO_IDL const in IDL", async () => {
+    // The type system sees that this constant does not exist and the
+    // ts-expect-error makes sure that ts compilation fails if that ever
+    // changes.
+    // @ts-expect-error
     assert.isUndefined(miscIdl.constants.find((c) => c.name === "NO_IDL"));
   });