no-useless-assertion: add test with conditional types

Fixes: #116

baselines/packages/mimir/test/no-useless-assertion/conditional-types/conditional-types.ts

@@ -0,0 +1,34 @@
+export {};
+
+type Nullable<T> = T extends null | undefined ? T : T | null | undefined;
+type NonNullable<T> = T extends null | undefined ? never : T;
+
+declare function nullable<T>(param: T): Nullable<T>;
+declare function nonNullable<T>(param: T): NonNullable<T>;
+
+declare function takeString(param: string): void;
+declare function takeNullable(param: Nullable<string>): void;
+
+declare let v: Nullable<string>;
+declare let s: NonNullable<typeof v>;
+
+takeString(v!);
+takeNullable(v);
+takeString(s);
+takeNullable(s);
+takeNullable(nullable(s));
+takeString(nonNullable(v));
+
+nullable(s)!;
+nonNullable(s);
+nullable(null)!;
+nonNullable(null);
+
+nullable(s) as string;
+nullable(s);
+nonNullable(s);
+
+v as NonNullable<typeof s>;
+s as Nullable<string>;
+s;
+(Boolean() ? s : null) as NonNullable<string>;

baselines/packages/mimir/test/no-useless-assertion/conditional-types/conditional-types.ts.lint

@@ -0,0 +1,44 @@
+export {};
+
+type Nullable<T> = T extends null | undefined ? T : T | null | undefined;
+type NonNullable<T> = T extends null | undefined ? never : T;
+
+declare function nullable<T>(param: T): Nullable<T>;
+declare function nonNullable<T>(param: T): NonNullable<T>;
+
+declare function takeString(param: string): void;
+declare function takeNullable(param: Nullable<string>): void;
+
+declare let v: Nullable<string>;
+declare let s: NonNullable<typeof v>;
+
+takeString(v!);
+takeNullable(v!);
+              ~   [error no-useless-assertion: This assertion is unnecessary as the receiver accepts 'null' and 'undefined' values.]
+takeString(s!);
+            ~   [error no-useless-assertion: This assertion is unnecesary as it doesn't change the type of the expression.]
+takeNullable(s!);
+              ~   [error no-useless-assertion: This assertion is unnecesary as it doesn't change the type of the expression.]
+takeNullable(nullable(s)!);
+                        ~   [error no-useless-assertion: This assertion is unnecessary as the receiver accepts 'null' and 'undefined' values.]
+takeString(nonNullable(v)!);
+                         ~   [error no-useless-assertion: This assertion is unnecesary as it doesn't change the type of the expression.]
+
+nullable(s)!;
+nonNullable(s)!;
+              ~  [error no-useless-assertion: This assertion is unnecesary as it doesn't change the type of the expression.]
+nullable(null)!;
+nonNullable(null)!;
+                 ~  [error no-useless-assertion: This assertion is unnecesary as it doesn't change the type of the expression.]
+
+nullable(s) as string;
+nullable(s) as string | null | undefined;
+            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~  [error no-useless-assertion: This assertion is unnecesary as it doesn't change the type of the expression.]
+nonNullable(s) as string;
+               ~~~~~~~~~  [error no-useless-assertion: This assertion is unnecesary as it doesn't change the type of the expression.]
+
+v as NonNullable<typeof s>;
+s as Nullable<string>;
+s as NonNullable<string>;
+  ~~~~~~~~~~~~~~~~~~~~~~  [error no-useless-assertion: This assertion is unnecesary as it doesn't change the type of the expression.]
+(Boolean() ? s : null) as NonNullable<string>;

packages/mimir/src/rules/no-useless-assertion.ts

@@ -110,7 +110,7 @@ export class Rule extends TypedRule {
             isObjectType(targetType) && (targetType.objectFlags & ts.ObjectFlags.Tuple || couldBeTupleType(targetType)))
             return;
         let sourceType = this.checker.getTypeAtLocation(node.expression);
-        if ((targetType.flags & (ts.TypeFlags.TypeParameter)) === 0 && (sourceType.flags & ts.TypeFlags.Literal) === 0) {
+        if ((targetType.flags & ts.TypeFlags.TypeParameter) === 0 && (sourceType.flags & ts.TypeFlags.Literal) === 0) {
             targetType = this.checker.getApparentType(targetType);
             sourceType = this.checker.getApparentType(sourceType);
         }

packages/mimir/test/no-useless-assertion/270-strict.test.json

@@ -1,5 +1,5 @@
 {
   "project": "tsconfig.json",
-  "exclude": ["global2.ts", "definite-assignment.ts"],
+  "files": ["global.ts", "non-null.ts", "type-assertion.ts"],
   "typescriptVersion": "~2.7.0"
 }

packages/mimir/test/no-useless-assertion/conditional-types.test.json

@@ -0,0 +1,5 @@
+{
+  "project": "tsconfig.json",
+  "files": ["conditional-types.ts"],
+  "typescriptVersion": ">= 2.8.0"
+}

packages/mimir/test/no-useless-assertion/conditional-types.ts

@@ -0,0 +1,34 @@
+export {};
+
+type Nullable<T> = T extends null | undefined ? T : T | null | undefined;
+type NonNullable<T> = T extends null | undefined ? never : T;
+
+declare function nullable<T>(param: T): Nullable<T>;
+declare function nonNullable<T>(param: T): NonNullable<T>;
+
+declare function takeString(param: string): void;
+declare function takeNullable(param: Nullable<string>): void;
+
+declare let v: Nullable<string>;
+declare let s: NonNullable<typeof v>;
+
+takeString(v!);
+takeNullable(v!);
+takeString(s!);
+takeNullable(s!);
+takeNullable(nullable(s)!);
+takeString(nonNullable(v)!);
+
+nullable(s)!;
+nonNullable(s)!;
+nullable(null)!;
+nonNullable(null)!;
+
+nullable(s) as string;
+nullable(s) as string | null | undefined;
+nonNullable(s) as string;
+
+v as NonNullable<typeof s>;
+s as Nullable<string>;
+s as NonNullable<string>;
+(Boolean() ? s : null) as NonNullable<string>;

packages/mimir/test/no-useless-assertion/post270-loose.test.json

@@ -1,5 +1,5 @@
 {
   "project": "tsconfig-loose.json",
-  "exclude": ["global2.ts", "definite-assignment.ts"],
+  "files": ["global.ts", "non-null.ts", "type-assertion.ts"],
   "typescriptVersion": ">= 2.7.0"
 }

packages/mimir/test/no-useless-assertion/post270-strict.test.json

@@ -1,5 +1,5 @@
 {
   "project": "tsconfig.json",
-  "exclude": ["global2.ts", "definite-assignment.ts"],
+  "files": ["global.ts", "non-null.ts", "type-assertion.ts"],
   "typescriptVersion": ">= 2.8.0"
 }

packages/mimir/test/no-useless-assertion/pre270-loose.test.json

@@ -1,5 +1,5 @@
 {
   "project": "tsconfig-loose.json",
-  "exclude": ["global2.ts", "definite-assignment.ts"],
+  "files": ["global.ts", "non-null.ts", "type-assertion.ts"],
   "typescriptVersion": "< 2.7.0"
 }

packages/mimir/test/no-useless-assertion/pre270-strict.test.json

@@ -1,5 +1,5 @@
 {
   "project": "tsconfig.json",
-  "exclude": ["global2.ts", "definite-assignment.ts"],
+  "files": ["global.ts", "non-null.ts", "type-assertion.ts"],
   "typescriptVersion": "< 2.7.0"
 }