mirror of
https://github.com/microsoft/TypeScript.git
synced 2025-11-18 17:21:48 +00:00
Include symbol information in the typewriter baselines.
This commit is contained in:
Cyrus Najmabadi
+26
-19
@@ -1,6 +1,5 @@
|
||||
interface TypeWriterResult {
|
||||
line: number;
|
||||
column: number;
|
||||
syntaxKind: number;
|
||||
sourceText: string;
|
||||
type: string;
|
||||
@@ -30,34 +29,42 @@ class TypeWriterWalker {
|
||||
|
||||
private visitNode(node: ts.Node): void {
|
||||
if (ts.isExpression(node) || node.kind === ts.SyntaxKind.Identifier) {
|
||||
this.log(node, this.getTypeOfNode(node));
|
||||
this.logTypeAndSymbol(node);
|
||||
}
|
||||
|
||||
ts.forEachChild(node, child => this.visitNode(child));
|
||||
}
|
||||
|
||||
private log(node: ts.Node, type: ts.Type): void {
|
||||
private logTypeAndSymbol(node: ts.Node): void {
|
||||
var actualPos = ts.skipTrivia(this.currentSourceFile.text, node.pos);
|
||||
var lineAndCharacter = this.currentSourceFile.getLineAndCharacterOfPosition(actualPos);
|
||||
var sourceText = ts.getTextOfNodeFromSourceText(this.currentSourceFile.text, node);
|
||||
|
||||
// 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
|
||||
// baseline comparisons easier. In the long term, we will want to just call typeToString
|
||||
this.results.push({
|
||||
line: lineAndCharacter.line,
|
||||
// todo(cyrusn): Not sure why column is one-based for type-writer. But I'm preserving
|
||||
// that behavior to prevent having a lot of baselines to fix up.
|
||||
column: lineAndCharacter.character + 1,
|
||||
syntaxKind: node.kind,
|
||||
sourceText: sourceText,
|
||||
type: this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.WriteOwnNameForAnyLike)
|
||||
});
|
||||
}
|
||||
|
||||
private getTypeOfNode(node: ts.Node): ts.Type {
|
||||
var type = this.checker.getTypeAtLocation(node);
|
||||
ts.Debug.assert(type !== undefined, "type doesn't exist");
|
||||
return type;
|
||||
var symbol = this.checker.getSymbolAtLocation(node);
|
||||
|
||||
var typeString = this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.NoTruncation);
|
||||
if (symbol) {
|
||||
var symbolString = "Symbol(" + this.checker.symbolToString(symbol, node.parent);
|
||||
if (symbol.declarations) {
|
||||
for (let declaration of symbol.declarations) {
|
||||
symbolString += ",";
|
||||
let declSourceFile = declaration.getSourceFile();
|
||||
let declLineAndCharacter = declSourceFile.getLineAndCharacterOfPosition(declaration.pos);
|
||||
symbolString += `Decl(${ ts.getBaseFileName(declSourceFile.fileName) },${ declLineAndCharacter.line },${ declLineAndCharacter.character })`
|
||||
}
|
||||
}
|
||||
symbolString += ")";
|
||||
|
||||
typeString += ", " + symbolString;
|
||||
}
|
||||
|
||||
this.results.push({
|
||||
line: lineAndCharacter.line,
|
||||
syntaxKind: node.kind,
|
||||
sourceText: sourceText,
|
||||
type: typeString
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,40 +1,40 @@
|
||||
=== tests/cases/compiler/2dArrays.ts ===
|
||||
class Cell {
|
||||
>Cell : Cell
|
||||
>Cell : Cell, Symbol(Cell,Decl(2dArrays.ts,0,0))
|
||||
}
|
||||
|
||||
class Ship {
|
||||
>Ship : Ship
|
||||
>Ship : Ship, Symbol(Ship,Decl(2dArrays.ts,1,1))
|
||||
|
||||
isSunk: boolean;
|
||||
>isSunk : boolean
|
||||
>isSunk : boolean, Symbol(isSunk,Decl(2dArrays.ts,3,12))
|
||||
}
|
||||
|
||||
class Board {
|
||||
>Board : Board
|
||||
>Board : Board, Symbol(Board,Decl(2dArrays.ts,5,1))
|
||||
|
||||
ships: Ship[];
|
||||
>ships : Ship[]
|
||||
>Ship : Ship
|
||||
>ships : Ship[], Symbol(ships,Decl(2dArrays.ts,7,13))
|
||||
>Ship : Ship, Symbol(Ship,Decl(2dArrays.ts,1,1))
|
||||
|
||||
cells: Cell[];
|
||||
>cells : Cell[]
|
||||
>Cell : Cell
|
||||
>cells : Cell[], Symbol(cells,Decl(2dArrays.ts,8,18))
|
||||
>Cell : Cell, Symbol(Cell,Decl(2dArrays.ts,0,0))
|
||||
|
||||
private allShipsSunk() {
|
||||
>allShipsSunk : () => boolean
|
||||
>allShipsSunk : () => boolean, Symbol(allShipsSunk,Decl(2dArrays.ts,9,18))
|
||||
|
||||
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
|
||||
>this.ships.every : (callbackfn: (value: Ship, index: number, array: Ship[]) => boolean, thisArg?: any) => boolean, Symbol(Array.every,Decl(lib.d.ts,1094,62))
|
||||
>this.ships : Ship[], Symbol(ships,Decl(2dArrays.ts,7,13))
|
||||
>this : Board, Symbol(Board,Decl(2dArrays.ts,5,1))
|
||||
>ships : Ship[], Symbol(ships,Decl(2dArrays.ts,7,13))
|
||||
>every : (callbackfn: (value: Ship, index: number, array: Ship[]) => boolean, thisArg?: any) => boolean, Symbol(Array.every,Decl(lib.d.ts,1094,62))
|
||||
>function (val) { return val.isSunk; } : (val: Ship) => boolean
|
||||
>val : Ship
|
||||
>val.isSunk : boolean
|
||||
>val : Ship
|
||||
>isSunk : boolean
|
||||
>val : Ship, Symbol(val,Decl(2dArrays.ts,12,42))
|
||||
>val.isSunk : boolean, Symbol(Ship.isSunk,Decl(2dArrays.ts,3,12))
|
||||
>val : Ship, Symbol(val,Decl(2dArrays.ts,12,42))
|
||||
>isSunk : boolean, Symbol(Ship.isSunk,Decl(2dArrays.ts,3,12))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -7,162 +7,162 @@
|
||||
*/
|
||||
|
||||
declare var process: any;
|
||||
>process : any
|
||||
>process : any, Symbol(process,Decl(APISample_compile.ts,7,11))
|
||||
|
||||
declare var console: any;
|
||||
>console : any
|
||||
>console : any, Symbol(console,Decl(APISample_compile.ts,8,11))
|
||||
|
||||
declare var os: any;
|
||||
>os : any
|
||||
>os : any, Symbol(os,Decl(APISample_compile.ts,9,11))
|
||||
|
||||
import ts = require("typescript");
|
||||
>ts : typeof ts
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_compile.ts,9,20))
|
||||
|
||||
export function compile(fileNames: string[], options: ts.CompilerOptions): void {
|
||||
>compile : (fileNames: string[], options: ts.CompilerOptions) => void
|
||||
>fileNames : string[]
|
||||
>options : ts.CompilerOptions
|
||||
>ts : unknown
|
||||
>CompilerOptions : ts.CompilerOptions
|
||||
>compile : (fileNames: string[], options: ts.CompilerOptions) => void, Symbol(compile,Decl(APISample_compile.ts,11,34))
|
||||
>fileNames : string[], Symbol(fileNames,Decl(APISample_compile.ts,13,24))
|
||||
>options : ts.CompilerOptions, Symbol(options,Decl(APISample_compile.ts,13,44))
|
||||
>ts : any, Symbol(ts,Decl(APISample_compile.ts,9,20))
|
||||
>CompilerOptions : ts.CompilerOptions, Symbol(ts.CompilerOptions,Decl(typescript.d.ts,1074,5))
|
||||
|
||||
var program = ts.createProgram(fileNames, options);
|
||||
>program : ts.Program
|
||||
>program : ts.Program, Symbol(program,Decl(APISample_compile.ts,14,7))
|
||||
>ts.createProgram(fileNames, options) : ts.Program
|
||||
>ts.createProgram : (rootNames: string[], options: ts.CompilerOptions, host?: ts.CompilerHost) => ts.Program
|
||||
>ts : typeof ts
|
||||
>createProgram : (rootNames: string[], options: ts.CompilerOptions, host?: ts.CompilerHost) => ts.Program
|
||||
>fileNames : string[]
|
||||
>options : ts.CompilerOptions
|
||||
>ts.createProgram : (rootNames: string[], options: ts.CompilerOptions, host?: ts.CompilerHost) => ts.Program, Symbol(ts.createProgram,Decl(typescript.d.ts,1201,113))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_compile.ts,9,20))
|
||||
>createProgram : (rootNames: string[], options: ts.CompilerOptions, host?: ts.CompilerHost) => ts.Program, Symbol(ts.createProgram,Decl(typescript.d.ts,1201,113))
|
||||
>fileNames : string[], Symbol(fileNames,Decl(APISample_compile.ts,13,24))
|
||||
>options : ts.CompilerOptions, Symbol(options,Decl(APISample_compile.ts,13,44))
|
||||
|
||||
var emitResult = program.emit();
|
||||
>emitResult : ts.EmitResult
|
||||
>emitResult : ts.EmitResult, Symbol(emitResult,Decl(APISample_compile.ts,15,7))
|
||||
>program.emit() : ts.EmitResult
|
||||
>program.emit : (targetSourceFile?: ts.SourceFile, writeFile?: ts.WriteFileCallback) => ts.EmitResult
|
||||
>program : ts.Program
|
||||
>emit : (targetSourceFile?: ts.SourceFile, writeFile?: ts.WriteFileCallback) => ts.EmitResult
|
||||
>program.emit : (targetSourceFile?: ts.SourceFile, writeFile?: ts.WriteFileCallback) => ts.EmitResult, Symbol(ts.Program.emit,Decl(typescript.d.ts,767,39))
|
||||
>program : ts.Program, Symbol(program,Decl(APISample_compile.ts,14,7))
|
||||
>emit : (targetSourceFile?: ts.SourceFile, writeFile?: ts.WriteFileCallback) => ts.EmitResult, Symbol(ts.Program.emit,Decl(typescript.d.ts,767,39))
|
||||
|
||||
var allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
|
||||
>allDiagnostics : ts.Diagnostic[]
|
||||
>allDiagnostics : ts.Diagnostic[], Symbol(allDiagnostics,Decl(APISample_compile.ts,17,7))
|
||||
>ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics) : ts.Diagnostic[]
|
||||
>ts.getPreEmitDiagnostics(program).concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }
|
||||
>ts.getPreEmitDiagnostics(program).concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }, Symbol(Array.concat,Decl(lib.d.ts,1025,13),Decl(lib.d.ts,1030,46))
|
||||
>ts.getPreEmitDiagnostics(program) : ts.Diagnostic[]
|
||||
>ts.getPreEmitDiagnostics : (program: ts.Program) => ts.Diagnostic[]
|
||||
>ts : typeof ts
|
||||
>getPreEmitDiagnostics : (program: ts.Program) => ts.Diagnostic[]
|
||||
>program : ts.Program
|
||||
>concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }
|
||||
>emitResult.diagnostics : ts.Diagnostic[]
|
||||
>emitResult : ts.EmitResult
|
||||
>diagnostics : ts.Diagnostic[]
|
||||
>ts.getPreEmitDiagnostics : (program: ts.Program) => ts.Diagnostic[], Symbol(ts.getPreEmitDiagnostics,Decl(typescript.d.ts,1199,98))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_compile.ts,9,20))
|
||||
>getPreEmitDiagnostics : (program: ts.Program) => ts.Diagnostic[], Symbol(ts.getPreEmitDiagnostics,Decl(typescript.d.ts,1199,98))
|
||||
>program : ts.Program, Symbol(program,Decl(APISample_compile.ts,14,7))
|
||||
>concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }, Symbol(Array.concat,Decl(lib.d.ts,1025,13),Decl(lib.d.ts,1030,46))
|
||||
>emitResult.diagnostics : ts.Diagnostic[], Symbol(ts.EmitResult.diagnostics,Decl(typescript.d.ts,820,29))
|
||||
>emitResult : ts.EmitResult, Symbol(emitResult,Decl(APISample_compile.ts,15,7))
|
||||
>diagnostics : ts.Diagnostic[], Symbol(ts.EmitResult.diagnostics,Decl(typescript.d.ts,820,29))
|
||||
|
||||
allDiagnostics.forEach(diagnostic => {
|
||||
>allDiagnostics.forEach(diagnostic => { var { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start); var message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n'); console.log(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`); }) : void
|
||||
>allDiagnostics.forEach : (callbackfn: (value: ts.Diagnostic, index: number, array: ts.Diagnostic[]) => void, thisArg?: any) => void
|
||||
>allDiagnostics : ts.Diagnostic[]
|
||||
>forEach : (callbackfn: (value: ts.Diagnostic, index: number, array: ts.Diagnostic[]) => void, thisArg?: any) => void
|
||||
>allDiagnostics.forEach : (callbackfn: (value: ts.Diagnostic, index: number, array: ts.Diagnostic[]) => void, thisArg?: any) => void, Symbol(Array.forEach,Decl(lib.d.ts,1108,95))
|
||||
>allDiagnostics : ts.Diagnostic[], Symbol(allDiagnostics,Decl(APISample_compile.ts,17,7))
|
||||
>forEach : (callbackfn: (value: ts.Diagnostic, index: number, array: ts.Diagnostic[]) => void, thisArg?: any) => void, Symbol(Array.forEach,Decl(lib.d.ts,1108,95))
|
||||
>diagnostic => { var { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start); var message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n'); console.log(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`); } : (diagnostic: ts.Diagnostic) => void
|
||||
>diagnostic : ts.Diagnostic
|
||||
>diagnostic : ts.Diagnostic, Symbol(diagnostic,Decl(APISample_compile.ts,19,27))
|
||||
|
||||
var { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
|
||||
>line : number
|
||||
>character : number
|
||||
>line : number, Symbol(line,Decl(APISample_compile.ts,20,13))
|
||||
>character : number, Symbol(character,Decl(APISample_compile.ts,20,19))
|
||||
>diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start) : ts.LineAndCharacter
|
||||
>diagnostic.file.getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter
|
||||
>diagnostic.file : ts.SourceFile
|
||||
>diagnostic : ts.Diagnostic
|
||||
>file : ts.SourceFile
|
||||
>getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter
|
||||
>diagnostic.start : number
|
||||
>diagnostic : ts.Diagnostic
|
||||
>start : number
|
||||
>diagnostic.file.getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter, Symbol(ts.SourceFile.getLineAndCharacterOfPosition,Decl(typescript.d.ts,1263,46))
|
||||
>diagnostic.file : ts.SourceFile, Symbol(ts.Diagnostic.file,Decl(typescript.d.ts,1062,26))
|
||||
>diagnostic : ts.Diagnostic, Symbol(diagnostic,Decl(APISample_compile.ts,19,27))
|
||||
>file : ts.SourceFile, Symbol(ts.Diagnostic.file,Decl(typescript.d.ts,1062,26))
|
||||
>getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter, Symbol(ts.SourceFile.getLineAndCharacterOfPosition,Decl(typescript.d.ts,1263,46))
|
||||
>diagnostic.start : number, Symbol(ts.Diagnostic.start,Decl(typescript.d.ts,1063,25))
|
||||
>diagnostic : ts.Diagnostic, Symbol(diagnostic,Decl(APISample_compile.ts,19,27))
|
||||
>start : number, Symbol(ts.Diagnostic.start,Decl(typescript.d.ts,1063,25))
|
||||
|
||||
var message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
|
||||
>message : string
|
||||
>message : string, Symbol(message,Decl(APISample_compile.ts,21,11))
|
||||
>ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n') : string
|
||||
>ts.flattenDiagnosticMessageText : (messageText: string | ts.DiagnosticMessageChain, newLine: string) => string
|
||||
>ts : typeof ts
|
||||
>flattenDiagnosticMessageText : (messageText: string | ts.DiagnosticMessageChain, newLine: string) => string
|
||||
>diagnostic.messageText : string | ts.DiagnosticMessageChain
|
||||
>diagnostic : ts.Diagnostic
|
||||
>messageText : string | ts.DiagnosticMessageChain
|
||||
>ts.flattenDiagnosticMessageText : (messageText: string | ts.DiagnosticMessageChain, newLine: string) => string, Symbol(ts.flattenDiagnosticMessageText,Decl(typescript.d.ts,1200,67))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_compile.ts,9,20))
|
||||
>flattenDiagnosticMessageText : (messageText: string | ts.DiagnosticMessageChain, newLine: string) => string, Symbol(ts.flattenDiagnosticMessageText,Decl(typescript.d.ts,1200,67))
|
||||
>diagnostic.messageText : string | ts.DiagnosticMessageChain, Symbol(ts.Diagnostic.messageText,Decl(typescript.d.ts,1065,23))
|
||||
>diagnostic : ts.Diagnostic, Symbol(diagnostic,Decl(APISample_compile.ts,19,27))
|
||||
>messageText : string | ts.DiagnosticMessageChain, Symbol(ts.Diagnostic.messageText,Decl(typescript.d.ts,1065,23))
|
||||
>'\n' : string
|
||||
|
||||
console.log(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
|
||||
>console.log(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`) : any
|
||||
>console.log : any
|
||||
>console : any
|
||||
>console : any, Symbol(console,Decl(APISample_compile.ts,8,11))
|
||||
>log : any
|
||||
>`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}` : string
|
||||
>diagnostic.file.fileName : string
|
||||
>diagnostic.file : ts.SourceFile
|
||||
>diagnostic : ts.Diagnostic
|
||||
>file : ts.SourceFile
|
||||
>fileName : string
|
||||
>diagnostic.file.fileName : string, Symbol(ts.SourceFile.fileName,Decl(typescript.d.ts,743,29))
|
||||
>diagnostic.file : ts.SourceFile, Symbol(ts.Diagnostic.file,Decl(typescript.d.ts,1062,26))
|
||||
>diagnostic : ts.Diagnostic, Symbol(diagnostic,Decl(APISample_compile.ts,19,27))
|
||||
>file : ts.SourceFile, Symbol(ts.Diagnostic.file,Decl(typescript.d.ts,1062,26))
|
||||
>fileName : string, Symbol(ts.SourceFile.fileName,Decl(typescript.d.ts,743,29))
|
||||
>line + 1 : number
|
||||
>line : number
|
||||
>line : number, Symbol(line,Decl(APISample_compile.ts,20,13))
|
||||
>1 : number
|
||||
>character + 1 : number
|
||||
>character : number
|
||||
>character : number, Symbol(character,Decl(APISample_compile.ts,20,19))
|
||||
>1 : number
|
||||
>message : string
|
||||
>message : string, Symbol(message,Decl(APISample_compile.ts,21,11))
|
||||
|
||||
});
|
||||
|
||||
var exitCode = emitResult.emitSkipped ? 1 : 0;
|
||||
>exitCode : number
|
||||
>exitCode : number, Symbol(exitCode,Decl(APISample_compile.ts,25,7))
|
||||
>emitResult.emitSkipped ? 1 : 0 : number
|
||||
>emitResult.emitSkipped : boolean
|
||||
>emitResult : ts.EmitResult
|
||||
>emitSkipped : boolean
|
||||
>emitResult.emitSkipped : boolean, Symbol(ts.EmitResult.emitSkipped,Decl(typescript.d.ts,819,26))
|
||||
>emitResult : ts.EmitResult, Symbol(emitResult,Decl(APISample_compile.ts,15,7))
|
||||
>emitSkipped : boolean, Symbol(ts.EmitResult.emitSkipped,Decl(typescript.d.ts,819,26))
|
||||
>1 : number
|
||||
>0 : number
|
||||
|
||||
console.log(`Process exiting with code '${exitCode}'.`);
|
||||
>console.log(`Process exiting with code '${exitCode}'.`) : any
|
||||
>console.log : any
|
||||
>console : any
|
||||
>console : any, Symbol(console,Decl(APISample_compile.ts,8,11))
|
||||
>log : any
|
||||
>`Process exiting with code '${exitCode}'.` : string
|
||||
>exitCode : number
|
||||
>exitCode : number, Symbol(exitCode,Decl(APISample_compile.ts,25,7))
|
||||
|
||||
process.exit(exitCode);
|
||||
>process.exit(exitCode) : any
|
||||
>process.exit : any
|
||||
>process : any
|
||||
>process : any, Symbol(process,Decl(APISample_compile.ts,7,11))
|
||||
>exit : any
|
||||
>exitCode : number
|
||||
>exitCode : number, Symbol(exitCode,Decl(APISample_compile.ts,25,7))
|
||||
}
|
||||
|
||||
compile(process.argv.slice(2), {
|
||||
>compile(process.argv.slice(2), { noEmitOnError: true, noImplicitAny: true, target: ts.ScriptTarget.ES5, module: ts.ModuleKind.CommonJS}) : void
|
||||
>compile : (fileNames: string[], options: ts.CompilerOptions) => void
|
||||
>compile : (fileNames: string[], options: ts.CompilerOptions) => void, Symbol(compile,Decl(APISample_compile.ts,11,34))
|
||||
>process.argv.slice(2) : any
|
||||
>process.argv.slice : any
|
||||
>process.argv : any
|
||||
>process : any
|
||||
>process : any, Symbol(process,Decl(APISample_compile.ts,7,11))
|
||||
>argv : any
|
||||
>slice : any
|
||||
>2 : number
|
||||
>{ noEmitOnError: true, noImplicitAny: true, target: ts.ScriptTarget.ES5, module: ts.ModuleKind.CommonJS} : { [x: string]: boolean | ts.ScriptTarget | ts.ModuleKind; noEmitOnError: boolean; noImplicitAny: boolean; target: ts.ScriptTarget; module: ts.ModuleKind; }
|
||||
|
||||
noEmitOnError: true, noImplicitAny: true,
|
||||
>noEmitOnError : boolean
|
||||
>noEmitOnError : boolean, Symbol(noEmitOnError,Decl(APISample_compile.ts,30,32))
|
||||
>true : boolean
|
||||
>noImplicitAny : boolean
|
||||
>noImplicitAny : boolean, Symbol(noImplicitAny,Decl(APISample_compile.ts,31,24))
|
||||
>true : boolean
|
||||
|
||||
target: ts.ScriptTarget.ES5, module: ts.ModuleKind.CommonJS
|
||||
>target : ts.ScriptTarget
|
||||
>ts.ScriptTarget.ES5 : ts.ScriptTarget
|
||||
>ts.ScriptTarget : typeof ts.ScriptTarget
|
||||
>ts : typeof ts
|
||||
>ScriptTarget : typeof ts.ScriptTarget
|
||||
>ES5 : ts.ScriptTarget
|
||||
>module : ts.ModuleKind
|
||||
>ts.ModuleKind.CommonJS : ts.ModuleKind
|
||||
>ts.ModuleKind : typeof ts.ModuleKind
|
||||
>ts : typeof ts
|
||||
>ModuleKind : typeof ts.ModuleKind
|
||||
>CommonJS : ts.ModuleKind
|
||||
>target : ts.ScriptTarget, Symbol(target,Decl(APISample_compile.ts,31,45))
|
||||
>ts.ScriptTarget.ES5 : ts.ScriptTarget, Symbol(ts.ScriptTarget.ES5,Decl(typescript.d.ts,1117,16))
|
||||
>ts.ScriptTarget : typeof ts.ScriptTarget, Symbol(ts.ScriptTarget,Decl(typescript.d.ts,1115,5))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_compile.ts,9,20))
|
||||
>ScriptTarget : typeof ts.ScriptTarget, Symbol(ts.ScriptTarget,Decl(typescript.d.ts,1115,5))
|
||||
>ES5 : ts.ScriptTarget, Symbol(ts.ScriptTarget.ES5,Decl(typescript.d.ts,1117,16))
|
||||
>module : ts.ModuleKind, Symbol(module,Decl(APISample_compile.ts,32,32))
|
||||
>ts.ModuleKind.CommonJS : ts.ModuleKind, Symbol(ts.ModuleKind.CommonJS,Decl(typescript.d.ts,1108,17))
|
||||
>ts.ModuleKind : typeof ts.ModuleKind, Symbol(ts.ModuleKind,Decl(typescript.d.ts,1106,5))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_compile.ts,9,20))
|
||||
>ModuleKind : typeof ts.ModuleKind, Symbol(ts.ModuleKind,Decl(typescript.d.ts,1106,5))
|
||||
>CommonJS : ts.ModuleKind, Symbol(ts.ModuleKind.CommonJS,Decl(typescript.d.ts,1108,17))
|
||||
|
||||
});
|
||||
|
||||
@@ -7,211 +7,211 @@
|
||||
*/
|
||||
|
||||
declare var process: any;
|
||||
>process : any
|
||||
>process : any, Symbol(process,Decl(APISample_linter.ts,7,11))
|
||||
|
||||
declare var console: any;
|
||||
>console : any
|
||||
>console : any, Symbol(console,Decl(APISample_linter.ts,8,11))
|
||||
|
||||
declare var readFileSync: any;
|
||||
>readFileSync : any
|
||||
>readFileSync : any, Symbol(readFileSync,Decl(APISample_linter.ts,9,11))
|
||||
|
||||
import * as ts from "typescript";
|
||||
>ts : typeof ts
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_linter.ts,11,6))
|
||||
|
||||
export function delint(sourceFile: ts.SourceFile) {
|
||||
>delint : (sourceFile: ts.SourceFile) => void
|
||||
>sourceFile : ts.SourceFile
|
||||
>ts : unknown
|
||||
>SourceFile : ts.SourceFile
|
||||
>delint : (sourceFile: ts.SourceFile) => void, Symbol(delint,Decl(APISample_linter.ts,11,33))
|
||||
>sourceFile : ts.SourceFile, Symbol(sourceFile,Decl(APISample_linter.ts,13,23))
|
||||
>ts : any, Symbol(ts,Decl(APISample_linter.ts,11,6))
|
||||
>SourceFile : ts.SourceFile, Symbol(ts.SourceFile,Decl(typescript.d.ts,740,5),Decl(typescript.d.ts,1261,5))
|
||||
|
||||
delintNode(sourceFile);
|
||||
>delintNode(sourceFile) : void
|
||||
>delintNode : (node: ts.Node) => void
|
||||
>sourceFile : ts.SourceFile
|
||||
>delintNode : (node: ts.Node) => void, Symbol(delintNode,Decl(APISample_linter.ts,14,27))
|
||||
>sourceFile : ts.SourceFile, Symbol(sourceFile,Decl(APISample_linter.ts,13,23))
|
||||
|
||||
function delintNode(node: ts.Node) {
|
||||
>delintNode : (node: ts.Node) => void
|
||||
>node : ts.Node
|
||||
>ts : unknown
|
||||
>Node : ts.Node
|
||||
>delintNode : (node: ts.Node) => void, Symbol(delintNode,Decl(APISample_linter.ts,14,27))
|
||||
>node : ts.Node, Symbol(node,Decl(APISample_linter.ts,16,24))
|
||||
>ts : any, Symbol(ts,Decl(APISample_linter.ts,11,6))
|
||||
>Node : ts.Node, Symbol(ts.Node,Decl(typescript.d.ts,296,5),Decl(typescript.d.ts,1221,32))
|
||||
|
||||
switch (node.kind) {
|
||||
>node.kind : ts.SyntaxKind
|
||||
>node : ts.Node
|
||||
>kind : ts.SyntaxKind
|
||||
>node.kind : ts.SyntaxKind, Symbol(ts.Node.kind,Decl(typescript.d.ts,297,38))
|
||||
>node : ts.Node, Symbol(node,Decl(APISample_linter.ts,16,24))
|
||||
>kind : ts.SyntaxKind, Symbol(ts.Node.kind,Decl(typescript.d.ts,297,38))
|
||||
|
||||
case ts.SyntaxKind.ForStatement:
|
||||
>ts.SyntaxKind.ForStatement : ts.SyntaxKind
|
||||
>ts.SyntaxKind : typeof ts.SyntaxKind
|
||||
>ts : typeof ts
|
||||
>SyntaxKind : typeof ts.SyntaxKind
|
||||
>ForStatement : ts.SyntaxKind
|
||||
>ts.SyntaxKind.ForStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.ForStatement,Decl(typescript.d.ts,209,29))
|
||||
>ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind,Decl(typescript.d.ts,22,5))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_linter.ts,11,6))
|
||||
>SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind,Decl(typescript.d.ts,22,5))
|
||||
>ForStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.ForStatement,Decl(typescript.d.ts,209,29))
|
||||
|
||||
case ts.SyntaxKind.ForInStatement:
|
||||
>ts.SyntaxKind.ForInStatement : ts.SyntaxKind
|
||||
>ts.SyntaxKind : typeof ts.SyntaxKind
|
||||
>ts : typeof ts
|
||||
>SyntaxKind : typeof ts.SyntaxKind
|
||||
>ForInStatement : ts.SyntaxKind
|
||||
>ts.SyntaxKind.ForInStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.ForInStatement,Decl(typescript.d.ts,210,27))
|
||||
>ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind,Decl(typescript.d.ts,22,5))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_linter.ts,11,6))
|
||||
>SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind,Decl(typescript.d.ts,22,5))
|
||||
>ForInStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.ForInStatement,Decl(typescript.d.ts,210,27))
|
||||
|
||||
case ts.SyntaxKind.WhileStatement:
|
||||
>ts.SyntaxKind.WhileStatement : ts.SyntaxKind
|
||||
>ts.SyntaxKind : typeof ts.SyntaxKind
|
||||
>ts : typeof ts
|
||||
>SyntaxKind : typeof ts.SyntaxKind
|
||||
>WhileStatement : ts.SyntaxKind
|
||||
>ts.SyntaxKind.WhileStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.WhileStatement,Decl(typescript.d.ts,208,26))
|
||||
>ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind,Decl(typescript.d.ts,22,5))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_linter.ts,11,6))
|
||||
>SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind,Decl(typescript.d.ts,22,5))
|
||||
>WhileStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.WhileStatement,Decl(typescript.d.ts,208,26))
|
||||
|
||||
case ts.SyntaxKind.DoStatement:
|
||||
>ts.SyntaxKind.DoStatement : ts.SyntaxKind
|
||||
>ts.SyntaxKind : typeof ts.SyntaxKind
|
||||
>ts : typeof ts
|
||||
>SyntaxKind : typeof ts.SyntaxKind
|
||||
>DoStatement : ts.SyntaxKind
|
||||
>ts.SyntaxKind.DoStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.DoStatement,Decl(typescript.d.ts,207,26))
|
||||
>ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind,Decl(typescript.d.ts,22,5))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_linter.ts,11,6))
|
||||
>SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind,Decl(typescript.d.ts,22,5))
|
||||
>DoStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.DoStatement,Decl(typescript.d.ts,207,26))
|
||||
|
||||
if ((<ts.IterationStatement>node).statement.kind !== ts.SyntaxKind.Block) {
|
||||
>(<ts.IterationStatement>node).statement.kind !== ts.SyntaxKind.Block : boolean
|
||||
>(<ts.IterationStatement>node).statement.kind : ts.SyntaxKind
|
||||
>(<ts.IterationStatement>node).statement : ts.Statement
|
||||
>(<ts.IterationStatement>node).statement.kind : ts.SyntaxKind, Symbol(ts.Node.kind,Decl(typescript.d.ts,297,38))
|
||||
>(<ts.IterationStatement>node).statement : ts.Statement, Symbol(ts.IterationStatement.statement,Decl(typescript.d.ts,589,52))
|
||||
>(<ts.IterationStatement>node) : ts.IterationStatement
|
||||
><ts.IterationStatement>node : ts.IterationStatement
|
||||
>ts : unknown
|
||||
>IterationStatement : ts.IterationStatement
|
||||
>node : ts.Node
|
||||
>statement : ts.Statement
|
||||
>kind : ts.SyntaxKind
|
||||
>ts.SyntaxKind.Block : ts.SyntaxKind
|
||||
>ts.SyntaxKind : typeof ts.SyntaxKind
|
||||
>ts : typeof ts
|
||||
>SyntaxKind : typeof ts.SyntaxKind
|
||||
>Block : ts.SyntaxKind
|
||||
>ts : any, Symbol(ts,Decl(APISample_linter.ts,11,6))
|
||||
>IterationStatement : ts.IterationStatement, Symbol(ts.IterationStatement,Decl(typescript.d.ts,588,5))
|
||||
>node : ts.Node, Symbol(node,Decl(APISample_linter.ts,16,24))
|
||||
>statement : ts.Statement, Symbol(ts.IterationStatement.statement,Decl(typescript.d.ts,589,52))
|
||||
>kind : ts.SyntaxKind, Symbol(ts.Node.kind,Decl(typescript.d.ts,297,38))
|
||||
>ts.SyntaxKind.Block : ts.SyntaxKind, Symbol(ts.SyntaxKind.Block,Decl(typescript.d.ts,202,36))
|
||||
>ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind,Decl(typescript.d.ts,22,5))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_linter.ts,11,6))
|
||||
>SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind,Decl(typescript.d.ts,22,5))
|
||||
>Block : ts.SyntaxKind, Symbol(ts.SyntaxKind.Block,Decl(typescript.d.ts,202,36))
|
||||
|
||||
report(node, "A looping statement's contents should be wrapped in a block body.");
|
||||
>report(node, "A looping statement's contents should be wrapped in a block body.") : void
|
||||
>report : (node: ts.Node, message: string) => void
|
||||
>node : ts.Node
|
||||
>report : (node: ts.Node, message: string) => void, Symbol(report,Decl(APISample_linter.ts,48,5))
|
||||
>node : ts.Node, Symbol(node,Decl(APISample_linter.ts,16,24))
|
||||
>"A looping statement's contents should be wrapped in a block body." : string
|
||||
}
|
||||
break;
|
||||
|
||||
case ts.SyntaxKind.IfStatement:
|
||||
>ts.SyntaxKind.IfStatement : ts.SyntaxKind
|
||||
>ts.SyntaxKind : typeof ts.SyntaxKind
|
||||
>ts : typeof ts
|
||||
>SyntaxKind : typeof ts.SyntaxKind
|
||||
>IfStatement : ts.SyntaxKind
|
||||
>ts.SyntaxKind.IfStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.IfStatement,Decl(typescript.d.ts,206,34))
|
||||
>ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind,Decl(typescript.d.ts,22,5))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_linter.ts,11,6))
|
||||
>SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind,Decl(typescript.d.ts,22,5))
|
||||
>IfStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.IfStatement,Decl(typescript.d.ts,206,34))
|
||||
|
||||
let ifStatement = (<ts.IfStatement>node);
|
||||
>ifStatement : ts.IfStatement
|
||||
>ifStatement : ts.IfStatement, Symbol(ifStatement,Decl(APISample_linter.ts,28,19))
|
||||
>(<ts.IfStatement>node) : ts.IfStatement
|
||||
><ts.IfStatement>node : ts.IfStatement
|
||||
>ts : unknown
|
||||
>IfStatement : ts.IfStatement
|
||||
>node : ts.Node
|
||||
>ts : any, Symbol(ts,Decl(APISample_linter.ts,11,6))
|
||||
>IfStatement : ts.IfStatement, Symbol(ts.IfStatement,Decl(typescript.d.ts,583,5))
|
||||
>node : ts.Node, Symbol(node,Decl(APISample_linter.ts,16,24))
|
||||
|
||||
if (ifStatement.thenStatement.kind !== ts.SyntaxKind.Block) {
|
||||
>ifStatement.thenStatement.kind !== ts.SyntaxKind.Block : boolean
|
||||
>ifStatement.thenStatement.kind : ts.SyntaxKind
|
||||
>ifStatement.thenStatement : ts.Statement
|
||||
>ifStatement : ts.IfStatement
|
||||
>thenStatement : ts.Statement
|
||||
>kind : ts.SyntaxKind
|
||||
>ts.SyntaxKind.Block : ts.SyntaxKind
|
||||
>ts.SyntaxKind : typeof ts.SyntaxKind
|
||||
>ts : typeof ts
|
||||
>SyntaxKind : typeof ts.SyntaxKind
|
||||
>Block : ts.SyntaxKind
|
||||
>ifStatement.thenStatement.kind : ts.SyntaxKind, Symbol(ts.Node.kind,Decl(typescript.d.ts,297,38))
|
||||
>ifStatement.thenStatement : ts.Statement, Symbol(ts.IfStatement.thenStatement,Decl(typescript.d.ts,585,31))
|
||||
>ifStatement : ts.IfStatement, Symbol(ifStatement,Decl(APISample_linter.ts,28,19))
|
||||
>thenStatement : ts.Statement, Symbol(ts.IfStatement.thenStatement,Decl(typescript.d.ts,585,31))
|
||||
>kind : ts.SyntaxKind, Symbol(ts.Node.kind,Decl(typescript.d.ts,297,38))
|
||||
>ts.SyntaxKind.Block : ts.SyntaxKind, Symbol(ts.SyntaxKind.Block,Decl(typescript.d.ts,202,36))
|
||||
>ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind,Decl(typescript.d.ts,22,5))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_linter.ts,11,6))
|
||||
>SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind,Decl(typescript.d.ts,22,5))
|
||||
>Block : ts.SyntaxKind, Symbol(ts.SyntaxKind.Block,Decl(typescript.d.ts,202,36))
|
||||
|
||||
report(ifStatement.thenStatement, "An if statement's contents should be wrapped in a block body.");
|
||||
>report(ifStatement.thenStatement, "An if statement's contents should be wrapped in a block body.") : void
|
||||
>report : (node: ts.Node, message: string) => void
|
||||
>ifStatement.thenStatement : ts.Statement
|
||||
>ifStatement : ts.IfStatement
|
||||
>thenStatement : ts.Statement
|
||||
>report : (node: ts.Node, message: string) => void, Symbol(report,Decl(APISample_linter.ts,48,5))
|
||||
>ifStatement.thenStatement : ts.Statement, Symbol(ts.IfStatement.thenStatement,Decl(typescript.d.ts,585,31))
|
||||
>ifStatement : ts.IfStatement, Symbol(ifStatement,Decl(APISample_linter.ts,28,19))
|
||||
>thenStatement : ts.Statement, Symbol(ts.IfStatement.thenStatement,Decl(typescript.d.ts,585,31))
|
||||
>"An if statement's contents should be wrapped in a block body." : string
|
||||
}
|
||||
if (ifStatement.elseStatement &&
|
||||
>ifStatement.elseStatement && ifStatement.elseStatement.kind !== ts.SyntaxKind.Block && ifStatement.elseStatement.kind !== ts.SyntaxKind.IfStatement : boolean
|
||||
>ifStatement.elseStatement && ifStatement.elseStatement.kind !== ts.SyntaxKind.Block : boolean
|
||||
>ifStatement.elseStatement : ts.Statement
|
||||
>ifStatement : ts.IfStatement
|
||||
>elseStatement : ts.Statement
|
||||
>ifStatement.elseStatement : ts.Statement, Symbol(ts.IfStatement.elseStatement,Decl(typescript.d.ts,586,33))
|
||||
>ifStatement : ts.IfStatement, Symbol(ifStatement,Decl(APISample_linter.ts,28,19))
|
||||
>elseStatement : ts.Statement, Symbol(ts.IfStatement.elseStatement,Decl(typescript.d.ts,586,33))
|
||||
|
||||
ifStatement.elseStatement.kind !== ts.SyntaxKind.Block &&
|
||||
>ifStatement.elseStatement.kind !== ts.SyntaxKind.Block : boolean
|
||||
>ifStatement.elseStatement.kind : ts.SyntaxKind
|
||||
>ifStatement.elseStatement : ts.Statement
|
||||
>ifStatement : ts.IfStatement
|
||||
>elseStatement : ts.Statement
|
||||
>kind : ts.SyntaxKind
|
||||
>ts.SyntaxKind.Block : ts.SyntaxKind
|
||||
>ts.SyntaxKind : typeof ts.SyntaxKind
|
||||
>ts : typeof ts
|
||||
>SyntaxKind : typeof ts.SyntaxKind
|
||||
>Block : ts.SyntaxKind
|
||||
>ifStatement.elseStatement.kind : ts.SyntaxKind, Symbol(ts.Node.kind,Decl(typescript.d.ts,297,38))
|
||||
>ifStatement.elseStatement : ts.Statement, Symbol(ts.IfStatement.elseStatement,Decl(typescript.d.ts,586,33))
|
||||
>ifStatement : ts.IfStatement, Symbol(ifStatement,Decl(APISample_linter.ts,28,19))
|
||||
>elseStatement : ts.Statement, Symbol(ts.IfStatement.elseStatement,Decl(typescript.d.ts,586,33))
|
||||
>kind : ts.SyntaxKind, Symbol(ts.Node.kind,Decl(typescript.d.ts,297,38))
|
||||
>ts.SyntaxKind.Block : ts.SyntaxKind, Symbol(ts.SyntaxKind.Block,Decl(typescript.d.ts,202,36))
|
||||
>ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind,Decl(typescript.d.ts,22,5))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_linter.ts,11,6))
|
||||
>SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind,Decl(typescript.d.ts,22,5))
|
||||
>Block : ts.SyntaxKind, Symbol(ts.SyntaxKind.Block,Decl(typescript.d.ts,202,36))
|
||||
|
||||
ifStatement.elseStatement.kind !== ts.SyntaxKind.IfStatement) {
|
||||
>ifStatement.elseStatement.kind !== ts.SyntaxKind.IfStatement : boolean
|
||||
>ifStatement.elseStatement.kind : ts.SyntaxKind
|
||||
>ifStatement.elseStatement : ts.Statement
|
||||
>ifStatement : ts.IfStatement
|
||||
>elseStatement : ts.Statement
|
||||
>kind : ts.SyntaxKind
|
||||
>ts.SyntaxKind.IfStatement : ts.SyntaxKind
|
||||
>ts.SyntaxKind : typeof ts.SyntaxKind
|
||||
>ts : typeof ts
|
||||
>SyntaxKind : typeof ts.SyntaxKind
|
||||
>IfStatement : ts.SyntaxKind
|
||||
>ifStatement.elseStatement.kind : ts.SyntaxKind, Symbol(ts.Node.kind,Decl(typescript.d.ts,297,38))
|
||||
>ifStatement.elseStatement : ts.Statement, Symbol(ts.IfStatement.elseStatement,Decl(typescript.d.ts,586,33))
|
||||
>ifStatement : ts.IfStatement, Symbol(ifStatement,Decl(APISample_linter.ts,28,19))
|
||||
>elseStatement : ts.Statement, Symbol(ts.IfStatement.elseStatement,Decl(typescript.d.ts,586,33))
|
||||
>kind : ts.SyntaxKind, Symbol(ts.Node.kind,Decl(typescript.d.ts,297,38))
|
||||
>ts.SyntaxKind.IfStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.IfStatement,Decl(typescript.d.ts,206,34))
|
||||
>ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind,Decl(typescript.d.ts,22,5))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_linter.ts,11,6))
|
||||
>SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind,Decl(typescript.d.ts,22,5))
|
||||
>IfStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.IfStatement,Decl(typescript.d.ts,206,34))
|
||||
|
||||
report(ifStatement.elseStatement, "An else statement's contents should be wrapped in a block body.");
|
||||
>report(ifStatement.elseStatement, "An else statement's contents should be wrapped in a block body.") : void
|
||||
>report : (node: ts.Node, message: string) => void
|
||||
>ifStatement.elseStatement : ts.Statement
|
||||
>ifStatement : ts.IfStatement
|
||||
>elseStatement : ts.Statement
|
||||
>report : (node: ts.Node, message: string) => void, Symbol(report,Decl(APISample_linter.ts,48,5))
|
||||
>ifStatement.elseStatement : ts.Statement, Symbol(ts.IfStatement.elseStatement,Decl(typescript.d.ts,586,33))
|
||||
>ifStatement : ts.IfStatement, Symbol(ifStatement,Decl(APISample_linter.ts,28,19))
|
||||
>elseStatement : ts.Statement, Symbol(ts.IfStatement.elseStatement,Decl(typescript.d.ts,586,33))
|
||||
>"An else statement's contents should be wrapped in a block body." : string
|
||||
}
|
||||
break;
|
||||
|
||||
case ts.SyntaxKind.BinaryExpression:
|
||||
>ts.SyntaxKind.BinaryExpression : ts.SyntaxKind
|
||||
>ts.SyntaxKind : typeof ts.SyntaxKind
|
||||
>ts : typeof ts
|
||||
>SyntaxKind : typeof ts.SyntaxKind
|
||||
>BinaryExpression : ts.SyntaxKind
|
||||
>ts.SyntaxKind.BinaryExpression : ts.SyntaxKind, Symbol(ts.SyntaxKind.BinaryExpression,Decl(typescript.d.ts,192,37))
|
||||
>ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind,Decl(typescript.d.ts,22,5))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_linter.ts,11,6))
|
||||
>SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind,Decl(typescript.d.ts,22,5))
|
||||
>BinaryExpression : ts.SyntaxKind, Symbol(ts.SyntaxKind.BinaryExpression,Decl(typescript.d.ts,192,37))
|
||||
|
||||
let op = (<ts.BinaryExpression>node).operatorToken.kind;
|
||||
>op : ts.SyntaxKind
|
||||
>(<ts.BinaryExpression>node).operatorToken.kind : ts.SyntaxKind
|
||||
>(<ts.BinaryExpression>node).operatorToken : ts.Node
|
||||
>op : ts.SyntaxKind, Symbol(op,Decl(APISample_linter.ts,40,19))
|
||||
>(<ts.BinaryExpression>node).operatorToken.kind : ts.SyntaxKind, Symbol(ts.Node.kind,Decl(typescript.d.ts,297,38))
|
||||
>(<ts.BinaryExpression>node).operatorToken : ts.Node, Symbol(ts.BinaryExpression.operatorToken,Decl(typescript.d.ts,497,25))
|
||||
>(<ts.BinaryExpression>node) : ts.BinaryExpression
|
||||
><ts.BinaryExpression>node : ts.BinaryExpression
|
||||
>ts : unknown
|
||||
>BinaryExpression : ts.BinaryExpression
|
||||
>node : ts.Node
|
||||
>operatorToken : ts.Node
|
||||
>kind : ts.SyntaxKind
|
||||
>ts : any, Symbol(ts,Decl(APISample_linter.ts,11,6))
|
||||
>BinaryExpression : ts.BinaryExpression, Symbol(ts.BinaryExpression,Decl(typescript.d.ts,495,5))
|
||||
>node : ts.Node, Symbol(node,Decl(APISample_linter.ts,16,24))
|
||||
>operatorToken : ts.Node, Symbol(ts.BinaryExpression.operatorToken,Decl(typescript.d.ts,497,25))
|
||||
>kind : ts.SyntaxKind, Symbol(ts.Node.kind,Decl(typescript.d.ts,297,38))
|
||||
|
||||
if (op === ts.SyntaxKind.EqualsEqualsToken || op == ts.SyntaxKind.ExclamationEqualsToken) {
|
||||
>op === ts.SyntaxKind.EqualsEqualsToken || op == ts.SyntaxKind.ExclamationEqualsToken : boolean
|
||||
>op === ts.SyntaxKind.EqualsEqualsToken : boolean
|
||||
>op : ts.SyntaxKind
|
||||
>ts.SyntaxKind.EqualsEqualsToken : ts.SyntaxKind
|
||||
>ts.SyntaxKind : typeof ts.SyntaxKind
|
||||
>ts : typeof ts
|
||||
>SyntaxKind : typeof ts.SyntaxKind
|
||||
>EqualsEqualsToken : ts.SyntaxKind
|
||||
>op : ts.SyntaxKind, Symbol(op,Decl(APISample_linter.ts,40,19))
|
||||
>ts.SyntaxKind.EqualsEqualsToken : ts.SyntaxKind, Symbol(ts.SyntaxKind.EqualsEqualsToken,Decl(typescript.d.ts,51,36))
|
||||
>ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind,Decl(typescript.d.ts,22,5))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_linter.ts,11,6))
|
||||
>SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind,Decl(typescript.d.ts,22,5))
|
||||
>EqualsEqualsToken : ts.SyntaxKind, Symbol(ts.SyntaxKind.EqualsEqualsToken,Decl(typescript.d.ts,51,36))
|
||||
>op == ts.SyntaxKind.ExclamationEqualsToken : boolean
|
||||
>op : ts.SyntaxKind
|
||||
>ts.SyntaxKind.ExclamationEqualsToken : ts.SyntaxKind
|
||||
>ts.SyntaxKind : typeof ts.SyntaxKind
|
||||
>ts : typeof ts
|
||||
>SyntaxKind : typeof ts.SyntaxKind
|
||||
>ExclamationEqualsToken : ts.SyntaxKind
|
||||
>op : ts.SyntaxKind, Symbol(op,Decl(APISample_linter.ts,40,19))
|
||||
>ts.SyntaxKind.ExclamationEqualsToken : ts.SyntaxKind, Symbol(ts.SyntaxKind.ExclamationEqualsToken,Decl(typescript.d.ts,52,31))
|
||||
>ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind,Decl(typescript.d.ts,22,5))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_linter.ts,11,6))
|
||||
>SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind,Decl(typescript.d.ts,22,5))
|
||||
>ExclamationEqualsToken : ts.SyntaxKind, Symbol(ts.SyntaxKind.ExclamationEqualsToken,Decl(typescript.d.ts,52,31))
|
||||
|
||||
report(node, "Use '===' and '!=='.")
|
||||
>report(node, "Use '===' and '!=='.") : void
|
||||
>report : (node: ts.Node, message: string) => void
|
||||
>node : ts.Node
|
||||
>report : (node: ts.Node, message: string) => void, Symbol(report,Decl(APISample_linter.ts,48,5))
|
||||
>node : ts.Node, Symbol(node,Decl(APISample_linter.ts,16,24))
|
||||
>"Use '===' and '!=='." : string
|
||||
}
|
||||
break;
|
||||
@@ -219,57 +219,57 @@ export function delint(sourceFile: ts.SourceFile) {
|
||||
|
||||
ts.forEachChild(node, delintNode);
|
||||
>ts.forEachChild(node, delintNode) : void
|
||||
>ts.forEachChild : <T>(node: ts.Node, cbNode: (node: ts.Node) => T, cbNodeArray?: (nodes: ts.Node[]) => T) => T
|
||||
>ts : typeof ts
|
||||
>forEachChild : <T>(node: ts.Node, cbNode: (node: ts.Node) => T, cbNodeArray?: (nodes: ts.Node[]) => T) => T
|
||||
>node : ts.Node
|
||||
>delintNode : (node: ts.Node) => void
|
||||
>ts.forEachChild : <T>(node: ts.Node, cbNode: (node: ts.Node) => T, cbNodeArray?: (nodes: ts.Node[]) => T) => T, Symbol(ts.forEachChild,Decl(typescript.d.ts,1186,48))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_linter.ts,11,6))
|
||||
>forEachChild : <T>(node: ts.Node, cbNode: (node: ts.Node) => T, cbNodeArray?: (nodes: ts.Node[]) => T) => T, Symbol(ts.forEachChild,Decl(typescript.d.ts,1186,48))
|
||||
>node : ts.Node, Symbol(node,Decl(APISample_linter.ts,16,24))
|
||||
>delintNode : (node: ts.Node) => void, Symbol(delintNode,Decl(APISample_linter.ts,14,27))
|
||||
}
|
||||
|
||||
function report(node: ts.Node, message: string) {
|
||||
>report : (node: ts.Node, message: string) => void
|
||||
>node : ts.Node
|
||||
>ts : unknown
|
||||
>Node : ts.Node
|
||||
>message : string
|
||||
>report : (node: ts.Node, message: string) => void, Symbol(report,Decl(APISample_linter.ts,48,5))
|
||||
>node : ts.Node, Symbol(node,Decl(APISample_linter.ts,50,20))
|
||||
>ts : any, Symbol(ts,Decl(APISample_linter.ts,11,6))
|
||||
>Node : ts.Node, Symbol(ts.Node,Decl(typescript.d.ts,296,5),Decl(typescript.d.ts,1221,32))
|
||||
>message : string, Symbol(message,Decl(APISample_linter.ts,50,34))
|
||||
|
||||
let { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
|
||||
>line : number
|
||||
>character : number
|
||||
>line : number, Symbol(line,Decl(APISample_linter.ts,51,13))
|
||||
>character : number, Symbol(character,Decl(APISample_linter.ts,51,19))
|
||||
>sourceFile.getLineAndCharacterOfPosition(node.getStart()) : ts.LineAndCharacter
|
||||
>sourceFile.getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter
|
||||
>sourceFile : ts.SourceFile
|
||||
>getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter
|
||||
>sourceFile.getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter, Symbol(ts.SourceFile.getLineAndCharacterOfPosition,Decl(typescript.d.ts,1263,46))
|
||||
>sourceFile : ts.SourceFile, Symbol(sourceFile,Decl(APISample_linter.ts,13,23))
|
||||
>getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter, Symbol(ts.SourceFile.getLineAndCharacterOfPosition,Decl(typescript.d.ts,1263,46))
|
||||
>node.getStart() : number
|
||||
>node.getStart : (sourceFile?: ts.SourceFile) => number
|
||||
>node : ts.Node
|
||||
>getStart : (sourceFile?: ts.SourceFile) => number
|
||||
>node.getStart : (sourceFile?: ts.SourceFile) => number, Symbol(ts.Node.getStart,Decl(typescript.d.ts,1226,53))
|
||||
>node : ts.Node, Symbol(node,Decl(APISample_linter.ts,50,20))
|
||||
>getStart : (sourceFile?: ts.SourceFile) => number, Symbol(ts.Node.getStart,Decl(typescript.d.ts,1226,53))
|
||||
|
||||
console.log(`${sourceFile.fileName} (${line + 1},${character + 1}): ${message}`);
|
||||
>console.log(`${sourceFile.fileName} (${line + 1},${character + 1}): ${message}`) : any
|
||||
>console.log : any
|
||||
>console : any
|
||||
>console : any, Symbol(console,Decl(APISample_linter.ts,8,11))
|
||||
>log : any
|
||||
>`${sourceFile.fileName} (${line + 1},${character + 1}): ${message}` : string
|
||||
>sourceFile.fileName : string
|
||||
>sourceFile : ts.SourceFile
|
||||
>fileName : string
|
||||
>sourceFile.fileName : string, Symbol(ts.SourceFile.fileName,Decl(typescript.d.ts,743,29))
|
||||
>sourceFile : ts.SourceFile, Symbol(sourceFile,Decl(APISample_linter.ts,13,23))
|
||||
>fileName : string, Symbol(ts.SourceFile.fileName,Decl(typescript.d.ts,743,29))
|
||||
>line + 1 : number
|
||||
>line : number
|
||||
>line : number, Symbol(line,Decl(APISample_linter.ts,51,13))
|
||||
>1 : number
|
||||
>character + 1 : number
|
||||
>character : number
|
||||
>character : number, Symbol(character,Decl(APISample_linter.ts,51,19))
|
||||
>1 : number
|
||||
>message : string
|
||||
>message : string, Symbol(message,Decl(APISample_linter.ts,50,34))
|
||||
}
|
||||
}
|
||||
|
||||
const fileNames = process.argv.slice(2);
|
||||
>fileNames : any
|
||||
>fileNames : any, Symbol(fileNames,Decl(APISample_linter.ts,56,5))
|
||||
>process.argv.slice(2) : any
|
||||
>process.argv.slice : any
|
||||
>process.argv : any
|
||||
>process : any
|
||||
>process : any, Symbol(process,Decl(APISample_linter.ts,7,11))
|
||||
>argv : any
|
||||
>slice : any
|
||||
>2 : number
|
||||
@@ -277,36 +277,36 @@ const fileNames = process.argv.slice(2);
|
||||
fileNames.forEach(fileName => {
|
||||
>fileNames.forEach(fileName => { // Parse a file let sourceFile = ts.createSourceFile(fileName, readFileSync(fileName).toString(), ts.ScriptTarget.ES6, /*setParentNodes */ true); // delint it delint(sourceFile);}) : any
|
||||
>fileNames.forEach : any
|
||||
>fileNames : any
|
||||
>fileNames : any, Symbol(fileNames,Decl(APISample_linter.ts,56,5))
|
||||
>forEach : any
|
||||
>fileName => { // Parse a file let sourceFile = ts.createSourceFile(fileName, readFileSync(fileName).toString(), ts.ScriptTarget.ES6, /*setParentNodes */ true); // delint it delint(sourceFile);} : (fileName: any) => void
|
||||
>fileName : any
|
||||
>fileName : any, Symbol(fileName,Decl(APISample_linter.ts,57,18))
|
||||
|
||||
// Parse a file
|
||||
let sourceFile = ts.createSourceFile(fileName, readFileSync(fileName).toString(), ts.ScriptTarget.ES6, /*setParentNodes */ true);
|
||||
>sourceFile : ts.SourceFile
|
||||
>sourceFile : ts.SourceFile, Symbol(sourceFile,Decl(APISample_linter.ts,59,7))
|
||||
>ts.createSourceFile(fileName, readFileSync(fileName).toString(), ts.ScriptTarget.ES6, /*setParentNodes */ true) : ts.SourceFile
|
||||
>ts.createSourceFile : (fileName: string, sourceText: string, languageVersion: ts.ScriptTarget, setParentNodes?: boolean) => ts.SourceFile
|
||||
>ts : typeof ts
|
||||
>createSourceFile : (fileName: string, sourceText: string, languageVersion: ts.ScriptTarget, setParentNodes?: boolean) => ts.SourceFile
|
||||
>fileName : any
|
||||
>ts.createSourceFile : (fileName: string, sourceText: string, languageVersion: ts.ScriptTarget, setParentNodes?: boolean) => ts.SourceFile, Symbol(ts.createSourceFile,Decl(typescript.d.ts,1190,62))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_linter.ts,11,6))
|
||||
>createSourceFile : (fileName: string, sourceText: string, languageVersion: ts.ScriptTarget, setParentNodes?: boolean) => ts.SourceFile, Symbol(ts.createSourceFile,Decl(typescript.d.ts,1190,62))
|
||||
>fileName : any, Symbol(fileName,Decl(APISample_linter.ts,57,18))
|
||||
>readFileSync(fileName).toString() : any
|
||||
>readFileSync(fileName).toString : any
|
||||
>readFileSync(fileName) : any
|
||||
>readFileSync : any
|
||||
>fileName : any
|
||||
>readFileSync : any, Symbol(readFileSync,Decl(APISample_linter.ts,9,11))
|
||||
>fileName : any, Symbol(fileName,Decl(APISample_linter.ts,57,18))
|
||||
>toString : any
|
||||
>ts.ScriptTarget.ES6 : ts.ScriptTarget
|
||||
>ts.ScriptTarget : typeof ts.ScriptTarget
|
||||
>ts : typeof ts
|
||||
>ScriptTarget : typeof ts.ScriptTarget
|
||||
>ES6 : ts.ScriptTarget
|
||||
>ts.ScriptTarget.ES6 : ts.ScriptTarget, Symbol(ts.ScriptTarget.ES6,Decl(typescript.d.ts,1118,16))
|
||||
>ts.ScriptTarget : typeof ts.ScriptTarget, Symbol(ts.ScriptTarget,Decl(typescript.d.ts,1115,5))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_linter.ts,11,6))
|
||||
>ScriptTarget : typeof ts.ScriptTarget, Symbol(ts.ScriptTarget,Decl(typescript.d.ts,1115,5))
|
||||
>ES6 : ts.ScriptTarget, Symbol(ts.ScriptTarget.ES6,Decl(typescript.d.ts,1118,16))
|
||||
>true : boolean
|
||||
|
||||
// delint it
|
||||
delint(sourceFile);
|
||||
>delint(sourceFile) : void
|
||||
>delint : (sourceFile: ts.SourceFile) => void
|
||||
>sourceFile : ts.SourceFile
|
||||
>delint : (sourceFile: ts.SourceFile) => void, Symbol(delint,Decl(APISample_linter.ts,11,33))
|
||||
>sourceFile : ts.SourceFile, Symbol(sourceFile,Decl(APISample_linter.ts,59,7))
|
||||
|
||||
});
|
||||
|
||||
@@ -7,38 +7,38 @@
|
||||
*/
|
||||
|
||||
declare var console: any;
|
||||
>console : any
|
||||
>console : any, Symbol(console,Decl(APISample_transform.ts,7,11))
|
||||
|
||||
import * as ts from "typescript";
|
||||
>ts : typeof ts
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_transform.ts,9,6))
|
||||
|
||||
const source = "let x: string = 'string'";
|
||||
>source : string
|
||||
>source : string, Symbol(source,Decl(APISample_transform.ts,11,5))
|
||||
>"let x: string = 'string'" : string
|
||||
|
||||
let result = ts.transpile(source, { module: ts.ModuleKind.CommonJS });
|
||||
>result : string
|
||||
>result : string, Symbol(result,Decl(APISample_transform.ts,13,3))
|
||||
>ts.transpile(source, { module: ts.ModuleKind.CommonJS }) : string
|
||||
>ts.transpile : (input: string, compilerOptions?: ts.CompilerOptions, fileName?: string, diagnostics?: ts.Diagnostic[]) => string
|
||||
>ts : typeof ts
|
||||
>transpile : (input: string, compilerOptions?: ts.CompilerOptions, fileName?: string, diagnostics?: ts.Diagnostic[]) => string
|
||||
>source : string
|
||||
>ts.transpile : (input: string, compilerOptions?: ts.CompilerOptions, fileName?: string, diagnostics?: ts.Diagnostic[]) => string, Symbol(ts.transpile,Decl(typescript.d.ts,1729,5))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_transform.ts,9,6))
|
||||
>transpile : (input: string, compilerOptions?: ts.CompilerOptions, fileName?: string, diagnostics?: ts.Diagnostic[]) => string, Symbol(ts.transpile,Decl(typescript.d.ts,1729,5))
|
||||
>source : string, Symbol(source,Decl(APISample_transform.ts,11,5))
|
||||
>{ module: ts.ModuleKind.CommonJS } : { [x: string]: ts.ModuleKind; module: ts.ModuleKind; }
|
||||
>module : ts.ModuleKind
|
||||
>ts.ModuleKind.CommonJS : ts.ModuleKind
|
||||
>ts.ModuleKind : typeof ts.ModuleKind
|
||||
>ts : typeof ts
|
||||
>ModuleKind : typeof ts.ModuleKind
|
||||
>CommonJS : ts.ModuleKind
|
||||
>module : ts.ModuleKind, Symbol(module,Decl(APISample_transform.ts,13,35))
|
||||
>ts.ModuleKind.CommonJS : ts.ModuleKind, Symbol(ts.ModuleKind.CommonJS,Decl(typescript.d.ts,1108,17))
|
||||
>ts.ModuleKind : typeof ts.ModuleKind, Symbol(ts.ModuleKind,Decl(typescript.d.ts,1106,5))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_transform.ts,9,6))
|
||||
>ModuleKind : typeof ts.ModuleKind, Symbol(ts.ModuleKind,Decl(typescript.d.ts,1106,5))
|
||||
>CommonJS : ts.ModuleKind, Symbol(ts.ModuleKind.CommonJS,Decl(typescript.d.ts,1108,17))
|
||||
|
||||
console.log(JSON.stringify(result));
|
||||
>console.log(JSON.stringify(result)) : any
|
||||
>console.log : any
|
||||
>console : any
|
||||
>console : any, Symbol(console,Decl(APISample_transform.ts,7,11))
|
||||
>log : any
|
||||
>JSON.stringify(result) : string
|
||||
>JSON.stringify : { (value: any): string; (value: any, replacer: (key: string, value: any) => any): string; (value: any, replacer: any[]): string; (value: any, replacer: (key: string, value: any) => any, space: any): string; (value: any, replacer: any[], space: any): string; }
|
||||
>JSON : JSON
|
||||
>stringify : { (value: any): string; (value: any, replacer: (key: string, value: any) => any): string; (value: any, replacer: any[]): string; (value: any, replacer: (key: string, value: any) => any, space: any): string; (value: any, replacer: any[], space: any): string; }
|
||||
>result : string
|
||||
>JSON.stringify : { (value: any): string; (value: any, replacer: (key: string, value: any) => any): string; (value: any, replacer: any[]): string; (value: any, replacer: (key: string, value: any) => any, space: any): string; (value: any, replacer: any[], space: any): string; }, Symbol(JSON.stringify,Decl(lib.d.ts,964,70),Decl(lib.d.ts,969,34),Decl(lib.d.ts,975,78),Decl(lib.d.ts,981,51),Decl(lib.d.ts,988,90))
|
||||
>JSON : JSON, Symbol(JSON,Decl(lib.d.ts,955,42),Decl(lib.d.ts,1000,11))
|
||||
>stringify : { (value: any): string; (value: any, replacer: (key: string, value: any) => any): string; (value: any, replacer: any[]): string; (value: any, replacer: (key: string, value: any) => any, space: any): string; (value: any, replacer: any[], space: any): string; }, Symbol(JSON.stringify,Decl(lib.d.ts,964,70),Decl(lib.d.ts,969,34),Decl(lib.d.ts,975,78),Decl(lib.d.ts,981,51),Decl(lib.d.ts,988,90))
|
||||
>result : string, Symbol(result,Decl(APISample_transform.ts,13,3))
|
||||
|
||||
|
||||
@@ -7,200 +7,200 @@
|
||||
*/
|
||||
|
||||
declare var process: any;
|
||||
>process : any
|
||||
>process : any, Symbol(process,Decl(APISample_watcher.ts,7,11))
|
||||
|
||||
declare var console: any;
|
||||
>console : any
|
||||
>console : any, Symbol(console,Decl(APISample_watcher.ts,8,11))
|
||||
|
||||
declare var fs: any;
|
||||
>fs : any
|
||||
>fs : any, Symbol(fs,Decl(APISample_watcher.ts,9,11))
|
||||
|
||||
declare var path: any;
|
||||
>path : any
|
||||
>path : any, Symbol(path,Decl(APISample_watcher.ts,10,11))
|
||||
|
||||
import * as ts from "typescript";
|
||||
>ts : typeof ts
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_watcher.ts,12,6))
|
||||
|
||||
function watch(rootFileNames: string[], options: ts.CompilerOptions) {
|
||||
>watch : (rootFileNames: string[], options: ts.CompilerOptions) => void
|
||||
>rootFileNames : string[]
|
||||
>options : ts.CompilerOptions
|
||||
>ts : unknown
|
||||
>CompilerOptions : ts.CompilerOptions
|
||||
>watch : (rootFileNames: string[], options: ts.CompilerOptions) => void, Symbol(watch,Decl(APISample_watcher.ts,12,33))
|
||||
>rootFileNames : string[], Symbol(rootFileNames,Decl(APISample_watcher.ts,14,15))
|
||||
>options : ts.CompilerOptions, Symbol(options,Decl(APISample_watcher.ts,14,39))
|
||||
>ts : any, Symbol(ts,Decl(APISample_watcher.ts,12,6))
|
||||
>CompilerOptions : ts.CompilerOptions, Symbol(ts.CompilerOptions,Decl(typescript.d.ts,1074,5))
|
||||
|
||||
const files: ts.Map<{ version: number }> = {};
|
||||
>files : ts.Map<{ version: number; }>
|
||||
>ts : unknown
|
||||
>Map : ts.Map<T>
|
||||
>version : number
|
||||
>files : ts.Map<{ version: number; }>, Symbol(files,Decl(APISample_watcher.ts,15,9))
|
||||
>ts : any, Symbol(ts,Decl(APISample_watcher.ts,12,6))
|
||||
>Map : ts.Map<T>, Symbol(ts.Map,Decl(typescript.d.ts,15,29))
|
||||
>version : number, Symbol(version,Decl(APISample_watcher.ts,15,25))
|
||||
>{} : { [x: string]: undefined; }
|
||||
|
||||
// initialize the list of files
|
||||
rootFileNames.forEach(fileName => {
|
||||
>rootFileNames.forEach(fileName => { files[fileName] = { version: 0 }; }) : void
|
||||
>rootFileNames.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
|
||||
>rootFileNames : string[]
|
||||
>forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
|
||||
>rootFileNames.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void, Symbol(Array.forEach,Decl(lib.d.ts,1108,95))
|
||||
>rootFileNames : string[], Symbol(rootFileNames,Decl(APISample_watcher.ts,14,15))
|
||||
>forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void, Symbol(Array.forEach,Decl(lib.d.ts,1108,95))
|
||||
>fileName => { files[fileName] = { version: 0 }; } : (fileName: string) => void
|
||||
>fileName : string
|
||||
>fileName : string, Symbol(fileName,Decl(APISample_watcher.ts,18,26))
|
||||
|
||||
files[fileName] = { version: 0 };
|
||||
>files[fileName] = { version: 0 } : { version: number; }
|
||||
>files[fileName] : { version: number; }
|
||||
>files : ts.Map<{ version: number; }>
|
||||
>fileName : string
|
||||
>files : ts.Map<{ version: number; }>, Symbol(files,Decl(APISample_watcher.ts,15,9))
|
||||
>fileName : string, Symbol(fileName,Decl(APISample_watcher.ts,18,26))
|
||||
>{ version: 0 } : { version: number; }
|
||||
>version : number
|
||||
>version : number, Symbol(version,Decl(APISample_watcher.ts,19,27))
|
||||
>0 : number
|
||||
|
||||
});
|
||||
|
||||
// Create the language service host to allow the LS to communicate with the host
|
||||
const servicesHost: ts.LanguageServiceHost = {
|
||||
>servicesHost : ts.LanguageServiceHost
|
||||
>ts : unknown
|
||||
>LanguageServiceHost : ts.LanguageServiceHost
|
||||
>servicesHost : ts.LanguageServiceHost, Symbol(servicesHost,Decl(APISample_watcher.ts,23,9))
|
||||
>ts : any, Symbol(ts,Decl(APISample_watcher.ts,12,6))
|
||||
>LanguageServiceHost : ts.LanguageServiceHost, Symbol(ts.LanguageServiceHost,Decl(typescript.d.ts,1295,5))
|
||||
>{ getScriptFileNames: () => rootFileNames, getScriptVersion: (fileName) => files[fileName] && files[fileName].version.toString(), getScriptSnapshot: (fileName) => { if (!fs.existsSync(fileName)) { return undefined; } return ts.ScriptSnapshot.fromString(fs.readFileSync(fileName).toString()); }, getCurrentDirectory: () => process.cwd(), getCompilationSettings: () => options, getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options), } : { getScriptFileNames: () => string[]; getScriptVersion: (fileName: string) => string; getScriptSnapshot: (fileName: string) => ts.IScriptSnapshot; getCurrentDirectory: () => any; getCompilationSettings: () => ts.CompilerOptions; getDefaultLibFileName: (options: ts.CompilerOptions) => string; }
|
||||
|
||||
getScriptFileNames: () => rootFileNames,
|
||||
>getScriptFileNames : () => string[]
|
||||
>getScriptFileNames : () => string[], Symbol(getScriptFileNames,Decl(APISample_watcher.ts,23,50))
|
||||
>() => rootFileNames : () => string[]
|
||||
>rootFileNames : string[]
|
||||
>rootFileNames : string[], Symbol(rootFileNames,Decl(APISample_watcher.ts,14,15))
|
||||
|
||||
getScriptVersion: (fileName) => files[fileName] && files[fileName].version.toString(),
|
||||
>getScriptVersion : (fileName: string) => string
|
||||
>getScriptVersion : (fileName: string) => string, Symbol(getScriptVersion,Decl(APISample_watcher.ts,24,48))
|
||||
>(fileName) => files[fileName] && files[fileName].version.toString() : (fileName: string) => string
|
||||
>fileName : string
|
||||
>fileName : string, Symbol(fileName,Decl(APISample_watcher.ts,25,27))
|
||||
>files[fileName] && files[fileName].version.toString() : string
|
||||
>files[fileName] : { version: number; }
|
||||
>files : ts.Map<{ version: number; }>
|
||||
>fileName : string
|
||||
>files : ts.Map<{ version: number; }>, Symbol(files,Decl(APISample_watcher.ts,15,9))
|
||||
>fileName : string, Symbol(fileName,Decl(APISample_watcher.ts,25,27))
|
||||
>files[fileName].version.toString() : string
|
||||
>files[fileName].version.toString : (radix?: number) => string
|
||||
>files[fileName].version : number
|
||||
>files[fileName].version.toString : (radix?: number) => string, Symbol(Number.toString,Decl(lib.d.ts,458,18))
|
||||
>files[fileName].version : number, Symbol(version,Decl(APISample_watcher.ts,15,25))
|
||||
>files[fileName] : { version: number; }
|
||||
>files : ts.Map<{ version: number; }>
|
||||
>fileName : string
|
||||
>version : number
|
||||
>toString : (radix?: number) => string
|
||||
>files : ts.Map<{ version: number; }>, Symbol(files,Decl(APISample_watcher.ts,15,9))
|
||||
>fileName : string, Symbol(fileName,Decl(APISample_watcher.ts,25,27))
|
||||
>version : number, Symbol(version,Decl(APISample_watcher.ts,15,25))
|
||||
>toString : (radix?: number) => string, Symbol(Number.toString,Decl(lib.d.ts,458,18))
|
||||
|
||||
getScriptSnapshot: (fileName) => {
|
||||
>getScriptSnapshot : (fileName: string) => ts.IScriptSnapshot
|
||||
>getScriptSnapshot : (fileName: string) => ts.IScriptSnapshot, Symbol(getScriptSnapshot,Decl(APISample_watcher.ts,25,94))
|
||||
>(fileName) => { if (!fs.existsSync(fileName)) { return undefined; } return ts.ScriptSnapshot.fromString(fs.readFileSync(fileName).toString()); } : (fileName: string) => ts.IScriptSnapshot
|
||||
>fileName : string
|
||||
>fileName : string, Symbol(fileName,Decl(APISample_watcher.ts,26,28))
|
||||
|
||||
if (!fs.existsSync(fileName)) {
|
||||
>!fs.existsSync(fileName) : boolean
|
||||
>fs.existsSync(fileName) : any
|
||||
>fs.existsSync : any
|
||||
>fs : any
|
||||
>fs : any, Symbol(fs,Decl(APISample_watcher.ts,9,11))
|
||||
>existsSync : any
|
||||
>fileName : string
|
||||
>fileName : string, Symbol(fileName,Decl(APISample_watcher.ts,26,28))
|
||||
|
||||
return undefined;
|
||||
>undefined : undefined
|
||||
>undefined : undefined, Symbol(undefined)
|
||||
}
|
||||
|
||||
return ts.ScriptSnapshot.fromString(fs.readFileSync(fileName).toString());
|
||||
>ts.ScriptSnapshot.fromString(fs.readFileSync(fileName).toString()) : ts.IScriptSnapshot
|
||||
>ts.ScriptSnapshot.fromString : (text: string) => ts.IScriptSnapshot
|
||||
>ts.ScriptSnapshot : typeof ts.ScriptSnapshot
|
||||
>ts : typeof ts
|
||||
>ScriptSnapshot : typeof ts.ScriptSnapshot
|
||||
>fromString : (text: string) => ts.IScriptSnapshot
|
||||
>ts.ScriptSnapshot.fromString : (text: string) => ts.IScriptSnapshot, Symbol(ts.ScriptSnapshot.fromString,Decl(typescript.d.ts,1288,27))
|
||||
>ts.ScriptSnapshot : typeof ts.ScriptSnapshot, Symbol(ts.ScriptSnapshot,Decl(typescript.d.ts,1287,5))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_watcher.ts,12,6))
|
||||
>ScriptSnapshot : typeof ts.ScriptSnapshot, Symbol(ts.ScriptSnapshot,Decl(typescript.d.ts,1287,5))
|
||||
>fromString : (text: string) => ts.IScriptSnapshot, Symbol(ts.ScriptSnapshot.fromString,Decl(typescript.d.ts,1288,27))
|
||||
>fs.readFileSync(fileName).toString() : any
|
||||
>fs.readFileSync(fileName).toString : any
|
||||
>fs.readFileSync(fileName) : any
|
||||
>fs.readFileSync : any
|
||||
>fs : any
|
||||
>fs : any, Symbol(fs,Decl(APISample_watcher.ts,9,11))
|
||||
>readFileSync : any
|
||||
>fileName : string
|
||||
>fileName : string, Symbol(fileName,Decl(APISample_watcher.ts,26,28))
|
||||
>toString : any
|
||||
|
||||
},
|
||||
getCurrentDirectory: () => process.cwd(),
|
||||
>getCurrentDirectory : () => any
|
||||
>getCurrentDirectory : () => any, Symbol(getCurrentDirectory,Decl(APISample_watcher.ts,32,10))
|
||||
>() => process.cwd() : () => any
|
||||
>process.cwd() : any
|
||||
>process.cwd : any
|
||||
>process : any
|
||||
>process : any, Symbol(process,Decl(APISample_watcher.ts,7,11))
|
||||
>cwd : any
|
||||
|
||||
getCompilationSettings: () => options,
|
||||
>getCompilationSettings : () => ts.CompilerOptions
|
||||
>getCompilationSettings : () => ts.CompilerOptions, Symbol(getCompilationSettings,Decl(APISample_watcher.ts,33,49))
|
||||
>() => options : () => ts.CompilerOptions
|
||||
>options : ts.CompilerOptions
|
||||
>options : ts.CompilerOptions, Symbol(options,Decl(APISample_watcher.ts,14,39))
|
||||
|
||||
getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),
|
||||
>getDefaultLibFileName : (options: ts.CompilerOptions) => string
|
||||
>getDefaultLibFileName : (options: ts.CompilerOptions) => string, Symbol(getDefaultLibFileName,Decl(APISample_watcher.ts,34,46))
|
||||
>(options) => ts.getDefaultLibFilePath(options) : (options: ts.CompilerOptions) => string
|
||||
>options : ts.CompilerOptions
|
||||
>options : ts.CompilerOptions, Symbol(options,Decl(APISample_watcher.ts,35,32))
|
||||
>ts.getDefaultLibFilePath(options) : string
|
||||
>ts.getDefaultLibFilePath : (options: ts.CompilerOptions) => string
|
||||
>ts : typeof ts
|
||||
>getDefaultLibFilePath : (options: ts.CompilerOptions) => string
|
||||
>options : ts.CompilerOptions
|
||||
>ts.getDefaultLibFilePath : (options: ts.CompilerOptions) => string, Symbol(ts.getDefaultLibFilePath,Decl(typescript.d.ts,1737,44))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_watcher.ts,12,6))
|
||||
>getDefaultLibFilePath : (options: ts.CompilerOptions) => string, Symbol(ts.getDefaultLibFilePath,Decl(typescript.d.ts,1737,44))
|
||||
>options : ts.CompilerOptions, Symbol(options,Decl(APISample_watcher.ts,35,32))
|
||||
|
||||
};
|
||||
|
||||
// Create the language service files
|
||||
const services = ts.createLanguageService(servicesHost, ts.createDocumentRegistry())
|
||||
>services : ts.LanguageService
|
||||
>services : ts.LanguageService, Symbol(services,Decl(APISample_watcher.ts,39,9))
|
||||
>ts.createLanguageService(servicesHost, ts.createDocumentRegistry()) : ts.LanguageService
|
||||
>ts.createLanguageService : (host: ts.LanguageServiceHost, documentRegistry?: ts.DocumentRegistry) => ts.LanguageService
|
||||
>ts : typeof ts
|
||||
>createLanguageService : (host: ts.LanguageServiceHost, documentRegistry?: ts.DocumentRegistry) => ts.LanguageService
|
||||
>servicesHost : ts.LanguageServiceHost
|
||||
>ts.createLanguageService : (host: ts.LanguageServiceHost, documentRegistry?: ts.DocumentRegistry) => ts.LanguageService, Symbol(ts.createLanguageService,Decl(typescript.d.ts,1735,97))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_watcher.ts,12,6))
|
||||
>createLanguageService : (host: ts.LanguageServiceHost, documentRegistry?: ts.DocumentRegistry) => ts.LanguageService, Symbol(ts.createLanguageService,Decl(typescript.d.ts,1735,97))
|
||||
>servicesHost : ts.LanguageServiceHost, Symbol(servicesHost,Decl(APISample_watcher.ts,23,9))
|
||||
>ts.createDocumentRegistry() : ts.DocumentRegistry
|
||||
>ts.createDocumentRegistry : () => ts.DocumentRegistry
|
||||
>ts : typeof ts
|
||||
>createDocumentRegistry : () => ts.DocumentRegistry
|
||||
>ts.createDocumentRegistry : () => ts.DocumentRegistry, Symbol(ts.createDocumentRegistry,Decl(typescript.d.ts,1733,193))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_watcher.ts,12,6))
|
||||
>createDocumentRegistry : () => ts.DocumentRegistry, Symbol(ts.createDocumentRegistry,Decl(typescript.d.ts,1733,193))
|
||||
|
||||
// Now let's watch the files
|
||||
rootFileNames.forEach(fileName => {
|
||||
>rootFileNames.forEach(fileName => { // First time around, emit all files emitFile(fileName); // Add a watch on the file to handle next change fs.watchFile(fileName, { persistent: true, interval: 250 }, (curr, prev) => { // Check timestamp if (+curr.mtime <= +prev.mtime) { return; } // Update the version to signal a change in the file files[fileName].version++; // write the changes to disk emitFile(fileName); }); }) : void
|
||||
>rootFileNames.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
|
||||
>rootFileNames : string[]
|
||||
>forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
|
||||
>rootFileNames.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void, Symbol(Array.forEach,Decl(lib.d.ts,1108,95))
|
||||
>rootFileNames : string[], Symbol(rootFileNames,Decl(APISample_watcher.ts,14,15))
|
||||
>forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void, Symbol(Array.forEach,Decl(lib.d.ts,1108,95))
|
||||
>fileName => { // First time around, emit all files emitFile(fileName); // Add a watch on the file to handle next change fs.watchFile(fileName, { persistent: true, interval: 250 }, (curr, prev) => { // Check timestamp if (+curr.mtime <= +prev.mtime) { return; } // Update the version to signal a change in the file files[fileName].version++; // write the changes to disk emitFile(fileName); }); } : (fileName: string) => void
|
||||
>fileName : string
|
||||
>fileName : string, Symbol(fileName,Decl(APISample_watcher.ts,42,26))
|
||||
|
||||
// First time around, emit all files
|
||||
emitFile(fileName);
|
||||
>emitFile(fileName) : void
|
||||
>emitFile : (fileName: string) => void
|
||||
>fileName : string
|
||||
>emitFile : (fileName: string) => void, Symbol(emitFile,Decl(APISample_watcher.ts,61,7))
|
||||
>fileName : string, Symbol(fileName,Decl(APISample_watcher.ts,42,26))
|
||||
|
||||
// Add a watch on the file to handle next change
|
||||
fs.watchFile(fileName,
|
||||
>fs.watchFile(fileName, { persistent: true, interval: 250 }, (curr, prev) => { // Check timestamp if (+curr.mtime <= +prev.mtime) { return; } // Update the version to signal a change in the file files[fileName].version++; // write the changes to disk emitFile(fileName); }) : any
|
||||
>fs.watchFile : any
|
||||
>fs : any
|
||||
>fs : any, Symbol(fs,Decl(APISample_watcher.ts,9,11))
|
||||
>watchFile : any
|
||||
>fileName : string
|
||||
>fileName : string, Symbol(fileName,Decl(APISample_watcher.ts,42,26))
|
||||
|
||||
{ persistent: true, interval: 250 },
|
||||
>{ persistent: true, interval: 250 } : { persistent: boolean; interval: number; }
|
||||
>persistent : boolean
|
||||
>persistent : boolean, Symbol(persistent,Decl(APISample_watcher.ts,48,13))
|
||||
>true : boolean
|
||||
>interval : number
|
||||
>interval : number, Symbol(interval,Decl(APISample_watcher.ts,48,31))
|
||||
>250 : number
|
||||
|
||||
(curr, prev) => {
|
||||
>(curr, prev) => { // Check timestamp if (+curr.mtime <= +prev.mtime) { return; } // Update the version to signal a change in the file files[fileName].version++; // write the changes to disk emitFile(fileName); } : (curr: any, prev: any) => void
|
||||
>curr : any
|
||||
>prev : any
|
||||
>curr : any, Symbol(curr,Decl(APISample_watcher.ts,49,13))
|
||||
>prev : any, Symbol(prev,Decl(APISample_watcher.ts,49,18))
|
||||
|
||||
// Check timestamp
|
||||
if (+curr.mtime <= +prev.mtime) {
|
||||
>+curr.mtime <= +prev.mtime : boolean
|
||||
>+curr.mtime : number
|
||||
>curr.mtime : any
|
||||
>curr : any
|
||||
>curr : any, Symbol(curr,Decl(APISample_watcher.ts,49,13))
|
||||
>mtime : any
|
||||
>+prev.mtime : number
|
||||
>prev.mtime : any
|
||||
>prev : any
|
||||
>prev : any, Symbol(prev,Decl(APISample_watcher.ts,49,18))
|
||||
>mtime : any
|
||||
|
||||
return;
|
||||
@@ -209,183 +209,183 @@ function watch(rootFileNames: string[], options: ts.CompilerOptions) {
|
||||
// Update the version to signal a change in the file
|
||||
files[fileName].version++;
|
||||
>files[fileName].version++ : number
|
||||
>files[fileName].version : number
|
||||
>files[fileName].version : number, Symbol(version,Decl(APISample_watcher.ts,15,25))
|
||||
>files[fileName] : { version: number; }
|
||||
>files : ts.Map<{ version: number; }>
|
||||
>fileName : string
|
||||
>version : number
|
||||
>files : ts.Map<{ version: number; }>, Symbol(files,Decl(APISample_watcher.ts,15,9))
|
||||
>fileName : string, Symbol(fileName,Decl(APISample_watcher.ts,42,26))
|
||||
>version : number, Symbol(version,Decl(APISample_watcher.ts,15,25))
|
||||
|
||||
// write the changes to disk
|
||||
emitFile(fileName);
|
||||
>emitFile(fileName) : void
|
||||
>emitFile : (fileName: string) => void
|
||||
>fileName : string
|
||||
>emitFile : (fileName: string) => void, Symbol(emitFile,Decl(APISample_watcher.ts,61,7))
|
||||
>fileName : string, Symbol(fileName,Decl(APISample_watcher.ts,42,26))
|
||||
|
||||
});
|
||||
});
|
||||
|
||||
function emitFile(fileName: string) {
|
||||
>emitFile : (fileName: string) => void
|
||||
>fileName : string
|
||||
>emitFile : (fileName: string) => void, Symbol(emitFile,Decl(APISample_watcher.ts,61,7))
|
||||
>fileName : string, Symbol(fileName,Decl(APISample_watcher.ts,63,22))
|
||||
|
||||
let output = services.getEmitOutput(fileName);
|
||||
>output : ts.EmitOutput
|
||||
>output : ts.EmitOutput, Symbol(output,Decl(APISample_watcher.ts,64,11))
|
||||
>services.getEmitOutput(fileName) : ts.EmitOutput
|
||||
>services.getEmitOutput : (fileName: string) => ts.EmitOutput
|
||||
>services : ts.LanguageService
|
||||
>getEmitOutput : (fileName: string) => ts.EmitOutput
|
||||
>fileName : string
|
||||
>services.getEmitOutput : (fileName: string) => ts.EmitOutput, Symbol(ts.LanguageService.getEmitOutput,Decl(typescript.d.ts,1339,132))
|
||||
>services : ts.LanguageService, Symbol(services,Decl(APISample_watcher.ts,39,9))
|
||||
>getEmitOutput : (fileName: string) => ts.EmitOutput, Symbol(ts.LanguageService.getEmitOutput,Decl(typescript.d.ts,1339,132))
|
||||
>fileName : string, Symbol(fileName,Decl(APISample_watcher.ts,63,22))
|
||||
|
||||
if (!output.emitSkipped) {
|
||||
>!output.emitSkipped : boolean
|
||||
>output.emitSkipped : boolean
|
||||
>output : ts.EmitOutput
|
||||
>emitSkipped : boolean
|
||||
>output.emitSkipped : boolean, Symbol(ts.EmitOutput.emitSkipped,Decl(typescript.d.ts,1542,34))
|
||||
>output : ts.EmitOutput, Symbol(output,Decl(APISample_watcher.ts,64,11))
|
||||
>emitSkipped : boolean, Symbol(ts.EmitOutput.emitSkipped,Decl(typescript.d.ts,1542,34))
|
||||
|
||||
console.log(`Emitting ${fileName}`);
|
||||
>console.log(`Emitting ${fileName}`) : any
|
||||
>console.log : any
|
||||
>console : any
|
||||
>console : any, Symbol(console,Decl(APISample_watcher.ts,8,11))
|
||||
>log : any
|
||||
>`Emitting ${fileName}` : string
|
||||
>fileName : string
|
||||
>fileName : string, Symbol(fileName,Decl(APISample_watcher.ts,63,22))
|
||||
}
|
||||
else {
|
||||
console.log(`Emitting ${fileName} failed`);
|
||||
>console.log(`Emitting ${fileName} failed`) : any
|
||||
>console.log : any
|
||||
>console : any
|
||||
>console : any, Symbol(console,Decl(APISample_watcher.ts,8,11))
|
||||
>log : any
|
||||
>`Emitting ${fileName} failed` : string
|
||||
>fileName : string
|
||||
>fileName : string, Symbol(fileName,Decl(APISample_watcher.ts,63,22))
|
||||
|
||||
logErrors(fileName);
|
||||
>logErrors(fileName) : void
|
||||
>logErrors : (fileName: string) => void
|
||||
>fileName : string
|
||||
>logErrors : (fileName: string) => void, Symbol(logErrors,Decl(APISample_watcher.ts,77,5))
|
||||
>fileName : string, Symbol(fileName,Decl(APISample_watcher.ts,63,22))
|
||||
}
|
||||
|
||||
output.outputFiles.forEach(o => {
|
||||
>output.outputFiles.forEach(o => { fs.writeFileSync(o.name, o.text, "utf8"); }) : void
|
||||
>output.outputFiles.forEach : (callbackfn: (value: ts.OutputFile, index: number, array: ts.OutputFile[]) => void, thisArg?: any) => void
|
||||
>output.outputFiles : ts.OutputFile[]
|
||||
>output : ts.EmitOutput
|
||||
>outputFiles : ts.OutputFile[]
|
||||
>forEach : (callbackfn: (value: ts.OutputFile, index: number, array: ts.OutputFile[]) => void, thisArg?: any) => void
|
||||
>output.outputFiles.forEach : (callbackfn: (value: ts.OutputFile, index: number, array: ts.OutputFile[]) => void, thisArg?: any) => void, Symbol(Array.forEach,Decl(lib.d.ts,1108,95))
|
||||
>output.outputFiles : ts.OutputFile[], Symbol(ts.EmitOutput.outputFiles,Decl(typescript.d.ts,1541,26))
|
||||
>output : ts.EmitOutput, Symbol(output,Decl(APISample_watcher.ts,64,11))
|
||||
>outputFiles : ts.OutputFile[], Symbol(ts.EmitOutput.outputFiles,Decl(typescript.d.ts,1541,26))
|
||||
>forEach : (callbackfn: (value: ts.OutputFile, index: number, array: ts.OutputFile[]) => void, thisArg?: any) => void, Symbol(Array.forEach,Decl(lib.d.ts,1108,95))
|
||||
>o => { fs.writeFileSync(o.name, o.text, "utf8"); } : (o: ts.OutputFile) => void
|
||||
>o : ts.OutputFile
|
||||
>o : ts.OutputFile, Symbol(o,Decl(APISample_watcher.ts,74,35))
|
||||
|
||||
fs.writeFileSync(o.name, o.text, "utf8");
|
||||
>fs.writeFileSync(o.name, o.text, "utf8") : any
|
||||
>fs.writeFileSync : any
|
||||
>fs : any
|
||||
>fs : any, Symbol(fs,Decl(APISample_watcher.ts,9,11))
|
||||
>writeFileSync : any
|
||||
>o.name : string
|
||||
>o : ts.OutputFile
|
||||
>name : string
|
||||
>o.text : string
|
||||
>o : ts.OutputFile
|
||||
>text : string
|
||||
>o.name : string, Symbol(ts.OutputFile.name,Decl(typescript.d.ts,1550,26))
|
||||
>o : ts.OutputFile, Symbol(o,Decl(APISample_watcher.ts,74,35))
|
||||
>name : string, Symbol(ts.OutputFile.name,Decl(typescript.d.ts,1550,26))
|
||||
>o.text : string, Symbol(ts.OutputFile.text,Decl(typescript.d.ts,1552,36))
|
||||
>o : ts.OutputFile, Symbol(o,Decl(APISample_watcher.ts,74,35))
|
||||
>text : string, Symbol(ts.OutputFile.text,Decl(typescript.d.ts,1552,36))
|
||||
>"utf8" : string
|
||||
|
||||
});
|
||||
}
|
||||
|
||||
function logErrors(fileName: string) {
|
||||
>logErrors : (fileName: string) => void
|
||||
>fileName : string
|
||||
>logErrors : (fileName: string) => void, Symbol(logErrors,Decl(APISample_watcher.ts,77,5))
|
||||
>fileName : string, Symbol(fileName,Decl(APISample_watcher.ts,79,23))
|
||||
|
||||
let allDiagnostics = services.getCompilerOptionsDiagnostics()
|
||||
>allDiagnostics : ts.Diagnostic[]
|
||||
>allDiagnostics : ts.Diagnostic[], Symbol(allDiagnostics,Decl(APISample_watcher.ts,80,11))
|
||||
>services.getCompilerOptionsDiagnostics() .concat(services.getSyntacticDiagnostics(fileName)) .concat(services.getSemanticDiagnostics(fileName)) : ts.Diagnostic[]
|
||||
>services.getCompilerOptionsDiagnostics() .concat(services.getSyntacticDiagnostics(fileName)) .concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }
|
||||
>services.getCompilerOptionsDiagnostics() .concat(services.getSyntacticDiagnostics(fileName)) .concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }, Symbol(Array.concat,Decl(lib.d.ts,1025,13),Decl(lib.d.ts,1030,46))
|
||||
>services.getCompilerOptionsDiagnostics() .concat(services.getSyntacticDiagnostics(fileName)) : ts.Diagnostic[]
|
||||
>services.getCompilerOptionsDiagnostics() .concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }
|
||||
>services.getCompilerOptionsDiagnostics() .concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }, Symbol(Array.concat,Decl(lib.d.ts,1025,13),Decl(lib.d.ts,1030,46))
|
||||
>services.getCompilerOptionsDiagnostics() : ts.Diagnostic[]
|
||||
>services.getCompilerOptionsDiagnostics : () => ts.Diagnostic[]
|
||||
>services : ts.LanguageService
|
||||
>getCompilerOptionsDiagnostics : () => ts.Diagnostic[]
|
||||
>services.getCompilerOptionsDiagnostics : () => ts.Diagnostic[], Symbol(ts.LanguageService.getCompilerOptionsDiagnostics,Decl(typescript.d.ts,1313,63))
|
||||
>services : ts.LanguageService, Symbol(services,Decl(APISample_watcher.ts,39,9))
|
||||
>getCompilerOptionsDiagnostics : () => ts.Diagnostic[], Symbol(ts.LanguageService.getCompilerOptionsDiagnostics,Decl(typescript.d.ts,1313,63))
|
||||
|
||||
.concat(services.getSyntacticDiagnostics(fileName))
|
||||
>concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }
|
||||
>concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }, Symbol(Array.concat,Decl(lib.d.ts,1025,13),Decl(lib.d.ts,1030,46))
|
||||
>services.getSyntacticDiagnostics(fileName) : ts.Diagnostic[]
|
||||
>services.getSyntacticDiagnostics : (fileName: string) => ts.Diagnostic[]
|
||||
>services : ts.LanguageService
|
||||
>getSyntacticDiagnostics : (fileName: string) => ts.Diagnostic[]
|
||||
>fileName : string
|
||||
>services.getSyntacticDiagnostics : (fileName: string) => ts.Diagnostic[], Symbol(ts.LanguageService.getSyntacticDiagnostics,Decl(typescript.d.ts,1311,37))
|
||||
>services : ts.LanguageService, Symbol(services,Decl(APISample_watcher.ts,39,9))
|
||||
>getSyntacticDiagnostics : (fileName: string) => ts.Diagnostic[], Symbol(ts.LanguageService.getSyntacticDiagnostics,Decl(typescript.d.ts,1311,37))
|
||||
>fileName : string, Symbol(fileName,Decl(APISample_watcher.ts,79,23))
|
||||
|
||||
.concat(services.getSemanticDiagnostics(fileName));
|
||||
>concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }
|
||||
>concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }, Symbol(Array.concat,Decl(lib.d.ts,1025,13),Decl(lib.d.ts,1030,46))
|
||||
>services.getSemanticDiagnostics(fileName) : ts.Diagnostic[]
|
||||
>services.getSemanticDiagnostics : (fileName: string) => ts.Diagnostic[]
|
||||
>services : ts.LanguageService
|
||||
>getSemanticDiagnostics : (fileName: string) => ts.Diagnostic[]
|
||||
>fileName : string
|
||||
>services.getSemanticDiagnostics : (fileName: string) => ts.Diagnostic[], Symbol(ts.LanguageService.getSemanticDiagnostics,Decl(typescript.d.ts,1312,64))
|
||||
>services : ts.LanguageService, Symbol(services,Decl(APISample_watcher.ts,39,9))
|
||||
>getSemanticDiagnostics : (fileName: string) => ts.Diagnostic[], Symbol(ts.LanguageService.getSemanticDiagnostics,Decl(typescript.d.ts,1312,64))
|
||||
>fileName : string, Symbol(fileName,Decl(APISample_watcher.ts,79,23))
|
||||
|
||||
allDiagnostics.forEach(diagnostic => {
|
||||
>allDiagnostics.forEach(diagnostic => { let message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"); if (diagnostic.file) { let { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start); console.log(` Error ${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`); } else { console.log(` Error: ${message}`); } }) : void
|
||||
>allDiagnostics.forEach : (callbackfn: (value: ts.Diagnostic, index: number, array: ts.Diagnostic[]) => void, thisArg?: any) => void
|
||||
>allDiagnostics : ts.Diagnostic[]
|
||||
>forEach : (callbackfn: (value: ts.Diagnostic, index: number, array: ts.Diagnostic[]) => void, thisArg?: any) => void
|
||||
>allDiagnostics.forEach : (callbackfn: (value: ts.Diagnostic, index: number, array: ts.Diagnostic[]) => void, thisArg?: any) => void, Symbol(Array.forEach,Decl(lib.d.ts,1108,95))
|
||||
>allDiagnostics : ts.Diagnostic[], Symbol(allDiagnostics,Decl(APISample_watcher.ts,80,11))
|
||||
>forEach : (callbackfn: (value: ts.Diagnostic, index: number, array: ts.Diagnostic[]) => void, thisArg?: any) => void, Symbol(Array.forEach,Decl(lib.d.ts,1108,95))
|
||||
>diagnostic => { let message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"); if (diagnostic.file) { let { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start); console.log(` Error ${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`); } else { console.log(` Error: ${message}`); } } : (diagnostic: ts.Diagnostic) => void
|
||||
>diagnostic : ts.Diagnostic
|
||||
>diagnostic : ts.Diagnostic, Symbol(diagnostic,Decl(APISample_watcher.ts,84,31))
|
||||
|
||||
let message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
|
||||
>message : string
|
||||
>message : string, Symbol(message,Decl(APISample_watcher.ts,85,15))
|
||||
>ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n") : string
|
||||
>ts.flattenDiagnosticMessageText : (messageText: string | ts.DiagnosticMessageChain, newLine: string) => string
|
||||
>ts : typeof ts
|
||||
>flattenDiagnosticMessageText : (messageText: string | ts.DiagnosticMessageChain, newLine: string) => string
|
||||
>diagnostic.messageText : string | ts.DiagnosticMessageChain
|
||||
>diagnostic : ts.Diagnostic
|
||||
>messageText : string | ts.DiagnosticMessageChain
|
||||
>ts.flattenDiagnosticMessageText : (messageText: string | ts.DiagnosticMessageChain, newLine: string) => string, Symbol(ts.flattenDiagnosticMessageText,Decl(typescript.d.ts,1200,67))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_watcher.ts,12,6))
|
||||
>flattenDiagnosticMessageText : (messageText: string | ts.DiagnosticMessageChain, newLine: string) => string, Symbol(ts.flattenDiagnosticMessageText,Decl(typescript.d.ts,1200,67))
|
||||
>diagnostic.messageText : string | ts.DiagnosticMessageChain, Symbol(ts.Diagnostic.messageText,Decl(typescript.d.ts,1065,23))
|
||||
>diagnostic : ts.Diagnostic, Symbol(diagnostic,Decl(APISample_watcher.ts,84,31))
|
||||
>messageText : string | ts.DiagnosticMessageChain, Symbol(ts.Diagnostic.messageText,Decl(typescript.d.ts,1065,23))
|
||||
>"\n" : string
|
||||
|
||||
if (diagnostic.file) {
|
||||
>diagnostic.file : ts.SourceFile
|
||||
>diagnostic : ts.Diagnostic
|
||||
>file : ts.SourceFile
|
||||
>diagnostic.file : ts.SourceFile, Symbol(ts.Diagnostic.file,Decl(typescript.d.ts,1062,26))
|
||||
>diagnostic : ts.Diagnostic, Symbol(diagnostic,Decl(APISample_watcher.ts,84,31))
|
||||
>file : ts.SourceFile, Symbol(ts.Diagnostic.file,Decl(typescript.d.ts,1062,26))
|
||||
|
||||
let { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
|
||||
>line : number
|
||||
>character : number
|
||||
>line : number, Symbol(line,Decl(APISample_watcher.ts,87,21))
|
||||
>character : number, Symbol(character,Decl(APISample_watcher.ts,87,27))
|
||||
>diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start) : ts.LineAndCharacter
|
||||
>diagnostic.file.getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter
|
||||
>diagnostic.file : ts.SourceFile
|
||||
>diagnostic : ts.Diagnostic
|
||||
>file : ts.SourceFile
|
||||
>getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter
|
||||
>diagnostic.start : number
|
||||
>diagnostic : ts.Diagnostic
|
||||
>start : number
|
||||
>diagnostic.file.getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter, Symbol(ts.SourceFile.getLineAndCharacterOfPosition,Decl(typescript.d.ts,1263,46))
|
||||
>diagnostic.file : ts.SourceFile, Symbol(ts.Diagnostic.file,Decl(typescript.d.ts,1062,26))
|
||||
>diagnostic : ts.Diagnostic, Symbol(diagnostic,Decl(APISample_watcher.ts,84,31))
|
||||
>file : ts.SourceFile, Symbol(ts.Diagnostic.file,Decl(typescript.d.ts,1062,26))
|
||||
>getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter, Symbol(ts.SourceFile.getLineAndCharacterOfPosition,Decl(typescript.d.ts,1263,46))
|
||||
>diagnostic.start : number, Symbol(ts.Diagnostic.start,Decl(typescript.d.ts,1063,25))
|
||||
>diagnostic : ts.Diagnostic, Symbol(diagnostic,Decl(APISample_watcher.ts,84,31))
|
||||
>start : number, Symbol(ts.Diagnostic.start,Decl(typescript.d.ts,1063,25))
|
||||
|
||||
console.log(` Error ${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
|
||||
>console.log(` Error ${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`) : any
|
||||
>console.log : any
|
||||
>console : any
|
||||
>console : any, Symbol(console,Decl(APISample_watcher.ts,8,11))
|
||||
>log : any
|
||||
>` Error ${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}` : string
|
||||
>diagnostic.file.fileName : string
|
||||
>diagnostic.file : ts.SourceFile
|
||||
>diagnostic : ts.Diagnostic
|
||||
>file : ts.SourceFile
|
||||
>fileName : string
|
||||
>diagnostic.file.fileName : string, Symbol(ts.SourceFile.fileName,Decl(typescript.d.ts,743,29))
|
||||
>diagnostic.file : ts.SourceFile, Symbol(ts.Diagnostic.file,Decl(typescript.d.ts,1062,26))
|
||||
>diagnostic : ts.Diagnostic, Symbol(diagnostic,Decl(APISample_watcher.ts,84,31))
|
||||
>file : ts.SourceFile, Symbol(ts.Diagnostic.file,Decl(typescript.d.ts,1062,26))
|
||||
>fileName : string, Symbol(ts.SourceFile.fileName,Decl(typescript.d.ts,743,29))
|
||||
>line + 1 : number
|
||||
>line : number
|
||||
>line : number, Symbol(line,Decl(APISample_watcher.ts,87,21))
|
||||
>1 : number
|
||||
>character + 1 : number
|
||||
>character : number
|
||||
>character : number, Symbol(character,Decl(APISample_watcher.ts,87,27))
|
||||
>1 : number
|
||||
>message : string
|
||||
>message : string, Symbol(message,Decl(APISample_watcher.ts,85,15))
|
||||
}
|
||||
else {
|
||||
console.log(` Error: ${message}`);
|
||||
>console.log(` Error: ${message}`) : any
|
||||
>console.log : any
|
||||
>console : any
|
||||
>console : any, Symbol(console,Decl(APISample_watcher.ts,8,11))
|
||||
>log : any
|
||||
>` Error: ${message}` : string
|
||||
>message : string
|
||||
>message : string, Symbol(message,Decl(APISample_watcher.ts,85,15))
|
||||
}
|
||||
});
|
||||
}
|
||||
@@ -393,36 +393,36 @@ function watch(rootFileNames: string[], options: ts.CompilerOptions) {
|
||||
|
||||
// Initialize files constituting the program as all .ts files in the current directory
|
||||
const currentDirectoryFiles = fs.readdirSync(process.cwd()).
|
||||
>currentDirectoryFiles : any
|
||||
>currentDirectoryFiles : any, Symbol(currentDirectoryFiles,Decl(APISample_watcher.ts,98,5))
|
||||
>fs.readdirSync(process.cwd()). filter(fileName=> fileName.length >= 3 && fileName.substr(fileName.length - 3, 3) === ".ts") : any
|
||||
>fs.readdirSync(process.cwd()). filter : any
|
||||
>fs.readdirSync(process.cwd()) : any
|
||||
>fs.readdirSync : any
|
||||
>fs : any
|
||||
>fs : any, Symbol(fs,Decl(APISample_watcher.ts,9,11))
|
||||
>readdirSync : any
|
||||
>process.cwd() : any
|
||||
>process.cwd : any
|
||||
>process : any
|
||||
>process : any, Symbol(process,Decl(APISample_watcher.ts,7,11))
|
||||
>cwd : any
|
||||
|
||||
filter(fileName=> fileName.length >= 3 && fileName.substr(fileName.length - 3, 3) === ".ts");
|
||||
>filter : any
|
||||
>fileName=> fileName.length >= 3 && fileName.substr(fileName.length - 3, 3) === ".ts" : (fileName: any) => boolean
|
||||
>fileName : any
|
||||
>fileName : any, Symbol(fileName,Decl(APISample_watcher.ts,99,11))
|
||||
>fileName.length >= 3 && fileName.substr(fileName.length - 3, 3) === ".ts" : boolean
|
||||
>fileName.length >= 3 : boolean
|
||||
>fileName.length : any
|
||||
>fileName : any
|
||||
>fileName : any, Symbol(fileName,Decl(APISample_watcher.ts,99,11))
|
||||
>length : any
|
||||
>3 : number
|
||||
>fileName.substr(fileName.length - 3, 3) === ".ts" : boolean
|
||||
>fileName.substr(fileName.length - 3, 3) : any
|
||||
>fileName.substr : any
|
||||
>fileName : any
|
||||
>fileName : any, Symbol(fileName,Decl(APISample_watcher.ts,99,11))
|
||||
>substr : any
|
||||
>fileName.length - 3 : number
|
||||
>fileName.length : any
|
||||
>fileName : any
|
||||
>fileName : any, Symbol(fileName,Decl(APISample_watcher.ts,99,11))
|
||||
>length : any
|
||||
>3 : number
|
||||
>3 : number
|
||||
@@ -431,13 +431,13 @@ const currentDirectoryFiles = fs.readdirSync(process.cwd()).
|
||||
// Start the watcher
|
||||
watch(currentDirectoryFiles, { module: ts.ModuleKind.CommonJS });
|
||||
>watch(currentDirectoryFiles, { module: ts.ModuleKind.CommonJS }) : void
|
||||
>watch : (rootFileNames: string[], options: ts.CompilerOptions) => void
|
||||
>currentDirectoryFiles : any
|
||||
>watch : (rootFileNames: string[], options: ts.CompilerOptions) => void, Symbol(watch,Decl(APISample_watcher.ts,12,33))
|
||||
>currentDirectoryFiles : any, Symbol(currentDirectoryFiles,Decl(APISample_watcher.ts,98,5))
|
||||
>{ module: ts.ModuleKind.CommonJS } : { [x: string]: ts.ModuleKind; module: ts.ModuleKind; }
|
||||
>module : ts.ModuleKind
|
||||
>ts.ModuleKind.CommonJS : ts.ModuleKind
|
||||
>ts.ModuleKind : typeof ts.ModuleKind
|
||||
>ts : typeof ts
|
||||
>ModuleKind : typeof ts.ModuleKind
|
||||
>CommonJS : ts.ModuleKind
|
||||
>module : ts.ModuleKind, Symbol(module,Decl(APISample_watcher.ts,102,30))
|
||||
>ts.ModuleKind.CommonJS : ts.ModuleKind, Symbol(ts.ModuleKind.CommonJS,Decl(typescript.d.ts,1108,17))
|
||||
>ts.ModuleKind : typeof ts.ModuleKind, Symbol(ts.ModuleKind,Decl(typescript.d.ts,1106,5))
|
||||
>ts : typeof ts, Symbol(ts,Decl(APISample_watcher.ts,12,6))
|
||||
>ModuleKind : typeof ts.ModuleKind, Symbol(ts.ModuleKind,Decl(typescript.d.ts,1106,5))
|
||||
>CommonJS : ts.ModuleKind, Symbol(ts.ModuleKind.CommonJS,Decl(typescript.d.ts,1108,17))
|
||||
|
||||
|
||||
+16
-16
@@ -1,33 +1,33 @@
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/module.d.ts ===
|
||||
declare module Point {
|
||||
>Point : typeof Point
|
||||
>Point : typeof Point, Symbol(Point,Decl(module.d.ts,0,0),Decl(function.d.ts,0,0))
|
||||
|
||||
export var Origin: { x: number; y: number; }
|
||||
>Origin : { x: number; y: number; }
|
||||
>x : number
|
||||
>y : number
|
||||
>Origin : { x: number; y: number; }, Symbol(Origin,Decl(module.d.ts,1,14))
|
||||
>x : number, Symbol(x,Decl(module.d.ts,1,24))
|
||||
>y : number, Symbol(y,Decl(module.d.ts,1,35))
|
||||
}
|
||||
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/function.d.ts ===
|
||||
declare function Point(): { x: number; y: number; }
|
||||
>Point : typeof Point
|
||||
>x : number
|
||||
>y : number
|
||||
>Point : typeof Point, Symbol(Point,Decl(module.d.ts,0,0),Decl(function.d.ts,0,0))
|
||||
>x : number, Symbol(x,Decl(function.d.ts,0,27))
|
||||
>y : number, Symbol(y,Decl(function.d.ts,0,38))
|
||||
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
|
||||
var cl: { x: number; y: number; }
|
||||
>cl : { x: number; y: number; }
|
||||
>x : number
|
||||
>y : number
|
||||
>cl : { x: number; y: number; }, Symbol(cl,Decl(test.ts,0,3),Decl(test.ts,1,3),Decl(test.ts,2,3))
|
||||
>x : number, Symbol(x,Decl(test.ts,0,9))
|
||||
>y : number, Symbol(y,Decl(test.ts,0,20))
|
||||
|
||||
var cl = Point();
|
||||
>cl : { x: number; y: number; }
|
||||
>cl : { x: number; y: number; }, Symbol(cl,Decl(test.ts,0,3),Decl(test.ts,1,3),Decl(test.ts,2,3))
|
||||
>Point() : { x: number; y: number; }
|
||||
>Point : typeof Point
|
||||
>Point : typeof Point, Symbol(Point,Decl(module.d.ts,0,0),Decl(function.d.ts,0,0))
|
||||
|
||||
var cl = Point.Origin;
|
||||
>cl : { x: number; y: number; }
|
||||
>Point.Origin : { x: number; y: number; }
|
||||
>Point : typeof Point
|
||||
>Origin : { x: number; y: number; }
|
||||
>cl : { x: number; y: number; }, Symbol(cl,Decl(test.ts,0,3),Decl(test.ts,1,3),Decl(test.ts,2,3))
|
||||
>Point.Origin : { x: number; y: number; }, Symbol(Point.Origin,Decl(module.d.ts,1,14))
|
||||
>Point : typeof Point, Symbol(Point,Decl(module.d.ts,0,0),Decl(function.d.ts,0,0))
|
||||
>Origin : { x: number; y: number; }, Symbol(Point.Origin,Decl(module.d.ts,1,14))
|
||||
|
||||
|
||||
@@ -1,61 +1,61 @@
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/module.d.ts ===
|
||||
declare module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(module.d.ts,0,0),Decl(class.d.ts,0,0))
|
||||
|
||||
export module Point {
|
||||
>Point : typeof Point
|
||||
>Point : typeof Point, Symbol(Point,Decl(module.d.ts,0,18),Decl(class.d.ts,0,18))
|
||||
|
||||
export var Origin: {
|
||||
>Origin : { x: number; y: number; }
|
||||
>Origin : { x: number; y: number; }, Symbol(Origin,Decl(module.d.ts,2,18))
|
||||
|
||||
x: number;
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(module.d.ts,2,28))
|
||||
|
||||
y: number;
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(module.d.ts,3,22))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/class.d.ts ===
|
||||
declare module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(module.d.ts,0,0),Decl(class.d.ts,0,0))
|
||||
|
||||
export class Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(module.d.ts,0,18),Decl(class.d.ts,0,18))
|
||||
|
||||
constructor(x: number, y: number);
|
||||
>x : number
|
||||
>y : number
|
||||
>x : number, Symbol(x,Decl(class.d.ts,2,20))
|
||||
>y : number, Symbol(y,Decl(class.d.ts,2,30))
|
||||
|
||||
x: number;
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(class.d.ts,2,42))
|
||||
|
||||
y: number;
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(class.d.ts,3,18))
|
||||
}
|
||||
}
|
||||
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
|
||||
var p: { x: number; y: number; }
|
||||
>p : { x: number; y: number; }
|
||||
>x : number
|
||||
>y : number
|
||||
>p : { x: number; y: number; }, Symbol(p,Decl(test.ts,0,3),Decl(test.ts,1,3),Decl(test.ts,2,3))
|
||||
>x : number, Symbol(x,Decl(test.ts,0,8))
|
||||
>y : number, Symbol(y,Decl(test.ts,0,19))
|
||||
|
||||
var p = A.Point.Origin;
|
||||
>p : { x: number; y: number; }
|
||||
>A.Point.Origin : { x: number; y: number; }
|
||||
>A.Point : typeof A.Point
|
||||
>A : typeof A
|
||||
>Point : typeof A.Point
|
||||
>Origin : { x: number; y: number; }
|
||||
>p : { x: number; y: number; }, Symbol(p,Decl(test.ts,0,3),Decl(test.ts,1,3),Decl(test.ts,2,3))
|
||||
>A.Point.Origin : { x: number; y: number; }, Symbol(A.Point.Origin,Decl(module.d.ts,2,18))
|
||||
>A.Point : typeof A.Point, Symbol(A.Point,Decl(module.d.ts,0,18),Decl(class.d.ts,0,18))
|
||||
>A : typeof A, Symbol(A,Decl(module.d.ts,0,0),Decl(class.d.ts,0,0))
|
||||
>Point : typeof A.Point, Symbol(A.Point,Decl(module.d.ts,0,18),Decl(class.d.ts,0,18))
|
||||
>Origin : { x: number; y: number; }, Symbol(A.Point.Origin,Decl(module.d.ts,2,18))
|
||||
|
||||
var p = new A.Point(0, 0); // unexpected error here, bug 840000
|
||||
>p : { x: number; y: number; }
|
||||
>p : { x: number; y: number; }, Symbol(p,Decl(test.ts,0,3),Decl(test.ts,1,3),Decl(test.ts,2,3))
|
||||
>new A.Point(0, 0) : A.Point
|
||||
>A.Point : typeof A.Point
|
||||
>A : typeof A
|
||||
>Point : typeof A.Point
|
||||
>A.Point : typeof A.Point, Symbol(A.Point,Decl(module.d.ts,0,18),Decl(class.d.ts,0,18))
|
||||
>A : typeof A, Symbol(A,Decl(module.d.ts,0,0),Decl(class.d.ts,0,0))
|
||||
>Point : typeof A.Point, Symbol(A.Point,Decl(module.d.ts,0,18),Decl(class.d.ts,0,18))
|
||||
>0 : number
|
||||
>0 : number
|
||||
|
||||
|
||||
+22
-22
@@ -1,55 +1,55 @@
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/module.d.ts ===
|
||||
declare module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(module.d.ts,0,0),Decl(classPoint.ts,0,0))
|
||||
|
||||
export module Point {
|
||||
>Point : typeof Point
|
||||
>Point : typeof Point, Symbol(Point,Decl(module.d.ts,0,18),Decl(classPoint.ts,0,10))
|
||||
|
||||
export var Origin: {
|
||||
>Origin : { x: number; y: number; }
|
||||
>Origin : { x: number; y: number; }, Symbol(Origin,Decl(module.d.ts,2,18))
|
||||
|
||||
x: number;
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(module.d.ts,2,28))
|
||||
|
||||
y: number;
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(module.d.ts,3,22))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/classPoint.ts ===
|
||||
module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(module.d.ts,0,0),Decl(classPoint.ts,0,0))
|
||||
|
||||
export class Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(module.d.ts,0,18),Decl(classPoint.ts,0,10))
|
||||
|
||||
constructor(public x: number, public y: number) { }
|
||||
>x : number
|
||||
>y : number
|
||||
>x : number, Symbol(x,Decl(classPoint.ts,2,20))
|
||||
>y : number, Symbol(y,Decl(classPoint.ts,2,37))
|
||||
}
|
||||
}
|
||||
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
|
||||
var p: { x: number; y: number; }
|
||||
>p : { x: number; y: number; }
|
||||
>x : number
|
||||
>y : number
|
||||
>p : { x: number; y: number; }, Symbol(p,Decl(test.ts,0,3),Decl(test.ts,1,3),Decl(test.ts,2,3))
|
||||
>x : number, Symbol(x,Decl(test.ts,0,8))
|
||||
>y : number, Symbol(y,Decl(test.ts,0,19))
|
||||
|
||||
var p = A.Point.Origin;
|
||||
>p : { x: number; y: number; }
|
||||
>A.Point.Origin : { x: number; y: number; }
|
||||
>A.Point : typeof A.Point
|
||||
>A : typeof A
|
||||
>Point : typeof A.Point
|
||||
>Origin : { x: number; y: number; }
|
||||
>p : { x: number; y: number; }, Symbol(p,Decl(test.ts,0,3),Decl(test.ts,1,3),Decl(test.ts,2,3))
|
||||
>A.Point.Origin : { x: number; y: number; }, Symbol(A.Point.Origin,Decl(module.d.ts,2,18))
|
||||
>A.Point : typeof A.Point, Symbol(A.Point,Decl(module.d.ts,0,18),Decl(classPoint.ts,0,10))
|
||||
>A : typeof A, Symbol(A,Decl(module.d.ts,0,0),Decl(classPoint.ts,0,0))
|
||||
>Point : typeof A.Point, Symbol(A.Point,Decl(module.d.ts,0,18),Decl(classPoint.ts,0,10))
|
||||
>Origin : { x: number; y: number; }, Symbol(A.Point.Origin,Decl(module.d.ts,2,18))
|
||||
|
||||
var p = new A.Point(0, 0); // unexpected error here, bug 840000
|
||||
>p : { x: number; y: number; }
|
||||
>p : { x: number; y: number; }, Symbol(p,Decl(test.ts,0,3),Decl(test.ts,1,3),Decl(test.ts,2,3))
|
||||
>new A.Point(0, 0) : A.Point
|
||||
>A.Point : typeof A.Point
|
||||
>A : typeof A
|
||||
>Point : typeof A.Point
|
||||
>A.Point : typeof A.Point, Symbol(A.Point,Decl(module.d.ts,0,18),Decl(classPoint.ts,0,10))
|
||||
>A : typeof A, Symbol(A,Decl(module.d.ts,0,0),Decl(classPoint.ts,0,0))
|
||||
>Point : typeof A.Point, Symbol(A.Point,Decl(module.d.ts,0,18),Decl(classPoint.ts,0,10))
|
||||
>0 : number
|
||||
>0 : number
|
||||
|
||||
|
||||
+16
-16
@@ -1,39 +1,39 @@
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/module.d.ts ===
|
||||
declare module Point {
|
||||
>Point : typeof Point
|
||||
>Point : typeof Point, Symbol(Point,Decl(module.d.ts,0,0),Decl(function.ts,0,0))
|
||||
|
||||
export var Origin: { x: number; y: number; }
|
||||
>Origin : { x: number; y: number; }
|
||||
>x : number
|
||||
>y : number
|
||||
>Origin : { x: number; y: number; }, Symbol(Origin,Decl(module.d.ts,1,14))
|
||||
>x : number, Symbol(x,Decl(module.d.ts,1,24))
|
||||
>y : number, Symbol(y,Decl(module.d.ts,1,35))
|
||||
}
|
||||
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/function.ts ===
|
||||
function Point() {
|
||||
>Point : typeof Point
|
||||
>Point : typeof Point, Symbol(Point,Decl(module.d.ts,0,0),Decl(function.ts,0,0))
|
||||
|
||||
return { x: 0, y: 0 };
|
||||
>{ x: 0, y: 0 } : { x: number; y: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(function.ts,1,12))
|
||||
>0 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(function.ts,1,18))
|
||||
>0 : number
|
||||
}
|
||||
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
|
||||
var cl: { x: number; y: number; }
|
||||
>cl : { x: number; y: number; }
|
||||
>x : number
|
||||
>y : number
|
||||
>cl : { x: number; y: number; }, Symbol(cl,Decl(test.ts,0,3),Decl(test.ts,1,3),Decl(test.ts,2,3))
|
||||
>x : number, Symbol(x,Decl(test.ts,0,9))
|
||||
>y : number, Symbol(y,Decl(test.ts,0,20))
|
||||
|
||||
var cl = Point();
|
||||
>cl : { x: number; y: number; }
|
||||
>cl : { x: number; y: number; }, Symbol(cl,Decl(test.ts,0,3),Decl(test.ts,1,3),Decl(test.ts,2,3))
|
||||
>Point() : { x: number; y: number; }
|
||||
>Point : typeof Point
|
||||
>Point : typeof Point, Symbol(Point,Decl(module.d.ts,0,0),Decl(function.ts,0,0))
|
||||
|
||||
var cl = Point.Origin;
|
||||
>cl : { x: number; y: number; }
|
||||
>Point.Origin : { x: number; y: number; }
|
||||
>Point : typeof Point
|
||||
>Origin : { x: number; y: number; }
|
||||
>cl : { x: number; y: number; }, Symbol(cl,Decl(test.ts,0,3),Decl(test.ts,1,3),Decl(test.ts,2,3))
|
||||
>Point.Origin : { x: number; y: number; }, Symbol(Point.Origin,Decl(module.d.ts,1,14))
|
||||
>Point : typeof Point, Symbol(Point,Decl(module.d.ts,0,0),Decl(function.ts,0,0))
|
||||
>Origin : { x: number; y: number; }, Symbol(Point.Origin,Decl(module.d.ts,1,14))
|
||||
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
=== tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrowFunctions/ArrowFunction4.ts ===
|
||||
var v = (a, b) => {
|
||||
>v : (a: any, b: any) => void
|
||||
>v : (a: any, b: any) => void, Symbol(v,Decl(ArrowFunction4.ts,0,3))
|
||||
>(a, b) => { } : (a: any, b: any) => void
|
||||
>a : any
|
||||
>b : any
|
||||
>a : any, Symbol(a,Decl(ArrowFunction4.ts,0,9))
|
||||
>b : any, Symbol(b,Decl(ArrowFunction4.ts,0,11))
|
||||
|
||||
};
|
||||
|
||||
+19
-19
@@ -1,55 +1,55 @@
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts ===
|
||||
class Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts,0,0),Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts,4,1))
|
||||
|
||||
constructor(public x: number, public y: number) { }
|
||||
>x : number
|
||||
>y : number
|
||||
>x : number, Symbol(x,Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts,1,16))
|
||||
>y : number, Symbol(y,Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts,1,33))
|
||||
|
||||
static Origin(): Point { return { x: 0, y: 0 }; }
|
||||
>Origin : () => Point
|
||||
>Point : Point
|
||||
>Origin : () => Point, Symbol(Point.Origin,Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts,1,55))
|
||||
>Point : Point, Symbol(Point,Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts,0,0),Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts,4,1))
|
||||
>{ x: 0, y: 0 } : { x: number; y: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts,3,37))
|
||||
>0 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts,3,43))
|
||||
>0 : number
|
||||
}
|
||||
|
||||
module Point {
|
||||
>Point : typeof Point
|
||||
>Point : typeof Point, Symbol(Point,Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts,0,0),Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts,4,1))
|
||||
|
||||
function Origin() { return ""; }// not an error, since not exported
|
||||
>Origin : () => string
|
||||
>Origin : () => string, Symbol(Origin,Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts,6,14))
|
||||
>"" : string
|
||||
}
|
||||
|
||||
|
||||
module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts,8,1))
|
||||
|
||||
export class Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts,11,10),Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts,16,5))
|
||||
|
||||
constructor(public x: number, public y: number) { }
|
||||
>x : number
|
||||
>y : number
|
||||
>x : number, Symbol(x,Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts,13,20))
|
||||
>y : number, Symbol(y,Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts,13,37))
|
||||
|
||||
static Origin(): Point { return { x: 0, y: 0 }; }
|
||||
>Origin : () => Point
|
||||
>Point : Point
|
||||
>Origin : () => Point, Symbol(Point.Origin,Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts,13,59))
|
||||
>Point : Point, Symbol(Point,Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts,11,10),Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts,16,5))
|
||||
>{ x: 0, y: 0 } : { x: number; y: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts,15,41))
|
||||
>0 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts,15,47))
|
||||
>0 : number
|
||||
}
|
||||
|
||||
export module Point {
|
||||
>Point : typeof Point
|
||||
>Point : typeof Point, Symbol(Point,Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts,11,10),Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts,16,5))
|
||||
|
||||
function Origin() { return ""; }// not an error since not exported
|
||||
>Origin : () => string
|
||||
>Origin : () => string, Symbol(Origin,Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts,18,25))
|
||||
>"" : string
|
||||
}
|
||||
}
|
||||
|
||||
+19
-19
@@ -1,55 +1,55 @@
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts ===
|
||||
class Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts,0,0),Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts,4,1))
|
||||
|
||||
constructor(public x: number, public y: number) { }
|
||||
>x : number
|
||||
>y : number
|
||||
>x : number, Symbol(x,Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts,1,16))
|
||||
>y : number, Symbol(y,Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts,1,33))
|
||||
|
||||
static Origin: Point = { x: 0, y: 0 };
|
||||
>Origin : Point
|
||||
>Point : Point
|
||||
>Origin : Point, Symbol(Point.Origin,Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts,1,55))
|
||||
>Point : Point, Symbol(Point,Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts,0,0),Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts,4,1))
|
||||
>{ x: 0, y: 0 } : { x: number; y: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts,3,28))
|
||||
>0 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts,3,34))
|
||||
>0 : number
|
||||
}
|
||||
|
||||
module Point {
|
||||
>Point : typeof Point
|
||||
>Point : typeof Point, Symbol(Point,Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts,0,0),Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts,4,1))
|
||||
|
||||
var Origin = ""; // not an error, since not exported
|
||||
>Origin : string
|
||||
>Origin : string, Symbol(Origin,Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts,7,7))
|
||||
>"" : string
|
||||
}
|
||||
|
||||
|
||||
module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts,8,1))
|
||||
|
||||
export class Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts,11,10),Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts,16,5))
|
||||
|
||||
constructor(public x: number, public y: number) { }
|
||||
>x : number
|
||||
>y : number
|
||||
>x : number, Symbol(x,Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts,13,20))
|
||||
>y : number, Symbol(y,Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts,13,37))
|
||||
|
||||
static Origin: Point = { x: 0, y: 0 };
|
||||
>Origin : Point
|
||||
>Point : Point
|
||||
>Origin : Point, Symbol(Point.Origin,Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts,13,59))
|
||||
>Point : Point, Symbol(Point,Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts,11,10),Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts,16,5))
|
||||
>{ x: 0, y: 0 } : { x: number; y: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts,15,32))
|
||||
>0 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts,15,38))
|
||||
>0 : number
|
||||
}
|
||||
|
||||
export module Point {
|
||||
>Point : typeof Point
|
||||
>Point : typeof Point, Symbol(Point,Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts,11,10),Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts,16,5))
|
||||
|
||||
var Origin = ""; // not an error since not exported
|
||||
>Origin : string
|
||||
>Origin : string, Symbol(Origin,Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts,19,11))
|
||||
>"" : string
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
=== tests/cases/conformance/statements/for-ofStatements/ES3For-ofTypeCheck2.ts ===
|
||||
for (var v of [true]) { }
|
||||
>v : boolean
|
||||
>v : boolean, Symbol(v,Decl(ES3For-ofTypeCheck2.ts,0,8))
|
||||
>[true] : boolean[]
|
||||
>true : boolean
|
||||
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
=== tests/cases/conformance/statements/for-ofStatements/ES3For-ofTypeCheck6.ts ===
|
||||
var union: string[] | number[];
|
||||
>union : string[] | number[]
|
||||
>union : string[] | number[], Symbol(union,Decl(ES3For-ofTypeCheck6.ts,0,3))
|
||||
|
||||
for (var v of union) { }
|
||||
>v : string | number
|
||||
>union : string[] | number[]
|
||||
>v : string | number, Symbol(v,Decl(ES3For-ofTypeCheck6.ts,1,8))
|
||||
>union : string[] | number[], Symbol(union,Decl(ES3For-ofTypeCheck6.ts,0,3))
|
||||
|
||||
|
||||
@@ -1,30 +1,30 @@
|
||||
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of10.ts ===
|
||||
function foo() {
|
||||
>foo : () => { x: number; }
|
||||
>foo : () => { x: number; }, Symbol(foo,Decl(ES5For-of10.ts,0,0))
|
||||
|
||||
return { x: 0 };
|
||||
>{ x: 0 } : { x: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ES5For-of10.ts,1,12))
|
||||
>0 : number
|
||||
}
|
||||
for (foo().x of []) {
|
||||
>foo().x : number
|
||||
>foo().x : number, Symbol(x,Decl(ES5For-of10.ts,1,12))
|
||||
>foo() : { x: number; }
|
||||
>foo : () => { x: number; }
|
||||
>x : number
|
||||
>foo : () => { x: number; }, Symbol(foo,Decl(ES5For-of10.ts,0,0))
|
||||
>x : number, Symbol(x,Decl(ES5For-of10.ts,1,12))
|
||||
>[] : undefined[]
|
||||
|
||||
for (foo().x of [])
|
||||
>foo().x : number
|
||||
>foo().x : number, Symbol(x,Decl(ES5For-of10.ts,1,12))
|
||||
>foo() : { x: number; }
|
||||
>foo : () => { x: number; }
|
||||
>x : number
|
||||
>foo : () => { x: number; }, Symbol(foo,Decl(ES5For-of10.ts,0,0))
|
||||
>x : number, Symbol(x,Decl(ES5For-of10.ts,1,12))
|
||||
>[] : undefined[]
|
||||
|
||||
var p = foo().x;
|
||||
>p : number
|
||||
>foo().x : number
|
||||
>p : number, Symbol(p,Decl(ES5For-of10.ts,5,11))
|
||||
>foo().x : number, Symbol(x,Decl(ES5For-of10.ts,1,12))
|
||||
>foo() : { x: number; }
|
||||
>foo : () => { x: number; }
|
||||
>x : number
|
||||
>foo : () => { x: number; }, Symbol(foo,Decl(ES5For-of10.ts,0,0))
|
||||
>x : number, Symbol(x,Decl(ES5For-of10.ts,1,12))
|
||||
}
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of11.ts ===
|
||||
var v;
|
||||
>v : any
|
||||
>v : any, Symbol(v,Decl(ES5For-of11.ts,0,3))
|
||||
|
||||
for (v of []) { }
|
||||
>v : any
|
||||
>v : any, Symbol(v,Decl(ES5For-of11.ts,0,3))
|
||||
>[] : undefined[]
|
||||
|
||||
|
||||
@@ -1,12 +1,12 @@
|
||||
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of13.ts ===
|
||||
for (let v of ['a', 'b', 'c']) {
|
||||
>v : string
|
||||
>v : string, Symbol(v,Decl(ES5For-of13.ts,0,8))
|
||||
>['a', 'b', 'c'] : string[]
|
||||
>'a' : string
|
||||
>'b' : string
|
||||
>'c' : string
|
||||
|
||||
var x = v;
|
||||
>x : string
|
||||
>v : string
|
||||
>x : string, Symbol(x,Decl(ES5For-of13.ts,1,7))
|
||||
>v : string, Symbol(v,Decl(ES5For-of13.ts,0,8))
|
||||
}
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of14.ts ===
|
||||
for (const v of []) {
|
||||
>v : any
|
||||
>v : any, Symbol(v,Decl(ES5For-of14.ts,0,10))
|
||||
>[] : undefined[]
|
||||
|
||||
var x = v;
|
||||
>x : any
|
||||
>v : any
|
||||
>x : any, Symbol(x,Decl(ES5For-of14.ts,1,7))
|
||||
>v : any, Symbol(v,Decl(ES5For-of14.ts,0,10))
|
||||
}
|
||||
|
||||
@@ -1,17 +1,17 @@
|
||||
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of15.ts ===
|
||||
for (let v of []) {
|
||||
>v : any
|
||||
>v : any, Symbol(v,Decl(ES5For-of15.ts,0,8))
|
||||
>[] : undefined[]
|
||||
|
||||
v;
|
||||
>v : any
|
||||
>v : any, Symbol(v,Decl(ES5For-of15.ts,0,8))
|
||||
|
||||
for (const v of []) {
|
||||
>v : any
|
||||
>v : any, Symbol(v,Decl(ES5For-of15.ts,2,14))
|
||||
>[] : undefined[]
|
||||
|
||||
var x = v;
|
||||
>x : any
|
||||
>v : any
|
||||
>x : any, Symbol(x,Decl(ES5For-of15.ts,3,11))
|
||||
>v : any, Symbol(v,Decl(ES5For-of15.ts,2,14))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,21 +1,21 @@
|
||||
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of16.ts ===
|
||||
for (let v of []) {
|
||||
>v : any
|
||||
>v : any, Symbol(v,Decl(ES5For-of16.ts,0,8))
|
||||
>[] : undefined[]
|
||||
|
||||
v;
|
||||
>v : any
|
||||
>v : any, Symbol(v,Decl(ES5For-of16.ts,0,8))
|
||||
|
||||
for (let v of []) {
|
||||
>v : any
|
||||
>v : any, Symbol(v,Decl(ES5For-of16.ts,2,12))
|
||||
>[] : undefined[]
|
||||
|
||||
var x = v;
|
||||
>x : any
|
||||
>v : any
|
||||
>x : any, Symbol(x,Decl(ES5For-of16.ts,3,11))
|
||||
>v : any, Symbol(v,Decl(ES5For-of16.ts,2,12))
|
||||
|
||||
v++;
|
||||
>v++ : number
|
||||
>v : any
|
||||
>v : any, Symbol(v,Decl(ES5For-of16.ts,2,12))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,16 +1,16 @@
|
||||
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of18.ts ===
|
||||
for (let v of []) {
|
||||
>v : any
|
||||
>v : any, Symbol(v,Decl(ES5For-of18.ts,0,8))
|
||||
>[] : undefined[]
|
||||
|
||||
v;
|
||||
>v : any
|
||||
>v : any, Symbol(v,Decl(ES5For-of18.ts,0,8))
|
||||
}
|
||||
for (let v of []) {
|
||||
>v : any
|
||||
>v : any, Symbol(v,Decl(ES5For-of18.ts,3,8))
|
||||
>[] : undefined[]
|
||||
|
||||
v;
|
||||
>v : any
|
||||
>v : any, Symbol(v,Decl(ES5For-of18.ts,3,8))
|
||||
}
|
||||
|
||||
|
||||
@@ -1,20 +1,20 @@
|
||||
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of19.ts ===
|
||||
for (let v of []) {
|
||||
>v : any
|
||||
>v : any, Symbol(v,Decl(ES5For-of19.ts,0,8))
|
||||
>[] : undefined[]
|
||||
|
||||
v;
|
||||
>v : any
|
||||
>v : any, Symbol(v,Decl(ES5For-of19.ts,0,8))
|
||||
|
||||
function foo() {
|
||||
>foo : () => void
|
||||
>foo : () => void, Symbol(foo,Decl(ES5For-of19.ts,1,6))
|
||||
|
||||
for (const v of []) {
|
||||
>v : any
|
||||
>v : any, Symbol(v,Decl(ES5For-of19.ts,3,18))
|
||||
>[] : undefined[]
|
||||
|
||||
v;
|
||||
>v : any
|
||||
>v : any, Symbol(v,Decl(ES5For-of19.ts,3,18))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of2.ts ===
|
||||
for (var v of []) {
|
||||
>v : any
|
||||
>v : any, Symbol(v,Decl(ES5For-of2.ts,0,8))
|
||||
>[] : undefined[]
|
||||
|
||||
var x = v;
|
||||
>x : any
|
||||
>v : any
|
||||
>x : any, Symbol(x,Decl(ES5For-of2.ts,1,7))
|
||||
>v : any, Symbol(v,Decl(ES5For-of2.ts,0,8))
|
||||
}
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of21.ts ===
|
||||
for (let v of []) {
|
||||
>v : any
|
||||
>v : any, Symbol(v,Decl(ES5For-of21.ts,0,8))
|
||||
>[] : undefined[]
|
||||
|
||||
for (let _i of []) { }
|
||||
>_i : any
|
||||
>_i : any, Symbol(_i,Decl(ES5For-of21.ts,1,12))
|
||||
>[] : undefined[]
|
||||
}
|
||||
|
||||
@@ -1,16 +1,16 @@
|
||||
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of24.ts ===
|
||||
var a = [1, 2, 3];
|
||||
>a : number[]
|
||||
>a : number[], Symbol(a,Decl(ES5For-of24.ts,0,3))
|
||||
>[1, 2, 3] : number[]
|
||||
>1 : number
|
||||
>2 : number
|
||||
>3 : number
|
||||
|
||||
for (var v of a) {
|
||||
>v : number
|
||||
>a : number[]
|
||||
>v : number, Symbol(v,Decl(ES5For-of24.ts,1,8))
|
||||
>a : number[], Symbol(a,Decl(ES5For-of24.ts,0,3))
|
||||
|
||||
let a = 0;
|
||||
>a : number
|
||||
>a : number, Symbol(a,Decl(ES5For-of24.ts,2,7))
|
||||
>0 : number
|
||||
}
|
||||
|
||||
@@ -1,18 +1,18 @@
|
||||
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of25.ts ===
|
||||
var a = [1, 2, 3];
|
||||
>a : number[]
|
||||
>a : number[], Symbol(a,Decl(ES5For-of25.ts,0,3))
|
||||
>[1, 2, 3] : number[]
|
||||
>1 : number
|
||||
>2 : number
|
||||
>3 : number
|
||||
|
||||
for (var v of a) {
|
||||
>v : number
|
||||
>a : number[]
|
||||
>v : number, Symbol(v,Decl(ES5For-of25.ts,1,8))
|
||||
>a : number[], Symbol(a,Decl(ES5For-of25.ts,0,3))
|
||||
|
||||
v;
|
||||
>v : number
|
||||
>v : number, Symbol(v,Decl(ES5For-of25.ts,1,8))
|
||||
|
||||
a;
|
||||
>a : number[]
|
||||
>a : number[], Symbol(a,Decl(ES5For-of25.ts,0,3))
|
||||
}
|
||||
|
||||
@@ -1,12 +1,12 @@
|
||||
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of3.ts ===
|
||||
for (var v of ['a', 'b', 'c'])
|
||||
>v : string
|
||||
>v : string, Symbol(v,Decl(ES5For-of3.ts,0,8))
|
||||
>['a', 'b', 'c'] : string[]
|
||||
>'a' : string
|
||||
>'b' : string
|
||||
>'c' : string
|
||||
|
||||
var x = v;
|
||||
>x : string
|
||||
>v : string
|
||||
>x : string, Symbol(x,Decl(ES5For-of3.ts,1,7))
|
||||
>v : string, Symbol(v,Decl(ES5For-of3.ts,0,8))
|
||||
|
||||
|
||||
@@ -1,13 +1,13 @@
|
||||
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of4.ts ===
|
||||
for (var v of [])
|
||||
>v : any
|
||||
>v : any, Symbol(v,Decl(ES5For-of4.ts,0,8))
|
||||
>[] : undefined[]
|
||||
|
||||
var x = v;
|
||||
>x : any
|
||||
>v : any
|
||||
>x : any, Symbol(x,Decl(ES5For-of4.ts,1,7))
|
||||
>v : any, Symbol(v,Decl(ES5For-of4.ts,0,8))
|
||||
|
||||
var y = v;
|
||||
>y : any
|
||||
>v : any
|
||||
>y : any, Symbol(y,Decl(ES5For-of4.ts,2,3))
|
||||
>v : any, Symbol(v,Decl(ES5For-of4.ts,0,8))
|
||||
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of5.ts ===
|
||||
for (var _a of []) {
|
||||
>_a : any
|
||||
>_a : any, Symbol(_a,Decl(ES5For-of5.ts,0,8))
|
||||
>[] : undefined[]
|
||||
|
||||
var x = _a;
|
||||
>x : any
|
||||
>_a : any
|
||||
>x : any, Symbol(x,Decl(ES5For-of5.ts,1,7))
|
||||
>_a : any, Symbol(_a,Decl(ES5For-of5.ts,0,8))
|
||||
}
|
||||
|
||||
@@ -1,16 +1,16 @@
|
||||
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of6.ts ===
|
||||
for (var w of []) {
|
||||
>w : any
|
||||
>w : any, Symbol(w,Decl(ES5For-of6.ts,0,8))
|
||||
>[] : undefined[]
|
||||
|
||||
for (var v of []) {
|
||||
>v : any
|
||||
>v : any, Symbol(v,Decl(ES5For-of6.ts,1,12))
|
||||
>[] : undefined[]
|
||||
|
||||
var x = [w, v];
|
||||
>x : any[]
|
||||
>x : any[], Symbol(x,Decl(ES5For-of6.ts,2,11))
|
||||
>[w, v] : any[]
|
||||
>w : any
|
||||
>v : any
|
||||
>w : any, Symbol(w,Decl(ES5For-of6.ts,0,8))
|
||||
>v : any, Symbol(v,Decl(ES5For-of6.ts,1,12))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,31 +1,31 @@
|
||||
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of9.ts ===
|
||||
function foo() {
|
||||
>foo : () => { x: number; }
|
||||
>foo : () => { x: number; }, Symbol(foo,Decl(ES5For-of9.ts,0,0))
|
||||
|
||||
return { x: 0 };
|
||||
>{ x: 0 } : { x: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ES5For-of9.ts,1,12))
|
||||
>0 : number
|
||||
}
|
||||
for (foo().x of []) {
|
||||
>foo().x : number
|
||||
>foo().x : number, Symbol(x,Decl(ES5For-of9.ts,1,12))
|
||||
>foo() : { x: number; }
|
||||
>foo : () => { x: number; }
|
||||
>x : number
|
||||
>foo : () => { x: number; }, Symbol(foo,Decl(ES5For-of9.ts,0,0))
|
||||
>x : number, Symbol(x,Decl(ES5For-of9.ts,1,12))
|
||||
>[] : undefined[]
|
||||
|
||||
for (foo().x of []) {
|
||||
>foo().x : number
|
||||
>foo().x : number, Symbol(x,Decl(ES5For-of9.ts,1,12))
|
||||
>foo() : { x: number; }
|
||||
>foo : () => { x: number; }
|
||||
>x : number
|
||||
>foo : () => { x: number; }, Symbol(foo,Decl(ES5For-of9.ts,0,0))
|
||||
>x : number, Symbol(x,Decl(ES5For-of9.ts,1,12))
|
||||
>[] : undefined[]
|
||||
|
||||
var p = foo().x;
|
||||
>p : number
|
||||
>foo().x : number
|
||||
>p : number, Symbol(p,Decl(ES5For-of9.ts,5,11))
|
||||
>foo().x : number, Symbol(x,Decl(ES5For-of9.ts,1,12))
|
||||
>foo() : { x: number; }
|
||||
>foo : () => { x: number; }
|
||||
>x : number
|
||||
>foo : () => { x: number; }, Symbol(foo,Decl(ES5For-of9.ts,0,0))
|
||||
>x : number, Symbol(x,Decl(ES5For-of9.ts,1,12))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck1.ts ===
|
||||
for (var v of "") { }
|
||||
>v : string
|
||||
>v : string, Symbol(v,Decl(ES5For-ofTypeCheck1.ts,0,8))
|
||||
>"" : string
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck2.ts ===
|
||||
for (var v of [true]) { }
|
||||
>v : boolean
|
||||
>v : boolean, Symbol(v,Decl(ES5For-ofTypeCheck2.ts,0,8))
|
||||
>[true] : boolean[]
|
||||
>true : boolean
|
||||
|
||||
|
||||
@@ -1,11 +1,11 @@
|
||||
=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck3.ts ===
|
||||
var tuple: [string, number] = ["", 0];
|
||||
>tuple : [string, number]
|
||||
>tuple : [string, number], Symbol(tuple,Decl(ES5For-ofTypeCheck3.ts,0,3))
|
||||
>["", 0] : [string, number]
|
||||
>"" : string
|
||||
>0 : number
|
||||
|
||||
for (var v of tuple) { }
|
||||
>v : string | number
|
||||
>tuple : [string, number]
|
||||
>v : string | number, Symbol(v,Decl(ES5For-ofTypeCheck3.ts,1,8))
|
||||
>tuple : [string, number], Symbol(tuple,Decl(ES5For-ofTypeCheck3.ts,0,3))
|
||||
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck4.ts ===
|
||||
var union: string | string[];
|
||||
>union : string | string[]
|
||||
>union : string | string[], Symbol(union,Decl(ES5For-ofTypeCheck4.ts,0,3))
|
||||
|
||||
for (const v of union) { }
|
||||
>v : string
|
||||
>union : string | string[]
|
||||
>v : string, Symbol(v,Decl(ES5For-ofTypeCheck4.ts,1,10))
|
||||
>union : string | string[], Symbol(union,Decl(ES5For-ofTypeCheck4.ts,0,3))
|
||||
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck5.ts ===
|
||||
var union: string | number[];
|
||||
>union : string | number[]
|
||||
>union : string | number[], Symbol(union,Decl(ES5For-ofTypeCheck5.ts,0,3))
|
||||
|
||||
for (var v of union) { }
|
||||
>v : string | number
|
||||
>union : string | number[]
|
||||
>v : string | number, Symbol(v,Decl(ES5For-ofTypeCheck5.ts,1,8))
|
||||
>union : string | number[], Symbol(union,Decl(ES5For-ofTypeCheck5.ts,0,3))
|
||||
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck6.ts ===
|
||||
var union: string[] | number[];
|
||||
>union : string[] | number[]
|
||||
>union : string[] | number[], Symbol(union,Decl(ES5For-ofTypeCheck6.ts,0,3))
|
||||
|
||||
for (var v of union) { }
|
||||
>v : string | number
|
||||
>union : string[] | number[]
|
||||
>v : string | number, Symbol(v,Decl(ES5For-ofTypeCheck6.ts,1,8))
|
||||
>union : string[] | number[], Symbol(union,Decl(ES5For-ofTypeCheck6.ts,0,3))
|
||||
|
||||
|
||||
@@ -1,10 +1,10 @@
|
||||
=== tests/cases/conformance/Symbols/ES5SymbolType1.ts ===
|
||||
var s: symbol;
|
||||
>s : symbol
|
||||
>s : symbol, Symbol(s,Decl(ES5SymbolType1.ts,0,3))
|
||||
|
||||
s.toString();
|
||||
>s.toString() : string
|
||||
>s.toString : () => string
|
||||
>s : symbol
|
||||
>toString : () => string
|
||||
>s.toString : () => string, Symbol(Object.toString,Decl(lib.d.ts,96,26))
|
||||
>s : symbol, Symbol(s,Decl(ES5SymbolType1.ts,0,3))
|
||||
>toString : () => string, Symbol(Object.toString,Decl(lib.d.ts,96,26))
|
||||
|
||||
|
||||
@@ -1,45 +1,45 @@
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/EnumAndModuleWithSameNameAndCommonRoot.ts ===
|
||||
enum enumdule {
|
||||
>enumdule : enumdule
|
||||
>enumdule : enumdule, Symbol(enumdule,Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,0,0),Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,2,1))
|
||||
|
||||
Red, Blue
|
||||
>Red : enumdule
|
||||
>Blue : enumdule
|
||||
>Red : enumdule, Symbol(enumdule.Red,Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,0,15))
|
||||
>Blue : enumdule, Symbol(enumdule.Blue,Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,1,8))
|
||||
}
|
||||
|
||||
module enumdule {
|
||||
>enumdule : typeof enumdule
|
||||
>enumdule : typeof enumdule, Symbol(enumdule,Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,0,0),Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,2,1))
|
||||
|
||||
export class Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,4,17))
|
||||
|
||||
constructor(public x: number, public y: number) { }
|
||||
>x : number
|
||||
>y : number
|
||||
>x : number, Symbol(x,Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,7,20))
|
||||
>y : number, Symbol(y,Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,7,37))
|
||||
}
|
||||
}
|
||||
|
||||
var x: enumdule;
|
||||
>x : enumdule
|
||||
>enumdule : enumdule
|
||||
>x : enumdule, Symbol(x,Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,11,3),Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,12,3))
|
||||
>enumdule : enumdule, Symbol(enumdule,Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,0,0),Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,2,1))
|
||||
|
||||
var x = enumdule.Red;
|
||||
>x : enumdule
|
||||
>enumdule.Red : enumdule
|
||||
>enumdule : typeof enumdule
|
||||
>Red : enumdule
|
||||
>x : enumdule, Symbol(x,Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,11,3),Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,12,3))
|
||||
>enumdule.Red : enumdule, Symbol(enumdule.Red,Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,0,15))
|
||||
>enumdule : typeof enumdule, Symbol(enumdule,Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,0,0),Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,2,1))
|
||||
>Red : enumdule, Symbol(enumdule.Red,Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,0,15))
|
||||
|
||||
var y: { x: number; y: number };
|
||||
>y : { x: number; y: number; }
|
||||
>x : number
|
||||
>y : number
|
||||
>y : { x: number; y: number; }, Symbol(y,Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,14,3),Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,15,3))
|
||||
>x : number, Symbol(x,Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,14,8))
|
||||
>y : number, Symbol(y,Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,14,19))
|
||||
|
||||
var y = new enumdule.Point(0, 0);
|
||||
>y : { x: number; y: number; }
|
||||
>y : { x: number; y: number; }, Symbol(y,Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,14,3),Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,15,3))
|
||||
>new enumdule.Point(0, 0) : enumdule.Point
|
||||
>enumdule.Point : typeof enumdule.Point
|
||||
>enumdule : typeof enumdule
|
||||
>Point : typeof enumdule.Point
|
||||
>enumdule.Point : typeof enumdule.Point, Symbol(enumdule.Point,Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,4,17))
|
||||
>enumdule : typeof enumdule, Symbol(enumdule,Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,0,0),Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,2,1))
|
||||
>Point : typeof enumdule.Point, Symbol(enumdule.Point,Decl(EnumAndModuleWithSameNameAndCommonRoot.ts,4,17))
|
||||
>0 : number
|
||||
>0 : number
|
||||
|
||||
|
||||
+14
-14
@@ -1,34 +1,34 @@
|
||||
=== tests/cases/conformance/internalModules/exportDeclarations/ExportClassWhichExtendsInterfaceWithInaccessibleType.ts ===
|
||||
module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts,0,0))
|
||||
|
||||
interface Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts,0,10))
|
||||
|
||||
x: number;
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts,2,21))
|
||||
|
||||
y: number;
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts,3,18))
|
||||
|
||||
fromOrigin(p: Point): number;
|
||||
>fromOrigin : (p: Point) => number
|
||||
>p : Point
|
||||
>Point : Point
|
||||
>fromOrigin : (p: Point) => number, Symbol(fromOrigin,Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts,4,18))
|
||||
>p : Point, Symbol(p,Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts,6,19))
|
||||
>Point : Point, Symbol(Point,Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts,0,10))
|
||||
}
|
||||
|
||||
export class Point2d implements Point {
|
||||
>Point2d : Point2d
|
||||
>Point : Point
|
||||
>Point2d : Point2d, Symbol(Point2d,Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts,7,5))
|
||||
>Point : Point, Symbol(Point,Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts,0,10))
|
||||
|
||||
constructor(public x: number, public y: number) { }
|
||||
>x : number
|
||||
>y : number
|
||||
>x : number, Symbol(x,Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts,10,20))
|
||||
>y : number, Symbol(y,Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts,10,37))
|
||||
|
||||
fromOrigin(p: Point) {
|
||||
>fromOrigin : (p: Point) => number
|
||||
>p : Point
|
||||
>Point : Point
|
||||
>fromOrigin : (p: Point) => number, Symbol(fromOrigin,Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts,10,59))
|
||||
>p : Point, Symbol(p,Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts,12,19))
|
||||
>Point : Point, Symbol(Point,Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts,0,10))
|
||||
|
||||
return 1;
|
||||
>1 : number
|
||||
|
||||
+23
-23
@@ -1,55 +1,55 @@
|
||||
=== tests/cases/conformance/internalModules/exportDeclarations/ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts ===
|
||||
module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,0,0))
|
||||
|
||||
export class Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,0,10))
|
||||
|
||||
x: number;
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,2,24))
|
||||
|
||||
y: number;
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,3,18))
|
||||
}
|
||||
|
||||
export var Origin: Point = { x: 0, y: 0 };
|
||||
>Origin : Point
|
||||
>Point : Point
|
||||
>Origin : Point, Symbol(Origin,Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,7,14))
|
||||
>Point : Point, Symbol(Point,Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,0,10))
|
||||
>{ x: 0, y: 0 } : { x: number; y: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,7,32))
|
||||
>0 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,7,38))
|
||||
>0 : number
|
||||
|
||||
export class Point3d extends Point {
|
||||
>Point3d : Point3d
|
||||
>Point : Point
|
||||
>Point3d : Point3d, Symbol(Point3d,Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,7,46))
|
||||
>Point : Point, Symbol(Point,Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,0,10))
|
||||
|
||||
z: number;
|
||||
>z : number
|
||||
>z : number, Symbol(z,Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,9,40))
|
||||
}
|
||||
|
||||
export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
|
||||
>Origin3d : Point3d
|
||||
>Point3d : Point3d
|
||||
>Origin3d : Point3d, Symbol(Origin3d,Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,13,14))
|
||||
>Point3d : Point3d, Symbol(Point3d,Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,7,46))
|
||||
>{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,13,36))
|
||||
>0 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,13,42))
|
||||
>0 : number
|
||||
>z : number
|
||||
>z : number, Symbol(z,Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,13,48))
|
||||
>0 : number
|
||||
|
||||
export class Line<TPoint extends Point>{
|
||||
>Line : Line<TPoint>
|
||||
>TPoint : TPoint
|
||||
>Point : Point
|
||||
>Line : Line<TPoint>, Symbol(Line,Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,13,56))
|
||||
>TPoint : TPoint, Symbol(TPoint,Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,15,22))
|
||||
>Point : Point, Symbol(Point,Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,0,10))
|
||||
|
||||
constructor(public start: TPoint, public end: TPoint) { }
|
||||
>start : TPoint
|
||||
>TPoint : TPoint
|
||||
>end : TPoint
|
||||
>TPoint : TPoint
|
||||
>start : TPoint, Symbol(start,Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,16,20))
|
||||
>TPoint : TPoint, Symbol(TPoint,Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,15,22))
|
||||
>end : TPoint, Symbol(end,Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,16,41))
|
||||
>TPoint : TPoint, Symbol(TPoint,Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,15,22))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+9
-9
@@ -1,27 +1,27 @@
|
||||
=== tests/cases/conformance/internalModules/exportDeclarations/ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts ===
|
||||
module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts,0,0))
|
||||
|
||||
class Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts,0,10))
|
||||
|
||||
x: number;
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts,2,17))
|
||||
|
||||
y: number;
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts,3,18))
|
||||
}
|
||||
|
||||
export class points {
|
||||
>points : points
|
||||
>points : points, Symbol(points,Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts,5,5))
|
||||
|
||||
[idx: number]: Point;
|
||||
>idx : number
|
||||
>Point : Point
|
||||
>idx : number, Symbol(idx,Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts,9,9))
|
||||
>Point : Point, Symbol(Point,Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts,0,10))
|
||||
|
||||
[idx: string]: Point;
|
||||
>idx : string
|
||||
>Point : Point
|
||||
>idx : string, Symbol(idx,Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts,10,9))
|
||||
>Point : Point, Symbol(Point,Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts,0,10))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+28
-28
@@ -1,62 +1,62 @@
|
||||
=== tests/cases/conformance/internalModules/exportDeclarations/ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts ===
|
||||
module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,0,0))
|
||||
|
||||
class Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,0,10))
|
||||
|
||||
x: number;
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,2,17))
|
||||
|
||||
y: number;
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,3,18))
|
||||
}
|
||||
|
||||
export var Origin: Point = { x: 0, y: 0 };
|
||||
>Origin : Point
|
||||
>Point : Point
|
||||
>Origin : Point, Symbol(Origin,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,7,14))
|
||||
>Point : Point, Symbol(Point,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,0,10))
|
||||
>{ x: 0, y: 0 } : { x: number; y: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,7,32))
|
||||
>0 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,7,38))
|
||||
>0 : number
|
||||
|
||||
export class Point3d extends Point {
|
||||
>Point3d : Point3d
|
||||
>Point : Point
|
||||
>Point3d : Point3d, Symbol(Point3d,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,7,46))
|
||||
>Point : Point, Symbol(Point,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,0,10))
|
||||
|
||||
z: number;
|
||||
>z : number
|
||||
>z : number, Symbol(z,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,9,40))
|
||||
}
|
||||
|
||||
export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
|
||||
>Origin3d : Point3d
|
||||
>Point3d : Point3d
|
||||
>Origin3d : Point3d, Symbol(Origin3d,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,13,14))
|
||||
>Point3d : Point3d, Symbol(Point3d,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,7,46))
|
||||
>{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,13,36))
|
||||
>0 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,13,42))
|
||||
>0 : number
|
||||
>z : number
|
||||
>z : number, Symbol(z,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,13,48))
|
||||
>0 : number
|
||||
|
||||
export class Line<TPoint extends Point>{
|
||||
>Line : Line<TPoint>
|
||||
>TPoint : TPoint
|
||||
>Point : Point
|
||||
>Line : Line<TPoint>, Symbol(Line,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,13,56))
|
||||
>TPoint : TPoint, Symbol(TPoint,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,15,22))
|
||||
>Point : Point, Symbol(Point,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,0,10))
|
||||
|
||||
constructor(public start: TPoint, public end: TPoint) { }
|
||||
>start : TPoint
|
||||
>TPoint : TPoint
|
||||
>end : TPoint
|
||||
>TPoint : TPoint
|
||||
>start : TPoint, Symbol(start,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,16,20))
|
||||
>TPoint : TPoint, Symbol(TPoint,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,15,22))
|
||||
>end : TPoint, Symbol(end,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,16,41))
|
||||
>TPoint : TPoint, Symbol(TPoint,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,15,22))
|
||||
|
||||
static fromorigin2d(p: Point): Line<Point>{
|
||||
>fromorigin2d : (p: Point) => Line<Point>
|
||||
>p : Point
|
||||
>Point : Point
|
||||
>Line : Line<TPoint>
|
||||
>Point : Point
|
||||
>fromorigin2d : (p: Point) => Line<Point>, Symbol(Line.fromorigin2d,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,16,65))
|
||||
>p : Point, Symbol(p,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,18,28))
|
||||
>Point : Point, Symbol(Point,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,0,10))
|
||||
>Line : Line<TPoint>, Symbol(Line,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,13,56))
|
||||
>Point : Point, Symbol(Point,Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts,0,10))
|
||||
|
||||
return null;
|
||||
>null : null
|
||||
|
||||
+17
-17
@@ -1,41 +1,41 @@
|
||||
=== tests/cases/conformance/internalModules/exportDeclarations/ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts ===
|
||||
module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts,0,0))
|
||||
|
||||
export class Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts,0,10))
|
||||
|
||||
x: number;
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts,2,24))
|
||||
|
||||
y: number;
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts,3,18))
|
||||
}
|
||||
|
||||
export class Line {
|
||||
>Line : Line
|
||||
>Line : Line, Symbol(Line,Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts,5,5))
|
||||
|
||||
constructor(public start: Point, public end: Point) { }
|
||||
>start : Point
|
||||
>Point : Point
|
||||
>end : Point
|
||||
>Point : Point
|
||||
>start : Point, Symbol(start,Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts,8,20))
|
||||
>Point : Point, Symbol(Point,Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts,0,10))
|
||||
>end : Point, Symbol(end,Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts,8,40))
|
||||
>Point : Point, Symbol(Point,Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts,0,10))
|
||||
}
|
||||
|
||||
export function fromOrigin(p: Point): Line {
|
||||
>fromOrigin : (p: Point) => Line
|
||||
>p : Point
|
||||
>Point : Point
|
||||
>Line : Line
|
||||
>fromOrigin : (p: Point) => Line, Symbol(fromOrigin,Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts,9,5))
|
||||
>p : Point, Symbol(p,Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts,11,31))
|
||||
>Point : Point, Symbol(Point,Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts,0,10))
|
||||
>Line : Line, Symbol(Line,Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts,5,5))
|
||||
|
||||
return new Line({ x: 0, y: 0 }, p);
|
||||
>new Line({ x: 0, y: 0 }, p) : Line
|
||||
>Line : typeof Line
|
||||
>Line : typeof Line, Symbol(Line,Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts,5,5))
|
||||
>{ x: 0, y: 0 } : { x: number; y: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts,12,25))
|
||||
>0 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts,12,31))
|
||||
>0 : number
|
||||
>p : Point
|
||||
>p : Point, Symbol(p,Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts,11,31))
|
||||
}
|
||||
}
|
||||
|
||||
+17
-17
@@ -1,41 +1,41 @@
|
||||
=== tests/cases/conformance/internalModules/exportDeclarations/ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts ===
|
||||
module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts,0,0))
|
||||
|
||||
class Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts,0,10))
|
||||
|
||||
x: number;
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts,2,17))
|
||||
|
||||
y: number;
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts,3,18))
|
||||
}
|
||||
|
||||
export class Line {
|
||||
>Line : Line
|
||||
>Line : Line, Symbol(Line,Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts,5,5))
|
||||
|
||||
constructor(public start: Point, public end: Point) { }
|
||||
>start : Point
|
||||
>Point : Point
|
||||
>end : Point
|
||||
>Point : Point
|
||||
>start : Point, Symbol(start,Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts,8,20))
|
||||
>Point : Point, Symbol(Point,Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts,0,10))
|
||||
>end : Point, Symbol(end,Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts,8,40))
|
||||
>Point : Point, Symbol(Point,Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts,0,10))
|
||||
}
|
||||
|
||||
export function fromOrigin(p: Point): Line {
|
||||
>fromOrigin : (p: Point) => Line
|
||||
>p : Point
|
||||
>Point : Point
|
||||
>Line : Line
|
||||
>fromOrigin : (p: Point) => Line, Symbol(fromOrigin,Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts,9,5))
|
||||
>p : Point, Symbol(p,Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts,11,31))
|
||||
>Point : Point, Symbol(Point,Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts,0,10))
|
||||
>Line : Line, Symbol(Line,Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts,5,5))
|
||||
|
||||
return new Line({ x: 0, y: 0 }, p);
|
||||
>new Line({ x: 0, y: 0 }, p) : Line
|
||||
>Line : typeof Line
|
||||
>Line : typeof Line, Symbol(Line,Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts,5,5))
|
||||
>{ x: 0, y: 0 } : { x: number; y: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts,12,25))
|
||||
>0 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts,12,31))
|
||||
>0 : number
|
||||
>p : Point
|
||||
>p : Point, Symbol(p,Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts,11,31))
|
||||
}
|
||||
}
|
||||
|
||||
+17
-17
@@ -1,41 +1,41 @@
|
||||
=== tests/cases/conformance/internalModules/exportDeclarations/ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts ===
|
||||
module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts,0,0))
|
||||
|
||||
export class Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts,0,10))
|
||||
|
||||
x: number;
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts,2,24))
|
||||
|
||||
y: number;
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts,3,18))
|
||||
}
|
||||
|
||||
class Line {
|
||||
>Line : Line
|
||||
>Line : Line, Symbol(Line,Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts,5,5))
|
||||
|
||||
constructor(public start: Point, public end: Point) { }
|
||||
>start : Point
|
||||
>Point : Point
|
||||
>end : Point
|
||||
>Point : Point
|
||||
>start : Point, Symbol(start,Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts,8,20))
|
||||
>Point : Point, Symbol(Point,Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts,0,10))
|
||||
>end : Point, Symbol(end,Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts,8,40))
|
||||
>Point : Point, Symbol(Point,Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts,0,10))
|
||||
}
|
||||
|
||||
export function fromOrigin(p: Point): Line {
|
||||
>fromOrigin : (p: Point) => Line
|
||||
>p : Point
|
||||
>Point : Point
|
||||
>Line : Line
|
||||
>fromOrigin : (p: Point) => Line, Symbol(fromOrigin,Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts,9,5))
|
||||
>p : Point, Symbol(p,Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts,11,31))
|
||||
>Point : Point, Symbol(Point,Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts,0,10))
|
||||
>Line : Line, Symbol(Line,Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts,5,5))
|
||||
|
||||
return new Line({ x: 0, y: 0 }, p);
|
||||
>new Line({ x: 0, y: 0 }, p) : Line
|
||||
>Line : typeof Line
|
||||
>Line : typeof Line, Symbol(Line,Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts,5,5))
|
||||
>{ x: 0, y: 0 } : { x: number; y: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts,12,25))
|
||||
>0 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts,12,31))
|
||||
>0 : number
|
||||
>p : Point
|
||||
>p : Point, Symbol(p,Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts,11,31))
|
||||
}
|
||||
}
|
||||
|
||||
+27
-27
@@ -1,63 +1,63 @@
|
||||
=== tests/cases/conformance/internalModules/exportDeclarations/ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts ===
|
||||
module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,0,0))
|
||||
|
||||
export interface Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,0,10))
|
||||
|
||||
x: number;
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,2,28))
|
||||
|
||||
y: number;
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,3,18))
|
||||
}
|
||||
|
||||
export var Origin: Point = { x: 0, y: 0 };
|
||||
>Origin : Point
|
||||
>Point : Point
|
||||
>Origin : Point, Symbol(Origin,Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,7,14))
|
||||
>Point : Point, Symbol(Point,Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,0,10))
|
||||
>{ x: 0, y: 0 } : { x: number; y: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,7,32))
|
||||
>0 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,7,38))
|
||||
>0 : number
|
||||
|
||||
export interface Point3d extends Point {
|
||||
>Point3d : Point3d
|
||||
>Point : Point
|
||||
>Point3d : Point3d, Symbol(Point3d,Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,7,46))
|
||||
>Point : Point, Symbol(Point,Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,0,10))
|
||||
|
||||
z: number;
|
||||
>z : number
|
||||
>z : number, Symbol(z,Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,9,44))
|
||||
}
|
||||
|
||||
export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
|
||||
>Origin3d : Point3d
|
||||
>Point3d : Point3d
|
||||
>Origin3d : Point3d, Symbol(Origin3d,Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,13,14))
|
||||
>Point3d : Point3d, Symbol(Point3d,Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,7,46))
|
||||
>{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,13,36))
|
||||
>0 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,13,42))
|
||||
>0 : number
|
||||
>z : number
|
||||
>z : number, Symbol(z,Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,13,48))
|
||||
>0 : number
|
||||
|
||||
export interface Line<TPoint extends Point>{
|
||||
>Line : Line<TPoint>
|
||||
>TPoint : TPoint
|
||||
>Point : Point
|
||||
>Line : Line<TPoint>, Symbol(Line,Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,13,56))
|
||||
>TPoint : TPoint, Symbol(TPoint,Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,15,26))
|
||||
>Point : Point, Symbol(Point,Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,0,10))
|
||||
|
||||
new (start: TPoint, end: TPoint);
|
||||
>start : TPoint
|
||||
>TPoint : TPoint
|
||||
>end : TPoint
|
||||
>TPoint : TPoint
|
||||
>start : TPoint, Symbol(start,Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,16,13))
|
||||
>TPoint : TPoint, Symbol(TPoint,Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,15,26))
|
||||
>end : TPoint, Symbol(end,Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,16,27))
|
||||
>TPoint : TPoint, Symbol(TPoint,Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,15,26))
|
||||
|
||||
start: TPoint;
|
||||
>start : TPoint
|
||||
>TPoint : TPoint
|
||||
>start : TPoint, Symbol(start,Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,16,41))
|
||||
>TPoint : TPoint, Symbol(TPoint,Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,15,26))
|
||||
|
||||
end: TPoint;
|
||||
>end : TPoint
|
||||
>TPoint : TPoint
|
||||
>end : TPoint, Symbol(end,Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,17,22))
|
||||
>TPoint : TPoint, Symbol(TPoint,Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts,15,26))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+9
-9
@@ -1,27 +1,27 @@
|
||||
=== tests/cases/conformance/internalModules/exportDeclarations/ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts ===
|
||||
module A {
|
||||
>A : unknown
|
||||
>A : any, Symbol(A,Decl(ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts,0,0))
|
||||
|
||||
interface Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts,0,10))
|
||||
|
||||
x: number;
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts,2,21))
|
||||
|
||||
y: number;
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts,3,18))
|
||||
}
|
||||
|
||||
export interface points {
|
||||
>points : points
|
||||
>points : points, Symbol(points,Decl(ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts,5,5))
|
||||
|
||||
[idx: number]: Point;
|
||||
>idx : number
|
||||
>Point : Point
|
||||
>idx : number, Symbol(idx,Decl(ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts,9,9))
|
||||
>Point : Point, Symbol(Point,Decl(ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts,0,10))
|
||||
|
||||
[idx: string]: Point;
|
||||
>idx : string
|
||||
>Point : Point
|
||||
>idx : string, Symbol(idx,Decl(ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts,10,9))
|
||||
>Point : Point, Symbol(Point,Decl(ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts,0,10))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+27
-27
@@ -1,63 +1,63 @@
|
||||
=== tests/cases/conformance/internalModules/exportDeclarations/ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts ===
|
||||
module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts,0,0))
|
||||
|
||||
interface Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts,0,10))
|
||||
|
||||
x: number;
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts,2,21))
|
||||
|
||||
y: number;
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts,3,18))
|
||||
}
|
||||
|
||||
export var Origin: Point = { x: 0, y: 0 };
|
||||
>Origin : Point
|
||||
>Point : Point
|
||||
>Origin : Point, Symbol(Origin,Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts,7,14))
|
||||
>Point : Point, Symbol(Point,Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts,0,10))
|
||||
>{ x: 0, y: 0 } : { x: number; y: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts,7,32))
|
||||
>0 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts,7,38))
|
||||
>0 : number
|
||||
|
||||
export interface Point3d extends Point {
|
||||
>Point3d : Point3d
|
||||
>Point : Point
|
||||
>Point3d : Point3d, Symbol(Point3d,Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts,7,46))
|
||||
>Point : Point, Symbol(Point,Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts,0,10))
|
||||
|
||||
z: number;
|
||||
>z : number
|
||||
>z : number, Symbol(z,Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts,9,44))
|
||||
}
|
||||
|
||||
export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
|
||||
>Origin3d : Point3d
|
||||
>Point3d : Point3d
|
||||
>Origin3d : Point3d, Symbol(Origin3d,Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts,13,14))
|
||||
>Point3d : Point3d, Symbol(Point3d,Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts,7,46))
|
||||
>{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts,13,36))
|
||||
>0 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts,13,42))
|
||||
>0 : number
|
||||
>z : number
|
||||
>z : number, Symbol(z,Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts,13,48))
|
||||
>0 : number
|
||||
|
||||
export interface Line<TPoint extends Point>{
|
||||
>Line : Line<TPoint>
|
||||
>TPoint : TPoint
|
||||
>Point : Point
|
||||
>Line : Line<TPoint>, Symbol(Line,Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts,13,56))
|
||||
>TPoint : TPoint, Symbol(TPoint,Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts,15,26))
|
||||
>Point : Point, Symbol(Point,Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts,0,10))
|
||||
|
||||
new (start: TPoint, end: TPoint);
|
||||
>start : TPoint
|
||||
>TPoint : TPoint
|
||||
>end : TPoint
|
||||
>TPoint : TPoint
|
||||
>start : TPoint, Symbol(start,Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts,16,13))
|
||||
>TPoint : TPoint, Symbol(TPoint,Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts,15,26))
|
||||
>end : TPoint, Symbol(end,Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts,16,27))
|
||||
>TPoint : TPoint, Symbol(TPoint,Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts,15,26))
|
||||
|
||||
start: TPoint;
|
||||
>start : TPoint
|
||||
>TPoint : TPoint
|
||||
>start : TPoint, Symbol(start,Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts,16,41))
|
||||
>TPoint : TPoint, Symbol(TPoint,Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts,15,26))
|
||||
|
||||
end: TPoint;
|
||||
>end : TPoint
|
||||
>TPoint : TPoint
|
||||
>end : TPoint, Symbol(end,Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts,18,22))
|
||||
>TPoint : TPoint, Symbol(TPoint,Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts,15,26))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+20
-20
@@ -1,51 +1,51 @@
|
||||
=== tests/cases/conformance/internalModules/exportDeclarations/ExportModuleWithAccessibleTypesOnItsExportedMembers.ts ===
|
||||
module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts,0,0))
|
||||
|
||||
export class Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts,0,10))
|
||||
|
||||
constructor(public x: number, public y: number) { }
|
||||
>x : number
|
||||
>y : number
|
||||
>x : number, Symbol(x,Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts,3,20))
|
||||
>y : number, Symbol(y,Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts,3,37))
|
||||
}
|
||||
|
||||
export module B {
|
||||
>B : typeof B
|
||||
>B : typeof B, Symbol(B,Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts,4,5))
|
||||
|
||||
export var Origin: Point = new Point(0, 0);
|
||||
>Origin : Point
|
||||
>Point : Point
|
||||
>Origin : Point, Symbol(Origin,Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts,7,18))
|
||||
>Point : Point, Symbol(Point,Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts,0,10))
|
||||
>new Point(0, 0) : Point
|
||||
>Point : typeof Point
|
||||
>Point : typeof Point, Symbol(Point,Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts,0,10))
|
||||
>0 : number
|
||||
>0 : number
|
||||
|
||||
export class Line {
|
||||
>Line : Line
|
||||
>Line : Line, Symbol(Line,Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts,7,51))
|
||||
|
||||
constructor(start: Point, end: Point) {
|
||||
>start : Point
|
||||
>Point : Point
|
||||
>end : Point
|
||||
>Point : Point
|
||||
>start : Point, Symbol(start,Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts,10,24))
|
||||
>Point : Point, Symbol(Point,Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts,0,10))
|
||||
>end : Point, Symbol(end,Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts,10,37))
|
||||
>Point : Point, Symbol(Point,Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts,0,10))
|
||||
|
||||
}
|
||||
|
||||
static fromOrigin(p: Point) {
|
||||
>fromOrigin : (p: Point) => Line
|
||||
>p : Point
|
||||
>Point : Point
|
||||
>fromOrigin : (p: Point) => Line, Symbol(Line.fromOrigin,Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts,12,13))
|
||||
>p : Point, Symbol(p,Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts,14,30))
|
||||
>Point : Point, Symbol(Point,Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts,0,10))
|
||||
|
||||
return new Line({ x: 0, y: 0 }, p);
|
||||
>new Line({ x: 0, y: 0 }, p) : Line
|
||||
>Line : typeof Line
|
||||
>Line : typeof Line, Symbol(Line,Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts,7,51))
|
||||
>{ x: 0, y: 0 } : { x: number; y: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts,15,33))
|
||||
>0 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts,15,39))
|
||||
>0 : number
|
||||
>p : Point
|
||||
>p : Point, Symbol(p,Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts,14,30))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+13
-13
@@ -1,35 +1,35 @@
|
||||
=== tests/cases/conformance/internalModules/exportDeclarations/ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts ===
|
||||
module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts,0,0))
|
||||
|
||||
class Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts,0,10))
|
||||
|
||||
constructor(public x: number, public y: number) { }
|
||||
>x : number
|
||||
>y : number
|
||||
>x : number, Symbol(x,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts,3,20))
|
||||
>y : number, Symbol(y,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts,3,37))
|
||||
}
|
||||
|
||||
export var Origin: Point = { x: 0, y: 0 };
|
||||
>Origin : Point
|
||||
>Point : Point
|
||||
>Origin : Point, Symbol(Origin,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts,6,14))
|
||||
>Point : Point, Symbol(Point,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts,0,10))
|
||||
>{ x: 0, y: 0 } : { x: number; y: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts,6,32))
|
||||
>0 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts,6,38))
|
||||
>0 : number
|
||||
|
||||
export var Unity = { start: new Point(0, 0), end: new Point(1, 0) };
|
||||
>Unity : { start: Point; end: Point; }
|
||||
>Unity : { start: Point; end: Point; }, Symbol(Unity,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts,8,14))
|
||||
>{ start: new Point(0, 0), end: new Point(1, 0) } : { start: Point; end: Point; }
|
||||
>start : Point
|
||||
>start : Point, Symbol(start,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts,8,24))
|
||||
>new Point(0, 0) : Point
|
||||
>Point : typeof Point
|
||||
>Point : typeof Point, Symbol(Point,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts,0,10))
|
||||
>0 : number
|
||||
>0 : number
|
||||
>end : Point
|
||||
>end : Point, Symbol(end,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts,8,48))
|
||||
>new Point(1, 0) : Point
|
||||
>Point : typeof Point
|
||||
>Point : typeof Point, Symbol(Point,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts,0,10))
|
||||
>1 : number
|
||||
>0 : number
|
||||
}
|
||||
|
||||
+15
-15
@@ -1,31 +1,31 @@
|
||||
=== tests/cases/conformance/internalModules/exportDeclarations/ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts ===
|
||||
module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts,0,0))
|
||||
|
||||
class Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts,0,10))
|
||||
|
||||
constructor(public x: number, public y: number) { }
|
||||
>x : number
|
||||
>y : number
|
||||
>x : number, Symbol(x,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts,3,20))
|
||||
>y : number, Symbol(y,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts,3,37))
|
||||
}
|
||||
|
||||
export var UnitSquare : {
|
||||
>UnitSquare : { top: { left: Point; right: Point; }; bottom: { left: Point; right: Point; }; }
|
||||
>UnitSquare : { top: { left: Point; right: Point; }; bottom: { left: Point; right: Point; }; }, Symbol(UnitSquare,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts,6,14))
|
||||
|
||||
top: { left: Point, right: Point },
|
||||
>top : { left: Point; right: Point; }
|
||||
>left : Point
|
||||
>Point : Point
|
||||
>right : Point
|
||||
>Point : Point
|
||||
>top : { left: Point; right: Point; }, Symbol(top,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts,6,29))
|
||||
>left : Point, Symbol(left,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts,7,14))
|
||||
>Point : Point, Symbol(Point,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts,0,10))
|
||||
>right : Point, Symbol(right,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts,7,27))
|
||||
>Point : Point, Symbol(Point,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts,0,10))
|
||||
|
||||
bottom: { left: Point, right: Point }
|
||||
>bottom : { left: Point; right: Point; }
|
||||
>left : Point
|
||||
>Point : Point
|
||||
>right : Point
|
||||
>Point : Point
|
||||
>bottom : { left: Point; right: Point; }, Symbol(bottom,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts,7,43))
|
||||
>left : Point, Symbol(left,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts,8,17))
|
||||
>Point : Point, Symbol(Point,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts,0,10))
|
||||
>right : Point, Symbol(right,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts,8,30))
|
||||
>Point : Point, Symbol(Point,Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts,0,10))
|
||||
|
||||
} = null;
|
||||
>null : null
|
||||
|
||||
+9
-9
@@ -1,22 +1,22 @@
|
||||
=== tests/cases/conformance/internalModules/exportDeclarations/ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts ===
|
||||
module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts,0,0))
|
||||
|
||||
class B {
|
||||
>B : B
|
||||
>B : B, Symbol(B,Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts,0,10))
|
||||
|
||||
id: number;
|
||||
>id : number
|
||||
>id : number, Symbol(id,Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts,1,13))
|
||||
}
|
||||
|
||||
export var beez: Array<B>;
|
||||
>beez : B[]
|
||||
>Array : T[]
|
||||
>B : B
|
||||
>beez : B[], Symbol(beez,Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts,5,14))
|
||||
>Array : T[], Symbol(Array,Decl(lib.d.ts,1000,23),Decl(lib.d.ts,1171,11))
|
||||
>B : B, Symbol(B,Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts,0,10))
|
||||
|
||||
export var beez2 = new Array<B>();
|
||||
>beez2 : B[]
|
||||
>beez2 : B[], Symbol(beez2,Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts,6,14))
|
||||
>new Array<B>() : B[]
|
||||
>Array : ArrayConstructor
|
||||
>B : B
|
||||
>Array : ArrayConstructor, Symbol(Array,Decl(lib.d.ts,1000,23),Decl(lib.d.ts,1171,11))
|
||||
>B : B, Symbol(B,Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts,0,10))
|
||||
}
|
||||
|
||||
@@ -1,25 +1,25 @@
|
||||
=== tests/cases/conformance/internalModules/exportDeclarations/ExportVariableWithAccessibleTypeInTypeAnnotation.ts ===
|
||||
module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts,0,0))
|
||||
|
||||
export interface Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts,0,10))
|
||||
|
||||
x: number;
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts,2,28))
|
||||
|
||||
y: number;
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts,3,18))
|
||||
}
|
||||
|
||||
// valid since Point is exported
|
||||
export var Origin: Point = { x: 0, y: 0 };
|
||||
>Origin : Point
|
||||
>Point : Point
|
||||
>Origin : Point, Symbol(Origin,Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts,8,14))
|
||||
>Point : Point, Symbol(Point,Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts,0,10))
|
||||
>{ x: 0, y: 0 } : { x: number; y: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts,8,32))
|
||||
>0 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts,8,38))
|
||||
>0 : number
|
||||
}
|
||||
|
||||
|
||||
+16
-16
@@ -1,45 +1,45 @@
|
||||
=== tests/cases/conformance/internalModules/exportDeclarations/ExportVariableWithInaccessibleTypeInTypeAnnotation.ts ===
|
||||
module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts,0,0))
|
||||
|
||||
export interface Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts,0,10))
|
||||
|
||||
x: number;
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts,2,28))
|
||||
|
||||
y: number;
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts,3,18))
|
||||
}
|
||||
|
||||
// valid since Point is exported
|
||||
export var Origin: Point = { x: 0, y: 0 };
|
||||
>Origin : Point
|
||||
>Point : Point
|
||||
>Origin : Point, Symbol(Origin,Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts,8,14))
|
||||
>Point : Point, Symbol(Point,Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts,0,10))
|
||||
>{ x: 0, y: 0 } : { x: number; y: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts,8,32))
|
||||
>0 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts,8,38))
|
||||
>0 : number
|
||||
|
||||
interface Point3d extends Point {
|
||||
>Point3d : Point3d
|
||||
>Point : Point
|
||||
>Point3d : Point3d, Symbol(Point3d,Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts,8,46))
|
||||
>Point : Point, Symbol(Point,Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts,0,10))
|
||||
|
||||
z: number;
|
||||
>z : number
|
||||
>z : number, Symbol(z,Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts,10,37))
|
||||
}
|
||||
|
||||
// invalid Point3d is not exported
|
||||
export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
|
||||
>Origin3d : Point3d
|
||||
>Point3d : Point3d
|
||||
>Origin3d : Point3d, Symbol(Origin3d,Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts,15,14))
|
||||
>Point3d : Point3d, Symbol(Point3d,Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts,8,46))
|
||||
>{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts,15,36))
|
||||
>0 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts,15,42))
|
||||
>0 : number
|
||||
>z : number
|
||||
>z : number, Symbol(z,Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts,15,48))
|
||||
>0 : number
|
||||
}
|
||||
|
||||
|
||||
+25
-25
@@ -1,58 +1,58 @@
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/function.ts ===
|
||||
module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(function.ts,0,0))
|
||||
|
||||
export function Point() {
|
||||
>Point : () => { x: number; y: number; }
|
||||
>Point : () => { x: number; y: number; }, Symbol(Point,Decl(function.ts,0,10))
|
||||
|
||||
return { x: 0, y: 0 };
|
||||
>{ x: 0, y: 0 } : { x: number; y: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(function.ts,2,16))
|
||||
>0 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(function.ts,2,22))
|
||||
>0 : number
|
||||
}
|
||||
}
|
||||
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/module.ts ===
|
||||
module B {
|
||||
>B : typeof B
|
||||
>B : typeof B, Symbol(B,Decl(module.ts,0,0))
|
||||
|
||||
export module Point {
|
||||
>Point : typeof Point
|
||||
>Point : typeof Point, Symbol(Point,Decl(module.ts,0,10))
|
||||
|
||||
export var Origin = { x: 0, y: 0 };
|
||||
>Origin : { x: number; y: number; }
|
||||
>Origin : { x: number; y: number; }, Symbol(Origin,Decl(module.ts,2,18))
|
||||
>{ x: 0, y: 0 } : { x: number; y: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(module.ts,2,29))
|
||||
>0 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(module.ts,2,35))
|
||||
>0 : number
|
||||
}
|
||||
}
|
||||
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
|
||||
var fn: () => { x: number; y: number };
|
||||
>fn : () => { x: number; y: number; }
|
||||
>x : number
|
||||
>y : number
|
||||
>fn : () => { x: number; y: number; }, Symbol(fn,Decl(test.ts,0,3),Decl(test.ts,1,3))
|
||||
>x : number, Symbol(x,Decl(test.ts,0,15))
|
||||
>y : number, Symbol(y,Decl(test.ts,0,26))
|
||||
|
||||
var fn = A.Point;
|
||||
>fn : () => { x: number; y: number; }
|
||||
>A.Point : () => { x: number; y: number; }
|
||||
>A : typeof A
|
||||
>Point : () => { x: number; y: number; }
|
||||
>fn : () => { x: number; y: number; }, Symbol(fn,Decl(test.ts,0,3),Decl(test.ts,1,3))
|
||||
>A.Point : () => { x: number; y: number; }, Symbol(A.Point,Decl(function.ts,0,10))
|
||||
>A : typeof A, Symbol(A,Decl(function.ts,0,0))
|
||||
>Point : () => { x: number; y: number; }, Symbol(A.Point,Decl(function.ts,0,10))
|
||||
|
||||
var cl: { x: number; y: number; }
|
||||
>cl : { x: number; y: number; }
|
||||
>x : number
|
||||
>y : number
|
||||
>cl : { x: number; y: number; }, Symbol(cl,Decl(test.ts,3,3),Decl(test.ts,4,3))
|
||||
>x : number, Symbol(x,Decl(test.ts,3,9))
|
||||
>y : number, Symbol(y,Decl(test.ts,3,20))
|
||||
|
||||
var cl = B.Point.Origin;
|
||||
>cl : { x: number; y: number; }
|
||||
>B.Point.Origin : { x: number; y: number; }
|
||||
>B.Point : typeof B.Point
|
||||
>B : typeof B
|
||||
>Point : typeof B.Point
|
||||
>Origin : { x: number; y: number; }
|
||||
>cl : { x: number; y: number; }, Symbol(cl,Decl(test.ts,3,3),Decl(test.ts,4,3))
|
||||
>B.Point.Origin : { x: number; y: number; }, Symbol(B.Point.Origin,Decl(module.ts,2,18))
|
||||
>B.Point : typeof B.Point, Symbol(B.Point,Decl(module.ts,0,10))
|
||||
>B : typeof B, Symbol(B,Decl(module.ts,0,0))
|
||||
>Point : typeof B.Point, Symbol(B.Point,Decl(module.ts,0,10))
|
||||
>Origin : { x: number; y: number; }, Symbol(B.Point.Origin,Decl(module.ts,2,18))
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration2_es6.ts ===
|
||||
function f(yield) {
|
||||
>f : (yield: any) => void
|
||||
>yield : any
|
||||
>f : (yield: any) => void, Symbol(f,Decl(FunctionDeclaration2_es6.ts,0,0))
|
||||
>yield : any, Symbol(yield,Decl(FunctionDeclaration2_es6.ts,0,11))
|
||||
}
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration4_es6.ts ===
|
||||
function yield() {
|
||||
>yield : () => void
|
||||
>yield : () => void, Symbol(yield,Decl(FunctionDeclaration4_es6.ts,0,0))
|
||||
}
|
||||
|
||||
@@ -1,45 +1,45 @@
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/ModuleAndEnumWithSameNameAndCommonRoot.ts ===
|
||||
module enumdule {
|
||||
>enumdule : typeof enumdule
|
||||
>enumdule : typeof enumdule, Symbol(enumdule,Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,0,0),Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,5,1))
|
||||
|
||||
export class Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,0,17))
|
||||
|
||||
constructor(public x: number, public y: number) { }
|
||||
>x : number
|
||||
>y : number
|
||||
>x : number, Symbol(x,Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,3,20))
|
||||
>y : number, Symbol(y,Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,3,37))
|
||||
}
|
||||
}
|
||||
|
||||
enum enumdule {
|
||||
>enumdule : enumdule
|
||||
>enumdule : enumdule, Symbol(enumdule,Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,0,0),Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,5,1))
|
||||
|
||||
Red, Blue
|
||||
>Red : enumdule
|
||||
>Blue : enumdule
|
||||
>Red : enumdule, Symbol(enumdule.Red,Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,7,15))
|
||||
>Blue : enumdule, Symbol(enumdule.Blue,Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,8,8))
|
||||
}
|
||||
|
||||
var x: enumdule;
|
||||
>x : enumdule
|
||||
>enumdule : enumdule
|
||||
>x : enumdule, Symbol(x,Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,11,3),Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,12,3))
|
||||
>enumdule : enumdule, Symbol(enumdule,Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,0,0),Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,5,1))
|
||||
|
||||
var x = enumdule.Red;
|
||||
>x : enumdule
|
||||
>enumdule.Red : enumdule
|
||||
>enumdule : typeof enumdule
|
||||
>Red : enumdule
|
||||
>x : enumdule, Symbol(x,Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,11,3),Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,12,3))
|
||||
>enumdule.Red : enumdule, Symbol(enumdule.Red,Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,7,15))
|
||||
>enumdule : typeof enumdule, Symbol(enumdule,Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,0,0),Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,5,1))
|
||||
>Red : enumdule, Symbol(enumdule.Red,Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,7,15))
|
||||
|
||||
var y: { x: number; y: number };
|
||||
>y : { x: number; y: number; }
|
||||
>x : number
|
||||
>y : number
|
||||
>y : { x: number; y: number; }, Symbol(y,Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,14,3),Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,15,3))
|
||||
>x : number, Symbol(x,Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,14,8))
|
||||
>y : number, Symbol(y,Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,14,19))
|
||||
|
||||
var y = new enumdule.Point(0, 0);
|
||||
>y : { x: number; y: number; }
|
||||
>y : { x: number; y: number; }, Symbol(y,Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,14,3),Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,15,3))
|
||||
>new enumdule.Point(0, 0) : enumdule.Point
|
||||
>enumdule.Point : typeof enumdule.Point
|
||||
>enumdule : typeof enumdule
|
||||
>Point : typeof enumdule.Point
|
||||
>enumdule.Point : typeof enumdule.Point, Symbol(enumdule.Point,Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,0,17))
|
||||
>enumdule : typeof enumdule, Symbol(enumdule,Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,0,0),Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,5,1))
|
||||
>Point : typeof enumdule.Point, Symbol(enumdule.Point,Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts,0,17))
|
||||
>0 : number
|
||||
>0 : number
|
||||
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
=== tests/cases/conformance/parser/ecmascript5/Protected/Protected5.ts ===
|
||||
class C {
|
||||
>C : C
|
||||
>C : C, Symbol(C,Decl(Protected5.ts,0,0))
|
||||
|
||||
protected static m() { }
|
||||
>m : () => void
|
||||
>m : () => void, Symbol(C.m,Decl(Protected5.ts,0,9))
|
||||
}
|
||||
|
||||
@@ -1,10 +1,10 @@
|
||||
=== tests/cases/conformance/parser/ecmascript5/Protected/Protected8.ts ===
|
||||
interface I {
|
||||
>I : I
|
||||
>I : I, Symbol(I,Decl(Protected8.ts,0,0))
|
||||
|
||||
protected
|
||||
>protected : any
|
||||
>protected : any, Symbol(protected,Decl(Protected8.ts,0,13))
|
||||
|
||||
p
|
||||
>p : any
|
||||
>p : any, Symbol(p,Decl(Protected8.ts,1,12))
|
||||
}
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
=== tests/cases/conformance/parser/ecmascript5/Protected/Protected9.ts ===
|
||||
class C {
|
||||
>C : C
|
||||
>C : C, Symbol(C,Decl(Protected9.ts,0,0))
|
||||
|
||||
constructor(protected p) { }
|
||||
>p : any
|
||||
>p : any, Symbol(p,Decl(Protected9.ts,1,15))
|
||||
}
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
=== tests/cases/conformance/parser/ecmascript5/TupleTypes/TupleType1.ts ===
|
||||
var v: [number]
|
||||
>v : [number]
|
||||
>v : [number], Symbol(v,Decl(TupleType1.ts,0,3))
|
||||
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
=== tests/cases/conformance/parser/ecmascript5/TupleTypes/TupleType2.ts ===
|
||||
var v: [number, string]
|
||||
>v : [number, string]
|
||||
>v : [number, string], Symbol(v,Decl(TupleType2.ts,0,3))
|
||||
|
||||
|
||||
+41
-41
@@ -1,82 +1,82 @@
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts ===
|
||||
module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,5,1))
|
||||
|
||||
export class Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,0,10))
|
||||
|
||||
x: number;
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,1,24))
|
||||
|
||||
y: number;
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,2,18))
|
||||
}
|
||||
}
|
||||
|
||||
module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,5,1))
|
||||
|
||||
class Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,7,10))
|
||||
|
||||
fromCarthesian(p: A.Point) {
|
||||
>fromCarthesian : (p: A.Point) => { x: number; y: number; }
|
||||
>p : A.Point
|
||||
>A : unknown
|
||||
>Point : A.Point
|
||||
>fromCarthesian : (p: A.Point) => { x: number; y: number; }, Symbol(fromCarthesian,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,8,17))
|
||||
>p : A.Point, Symbol(p,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,9,23))
|
||||
>A : any, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,5,1))
|
||||
>Point : A.Point, Symbol(Point,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,0,10))
|
||||
|
||||
return { x: p.x, y: p.y };
|
||||
>{ x: p.x, y: p.y } : { x: number; y: number; }
|
||||
>x : number
|
||||
>p.x : number
|
||||
>p : A.Point
|
||||
>x : number
|
||||
>y : number
|
||||
>p.y : number
|
||||
>p : A.Point
|
||||
>y : number
|
||||
>x : number, Symbol(x,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,10,20))
|
||||
>p.x : number, Symbol(Point.x,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,1,24))
|
||||
>p : A.Point, Symbol(p,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,9,23))
|
||||
>x : number, Symbol(Point.x,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,1,24))
|
||||
>y : number, Symbol(y,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,10,28))
|
||||
>p.y : number, Symbol(Point.y,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,2,18))
|
||||
>p : A.Point, Symbol(p,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,9,23))
|
||||
>y : number, Symbol(Point.y,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,2,18))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ensure merges as expected
|
||||
var p: { x: number; y: number; };
|
||||
>p : { x: number; y: number; }
|
||||
>x : number
|
||||
>y : number
|
||||
>p : { x: number; y: number; }, Symbol(p,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,16,3),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,17,3))
|
||||
>x : number, Symbol(x,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,16,8))
|
||||
>y : number, Symbol(y,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,16,19))
|
||||
|
||||
var p: A.Point;
|
||||
>p : { x: number; y: number; }
|
||||
>A : unknown
|
||||
>Point : A.Point
|
||||
>p : { x: number; y: number; }, Symbol(p,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,16,3),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,17,3))
|
||||
>A : any, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,5,1))
|
||||
>Point : A.Point, Symbol(A.Point,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,0,10))
|
||||
|
||||
module X.Y.Z {
|
||||
>X : typeof X
|
||||
>Y : typeof Y
|
||||
>Z : typeof Z
|
||||
>X : typeof X, Symbol(X,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,17,15),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,23,1))
|
||||
>Y : typeof Y, Symbol(Y,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,19,9),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,25,10))
|
||||
>Z : typeof Z, Symbol(Z,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,19,11),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,26,21))
|
||||
|
||||
export class Line {
|
||||
>Line : Line
|
||||
>Line : Line, Symbol(Line,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,19,14))
|
||||
|
||||
length: number;
|
||||
>length : number
|
||||
>length : number, Symbol(length,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,20,23))
|
||||
}
|
||||
}
|
||||
|
||||
module X {
|
||||
>X : typeof X
|
||||
>X : typeof X, Symbol(X,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,17,15),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,23,1))
|
||||
|
||||
export module Y {
|
||||
>Y : typeof Y
|
||||
>Y : typeof Y, Symbol(Y,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,19,9),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,25,10))
|
||||
|
||||
export module Z {
|
||||
>Z : typeof Z
|
||||
>Z : typeof Z, Symbol(Z,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,19,11),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,26,21))
|
||||
|
||||
class Line {
|
||||
>Line : Line
|
||||
>Line : Line, Symbol(Line,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,27,25))
|
||||
|
||||
name: string;
|
||||
>name : string
|
||||
>name : string, Symbol(name,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,28,24))
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -84,14 +84,14 @@ module X {
|
||||
|
||||
// ensure merges as expected
|
||||
var l: { length: number; }
|
||||
>l : { length: number; }
|
||||
>length : number
|
||||
>l : { length: number; }, Symbol(l,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,36,3),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,37,3))
|
||||
>length : number, Symbol(length,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,36,8))
|
||||
|
||||
var l: X.Y.Z.Line;
|
||||
>l : { length: number; }
|
||||
>X : unknown
|
||||
>Y : unknown
|
||||
>Z : unknown
|
||||
>Line : X.Y.Z.Line
|
||||
>l : { length: number; }, Symbol(l,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,36,3),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,37,3))
|
||||
>X : any, Symbol(X,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,17,15),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,23,1))
|
||||
>Y : any, Symbol(X.Y,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,19,9),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,25,10))
|
||||
>Z : any, Symbol(X.Y.Z,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,19,11),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,26,21))
|
||||
>Line : X.Y.Z.Line, Symbol(X.Y.Z.Line,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts,19,14))
|
||||
|
||||
|
||||
|
||||
+51
-51
@@ -1,103 +1,103 @@
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts ===
|
||||
module A {
|
||||
>A : unknown
|
||||
>A : any, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,6,1))
|
||||
|
||||
export interface Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,0,10))
|
||||
|
||||
x: number;
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,1,28))
|
||||
|
||||
y: number;
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,2,18))
|
||||
|
||||
toCarth(): Point;
|
||||
>toCarth : () => Point
|
||||
>Point : Point
|
||||
>toCarth : () => Point, Symbol(toCarth,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,3,18))
|
||||
>Point : Point, Symbol(Point,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,0,10))
|
||||
}
|
||||
}
|
||||
|
||||
module A {
|
||||
>A : unknown
|
||||
>A : any, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,6,1))
|
||||
|
||||
interface Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,8,10))
|
||||
|
||||
fromCarth(): Point;
|
||||
>fromCarth : () => Point
|
||||
>Point : Point
|
||||
>fromCarth : () => Point, Symbol(fromCarth,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,9,21))
|
||||
>Point : Point, Symbol(Point,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,8,10))
|
||||
}
|
||||
}
|
||||
|
||||
// ensure merges as expected
|
||||
var p: { x: number; y: number; toCarth(): A.Point; };
|
||||
>p : { x: number; y: number; toCarth(): A.Point; }
|
||||
>x : number
|
||||
>y : number
|
||||
>toCarth : () => A.Point
|
||||
>A : unknown
|
||||
>Point : A.Point
|
||||
>p : { x: number; y: number; toCarth(): A.Point; }, Symbol(p,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,15,3),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,16,3))
|
||||
>x : number, Symbol(x,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,15,8))
|
||||
>y : number, Symbol(y,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,15,19))
|
||||
>toCarth : () => A.Point, Symbol(toCarth,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,15,30))
|
||||
>A : any, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,6,1))
|
||||
>Point : A.Point, Symbol(A.Point,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,0,10))
|
||||
|
||||
var p: A.Point;
|
||||
>p : { x: number; y: number; toCarth(): A.Point; }
|
||||
>A : unknown
|
||||
>Point : A.Point
|
||||
>p : { x: number; y: number; toCarth(): A.Point; }, Symbol(p,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,15,3),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,16,3))
|
||||
>A : any, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,6,1))
|
||||
>Point : A.Point, Symbol(A.Point,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,0,10))
|
||||
|
||||
module X.Y.Z {
|
||||
>X : unknown
|
||||
>Y : unknown
|
||||
>Z : unknown
|
||||
>X : any, Symbol(X,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,16,15),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,22,1))
|
||||
>Y : any, Symbol(Y,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,18,9),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,24,10))
|
||||
>Z : any, Symbol(Z,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,18,11),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,25,20))
|
||||
|
||||
export interface Line {
|
||||
>Line : Line
|
||||
>Line : Line, Symbol(Line,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,18,14))
|
||||
|
||||
new (start: A.Point, end: A.Point);
|
||||
>start : A.Point
|
||||
>A : unknown
|
||||
>Point : A.Point
|
||||
>end : A.Point
|
||||
>A : unknown
|
||||
>Point : A.Point
|
||||
>start : A.Point, Symbol(start,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,20,13))
|
||||
>A : any, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,6,1))
|
||||
>Point : A.Point, Symbol(A.Point,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,0,10))
|
||||
>end : A.Point, Symbol(end,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,20,28))
|
||||
>A : any, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,6,1))
|
||||
>Point : A.Point, Symbol(A.Point,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,0,10))
|
||||
}
|
||||
}
|
||||
|
||||
module X {
|
||||
>X : unknown
|
||||
>X : any, Symbol(X,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,16,15),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,22,1))
|
||||
|
||||
export module Y.Z {
|
||||
>Y : unknown
|
||||
>Z : unknown
|
||||
>Y : any, Symbol(Y,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,18,9),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,24,10))
|
||||
>Z : any, Symbol(Z,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,18,11),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,25,20))
|
||||
|
||||
interface Line {
|
||||
>Line : Line
|
||||
>Line : Line, Symbol(Line,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,25,23))
|
||||
|
||||
start: A.Point;
|
||||
>start : A.Point
|
||||
>A : unknown
|
||||
>Point : A.Point
|
||||
>start : A.Point, Symbol(start,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,26,24))
|
||||
>A : any, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,6,1))
|
||||
>Point : A.Point, Symbol(A.Point,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,0,10))
|
||||
|
||||
end: A.Point;
|
||||
>end : A.Point
|
||||
>A : unknown
|
||||
>Point : A.Point
|
||||
>end : A.Point, Symbol(end,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,27,27))
|
||||
>A : any, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,6,1))
|
||||
>Point : A.Point, Symbol(A.Point,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,0,10))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ensure merges as expected
|
||||
var l: { new (s: A.Point, e: A.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
|
||||
>l : new (s: A.Point, e: A.Point) => any, Symbol(l,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,34,3),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,35,3))
|
||||
>s : A.Point, Symbol(s,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,34,14))
|
||||
>A : any, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,6,1))
|
||||
>Point : A.Point, Symbol(A.Point,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,0,10))
|
||||
>e : A.Point, Symbol(e,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,34,25))
|
||||
>A : any, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,6,1))
|
||||
>Point : A.Point, Symbol(A.Point,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,0,10))
|
||||
|
||||
var l: X.Y.Z.Line;
|
||||
>l : new (s: A.Point, e: A.Point) => any
|
||||
>X : unknown
|
||||
>Y : unknown
|
||||
>Z : unknown
|
||||
>Line : X.Y.Z.Line
|
||||
>l : new (s: A.Point, e: A.Point) => any, Symbol(l,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,34,3),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,35,3))
|
||||
>X : any, Symbol(X,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,16,15),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,22,1))
|
||||
>Y : any, Symbol(X.Y,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,18,9),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,24,10))
|
||||
>Z : any, Symbol(X.Y.Z,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,18,11),Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,25,20))
|
||||
>Line : X.Y.Z.Line, Symbol(X.Y.Z.Line,Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts,18,14))
|
||||
|
||||
|
||||
+67
-67
@@ -1,69 +1,69 @@
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/part1.ts ===
|
||||
module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(part1.ts,0,0),Decl(part2.ts,0,0))
|
||||
|
||||
export interface Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(part1.ts,0,10))
|
||||
|
||||
x: number;
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(part1.ts,1,28))
|
||||
|
||||
y: number;
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(part1.ts,2,18))
|
||||
}
|
||||
|
||||
export module Utils {
|
||||
>Utils : typeof Utils
|
||||
>Utils : typeof Utils, Symbol(Utils,Decl(part1.ts,4,5),Decl(part2.ts,2,31))
|
||||
|
||||
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
|
||||
>mirror : <T extends Point>(p: T) => { x: number; y: number; }, Symbol(mirror,Decl(part1.ts,6,25))
|
||||
>T : T, Symbol(T,Decl(part1.ts,7,31))
|
||||
>Point : Point, Symbol(Point,Decl(part1.ts,0,10))
|
||||
>p : T, Symbol(p,Decl(part1.ts,7,48))
|
||||
>T : T, Symbol(T,Decl(part1.ts,7,31))
|
||||
|
||||
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
|
||||
>x : number, Symbol(x,Decl(part1.ts,8,20))
|
||||
>p.y : number, Symbol(Point.y,Decl(part1.ts,2,18))
|
||||
>p : T, Symbol(p,Decl(part1.ts,7,48))
|
||||
>y : number, Symbol(Point.y,Decl(part1.ts,2,18))
|
||||
>y : number, Symbol(y,Decl(part1.ts,8,28))
|
||||
>p.x : number, Symbol(Point.x,Decl(part1.ts,1,28))
|
||||
>p : T, Symbol(p,Decl(part1.ts,7,48))
|
||||
>x : number, Symbol(Point.x,Decl(part1.ts,1,28))
|
||||
}
|
||||
}
|
||||
export var Origin: Point = { x: 0, y: 0 };
|
||||
>Origin : Point
|
||||
>Point : Point
|
||||
>Origin : Point, Symbol(Origin,Decl(part1.ts,11,14))
|
||||
>Point : Point, Symbol(Point,Decl(part1.ts,0,10))
|
||||
>{ x: 0, y: 0 } : { x: number; y: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(part1.ts,11,32))
|
||||
>0 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(part1.ts,11,38))
|
||||
>0 : number
|
||||
}
|
||||
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/part2.ts ===
|
||||
module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(part1.ts,0,0),Decl(part2.ts,0,0))
|
||||
|
||||
// not a collision, since we don't export
|
||||
var Origin: string = "0,0";
|
||||
>Origin : string
|
||||
>Origin : string, Symbol(Origin,Decl(part2.ts,2,7))
|
||||
>"0,0" : string
|
||||
|
||||
export module Utils {
|
||||
>Utils : typeof Utils
|
||||
>Utils : typeof Utils, Symbol(Utils,Decl(part1.ts,4,5),Decl(part2.ts,2,31))
|
||||
|
||||
export class Plane {
|
||||
>Plane : Plane
|
||||
>Plane : Plane, Symbol(Plane,Decl(part2.ts,4,25))
|
||||
|
||||
constructor(public tl: Point, public br: Point) { }
|
||||
>tl : Point
|
||||
>Point : Point
|
||||
>br : Point
|
||||
>Point : Point
|
||||
>tl : Point, Symbol(tl,Decl(part2.ts,6,24))
|
||||
>Point : Point, Symbol(Point,Decl(part1.ts,0,10))
|
||||
>br : Point, Symbol(br,Decl(part2.ts,6,41))
|
||||
>Point : Point, Symbol(Point,Decl(part1.ts,0,10))
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -72,59 +72,59 @@ module A {
|
||||
// test the merging actually worked
|
||||
|
||||
var o: { x: number; y: number };
|
||||
>o : { x: number; y: number; }
|
||||
>x : number
|
||||
>y : number
|
||||
>o : { x: number; y: number; }, Symbol(o,Decl(part3.ts,2,3),Decl(part3.ts,3,3),Decl(part3.ts,4,3),Decl(part3.ts,5,3))
|
||||
>x : number, Symbol(x,Decl(part3.ts,2,8))
|
||||
>y : number, Symbol(y,Decl(part3.ts,2,19))
|
||||
|
||||
var o: A.Point;
|
||||
>o : { x: number; y: number; }
|
||||
>A : unknown
|
||||
>Point : A.Point
|
||||
>o : { x: number; y: number; }, Symbol(o,Decl(part3.ts,2,3),Decl(part3.ts,3,3),Decl(part3.ts,4,3),Decl(part3.ts,5,3))
|
||||
>A : any, Symbol(A,Decl(part1.ts,0,0),Decl(part2.ts,0,0))
|
||||
>Point : A.Point, Symbol(A.Point,Decl(part1.ts,0,10))
|
||||
|
||||
var o = A.Origin;
|
||||
>o : { x: number; y: number; }
|
||||
>A.Origin : A.Point
|
||||
>A : typeof A
|
||||
>Origin : A.Point
|
||||
>o : { x: number; y: number; }, Symbol(o,Decl(part3.ts,2,3),Decl(part3.ts,3,3),Decl(part3.ts,4,3),Decl(part3.ts,5,3))
|
||||
>A.Origin : A.Point, Symbol(A.Origin,Decl(part1.ts,11,14))
|
||||
>A : typeof A, Symbol(A,Decl(part1.ts,0,0),Decl(part2.ts,0,0))
|
||||
>Origin : A.Point, Symbol(A.Origin,Decl(part1.ts,11,14))
|
||||
|
||||
var o = A.Utils.mirror(o);
|
||||
>o : { x: number; y: number; }
|
||||
>o : { x: number; y: number; }, Symbol(o,Decl(part3.ts,2,3),Decl(part3.ts,3,3),Decl(part3.ts,4,3),Decl(part3.ts,5,3))
|
||||
>A.Utils.mirror(o) : { x: number; y: number; }
|
||||
>A.Utils.mirror : <T extends A.Point>(p: T) => { x: number; y: number; }
|
||||
>A.Utils : typeof A.Utils
|
||||
>A : typeof A
|
||||
>Utils : typeof A.Utils
|
||||
>mirror : <T extends A.Point>(p: T) => { x: number; y: number; }
|
||||
>o : { x: number; y: number; }
|
||||
>A.Utils.mirror : <T extends A.Point>(p: T) => { x: number; y: number; }, Symbol(A.Utils.mirror,Decl(part1.ts,6,25))
|
||||
>A.Utils : typeof A.Utils, Symbol(A.Utils,Decl(part1.ts,4,5),Decl(part2.ts,2,31))
|
||||
>A : typeof A, Symbol(A,Decl(part1.ts,0,0),Decl(part2.ts,0,0))
|
||||
>Utils : typeof A.Utils, Symbol(A.Utils,Decl(part1.ts,4,5),Decl(part2.ts,2,31))
|
||||
>mirror : <T extends A.Point>(p: T) => { x: number; y: number; }, Symbol(A.Utils.mirror,Decl(part1.ts,6,25))
|
||||
>o : { x: number; y: number; }, Symbol(o,Decl(part3.ts,2,3),Decl(part3.ts,3,3),Decl(part3.ts,4,3),Decl(part3.ts,5,3))
|
||||
|
||||
var p: { tl: A.Point; br: A.Point };
|
||||
>p : { tl: A.Point; br: A.Point; }
|
||||
>tl : A.Point
|
||||
>A : unknown
|
||||
>Point : A.Point
|
||||
>br : A.Point
|
||||
>A : unknown
|
||||
>Point : A.Point
|
||||
>p : { tl: A.Point; br: A.Point; }, Symbol(p,Decl(part3.ts,7,3),Decl(part3.ts,8,3),Decl(part3.ts,9,3))
|
||||
>tl : A.Point, Symbol(tl,Decl(part3.ts,7,8))
|
||||
>A : any, Symbol(A,Decl(part1.ts,0,0),Decl(part2.ts,0,0))
|
||||
>Point : A.Point, Symbol(A.Point,Decl(part1.ts,0,10))
|
||||
>br : A.Point, Symbol(br,Decl(part3.ts,7,21))
|
||||
>A : any, Symbol(A,Decl(part1.ts,0,0),Decl(part2.ts,0,0))
|
||||
>Point : A.Point, Symbol(A.Point,Decl(part1.ts,0,10))
|
||||
|
||||
var p: A.Utils.Plane;
|
||||
>p : { tl: A.Point; br: A.Point; }
|
||||
>A : unknown
|
||||
>Utils : unknown
|
||||
>Plane : A.Utils.Plane
|
||||
>p : { tl: A.Point; br: A.Point; }, Symbol(p,Decl(part3.ts,7,3),Decl(part3.ts,8,3),Decl(part3.ts,9,3))
|
||||
>A : any, Symbol(A,Decl(part1.ts,0,0),Decl(part2.ts,0,0))
|
||||
>Utils : any, Symbol(A.Utils,Decl(part1.ts,4,5),Decl(part2.ts,2,31))
|
||||
>Plane : A.Utils.Plane, Symbol(A.Utils.Plane,Decl(part2.ts,4,25))
|
||||
|
||||
var p = new A.Utils.Plane(o, { x: 1, y: 1 });
|
||||
>p : { tl: A.Point; br: A.Point; }
|
||||
>p : { tl: A.Point; br: A.Point; }, Symbol(p,Decl(part3.ts,7,3),Decl(part3.ts,8,3),Decl(part3.ts,9,3))
|
||||
>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 A.Utils
|
||||
>Plane : typeof A.Utils.Plane
|
||||
>o : { x: number; y: number; }
|
||||
>A.Utils.Plane : typeof A.Utils.Plane, Symbol(A.Utils.Plane,Decl(part2.ts,4,25))
|
||||
>A.Utils : typeof A.Utils, Symbol(A.Utils,Decl(part1.ts,4,5),Decl(part2.ts,2,31))
|
||||
>A : typeof A, Symbol(A,Decl(part1.ts,0,0),Decl(part2.ts,0,0))
|
||||
>Utils : typeof A.Utils, Symbol(A.Utils,Decl(part1.ts,4,5),Decl(part2.ts,2,31))
|
||||
>Plane : typeof A.Utils.Plane, Symbol(A.Utils.Plane,Decl(part2.ts,4,25))
|
||||
>o : { x: number; y: number; }, Symbol(o,Decl(part3.ts,2,3),Decl(part3.ts,3,3),Decl(part3.ts,4,3),Decl(part3.ts,5,3))
|
||||
>{ x: 1, y: 1 } : { x: number; y: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(part3.ts,9,30))
|
||||
>1 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(part3.ts,9,36))
|
||||
>1 : number
|
||||
|
||||
|
||||
|
||||
+60
-60
@@ -1,112 +1,112 @@
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts ===
|
||||
module A {
|
||||
>A : unknown
|
||||
>A : any, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,6,1))
|
||||
|
||||
export interface Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,10),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,8,10))
|
||||
|
||||
x: number;
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,1,28))
|
||||
|
||||
y: number;
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,2,18))
|
||||
|
||||
toCarth(): Point;
|
||||
>toCarth : () => Point
|
||||
>Point : Point
|
||||
>toCarth : () => Point, Symbol(toCarth,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,3,18))
|
||||
>Point : Point, Symbol(Point,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,10),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,8,10))
|
||||
}
|
||||
}
|
||||
|
||||
module A {
|
||||
>A : unknown
|
||||
>A : any, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,6,1))
|
||||
|
||||
export interface Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,10),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,8,10))
|
||||
|
||||
fromCarth(): Point;
|
||||
>fromCarth : () => Point
|
||||
>Point : Point
|
||||
>fromCarth : () => Point, Symbol(fromCarth,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,9,28))
|
||||
>Point : Point, Symbol(Point,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,10),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,8,10))
|
||||
}
|
||||
}
|
||||
|
||||
// ensure merges as expected
|
||||
var p: { x: number; y: number; toCarth(): A.Point; fromCarth(): A.Point; };
|
||||
>p : { x: number; y: number; toCarth(): A.Point; fromCarth(): A.Point; }
|
||||
>x : number
|
||||
>y : number
|
||||
>toCarth : () => A.Point
|
||||
>A : unknown
|
||||
>Point : A.Point
|
||||
>fromCarth : () => A.Point
|
||||
>A : unknown
|
||||
>Point : A.Point
|
||||
>p : { x: number; y: number; toCarth(): A.Point; fromCarth(): A.Point; }, Symbol(p,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,15,3),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,16,3))
|
||||
>x : number, Symbol(x,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,15,8))
|
||||
>y : number, Symbol(y,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,15,19))
|
||||
>toCarth : () => A.Point, Symbol(toCarth,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,15,30))
|
||||
>A : any, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,6,1))
|
||||
>Point : A.Point, Symbol(A.Point,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,10),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,8,10))
|
||||
>fromCarth : () => A.Point, Symbol(fromCarth,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,15,50))
|
||||
>A : any, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,6,1))
|
||||
>Point : A.Point, Symbol(A.Point,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,10),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,8,10))
|
||||
|
||||
var p: A.Point;
|
||||
>p : { x: number; y: number; toCarth(): A.Point; fromCarth(): A.Point; }
|
||||
>A : unknown
|
||||
>Point : A.Point
|
||||
>p : { x: number; y: number; toCarth(): A.Point; fromCarth(): A.Point; }, Symbol(p,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,15,3),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,16,3))
|
||||
>A : any, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,6,1))
|
||||
>Point : A.Point, Symbol(A.Point,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,10),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,8,10))
|
||||
|
||||
module X.Y.Z {
|
||||
>X : unknown
|
||||
>Y : unknown
|
||||
>Z : unknown
|
||||
>X : any, Symbol(X,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,16,15),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,22,1))
|
||||
>Y : any, Symbol(Y,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,18,9),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,24,10))
|
||||
>Z : any, Symbol(Z,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,18,11),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,25,20))
|
||||
|
||||
export interface Line {
|
||||
>Line : Line
|
||||
>Line : Line, Symbol(Line,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,18,14),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,25,23))
|
||||
|
||||
new (start: A.Point, end: A.Point);
|
||||
>start : A.Point
|
||||
>A : unknown
|
||||
>Point : A.Point
|
||||
>end : A.Point
|
||||
>A : unknown
|
||||
>Point : A.Point
|
||||
>start : A.Point, Symbol(start,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,20,13))
|
||||
>A : any, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,6,1))
|
||||
>Point : A.Point, Symbol(A.Point,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,10),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,8,10))
|
||||
>end : A.Point, Symbol(end,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,20,28))
|
||||
>A : any, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,6,1))
|
||||
>Point : A.Point, Symbol(A.Point,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,10),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,8,10))
|
||||
}
|
||||
}
|
||||
|
||||
module X {
|
||||
>X : unknown
|
||||
>X : any, Symbol(X,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,16,15),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,22,1))
|
||||
|
||||
export module Y.Z {
|
||||
>Y : unknown
|
||||
>Z : unknown
|
||||
>Y : any, Symbol(Y,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,18,9),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,24,10))
|
||||
>Z : any, Symbol(Z,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,18,11),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,25,20))
|
||||
|
||||
export interface Line {
|
||||
>Line : Line
|
||||
>Line : Line, Symbol(Line,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,18,14),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,25,23))
|
||||
|
||||
start: A.Point;
|
||||
>start : A.Point
|
||||
>A : unknown
|
||||
>Point : A.Point
|
||||
>start : A.Point, Symbol(start,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,26,31))
|
||||
>A : any, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,6,1))
|
||||
>Point : A.Point, Symbol(A.Point,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,10),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,8,10))
|
||||
|
||||
end: A.Point;
|
||||
>end : A.Point
|
||||
>A : unknown
|
||||
>Point : A.Point
|
||||
>end : A.Point, Symbol(end,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,27,27))
|
||||
>A : any, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,6,1))
|
||||
>Point : A.Point, Symbol(A.Point,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,10),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,8,10))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ensure merges as expected
|
||||
var l: { start: A.Point; end: A.Point; new (s: A.Point, e: A.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
|
||||
>l : { new (s: A.Point, e: A.Point): any; start: A.Point; end: A.Point; }, Symbol(l,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,34,3),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,35,3))
|
||||
>start : A.Point, Symbol(start,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,34,8))
|
||||
>A : any, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,6,1))
|
||||
>Point : A.Point, Symbol(A.Point,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,10),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,8,10))
|
||||
>end : A.Point, Symbol(end,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,34,24))
|
||||
>A : any, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,6,1))
|
||||
>Point : A.Point, Symbol(A.Point,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,10),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,8,10))
|
||||
>s : A.Point, Symbol(s,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,34,44))
|
||||
>A : any, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,6,1))
|
||||
>Point : A.Point, Symbol(A.Point,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,10),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,8,10))
|
||||
>e : A.Point, Symbol(e,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,34,55))
|
||||
>A : any, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,6,1))
|
||||
>Point : A.Point, Symbol(A.Point,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,0,10),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,8,10))
|
||||
|
||||
var l: X.Y.Z.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
|
||||
>l : { new (s: A.Point, e: A.Point): any; start: A.Point; end: A.Point; }, Symbol(l,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,34,3),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,35,3))
|
||||
>X : any, Symbol(X,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,16,15),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,22,1))
|
||||
>Y : any, Symbol(X.Y,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,18,9),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,24,10))
|
||||
>Z : any, Symbol(X.Y.Z,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,18,11),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,25,20))
|
||||
>Line : X.Y.Z.Line, Symbol(X.Y.Z.Line,Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,18,14),Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts,25,23))
|
||||
|
||||
|
||||
+30
-30
@@ -1,62 +1,62 @@
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts ===
|
||||
module A.B {
|
||||
>A : typeof A
|
||||
>B : typeof B
|
||||
>A : typeof A, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,2,1))
|
||||
>B : typeof B, Symbol(B,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,0,9))
|
||||
|
||||
export var x: number;
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,1,14))
|
||||
}
|
||||
|
||||
module A{
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,2,1))
|
||||
|
||||
module B {
|
||||
>B : typeof B
|
||||
>B : typeof B, Symbol(B,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,4,9))
|
||||
|
||||
export var x: string;
|
||||
>x : string
|
||||
>x : string, Symbol(x,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,6,18))
|
||||
}
|
||||
}
|
||||
|
||||
// ensure the right var decl is exported
|
||||
var x: number;
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,11,3),Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,12,3))
|
||||
|
||||
var x = A.B.x;
|
||||
>x : number
|
||||
>A.B.x : number
|
||||
>A.B : typeof A.B
|
||||
>A : typeof A
|
||||
>B : typeof A.B
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,11,3),Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,12,3))
|
||||
>A.B.x : number, Symbol(A.B.x,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,1,14))
|
||||
>A.B : typeof A.B, Symbol(A.B,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,0,9))
|
||||
>A : typeof A, Symbol(A,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,0,0),Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,2,1))
|
||||
>B : typeof A.B, Symbol(A.B,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,0,9))
|
||||
>x : number, Symbol(A.B.x,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,1,14))
|
||||
|
||||
module X.Y.Z {
|
||||
>X : typeof X
|
||||
>Y : typeof Y
|
||||
>Z : typeof Z
|
||||
>X : typeof X, Symbol(X,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,12,14),Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,18,1))
|
||||
>Y : typeof Y, Symbol(Y,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,14,9),Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,20,10))
|
||||
>Z : typeof Z, Symbol(Z,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,14,11))
|
||||
|
||||
export class Line {
|
||||
>Line : Line
|
||||
>Line : Line, Symbol(Line,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,14,14))
|
||||
|
||||
length: number;
|
||||
>length : number
|
||||
>length : number, Symbol(length,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,15,23))
|
||||
}
|
||||
}
|
||||
|
||||
module X {
|
||||
>X : typeof X
|
||||
>X : typeof X, Symbol(X,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,12,14),Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,18,1))
|
||||
|
||||
export module Y {
|
||||
>Y : typeof Y
|
||||
>Y : typeof Y, Symbol(Y,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,14,9),Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,20,10))
|
||||
|
||||
module Z {
|
||||
>Z : typeof Z
|
||||
>Z : typeof Z, Symbol(Z,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,21,21))
|
||||
|
||||
export class Line {
|
||||
>Line : Line
|
||||
>Line : Line, Symbol(Line,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,22,18))
|
||||
|
||||
name: string;
|
||||
>name : string
|
||||
>name : string, Symbol(name,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,23,31))
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -64,13 +64,13 @@ module X {
|
||||
|
||||
// make sure merging works as expected
|
||||
var l: { length: number };
|
||||
>l : { length: number; }
|
||||
>length : number
|
||||
>l : { length: number; }, Symbol(l,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,31,3),Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,32,3))
|
||||
>length : number, Symbol(length,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,31,8))
|
||||
|
||||
var l: X.Y.Z.Line;
|
||||
>l : { length: number; }
|
||||
>X : unknown
|
||||
>Y : unknown
|
||||
>Z : unknown
|
||||
>Line : X.Y.Z.Line
|
||||
>l : { length: number; }, Symbol(l,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,31,3),Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,32,3))
|
||||
>X : any, Symbol(X,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,12,14),Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,18,1))
|
||||
>Y : any, Symbol(X.Y,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,14,9),Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,20,10))
|
||||
>Z : any, Symbol(X.Y.Z,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,14,11))
|
||||
>Line : X.Y.Z.Line, Symbol(X.Y.Z.Line,Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts,14,14))
|
||||
|
||||
|
||||
+37
-37
@@ -1,40 +1,40 @@
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/part1.ts ===
|
||||
module Root {
|
||||
>Root : typeof Root
|
||||
>Root : typeof Root, Symbol(Root,Decl(part1.ts,0,0))
|
||||
|
||||
export module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(part1.ts,0,13))
|
||||
|
||||
export interface Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(part1.ts,1,21))
|
||||
|
||||
x: number;
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(part1.ts,2,32))
|
||||
|
||||
y: number;
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(part1.ts,3,22))
|
||||
}
|
||||
|
||||
export module Utils {
|
||||
>Utils : typeof Utils
|
||||
>Utils : typeof Utils, Symbol(Utils,Decl(part1.ts,5,9))
|
||||
|
||||
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
|
||||
>mirror : <T extends Point>(p: T) => { x: number; y: number; }, Symbol(mirror,Decl(part1.ts,7,29))
|
||||
>T : T, Symbol(T,Decl(part1.ts,8,35))
|
||||
>Point : Point, Symbol(Point,Decl(part1.ts,1,21))
|
||||
>p : T, Symbol(p,Decl(part1.ts,8,52))
|
||||
>T : T, Symbol(T,Decl(part1.ts,8,35))
|
||||
|
||||
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
|
||||
>x : number, Symbol(x,Decl(part1.ts,9,24))
|
||||
>p.y : number, Symbol(Point.y,Decl(part1.ts,3,22))
|
||||
>p : T, Symbol(p,Decl(part1.ts,8,52))
|
||||
>y : number, Symbol(Point.y,Decl(part1.ts,3,22))
|
||||
>y : number, Symbol(y,Decl(part1.ts,9,32))
|
||||
>p.x : number, Symbol(Point.x,Decl(part1.ts,2,32))
|
||||
>p : T, Symbol(p,Decl(part1.ts,8,52))
|
||||
>x : number, Symbol(Point.x,Decl(part1.ts,2,32))
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -42,38 +42,38 @@ module Root {
|
||||
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/part2.ts ===
|
||||
module otherRoot {
|
||||
>otherRoot : typeof otherRoot
|
||||
>otherRoot : typeof otherRoot, Symbol(otherRoot,Decl(part2.ts,0,0))
|
||||
|
||||
export module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(part2.ts,0,18))
|
||||
|
||||
// have to be fully qualified since in different root
|
||||
export var Origin: Root.A.Point = { x: 0, y: 0 };
|
||||
>Origin : Root.A.Point
|
||||
>Root : unknown
|
||||
>A : unknown
|
||||
>Point : Root.A.Point
|
||||
>Origin : Root.A.Point, Symbol(Origin,Decl(part2.ts,3,18))
|
||||
>Root : any, Symbol(Root,Decl(part1.ts,0,0))
|
||||
>A : any, Symbol(Root.A,Decl(part1.ts,0,13))
|
||||
>Point : Root.A.Point, Symbol(Root.A.Point,Decl(part1.ts,1,21))
|
||||
>{ x: 0, y: 0 } : { x: number; y: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(part2.ts,3,43))
|
||||
>0 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(part2.ts,3,49))
|
||||
>0 : number
|
||||
|
||||
export module Utils {
|
||||
>Utils : typeof Utils
|
||||
>Utils : typeof Utils, Symbol(Utils,Decl(part2.ts,3,57))
|
||||
|
||||
export class Plane {
|
||||
>Plane : Plane
|
||||
>Plane : Plane, Symbol(Plane,Decl(part2.ts,5,29))
|
||||
|
||||
constructor(public tl: Root.A.Point, public br: Root.A.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
|
||||
>tl : Root.A.Point, Symbol(tl,Decl(part2.ts,7,28))
|
||||
>Root : any, Symbol(Root,Decl(part1.ts,0,0))
|
||||
>A : any, Symbol(Root.A,Decl(part1.ts,0,13))
|
||||
>Point : Root.A.Point, Symbol(Root.A.Point,Decl(part1.ts,1,21))
|
||||
>br : Root.A.Point, Symbol(br,Decl(part2.ts,7,52))
|
||||
>Root : any, Symbol(Root,Decl(part1.ts,0,0))
|
||||
>A : any, Symbol(Root.A,Decl(part1.ts,0,13))
|
||||
>Point : Root.A.Point, Symbol(Root.A.Point,Decl(part1.ts,1,21))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+66
-66
@@ -1,65 +1,65 @@
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/part1.ts ===
|
||||
module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(part1.ts,0,0),Decl(part2.ts,0,0))
|
||||
|
||||
export interface Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(part1.ts,0,10))
|
||||
|
||||
x: number;
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(part1.ts,1,28))
|
||||
|
||||
y: number;
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(part1.ts,2,18))
|
||||
}
|
||||
|
||||
export module Utils {
|
||||
>Utils : typeof Utils
|
||||
>Utils : typeof Utils, Symbol(Utils,Decl(part1.ts,4,5),Decl(part2.ts,1,46))
|
||||
|
||||
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
|
||||
>mirror : <T extends Point>(p: T) => { x: number; y: number; }, Symbol(mirror,Decl(part1.ts,6,25))
|
||||
>T : T, Symbol(T,Decl(part1.ts,7,31))
|
||||
>Point : Point, Symbol(Point,Decl(part1.ts,0,10))
|
||||
>p : T, Symbol(p,Decl(part1.ts,7,48))
|
||||
>T : T, Symbol(T,Decl(part1.ts,7,31))
|
||||
|
||||
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
|
||||
>x : number, Symbol(x,Decl(part1.ts,8,20))
|
||||
>p.y : number, Symbol(Point.y,Decl(part1.ts,2,18))
|
||||
>p : T, Symbol(p,Decl(part1.ts,7,48))
|
||||
>y : number, Symbol(Point.y,Decl(part1.ts,2,18))
|
||||
>y : number, Symbol(y,Decl(part1.ts,8,28))
|
||||
>p.x : number, Symbol(Point.x,Decl(part1.ts,1,28))
|
||||
>p : T, Symbol(p,Decl(part1.ts,7,48))
|
||||
>x : number, Symbol(Point.x,Decl(part1.ts,1,28))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
=== tests/cases/conformance/internalModules/DeclarationMerging/part2.ts ===
|
||||
module A {
|
||||
>A : typeof A
|
||||
>A : typeof A, Symbol(A,Decl(part1.ts,0,0),Decl(part2.ts,0,0))
|
||||
|
||||
export var Origin: Point = { x: 0, y: 0 };
|
||||
>Origin : Point
|
||||
>Point : Point
|
||||
>Origin : Point, Symbol(Origin,Decl(part2.ts,1,14))
|
||||
>Point : Point, Symbol(Point,Decl(part1.ts,0,10))
|
||||
>{ x: 0, y: 0 } : { x: number; y: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(part2.ts,1,32))
|
||||
>0 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(part2.ts,1,38))
|
||||
>0 : number
|
||||
|
||||
export module Utils {
|
||||
>Utils : typeof Utils
|
||||
>Utils : typeof Utils, Symbol(Utils,Decl(part1.ts,4,5),Decl(part2.ts,1,46))
|
||||
|
||||
export class Plane {
|
||||
>Plane : Plane
|
||||
>Plane : Plane, Symbol(Plane,Decl(part2.ts,3,25))
|
||||
|
||||
constructor(public tl: Point, public br: Point) { }
|
||||
>tl : Point
|
||||
>Point : Point
|
||||
>br : Point
|
||||
>Point : Point
|
||||
>tl : Point, Symbol(tl,Decl(part2.ts,5,24))
|
||||
>Point : Point, Symbol(Point,Decl(part1.ts,0,10))
|
||||
>br : Point, Symbol(br,Decl(part2.ts,5,41))
|
||||
>Point : Point, Symbol(Point,Decl(part1.ts,0,10))
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -68,59 +68,59 @@ module A {
|
||||
// test the merging actually worked
|
||||
|
||||
var o: { x: number; y: number };
|
||||
>o : { x: number; y: number; }
|
||||
>x : number
|
||||
>y : number
|
||||
>o : { x: number; y: number; }, Symbol(o,Decl(part3.ts,2,3),Decl(part3.ts,3,3),Decl(part3.ts,4,3),Decl(part3.ts,5,3))
|
||||
>x : number, Symbol(x,Decl(part3.ts,2,8))
|
||||
>y : number, Symbol(y,Decl(part3.ts,2,19))
|
||||
|
||||
var o: A.Point;
|
||||
>o : { x: number; y: number; }
|
||||
>A : unknown
|
||||
>Point : A.Point
|
||||
>o : { x: number; y: number; }, Symbol(o,Decl(part3.ts,2,3),Decl(part3.ts,3,3),Decl(part3.ts,4,3),Decl(part3.ts,5,3))
|
||||
>A : any, Symbol(A,Decl(part1.ts,0,0),Decl(part2.ts,0,0))
|
||||
>Point : A.Point, Symbol(A.Point,Decl(part1.ts,0,10))
|
||||
|
||||
var o = A.Origin;
|
||||
>o : { x: number; y: number; }
|
||||
>A.Origin : A.Point
|
||||
>A : typeof A
|
||||
>Origin : A.Point
|
||||
>o : { x: number; y: number; }, Symbol(o,Decl(part3.ts,2,3),Decl(part3.ts,3,3),Decl(part3.ts,4,3),Decl(part3.ts,5,3))
|
||||
>A.Origin : A.Point, Symbol(A.Origin,Decl(part2.ts,1,14))
|
||||
>A : typeof A, Symbol(A,Decl(part1.ts,0,0),Decl(part2.ts,0,0))
|
||||
>Origin : A.Point, Symbol(A.Origin,Decl(part2.ts,1,14))
|
||||
|
||||
var o = A.Utils.mirror(o);
|
||||
>o : { x: number; y: number; }
|
||||
>o : { x: number; y: number; }, Symbol(o,Decl(part3.ts,2,3),Decl(part3.ts,3,3),Decl(part3.ts,4,3),Decl(part3.ts,5,3))
|
||||
>A.Utils.mirror(o) : { x: number; y: number; }
|
||||
>A.Utils.mirror : <T extends A.Point>(p: T) => { x: number; y: number; }
|
||||
>A.Utils : typeof A.Utils
|
||||
>A : typeof A
|
||||
>Utils : typeof A.Utils
|
||||
>mirror : <T extends A.Point>(p: T) => { x: number; y: number; }
|
||||
>o : { x: number; y: number; }
|
||||
>A.Utils.mirror : <T extends A.Point>(p: T) => { x: number; y: number; }, Symbol(A.Utils.mirror,Decl(part1.ts,6,25))
|
||||
>A.Utils : typeof A.Utils, Symbol(A.Utils,Decl(part1.ts,4,5),Decl(part2.ts,1,46))
|
||||
>A : typeof A, Symbol(A,Decl(part1.ts,0,0),Decl(part2.ts,0,0))
|
||||
>Utils : typeof A.Utils, Symbol(A.Utils,Decl(part1.ts,4,5),Decl(part2.ts,1,46))
|
||||
>mirror : <T extends A.Point>(p: T) => { x: number; y: number; }, Symbol(A.Utils.mirror,Decl(part1.ts,6,25))
|
||||
>o : { x: number; y: number; }, Symbol(o,Decl(part3.ts,2,3),Decl(part3.ts,3,3),Decl(part3.ts,4,3),Decl(part3.ts,5,3))
|
||||
|
||||
var p: { tl: A.Point; br: A.Point };
|
||||
>p : { tl: A.Point; br: A.Point; }
|
||||
>tl : A.Point
|
||||
>A : unknown
|
||||
>Point : A.Point
|
||||
>br : A.Point
|
||||
>A : unknown
|
||||
>Point : A.Point
|
||||
>p : { tl: A.Point; br: A.Point; }, Symbol(p,Decl(part3.ts,7,3),Decl(part3.ts,8,3),Decl(part3.ts,9,3))
|
||||
>tl : A.Point, Symbol(tl,Decl(part3.ts,7,8))
|
||||
>A : any, Symbol(A,Decl(part1.ts,0,0),Decl(part2.ts,0,0))
|
||||
>Point : A.Point, Symbol(A.Point,Decl(part1.ts,0,10))
|
||||
>br : A.Point, Symbol(br,Decl(part3.ts,7,21))
|
||||
>A : any, Symbol(A,Decl(part1.ts,0,0),Decl(part2.ts,0,0))
|
||||
>Point : A.Point, Symbol(A.Point,Decl(part1.ts,0,10))
|
||||
|
||||
var p: A.Utils.Plane;
|
||||
>p : { tl: A.Point; br: A.Point; }
|
||||
>A : unknown
|
||||
>Utils : unknown
|
||||
>Plane : A.Utils.Plane
|
||||
>p : { tl: A.Point; br: A.Point; }, Symbol(p,Decl(part3.ts,7,3),Decl(part3.ts,8,3),Decl(part3.ts,9,3))
|
||||
>A : any, Symbol(A,Decl(part1.ts,0,0),Decl(part2.ts,0,0))
|
||||
>Utils : any, Symbol(A.Utils,Decl(part1.ts,4,5),Decl(part2.ts,1,46))
|
||||
>Plane : A.Utils.Plane, Symbol(A.Utils.Plane,Decl(part2.ts,3,25))
|
||||
|
||||
var p = new A.Utils.Plane(o, { x: 1, y: 1 });
|
||||
>p : { tl: A.Point; br: A.Point; }
|
||||
>p : { tl: A.Point; br: A.Point; }, Symbol(p,Decl(part3.ts,7,3),Decl(part3.ts,8,3),Decl(part3.ts,9,3))
|
||||
>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 A.Utils
|
||||
>Plane : typeof A.Utils.Plane
|
||||
>o : { x: number; y: number; }
|
||||
>A.Utils.Plane : typeof A.Utils.Plane, Symbol(A.Utils.Plane,Decl(part2.ts,3,25))
|
||||
>A.Utils : typeof A.Utils, Symbol(A.Utils,Decl(part1.ts,4,5),Decl(part2.ts,1,46))
|
||||
>A : typeof A, Symbol(A,Decl(part1.ts,0,0),Decl(part2.ts,0,0))
|
||||
>Utils : typeof A.Utils, Symbol(A.Utils,Decl(part1.ts,4,5),Decl(part2.ts,1,46))
|
||||
>Plane : typeof A.Utils.Plane, Symbol(A.Utils.Plane,Decl(part2.ts,3,25))
|
||||
>o : { x: number; y: number; }, Symbol(o,Decl(part3.ts,2,3),Decl(part3.ts,3,3),Decl(part3.ts,4,3),Decl(part3.ts,5,3))
|
||||
>{ x: 1, y: 1 } : { x: number; y: number; }
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(part3.ts,9,30))
|
||||
>1 : number
|
||||
>y : number
|
||||
>y : number, Symbol(y,Decl(part3.ts,9,36))
|
||||
>1 : number
|
||||
|
||||
|
||||
|
||||
@@ -1,26 +1,26 @@
|
||||
=== tests/cases/conformance/expressions/typeGuards/TypeGuardWithArrayUnion.ts ===
|
||||
class Message {
|
||||
>Message : Message
|
||||
>Message : Message, Symbol(Message,Decl(TypeGuardWithArrayUnion.ts,0,0))
|
||||
|
||||
value: string;
|
||||
>value : string
|
||||
>value : string, Symbol(value,Decl(TypeGuardWithArrayUnion.ts,0,15))
|
||||
}
|
||||
|
||||
function saySize(message: Message | Message[]) {
|
||||
>saySize : (message: Message | Message[]) => number
|
||||
>message : Message | Message[]
|
||||
>Message : Message
|
||||
>Message : Message
|
||||
>saySize : (message: Message | Message[]) => number, Symbol(saySize,Decl(TypeGuardWithArrayUnion.ts,2,1))
|
||||
>message : Message | Message[], Symbol(message,Decl(TypeGuardWithArrayUnion.ts,4,17))
|
||||
>Message : Message, Symbol(Message,Decl(TypeGuardWithArrayUnion.ts,0,0))
|
||||
>Message : Message, Symbol(Message,Decl(TypeGuardWithArrayUnion.ts,0,0))
|
||||
|
||||
if (message instanceof Array) {
|
||||
>message instanceof Array : boolean
|
||||
>message : Message | Message[]
|
||||
>Array : ArrayConstructor
|
||||
>message : Message | Message[], Symbol(message,Decl(TypeGuardWithArrayUnion.ts,4,17))
|
||||
>Array : ArrayConstructor, Symbol(Array,Decl(lib.d.ts,1000,23),Decl(lib.d.ts,1171,11))
|
||||
|
||||
return message.length; // Should have type Message[] here
|
||||
>message.length : number
|
||||
>message : Message[]
|
||||
>length : number
|
||||
>message.length : number, Symbol(Array.length,Decl(lib.d.ts,1007,20))
|
||||
>message : Message[], Symbol(message,Decl(TypeGuardWithArrayUnion.ts,4,17))
|
||||
>length : number, Symbol(Array.length,Decl(lib.d.ts,1007,20))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,100 +1,100 @@
|
||||
=== tests/cases/conformance/expressions/typeGuards/TypeGuardWithEnumUnion.ts ===
|
||||
enum Color { R, G, B }
|
||||
>Color : Color
|
||||
>R : Color
|
||||
>G : Color
|
||||
>B : Color
|
||||
>Color : Color, Symbol(Color,Decl(TypeGuardWithEnumUnion.ts,0,0))
|
||||
>R : Color, Symbol(Color.R,Decl(TypeGuardWithEnumUnion.ts,0,12))
|
||||
>G : Color, Symbol(Color.G,Decl(TypeGuardWithEnumUnion.ts,0,15))
|
||||
>B : Color, Symbol(Color.B,Decl(TypeGuardWithEnumUnion.ts,0,18))
|
||||
|
||||
function f1(x: Color | string) {
|
||||
>f1 : (x: string | Color) => void
|
||||
>x : string | Color
|
||||
>Color : Color
|
||||
>f1 : (x: string | Color) => void, Symbol(f1,Decl(TypeGuardWithEnumUnion.ts,0,22))
|
||||
>x : string | Color, Symbol(x,Decl(TypeGuardWithEnumUnion.ts,2,12))
|
||||
>Color : Color, Symbol(Color,Decl(TypeGuardWithEnumUnion.ts,0,0))
|
||||
|
||||
if (typeof x === "number") {
|
||||
>typeof x === "number" : boolean
|
||||
>typeof x : string
|
||||
>x : string | Color
|
||||
>x : string | Color, Symbol(x,Decl(TypeGuardWithEnumUnion.ts,2,12))
|
||||
>"number" : string
|
||||
|
||||
var y = x;
|
||||
>y : Color
|
||||
>x : Color
|
||||
>y : Color, Symbol(y,Decl(TypeGuardWithEnumUnion.ts,4,11),Decl(TypeGuardWithEnumUnion.ts,5,11))
|
||||
>x : Color, Symbol(x,Decl(TypeGuardWithEnumUnion.ts,2,12))
|
||||
|
||||
var y: Color;
|
||||
>y : Color
|
||||
>Color : Color
|
||||
>y : Color, Symbol(y,Decl(TypeGuardWithEnumUnion.ts,4,11),Decl(TypeGuardWithEnumUnion.ts,5,11))
|
||||
>Color : Color, Symbol(Color,Decl(TypeGuardWithEnumUnion.ts,0,0))
|
||||
}
|
||||
else {
|
||||
var z = x;
|
||||
>z : string
|
||||
>x : string
|
||||
>z : string, Symbol(z,Decl(TypeGuardWithEnumUnion.ts,8,11),Decl(TypeGuardWithEnumUnion.ts,9,11))
|
||||
>x : string, Symbol(x,Decl(TypeGuardWithEnumUnion.ts,2,12))
|
||||
|
||||
var z: string;
|
||||
>z : string
|
||||
>z : string, Symbol(z,Decl(TypeGuardWithEnumUnion.ts,8,11),Decl(TypeGuardWithEnumUnion.ts,9,11))
|
||||
}
|
||||
}
|
||||
|
||||
function f2(x: Color | string | string[]) {
|
||||
>f2 : (x: string | string[] | Color) => void
|
||||
>x : string | string[] | Color
|
||||
>Color : Color
|
||||
>f2 : (x: string | string[] | Color) => void, Symbol(f2,Decl(TypeGuardWithEnumUnion.ts,11,1))
|
||||
>x : string | string[] | Color, Symbol(x,Decl(TypeGuardWithEnumUnion.ts,13,12))
|
||||
>Color : Color, Symbol(Color,Decl(TypeGuardWithEnumUnion.ts,0,0))
|
||||
|
||||
if (typeof x === "object") {
|
||||
>typeof x === "object" : boolean
|
||||
>typeof x : string
|
||||
>x : string | string[] | Color
|
||||
>x : string | string[] | Color, Symbol(x,Decl(TypeGuardWithEnumUnion.ts,13,12))
|
||||
>"object" : string
|
||||
|
||||
var y = x;
|
||||
>y : string[]
|
||||
>x : string[]
|
||||
>y : string[], Symbol(y,Decl(TypeGuardWithEnumUnion.ts,15,11),Decl(TypeGuardWithEnumUnion.ts,16,11))
|
||||
>x : string[], Symbol(x,Decl(TypeGuardWithEnumUnion.ts,13,12))
|
||||
|
||||
var y: string[];
|
||||
>y : string[]
|
||||
>y : string[], Symbol(y,Decl(TypeGuardWithEnumUnion.ts,15,11),Decl(TypeGuardWithEnumUnion.ts,16,11))
|
||||
}
|
||||
if (typeof x === "number") {
|
||||
>typeof x === "number" : boolean
|
||||
>typeof x : string
|
||||
>x : string | string[] | Color
|
||||
>x : string | string[] | Color, Symbol(x,Decl(TypeGuardWithEnumUnion.ts,13,12))
|
||||
>"number" : string
|
||||
|
||||
var z = x;
|
||||
>z : Color
|
||||
>x : Color
|
||||
>z : Color, Symbol(z,Decl(TypeGuardWithEnumUnion.ts,19,11),Decl(TypeGuardWithEnumUnion.ts,20,11))
|
||||
>x : Color, Symbol(x,Decl(TypeGuardWithEnumUnion.ts,13,12))
|
||||
|
||||
var z: Color;
|
||||
>z : Color
|
||||
>Color : Color
|
||||
>z : Color, Symbol(z,Decl(TypeGuardWithEnumUnion.ts,19,11),Decl(TypeGuardWithEnumUnion.ts,20,11))
|
||||
>Color : Color, Symbol(Color,Decl(TypeGuardWithEnumUnion.ts,0,0))
|
||||
}
|
||||
else {
|
||||
var w = x;
|
||||
>w : string | string[]
|
||||
>x : string | string[]
|
||||
>w : string | string[], Symbol(w,Decl(TypeGuardWithEnumUnion.ts,23,11),Decl(TypeGuardWithEnumUnion.ts,24,11))
|
||||
>x : string | string[], Symbol(x,Decl(TypeGuardWithEnumUnion.ts,13,12))
|
||||
|
||||
var w: string | string[];
|
||||
>w : string | string[]
|
||||
>w : string | string[], Symbol(w,Decl(TypeGuardWithEnumUnion.ts,23,11),Decl(TypeGuardWithEnumUnion.ts,24,11))
|
||||
}
|
||||
if (typeof x === "string") {
|
||||
>typeof x === "string" : boolean
|
||||
>typeof x : string
|
||||
>x : string | string[] | Color
|
||||
>x : string | string[] | Color, Symbol(x,Decl(TypeGuardWithEnumUnion.ts,13,12))
|
||||
>"string" : string
|
||||
|
||||
var a = x;
|
||||
>a : string
|
||||
>x : string
|
||||
>a : string, Symbol(a,Decl(TypeGuardWithEnumUnion.ts,27,11),Decl(TypeGuardWithEnumUnion.ts,28,11))
|
||||
>x : string, Symbol(x,Decl(TypeGuardWithEnumUnion.ts,13,12))
|
||||
|
||||
var a: string;
|
||||
>a : string
|
||||
>a : string, Symbol(a,Decl(TypeGuardWithEnumUnion.ts,27,11),Decl(TypeGuardWithEnumUnion.ts,28,11))
|
||||
}
|
||||
else {
|
||||
var b = x;
|
||||
>b : string[] | Color
|
||||
>x : string[] | Color
|
||||
>b : string[] | Color, Symbol(b,Decl(TypeGuardWithEnumUnion.ts,31,11),Decl(TypeGuardWithEnumUnion.ts,32,11))
|
||||
>x : string[] | Color, Symbol(x,Decl(TypeGuardWithEnumUnion.ts,13,12))
|
||||
|
||||
var b: Color | string[];
|
||||
>b : string[] | Color
|
||||
>Color : Color
|
||||
>b : string[] | Color, Symbol(b,Decl(TypeGuardWithEnumUnion.ts,31,11),Decl(TypeGuardWithEnumUnion.ts,32,11))
|
||||
>Color : Color, Symbol(Color,Decl(TypeGuardWithEnumUnion.ts,0,0))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,100 +1,100 @@
|
||||
=== tests/cases/conformance/expressions/typeGuards/TypeGuardWithEnumUnion.ts ===
|
||||
enum Color { R, G, B }
|
||||
>Color : Color
|
||||
>R : Color
|
||||
>G : Color
|
||||
>B : Color
|
||||
>Color : Color, Symbol(Color,Decl(TypeGuardWithEnumUnion.ts,0,0))
|
||||
>R : Color, Symbol(Color.R,Decl(TypeGuardWithEnumUnion.ts,0,12))
|
||||
>G : Color, Symbol(Color.G,Decl(TypeGuardWithEnumUnion.ts,0,15))
|
||||
>B : Color, Symbol(Color.B,Decl(TypeGuardWithEnumUnion.ts,0,18))
|
||||
|
||||
function f1(x: Color | string) {
|
||||
>f1 : (x: string | Color) => void
|
||||
>x : string | Color
|
||||
>Color : Color
|
||||
>f1 : (x: string | Color) => void, Symbol(f1,Decl(TypeGuardWithEnumUnion.ts,0,22))
|
||||
>x : string | Color, Symbol(x,Decl(TypeGuardWithEnumUnion.ts,2,12))
|
||||
>Color : Color, Symbol(Color,Decl(TypeGuardWithEnumUnion.ts,0,0))
|
||||
|
||||
if (typeof x === "number") {
|
||||
>typeof x === "number" : boolean
|
||||
>typeof x : string
|
||||
>x : string | Color
|
||||
>x : string | Color, Symbol(x,Decl(TypeGuardWithEnumUnion.ts,2,12))
|
||||
>"number" : string
|
||||
|
||||
var y = x;
|
||||
>y : Color
|
||||
>x : Color
|
||||
>y : Color, Symbol(y,Decl(TypeGuardWithEnumUnion.ts,4,11),Decl(TypeGuardWithEnumUnion.ts,5,11))
|
||||
>x : Color, Symbol(x,Decl(TypeGuardWithEnumUnion.ts,2,12))
|
||||
|
||||
var y: Color;
|
||||
>y : Color
|
||||
>Color : Color
|
||||
>y : Color, Symbol(y,Decl(TypeGuardWithEnumUnion.ts,4,11),Decl(TypeGuardWithEnumUnion.ts,5,11))
|
||||
>Color : Color, Symbol(Color,Decl(TypeGuardWithEnumUnion.ts,0,0))
|
||||
}
|
||||
else {
|
||||
var z = x;
|
||||
>z : string
|
||||
>x : string
|
||||
>z : string, Symbol(z,Decl(TypeGuardWithEnumUnion.ts,8,11),Decl(TypeGuardWithEnumUnion.ts,9,11))
|
||||
>x : string, Symbol(x,Decl(TypeGuardWithEnumUnion.ts,2,12))
|
||||
|
||||
var z: string;
|
||||
>z : string
|
||||
>z : string, Symbol(z,Decl(TypeGuardWithEnumUnion.ts,8,11),Decl(TypeGuardWithEnumUnion.ts,9,11))
|
||||
}
|
||||
}
|
||||
|
||||
function f2(x: Color | string | string[]) {
|
||||
>f2 : (x: string | Color | string[]) => void
|
||||
>x : string | Color | string[]
|
||||
>Color : Color
|
||||
>f2 : (x: string | Color | string[]) => void, Symbol(f2,Decl(TypeGuardWithEnumUnion.ts,11,1))
|
||||
>x : string | Color | string[], Symbol(x,Decl(TypeGuardWithEnumUnion.ts,13,12))
|
||||
>Color : Color, Symbol(Color,Decl(TypeGuardWithEnumUnion.ts,0,0))
|
||||
|
||||
if (typeof x === "object") {
|
||||
>typeof x === "object" : boolean
|
||||
>typeof x : string
|
||||
>x : string | Color | string[]
|
||||
>x : string | Color | string[], Symbol(x,Decl(TypeGuardWithEnumUnion.ts,13,12))
|
||||
>"object" : string
|
||||
|
||||
var y = x;
|
||||
>y : string[]
|
||||
>x : string[]
|
||||
>y : string[], Symbol(y,Decl(TypeGuardWithEnumUnion.ts,15,11),Decl(TypeGuardWithEnumUnion.ts,16,11))
|
||||
>x : string[], Symbol(x,Decl(TypeGuardWithEnumUnion.ts,13,12))
|
||||
|
||||
var y: string[];
|
||||
>y : string[]
|
||||
>y : string[], Symbol(y,Decl(TypeGuardWithEnumUnion.ts,15,11),Decl(TypeGuardWithEnumUnion.ts,16,11))
|
||||
}
|
||||
if (typeof x === "number") {
|
||||
>typeof x === "number" : boolean
|
||||
>typeof x : string
|
||||
>x : string | Color | string[]
|
||||
>x : string | Color | string[], Symbol(x,Decl(TypeGuardWithEnumUnion.ts,13,12))
|
||||
>"number" : string
|
||||
|
||||
var z = x;
|
||||
>z : Color
|
||||
>x : Color
|
||||
>z : Color, Symbol(z,Decl(TypeGuardWithEnumUnion.ts,19,11),Decl(TypeGuardWithEnumUnion.ts,20,11))
|
||||
>x : Color, Symbol(x,Decl(TypeGuardWithEnumUnion.ts,13,12))
|
||||
|
||||
var z: Color;
|
||||
>z : Color
|
||||
>Color : Color
|
||||
>z : Color, Symbol(z,Decl(TypeGuardWithEnumUnion.ts,19,11),Decl(TypeGuardWithEnumUnion.ts,20,11))
|
||||
>Color : Color, Symbol(Color,Decl(TypeGuardWithEnumUnion.ts,0,0))
|
||||
}
|
||||
else {
|
||||
var w = x;
|
||||
>w : string | string[]
|
||||
>x : string | string[]
|
||||
>w : string | string[], Symbol(w,Decl(TypeGuardWithEnumUnion.ts,23,11),Decl(TypeGuardWithEnumUnion.ts,24,11))
|
||||
>x : string | string[], Symbol(x,Decl(TypeGuardWithEnumUnion.ts,13,12))
|
||||
|
||||
var w: string | string[];
|
||||
>w : string | string[]
|
||||
>w : string | string[], Symbol(w,Decl(TypeGuardWithEnumUnion.ts,23,11),Decl(TypeGuardWithEnumUnion.ts,24,11))
|
||||
}
|
||||
if (typeof x === "string") {
|
||||
>typeof x === "string" : boolean
|
||||
>typeof x : string
|
||||
>x : string | Color | string[]
|
||||
>x : string | Color | string[], Symbol(x,Decl(TypeGuardWithEnumUnion.ts,13,12))
|
||||
>"string" : string
|
||||
|
||||
var a = x;
|
||||
>a : string
|
||||
>x : string
|
||||
>a : string, Symbol(a,Decl(TypeGuardWithEnumUnion.ts,27,11),Decl(TypeGuardWithEnumUnion.ts,28,11))
|
||||
>x : string, Symbol(x,Decl(TypeGuardWithEnumUnion.ts,13,12))
|
||||
|
||||
var a: string;
|
||||
>a : string
|
||||
>a : string, Symbol(a,Decl(TypeGuardWithEnumUnion.ts,27,11),Decl(TypeGuardWithEnumUnion.ts,28,11))
|
||||
}
|
||||
else {
|
||||
var b = x;
|
||||
>b : Color | string[]
|
||||
>x : Color | string[]
|
||||
>b : Color | string[], Symbol(b,Decl(TypeGuardWithEnumUnion.ts,31,11),Decl(TypeGuardWithEnumUnion.ts,32,11))
|
||||
>x : Color | string[], Symbol(x,Decl(TypeGuardWithEnumUnion.ts,13,12))
|
||||
|
||||
var b: Color | string[];
|
||||
>b : Color | string[]
|
||||
>Color : Color
|
||||
>b : Color | string[], Symbol(b,Decl(TypeGuardWithEnumUnion.ts,31,11),Decl(TypeGuardWithEnumUnion.ts,32,11))
|
||||
>Color : Color, Symbol(Color,Decl(TypeGuardWithEnumUnion.ts,0,0))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
=== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration10_es6.ts ===
|
||||
let a: number = 1
|
||||
>a : number
|
||||
>a : number, Symbol(a,Decl(VariableDeclaration10_es6.ts,0,3))
|
||||
>1 : number
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
=== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration3_es6.ts ===
|
||||
const a = 1
|
||||
>a : number
|
||||
>a : number, Symbol(a,Decl(VariableDeclaration3_es6.ts,0,5))
|
||||
>1 : number
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
=== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration5_es6.ts ===
|
||||
const a: number = 1
|
||||
>a : number
|
||||
>a : number, Symbol(a,Decl(VariableDeclaration5_es6.ts,0,5))
|
||||
>1 : number
|
||||
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
=== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration7_es6.ts ===
|
||||
let a
|
||||
>a : any
|
||||
>a : any, Symbol(a,Decl(VariableDeclaration7_es6.ts,0,3))
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
=== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration8_es6.ts ===
|
||||
let a = 1
|
||||
>a : number
|
||||
>a : number, Symbol(a,Decl(VariableDeclaration8_es6.ts,0,3))
|
||||
>1 : number
|
||||
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
=== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration9_es6.ts ===
|
||||
let a: number
|
||||
>a : number
|
||||
>a : number, Symbol(a,Decl(VariableDeclaration9_es6.ts,0,3))
|
||||
|
||||
|
||||
@@ -1,17 +1,17 @@
|
||||
=== tests/cases/compiler/acceptableAlias1.ts ===
|
||||
module M {
|
||||
>M : typeof M
|
||||
>M : typeof M, Symbol(M,Decl(acceptableAlias1.ts,0,0))
|
||||
|
||||
export module N {
|
||||
>N : unknown
|
||||
>N : any, Symbol(N,Decl(acceptableAlias1.ts,0,10))
|
||||
}
|
||||
export import X = N;
|
||||
>X : unknown
|
||||
>N : unknown
|
||||
>X : any, Symbol(X,Decl(acceptableAlias1.ts,2,5))
|
||||
>N : any, Symbol(N,Decl(acceptableAlias1.ts,0,10))
|
||||
}
|
||||
|
||||
import r = M.X;
|
||||
>r : unknown
|
||||
>M : typeof M
|
||||
>X : unknown
|
||||
>r : any, Symbol(r,Decl(acceptableAlias1.ts,4,1))
|
||||
>M : typeof M, Symbol(M,Decl(acceptableAlias1.ts,0,0))
|
||||
>X : any, Symbol(r,Decl(acceptableAlias1.ts,0,10))
|
||||
|
||||
|
||||
@@ -1,57 +1,57 @@
|
||||
=== tests/cases/compiler/accessOverriddenBaseClassMember1.ts ===
|
||||
class Point {
|
||||
>Point : Point
|
||||
>Point : Point, Symbol(Point,Decl(accessOverriddenBaseClassMember1.ts,0,0))
|
||||
|
||||
constructor(public x: number, public y: number) { }
|
||||
>x : number
|
||||
>y : number
|
||||
>x : number, Symbol(x,Decl(accessOverriddenBaseClassMember1.ts,1,16))
|
||||
>y : number, Symbol(y,Decl(accessOverriddenBaseClassMember1.ts,1,33))
|
||||
|
||||
public toString() {
|
||||
>toString : () => string
|
||||
>toString : () => string, Symbol(toString,Decl(accessOverriddenBaseClassMember1.ts,1,55))
|
||||
|
||||
return "x=" + this.x + " y=" + this.y;
|
||||
>"x=" + this.x + " y=" + this.y : string
|
||||
>"x=" + this.x + " y=" : string
|
||||
>"x=" + this.x : string
|
||||
>"x=" : string
|
||||
>this.x : number
|
||||
>this : Point
|
||||
>x : number
|
||||
>this.x : number, Symbol(x,Decl(accessOverriddenBaseClassMember1.ts,1,16))
|
||||
>this : Point, Symbol(Point,Decl(accessOverriddenBaseClassMember1.ts,0,0))
|
||||
>x : number, Symbol(x,Decl(accessOverriddenBaseClassMember1.ts,1,16))
|
||||
>" y=" : string
|
||||
>this.y : number
|
||||
>this : Point
|
||||
>y : number
|
||||
>this.y : number, Symbol(y,Decl(accessOverriddenBaseClassMember1.ts,1,33))
|
||||
>this : Point, Symbol(Point,Decl(accessOverriddenBaseClassMember1.ts,0,0))
|
||||
>y : number, Symbol(y,Decl(accessOverriddenBaseClassMember1.ts,1,33))
|
||||
}
|
||||
}
|
||||
class ColoredPoint extends Point {
|
||||
>ColoredPoint : ColoredPoint
|
||||
>Point : Point
|
||||
>ColoredPoint : ColoredPoint, Symbol(ColoredPoint,Decl(accessOverriddenBaseClassMember1.ts,5,1))
|
||||
>Point : Point, Symbol(Point,Decl(accessOverriddenBaseClassMember1.ts,0,0))
|
||||
|
||||
constructor(x: number, y: number, public color: string) {
|
||||
>x : number
|
||||
>y : number
|
||||
>color : string
|
||||
>x : number, Symbol(x,Decl(accessOverriddenBaseClassMember1.ts,7,16))
|
||||
>y : number, Symbol(y,Decl(accessOverriddenBaseClassMember1.ts,7,26))
|
||||
>color : string, Symbol(color,Decl(accessOverriddenBaseClassMember1.ts,7,37))
|
||||
|
||||
super(x, y);
|
||||
>super(x, y) : void
|
||||
>super : typeof Point
|
||||
>x : number
|
||||
>y : number
|
||||
>super : typeof Point, Symbol(Point,Decl(accessOverriddenBaseClassMember1.ts,0,0))
|
||||
>x : number, Symbol(x,Decl(accessOverriddenBaseClassMember1.ts,7,16))
|
||||
>y : number, Symbol(y,Decl(accessOverriddenBaseClassMember1.ts,7,26))
|
||||
}
|
||||
public toString() {
|
||||
>toString : () => string
|
||||
>toString : () => string, Symbol(toString,Decl(accessOverriddenBaseClassMember1.ts,9,5))
|
||||
|
||||
return super.toString() + " color=" + this.color;
|
||||
>super.toString() + " color=" + this.color : string
|
||||
>super.toString() + " color=" : string
|
||||
>super.toString() : string
|
||||
>super.toString : () => string
|
||||
>super : Point
|
||||
>toString : () => string
|
||||
>super.toString : () => string, Symbol(Point.toString,Decl(accessOverriddenBaseClassMember1.ts,1,55))
|
||||
>super : Point, Symbol(Point,Decl(accessOverriddenBaseClassMember1.ts,0,0))
|
||||
>toString : () => string, Symbol(Point.toString,Decl(accessOverriddenBaseClassMember1.ts,1,55))
|
||||
>" color=" : string
|
||||
>this.color : string
|
||||
>this : ColoredPoint
|
||||
>color : string
|
||||
>this.color : string, Symbol(color,Decl(accessOverriddenBaseClassMember1.ts,7,37))
|
||||
>this : ColoredPoint, Symbol(ColoredPoint,Decl(accessOverriddenBaseClassMember1.ts,5,1))
|
||||
>color : string, Symbol(color,Decl(accessOverriddenBaseClassMember1.ts,7,37))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,10 +1,10 @@
|
||||
=== tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES5.ts ===
|
||||
|
||||
class C {
|
||||
>C : C
|
||||
>C : C, Symbol(C,Decl(accessorWithES5.ts,0,0))
|
||||
|
||||
get x() {
|
||||
>x : number
|
||||
>x : number, Symbol(x,Decl(accessorWithES5.ts,1,9))
|
||||
|
||||
return 1;
|
||||
>1 : number
|
||||
@@ -12,28 +12,28 @@ class C {
|
||||
}
|
||||
|
||||
class D {
|
||||
>D : D
|
||||
>D : D, Symbol(D,Decl(accessorWithES5.ts,5,1))
|
||||
|
||||
set x(v) {
|
||||
>x : any
|
||||
>v : any
|
||||
>x : any, Symbol(x,Decl(accessorWithES5.ts,7,9))
|
||||
>v : any, Symbol(v,Decl(accessorWithES5.ts,8,10))
|
||||
}
|
||||
}
|
||||
|
||||
var x = {
|
||||
>x : { a: number; }
|
||||
>x : { a: number; }, Symbol(x,Decl(accessorWithES5.ts,12,3))
|
||||
>{ get a() { return 1 }} : { a: number; }
|
||||
|
||||
get a() { return 1 }
|
||||
>a : number
|
||||
>a : number, Symbol(a,Decl(accessorWithES5.ts,12,9))
|
||||
>1 : number
|
||||
}
|
||||
|
||||
var y = {
|
||||
>y : { b: any; }
|
||||
>y : { b: any; }, Symbol(y,Decl(accessorWithES5.ts,16,3))
|
||||
>{ set b(v) { }} : { b: any; }
|
||||
|
||||
set b(v) { }
|
||||
>b : any
|
||||
>v : any
|
||||
>b : any, Symbol(b,Decl(accessorWithES5.ts,16,9))
|
||||
>v : any, Symbol(v,Decl(accessorWithES5.ts,17,10))
|
||||
}
|
||||
|
||||
@@ -1,24 +1,24 @@
|
||||
=== tests/cases/compiler/addMoreCallSignaturesToBaseSignature.ts ===
|
||||
interface Foo {
|
||||
>Foo : Foo
|
||||
>Foo : Foo, Symbol(Foo,Decl(addMoreCallSignaturesToBaseSignature.ts,0,0))
|
||||
|
||||
(): string;
|
||||
}
|
||||
|
||||
interface Bar extends Foo {
|
||||
>Bar : Bar
|
||||
>Foo : Foo
|
||||
>Bar : Bar, Symbol(Bar,Decl(addMoreCallSignaturesToBaseSignature.ts,2,1))
|
||||
>Foo : Foo, Symbol(Foo,Decl(addMoreCallSignaturesToBaseSignature.ts,0,0))
|
||||
|
||||
(key: string): string;
|
||||
>key : string
|
||||
>key : string, Symbol(key,Decl(addMoreCallSignaturesToBaseSignature.ts,5,5))
|
||||
}
|
||||
|
||||
var a: Bar;
|
||||
>a : Bar
|
||||
>Bar : Bar
|
||||
>a : Bar, Symbol(a,Decl(addMoreCallSignaturesToBaseSignature.ts,8,3))
|
||||
>Bar : Bar, Symbol(Bar,Decl(addMoreCallSignaturesToBaseSignature.ts,2,1))
|
||||
|
||||
var kitty = a();
|
||||
>kitty : string
|
||||
>kitty : string, Symbol(kitty,Decl(addMoreCallSignaturesToBaseSignature.ts,9,3))
|
||||
>a() : string
|
||||
>a : Bar
|
||||
>a : Bar, Symbol(a,Decl(addMoreCallSignaturesToBaseSignature.ts,8,3))
|
||||
|
||||
|
||||
@@ -1,26 +1,26 @@
|
||||
=== tests/cases/compiler/addMoreCallSignaturesToBaseSignature2.ts ===
|
||||
interface Foo {
|
||||
>Foo : Foo
|
||||
>Foo : Foo, Symbol(Foo,Decl(addMoreCallSignaturesToBaseSignature2.ts,0,0))
|
||||
|
||||
(bar:number): string;
|
||||
>bar : number
|
||||
>bar : number, Symbol(bar,Decl(addMoreCallSignaturesToBaseSignature2.ts,1,5))
|
||||
}
|
||||
|
||||
interface Bar extends Foo {
|
||||
>Bar : Bar
|
||||
>Foo : Foo
|
||||
>Bar : Bar, Symbol(Bar,Decl(addMoreCallSignaturesToBaseSignature2.ts,2,1))
|
||||
>Foo : Foo, Symbol(Foo,Decl(addMoreCallSignaturesToBaseSignature2.ts,0,0))
|
||||
|
||||
(key: string): string;
|
||||
>key : string
|
||||
>key : string, Symbol(key,Decl(addMoreCallSignaturesToBaseSignature2.ts,5,5))
|
||||
}
|
||||
|
||||
var a: Bar;
|
||||
>a : Bar
|
||||
>Bar : Bar
|
||||
>a : Bar, Symbol(a,Decl(addMoreCallSignaturesToBaseSignature2.ts,8,3))
|
||||
>Bar : Bar, Symbol(Bar,Decl(addMoreCallSignaturesToBaseSignature2.ts,2,1))
|
||||
|
||||
var kitty = a(1);
|
||||
>kitty : string
|
||||
>kitty : string, Symbol(kitty,Decl(addMoreCallSignaturesToBaseSignature2.ts,9,3))
|
||||
>a(1) : string
|
||||
>a : Bar
|
||||
>a : Bar, Symbol(a,Decl(addMoreCallSignaturesToBaseSignature2.ts,8,3))
|
||||
>1 : number
|
||||
|
||||
|
||||
@@ -1,171 +1,171 @@
|
||||
=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithAnyAndEveryType.ts ===
|
||||
function foo() { }
|
||||
>foo : () => void
|
||||
>foo : () => void, Symbol(foo,Decl(additionOperatorWithAnyAndEveryType.ts,0,0))
|
||||
|
||||
class C {
|
||||
>C : C
|
||||
>C : C, Symbol(C,Decl(additionOperatorWithAnyAndEveryType.ts,0,18))
|
||||
|
||||
public a: string;
|
||||
>a : string
|
||||
>a : string, Symbol(a,Decl(additionOperatorWithAnyAndEveryType.ts,1,9))
|
||||
|
||||
static foo() { }
|
||||
>foo : () => void
|
||||
>foo : () => void, Symbol(C.foo,Decl(additionOperatorWithAnyAndEveryType.ts,2,21))
|
||||
}
|
||||
enum E { a, b, c }
|
||||
>E : E
|
||||
>a : E
|
||||
>b : E
|
||||
>c : E
|
||||
>E : E, Symbol(E,Decl(additionOperatorWithAnyAndEveryType.ts,4,1))
|
||||
>a : E, Symbol(E.a,Decl(additionOperatorWithAnyAndEveryType.ts,5,8))
|
||||
>b : E, Symbol(E.b,Decl(additionOperatorWithAnyAndEveryType.ts,5,11))
|
||||
>c : E, Symbol(E.c,Decl(additionOperatorWithAnyAndEveryType.ts,5,14))
|
||||
|
||||
module M { export var a }
|
||||
>M : typeof M
|
||||
>a : any
|
||||
>M : typeof M, Symbol(M,Decl(additionOperatorWithAnyAndEveryType.ts,5,18))
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithAnyAndEveryType.ts,6,21))
|
||||
|
||||
var a: any;
|
||||
>a : any
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithAnyAndEveryType.ts,8,3))
|
||||
|
||||
var b: boolean;
|
||||
>b : boolean
|
||||
>b : boolean, Symbol(b,Decl(additionOperatorWithAnyAndEveryType.ts,9,3))
|
||||
|
||||
var c: number;
|
||||
>c : number
|
||||
>c : number, Symbol(c,Decl(additionOperatorWithAnyAndEveryType.ts,10,3))
|
||||
|
||||
var d: string;
|
||||
>d : string
|
||||
>d : string, Symbol(d,Decl(additionOperatorWithAnyAndEveryType.ts,11,3))
|
||||
|
||||
var e: Object;
|
||||
>e : Object
|
||||
>Object : Object
|
||||
>e : Object, Symbol(e,Decl(additionOperatorWithAnyAndEveryType.ts,12,3))
|
||||
>Object : Object, Symbol(Object,Decl(lib.d.ts,92,1),Decl(lib.d.ts,223,11))
|
||||
|
||||
// any as left operand, result is type Any except plusing string
|
||||
var r1 = a + a;
|
||||
>r1 : any
|
||||
>r1 : any, Symbol(r1,Decl(additionOperatorWithAnyAndEveryType.ts,15,3))
|
||||
>a + a : any
|
||||
>a : any
|
||||
>a : any
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithAnyAndEveryType.ts,8,3))
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithAnyAndEveryType.ts,8,3))
|
||||
|
||||
var r2 = a + b;
|
||||
>r2 : any
|
||||
>r2 : any, Symbol(r2,Decl(additionOperatorWithAnyAndEveryType.ts,16,3))
|
||||
>a + b : any
|
||||
>a : any
|
||||
>b : boolean
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithAnyAndEveryType.ts,8,3))
|
||||
>b : boolean, Symbol(b,Decl(additionOperatorWithAnyAndEveryType.ts,9,3))
|
||||
|
||||
var r3 = a + c;
|
||||
>r3 : any
|
||||
>r3 : any, Symbol(r3,Decl(additionOperatorWithAnyAndEveryType.ts,17,3))
|
||||
>a + c : any
|
||||
>a : any
|
||||
>c : number
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithAnyAndEveryType.ts,8,3))
|
||||
>c : number, Symbol(c,Decl(additionOperatorWithAnyAndEveryType.ts,10,3))
|
||||
|
||||
var r4 = a + d;
|
||||
>r4 : string
|
||||
>r4 : string, Symbol(r4,Decl(additionOperatorWithAnyAndEveryType.ts,18,3))
|
||||
>a + d : string
|
||||
>a : any
|
||||
>d : string
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithAnyAndEveryType.ts,8,3))
|
||||
>d : string, Symbol(d,Decl(additionOperatorWithAnyAndEveryType.ts,11,3))
|
||||
|
||||
var r5 = a + e;
|
||||
>r5 : any
|
||||
>r5 : any, Symbol(r5,Decl(additionOperatorWithAnyAndEveryType.ts,19,3))
|
||||
>a + e : any
|
||||
>a : any
|
||||
>e : Object
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithAnyAndEveryType.ts,8,3))
|
||||
>e : Object, Symbol(e,Decl(additionOperatorWithAnyAndEveryType.ts,12,3))
|
||||
|
||||
// any as right operand, result is type Any except plusing string
|
||||
var r6 = b + a;
|
||||
>r6 : any
|
||||
>r6 : any, Symbol(r6,Decl(additionOperatorWithAnyAndEveryType.ts,22,3))
|
||||
>b + a : any
|
||||
>b : boolean
|
||||
>a : any
|
||||
>b : boolean, Symbol(b,Decl(additionOperatorWithAnyAndEveryType.ts,9,3))
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithAnyAndEveryType.ts,8,3))
|
||||
|
||||
var r7 = c + a;
|
||||
>r7 : any
|
||||
>r7 : any, Symbol(r7,Decl(additionOperatorWithAnyAndEveryType.ts,23,3))
|
||||
>c + a : any
|
||||
>c : number
|
||||
>a : any
|
||||
>c : number, Symbol(c,Decl(additionOperatorWithAnyAndEveryType.ts,10,3))
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithAnyAndEveryType.ts,8,3))
|
||||
|
||||
var r8 = d + a;
|
||||
>r8 : string
|
||||
>r8 : string, Symbol(r8,Decl(additionOperatorWithAnyAndEveryType.ts,24,3))
|
||||
>d + a : string
|
||||
>d : string
|
||||
>a : any
|
||||
>d : string, Symbol(d,Decl(additionOperatorWithAnyAndEveryType.ts,11,3))
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithAnyAndEveryType.ts,8,3))
|
||||
|
||||
var r9 = e + a;
|
||||
>r9 : any
|
||||
>r9 : any, Symbol(r9,Decl(additionOperatorWithAnyAndEveryType.ts,25,3))
|
||||
>e + a : any
|
||||
>e : Object
|
||||
>a : any
|
||||
>e : Object, Symbol(e,Decl(additionOperatorWithAnyAndEveryType.ts,12,3))
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithAnyAndEveryType.ts,8,3))
|
||||
|
||||
// other cases
|
||||
var r10 = a + foo;
|
||||
>r10 : any
|
||||
>r10 : any, Symbol(r10,Decl(additionOperatorWithAnyAndEveryType.ts,28,3))
|
||||
>a + foo : any
|
||||
>a : any
|
||||
>foo : () => void
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithAnyAndEveryType.ts,8,3))
|
||||
>foo : () => void, Symbol(foo,Decl(additionOperatorWithAnyAndEveryType.ts,0,0))
|
||||
|
||||
var r11 = a + foo();
|
||||
>r11 : any
|
||||
>r11 : any, Symbol(r11,Decl(additionOperatorWithAnyAndEveryType.ts,29,3))
|
||||
>a + foo() : any
|
||||
>a : any
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithAnyAndEveryType.ts,8,3))
|
||||
>foo() : void
|
||||
>foo : () => void
|
||||
>foo : () => void, Symbol(foo,Decl(additionOperatorWithAnyAndEveryType.ts,0,0))
|
||||
|
||||
var r12 = a + C;
|
||||
>r12 : any
|
||||
>r12 : any, Symbol(r12,Decl(additionOperatorWithAnyAndEveryType.ts,30,3))
|
||||
>a + C : any
|
||||
>a : any
|
||||
>C : typeof C
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithAnyAndEveryType.ts,8,3))
|
||||
>C : typeof C, Symbol(C,Decl(additionOperatorWithAnyAndEveryType.ts,0,18))
|
||||
|
||||
var r13 = a + new C();
|
||||
>r13 : any
|
||||
>r13 : any, Symbol(r13,Decl(additionOperatorWithAnyAndEveryType.ts,31,3))
|
||||
>a + new C() : any
|
||||
>a : any
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithAnyAndEveryType.ts,8,3))
|
||||
>new C() : C
|
||||
>C : typeof C
|
||||
>C : typeof C, Symbol(C,Decl(additionOperatorWithAnyAndEveryType.ts,0,18))
|
||||
|
||||
var r14 = a + E;
|
||||
>r14 : any
|
||||
>r14 : any, Symbol(r14,Decl(additionOperatorWithAnyAndEveryType.ts,32,3))
|
||||
>a + E : any
|
||||
>a : any
|
||||
>E : typeof E
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithAnyAndEveryType.ts,8,3))
|
||||
>E : typeof E, Symbol(E,Decl(additionOperatorWithAnyAndEveryType.ts,4,1))
|
||||
|
||||
var r15 = a + E.a;
|
||||
>r15 : any
|
||||
>r15 : any, Symbol(r15,Decl(additionOperatorWithAnyAndEveryType.ts,33,3))
|
||||
>a + E.a : any
|
||||
>a : any
|
||||
>E.a : E
|
||||
>E : typeof E
|
||||
>a : E
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithAnyAndEveryType.ts,8,3))
|
||||
>E.a : E, Symbol(E.a,Decl(additionOperatorWithAnyAndEveryType.ts,5,8))
|
||||
>E : typeof E, Symbol(E,Decl(additionOperatorWithAnyAndEveryType.ts,4,1))
|
||||
>a : E, Symbol(E.a,Decl(additionOperatorWithAnyAndEveryType.ts,5,8))
|
||||
|
||||
var r16 = a + M;
|
||||
>r16 : any
|
||||
>r16 : any, Symbol(r16,Decl(additionOperatorWithAnyAndEveryType.ts,34,3))
|
||||
>a + M : any
|
||||
>a : any
|
||||
>M : typeof M
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithAnyAndEveryType.ts,8,3))
|
||||
>M : typeof M, Symbol(M,Decl(additionOperatorWithAnyAndEveryType.ts,5,18))
|
||||
|
||||
var r17 = a + '';
|
||||
>r17 : string
|
||||
>r17 : string, Symbol(r17,Decl(additionOperatorWithAnyAndEveryType.ts,35,3))
|
||||
>a + '' : string
|
||||
>a : any
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithAnyAndEveryType.ts,8,3))
|
||||
>'' : string
|
||||
|
||||
var r18 = a + 123;
|
||||
>r18 : any
|
||||
>r18 : any, Symbol(r18,Decl(additionOperatorWithAnyAndEveryType.ts,36,3))
|
||||
>a + 123 : any
|
||||
>a : any
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithAnyAndEveryType.ts,8,3))
|
||||
>123 : number
|
||||
|
||||
var r19 = a + { a: '' };
|
||||
>r19 : any
|
||||
>r19 : any, Symbol(r19,Decl(additionOperatorWithAnyAndEveryType.ts,37,3))
|
||||
>a + { a: '' } : any
|
||||
>a : any
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithAnyAndEveryType.ts,8,3))
|
||||
>{ a: '' } : { a: string; }
|
||||
>a : string
|
||||
>a : string, Symbol(a,Decl(additionOperatorWithAnyAndEveryType.ts,37,15))
|
||||
>'' : string
|
||||
|
||||
var r20 = a + ((a: string) => { return a });
|
||||
>r20 : any
|
||||
>r20 : any, Symbol(r20,Decl(additionOperatorWithAnyAndEveryType.ts,38,3))
|
||||
>a + ((a: string) => { return a }) : any
|
||||
>a : any
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithAnyAndEveryType.ts,8,3))
|
||||
>((a: string) => { return a }) : (a: string) => string
|
||||
>(a: string) => { return a } : (a: string) => string
|
||||
>a : string
|
||||
>a : string
|
||||
>a : string, Symbol(a,Decl(additionOperatorWithAnyAndEveryType.ts,38,16))
|
||||
>a : string, Symbol(a,Decl(additionOperatorWithAnyAndEveryType.ts,38,16))
|
||||
|
||||
|
||||
@@ -2,127 +2,127 @@
|
||||
// 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
|
||||
>E : E, Symbol(E,Decl(additionOperatorWithNullValueAndValidOperator.ts,0,0))
|
||||
>a : E, Symbol(E.a,Decl(additionOperatorWithNullValueAndValidOperator.ts,2,8))
|
||||
>b : E, Symbol(E.b,Decl(additionOperatorWithNullValueAndValidOperator.ts,2,11))
|
||||
>c : E, Symbol(E.c,Decl(additionOperatorWithNullValueAndValidOperator.ts,2,14))
|
||||
|
||||
var a: any;
|
||||
>a : any
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithNullValueAndValidOperator.ts,4,3))
|
||||
|
||||
var b: number;
|
||||
>b : number
|
||||
>b : number, Symbol(b,Decl(additionOperatorWithNullValueAndValidOperator.ts,5,3))
|
||||
|
||||
var c: E;
|
||||
>c : E
|
||||
>E : E
|
||||
>c : E, Symbol(c,Decl(additionOperatorWithNullValueAndValidOperator.ts,6,3))
|
||||
>E : E, Symbol(E,Decl(additionOperatorWithNullValueAndValidOperator.ts,0,0))
|
||||
|
||||
var d: string;
|
||||
>d : string
|
||||
>d : string, Symbol(d,Decl(additionOperatorWithNullValueAndValidOperator.ts,7,3))
|
||||
|
||||
// null + any
|
||||
var r1: any = null + a;
|
||||
>r1 : any
|
||||
>r1 : any, Symbol(r1,Decl(additionOperatorWithNullValueAndValidOperator.ts,10,3))
|
||||
>null + a : any
|
||||
>null : null
|
||||
>a : any
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithNullValueAndValidOperator.ts,4,3))
|
||||
|
||||
var r2: any = a + null;
|
||||
>r2 : any
|
||||
>r2 : any, Symbol(r2,Decl(additionOperatorWithNullValueAndValidOperator.ts,11,3))
|
||||
>a + null : any
|
||||
>a : any
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithNullValueAndValidOperator.ts,4,3))
|
||||
>null : null
|
||||
|
||||
// null + number/enum
|
||||
var r3 = null + b;
|
||||
>r3 : number
|
||||
>r3 : number, Symbol(r3,Decl(additionOperatorWithNullValueAndValidOperator.ts,14,3))
|
||||
>null + b : number
|
||||
>null : null
|
||||
>b : number
|
||||
>b : number, Symbol(b,Decl(additionOperatorWithNullValueAndValidOperator.ts,5,3))
|
||||
|
||||
var r4 = null + 1;
|
||||
>r4 : number
|
||||
>r4 : number, Symbol(r4,Decl(additionOperatorWithNullValueAndValidOperator.ts,15,3))
|
||||
>null + 1 : number
|
||||
>null : null
|
||||
>1 : number
|
||||
|
||||
var r5 = null + c;
|
||||
>r5 : number
|
||||
>r5 : number, Symbol(r5,Decl(additionOperatorWithNullValueAndValidOperator.ts,16,3))
|
||||
>null + c : number
|
||||
>null : null
|
||||
>c : E
|
||||
>c : E, Symbol(c,Decl(additionOperatorWithNullValueAndValidOperator.ts,6,3))
|
||||
|
||||
var r6 = null + E.a;
|
||||
>r6 : number
|
||||
>r6 : number, Symbol(r6,Decl(additionOperatorWithNullValueAndValidOperator.ts,17,3))
|
||||
>null + E.a : number
|
||||
>null : null
|
||||
>E.a : E
|
||||
>E : typeof E
|
||||
>a : E
|
||||
>E.a : E, Symbol(E.a,Decl(additionOperatorWithNullValueAndValidOperator.ts,2,8))
|
||||
>E : typeof E, Symbol(E,Decl(additionOperatorWithNullValueAndValidOperator.ts,0,0))
|
||||
>a : E, Symbol(E.a,Decl(additionOperatorWithNullValueAndValidOperator.ts,2,8))
|
||||
|
||||
var r7 = null + E['a'];
|
||||
>r7 : number
|
||||
>r7 : number, Symbol(r7,Decl(additionOperatorWithNullValueAndValidOperator.ts,18,3))
|
||||
>null + E['a'] : number
|
||||
>null : null
|
||||
>E['a'] : E
|
||||
>E : typeof E
|
||||
>'a' : string
|
||||
>E : typeof E, Symbol(E,Decl(additionOperatorWithNullValueAndValidOperator.ts,0,0))
|
||||
>'a' : string, Symbol(E.a,Decl(additionOperatorWithNullValueAndValidOperator.ts,2,8))
|
||||
|
||||
var r8 = b + null;
|
||||
>r8 : number
|
||||
>r8 : number, Symbol(r8,Decl(additionOperatorWithNullValueAndValidOperator.ts,19,3))
|
||||
>b + null : number
|
||||
>b : number
|
||||
>b : number, Symbol(b,Decl(additionOperatorWithNullValueAndValidOperator.ts,5,3))
|
||||
>null : null
|
||||
|
||||
var r9 = 1 + null;
|
||||
>r9 : number
|
||||
>r9 : number, Symbol(r9,Decl(additionOperatorWithNullValueAndValidOperator.ts,20,3))
|
||||
>1 + null : number
|
||||
>1 : number
|
||||
>null : null
|
||||
|
||||
var r10 = c + null
|
||||
>r10 : number
|
||||
>r10 : number, Symbol(r10,Decl(additionOperatorWithNullValueAndValidOperator.ts,21,3))
|
||||
>c + null : number
|
||||
>c : E
|
||||
>c : E, Symbol(c,Decl(additionOperatorWithNullValueAndValidOperator.ts,6,3))
|
||||
>null : null
|
||||
|
||||
var r11 = E.a + null;
|
||||
>r11 : number
|
||||
>r11 : number, Symbol(r11,Decl(additionOperatorWithNullValueAndValidOperator.ts,22,3))
|
||||
>E.a + null : number
|
||||
>E.a : E
|
||||
>E : typeof E
|
||||
>a : E
|
||||
>E.a : E, Symbol(E.a,Decl(additionOperatorWithNullValueAndValidOperator.ts,2,8))
|
||||
>E : typeof E, Symbol(E,Decl(additionOperatorWithNullValueAndValidOperator.ts,0,0))
|
||||
>a : E, Symbol(E.a,Decl(additionOperatorWithNullValueAndValidOperator.ts,2,8))
|
||||
>null : null
|
||||
|
||||
var r12 = E['a'] + null;
|
||||
>r12 : number
|
||||
>r12 : number, Symbol(r12,Decl(additionOperatorWithNullValueAndValidOperator.ts,23,3))
|
||||
>E['a'] + null : number
|
||||
>E['a'] : E
|
||||
>E : typeof E
|
||||
>'a' : string
|
||||
>E : typeof E, Symbol(E,Decl(additionOperatorWithNullValueAndValidOperator.ts,0,0))
|
||||
>'a' : string, Symbol(E.a,Decl(additionOperatorWithNullValueAndValidOperator.ts,2,8))
|
||||
>null : null
|
||||
|
||||
// null + string
|
||||
var r13 = null + d;
|
||||
>r13 : string
|
||||
>r13 : string, Symbol(r13,Decl(additionOperatorWithNullValueAndValidOperator.ts,26,3))
|
||||
>null + d : string
|
||||
>null : null
|
||||
>d : string
|
||||
>d : string, Symbol(d,Decl(additionOperatorWithNullValueAndValidOperator.ts,7,3))
|
||||
|
||||
var r14 = null + '';
|
||||
>r14 : string
|
||||
>r14 : string, Symbol(r14,Decl(additionOperatorWithNullValueAndValidOperator.ts,27,3))
|
||||
>null + '' : string
|
||||
>null : null
|
||||
>'' : string
|
||||
|
||||
var r15 = d + null;
|
||||
>r15 : string
|
||||
>r15 : string, Symbol(r15,Decl(additionOperatorWithNullValueAndValidOperator.ts,28,3))
|
||||
>d + null : string
|
||||
>d : string
|
||||
>d : string, Symbol(d,Decl(additionOperatorWithNullValueAndValidOperator.ts,7,3))
|
||||
>null : null
|
||||
|
||||
var r16 = '' + null;
|
||||
>r16 : string
|
||||
>r16 : string, Symbol(r16,Decl(additionOperatorWithNullValueAndValidOperator.ts,29,3))
|
||||
>'' + null : string
|
||||
>'' : string
|
||||
>null : null
|
||||
|
||||
@@ -1,121 +1,121 @@
|
||||
=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNumberAndEnum.ts ===
|
||||
enum E { a, b }
|
||||
>E : E
|
||||
>a : E
|
||||
>b : E
|
||||
>E : E, Symbol(E,Decl(additionOperatorWithNumberAndEnum.ts,0,0))
|
||||
>a : E, Symbol(E.a,Decl(additionOperatorWithNumberAndEnum.ts,0,8))
|
||||
>b : E, Symbol(E.b,Decl(additionOperatorWithNumberAndEnum.ts,0,11))
|
||||
|
||||
enum F { c, d }
|
||||
>F : F
|
||||
>c : F
|
||||
>d : F
|
||||
>F : F, Symbol(F,Decl(additionOperatorWithNumberAndEnum.ts,0,15))
|
||||
>c : F, Symbol(F.c,Decl(additionOperatorWithNumberAndEnum.ts,1,8))
|
||||
>d : F, Symbol(F.d,Decl(additionOperatorWithNumberAndEnum.ts,1,11))
|
||||
|
||||
var a: number;
|
||||
>a : number
|
||||
>a : number, Symbol(a,Decl(additionOperatorWithNumberAndEnum.ts,3,3))
|
||||
|
||||
var b: E;
|
||||
>b : E
|
||||
>E : E
|
||||
>b : E, Symbol(b,Decl(additionOperatorWithNumberAndEnum.ts,4,3))
|
||||
>E : E, Symbol(E,Decl(additionOperatorWithNumberAndEnum.ts,0,0))
|
||||
|
||||
var c: E | F;
|
||||
>c : E | F
|
||||
>E : E
|
||||
>F : F
|
||||
>c : E | F, Symbol(c,Decl(additionOperatorWithNumberAndEnum.ts,5,3))
|
||||
>E : E, Symbol(E,Decl(additionOperatorWithNumberAndEnum.ts,0,0))
|
||||
>F : F, Symbol(F,Decl(additionOperatorWithNumberAndEnum.ts,0,15))
|
||||
|
||||
var r1 = a + a;
|
||||
>r1 : number
|
||||
>r1 : number, Symbol(r1,Decl(additionOperatorWithNumberAndEnum.ts,7,3))
|
||||
>a + a : number
|
||||
>a : number
|
||||
>a : number
|
||||
>a : number, Symbol(a,Decl(additionOperatorWithNumberAndEnum.ts,3,3))
|
||||
>a : number, Symbol(a,Decl(additionOperatorWithNumberAndEnum.ts,3,3))
|
||||
|
||||
var r2 = a + b;
|
||||
>r2 : number
|
||||
>r2 : number, Symbol(r2,Decl(additionOperatorWithNumberAndEnum.ts,8,3))
|
||||
>a + b : number
|
||||
>a : number
|
||||
>b : E
|
||||
>a : number, Symbol(a,Decl(additionOperatorWithNumberAndEnum.ts,3,3))
|
||||
>b : E, Symbol(b,Decl(additionOperatorWithNumberAndEnum.ts,4,3))
|
||||
|
||||
var r3 = b + a;
|
||||
>r3 : number
|
||||
>r3 : number, Symbol(r3,Decl(additionOperatorWithNumberAndEnum.ts,9,3))
|
||||
>b + a : number
|
||||
>b : E
|
||||
>a : number
|
||||
>b : E, Symbol(b,Decl(additionOperatorWithNumberAndEnum.ts,4,3))
|
||||
>a : number, Symbol(a,Decl(additionOperatorWithNumberAndEnum.ts,3,3))
|
||||
|
||||
var r4 = b + b;
|
||||
>r4 : number
|
||||
>r4 : number, Symbol(r4,Decl(additionOperatorWithNumberAndEnum.ts,10,3))
|
||||
>b + b : number
|
||||
>b : E
|
||||
>b : E
|
||||
>b : E, Symbol(b,Decl(additionOperatorWithNumberAndEnum.ts,4,3))
|
||||
>b : E, Symbol(b,Decl(additionOperatorWithNumberAndEnum.ts,4,3))
|
||||
|
||||
var r5 = 0 + a;
|
||||
>r5 : number
|
||||
>r5 : number, Symbol(r5,Decl(additionOperatorWithNumberAndEnum.ts,12,3))
|
||||
>0 + a : number
|
||||
>0 : number
|
||||
>a : number
|
||||
>a : number, Symbol(a,Decl(additionOperatorWithNumberAndEnum.ts,3,3))
|
||||
|
||||
var r6 = E.a + 0;
|
||||
>r6 : number
|
||||
>r6 : number, Symbol(r6,Decl(additionOperatorWithNumberAndEnum.ts,13,3))
|
||||
>E.a + 0 : number
|
||||
>E.a : E
|
||||
>E : typeof E
|
||||
>a : E
|
||||
>E.a : E, Symbol(E.a,Decl(additionOperatorWithNumberAndEnum.ts,0,8))
|
||||
>E : typeof E, Symbol(E,Decl(additionOperatorWithNumberAndEnum.ts,0,0))
|
||||
>a : E, Symbol(E.a,Decl(additionOperatorWithNumberAndEnum.ts,0,8))
|
||||
>0 : number
|
||||
|
||||
var r7 = E.a + E.b;
|
||||
>r7 : number
|
||||
>r7 : number, Symbol(r7,Decl(additionOperatorWithNumberAndEnum.ts,14,3))
|
||||
>E.a + E.b : number
|
||||
>E.a : E
|
||||
>E : typeof E
|
||||
>a : E
|
||||
>E.b : E
|
||||
>E : typeof E
|
||||
>b : E
|
||||
>E.a : E, Symbol(E.a,Decl(additionOperatorWithNumberAndEnum.ts,0,8))
|
||||
>E : typeof E, Symbol(E,Decl(additionOperatorWithNumberAndEnum.ts,0,0))
|
||||
>a : E, Symbol(E.a,Decl(additionOperatorWithNumberAndEnum.ts,0,8))
|
||||
>E.b : E, Symbol(E.b,Decl(additionOperatorWithNumberAndEnum.ts,0,11))
|
||||
>E : typeof E, Symbol(E,Decl(additionOperatorWithNumberAndEnum.ts,0,0))
|
||||
>b : E, Symbol(E.b,Decl(additionOperatorWithNumberAndEnum.ts,0,11))
|
||||
|
||||
var r8 = E['a'] + E['b'];
|
||||
>r8 : number
|
||||
>r8 : number, Symbol(r8,Decl(additionOperatorWithNumberAndEnum.ts,15,3))
|
||||
>E['a'] + E['b'] : number
|
||||
>E['a'] : E
|
||||
>E : typeof E
|
||||
>'a' : string
|
||||
>E : typeof E, Symbol(E,Decl(additionOperatorWithNumberAndEnum.ts,0,0))
|
||||
>'a' : string, Symbol(E.a,Decl(additionOperatorWithNumberAndEnum.ts,0,8))
|
||||
>E['b'] : E
|
||||
>E : typeof E
|
||||
>'b' : string
|
||||
>E : typeof E, Symbol(E,Decl(additionOperatorWithNumberAndEnum.ts,0,0))
|
||||
>'b' : string, Symbol(E.b,Decl(additionOperatorWithNumberAndEnum.ts,0,11))
|
||||
|
||||
var r9 = E['a'] + F['c'];
|
||||
>r9 : number
|
||||
>r9 : number, Symbol(r9,Decl(additionOperatorWithNumberAndEnum.ts,16,3))
|
||||
>E['a'] + F['c'] : number
|
||||
>E['a'] : E
|
||||
>E : typeof E
|
||||
>'a' : string
|
||||
>E : typeof E, Symbol(E,Decl(additionOperatorWithNumberAndEnum.ts,0,0))
|
||||
>'a' : string, Symbol(E.a,Decl(additionOperatorWithNumberAndEnum.ts,0,8))
|
||||
>F['c'] : F
|
||||
>F : typeof F
|
||||
>'c' : string
|
||||
>F : typeof F, Symbol(F,Decl(additionOperatorWithNumberAndEnum.ts,0,15))
|
||||
>'c' : string, Symbol(F.c,Decl(additionOperatorWithNumberAndEnum.ts,1,8))
|
||||
|
||||
var r10 = a + c;
|
||||
>r10 : number
|
||||
>r10 : number, Symbol(r10,Decl(additionOperatorWithNumberAndEnum.ts,18,3))
|
||||
>a + c : number
|
||||
>a : number
|
||||
>c : E | F
|
||||
>a : number, Symbol(a,Decl(additionOperatorWithNumberAndEnum.ts,3,3))
|
||||
>c : E | F, Symbol(c,Decl(additionOperatorWithNumberAndEnum.ts,5,3))
|
||||
|
||||
var r11 = c + a;
|
||||
>r11 : number
|
||||
>r11 : number, Symbol(r11,Decl(additionOperatorWithNumberAndEnum.ts,19,3))
|
||||
>c + a : number
|
||||
>c : E | F
|
||||
>a : number
|
||||
>c : E | F, Symbol(c,Decl(additionOperatorWithNumberAndEnum.ts,5,3))
|
||||
>a : number, Symbol(a,Decl(additionOperatorWithNumberAndEnum.ts,3,3))
|
||||
|
||||
var r12 = b + c;
|
||||
>r12 : number
|
||||
>r12 : number, Symbol(r12,Decl(additionOperatorWithNumberAndEnum.ts,20,3))
|
||||
>b + c : number
|
||||
>b : E
|
||||
>c : E | F
|
||||
>b : E, Symbol(b,Decl(additionOperatorWithNumberAndEnum.ts,4,3))
|
||||
>c : E | F, Symbol(c,Decl(additionOperatorWithNumberAndEnum.ts,5,3))
|
||||
|
||||
var r13 = c + b;
|
||||
>r13 : number
|
||||
>r13 : number, Symbol(r13,Decl(additionOperatorWithNumberAndEnum.ts,21,3))
|
||||
>c + b : number
|
||||
>c : E | F
|
||||
>b : E
|
||||
>c : E | F, Symbol(c,Decl(additionOperatorWithNumberAndEnum.ts,5,3))
|
||||
>b : E, Symbol(b,Decl(additionOperatorWithNumberAndEnum.ts,4,3))
|
||||
|
||||
var r14 = c + c;
|
||||
>r14 : number
|
||||
>r14 : number, Symbol(r14,Decl(additionOperatorWithNumberAndEnum.ts,22,3))
|
||||
>c + c : number
|
||||
>c : E | F
|
||||
>c : E | F
|
||||
>c : E | F, Symbol(c,Decl(additionOperatorWithNumberAndEnum.ts,5,3))
|
||||
>c : E | F, Symbol(c,Decl(additionOperatorWithNumberAndEnum.ts,5,3))
|
||||
|
||||
|
||||
@@ -1,161 +1,161 @@
|
||||
=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithStringAndEveryType.ts ===
|
||||
enum E { a, b, c }
|
||||
>E : E
|
||||
>a : E
|
||||
>b : E
|
||||
>c : E
|
||||
>E : E, Symbol(E,Decl(additionOperatorWithStringAndEveryType.ts,0,0))
|
||||
>a : E, Symbol(E.a,Decl(additionOperatorWithStringAndEveryType.ts,0,8))
|
||||
>b : E, Symbol(E.b,Decl(additionOperatorWithStringAndEveryType.ts,0,11))
|
||||
>c : E, Symbol(E.c,Decl(additionOperatorWithStringAndEveryType.ts,0,14))
|
||||
|
||||
var a: any;
|
||||
>a : any
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithStringAndEveryType.ts,2,3))
|
||||
|
||||
var b: boolean;
|
||||
>b : boolean
|
||||
>b : boolean, Symbol(b,Decl(additionOperatorWithStringAndEveryType.ts,3,3))
|
||||
|
||||
var c: number;
|
||||
>c : number
|
||||
>c : number, Symbol(c,Decl(additionOperatorWithStringAndEveryType.ts,4,3))
|
||||
|
||||
var d: string;
|
||||
>d : string
|
||||
>d : string, Symbol(d,Decl(additionOperatorWithStringAndEveryType.ts,5,3))
|
||||
|
||||
var e: Object;
|
||||
>e : Object
|
||||
>Object : Object
|
||||
>e : Object, Symbol(e,Decl(additionOperatorWithStringAndEveryType.ts,6,3))
|
||||
>Object : Object, Symbol(Object,Decl(lib.d.ts,92,1),Decl(lib.d.ts,223,11))
|
||||
|
||||
var f: void;
|
||||
>f : void
|
||||
>f : void, Symbol(f,Decl(additionOperatorWithStringAndEveryType.ts,7,3))
|
||||
|
||||
var g: E;
|
||||
>g : E
|
||||
>E : E
|
||||
>g : E, Symbol(g,Decl(additionOperatorWithStringAndEveryType.ts,8,3))
|
||||
>E : E, Symbol(E,Decl(additionOperatorWithStringAndEveryType.ts,0,0))
|
||||
|
||||
var x: string;
|
||||
>x : string
|
||||
>x : string, Symbol(x,Decl(additionOperatorWithStringAndEveryType.ts,10,3))
|
||||
|
||||
// string could plus every type, and the result is always string
|
||||
// string as left operand
|
||||
var r1 = x + a;
|
||||
>r1 : string
|
||||
>r1 : string, Symbol(r1,Decl(additionOperatorWithStringAndEveryType.ts,14,3))
|
||||
>x + a : string
|
||||
>x : string
|
||||
>a : any
|
||||
>x : string, Symbol(x,Decl(additionOperatorWithStringAndEveryType.ts,10,3))
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithStringAndEveryType.ts,2,3))
|
||||
|
||||
var r2 = x + b;
|
||||
>r2 : string
|
||||
>r2 : string, Symbol(r2,Decl(additionOperatorWithStringAndEveryType.ts,15,3))
|
||||
>x + b : string
|
||||
>x : string
|
||||
>b : boolean
|
||||
>x : string, Symbol(x,Decl(additionOperatorWithStringAndEveryType.ts,10,3))
|
||||
>b : boolean, Symbol(b,Decl(additionOperatorWithStringAndEveryType.ts,3,3))
|
||||
|
||||
var r3 = x + c;
|
||||
>r3 : string
|
||||
>r3 : string, Symbol(r3,Decl(additionOperatorWithStringAndEveryType.ts,16,3))
|
||||
>x + c : string
|
||||
>x : string
|
||||
>c : number
|
||||
>x : string, Symbol(x,Decl(additionOperatorWithStringAndEveryType.ts,10,3))
|
||||
>c : number, Symbol(c,Decl(additionOperatorWithStringAndEveryType.ts,4,3))
|
||||
|
||||
var r4 = x + d;
|
||||
>r4 : string
|
||||
>r4 : string, Symbol(r4,Decl(additionOperatorWithStringAndEveryType.ts,17,3))
|
||||
>x + d : string
|
||||
>x : string
|
||||
>d : string
|
||||
>x : string, Symbol(x,Decl(additionOperatorWithStringAndEveryType.ts,10,3))
|
||||
>d : string, Symbol(d,Decl(additionOperatorWithStringAndEveryType.ts,5,3))
|
||||
|
||||
var r5 = x + e;
|
||||
>r5 : string
|
||||
>r5 : string, Symbol(r5,Decl(additionOperatorWithStringAndEveryType.ts,18,3))
|
||||
>x + e : string
|
||||
>x : string
|
||||
>e : Object
|
||||
>x : string, Symbol(x,Decl(additionOperatorWithStringAndEveryType.ts,10,3))
|
||||
>e : Object, Symbol(e,Decl(additionOperatorWithStringAndEveryType.ts,6,3))
|
||||
|
||||
var r6 = x + f;
|
||||
>r6 : string
|
||||
>r6 : string, Symbol(r6,Decl(additionOperatorWithStringAndEveryType.ts,19,3))
|
||||
>x + f : string
|
||||
>x : string
|
||||
>f : void
|
||||
>x : string, Symbol(x,Decl(additionOperatorWithStringAndEveryType.ts,10,3))
|
||||
>f : void, Symbol(f,Decl(additionOperatorWithStringAndEveryType.ts,7,3))
|
||||
|
||||
var r7 = x + g;
|
||||
>r7 : string
|
||||
>r7 : string, Symbol(r7,Decl(additionOperatorWithStringAndEveryType.ts,20,3))
|
||||
>x + g : string
|
||||
>x : string
|
||||
>g : E
|
||||
>x : string, Symbol(x,Decl(additionOperatorWithStringAndEveryType.ts,10,3))
|
||||
>g : E, Symbol(g,Decl(additionOperatorWithStringAndEveryType.ts,8,3))
|
||||
|
||||
// string as right operand
|
||||
var r8 = a + x;
|
||||
>r8 : string
|
||||
>r8 : string, Symbol(r8,Decl(additionOperatorWithStringAndEveryType.ts,23,3))
|
||||
>a + x : string
|
||||
>a : any
|
||||
>x : string
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithStringAndEveryType.ts,2,3))
|
||||
>x : string, Symbol(x,Decl(additionOperatorWithStringAndEveryType.ts,10,3))
|
||||
|
||||
var r9 = b + x;
|
||||
>r9 : string
|
||||
>r9 : string, Symbol(r9,Decl(additionOperatorWithStringAndEveryType.ts,24,3))
|
||||
>b + x : string
|
||||
>b : boolean
|
||||
>x : string
|
||||
>b : boolean, Symbol(b,Decl(additionOperatorWithStringAndEveryType.ts,3,3))
|
||||
>x : string, Symbol(x,Decl(additionOperatorWithStringAndEveryType.ts,10,3))
|
||||
|
||||
var r10 = c + x;
|
||||
>r10 : string
|
||||
>r10 : string, Symbol(r10,Decl(additionOperatorWithStringAndEveryType.ts,25,3))
|
||||
>c + x : string
|
||||
>c : number
|
||||
>x : string
|
||||
>c : number, Symbol(c,Decl(additionOperatorWithStringAndEveryType.ts,4,3))
|
||||
>x : string, Symbol(x,Decl(additionOperatorWithStringAndEveryType.ts,10,3))
|
||||
|
||||
var r11 = d + x;
|
||||
>r11 : string
|
||||
>r11 : string, Symbol(r11,Decl(additionOperatorWithStringAndEveryType.ts,26,3))
|
||||
>d + x : string
|
||||
>d : string
|
||||
>x : string
|
||||
>d : string, Symbol(d,Decl(additionOperatorWithStringAndEveryType.ts,5,3))
|
||||
>x : string, Symbol(x,Decl(additionOperatorWithStringAndEveryType.ts,10,3))
|
||||
|
||||
var r12 = e + x;
|
||||
>r12 : string
|
||||
>r12 : string, Symbol(r12,Decl(additionOperatorWithStringAndEveryType.ts,27,3))
|
||||
>e + x : string
|
||||
>e : Object
|
||||
>x : string
|
||||
>e : Object, Symbol(e,Decl(additionOperatorWithStringAndEveryType.ts,6,3))
|
||||
>x : string, Symbol(x,Decl(additionOperatorWithStringAndEveryType.ts,10,3))
|
||||
|
||||
var r13 = f + x;
|
||||
>r13 : string
|
||||
>r13 : string, Symbol(r13,Decl(additionOperatorWithStringAndEveryType.ts,28,3))
|
||||
>f + x : string
|
||||
>f : void
|
||||
>x : string
|
||||
>f : void, Symbol(f,Decl(additionOperatorWithStringAndEveryType.ts,7,3))
|
||||
>x : string, Symbol(x,Decl(additionOperatorWithStringAndEveryType.ts,10,3))
|
||||
|
||||
var r14 = g + x;
|
||||
>r14 : string
|
||||
>r14 : string, Symbol(r14,Decl(additionOperatorWithStringAndEveryType.ts,29,3))
|
||||
>g + x : string
|
||||
>g : E
|
||||
>x : string
|
||||
>g : E, Symbol(g,Decl(additionOperatorWithStringAndEveryType.ts,8,3))
|
||||
>x : string, Symbol(x,Decl(additionOperatorWithStringAndEveryType.ts,10,3))
|
||||
|
||||
// other cases
|
||||
var r15 = x + E;
|
||||
>r15 : string
|
||||
>r15 : string, Symbol(r15,Decl(additionOperatorWithStringAndEveryType.ts,32,3))
|
||||
>x + E : string
|
||||
>x : string
|
||||
>E : typeof E
|
||||
>x : string, Symbol(x,Decl(additionOperatorWithStringAndEveryType.ts,10,3))
|
||||
>E : typeof E, Symbol(E,Decl(additionOperatorWithStringAndEveryType.ts,0,0))
|
||||
|
||||
var r16 = x + E.a;
|
||||
>r16 : string
|
||||
>r16 : string, Symbol(r16,Decl(additionOperatorWithStringAndEveryType.ts,33,3))
|
||||
>x + E.a : string
|
||||
>x : string
|
||||
>E.a : E
|
||||
>E : typeof E
|
||||
>a : E
|
||||
>x : string, Symbol(x,Decl(additionOperatorWithStringAndEveryType.ts,10,3))
|
||||
>E.a : E, Symbol(E.a,Decl(additionOperatorWithStringAndEveryType.ts,0,8))
|
||||
>E : typeof E, Symbol(E,Decl(additionOperatorWithStringAndEveryType.ts,0,0))
|
||||
>a : E, Symbol(E.a,Decl(additionOperatorWithStringAndEveryType.ts,0,8))
|
||||
|
||||
var r17 = x + '';
|
||||
>r17 : string
|
||||
>r17 : string, Symbol(r17,Decl(additionOperatorWithStringAndEveryType.ts,34,3))
|
||||
>x + '' : string
|
||||
>x : string
|
||||
>x : string, Symbol(x,Decl(additionOperatorWithStringAndEveryType.ts,10,3))
|
||||
>'' : string
|
||||
|
||||
var r18 = x + 0;
|
||||
>r18 : string
|
||||
>r18 : string, Symbol(r18,Decl(additionOperatorWithStringAndEveryType.ts,35,3))
|
||||
>x + 0 : string
|
||||
>x : string
|
||||
>x : string, Symbol(x,Decl(additionOperatorWithStringAndEveryType.ts,10,3))
|
||||
>0 : number
|
||||
|
||||
var r19 = x + { a: '' };
|
||||
>r19 : string
|
||||
>r19 : string, Symbol(r19,Decl(additionOperatorWithStringAndEveryType.ts,36,3))
|
||||
>x + { a: '' } : string
|
||||
>x : string
|
||||
>x : string, Symbol(x,Decl(additionOperatorWithStringAndEveryType.ts,10,3))
|
||||
>{ a: '' } : { a: string; }
|
||||
>a : string
|
||||
>a : string, Symbol(a,Decl(additionOperatorWithStringAndEveryType.ts,36,15))
|
||||
>'' : string
|
||||
|
||||
var r20 = x + [];
|
||||
>r20 : string
|
||||
>r20 : string, Symbol(r20,Decl(additionOperatorWithStringAndEveryType.ts,37,3))
|
||||
>x + [] : string
|
||||
>x : string
|
||||
>x : string, Symbol(x,Decl(additionOperatorWithStringAndEveryType.ts,10,3))
|
||||
>[] : undefined[]
|
||||
|
||||
|
||||
+59
-59
@@ -2,128 +2,128 @@
|
||||
// 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
|
||||
>E : E, Symbol(E,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,0,0))
|
||||
>a : E, Symbol(E.a,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,2,8))
|
||||
>b : E, Symbol(E.b,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,2,11))
|
||||
>c : E, Symbol(E.c,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,2,14))
|
||||
|
||||
var a: any;
|
||||
>a : any
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,4,3))
|
||||
|
||||
var b: number;
|
||||
>b : number
|
||||
>b : number, Symbol(b,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,5,3))
|
||||
|
||||
var c: E;
|
||||
>c : E
|
||||
>E : E
|
||||
>c : E, Symbol(c,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,6,3))
|
||||
>E : E, Symbol(E,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,0,0))
|
||||
|
||||
var d: string;
|
||||
>d : string
|
||||
>d : string, Symbol(d,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,7,3))
|
||||
|
||||
// undefined + any
|
||||
var r1: any = undefined + a;
|
||||
>r1 : any
|
||||
>r1 : any, Symbol(r1,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,10,3))
|
||||
>undefined + a : any
|
||||
>undefined : undefined
|
||||
>a : any
|
||||
>undefined : undefined, Symbol(undefined)
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,4,3))
|
||||
|
||||
var r2: any = a + undefined;
|
||||
>r2 : any
|
||||
>r2 : any, Symbol(r2,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,11,3))
|
||||
>a + undefined : any
|
||||
>a : any
|
||||
>undefined : undefined
|
||||
>a : any, Symbol(a,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,4,3))
|
||||
>undefined : undefined, Symbol(undefined)
|
||||
|
||||
// undefined + number/enum
|
||||
var r3 = undefined + b;
|
||||
>r3 : number
|
||||
>r3 : number, Symbol(r3,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,14,3))
|
||||
>undefined + b : number
|
||||
>undefined : undefined
|
||||
>b : number
|
||||
>undefined : undefined, Symbol(undefined)
|
||||
>b : number, Symbol(b,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,5,3))
|
||||
|
||||
var r4 = undefined + 1;
|
||||
>r4 : number
|
||||
>r4 : number, Symbol(r4,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,15,3))
|
||||
>undefined + 1 : number
|
||||
>undefined : undefined
|
||||
>undefined : undefined, Symbol(undefined)
|
||||
>1 : number
|
||||
|
||||
var r5 = undefined + c;
|
||||
>r5 : number
|
||||
>r5 : number, Symbol(r5,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,16,3))
|
||||
>undefined + c : number
|
||||
>undefined : undefined
|
||||
>c : E
|
||||
>undefined : undefined, Symbol(undefined)
|
||||
>c : E, Symbol(c,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,6,3))
|
||||
|
||||
var r6 = undefined + E.a;
|
||||
>r6 : number
|
||||
>r6 : number, Symbol(r6,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,17,3))
|
||||
>undefined + E.a : number
|
||||
>undefined : undefined
|
||||
>E.a : E
|
||||
>E : typeof E
|
||||
>a : E
|
||||
>undefined : undefined, Symbol(undefined)
|
||||
>E.a : E, Symbol(E.a,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,2,8))
|
||||
>E : typeof E, Symbol(E,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,0,0))
|
||||
>a : E, Symbol(E.a,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,2,8))
|
||||
|
||||
var r7 = undefined + E['a'];
|
||||
>r7 : number
|
||||
>r7 : number, Symbol(r7,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,18,3))
|
||||
>undefined + E['a'] : number
|
||||
>undefined : undefined
|
||||
>undefined : undefined, Symbol(undefined)
|
||||
>E['a'] : E
|
||||
>E : typeof E
|
||||
>'a' : string
|
||||
>E : typeof E, Symbol(E,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,0,0))
|
||||
>'a' : string, Symbol(E.a,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,2,8))
|
||||
|
||||
var r8 = b + undefined;
|
||||
>r8 : number
|
||||
>r8 : number, Symbol(r8,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,19,3))
|
||||
>b + undefined : number
|
||||
>b : number
|
||||
>undefined : undefined
|
||||
>b : number, Symbol(b,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,5,3))
|
||||
>undefined : undefined, Symbol(undefined)
|
||||
|
||||
var r9 = 1 + undefined;
|
||||
>r9 : number
|
||||
>r9 : number, Symbol(r9,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,20,3))
|
||||
>1 + undefined : number
|
||||
>1 : number
|
||||
>undefined : undefined
|
||||
>undefined : undefined, Symbol(undefined)
|
||||
|
||||
var r10 = c + undefined
|
||||
>r10 : number
|
||||
>r10 : number, Symbol(r10,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,21,3))
|
||||
>c + undefined : number
|
||||
>c : E
|
||||
>undefined : undefined
|
||||
>c : E, Symbol(c,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,6,3))
|
||||
>undefined : undefined, Symbol(undefined)
|
||||
|
||||
var r11 = E.a + undefined;
|
||||
>r11 : number
|
||||
>r11 : number, Symbol(r11,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,22,3))
|
||||
>E.a + undefined : number
|
||||
>E.a : E
|
||||
>E : typeof E
|
||||
>a : E
|
||||
>undefined : undefined
|
||||
>E.a : E, Symbol(E.a,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,2,8))
|
||||
>E : typeof E, Symbol(E,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,0,0))
|
||||
>a : E, Symbol(E.a,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,2,8))
|
||||
>undefined : undefined, Symbol(undefined)
|
||||
|
||||
var r12 = E['a'] + undefined;
|
||||
>r12 : number
|
||||
>r12 : number, Symbol(r12,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,23,3))
|
||||
>E['a'] + undefined : number
|
||||
>E['a'] : E
|
||||
>E : typeof E
|
||||
>'a' : string
|
||||
>undefined : undefined
|
||||
>E : typeof E, Symbol(E,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,0,0))
|
||||
>'a' : string, Symbol(E.a,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,2,8))
|
||||
>undefined : undefined, Symbol(undefined)
|
||||
|
||||
// undefined + string
|
||||
var r13 = undefined + d;
|
||||
>r13 : string
|
||||
>r13 : string, Symbol(r13,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,26,3))
|
||||
>undefined + d : string
|
||||
>undefined : undefined
|
||||
>d : string
|
||||
>undefined : undefined, Symbol(undefined)
|
||||
>d : string, Symbol(d,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,7,3))
|
||||
|
||||
var r14 = undefined + '';
|
||||
>r14 : string
|
||||
>r14 : string, Symbol(r14,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,27,3))
|
||||
>undefined + '' : string
|
||||
>undefined : undefined
|
||||
>undefined : undefined, Symbol(undefined)
|
||||
>'' : string
|
||||
|
||||
var r15 = d + undefined;
|
||||
>r15 : string
|
||||
>r15 : string, Symbol(r15,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,28,3))
|
||||
>d + undefined : string
|
||||
>d : string
|
||||
>undefined : undefined
|
||||
>d : string, Symbol(d,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,7,3))
|
||||
>undefined : undefined, Symbol(undefined)
|
||||
|
||||
var r16 = '' + undefined;
|
||||
>r16 : string
|
||||
>r16 : string, Symbol(r16,Decl(additionOperatorWithUndefinedValueAndValidOperator.ts,29,3))
|
||||
>'' + undefined : string
|
||||
>'' : string
|
||||
>undefined : undefined
|
||||
>undefined : undefined, Symbol(undefined)
|
||||
|
||||
|
||||
@@ -1,61 +1,61 @@
|
||||
=== tests/cases/compiler/aliasUsage1_main.ts ===
|
||||
import Backbone = require("aliasUsage1_backbone");
|
||||
>Backbone : typeof Backbone
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsage1_main.ts,0,0))
|
||||
|
||||
import moduleA = require("aliasUsage1_moduleA");
|
||||
>moduleA : typeof moduleA
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsage1_main.ts,0,50))
|
||||
|
||||
interface IHasVisualizationModel {
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsage1_main.ts,1,48))
|
||||
|
||||
VisualizationModel: typeof Backbone.Model;
|
||||
>VisualizationModel : typeof Backbone.Model
|
||||
>Backbone.Model : typeof Backbone.Model
|
||||
>Backbone : typeof Backbone
|
||||
>Model : typeof Backbone.Model
|
||||
>VisualizationModel : typeof Backbone.Model, Symbol(VisualizationModel,Decl(aliasUsage1_main.ts,2,34))
|
||||
>Backbone.Model : typeof Backbone.Model, Symbol(Backbone.Model,Decl(aliasUsage1_backbone.ts,0,0))
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsage1_main.ts,0,0))
|
||||
>Model : typeof Backbone.Model, Symbol(Backbone.Model,Decl(aliasUsage1_backbone.ts,0,0))
|
||||
}
|
||||
class C2 {
|
||||
>C2 : C2
|
||||
>C2 : C2, Symbol(C2,Decl(aliasUsage1_main.ts,4,1))
|
||||
|
||||
x: IHasVisualizationModel;
|
||||
>x : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>x : IHasVisualizationModel, Symbol(x,Decl(aliasUsage1_main.ts,5,10))
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsage1_main.ts,1,48))
|
||||
|
||||
get A() {
|
||||
>A : IHasVisualizationModel
|
||||
>A : IHasVisualizationModel, Symbol(A,Decl(aliasUsage1_main.ts,6,30),Decl(aliasUsage1_main.ts,9,5))
|
||||
|
||||
return this.x;
|
||||
>this.x : IHasVisualizationModel
|
||||
>this : C2
|
||||
>x : IHasVisualizationModel
|
||||
>this.x : IHasVisualizationModel, Symbol(x,Decl(aliasUsage1_main.ts,5,10))
|
||||
>this : C2, Symbol(C2,Decl(aliasUsage1_main.ts,4,1))
|
||||
>x : IHasVisualizationModel, Symbol(x,Decl(aliasUsage1_main.ts,5,10))
|
||||
}
|
||||
set A(x) {
|
||||
>A : IHasVisualizationModel
|
||||
>x : IHasVisualizationModel
|
||||
>A : IHasVisualizationModel, Symbol(A,Decl(aliasUsage1_main.ts,6,30),Decl(aliasUsage1_main.ts,9,5))
|
||||
>x : IHasVisualizationModel, Symbol(x,Decl(aliasUsage1_main.ts,10,10))
|
||||
|
||||
x = moduleA;
|
||||
>x = moduleA : typeof moduleA
|
||||
>x : IHasVisualizationModel
|
||||
>moduleA : typeof moduleA
|
||||
>x : IHasVisualizationModel, Symbol(x,Decl(aliasUsage1_main.ts,10,10))
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsage1_main.ts,0,50))
|
||||
}
|
||||
}
|
||||
=== tests/cases/compiler/aliasUsage1_backbone.ts ===
|
||||
export class Model {
|
||||
>Model : Model
|
||||
>Model : Model, Symbol(Model,Decl(aliasUsage1_backbone.ts,0,0))
|
||||
|
||||
public someData: string;
|
||||
>someData : string
|
||||
>someData : string, Symbol(someData,Decl(aliasUsage1_backbone.ts,0,20))
|
||||
}
|
||||
|
||||
=== tests/cases/compiler/aliasUsage1_moduleA.ts ===
|
||||
import Backbone = require("aliasUsage1_backbone");
|
||||
>Backbone : typeof Backbone
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsage1_moduleA.ts,0,0))
|
||||
|
||||
export class VisualizationModel extends Backbone.Model {
|
||||
>VisualizationModel : VisualizationModel
|
||||
>Backbone.Model : unknown
|
||||
>Backbone : typeof Backbone
|
||||
>Model : Backbone.Model
|
||||
>VisualizationModel : VisualizationModel, Symbol(VisualizationModel,Decl(aliasUsage1_moduleA.ts,0,50))
|
||||
>Backbone.Model : any, Symbol(Backbone.Model,Decl(aliasUsage1_backbone.ts,0,0))
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsage1_moduleA.ts,0,0))
|
||||
>Model : Backbone.Model, Symbol(Backbone.Model,Decl(aliasUsage1_backbone.ts,0,0))
|
||||
|
||||
// interesting stuff here
|
||||
}
|
||||
|
||||
@@ -1,49 +1,49 @@
|
||||
=== tests/cases/compiler/aliasUsageInArray_main.ts ===
|
||||
import Backbone = require("aliasUsageInArray_backbone");
|
||||
>Backbone : typeof Backbone
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInArray_main.ts,0,0))
|
||||
|
||||
import moduleA = require("aliasUsageInArray_moduleA");
|
||||
>moduleA : typeof moduleA
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInArray_main.ts,0,56))
|
||||
|
||||
interface IHasVisualizationModel {
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInArray_main.ts,1,54))
|
||||
|
||||
VisualizationModel: typeof Backbone.Model;
|
||||
>VisualizationModel : typeof Backbone.Model
|
||||
>Backbone.Model : typeof Backbone.Model
|
||||
>Backbone : typeof Backbone
|
||||
>Model : typeof Backbone.Model
|
||||
>VisualizationModel : typeof Backbone.Model, Symbol(VisualizationModel,Decl(aliasUsageInArray_main.ts,2,34))
|
||||
>Backbone.Model : typeof Backbone.Model, Symbol(Backbone.Model,Decl(aliasUsageInArray_backbone.ts,0,0))
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInArray_main.ts,0,0))
|
||||
>Model : typeof Backbone.Model, Symbol(Backbone.Model,Decl(aliasUsageInArray_backbone.ts,0,0))
|
||||
}
|
||||
|
||||
var xs: IHasVisualizationModel[] = [moduleA];
|
||||
>xs : IHasVisualizationModel[]
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>xs : IHasVisualizationModel[], Symbol(xs,Decl(aliasUsageInArray_main.ts,6,3))
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInArray_main.ts,1,54))
|
||||
>[moduleA] : typeof moduleA[]
|
||||
>moduleA : typeof moduleA
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInArray_main.ts,0,56))
|
||||
|
||||
var xs2: typeof moduleA[] = [moduleA];
|
||||
>xs2 : typeof moduleA[]
|
||||
>moduleA : typeof moduleA
|
||||
>xs2 : typeof moduleA[], Symbol(xs2,Decl(aliasUsageInArray_main.ts,7,3))
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInArray_main.ts,0,56))
|
||||
>[moduleA] : typeof moduleA[]
|
||||
>moduleA : typeof moduleA
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInArray_main.ts,0,56))
|
||||
|
||||
=== tests/cases/compiler/aliasUsageInArray_backbone.ts ===
|
||||
export class Model {
|
||||
>Model : Model
|
||||
>Model : Model, Symbol(Model,Decl(aliasUsageInArray_backbone.ts,0,0))
|
||||
|
||||
public someData: string;
|
||||
>someData : string
|
||||
>someData : string, Symbol(someData,Decl(aliasUsageInArray_backbone.ts,0,20))
|
||||
}
|
||||
|
||||
=== tests/cases/compiler/aliasUsageInArray_moduleA.ts ===
|
||||
import Backbone = require("aliasUsageInArray_backbone");
|
||||
>Backbone : typeof Backbone
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInArray_moduleA.ts,0,0))
|
||||
|
||||
export class VisualizationModel extends Backbone.Model {
|
||||
>VisualizationModel : VisualizationModel
|
||||
>Backbone.Model : unknown
|
||||
>Backbone : typeof Backbone
|
||||
>Model : Backbone.Model
|
||||
>VisualizationModel : VisualizationModel, Symbol(VisualizationModel,Decl(aliasUsageInArray_moduleA.ts,0,56))
|
||||
>Backbone.Model : any, Symbol(Backbone.Model,Decl(aliasUsageInArray_backbone.ts,0,0))
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInArray_moduleA.ts,0,0))
|
||||
>Model : Backbone.Model, Symbol(Backbone.Model,Decl(aliasUsageInArray_backbone.ts,0,0))
|
||||
|
||||
// interesting stuff here
|
||||
}
|
||||
|
||||
@@ -1,50 +1,50 @@
|
||||
=== tests/cases/compiler/aliasUsageInFunctionExpression_main.ts ===
|
||||
import Backbone = require("aliasUsageInFunctionExpression_backbone");
|
||||
>Backbone : typeof Backbone
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInFunctionExpression_main.ts,0,0))
|
||||
|
||||
import moduleA = require("aliasUsageInFunctionExpression_moduleA");
|
||||
>moduleA : typeof moduleA
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInFunctionExpression_main.ts,0,69))
|
||||
|
||||
interface IHasVisualizationModel {
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInFunctionExpression_main.ts,1,67))
|
||||
|
||||
VisualizationModel: typeof Backbone.Model;
|
||||
>VisualizationModel : typeof Backbone.Model
|
||||
>Backbone.Model : typeof Backbone.Model
|
||||
>Backbone : typeof Backbone
|
||||
>Model : typeof Backbone.Model
|
||||
>VisualizationModel : typeof Backbone.Model, Symbol(VisualizationModel,Decl(aliasUsageInFunctionExpression_main.ts,2,34))
|
||||
>Backbone.Model : typeof Backbone.Model, Symbol(Backbone.Model,Decl(aliasUsageInFunctionExpression_backbone.ts,0,0))
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInFunctionExpression_main.ts,0,0))
|
||||
>Model : typeof Backbone.Model, Symbol(Backbone.Model,Decl(aliasUsageInFunctionExpression_backbone.ts,0,0))
|
||||
}
|
||||
var f = (x: IHasVisualizationModel) => x;
|
||||
>f : (x: IHasVisualizationModel) => IHasVisualizationModel
|
||||
>f : (x: IHasVisualizationModel) => IHasVisualizationModel, Symbol(f,Decl(aliasUsageInFunctionExpression_main.ts,5,3))
|
||||
>(x: IHasVisualizationModel) => x : (x: IHasVisualizationModel) => IHasVisualizationModel
|
||||
>x : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>x : IHasVisualizationModel
|
||||
>x : IHasVisualizationModel, Symbol(x,Decl(aliasUsageInFunctionExpression_main.ts,5,9))
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInFunctionExpression_main.ts,1,67))
|
||||
>x : IHasVisualizationModel, Symbol(x,Decl(aliasUsageInFunctionExpression_main.ts,5,9))
|
||||
|
||||
f = (x) => moduleA;
|
||||
>f = (x) => moduleA : (x: IHasVisualizationModel) => typeof moduleA
|
||||
>f : (x: IHasVisualizationModel) => IHasVisualizationModel
|
||||
>f : (x: IHasVisualizationModel) => IHasVisualizationModel, Symbol(f,Decl(aliasUsageInFunctionExpression_main.ts,5,3))
|
||||
>(x) => moduleA : (x: IHasVisualizationModel) => typeof moduleA
|
||||
>x : IHasVisualizationModel
|
||||
>moduleA : typeof moduleA
|
||||
>x : IHasVisualizationModel, Symbol(x,Decl(aliasUsageInFunctionExpression_main.ts,6,5))
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInFunctionExpression_main.ts,0,69))
|
||||
|
||||
=== tests/cases/compiler/aliasUsageInFunctionExpression_backbone.ts ===
|
||||
export class Model {
|
||||
>Model : Model
|
||||
>Model : Model, Symbol(Model,Decl(aliasUsageInFunctionExpression_backbone.ts,0,0))
|
||||
|
||||
public someData: string;
|
||||
>someData : string
|
||||
>someData : string, Symbol(someData,Decl(aliasUsageInFunctionExpression_backbone.ts,0,20))
|
||||
}
|
||||
|
||||
=== tests/cases/compiler/aliasUsageInFunctionExpression_moduleA.ts ===
|
||||
import Backbone = require("aliasUsageInFunctionExpression_backbone");
|
||||
>Backbone : typeof Backbone
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInFunctionExpression_moduleA.ts,0,0))
|
||||
|
||||
export class VisualizationModel extends Backbone.Model {
|
||||
>VisualizationModel : VisualizationModel
|
||||
>Backbone.Model : unknown
|
||||
>Backbone : typeof Backbone
|
||||
>Model : Backbone.Model
|
||||
>VisualizationModel : VisualizationModel, Symbol(VisualizationModel,Decl(aliasUsageInFunctionExpression_moduleA.ts,0,69))
|
||||
>Backbone.Model : any, Symbol(Backbone.Model,Decl(aliasUsageInFunctionExpression_backbone.ts,0,0))
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInFunctionExpression_moduleA.ts,0,0))
|
||||
>Model : Backbone.Model, Symbol(Backbone.Model,Decl(aliasUsageInFunctionExpression_backbone.ts,0,0))
|
||||
|
||||
// interesting stuff here
|
||||
}
|
||||
|
||||
@@ -1,65 +1,65 @@
|
||||
=== tests/cases/compiler/aliasUsageInGenericFunction_main.ts ===
|
||||
import Backbone = require("aliasUsageInGenericFunction_backbone");
|
||||
>Backbone : typeof Backbone
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInGenericFunction_main.ts,0,0))
|
||||
|
||||
import moduleA = require("aliasUsageInGenericFunction_moduleA");
|
||||
>moduleA : typeof moduleA
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInGenericFunction_main.ts,0,66))
|
||||
|
||||
interface IHasVisualizationModel {
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInGenericFunction_main.ts,1,64))
|
||||
|
||||
VisualizationModel: typeof Backbone.Model;
|
||||
>VisualizationModel : typeof Backbone.Model
|
||||
>Backbone.Model : typeof Backbone.Model
|
||||
>Backbone : typeof Backbone
|
||||
>Model : typeof Backbone.Model
|
||||
>VisualizationModel : typeof Backbone.Model, Symbol(VisualizationModel,Decl(aliasUsageInGenericFunction_main.ts,2,34))
|
||||
>Backbone.Model : typeof Backbone.Model, Symbol(Backbone.Model,Decl(aliasUsageInGenericFunction_backbone.ts,0,0))
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInGenericFunction_main.ts,0,0))
|
||||
>Model : typeof Backbone.Model, Symbol(Backbone.Model,Decl(aliasUsageInGenericFunction_backbone.ts,0,0))
|
||||
}
|
||||
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
|
||||
>foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T, Symbol(foo,Decl(aliasUsageInGenericFunction_main.ts,4,1))
|
||||
>T : T, Symbol(T,Decl(aliasUsageInGenericFunction_main.ts,5,13))
|
||||
>a : IHasVisualizationModel, Symbol(a,Decl(aliasUsageInGenericFunction_main.ts,5,24))
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInGenericFunction_main.ts,1,64))
|
||||
>x : T, Symbol(x,Decl(aliasUsageInGenericFunction_main.ts,5,54))
|
||||
>T : T, Symbol(T,Decl(aliasUsageInGenericFunction_main.ts,5,13))
|
||||
|
||||
return x;
|
||||
>x : T
|
||||
>x : T, Symbol(x,Decl(aliasUsageInGenericFunction_main.ts,5,54))
|
||||
}
|
||||
var r = foo({ a: moduleA });
|
||||
>r : { a: typeof moduleA; }
|
||||
>r : { a: typeof moduleA; }, Symbol(r,Decl(aliasUsageInGenericFunction_main.ts,8,3))
|
||||
>foo({ a: moduleA }) : { a: typeof moduleA; }
|
||||
>foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T
|
||||
>foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T, Symbol(foo,Decl(aliasUsageInGenericFunction_main.ts,4,1))
|
||||
>{ a: moduleA } : { a: typeof moduleA; }
|
||||
>a : typeof moduleA
|
||||
>moduleA : typeof moduleA
|
||||
>a : typeof moduleA, Symbol(a,Decl(aliasUsageInGenericFunction_main.ts,8,13))
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInGenericFunction_main.ts,0,66))
|
||||
|
||||
var r2 = foo({ a: <IHasVisualizationModel>null });
|
||||
>r2 : { a: IHasVisualizationModel; }
|
||||
>r2 : { a: IHasVisualizationModel; }, Symbol(r2,Decl(aliasUsageInGenericFunction_main.ts,9,3))
|
||||
>foo({ a: <IHasVisualizationModel>null }) : { a: IHasVisualizationModel; }
|
||||
>foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T
|
||||
>foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T, Symbol(foo,Decl(aliasUsageInGenericFunction_main.ts,4,1))
|
||||
>{ a: <IHasVisualizationModel>null } : { a: IHasVisualizationModel; }
|
||||
>a : IHasVisualizationModel
|
||||
>a : IHasVisualizationModel, Symbol(a,Decl(aliasUsageInGenericFunction_main.ts,9,14))
|
||||
><IHasVisualizationModel>null : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInGenericFunction_main.ts,1,64))
|
||||
>null : null
|
||||
|
||||
=== tests/cases/compiler/aliasUsageInGenericFunction_backbone.ts ===
|
||||
export class Model {
|
||||
>Model : Model
|
||||
>Model : Model, Symbol(Model,Decl(aliasUsageInGenericFunction_backbone.ts,0,0))
|
||||
|
||||
public someData: string;
|
||||
>someData : string
|
||||
>someData : string, Symbol(someData,Decl(aliasUsageInGenericFunction_backbone.ts,0,20))
|
||||
}
|
||||
|
||||
=== tests/cases/compiler/aliasUsageInGenericFunction_moduleA.ts ===
|
||||
import Backbone = require("aliasUsageInGenericFunction_backbone");
|
||||
>Backbone : typeof Backbone
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInGenericFunction_moduleA.ts,0,0))
|
||||
|
||||
export class VisualizationModel extends Backbone.Model {
|
||||
>VisualizationModel : VisualizationModel
|
||||
>Backbone.Model : unknown
|
||||
>Backbone : typeof Backbone
|
||||
>Model : Backbone.Model
|
||||
>VisualizationModel : VisualizationModel, Symbol(VisualizationModel,Decl(aliasUsageInGenericFunction_moduleA.ts,0,66))
|
||||
>Backbone.Model : any, Symbol(Backbone.Model,Decl(aliasUsageInGenericFunction_backbone.ts,0,0))
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInGenericFunction_moduleA.ts,0,0))
|
||||
>Model : Backbone.Model, Symbol(Backbone.Model,Decl(aliasUsageInGenericFunction_backbone.ts,0,0))
|
||||
|
||||
// interesting stuff here
|
||||
}
|
||||
|
||||
@@ -1,58 +1,58 @@
|
||||
=== tests/cases/compiler/aliasUsageInIndexerOfClass_main.ts ===
|
||||
import Backbone = require("aliasUsageInIndexerOfClass_backbone");
|
||||
>Backbone : typeof Backbone
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInIndexerOfClass_main.ts,0,0))
|
||||
|
||||
import moduleA = require("aliasUsageInIndexerOfClass_moduleA");
|
||||
>moduleA : typeof moduleA
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInIndexerOfClass_main.ts,0,65))
|
||||
|
||||
interface IHasVisualizationModel {
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInIndexerOfClass_main.ts,1,63))
|
||||
|
||||
VisualizationModel: typeof Backbone.Model;
|
||||
>VisualizationModel : typeof Backbone.Model
|
||||
>Backbone.Model : typeof Backbone.Model
|
||||
>Backbone : typeof Backbone
|
||||
>Model : typeof Backbone.Model
|
||||
>VisualizationModel : typeof Backbone.Model, Symbol(VisualizationModel,Decl(aliasUsageInIndexerOfClass_main.ts,2,34))
|
||||
>Backbone.Model : typeof Backbone.Model, Symbol(Backbone.Model,Decl(aliasUsageInIndexerOfClass_backbone.ts,0,0))
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInIndexerOfClass_main.ts,0,0))
|
||||
>Model : typeof Backbone.Model, Symbol(Backbone.Model,Decl(aliasUsageInIndexerOfClass_backbone.ts,0,0))
|
||||
}
|
||||
class N {
|
||||
>N : N
|
||||
>N : N, Symbol(N,Decl(aliasUsageInIndexerOfClass_main.ts,4,1))
|
||||
|
||||
[idx: string]: IHasVisualizationModel
|
||||
>idx : string
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>idx : string, Symbol(idx,Decl(aliasUsageInIndexerOfClass_main.ts,6,5))
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInIndexerOfClass_main.ts,1,63))
|
||||
|
||||
x = moduleA;
|
||||
>x : typeof moduleA
|
||||
>moduleA : typeof moduleA
|
||||
>x : typeof moduleA, Symbol(x,Decl(aliasUsageInIndexerOfClass_main.ts,6,41))
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInIndexerOfClass_main.ts,0,65))
|
||||
}
|
||||
class N2 {
|
||||
>N2 : N2
|
||||
>N2 : N2, Symbol(N2,Decl(aliasUsageInIndexerOfClass_main.ts,8,1))
|
||||
|
||||
[idx: string]: typeof moduleA
|
||||
>idx : string
|
||||
>moduleA : typeof moduleA
|
||||
>idx : string, Symbol(idx,Decl(aliasUsageInIndexerOfClass_main.ts,10,5))
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInIndexerOfClass_main.ts,0,65))
|
||||
|
||||
x: IHasVisualizationModel;
|
||||
>x : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>x : IHasVisualizationModel, Symbol(x,Decl(aliasUsageInIndexerOfClass_main.ts,10,33))
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInIndexerOfClass_main.ts,1,63))
|
||||
}
|
||||
=== tests/cases/compiler/aliasUsageInIndexerOfClass_backbone.ts ===
|
||||
export class Model {
|
||||
>Model : Model
|
||||
>Model : Model, Symbol(Model,Decl(aliasUsageInIndexerOfClass_backbone.ts,0,0))
|
||||
|
||||
public someData: string;
|
||||
>someData : string
|
||||
>someData : string, Symbol(someData,Decl(aliasUsageInIndexerOfClass_backbone.ts,0,20))
|
||||
}
|
||||
|
||||
=== tests/cases/compiler/aliasUsageInIndexerOfClass_moduleA.ts ===
|
||||
import Backbone = require("aliasUsageInIndexerOfClass_backbone");
|
||||
>Backbone : typeof Backbone
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInIndexerOfClass_moduleA.ts,0,0))
|
||||
|
||||
export class VisualizationModel extends Backbone.Model {
|
||||
>VisualizationModel : VisualizationModel
|
||||
>Backbone.Model : unknown
|
||||
>Backbone : typeof Backbone
|
||||
>Model : Backbone.Model
|
||||
>VisualizationModel : VisualizationModel, Symbol(VisualizationModel,Decl(aliasUsageInIndexerOfClass_moduleA.ts,0,65))
|
||||
>Backbone.Model : any, Symbol(Backbone.Model,Decl(aliasUsageInIndexerOfClass_backbone.ts,0,0))
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInIndexerOfClass_moduleA.ts,0,0))
|
||||
>Model : Backbone.Model, Symbol(Backbone.Model,Decl(aliasUsageInIndexerOfClass_backbone.ts,0,0))
|
||||
|
||||
// interesting stuff here
|
||||
}
|
||||
|
||||
@@ -1,63 +1,63 @@
|
||||
=== tests/cases/compiler/aliasUsageInObjectLiteral_main.ts ===
|
||||
import Backbone = require("aliasUsageInObjectLiteral_backbone");
|
||||
>Backbone : typeof Backbone
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInObjectLiteral_main.ts,0,0))
|
||||
|
||||
import moduleA = require("aliasUsageInObjectLiteral_moduleA");
|
||||
>moduleA : typeof moduleA
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInObjectLiteral_main.ts,0,64))
|
||||
|
||||
interface IHasVisualizationModel {
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInObjectLiteral_main.ts,1,62))
|
||||
|
||||
VisualizationModel: typeof Backbone.Model;
|
||||
>VisualizationModel : typeof Backbone.Model
|
||||
>Backbone.Model : typeof Backbone.Model
|
||||
>Backbone : typeof Backbone
|
||||
>Model : typeof Backbone.Model
|
||||
>VisualizationModel : typeof Backbone.Model, Symbol(VisualizationModel,Decl(aliasUsageInObjectLiteral_main.ts,2,34))
|
||||
>Backbone.Model : typeof Backbone.Model, Symbol(Backbone.Model,Decl(aliasUsageInObjectLiteral_backbone.ts,0,0))
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInObjectLiteral_main.ts,0,0))
|
||||
>Model : typeof Backbone.Model, Symbol(Backbone.Model,Decl(aliasUsageInObjectLiteral_backbone.ts,0,0))
|
||||
}
|
||||
var a: { x: typeof moduleA } = { x: moduleA };
|
||||
>a : { x: typeof moduleA; }
|
||||
>x : typeof moduleA
|
||||
>moduleA : typeof moduleA
|
||||
>a : { x: typeof moduleA; }, Symbol(a,Decl(aliasUsageInObjectLiteral_main.ts,5,3))
|
||||
>x : typeof moduleA, Symbol(x,Decl(aliasUsageInObjectLiteral_main.ts,5,8))
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInObjectLiteral_main.ts,0,64))
|
||||
>{ x: moduleA } : { x: typeof moduleA; }
|
||||
>x : typeof moduleA
|
||||
>moduleA : typeof moduleA
|
||||
>x : typeof moduleA, Symbol(x,Decl(aliasUsageInObjectLiteral_main.ts,5,32))
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInObjectLiteral_main.ts,0,64))
|
||||
|
||||
var b: { x: IHasVisualizationModel } = { x: moduleA };
|
||||
>b : { x: IHasVisualizationModel; }
|
||||
>x : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>b : { x: IHasVisualizationModel; }, Symbol(b,Decl(aliasUsageInObjectLiteral_main.ts,6,3))
|
||||
>x : IHasVisualizationModel, Symbol(x,Decl(aliasUsageInObjectLiteral_main.ts,6,8))
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInObjectLiteral_main.ts,1,62))
|
||||
>{ x: moduleA } : { x: typeof moduleA; }
|
||||
>x : typeof moduleA
|
||||
>moduleA : typeof moduleA
|
||||
>x : typeof moduleA, Symbol(x,Decl(aliasUsageInObjectLiteral_main.ts,6,40))
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInObjectLiteral_main.ts,0,64))
|
||||
|
||||
var c: { y: { z: IHasVisualizationModel } } = { y: { z: moduleA } };
|
||||
>c : { y: { z: IHasVisualizationModel; }; }
|
||||
>y : { z: IHasVisualizationModel; }
|
||||
>z : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>c : { y: { z: IHasVisualizationModel; }; }, Symbol(c,Decl(aliasUsageInObjectLiteral_main.ts,7,3))
|
||||
>y : { z: IHasVisualizationModel; }, Symbol(y,Decl(aliasUsageInObjectLiteral_main.ts,7,8))
|
||||
>z : IHasVisualizationModel, Symbol(z,Decl(aliasUsageInObjectLiteral_main.ts,7,13))
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInObjectLiteral_main.ts,1,62))
|
||||
>{ y: { z: moduleA } } : { y: { z: typeof moduleA; }; }
|
||||
>y : { z: typeof moduleA; }
|
||||
>y : { z: typeof moduleA; }, Symbol(y,Decl(aliasUsageInObjectLiteral_main.ts,7,47))
|
||||
>{ z: moduleA } : { z: typeof moduleA; }
|
||||
>z : typeof moduleA
|
||||
>moduleA : typeof moduleA
|
||||
>z : typeof moduleA, Symbol(z,Decl(aliasUsageInObjectLiteral_main.ts,7,52))
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInObjectLiteral_main.ts,0,64))
|
||||
|
||||
=== tests/cases/compiler/aliasUsageInObjectLiteral_backbone.ts ===
|
||||
export class Model {
|
||||
>Model : Model
|
||||
>Model : Model, Symbol(Model,Decl(aliasUsageInObjectLiteral_backbone.ts,0,0))
|
||||
|
||||
public someData: string;
|
||||
>someData : string
|
||||
>someData : string, Symbol(someData,Decl(aliasUsageInObjectLiteral_backbone.ts,0,20))
|
||||
}
|
||||
|
||||
=== tests/cases/compiler/aliasUsageInObjectLiteral_moduleA.ts ===
|
||||
import Backbone = require("aliasUsageInObjectLiteral_backbone");
|
||||
>Backbone : typeof Backbone
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInObjectLiteral_moduleA.ts,0,0))
|
||||
|
||||
export class VisualizationModel extends Backbone.Model {
|
||||
>VisualizationModel : VisualizationModel
|
||||
>Backbone.Model : unknown
|
||||
>Backbone : typeof Backbone
|
||||
>Model : Backbone.Model
|
||||
>VisualizationModel : VisualizationModel, Symbol(VisualizationModel,Decl(aliasUsageInObjectLiteral_moduleA.ts,0,64))
|
||||
>Backbone.Model : any, Symbol(Backbone.Model,Decl(aliasUsageInObjectLiteral_backbone.ts,0,0))
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInObjectLiteral_moduleA.ts,0,0))
|
||||
>Model : Backbone.Model, Symbol(Backbone.Model,Decl(aliasUsageInObjectLiteral_backbone.ts,0,0))
|
||||
|
||||
// interesting stuff here
|
||||
}
|
||||
|
||||
@@ -1,87 +1,87 @@
|
||||
=== tests/cases/compiler/aliasUsageInOrExpression_main.ts ===
|
||||
import Backbone = require("aliasUsageInOrExpression_backbone");
|
||||
>Backbone : typeof Backbone
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInOrExpression_main.ts,0,0))
|
||||
|
||||
import moduleA = require("aliasUsageInOrExpression_moduleA");
|
||||
>moduleA : typeof moduleA
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInOrExpression_main.ts,0,63))
|
||||
|
||||
interface IHasVisualizationModel {
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInOrExpression_main.ts,1,61))
|
||||
|
||||
VisualizationModel: typeof Backbone.Model;
|
||||
>VisualizationModel : typeof Backbone.Model
|
||||
>Backbone.Model : typeof Backbone.Model
|
||||
>Backbone : typeof Backbone
|
||||
>Model : typeof Backbone.Model
|
||||
>VisualizationModel : typeof Backbone.Model, Symbol(VisualizationModel,Decl(aliasUsageInOrExpression_main.ts,2,34))
|
||||
>Backbone.Model : typeof Backbone.Model, Symbol(Backbone.Model,Decl(aliasUsageInOrExpression_backbone.ts,0,0))
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInOrExpression_main.ts,0,0))
|
||||
>Model : typeof Backbone.Model, Symbol(Backbone.Model,Decl(aliasUsageInOrExpression_backbone.ts,0,0))
|
||||
}
|
||||
var i: IHasVisualizationModel;
|
||||
>i : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>i : IHasVisualizationModel, Symbol(i,Decl(aliasUsageInOrExpression_main.ts,5,3))
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInOrExpression_main.ts,1,61))
|
||||
|
||||
var d1 = i || moduleA;
|
||||
>d1 : IHasVisualizationModel
|
||||
>d1 : IHasVisualizationModel, Symbol(d1,Decl(aliasUsageInOrExpression_main.ts,6,3))
|
||||
>i || moduleA : IHasVisualizationModel
|
||||
>i : IHasVisualizationModel
|
||||
>moduleA : typeof moduleA
|
||||
>i : IHasVisualizationModel, Symbol(i,Decl(aliasUsageInOrExpression_main.ts,5,3))
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInOrExpression_main.ts,0,63))
|
||||
|
||||
var d2: IHasVisualizationModel = i || moduleA;
|
||||
>d2 : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>d2 : IHasVisualizationModel, Symbol(d2,Decl(aliasUsageInOrExpression_main.ts,7,3),Decl(aliasUsageInOrExpression_main.ts,8,3))
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInOrExpression_main.ts,1,61))
|
||||
>i || moduleA : IHasVisualizationModel
|
||||
>i : IHasVisualizationModel
|
||||
>moduleA : typeof moduleA
|
||||
>i : IHasVisualizationModel, Symbol(i,Decl(aliasUsageInOrExpression_main.ts,5,3))
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInOrExpression_main.ts,0,63))
|
||||
|
||||
var d2: IHasVisualizationModel = moduleA || i;
|
||||
>d2 : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>d2 : IHasVisualizationModel, Symbol(d2,Decl(aliasUsageInOrExpression_main.ts,7,3),Decl(aliasUsageInOrExpression_main.ts,8,3))
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInOrExpression_main.ts,1,61))
|
||||
>moduleA || i : IHasVisualizationModel
|
||||
>moduleA : typeof moduleA
|
||||
>i : IHasVisualizationModel
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInOrExpression_main.ts,0,63))
|
||||
>i : IHasVisualizationModel, Symbol(i,Decl(aliasUsageInOrExpression_main.ts,5,3))
|
||||
|
||||
var e: { x: IHasVisualizationModel } = <{ x: IHasVisualizationModel }>null || { x: moduleA };
|
||||
>e : { x: IHasVisualizationModel; }
|
||||
>x : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>e : { x: IHasVisualizationModel; }, Symbol(e,Decl(aliasUsageInOrExpression_main.ts,9,3))
|
||||
>x : IHasVisualizationModel, Symbol(x,Decl(aliasUsageInOrExpression_main.ts,9,8))
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInOrExpression_main.ts,1,61))
|
||||
><{ x: IHasVisualizationModel }>null || { x: moduleA } : { x: IHasVisualizationModel; }
|
||||
><{ x: IHasVisualizationModel }>null : { x: IHasVisualizationModel; }
|
||||
>x : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>x : IHasVisualizationModel, Symbol(x,Decl(aliasUsageInOrExpression_main.ts,9,41))
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInOrExpression_main.ts,1,61))
|
||||
>null : null
|
||||
>{ x: moduleA } : { x: typeof moduleA; }
|
||||
>x : typeof moduleA
|
||||
>moduleA : typeof moduleA
|
||||
>x : typeof moduleA, Symbol(x,Decl(aliasUsageInOrExpression_main.ts,9,79))
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInOrExpression_main.ts,0,63))
|
||||
|
||||
var f: { x: IHasVisualizationModel } = <{ x: IHasVisualizationModel }>null ? { x: moduleA } : null;
|
||||
>f : { x: IHasVisualizationModel; }
|
||||
>x : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>f : { x: IHasVisualizationModel; }, Symbol(f,Decl(aliasUsageInOrExpression_main.ts,10,3))
|
||||
>x : IHasVisualizationModel, Symbol(x,Decl(aliasUsageInOrExpression_main.ts,10,8))
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInOrExpression_main.ts,1,61))
|
||||
><{ x: IHasVisualizationModel }>null ? { x: moduleA } : null : { x: typeof moduleA; }
|
||||
><{ x: IHasVisualizationModel }>null : { x: IHasVisualizationModel; }
|
||||
>x : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>x : IHasVisualizationModel, Symbol(x,Decl(aliasUsageInOrExpression_main.ts,10,41))
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInOrExpression_main.ts,1,61))
|
||||
>null : null
|
||||
>{ x: moduleA } : { x: typeof moduleA; }
|
||||
>x : typeof moduleA
|
||||
>moduleA : typeof moduleA
|
||||
>x : typeof moduleA, Symbol(x,Decl(aliasUsageInOrExpression_main.ts,10,78))
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInOrExpression_main.ts,0,63))
|
||||
>null : null
|
||||
|
||||
=== tests/cases/compiler/aliasUsageInOrExpression_backbone.ts ===
|
||||
export class Model {
|
||||
>Model : Model
|
||||
>Model : Model, Symbol(Model,Decl(aliasUsageInOrExpression_backbone.ts,0,0))
|
||||
|
||||
public someData: string;
|
||||
>someData : string
|
||||
>someData : string, Symbol(someData,Decl(aliasUsageInOrExpression_backbone.ts,0,20))
|
||||
}
|
||||
|
||||
=== tests/cases/compiler/aliasUsageInOrExpression_moduleA.ts ===
|
||||
import Backbone = require("aliasUsageInOrExpression_backbone");
|
||||
>Backbone : typeof Backbone
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInOrExpression_moduleA.ts,0,0))
|
||||
|
||||
export class VisualizationModel extends Backbone.Model {
|
||||
>VisualizationModel : VisualizationModel
|
||||
>Backbone.Model : unknown
|
||||
>Backbone : typeof Backbone
|
||||
>Model : Backbone.Model
|
||||
>VisualizationModel : VisualizationModel, Symbol(VisualizationModel,Decl(aliasUsageInOrExpression_moduleA.ts,0,63))
|
||||
>Backbone.Model : any, Symbol(Backbone.Model,Decl(aliasUsageInOrExpression_backbone.ts,0,0))
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInOrExpression_moduleA.ts,0,0))
|
||||
>Model : Backbone.Model, Symbol(Backbone.Model,Decl(aliasUsageInOrExpression_backbone.ts,0,0))
|
||||
|
||||
// interesting stuff here
|
||||
}
|
||||
|
||||
@@ -1,87 +1,87 @@
|
||||
=== tests/cases/compiler/aliasUsageInOrExpression_main.ts ===
|
||||
import Backbone = require("aliasUsageInOrExpression_backbone");
|
||||
>Backbone : typeof Backbone
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInOrExpression_main.ts,0,0))
|
||||
|
||||
import moduleA = require("aliasUsageInOrExpression_moduleA");
|
||||
>moduleA : typeof moduleA
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInOrExpression_main.ts,0,63))
|
||||
|
||||
interface IHasVisualizationModel {
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInOrExpression_main.ts,1,61))
|
||||
|
||||
VisualizationModel: typeof Backbone.Model;
|
||||
>VisualizationModel : typeof Backbone.Model
|
||||
>Backbone.Model : typeof Backbone.Model
|
||||
>Backbone : typeof Backbone
|
||||
>Model : typeof Backbone.Model
|
||||
>VisualizationModel : typeof Backbone.Model, Symbol(VisualizationModel,Decl(aliasUsageInOrExpression_main.ts,2,34))
|
||||
>Backbone.Model : typeof Backbone.Model, Symbol(Backbone.Model,Decl(aliasUsageInOrExpression_backbone.ts,0,0))
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInOrExpression_main.ts,0,0))
|
||||
>Model : typeof Backbone.Model, Symbol(Backbone.Model,Decl(aliasUsageInOrExpression_backbone.ts,0,0))
|
||||
}
|
||||
var i: IHasVisualizationModel;
|
||||
>i : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>i : IHasVisualizationModel, Symbol(i,Decl(aliasUsageInOrExpression_main.ts,5,3))
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInOrExpression_main.ts,1,61))
|
||||
|
||||
var d1 = i || moduleA;
|
||||
>d1 : typeof moduleA
|
||||
>d1 : typeof moduleA, Symbol(d1,Decl(aliasUsageInOrExpression_main.ts,6,3))
|
||||
>i || moduleA : typeof moduleA
|
||||
>i : IHasVisualizationModel
|
||||
>moduleA : typeof moduleA
|
||||
>i : IHasVisualizationModel, Symbol(i,Decl(aliasUsageInOrExpression_main.ts,5,3))
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInOrExpression_main.ts,0,63))
|
||||
|
||||
var d2: IHasVisualizationModel = i || moduleA;
|
||||
>d2 : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>d2 : IHasVisualizationModel, Symbol(d2,Decl(aliasUsageInOrExpression_main.ts,7,3),Decl(aliasUsageInOrExpression_main.ts,8,3))
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInOrExpression_main.ts,1,61))
|
||||
>i || moduleA : typeof moduleA
|
||||
>i : IHasVisualizationModel
|
||||
>moduleA : typeof moduleA
|
||||
>i : IHasVisualizationModel, Symbol(i,Decl(aliasUsageInOrExpression_main.ts,5,3))
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInOrExpression_main.ts,0,63))
|
||||
|
||||
var d2: IHasVisualizationModel = moduleA || i;
|
||||
>d2 : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>d2 : IHasVisualizationModel, Symbol(d2,Decl(aliasUsageInOrExpression_main.ts,7,3),Decl(aliasUsageInOrExpression_main.ts,8,3))
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInOrExpression_main.ts,1,61))
|
||||
>moduleA || i : typeof moduleA
|
||||
>moduleA : typeof moduleA
|
||||
>i : IHasVisualizationModel
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInOrExpression_main.ts,0,63))
|
||||
>i : IHasVisualizationModel, Symbol(i,Decl(aliasUsageInOrExpression_main.ts,5,3))
|
||||
|
||||
var e: { x: IHasVisualizationModel } = <{ x: IHasVisualizationModel }>null || { x: moduleA };
|
||||
>e : { x: IHasVisualizationModel; }
|
||||
>x : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>e : { x: IHasVisualizationModel; }, Symbol(e,Decl(aliasUsageInOrExpression_main.ts,9,3))
|
||||
>x : IHasVisualizationModel, Symbol(x,Decl(aliasUsageInOrExpression_main.ts,9,8))
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInOrExpression_main.ts,1,61))
|
||||
><{ x: IHasVisualizationModel }>null || { x: moduleA } : { x: IHasVisualizationModel; }
|
||||
><{ x: IHasVisualizationModel }>null : { x: IHasVisualizationModel; }
|
||||
>x : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>x : IHasVisualizationModel, Symbol(x,Decl(aliasUsageInOrExpression_main.ts,9,41))
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInOrExpression_main.ts,1,61))
|
||||
>null : null
|
||||
>{ x: moduleA } : { x: typeof moduleA; }
|
||||
>x : typeof moduleA
|
||||
>moduleA : typeof moduleA
|
||||
>x : typeof moduleA, Symbol(x,Decl(aliasUsageInOrExpression_main.ts,9,79))
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInOrExpression_main.ts,0,63))
|
||||
|
||||
var f: { x: IHasVisualizationModel } = <{ x: IHasVisualizationModel }>null ? { x: moduleA } : null;
|
||||
>f : { x: IHasVisualizationModel; }
|
||||
>x : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>f : { x: IHasVisualizationModel; }, Symbol(f,Decl(aliasUsageInOrExpression_main.ts,10,3))
|
||||
>x : IHasVisualizationModel, Symbol(x,Decl(aliasUsageInOrExpression_main.ts,10,8))
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInOrExpression_main.ts,1,61))
|
||||
><{ x: IHasVisualizationModel }>null ? { x: moduleA } : null : { x: typeof moduleA; }
|
||||
><{ x: IHasVisualizationModel }>null : { x: IHasVisualizationModel; }
|
||||
>x : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>x : IHasVisualizationModel, Symbol(x,Decl(aliasUsageInOrExpression_main.ts,10,41))
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInOrExpression_main.ts,1,61))
|
||||
>null : null
|
||||
>{ x: moduleA } : { x: typeof moduleA; }
|
||||
>x : typeof moduleA
|
||||
>moduleA : typeof moduleA
|
||||
>x : typeof moduleA, Symbol(x,Decl(aliasUsageInOrExpression_main.ts,10,78))
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInOrExpression_main.ts,0,63))
|
||||
>null : null
|
||||
|
||||
=== tests/cases/compiler/aliasUsageInOrExpression_backbone.ts ===
|
||||
export class Model {
|
||||
>Model : Model
|
||||
>Model : Model, Symbol(Model,Decl(aliasUsageInOrExpression_backbone.ts,0,0))
|
||||
|
||||
public someData: string;
|
||||
>someData : string
|
||||
>someData : string, Symbol(someData,Decl(aliasUsageInOrExpression_backbone.ts,0,20))
|
||||
}
|
||||
|
||||
=== tests/cases/compiler/aliasUsageInOrExpression_moduleA.ts ===
|
||||
import Backbone = require("aliasUsageInOrExpression_backbone");
|
||||
>Backbone : typeof Backbone
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInOrExpression_moduleA.ts,0,0))
|
||||
|
||||
export class VisualizationModel extends Backbone.Model {
|
||||
>VisualizationModel : VisualizationModel
|
||||
>Backbone.Model : unknown
|
||||
>Backbone : typeof Backbone
|
||||
>Model : Backbone.Model
|
||||
>VisualizationModel : VisualizationModel, Symbol(VisualizationModel,Decl(aliasUsageInOrExpression_moduleA.ts,0,63))
|
||||
>Backbone.Model : any, Symbol(Backbone.Model,Decl(aliasUsageInOrExpression_backbone.ts,0,0))
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInOrExpression_moduleA.ts,0,0))
|
||||
>Model : Backbone.Model, Symbol(Backbone.Model,Decl(aliasUsageInOrExpression_backbone.ts,0,0))
|
||||
|
||||
// interesting stuff here
|
||||
}
|
||||
|
||||
@@ -1,54 +1,54 @@
|
||||
=== tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_main.ts ===
|
||||
import Backbone = require("aliasUsageInTypeArgumentOfExtendsClause_backbone");
|
||||
>Backbone : typeof Backbone
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts,0,0))
|
||||
|
||||
import moduleA = require("aliasUsageInTypeArgumentOfExtendsClause_moduleA");
|
||||
>moduleA : typeof moduleA
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts,0,78))
|
||||
|
||||
interface IHasVisualizationModel {
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts,1,76))
|
||||
|
||||
VisualizationModel: typeof Backbone.Model;
|
||||
>VisualizationModel : typeof Backbone.Model
|
||||
>Backbone.Model : typeof Backbone.Model
|
||||
>Backbone : typeof Backbone
|
||||
>Model : typeof Backbone.Model
|
||||
>VisualizationModel : typeof Backbone.Model, Symbol(VisualizationModel,Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts,2,34))
|
||||
>Backbone.Model : typeof Backbone.Model, Symbol(Backbone.Model,Decl(aliasUsageInTypeArgumentOfExtendsClause_backbone.ts,0,0))
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts,0,0))
|
||||
>Model : typeof Backbone.Model, Symbol(Backbone.Model,Decl(aliasUsageInTypeArgumentOfExtendsClause_backbone.ts,0,0))
|
||||
}
|
||||
class C<T extends IHasVisualizationModel> {
|
||||
>C : C<T>
|
||||
>T : T
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>C : C<T>, Symbol(C,Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts,4,1))
|
||||
>T : T, Symbol(T,Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts,5,8))
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts,1,76))
|
||||
|
||||
x: T;
|
||||
>x : T
|
||||
>T : T
|
||||
>x : T, Symbol(x,Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts,5,43))
|
||||
>T : T, Symbol(T,Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts,5,8))
|
||||
}
|
||||
class D extends C<IHasVisualizationModel> {
|
||||
>D : D
|
||||
>C : C<T>
|
||||
>IHasVisualizationModel : IHasVisualizationModel
|
||||
>D : D, Symbol(D,Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts,7,1))
|
||||
>C : C<T>, Symbol(C,Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts,4,1))
|
||||
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel,Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts,1,76))
|
||||
|
||||
x = moduleA;
|
||||
>x : typeof moduleA
|
||||
>moduleA : typeof moduleA
|
||||
>x : typeof moduleA, Symbol(x,Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts,8,43))
|
||||
>moduleA : typeof moduleA, Symbol(moduleA,Decl(aliasUsageInTypeArgumentOfExtendsClause_main.ts,0,78))
|
||||
}
|
||||
=== tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_backbone.ts ===
|
||||
export class Model {
|
||||
>Model : Model
|
||||
>Model : Model, Symbol(Model,Decl(aliasUsageInTypeArgumentOfExtendsClause_backbone.ts,0,0))
|
||||
|
||||
public someData: string;
|
||||
>someData : string
|
||||
>someData : string, Symbol(someData,Decl(aliasUsageInTypeArgumentOfExtendsClause_backbone.ts,0,20))
|
||||
}
|
||||
|
||||
=== tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_moduleA.ts ===
|
||||
import Backbone = require("aliasUsageInTypeArgumentOfExtendsClause_backbone");
|
||||
>Backbone : typeof Backbone
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInTypeArgumentOfExtendsClause_moduleA.ts,0,0))
|
||||
|
||||
export class VisualizationModel extends Backbone.Model {
|
||||
>VisualizationModel : VisualizationModel
|
||||
>Backbone.Model : unknown
|
||||
>Backbone : typeof Backbone
|
||||
>Model : Backbone.Model
|
||||
>VisualizationModel : VisualizationModel, Symbol(VisualizationModel,Decl(aliasUsageInTypeArgumentOfExtendsClause_moduleA.ts,0,78))
|
||||
>Backbone.Model : any, Symbol(Backbone.Model,Decl(aliasUsageInTypeArgumentOfExtendsClause_backbone.ts,0,0))
|
||||
>Backbone : typeof Backbone, Symbol(Backbone,Decl(aliasUsageInTypeArgumentOfExtendsClause_moduleA.ts,0,0))
|
||||
>Model : Backbone.Model, Symbol(Backbone.Model,Decl(aliasUsageInTypeArgumentOfExtendsClause_backbone.ts,0,0))
|
||||
|
||||
// interesting stuff here
|
||||
}
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user