5353475fce
* Always generate type & symbol baselines * Accept changed shadowed baselines * Accept brand new type and symbol baselines * Allow `getTypeAtLocation` to return undefined in the type writer * Accept baselines which had missing type information * Bind container for dynamically names enum members so they may be printed * Accept type/symbol baselines for enums with computed members * First pass at reducing typeWriter memory overhead * Use generators to allow for type and symbol baselines with no cache * Accept new baselines for tests whose output was fixed by better newline splitting * Hard cap on number of declarations printed, cache declaration print text * handle differing newlines better still to handle RWC newlines * Lower abridging count, accept abridged baselines * Limit max RWC error output size, limit RWC type and symbol baseline input size * Move skip logic into type and symbol baseliner to streamline error handling * Accept removal of empty baselines * Canonicalize path earlier to handle odd paths in input files * Do canonicalization earlier still, also ensure parallel perf profiles for different targets do not trample one another * No need to pathify again
131 lines
2.9 KiB
Plaintext
131 lines
2.9 KiB
Plaintext
=== tests/cases/compiler/sourceMapSample.ts ===
|
|
module Foo.Bar {
|
|
>Foo : typeof Foo
|
|
>Bar : typeof Bar
|
|
|
|
"use strict";
|
|
>"use strict" : "use strict"
|
|
|
|
class Greeter {
|
|
>Greeter : Greeter
|
|
|
|
constructor(public greeting: string) {
|
|
>greeting : string
|
|
}
|
|
|
|
greet() {
|
|
>greet : () => string
|
|
|
|
return "<h1>" + this.greeting + "</h1>";
|
|
>"<h1>" + this.greeting + "</h1>" : string
|
|
>"<h1>" + this.greeting : string
|
|
>"<h1>" : "<h1>"
|
|
>this.greeting : string
|
|
>this : this
|
|
>greeting : string
|
|
>"</h1>" : "</h1>"
|
|
}
|
|
}
|
|
|
|
|
|
function foo(greeting: string): Foo.Bar.Greeter {
|
|
>foo : (greeting: string) => any
|
|
>greeting : string
|
|
>Foo : any
|
|
>Bar : any
|
|
>Greeter : No type information available!
|
|
|
|
return new Greeter(greeting);
|
|
>new Greeter(greeting) : Greeter
|
|
>Greeter : typeof Greeter
|
|
>greeting : string
|
|
}
|
|
|
|
var greeter = new Greeter("Hello, world!");
|
|
>greeter : Greeter
|
|
>new Greeter("Hello, world!") : Greeter
|
|
>Greeter : typeof Greeter
|
|
>"Hello, world!" : "Hello, world!"
|
|
|
|
var str = greeter.greet();
|
|
>str : string
|
|
>greeter.greet() : string
|
|
>greeter.greet : () => string
|
|
>greeter : Greeter
|
|
>greet : () => string
|
|
|
|
function foo2(greeting: string, ...restGreetings: string[]) {
|
|
>foo2 : (greeting: string, ...restGreetings: string[]) => Greeter[]
|
|
>greeting : string
|
|
>restGreetings : string[]
|
|
|
|
var greeters: Greeter[] = [];
|
|
>greeters : Greeter[]
|
|
>Greeter : Greeter
|
|
>[] : undefined[]
|
|
|
|
greeters[0] = new Greeter(greeting);
|
|
>greeters[0] = new Greeter(greeting) : Greeter
|
|
>greeters[0] : Greeter
|
|
>greeters : Greeter[]
|
|
>0 : 0
|
|
>new Greeter(greeting) : Greeter
|
|
>Greeter : typeof Greeter
|
|
>greeting : string
|
|
|
|
for (var i = 0; i < restGreetings.length; i++) {
|
|
>i : number
|
|
>0 : 0
|
|
>i < restGreetings.length : boolean
|
|
>i : number
|
|
>restGreetings.length : number
|
|
>restGreetings : string[]
|
|
>length : number
|
|
>i++ : number
|
|
>i : number
|
|
|
|
greeters.push(new Greeter(restGreetings[i]));
|
|
>greeters.push(new Greeter(restGreetings[i])) : number
|
|
>greeters.push : (...items: Greeter[]) => number
|
|
>greeters : Greeter[]
|
|
>push : (...items: Greeter[]) => number
|
|
>new Greeter(restGreetings[i]) : Greeter
|
|
>Greeter : typeof Greeter
|
|
>restGreetings[i] : string
|
|
>restGreetings : string[]
|
|
>i : number
|
|
}
|
|
|
|
return greeters;
|
|
>greeters : Greeter[]
|
|
}
|
|
|
|
var b = foo2("Hello", "World", "!");
|
|
>b : Greeter[]
|
|
>foo2("Hello", "World", "!") : Greeter[]
|
|
>foo2 : (greeting: string, ...restGreetings: string[]) => Greeter[]
|
|
>"Hello" : "Hello"
|
|
>"World" : "World"
|
|
>"!" : "!"
|
|
|
|
for (var j = 0; j < b.length; j++) {
|
|
>j : number
|
|
>0 : 0
|
|
>j < b.length : boolean
|
|
>j : number
|
|
>b.length : number
|
|
>b : Greeter[]
|
|
>length : number
|
|
>j++ : number
|
|
>j : number
|
|
|
|
b[j].greet();
|
|
>b[j].greet() : string
|
|
>b[j].greet : () => string
|
|
>b[j] : Greeter
|
|
>b : Greeter[]
|
|
>j : number
|
|
>greet : () => string
|
|
}
|
|
}
|