Remove aliasDefaults

Author: lorisleiva

packages/renderers-rust/README.md

@@ -60,13 +60,11 @@ Using the `traitOptions` attribute, you may configure the default traits that wi
 -   `dataEnumDefaults`: The default traits to implement for all data enum types, in addition to the `baseDefaults` traits. Data enums are enums with at least one non-unit variant — e.g. `pub enum Command { Write(String), Quit }`.
 -   `scalarEnumDefaults`: The default traits to implement for all scalar enum types, in addition to the `baseDefaults` traits. Scalar enums are enums with unit variants only — e.g. `pub enum Feedback { Good, Bad }`.
 -   `structDefaults`: The default traits to implement for all struct types, in addition to the `baseDefaults` traits.
--   `aliasDefaults`: The default traits to implement for all type aliases, in addition to the `baseDefaults` traits.
 
 Note that you must provide the fully qualified name of the traits you provide (e.g. `serde::Serialize`). Here are the default values for these attributes:
 
 ```ts
 const traitOptions = {
-    aliasDefaults: [],
     baseDefaults: ['borsh::BorshSerialize', 'borsh::BorshDeserialize', 'Clone', 'Debug', 'Eq', 'PartialEq'],
     dataEnumDefaults: [],
     scalarEnumDefaults: ['Copy', 'PartialOrd', 'Hash', 'num_derive::FromPrimitive'],

packages/renderers-rust/src/utils/traitOptions.ts

@@ -3,8 +3,6 @@ import { AccountNode, assertIsNode, camelCase, DefinedTypeNode, isNode, isScalar
 import { ImportMap } from '../ImportMap';
 
 export type TraitOptions = {
-    /** The default traits to implement for type aliases only — on top of the base defaults. */
-    aliasDefaults?: string[];
     /** The default traits to implement for all types. */
     baseDefaults?: string[];
     /**
@@ -32,7 +30,6 @@ export type TraitOptions = {
 };
 
 export const DEFAULT_TRAIT_OPTIONS: Required<TraitOptions> = {
-    aliasDefaults: [],
     baseDefaults: ['borsh::BorshSerialize', 'borsh::BorshDeserialize', 'Clone', 'Debug', 'Eq', 'PartialEq'],
     dataEnumDefaults: [],
     featureFlags: { serde: ['serde::Serialize', 'serde::Deserialize'] },
@@ -55,8 +52,13 @@ export function getTraitsFromNode(
     assertIsNode(node, ['accountNode', 'definedTypeNode']);
     const options: Required<TraitOptions> = { ...DEFAULT_TRAIT_OPTIONS, ...userOptions };
 
-    // Find all the FQN traits for the node.
+    // Get the node type and return early if it's a type alias.
     const nodeType = getNodeType(node);
+    if (nodeType === 'alias') {
+        return { imports: new ImportMap(), render: '' };
+    }
+
+    // Find all the FQN traits for the node.
     const sanitizedOverrides = Object.fromEntries(
         Object.entries(options.overrides).map(([key, value]) => [camelCase(key), value]),
     );
@@ -98,21 +100,18 @@ function getNodeType(node: AccountNode | DefinedTypeNode): 'alias' | 'dataEnum'
 }
 
 function getDefaultTraits(
-    nodeType: 'alias' | 'dataEnum' | 'scalarEnum' | 'struct',
+    nodeType: 'dataEnum' | 'scalarEnum' | 'struct',
     options: Pick<
         Required<TraitOptions>,
-        'aliasDefaults' | 'baseDefaults' | 'dataEnumDefaults' | 'scalarEnumDefaults' | 'structDefaults'
+        'baseDefaults' | 'dataEnumDefaults' | 'scalarEnumDefaults' | 'structDefaults'
     >,
 ): string[] {
     switch (nodeType) {
-        case 'alias':
-            return [...options.baseDefaults, ...options.aliasDefaults];
         case 'dataEnum':
             return [...options.baseDefaults, ...options.dataEnumDefaults];
         case 'scalarEnum':
             return [...options.baseDefaults, ...options.scalarEnumDefaults];
         case 'struct':
-        default:
             return [...options.baseDefaults, ...options.structDefaults];
     }
 }

packages/renderers-rust/test/utils/traitOptions.test.ts

@@ -87,34 +87,20 @@ describe('default values', () => {
         ]);
     });
 
-    test('it defaults to a set of traits for aliases', () => {
-        // Given a defined type node that is not an enum or struct.
-        const node = definedTypeNode({
-            name: 'Score',
-            type: numberTypeNode('u64'),
-        });
-
-        // When we get the traits from the node using the default options.
-        const { render, imports } = getTraitsFromNode(node);
-
-        // Then we expect the following traits to be rendered.
-        expect(render).toBe(`#[derive(BorshSerialize, BorshDeserialize, Clone, Debug, Eq, PartialEq)]\n`);
-
-        // And the following imports to be used.
-        expect([...imports.imports]).toStrictEqual(['borsh::BorshSerialize', 'borsh::BorshDeserialize']);
-    });
-
     test('it does not use default traits if they are overridden', () => {
         // Given a defined type node that should use custom traits.
-        const node = definedTypeNode({
-            name: 'Score',
-            type: numberTypeNode('u64'),
+        const node = accountNode({
+            data: structTypeNode([
+                structFieldTypeNode({ name: 'x', type: numberTypeNode('u64') }),
+                structFieldTypeNode({ name: 'y', type: numberTypeNode('u64') }),
+            ]),
+            name: 'Coordinates',
         });
 
         // When we get the traits from the node using the
         // default options with the overrides attribute.
         const { render, imports } = getTraitsFromNode(node, {
-            overrides: { score: ['My', 'special::Traits'] },
+            overrides: { coordinates: ['My', 'special::Traits'] },
         });
 
         // Then we expect the following traits to be rendered.
@@ -126,15 +112,18 @@ describe('default values', () => {
 
     test('it still uses feature flags for overridden traits', () => {
         // Given a defined type node that should use custom traits.
-        const node = definedTypeNode({
-            name: 'Score',
-            type: numberTypeNode('u64'),
+        const node = accountNode({
+            data: structTypeNode([
+                structFieldTypeNode({ name: 'x', type: numberTypeNode('u64') }),
+                structFieldTypeNode({ name: 'y', type: numberTypeNode('u64') }),
+            ]),
+            name: 'Coordinates',
         });
 
         // When we get the traits from the node using custom traits
         // such that some are part of the feature flag defaults.
         const { render, imports } = getTraitsFromNode(node, {
-            overrides: { score: ['My', 'special::Traits', 'serde::Serialize'] },
+            overrides: { coordinates: ['My', 'special::Traits', 'serde::Serialize'] },
         });
 
         // Then we expect the following traits to be rendered.
@@ -146,7 +135,6 @@ describe('default values', () => {
 });
 
 const RESET_OPTIONS: Required<TraitOptions> = {
-    aliasDefaults: [],
     baseDefaults: [],
     dataEnumDefaults: [],
     featureFlags: {},
@@ -220,22 +208,21 @@ describe('base traits', () => {
         expect(render).toBe(`#[derive(MyBaseTrait, MyStructTrait)]\n`);
     });
 
-    test('it uses both the base and alias traits', () => {
+    test('it never uses traits for type aliases', () => {
         // Given a defined type node that is not an enum or struct.
         const node = definedTypeNode({
             name: 'Score',
             type: numberTypeNode('u64'),
         });
 
-        // When we get the traits from the node using custom base and alias defaults.
+        // When we get the traits from the node such that we have base defaults.
         const { render } = getTraitsFromNode(node, {
             ...RESET_OPTIONS,
-            aliasDefaults: ['MyAliasTrait'],
             baseDefaults: ['MyBaseTrait'],
         });
 
-        // Then we expect both the base and alias traits to be rendered.
-        expect(render).toBe(`#[derive(MyBaseTrait, MyAliasTrait)]\n`);
+        // Then we expect no traits to be rendered.
+        expect(render).toBe('');
     });
 
     test('it identifies feature flags under all default traits', () => {