Fix emit issue regarding null/undefined in type annotations

tests/baselines/reference/constructorArgsErrors1.js

@@ -6,7 +6,7 @@ class foo {
 
 //// [constructorArgsErrors1.js]
 var foo = (function () {
-    function foo(static a) {
+    function foo(a) {
     }
     return foo;
 }());

tests/baselines/reference/constructorArgsErrors5.js

@@ -7,7 +7,7 @@ class foo {
 
 //// [constructorArgsErrors5.js]
 var foo = (function () {
-    function foo(export a) {
+    function foo(a) {
     }
     return foo;
 }());

tests/baselines/reference/parserErrorRecovery_ParameterList6.js

@@ -7,7 +7,6 @@ class Foo {
 var Foo = (function () {
     function Foo() {
     }
-    Foo.prototype.banana = function (x) { };
     return Foo;
 }());
 break ;

tests/baselines/reference/transformsElideNullUndefinedType.js

@@ -0,0 +1,54 @@
+//// [transformsElideNullUndefinedType.ts]
+
+var v0: null;
+var v1: undefined;
+
+function f0(): null { return null; }
+function f1(): undefined { return undefined; }
+
+var f2 = function (): null { return null; }
+var f3 = function (): undefined { return undefined; }
+
+var f4 = (): null => null;
+var f5 = (): undefined => undefined;
+
+function f6(p0: null) { }
+function f7(p1: undefined) { }
+
+class C<T> {
+    m0(): null { return null; }
+    m1(): undefined { return undefined; }
+
+    get a0(): null { return null; }
+    get a1(): undefined { return undefined; }
+}
+
+declare function fn<T>();
+
+fn<null>();
+fn<undefined>();
+
+new C<null>();
+new C<undefined>();
+
+//// [transformsElideNullUndefinedType.js]
+var v0;
+var v1;
+function f0() { return null; }
+function f1() { return undefined; }
+var f2 = function () { return null; };
+var f3 = function () { return undefined; };
+var f4 = () => null;
+var f5 = () => undefined;
+function f6(p0) { }
+function f7(p1) { }
+class C {
+    m0() { return null; }
+    m1() { return undefined; }
+    get a0() { return null; }
+    get a1() { return undefined; }
+}
+fn();
+fn();
+new C();
+new C();

tests/baselines/reference/transformsElideNullUndefinedType.symbols

@@ -0,0 +1,72 @@
+=== tests/cases/compiler/transformsElideNullUndefinedType.ts ===
+
+var v0: null;
+>v0 : Symbol(v0, Decl(transformsElideNullUndefinedType.ts, 1, 3))
+
+var v1: undefined;
+>v1 : Symbol(v1, Decl(transformsElideNullUndefinedType.ts, 2, 3))
+
+function f0(): null { return null; }
+>f0 : Symbol(f0, Decl(transformsElideNullUndefinedType.ts, 2, 18))
+
+function f1(): undefined { return undefined; }
+>f1 : Symbol(f1, Decl(transformsElideNullUndefinedType.ts, 4, 36))
+>undefined : Symbol(undefined)
+
+var f2 = function (): null { return null; }
+>f2 : Symbol(f2, Decl(transformsElideNullUndefinedType.ts, 7, 3))
+
+var f3 = function (): undefined { return undefined; }
+>f3 : Symbol(f3, Decl(transformsElideNullUndefinedType.ts, 8, 3))
+>undefined : Symbol(undefined)
+
+var f4 = (): null => null;
+>f4 : Symbol(f4, Decl(transformsElideNullUndefinedType.ts, 10, 3))
+
+var f5 = (): undefined => undefined;
+>f5 : Symbol(f5, Decl(transformsElideNullUndefinedType.ts, 11, 3))
+>undefined : Symbol(undefined)
+
+function f6(p0: null) { }
+>f6 : Symbol(f6, Decl(transformsElideNullUndefinedType.ts, 11, 36))
+>p0 : Symbol(p0, Decl(transformsElideNullUndefinedType.ts, 13, 12))
+
+function f7(p1: undefined) { }
+>f7 : Symbol(f7, Decl(transformsElideNullUndefinedType.ts, 13, 25))
+>p1 : Symbol(p1, Decl(transformsElideNullUndefinedType.ts, 14, 12))
+
+class C<T> {
+>C : Symbol(C, Decl(transformsElideNullUndefinedType.ts, 14, 30))
+>T : Symbol(T, Decl(transformsElideNullUndefinedType.ts, 16, 8))
+
+    m0(): null { return null; }
+>m0 : Symbol(C.m0, Decl(transformsElideNullUndefinedType.ts, 16, 12))
+
+    m1(): undefined { return undefined; }
+>m1 : Symbol(C.m1, Decl(transformsElideNullUndefinedType.ts, 17, 31))
+>undefined : Symbol(undefined)
+
+    get a0(): null { return null; }
+>a0 : Symbol(C.a0, Decl(transformsElideNullUndefinedType.ts, 18, 41))
+
+    get a1(): undefined { return undefined; }
+>a1 : Symbol(C.a1, Decl(transformsElideNullUndefinedType.ts, 20, 35))
+>undefined : Symbol(undefined)
+}
+
+declare function fn<T>();
+>fn : Symbol(fn, Decl(transformsElideNullUndefinedType.ts, 22, 1))
+>T : Symbol(T, Decl(transformsElideNullUndefinedType.ts, 24, 20))
+
+fn<null>();
+>fn : Symbol(fn, Decl(transformsElideNullUndefinedType.ts, 22, 1))
+
+fn<undefined>();
+>fn : Symbol(fn, Decl(transformsElideNullUndefinedType.ts, 22, 1))
+
+new C<null>();
+>C : Symbol(C, Decl(transformsElideNullUndefinedType.ts, 14, 30))
+
+new C<undefined>();
+>C : Symbol(C, Decl(transformsElideNullUndefinedType.ts, 14, 30))
+

tests/baselines/reference/transformsElideNullUndefinedType.types

@@ -0,0 +1,94 @@
+=== tests/cases/compiler/transformsElideNullUndefinedType.ts ===
+
+var v0: null;
+>v0 : null
+>null : null
+
+var v1: undefined;
+>v1 : undefined
+
+function f0(): null { return null; }
+>f0 : () => null
+>null : null
+>null : null
+
+function f1(): undefined { return undefined; }
+>f1 : () => undefined
+>undefined : undefined
+
+var f2 = function (): null { return null; }
+>f2 : () => null
+>function (): null { return null; } : () => null
+>null : null
+>null : null
+
+var f3 = function (): undefined { return undefined; }
+>f3 : () => undefined
+>function (): undefined { return undefined; } : () => undefined
+>undefined : undefined
+
+var f4 = (): null => null;
+>f4 : () => null
+>(): null => null : () => null
+>null : null
+>null : null
+
+var f5 = (): undefined => undefined;
+>f5 : () => undefined
+>(): undefined => undefined : () => undefined
+>undefined : undefined
+
+function f6(p0: null) { }
+>f6 : (p0: null) => void
+>p0 : null
+>null : null
+
+function f7(p1: undefined) { }
+>f7 : (p1: undefined) => void
+>p1 : undefined
+
+class C<T> {
+>C : C<T>
+>T : T
+
+    m0(): null { return null; }
+>m0 : () => null
+>null : null
+>null : null
+
+    m1(): undefined { return undefined; }
+>m1 : () => undefined
+>undefined : undefined
+
+    get a0(): null { return null; }
+>a0 : null
+>null : null
+>null : null
+
+    get a1(): undefined { return undefined; }
+>a1 : undefined
+>undefined : undefined
+}
+
+declare function fn<T>();
+>fn : <T>() => any
+>T : T
+
+fn<null>();
+>fn<null>() : any
+>fn : <T>() => any
+>null : null
+
+fn<undefined>();
+>fn<undefined>() : any
+>fn : <T>() => any
+
+new C<null>();
+>new C<null>() : C<null>
+>C : typeof C
+>null : null
+
+new C<undefined>();
+>new C<undefined>() : C<undefined>
+>C : typeof C
+

tests/baselines/reference/typeGuardFunctionErrors.js

@@ -171,7 +171,6 @@ var C = (function (_super) {
 function hasANonBooleanReturnStatement(x) {
     return '';
 }
-function hasTypeGuardTypeInsideTypeGuardType(x) { }
 is;
 A;
 {
@@ -232,7 +231,6 @@ function b2(a, A) {
     if (a === void 0) { a = is; }
 }
 ;
-function b3() { }
 is;
 A;
 {

tests/cases/compiler/transformsElideNullUndefinedType.ts

@@ -0,0 +1,32 @@
+// @target: es6
+
+var v0: null;
+var v1: undefined;
+
+function f0(): null { return null; }
+function f1(): undefined { return undefined; }
+
+var f2 = function (): null { return null; }
+var f3 = function (): undefined { return undefined; }
+
+var f4 = (): null => null;
+var f5 = (): undefined => undefined;
+
+function f6(p0: null) { }
+function f7(p1: undefined) { }
+
+class C<T> {
+    m0(): null { return null; }
+    m1(): undefined { return undefined; }
+
+    get a0(): null { return null; }
+    get a1(): undefined { return undefined; }
+}
+
+declare function fn<T>();
+
+fn<null>();
+fn<undefined>();
+
+new C<null>();
+new C<undefined>();