File: jsdocInTypeScript.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 (113 lines) | stat: -rw-r--r-- 2,340 bytes parent folder | download | duplicates (2)
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
=== tests/cases/compiler/jsdocInTypeScript.ts ===
// JSDoc typedef tags are not bound TypeScript files.
/** @typedef {function} T */
declare const x: T;
>x : T

class T {
>T : T

    prop: number;
>prop : number
}

x.prop;
>x.prop : number
>x : T
>prop : number

// Just to be sure that @property has no impact either.
/**
 * @typedef {Object} MyType
 * @property {string} yes
 */
declare const myType: MyType; // should error, no such type
>myType : any

// @param type has no effect.
/**
 * @param {number} x
 * @returns string
 */
function f(x: boolean) { return x * 2; } // Should error
>f : (x: boolean) => number
>x : boolean
>x * 2 : number
>x : boolean
>2 : 2

// Should fail, because it takes a boolean and returns a number
f(1); f(true).length;
>f(1) : number
>f : (x: boolean) => number
>1 : 1
>f(true).length : any
>f(true) : number
>f : (x: boolean) => number
>true : true
>length : any

// @type has no effect either.
/** @type {{ x?: number }} */
const z = {};
>z : {}
>{} : {}

z.x = 1; // Error
>z.x = 1 : 1
>z.x : any
>z : {}
>x : any
>1 : 1

// @template tag should not interfere with constraint or default.
/** @template T */
interface I<T extends number = 0> {}

/** @template T */
function tem<T extends number>(t: T): I<T> { return {}; }
>tem : <T extends number>(t: T) => I<T>
>t : T
>{} : {}

let i: I; // Should succeed thanks to type parameter default
>i : I<0>

/** @typedef {string} N.Str */
import M = N; // Error: @typedef does not create namespaces in TypeScript code.
>M : any
>N : any

// Not legal JSDoc, but that shouldn't matter in TypeScript.
/**
 * @type {{foo: (function(string, string): string)}}
 */
const obj = { foo: (a, b) => a + b };
>obj : { foo: (a: any, b: any) => any; }
>{ foo: (a, b) => a + b } : { foo: (a: any, b: any) => any; }
>foo : (a: any, b: any) => any
>(a, b) => a + b : (a: any, b: any) => any
>a : any
>b : any
>a + b : any
>a : any
>b : any

/** @enum {string} */
var E = {};
>E : {}
>{} : {}

E[""];
>E[""] : any
>E : {}
>"" : ""

// make sure import types in JSDoc are not resolved
/** @type {import("should-not-be-resolved").Type} */
var v = import(String());
>v : Promise<any>
>import(String()) : Promise<any>
>String() : string
>String : StringConstructor