Activity

1. Ryan Cavanaugh (RyanCavanaugh)

   added

   BugA bug in TypeScriptA bug in TypeScript

   on Jan 12, 2021
2. Ryan Cavanaugh (RyanCavanaugh)

   added this to the Backlog milestone on Jan 12, 2021
3. rafasofizada commented on Sep 7, 2021

   

   Rafael Sofi-zada (rafasofizada)

   on Sep 7, 2021

   Author

   More actions

   I have found the cause of the bug.

   Updated Minimal Bug Reproduction

   There's no difference between subclassing through mixins vs subclassing through class extension, as I thought at the time of writing the bug report. To show this, here is an updated minimal bug reproduction, featuring two mixins:

   function ShouldThrowButDoesnt<TBase extends new(...args: any[]) => any>(Base: TBase) {
     return class ShouldThrowButDoesnt extends Base {
       private constructor(...args: any[]) {
         super();
       }
     }
   }
   
   function ShouldThrowAndDoes(Base: new(...args: any[]) => any) {
     return class ShouldThrowAndDoes extends Base {
       private constructor(...args: any[]) {
         super();
       }
     }
   }
   
   class Base {
     constructor() {}
   }
   
   const shouldThrowButDoesnt = ShouldThrowButDoesnt(Base);
   const shouldThrowAndDoes = ShouldThrowAndDoes(Base);
   
   new shouldThrowButDoesnt();
   new shouldThrowAndDoes();

   Problem Cause

   The only difference between the two mixins ShouldThrowButDoesnt and ShouldThrowAndDoes is that in the former, the class parameter is of a generic type. Because of this (and I don't know exactly why), in checker.ts > resolveNewExpression(), when obtaining constructor signatures (checker.ts, line 29642 in v4.4.2), ShouldThrowButDoesnt is represented as an intersection type with type members ShouldThrowButDoesnt and Base (this intersection is obtained by getReducedApparentType()).

   Now, the cause of the problem is in how TypeScript resolves this intersection. In checker.ts > resolveIntersectionTypeMembers() (emphasis mine):

   function resolveIntersectionTypeMembers(type: IntersectionType) {
       // The members and properties collections are empty for intersection types. To get all properties of an
       // intersection type use getPropertiesOfType (only the language service uses this).
       let callSignatures: Signature[] | undefined;
       let constructSignatures: Signature[] | undefined;
       let indexInfos: IndexInfo[] | undefined;
       const types = type.types;
       const mixinFlags = findMixins(types);
       const mixinCount = countWhere(mixinFlags, (b) => b);
       for (let i = 0; i < types.length; i++) {
           const t = type.types[i];
           // When an intersection type contains mixin constructor types, the construct signatures from
           //         ^^^^^^^^^^^^.              ^^^^^^^^^^^^^^^^^
           // those types are discarded and their return types are mixed into the return types of all
           //                 ^^^^^^^^^
           // other construct signatures in the intersection type. For example, the intersection type
           // '{ new(...args: any[]) => A } & { new(s: string) => B }' has a single construct signature
           // 'new(s: string) => A & B'.
           if (!mixinFlags[i]) {
               let signatures = getSignaturesOfType(t, SignatureKind.Construct);
               if (signatures.length && mixinCount > 0) {
                   signatures = map(signatures, s => {
                       const clone = cloneSignature(s);
                       clone.resolvedReturnType = includeMixinType(getReturnTypeOfSignature(s), types, mixinFlags, i);
                       return clone;
                   });
               }
               constructSignatures = appendSignatures(constructSignatures, signatures);
           }
           callSignatures = appendSignatures(callSignatures, getSignaturesOfType(t, SignatureKind.Call));
           indexInfos = reduceLeft(getIndexInfosOfType(t), (infos, newInfo) => appendIndexInfo(infos, newInfo, /*union*/ false), indexInfos);
       }
       setStructuredTypeMembers(type, emptySymbols, callSignatures || emptyArray, constructSignatures || emptyArray, indexInfos || emptyArray);
   }

   Paraphrasing what was said in the comments, the mixin constructor signatures are discarded and instead their return types are merged (because mixins are not supposed to mess with a class' constructor signature).

   Therefore, mixin constructor's accessibility isn't taken into consideration at all!
   Ryan Cavanaugh (@RyanCavanaugh) Andrew Branch (@andrewbranch) I'd appreciate it if you could review this update and assign the bug to me (I'm sorry if it's not appropriate to tag you directly).

   However, I'm not really sure how a good solution would look like. Removing the !mixinFlags[i] check makes sense, but breaks a bunch of different tests. Perhaps we should only discard mixins that have a public constructor, but process all those that have a non-public one?
4. andrewbranch commented on Sep 7, 2021

   

   Andrew Branch (andrewbranch)

   on Sep 7, 2021

   Member

   More actions

   We don’t assign bugs to community members. Any bug in the Backlog milestone is fair game for any community member to submit a PR, but there is no guarantee we will accept it, and your chances of getting a review and the support you need is much better if you choose an issue labeled “help wanted.” As it is, we can’t take the time to investigate this bug and answer your questions about it right now because it’s on the backlog, and we have work that is milestoned for upcoming releases that needs our attention. If you want to contribute, I would strongly recommend looking at the “help wanted” label first.

   👍React with 👍1Reacted by Rafael Sofi-zada
5. rbuckton commented on Oct 5, 2021

   

   Ron Buckton (rbuckton)

   on Oct 5, 2021

   Contributor

   More actions

   This seems like something that #41587 would solve, since we can't annotate an interface or function/constructor type with visibility modifiers like private/protected. With #41587, we could change the inferred return type of ShouldThrowButDoesnt to use a typeof class so that this works both in the current project and when imported from a declaration file:

   declare function ShouldThrowButDoesent<TBase extends new (...args: any[]) => any>(Base: TBase): typeof class extends TBase {
     private constructor(...args: any[]);
   };

   Unfortunately, there's still a lot of work to go on #41587, judging from the notes in #41824.
6. Ryan Cavanaugh (RyanCavanaugh)

   added

   Domain: classesBehavior of various `class` constructs, e.g. mixins or base classesBehavior of various `class` constructs, e.g. mixins or base classes

   on Oct 16, 2025