openharmony/third_party_typescript
1
0
Fork 0
mirror of https://gitee.com/openharmony/third_party_typescript synced 2024-11-30 18:42:25 +00:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

Merge pull request #554 from Microsoft/typeBaselines

Browse Source 
Changes to typeWriter and type baselines
This commit is contained in:
Jason Freeman 2014-08-28 20:40:33 -04:00
commit 0a6f027d31
526 changed files with 13704 additions and 13580 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/compiler/checker.ts
View File

@ -906,7 +906,7 @@ module ts {
// Get qualified name
if (enclosingDeclaration &&
// Properties/methods/Signatures/Constructors/TypeParameters do not need qualification
!(symbol.flags & SymbolFlags.PropertyOrAccessor & SymbolFlags.Signature & SymbolFlags.Constructor & SymbolFlags.Method & SymbolFlags.TypeParameter)) {
!(symbol.flags & (SymbolFlags.PropertyOrAccessor | SymbolFlags.Signature | SymbolFlags.Constructor | SymbolFlags.Method | SymbolFlags.TypeParameter))) {
var symbolName: string;
while (symbol) {
var isFirstName = !symbolName;
@ -2236,13 +2236,12 @@ module ts {
return emptyObjectType;
}
var type = getDeclaredTypeOfSymbol(symbol);
var name = symbol.name;
if (!(type.flags & TypeFlags.ObjectType)) {
error(getTypeDeclaration(symbol), Diagnostics.Global_type_0_must_be_a_class_or_interface_type, name);
error(getTypeDeclaration(symbol), Diagnostics.Global_type_0_must_be_a_class_or_interface_type, symbol.name);
return emptyObjectType;
}
if (((<InterfaceType>type).typeParameters ? (<InterfaceType>type).typeParameters.length : 0) !== arity) {
error(getTypeDeclaration(symbol), Diagnostics.Global_type_0_must_have_1_type_parameter_s, name, arity);
error(getTypeDeclaration(symbol), Diagnostics.Global_type_0_must_have_1_type_parameter_s, symbol.name, arity);
return emptyObjectType;
}
return <ObjectType>type;
@ -3545,7 +3544,8 @@ module ts {
return false;
}
function checkSuperExpression(node: Node, isCallExpression: boolean): Type {
function checkSuperExpression(node: Node): Type {
var isCallExpression = node.parent.kind === SyntaxKind.CallExpression && (<CallExpression>node.parent).func === node;
var enclosingClass = <ClassDeclaration>getAncestor(node, SyntaxKind.ClassDeclaration);
var baseClass: Type;
if (enclosingClass && enclosingClass.baseType) {
@ -4179,7 +4179,7 @@ module ts {
function resolveCallExpression(node: CallExpression): Signature {
if (node.func.kind === SyntaxKind.SuperKeyword) {
var superType = checkSuperExpression(node.func, true);
var superType = checkSuperExpression(node.func);
if (superType !== unknownType) {
return resolveCall(node, getSignaturesOfType(superType, SignatureKind.Construct));
}
@ -4827,7 +4827,7 @@ module ts {
case SyntaxKind.ThisKeyword:
return checkThisExpression(node);
case SyntaxKind.SuperKeyword:
return checkSuperExpression(node, false);
return checkSuperExpression(node);
case SyntaxKind.NullKeyword:
return nullType;
case SyntaxKind.TrueKeyword:
@ -6681,6 +6681,7 @@ module ts {
case SyntaxKind.Parameter:
case SyntaxKind.Property:
case SyntaxKind.EnumMember:
case SyntaxKind.PropertyAssignment:
return (<VariableDeclaration>parent).initializer === node;
case SyntaxKind.ExpressionStatement:
case SyntaxKind.IfStatement:
@ -6810,6 +6811,11 @@ module ts {
/*all meanings*/ SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Import);
}
if (isInRightSideOfImportOrExportAssignment(entityName)) {
// Since we already checked for ExportAssignment, this really could only be an Import
return getSymbolOfPartOfRightHandSideOfImport(entityName);
}
if (isRightSideOfQualifiedNameOrPropertyAccess(entityName)) {
entityName = entityName.parent;
}
@ -6920,11 +6926,7 @@ module ts {
}
if (isInRightSideOfImportOrExportAssignment(node)) {
var symbol: Symbol;
symbol = node.parent.kind === SyntaxKind.ExportAssignment
? getSymbolInfo(node)
: getSymbolOfPartOfRightHandSideOfImport(node);
var symbol = getSymbolInfo(node);
var declaredType = getDeclaredTypeOfSymbol(symbol);
return declaredType !== unknownType ? declaredType : getTypeOfSymbol(symbol);
}

26
src/harness/compilerRunner.ts
View File

@ -41,16 +41,16 @@ class CompilerBaselineRunner extends RunnerBase {
describe('compiler tests for ' + fileName, () => {
// Mocha holds onto the closure environment of the describe callback even after the test is done.
// Everything declared here should be cleared out in the "after" callback.
var justName = fileName.replace(/^.*[\\\/]/, ''); // strips the fileName from the path.
var content = Harness.IO.readFile(fileName);
var testCaseContent = Harness.TestCaseParser.makeUnitsFromTest(content, fileName);
var justName: string;
var content: string;
var testCaseContent: { settings: Harness.TestCaseParser.CompilerSetting[]; testUnitData: Harness.TestCaseParser.TestUnitData[]; }
var units = testCaseContent.testUnitData;
var tcSettings = testCaseContent.settings;
var createNewInstance = false;
var units: Harness.TestCaseParser.TestUnitData[];
var tcSettings: Harness.TestCaseParser.CompilerSetting[];
var createNewInstance: boolean;
var lastUnit = units[units.length - 1];
var rootDir = lastUnit.originalFilePath.indexOf('conformance') === -1 ? 'tests/cases/compiler/' : lastUnit.originalFilePath.substring(0, lastUnit.originalFilePath.lastIndexOf('/')) + '/';
var lastUnit: Harness.TestCaseParser.TestUnitData;
var rootDir: string;
var result: Harness.Compiler.CompilerResult;
var checker: ts.TypeChecker;
@ -68,6 +68,14 @@ class CompilerBaselineRunner extends RunnerBase {
var createNewInstance = false;
before(() => {
justName = fileName.replace(/^.*[\\\/]/, ''); // strips the fileName from the path.
content = Harness.IO.readFile(fileName);
testCaseContent = Harness.TestCaseParser.makeUnitsFromTest(content, fileName);
units = testCaseContent.testUnitData;
tcSettings = testCaseContent.settings;
createNewInstance = false;
lastUnit = units[units.length - 1];
rootDir = lastUnit.originalFilePath.indexOf('conformance') === -1 ? 'tests/cases/compiler/' : lastUnit.originalFilePath.substring(0, lastUnit.originalFilePath.lastIndexOf('/')) + '/';
harnessCompiler = Harness.Compiler.getCompiler();
// We need to assemble the list of input files for the compiler and other related files on the 'filesystem' (ie in a multi-file test)
// If the last file in a test uses require or a triple slash reference we'll assume all other files will be brought in via references,
@ -307,7 +315,7 @@ class CompilerBaselineRunner extends RunnerBase {
allFiles.forEach(file => {
var codeLines = file.content.split('\n');
walker.getTypes(file.unitName).forEach(result => {
var formattedLine = result.identifierName + " : " + result.type;
var formattedLine = result.sourceText.replace(/\r?\n/g, "") + " : " + result.type;
if (!typeMap[file.unitName]) {
typeMap[file.unitName] = {};
}

9
src/harness/typeWriter.ts
View File

@ -2,7 +2,7 @@ interface TypeWriterResult {
line: number;
column: number;
syntaxKind: string;
identifierName: string;
sourceText: string;
type: string;
}
@ -28,7 +28,7 @@ class TypeWriterWalker {
// TODO: Ideally we should log all expressions, but to compare to the
// old typeWriter baselines, suppress tokens
case ts.SyntaxKind.ThisKeyword:
case ts.SyntaxKind.RegularExpressionLiteral:
case ts.SyntaxKind.SuperKeyword:
case ts.SyntaxKind.ArrayLiteral:
case ts.SyntaxKind.ObjectLiteral:
case ts.SyntaxKind.PropertyAccess:
@ -77,7 +77,6 @@ class TypeWriterWalker {
var actualPos = ts.skipTrivia(this.currentSourceFile.text, node.pos);
var lineAndCharacter = this.currentSourceFile.getLineAndCharacterFromPosition(actualPos);
var sourceText = ts.getSourceTextOfNodeFromSourceText(this.currentSourceFile.text, node);
var isUnknownType = (<ts.IntrinsicType>type).intrinsicName === "unknown";
// If we got an unknown type, we temporarily want to fall back to just pretending the name
// (source text) of the node is the type. This is to align with the old typeWriter to make
@ -86,8 +85,8 @@ class TypeWriterWalker {
line: lineAndCharacter.line - 1,
column: lineAndCharacter.character,
syntaxKind: ts.SyntaxKind[node.kind],
identifierName: sourceText,
type: isUnknownType ? sourceText : this.checker.typeToString(type)
sourceText: sourceText,
type: this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.None)
});
}

10
tests/baselines/reference/AmbientModuleAndAmbientWithSameNameAndCommonRoot.types
View File

@ -45,15 +45,15 @@ var p: { 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.Point : typeof A.Point
>A : typeof A
>Point : typeof Point
>Point : typeof A.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
>new A.Point(0, 0) : A.Point
>A.Point : typeof A.Point
>A : typeof A
>Point : typeof Point
>Point : typeof A.Point

10
tests/baselines/reference/AmbientModuleAndNonAmbientClassWithSameNameAndCommonRoot.types
View File

@ -39,15 +39,15 @@ var p: { 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.Point : typeof A.Point
>A : typeof A
>Point : typeof Point
>Point : typeof A.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
>new A.Point(0, 0) : A.Point
>A.Point : typeof A.Point
>A : typeof A
>Point : typeof Point
>Point : typeof A.Point

6
tests/baselines/reference/ArrowFunction1.errors.txt Normal file
View File

@ -0,0 +1,6 @@
==== tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrowFunctions/ArrowFunction1.ts (1 errors) ====
var v = (a: ) => {
~
!!! Type expected.
};

8
tests/baselines/reference/ArrowFunction2.errors.txt Normal file
View File

@ -0,0 +1,8 @@
==== tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrowFunctions/ArrowFunction2.ts (2 errors) ====
var v = (a: b,) => {
~
!!! Trailing comma not allowed.
~
!!! Cannot find name 'b'.
};

10
tests/baselines/reference/ArrowFunction3.errors.txt Normal file
View File

@ -0,0 +1,10 @@
==== tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrowFunctions/ArrowFunction3.ts (3 errors) ====
var v = (a): => {
~
!!! ',' expected.
~~
!!! ';' expected.
~
!!! Cannot find name 'a'.
};

8
tests/baselines/reference/ArrowFunction4.js Normal file
View File

@ -0,0 +1,8 @@
//// [ArrowFunction4.ts]
var v = (a, b) => {
};
//// [ArrowFunction4.js]
var v = function (a, b) {
};

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

@ -0,0 +1,8 @@
=== tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrowFunctions/ArrowFunction4.ts ===
var v = (a, b) => {
>v : (a: any, b: any) => void
>(a, b) => { } : (a: any, b: any) => void
>a : any
>b : any
};

6
tests/baselines/reference/EnumAndModuleWithSameNameAndCommonRoot.types
View File

@ -36,8 +36,8 @@ var y: { 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
>new enumdule.Point(0, 0) : enumdule.Point
>enumdule.Point : typeof enumdule.Point
>enumdule : typeof enumdule
>Point : typeof Point
>Point : typeof enumdule.Point

2
tests/baselines/reference/ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.types
View File

@ -1,6 +1,6 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts ===
module A {
>A : A
>A : unknown
interface Point {
>Point : Point

4
tests/baselines/reference/FunctionAndModuleWithSameNameAndDifferentCommonRoot.types
View File

@ -47,8 +47,8 @@ var cl: { 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.Point : typeof B.Point
>B : typeof B
>Point : typeof Point
>Point : typeof B.Point
>Origin : { x: number; y: number; }

6
tests/baselines/reference/ModuleAndEnumWithSameNameAndCommonRoot.types
View File

@ -36,8 +36,8 @@ var y: { 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
>new enumdule.Point(0, 0) : enumdule.Point
>enumdule.Point : typeof enumdule.Point
>enumdule : typeof enumdule
>Point : typeof Point
>Point : typeof enumdule.Point

24
tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.types
View File

@ -20,20 +20,20 @@ module A {
>Point : Point
fromCarthesian(p: A.Point) {
>fromCarthesian : (p: Point) => { x: number; y: number; }
>p : Point
>A : A
>Point : Point
>fromCarthesian : (p: A.Point) => { x: number; y: number; }
>p : A.Point
>A : unknown
>Point : A.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
>p : A.Point
>x : number
>y : number
>p.y : number
>p : Point
>p : A.Point
>y : number
}
}
@ -47,8 +47,8 @@ var p: { x: number; y: number; };
var p: A.Point;
>p : { x: number; y: number; }
>A : A
>Point : Point
>A : unknown
>Point : A.Point
module X.Y.Z {
>X : typeof X
@ -89,9 +89,9 @@ var l: { length: number; }
var l: X.Y.Z.Line;
>l : { length: number; }
>X : X
>Y : Y
>Z : Z
>Line : Line
>X : unknown
>Y : unknown
>Z : unknown
>Line : X.Y.Z.Line

78
tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.types
View File

@ -1,6 +1,6 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts ===
module A {
>A : A
>A : unknown
export interface Point {
>Point : Point
@ -18,7 +18,7 @@ module A {
}
module A {
>A : A
>A : unknown
interface Point {
>Point : Point
@ -31,73 +31,73 @@ module A {
// ensure merges as expected
var p: { x: number; y: number; toCarth(): A.Point; };
>p : { x: number; y: number; toCarth(): Point; }
>p : { x: number; y: number; toCarth(): A.Point; }
>x : number
>y : number
>toCarth : () => Point
>A : A
>Point : Point
>toCarth : () => A.Point
>A : unknown
>Point : A.Point
var p: A.Point;
>p : { x: number; y: number; toCarth(): Point; }
>A : A
>Point : Point
>p : { x: number; y: number; toCarth(): A.Point; }
>A : unknown
>Point : A.Point
module X.Y.Z {
>X : X
>Y : Y
>Z : Z
>X : unknown
>Y : unknown
>Z : unknown
export interface Line {
>Line : Line
new (start: A.Point, end: A.Point);
>start : Point
>A : A
>Point : Point
>end : Point
>A : A
>Point : Point
>start : A.Point
>A : unknown
>Point : A.Point
>end : A.Point
>A : unknown
>Point : A.Point
}
}
module X {
>X : X
>X : unknown
export module Y.Z {
>Y : Y
>Z : Z
>Y : unknown
>Z : unknown
interface Line {
>Line : Line
start: A.Point;
>start : Point
>A : A
>Point : Point
>start : A.Point
>A : unknown
>Point : A.Point
end: A.Point;
>end : Point
>A : A
>Point : Point
>end : A.Point
>A : unknown
>Point : A.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
>l : new (s: A.Point, e: A.Point) => any
>s : A.Point
>A : unknown
>Point : A.Point
>e : A.Point
>A : unknown
>Point : A.Point
var l: X.Y.Z.Line;
>l : new (s: Point, e: Point) => any
>X : X
>Y : Y
>Z : Z
>Line : Line
>l : new (s: A.Point, e: A.Point) => any
>X : unknown
>Y : unknown
>Z : unknown
>Line : X.Y.Z.Line

50
tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedLocalVarsOfTheSameName.types
View File

@ -75,48 +75,48 @@ var o: { x: number; y: number };
var o: A.Point;
>o : { x: number; y: number; }
>A : A
>Point : Point
>A : unknown
>Point : A.Point
var o = A.Origin;
>o : { x: number; y: number; }
>A.Origin : Point
>A.Origin : A.Point
>A : typeof A
>Origin : Point
>Origin : A.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.Utils.mirror : <T extends A.Point>(p: T) => { x: number; y: number; }
>A.Utils : typeof A.Utils
>A : typeof A
>Utils : typeof Utils
>mirror : <T extends Point>(p: T) => { x: number; y: number; }
>Utils : typeof A.Utils
>mirror : <T extends A.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
>p : { tl: A.Point; br: A.Point; }
>tl : A.Point
>A : unknown
>Point : A.Point
>br : A.Point
>A : unknown
>Point : A.Point
var p: A.Utils.Plane;
>p : { tl: Point; br: Point; }
>A : A
>Utils : Utils
>Plane : Plane
>p : { tl: A.Point; br: A.Point; }
>A : unknown
>Utils : unknown
>Plane : A.Utils.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
>p : { tl: A.Point; br: A.Point; }
>new A.Utils.Plane(o, { x: 1, y: 1 }) : A.Utils.Plane
>A.Utils.Plane : typeof A.Utils.Plane
>A.Utils : typeof A.Utils
>A : typeof A
>Utils : typeof Utils
>Plane : typeof Plane
>Utils : typeof A.Utils
>Plane : typeof A.Utils.Plane
>o : { x: number; y: number; }
>{ x: 1, y: 1 } : { x: number; y: number; }
>x : number

96
tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.types
View File

@ -1,6 +1,6 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts ===
module A {
>A : A
>A : unknown
export interface Point {
>Point : Point
@ -18,7 +18,7 @@ module A {
}
module A {
>A : A
>A : unknown
export interface Point {
>Point : Point
@ -31,82 +31,82 @@ module A {
// 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; }
>p : { x: number; y: number; toCarth(): A.Point; fromCarth(): A.Point; }
>x : number
>y : number
>toCarth : () => Point
>A : A
>Point : Point
>fromCarth : () => Point
>A : A
>Point : Point
>toCarth : () => A.Point
>A : unknown
>Point : A.Point
>fromCarth : () => A.Point
>A : unknown
>Point : A.Point
var p: A.Point;
>p : { x: number; y: number; toCarth(): Point; fromCarth(): Point; }
>A : A
>Point : Point
>p : { x: number; y: number; toCarth(): A.Point; fromCarth(): A.Point; }
>A : unknown
>Point : A.Point
module X.Y.Z {
>X : X
>Y : Y
>Z : Z
>X : unknown
>Y : unknown
>Z : unknown
export interface Line {
>Line : Line
new (start: A.Point, end: A.Point);
>start : Point
>A : A
>Point : Point
>end : Point
>A : A
>Point : Point
>start : A.Point
>A : unknown
>Point : A.Point
>end : A.Point
>A : unknown
>Point : A.Point
}
}
module X {
>X : X
>X : unknown
export module Y.Z {
>Y : Y
>Z : Z
>Y : unknown
>Z : unknown
export interface Line {
>Line : Line
start: A.Point;
>start : Point
>A : A
>Point : Point
>start : A.Point
>A : unknown
>Point : A.Point
end: A.Point;
>end : Point
>A : A
>Point : Point
>end : A.Point
>A : unknown
>Point : A.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
>l : { new (s: A.Point, e: A.Point): any; start: A.Point; end: A.Point; }
>start : A.Point
>A : unknown
>Point : A.Point
>end : A.Point
>A : unknown
>Point : A.Point
>s : A.Point
>A : unknown
>Point : A.Point
>e : A.Point
>A : unknown
>Point : A.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
>l : { new (s: A.Point, e: A.Point): any; start: A.Point; end: A.Point; }
>X : unknown
>Y : unknown
>Z : unknown
>Line : X.Y.Z.Line

12
tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.types
View File

@ -25,9 +25,9 @@ var x: number;
var x = A.B.x;
>x : number
>A.B.x : number
>A.B : typeof B
>A.B : typeof A.B
>A : typeof A
>B : typeof B
>B : typeof A.B
>x : number
module X.Y.Z {
@ -69,8 +69,8 @@ var l: { length: number };
var l: X.Y.Z.Line;
>l : { length: number; }
>X : X
>Y : Y
>Z : Z
>Line : Line
>X : unknown
>Y : unknown
>Z : unknown
>Line : X.Y.Z.Line

24
tests/baselines/reference/TwoInternalModulesWithTheSameNameAndDifferentCommonRoot.types
View File

@ -49,10 +49,10 @@ module otherRoot {
// 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
>Origin : Root.A.Point
>Root : unknown
>A : unknown
>Point : Root.A.Point
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
@ -64,14 +64,14 @@ module otherRoot {
>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
>tl : Root.A.Point
>Root : unknown
>A : unknown
>Point : Root.A.Point
>br : Root.A.Point
>Root : unknown
>A : unknown
>Point : Root.A.Point
}
}
}

50
tests/baselines/reference/TwoInternalModulesWithTheSameNameAndSameCommonRoot.types
View File

@ -72,48 +72,48 @@ var o: { x: number; y: number };
var o: A.Point;
>o : { x: number; y: number; }
>A : A
>Point : Point
>A : unknown
>Point : A.Point
var o = A.Origin;
>o : { x: number; y: number; }
>A.Origin : Point
>A.Origin : A.Point
>A : typeof A
>Origin : Point
>Origin : A.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.Utils.mirror : <T extends A.Point>(p: T) => { x: number; y: number; }
>A.Utils : typeof A.Utils
>A : typeof A
>Utils : typeof Utils
>mirror : <T extends Point>(p: T) => { x: number; y: number; }
>Utils : typeof A.Utils
>mirror : <T extends A.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
>p : { tl: A.Point; br: A.Point; }
>tl : A.Point
>A : unknown
>Point : A.Point
>br : A.Point
>A : unknown
>Point : A.Point
var p: A.Utils.Plane;
>p : { tl: Point; br: Point; }
>A : A
>Utils : Utils
>Plane : Plane
>p : { tl: A.Point; br: A.Point; }
>A : unknown
>Utils : unknown
>Plane : A.Utils.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
>p : { tl: A.Point; br: A.Point; }
>new A.Utils.Plane(o, { x: 1, y: 1 }) : A.Utils.Plane
>A.Utils.Plane : typeof A.Utils.Plane
>A.Utils : typeof A.Utils
>A : typeof A
>Utils : typeof Utils
>Plane : typeof Plane
>Utils : typeof A.Utils
>Plane : typeof A.Utils.Plane
>o : { x: number; y: number; }
>{ x: 1, y: 1 } : { x: number; y: number; }
>x : number

12
tests/baselines/reference/TypeArgumentList1.errors.txt Normal file
View File

@ -0,0 +1,12 @@
==== tests/cases/conformance/parser/ecmascript5/ErrorRecovery/TypeArgumentLists/TypeArgumentList1.ts (5 errors) ====
Foo<A,B,\ C>(4, 5, 6);
!!! Invalid character.
~~~
!!! Cannot find name 'Foo'.
~
!!! Cannot find name 'A'.
~
!!! Cannot find name 'B'.
~
!!! Cannot find name 'C'.

10
tests/baselines/reference/acceptableAlias1.types
View File

@ -3,15 +3,15 @@ module M {
>M : typeof M
export module N {
>N : N
>N : unknown
}
export import X = N;
>X : X
>N : N
>X : unknown
>N : unknown
}
import r = M.X;
>r : r
>r : unknown
>M : typeof M
>X : X
>X : unknown

2
tests/baselines/reference/accessOverriddenBaseClassMember1.types
View File

@ -32,6 +32,7 @@ class ColoredPoint extends Point {
super(x, y);
>super(x, y) : void
>super : typeof Point
>x : number
>y : number
}
@ -43,6 +44,7 @@ class ColoredPoint extends Point {
>super.toString() + " color=" : string
>super.toString() : string
>super.toString : () => string
>super : Point
>toString : () => string
>this.color : string
>this : ColoredPoint

8
tests/baselines/reference/accessorWithES5.types
View File

@ -21,9 +21,7 @@ class D {
var x = {
>x : { a: number; }
>{
get a() { return 1 }
} : { a: number; }
>{ get a() { return 1 }} : { a: number; }
get a() { return 1 }
>a : number
@ -31,9 +29,7 @@ var x = {
var y = {
>y : { b: any; }
>{
set b(v) { }
} : { b: any; }
>{ set b(v) { }} : { b: any; }
set b(v) { }
>b : any

20
tests/baselines/reference/aliasUsageInAccessorsOfClass.types
View File

@ -1,17 +1,17 @@
=== tests/cases/compiler/aliasUsage1_main.ts ===
import Backbone = require("aliasUsage1_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsage1_backbone"
>Backbone : typeof Backbone
import moduleA = require("aliasUsage1_moduleA");
>moduleA : typeof "tests/cases/compiler/aliasUsage1_moduleA"
>moduleA : typeof moduleA
interface IHasVisualizationModel {
>IHasVisualizationModel : IHasVisualizationModel
VisualizationModel: typeof Backbone.Model;
>VisualizationModel : typeof Model
>Backbone : typeof "tests/cases/compiler/aliasUsage1_backbone"
>Model : typeof Model
>VisualizationModel : typeof Backbone.Model
>Backbone : typeof Backbone
>Model : typeof Backbone.Model
}
class C2 {
>C2 : C2
@ -33,9 +33,9 @@ class C2 {
>x : IHasVisualizationModel
x = moduleA;
>x = moduleA : typeof "tests/cases/compiler/aliasUsage1_moduleA"
>x = moduleA : typeof moduleA
>x : IHasVisualizationModel
>moduleA : typeof "tests/cases/compiler/aliasUsage1_moduleA"
>moduleA : typeof moduleA
}
}
=== tests/cases/compiler/aliasUsage1_backbone.ts ===
@ -48,12 +48,12 @@ export class Model {
=== tests/cases/compiler/aliasUsage1_moduleA.ts ===
import Backbone = require("aliasUsage1_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsage1_backbone"
>Backbone : typeof Backbone
export class VisualizationModel extends Backbone.Model {
>VisualizationModel : VisualizationModel
>Backbone : Backbone
>Model : Model
>Backbone : unknown
>Model : Backbone.Model
// interesting stuff here
}

26
tests/baselines/reference/aliasUsageInArray.types
View File

@ -1,30 +1,30 @@
=== tests/cases/compiler/aliasUsageInArray_main.ts ===
import Backbone = require("aliasUsageInArray_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInArray_backbone"
>Backbone : typeof Backbone
import moduleA = require("aliasUsageInArray_moduleA");
>moduleA : typeof "tests/cases/compiler/aliasUsageInArray_moduleA"
>moduleA : typeof moduleA
interface IHasVisualizationModel {
>IHasVisualizationModel : IHasVisualizationModel
VisualizationModel: typeof Backbone.Model;
>VisualizationModel : typeof Model
>Backbone : typeof "tests/cases/compiler/aliasUsageInArray_backbone"
>Model : typeof Model
>VisualizationModel : typeof Backbone.Model
>Backbone : typeof Backbone
>Model : typeof Backbone.Model
}
var xs: IHasVisualizationModel[] = [moduleA];
>xs : IHasVisualizationModel[]
>IHasVisualizationModel : IHasVisualizationModel
>[moduleA] : IHasVisualizationModel[]
>moduleA : typeof "tests/cases/compiler/aliasUsageInArray_moduleA"
>moduleA : typeof 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"
>xs2 : typeof moduleA[]
>moduleA : typeof moduleA
>[moduleA] : typeof moduleA[]
>moduleA : typeof moduleA
=== tests/cases/compiler/aliasUsageInArray_backbone.ts ===
export class Model {
@ -36,12 +36,12 @@ export class Model {
=== tests/cases/compiler/aliasUsageInArray_moduleA.ts ===
import Backbone = require("aliasUsageInArray_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInArray_backbone"
>Backbone : typeof Backbone
export class VisualizationModel extends Backbone.Model {
>VisualizationModel : VisualizationModel
>Backbone : Backbone
>Model : Model
>Backbone : unknown
>Model : Backbone.Model
// interesting stuff here
}

22
tests/baselines/reference/aliasUsageInFunctionExpression.types
View File

@ -1,17 +1,17 @@
=== tests/cases/compiler/aliasUsageInFunctionExpression_main.ts ===
import Backbone = require("aliasUsageInFunctionExpression_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInFunctionExpression_backbone"
>Backbone : typeof Backbone
import moduleA = require("aliasUsageInFunctionExpression_moduleA");
>moduleA : typeof "tests/cases/compiler/aliasUsageInFunctionExpression_moduleA"
>moduleA : typeof moduleA
interface IHasVisualizationModel {
>IHasVisualizationModel : IHasVisualizationModel
VisualizationModel: typeof Backbone.Model;
>VisualizationModel : typeof Model
>Backbone : typeof "tests/cases/compiler/aliasUsageInFunctionExpression_backbone"
>Model : typeof Model
>VisualizationModel : typeof Backbone.Model
>Backbone : typeof Backbone
>Model : typeof Backbone.Model
}
var f = (x: IHasVisualizationModel) => x;
>f : (x: IHasVisualizationModel) => IHasVisualizationModel
@ -21,11 +21,11 @@ var f = (x: IHasVisualizationModel) => x;
>x : IHasVisualizationModel
f = (x) => moduleA;
>f = (x) => moduleA : (x: IHasVisualizationModel) => typeof "tests/cases/compiler/aliasUsageInFunctionExpression_moduleA"
>f = (x) => moduleA : (x: IHasVisualizationModel) => typeof moduleA
>f : (x: IHasVisualizationModel) => IHasVisualizationModel
>(x) => moduleA : (x: IHasVisualizationModel) => typeof "tests/cases/compiler/aliasUsageInFunctionExpression_moduleA"
>(x) => moduleA : (x: IHasVisualizationModel) => typeof moduleA
>x : IHasVisualizationModel
>moduleA : typeof "tests/cases/compiler/aliasUsageInFunctionExpression_moduleA"
>moduleA : typeof moduleA
=== tests/cases/compiler/aliasUsageInFunctionExpression_backbone.ts ===
export class Model {
@ -37,12 +37,12 @@ export class Model {
=== tests/cases/compiler/aliasUsageInFunctionExpression_moduleA.ts ===
import Backbone = require("aliasUsageInFunctionExpression_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInFunctionExpression_backbone"
>Backbone : typeof Backbone
export class VisualizationModel extends Backbone.Model {
>VisualizationModel : VisualizationModel
>Backbone : Backbone
>Model : Model
>Backbone : unknown
>Model : Backbone.Model
// interesting stuff here
}

26
tests/baselines/reference/aliasUsageInGenericFunction.types
View File

@ -1,17 +1,17 @@
=== tests/cases/compiler/aliasUsageInGenericFunction_main.ts ===
import Backbone = require("aliasUsageInGenericFunction_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInGenericFunction_backbone"
>Backbone : typeof Backbone
import moduleA = require("aliasUsageInGenericFunction_moduleA");
>moduleA : typeof "tests/cases/compiler/aliasUsageInGenericFunction_moduleA"
>moduleA : typeof moduleA
interface IHasVisualizationModel {
>IHasVisualizationModel : IHasVisualizationModel
VisualizationModel: typeof Backbone.Model;
>VisualizationModel : typeof Model
>Backbone : typeof "tests/cases/compiler/aliasUsageInGenericFunction_backbone"
>Model : typeof Model
>VisualizationModel : typeof Backbone.Model
>Backbone : typeof Backbone
>Model : typeof Backbone.Model
}
function foo<T extends { a: IHasVisualizationModel }>(x: T) {
>foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T
@ -25,12 +25,12 @@ function foo<T extends { a: IHasVisualizationModel }>(x: T) {
>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"; }
>r : { a: typeof moduleA; }
>foo({ a: moduleA }) : { a: typeof 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
>{ a: moduleA } : { a: typeof moduleA; }
>a : typeof moduleA
>moduleA : typeof moduleA
var r2 = foo({ a: <IHasVisualizationModel>null });
>r2 : { a: IHasVisualizationModel; }
@ -51,12 +51,12 @@ export class Model {
=== tests/cases/compiler/aliasUsageInGenericFunction_moduleA.ts ===
import Backbone = require("aliasUsageInGenericFunction_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInGenericFunction_backbone"
>Backbone : typeof Backbone
export class VisualizationModel extends Backbone.Model {
>VisualizationModel : VisualizationModel
>Backbone : Backbone
>Model : Model
>Backbone : unknown
>Model : Backbone.Model
// interesting stuff here
}

22
tests/baselines/reference/aliasUsageInIndexerOfClass.types
View File

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

44
tests/baselines/reference/aliasUsageInObjectLiteral.types
View File

@ -1,44 +1,44 @@
=== tests/cases/compiler/aliasUsageInObjectLiteral_main.ts ===
import Backbone = require("aliasUsageInObjectLiteral_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInObjectLiteral_backbone"
>Backbone : typeof Backbone
import moduleA = require("aliasUsageInObjectLiteral_moduleA");
>moduleA : typeof "tests/cases/compiler/aliasUsageInObjectLiteral_moduleA"
>moduleA : typeof moduleA
interface IHasVisualizationModel {
>IHasVisualizationModel : IHasVisualizationModel
VisualizationModel: typeof Backbone.Model;
>VisualizationModel : typeof Model
>Backbone : typeof "tests/cases/compiler/aliasUsageInObjectLiteral_backbone"
>Model : typeof Model
>VisualizationModel : typeof Backbone.Model
>Backbone : typeof Backbone
>Model : typeof Backbone.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
>a : { x: typeof moduleA; }
>x : typeof moduleA
>moduleA : typeof moduleA
>{ x: moduleA } : { x: typeof moduleA; }
>x : typeof moduleA
>moduleA : typeof 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
>{ x: moduleA } : { x: typeof moduleA; }
>x : typeof moduleA
>moduleA : typeof 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
>{ y: { z: moduleA } } : { y: { z: typeof moduleA; }; }
>y : { z: typeof moduleA; }
>{ z: moduleA } : { z: typeof moduleA; }
>z : typeof moduleA
>moduleA : typeof moduleA
=== tests/cases/compiler/aliasUsageInObjectLiteral_backbone.ts ===
export class Model {
@ -50,12 +50,12 @@ export class Model {
=== tests/cases/compiler/aliasUsageInObjectLiteral_moduleA.ts ===
import Backbone = require("aliasUsageInObjectLiteral_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInObjectLiteral_backbone"
>Backbone : typeof Backbone
export class VisualizationModel extends Backbone.Model {
>VisualizationModel : VisualizationModel
>Backbone : Backbone
>Model : Model
>Backbone : unknown
>Model : Backbone.Model
// interesting stuff here
}

34
tests/baselines/reference/aliasUsageInOrExpression.types
View File

@ -1,17 +1,17 @@
=== tests/cases/compiler/aliasUsageInOrExpression_main.ts ===
import Backbone = require("aliasUsageInOrExpression_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInOrExpression_backbone"
>Backbone : typeof Backbone
import moduleA = require("aliasUsageInOrExpression_moduleA");
>moduleA : typeof "tests/cases/compiler/aliasUsageInOrExpression_moduleA"
>moduleA : typeof moduleA
interface IHasVisualizationModel {
>IHasVisualizationModel : IHasVisualizationModel
VisualizationModel: typeof Backbone.Model;
>VisualizationModel : typeof Model
>Backbone : typeof "tests/cases/compiler/aliasUsageInOrExpression_backbone"
>Model : typeof Model
>VisualizationModel : typeof Backbone.Model
>Backbone : typeof Backbone
>Model : typeof Backbone.Model
}
var i: IHasVisualizationModel;
>i : IHasVisualizationModel
@ -21,20 +21,20 @@ var d1 = i || moduleA;
>d1 : IHasVisualizationModel
>i || moduleA : IHasVisualizationModel
>i : IHasVisualizationModel
>moduleA : typeof "tests/cases/compiler/aliasUsageInOrExpression_moduleA"
>moduleA : typeof moduleA
var d2: IHasVisualizationModel = i || moduleA;
>d2 : IHasVisualizationModel
>IHasVisualizationModel : IHasVisualizationModel
>i || moduleA : IHasVisualizationModel
>i : IHasVisualizationModel
>moduleA : typeof "tests/cases/compiler/aliasUsageInOrExpression_moduleA"
>moduleA : typeof moduleA
var d2: IHasVisualizationModel = moduleA || i;
>d2 : IHasVisualizationModel
>IHasVisualizationModel : IHasVisualizationModel
>moduleA || i : IHasVisualizationModel
>moduleA : typeof "tests/cases/compiler/aliasUsageInOrExpression_moduleA"
>moduleA : typeof moduleA
>i : IHasVisualizationModel
var e: { x: IHasVisualizationModel } = <{ x: IHasVisualizationModel }>null || { x: moduleA };
@ -45,9 +45,9 @@ var e: { x: IHasVisualizationModel } = <{ x: IHasVisualizationModel }>null || {
><{ 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
>{ x: moduleA } : { x: typeof moduleA; }
>x : typeof moduleA
>moduleA : typeof moduleA
var f: { x: IHasVisualizationModel } = <{ x: IHasVisualizationModel }>null ? { x: moduleA } : null;
>f : { x: IHasVisualizationModel; }
@ -57,9 +57,9 @@ var f: { x: IHasVisualizationModel } = <{ x: IHasVisualizationModel }>null ? { x
><{ 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
>{ x: moduleA } : { x: typeof moduleA; }
>x : typeof moduleA
>moduleA : typeof moduleA
=== tests/cases/compiler/aliasUsageInOrExpression_backbone.ts ===
export class Model {
@ -71,12 +71,12 @@ export class Model {
=== tests/cases/compiler/aliasUsageInOrExpression_moduleA.ts ===
import Backbone = require("aliasUsageInOrExpression_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInOrExpression_backbone"
>Backbone : typeof Backbone
export class VisualizationModel extends Backbone.Model {
>VisualizationModel : VisualizationModel
>Backbone : Backbone
>Model : Model
>Backbone : unknown
>Model : Backbone.Model
// interesting stuff here
}

20
tests/baselines/reference/aliasUsageInTypeArgumentOfExtendsClause.types
View File

@ -1,17 +1,17 @@
=== tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_main.ts ===
import Backbone = require("aliasUsageInTypeArgumentOfExtendsClause_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_backbone"
>Backbone : typeof Backbone
import moduleA = require("aliasUsageInTypeArgumentOfExtendsClause_moduleA");
>moduleA : typeof "tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_moduleA"
>moduleA : typeof moduleA
interface IHasVisualizationModel {
>IHasVisualizationModel : IHasVisualizationModel
VisualizationModel: typeof Backbone.Model;
>VisualizationModel : typeof Model
>Backbone : typeof "tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_backbone"
>Model : typeof Model
>VisualizationModel : typeof Backbone.Model
>Backbone : typeof Backbone
>Model : typeof Backbone.Model
}
class C<T extends IHasVisualizationModel> {
>C : C<T>
@ -28,8 +28,8 @@ class D extends C<IHasVisualizationModel> {
>IHasVisualizationModel : IHasVisualizationModel
x = moduleA;
>x : typeof "tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_moduleA"
>moduleA : typeof "tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_moduleA"
>x : typeof moduleA
>moduleA : typeof moduleA
}
=== tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_backbone.ts ===
export class Model {
@ -41,12 +41,12 @@ export class Model {
=== tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_moduleA.ts ===
import Backbone = require("aliasUsageInTypeArgumentOfExtendsClause_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_backbone"
>Backbone : typeof Backbone
export class VisualizationModel extends Backbone.Model {
>VisualizationModel : VisualizationModel
>Backbone : Backbone
>Model : Model
>Backbone : unknown
>Model : Backbone.Model
// interesting stuff here
}

20
tests/baselines/reference/aliasUsageInVarAssignment.types
View File

@ -1,25 +1,25 @@
=== tests/cases/compiler/aliasUsageInVarAssignment_main.ts ===
import Backbone = require("aliasUsageInVarAssignment_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInVarAssignment_backbone"
>Backbone : typeof Backbone
import moduleA = require("aliasUsageInVarAssignment_moduleA");
>moduleA : typeof "tests/cases/compiler/aliasUsageInVarAssignment_moduleA"
>moduleA : typeof moduleA
interface IHasVisualizationModel {
>IHasVisualizationModel : IHasVisualizationModel
VisualizationModel: typeof Backbone.Model;
>VisualizationModel : typeof Model
>Backbone : typeof "tests/cases/compiler/aliasUsageInVarAssignment_backbone"
>Model : typeof Model
>VisualizationModel : typeof Backbone.Model
>Backbone : typeof Backbone
>Model : typeof Backbone.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"
>m : typeof moduleA
>moduleA : typeof moduleA
>i : IHasVisualizationModel
=== tests/cases/compiler/aliasUsageInVarAssignment_backbone.ts ===
@ -32,12 +32,12 @@ export class Model {
=== tests/cases/compiler/aliasUsageInVarAssignment_moduleA.ts ===
import Backbone = require("aliasUsageInVarAssignment_backbone");
>Backbone : typeof "tests/cases/compiler/aliasUsageInVarAssignment_backbone"
>Backbone : typeof Backbone
export class VisualizationModel extends Backbone.Model {
>VisualizationModel : VisualizationModel
>Backbone : Backbone
>Model : Model
>Backbone : unknown
>Model : Backbone.Model
// interesting stuff here
}

13
tests/baselines/reference/aliasUsedAsNameValue.types
View File

@ -2,25 +2,22 @@
///<reference path='aliasUsedAsNameValue_0.ts' />
///<reference path='aliasUsedAsNameValue_1.ts' />
import mod = require("aliasUsedAsNameValue_0");
>mod : typeof "tests/cases/compiler/aliasUsedAsNameValue_0"
>mod : typeof mod
import b = require("aliasUsedAsNameValue_1");
>b : typeof "tests/cases/compiler/aliasUsedAsNameValue_1"
>b : typeof b
export var a = function () {
>a : () => void
>function () {
//var x = mod.id; // TODO needed hack that mod is loaded
b.b(mod);
} : () => 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 : typeof b
>b : (a: any) => any
>mod : typeof "tests/cases/compiler/aliasUsedAsNameValue_0"
>mod : typeof mod
}
=== tests/cases/compiler/aliasUsedAsNameValue_0.ts ===

18
tests/baselines/reference/ambientExternalModuleWithInternalImportDeclaration.types
View File

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

8
tests/baselines/reference/ambientExternalModuleWithoutInternalImportDeclaration.types
View File

@ -1,12 +1,12 @@
=== tests/cases/compiler/ambientExternalModuleWithoutInternalImportDeclaration_1.ts ===
///<reference path='ambientExternalModuleWithoutInternalImportDeclaration_0.ts'/>
import A = require('M');
>A : typeof C
>A : typeof A
var c = new A();
>c : C
>new A() : C
>A : typeof C
>c : A
>new A() : A
>A : typeof A
=== tests/cases/compiler/ambientExternalModuleWithoutInternalImportDeclaration_0.ts ===
declare module 'M' {

16
tests/baselines/reference/ambientModuleExports.types
View File

@ -24,11 +24,11 @@ Foo.b;
>b : number
var c = new Foo.C();
>c : C
>new Foo.C() : C
>Foo.C : typeof C
>c : Foo.C
>new Foo.C() : Foo.C
>Foo.C : typeof Foo.C
>Foo : typeof Foo
>C : typeof C
>C : typeof Foo.C
declare module Foo2 {
>Foo2 : typeof Foo2
@ -55,9 +55,9 @@ Foo2.b;
>b : number
var c2 = new Foo2.C();
>c2 : C
>new Foo2.C() : C
>Foo2.C : typeof C
>c2 : Foo2.C
>new Foo2.C() : Foo2.C
>Foo2.C : typeof Foo2.C
>Foo2 : typeof Foo2
>C : typeof C
>C : typeof Foo2.C

4
tests/baselines/reference/ambientModules.types
View File

@ -7,8 +7,8 @@ declare module Foo.Bar { export var foo; };
Foo.Bar.foo = 5;
>Foo.Bar.foo = 5 : number
>Foo.Bar.foo : any
>Foo.Bar : typeof Bar
>Foo.Bar : typeof Foo.Bar
>Foo : typeof Foo
>Bar : typeof Bar
>Bar : typeof Foo.Bar
>foo : any

12
tests/baselines/reference/amdImportAsPrimaryExpression.types
View File

@ -1,14 +1,14 @@
=== tests/cases/conformance/externalModules/foo_1.ts ===
import foo = require("./foo_0");
>foo : typeof "tests/cases/conformance/externalModules/foo_0"
>foo : typeof foo
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
>foo.E1.A : foo.E1
>foo.E1 : typeof foo.E1
>foo : typeof foo
>E1 : typeof foo.E1
>A : foo.E1
// Should cause runtime import - interesting optimization possibility, as gets inlined to 0.
}

40
tests/baselines/reference/amdImportNotAsPrimaryExpression.types
View File

@ -1,43 +1,43 @@
=== tests/cases/conformance/externalModules/foo_1.ts ===
import foo = require("./foo_0");
>foo : typeof "tests/cases/conformance/externalModules/foo_0"
>foo : typeof foo
// None of the below should cause a runtime dependency on foo_0
import f = foo.M1;
>f : f
>foo : typeof "tests/cases/conformance/externalModules/foo_0"
>M1 : M1
>f : unknown
>foo : typeof foo
>M1 : unknown
var i: f.I2;
>i : I2
>f : f
>I2 : I2
>i : f.I2
>f : unknown
>I2 : f.I2
var x: foo.C1 = <{m1: number}>{};
>x : C1
>foo : foo
>C1 : C1
>x : foo.C1
>foo : unknown
>C1 : foo.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
>foo : typeof foo
>C1 : typeof foo.C1
>s1 : boolean
var z: foo.M1.I2;
>z : I2
>foo : foo
>M1 : M1
>I2 : I2
>z : f.I2
>foo : unknown
>M1 : unknown
>I2 : f.I2
var e: number = <foo.E1>0;
>e : number
><foo.E1>0 : E1
>foo : foo
>E1 : E1
><foo.E1>0 : foo.E1
>foo : unknown
>E1 : foo.E1
=== tests/cases/conformance/externalModules/foo_0.ts ===
export class C1 {
@ -61,7 +61,7 @@ export interface I1 {
}
export module M1 {
>M1 : M1
>M1 : unknown
export interface I2 {
>I2 : I2

10
tests/baselines/reference/anonterface.types
View File

@ -20,16 +20,16 @@ module M {
}
var c=new M.C();
>c : C
>new M.C() : C
>M.C : typeof C
>c : M.C
>new M.C() : M.C
>M.C : typeof M.C
>M : typeof M
>C : typeof C
>C : typeof M.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
>c : M.C
>m : (fn: (n: number) => string, n2: number) => string
>function(n) { return "hello: "+n; } : (n: number) => string
>n : number

22
tests/baselines/reference/anyInferenceAnonymousFunctions.types
View File

@ -3,19 +3,11 @@ var paired: any[];
>paired : any[]
paired.reduce(function (a1, a2) {
>paired.reduce(function (a1, a2) {
return a1.concat({});
} , []) : any
>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
>function (a1, a2) { return a1.concat({});} : (a1: any, a2: any) => any
>a1 : any
>a2 : any
@ -30,17 +22,11 @@ paired.reduce(function (a1, a2) {
>[] : undefined[]
paired.reduce((b1, b2) => {
>paired.reduce((b1, b2) => {
return b1.concat({});
} , []) : any
>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, b2) => { return b1.concat({});} : (b1: any, b2: any) => any
>b1 : any
>b2 : any

4
tests/baselines/reference/argumentsUsedInObjectLiteralProperty.types
View File

@ -8,9 +8,7 @@ class A {
>selectedValue : any
return {
>{
selectedValue: arguments.length
} : { selectedValue: number; }
>{ selectedValue: arguments.length } : { selectedValue: number; }
selectedValue: arguments.length
>selectedValue : number

6
tests/baselines/reference/arrayBestCommonTypes.types
View File

@ -248,7 +248,7 @@ class f {
>y : string
>{x: anyObj, y: 'a'} : { x: any; y: string; }
>x : any
>anyObj : anyObj
>anyObj : any
>y : string
var a2 = [ {x: anyObj, y: 'a'}, {x: 0, y: 'a'}, {x: 'a', y: 'a'} ];
@ -256,7 +256,7 @@ class f {
>[ {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
>anyObj : any
>y : string
>{x: 0, y: 'a'} : { x: number; y: string; }
>x : number
@ -273,7 +273,7 @@ class f {
>y : string
>{x: anyObj, y: 'a'} : { x: any; y: string; }
>x : any
>anyObj : anyObj
>anyObj : any
>y : string
>{x: 'a', y: 'a'} : { x: string; y: string; }
>x : string

6
tests/baselines/reference/arrayConcatMap.types
View File

@ -1,10 +1,8 @@
=== 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 }]) .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[]

32
tests/baselines/reference/arrayLiteralTypeInference.types
View File

@ -25,10 +25,7 @@ class ActionB extends Action {
var x1: Action[] = [
>x1 : Action[]
>Action : Action
>[
{ id: 2, trueness: false },
{ id: 3, name: "three" }
] : Action[]
>[ { id: 2, trueness: false }, { id: 3, name: "three" }] : Action[]
{ id: 2, trueness: false },
>{ id: 2, trueness: false } : { id: number; trueness: boolean; }
@ -45,10 +42,7 @@ var x1: Action[] = [
var x2: Action[] = [
>x2 : Action[]
>Action : Action
>[
new ActionA(),
new ActionB()
] : Action[]
>[ new ActionA(), new ActionB()] : Action[]
new ActionA(),
>new ActionA() : ActionA
@ -63,11 +57,7 @@ var x2: Action[] = [
var x3: Action[] = [
>x3 : Action[]
>Action : Action
>[
new Action(),
new ActionA(),
new ActionB()
] : Action[]
>[ new Action(), new ActionA(), new ActionB()] : Action[]
new Action(),
>new Action() : Action
@ -88,10 +78,7 @@ var z1: { id: number }[] =
>id : number
[
>[
{ id: 2, trueness: false },
{ id: 3, name: "three" }
] : { id: number; }[]
>[ { id: 2, trueness: false }, { id: 3, name: "three" } ] : { id: number; }[]
{ id: 2, trueness: false },
>{ id: 2, trueness: false } : { id: number; trueness: boolean; }
@ -110,10 +97,7 @@ var z2: { id: number }[] =
>id : number
[
>[
new ActionA(),
new ActionB()
] : { id: number; }[]
>[ new ActionA(), new ActionB() ] : { id: number; }[]
new ActionA(),
>new ActionA() : ActionA
@ -130,11 +114,7 @@ var z3: { id: number }[] =
>id : number
[
>[
new Action(),
new ActionA(),
new ActionB()
] : { id: number; }[]
>[ new Action(), new ActionA(), new ActionB() ] : { id: number; }[]
new Action(),
>new Action() : Action

12
tests/baselines/reference/arrayTypeInSignatureOfInterfaceAndClass.types
View File

@ -62,11 +62,11 @@ declare module Data {
//removeIndices: WinJS.Promise<IListItem<T>[]>;
removeIndices(indices: number[], options?: any): WinJS.Promise<IListItem<T>[]>;
>removeIndices : (indices: number[], options?: any) => Promise<IListItem<T>[]>
>removeIndices : (indices: number[], options?: any) => WinJS.Promise<IListItem<T>[]>
>indices : number[]
>options : any
>WinJS : WinJS
>Promise : Promise<T>
>WinJS : unknown
>Promise : WinJS.Promise<T>
>IListItem : IListItem<T>
>T : T
}
@ -78,11 +78,11 @@ declare module Data {
//removeIndices: WinJS.Promise<IListItem<T>[]>;
public removeIndices(indices: number[], options?: any): WinJS.Promise<IListItem<T>[]>;
>removeIndices : (indices: number[], options?: any) => Promise<IListItem<T>[]>
>removeIndices : (indices: number[], options?: any) => WinJS.Promise<IListItem<T>[]>
>indices : number[]
>options : any
>WinJS : WinJS
>Promise : Promise<T>
>WinJS : unknown
>Promise : WinJS.Promise<T>
>IListItem : IListItem<T>
>T : T
}

39
tests/baselines/reference/arrayconcat.types
View File

@ -36,50 +36,17 @@ class parser {
>m : () => void
this.options = this.options.sort(function(a, b) {
>this.options = this.options.sort(function(a, b) {
var aName = a.name.toLowerCase();
var bName = b.name.toLowerCase();
if (aName > bName) {
return 1;
} else if (aName < bName) {
return -1;
} else {
return 0;
}
}) : IOptions[]
>this.options = this.options.sort(function(a, b) { var aName = a.name.toLowerCase(); var bName = b.name.toLowerCase(); if (aName > bName) { return 1; } else if (aName < bName) { return -1; } else { return 0; } }) : IOptions[]
>this.options : IOptions[]
>this : parser
>options : IOptions[]
>this.options.sort(function(a, b) {
var aName = a.name.toLowerCase();
var bName = b.name.toLowerCase();
if (aName > bName) {
return 1;
} else if (aName < bName) {
return -1;
} else {
return 0;
}
}) : IOptions[]
>this.options.sort(function(a, b) { var aName = a.name.toLowerCase(); var bName = b.name.toLowerCase(); if (aName > bName) { return 1; } else if (aName < bName) { return -1; } else { return 0; } }) : IOptions[]
>this.options.sort : (compareFn?: (a: IOptions, b: IOptions) => number) => IOptions[]
>this.options : IOptions[]
>this : parser
>options : IOptions[]
>sort : (compareFn?: (a: IOptions, b: IOptions) => number) => IOptions[]
>function(a, b) {
var aName = a.name.toLowerCase();
var bName = b.name.toLowerCase();
if (aName > bName) {
return 1;
} else if (aName < bName) {
return -1;
} else {
return 0;
}
} : (a: IOptions, b: IOptions) => number
>function(a, b) { var aName = a.name.toLowerCase(); var bName = b.name.toLowerCase(); if (aName > bName) { return 1; } else if (aName < bName) { return -1; } else { return 0; } } : (a: IOptions, b: IOptions) => number
>a : IOptions
>b : IOptions

14
tests/baselines/reference/arrowFunctionExpressions.types
View File

@ -182,12 +182,7 @@ function outerFn() {
// Arrow function used in nested function in arrow function
var f = (n: string) => {
>f : (n: string) => () => string
>(n: string) => {
function fn(x: number) {
return () => n + x;
}
return fn(4);
} : (n: string) => () => string
>(n: string) => { function fn(x: number) { return () => n + x; } return fn(4);} : (n: string) => () => string
>n : string
function fn(x: number) {
@ -220,12 +215,7 @@ function someOuterFn() {
var arr = (n: string) => {
>arr : (n: string) => () => () => number
>(n: string) => {
function innerFn() {
return () => n.length;
}
return innerFn;
} : (n: string) => () => () => number
>(n: string) => { function innerFn() { return () => n.length; } return innerFn; } : (n: string) => () => () => number
>n : string
function innerFn() {

40
tests/baselines/reference/asiArith.types
View File

@ -9,30 +9,16 @@ var z =
>z : number
x
>x
+
+
+
y : number
>x+++y : number
>x : number
+
+
>+
+
y : number
>++y : number
+
>+
y : number
>+y : number
y
>y : number
@ -48,30 +34,16 @@ var c =
>c : number
x
>x
-
-
-
y : number
>x---y : number
>x : number
-
-
>-
-
y : number
>--y : number
-
>-
y : number
>-y : number
y
>y : number

6
tests/baselines/reference/asiInES6Classes.types
View File

@ -6,11 +6,7 @@ class Foo {
defaults = {
>defaults : { done: boolean; }
>{
done: false
} : { done: boolean; }
>{ done: false } : { done: boolean; }
done: false
>done : boolean

6
tests/baselines/reference/assignToPrototype1.types
View File

@ -9,15 +9,13 @@ declare class Point {
}
Point.prototype.add = function(dx, dy) {
>Point.prototype.add = function(dx, dy) {
} : (dx: number, dy: number) => void
>Point.prototype.add = function(dx, dy) {} : (dx: number, dy: number) => void
>Point.prototype.add : (dx: number, dy: number) => void
>Point.prototype : Point
>Point : typeof Point
>prototype : Point
>add : (dx: number, dy: number) => void
>function(dx, dy) {
} : (dx: number, dy: number) => void
>function(dx, dy) {} : (dx: number, dy: number) => void
>dx : number
>dy : number

170
tests/baselines/reference/assignmentCompatWithObjectMembers.js Normal file
View File

@ -0,0 +1,170 @@
//// [assignmentCompatWithObjectMembers.ts]
// members N and M of types S and T have the same name, same accessibility, same optionality, and N is assignable M
// no errors expected
module SimpleTypes {
class S { foo: string; }
class T { foo: string; }
var s: S;
var t: T;
interface S2 { foo: string; }
interface T2 { foo: string; }
var s2: S2;
var t2: T2;
var a: { foo: string; }
var b: { foo: string; }
var a2 = { foo: '' };
var b2 = { foo: '' };
s = t;
t = s;
s = s2;
s = a2;
s2 = t2;
t2 = s2;
s2 = t;
s2 = b;
s2 = a2;
a = b;
b = a;
a = s;
a = s2;
a = a2;
a2 = b2;
b2 = a2;
a2 = b;
a2 = t2;
a2 = t;
}
module ObjectTypes {
class S { foo: S; }
class T { foo: T; }
var s: S;
var t: T;
interface S2 { foo: S2; }
interface T2 { foo: T2; }
var s2: S2;
var t2: T2;
var a: { foo: typeof a; }
var b: { foo: typeof b; }
var a2 = { foo: a2 };
var b2 = { foo: b2 };
s = t;
t = s;
s = s2;
s = a2;
s2 = t2;
t2 = s2;
s2 = t;
s2 = b;
s2 = a2;
a = b;
b = a;
a = s;
a = s2;
a = a2;
a2 = b2;
b2 = a2;
a2 = b;
a2 = t2;
a2 = t;
}
//// [assignmentCompatWithObjectMembers.js]
// members N and M of types S and T have the same name, same accessibility, same optionality, and N is assignable M
// no errors expected
var SimpleTypes;
(function (SimpleTypes) {
var S = (function () {
function S() {
}
return S;
})();
var T = (function () {
function T() {
}
return T;
})();
var s;
var t;
var s2;
var t2;
var a;
var b;
var a2 = { foo: '' };
var b2 = { foo: '' };
s = t;
t = s;
s = s2;
s = a2;
s2 = t2;
t2 = s2;
s2 = t;
s2 = b;
s2 = a2;
a = b;
b = a;
a = s;
a = s2;
a = a2;
a2 = b2;
b2 = a2;
a2 = b;
a2 = t2;
a2 = t;
})(SimpleTypes || (SimpleTypes = {}));
var ObjectTypes;
(function (ObjectTypes) {
var S = (function () {
function S() {
}
return S;
})();
var T = (function () {
function T() {
}
return T;
})();
var s;
var t;
var s2;
var t2;
var a;
var b;
var a2 = { foo: a2 };
var b2 = { foo: b2 };
s = t;
t = s;
s = s2;
s = a2;
s2 = t2;
t2 = s2;
s2 = t;
s2 = b;
s2 = a2;
a = b;
b = a;
a = s;
a = s2;
a = a2;
a2 = b2;
b2 = a2;
a2 = b;
a2 = t2;
a2 = t;
})(ObjectTypes || (ObjectTypes = {}));

310
tests/baselines/reference/assignmentCompatWithObjectMembers.types Normal file
View File

@ -0,0 +1,310 @@
=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembers.ts ===
// members N and M of types S and T have the same name, same accessibility, same optionality, and N is assignable M
// no errors expected
module SimpleTypes {
>SimpleTypes : typeof SimpleTypes
class S { foo: string; }
>S : S
>foo : string
class T { foo: string; }
>T : T
>foo : string
var s: S;
>s : S
>S : S
var t: T;
>t : T
>T : T
interface S2 { foo: string; }
>S2 : S2
>foo : string
interface T2 { foo: string; }
>T2 : T2
>foo : string
var s2: S2;
>s2 : S2
>S2 : S2
var t2: T2;
>t2 : T2
>T2 : T2
var a: { foo: string; }
>a : { foo: string; }
>foo : string
var b: { foo: string; }
>b : { foo: string; }
>foo : string
var a2 = { foo: '' };
>a2 : { foo: string; }
>{ foo: '' } : { foo: string; }
>foo : string
var b2 = { foo: '' };
>b2 : { foo: string; }
>{ foo: '' } : { foo: string; }
>foo : string
s = t;
>s = t : T
>s : S
>t : T
t = s;
>t = s : S
>t : T
>s : S
s = s2;
>s = s2 : S2
>s : S
>s2 : S2
s = a2;
>s = a2 : { foo: string; }
>s : S
>a2 : { foo: string; }
s2 = t2;
>s2 = t2 : T2
>s2 : S2
>t2 : T2
t2 = s2;
>t2 = s2 : S2
>t2 : T2
>s2 : S2
s2 = t;
>s2 = t : T
>s2 : S2
>t : T
s2 = b;
>s2 = b : { foo: string; }
>s2 : S2
>b : { foo: string; }
s2 = a2;
>s2 = a2 : { foo: string; }
>s2 : S2
>a2 : { foo: string; }
a = b;
>a = b : { foo: string; }
>a : { foo: string; }
>b : { foo: string; }
b = a;
>b = a : { foo: string; }
>b : { foo: string; }
>a : { foo: string; }
a = s;
>a = s : S
>a : { foo: string; }
>s : S
a = s2;
>a = s2 : S2
>a : { foo: string; }
>s2 : S2
a = a2;
>a = a2 : { foo: string; }
>a : { foo: string; }
>a2 : { foo: string; }
a2 = b2;
>a2 = b2 : { foo: string; }
>a2 : { foo: string; }
>b2 : { foo: string; }
b2 = a2;
>b2 = a2 : { foo: string; }
>b2 : { foo: string; }
>a2 : { foo: string; }
a2 = b;
>a2 = b : { foo: string; }
>a2 : { foo: string; }
>b : { foo: string; }
a2 = t2;
>a2 = t2 : T2
>a2 : { foo: string; }
>t2 : T2
a2 = t;
>a2 = t : T
>a2 : { foo: string; }
>t : T
}
module ObjectTypes {
>ObjectTypes : typeof ObjectTypes
class S { foo: S; }
>S : S
>foo : S
>S : S
class T { foo: T; }
>T : T
>foo : T
>T : T
var s: S;
>s : S
>S : S
var t: T;
>t : T
>T : T
interface S2 { foo: S2; }
>S2 : S2
>foo : S2
>S2 : S2
interface T2 { foo: T2; }
>T2 : T2
>foo : T2
>T2 : T2
var s2: S2;
>s2 : S2
>S2 : S2
var t2: T2;
>t2 : T2
>T2 : T2
var a: { foo: typeof a; }
>a : { foo: any; }
>foo : { foo: any; }
>a : { foo: any; }
var b: { foo: typeof b; }
>b : { foo: any; }
>foo : { foo: any; }
>b : { foo: any; }
var a2 = { foo: a2 };
>a2 : any
>{ foo: a2 } : { foo: any; }
>foo : any
>a2 : any
var b2 = { foo: b2 };
>b2 : any
>{ foo: b2 } : { foo: any; }
>foo : any
>b2 : any
s = t;
>s = t : T
>s : S
>t : T
t = s;
>t = s : S
>t : T
>s : S
s = s2;
>s = s2 : S2
>s : S
>s2 : S2
s = a2;
>s = a2 : any
>s : S
>a2 : any
s2 = t2;
>s2 = t2 : T2
>s2 : S2
>t2 : T2
t2 = s2;
>t2 = s2 : S2
>t2 : T2
>s2 : S2
s2 = t;
>s2 = t : T
>s2 : S2
>t : T
s2 = b;
>s2 = b : { foo: any; }
>s2 : S2
>b : { foo: any; }
s2 = a2;
>s2 = a2 : any
>s2 : S2
>a2 : any
a = b;
>a = b : { foo: any; }
>a : { foo: any; }
>b : { foo: any; }
b = a;
>b = a : { foo: any; }
>b : { foo: any; }
>a : { foo: any; }
a = s;
>a = s : S
>a : { foo: any; }
>s : S
a = s2;
>a = s2 : S2
>a : { foo: any; }
>s2 : S2
a = a2;
>a = a2 : any
>a : { foo: any; }
>a2 : any
a2 = b2;
>a2 = b2 : any
>a2 : any
>b2 : any
b2 = a2;
>b2 = a2 : any
>b2 : any
>a2 : any
a2 = b;
>a2 = b : { foo: any; }
>a2 : any
>b : { foo: any; }
a2 = t2;
>a2 = t2 : T2
>a2 : any
>t2 : T2
a2 = t;
>a2 = t : T
>a2 : any
>t : T
}

6
tests/baselines/reference/assignmentCompatability1.types
View File

@ -31,11 +31,11 @@ module __test2__ {
>aa : {}
}
__test2__.__val__aa = __test1__.__val__obj4
>__test2__.__val__aa = __test1__.__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__test2__.__val__aa = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional<number, string>
>__test2__.__val__aa : {}
>__test2__ : typeof __test2__
>__val__aa : {}
>__test1__.__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional<number, string>
>__test1__ : typeof __test1__
>__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__val__obj4 : __test1__.interfaceWithPublicAndOptional<number, string>

6
tests/baselines/reference/assignmentCompatability2.types
View File

@ -30,11 +30,11 @@ module __test2__ {
>aa : {}
}
__test2__.__val__aa = __test1__.__val__obj4
>__test2__.__val__aa = __test1__.__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__test2__.__val__aa = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional<number, string>
>__test2__.__val__aa : {}
>__test2__ : typeof __test2__
>__val__aa : {}
>__test1__.__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional<number, string>
>__test1__ : typeof __test1__
>__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__val__obj4 : __test1__.interfaceWithPublicAndOptional<number, string>

6
tests/baselines/reference/assignmentCompatability3.types
View File

@ -32,11 +32,11 @@ module __test2__ {
>obj : { one: number; }
}
__test2__.__val__obj = __test1__.__val__obj4
>__test2__.__val__obj = __test1__.__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__test2__.__val__obj = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional<number, string>
>__test2__.__val__obj : { one: number; }
>__test2__ : typeof __test2__
>__val__obj : { one: number; }
>__test1__.__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional<number, string>
>__test1__ : typeof __test1__
>__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__val__obj4 : __test1__.interfaceWithPublicAndOptional<number, string>

6
tests/baselines/reference/assignmentCompatability4.types
View File

@ -31,11 +31,11 @@ module __test2__ {
>aa : { one: number; }
}
__test2__.__val__aa = __test1__.__val__obj4
>__test2__.__val__aa = __test1__.__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__test2__.__val__aa = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional<number, string>
>__test2__.__val__aa : { one: number; }
>__test2__ : typeof __test2__
>__val__aa : { one: number; }
>__test1__.__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional<number, string>
>__test1__ : typeof __test1__
>__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__val__obj4 : __test1__.interfaceWithPublicAndOptional<number, string>

10
tests/baselines/reference/assignmentCompatability5.types
View File

@ -37,11 +37,11 @@ module __test2__ {
>obj1 : interfaceOne<number>
}
__test2__.__val__obj1 = __test1__.__val__obj4
>__test2__.__val__obj1 = __test1__.__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__test2__.__val__obj1 : interfaceOne<number>
>__test2__.__val__obj1 = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional<number, string>
>__test2__.__val__obj1 : __test2__.interfaceOne<number>
>__test2__ : typeof __test2__
>__val__obj1 : interfaceOne<number>
>__test1__.__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__val__obj1 : __test2__.interfaceOne<number>
>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional<number, string>
>__test1__ : typeof __test1__
>__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__val__obj4 : __test1__.interfaceWithPublicAndOptional<number, string>

10
tests/baselines/reference/assignmentCompatability6.types
View File

@ -36,11 +36,11 @@ module __test2__ {
>obj3 : interfaceWithOptional<number>
}
__test2__.__val__obj3 = __test1__.__val__obj4
>__test2__.__val__obj3 = __test1__.__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__test2__.__val__obj3 : interfaceWithOptional<number>
>__test2__.__val__obj3 = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional<number, string>
>__test2__.__val__obj3 : __test2__.interfaceWithOptional<number>
>__test2__ : typeof __test2__
>__val__obj3 : interfaceWithOptional<number>
>__test1__.__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__val__obj3 : __test2__.interfaceWithOptional<number>
>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional<number, string>
>__test1__ : typeof __test1__
>__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__val__obj4 : __test1__.interfaceWithPublicAndOptional<number, string>

10
tests/baselines/reference/assignmentCompatability7.types
View File

@ -40,11 +40,11 @@ module __test2__ {
>obj4 : interfaceWithPublicAndOptional<number, string>
}
__test2__.__val__obj4 = __test1__.__val__obj4
>__test2__.__val__obj4 = __test1__.__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__test2__.__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__test2__.__val__obj4 = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional<number, string>
>__test2__.__val__obj4 : __test2__.interfaceWithPublicAndOptional<number, string>
>__test2__ : typeof __test2__
>__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__test1__.__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__val__obj4 : __test2__.interfaceWithPublicAndOptional<number, string>
>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional<number, string>
>__test1__ : typeof __test1__
>__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__val__obj4 : __test1__.interfaceWithPublicAndOptional<number, string>

10
tests/baselines/reference/assignmentCompatability8.types
View File

@ -36,11 +36,11 @@ module __test2__ {
>x1 : classWithPublic<number>
}
__test2__.__val__x1 = __test1__.__val__obj4
>__test2__.__val__x1 = __test1__.__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__test2__.__val__x1 : classWithPublic<number>
>__test2__.__val__x1 = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional<number, string>
>__test2__.__val__x1 : __test2__.classWithPublic<number>
>__test2__ : typeof __test2__
>__val__x1 : classWithPublic<number>
>__test1__.__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__val__x1 : __test2__.classWithPublic<number>
>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional<number, string>
>__test1__ : typeof __test1__
>__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__val__obj4 : __test1__.interfaceWithPublicAndOptional<number, string>

10
tests/baselines/reference/assignmentCompatability9.types
View File

@ -36,11 +36,11 @@ module __test2__ {
>x3 : classWithOptional<number>
}
__test2__.__val__x3 = __test1__.__val__obj4
>__test2__.__val__x3 = __test1__.__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__test2__.__val__x3 : classWithOptional<number>
>__test2__.__val__x3 = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional<number, string>
>__test2__.__val__x3 : __test2__.classWithOptional<number>
>__test2__ : typeof __test2__
>__val__x3 : classWithOptional<number>
>__test1__.__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__val__x3 : __test2__.classWithOptional<number>
>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional<number, string>
>__test1__ : typeof __test1__
>__val__obj4 : interfaceWithPublicAndOptional<number, string>
>__val__obj4 : __test1__.interfaceWithPublicAndOptional<number, string>

20
tests/baselines/reference/badThisBinding.types
View File

@ -12,26 +12,14 @@ class Greeter {
constructor() {
foo(() => {
>foo(() => {
bar(() => {
var x = this;
});
}) : any
>foo(() => { bar(() => { var x = this; }); }) : any
>foo : (a: any) => any
>() => {
bar(() => {
var x = this;
});
} : () => void
>() => { bar(() => { var x = this; }); } : () => void
bar(() => {
>bar(() => {
var x = this;
}) : any
>bar(() => { var x = this; }) : any
>bar : (a: any) => any
>() => {
var x = this;
} : () => void
>() => { var x = this; } : () => void
var x = this;
>x : Greeter

2
tests/baselines/reference/bestCommonTypeWithContextualTyping.types
View File

@ -38,7 +38,7 @@ var obj: { [s: string]: Contextual } = { s: e }; // { s: Ellement; [s: string]:
>Contextual : Contextual
>{ s: e } : { [x: string]: Ellement; s: Ellement; }
>s : Ellement
>e : e
>e : Ellement
var conditional: Contextual = null ? e : e; // Ellement
>conditional : Contextual

9
tests/baselines/reference/breakInIterationOrSwitchStatement1.js Normal file
View File

@ -0,0 +1,9 @@
//// [breakInIterationOrSwitchStatement1.ts]
while (true) {
break;
}
//// [breakInIterationOrSwitchStatement1.js]
while (true) {
break;
}

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

@ -0,0 +1,5 @@
=== tests/cases/compiler/breakInIterationOrSwitchStatement1.ts ===
while (true) {
No type information for this code. break;
No type information for this code.}
No type information for this code.

10
tests/baselines/reference/breakInIterationOrSwitchStatement2.js Normal file
View File

@ -0,0 +1,10 @@
//// [breakInIterationOrSwitchStatement2.ts]
do {
break;
}
while (true);
//// [breakInIterationOrSwitchStatement2.js]
do {
break;
} while (true);

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

@ -0,0 +1,6 @@
=== tests/cases/compiler/breakInIterationOrSwitchStatement2.ts ===
do {
No type information for this code. break;
No type information for this code.}
No type information for this code.while (true);
No type information for this code.

9
tests/baselines/reference/breakInIterationOrSwitchStatement3.js Normal file
View File

@ -0,0 +1,9 @@
//// [breakInIterationOrSwitchStatement3.ts]
for (;;) {
break;
}
//// [breakInIterationOrSwitchStatement3.js]
for (;;) {
break;
}

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

@ -0,0 +1,5 @@
=== tests/cases/compiler/breakInIterationOrSwitchStatement3.ts ===
for (;;) {
No type information for this code. break;
No type information for this code.}
No type information for this code.

6
tests/baselines/reference/breakInIterationOrSwitchStatement4.errors.txt Normal file
View File

@ -0,0 +1,6 @@
==== tests/cases/compiler/breakInIterationOrSwitchStatement4.ts (1 errors) ====
for (var i in something) {
~~~~~~~~~
!!! Cannot find name 'something'.
break;
}

9
tests/baselines/reference/breakInIterationOrSwitchStatement4.js Normal file
View File

@ -0,0 +1,9 @@
//// [breakInIterationOrSwitchStatement4.ts]
for (var i in something) {
break;
}
//// [breakInIterationOrSwitchStatement4.js]
for (var i in something) {
break;
}

4
tests/baselines/reference/breakNotInIterationOrSwitchStatement1.errors.txt Normal file
View File

@ -0,0 +1,4 @@
==== tests/cases/compiler/breakNotInIterationOrSwitchStatement1.ts (1 errors) ====
break;
~~~~~~
!!! A 'break' statement can only be used within an enclosing iteration or switch statement.

8
tests/baselines/reference/breakNotInIterationOrSwitchStatement2.errors.txt Normal file
View File

@ -0,0 +1,8 @@
==== tests/cases/compiler/breakNotInIterationOrSwitchStatement2.ts (1 errors) ====
while (true) {
function f() {
break;
~~~~~~
!!! Jump target cannot cross function boundary.
}
}

6
tests/baselines/reference/breakTarget1.js Normal file
View File

@ -0,0 +1,6 @@
//// [breakTarget1.ts]
target:
break target;
//// [breakTarget1.js]
target: break target;

4
tests/baselines/reference/breakTarget1.types Normal file
View File

@ -0,0 +1,4 @@
=== tests/cases/compiler/breakTarget1.ts ===
target:
No type information for this code. break target;
No type information for this code.

10
tests/baselines/reference/breakTarget2.js Normal file
View File

@ -0,0 +1,10 @@
//// [breakTarget2.ts]
target:
while (true) {
break target;
}
//// [breakTarget2.js]
target: while (true) {
break target;
}

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

@ -0,0 +1,6 @@
=== tests/cases/compiler/breakTarget2.ts ===
target:
No type information for this code.while (true) {
No type information for this code. break target;
No type information for this code.}
No type information for this code.

11
tests/baselines/reference/breakTarget3.js Normal file
View File

@ -0,0 +1,11 @@
//// [breakTarget3.ts]
target1:
target2:
while (true) {
break target1;
}
//// [breakTarget3.js]
target1: target2: while (true) {
break target1;
}

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

@ -0,0 +1,7 @@
=== tests/cases/compiler/breakTarget3.ts ===
target1:
No type information for this code.target2:
No type information for this code.while (true) {
No type information for this code. break target1;
No type information for this code.}
No type information for this code.

11
tests/baselines/reference/breakTarget4.js Normal file
View File

@ -0,0 +1,11 @@
//// [breakTarget4.ts]
target1:
target2:
while (true) {
break target2;
}
//// [breakTarget4.js]
target1: target2: while (true) {
break target2;
}

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

@ -0,0 +1,7 @@
=== tests/cases/compiler/breakTarget4.ts ===
target1:
No type information for this code.target2:
No type information for this code.while (true) {
No type information for this code. break target2;
No type information for this code.}
No type information for this code.

11
tests/baselines/reference/breakTarget5.errors.txt Normal file
View File

@ -0,0 +1,11 @@
==== tests/cases/compiler/breakTarget5.ts (1 errors) ====
target:
while (true) {
function f() {
while (true) {
break target;
~~~~~~~~~~~~~
!!! Jump target cannot cross function boundary.
}
}
}

6
tests/baselines/reference/breakTarget6.errors.txt Normal file
View File

@ -0,0 +1,6 @@
==== tests/cases/compiler/breakTarget6.ts (1 errors) ====
while (true) {
break target;
~~~~~~~~~~~~~
!!! A 'break' statement can only jump to a label of an enclosing statement.
}

2
tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.types
View File

@ -111,7 +111,7 @@ function foo8(x: number) {
return { x: x };
>{ x: x } : { x: number; }
>x : number
>x : x
>x : number
}
var r8 = foo8(1);
>r8 : { x: number; }

6
tests/baselines/reference/callSignaturesWithOptionalParameters.types
View File

@ -134,11 +134,7 @@ a.foo(1);
var b = {
>b : { foo: (x?: number) => void; a: (x: number, y?: number) => void; b: (x?: number) => void; }
>{
foo(x?: number) { },
a: function foo(x: number, y?: number) { },
b: (x?: number) => { }
} : { foo: (x?: number) => void; a: (x: number, y?: number) => void; b: (x?: number) => void; }
>{ foo(x?: number) { }, a: function foo(x: number, y?: number) { }, b: (x?: number) => { }} : { foo: (x?: number) => void; a: (x: number, y?: number) => void; b: (x?: number) => void; }
foo(x?: number) { },
>foo : (x?: number) => void

1
tests/baselines/reference/captureThisInSuperCall.types
View File

@ -12,6 +12,7 @@ class B extends A {
constructor() { super({ test: () => this.someMethod()}); }
>super({ test: () => this.someMethod()}) : void
>super : typeof A
>{ test: () => this.someMethod()} : { test: () => void; }
>test : () => void
>() => this.someMethod() : () => void

1
tests/baselines/reference/castExpressionParentheses.types
View File

@ -26,7 +26,6 @@ declare var a;
(<any>/regexp/g);
>(<any>/regexp/g) : any
><any>/regexp/g : any
>/regexp/g : RegExp
(<any>false);
>(<any>false) : any

31
tests/baselines/reference/castTest.types
View File

@ -63,31 +63,10 @@ declare class Point
var p_cast = <Point> ({
>p_cast : Point
><Point> ({
x: 0,
y: 0,
add: function(dx, dy) {
return new Point(this.x + dx, this.y + dy);
},
mult: function(p) { return p; }
}) : Point
><Point> ({ x: 0, y: 0, add: function(dx, dy) { return new Point(this.x + dx, this.y + dy); }, mult: function(p) { return p; }}) : Point
>Point : Point
>({
x: 0,
y: 0,
add: function(dx, dy) {
return new Point(this.x + dx, this.y + dy);
},
mult: function(p) { return p; }
}) : { x: number; y: number; add: (dx: any, dy: any) => Point; mult: (p: any) => any; }
>{
x: 0,
y: 0,
add: function(dx, dy) {
return new Point(this.x + dx, this.y + dy);
},
mult: function(p) { return p; }
} : { x: number; y: number; add: (dx: any, dy: any) => Point; mult: (p: any) => any; }
>({ x: 0, y: 0, add: function(dx, dy) { return new Point(this.x + dx, this.y + dy); }, mult: function(p) { return p; }}) : { x: number; y: number; add: (dx: any, dy: any) => Point; mult: (p: any) => any; }
>{ x: 0, y: 0, add: function(dx, dy) { return new Point(this.x + dx, this.y + dy); }, mult: function(p) { return p; }} : { x: number; y: number; add: (dx: any, dy: any) => Point; mult: (p: any) => any; }
x: 0,
>x : number
@ -97,9 +76,7 @@ var p_cast = <Point> ({
add: function(dx, dy) {
>add : (dx: any, dy: any) => Point
>function(dx, dy) {
return new Point(this.x + dx, this.y + dy);
} : (dx: any, dy: any) => Point
>function(dx, dy) { return new Point(this.x + dx, this.y + dy); } : (dx: any, dy: any) => Point
>dx : any
>dy : any

12
tests/baselines/reference/chainedImportAlias.types
View File

@ -1,17 +1,17 @@
=== tests/cases/compiler/chainedImportAlias_file1.ts ===
import x = require('chainedImportAlias_file0');
>x : typeof "tests/cases/compiler/chainedImportAlias_file0"
>x : typeof x
import y = x;
>y : typeof "tests/cases/compiler/chainedImportAlias_file0"
>x : typeof "tests/cases/compiler/chainedImportAlias_file0"
>y : typeof x
>x : typeof x
y.m.foo();
>y.m.foo() : void
>y.m.foo : () => void
>y.m : typeof m
>y : typeof "tests/cases/compiler/chainedImportAlias_file0"
>m : typeof m
>y.m : typeof x.m
>y : typeof x
>m : typeof x.m
>foo : () => void
=== tests/cases/compiler/chainedImportAlias_file0.ts ===

22
tests/baselines/reference/circularImportAlias.types
View File

@ -2,16 +2,16 @@
// expected no error
module B {
>B : typeof B
>B : typeof a.b
export import a = A;
>a : typeof A
>A : typeof A
>a : typeof a
>A : typeof a
export class D extends a.C {
>D : D
>a : a
>C : C
>a : unknown
>C : a.C
id: number;
>id : number
@ -19,15 +19,15 @@ module B {
}
module A {
>A : typeof A
>A : typeof b.a
export class C { name: string }
>C : C
>name : string
export import b = B;
>b : typeof B
>B : typeof B
>b : typeof b
>B : typeof b
}
var c: { name: string };
@ -36,12 +36,12 @@ var c: { name: string };
var c = new B.a.C();
>c : { name: string; }
>new B.a.C() : C
>B.a.C : typeof C
>new B.a.C() : A.C
>B.a.C : typeof A.C
>B.a : typeof A
>B : typeof B
>a : typeof A
>C : typeof C
>C : typeof A.C

2
tests/baselines/reference/classDeclarationMergedInModuleWithContinuation.types
View File

@ -18,7 +18,7 @@ module M {
export class O extends M.N {
>O : O
>M : M
>M : unknown
>N : N
}
}

2
tests/baselines/reference/classExtendingQualifiedName2.types
View File

@ -8,7 +8,7 @@ module M {
class D extends M.C {
>D : D
>M : M
>M : unknown
>C : C
}
}

10
tests/baselines/reference/classImplementsImportedInterface.types
View File

@ -1,6 +1,6 @@
=== tests/cases/compiler/classImplementsImportedInterface.ts ===
module M1 {
>M1 : M1
>M1 : unknown
export interface I {
>I : I
@ -14,13 +14,13 @@ module M2 {
>M2 : typeof M2
import T = M1.I;
>T : T
>M1 : M1
>I : I
>T : unknown
>M1 : unknown
>I : T
class C implements T {
>C : C
>T : I
>T : T
foo() {}
>foo : () => void

4
tests/baselines/reference/classMemberInitializerWithLamdaScoping5.types
View File

@ -17,9 +17,7 @@ class Greeter {
messageHandler = (message: string) => {
>messageHandler : (message: string) => void
>(message: string) => {
console.log(message); // This shouldnt be error
} : (message: string) => void
>(message: string) => { console.log(message); // This shouldnt be error } : (message: string) => void
>message : string
console.log(message); // This shouldnt be error

1
tests/baselines/reference/classSideInheritance2.types
View File

@ -21,6 +21,7 @@ class SubText extends TextBase {
super();
>super() : void
>super : typeof TextBase
}
}

6
tests/baselines/reference/cloduleAcrossModuleDefinitions.types
View File

@ -25,7 +25,7 @@ module A {
}
var b: A.B; // ok
>b : B
>A : A
>B : B
>b : A.B
>A : unknown
>B : A.B

2
tests/baselines/reference/cloduleAndTypeParameters.types
View File

@ -3,7 +3,7 @@ class Foo<T extends Foo.Bar> {
>Foo : Foo<T>
>T : T
>Foo : Foo<T>
>Bar : Bar
>Bar : Foo.Bar
constructor() {
}

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