Make never rest type top-like

Author: jack-williams

src/compiler/checker.ts

@@ -25632,7 +25632,7 @@ namespace ts {
 
         function getNonArrayRestType(signature: Signature) {
             const restType = getEffectiveRestType(signature);
-            return restType && !isArrayType(restType) && !isTypeAny(restType) ? restType : undefined;
+            return restType && !isArrayType(restType) && !isTypeAny(restType) && (restType.flags & TypeFlags.Never) === 0 ? restType : undefined;
         }
 
         function getTypeOfFirstParameterOfSignature(signature: Signature) {

tests/baselines/reference/genericRestTypes.js

@@ -11,8 +11,24 @@ type Explicit = (...args: Tail<Parameters<MyFunctionType>>) => ReturnType<MyFunc
 
 type Bind1<T extends (head: any, ...tail: any[]) => any> = (...args: Tail<Parameters<T>>) => ReturnType<T>;
 type Generic = Bind1<MyFunctionType>; // (bar: string) => boolean
+
+function assignmentWithComplexRest<T extends any[]>() {
+    const fn1: (x: string, ...rest: T) => void = (x, ..._) => x;
+    const fn2: (...args: never) => void = fn1;
+    type Fn2Ret = ReturnType<typeof fn2>;
+}
 
 
 //// [genericRestTypes.js]
 "use strict";
 // Repro from #25793
+function assignmentWithComplexRest() {
+    var fn1 = function (x) {
+        var _ = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            _[_i - 1] = arguments[_i];
+        }
+        return x;
+    };
+    var fn2 = fn1;
+}

tests/baselines/reference/genericRestTypes.symbols

@@ -44,3 +44,27 @@ type Generic = Bind1<MyFunctionType>; // (bar: string) => boolean
 >Bind1 : Symbol(Bind1, Decl(genericRestTypes.ts, 8, 90))
 >MyFunctionType : Symbol(MyFunctionType, Decl(genericRestTypes.ts, 4, 110))
 
+function assignmentWithComplexRest<T extends any[]>() {
+>assignmentWithComplexRest : Symbol(assignmentWithComplexRest, Decl(genericRestTypes.ts, 11, 37))
+>T : Symbol(T, Decl(genericRestTypes.ts, 13, 35))
+
+    const fn1: (x: string, ...rest: T) => void = (x, ..._) => x;
+>fn1 : Symbol(fn1, Decl(genericRestTypes.ts, 14, 9))
+>x : Symbol(x, Decl(genericRestTypes.ts, 14, 16))
+>rest : Symbol(rest, Decl(genericRestTypes.ts, 14, 26))
+>T : Symbol(T, Decl(genericRestTypes.ts, 13, 35))
+>x : Symbol(x, Decl(genericRestTypes.ts, 14, 50))
+>_ : Symbol(_, Decl(genericRestTypes.ts, 14, 52))
+>x : Symbol(x, Decl(genericRestTypes.ts, 14, 50))
+
+    const fn2: (...args: never) => void = fn1;
+>fn2 : Symbol(fn2, Decl(genericRestTypes.ts, 15, 9))
+>args : Symbol(args, Decl(genericRestTypes.ts, 15, 16))
+>fn1 : Symbol(fn1, Decl(genericRestTypes.ts, 14, 9))
+
+    type Fn2Ret = ReturnType<typeof fn2>;
+>Fn2Ret : Symbol(Fn2Ret, Decl(genericRestTypes.ts, 15, 46))
+>ReturnType : Symbol(ReturnType, Decl(lib.es5.d.ts, --, --))
+>fn2 : Symbol(fn2, Decl(genericRestTypes.ts, 15, 9))
+}
+

tests/baselines/reference/genericRestTypes.types

@@ -27,3 +27,25 @@ type Bind1<T extends (head: any, ...tail: any[]) => any> = (...args: Tail<Parame
 type Generic = Bind1<MyFunctionType>; // (bar: string) => boolean
 >Generic : Bind1<MyFunctionType>
 
+function assignmentWithComplexRest<T extends any[]>() {
+>assignmentWithComplexRest : <T extends any[]>() => void
+
+    const fn1: (x: string, ...rest: T) => void = (x, ..._) => x;
+>fn1 : (x: string, ...rest: T) => void
+>x : string
+>rest : T
+>(x, ..._) => x : (x: string, ..._: T) => string
+>x : string
+>_ : T
+>x : string
+
+    const fn2: (...args: never) => void = fn1;
+>fn2 : (...args: never) => void
+>args : never
+>fn1 : (x: string, ...rest: T) => void
+
+    type Fn2Ret = ReturnType<typeof fn2>;
+>Fn2Ret : void
+>fn2 : (...args: never) => void
+}
+

tests/cases/compiler/genericRestTypes.ts

@@ -12,3 +12,9 @@ type Explicit = (...args: Tail<Parameters<MyFunctionType>>) => ReturnType<MyFunc
 
 type Bind1<T extends (head: any, ...tail: any[]) => any> = (...args: Tail<Parameters<T>>) => ReturnType<T>;
 type Generic = Bind1<MyFunctionType>; // (bar: string) => boolean
+
+function assignmentWithComplexRest<T extends any[]>() {
+    const fn1: (x: string, ...rest: T) => void = (x, ..._) => x;
+    const fn2: (...args: never) => void = fn1;
+    type Fn2Ret = ReturnType<typeof fn2>;
+}