Skip to content
Navigation Menu
{{ message }}
-
Notifications
You must be signed in to change notification settings - Fork 16
Expand file tree
/
Copy pathfunction.ts
More file actions
349 lines (292 loc) · 9.39 KB
/
Copy pathfunction.ts
File metadata and controls
349 lines (292 loc) · 9.39 KB
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
import { Next, ToString } from "./types";
import { quoteKey, isValidVariableName } from "./quote";
/**
* Used in function stringification.
*/
/* istanbul ignore next */
const METHOD_NAMES_ARE_QUOTED =
{
" "() {
/* Empty. */
},
}[" "]
.toString()
.charAt(0) === '"';
const FUNCTION_PREFIXES = {
Function: "function ",
GeneratorFunction: "function* ",
AsyncFunction: "async function ",
AsyncGeneratorFunction: "async function* ",
};
const METHOD_PREFIXES = {
Function: "",
GeneratorFunction: "*",
AsyncFunction: "async ",
AsyncGeneratorFunction: "async *",
};
const TOKENS_PRECEDING_REGEXPS = new Set(
(
"case delete else in instanceof new return throw typeof void " +
", ; : + - ! ~ & | ^ * / % < > ? ="
).split(" "),
);
/**
* Track function parser usage.
*/
export const USED_METHOD_KEY = new WeakSet<(...args: unknown[]) => unknown>();
/**
* Stringify a function.
*/
export const functionToString: ToString = (fn, space, next, key) => {
const name = typeof key === "string" ? key : undefined;
// Track in function parser for object stringify to avoid duplicate output.
if (name !== undefined) USED_METHOD_KEY.add(fn);
return new FunctionParser(fn, space, next, name).stringify();
};
/**
* Rewrite a stringified function to remove initial indentation.
*/
export function dedentFunction(fnString: string) {
let found: string | undefined;
for (const line of fnString.split("\n").slice(1)) {
const m = /^[\s\t]+/.exec(line);
if (!m) return fnString; // Early exit without indent.
const [str] = m;
if (found === undefined) found = str;
else if (str.length < found.length) found = str;
}
return found ? fnString.split(`\n${found}`).join("\n") : fnString;
}
/**
* Function parser and stringify.
*/
export class FunctionParser {
fnString: string;
fnType: keyof typeof FUNCTION_PREFIXES;
keyQuote: string | undefined;
keyPrefix: string;
isMethodCandidate: boolean;
pos = 0;
hadKeyword = false;
constructor(
public fn: (...args: unknown[]) => unknown,
public indent: string,
public next: Next,
public key?: string,
) {
this.fnString = Function.prototype.toString.call(fn);
this.fnType = fn.constructor.name as keyof typeof FUNCTION_PREFIXES;
this.keyQuote = key === undefined ? "" : quoteKey(key, next);
this.keyPrefix =
key === undefined ? "" : `${this.keyQuote}:${indent ? " " : ""}`;
this.isMethodCandidate =
key === undefined ? false : this.fn.name === "" || this.fn.name === key;
}
stringify() {
const value = this.tryParse();
// If we can't stringify this function, return a void expression; for
// bonus help with debugging, include the function as a string literal.
if (!value) {
return `${this.keyPrefix}void ${this.next(this.fnString)}`;
}
return dedentFunction(value);
}
getPrefix() {
if (this.isMethodCandidate && !this.hadKeyword) {
return METHOD_PREFIXES[this.fnType] + this.keyQuote;
}
return this.keyPrefix + FUNCTION_PREFIXES[this.fnType];
}
tryParse() {
if (this.fnString[this.fnString.length - 1] !== "}") {
// Must be an arrow function.
return this.keyPrefix + this.fnString;
}
// Attempt to remove function prefix.
if (this.fn.name) {
const result = this.tryStrippingName();
if (result) return result;
}
// Support class expressions.
const prevPos = this.pos;
if (this.consumeSyntax() === "class") return this.fnString;
this.pos = prevPos;
if (this.tryParsePrefixTokens()) {
const result = this.tryStrippingName();
if (result) return result;
let offset = this.pos;
switch (this.consumeSyntax("WORD_LIKE")) {
case "WORD_LIKE":
if (this.isMethodCandidate && !this.hadKeyword) {
offset = this.pos;
}
case "()":
if (this.fnString.substr(this.pos, 2) === "=>") {
return this.keyPrefix + this.fnString;
}
this.pos = offset;
case '"':
case "'":
case "[]":
return this.getPrefix() + this.fnString.substr(this.pos);
}
}
}
/**
* Attempt to parse the function from the current position by first stripping
* the function's name from the front. This is not a fool-proof method on all
* JavaScript engines, but yields good results on Node.js 4 (and slightly
* less good results on Node.js 6 and 8).
*/
tryStrippingName() {
if (METHOD_NAMES_ARE_QUOTED) {
// ... then this approach is unnecessary and yields false positives.
return;
}
let start = this.pos;
const prefix = this.fnString.substr(this.pos, this.fn.name.length);
if (prefix === this.fn.name) {
this.pos += prefix.length;
if (
this.consumeSyntax() === "()" &&
this.consumeSyntax() === "{}" &&
this.pos === this.fnString.length
) {
// Don't include the function's name if it will be included in the
// prefix, or if it's invalid as a name in a function expression.
if (this.isMethodCandidate || !isValidVariableName(prefix)) {
start += prefix.length;
}
return this.getPrefix() + this.fnString.substr(start);
}
}
this.pos = start;
}
/**
* Attempt to advance the parser past the keywords expected to be at the
* start of this function's definition. This method sets `this.hadKeyword`
* based on whether or not a `function` keyword is consumed.
*/
tryParsePrefixTokens(): boolean {
let posPrev = this.pos;
this.hadKeyword = false;
switch (this.fnType) {
case "AsyncFunction":
if (this.consumeSyntax() !== "async") return false;
posPrev = this.pos;
case "Function":
if (this.consumeSyntax() === "function") {
this.hadKeyword = true;
} else {
this.pos = posPrev;
}
return true;
case "AsyncGeneratorFunction":
if (this.consumeSyntax() !== "async") return false;
case "GeneratorFunction":
let token = this.consumeSyntax();
if (token === "function") {
token = this.consumeSyntax();
this.hadKeyword = true;
}
return token === "*";
}
}
/**
* Advance the parser past one element of JavaScript syntax. This could be a
* matched pair of delimiters, like braces or parentheses, or an atomic unit
* like a keyword, variable, or operator. Return a normalized string
* representation of the element parsed--for example, returns '{}' for a
* matched pair of braces. Comments and whitespace are skipped.
*
* (This isn't a full parser, so the token scanning logic used here is as
* simple as it can be. As a consequence, some things that are one token in
* JavaScript, like decimal number literals or most multi-character operators
* like '&&', are split into more than one token here. However, awareness of
* some multi-character sequences like '=>' is necessary, so we match the few
* of them that we care about.)
*/
consumeSyntax(wordLikeToken?: string) {
const m = this.consumeMatch(
/^(?:([A-Za-z_0-9$\xA0-\uFFFF]+)|=>|\+\+|\-\-|.)/,
);
if (!m) return;
const [token, match] = m;
this.consumeWhitespace();
if (match) return wordLikeToken || match;
switch (token) {
case "(":
return this.consumeSyntaxUntil("(", ")");
case "[":
return this.consumeSyntaxUntil("[", "]");
case "{":
return this.consumeSyntaxUntil("{", "}");
case "`":
return this.consumeTemplate();
case '"':
return this.consumeRegExp(/^(?:[^\\"]|\\.)*"/, '"');
case "'":
return this.consumeRegExp(/^(?:[^\\']|\\.)*'/, "'");
}
return token;
}
consumeSyntaxUntil(startToken: string, endToken: string): string | undefined {
let isRegExpAllowed = true;
for (;;) {
const token = this.consumeSyntax();
if (token === endToken) return startToken + endToken;
if (!token || token === ")" || token === "]" || token === "}") return;
if (
token === "/" &&
isRegExpAllowed &&
this.consumeMatch(/^(?:\\.|[^\\\/\n[]|\[(?:\\.|[^\]])*\])+\/[a-z]*/)
) {
isRegExpAllowed = false;
this.consumeWhitespace();
} else {
isRegExpAllowed = TOKENS_PRECEDING_REGEXPS.has(token);
}
}
}
consumeMatch(re: RegExp) {
const m = re.exec(this.fnString.substr(this.pos));
if (m) this.pos += m[0].length;
return m;
}
/**
* Advance the parser past an arbitrary regular expression. Return `token`,
* or the match object of the regexp.
*/
consumeRegExp(re: RegExp, token: string): string | undefined {
const m = re.exec(this.fnString.substr(this.pos));
if (!m) return;
this.pos += m[0].length;
this.consumeWhitespace();
return token;
}
/**
* Advance the parser past a template string.
*/
consumeTemplate() {
for (;;) {
this.consumeMatch(/^(?:[^`$\\]|\\.|\$(?!{))*/);
if (this.fnString[this.pos] === "`") {
this.pos++;
this.consumeWhitespace();
return "`";
}
if (this.fnString.substr(this.pos, 2) === "${") {
this.pos += 2;
this.consumeWhitespace();
if (this.consumeSyntaxUntil("{", "}")) continue;
}
return;
}
}
/**
* Advance the parser past any whitespace or comments.
*/
consumeWhitespace() {
this.consumeMatch(/^(?:\s|\/\/.*|\/\*[^]*?\*\/)*/);
}
}
You can’t perform that action at this time.