File: sourceMapValidationClasses.types

package info (click to toggle)
node-typescript 3.3.3333-1
  • links: PTS, VCS
  • area: main
  • in suites: buster
  • size: 324,548 kB
  • sloc: makefile: 6; sh: 3
file content (127 lines) | stat: -rw-r--r-- 2,974 bytes parent folder | download | duplicates (5)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
=== tests/cases/compiler/sourceMapValidationClasses.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): Greeter {
>foo : (greeting: string) => Greeter
>greeting : string

        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 /* more greeting */: string[]) {
>foo2 : (greeting: string, ...restGreetings: string[]) => Greeter[]
>greeting : string
>restGreetings : string[]

        var greeters: Greeter[] = []; /* inline block comment */
>greeters : 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"
>"!" : "!"

    // This is simple signle line comment
    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
    }
}