microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-05-14 18:39:19 -05:00
Code Issues Packages Projects Releases 212 Wiki Activity

Accept type baselines

Browse Source
This commit is contained in:
Jason Freeman
2014-08-15 14:33:16 -07:00
parent 91c1a81563
commit 27bf9b702e
1702 changed files with 143213 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
tests/baselines/reference/2dArrays.types Normal file
View File

@@ -0,0 +1,40 @@
=== tests/cases/compiler/2dArrays.ts ===
class Cell {
>Cell : Cell
}
class Ship {
>Ship : Ship
isSunk: boolean;
>isSunk : boolean
}
class Board {
>Board : Board
ships: Ship[];
>ships : Ship[]
>Ship : Ship
cells: Cell[];
>cells : Cell[]
>Cell : Cell
private allShipsSunk() {
>allShipsSunk : () => boolean
return this.ships.every(function (val) { return val.isSunk; });
>this.ships.every(function (val) { return val.isSunk; }) : boolean
>this.ships.every : (callbackfn: (value: Ship, index: number, array: Ship[]) => boolean, thisArg?: any) => boolean
>this.ships : Ship[]
>this : Board
>ships : Ship[]
>every : (callbackfn: (value: Ship, index: number, array: Ship[]) => boolean, thisArg?: any) => boolean
>function (val) { return val.isSunk; } : (val: Ship) => boolean
>val : Ship
>val.isSunk : boolean
>val : Ship
>isSunk : boolean
}
}

33
tests/baselines/reference/AmbientModuleAndAmbientFunctionWithTheSameNameAndCommonRoot.types Normal file
View File

@@ -0,0 +1,33 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/module.d.ts ===
declare module Point {
>Point : typeof Point
export var Origin: { x: number; y: number; }
>Origin : { x: number; y: number; }
>x : number
>y : number
}
=== tests/cases/conformance/internalModules/DeclarationMerging/function.d.ts ===
declare function Point(): { x: number; y: number; }
>Point : typeof Point
>x : number
>y : number
=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
var cl: { x: number; y: number; }
>cl : { x: number; y: number; }
>x : number
>y : number
var cl = Point();
>cl : { x: number; y: number; }
>Point() : { x: number; y: number; }
>Point : typeof Point
var cl = Point.Origin;
>cl : { x: number; y: number; }
>Point.Origin : { x: number; y: number; }
>Point : typeof Point
>Origin : { x: number; y: number; }

59
tests/baselines/reference/AmbientModuleAndAmbientWithSameNameAndCommonRoot.types Normal file
View File

@@ -0,0 +1,59 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/module.d.ts ===
declare module A {
>A : typeof A
export module Point {
>Point : typeof Point
export var Origin: {
>Origin : { x: number; y: number; }
x: number;
>x : number
y: number;
>y : number
}
}
}
=== tests/cases/conformance/internalModules/DeclarationMerging/class.d.ts ===
declare module A {
>A : typeof A
export class Point {
>Point : Point
constructor(x: number, y: number);
>x : number
>y : number
x: number;
>x : number
y: number;
>y : number
}
}
=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
var p: { x: number; y: number; }
>p : { x: number; y: number; }
>x : number
>y : number
var p = A.Point.Origin;
>p : { x: number; y: number; }
>A.Point.Origin : { x: number; y: number; }
>A.Point : typeof Point
>A : typeof A
>Point : typeof Point
>Origin : { x: number; y: number; }
var p = new A.Point(0, 0); // unexpected error here, bug 840000
>p : { x: number; y: number; }
>new A.Point(0, 0) : Point
>A.Point : typeof Point
>A : typeof A
>Point : typeof Point

53
tests/baselines/reference/AmbientModuleAndNonAmbientClassWithSameNameAndCommonRoot.types Normal file
View File

@@ -0,0 +1,53 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/module.d.ts ===
declare module A {
>A : typeof A
export module Point {
>Point : typeof Point
export var Origin: {
>Origin : { x: number; y: number; }
x: number;
>x : number
y: number;
>y : number
}
}
}
=== tests/cases/conformance/internalModules/DeclarationMerging/classPoint.ts ===
module A {
>A : typeof A
export class Point {
>Point : Point
constructor(public x: number, public y: number) { }
>x : number
>y : number
}
}
=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
var p: { x: number; y: number; }
>p : { x: number; y: number; }
>x : number
>y : number
var p = A.Point.Origin;
>p : { x: number; y: number; }
>A.Point.Origin : { x: number; y: number; }
>A.Point : typeof Point
>A : typeof A
>Point : typeof Point
>Origin : { x: number; y: number; }
var p = new A.Point(0, 0); // unexpected error here, bug 840000
>p : { x: number; y: number; }
>new A.Point(0, 0) : Point
>A.Point : typeof Point
>A : typeof A
>Point : typeof Point

37
tests/baselines/reference/AmbientModuleAndNonAmbientFunctionWithTheSameNameAndCommonRoot.types Normal file
View File

@@ -0,0 +1,37 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/module.d.ts ===
declare module Point {
>Point : typeof Point
export var Origin: { x: number; y: number; }
>Origin : { x: number; y: number; }
>x : number
>y : number
}
=== tests/cases/conformance/internalModules/DeclarationMerging/function.ts ===
function Point() {
>Point : typeof Point
return { x: 0, y: 0 };
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
}
=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
var cl: { x: number; y: number; }
>cl : { x: number; y: number; }
>x : number
>y : number
var cl = Point();
>cl : { x: number; y: number; }
>Point() : { x: number; y: number; }
>Point : typeof Point
var cl = Point.Origin;
>cl : { x: number; y: number; }
>Point.Origin : { x: number; y: number; }
>Point : typeof Point
>Origin : { x: number; y: number; }

49
tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.types Normal file
View File

@@ -0,0 +1,49 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts ===
class Point {
>Point : Point
constructor(public x: number, public y: number) { }
>x : number
>y : number
static Origin(): Point { return { x: 0, y: 0 }; }
>Origin : () => Point
>Point : Point
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
}
module Point {
>Point : typeof Point
function Origin() { return ""; }// not an error, since not exported
>Origin : () => string
}
module A {
>A : typeof A
export class Point {
>Point : Point
constructor(public x: number, public y: number) { }
>x : number
>y : number
static Origin(): Point { return { x: 0, y: 0 }; }
>Origin : () => Point
>Point : Point
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
}
export module Point {
>Point : typeof Point
function Origin() { return ""; }// not an error since not exported
>Origin : () => string
}
}

49
tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.types Normal file
View File

@@ -0,0 +1,49 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts ===
class Point {
>Point : Point
constructor(public x: number, public y: number) { }
>x : number
>y : number
static Origin: Point = { x: 0, y: 0 };
>Origin : Point
>Point : Point
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
}
module Point {
>Point : typeof Point
var Origin = ""; // not an error, since not exported
>Origin : string
}
module A {
>A : typeof A
export class Point {
>Point : Point
constructor(public x: number, public y: number) { }
>x : number
>y : number
static Origin: Point = { x: 0, y: 0 };
>Origin : Point
>Point : Point
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
}
export module Point {
>Point : typeof Point
var Origin = ""; // not an error since not exported
>Origin : string
}
}

3
tests/baselines/reference/ClassAndModuleThatMergeWithStringIndexerAndExportedFunctionWithTypeIncompatibleWithIndexer.types Normal file
View File

@@ -0,0 +1,3 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithStringIndexerAndExportedFunctionWithTypeIncompatibleWithIndexer.ts ===
No type information for this code.

43
tests/baselines/reference/EnumAndModuleWithSameNameAndCommonRoot.types Normal file
View File

@@ -0,0 +1,43 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/EnumAndModuleWithSameNameAndCommonRoot.ts ===
enum enumdule {
>enumdule : enumdule
Red, Blue
>Red : enumdule
>Blue : enumdule
}
module enumdule {
>enumdule : typeof enumdule
export class Point {
>Point : Point
constructor(public x: number, public y: number) { }
>x : number
>y : number
}
}
var x: enumdule;
>x : enumdule
>enumdule : enumdule
var x = enumdule.Red;
>x : enumdule
>enumdule.Red : enumdule
>enumdule : typeof enumdule
>Red : enumdule
var y: { x: number; y: number };
>y : { x: number; y: number; }
>x : number
>y : number
var y = new enumdule.Point(0, 0);
>y : { x: number; y: number; }
>new enumdule.Point(0, 0) : Point
>enumdule.Point : typeof Point
>enumdule : typeof enumdule
>Point : typeof Point

38
tests/baselines/reference/ExportClassWhichExtendsInterfaceWithInaccessibleType.types Normal file
View File

@@ -0,0 +1,38 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportClassWhichExtendsInterfaceWithInaccessibleType.ts ===
module A {
>A : typeof A
interface Point {
>Point : Point
x: number;
>x : number
y: number;
>y : number
fromOrigin(p: Point): number;
>fromOrigin : (p: Point) => number
>p : Point
>Point : Point
}
export class Point2d implements Point {
>Point2d : Point2d
>Point : Point
constructor(public x: number, public y: number) { }
>x : number
>y : number
fromOrigin(p: Point) {
>fromOrigin : (p: Point) => number
>p : Point
>Point : Point
return 1;
}
}
}

50
tests/baselines/reference/ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.types Normal file
View File

@@ -0,0 +1,50 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts ===
module A {
>A : typeof A
export class Point {
>Point : Point
x: number;
>x : number
y: number;
>y : number
}
export var Origin: Point = { x: 0, y: 0 };
>Origin : Point
>Point : Point
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
export class Point3d extends Point {
>Point3d : Point3d
>Point : Point
z: number;
>z : number
}
export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
>Origin3d : Point3d
>Point3d : Point3d
>{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
>x : number
>y : number
>z : number
export class Line<TPoint extends Point>{
>Line : Line<TPoint>
>TPoint : TPoint
>Point : Point
constructor(public start: TPoint, public end: TPoint) { }
>start : TPoint
>TPoint : TPoint
>end : TPoint
>TPoint : TPoint
}
}

28
tests/baselines/reference/ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.types Normal file
View File

@@ -0,0 +1,28 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts ===
module A {
>A : typeof A
class Point {
>Point : Point
x: number;
>x : number
y: number;
>y : number
}
export class points {
>points : points
[idx: number]: Point;
>idx : number
>Point : Point
[idx: string]: Point;
>idx : string
>Point : Point
}
}

60
tests/baselines/reference/ExportClassWithInaccessibleTypeInTypeParameterConstraint.types Normal file
View File

@@ -0,0 +1,60 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts ===
module A {
>A : typeof A
class Point {
>Point : Point
x: number;
>x : number
y: number;
>y : number
}
export var Origin: Point = { x: 0, y: 0 };
>Origin : Point
>Point : Point
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
export class Point3d extends Point {
>Point3d : Point3d
>Point : Point
z: number;
>z : number
}
export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
>Origin3d : Point3d
>Point3d : Point3d
>{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
>x : number
>y : number
>z : number
export class Line<TPoint extends Point>{
>Line : Line<TPoint>
>TPoint : TPoint
>Point : Point
constructor(public start: TPoint, public end: TPoint) { }
>start : TPoint
>TPoint : TPoint
>end : TPoint
>TPoint : TPoint
static fromorigin2d(p: Point): Line<Point>{
>fromorigin2d : (p: Point) => Line<Point>
>p : Point
>Point : Point
>Line : Line
>Point : Point
return null;
}
}
}

39
tests/baselines/reference/ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.types Normal file
View File

@@ -0,0 +1,39 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts ===
module A {
>A : typeof A
export class Point {
>Point : Point
x: number;
>x : number
y: number;
>y : number
}
export class Line {
>Line : Line
constructor(public start: Point, public end: Point) { }
>start : Point
>Point : Point
>end : Point
>Point : Point
}
export function fromOrigin(p: Point): Line {
>fromOrigin : (p: Point) => Line
>p : Point
>Point : Point
>Line : Line
return new Line({ x: 0, y: 0 }, p);
>new Line({ x: 0, y: 0 }, p) : Line
>Line : typeof Line
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
>p : Point
}
}

39
tests/baselines/reference/ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.types Normal file
View File

@@ -0,0 +1,39 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts ===
module A {
>A : typeof A
class Point {
>Point : Point
x: number;
>x : number
y: number;
>y : number
}
export class Line {
>Line : Line
constructor(public start: Point, public end: Point) { }
>start : Point
>Point : Point
>end : Point
>Point : Point
}
export function fromOrigin(p: Point): Line {
>fromOrigin : (p: Point) => Line
>p : Point
>Point : Point
>Line : Line
return new Line({ x: 0, y: 0 }, p);
>new Line({ x: 0, y: 0 }, p) : Line
>Line : typeof Line
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
>p : Point
}
}

39
tests/baselines/reference/ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.types Normal file
View File

@@ -0,0 +1,39 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts ===
module A {
>A : typeof A
export class Point {
>Point : Point
x: number;
>x : number
y: number;
>y : number
}
class Line {
>Line : Line
constructor(public start: Point, public end: Point) { }
>start : Point
>Point : Point
>end : Point
>Point : Point
}
export function fromOrigin(p: Point): Line {
>fromOrigin : (p: Point) => Line
>p : Point
>Point : Point
>Line : Line
return new Line({ x: 0, y: 0 }, p);
>new Line({ x: 0, y: 0 }, p) : Line
>Line : typeof Line
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
>p : Point
}
}

58
tests/baselines/reference/ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.types Normal file
View File

@@ -0,0 +1,58 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts ===
module A {
>A : typeof A
export interface Point {
>Point : Point
x: number;
>x : number
y: number;
>y : number
}
export var Origin: Point = { x: 0, y: 0 };
>Origin : Point
>Point : Point
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
export interface Point3d extends Point {
>Point3d : Point3d
>Point : Point
z: number;
>z : number
}
export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
>Origin3d : Point3d
>Point3d : Point3d
>{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
>x : number
>y : number
>z : number
export interface Line<TPoint extends Point>{
>Line : Line<TPoint>
>TPoint : TPoint
>Point : Point
new (start: TPoint, end: TPoint);
>start : TPoint
>TPoint : TPoint
>end : TPoint
>TPoint : TPoint
start: TPoint;
>start : TPoint
>TPoint : TPoint
end: TPoint;
>end : TPoint
>TPoint : TPoint
}
}

28
tests/baselines/reference/ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.types Normal file
View File

@@ -0,0 +1,28 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts ===
module A {
>A : A
interface Point {
>Point : Point
x: number;
>x : number
y: number;
>y : number
}
export interface points {
>points : points
[idx: number]: Point;
>idx : number
>Point : Point
[idx: string]: Point;
>idx : string
>Point : Point
}
}

58
tests/baselines/reference/ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.types Normal file
View File

@@ -0,0 +1,58 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts ===
module A {
>A : typeof A
interface Point {
>Point : Point
x: number;
>x : number
y: number;
>y : number
}
export var Origin: Point = { x: 0, y: 0 };
>Origin : Point
>Point : Point
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
export interface Point3d extends Point {
>Point3d : Point3d
>Point : Point
z: number;
>z : number
}
export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
>Origin3d : Point3d
>Point3d : Point3d
>{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
>x : number
>y : number
>z : number
export interface Line<TPoint extends Point>{
>Line : Line<TPoint>
>TPoint : TPoint
>Point : Point
new (start: TPoint, end: TPoint);
>start : TPoint
>TPoint : TPoint
>end : TPoint
>TPoint : TPoint
start: TPoint;
>start : TPoint
>TPoint : TPoint
end: TPoint;
>end : TPoint
>TPoint : TPoint
}
}

48
tests/baselines/reference/ExportModuleWithAccessibleTypesOnItsExportedMembers.types Normal file
View File

@@ -0,0 +1,48 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportModuleWithAccessibleTypesOnItsExportedMembers.ts ===
module A {
>A : typeof A
export class Point {
>Point : Point
constructor(public x: number, public y: number) { }
>x : number
>y : number
}
export module B {
>B : typeof B
export var Origin: Point = new Point(0, 0);
>Origin : Point
>Point : Point
>new Point(0, 0) : Point
>Point : typeof Point
export class Line {
>Line : Line
constructor(start: Point, end: Point) {
>start : Point
>Point : Point
>end : Point
>Point : Point
}
static fromOrigin(p: Point) {
>fromOrigin : (p: Point) => Line
>p : Point
>Point : Point
return new Line({ x: 0, y: 0 }, p);
>new Line({ x: 0, y: 0 }, p) : Line
>Line : typeof Line
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
>p : Point
}
}
}
}

30
tests/baselines/reference/ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.types Normal file
View File

@@ -0,0 +1,30 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts ===
module A {
>A : typeof A
class Point {
>Point : Point
constructor(public x: number, public y: number) { }
>x : number
>y : number
}
export var Origin: Point = { x: 0, y: 0 };
>Origin : Point
>Point : Point
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
export var Unity = { start: new Point(0, 0), end: new Point(1, 0) };
>Unity : { start: Point; end: Point; }
>{ start: new Point(0, 0), end: new Point(1, 0) } : { start: Point; end: Point; }
>start : Point
>new Point(0, 0) : Point
>Point : typeof Point
>end : Point
>new Point(1, 0) : Point
>Point : typeof Point
}

22
tests/baselines/reference/ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.types Normal file
View File

@@ -0,0 +1,22 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts ===
module A {
>A : typeof A
class B {
>B : B
id: number;
>id : number
}
export var beez: Array<B>;
>beez : B[]
>Array : Array
>B : B
export var beez2 = new Array<B>();
>beez2 : B[]
>new Array<B>() : B[]
>Array : { (arrayLength?: number): any[]; <T>(arrayLength: number): T[]; <T>(...items: T[]): T[]; new (arrayLength?: number): any[]; new <T>(arrayLength: number): T[]; new <T>(...items: T[]): T[]; isArray(arg: any): boolean; prototype: any[]; }
>B : B
}

23
tests/baselines/reference/ExportVariableWithAccessibleTypeInTypeAnnotation.types Normal file
View File

@@ -0,0 +1,23 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportVariableWithAccessibleTypeInTypeAnnotation.ts ===
module A {
>A : typeof A
export interface Point {
>Point : Point
x: number;
>x : number
y: number;
>y : number
}
// valid since Point is exported
export var Origin: Point = { x: 0, y: 0 };
>Origin : Point
>Point : Point
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
}

40
tests/baselines/reference/ExportVariableWithInaccessibleTypeInTypeAnnotation.types Normal file
View File

@@ -0,0 +1,40 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportVariableWithInaccessibleTypeInTypeAnnotation.ts ===
module A {
>A : typeof A
export interface Point {
>Point : Point
x: number;
>x : number
y: number;
>y : number
}
// valid since Point is exported
export var Origin: Point = { x: 0, y: 0 };
>Origin : Point
>Point : Point
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
interface Point3d extends Point {
>Point3d : Point3d
>Point : Point
z: number;
>z : number
}
// invalid Point3d is not exported
export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
>Origin3d : Point3d
>Point3d : Point3d
>{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
>x : number
>y : number
>z : number
}

54
tests/baselines/reference/FunctionAndModuleWithSameNameAndDifferentCommonRoot.types Normal file
View File

@@ -0,0 +1,54 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/function.ts ===
module A {
>A : typeof A
export function Point() {
>Point : () => { x: number; y: number; }
return { x: 0, y: 0 };
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
}
}
=== tests/cases/conformance/internalModules/DeclarationMerging/module.ts ===
module B {
>B : typeof B
export module Point {
>Point : typeof Point
export var Origin = { x: 0, y: 0 };
>Origin : { x: number; y: number; }
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
}
}
=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
var fn: () => { x: number; y: number };
>fn : () => { x: number; y: number; }
>x : number
>y : number
var fn = A.Point;
>fn : () => { x: number; y: number; }
>A.Point : () => { x: number; y: number; }
>A : typeof A
>Point : () => { x: number; y: number; }
var cl: { x: number; y: number; }
>cl : { x: number; y: number; }
>x : number
>y : number
var cl = B.Point.Origin;
>cl : { x: number; y: number; }
>B.Point.Origin : { x: number; y: number; }
>B.Point : typeof Point
>B : typeof B
>Point : typeof Point
>Origin : { x: number; y: number; }

43
tests/baselines/reference/ModuleAndEnumWithSameNameAndCommonRoot.types Normal file
View File

@@ -0,0 +1,43 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/ModuleAndEnumWithSameNameAndCommonRoot.ts ===
module enumdule {
>enumdule : typeof enumdule
export class Point {
>Point : Point
constructor(public x: number, public y: number) { }
>x : number
>y : number
}
}
enum enumdule {
>enumdule : enumdule
Red, Blue
>Red : enumdule
>Blue : enumdule
}
var x: enumdule;
>x : enumdule
>enumdule : enumdule
var x = enumdule.Red;
>x : enumdule
>enumdule.Red : enumdule
>enumdule : typeof enumdule
>Red : enumdule
var y: { x: number; y: number };
>y : { x: number; y: number; }
>x : number
>y : number
var y = new enumdule.Point(0, 0);
>y : { x: number; y: number; }
>new enumdule.Point(0, 0) : Point
>enumdule.Point : typeof Point
>enumdule : typeof enumdule
>Point : typeof Point

97
tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.types Normal file
View File

@@ -0,0 +1,97 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts ===
module A {
>A : typeof A
export class Point {
>Point : Point
x: number;
>x : number
y: number;
>y : number
}
}
module A {
>A : typeof A
class Point {
>Point : Point
fromCarthesian(p: A.Point) {
>fromCarthesian : (p: Point) => { x: number; y: number; }
>p : Point
>A : A
>Point : Point
return { x: p.x, y: p.y };
>{ x: p.x, y: p.y } : { x: number; y: number; }
>x : number
>p.x : number
>p : Point
>x : number
>y : number
>p.y : number
>p : Point
>y : number
}
}
}
// ensure merges as expected
var p: { x: number; y: number; };
>p : { x: number; y: number; }
>x : number
>y : number
var p: A.Point;
>p : { x: number; y: number; }
>A : A
>Point : Point
module X.Y.Z {
>X : typeof X
>Y : typeof Y
>Z : typeof Z
export class Line {
>Line : Line
length: number;
>length : number
}
}
module X {
>X : typeof X
export module Y {
>Y : typeof Y
export module Z {
>Z : typeof Z
class Line {
>Line : Line
name: string;
>name : string
}
}
}
}
// ensure merges as expected
var l: { length: number; }
>l : { length: number; }
>length : number
var l: X.Y.Z.Line;
>l : { length: number; }
>X : X
>Y : Y
>Z : Z
>Line : Line

103
tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.types Normal file
View File

@@ -0,0 +1,103 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts ===
module A {
>A : A
export interface Point {
>Point : Point
x: number;
>x : number
y: number;
>y : number
toCarth(): Point;
>toCarth : () => Point
>Point : Point
}
}
module A {
>A : A
interface Point {
>Point : Point
fromCarth(): Point;
>fromCarth : () => Point
>Point : Point
}
}
// ensure merges as expected
var p: { x: number; y: number; toCarth(): A.Point; };
>p : { x: number; y: number; toCarth(): Point; }
>x : number
>y : number
>toCarth : () => Point
>A : A
>Point : Point
var p: A.Point;
>p : { x: number; y: number; toCarth(): Point; }
>A : A
>Point : Point
module X.Y.Z {
>X : X
>Y : Y
>Z : Z
export interface Line {
>Line : Line
new (start: A.Point, end: A.Point);
>start : Point
>A : A
>Point : Point
>end : Point
>A : A
>Point : Point
}
}
module X {
>X : X
export module Y.Z {
>Y : Y
>Z : Z
interface Line {
>Line : Line
start: A.Point;
>start : Point
>A : A
>Point : Point
end: A.Point;
>end : Point
>A : A
>Point : Point
}
}
}
// ensure merges as expected
var l: { new (s: A.Point, e: A.Point); }
>l : new (s: Point, e: Point) => any
>s : Point
>A : A
>Point : Point
>e : Point
>A : A
>Point : Point
var l: X.Y.Z.Line;
>l : new (s: Point, e: Point) => any
>X : X
>Y : Y
>Z : Z
>Line : Line

125
tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedLocalVarsOfTheSameName.types Normal file
View File

@@ -0,0 +1,125 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/part1.ts ===
module A {
>A : typeof A
export interface Point {
>Point : Point
x: number;
>x : number
y: number;
>y : number
}
export module Utils {
>Utils : typeof Utils
export function mirror<T extends Point>(p: T) {
>mirror : <T extends Point>(p: T) => { x: number; y: number; }
>T : T
>Point : Point
>p : T
>T : T
return { x: p.y, y: p.x };
>{ x: p.y, y: p.x } : { x: number; y: number; }
>x : number
>p.y : number
>p : T
>y : number
>y : number
>p.x : number
>p : T
>x : number
}
}
export var Origin: Point = { x: 0, y: 0 };
>Origin : Point
>Point : Point
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
}
=== tests/cases/conformance/internalModules/DeclarationMerging/part2.ts ===
module A {
>A : typeof A
// not a collision, since we don't export
var Origin: string = "0,0";
>Origin : string
export module Utils {
>Utils : typeof Utils
export class Plane {
>Plane : Plane
constructor(public tl: Point, public br: Point) { }
>tl : Point
>Point : Point
>br : Point
>Point : Point
}
}
}
=== tests/cases/conformance/internalModules/DeclarationMerging/part3.ts ===
// test the merging actually worked
var o: { x: number; y: number };
>o : { x: number; y: number; }
>x : number
>y : number
var o: A.Point;
>o : { x: number; y: number; }
>A : A
>Point : Point
var o = A.Origin;
>o : { x: number; y: number; }
>A.Origin : Point
>A : typeof A
>Origin : Point
var o = A.Utils.mirror(o);
>o : { x: number; y: number; }
>A.Utils.mirror(o) : { x: number; y: number; }
>A.Utils.mirror : <T extends Point>(p: T) => { x: number; y: number; }
>A.Utils : typeof Utils
>A : typeof A
>Utils : typeof Utils
>mirror : <T extends Point>(p: T) => { x: number; y: number; }
>o : { x: number; y: number; }
var p: { tl: A.Point; br: A.Point };
>p : { tl: Point; br: Point; }
>tl : Point
>A : A
>Point : Point
>br : Point
>A : A
>Point : Point
var p: A.Utils.Plane;
>p : { tl: Point; br: Point; }
>A : A
>Utils : Utils
>Plane : Plane
var p = new A.Utils.Plane(o, { x: 1, y: 1 });
>p : { tl: Point; br: Point; }
>new A.Utils.Plane(o, { x: 1, y: 1 }) : Plane
>A.Utils.Plane : typeof Plane
>A.Utils : typeof Utils
>A : typeof A
>Utils : typeof Utils
>Plane : typeof Plane
>o : { x: number; y: number; }
>{ x: 1, y: 1 } : { x: number; y: number; }
>x : number
>y : number

112
tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.types Normal file
View File

@@ -0,0 +1,112 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts ===
module A {
>A : A
export interface Point {
>Point : Point
x: number;
>x : number
y: number;
>y : number
toCarth(): Point;
>toCarth : () => Point
>Point : Point
}
}
module A {
>A : A
export interface Point {
>Point : Point
fromCarth(): Point;
>fromCarth : () => Point
>Point : Point
}
}
// ensure merges as expected
var p: { x: number; y: number; toCarth(): A.Point; fromCarth(): A.Point; };
>p : { x: number; y: number; toCarth(): Point; fromCarth(): Point; }
>x : number
>y : number
>toCarth : () => Point
>A : A
>Point : Point
>fromCarth : () => Point
>A : A
>Point : Point
var p: A.Point;
>p : { x: number; y: number; toCarth(): Point; fromCarth(): Point; }
>A : A
>Point : Point
module X.Y.Z {
>X : X
>Y : Y
>Z : Z
export interface Line {
>Line : Line
new (start: A.Point, end: A.Point);
>start : Point
>A : A
>Point : Point
>end : Point
>A : A
>Point : Point
}
}
module X {
>X : X
export module Y.Z {
>Y : Y
>Z : Z
export interface Line {
>Line : Line
start: A.Point;
>start : Point
>A : A
>Point : Point
end: A.Point;
>end : Point
>A : A
>Point : Point
}
}
}
// ensure merges as expected
var l: { start: A.Point; end: A.Point; new (s: A.Point, e: A.Point); }
>l : { new (s: Point, e: Point): any; start: Point; end: Point; }
>start : Point
>A : A
>Point : Point
>end : Point
>A : A
>Point : Point
>s : Point
>A : A
>Point : Point
>e : Point
>A : A
>Point : Point
var l: X.Y.Z.Line;
>l : { new (s: Point, e: Point): any; start: Point; end: Point; }
>X : X
>Y : Y
>Z : Z
>Line : Line

76
tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.types Normal file
View File

@@ -0,0 +1,76 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts ===
module A.B {
>A : typeof A
>B : typeof B
export var x: number;
>x : number
}
module A{
>A : typeof A
module B {
>B : typeof B
export var x: string;
>x : string
}
}
// ensure the right var decl is exported
var x: number;
>x : number
var x = A.B.x;
>x : number
>A.B.x : number
>A.B : typeof B
>A : typeof A
>B : typeof B
>x : number
module X.Y.Z {
>X : typeof X
>Y : typeof Y
>Z : typeof Z
export class Line {
>Line : Line
length: number;
>length : number
}
}
module X {
>X : typeof X
export module Y {
>Y : typeof Y
module Z {
>Z : typeof Z
export class Line {
>Line : Line
name: string;
>name : string
}
}
}
}
// make sure merging works as expected
var l: { length: number };
>l : { length: number; }
>length : number
var l: X.Y.Z.Line;
>l : { length: number; }
>X : X
>Y : Y
>Z : Z
>Line : Line

78
tests/baselines/reference/TwoInternalModulesWithTheSameNameAndDifferentCommonRoot.types Normal file
View File

@@ -0,0 +1,78 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/part1.ts ===
module Root {
>Root : typeof Root
export module A {
>A : typeof A
export interface Point {
>Point : Point
x: number;
>x : number
y: number;
>y : number
}
export module Utils {
>Utils : typeof Utils
export function mirror<T extends Point>(p: T) {
>mirror : <T extends Point>(p: T) => { x: number; y: number; }
>T : T
>Point : Point
>p : T
>T : T
return { x: p.y, y: p.x };
>{ x: p.y, y: p.x } : { x: number; y: number; }
>x : number
>p.y : number
>p : T
>y : number
>y : number
>p.x : number
>p : T
>x : number
}
}
}
}
=== tests/cases/conformance/internalModules/DeclarationMerging/part2.ts ===
module otherRoot {
>otherRoot : typeof otherRoot
export module A {
>A : typeof A
// have to be fully qualified since in different root
export var Origin: Root.A.Point = { x: 0, y: 0 };
>Origin : Point
>Root : Root
>A : A
>Point : Point
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
export module Utils {
>Utils : typeof Utils
export class Plane {
>Plane : Plane
constructor(public tl: Root.A.Point, public br: Root.A.Point) { }
>tl : Point
>Root : Root
>A : A
>Point : Point
>br : Point
>Root : Root
>A : A
>Point : Point
}
}
}
}

122
tests/baselines/reference/TwoInternalModulesWithTheSameNameAndSameCommonRoot.types Normal file
View File

@@ -0,0 +1,122 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/part1.ts ===
module A {
>A : typeof A
export interface Point {
>Point : Point
x: number;
>x : number
y: number;
>y : number
}
export module Utils {
>Utils : typeof Utils
export function mirror<T extends Point>(p: T) {
>mirror : <T extends Point>(p: T) => { x: number; y: number; }
>T : T
>Point : Point
>p : T
>T : T
return { x: p.y, y: p.x };
>{ x: p.y, y: p.x } : { x: number; y: number; }
>x : number
>p.y : number
>p : T
>y : number
>y : number
>p.x : number
>p : T
>x : number
}
}
}
=== tests/cases/conformance/internalModules/DeclarationMerging/part2.ts ===
module A {
>A : typeof A
export var Origin: Point = { x: 0, y: 0 };
>Origin : Point
>Point : Point
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
export module Utils {
>Utils : typeof Utils
export class Plane {
>Plane : Plane
constructor(public tl: Point, public br: Point) { }
>tl : Point
>Point : Point
>br : Point
>Point : Point
}
}
}
=== tests/cases/conformance/internalModules/DeclarationMerging/part3.ts ===
// test the merging actually worked
var o: { x: number; y: number };
>o : { x: number; y: number; }
>x : number
>y : number
var o: A.Point;
>o : { x: number; y: number; }
>A : A
>Point : Point
var o = A.Origin;
>o : { x: number; y: number; }
>A.Origin : Point
>A : typeof A
>Origin : Point
var o = A.Utils.mirror(o);
>o : { x: number; y: number; }
>A.Utils.mirror(o) : { x: number; y: number; }
>A.Utils.mirror : <T extends Point>(p: T) => { x: number; y: number; }
>A.Utils : typeof Utils
>A : typeof A
>Utils : typeof Utils
>mirror : <T extends Point>(p: T) => { x: number; y: number; }
>o : { x: number; y: number; }
var p: { tl: A.Point; br: A.Point };
>p : { tl: Point; br: Point; }
>tl : Point
>A : A
>Point : Point
>br : Point
>A : A
>Point : Point
var p: A.Utils.Plane;
>p : { tl: Point; br: Point; }
>A : A
>Utils : Utils
>Plane : Plane
var p = new A.Utils.Plane(o, { x: 1, y: 1 });
>p : { tl: Point; br: Point; }
>new A.Utils.Plane(o, { x: 1, y: 1 }) : Plane
>A.Utils.Plane : typeof Plane
>A.Utils : typeof Utils
>A : typeof A
>Utils : typeof Utils
>Plane : typeof Plane
>o : { x: number; y: number; }
>{ x: 1, y: 1 } : { x: number; y: number; }
>x : number
>y : number

17
tests/baselines/reference/acceptableAlias1.types Normal file
View File

@@ -0,0 +1,17 @@
=== tests/cases/compiler/acceptableAlias1.ts ===
module M {
>M : typeof M
export module N {
>N : N
}
export import X = N;
>X : X
>N : N
}
import r = M.X;
>r : r
>M : M
>X : X

52
tests/baselines/reference/accessOverriddenBaseClassMember1.types Normal file
View File

@@ -0,0 +1,52 @@
=== tests/cases/compiler/accessOverriddenBaseClassMember1.ts ===
class Point {
>Point : Point
constructor(public x: number, public y: number) { }
>x : number
>y : number
public toString() {
>toString : () => string
return "x=" + this.x + " y=" + this.y;
>"x=" + this.x + " y=" + this.y : string
>"x=" + this.x + " y=" : string
>"x=" + this.x : string
>this.x : number
>this : Point
>x : number
>this.y : number
>this : Point
>y : number
}
}
class ColoredPoint extends Point {
>ColoredPoint : ColoredPoint
>Point : Point
constructor(x: number, y: number, public color: string) {
>x : number
>y : number
>color : string
super(x, y);
>super(x, y) : void
>x : number
>y : number
}
public toString() {
>toString : () => string
return super.toString() + " color=" + this.color;
>super.toString() + " color=" + this.color : string
>super.toString() + " color=" : string
>super.toString() : string
>super.toString : () => string
>toString : () => string
>this.color : string
>this : ColoredPoint
>color : string
}
}

41
tests/baselines/reference/accessorWithES5.types Normal file
View File

@@ -0,0 +1,41 @@
=== tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES5.ts ===
class C {
>C : C
get x() {
>x : number
return 1;
}
}
class D {
>D : D
set x(v) {
>x : any
>v : any
}
}
var x = {
>x : { a: number; }
>{
get a() { return 1 }
} : { a: number; }
get a() { return 1 }
>a : number
}
var y = {
>y : { b: any; }
>{
set b(v) { }
} : { b: any; }
set b(v) { }
>b : any
>v : any
}

24
tests/baselines/reference/addMoreCallSignaturesToBaseSignature.types Normal file
View File

@@ -0,0 +1,24 @@
=== tests/cases/compiler/addMoreCallSignaturesToBaseSignature.ts ===
interface Foo {
>Foo : Foo
(): string;
}
interface Bar extends Foo {
>Bar : Bar
>Foo : Foo
(key: string): string;
>key : string
}
var a: Bar;
>a : Bar
>Bar : Bar
var kitty = a();
>kitty : string
>a() : string
>a : Bar

25
tests/baselines/reference/addMoreCallSignaturesToBaseSignature2.types Normal file
View File

@@ -0,0 +1,25 @@
=== tests/cases/compiler/addMoreCallSignaturesToBaseSignature2.ts ===
interface Foo {
>Foo : Foo
(bar:number): string;
>bar : number
}
interface Bar extends Foo {
>Bar : Bar
>Foo : Foo
(key: string): string;
>key : string
}
var a: Bar;
>a : Bar
>Bar : Bar
var kitty = a(1);
>kitty : string
>a(1) : string
>a : Bar

168
tests/baselines/reference/additionOperatorWithAnyAndEveryType.types Normal file
View File

@@ -0,0 +1,168 @@
=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithAnyAndEveryType.ts ===
function foo() { }
>foo : () => void
class C {
>C : C
public a: string;
>a : string
static foo() { }
>foo : () => void
}
enum E { a, b, c }
>E : E
>a : E
>b : E
>c : E
module M { export var a }
>M : typeof M
>a : any
var a: any;
>a : any
var b: boolean;
>b : boolean
var c: number;
>c : number
var d: string;
>d : string
var e: Object;
>e : Object
>Object : Object
// any as left operand, result is type Any except plusing string
var r1 = a + a;
>r1 : any
>a + a : any
>a : any
>a : any
var r2 = a + b;
>r2 : any
>a + b : any
>a : any
>b : boolean
var r3 = a + c;
>r3 : any
>a + c : any
>a : any
>c : number
var r4 = a + d;
>r4 : string
>a + d : string
>a : any
>d : string
var r5 = a + e;
>r5 : any
>a + e : any
>a : any
>e : Object
// any as right operand, result is type Any except plusing string
var r6 = b + a;
>r6 : any
>b + a : any
>b : boolean
>a : any
var r7 = c + a;
>r7 : any
>c + a : any
>c : number
>a : any
var r8 = d + a;
>r8 : string
>d + a : string
>d : string
>a : any
var r9 = e + a;
>r9 : any
>e + a : any
>e : Object
>a : any
// other cases
var r10 = a + foo;
>r10 : any
>a + foo : any
>a : any
>foo : () => void
var r11 = a + foo();
>r11 : any
>a + foo() : any
>a : any
>foo() : void
>foo : () => void
var r12 = a + C;
>r12 : any
>a + C : any
>a : any
>C : typeof C
var r13 = a + new C();
>r13 : any
>a + new C() : any
>a : any
>new C() : C
>C : typeof C
var r14 = a + E;
>r14 : any
>a + E : any
>a : any
>E : typeof E
var r15 = a + E.a;
>r15 : any
>a + E.a : any
>a : any
>E.a : E
>E : typeof E
>a : E
var r16 = a + M;
>r16 : any
>a + M : any
>a : any
>M : typeof M
var r17 = a + '';
>r17 : string
>a + '' : string
>a : any
var r18 = a + 123;
>r18 : any
>a + 123 : any
>a : any
var r19 = a + { a: '' };
>r19 : any
>a + { a: '' } : any
>a : any
>{ a: '' } : { a: string; }
>a : string
var r20 = a + ((a: string) => { return a });
>r20 : any
>a + ((a: string) => { return a }) : any
>a : any
>((a: string) => { return a }) : (a: string) => string
>(a: string) => { return a } : (a: string) => string
>a : string
>a : string

107
tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.types Normal file
View File

@@ -0,0 +1,107 @@
=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndValidOperator.ts ===
// If one operand is the null or undefined value, it is treated as having the type of the other operand.
enum E { a, b, c }
>E : E
>a : E
>b : E
>c : E
var a: any;
>a : any
var b: number;
>b : number
var c: E;
>c : E
>E : E
var d: string;
>d : string
// null + any
var r1: any = null + a;
>r1 : any
>null + a : any
>a : any
var r2: any = a + null;
>r2 : any
>a + null : any
>a : any
// null + number/enum
var r3 = null + b;
>r3 : number
>null + b : number
>b : number
var r4 = null + 1;
>r4 : number
>null + 1 : number
var r5 = null + c;
>r5 : number
>null + c : number
>c : E
var r6 = null + E.a;
>r6 : number
>null + E.a : number
>E.a : E
>E : typeof E
>a : E
var r7 = null + E['a'];
>r7 : number
>null + E['a'] : number
>E['a'] : E
>E : typeof E
var r8 = b + null;
>r8 : number
>b + null : number
>b : number
var r9 = 1 + null;
>r9 : number
>1 + null : number
var r10 = c + null
>r10 : number
>c + null : number
>c : E
var r11 = E.a + null;
>r11 : number
>E.a + null : number
>E.a : E
>E : typeof E
>a : E
var r12 = E['a'] + null;
>r12 : number
>E['a'] + null : number
>E['a'] : E
>E : typeof E
// null + string
var r13 = null + d;
>r13 : string
>null + d : string
>d : string
var r14 = null + '';
>r14 : string
>null + '' : string
var r15 = d + null;
>r15 : string
>d + null : string
>d : string
var r16 = '' + null;
>r16 : string
>'' + null : string

67
tests/baselines/reference/additionOperatorWithNumberAndEnum.types Normal file
View File

@@ -0,0 +1,67 @@
=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNumberAndEnum.ts ===
enum E { a, b }
>E : E
>a : E
>b : E
var a: number;
>a : number
var b: E;
>b : E
>E : E
var r1 = a + a;
>r1 : number
>a + a : number
>a : number
>a : number
var r2 = a + b;
>r2 : number
>a + b : number
>a : number
>b : E
var r3 = b + a;
>r3 : number
>b + a : number
>b : E
>a : number
var r4 = b + b;
>r4 : number
>b + b : number
>b : E
>b : E
var r5 = 0 + a;
>r5 : number
>0 + a : number
>a : number
var r6 = E.a + 0;
>r6 : number
>E.a + 0 : number
>E.a : E
>E : typeof E
>a : E
var r7 = E.a + E.b;
>r7 : number
>E.a + E.b : number
>E.a : E
>E : typeof E
>a : E
>E.b : E
>E : typeof E
>b : E
var r8 = E['a'] + E['b'];
>r8 : number
>E['a'] + E['b'] : number
>E['a'] : E
>E : typeof E
>E['b'] : E
>E : typeof E

158
tests/baselines/reference/additionOperatorWithStringAndEveryType.types Normal file
View File

@@ -0,0 +1,158 @@
=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithStringAndEveryType.ts ===
enum E { a, b, c }
>E : E
>a : E
>b : E
>c : E
var a: any;
>a : any
var b: boolean;
>b : boolean
var c: number;
>c : number
var d: string;
>d : string
var e: Object;
>e : Object
>Object : Object
var f: void;
>f : void
var g: E;
>g : E
>E : E
var x: string;
>x : string
// string could plus every type, and the result is always string
// string as left operand
var r1 = x + a;
>r1 : string
>x + a : string
>x : string
>a : any
var r2 = x + b;
>r2 : string
>x + b : string
>x : string
>b : boolean
var r3 = x + c;
>r3 : string
>x + c : string
>x : string
>c : number
var r4 = x + d;
>r4 : string
>x + d : string
>x : string
>d : string
var r5 = x + e;
>r5 : string
>x + e : string
>x : string
>e : Object
var r6 = x + f;
>r6 : string
>x + f : string
>x : string
>f : void
var r7 = x + g;
>r7 : string
>x + g : string
>x : string
>g : E
// string as right operand
var r8 = a + x;
>r8 : string
>a + x : string
>a : any
>x : string
var r9 = b + x;
>r9 : string
>b + x : string
>b : boolean
>x : string
var r10 = c + x;
>r10 : string
>c + x : string
>c : number
>x : string
var r11 = d + x;
>r11 : string
>d + x : string
>d : string
>x : string
var r12 = e + x;
>r12 : string
>e + x : string
>e : Object
>x : string
var r13 = f + x;
>r13 : string
>f + x : string
>f : void
>x : string
var r14 = g + x;
>r14 : string
>g + x : string
>g : E
>x : string
// other cases
var r15 = x + E;
>r15 : string
>x + E : string
>x : string
>E : typeof E
var r16 = x + E.a;
>r16 : string
>x + E.a : string
>x : string
>E.a : E
>E : typeof E
>a : E
var r17 = x + '';
>r17 : string
>x + '' : string
>x : string
var r18 = x + 0;
>r18 : string
>x + 0 : string
>x : string
var r19 = x + { a: '' };
>r19 : string
>x + { a: '' } : string
>x : string
>{ a: '' } : { a: string; }
>a : string
var r20 = x + [];
>r20 : string
>x + [] : string
>x : string
>[] : undefined[]

123
tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.types Normal file
View File

@@ -0,0 +1,123 @@
=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndValidOperator.ts ===
// If one operand is the null or undefined value, it is treated as having the type of the other operand.
enum E { a, b, c }
>E : E
>a : E
>b : E
>c : E
var a: any;
>a : any
var b: number;
>b : number
var c: E;
>c : E
>E : E
var d: string;
>d : string
// undefined + any
var r1: any = undefined + a;
>r1 : any
>undefined + a : any
>undefined : undefined
>a : any
var r2: any = a + undefined;
>r2 : any
>a + undefined : any
>a : any
>undefined : undefined
// undefined + number/enum
var r3 = undefined + b;
>r3 : number
>undefined + b : number
>undefined : undefined
>b : number
var r4 = undefined + 1;
>r4 : number
>undefined + 1 : number
>undefined : undefined
var r5 = undefined + c;
>r5 : number
>undefined + c : number
>undefined : undefined
>c : E
var r6 = undefined + E.a;
>r6 : number
>undefined + E.a : number
>undefined : undefined
>E.a : E
>E : typeof E
>a : E
var r7 = undefined + E['a'];
>r7 : number
>undefined + E['a'] : number
>undefined : undefined
>E['a'] : E
>E : typeof E
var r8 = b + undefined;
>r8 : number
>b + undefined : number
>b : number
>undefined : undefined
var r9 = 1 + undefined;
>r9 : number
>1 + undefined : number
>undefined : undefined
var r10 = c + undefined
>r10 : number
>c + undefined : number
>c : E
>undefined : undefined
var r11 = E.a + undefined;
>r11 : number
>E.a + undefined : number
>E.a : E
>E : typeof E
>a : E
>undefined : undefined
var r12 = E['a'] + undefined;
>r12 : number
>E['a'] + undefined : number
>E['a'] : E
>E : typeof E
>undefined : undefined
// undefined + string
var r13 = undefined + d;
>r13 : string
>undefined + d : string
>undefined : undefined
>d : string
var r14 = undefined + '';
>r14 : string
>undefined + '' : string
>undefined : undefined
var r15 = d + undefined;
>r15 : string
>d + undefined : string
>d : string
>undefined : undefined
var r16 = '' + undefined;
>r16 : string
>'' + undefined : string
>undefined : undefined

11
tests/baselines/reference/aliasInaccessibleModule.types Normal file
View File

@@ -0,0 +1,11 @@
=== tests/cases/compiler/aliasInaccessibleModule.ts ===
module M {
>M : typeof M
module N {
>N : N
}
export import X = N;
>X : X
>N : N
}

20
tests/baselines/reference/aliasInaccessibleModule2.types Normal file
View File

@@ -0,0 +1,20 @@
=== tests/cases/compiler/aliasInaccessibleModule2.ts ===
module M {
>M : typeof M
module N {
>N : typeof N
class C {
>C : C
}
}
import R = N;
>R : typeof N
>N : typeof N
export import X = R;
>X : typeof N
>R : typeof N
}

48
tests/baselines/reference/aliasUsageInArray.types Normal file
View File

@@ -0,0 +1,48 @@
=== tests/cases/compiler/aliasUsageInArray_main.ts ===
import Backbone = require("aliasUsageInArray_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInArray_backbone"
import moduleA = require("aliasUsageInArray_moduleA");
>moduleA : typeof "tests/cases/compiler/aliasUsageInArray_moduleA"
interface IHasVisualizationModel {
>IHasVisualizationModel : IHasVisualizationModel
VisualizationModel: typeof Backbone.Model;
>VisualizationModel : typeof Model
>Backbone : typeof "tests/cases/compiler/aliasUsageInArray_backbone"
>Model : typeof Model
}
var xs: IHasVisualizationModel[] = [moduleA];
>xs : IHasVisualizationModel[]
>IHasVisualizationModel : IHasVisualizationModel
>[moduleA] : IHasVisualizationModel[]
>moduleA : typeof "tests/cases/compiler/aliasUsageInArray_moduleA"
var xs2: typeof moduleA[] = [moduleA];
>xs2 : typeof "tests/cases/compiler/aliasUsageInArray_moduleA"[]
>moduleA : typeof "tests/cases/compiler/aliasUsageInArray_moduleA"
>[moduleA] : typeof "tests/cases/compiler/aliasUsageInArray_moduleA"[]
>moduleA : typeof "tests/cases/compiler/aliasUsageInArray_moduleA"
=== tests/cases/compiler/aliasUsageInArray_backbone.ts ===
export class Model {
>Model : Model
public someData: string;
>someData : string
}
=== tests/cases/compiler/aliasUsageInArray_moduleA.ts ===
import Backbone = require("aliasUsageInArray_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInArray_backbone"
export class VisualizationModel extends Backbone.Model {
>VisualizationModel : VisualizationModel
>Backbone : Backbone
>Model : Model
// interesting stuff here
}

49
tests/baselines/reference/aliasUsageInFunctionExpression.types Normal file
View File

@@ -0,0 +1,49 @@
=== tests/cases/compiler/aliasUsageInFunctionExpression_main.ts ===
import Backbone = require("aliasUsageInFunctionExpression_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInFunctionExpression_backbone"
import moduleA = require("aliasUsageInFunctionExpression_moduleA");
>moduleA : typeof "tests/cases/compiler/aliasUsageInFunctionExpression_moduleA"
interface IHasVisualizationModel {
>IHasVisualizationModel : IHasVisualizationModel
VisualizationModel: typeof Backbone.Model;
>VisualizationModel : typeof Model
>Backbone : typeof "tests/cases/compiler/aliasUsageInFunctionExpression_backbone"
>Model : typeof Model
}
var f = (x: IHasVisualizationModel) => x;
>f : (x: IHasVisualizationModel) => IHasVisualizationModel
>(x: IHasVisualizationModel) => x : (x: IHasVisualizationModel) => IHasVisualizationModel
>x : IHasVisualizationModel
>IHasVisualizationModel : IHasVisualizationModel
>x : IHasVisualizationModel
f = (x) => moduleA;
>f = (x) => moduleA : (x: IHasVisualizationModel) => typeof "tests/cases/compiler/aliasUsageInFunctionExpression_moduleA"
>f : (x: IHasVisualizationModel) => IHasVisualizationModel
>(x) => moduleA : (x: IHasVisualizationModel) => typeof "tests/cases/compiler/aliasUsageInFunctionExpression_moduleA"
>x : IHasVisualizationModel
>moduleA : typeof "tests/cases/compiler/aliasUsageInFunctionExpression_moduleA"
=== tests/cases/compiler/aliasUsageInFunctionExpression_backbone.ts ===
export class Model {
>Model : Model
public someData: string;
>someData : string
}
=== tests/cases/compiler/aliasUsageInFunctionExpression_moduleA.ts ===
import Backbone = require("aliasUsageInFunctionExpression_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInFunctionExpression_backbone"
export class VisualizationModel extends Backbone.Model {
>VisualizationModel : VisualizationModel
>Backbone : Backbone
>Model : Model
// interesting stuff here
}

63
tests/baselines/reference/aliasUsageInGenericFunction.types Normal file
View File

@@ -0,0 +1,63 @@
=== tests/cases/compiler/aliasUsageInGenericFunction_main.ts ===
import Backbone = require("aliasUsageInGenericFunction_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInGenericFunction_backbone"
import moduleA = require("aliasUsageInGenericFunction_moduleA");
>moduleA : typeof "tests/cases/compiler/aliasUsageInGenericFunction_moduleA"
interface IHasVisualizationModel {
>IHasVisualizationModel : IHasVisualizationModel
VisualizationModel: typeof Backbone.Model;
>VisualizationModel : typeof Model
>Backbone : typeof "tests/cases/compiler/aliasUsageInGenericFunction_backbone"
>Model : typeof Model
}
function foo<T extends { a: IHasVisualizationModel }>(x: T) {
>foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T
>T : T
>a : IHasVisualizationModel
>IHasVisualizationModel : IHasVisualizationModel
>x : T
>T : T
return x;
>x : T
}
var r = foo({ a: moduleA });
>r : { a: typeof "tests/cases/compiler/aliasUsageInGenericFunction_moduleA"; }
>foo({ a: moduleA }) : { a: typeof "tests/cases/compiler/aliasUsageInGenericFunction_moduleA"; }
>foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T
>{ a: moduleA } : { a: typeof "tests/cases/compiler/aliasUsageInGenericFunction_moduleA"; }
>a : typeof "tests/cases/compiler/aliasUsageInGenericFunction_moduleA"
>moduleA : moduleA
var r2 = foo({ a: <IHasVisualizationModel>null });
>r2 : { a: IHasVisualizationModel; }
>foo({ a: <IHasVisualizationModel>null }) : { a: IHasVisualizationModel; }
>foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T
>{ a: <IHasVisualizationModel>null } : { a: IHasVisualizationModel; }
>a : IHasVisualizationModel
><IHasVisualizationModel>null : IHasVisualizationModel
>IHasVisualizationModel : IHasVisualizationModel
=== tests/cases/compiler/aliasUsageInGenericFunction_backbone.ts ===
export class Model {
>Model : Model
public someData: string;
>someData : string
}
=== tests/cases/compiler/aliasUsageInGenericFunction_moduleA.ts ===
import Backbone = require("aliasUsageInGenericFunction_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInGenericFunction_backbone"
export class VisualizationModel extends Backbone.Model {
>VisualizationModel : VisualizationModel
>Backbone : Backbone
>Model : Model
// interesting stuff here
}

57
tests/baselines/reference/aliasUsageInIndexerOfClass.types Normal file
View File

@@ -0,0 +1,57 @@
=== tests/cases/compiler/aliasUsageInIndexerOfClass_main.ts ===
import Backbone = require("aliasUsageInIndexerOfClass_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInIndexerOfClass_backbone"
import moduleA = require("aliasUsageInIndexerOfClass_moduleA");
>moduleA : typeof "tests/cases/compiler/aliasUsageInIndexerOfClass_moduleA"
interface IHasVisualizationModel {
>IHasVisualizationModel : IHasVisualizationModel
VisualizationModel: typeof Backbone.Model;
>VisualizationModel : typeof Model
>Backbone : typeof "tests/cases/compiler/aliasUsageInIndexerOfClass_backbone"
>Model : typeof Model
}
class N {
>N : N
[idx: string]: IHasVisualizationModel
>idx : string
>IHasVisualizationModel : IHasVisualizationModel
x = moduleA;
>x : typeof "tests/cases/compiler/aliasUsageInIndexerOfClass_moduleA"
>moduleA : typeof "tests/cases/compiler/aliasUsageInIndexerOfClass_moduleA"
}
class N2 {
>N2 : N2
[idx: string]: typeof moduleA
>idx : string
>moduleA : typeof "tests/cases/compiler/aliasUsageInIndexerOfClass_moduleA"
x: IHasVisualizationModel;
>x : IHasVisualizationModel
>IHasVisualizationModel : IHasVisualizationModel
}
=== tests/cases/compiler/aliasUsageInIndexerOfClass_backbone.ts ===
export class Model {
>Model : Model
public someData: string;
>someData : string
}
=== tests/cases/compiler/aliasUsageInIndexerOfClass_moduleA.ts ===
import Backbone = require("aliasUsageInIndexerOfClass_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInIndexerOfClass_backbone"
export class VisualizationModel extends Backbone.Model {
>VisualizationModel : VisualizationModel
>Backbone : Backbone
>Model : Model
// interesting stuff here
}

62
tests/baselines/reference/aliasUsageInObjectLiteral.types Normal file
View File

@@ -0,0 +1,62 @@
=== tests/cases/compiler/aliasUsageInObjectLiteral_main.ts ===
import Backbone = require("aliasUsageInObjectLiteral_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInObjectLiteral_backbone"
import moduleA = require("aliasUsageInObjectLiteral_moduleA");
>moduleA : typeof "tests/cases/compiler/aliasUsageInObjectLiteral_moduleA"
interface IHasVisualizationModel {
>IHasVisualizationModel : IHasVisualizationModel
VisualizationModel: typeof Backbone.Model;
>VisualizationModel : typeof Model
>Backbone : typeof "tests/cases/compiler/aliasUsageInObjectLiteral_backbone"
>Model : typeof Model
}
var a: { x: typeof moduleA } = { x: moduleA };
>a : { x: typeof "tests/cases/compiler/aliasUsageInObjectLiteral_moduleA"; }
>x : typeof "tests/cases/compiler/aliasUsageInObjectLiteral_moduleA"
>moduleA : typeof "tests/cases/compiler/aliasUsageInObjectLiteral_moduleA"
>{ x: moduleA } : { x: typeof "tests/cases/compiler/aliasUsageInObjectLiteral_moduleA"; }
>x : typeof "tests/cases/compiler/aliasUsageInObjectLiteral_moduleA"
>moduleA : moduleA
var b: { x: IHasVisualizationModel } = { x: moduleA };
>b : { x: IHasVisualizationModel; }
>x : IHasVisualizationModel
>IHasVisualizationModel : IHasVisualizationModel
>{ x: moduleA } : { x: typeof "tests/cases/compiler/aliasUsageInObjectLiteral_moduleA"; }
>x : typeof "tests/cases/compiler/aliasUsageInObjectLiteral_moduleA"
>moduleA : moduleA
var c: { y: { z: IHasVisualizationModel } } = { y: { z: moduleA } };
>c : { y: { z: IHasVisualizationModel; }; }
>y : { z: IHasVisualizationModel; }
>z : IHasVisualizationModel
>IHasVisualizationModel : IHasVisualizationModel
>{ y: { z: moduleA } } : { y: { z: typeof "tests/cases/compiler/aliasUsageInObjectLiteral_moduleA"; }; }
>y : { z: typeof "tests/cases/compiler/aliasUsageInObjectLiteral_moduleA"; }
>{ z: moduleA } : { z: typeof "tests/cases/compiler/aliasUsageInObjectLiteral_moduleA"; }
>z : typeof "tests/cases/compiler/aliasUsageInObjectLiteral_moduleA"
>moduleA : moduleA
=== tests/cases/compiler/aliasUsageInObjectLiteral_backbone.ts ===
export class Model {
>Model : Model
public someData: string;
>someData : string
}
=== tests/cases/compiler/aliasUsageInObjectLiteral_moduleA.ts ===
import Backbone = require("aliasUsageInObjectLiteral_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInObjectLiteral_backbone"
export class VisualizationModel extends Backbone.Model {
>VisualizationModel : VisualizationModel
>Backbone : Backbone
>Model : Model
// interesting stuff here
}

83
tests/baselines/reference/aliasUsageInOrExpression.types Normal file
View File

@@ -0,0 +1,83 @@
=== tests/cases/compiler/aliasUsageInOrExpression_main.ts ===
import Backbone = require("aliasUsageInOrExpression_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInOrExpression_backbone"
import moduleA = require("aliasUsageInOrExpression_moduleA");
>moduleA : typeof "tests/cases/compiler/aliasUsageInOrExpression_moduleA"
interface IHasVisualizationModel {
>IHasVisualizationModel : IHasVisualizationModel
VisualizationModel: typeof Backbone.Model;
>VisualizationModel : typeof Model
>Backbone : typeof "tests/cases/compiler/aliasUsageInOrExpression_backbone"
>Model : typeof Model
}
var i: IHasVisualizationModel;
>i : IHasVisualizationModel
>IHasVisualizationModel : IHasVisualizationModel
var d1 = i || moduleA;
>d1 : IHasVisualizationModel
>i || moduleA : IHasVisualizationModel
>i : IHasVisualizationModel
>moduleA : typeof "tests/cases/compiler/aliasUsageInOrExpression_moduleA"
var d2: IHasVisualizationModel = i || moduleA;
>d2 : IHasVisualizationModel
>IHasVisualizationModel : IHasVisualizationModel
>i || moduleA : IHasVisualizationModel
>i : IHasVisualizationModel
>moduleA : typeof "tests/cases/compiler/aliasUsageInOrExpression_moduleA"
var d2: IHasVisualizationModel = moduleA || i;
>d2 : IHasVisualizationModel
>IHasVisualizationModel : IHasVisualizationModel
>moduleA || i : IHasVisualizationModel
>moduleA : typeof "tests/cases/compiler/aliasUsageInOrExpression_moduleA"
>i : IHasVisualizationModel
var e: { x: IHasVisualizationModel } = <{ x: IHasVisualizationModel }>null || { x: moduleA };
>e : { x: IHasVisualizationModel; }
>x : IHasVisualizationModel
>IHasVisualizationModel : IHasVisualizationModel
><{ x: IHasVisualizationModel }>null || { x: moduleA } : { x: IHasVisualizationModel; }
><{ x: IHasVisualizationModel }>null : { x: IHasVisualizationModel; }
>x : IHasVisualizationModel
>IHasVisualizationModel : IHasVisualizationModel
>{ x: moduleA } : { x: typeof "tests/cases/compiler/aliasUsageInOrExpression_moduleA"; }
>x : typeof "tests/cases/compiler/aliasUsageInOrExpression_moduleA"
>moduleA : moduleA
var f: { x: IHasVisualizationModel } = <{ x: IHasVisualizationModel }>null ? { x: moduleA } : null;
>f : { x: IHasVisualizationModel; }
>x : IHasVisualizationModel
>IHasVisualizationModel : IHasVisualizationModel
><{ x: IHasVisualizationModel }>null ? { x: moduleA } : null : { x: IHasVisualizationModel; }
><{ x: IHasVisualizationModel }>null : { x: IHasVisualizationModel; }
>x : IHasVisualizationModel
>IHasVisualizationModel : IHasVisualizationModel
>{ x: moduleA } : { x: typeof "tests/cases/compiler/aliasUsageInOrExpression_moduleA"; }
>x : typeof "tests/cases/compiler/aliasUsageInOrExpression_moduleA"
>moduleA : moduleA
=== tests/cases/compiler/aliasUsageInOrExpression_backbone.ts ===
export class Model {
>Model : Model
public someData: string;
>someData : string
}
=== tests/cases/compiler/aliasUsageInOrExpression_moduleA.ts ===
import Backbone = require("aliasUsageInOrExpression_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInOrExpression_backbone"
export class VisualizationModel extends Backbone.Model {
>VisualizationModel : VisualizationModel
>Backbone : Backbone
>Model : Model
// interesting stuff here
}

53
tests/baselines/reference/aliasUsageInTypeArgumentOfExtendsClause.types Normal file
View File

@@ -0,0 +1,53 @@
=== tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_main.ts ===
import Backbone = require("aliasUsageInTypeArgumentOfExtendsClause_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_backbone"
import moduleA = require("aliasUsageInTypeArgumentOfExtendsClause_moduleA");
>moduleA : typeof "tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_moduleA"
interface IHasVisualizationModel {
>IHasVisualizationModel : IHasVisualizationModel
VisualizationModel: typeof Backbone.Model;
>VisualizationModel : typeof Model
>Backbone : typeof "tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_backbone"
>Model : typeof Model
}
class C<T extends IHasVisualizationModel> {
>C : C<T>
>T : T
>IHasVisualizationModel : IHasVisualizationModel
x: T;
>x : T
>T : T
}
class D extends C<IHasVisualizationModel> {
>D : D
>C : C
>IHasVisualizationModel : IHasVisualizationModel
x = moduleA;
>x : typeof "tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_moduleA"
>moduleA : typeof "tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_moduleA"
}
=== tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_backbone.ts ===
export class Model {
>Model : Model
public someData: string;
>someData : string
}
=== tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_moduleA.ts ===
import Backbone = require("aliasUsageInTypeArgumentOfExtendsClause_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_backbone"
export class VisualizationModel extends Backbone.Model {
>VisualizationModel : VisualizationModel
>Backbone : Backbone
>Model : Model
// interesting stuff here
}

44
tests/baselines/reference/aliasUsageInVarAssignment.types Normal file
View File

@@ -0,0 +1,44 @@
=== tests/cases/compiler/aliasUsageInVarAssignment_main.ts ===
import Backbone = require("aliasUsageInVarAssignment_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInVarAssignment_backbone"
import moduleA = require("aliasUsageInVarAssignment_moduleA");
>moduleA : typeof "tests/cases/compiler/aliasUsageInVarAssignment_moduleA"
interface IHasVisualizationModel {
>IHasVisualizationModel : IHasVisualizationModel
VisualizationModel: typeof Backbone.Model;
>VisualizationModel : typeof Model
>Backbone : typeof "tests/cases/compiler/aliasUsageInVarAssignment_backbone"
>Model : typeof Model
}
var i: IHasVisualizationModel;
>i : IHasVisualizationModel
>IHasVisualizationModel : IHasVisualizationModel
var m: typeof moduleA = i;
>m : typeof "tests/cases/compiler/aliasUsageInVarAssignment_moduleA"
>moduleA : typeof "tests/cases/compiler/aliasUsageInVarAssignment_moduleA"
>i : IHasVisualizationModel
=== tests/cases/compiler/aliasUsageInVarAssignment_backbone.ts ===
export class Model {
>Model : Model
public someData: string;
>someData : string
}
=== tests/cases/compiler/aliasUsageInVarAssignment_moduleA.ts ===
import Backbone = require("aliasUsageInVarAssignment_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInVarAssignment_backbone"
export class VisualizationModel extends Backbone.Model {
>VisualizationModel : VisualizationModel
>Backbone : Backbone
>Model : Model
// interesting stuff here
}

34
tests/baselines/reference/aliasUsedAsNameValue.types Normal file
View File

@@ -0,0 +1,34 @@
=== tests/cases/compiler/aliasUsedAsNameValue_2.ts ===
///<reference path='aliasUsedAsNameValue_0.ts' />
///<reference path='aliasUsedAsNameValue_1.ts' />
import mod = require("aliasUsedAsNameValue_0");
>mod : typeof "tests/cases/compiler/aliasUsedAsNameValue_0"
import b = require("aliasUsedAsNameValue_1");
>b : typeof "tests/cases/compiler/aliasUsedAsNameValue_1"
export var a = function () {
>a : () => void
>function () {
//var x = mod.id; // TODO needed hack that mod is loaded
b.b(mod);
} : () => void
//var x = mod.id; // TODO needed hack that mod is loaded
b.b(mod);
>b.b(mod) : any
>b.b : (a: any) => any
>b : typeof "tests/cases/compiler/aliasUsedAsNameValue_1"
>b : (a: any) => any
>mod : typeof "tests/cases/compiler/aliasUsedAsNameValue_0"
}
=== tests/cases/compiler/aliasUsedAsNameValue_0.ts ===
export var id: number;
>id : number
=== tests/cases/compiler/aliasUsedAsNameValue_1.ts ===
export function b(a: any): any { return null; }
>b : (a: any) => any
>a : any

8
tests/baselines/reference/ambientClassDeclarationWithExtends.types Normal file
View File

@@ -0,0 +1,8 @@
=== tests/cases/compiler/ambientClassDeclarationWithExtends.ts ===
declare class A { }
>A : A
declare class B extends A { }
>B : B
>A : A

168
tests/baselines/reference/ambientDeclarations.types Normal file
View File

@@ -0,0 +1,168 @@
=== tests/cases/conformance/ambient/ambientDeclarations.ts ===
// Ambient variable without type annotation
declare var n;
>n : any
// Ambient variable with type annotation
declare var m: string;
>m : string
// Ambient function with no type annotations
declare function fn1();
>fn1 : () => any
// Ambient function with type annotations
declare function fn2(n: string): number;
>fn2 : (n: string) => number
>n : string
// Ambient function with valid overloads
declare function fn3(n: string): number;
>fn3 : (n: string) => number
>n : string
declare function fn4(n: number, y: number): string;
>fn4 : (n: number, y: number) => string
>n : number
>y : number
// Ambient function with optional parameters
declare function fn5(x, y?);
>fn5 : (x: any, y?: any) => any
>x : any
>y : any
declare function fn6(e?);
>fn6 : (e?: any) => any
>e : any
declare function fn7(x, y?, ...z);
>fn7 : (x: any, y?: any, ...z: any[]) => any
>x : any
>y : any
>z : any[]
declare function fn8(y?, ...z: number[]);
>fn8 : (y?: any, ...z: number[]) => any
>y : any
>z : number[]
declare function fn9(...q: {}[]);
>fn9 : (...q: {}[]) => any
>q : {}[]
declare function fn10<T>(...q: T[]);
>fn10 : <T>(...q: T[]) => any
>T : T
>q : T[]
>T : T
// Ambient class
declare class cls {
>cls : cls
constructor();
method(): cls;
>method : () => cls
>cls : cls
static static(p): number;
>static : (p: any) => number
>p : any
static q;
>q : any
private fn();
>fn : () => any
private static fns();
>fns : () => any
}
// Ambient enum
declare enum E1 {
>E1 : E1
x,
>x : E1
y,
>y : E1
z
>z : E1
}
// Ambient enum with integer literal initializer
declare enum E2 {
>E2 : E2
q,
>q : E2
a = 1,
>a : E2
b,
>b : E2
c = 2,
>c : E2
d
>d : E2
}
// Ambient enum members are always exported with or without export keyword
declare enum E3 {
>E3 : E3
A
>A : E3
}
declare module E3 {
>E3 : typeof E3
var B;
>B : any
}
var x = E3.B;
>x : any
>E3.B : any
>E3 : typeof E3
>B : any
// Ambient module
declare module M1 {
>M1 : typeof M1
var x;
>x : any
function fn(): number;
>fn : () => number
}
// Ambient module members are always exported with or without export keyword
var p = M1.x;
>p : any
>M1.x : any
>M1 : typeof M1
>x : any
var q = M1.fn();
>q : number
>M1.fn() : number
>M1.fn : () => number
>M1 : typeof M1
>fn : () => number
// Ambient external module in the global module
// Ambient external module with a string literal name that is a top level external module name
declare module 'external1' {
var q;
>q : any
}

7
tests/baselines/reference/ambientEnumElementInitializer1.types Normal file
View File

@@ -0,0 +1,7 @@
=== tests/cases/compiler/ambientEnumElementInitializer1.ts ===
declare enum E {
>E : E
e = 3
>e : E
}

8
tests/baselines/reference/ambientEnumElementInitializer2.types Normal file
View File

@@ -0,0 +1,8 @@
=== tests/cases/compiler/ambientEnumElementInitializer2.ts ===
declare enum E {
>E : E
e = -3 // Negative
>e : E
>-3 : number
}

7
tests/baselines/reference/ambientEnumElementInitializer4.types Normal file
View File

@@ -0,0 +1,7 @@
=== tests/cases/compiler/ambientEnumElementInitializer4.ts ===
declare enum E {
>E : E
e = 0xA
>e : E
}

8
tests/baselines/reference/ambientEnumElementInitializer5.types Normal file
View File

@@ -0,0 +1,8 @@
=== tests/cases/compiler/ambientEnumElementInitializer5.ts ===
declare enum E {
>E : E
e = -0xA
>e : E
>-0xA : number
}

11
tests/baselines/reference/ambientEnumElementInitializer6.types Normal file
View File

@@ -0,0 +1,11 @@
=== tests/cases/compiler/ambientEnumElementInitializer6.ts ===
declare module M {
>M : typeof M
enum E {
>E : E
e = 3
>e : E
}
}

9
tests/baselines/reference/ambientExternalModuleReopen.types Normal file
View File

@@ -0,0 +1,9 @@
=== tests/cases/compiler/ambientExternalModuleReopen.ts ===
declare module "fs" {
var x: string;
>x : string
}
declare module 'fs' {
var y: number;
>y : number
}

33
tests/baselines/reference/ambientExternalModuleWithInternalImportDeclaration.types Normal file
View File

@@ -0,0 +1,33 @@
=== tests/cases/compiler/ambientExternalModuleWithInternalImportDeclaration_1.ts ===
///<reference path='ambientExternalModuleWithInternalImportDeclaration_0.ts'/>
import A = require('M');
>A : typeof C
var c = new A();
>c : C
>new A() : C
>A : typeof C
=== tests/cases/compiler/ambientExternalModuleWithInternalImportDeclaration_0.ts ===
declare module 'M' {
module C {
>C : typeof C
export var f: number;
>f : number
}
class C {
>C : C
foo(): void;
>foo : () => void
}
import X = C;
>X : typeof C
>C : C
export = X;
>X : C
}

29
tests/baselines/reference/ambientExternalModuleWithoutInternalImportDeclaration.types Normal file
View File

@@ -0,0 +1,29 @@
=== tests/cases/compiler/ambientExternalModuleWithoutInternalImportDeclaration_1.ts ===
///<reference path='ambientExternalModuleWithoutInternalImportDeclaration_0.ts'/>
import A = require('M');
>A : typeof C
var c = new A();
>c : C
>new A() : C
>A : typeof C
=== tests/cases/compiler/ambientExternalModuleWithoutInternalImportDeclaration_0.ts ===
declare module 'M' {
module C {
>C : typeof C
export var f: number;
>f : number
}
class C {
>C : C
foo(): void;
>foo : () => void
}
export = C;
>C : C
}

12
tests/baselines/reference/ambientFundule.types Normal file
View File

@@ -0,0 +1,12 @@
=== tests/cases/compiler/ambientFundule.ts ===
declare function f();
>f : typeof f
declare module f { var x }
>f : typeof f
>x : any
declare function f(x);
>f : typeof f
>x : any

63
tests/baselines/reference/ambientModuleExports.types Normal file
View File

@@ -0,0 +1,63 @@
=== tests/cases/compiler/ambientModuleExports.ts ===
declare module Foo {
>Foo : typeof Foo
function a():void;
>a : () => void
var b:number;
>b : number
class C {}
>C : C
}
Foo.a();
>Foo.a() : void
>Foo.a : () => void
>Foo : typeof Foo
>a : () => void
Foo.b;
>Foo.b : number
>Foo : typeof Foo
>b : number
var c = new Foo.C();
>c : C
>new Foo.C() : C
>Foo.C : typeof C
>Foo : typeof Foo
>C : typeof C
declare module Foo2 {
>Foo2 : typeof Foo2
export function a(): void;
>a : () => void
export var b: number;
>b : number
export class C { }
>C : C
}
Foo2.a();
>Foo2.a() : void
>Foo2.a : () => void
>Foo2 : typeof Foo2
>a : () => void
Foo2.b;
>Foo2.b : number
>Foo2 : typeof Foo2
>b : number
var c2 = new Foo2.C();
>c2 : C
>new Foo2.C() : C
>Foo2.C : typeof C
>Foo2 : typeof Foo2
>C : typeof C

11
tests/baselines/reference/ambientModuleWithClassDeclarationWithExtends.types Normal file
View File

@@ -0,0 +1,11 @@
=== tests/cases/compiler/ambientModuleWithClassDeclarationWithExtends.ts ===
declare module foo {
>foo : typeof foo
class A { }
>A : A
class B extends A { }
>B : B
>A : A
}

14
tests/baselines/reference/ambientModules.types Normal file
View File

@@ -0,0 +1,14 @@
=== tests/cases/compiler/ambientModules.ts ===
declare module Foo.Bar { export var foo; };
>Foo : typeof Foo
>Bar : typeof Bar
>foo : any
Foo.Bar.foo = 5;
>Foo.Bar.foo = 5 : number
>Foo.Bar.foo : any
>Foo.Bar : typeof Bar
>Foo : typeof Foo
>Bar : typeof Bar
>foo : any

78
tests/baselines/reference/ambiguousCallsWhereReturnTypesAgree.types Normal file
View File

@@ -0,0 +1,78 @@
=== tests/cases/compiler/ambiguousCallsWhereReturnTypesAgree.ts ===
class TestClass {
>TestClass : TestClass
public bar(x: string): void;
>bar : { (x: string): void; (x: string[]): void; }
>x : string
public bar(x: string[]): void;
>bar : { (x: string): void; (x: string[]): void; }
>x : string[]
public bar(x: any): void {
>bar : { (x: string): void; (x: string[]): void; }
>x : any
}
public foo(x: string): void;
>foo : { (x: string): void; (x: string[]): void; }
>x : string
public foo(x: string[]): void;
>foo : { (x: string): void; (x: string[]): void; }
>x : string[]
public foo(x: any): void {
>foo : { (x: string): void; (x: string[]): void; }
>x : any
this.bar(x); // should not error
>this.bar(x) : void
>this.bar : { (x: string): void; (x: string[]): void; }
>this : TestClass
>bar : { (x: string): void; (x: string[]): void; }
>x : any
}
}
class TestClass2 {
>TestClass2 : TestClass2
public bar(x: string): number;
>bar : { (x: string): number; (x: string[]): number; }
>x : string
public bar(x: string[]): number;
>bar : { (x: string): number; (x: string[]): number; }
>x : string[]
public bar(x: any): number {
>bar : { (x: string): number; (x: string[]): number; }
>x : any
return 0;
}
public foo(x: string): number;
>foo : { (x: string): number; (x: string[]): number; }
>x : string
public foo(x: string[]): number;
>foo : { (x: string): number; (x: string[]): number; }
>x : string[]
public foo(x: any): number {
>foo : { (x: string): number; (x: string[]): number; }
>x : any
return this.bar(x); // should not error
>this.bar(x) : number
>this.bar : { (x: string): number; (x: string[]): number; }
>this : TestClass2
>bar : { (x: string): number; (x: string[]): number; }
>x : any
}
}

34
tests/baselines/reference/ambiguousOverloadResolution.types Normal file
View File

@@ -0,0 +1,34 @@
=== tests/cases/compiler/ambiguousOverloadResolution.ts ===
class A { }
>A : A
class B extends A { x: number; }
>B : B
>A : A
>x : number
declare function f(p: A, q: B): number;
>f : { (p: A, q: B): number; (p: B, q: A): string; }
>p : A
>A : A
>q : B
>B : B
declare function f(p: B, q: A): string;
>f : { (p: A, q: B): number; (p: B, q: A): string; }
>p : B
>B : B
>q : A
>A : A
var x: B;
>x : B
>B : B
var t: number = f(x, x); // Not an error
>t : number
>f(x, x) : number
>f : { (p: A, q: B): number; (p: B, q: A): string; }
>x : B
>x : B

25
tests/baselines/reference/amdImportAsPrimaryExpression.types Normal file
View File

@@ -0,0 +1,25 @@
=== tests/cases/conformance/externalModules/foo_1.ts ===
import foo = require("./foo_0");
>foo : typeof "tests/cases/conformance/externalModules/foo_0"
if(foo.E1.A === 0){
>foo.E1.A === 0 : boolean
>foo.E1.A : E1
>foo.E1 : typeof E1
>foo : typeof "tests/cases/conformance/externalModules/foo_0"
>E1 : typeof E1
>A : E1
// Should cause runtime import - interesting optimization possibility, as gets inlined to 0.
}
=== tests/cases/conformance/externalModules/foo_0.ts ===
export enum E1 {
>E1 : E1
A,B,C
>A : E1
>B : E1
>C : E1
}

82
tests/baselines/reference/amdImportNotAsPrimaryExpression.types Normal file
View File

@@ -0,0 +1,82 @@
=== tests/cases/conformance/externalModules/foo_1.ts ===
import foo = require("./foo_0");
>foo : typeof "tests/cases/conformance/externalModules/foo_0"
// None of the below should cause a runtime dependency on foo_0
import f = foo.M1;
>f : f
>foo : foo
>M1 : M1
var i: f.I2;
>i : I2
>f : f
>I2 : I2
var x: foo.C1 = <{m1: number}>{};
>x : C1
>foo : foo
>C1 : C1
><{m1: number}>{} : { m1: number; }
>m1 : number
>{} : {}
var y: typeof foo.C1.s1 = false;
>y : boolean
>foo : typeof "tests/cases/conformance/externalModules/foo_0"
>C1 : typeof C1
>s1 : boolean
var z: foo.M1.I2;
>z : I2
>foo : foo
>M1 : M1
>I2 : I2
var e: number = <foo.E1>0;
>e : number
><foo.E1>0 : E1
>foo : foo
>E1 : E1
=== tests/cases/conformance/externalModules/foo_0.ts ===
export class C1 {
>C1 : C1
m1 = 42;
>m1 : number
static s1 = true;
>s1 : boolean
}
export interface I1 {
>I1 : I1
name: string;
>name : string
age: number;
>age : number
}
export module M1 {
>M1 : M1
export interface I2 {
>I2 : I2
foo: string;
>foo : string
}
}
export enum E1 {
>E1 : E1
A,B,C
>A : E1
>B : E1
>C : E1
}

41
tests/baselines/reference/anonterface.types Normal file
View File

@@ -0,0 +1,41 @@
=== tests/cases/compiler/anonterface.ts ===
module M {
>M : typeof M
export class C {
>C : C
m(fn:{ (n:number):string; },n2:number):string {
>m : (fn: (n: number) => string, n2: number) => string
>fn : (n: number) => string
>n : number
>n2 : number
return fn(n2);
>fn(n2) : string
>fn : (n: number) => string
>n2 : number
}
}
}
var c=new M.C();
>c : C
>new M.C() : C
>M.C : typeof C
>M : typeof M
>C : typeof C
c.m(function(n) { return "hello: "+n; },18);
>c.m(function(n) { return "hello: "+n; },18) : string
>c.m : (fn: (n: number) => string, n2: number) => string
>c : C
>m : (fn: (n: number) => string, n2: number) => string
>function(n) { return "hello: "+n; } : (n: number) => string
>n : number
>"hello: "+n : string
>n : number

23
tests/baselines/reference/anyAsFunctionCall.types Normal file
View File

@@ -0,0 +1,23 @@
=== tests/cases/conformance/types/any/anyAsFunctionCall.ts ===
// any is considered an untyped function call
// can be called except with type arguments which is an error
var x: any;
>x : any
var a = x();
>a : any
>x() : any
>x : any
var b = x('hello');
>b : any
>x('hello') : any
>x : any
var c = x(x);
>c : any
>x(x) : any
>x : any
>x : any

35
tests/baselines/reference/anyAsReturnTypeForNewOnCall.types Normal file
View File

@@ -0,0 +1,35 @@
=== tests/cases/compiler/anyAsReturnTypeForNewOnCall.ts ===
function Point(x, y) {
>Point : (x: any, y: any) => void
>x : any
>y : any
this.x = x;
>this.x = x : any
>this.x : any
>this : any
>x : any
>x : any
this.y = y;
>this.y = y : any
>this.y : any
>this : any
>y : any
>y : any
}
var o = new Point(3, 4);
>o : any
>new Point(3, 4) : any
>Point : (x: any, y: any) => void
var xx = o.x;
>xx : any
>o.x : any
>o : any
>x : any

321
tests/baselines/reference/anyAssignabilityInInheritance.types Normal file
View File

@@ -0,0 +1,321 @@
=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/anyAssignabilityInInheritance.ts ===
// any is not a subtype of any other types, errors expected on all the below derived classes unless otherwise noted
interface I {
>I : I
[x: string]: any;
>x : string
foo: any; // ok, any identical to itself
>foo : any
}
var a: any;
>a : any
declare function foo2(x: number): number;
>foo2 : { (x: number): number; (x: any): any; }
>x : number
declare function foo2(x: any): any;
>foo2 : { (x: number): number; (x: any): any; }
>x : any
var r3 = foo2(a); // any, not a subtype of number so it skips that overload, is a subtype of itself so it picks second (if truly ambiguous it would pick first overload)
>r3 : any
>foo2(a) : any
>foo2 : { (x: number): number; (x: any): any; }
>a : any
declare function foo3(x: string): string;
>foo3 : { (x: string): string; (x: any): any; }
>x : string
declare function foo3(x: any): any;
>foo3 : { (x: string): string; (x: any): any; }
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
>a : any
declare function foo4(x: boolean): boolean;
>foo4 : { (x: boolean): boolean; (x: any): any; }
>x : boolean
declare function foo4(x: any): any;
>foo4 : { (x: boolean): boolean; (x: any): any; }
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
>a : any
declare function foo5(x: Date): Date;
>foo5 : { (x: Date): Date; (x: any): any; }
>x : Date
>Date : Date
>Date : Date
declare function foo5(x: any): any;
>foo5 : { (x: Date): Date; (x: any): any; }
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
>a : any
declare function foo6(x: RegExp): RegExp;
>foo6 : { (x: RegExp): RegExp; (x: any): any; }
>x : RegExp
>RegExp : RegExp
>RegExp : RegExp
declare function foo6(x: any): any;
>foo6 : { (x: RegExp): RegExp; (x: any): any; }
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
>a : any
declare function foo7(x: { bar: number }): { bar: number };
>foo7 : { (x: { bar: number; }): { bar: number; }; (x: any): any; }
>x : { bar: number; }
>bar : number
>bar : number
declare function foo7(x: any): any;
>foo7 : { (x: { bar: number; }): { bar: number; }; (x: any): any; }
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
>a : any
declare function foo8(x: number[]): number[];
>foo8 : { (x: number[]): number[]; (x: any): any; }
>x : number[]
declare function foo8(x: any): any;
>foo8 : { (x: number[]): number[]; (x: any): any; }
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
>a : any
interface I8 { foo: string }
>I8 : I8
>foo : string
declare function foo9(x: I8): I8;
>foo9 : { (x: I8): I8; (x: any): any; }
>x : I8
>I8 : I8
>I8 : I8
declare function foo9(x: any): any;
>foo9 : { (x: I8): I8; (x: any): any; }
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
>a : any
class A { foo: number; }
>A : A
>foo : number
declare function foo10(x: A): A;
>foo10 : { (x: A): A; (x: any): any; }
>x : A
>A : A
>A : A
declare function foo10(x: any): any;
>foo10 : { (x: A): A; (x: any): any; }
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
>a : any
class A2<T> { foo: T; }
>A2 : A2<T>
>T : T
>foo : T
>T : T
declare function foo11(x: A2<string>): A2<string>;
>foo11 : { (x: A2<string>): A2<string>; (x: any): any; }
>x : A2<string>
>A2 : A2
>A2 : A2
declare function foo11(x: any): any;
>foo11 : { (x: A2<string>): A2<string>; (x: any): any; }
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
>a : any
declare function foo12(x: (x) => number): (x) => number;
>foo12 : { (x: (x: any) => number): (x: any) => number; (x: any): any; }
>x : (x: any) => number
>x : any
>x : any
declare function foo12(x: any): any;
>foo12 : { (x: (x: any) => number): (x: any) => number; (x: any): any; }
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
>a : any
declare function foo13(x: <T>(x: T) => T): <T>(x: T) => T;
>foo13 : { (x: <T>(x: T) => T): <T>(x: T) => T; (x: any): any; }
>x : <T>(x: T) => T
>T : T
>x : T
>T : T
>T : T
>T : T
>x : T
>T : T
>T : T
declare function foo13(x: any): any;
>foo13 : { (x: <T>(x: T) => T): <T>(x: T) => T; (x: any): any; }
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
>a : any
enum E { A }
>E : E
>A : E
declare function foo14(x: E): E;
>foo14 : { (x: E): E; (x: any): any; }
>x : E
>E : E
>E : E
declare function foo14(x: any): any;
>foo14 : { (x: E): E; (x: any): any; }
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
>a : any
function f() { }
>f : typeof f
module f {
>f : typeof f
export var bar = 1;
>bar : number
}
declare function foo15(x: typeof f): typeof f;
>foo15 : { (x: typeof f): typeof f; (x: any): any; }
>x : typeof f
>f : typeof f
>f : typeof f
declare function foo15(x: any): any;
>foo15 : { (x: typeof f): typeof f; (x: any): any; }
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
>a : any
class CC { baz: string }
>CC : CC
>baz : string
module CC {
>CC : typeof CC
export var bar = 1;
>bar : number
}
declare function foo16(x: CC): CC;
>foo16 : { (x: CC): CC; (x: any): any; }
>x : CC
>CC : CC
>CC : CC
declare function foo16(x: any): any;
>foo16 : { (x: CC): CC; (x: any): any; }
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
>a : any
declare function foo17(x: Object): Object;
>foo17 : { (x: Object): Object; (x: any): any; }
>x : Object
>Object : Object
>Object : Object
declare function foo17(x: any): any;
>foo17 : { (x: Object): Object; (x: any): any; }
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
>a : any
declare function foo18(x: {}): {};
>foo18 : { (x: {}): {}; (x: any): any; }
>x : {}
declare function foo18(x: any): any;
>foo18 : { (x: {}): {}; (x: any): any; }
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
>a : any

156
tests/baselines/reference/anyAssignableToEveryType.types Normal file
View File

@@ -0,0 +1,156 @@
=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/anyAssignableToEveryType.ts ===
var a: any;
>a : any
class C {
>C : C
foo: string;
>foo : string
}
var ac: C;
>ac : C
>C : C
interface I {
>I : I
foo: string;
>foo : string
}
var ai: I;
>ai : I
>I : I
enum E { A }
>E : E
>A : E
var ae: E;
>ae : E
>E : E
var b: number = a;
>b : number
>a : any
var c: string = a;
>c : string
>a : any
var d: boolean = a;
>d : boolean
>a : any
var e: Date = a;
>e : Date
>Date : Date
>a : any
var f: any = a;
>f : any
>a : any
var g: void = a;
>g : void
>a : any
var h: Object = a;
>h : Object
>Object : Object
>a : any
var i: {} = a;
>i : {}
>a : any
var j: () => {} = a;
>j : () => {}
>a : any
var k: Function = a;
>k : Function
>Function : Function
>a : any
var l: (x: number) => string = a;
>l : (x: number) => string
>x : number
>a : any
ac = a;
>ac = a : any
>ac : C
>a : any
ai = a;
>ai = a : any
>ai : I
>a : any
ae = a;
>ae = a : any
>ae : E
>a : any
var m: number[] = a;
>m : number[]
>a : any
var n: { foo: string } = a;
>n : { foo: string; }
>foo : string
>a : any
var o: <T>(x: T) => T = a;
>o : <T>(x: T) => T
>T : T
>x : T
>T : T
>T : T
>a : any
var p: Number = a;
>p : Number
>Number : Number
>a : any
var q: String = a;
>q : String
>String : String
>a : any
function foo<T, U /*extends T*/, V extends Date>(x: T, y: U, z: V) {
>foo : <T, U, V extends Date>(x: T, y: U, z: V) => void
>T : T
>U : U
>V : V
>Date : Date
>x : T
>T : T
>y : U
>U : U
>z : V
>V : V
x = a;
>x = a : any
>x : T
>a : any
y = a;
>y = a : any
>y : U
>a : any
z = a;
>z = a : any
>z : V
>a : any
}
//function foo<T, U extends T, V extends Date>(x: T, y: U, z: V) {
// x = a;
// y = a;
// z = a;
//}

93
tests/baselines/reference/anyInferenceAnonymousFunctions.types Normal file
View File

@@ -0,0 +1,93 @@
=== tests/cases/compiler/anyInferenceAnonymousFunctions.ts ===
var paired: any[];
>paired : any[]
paired.reduce(function (a1, a2) {
>paired.reduce(function (a1, a2) {
return a1.concat({});
} , []) : any
>paired.reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
>paired : any[]
>reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
>function (a1, a2) {
return a1.concat({});
} : (a1: any, a2: any) => any
>a1 : any
>a2 : any
return a1.concat({});
>a1.concat({}) : any
>a1.concat : any
>a1 : any
>concat : any
>{} : {}
} , []);
>[] : undefined[]
paired.reduce((b1, b2) => {
>paired.reduce((b1, b2) => {
return b1.concat({});
} , []) : any
>paired.reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
>paired : any[]
>reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
>(b1, b2) => {
return b1.concat({});
} : (b1: any, b2: any) => any
>b1 : any
>b2 : any
return b1.concat({});
>b1.concat({}) : any
>b1.concat : any
>b1 : any
>concat : any
>{} : {}
} , []);
>[] : undefined[]
paired.reduce((b3, b4) => b3.concat({}), []);
>paired.reduce((b3, b4) => b3.concat({}), []) : any
>paired.reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
>paired : any[]
>reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
>(b3, b4) => b3.concat({}) : (b3: any, b4: any) => any
>b3 : any
>b4 : any
>b3.concat({}) : any
>b3.concat : any
>b3 : any
>concat : any
>{} : {}
>[] : undefined[]
paired.map((c1) => c1.count);
>paired.map((c1) => c1.count) : any[]
>paired.map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
>paired : any[]
>map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
>(c1) => c1.count : (c1: any) => any
>c1 : any
>c1.count : any
>c1 : any
>count : any
paired.map(function (c2) { return c2.count; });
>paired.map(function (c2) { return c2.count; }) : any[]
>paired.map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
>paired : any[]
>map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
>function (c2) { return c2.count; } : (c2: any) => any
>c2 : any
>c2.count : any
>c2 : any
>count : any

15
tests/baselines/reference/anyIsAssignableToObject.types Normal file
View File

@@ -0,0 +1,15 @@
=== tests/cases/compiler/anyIsAssignableToObject.ts ===
interface P {
>P : P
p: {};
>p : {}
}
interface Q extends P { // Check assignability here. Any is assignable to {}
>Q : Q
>P : P
p: any;
>p : any
}

15
tests/baselines/reference/anyIsAssignableToVoid.types Normal file
View File

@@ -0,0 +1,15 @@
=== tests/cases/compiler/anyIsAssignableToVoid.ts ===
interface P {
>P : P
p: void;
>p : void
}
interface Q extends P { // check assignability here. any is assignable to void.
>Q : Q
>P : P
p: any;
>p : any
}

16
tests/baselines/reference/anyPlusAny1.types Normal file
View File

@@ -0,0 +1,16 @@
=== tests/cases/compiler/anyPlusAny1.ts ===
var x;
>x : any
x.name = "hello";
>x.name = "hello" : string
>x.name : any
>x : any
>name : any
var z = x + x;
>z : any
>x + x : any
>x : any
>x : any

43
tests/baselines/reference/anyPropertyAccess.types Normal file
View File

@@ -0,0 +1,43 @@
=== tests/cases/conformance/types/any/anyPropertyAccess.ts ===
var x: any;
>x : any
var a = x.foo;
>a : any
>x.foo : any
>x : any
>foo : any
var b = x['foo'];
>b : any
>x['foo'] : any
>x : any
var c = x['fn']();
>c : any
>x['fn']() : any
>x['fn'] : any
>x : any
var d = x.bar.baz;
>d : any
>x.bar.baz : any
>x.bar : any
>x : any
>bar : any
>baz : any
var e = x[0].foo;
>e : any
>x[0].foo : any
>x[0] : any
>x : any
>foo : any
var f = x['0'].bar;
>f : any
>x['0'].bar : any
>x['0'] : any
>x : any
>bar : any

36
tests/baselines/reference/argsInScope.types Normal file
View File

@@ -0,0 +1,36 @@
=== tests/cases/compiler/argsInScope.ts ===
class C {
>C : C
P(ii:number, j:number, k:number) {
>P : (ii: number, j: number, k: number) => void
>ii : number
>j : number
>k : number
for (var i = 0; i < arguments.length; i++) {
>i : number
>i < arguments.length : boolean
>i : number
>arguments.length : number
>arguments : IArguments
>length : number
>i++ : number
>i : number
// WScript.Echo("param: " + arguments[i]);
}
}
}
var c = new C();
>c : C
>new C() : C
>C : typeof C
c.P(1,2,3);
>c.P(1,2,3) : void
>c.P : (ii: number, j: number, k: number) => void
>c : C
>P : (ii: number, j: number, k: number) => void

9
tests/baselines/reference/arguments.types Normal file
View File

@@ -0,0 +1,9 @@
=== tests/cases/compiler/arguments.ts ===
function f() {
>f : () => void
var x=arguments[12];
>x : any
>arguments[12] : any
>arguments : IArguments
}

23
tests/baselines/reference/argumentsUsedInObjectLiteralProperty.types Normal file
View File

@@ -0,0 +1,23 @@
=== tests/cases/compiler/argumentsUsedInObjectLiteralProperty.ts ===
class A {
>A : A
public static createSelectableViewModel(initialState?: any, selectedValue?: any) {
>createSelectableViewModel : (initialState?: any, selectedValue?: any) => { selectedValue: number; }
>initialState : any
>selectedValue : any
return {
>{
selectedValue: arguments.length
} : { selectedValue: number; }
selectedValue: arguments.length
>selectedValue : number
>arguments.length : number
>arguments : IArguments
>length : number
};
}
}

437
tests/baselines/reference/arithmeticOperatorWithAnyAndNumber.types Normal file
View File

@@ -0,0 +1,437 @@
=== tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithAnyAndNumber.ts ===
var a: any;
>a : any
var b: number;
>b : number
// operator *
var ra1 = a * a;
>ra1 : number
>a * a : number
>a : any
>a : any
var ra2 = a * b;
>ra2 : number
>a * b : number
>a : any
>b : number
var ra3 = a * 0;
>ra3 : number
>a * 0 : number
>a : any
var ra4 = 0 * a;
>ra4 : number
>0 * a : number
>a : any
var ra5 = 0 * 0;
>ra5 : number
>0 * 0 : number
var ra6 = b * 0;
>ra6 : number
>b * 0 : number
>b : number
var ra7 = 0 * b;
>ra7 : number
>0 * b : number
>b : number
var ra8 = b * b;
>ra8 : number
>b * b : number
>b : number
>b : number
// operator /
var rb1 = a / a;
>rb1 : number
>a / a : number
>a : any
>a : any
var rb2 = a / b;
>rb2 : number
>a / b : number
>a : any
>b : number
var rb3 = a / 0;
>rb3 : number
>a / 0 : number
>a : any
var rb4 = 0 / a;
>rb4 : number
>0 / a : number
>a : any
var rb5 = 0 / 0;
>rb5 : number
>0 / 0 : number
var rb6 = b / 0;
>rb6 : number
>b / 0 : number
>b : number
var rb7 = 0 / b;
>rb7 : number
>0 / b : number
>b : number
var rb8 = b / b;
>rb8 : number
>b / b : number
>b : number
>b : number
// operator %
var rc1 = a % a;
>rc1 : number
>a % a : number
>a : any
>a : any
var rc2 = a % b;
>rc2 : number
>a % b : number
>a : any
>b : number
var rc3 = a % 0;
>rc3 : number
>a % 0 : number
>a : any
var rc4 = 0 % a;
>rc4 : number
>0 % a : number
>a : any
var rc5 = 0 % 0;
>rc5 : number
>0 % 0 : number
var rc6 = b % 0;
>rc6 : number
>b % 0 : number
>b : number
var rc7 = 0 % b;
>rc7 : number
>0 % b : number
>b : number
var rc8 = b % b;
>rc8 : number
>b % b : number
>b : number
>b : number
// operator -
var rd1 = a - a;
>rd1 : number
>a - a : number
>a : any
>a : any
var rd2 = a - b;
>rd2 : number
>a - b : number
>a : any
>b : number
var rd3 = a - 0;
>rd3 : number
>a - 0 : number
>a : any
var rd4 = 0 - a;
>rd4 : number
>0 - a : number
>a : any
var rd5 = 0 - 0;
>rd5 : number
>0 - 0 : number
var rd6 = b - 0;
>rd6 : number
>b - 0 : number
>b : number
var rd7 = 0 - b;
>rd7 : number
>0 - b : number
>b : number
var rd8 = b - b;
>rd8 : number
>b - b : number
>b : number
>b : number
// operator <<
var re1 = a << a;
>re1 : number
>a << a : number
>a : any
>a : any
var re2 = a << b;
>re2 : number
>a << b : number
>a : any
>b : number
var re3 = a << 0;
>re3 : number
>a << 0 : number
>a : any
var re4 = 0 << a;
>re4 : number
>0 << a : number
>a : any
var re5 = 0 << 0;
>re5 : number
>0 << 0 : number
var re6 = b << 0;
>re6 : number
>b << 0 : number
>b : number
var re7 = 0 << b;
>re7 : number
>0 << b : number
>b : number
var re8 = b << b;
>re8 : number
>b << b : number
>b : number
>b : number
// operator >>
var rf1 = a >> a;
>rf1 : number
>a >> a : number
>a : any
>a : any
var rf2 = a >> b;
>rf2 : number
>a >> b : number
>a : any
>b : number
var rf3 = a >> 0;
>rf3 : number
>a >> 0 : number
>a : any
var rf4 = 0 >> a;
>rf4 : number
>0 >> a : number
>a : any
var rf5 = 0 >> 0;
>rf5 : number
>0 >> 0 : number
var rf6 = b >> 0;
>rf6 : number
>b >> 0 : number
>b : number
var rf7 = 0 >> b;
>rf7 : number
>0 >> b : number
>b : number
var rf8 = b >> b;
>rf8 : number
>b >> b : number
>b : number
>b : number
// operator >>>
var rg1 = a >>> a;
>rg1 : number
>a >>> a : number
>a : any
>a : any
var rg2 = a >>> b;
>rg2 : number
>a >>> b : number
>a : any
>b : number
var rg3 = a >>> 0;
>rg3 : number
>a >>> 0 : number
>a : any
var rg4 = 0 >>> a;
>rg4 : number
>0 >>> a : number
>a : any
var rg5 = 0 >>> 0;
>rg5 : number
>0 >>> 0 : number
var rg6 = b >>> 0;
>rg6 : number
>b >>> 0 : number
>b : number
var rg7 = 0 >>> b;
>rg7 : number
>0 >>> b : number
>b : number
var rg8 = b >>> b;
>rg8 : number
>b >>> b : number
>b : number
>b : number
// operator &
var rh1 = a & a;
>rh1 : number
>a & a : number
>a : any
>a : any
var rh2 = a & b;
>rh2 : number
>a & b : number
>a : any
>b : number
var rh3 = a & 0;
>rh3 : number
>a & 0 : number
>a : any
var rh4 = 0 & a;
>rh4 : number
>0 & a : number
>a : any
var rh5 = 0 & 0;
>rh5 : number
>0 & 0 : number
var rh6 = b & 0;
>rh6 : number
>b & 0 : number
>b : number
var rh7 = 0 & b;
>rh7 : number
>0 & b : number
>b : number
var rh8 = b & b;
>rh8 : number
>b & b : number
>b : number
>b : number
// operator ^
var ri1 = a ^ a;
>ri1 : number
>a ^ a : number
>a : any
>a : any
var ri2 = a ^ b;
>ri2 : number
>a ^ b : number
>a : any
>b : number
var ri3 = a ^ 0;
>ri3 : number
>a ^ 0 : number
>a : any
var ri4 = 0 ^ a;
>ri4 : number
>0 ^ a : number
>a : any
var ri5 = 0 ^ 0;
>ri5 : number
>0 ^ 0 : number
var ri6 = b ^ 0;
>ri6 : number
>b ^ 0 : number
>b : number
var ri7 = 0 ^ b;
>ri7 : number
>0 ^ b : number
>b : number
var ri8 = b ^ b;
>ri8 : number
>b ^ b : number
>b : number
>b : number
// operator |
var rj1 = a | a;
>rj1 : number
>a | a : number
>a : any
>a : any
var rj2 = a | b;
>rj2 : number
>a | b : number
>a : any
>b : number
var rj3 = a | 0;
>rj3 : number
>a | 0 : number
>a : any
var rj4 = 0 | a;
>rj4 : number
>0 | a : number
>a : any
var rj5 = 0 | 0;
>rj5 : number
>0 | 0 : number
var rj6 = b | 0;
>rj6 : number
>b | 0 : number
>b : number
var rj7 = 0 | b;
>rj7 : number
>0 | b : number
>b : number
var rj8 = b | b;
>rj8 : number
>b | b : number
>b : number
>b : number

893
tests/baselines/reference/arithmeticOperatorWithEnum.types Normal file
View File

@@ -0,0 +1,893 @@
=== tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithEnum.ts ===
// operands of an enum type are treated as having the primitive type Number.
enum E {
>E : E
a,
>a : E
b
>b : E
}
var a: any;
>a : any
var b: number;
>b : number
var c: E;
>c : E
>E : E
// operator *
var ra1 = c * a;
>ra1 : number
>c * a : number
>c : E
>a : any
var ra2 = c * b;
>ra2 : number
>c * b : number
>c : E
>b : number
var ra3 = c * c;
>ra3 : number
>c * c : number
>c : E
>c : E
var ra4 = a * c;
>ra4 : number
>a * c : number
>a : any
>c : E
var ra5 = b * c;
>ra5 : number
>b * c : number
>b : number
>c : E
var ra6 = E.a * a;
>ra6 : number
>E.a * a : number
>E.a : E
>E : typeof E
>a : E
>a : any
var ra7 = E.a * b;
>ra7 : number
>E.a * b : number
>E.a : E
>E : typeof E
>a : E
>b : number
var ra8 = E.a * E.b;
>ra8 : number
>E.a * E.b : number
>E.a : E
>E : typeof E
>a : E
>E.b : E
>E : typeof E
>b : E
var ra9 = E.a * 1;
>ra9 : number
>E.a * 1 : number
>E.a : E
>E : typeof E
>a : E
var ra10 = a * E.b;
>ra10 : number
>a * E.b : number
>a : any
>E.b : E
>E : typeof E
>b : E
var ra11 = b * E.b;
>ra11 : number
>b * E.b : number
>b : number
>E.b : E
>E : typeof E
>b : E
var ra12 = 1 * E.b;
>ra12 : number
>1 * E.b : number
>E.b : E
>E : typeof E
>b : E
// operator /
var rb1 = c / a;
>rb1 : number
>c / a : number
>c : E
>a : any
var rb2 = c / b;
>rb2 : number
>c / b : number
>c : E
>b : number
var rb3 = c / c;
>rb3 : number
>c / c : number
>c : E
>c : E
var rb4 = a / c;
>rb4 : number
>a / c : number
>a : any
>c : E
var rb5 = b / c;
>rb5 : number
>b / c : number
>b : number
>c : E
var rb6 = E.a / a;
>rb6 : number
>E.a / a : number
>E.a : E
>E : typeof E
>a : E
>a : any
var rb7 = E.a / b;
>rb7 : number
>E.a / b : number
>E.a : E
>E : typeof E
>a : E
>b : number
var rb8 = E.a / E.b;
>rb8 : number
>E.a / E.b : number
>E.a : E
>E : typeof E
>a : E
>E.b : E
>E : typeof E
>b : E
var rb9 = E.a / 1;
>rb9 : number
>E.a / 1 : number
>E.a : E
>E : typeof E
>a : E
var rb10 = a / E.b;
>rb10 : number
>a / E.b : number
>a : any
>E.b : E
>E : typeof E
>b : E
var rb11 = b / E.b;
>rb11 : number
>b / E.b : number
>b : number
>E.b : E
>E : typeof E
>b : E
var rb12 = 1 / E.b;
>rb12 : number
>1 / E.b : number
>E.b : E
>E : typeof E
>b : E
// operator %
var rc1 = c % a;
>rc1 : number
>c % a : number
>c : E
>a : any
var rc2 = c % b;
>rc2 : number
>c % b : number
>c : E
>b : number
var rc3 = c % c;
>rc3 : number
>c % c : number
>c : E
>c : E
var rc4 = a % c;
>rc4 : number
>a % c : number
>a : any
>c : E
var rc5 = b % c;
>rc5 : number
>b % c : number
>b : number
>c : E
var rc6 = E.a % a;
>rc6 : number
>E.a % a : number
>E.a : E
>E : typeof E
>a : E
>a : any
var rc7 = E.a % b;
>rc7 : number
>E.a % b : number
>E.a : E
>E : typeof E
>a : E
>b : number
var rc8 = E.a % E.b;
>rc8 : number
>E.a % E.b : number
>E.a : E
>E : typeof E
>a : E
>E.b : E
>E : typeof E
>b : E
var rc9 = E.a % 1;
>rc9 : number
>E.a % 1 : number
>E.a : E
>E : typeof E
>a : E
var rc10 = a % E.b;
>rc10 : number
>a % E.b : number
>a : any
>E.b : E
>E : typeof E
>b : E
var rc11 = b % E.b;
>rc11 : number
>b % E.b : number
>b : number
>E.b : E
>E : typeof E
>b : E
var rc12 = 1 % E.b;
>rc12 : number
>1 % E.b : number
>E.b : E
>E : typeof E
>b : E
// operator -
var rd1 = c - a;
>rd1 : number
>c - a : number
>c : E
>a : any
var rd2 = c - b;
>rd2 : number
>c - b : number
>c : E
>b : number
var rd3 = c - c;
>rd3 : number
>c - c : number
>c : E
>c : E
var rd4 = a - c;
>rd4 : number
>a - c : number
>a : any
>c : E
var rd5 = b - c;
>rd5 : number
>b - c : number
>b : number
>c : E
var rd6 = E.a - a;
>rd6 : number
>E.a - a : number
>E.a : E
>E : typeof E
>a : E
>a : any
var rd7 = E.a - b;
>rd7 : number
>E.a - b : number
>E.a : E
>E : typeof E
>a : E
>b : number
var rd8 = E.a - E.b;
>rd8 : number
>E.a - E.b : number
>E.a : E
>E : typeof E
>a : E
>E.b : E
>E : typeof E
>b : E
var rd9 = E.a - 1;
>rd9 : number
>E.a - 1 : number
>E.a : E
>E : typeof E
>a : E
var rd10 = a - E.b;
>rd10 : number
>a - E.b : number
>a : any
>E.b : E
>E : typeof E
>b : E
var rd11 = b - E.b;
>rd11 : number
>b - E.b : number
>b : number
>E.b : E
>E : typeof E
>b : E
var rd12 = 1 - E.b;
>rd12 : number
>1 - E.b : number
>E.b : E
>E : typeof E
>b : E
// operator <<
var re1 = c << a;
>re1 : number
>c << a : number
>c : E
>a : any
var re2 = c << b;
>re2 : number
>c << b : number
>c : E
>b : number
var re3 = c << c;
>re3 : number
>c << c : number
>c : E
>c : E
var re4 = a << c;
>re4 : number
>a << c : number
>a : any
>c : E
var re5 = b << c;
>re5 : number
>b << c : number
>b : number
>c : E
var re6 = E.a << a;
>re6 : number
>E.a << a : number
>E.a : E
>E : typeof E
>a : E
>a : any
var re7 = E.a << b;
>re7 : number
>E.a << b : number
>E.a : E
>E : typeof E
>a : E
>b : number
var re8 = E.a << E.b;
>re8 : number
>E.a << E.b : number
>E.a : E
>E : typeof E
>a : E
>E.b : E
>E : typeof E
>b : E
var re9 = E.a << 1;
>re9 : number
>E.a << 1 : number
>E.a : E
>E : typeof E
>a : E
var re10 = a << E.b;
>re10 : number
>a << E.b : number
>a : any
>E.b : E
>E : typeof E
>b : E
var re11 = b << E.b;
>re11 : number
>b << E.b : number
>b : number
>E.b : E
>E : typeof E
>b : E
var re12 = 1 << E.b;
>re12 : number
>1 << E.b : number
>E.b : E
>E : typeof E
>b : E
// operator >>
var rf1 = c >> a;
>rf1 : number
>c >> a : number
>c : E
>a : any
var rf2 = c >> b;
>rf2 : number
>c >> b : number
>c : E
>b : number
var rf3 = c >> c;
>rf3 : number
>c >> c : number
>c : E
>c : E
var rf4 = a >> c;
>rf4 : number
>a >> c : number
>a : any
>c : E
var rf5 = b >> c;
>rf5 : number
>b >> c : number
>b : number
>c : E
var rf6 = E.a >> a;
>rf6 : number
>E.a >> a : number
>E.a : E
>E : typeof E
>a : E
>a : any
var rf7 = E.a >> b;
>rf7 : number
>E.a >> b : number
>E.a : E
>E : typeof E
>a : E
>b : number
var rf8 = E.a >> E.b;
>rf8 : number
>E.a >> E.b : number
>E.a : E
>E : typeof E
>a : E
>E.b : E
>E : typeof E
>b : E
var rf9 = E.a >> 1;
>rf9 : number
>E.a >> 1 : number
>E.a : E
>E : typeof E
>a : E
var rf10 = a >> E.b;
>rf10 : number
>a >> E.b : number
>a : any
>E.b : E
>E : typeof E
>b : E
var rf11 = b >> E.b;
>rf11 : number
>b >> E.b : number
>b : number
>E.b : E
>E : typeof E
>b : E
var rf12 = 1 >> E.b;
>rf12 : number
>1 >> E.b : number
>E.b : E
>E : typeof E
>b : E
// operator >>>
var rg1 = c >>> a;
>rg1 : number
>c >>> a : number
>c : E
>a : any
var rg2 = c >>> b;
>rg2 : number
>c >>> b : number
>c : E
>b : number
var rg3 = c >>> c;
>rg3 : number
>c >>> c : number
>c : E
>c : E
var rg4 = a >>> c;
>rg4 : number
>a >>> c : number
>a : any
>c : E
var rg5 = b >>> c;
>rg5 : number
>b >>> c : number
>b : number
>c : E
var rg6 = E.a >>> a;
>rg6 : number
>E.a >>> a : number
>E.a : E
>E : typeof E
>a : E
>a : any
var rg7 = E.a >>> b;
>rg7 : number
>E.a >>> b : number
>E.a : E
>E : typeof E
>a : E
>b : number
var rg8 = E.a >>> E.b;
>rg8 : number
>E.a >>> E.b : number
>E.a : E
>E : typeof E
>a : E
>E.b : E
>E : typeof E
>b : E
var rg9 = E.a >>> 1;
>rg9 : number
>E.a >>> 1 : number
>E.a : E
>E : typeof E
>a : E
var rg10 = a >>> E.b;
>rg10 : number
>a >>> E.b : number
>a : any
>E.b : E
>E : typeof E
>b : E
var rg11 = b >>> E.b;
>rg11 : number
>b >>> E.b : number
>b : number
>E.b : E
>E : typeof E
>b : E
var rg12 = 1 >>> E.b;
>rg12 : number
>1 >>> E.b : number
>E.b : E
>E : typeof E
>b : E
// operator &
var rh1 = c & a;
>rh1 : number
>c & a : number
>c : E
>a : any
var rh2 = c & b;
>rh2 : number
>c & b : number
>c : E
>b : number
var rh3 = c & c;
>rh3 : number
>c & c : number
>c : E
>c : E
var rh4 = a & c;
>rh4 : number
>a & c : number
>a : any
>c : E
var rh5 = b & c;
>rh5 : number
>b & c : number
>b : number
>c : E
var rh6 = E.a & a;
>rh6 : number
>E.a & a : number
>E.a : E
>E : typeof E
>a : E
>a : any
var rh7 = E.a & b;
>rh7 : number
>E.a & b : number
>E.a : E
>E : typeof E
>a : E
>b : number
var rh8 = E.a & E.b;
>rh8 : number
>E.a & E.b : number
>E.a : E
>E : typeof E
>a : E
>E.b : E
>E : typeof E
>b : E
var rh9 = E.a & 1;
>rh9 : number
>E.a & 1 : number
>E.a : E
>E : typeof E
>a : E
var rh10 = a & E.b;
>rh10 : number
>a & E.b : number
>a : any
>E.b : E
>E : typeof E
>b : E
var rh11 = b & E.b;
>rh11 : number
>b & E.b : number
>b : number
>E.b : E
>E : typeof E
>b : E
var rh12 = 1 & E.b;
>rh12 : number
>1 & E.b : number
>E.b : E
>E : typeof E
>b : E
// operator ^
var ri1 = c ^ a;
>ri1 : number
>c ^ a : number
>c : E
>a : any
var ri2 = c ^ b;
>ri2 : number
>c ^ b : number
>c : E
>b : number
var ri3 = c ^ c;
>ri3 : number
>c ^ c : number
>c : E
>c : E
var ri4 = a ^ c;
>ri4 : number
>a ^ c : number
>a : any
>c : E
var ri5 = b ^ c;
>ri5 : number
>b ^ c : number
>b : number
>c : E
var ri6 = E.a ^ a;
>ri6 : number
>E.a ^ a : number
>E.a : E
>E : typeof E
>a : E
>a : any
var ri7 = E.a ^ b;
>ri7 : number
>E.a ^ b : number
>E.a : E
>E : typeof E
>a : E
>b : number
var ri8 = E.a ^ E.b;
>ri8 : number
>E.a ^ E.b : number
>E.a : E
>E : typeof E
>a : E
>E.b : E
>E : typeof E
>b : E
var ri9 = E.a ^ 1;
>ri9 : number
>E.a ^ 1 : number
>E.a : E
>E : typeof E
>a : E
var ri10 = a ^ E.b;
>ri10 : number
>a ^ E.b : number
>a : any
>E.b : E
>E : typeof E
>b : E
var ri11 = b ^ E.b;
>ri11 : number
>b ^ E.b : number
>b : number
>E.b : E
>E : typeof E
>b : E
var ri12 = 1 ^ E.b;
>ri12 : number
>1 ^ E.b : number
>E.b : E
>E : typeof E
>b : E
// operator |
var rj1 = c | a;
>rj1 : number
>c | a : number
>c : E
>a : any
var rj2 = c | b;
>rj2 : number
>c | b : number
>c : E
>b : number
var rj3 = c | c;
>rj3 : number
>c | c : number
>c : E
>c : E
var rj4 = a | c;
>rj4 : number
>a | c : number
>a : any
>c : E
var rj5 = b | c;
>rj5 : number
>b | c : number
>b : number
>c : E
var rj6 = E.a | a;
>rj6 : number
>E.a | a : number
>E.a : E
>E : typeof E
>a : E
>a : any
var rj7 = E.a | b;
>rj7 : number
>E.a | b : number
>E.a : E
>E : typeof E
>a : E
>b : number
var rj8 = E.a | E.b;
>rj8 : number
>E.a | E.b : number
>E.a : E
>E : typeof E
>a : E
>E.b : E
>E : typeof E
>b : E
var rj9 = E.a | 1;
>rj9 : number
>E.a | 1 : number
>E.a : E
>E : typeof E
>a : E
var rj10 = a | E.b;
>rj10 : number
>a | E.b : number
>a : any
>E.b : E
>E : typeof E
>b : E
var rj11 = b | E.b;
>rj11 : number
>b | E.b : number
>b : number
>E.b : E
>E : typeof E
>b : E
var rj12 = 1 | E.b;
>rj12 : number
>1 | E.b : number
>E.b : E
>E : typeof E
>b : E

450
tests/baselines/reference/arithmeticOperatorWithNullValueAndValidOperands.types Normal file
View File

@@ -0,0 +1,450 @@
=== tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts ===
// If one operand is the null or undefined value, it is treated as having the type of the
// other operand.
enum E {
>E : E
a,
>a : E
b
>b : E
}
var a: any;
>a : any
var b: number;
>b : number
// operator *
var ra1 = null * a;
>ra1 : number
>null * a : number
>a : any
var ra2 = null * b;
>ra2 : number
>null * b : number
>b : number
var ra3 = null * 1;
>ra3 : number
>null * 1 : number
var ra4 = null * E.a;
>ra4 : number
>null * E.a : number
>E.a : E
>E : typeof E
>a : E
var ra5 = a * null;
>ra5 : number
>a * null : number
>a : any
var ra6 = b * null;
>ra6 : number
>b * null : number
>b : number
var ra7 = 0 * null;
>ra7 : number
>0 * null : number
var ra8 = E.b * null;
>ra8 : number
>E.b * null : number
>E.b : E
>E : typeof E
>b : E
// operator /
var rb1 = null / a;
>rb1 : number
>null / a : number
>a : any
var rb2 = null / b;
>rb2 : number
>null / b : number
>b : number
var rb3 = null / 1;
>rb3 : number
>null / 1 : number
var rb4 = null / E.a;
>rb4 : number
>null / E.a : number
>E.a : E
>E : typeof E
>a : E
var rb5 = a / null;
>rb5 : number
>a / null : number
>a : any
var rb6 = b / null;
>rb6 : number
>b / null : number
>b : number
var rb7 = 0 / null;
>rb7 : number
>0 / null : number
var rb8 = E.b / null;
>rb8 : number
>E.b / null : number
>E.b : E
>E : typeof E
>b : E
// operator %
var rc1 = null % a;
>rc1 : number
>null % a : number
>a : any
var rc2 = null % b;
>rc2 : number
>null % b : number
>b : number
var rc3 = null % 1;
>rc3 : number
>null % 1 : number
var rc4 = null % E.a;
>rc4 : number
>null % E.a : number
>E.a : E
>E : typeof E
>a : E
var rc5 = a % null;
>rc5 : number
>a % null : number
>a : any
var rc6 = b % null;
>rc6 : number
>b % null : number
>b : number
var rc7 = 0 % null;
>rc7 : number
>0 % null : number
var rc8 = E.b % null;
>rc8 : number
>E.b % null : number
>E.b : E
>E : typeof E
>b : E
// operator -
var rd1 = null - a;
>rd1 : number
>null - a : number
>a : any
var rd2 = null - b;
>rd2 : number
>null - b : number
>b : number
var rd3 = null - 1;
>rd3 : number
>null - 1 : number
var rd4 = null - E.a;
>rd4 : number
>null - E.a : number
>E.a : E
>E : typeof E
>a : E
var rd5 = a - null;
>rd5 : number
>a - null : number
>a : any
var rd6 = b - null;
>rd6 : number
>b - null : number
>b : number
var rd7 = 0 - null;
>rd7 : number
>0 - null : number
var rd8 = E.b - null;
>rd8 : number
>E.b - null : number
>E.b : E
>E : typeof E
>b : E
// operator <<
var re1 = null << a;
>re1 : number
>null << a : number
>a : any
var re2 = null << b;
>re2 : number
>null << b : number
>b : number
var re3 = null << 1;
>re3 : number
>null << 1 : number
var re4 = null << E.a;
>re4 : number
>null << E.a : number
>E.a : E
>E : typeof E
>a : E
var re5 = a << null;
>re5 : number
>a << null : number
>a : any
var re6 = b << null;
>re6 : number
>b << null : number
>b : number
var re7 = 0 << null;
>re7 : number
>0 << null : number
var re8 = E.b << null;
>re8 : number
>E.b << null : number
>E.b : E
>E : typeof E
>b : E
// operator >>
var rf1 = null >> a;
>rf1 : number
>null >> a : number
>a : any
var rf2 = null >> b;
>rf2 : number
>null >> b : number
>b : number
var rf3 = null >> 1;
>rf3 : number
>null >> 1 : number
var rf4 = null >> E.a;
>rf4 : number
>null >> E.a : number
>E.a : E
>E : typeof E
>a : E
var rf5 = a >> null;
>rf5 : number
>a >> null : number
>a : any
var rf6 = b >> null;
>rf6 : number
>b >> null : number
>b : number
var rf7 = 0 >> null;
>rf7 : number
>0 >> null : number
var rf8 = E.b >> null;
>rf8 : number
>E.b >> null : number
>E.b : E
>E : typeof E
>b : E
// operator >>>
var rg1 = null >>> a;
>rg1 : number
>null >>> a : number
>a : any
var rg2 = null >>> b;
>rg2 : number
>null >>> b : number
>b : number
var rg3 = null >>> 1;
>rg3 : number
>null >>> 1 : number
var rg4 = null >>> E.a;
>rg4 : number
>null >>> E.a : number
>E.a : E
>E : typeof E
>a : E
var rg5 = a >>> null;
>rg5 : number
>a >>> null : number
>a : any
var rg6 = b >>> null;
>rg6 : number
>b >>> null : number
>b : number
var rg7 = 0 >>> null;
>rg7 : number
>0 >>> null : number
var rg8 = E.b >>> null;
>rg8 : number
>E.b >>> null : number
>E.b : E
>E : typeof E
>b : E
// operator &
var rh1 = null & a;
>rh1 : number
>null & a : number
>a : any
var rh2 = null & b;
>rh2 : number
>null & b : number
>b : number
var rh3 = null & 1;
>rh3 : number
>null & 1 : number
var rh4 = null & E.a;
>rh4 : number
>null & E.a : number
>E.a : E
>E : typeof E
>a : E
var rh5 = a & null;
>rh5 : number
>a & null : number
>a : any
var rh6 = b & null;
>rh6 : number
>b & null : number
>b : number
var rh7 = 0 & null;
>rh7 : number
>0 & null : number
var rh8 = E.b & null;
>rh8 : number
>E.b & null : number
>E.b : E
>E : typeof E
>b : E
// operator ^
var ri1 = null ^ a;
>ri1 : number
>null ^ a : number
>a : any
var ri2 = null ^ b;
>ri2 : number
>null ^ b : number
>b : number
var ri3 = null ^ 1;
>ri3 : number
>null ^ 1 : number
var ri4 = null ^ E.a;
>ri4 : number
>null ^ E.a : number
>E.a : E
>E : typeof E
>a : E
var ri5 = a ^ null;
>ri5 : number
>a ^ null : number
>a : any
var ri6 = b ^ null;
>ri6 : number
>b ^ null : number
>b : number
var ri7 = 0 ^ null;
>ri7 : number
>0 ^ null : number
var ri8 = E.b ^ null;
>ri8 : number
>E.b ^ null : number
>E.b : E
>E : typeof E
>b : E
// operator |
var rj1 = null | a;
>rj1 : number
>null | a : number
>a : any
var rj2 = null | b;
>rj2 : number
>null | b : number
>b : number
var rj3 = null | 1;
>rj3 : number
>null | 1 : number
var rj4 = null | E.a;
>rj4 : number
>null | E.a : number
>E.a : E
>E : typeof E
>a : E
var rj5 = a | null;
>rj5 : number
>a | null : number
>a : any
var rj6 = b | null;
>rj6 : number
>b | null : number
>b : number
var rj7 = 0 | null;
>rj7 : number
>0 | null : number
var rj8 = E.b | null;
>rj8 : number
>E.b | null : number
>E.b : E
>E : typeof E
>b : E

530
tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndValidOperands.types Normal file
View File

@@ -0,0 +1,530 @@
=== tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts ===
// If one operand is the undefined or undefined value, it is treated as having the type of the
// other operand.
enum E {
>E : E
a,
>a : E
b
>b : E
}
var a: any;
>a : any
var b: number;
>b : number
// operator *
var ra1 = undefined * a;
>ra1 : number
>undefined * a : number
>undefined : undefined
>a : any
var ra2 = undefined * b;
>ra2 : number
>undefined * b : number
>undefined : undefined
>b : number
var ra3 = undefined * 1;
>ra3 : number
>undefined * 1 : number
>undefined : undefined
var ra4 = undefined * E.a;
>ra4 : number
>undefined * E.a : number
>undefined : undefined
>E.a : E
>E : typeof E
>a : E
var ra5 = a * undefined;
>ra5 : number
>a * undefined : number
>a : any
>undefined : undefined
var ra6 = b * undefined;
>ra6 : number
>b * undefined : number
>b : number
>undefined : undefined
var ra7 = 0 * undefined;
>ra7 : number
>0 * undefined : number
>undefined : undefined
var ra8 = E.b * undefined;
>ra8 : number
>E.b * undefined : number
>E.b : E
>E : typeof E
>b : E
>undefined : undefined
// operator /
var rb1 = undefined / a;
>rb1 : number
>undefined / a : number
>undefined : undefined
>a : any
var rb2 = undefined / b;
>rb2 : number
>undefined / b : number
>undefined : undefined
>b : number
var rb3 = undefined / 1;
>rb3 : number
>undefined / 1 : number
>undefined : undefined
var rb4 = undefined / E.a;
>rb4 : number
>undefined / E.a : number
>undefined : undefined
>E.a : E
>E : typeof E
>a : E
var rb5 = a / undefined;
>rb5 : number
>a / undefined : number
>a : any
>undefined : undefined
var rb6 = b / undefined;
>rb6 : number
>b / undefined : number
>b : number
>undefined : undefined
var rb7 = 0 / undefined;
>rb7 : number
>0 / undefined : number
>undefined : undefined
var rb8 = E.b / undefined;
>rb8 : number
>E.b / undefined : number
>E.b : E
>E : typeof E
>b : E
>undefined : undefined
// operator %
var rc1 = undefined % a;
>rc1 : number
>undefined % a : number
>undefined : undefined
>a : any
var rc2 = undefined % b;
>rc2 : number
>undefined % b : number
>undefined : undefined
>b : number
var rc3 = undefined % 1;
>rc3 : number
>undefined % 1 : number
>undefined : undefined
var rc4 = undefined % E.a;
>rc4 : number
>undefined % E.a : number
>undefined : undefined
>E.a : E
>E : typeof E
>a : E
var rc5 = a % undefined;
>rc5 : number
>a % undefined : number
>a : any
>undefined : undefined
var rc6 = b % undefined;
>rc6 : number
>b % undefined : number
>b : number
>undefined : undefined
var rc7 = 0 % undefined;
>rc7 : number
>0 % undefined : number
>undefined : undefined
var rc8 = E.b % undefined;
>rc8 : number
>E.b % undefined : number
>E.b : E
>E : typeof E
>b : E
>undefined : undefined
// operator -
var rd1 = undefined - a;
>rd1 : number
>undefined - a : number
>undefined : undefined
>a : any
var rd2 = undefined - b;
>rd2 : number
>undefined - b : number
>undefined : undefined
>b : number
var rd3 = undefined - 1;
>rd3 : number
>undefined - 1 : number
>undefined : undefined
var rd4 = undefined - E.a;
>rd4 : number
>undefined - E.a : number
>undefined : undefined
>E.a : E
>E : typeof E
>a : E
var rd5 = a - undefined;
>rd5 : number
>a - undefined : number
>a : any
>undefined : undefined
var rd6 = b - undefined;
>rd6 : number
>b - undefined : number
>b : number
>undefined : undefined
var rd7 = 0 - undefined;
>rd7 : number
>0 - undefined : number
>undefined : undefined
var rd8 = E.b - undefined;
>rd8 : number
>E.b - undefined : number
>E.b : E
>E : typeof E
>b : E
>undefined : undefined
// operator <<
var re1 = undefined << a;
>re1 : number
>undefined << a : number
>undefined : undefined
>a : any
var re2 = undefined << b;
>re2 : number
>undefined << b : number
>undefined : undefined
>b : number
var re3 = undefined << 1;
>re3 : number
>undefined << 1 : number
>undefined : undefined
var re4 = undefined << E.a;
>re4 : number
>undefined << E.a : number
>undefined : undefined
>E.a : E
>E : typeof E
>a : E
var re5 = a << undefined;
>re5 : number
>a << undefined : number
>a : any
>undefined : undefined
var re6 = b << undefined;
>re6 : number
>b << undefined : number
>b : number
>undefined : undefined
var re7 = 0 << undefined;
>re7 : number
>0 << undefined : number
>undefined : undefined
var re8 = E.b << undefined;
>re8 : number
>E.b << undefined : number
>E.b : E
>E : typeof E
>b : E
>undefined : undefined
// operator >>
var rf1 = undefined >> a;
>rf1 : number
>undefined >> a : number
>undefined : undefined
>a : any
var rf2 = undefined >> b;
>rf2 : number
>undefined >> b : number
>undefined : undefined
>b : number
var rf3 = undefined >> 1;
>rf3 : number
>undefined >> 1 : number
>undefined : undefined
var rf4 = undefined >> E.a;
>rf4 : number
>undefined >> E.a : number
>undefined : undefined
>E.a : E
>E : typeof E
>a : E
var rf5 = a >> undefined;
>rf5 : number
>a >> undefined : number
>a : any
>undefined : undefined
var rf6 = b >> undefined;
>rf6 : number
>b >> undefined : number
>b : number
>undefined : undefined
var rf7 = 0 >> undefined;
>rf7 : number
>0 >> undefined : number
>undefined : undefined
var rf8 = E.b >> undefined;
>rf8 : number
>E.b >> undefined : number
>E.b : E
>E : typeof E
>b : E
>undefined : undefined
// operator >>>
var rg1 = undefined >>> a;
>rg1 : number
>undefined >>> a : number
>undefined : undefined
>a : any
var rg2 = undefined >>> b;
>rg2 : number
>undefined >>> b : number
>undefined : undefined
>b : number
var rg3 = undefined >>> 1;
>rg3 : number
>undefined >>> 1 : number
>undefined : undefined
var rg4 = undefined >>> E.a;
>rg4 : number
>undefined >>> E.a : number
>undefined : undefined
>E.a : E
>E : typeof E
>a : E
var rg5 = a >>> undefined;
>rg5 : number
>a >>> undefined : number
>a : any
>undefined : undefined
var rg6 = b >>> undefined;
>rg6 : number
>b >>> undefined : number
>b : number
>undefined : undefined
var rg7 = 0 >>> undefined;
>rg7 : number
>0 >>> undefined : number
>undefined : undefined
var rg8 = E.b >>> undefined;
>rg8 : number
>E.b >>> undefined : number
>E.b : E
>E : typeof E
>b : E
>undefined : undefined
// operator &
var rh1 = undefined & a;
>rh1 : number
>undefined & a : number
>undefined : undefined
>a : any
var rh2 = undefined & b;
>rh2 : number
>undefined & b : number
>undefined : undefined
>b : number
var rh3 = undefined & 1;
>rh3 : number
>undefined & 1 : number
>undefined : undefined
var rh4 = undefined & E.a;
>rh4 : number
>undefined & E.a : number
>undefined : undefined
>E.a : E
>E : typeof E
>a : E
var rh5 = a & undefined;
>rh5 : number
>a & undefined : number
>a : any
>undefined : undefined
var rh6 = b & undefined;
>rh6 : number
>b & undefined : number
>b : number
>undefined : undefined
var rh7 = 0 & undefined;
>rh7 : number
>0 & undefined : number
>undefined : undefined
var rh8 = E.b & undefined;
>rh8 : number
>E.b & undefined : number
>E.b : E
>E : typeof E
>b : E
>undefined : undefined
// operator ^
var ri1 = undefined ^ a;
>ri1 : number
>undefined ^ a : number
>undefined : undefined
>a : any
var ri2 = undefined ^ b;
>ri2 : number
>undefined ^ b : number
>undefined : undefined
>b : number
var ri3 = undefined ^ 1;
>ri3 : number
>undefined ^ 1 : number
>undefined : undefined
var ri4 = undefined ^ E.a;
>ri4 : number
>undefined ^ E.a : number
>undefined : undefined
>E.a : E
>E : typeof E
>a : E
var ri5 = a ^ undefined;
>ri5 : number
>a ^ undefined : number
>a : any
>undefined : undefined
var ri6 = b ^ undefined;
>ri6 : number
>b ^ undefined : number
>b : number
>undefined : undefined
var ri7 = 0 ^ undefined;
>ri7 : number
>0 ^ undefined : number
>undefined : undefined
var ri8 = E.b ^ undefined;
>ri8 : number
>E.b ^ undefined : number
>E.b : E
>E : typeof E
>b : E
>undefined : undefined
// operator |
var rj1 = undefined | a;
>rj1 : number
>undefined | a : number
>undefined : undefined
>a : any
var rj2 = undefined | b;
>rj2 : number
>undefined | b : number
>undefined : undefined
>b : number
var rj3 = undefined | 1;
>rj3 : number
>undefined | 1 : number
>undefined : undefined
var rj4 = undefined | E.a;
>rj4 : number
>undefined | E.a : number
>undefined : undefined
>E.a : E
>E : typeof E
>a : E
var rj5 = a | undefined;
>rj5 : number
>a | undefined : number
>a : any
>undefined : undefined
var rj6 = b | undefined;
>rj6 : number
>b | undefined : number
>b : number
>undefined : undefined
var rj7 = 0 | undefined;
>rj7 : number
>0 | undefined : number
>undefined : undefined
var rj8 = E.b | undefined;
>rj8 : number
>E.b | undefined : number
>E.b : E
>E : typeof E
>b : E
>undefined : undefined

52
tests/baselines/reference/arrayAssignmentTest6.types Normal file
View File

@@ -0,0 +1,52 @@
=== tests/cases/compiler/arrayAssignmentTest6.ts ===
module Test {
>Test : typeof Test
interface IState {
>IState : IState
}
interface IToken {
>IToken : IToken
startIndex: number;
>startIndex : number
}
interface ILineTokens {
>ILineTokens : ILineTokens
tokens: IToken[];
>tokens : IToken[]
>IToken : IToken
endState: IState;
>endState : IState
>IState : IState
}
interface IMode {
>IMode : IMode
tokenize(line:string, state:IState, includeStates:boolean):ILineTokens;
>tokenize : (line: string, state: IState, includeStates: boolean) => ILineTokens
>line : string
>state : IState
>IState : IState
>includeStates : boolean
>ILineTokens : ILineTokens
}
export class Bug implements IMode {
>Bug : Bug
>IMode : IMode
public tokenize(line:string, tokens:IToken[], includeStates:boolean):ILineTokens {
>tokenize : (line: string, tokens: IToken[], includeStates: boolean) => ILineTokens
>line : string
>tokens : IToken[]
>IToken : IToken
>includeStates : boolean
>ILineTokens : ILineTokens
return null;
}
}
}

25
tests/baselines/reference/arrayAugment.types Normal file
View File

@@ -0,0 +1,25 @@
=== tests/cases/compiler/arrayAugment.ts ===
interface Array<T> {
>Array : T[]
>T : T
split: (parts: number) => T[][];
>split : (parts: number) => T[][]
>parts : number
>T : T
}
var x = [''];
>x : string[]
>[''] : string[]
var y = x.split(4);
>y : string[][]
>x.split(4) : string[][]
>x.split : (parts: number) => string[][]
>x : string[]
>split : (parts: number) => string[][]
var y: string[][]; // Expect no error here
>y : string[][]

327
tests/baselines/reference/arrayBestCommonTypes.types Normal file
View File

@@ -0,0 +1,327 @@
=== tests/cases/compiler/arrayBestCommonTypes.ts ===
interface iface { }
>iface : iface
class base implements iface { }
>base : base
>iface : iface
class base2 implements iface { }
>base2 : base2
>iface : iface
class derived extends base { }
>derived : derived
>base : base
class f {
>f : f
public voidIfAny(x: boolean, y?: boolean): number;
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>x : boolean
>y : boolean
public voidIfAny(x: string, y?: boolean): number;
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>x : string
>y : boolean
public voidIfAny(x: number, y?: boolean): number;
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>x : number
>y : boolean
public voidIfAny(x: any, y =false): any { return null; }
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>x : any
>y : boolean
public x() {
>x : () => void
<number>(this.voidIfAny([4, 2][0]));
><number>(this.voidIfAny([4, 2][0])) : number
>(this.voidIfAny([4, 2][0])) : number
>this.voidIfAny([4, 2][0]) : number
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>this : f
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>[4, 2][0] : number
>[4, 2] : number[]
<number>(this.voidIfAny([4, 2, undefined][0]));
><number>(this.voidIfAny([4, 2, undefined][0])) : number
>(this.voidIfAny([4, 2, undefined][0])) : number
>this.voidIfAny([4, 2, undefined][0]) : number
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>this : f
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>[4, 2, undefined][0] : number
>[4, 2, undefined] : number[]
>undefined : undefined
<number>(this.voidIfAny([undefined, 2, 4][0]));
><number>(this.voidIfAny([undefined, 2, 4][0])) : number
>(this.voidIfAny([undefined, 2, 4][0])) : number
>this.voidIfAny([undefined, 2, 4][0]) : number
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>this : f
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>[undefined, 2, 4][0] : number
>[undefined, 2, 4] : number[]
>undefined : undefined
<number>(this.voidIfAny([null, 2, 4][0]));
><number>(this.voidIfAny([null, 2, 4][0])) : number
>(this.voidIfAny([null, 2, 4][0])) : number
>this.voidIfAny([null, 2, 4][0]) : number
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>this : f
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>[null, 2, 4][0] : number
>[null, 2, 4] : number[]
<number>(this.voidIfAny([2, 4, null][0]));
><number>(this.voidIfAny([2, 4, null][0])) : number
>(this.voidIfAny([2, 4, null][0])) : number
>this.voidIfAny([2, 4, null][0]) : number
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>this : f
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>[2, 4, null][0] : number
>[2, 4, null] : number[]
<number>(this.voidIfAny([undefined, 4, null][0]));
><number>(this.voidIfAny([undefined, 4, null][0])) : number
>(this.voidIfAny([undefined, 4, null][0])) : number
>this.voidIfAny([undefined, 4, null][0]) : number
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>this : f
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>[undefined, 4, null][0] : number
>[undefined, 4, null] : number[]
>undefined : undefined
<number>(this.voidIfAny(['', "q"][0]));
><number>(this.voidIfAny(['', "q"][0])) : number
>(this.voidIfAny(['', "q"][0])) : number
>this.voidIfAny(['', "q"][0]) : number
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>this : f
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>['', "q"][0] : string
>['', "q"] : string[]
<number>(this.voidIfAny(['', "q", undefined][0]));
><number>(this.voidIfAny(['', "q", undefined][0])) : number
>(this.voidIfAny(['', "q", undefined][0])) : number
>this.voidIfAny(['', "q", undefined][0]) : number
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>this : f
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>['', "q", undefined][0] : string
>['', "q", undefined] : string[]
>undefined : undefined
<number>(this.voidIfAny([undefined, "q", ''][0]));
><number>(this.voidIfAny([undefined, "q", ''][0])) : number
>(this.voidIfAny([undefined, "q", ''][0])) : number
>this.voidIfAny([undefined, "q", ''][0]) : number
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>this : f
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>[undefined, "q", ''][0] : string
>[undefined, "q", ''] : string[]
>undefined : undefined
<number>(this.voidIfAny([null, "q", ''][0]));
><number>(this.voidIfAny([null, "q", ''][0])) : number
>(this.voidIfAny([null, "q", ''][0])) : number
>this.voidIfAny([null, "q", ''][0]) : number
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>this : f
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>[null, "q", ''][0] : string
>[null, "q", ''] : string[]
<number>(this.voidIfAny(["q", '', null][0]));
><number>(this.voidIfAny(["q", '', null][0])) : number
>(this.voidIfAny(["q", '', null][0])) : number
>this.voidIfAny(["q", '', null][0]) : number
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>this : f
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>["q", '', null][0] : string
>["q", '', null] : string[]
<number>(this.voidIfAny([undefined, '', null][0]));
><number>(this.voidIfAny([undefined, '', null][0])) : number
>(this.voidIfAny([undefined, '', null][0])) : number
>this.voidIfAny([undefined, '', null][0]) : number
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>this : f
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>[undefined, '', null][0] : string
>[undefined, '', null] : string[]
>undefined : undefined
<number>(this.voidIfAny([[3,4],[null]][0][0]));
><number>(this.voidIfAny([[3,4],[null]][0][0])) : number
>(this.voidIfAny([[3,4],[null]][0][0])) : number
>this.voidIfAny([[3,4],[null]][0][0]) : number
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>this : f
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
>[[3,4],[null]][0][0] : number
>[[3,4],[null]][0] : number[]
>[[3,4],[null]] : number[][]
>[3,4] : number[]
>[null] : null[]
var t1: { x: number; y: base; }[] = [ { x: 7, y: new derived() }, { x: 5, y: new base() } ];
>t1 : { x: number; y: base; }[]
>x : number
>y : base
>base : base
>[ { x: 7, y: new derived() }, { x: 5, y: new base() } ] : { x: number; y: base; }[]
>{ x: 7, y: new derived() } : { x: number; y: derived; }
>x : number
>y : derived
>new derived() : derived
>derived : typeof derived
>{ x: 5, y: new base() } : { x: number; y: base; }
>x : number
>y : base
>new base() : base
>base : typeof base
var t2: { x: boolean; y: base; }[] = [ { x: true, y: new derived() }, { x: false, y: new base() } ];
>t2 : { x: boolean; y: base; }[]
>x : boolean
>y : base
>base : base
>[ { x: true, y: new derived() }, { x: false, y: new base() } ] : { x: boolean; y: base; }[]
>{ x: true, y: new derived() } : { x: boolean; y: derived; }
>x : boolean
>y : derived
>new derived() : derived
>derived : typeof derived
>{ x: false, y: new base() } : { x: boolean; y: base; }
>x : boolean
>y : base
>new base() : base
>base : typeof base
var t3: { x: string; y: base; }[] = [ { x: undefined, y: new base() }, { x: '', y: new derived() } ];
>t3 : { x: string; y: base; }[]
>x : string
>y : base
>base : base
>[ { x: undefined, y: new base() }, { x: '', y: new derived() } ] : { x: string; y: base; }[]
>{ x: undefined, y: new base() } : { x: undefined; y: base; }
>x : any
>undefined : undefined
>y : base
>new base() : base
>base : typeof base
>{ x: '', y: new derived() } : { x: string; y: derived; }
>x : string
>y : derived
>new derived() : derived
>derived : typeof derived
var anyObj: any = null;
>anyObj : any
// Order matters here so test all the variants
var a1 = [ {x: 0, y: 'a'}, {x: 'a', y: 'a'}, {x: anyObj, y: 'a'} ];
>a1 : { x: any; y: string; }[]
>[ {x: 0, y: 'a'}, {x: 'a', y: 'a'}, {x: anyObj, y: 'a'} ] : { x: any; y: string; }[]
>{x: 0, y: 'a'} : { x: number; y: string; }
>x : number
>y : string
>{x: 'a', y: 'a'} : { x: string; y: string; }
>x : string
>y : string
>{x: anyObj, y: 'a'} : { x: any; y: string; }
>x : any
>anyObj : anyObj
>y : string
var a2 = [ {x: anyObj, y: 'a'}, {x: 0, y: 'a'}, {x: 'a', y: 'a'} ];
>a2 : { x: any; y: string; }[]
>[ {x: anyObj, y: 'a'}, {x: 0, y: 'a'}, {x: 'a', y: 'a'} ] : { x: any; y: string; }[]
>{x: anyObj, y: 'a'} : { x: any; y: string; }
>x : any
>anyObj : anyObj
>y : string
>{x: 0, y: 'a'} : { x: number; y: string; }
>x : number
>y : string
>{x: 'a', y: 'a'} : { x: string; y: string; }
>x : string
>y : string
var a3 = [ {x: 0, y: 'a'}, {x: anyObj, y: 'a'}, {x: 'a', y: 'a'} ];
>a3 : { x: any; y: string; }[]
>[ {x: 0, y: 'a'}, {x: anyObj, y: 'a'}, {x: 'a', y: 'a'} ] : { x: any; y: string; }[]
>{x: 0, y: 'a'} : { x: number; y: string; }
>x : number
>y : string
>{x: anyObj, y: 'a'} : { x: any; y: string; }
>x : any
>anyObj : anyObj
>y : string
>{x: 'a', y: 'a'} : { x: string; y: string; }
>x : string
>y : string
var ifaceObj: iface = null;
>ifaceObj : iface
>iface : iface
var baseObj = new base();
>baseObj : base
>new base() : base
>base : typeof base
var base2Obj = new base2();
>base2Obj : base2
>new base2() : base2
>base2 : typeof base2
var b1 = [ baseObj, base2Obj, ifaceObj ];
>b1 : base[]
>[ baseObj, base2Obj, ifaceObj ] : base[]
>baseObj : base
>base2Obj : base2
>ifaceObj : iface
var b2 = [ base2Obj, baseObj, ifaceObj ];
>b2 : base2[]
>[ base2Obj, baseObj, ifaceObj ] : base2[]
>base2Obj : base2
>baseObj : base
>ifaceObj : iface
var b3 = [ baseObj, ifaceObj, base2Obj ];
>b3 : base[]
>[ baseObj, ifaceObj, base2Obj ] : base[]
>baseObj : base
>ifaceObj : iface
>base2Obj : base2
var b4 = [ ifaceObj, baseObj, base2Obj ];
>b4 : iface[]
>[ ifaceObj, baseObj, base2Obj ] : iface[]
>ifaceObj : iface
>baseObj : base
>base2Obj : base2
}
}

28
tests/baselines/reference/arrayConcat2.types Normal file
View File

@@ -0,0 +1,28 @@
=== tests/cases/compiler/arrayConcat2.ts ===
var a: string[] = [];
>a : string[]
>[] : string[]
a.concat("hello", 'world');
>a.concat("hello", 'world') : string[]
>a.concat : { <U extends string[]>(...items: U[]): string[]; (...items: string[]): string[]; }
>a : string[]
>concat : { <U extends string[]>(...items: U[]): string[]; (...items: string[]): string[]; }
a.concat('Hello');
>a.concat('Hello') : string[]
>a.concat : { <U extends string[]>(...items: U[]): string[]; (...items: string[]): string[]; }
>a : string[]
>concat : { <U extends string[]>(...items: U[]): string[]; (...items: string[]): string[]; }
var b = new Array<string>();
>b : string[]
>new Array<string>() : string[]
>Array : { (arrayLength?: number): any[]; <T>(arrayLength: number): T[]; <T>(...items: T[]): T[]; new (arrayLength?: number): any[]; new <T>(arrayLength: number): T[]; new <T>(...items: T[]): T[]; isArray(arg: any): boolean; prototype: any[]; }
b.concat('hello');
>b.concat('hello') : string[]
>b.concat : { <U extends string[]>(...items: U[]): string[]; (...items: string[]): string[]; }
>b : string[]
>concat : { <U extends string[]>(...items: U[]): string[]; (...items: string[]): string[]; }

26
tests/baselines/reference/arrayConcatMap.types Normal file
View File

@@ -0,0 +1,26 @@
=== tests/cases/compiler/arrayConcatMap.ts ===
var x = [].concat([{ a: 1 }], [{ a: 2 }])
>x : any[]
>[].concat([{ a: 1 }], [{ a: 2 }])
.map(b => b.a) : any[]
>[].concat([{ a: 1 }], [{ a: 2 }])
.map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
>[].concat([{ a: 1 }], [{ a: 2 }]) : any[]
>[].concat : { <U extends any[]>(...items: U[]): any[]; (...items: any[]): any[]; }
>[] : undefined[]
>concat : { <U extends any[]>(...items: U[]): any[]; (...items: any[]): any[]; }
>[{ a: 1 }] : { a: number; }[]
>{ a: 1 } : { a: number; }
>a : number
>[{ a: 2 }] : { a: number; }[]
>{ a: 2 } : { a: number; }
>a : number
.map(b => b.a);
>map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
>b => b.a : (b: any) => any
>b : any
>b.a : any
>b : any
>a : any

43
tests/baselines/reference/arrayConstructors1.types Normal file
View File

@@ -0,0 +1,43 @@
=== tests/cases/compiler/arrayConstructors1.ts ===
var x: string[];
>x : string[]
x = new Array(1);
>x = new Array(1) : any[]
>x : string[]
>new Array(1) : any[]
>Array : { (arrayLength?: number): any[]; <T>(arrayLength: number): T[]; <T>(...items: T[]): T[]; new (arrayLength?: number): any[]; new <T>(arrayLength: number): T[]; new <T>(...items: T[]): T[]; isArray(arg: any): boolean; prototype: any[]; }
x = new Array('hi', 'bye');
>x = new Array('hi', 'bye') : string[]
>x : string[]
>new Array('hi', 'bye') : string[]
>Array : { (arrayLength?: number): any[]; <T>(arrayLength: number): T[]; <T>(...items: T[]): T[]; new (arrayLength?: number): any[]; new <T>(arrayLength: number): T[]; new <T>(...items: T[]): T[]; isArray(arg: any): boolean; prototype: any[]; }
x = new Array<string>('hi', 'bye');
>x = new Array<string>('hi', 'bye') : string[]
>x : string[]
>new Array<string>('hi', 'bye') : string[]
>Array : { (arrayLength?: number): any[]; <T>(arrayLength: number): T[]; <T>(...items: T[]): T[]; new (arrayLength?: number): any[]; new <T>(arrayLength: number): T[]; new <T>(...items: T[]): T[]; isArray(arg: any): boolean; prototype: any[]; }
var y: number[];
>y : number[]
y = new Array(1);
>y = new Array(1) : any[]
>y : number[]
>new Array(1) : any[]
>Array : { (arrayLength?: number): any[]; <T>(arrayLength: number): T[]; <T>(...items: T[]): T[]; new (arrayLength?: number): any[]; new <T>(arrayLength: number): T[]; new <T>(...items: T[]): T[]; isArray(arg: any): boolean; prototype: any[]; }
y = new Array(1,2);
>y = new Array(1,2) : number[]
>y : number[]
>new Array(1,2) : number[]
>Array : { (arrayLength?: number): any[]; <T>(arrayLength: number): T[]; <T>(...items: T[]): T[]; new (arrayLength?: number): any[]; new <T>(arrayLength: number): T[]; new <T>(...items: T[]): T[]; isArray(arg: any): boolean; prototype: any[]; }
y = new Array<number>(1, 2);
>y = new Array<number>(1, 2) : number[]
>y : number[]
>new Array<number>(1, 2) : number[]
>Array : { (arrayLength?: number): any[]; <T>(arrayLength: number): T[]; <T>(...items: T[]): T[]; new (arrayLength?: number): any[]; new <T>(arrayLength: number): T[]; new <T>(...items: T[]): T[]; isArray(arg: any): boolean; prototype: any[]; }

47
tests/baselines/reference/arrayLiteral.types Normal file
View File

@@ -0,0 +1,47 @@
=== tests/cases/conformance/types/specifyingTypes/typeLiterals/arrayLiteral.ts ===
// valid uses of array literals
var x = [];
>x : any[]
>[] : undefined[]
var x = new Array(1);
>x : any[]
>new Array(1) : any[]
>Array : { (arrayLength?: number): any[]; <T>(arrayLength: number): T[]; <T>(...items: T[]): T[]; new (arrayLength?: number): any[]; new <T>(arrayLength: number): T[]; new <T>(...items: T[]): T[]; isArray(arg: any): boolean; prototype: any[]; }
var y = [1];
>y : number[]
>[1] : number[]
var y = [1, 2];
>y : number[]
>[1, 2] : number[]
var y = new Array<number>();
>y : number[]
>new Array<number>() : number[]
>Array : { (arrayLength?: number): any[]; <T>(arrayLength: number): T[]; <T>(...items: T[]): T[]; new (arrayLength?: number): any[]; new <T>(arrayLength: number): T[]; new <T>(...items: T[]): T[]; isArray(arg: any): boolean; prototype: any[]; }
var x2: number[] = [];
>x2 : number[]
>[] : number[]
var x2: number[] = new Array(1);
>x2 : number[]
>new Array(1) : any[]
>Array : { (arrayLength?: number): any[]; <T>(arrayLength: number): T[]; <T>(...items: T[]): T[]; new (arrayLength?: number): any[]; new <T>(arrayLength: number): T[]; new <T>(...items: T[]): T[]; isArray(arg: any): boolean; prototype: any[]; }
var y2: number[] = [1];
>y2 : number[]
>[1] : number[]
var y2: number[] = [1, 2];
>y2 : number[]
>[1, 2] : number[]
var y2: number[] = new Array<number>();
>y2 : number[]
>new Array<number>() : number[]
>Array : { (arrayLength?: number): any[]; <T>(arrayLength: number): T[]; <T>(...items: T[]): T[]; new (arrayLength?: number): any[]; new <T>(arrayLength: number): T[]; new <T>(...items: T[]): T[]; isArray(arg: any): boolean; prototype: any[]; }

5
tests/baselines/reference/arrayLiteral1.types Normal file
View File

@@ -0,0 +1,5 @@
=== tests/cases/compiler/arrayLiteral1.ts ===
var v30 = [1, 2];
>v30 : number[]
>[1, 2] : number[]

6
tests/baselines/reference/arrayLiteral2.types Normal file
View File

@@ -0,0 +1,6 @@
=== tests/cases/compiler/arrayLiteral2.ts ===
var v30 = [1, 2], v31;
>v30 : number[]
>[1, 2] : number[]
>v31 : any

11
tests/baselines/reference/arrayLiteralInNonVarArgParameter.types Normal file
View File

@@ -0,0 +1,11 @@
=== tests/cases/compiler/arrayLiteralInNonVarArgParameter.ts ===
function panic(val: string[], ...opt: string[]) { }
>panic : (val: string[], ...opt: string[]) => void
>val : string[]
>opt : string[]
panic([], 'one', 'two');
>panic([], 'one', 'two') : void
>panic : (val: string[], ...opt: string[]) => void
>[] : string[]

156
tests/baselines/reference/arrayLiteralTypeInference.types Normal file
View File

@@ -0,0 +1,156 @@
=== tests/cases/compiler/arrayLiteralTypeInference.ts ===
class Action {
>Action : Action
id: number;
>id : number
}
class ActionA extends Action {
>ActionA : ActionA
>Action : Action
value: string;
>value : string
}
class ActionB extends Action {
>ActionB : ActionB
>Action : Action
trueNess: boolean;
>trueNess : boolean
}
var x1: Action[] = [
>x1 : Action[]
>Action : Action
>[
{ id: 2, trueness: false },
{ id: 3, name: "three" }
] : Action[]
{ id: 2, trueness: false },
>{ id: 2, trueness: false } : { id: number; trueness: boolean; }
>id : number
>trueness : boolean
{ id: 3, name: "three" }
>{ id: 3, name: "three" } : { id: number; name: string; }
>id : number
>name : string
]
var x2: Action[] = [
>x2 : Action[]
>Action : Action
>[
new ActionA(),
new ActionB()
] : Action[]
new ActionA(),
>new ActionA() : ActionA
>ActionA : typeof ActionA
new ActionB()
>new ActionB() : ActionB
>ActionB : typeof ActionB
]
var x3: Action[] = [
>x3 : Action[]
>Action : Action
>[
new Action(),
new ActionA(),
new ActionB()
] : Action[]
new Action(),
>new Action() : Action
>Action : typeof Action
new ActionA(),
>new ActionA() : ActionA
>ActionA : typeof ActionA
new ActionB()
>new ActionB() : ActionB
>ActionB : typeof ActionB
]
var z1: { id: number }[] =
>z1 : { id: number; }[]
>id : number
[
>[
{ id: 2, trueness: false },
{ id: 3, name: "three" }
] : { id: number; }[]
{ id: 2, trueness: false },
>{ id: 2, trueness: false } : { id: number; trueness: boolean; }
>id : number
>trueness : boolean
{ id: 3, name: "three" }
>{ id: 3, name: "three" } : { id: number; name: string; }
>id : number
>name : string
]
var z2: { id: number }[] =
>z2 : { id: number; }[]
>id : number
[
>[
new ActionA(),
new ActionB()
] : { id: number; }[]
new ActionA(),
>new ActionA() : ActionA
>ActionA : typeof ActionA
new ActionB()
>new ActionB() : ActionB
>ActionB : typeof ActionB
]
var z3: { id: number }[] =
>z3 : { id: number; }[]
>id : number
[
>[
new Action(),
new ActionA(),
new ActionB()
] : { id: number; }[]
new Action(),
>new Action() : Action
>Action : typeof Action
new ActionA(),
>new ActionA() : ActionA
>ActionA : typeof ActionA
new ActionB()
>new ActionB() : ActionB
>ActionB : typeof ActionB
]

Some files were not shown because too many files have changed in this diff Show More