microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-05-15 12:51:30 -05:00
Code Issues Packages Projects Releases 212 Wiki Activity

Adds tests

Browse Source
This commit is contained in:
Tingan Ho
2015-06-02 12:49:36 +08:00
parent 284b9db268
commit f8e2b99b6c
19 changed files with 2142 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

105
tests/baselines/reference/typeGuardFunction.js Normal file
View File

@@ -0,0 +1,105 @@
//// [typeGuardFunction.ts]
class A {
propA: number;
}
class B {
propB: number;
}
class C extends A {
propC: number;
}
declare function isA(p1: any): p1 is A;
declare function isB(p1: any): p1 is B;
declare function isC(p1: any): p1 is C;
declare function retC(): C;
var a: A;
var b: B;
// Basic.
if (isC(a)) {
a.propC;
}
// Sub type.
var subType: C;
if(isA(subType)) {
subType.propC;
}
// Union type.
var union: A | B;
if(isA(union)) {
union.propA;
}
// The parameter index and argument index for the type guard target is matching.
// The type predicate type is assignable to the parameter type.
declare function isC_multipleParams(p1, p2): p1 is C;
if (isC_multipleParams(a, 0)) {
a.propC;
}
// Evaluations are asssignable to boolean.
declare function acceptingBoolean(a: boolean);
acceptingBoolean(isA(a));
// Type predicates with different parameter name.
declare function acceptingTypeGuardFunction(p1: (item) => item is A);
acceptingTypeGuardFunction(isA);
let union2: C | B;
let union3: boolean | B = isA(union2) || union2;
//// [typeGuardFunction.js]
var __extends = (this && this.__extends) || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
__.prototype = b.prototype;
d.prototype = new __();
};
var A = (function () {
function A() {
}
return A;
})();
var B = (function () {
function B() {
}
return B;
})();
var C = (function (_super) {
__extends(C, _super);
function C() {
_super.apply(this, arguments);
}
return C;
})(A);
var a;
var b;
// Basic.
if (isC(a)) {
a.propC;
}
// Sub type.
var subType;
if (isA(subType)) {
subType.propC;
}
// Union type.
var union;
if (isA(union)) {
union.propA;
}
if (isC_multipleParams(a, 0)) {
a.propC;
}
acceptingBoolean(isA(a));
acceptingTypeGuardFunction(isA);
var union2;
var union3 = isA(union2) || union2;

144
tests/baselines/reference/typeGuardFunction.symbols Normal file
View File

@@ -0,0 +1,144 @@
=== tests/cases/conformance/expressions/typeGuards/typeGuardFunction.ts ===
class A {
>A : Symbol(A, Decl(typeGuardFunction.ts, 0, 0))
propA: number;
>propA : Symbol(propA, Decl(typeGuardFunction.ts, 1, 9))
}
class B {
>B : Symbol(B, Decl(typeGuardFunction.ts, 3, 1))
propB: number;
>propB : Symbol(propB, Decl(typeGuardFunction.ts, 5, 9))
}
class C extends A {
>C : Symbol(C, Decl(typeGuardFunction.ts, 7, 1))
>A : Symbol(A, Decl(typeGuardFunction.ts, 0, 0))
propC: number;
>propC : Symbol(propC, Decl(typeGuardFunction.ts, 9, 19))
}
declare function isA(p1: any): p1 is A;
>isA : Symbol(isA, Decl(typeGuardFunction.ts, 11, 1))
>p1 : Symbol(p1, Decl(typeGuardFunction.ts, 13, 21))
>A : Symbol(A, Decl(typeGuardFunction.ts, 0, 0))
declare function isB(p1: any): p1 is B;
>isB : Symbol(isB, Decl(typeGuardFunction.ts, 13, 39))
>p1 : Symbol(p1, Decl(typeGuardFunction.ts, 14, 21))
>B : Symbol(B, Decl(typeGuardFunction.ts, 3, 1))
declare function isC(p1: any): p1 is C;
>isC : Symbol(isC, Decl(typeGuardFunction.ts, 14, 39))
>p1 : Symbol(p1, Decl(typeGuardFunction.ts, 15, 21))
>C : Symbol(C, Decl(typeGuardFunction.ts, 7, 1))
declare function retC(): C;
>retC : Symbol(retC, Decl(typeGuardFunction.ts, 15, 39))
>C : Symbol(C, Decl(typeGuardFunction.ts, 7, 1))
var a: A;
>a : Symbol(a, Decl(typeGuardFunction.ts, 19, 3))
>A : Symbol(A, Decl(typeGuardFunction.ts, 0, 0))
var b: B;
>b : Symbol(b, Decl(typeGuardFunction.ts, 20, 3))
>B : Symbol(B, Decl(typeGuardFunction.ts, 3, 1))
// Basic.
if (isC(a)) {
>isC : Symbol(isC, Decl(typeGuardFunction.ts, 14, 39))
>a : Symbol(a, Decl(typeGuardFunction.ts, 19, 3))
a.propC;
>a.propC : Symbol(C.propC, Decl(typeGuardFunction.ts, 9, 19))
>a : Symbol(a, Decl(typeGuardFunction.ts, 19, 3))
>propC : Symbol(C.propC, Decl(typeGuardFunction.ts, 9, 19))
}
// Sub type.
var subType: C;
>subType : Symbol(subType, Decl(typeGuardFunction.ts, 28, 3))
>C : Symbol(C, Decl(typeGuardFunction.ts, 7, 1))
if(isA(subType)) {
>isA : Symbol(isA, Decl(typeGuardFunction.ts, 11, 1))
>subType : Symbol(subType, Decl(typeGuardFunction.ts, 28, 3))
subType.propC;
>subType.propC : Symbol(C.propC, Decl(typeGuardFunction.ts, 9, 19))
>subType : Symbol(subType, Decl(typeGuardFunction.ts, 28, 3))
>propC : Symbol(C.propC, Decl(typeGuardFunction.ts, 9, 19))
}
// Union type.
var union: A | B;
>union : Symbol(union, Decl(typeGuardFunction.ts, 34, 3))
>A : Symbol(A, Decl(typeGuardFunction.ts, 0, 0))
>B : Symbol(B, Decl(typeGuardFunction.ts, 3, 1))
if(isA(union)) {
>isA : Symbol(isA, Decl(typeGuardFunction.ts, 11, 1))
>union : Symbol(union, Decl(typeGuardFunction.ts, 34, 3))
union.propA;
>union.propA : Symbol(A.propA, Decl(typeGuardFunction.ts, 1, 9))
>union : Symbol(union, Decl(typeGuardFunction.ts, 34, 3))
>propA : Symbol(A.propA, Decl(typeGuardFunction.ts, 1, 9))
}
// The parameter index and argument index for the type guard target is matching.
// The type predicate type is assignable to the parameter type.
declare function isC_multipleParams(p1, p2): p1 is C;
>isC_multipleParams : Symbol(isC_multipleParams, Decl(typeGuardFunction.ts, 37, 1))
>p1 : Symbol(p1, Decl(typeGuardFunction.ts, 41, 36))
>p2 : Symbol(p2, Decl(typeGuardFunction.ts, 41, 39))
>C : Symbol(C, Decl(typeGuardFunction.ts, 7, 1))
if (isC_multipleParams(a, 0)) {
>isC_multipleParams : Symbol(isC_multipleParams, Decl(typeGuardFunction.ts, 37, 1))
>a : Symbol(a, Decl(typeGuardFunction.ts, 19, 3))
a.propC;
>a.propC : Symbol(C.propC, Decl(typeGuardFunction.ts, 9, 19))
>a : Symbol(a, Decl(typeGuardFunction.ts, 19, 3))
>propC : Symbol(C.propC, Decl(typeGuardFunction.ts, 9, 19))
}
// Evaluations are asssignable to boolean.
declare function acceptingBoolean(a: boolean);
>acceptingBoolean : Symbol(acceptingBoolean, Decl(typeGuardFunction.ts, 44, 1))
>a : Symbol(a, Decl(typeGuardFunction.ts, 47, 34))
acceptingBoolean(isA(a));
>acceptingBoolean : Symbol(acceptingBoolean, Decl(typeGuardFunction.ts, 44, 1))
>isA : Symbol(isA, Decl(typeGuardFunction.ts, 11, 1))
>a : Symbol(a, Decl(typeGuardFunction.ts, 19, 3))
// Type predicates with different parameter name.
declare function acceptingTypeGuardFunction(p1: (item) => item is A);
>acceptingTypeGuardFunction : Symbol(acceptingTypeGuardFunction, Decl(typeGuardFunction.ts, 48, 25))
>p1 : Symbol(p1, Decl(typeGuardFunction.ts, 51, 44))
>item : Symbol(item, Decl(typeGuardFunction.ts, 51, 49))
>A : Symbol(A, Decl(typeGuardFunction.ts, 0, 0))
acceptingTypeGuardFunction(isA);
>acceptingTypeGuardFunction : Symbol(acceptingTypeGuardFunction, Decl(typeGuardFunction.ts, 48, 25))
>isA : Symbol(isA, Decl(typeGuardFunction.ts, 11, 1))
let union2: C | B;
>union2 : Symbol(union2, Decl(typeGuardFunction.ts, 54, 3))
>C : Symbol(C, Decl(typeGuardFunction.ts, 7, 1))
>B : Symbol(B, Decl(typeGuardFunction.ts, 3, 1))
let union3: boolean | B = isA(union2) || union2;
>union3 : Symbol(union3, Decl(typeGuardFunction.ts, 55, 3))
>B : Symbol(B, Decl(typeGuardFunction.ts, 3, 1))
>isA : Symbol(isA, Decl(typeGuardFunction.ts, 11, 1))
>union2 : Symbol(union2, Decl(typeGuardFunction.ts, 54, 3))
>union2 : Symbol(union2, Decl(typeGuardFunction.ts, 54, 3))

159
tests/baselines/reference/typeGuardFunction.types Normal file
View File

@@ -0,0 +1,159 @@
=== tests/cases/conformance/expressions/typeGuards/typeGuardFunction.ts ===
class A {
>A : A
propA: number;
>propA : number
}
class B {
>B : B
propB: number;
>propB : number
}
class C extends A {
>C : C
>A : A
propC: number;
>propC : number
}
declare function isA(p1: any): p1 is A;
>isA : (p1: any) => boolean
>p1 : any
>p1 : any
>A : A
declare function isB(p1: any): p1 is B;
>isB : (p1: any) => boolean
>p1 : any
>p1 : any
>B : B
declare function isC(p1: any): p1 is C;
>isC : (p1: any) => boolean
>p1 : any
>p1 : any
>C : C
declare function retC(): C;
>retC : () => C
>C : C
var a: A;
>a : A
>A : A
var b: B;
>b : B
>B : B
// Basic.
if (isC(a)) {
>isC(a) : boolean
>isC : (p1: any) => boolean
>a : A
a.propC;
>a.propC : number
>a : C
>propC : number
}
// Sub type.
var subType: C;
>subType : C
>C : C
if(isA(subType)) {
>isA(subType) : boolean
>isA : (p1: any) => boolean
>subType : C
subType.propC;
>subType.propC : number
>subType : C
>propC : number
}
// Union type.
var union: A | B;
>union : A | B
>A : A
>B : B
if(isA(union)) {
>isA(union) : boolean
>isA : (p1: any) => boolean
>union : A | B
union.propA;
>union.propA : number
>union : A
>propA : number
}
// The parameter index and argument index for the type guard target is matching.
// The type predicate type is assignable to the parameter type.
declare function isC_multipleParams(p1, p2): p1 is C;
>isC_multipleParams : (p1: any, p2: any) => boolean
>p1 : any
>p2 : any
>p1 : any
>C : C
if (isC_multipleParams(a, 0)) {
>isC_multipleParams(a, 0) : boolean
>isC_multipleParams : (p1: any, p2: any) => boolean
>a : A
>0 : number
a.propC;
>a.propC : number
>a : C
>propC : number
}
// Evaluations are asssignable to boolean.
declare function acceptingBoolean(a: boolean);
>acceptingBoolean : (a: boolean) => any
>a : boolean
acceptingBoolean(isA(a));
>acceptingBoolean(isA(a)) : any
>acceptingBoolean : (a: boolean) => any
>isA(a) : boolean
>isA : (p1: any) => boolean
>a : A
// Type predicates with different parameter name.
declare function acceptingTypeGuardFunction(p1: (item) => item is A);
>acceptingTypeGuardFunction : (p1: (item: any) => boolean) => any
>p1 : (item: any) => boolean
>item : any
>item : any
>A : A
acceptingTypeGuardFunction(isA);
>acceptingTypeGuardFunction(isA) : any
>acceptingTypeGuardFunction : (p1: (item: any) => boolean) => any
>isA : (p1: any) => boolean
let union2: C | B;
>union2 : B | C
>C : C
>B : B
let union3: boolean | B = isA(union2) || union2;
>union3 : boolean | B
>B : B
>isA(union2) || union2 : boolean | B
>isA(union2) : boolean
>isA : (p1: any) => boolean
>union2 : B | C
>union2 : B

174
tests/baselines/reference/typeGuardFunctionErrors.errors.txt Normal file
View File

@@ -0,0 +1,174 @@
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(15,12): error TS1225: A type-guard function can only return a boolean.
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(18,55): error TS2304: Cannot find name 'x'.
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(18,57): error TS1144: '{' or ';' expected.
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(18,57): error TS2304: Cannot find name 'is'.
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(18,60): error TS1005: ';' expected.
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(18,62): error TS1005: ';' expected.
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(22,33): error TS2304: Cannot find name 'x'.
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(26,10): error TS2391: Function implementation is missing or not immediately following the declaration.
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(27,5): error TS1131: Property or signature expected.
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(28,1): error TS1128: Declaration or statement expected.
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(30,38): error TS1226: Cannot find parameter 'x'.
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(34,51): error TS2322: Type 'B' is not assignable to type 'A'.
Property 'propA' is missing in type 'B'.
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(38,56): error TS2322: Type 'number' is not assignable to type 'string'.
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(42,56): error TS2322: Type 'T[]' is not assignable to type 'string'.
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(56,7): error TS2339: Property 'propB' does not exist on type 'A'.
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(61,7): error TS2339: Property 'propB' does not exist on type 'A'.
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(66,7): error TS2339: Property 'propB' does not exist on type 'A'.
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(71,46): error TS2345: Argument of type '(p1: any) => boolean' is not assignable to parameter of type '(p1: any) => boolean'.
Type-guard annotation 'p1 is C' is not assignable to 'p1 is B'.
Type 'C' is not assignable to type 'B'.
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(75,1): error TS2322: Type '(p1: any, p2: any) => boolean' is not assignable to type '(p1: any, p2: any) => boolean'.
A non-type guard function is not assignable to a type guard function.
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(81,1): error TS2322: Type '(p1: any, p2: any) => boolean' is not assignable to type '(p1: any, p2: any) => boolean'.
Type-guard annotation 'p2 is A' is not assignable to 'p1 is A'.
Parameter index from 'p2' does not match the parameter index from 'p1'.
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(87,1): error TS2322: Type '(p1: any, p2: any, p3: any) => boolean' is not assignable to type '(p1: any, p2: any) => boolean'.
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(92,56): error TS1226: Cannot find parameter 'p1'.
==== tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts (22 errors) ====
class A {
propA: number;
}
class B {
propB: number;
}
class C extends A {
propC: number;
}
function hasANonBooleanReturnStatement(x): x is A {
return '';
~~
!!! error TS1225: A type-guard function can only return a boolean.
}
function hasTypeGuardTypeInsideTypeGuardType(x): x is x is A {
~
!!! error TS2304: Cannot find name 'x'.
~~
!!! error TS1144: '{' or ';' expected.
~~
!!! error TS2304: Cannot find name 'is'.
~
!!! error TS1005: ';' expected.
~
!!! error TS1005: ';' expected.
return true;
}
function hasMissingIsKeyword(): x {
~
!!! error TS2304: Cannot find name 'x'.
return true;
}
function hasMissingTypeInTypeGuardType(x): x is {
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2391: Function implementation is missing or not immediately following the declaration.
return true;
~~~~~~
!!! error TS1131: Property or signature expected.
}
~
!!! error TS1128: Declaration or statement expected.
function hasNonMatchingParameter(y): x is A {
~
!!! error TS1226: Cannot find parameter 'x'.
return true;
}
function hasNonMatchingParameterType1(x: A): x is B {
~
!!! error TS2322: Type 'B' is not assignable to type 'A'.
!!! error TS2322: Property 'propA' is missing in type 'B'.
return true;
}
function hasNonMatchingParameterType2(x: string): x is number {
~~~~~~
!!! error TS2322: Type 'number' is not assignable to type 'string'.
return true;
}
function hasNonMathcingGenericType<T>(a: string): a is T[] {
~~~
!!! error TS2322: Type 'T[]' is not assignable to type 'string'.
return true;
}
let a: A;
let b: B;
declare function isB(p1): p1 is B;
declare function isC(p1): p1 is C;
declare function funA(p1: any, p2: any): p1 is B;
declare function hasNoTypeGuard(x);
// Passed argument is not the same as the one being guarded.
if (isB(b)) {
a.propB;
~~~~~
!!! error TS2339: Property 'propB' does not exist on type 'A'.
}
// Parameter index and argument index for the type guard target is not matching.
if (funA(0, a)) {
a.propB; // Error
~~~~~
!!! error TS2339: Property 'propB' does not exist on type 'A'.
}
// No type guard in if statement
if (hasNoTypeGuard(a)) {
a.propB;
~~~~~
!!! error TS2339: Property 'propB' does not exist on type 'A'.
}
// Type predicate type is not assignable
declare function acceptingDifferentSignatureTypeGuardFunction(p1: (p1) => p1 is B);
acceptingDifferentSignatureTypeGuardFunction(isC);
~~~
!!! error TS2345: Argument of type '(p1: any) => boolean' is not assignable to parameter of type '(p1: any) => boolean'.
!!! error TS2345: Type-guard annotation 'p1 is C' is not assignable to 'p1 is B'.
!!! error TS2345: Type 'C' is not assignable to type 'B'.
// Boolean not assignable to type guard
var assign1: (p1, p2) => p1 is A;
assign1 = function(p1, p2): boolean {
~~~~~~~
!!! error TS2322: Type '(p1: any, p2: any) => boolean' is not assignable to type '(p1: any, p2: any) => boolean'.
!!! error TS2322: A non-type guard function is not assignable to a type guard function.
return true;
};
// Must have matching parameter index
var assign2: (p1, p2) => p1 is A;
assign2 = function(p1, p2): p2 is A {
~~~~~~~
!!! error TS2322: Type '(p1: any, p2: any) => boolean' is not assignable to type '(p1: any, p2: any) => boolean'.
!!! error TS2322: Type-guard annotation 'p2 is A' is not assignable to 'p1 is A'.
!!! error TS2322: Parameter index from 'p2' does not match the parameter index from 'p1'.
return true;
};
// No matching signature
var assign3: (p1, p2) => p1 is A;
assign3 = function(p1, p2, p3): p1 is A {
~~~~~~~
!!! error TS2322: Type '(p1: any, p2: any, p3: any) => boolean' is not assignable to type '(p1: any, p2: any) => boolean'.
return true;
};
// Type guard paramater referring to a binding pattern
declare function destructureParameter({ p1, p2, p3 }): p1 is A;
~~
!!! error TS1226: Cannot find parameter 'p1'.

173
tests/baselines/reference/typeGuardFunctionErrors.js Normal file
View File

@@ -0,0 +1,173 @@
//// [typeGuardFunctionErrors.ts]
class A {
propA: number;
}
class B {
propB: number;
}
class C extends A {
propC: number;
}
function hasANonBooleanReturnStatement(x): x is A {
return '';
}
function hasTypeGuardTypeInsideTypeGuardType(x): x is x is A {
return true;
}
function hasMissingIsKeyword(): x {
return true;
}
function hasMissingTypeInTypeGuardType(x): x is {
return true;
}
function hasNonMatchingParameter(y): x is A {
return true;
}
function hasNonMatchingParameterType1(x: A): x is B {
return true;
}
function hasNonMatchingParameterType2(x: string): x is number {
return true;
}
function hasNonMathcingGenericType<T>(a: string): a is T[] {
return true;
}
let a: A;
let b: B;
declare function isB(p1): p1 is B;
declare function isC(p1): p1 is C;
declare function funA(p1: any, p2: any): p1 is B;
declare function hasNoTypeGuard(x);
// Passed argument is not the same as the one being guarded.
if (isB(b)) {
a.propB;
}
// Parameter index and argument index for the type guard target is not matching.
if (funA(0, a)) {
a.propB; // Error
}
// No type guard in if statement
if (hasNoTypeGuard(a)) {
a.propB;
}
// Type predicate type is not assignable
declare function acceptingDifferentSignatureTypeGuardFunction(p1: (p1) => p1 is B);
acceptingDifferentSignatureTypeGuardFunction(isC);
// Boolean not assignable to type guard
var assign1: (p1, p2) => p1 is A;
assign1 = function(p1, p2): boolean {
return true;
};
// Must have matching parameter index
var assign2: (p1, p2) => p1 is A;
assign2 = function(p1, p2): p2 is A {
return true;
};
// No matching signature
var assign3: (p1, p2) => p1 is A;
assign3 = function(p1, p2, p3): p1 is A {
return true;
};
// Type guard paramater referring to a binding pattern
declare function destructureParameter({ p1, p2, p3 }): p1 is A;
//// [typeGuardFunctionErrors.js]
var __extends = (this && this.__extends) || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
__.prototype = b.prototype;
d.prototype = new __();
};
var A = (function () {
function A() {
}
return A;
})();
var B = (function () {
function B() {
}
return B;
})();
var C = (function (_super) {
__extends(C, _super);
function C() {
_super.apply(this, arguments);
}
return C;
})(A);
function hasANonBooleanReturnStatement(x) {
return '';
}
is;
A;
{
return true;
}
function hasMissingIsKeyword() {
return true;
}
return true;
function hasNonMatchingParameter(y) {
return true;
}
function hasNonMatchingParameterType1(x) {
return true;
}
function hasNonMatchingParameterType2(x) {
return true;
}
function hasNonMathcingGenericType(a) {
return true;
}
var a;
var b;
// Passed argument is not the same as the one being guarded.
if (isB(b)) {
a.propB;
}
// Parameter index and argument index for the type guard target is not matching.
if (funA(0, a)) {
a.propB; // Error
}
// No type guard in if statement
if (hasNoTypeGuard(a)) {
a.propB;
}
acceptingDifferentSignatureTypeGuardFunction(isC);
// Boolean not assignable to type guard
var assign1;
assign1 = function (p1, p2) {
return true;
};
// Must have matching parameter index
var assign2;
assign2 = function (p1, p2) {
return true;
};
// No matching signature
var assign3;
assign3 = function (p1, p2, p3) {
return true;
};

69
tests/baselines/reference/typeGuardFunctionGenerics.js Normal file
View File

@@ -0,0 +1,69 @@
//// [typeGuardFunctionGenerics.ts]
class A {
propA: number;
}
class B {
propB: number;
}
class C extends A {
propC: number;
}
declare function isB(p1): p1 is B;
declare function isC(p1): p1 is C;
declare function retC(x): C;
declare function funA<T>(p1: (p1) => T): T;
declare function funB<T>(p1: (p1) => T, p2: any): p2 is T;
declare function funC<T>(p1: (p1) => p1 is T): T;
declare function funD<T>(p1: (p1) => p1 is T, p2: any): p2 is T;
declare function funE<T, U>(p1: (p1) => p1 is T, p2: U): T;
let a: A;
let test1: boolean = funA(isB);
if (funB(retC, a)) {
a.propC;
}
let test2: B = funC(isB);
if (funD(isC, a)) {
a.propC;
}
let test3: B = funE(isB, 1);
//// [typeGuardFunctionGenerics.js]
var __extends = (this && this.__extends) || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
__.prototype = b.prototype;
d.prototype = new __();
};
var A = (function () {
function A() {
}
return A;
})();
var B = (function () {
function B() {
}
return B;
})();
var C = (function (_super) {
__extends(C, _super);
function C() {
_super.apply(this, arguments);
}
return C;
})(A);
var a;
var test1 = funA(isB);
if (funB(retC, a)) {
a.propC;
}
var test2 = funC(isB);
if (funD(isC, a)) {
a.propC;
}
var test3 = funE(isB, 1);

125
tests/baselines/reference/typeGuardFunctionGenerics.symbols Normal file
View File

@@ -0,0 +1,125 @@
=== tests/cases/conformance/expressions/typeGuards/typeGuardFunctionGenerics.ts ===
class A {
>A : Symbol(A, Decl(typeGuardFunctionGenerics.ts, 0, 0))
propA: number;
>propA : Symbol(propA, Decl(typeGuardFunctionGenerics.ts, 1, 9))
}
class B {
>B : Symbol(B, Decl(typeGuardFunctionGenerics.ts, 3, 1))
propB: number;
>propB : Symbol(propB, Decl(typeGuardFunctionGenerics.ts, 5, 9))
}
class C extends A {
>C : Symbol(C, Decl(typeGuardFunctionGenerics.ts, 7, 1))
>A : Symbol(A, Decl(typeGuardFunctionGenerics.ts, 0, 0))
propC: number;
>propC : Symbol(propC, Decl(typeGuardFunctionGenerics.ts, 9, 19))
}
declare function isB(p1): p1 is B;
>isB : Symbol(isB, Decl(typeGuardFunctionGenerics.ts, 11, 1))
>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 13, 21))
>B : Symbol(B, Decl(typeGuardFunctionGenerics.ts, 3, 1))
declare function isC(p1): p1 is C;
>isC : Symbol(isC, Decl(typeGuardFunctionGenerics.ts, 13, 34))
>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 14, 21))
>C : Symbol(C, Decl(typeGuardFunctionGenerics.ts, 7, 1))
declare function retC(x): C;
>retC : Symbol(retC, Decl(typeGuardFunctionGenerics.ts, 14, 34))
>x : Symbol(x, Decl(typeGuardFunctionGenerics.ts, 15, 22))
>C : Symbol(C, Decl(typeGuardFunctionGenerics.ts, 7, 1))
declare function funA<T>(p1: (p1) => T): T;
>funA : Symbol(funA, Decl(typeGuardFunctionGenerics.ts, 15, 28))
>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 17, 22))
>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 17, 25))
>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 17, 30))
>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 17, 22))
>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 17, 22))
declare function funB<T>(p1: (p1) => T, p2: any): p2 is T;
>funB : Symbol(funB, Decl(typeGuardFunctionGenerics.ts, 17, 43))
>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 18, 22))
>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 18, 25))
>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 18, 30))
>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 18, 22))
>p2 : Symbol(p2, Decl(typeGuardFunctionGenerics.ts, 18, 39))
>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 18, 22))
declare function funC<T>(p1: (p1) => p1 is T): T;
>funC : Symbol(funC, Decl(typeGuardFunctionGenerics.ts, 18, 58))
>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 19, 22))
>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 19, 25))
>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 19, 30))
>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 19, 22))
>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 19, 22))
declare function funD<T>(p1: (p1) => p1 is T, p2: any): p2 is T;
>funD : Symbol(funD, Decl(typeGuardFunctionGenerics.ts, 19, 49))
>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 20, 22))
>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 20, 25))
>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 20, 30))
>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 20, 22))
>p2 : Symbol(p2, Decl(typeGuardFunctionGenerics.ts, 20, 45))
>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 20, 22))
declare function funE<T, U>(p1: (p1) => p1 is T, p2: U): T;
>funE : Symbol(funE, Decl(typeGuardFunctionGenerics.ts, 20, 64))
>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 21, 22))
>U : Symbol(U, Decl(typeGuardFunctionGenerics.ts, 21, 24))
>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 21, 28))
>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 21, 33))
>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 21, 22))
>p2 : Symbol(p2, Decl(typeGuardFunctionGenerics.ts, 21, 48))
>U : Symbol(U, Decl(typeGuardFunctionGenerics.ts, 21, 24))
>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 21, 22))
let a: A;
>a : Symbol(a, Decl(typeGuardFunctionGenerics.ts, 23, 3))
>A : Symbol(A, Decl(typeGuardFunctionGenerics.ts, 0, 0))
let test1: boolean = funA(isB);
>test1 : Symbol(test1, Decl(typeGuardFunctionGenerics.ts, 24, 3))
>funA : Symbol(funA, Decl(typeGuardFunctionGenerics.ts, 15, 28))
>isB : Symbol(isB, Decl(typeGuardFunctionGenerics.ts, 11, 1))
if (funB(retC, a)) {
>funB : Symbol(funB, Decl(typeGuardFunctionGenerics.ts, 17, 43))
>retC : Symbol(retC, Decl(typeGuardFunctionGenerics.ts, 14, 34))
>a : Symbol(a, Decl(typeGuardFunctionGenerics.ts, 23, 3))
a.propC;
>a.propC : Symbol(C.propC, Decl(typeGuardFunctionGenerics.ts, 9, 19))
>a : Symbol(a, Decl(typeGuardFunctionGenerics.ts, 23, 3))
>propC : Symbol(C.propC, Decl(typeGuardFunctionGenerics.ts, 9, 19))
}
let test2: B = funC(isB);
>test2 : Symbol(test2, Decl(typeGuardFunctionGenerics.ts, 28, 3))
>B : Symbol(B, Decl(typeGuardFunctionGenerics.ts, 3, 1))
>funC : Symbol(funC, Decl(typeGuardFunctionGenerics.ts, 18, 58))
>isB : Symbol(isB, Decl(typeGuardFunctionGenerics.ts, 11, 1))
if (funD(isC, a)) {
>funD : Symbol(funD, Decl(typeGuardFunctionGenerics.ts, 19, 49))
>isC : Symbol(isC, Decl(typeGuardFunctionGenerics.ts, 13, 34))
>a : Symbol(a, Decl(typeGuardFunctionGenerics.ts, 23, 3))
a.propC;
>a.propC : Symbol(C.propC, Decl(typeGuardFunctionGenerics.ts, 9, 19))
>a : Symbol(a, Decl(typeGuardFunctionGenerics.ts, 23, 3))
>propC : Symbol(C.propC, Decl(typeGuardFunctionGenerics.ts, 9, 19))
}
let test3: B = funE(isB, 1);
>test3 : Symbol(test3, Decl(typeGuardFunctionGenerics.ts, 32, 3))
>B : Symbol(B, Decl(typeGuardFunctionGenerics.ts, 3, 1))
>funE : Symbol(funE, Decl(typeGuardFunctionGenerics.ts, 20, 64))
>isB : Symbol(isB, Decl(typeGuardFunctionGenerics.ts, 11, 1))

138
tests/baselines/reference/typeGuardFunctionGenerics.types Normal file
View File

@@ -0,0 +1,138 @@
=== tests/cases/conformance/expressions/typeGuards/typeGuardFunctionGenerics.ts ===
class A {
>A : A
propA: number;
>propA : number
}
class B {
>B : B
propB: number;
>propB : number
}
class C extends A {
>C : C
>A : A
propC: number;
>propC : number
}
declare function isB(p1): p1 is B;
>isB : (p1: any) => boolean
>p1 : any
>p1 : any
>B : B
declare function isC(p1): p1 is C;
>isC : (p1: any) => boolean
>p1 : any
>p1 : any
>C : C
declare function retC(x): C;
>retC : (x: any) => C
>x : any
>C : C
declare function funA<T>(p1: (p1) => T): T;
>funA : <T>(p1: (p1: any) => T) => T
>T : T
>p1 : (p1: any) => T
>p1 : any
>T : T
>T : T
declare function funB<T>(p1: (p1) => T, p2: any): p2 is T;
>funB : <T>(p1: (p1: any) => T, p2: any) => boolean
>T : T
>p1 : (p1: any) => T
>p1 : any
>T : T
>p2 : any
>p2 : any
>T : T
declare function funC<T>(p1: (p1) => p1 is T): T;
>funC : <T>(p1: (p1: any) => boolean) => T
>T : T
>p1 : (p1: any) => boolean
>p1 : any
>p1 : any
>T : T
>T : T
declare function funD<T>(p1: (p1) => p1 is T, p2: any): p2 is T;
>funD : <T>(p1: (p1: any) => boolean, p2: any) => boolean
>T : T
>p1 : (p1: any) => boolean
>p1 : any
>p1 : any
>T : T
>p2 : any
>p2 : any
>T : T
declare function funE<T, U>(p1: (p1) => p1 is T, p2: U): T;
>funE : <T, U>(p1: (p1: any) => boolean, p2: U) => T
>T : T
>U : U
>p1 : (p1: any) => boolean
>p1 : any
>p1 : any
>T : T
>p2 : U
>U : U
>T : T
let a: A;
>a : A
>A : A
let test1: boolean = funA(isB);
>test1 : boolean
>funA(isB) : boolean
>funA : <T>(p1: (p1: any) => T) => T
>isB : (p1: any) => boolean
if (funB(retC, a)) {
>funB(retC, a) : boolean
>funB : <T>(p1: (p1: any) => T, p2: any) => boolean
>retC : (x: any) => C
>a : A
a.propC;
>a.propC : number
>a : C
>propC : number
}
let test2: B = funC(isB);
>test2 : B
>B : B
>funC(isB) : B
>funC : <T>(p1: (p1: any) => boolean) => T
>isB : (p1: any) => boolean
if (funD(isC, a)) {
>funD(isC, a) : boolean
>funD : <T>(p1: (p1: any) => boolean, p2: any) => boolean
>isC : (p1: any) => boolean
>a : A
a.propC;
>a.propC : number
>a : C
>propC : number
}
let test3: B = funE(isB, 1);
>test3 : B
>B : B
>funE(isB, 1) : B
>funE : <T, U>(p1: (p1: any) => boolean, p2: U) => T
>isB : (p1: any) => boolean
>1 : number

85
tests/baselines/reference/typeGuardOfFormIsType.js Normal file
View File

@@ -0,0 +1,85 @@
//// [typeGuardOfFormIsType.ts]
class C1 {
p1: string;
}
class C2 {
p2: number;
}
class D1 extends C1 {
p3: number;
}
var str: string;
var num: number;
var strOrNum: string | number;
function isC1(x: any): x is C1 {
return true;
}
function isC2(x: any): x is C2 {
return true;
}
function isD1(x: any): x is D1 {
return true;
}
var c1Orc2: C1 | C2;
str = isC1(c1Orc2) && c1Orc2.p1; // C1
num = isC2(c1Orc2) && c1Orc2.p2; // C2
str = isD1(c1Orc2) && c1Orc2.p1; // D1
num = isD1(c1Orc2) && c1Orc2.p3; // D1
var c2Ord1: C2 | D1;
num = isC2(c2Ord1) && c2Ord1.p2; // C2
num = isD1(c2Ord1) && c2Ord1.p3; // D1
str = isD1(c2Ord1) && c2Ord1.p1; // D1
var r2: C2 | D1 = isC1(c2Ord1) && c2Ord1; // C2 | D1
//// [typeGuardOfFormIsType.js]
var __extends = (this && this.__extends) || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
__.prototype = b.prototype;
d.prototype = new __();
};
var C1 = (function () {
function C1() {
}
return C1;
})();
var C2 = (function () {
function C2() {
}
return C2;
})();
var D1 = (function (_super) {
__extends(D1, _super);
function D1() {
_super.apply(this, arguments);
}
return D1;
})(C1);
var str;
var num;
var strOrNum;
function isC1(x) {
return true;
}
function isC2(x) {
return true;
}
function isD1(x) {
return true;
}
var c1Orc2;
str = isC1(c1Orc2) && c1Orc2.p1; // C1
num = isC2(c1Orc2) && c1Orc2.p2; // C2
str = isD1(c1Orc2) && c1Orc2.p1; // D1
num = isD1(c1Orc2) && c1Orc2.p3; // D1
var c2Ord1;
num = isC2(c2Ord1) && c2Ord1.p2; // C2
num = isD1(c2Ord1) && c2Ord1.p3; // D1
str = isD1(c2Ord1) && c2Ord1.p1; // D1
var r2 = isC1(c2Ord1) && c2Ord1; // C2 | D1

128
tests/baselines/reference/typeGuardOfFormIsType.symbols Normal file
View File

@@ -0,0 +1,128 @@
=== tests/cases/conformance/expressions/typeGuards/typeGuardOfFormIsType.ts ===
class C1 {
>C1 : Symbol(C1, Decl(typeGuardOfFormIsType.ts, 0, 0))
p1: string;
>p1 : Symbol(p1, Decl(typeGuardOfFormIsType.ts, 1, 10))
}
class C2 {
>C2 : Symbol(C2, Decl(typeGuardOfFormIsType.ts, 3, 1))
p2: number;
>p2 : Symbol(p2, Decl(typeGuardOfFormIsType.ts, 4, 10))
}
class D1 extends C1 {
>D1 : Symbol(D1, Decl(typeGuardOfFormIsType.ts, 6, 1))
>C1 : Symbol(C1, Decl(typeGuardOfFormIsType.ts, 0, 0))
p3: number;
>p3 : Symbol(p3, Decl(typeGuardOfFormIsType.ts, 7, 21))
}
var str: string;
>str : Symbol(str, Decl(typeGuardOfFormIsType.ts, 10, 3))
var num: number;
>num : Symbol(num, Decl(typeGuardOfFormIsType.ts, 11, 3))
var strOrNum: string | number;
>strOrNum : Symbol(strOrNum, Decl(typeGuardOfFormIsType.ts, 12, 3))
function isC1(x: any): x is C1 {
>isC1 : Symbol(isC1, Decl(typeGuardOfFormIsType.ts, 12, 30))
>x : Symbol(x, Decl(typeGuardOfFormIsType.ts, 14, 14))
>C1 : Symbol(C1, Decl(typeGuardOfFormIsType.ts, 0, 0))
return true;
}
function isC2(x: any): x is C2 {
>isC2 : Symbol(isC2, Decl(typeGuardOfFormIsType.ts, 16, 1))
>x : Symbol(x, Decl(typeGuardOfFormIsType.ts, 18, 14))
>C2 : Symbol(C2, Decl(typeGuardOfFormIsType.ts, 3, 1))
return true;
}
function isD1(x: any): x is D1 {
>isD1 : Symbol(isD1, Decl(typeGuardOfFormIsType.ts, 20, 1))
>x : Symbol(x, Decl(typeGuardOfFormIsType.ts, 22, 14))
>D1 : Symbol(D1, Decl(typeGuardOfFormIsType.ts, 6, 1))
return true;
}
var c1Orc2: C1 | C2;
>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsType.ts, 26, 3))
>C1 : Symbol(C1, Decl(typeGuardOfFormIsType.ts, 0, 0))
>C2 : Symbol(C2, Decl(typeGuardOfFormIsType.ts, 3, 1))
str = isC1(c1Orc2) && c1Orc2.p1; // C1
>str : Symbol(str, Decl(typeGuardOfFormIsType.ts, 10, 3))
>isC1 : Symbol(isC1, Decl(typeGuardOfFormIsType.ts, 12, 30))
>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsType.ts, 26, 3))
>c1Orc2.p1 : Symbol(C1.p1, Decl(typeGuardOfFormIsType.ts, 1, 10))
>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsType.ts, 26, 3))
>p1 : Symbol(C1.p1, Decl(typeGuardOfFormIsType.ts, 1, 10))
num = isC2(c1Orc2) && c1Orc2.p2; // C2
>num : Symbol(num, Decl(typeGuardOfFormIsType.ts, 11, 3))
>isC2 : Symbol(isC2, Decl(typeGuardOfFormIsType.ts, 16, 1))
>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsType.ts, 26, 3))
>c1Orc2.p2 : Symbol(C2.p2, Decl(typeGuardOfFormIsType.ts, 4, 10))
>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsType.ts, 26, 3))
>p2 : Symbol(C2.p2, Decl(typeGuardOfFormIsType.ts, 4, 10))
str = isD1(c1Orc2) && c1Orc2.p1; // D1
>str : Symbol(str, Decl(typeGuardOfFormIsType.ts, 10, 3))
>isD1 : Symbol(isD1, Decl(typeGuardOfFormIsType.ts, 20, 1))
>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsType.ts, 26, 3))
>c1Orc2.p1 : Symbol(C1.p1, Decl(typeGuardOfFormIsType.ts, 1, 10))
>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsType.ts, 26, 3))
>p1 : Symbol(C1.p1, Decl(typeGuardOfFormIsType.ts, 1, 10))
num = isD1(c1Orc2) && c1Orc2.p3; // D1
>num : Symbol(num, Decl(typeGuardOfFormIsType.ts, 11, 3))
>isD1 : Symbol(isD1, Decl(typeGuardOfFormIsType.ts, 20, 1))
>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsType.ts, 26, 3))
>c1Orc2.p3 : Symbol(D1.p3, Decl(typeGuardOfFormIsType.ts, 7, 21))
>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsType.ts, 26, 3))
>p3 : Symbol(D1.p3, Decl(typeGuardOfFormIsType.ts, 7, 21))
var c2Ord1: C2 | D1;
>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsType.ts, 32, 3))
>C2 : Symbol(C2, Decl(typeGuardOfFormIsType.ts, 3, 1))
>D1 : Symbol(D1, Decl(typeGuardOfFormIsType.ts, 6, 1))
num = isC2(c2Ord1) && c2Ord1.p2; // C2
>num : Symbol(num, Decl(typeGuardOfFormIsType.ts, 11, 3))
>isC2 : Symbol(isC2, Decl(typeGuardOfFormIsType.ts, 16, 1))
>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsType.ts, 32, 3))
>c2Ord1.p2 : Symbol(C2.p2, Decl(typeGuardOfFormIsType.ts, 4, 10))
>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsType.ts, 32, 3))
>p2 : Symbol(C2.p2, Decl(typeGuardOfFormIsType.ts, 4, 10))
num = isD1(c2Ord1) && c2Ord1.p3; // D1
>num : Symbol(num, Decl(typeGuardOfFormIsType.ts, 11, 3))
>isD1 : Symbol(isD1, Decl(typeGuardOfFormIsType.ts, 20, 1))
>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsType.ts, 32, 3))
>c2Ord1.p3 : Symbol(D1.p3, Decl(typeGuardOfFormIsType.ts, 7, 21))
>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsType.ts, 32, 3))
>p3 : Symbol(D1.p3, Decl(typeGuardOfFormIsType.ts, 7, 21))
str = isD1(c2Ord1) && c2Ord1.p1; // D1
>str : Symbol(str, Decl(typeGuardOfFormIsType.ts, 10, 3))
>isD1 : Symbol(isD1, Decl(typeGuardOfFormIsType.ts, 20, 1))
>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsType.ts, 32, 3))
>c2Ord1.p1 : Symbol(C1.p1, Decl(typeGuardOfFormIsType.ts, 1, 10))
>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsType.ts, 32, 3))
>p1 : Symbol(C1.p1, Decl(typeGuardOfFormIsType.ts, 1, 10))
var r2: C2 | D1 = isC1(c2Ord1) && c2Ord1; // C2 | D1
>r2 : Symbol(r2, Decl(typeGuardOfFormIsType.ts, 36, 3))
>C2 : Symbol(C2, Decl(typeGuardOfFormIsType.ts, 3, 1))
>D1 : Symbol(D1, Decl(typeGuardOfFormIsType.ts, 6, 1))
>isC1 : Symbol(isC1, Decl(typeGuardOfFormIsType.ts, 12, 30))
>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsType.ts, 32, 3))
>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsType.ts, 32, 3))

157
tests/baselines/reference/typeGuardOfFormIsType.types Normal file
View File

@@ -0,0 +1,157 @@
=== tests/cases/conformance/expressions/typeGuards/typeGuardOfFormIsType.ts ===
class C1 {
>C1 : C1
p1: string;
>p1 : string
}
class C2 {
>C2 : C2
p2: number;
>p2 : number
}
class D1 extends C1 {
>D1 : D1
>C1 : C1
p3: number;
>p3 : number
}
var str: string;
>str : string
var num: number;
>num : number
var strOrNum: string | number;
>strOrNum : string | number
function isC1(x: any): x is C1 {
>isC1 : (x: any) => boolean
>x : any
>x : any
>C1 : C1
return true;
>true : boolean
}
function isC2(x: any): x is C2 {
>isC2 : (x: any) => boolean
>x : any
>x : any
>C2 : C2
return true;
>true : boolean
}
function isD1(x: any): x is D1 {
>isD1 : (x: any) => boolean
>x : any
>x : any
>D1 : D1
return true;
>true : boolean
}
var c1Orc2: C1 | C2;
>c1Orc2 : C1 | C2
>C1 : C1
>C2 : C2
str = isC1(c1Orc2) && c1Orc2.p1; // C1
>str = isC1(c1Orc2) && c1Orc2.p1 : string
>str : string
>isC1(c1Orc2) && c1Orc2.p1 : string
>isC1(c1Orc2) : boolean
>isC1 : (x: any) => boolean
>c1Orc2 : C1 | C2
>c1Orc2.p1 : string
>c1Orc2 : C1
>p1 : string
num = isC2(c1Orc2) && c1Orc2.p2; // C2
>num = isC2(c1Orc2) && c1Orc2.p2 : number
>num : number
>isC2(c1Orc2) && c1Orc2.p2 : number
>isC2(c1Orc2) : boolean
>isC2 : (x: any) => boolean
>c1Orc2 : C1 | C2
>c1Orc2.p2 : number
>c1Orc2 : C2
>p2 : number
str = isD1(c1Orc2) && c1Orc2.p1; // D1
>str = isD1(c1Orc2) && c1Orc2.p1 : string
>str : string
>isD1(c1Orc2) && c1Orc2.p1 : string
>isD1(c1Orc2) : boolean
>isD1 : (x: any) => boolean
>c1Orc2 : C1 | C2
>c1Orc2.p1 : string
>c1Orc2 : D1
>p1 : string
num = isD1(c1Orc2) && c1Orc2.p3; // D1
>num = isD1(c1Orc2) && c1Orc2.p3 : number
>num : number
>isD1(c1Orc2) && c1Orc2.p3 : number
>isD1(c1Orc2) : boolean
>isD1 : (x: any) => boolean
>c1Orc2 : C1 | C2
>c1Orc2.p3 : number
>c1Orc2 : D1
>p3 : number
var c2Ord1: C2 | D1;
>c2Ord1 : C2 | D1
>C2 : C2
>D1 : D1
num = isC2(c2Ord1) && c2Ord1.p2; // C2
>num = isC2(c2Ord1) && c2Ord1.p2 : number
>num : number
>isC2(c2Ord1) && c2Ord1.p2 : number
>isC2(c2Ord1) : boolean
>isC2 : (x: any) => boolean
>c2Ord1 : C2 | D1
>c2Ord1.p2 : number
>c2Ord1 : C2
>p2 : number
num = isD1(c2Ord1) && c2Ord1.p3; // D1
>num = isD1(c2Ord1) && c2Ord1.p3 : number
>num : number
>isD1(c2Ord1) && c2Ord1.p3 : number
>isD1(c2Ord1) : boolean
>isD1 : (x: any) => boolean
>c2Ord1 : C2 | D1
>c2Ord1.p3 : number
>c2Ord1 : D1
>p3 : number
str = isD1(c2Ord1) && c2Ord1.p1; // D1
>str = isD1(c2Ord1) && c2Ord1.p1 : string
>str : string
>isD1(c2Ord1) && c2Ord1.p1 : string
>isD1(c2Ord1) : boolean
>isD1 : (x: any) => boolean
>c2Ord1 : C2 | D1
>c2Ord1.p1 : string
>c2Ord1 : D1
>p1 : string
var r2: C2 | D1 = isC1(c2Ord1) && c2Ord1; // C2 | D1
>r2 : C2 | D1
>C2 : C2
>D1 : D1
>isC1(c2Ord1) && c2Ord1 : D1
>isC1(c2Ord1) : boolean
>isC1 : (x: any) => boolean
>c2Ord1 : C2 | D1
>c2Ord1 : D1

74
tests/baselines/reference/typeGuardOfFormIsTypeOnInterfaces.js Normal file
View File

@@ -0,0 +1,74 @@
//// [typeGuardOfFormIsTypeOnInterfaces.ts]
interface C1 {
(): C1;
prototype: C1;
p1: string;
}
interface C2 {
(): C2;
prototype: C2;
p2: number;
}
interface D1 extends C1 {
prototype: D1;
p3: number;
}
var str: string;
var num: number;
var strOrNum: string | number;
function isC1(x: any): x is C1 {
return true;
}
function isC2(x: any): x is C2 {
return true;
}
function isD1(x: any): x is D1 {
return true;
}
var c1: C1;
var c2: C2;
var d1: D1;
var c1Orc2: C1 | C2;
str = isC1(c1Orc2) && c1Orc2.p1; // C1
num = isC2(c1Orc2) && c1Orc2.p2; // C2
str = isD1(c1Orc2) && c1Orc2.p1; // D1
num = isD1(c1Orc2) && c1Orc2.p3; // D1
var c2Ord1: C2 | D1;
num = isC2(c2Ord1) && c2Ord1.p2; // C2
num = isD1(c2Ord1) && c2Ord1.p3; // D1
str = isD1(c2Ord1) && c2Ord1.p1; // D1
var r2: C2 | D1 = isC1(c2Ord1) && c2Ord1; // C2 | D1
//// [typeGuardOfFormIsTypeOnInterfaces.js]
var str;
var num;
var strOrNum;
function isC1(x) {
return true;
}
function isC2(x) {
return true;
}
function isD1(x) {
return true;
}
var c1;
var c2;
var d1;
var c1Orc2;
str = isC1(c1Orc2) && c1Orc2.p1; // C1
num = isC2(c1Orc2) && c1Orc2.p2; // C2
str = isD1(c1Orc2) && c1Orc2.p1; // D1
num = isD1(c1Orc2) && c1Orc2.p3; // D1
var c2Ord1;
num = isC2(c2Ord1) && c2Ord1.p2; // C2
num = isD1(c2Ord1) && c2Ord1.p3; // D1
str = isD1(c2Ord1) && c2Ord1.p1; // D1
var r2 = isC1(c2Ord1) && c2Ord1; // C2 | D1

159
tests/baselines/reference/typeGuardOfFormIsTypeOnInterfaces.symbols Normal file
View File

@@ -0,0 +1,159 @@
=== tests/cases/conformance/expressions/typeGuards/typeGuardOfFormIsTypeOnInterfaces.ts ===
interface C1 {
>C1 : Symbol(C1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 0, 0))
(): C1;
>C1 : Symbol(C1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 0, 0))
prototype: C1;
>prototype : Symbol(prototype, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 2, 11))
>C1 : Symbol(C1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 0, 0))
p1: string;
>p1 : Symbol(p1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 3, 18))
}
interface C2 {
>C2 : Symbol(C2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 5, 1))
(): C2;
>C2 : Symbol(C2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 5, 1))
prototype: C2;
>prototype : Symbol(prototype, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 7, 11))
>C2 : Symbol(C2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 5, 1))
p2: number;
>p2 : Symbol(p2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 8, 18))
}
interface D1 extends C1 {
>D1 : Symbol(D1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 10, 1))
>C1 : Symbol(C1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 0, 0))
prototype: D1;
>prototype : Symbol(prototype, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 11, 25))
>D1 : Symbol(D1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 10, 1))
p3: number;
>p3 : Symbol(p3, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 12, 18))
}
var str: string;
>str : Symbol(str, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 15, 3))
var num: number;
>num : Symbol(num, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 16, 3))
var strOrNum: string | number;
>strOrNum : Symbol(strOrNum, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 17, 3))
function isC1(x: any): x is C1 {
>isC1 : Symbol(isC1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 17, 30))
>x : Symbol(x, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 20, 14))
>C1 : Symbol(C1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 0, 0))
return true;
}
function isC2(x: any): x is C2 {
>isC2 : Symbol(isC2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 22, 1))
>x : Symbol(x, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 24, 14))
>C2 : Symbol(C2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 5, 1))
return true;
}
function isD1(x: any): x is D1 {
>isD1 : Symbol(isD1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 26, 1))
>x : Symbol(x, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 28, 14))
>D1 : Symbol(D1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 10, 1))
return true;
}
var c1: C1;
>c1 : Symbol(c1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 32, 3))
>C1 : Symbol(C1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 0, 0))
var c2: C2;
>c2 : Symbol(c2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 33, 3))
>C2 : Symbol(C2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 5, 1))
var d1: D1;
>d1 : Symbol(d1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 34, 3))
>D1 : Symbol(D1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 10, 1))
var c1Orc2: C1 | C2;
>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 35, 3))
>C1 : Symbol(C1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 0, 0))
>C2 : Symbol(C2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 5, 1))
str = isC1(c1Orc2) && c1Orc2.p1; // C1
>str : Symbol(str, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 15, 3))
>isC1 : Symbol(isC1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 17, 30))
>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 35, 3))
>c1Orc2.p1 : Symbol(C1.p1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 3, 18))
>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 35, 3))
>p1 : Symbol(C1.p1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 3, 18))
num = isC2(c1Orc2) && c1Orc2.p2; // C2
>num : Symbol(num, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 16, 3))
>isC2 : Symbol(isC2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 22, 1))
>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 35, 3))
>c1Orc2.p2 : Symbol(C2.p2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 8, 18))
>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 35, 3))
>p2 : Symbol(C2.p2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 8, 18))
str = isD1(c1Orc2) && c1Orc2.p1; // D1
>str : Symbol(str, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 15, 3))
>isD1 : Symbol(isD1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 26, 1))
>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 35, 3))
>c1Orc2.p1 : Symbol(C1.p1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 3, 18))
>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 35, 3))
>p1 : Symbol(C1.p1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 3, 18))
num = isD1(c1Orc2) && c1Orc2.p3; // D1
>num : Symbol(num, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 16, 3))
>isD1 : Symbol(isD1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 26, 1))
>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 35, 3))
>c1Orc2.p3 : Symbol(D1.p3, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 12, 18))
>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 35, 3))
>p3 : Symbol(D1.p3, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 12, 18))
var c2Ord1: C2 | D1;
>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 41, 3))
>C2 : Symbol(C2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 5, 1))
>D1 : Symbol(D1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 10, 1))
num = isC2(c2Ord1) && c2Ord1.p2; // C2
>num : Symbol(num, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 16, 3))
>isC2 : Symbol(isC2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 22, 1))
>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 41, 3))
>c2Ord1.p2 : Symbol(C2.p2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 8, 18))
>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 41, 3))
>p2 : Symbol(C2.p2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 8, 18))
num = isD1(c2Ord1) && c2Ord1.p3; // D1
>num : Symbol(num, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 16, 3))
>isD1 : Symbol(isD1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 26, 1))
>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 41, 3))
>c2Ord1.p3 : Symbol(D1.p3, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 12, 18))
>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 41, 3))
>p3 : Symbol(D1.p3, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 12, 18))
str = isD1(c2Ord1) && c2Ord1.p1; // D1
>str : Symbol(str, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 15, 3))
>isD1 : Symbol(isD1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 26, 1))
>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 41, 3))
>c2Ord1.p1 : Symbol(C1.p1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 3, 18))
>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 41, 3))
>p1 : Symbol(C1.p1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 3, 18))
var r2: C2 | D1 = isC1(c2Ord1) && c2Ord1; // C2 | D1
>r2 : Symbol(r2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 45, 3))
>C2 : Symbol(C2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 5, 1))
>D1 : Symbol(D1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 10, 1))
>isC1 : Symbol(isC1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 17, 30))
>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 41, 3))
>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 41, 3))

188
tests/baselines/reference/typeGuardOfFormIsTypeOnInterfaces.types Normal file
View File

@@ -0,0 +1,188 @@
=== tests/cases/conformance/expressions/typeGuards/typeGuardOfFormIsTypeOnInterfaces.ts ===
interface C1 {
>C1 : C1
(): C1;
>C1 : C1
prototype: C1;
>prototype : C1
>C1 : C1
p1: string;
>p1 : string
}
interface C2 {
>C2 : C2
(): C2;
>C2 : C2
prototype: C2;
>prototype : C2
>C2 : C2
p2: number;
>p2 : number
}
interface D1 extends C1 {
>D1 : D1
>C1 : C1
prototype: D1;
>prototype : D1
>D1 : D1
p3: number;
>p3 : number
}
var str: string;
>str : string
var num: number;
>num : number
var strOrNum: string | number;
>strOrNum : string | number
function isC1(x: any): x is C1 {
>isC1 : (x: any) => boolean
>x : any
>x : any
>C1 : C1
return true;
>true : boolean
}
function isC2(x: any): x is C2 {
>isC2 : (x: any) => boolean
>x : any
>x : any
>C2 : C2
return true;
>true : boolean
}
function isD1(x: any): x is D1 {
>isD1 : (x: any) => boolean
>x : any
>x : any
>D1 : D1
return true;
>true : boolean
}
var c1: C1;
>c1 : C1
>C1 : C1
var c2: C2;
>c2 : C2
>C2 : C2
var d1: D1;
>d1 : D1
>D1 : D1
var c1Orc2: C1 | C2;
>c1Orc2 : C1 | C2
>C1 : C1
>C2 : C2
str = isC1(c1Orc2) && c1Orc2.p1; // C1
>str = isC1(c1Orc2) && c1Orc2.p1 : string
>str : string
>isC1(c1Orc2) && c1Orc2.p1 : string
>isC1(c1Orc2) : boolean
>isC1 : (x: any) => boolean
>c1Orc2 : C1 | C2
>c1Orc2.p1 : string
>c1Orc2 : C1
>p1 : string
num = isC2(c1Orc2) && c1Orc2.p2; // C2
>num = isC2(c1Orc2) && c1Orc2.p2 : number
>num : number
>isC2(c1Orc2) && c1Orc2.p2 : number
>isC2(c1Orc2) : boolean
>isC2 : (x: any) => boolean
>c1Orc2 : C1 | C2
>c1Orc2.p2 : number
>c1Orc2 : C2
>p2 : number
str = isD1(c1Orc2) && c1Orc2.p1; // D1
>str = isD1(c1Orc2) && c1Orc2.p1 : string
>str : string
>isD1(c1Orc2) && c1Orc2.p1 : string
>isD1(c1Orc2) : boolean
>isD1 : (x: any) => boolean
>c1Orc2 : C1 | C2
>c1Orc2.p1 : string
>c1Orc2 : D1
>p1 : string
num = isD1(c1Orc2) && c1Orc2.p3; // D1
>num = isD1(c1Orc2) && c1Orc2.p3 : number
>num : number
>isD1(c1Orc2) && c1Orc2.p3 : number
>isD1(c1Orc2) : boolean
>isD1 : (x: any) => boolean
>c1Orc2 : C1 | C2
>c1Orc2.p3 : number
>c1Orc2 : D1
>p3 : number
var c2Ord1: C2 | D1;
>c2Ord1 : C2 | D1
>C2 : C2
>D1 : D1
num = isC2(c2Ord1) && c2Ord1.p2; // C2
>num = isC2(c2Ord1) && c2Ord1.p2 : number
>num : number
>isC2(c2Ord1) && c2Ord1.p2 : number
>isC2(c2Ord1) : boolean
>isC2 : (x: any) => boolean
>c2Ord1 : C2 | D1
>c2Ord1.p2 : number
>c2Ord1 : C2
>p2 : number
num = isD1(c2Ord1) && c2Ord1.p3; // D1
>num = isD1(c2Ord1) && c2Ord1.p3 : number
>num : number
>isD1(c2Ord1) && c2Ord1.p3 : number
>isD1(c2Ord1) : boolean
>isD1 : (x: any) => boolean
>c2Ord1 : C2 | D1
>c2Ord1.p3 : number
>c2Ord1 : D1
>p3 : number
str = isD1(c2Ord1) && c2Ord1.p1; // D1
>str = isD1(c2Ord1) && c2Ord1.p1 : string
>str : string
>isD1(c2Ord1) && c2Ord1.p1 : string
>isD1(c2Ord1) : boolean
>isD1 : (x: any) => boolean
>c2Ord1 : C2 | D1
>c2Ord1.p1 : string
>c2Ord1 : D1
>p1 : string
var r2: C2 | D1 = isC1(c2Ord1) && c2Ord1; // C2 | D1
>r2 : C2 | D1
>C2 : C2
>D1 : D1
>isC1(c2Ord1) && c2Ord1 : D1
>isC1(c2Ord1) : boolean
>isC1 : (x: any) => boolean
>c2Ord1 : C2 | D1
>c2Ord1 : D1

56
tests/cases/conformance/expressions/typeGuards/typeGuardFunction.ts Normal file
View File

@@ -0,0 +1,56 @@
class A {
propA: number;
}
class B {
propB: number;
}
class C extends A {
propC: number;
}
declare function isA(p1: any): p1 is A;
declare function isB(p1: any): p1 is B;
declare function isC(p1: any): p1 is C;
declare function retC(): C;
var a: A;
var b: B;
// Basic.
if (isC(a)) {
a.propC;
}
// Sub type.
var subType: C;
if(isA(subType)) {
subType.propC;
}
// Union type.
var union: A | B;
if(isA(union)) {
union.propA;
}
// The parameter index and argument index for the type guard target is matching.
// The type predicate type is assignable to the parameter type.
declare function isC_multipleParams(p1, p2): p1 is C;
if (isC_multipleParams(a, 0)) {
a.propC;
}
// Evaluations are asssignable to boolean.
declare function acceptingBoolean(a: boolean);
acceptingBoolean(isA(a));
// Type predicates with different parameter name.
declare function acceptingTypeGuardFunction(p1: (item) => item is A);
acceptingTypeGuardFunction(isA);
let union2: C | B;
let union3: boolean | B = isA(union2) || union2;

92
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts Normal file
View File

@@ -0,0 +1,92 @@
class A {
propA: number;
}
class B {
propB: number;
}
class C extends A {
propC: number;
}
function hasANonBooleanReturnStatement(x): x is A {
return '';
}
function hasTypeGuardTypeInsideTypeGuardType(x): x is x is A {
return true;
}
function hasMissingIsKeyword(): x {
return true;
}
function hasMissingTypeInTypeGuardType(x): x is {
return true;
}
function hasNonMatchingParameter(y): x is A {
return true;
}
function hasNonMatchingParameterType1(x: A): x is B {
return true;
}
function hasNonMatchingParameterType2(x: string): x is number {
return true;
}
function hasNonMathcingGenericType<T>(a: string): a is T[] {
return true;
}
let a: A;
let b: B;
declare function isB(p1): p1 is B;
declare function isC(p1): p1 is C;
declare function funA(p1: any, p2: any): p1 is B;
declare function hasNoTypeGuard(x);
// Passed argument is not the same as the one being guarded.
if (isB(b)) {
a.propB;
}
// Parameter index and argument index for the type guard target is not matching.
if (funA(0, a)) {
a.propB; // Error
}
// No type guard in if statement
if (hasNoTypeGuard(a)) {
a.propB;
}
// Type predicate type is not assignable
declare function acceptingDifferentSignatureTypeGuardFunction(p1: (p1) => p1 is B);
acceptingDifferentSignatureTypeGuardFunction(isC);
// Boolean not assignable to type guard
var assign1: (p1, p2) => p1 is A;
assign1 = function(p1, p2): boolean {
return true;
};
// Must have matching parameter index
var assign2: (p1, p2) => p1 is A;
assign2 = function(p1, p2): p2 is A {
return true;
};
// No matching signature
var assign3: (p1, p2) => p1 is A;
assign3 = function(p1, p2, p3): p1 is A {
return true;
};
// Type guard paramater referring to a binding pattern
declare function destructureParameter({ p1, p2, p3 }): p1 is A;

33
tests/cases/conformance/expressions/typeGuards/typeGuardFunctionGenerics.ts Normal file
View File

@@ -0,0 +1,33 @@
class A {
propA: number;
}
class B {
propB: number;
}
class C extends A {
propC: number;
}
declare function isB(p1): p1 is B;
declare function isC(p1): p1 is C;
declare function retC(x): C;
declare function funA<T>(p1: (p1) => T): T;
declare function funB<T>(p1: (p1) => T, p2: any): p2 is T;
declare function funC<T>(p1: (p1) => p1 is T): T;
declare function funD<T>(p1: (p1) => p1 is T, p2: any): p2 is T;
declare function funE<T, U>(p1: (p1) => p1 is T, p2: U): T;
let a: A;
let test1: boolean = funA(isB);
if (funB(retC, a)) {
a.propC;
}
let test2: B = funC(isB);
if (funD(isC, a)) {
a.propC;
}
let test3: B = funE(isB, 1);

37
tests/cases/conformance/expressions/typeGuards/typeGuardOfFormIsType.ts Normal file
View File

@@ -0,0 +1,37 @@
class C1 {
p1: string;
}
class C2 {
p2: number;
}
class D1 extends C1 {
p3: number;
}
var str: string;
var num: number;
var strOrNum: string | number;
function isC1(x: any): x is C1 {
return true;
}
function isC2(x: any): x is C2 {
return true;
}
function isD1(x: any): x is D1 {
return true;
}
var c1Orc2: C1 | C2;
str = isC1(c1Orc2) && c1Orc2.p1; // C1
num = isC2(c1Orc2) && c1Orc2.p2; // C2
str = isD1(c1Orc2) && c1Orc2.p1; // D1
num = isD1(c1Orc2) && c1Orc2.p3; // D1
var c2Ord1: C2 | D1;
num = isC2(c2Ord1) && c2Ord1.p2; // C2
num = isD1(c2Ord1) && c2Ord1.p3; // D1
str = isD1(c2Ord1) && c2Ord1.p1; // D1
var r2: C2 | D1 = isC1(c2Ord1) && c2Ord1; // C2 | D1

46
tests/cases/conformance/expressions/typeGuards/typeGuardOfFormIsTypeOnInterfaces.ts Normal file
View File

@@ -0,0 +1,46 @@
interface C1 {
(): C1;
prototype: C1;
p1: string;
}
interface C2 {
(): C2;
prototype: C2;
p2: number;
}
interface D1 extends C1 {
prototype: D1;
p3: number;
}
var str: string;
var num: number;
var strOrNum: string | number;
function isC1(x: any): x is C1 {
return true;
}
function isC2(x: any): x is C2 {
return true;
}
function isD1(x: any): x is D1 {
return true;
}
var c1: C1;
var c2: C2;
var d1: D1;
var c1Orc2: C1 | C2;
str = isC1(c1Orc2) && c1Orc2.p1; // C1
num = isC2(c1Orc2) && c1Orc2.p2; // C2
str = isD1(c1Orc2) && c1Orc2.p1; // D1
num = isD1(c1Orc2) && c1Orc2.p3; // D1
var c2Ord1: C2 | D1;
num = isC2(c2Ord1) && c2Ord1.p2; // C2
num = isD1(c2Ord1) && c2Ord1.p3; // D1
str = isD1(c2Ord1) && c2Ord1.p1; // D1
var r2: C2 | D1 = isC1(c2Ord1) && c2Ord1; // C2 | D1