Complete refactoring

src/TraitExpressionBuilder.ts

@@ -2,7 +2,7 @@ import { Call, Fn, Pipe, Tuples } from "hotscript"
 import { uniq } from "lodash-es"
 import { AbstractClass } from "type-fest"
 import { Trait } from "./Trait"
-import { TraitExpression, emptyTraitExpression } from "./TraitExpression"
+import { TraitExpression } from "./TraitExpression"
 import { ExtendableFn, StaticMembersFn } from "./util"
 
 
@@ -51,76 +51,64 @@ type ImplStaticMembersExtendable<
 
 type BuildTraitExpression<
     Superclass extends AbstractClass<{}>,
-    OwnTraits  extends Trait<any, any, any, any>[],
-    AllTraits  extends Trait<any, any, any, any>[],
+    Traits     extends Trait<any, any, any, any>[],
 > = (
-    AbstractMembersExtendable<Superclass, AllTraits> extends false
+    AbstractMembersExtendable<Superclass, Traits> extends false
         ? "Type conflict between the traits abstract members and/or the superclass instance."
-        : ImplInstanceExtendable<Superclass, AllTraits> extends false
+        : ImplInstanceExtendable<Superclass, Traits> extends false
             ? "Type conflict between the traits implementation instances and/or the superclass instance."
-            : ImplStaticMembersExtendable<Superclass, AllTraits> extends false
+            : ImplStaticMembersExtendable<Superclass, Traits> extends false
                 ? "Type conflict between the traits implementation static members and/or the superclass static members."
-                : TraitExpression<Superclass, OwnTraits, AllTraits>
+                : TraitExpression<Superclass, Traits>
 )
 
 
 class TraitExpressionBuilder<
-    Superclass      extends AbstractClass<{}>,
-    const OwnTraits extends Trait<any, any, any, any>[],
-    const AllTraits extends Trait<any, any, any, any>[],
+    Superclass   extends AbstractClass<object>,
+    const Traits extends Trait<any, any, any, any>[],
 > {
-    constructor(private readonly expression: TraitExpression<Superclass, OwnTraits, AllTraits>) {}
+    constructor(
+        private readonly expressionSuperclass:  Superclass,
+        private readonly expressionTraits:      Traits,
+    ) {}
 
     extends<
-        Super extends AbstractClass<any>
+        Super extends AbstractClass<object>
     >(
         superclass: Super
     ) {
         return new TraitExpressionBuilder(
-            new TraitExpression(
-                superclass,
-                this.expression.ownTraits,
-                this.expression.allTraits,
-            )
+            superclass,
+            this.expressionTraits,
         )
     }
 
     expresses<
-        const Traits extends Trait<any, any, any, any>[]
+        const T extends Trait<any, any, any, any>[]
     >(
-        ...traits: Traits
+        ...traits: T
     ): TraitExpressionBuilder<
         Superclass,
-        [...OwnTraits, ...Traits],
-        [...AllTraits, ...SpreadSupertraits<Traits>]
+        [...Traits, ...SpreadSupertraits<T>]
     > {
         return new TraitExpressionBuilder(
-            new TraitExpression(
-                this.expression.superclass,
-                uniq([...this.expression.ownTraits, ...traits]) as [...OwnTraits, ...Traits],
-                uniq([...this.expression.allTraits, ...this.spreadSupertraits(traits)]) as [...AllTraits, ...SpreadSupertraits<Traits>],
-            )
+            this.expressionSuperclass,
+
+            uniq([
+                ...this.expressionTraits,
+                ...traits.flatMap(trait => [
+                    ...trait.superExpression.allTraits,
+                    trait,
+                ]),
+            ]) as [...Traits, ...SpreadSupertraits<T>],
         )
     }
 
-    private spreadSupertraits<
-        const Traits extends Trait<
-            TraitExpression<any, any, Trait<any, any, any, any>[]>,
-            any,
-            any,
-            any
-        >[]
-    >(
-        traits: Traits
-    ) {
-        return traits.flatMap(trait => [
-            ...trait.supertraits.allTraits,
-            trait,
-        ]) as SpreadSupertraits<Traits>
-    }
-
     build() {
-        return this.expression as BuildTraitExpression<Superclass, OwnTraits, AllTraits>
+        return new TraitExpression(
+            this.expressionSuperclass,
+            this.expressionTraits,
+        ) as BuildTraitExpression<Superclass, Traits>
     }
 
     then<V>(fn: (expression: ReturnType<typeof this.build>) => V): V {
@@ -128,4 +116,4 @@ class TraitExpressionBuilder<
     }
 }
 
-export const expression = new TraitExpressionBuilder(emptyTraitExpression)
+export const expression = new TraitExpressionBuilder(TraitExpression.NullSuperclass, [])