Skip to content

Commit 5e0160b

Browse files
rbucktonrbuckton
committed
Reduce number of helpers
1 parent 30aff2f commit 5e0160b

31 files changed

Lines changed: 1041 additions & 852 deletions

‎src/compiler/factory.ts‎

Lines changed: 22 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -1750,7 +1750,16 @@ namespace ts {
17501750
name: "typescript:values",
17511751
scoped: false,
17521752
text: `
1753-
var __values = (this && this.__values) || function (o) { return (i = typeof Symbol === "function" && o[Symbol.iterator] || 0) ? i.call(o) : { next: function () { return { done: d = d || i >= o.length, value: d ? void 0 : o[i++] }; } }; var i, d; };
1753+
var __values = (this && this.__values) || function (o) {
1754+
var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
1755+
if (m) return m.call(o);
1756+
return {
1757+
next: function () {
1758+
if (o && i >= o.length) o = void 0;
1759+
return { value: o && o[i++], done: !o };
1760+
}
1761+
};
1762+
};
17541763
`
17551764
};
17561765

@@ -1764,52 +1773,24 @@ namespace ts {
17641773
);
17651774
}
17661775

1767-
const stepHelper: EmitHelper = {
1768-
name: "typescript:step",
1769-
scoped: false,
1770-
text: `
1771-
var __step = (this && this.__step) || function (r) { return !(r.done || (r.done = (r.result = r.iterator.next()).done)); };
1772-
`
1773-
};
1774-
1775-
export function createStepHelper(context: TransformationContext, iteratorRecord: Expression, location?: TextRange) {
1776-
context.requestEmitHelper(stepHelper);
1777-
return createCall(
1778-
getHelperName("__step"),
1779-
/*typeArguments*/ undefined,
1780-
[iteratorRecord],
1781-
location
1782-
);
1783-
}
1784-
1785-
const closeHelper: EmitHelper = {
1786-
name: "typescript:close",
1787-
scoped: false,
1788-
text: `
1789-
var __close = (this && this.__close) || function (r) { return (m = !(r && r.done) && r.iterator["return"]) && m.call(r.iterator); var m; };
1790-
`
1791-
};
1792-
1793-
export function createCloseHelper(context: TransformationContext, iteratorRecord: Expression, location?: TextRange) {
1794-
context.requestEmitHelper(closeHelper);
1795-
return createCall(
1796-
getHelperName("__close"),
1797-
/*typeArguments*/ undefined,
1798-
[iteratorRecord],
1799-
location
1800-
);
1801-
}
1802-
18031776
const readHelper: EmitHelper = {
18041777
name: "typescript:read",
18051778
scoped: false,
18061779
text: `
18071780
var __read = (this && this.__read) || function (o, n) {
1808-
if (!(m = typeof Symbol === "function" && o[Symbol.iterator])) return o;
1809-
var m, i = m.call(o), ar = [], r, e;
1810-
try { while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); }
1781+
var m = typeof Symbol === "function" && o[Symbol.iterator];
1782+
if (!m) return o;
1783+
var i = m.call(o), r, ar = [], e;
1784+
try {
1785+
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
1786+
}
18111787
catch (error) { e = { error: error }; }
1812-
finally { try { if (m = !(r && r.done) && i["return"]) m.call(i); } finally { if (e) throw e.error; } }
1788+
finally {
1789+
try {
1790+
if (r && !r.done && (m = i["return"])) m.call(i);
1791+
}
1792+
finally { if (e) throw e.error; }
1793+
}
18131794
return ar;
18141795
};
18151796
`

‎src/compiler/transformers/es2015.ts‎

Lines changed: 89 additions & 123 deletions
Original file line numberDiff line numberDiff line change
@@ -2202,7 +2202,8 @@ namespace ts {
22022202
compilerOptions.downlevelIteration ? convertForOfStatementForIterable : convertForOfStatementForArray);
22032203
}
22042204

2205-
function convertForOfStatementHead(statements: Statement[], node: ForOfStatement, boundValue: Expression, convertedLoopBodyStatements: Statement[]) {
2205+
function convertForOfStatementHead(node: ForOfStatement, boundValue: Expression, convertedLoopBodyStatements: Statement[]) {
2206+
const statements: Statement[] = [];
22062207
if (isVariableDeclarationList(node.initializer)) {
22072208
if (node.initializer.flags & NodeFlags.BlockScoped) {
22082209
enableSubstitutionsForBlockScopedBindings();
@@ -2291,72 +2292,16 @@ namespace ts {
22912292
}
22922293
}
22932294

2294-
return { bodyLocation, statementsLocation };
2295-
}
2296-
2297-
function convertForOfStatementForIterable(node: ForOfStatement, outermostLabeledStatement: LabeledStatement, convertedLoopBodyStatements: Statement[]): Statement {
2298-
const expression = visitNode(node.expression, visitor, isExpression);
2299-
const iteratorRecord = isIdentifier(node.expression)
2300-
? getGeneratedNameForNode(node.expression)
2301-
: createUniqueName("iterator");
2302-
2303-
const statements: Statement[] = [];
2304-
const { bodyLocation, statementsLocation } = convertForOfStatementHead(
2305-
statements,
2306-
node,
2307-
createPropertyAccess(
2308-
createPropertyAccess(iteratorRecord, "result"),
2309-
"value"
2310-
),
2311-
convertedLoopBodyStatements);
2312-
2313-
let statement: Statement = setEmitFlags(
2314-
createFor(
2315-
createVariableDeclarationList(
2316-
[
2317-
createVariableDeclaration(
2318-
iteratorRecord,
2319-
/*type*/ undefined,
2320-
createObjectLiteral(
2321-
[
2322-
createPropertyAssignment(
2323-
"iterator",
2324-
createValuesHelper(
2325-
context,
2326-
expression,
2327-
node.expression
2328-
),
2329-
node.expression
2330-
)
2331-
],
2332-
node.expression
2333-
),
2334-
node.expression
2335-
)
2336-
],
2337-
node.expression
2338-
),
2339-
/*condition*/ createStepHelper(
2340-
context,
2341-
iteratorRecord,
2342-
node.initializer
2343-
),
2344-
/*incrementor*/ undefined,
2345-
setEmitFlags(
2346-
createBlock(
2347-
createNodeArray(statements, statementsLocation),
2348-
bodyLocation,
2349-
/*multiLine*/ true
2350-
),
2351-
EmitFlags.NoSourceMap | EmitFlags.NoTokenSourceMaps
2352-
),
2353-
/*location*/ node
2295+
// The old emitter does not emit source maps for the block.
2296+
// We add the location to preserve comments.
2297+
return setEmitFlags(
2298+
createBlock(
2299+
createNodeArray(statements, /*location*/ statementsLocation),
2300+
/*location*/ bodyLocation,
2301+
/*multiLine*/ true
23542302
),
2355-
EmitFlags.NoTokenTrailingSourceMaps
2303+
EmitFlags.NoSourceMap | EmitFlags.NoTokenSourceMaps
23562304
);
2357-
2358-
statement = restoreEnclosingLabel(statement, outermostLabeledStatement);
2359-
return closeIterator(statement, iteratorRecord);
23602305
}
23612306

23622307
function convertForOfStatementForArray(node: ForOfStatement, outermostLabeledStatement: LabeledStatement, convertedLoopBodyStatements: Statement[]): Statement {
@@ -2382,51 +2327,37 @@ namespace ts {
23822327
// for-of bodies are always emitted as blocks.
23832328

23842329
const expression = visitNode(node.expression, visitor, isExpression);
2385-
const statements: Statement[] = [];
23862330

23872331
// In the case where the user wrote an identifier as the RHS, like this:
23882332
//
23892333
// for (let v of arr) { }
23902334
//
23912335
// we don't want to emit a temporary variable for the RHS, just use it directly.
23922336
const counter = createLoopVariable();
2393-
const rhsReference = expression.kind === SyntaxKind.Identifier
2394-
? createUniqueName((<Identifier>expression).text)
2395-
: createTempVariable(/*recordTempVariable*/ undefined);
2396-
2397-
const { bodyLocation, statementsLocation } = convertForOfStatementHead(
2398-
statements,
2399-
node,
2400-
createElementAccess(rhsReference, counter),
2401-
convertedLoopBodyStatements);
2337+
const rhsReference = isIdentifier(expression) ? getGeneratedNameForNode(expression) : createTempVariable(/*recordTempVariable*/ undefined);
24022338

24032339
// The old emitter does not emit source maps for the expression
24042340
setEmitFlags(expression, EmitFlags.NoSourceMap | getEmitFlags(expression));
24052341

2406-
// The old emitter does not emit source maps for the block.
2407-
// We add the location to preserve comments.
2408-
const body = createBlock(
2409-
createNodeArray(statements, /*location*/ statementsLocation),
2410-
/*location*/ bodyLocation
2411-
);
2412-
2413-
setEmitFlags(body, EmitFlags.NoSourceMap | EmitFlags.NoTokenSourceMaps);
2414-
24152342
const forStatement = createFor(
2416-
setEmitFlags(
2343+
/*initializer*/ setEmitFlags(
24172344
createVariableDeclarationList([
24182345
createVariableDeclaration(counter, /*type*/ undefined, createLiteral(0), /*location*/ moveRangePos(node.expression, -1)),
24192346
createVariableDeclaration(rhsReference, /*type*/ undefined, expression, /*location*/ node.expression)
24202347
], /*location*/ node.expression),
24212348
EmitFlags.NoHoisting
24222349
),
2423-
createLessThan(
2350+
/*condition*/ createLessThan(
24242351
counter,
24252352
createPropertyAccess(rhsReference, "length"),
24262353
/*location*/ node.expression
24272354
),
2428-
createPostfixIncrement(counter, /*location*/ node.expression),
2429-
body,
2355+
/*incrementor*/ createPostfixIncrement(counter, /*location*/ node.expression),
2356+
/*statement*/ convertForOfStatementHead(
2357+
node,
2358+
createElementAccess(rhsReference, counter),
2359+
convertedLoopBodyStatements
2360+
),
24302361
/*location*/ node
24312362
);
24322363

@@ -2435,14 +2366,47 @@ namespace ts {
24352366
return restoreEnclosingLabel(forStatement, outermostLabeledStatement, convertedLoopState && resetLabel);
24362367
}
24372368

2438-
function closeIterator(statement: Statement, iteratorRecord: Expression) {
2369+
function convertForOfStatementForIterable(node: ForOfStatement, outermostLabeledStatement: LabeledStatement, convertedLoopBodyStatements: Statement[]): Statement {
2370+
const expression = visitNode(node.expression, visitor, isExpression);
2371+
const iterator = isIdentifier(expression) ? getGeneratedNameForNode(expression) : createTempVariable(/*recordTempVariable*/ undefined);
2372+
const result = isIdentifier(expression) ? getGeneratedNameForNode(iterator) : createTempVariable(/*recordTempVariable*/ undefined);
24392373
const errorRecord = createUniqueName("e");
2440-
hoistVariableDeclaration(errorRecord);
24412374
const catchVariable = getGeneratedNameForNode(errorRecord);
2375+
const returnMethod = createTempVariable(/*recordTempVariable*/ undefined);
2376+
const values = createValuesHelper(context, expression, node.expression);
2377+
const next = createCall(createPropertyAccess(iterator, "next" ), /*typeArguments*/ undefined, []);
2378+
2379+
hoistVariableDeclaration(errorRecord);
2380+
hoistVariableDeclaration(returnMethod);
2381+
2382+
const forStatement = setEmitFlags(
2383+
createFor(
2384+
/*initializer*/ setEmitFlags(
2385+
createVariableDeclarationList([
2386+
createVariableDeclaration(iterator, /*type*/ undefined, values, /*location*/ node.expression),
2387+
createVariableDeclaration(result, /*type*/ undefined, next)
2388+
], /*location*/ node.expression),
2389+
EmitFlags.NoHoisting
2390+
),
2391+
/*condition*/ createLogicalNot(createPropertyAccess(result, "done")),
2392+
/*incrementor*/ createAssignment(result, next),
2393+
/*statement*/ convertForOfStatementHead(
2394+
node,
2395+
createPropertyAccess(result, "value"),
2396+
convertedLoopBodyStatements
2397+
),
2398+
/*location*/ node
2399+
),
2400+
EmitFlags.NoTokenTrailingSourceMaps
2401+
);
24422402

24432403
return createTry(
24442404
createBlock([
2445-
statement
2405+
restoreEnclosingLabel(
2406+
forStatement,
2407+
outermostLabeledStatement,
2408+
convertedLoopState && resetLabel
2409+
)
24462410
]),
24472411
createCatchClause(catchVariable,
24482412
setEmitFlags(
@@ -2451,10 +2415,7 @@ namespace ts {
24512415
createAssignment(
24522416
errorRecord,
24532417
createObjectLiteral([
2454-
createPropertyAssignment(
2455-
"error",
2456-
catchVariable
2457-
)
2418+
createPropertyAssignment("error", catchVariable)
24582419
])
24592420
)
24602421
)
@@ -2463,39 +2424,44 @@ namespace ts {
24632424
)
24642425
),
24652426
createBlock([
2466-
setEmitFlags(
2467-
createTry(
2468-
setEmitFlags(
2469-
createBlock([
2470-
createStatement(
2471-
createCloseHelper(
2472-
context,
2473-
iteratorRecord
2474-
)
2475-
)
2476-
]),
2477-
EmitFlags.SingleLine
2478-
),
2479-
undefined,
2427+
createTry(
2428+
/*tryBlock*/ createBlock([
24802429
setEmitFlags(
2481-
createBlock([
2482-
setEmitFlags(
2483-
createIf(
2484-
errorRecord,
2485-
createThrow(
2486-
createPropertyAccess(
2487-
errorRecord,
2488-
"error"
2489-
)
2430+
createIf(
2431+
createLogicalAnd(
2432+
createLogicalAnd(
2433+
result,
2434+
createLogicalNot(
2435+
createPropertyAccess(result, "done")
24902436
)
24912437
),
2492-
EmitFlags.SingleLine
2438+
createAssignment(
2439+
returnMethod,
2440+
createPropertyAccess(iterator, "return")
2441+
)
2442+
),
2443+
createStatement(
2444+
createFunctionCall(returnMethod, iterator, [])
24932445
)
2494-
]),
2446+
),
24952447
EmitFlags.SingleLine
2496-
)
2497-
),
2498-
EmitFlags.SingleLine
2448+
),
2449+
]),
2450+
/*catchClause*/ undefined,
2451+
/*finallyBlock*/ setEmitFlags(
2452+
createBlock([
2453+
setEmitFlags(
2454+
createIf(
2455+
errorRecord,
2456+
createThrow(
2457+
createPropertyAccess(errorRecord, "error")
2458+
)
2459+
),
2460+
EmitFlags.SingleLine
2461+
)
2462+
]),
2463+
EmitFlags.SingleLine
2464+
)
24992465
)
25002466
])
25012467
);

0 commit comments

Comments
 (0)