src/Trait.ts

@@ -1,6 +1,6 @@
 import { Fn } from "hotscript"
 import { AbstractClass, Class, Opaque } from "type-fest"
-import { AbstractTag, TraitExpression, TraitExpressionAllTraits, TraitExpressionNullSuperclass, emptyTraitExpression } from "."
+import { AbstractTag, TraitExpression, TraitExpressionNullSuperclass, emptyTraitExpression } from "."
 import { StaticMembers } from "./util"
 
 
@@ -89,7 +89,7 @@ export namespace Trait {
 
     export type Supertraits<T> = (
         T extends Trait<infer Super, any, any>
-            ? TraitExpressionAllTraits<Super>
+            ? TraitExpression.AllTraits<Super>
             : never
     )
     export interface SupertraitsFn extends Fn {

src/TraitExpression.ts

@@ -61,31 +61,33 @@ export class TraitExpression<
     }
 }
 
-export type TraitExpressionSuper<T> = (
+export namespace TraitExpression {
-    T extends TraitExpression<infer Super, any, any>
+    export type Super<T> = (
-        ? Super
+        T extends TraitExpression<infer Super, any, any>
-        : never
+            ? Super
-)
+            : never
-export interface TraitExpressionSuperFn extends Fn {
+    )
-    return: TraitExpressionSuper<this["arg0"]>
+    export interface SuperFn extends Fn {
-}
+        return: TraitExpression.Super<this["arg0"]>
+    }
 
-export type TraitExpressionOwnTraits<T> = (
+    export type OwnTraits<T> = (
-    T extends TraitExpression<any, infer OwnTraits, any>
+        T extends TraitExpression<any, infer OwnTraits, any>
-        ? OwnTraits
+            ? OwnTraits
-        : never
+            : never
-)
+    )
-export interface TraitExpressionOwnTraitsFn extends Fn {
+    export interface OwnTraitsFn extends Fn {
-    return: TraitExpressionOwnTraits<this["arg0"]>
+        return: TraitExpression.OwnTraits<this["arg0"]>
-}
+    }
 
-export type TraitExpressionAllTraits<T> = (
+    export type AllTraits<T> = (
-    T extends TraitExpression<any, any, infer AllTraits>
+        T extends TraitExpression<any, any, infer AllTraits>
-        ? AllTraits
+            ? AllTraits
-        : never
+            : never
-)
+    )
-export interface TraitExpressionAllTraitsFn extends Fn {
+    export interface AllTraitsFn extends Fn {
-    return: TraitExpressionAllTraits<this["arg0"]>
+        return: TraitExpression.AllTraits<this["arg0"]>
+    }
 }
 
 

src/TraitExpressionBuilder.ts

@@ -119,13 +119,13 @@ type GetTraitExpression<
     OwnTraits extends Trait<any, any, any>[],
     AllTraits extends Trait<any, any, any>[],
 > = (
-    Call<Tuples.IsEmpty, OwnTraits> extends true
+    Call<Tuples.IsEmpty, AllTraits> extends true
         ? "Cannot express an empty list of traits."
-        : AbstractMembersExtendable<Super, OwnTraits> extends false
+        : AbstractMembersExtendable<Super, AllTraits> extends false
             ? "Type conflict between the traits abstract members and/or the superclass instance."
-            : ImplInstanceExtendable<Super, OwnTraits> extends false
+            : ImplInstanceExtendable<Super, AllTraits> extends false
                 ? "Type conflict between the traits implementation instances and/or the superclass instance."
-                : ImplStaticMembersExtendable<Super, OwnTraits> extends false
+                : ImplStaticMembersExtendable<Super, AllTraits> extends false
                     ? "Type conflict between the traits implementation static members and/or the superclass static members."
                     : TraitExpression<Super, OwnTraits, AllTraits>
 )