Negated Types

packages/typescript/src/api/async/api.ts

@@ -2610,6 +2610,11 @@ export class Checker {
         return type.getNonNullableType();
     }
 
+    /** Get the negation of a type. Always returns a type. */
+    async getNegatedType(type: Type): Promise<Type> {
+        return type.getNegatedType();
+    }
+
     /**
      * Get the type for a type node. Always returns a type; for type nodes whose
      * type cannot be determined the checker yields the error type (use
@@ -3447,6 +3452,7 @@ class TypeObject implements Type {
     private constraint: number | false;
     private default: number | false;
     private nonNullableType: number | false;
+    private negatedType: number | false;
     private apparentType: number | false;
     private reducedType: number | false;
     private properties: readonly Symbol[] | false;
@@ -3526,6 +3532,7 @@ class TypeObject implements Type {
         this.constraint = false;
         this.default = false;
         this.nonNullableType = false;
+        this.negatedType = false;
         this.apparentType = false;
         this.reducedType = false;
         this.properties = false;
@@ -3581,6 +3588,12 @@ class TypeObject implements Type {
         return result;
     }
 
+    async getNegatedType(): Promise<Type> {
+        const result = await this.objectRegistry.fetchType(this, "getNegatedType", this.negatedType);
+        this.negatedType = result.id;
+        return result;
+    }
+
     async getStringIndexType(): Promise<Type | undefined> {
         if (this.stringIndexType === false) {
             this.stringIndexType = await this.getStringIndexTypeWorker();

packages/typescript/src/api/async/types.ts

@@ -67,6 +67,9 @@ export interface Type {
     /** Get this type with `null` and `undefined` removed. */
     getNonNullableType(): Promise<Type>;
 
+    /** Get the negation of this type. */
+    getNegatedType(): Promise<Type>;
+
     /** Get this type's string index value type, if present. */
     getStringIndexType(): Promise<Type | undefined>;
 

packages/typescript/src/api/node/encoder.generated.ts

@@ -77,7 +77,7 @@ export function getNodeCommonData(node: Node): number {
         case SyntaxKind.ObjectLiteralExpression:
             return ((node as ObjectLiteralExpression).multiLine ? 1 : 0) << 24;
         case SyntaxKind.TypeOperator:
-            return ((node as TypeOperatorNode).operator === SyntaxKind.ReadonlyKeyword ? 1 : (node as TypeOperatorNode).operator === SyntaxKind.UniqueKeyword ? 2 : 0) << 24;
+            return ((node as TypeOperatorNode).operator === SyntaxKind.ReadonlyKeyword ? 1 : (node as TypeOperatorNode).operator === SyntaxKind.UniqueKeyword ? 2 : (node as TypeOperatorNode).operator === SyntaxKind.NotKeyword ? 3 : 0) << 24;
         case SyntaxKind.ImportAttributes:
             return ((node as ImportAttributes).multiLine ? 1 : 0) << 24 | ((node as ImportAttributes).token === SyntaxKind.AssertKeyword ? 1 : 0) << 25;
         case SyntaxKind.JsxText:

packages/typescript/src/api/node/node.generated.ts

@@ -580,6 +580,7 @@ export class RemoteNode extends RemoteNodeBase implements Node {
                 const idx = (this.data >> 24) & 0x3;
                 if (idx === 1) return SyntaxKind.ReadonlyKeyword;
                 if (idx === 2) return SyntaxKind.UniqueKeyword;
+                if (idx === 3) return SyntaxKind.NotKeyword;
                 return SyntaxKind.KeyOfKeyword;
             }
         }

packages/typescript/src/api/proto.generated.ts

@@ -151,6 +151,7 @@ export interface APIMethodInfo {
     getApparentPropertiesOfType: APIMethod<GetTypePropertyParams, SymbolResponse[]>;
     getApparentType: APIMethod<GetTypePropertyParams, TypeResponse>;
     getReducedType: APIMethod<GetTypePropertyParams, TypeResponse>;
+    getNegatedType: APIMethod<GetTypePropertyParams, TypeResponse>;
     getPropertyOfType: APIMethod<GetPropertyOfTypeParams, SymbolResponse | null>;
     getTypeOfPropertyOfType: APIMethod<GetPropertyOfTypeParams, TypeResponse | null>;
     getIndexInfoOfType: APIMethod<GetIndexInfoOfTypeParams, IndexInfoResponse | null>;
@@ -1222,6 +1223,7 @@ export interface BatchRequest {
         | "getModeForResolutionAtIndex"
         | "getModeForUsageLocation"
         | "getNameTypeOfMappedType"
+        | "getNegatedType"
         | "getNeverType"
         | "getNonMissingTypeOfSymbol"
         | "getNonNullableType"
@@ -1404,6 +1406,7 @@ export interface BatchResponse {
         | "getModeForResolutionAtIndex"
         | "getModeForUsageLocation"
         | "getNameTypeOfMappedType"
+        | "getNegatedType"
         | "getNeverType"
         | "getNonMissingTypeOfSymbol"
         | "getNonNullableType"

packages/typescript/src/api/sync/api.ts

@@ -4941,6 +4941,24 @@ export class Checker {
         );
     }
 
+    /** Get the negation of a type. Always returns a type. */
+    get getNegatedType(): {
+        (type: Type): Type;
+        gen(type: Type): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    } {
+        const owner = this;
+        return cacheGeneratorMethod(
+            owner,
+            "getNegatedType",
+            function (type: Type): Type {
+                return type.getNegatedType();
+            },
+            function* (type: Type): Generator<ProtocolRequest, Type, ProtocolResponse["result"]> {
+                return yield* type.getNegatedType.gen();
+            },
+        );
+    }
+
     /**
      * Get the type for a type node. Always returns a type; for type nodes whose
      * type cannot be determined the checker yields the error type (use
@@ -7012,6 +7030,7 @@ class TypeObject implements Type {
     private constraint: number | false;
     private default: number | false;
     private nonNullableType: number | false;
+    private negatedType: number | false;
     private apparentType: number | false;
     private reducedType: number | false;
     private properties: readonly Symbol[] | false;
@@ -7091,6 +7110,7 @@ class TypeObject implements Type {
         this.constraint = false;
         this.default = false;
         this.nonNullableType = false;
+        this.negatedType = false;
         this.apparentType = false;
         this.reducedType = false;
         this.properties = false;
@@ -7251,6 +7271,27 @@ class TypeObject implements Type {
         );
     }
 
+    get getNegatedType(): {
+        (): Type;
+        gen(): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    } {
+        const owner = this;
+        return cacheGeneratorMethod(
+            owner,
+            "getNegatedType",
+            function (): Type {
+                const result = owner.objectRegistry.fetchType(owner, "getNegatedType", owner.negatedType);
+                owner.negatedType = result.id;
+                return result;
+            },
+            function* (): Generator<ProtocolRequest, Type, ProtocolResponse["result"]> {
+                const result = yield* owner.objectRegistry.fetchType.gen(owner, "getNegatedType", owner.negatedType);
+                owner.negatedType = result.id;
+                return result;
+            },
+        );
+    }
+
     get getStringIndexType(): {
         (): Type | undefined;
         gen(): Generator<ProtocolRequest, Type | undefined, ProtocolResponse["result"]>;

packages/typescript/src/api/sync/types.ts

@@ -107,6 +107,12 @@ export interface Type {
         gen(): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
     };
 
+    /** Get the negation of this type. */
+    getNegatedType: {
+        (): Type;
+        gen(): Generator<ProtocolRequest, Type, ProtocolResponse["result"]>;
+    };
+
     /** Get this type's string index value type, if present. */
     getStringIndexType: {
         (): Type | undefined;

packages/typescript/src/ast/ast.generated.ts

@@ -140,6 +140,7 @@ export type KeywordSyntaxKind =
     | SyntaxKind.ModuleKeyword
     | SyntaxKind.NamespaceKeyword
     | SyntaxKind.NeverKeyword
+    | SyntaxKind.NotKeyword
     | SyntaxKind.OutKeyword
     | SyntaxKind.ReadonlyKeyword
     | SyntaxKind.RequireKeyword
@@ -312,6 +313,7 @@ export type TokenSyntaxKind =
     | SyntaxKind.ModuleKeyword
     | SyntaxKind.NamespaceKeyword
     | SyntaxKind.NeverKeyword
+    | SyntaxKind.NotKeyword
     | SyntaxKind.OutKeyword
     | SyntaxKind.ReadonlyKeyword
     | SyntaxKind.RequireKeyword
@@ -964,7 +966,7 @@ export interface ConditionalTypeNode extends TypeNodeBase {
 }
 export interface TypeOperatorNode extends TypeNodeBase {
     readonly kind: SyntaxKind.TypeOperator;
-    readonly operator: SyntaxKind.KeyOfKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.UniqueKeyword;
+    readonly operator: SyntaxKind.KeyOfKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.NotKeyword;
     readonly type: TypeNode;
 }
 export interface InferTypeNode extends TypeNodeBase {

packages/typescript/src/ast/factory.generated.ts

@@ -4711,7 +4711,7 @@ export function createConditionalTypeNode(checkType: TypeNode, extendsType: Type
     }) as unknown as ConditionalTypeNode;
 }
 
-export function createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.UniqueKeyword, type: TypeNode): TypeOperatorNode {
+export function createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.NotKeyword, type: TypeNode): TypeOperatorNode {
     return new NodeObject(SyntaxKind.TypeOperator, {
         operator,
         type,

packages/typescript/src/enums/objectFlags.enum.ts

@@ -49,4 +49,5 @@ export enum ObjectFlags {
     IsNeverIntersectionComputed = 1 << 25,
     IsNeverIntersection = 1 << 26,
     IsConstrainedTypeVariable = 1 << 27,
+    FreshNegated = 1 << 25,
 }

packages/typescript/src/enums/objectFlags.ts

@@ -49,4 +49,5 @@ export var ObjectFlags: any;
     ObjectFlags[ObjectFlags["IsNeverIntersectionComputed"] = 33554432] = "IsNeverIntersectionComputed";
     ObjectFlags[ObjectFlags["IsNeverIntersection"] = 67108864] = "IsNeverIntersection";
     ObjectFlags[ObjectFlags["IsConstrainedTypeVariable"] = 134217728] = "IsConstrainedTypeVariable";
+    ObjectFlags[ObjectFlags["FreshNegated"] = 33554432] = "FreshNegated";
 })(ObjectFlags || (ObjectFlags = {}));