Skip to content

Commit 0dd96f5

Browse files
rbucktonrbuckton
committed
Merge branch 'master' into streamlineDestructuring
2 parents cbdde42 + d96a0ad commit 0dd96f5

File tree

192 files changed

+2980
-2557
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

192 files changed

+2980
-2557
lines changed

‎src/compiler/binder.ts

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -234,8 +234,8 @@ namespace ts {
234234
if (node.name.kind === SyntaxKind.ComputedPropertyName) {
235235
const nameExpression = (<ComputedPropertyName>node.name).expression;
236236
// treat computed property names where expression is string/numeric literal as just string/numeric literal
237-
if (isStringOrNumericLiteral(nameExpression.kind)) {
238-
return (<LiteralExpression>nameExpression).text;
237+
if (isStringOrNumericLiteral(nameExpression)) {
238+
return nameExpression.text;
239239
}
240240

241241
Debug.assert(isWellKnownSymbolSyntactically(nameExpression));

‎src/compiler/checker.ts

Lines changed: 13 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -3030,7 +3030,7 @@ namespace ts {
30303030
}
30313031

30323032
function isComputedNonLiteralName(name: PropertyName): boolean {
3033-
return name.kind === SyntaxKind.ComputedPropertyName && !isStringOrNumericLiteral((<ComputedPropertyName>name).expression.kind);
3033+
return name.kind === SyntaxKind.ComputedPropertyName && !isStringOrNumericLiteral((<ComputedPropertyName>name).expression);
30343034
}
30353035

30363036
function getRestType(source: Type, properties: PropertyName[], symbol: Symbol): Type {
@@ -8907,7 +8907,7 @@ namespace ts {
89078907
return type;
89088908
}
89098909

8910-
function getTypeOfDestructuredProperty(type: Type, name: Identifier | LiteralExpression | ComputedPropertyName) {
8910+
function getTypeOfDestructuredProperty(type: Type, name: PropertyName) {
89118911
const text = getTextOfPropertyName(name);
89128912
return getTypeOfPropertyOfType(type, text) ||
89138913
isNumericLiteralName(text) && getIndexTypeOfType(type, IndexKind.Number) ||
@@ -9936,8 +9936,7 @@ namespace ts {
99369936
// Due to the emit for class decorators, any reference to the class from inside of the class body
99379937
// must instead be rewritten to point to a temporary variable to avoid issues with the double-bind
99389938
// behavior of class names in ES6.
9939-
if (languageVersion === ScriptTarget.ES2015
9940-
&& declaration.kind === SyntaxKind.ClassDeclaration
9939+
if (declaration.kind === SyntaxKind.ClassDeclaration
99419940
&& nodeIsDecorated(declaration)) {
99429941
let container = getContainingClass(node);
99439942
while (container !== undefined) {
@@ -11165,10 +11164,10 @@ namespace ts {
1116511164
return links.resolvedType;
1116611165
}
1116711166

11168-
function getObjectLiteralIndexInfo(node: ObjectLiteralExpression, properties: Symbol[], kind: IndexKind): IndexInfo {
11167+
function getObjectLiteralIndexInfo(propertyNodes: NodeArray<ObjectLiteralElementLike>, offset: number, properties: Symbol[], kind: IndexKind): IndexInfo {
1116911168
const propTypes: Type[] = [];
1117011169
for (let i = 0; i < properties.length; i++) {
11171-
if (kind === IndexKind.String || isNumericName(node.properties[i].name)) {
11170+
if (kind === IndexKind.String || isNumericName(propertyNodes[i + offset].name)) {
1117211171
propTypes.push(getTypeOfSymbol(properties[i]));
1117311172
}
1117411173
}
@@ -11194,7 +11193,9 @@ namespace ts {
1119411193
let hasComputedStringProperty = false;
1119511194
let hasComputedNumberProperty = false;
1119611195

11197-
for (const memberDecl of node.properties) {
11196+
let offset = 0;
11197+
for (let i = 0; i < node.properties.length; i++) {
11198+
const memberDecl = node.properties[i];
1119811199
let member = memberDecl.symbol;
1119911200
if (memberDecl.kind === SyntaxKind.PropertyAssignment ||
1120011201
memberDecl.kind === SyntaxKind.ShorthandPropertyAssignment ||
@@ -11263,6 +11264,7 @@ namespace ts {
1126311264
return unknownType;
1126411265
}
1126511266
spread = getSpreadType(spread, type, /*isFromObjectLiteral*/ false);
11267+
offset = i + 1;
1126611268
continue;
1126711269
}
1126811270
else {
@@ -11316,8 +11318,8 @@ namespace ts {
1131611318
return createObjectLiteralType();
1131711319

1131811320
function createObjectLiteralType() {
11319-
const stringIndexInfo = hasComputedStringProperty ? getObjectLiteralIndexInfo(node, propertiesArray, IndexKind.String) : undefined;
11320-
const numberIndexInfo = hasComputedNumberProperty ? getObjectLiteralIndexInfo(node, propertiesArray, IndexKind.Number) : undefined;
11321+
const stringIndexInfo = hasComputedStringProperty ? getObjectLiteralIndexInfo(node.properties, offset, propertiesArray, IndexKind.String) : undefined;
11322+
const numberIndexInfo = hasComputedNumberProperty ? getObjectLiteralIndexInfo(node.properties, offset, propertiesArray, IndexKind.Number) : undefined;
1132111323
const result = createAnonymousType(node.symbol, propertiesTable, emptyArray, emptyArray, stringIndexInfo, numberIndexInfo);
1132211324
const freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : TypeFlags.FreshLiteral;
1132311325
result.flags |= TypeFlags.ContainsObjectLiteral | freshObjectLiteralFlag | (typeFlags & TypeFlags.PropagatingFlags);
@@ -14501,6 +14503,8 @@ namespace ts {
1450114503
case SyntaxKind.LessThanEqualsToken:
1450214504
case SyntaxKind.GreaterThanEqualsToken:
1450314505
if (checkForDisallowedESSymbolOperand(operator)) {
14506+
leftType = getBaseTypeOfLiteralType(leftType);
14507+
rightType = getBaseTypeOfLiteralType(rightType);
1450414508
if (!isTypeComparableTo(leftType, rightType) && !isTypeComparableTo(rightType, leftType)) {
1450514509
reportOperatorError();
1450614510
}

‎src/compiler/emitter.ts

Lines changed: 7 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -38,15 +38,21 @@ var __assign = (this && this.__assign) || Object.assign || function(t) {
3838
s = arguments[i];
3939
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
4040
t[p] = s[p];
41+
if (typeof Object.getOwnPropertySymbols === "function")
42+
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++)
43+
t[p[i]] = s[p[i]];
4144
}
4245
return t;
4346
};`;
4447

4548
const restHelper = `
4649
var __rest = (this && this.__rest) || function (s, e) {
4750
var t = {};
48-
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && !e.indexOf(p))
51+
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
4952
t[p] = s[p];
53+
if (typeof Object.getOwnPropertySymbols === "function")
54+
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
55+
t[p[i]] = s[p[i]];
5056
return t;
5157
};`;
5258

‎src/compiler/factory.ts

Lines changed: 13 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -102,12 +102,12 @@ namespace ts {
102102

103103
// Literals
104104

105-
export function createLiteral(textSource: StringLiteral | Identifier, location?: TextRange): StringLiteral;
105+
export function createLiteral(textSource: StringLiteral | NumericLiteral | Identifier, location?: TextRange): StringLiteral;
106106
export function createLiteral(value: string, location?: TextRange): StringLiteral;
107107
export function createLiteral(value: number, location?: TextRange): NumericLiteral;
108108
export function createLiteral(value: boolean, location?: TextRange): BooleanLiteral;
109109
export function createLiteral(value: string | number | boolean, location?: TextRange): PrimaryExpression;
110-
export function createLiteral(value: string | number | boolean | StringLiteral | Identifier, location?: TextRange): PrimaryExpression {
110+
export function createLiteral(value: string | number | boolean | StringLiteral | NumericLiteral | Identifier, location?: TextRange): PrimaryExpression {
111111
if (typeof value === "number") {
112112
const node = <NumericLiteral>createNode(SyntaxKind.NumericLiteral, location, /*flags*/ undefined);
113113
node.text = value.toString();
@@ -3796,7 +3796,10 @@ namespace ts {
37963796
// `"a"` in `let { "a": b } = ...`
37973797
// `1` in `let { 1: b } = ...`
37983798
if ((<BindingElement>bindingElement).propertyName) {
3799-
return (<BindingElement>bindingElement).propertyName;
3799+
const propertyName = (<BindingElement>bindingElement).propertyName;
3800+
return isComputedPropertyName(propertyName) && isStringOrNumericLiteral(propertyName.expression)
3801+
? propertyName.expression
3802+
: propertyName;
38003803
}
38013804

38023805
break;
@@ -3807,7 +3810,10 @@ namespace ts {
38073810
// `"a"` in `({ "a": b } = ...)`
38083811
// `1` in `({ 1: b } = ...)`
38093812
if ((<PropertyAssignment>bindingElement).name) {
3810-
return (<PropertyAssignment>bindingElement).name;
3813+
const propertyName = (<PropertyAssignment>bindingElement).name;
3814+
return isComputedPropertyName(propertyName) && isStringOrNumericLiteral(propertyName.expression)
3815+
? propertyName.expression
3816+
: propertyName;
38113817
}
38123818

38133819
break;
@@ -3819,7 +3825,9 @@ namespace ts {
38193825

38203826
const target = getTargetOfBindingOrAssignmentElement(bindingElement);
38213827
if (target && isPropertyName(target)) {
3822-
return target;
3828+
return isComputedPropertyName(target) && isStringOrNumericLiteral(target.expression)
3829+
? target.expression
3830+
: target;
38233831
}
38243832

38253833
Debug.fail("Invalid property name for binding element.");

‎src/compiler/parser.ts

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1168,7 +1168,7 @@ namespace ts {
11681168

11691169
function parsePropertyNameWorker(allowComputedPropertyNames: boolean): PropertyName {
11701170
if (token() === SyntaxKind.StringLiteral || token() === SyntaxKind.NumericLiteral) {
1171-
return parseLiteralNode(/*internName*/ true);
1171+
return <StringLiteral | NumericLiteral>parseLiteralNode(/*internName*/ true);
11721172
}
11731173
if (allowComputedPropertyNames && token() === SyntaxKind.OpenBracketToken) {
11741174
return parseComputedPropertyName();
@@ -5514,7 +5514,7 @@ namespace ts {
55145514
node.flags |= NodeFlags.GlobalAugmentation;
55155515
}
55165516
else {
5517-
node.name = parseLiteralNode(/*internName*/ true);
5517+
node.name = <StringLiteral>parseLiteralNode(/*internName*/ true);
55185518
}
55195519

55205520
if (token() === SyntaxKind.OpenBraceToken) {

‎src/compiler/transformers/destructuring.ts

Lines changed: 28 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -240,21 +240,26 @@ namespace ts {
240240
boundValue = ensureIdentifier(host, boundValue, reuseIdentifierExpressions, location);
241241
}
242242
let bindingElements: BindingOrAssignmentElement[];
243+
let computedTempVariables: Expression[];
243244
for (let i = 0; i < numElements; i++) {
244245
const element = elements[i];
245246
if (!getRestIndicatorOfBindingOrAssignmentElement(element)) {
247+
const propertyName = getPropertyNameOfBindingOrAssignmentElement(element);
246248
if (host.level >= FlattenLevel.ObjectRest
247249
&& !(element.transformFlags & (TransformFlags.ContainsRest | TransformFlags.ContainsObjectRest))
248-
&& !(getTargetOfBindingOrAssignmentElement(element).transformFlags & (TransformFlags.ContainsRest | TransformFlags.ContainsObjectRest))) {
250+
&& !(getTargetOfBindingOrAssignmentElement(element).transformFlags & (TransformFlags.ContainsRest | TransformFlags.ContainsObjectRest))
251+
&& !isComputedPropertyName(propertyName)) {
249252
bindingElements = append(bindingElements, element);
250253
}
251254
else {
252255
if (bindingElements) {
253256
host.emitBindingOrAssignment(host.createObjectBindingOrAssignmentPattern(bindingElements), boundValue, location, bindingTarget);
254257
bindingElements = undefined;
255258
}
256-
const propertyName = getPropertyNameOfBindingOrAssignmentElement(element);
257259
const value = createDestructuringPropertyAccess(host, boundValue, propertyName);
260+
if (isComputedPropertyName(propertyName)) {
261+
computedTempVariables = append(computedTempVariables, (value as ElementAccessExpression).argumentExpression);
262+
}
258263
flattenBindingOrAssignmentElement(host, element, value, /*location*/ element);
259264
}
260265
}
@@ -263,7 +268,7 @@ namespace ts {
263268
host.emitBindingOrAssignment(host.createObjectBindingOrAssignmentPattern(bindingElements), boundValue, location, bindingTarget);
264269
bindingElements = undefined;
265270
}
266-
const value = createRestCall(boundValue, elements, bindingTarget);
271+
const value = createRestCall(boundValue, elements, computedTempVariables, bindingTarget);
267272
flattenBindingOrAssignmentElement(host, element, value, element);
268273
}
269274
}
@@ -429,17 +434,28 @@ namespace ts {
429434

430435
/** Given value: o, propName: p, pattern: { a, b, ...p } from the original statement
431436
* `{ a, b, ...p } = o`, create `p = __rest(o, ["a", "b"]);`*/
432-
function createRestCall(value: Expression, elements: BindingOrAssignmentElement[], location: TextRange): Expression {
433-
const propertyNames: LiteralExpression[] = [];
437+
function createRestCall(value: Expression, elements: BindingOrAssignmentElement[], computedTempVariables: Expression[], location: TextRange): Expression {
438+
const propertyNames: Expression[] = [];
434439
for (let i = 0; i < elements.length - 1; i++) {
435-
if (isOmittedExpression(elements[i])) {
436-
continue;
440+
const propertyName = getPropertyNameOfBindingOrAssignmentElement(elements[i]);
441+
if (propertyName) {
442+
if (isComputedPropertyName(propertyName)) {
443+
// get the temp name and put that in there instead, like `_tmp + ""`
444+
const temp = computedTempVariables.shift();
445+
propertyNames.push(
446+
createConditional(
447+
createStrictEquality(createTypeOf(temp), createLiteral("symbol")),
448+
createToken(SyntaxKind.QuestionToken),
449+
temp,
450+
createToken(SyntaxKind.ColonToken),
451+
createAdd(temp, createLiteral(""))
452+
)
453+
);
454+
}
455+
else {
456+
propertyNames.push(createLiteral(propertyName));
457+
}
437458
}
438-
const str = <StringLiteral>createSynthesizedNode(SyntaxKind.StringLiteral);
439-
str.pos = location.pos;
440-
str.end = location.end;
441-
str.text = getTextOfPropertyName(getPropertyNameOfBindingOrAssignmentElement(elements[i]));
442-
propertyNames.push(str);
443459
}
444460
const args = createSynthesizedNodeArray([value, createArrayLiteral(propertyNames, location)]);
445461
return createCall(createIdentifier("__rest"), undefined, args);

‎src/compiler/transformers/es2015.ts

Lines changed: 14 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1011,7 +1011,20 @@ namespace ts {
10111011

10121012
// Return the result if we have an immediate super() call on the last statement.
10131013
if (superCallExpression && statementOffset === ctorStatements.length - 1) {
1014-
statements.push(createReturn(superCallExpression));
1014+
const returnStatement = createReturn(superCallExpression);
1015+
1016+
if (superCallExpression.kind !== SyntaxKind.BinaryExpression
1017+
|| (superCallExpression as BinaryExpression).left.kind !== SyntaxKind.CallExpression) {
1018+
Debug.fail("Assumed generated super call would have form 'super.call(...) || this'.");
1019+
}
1020+
1021+
// Shift comments from the original super call to the return statement.
1022+
setCommentRange(returnStatement, getCommentRange(
1023+
setEmitFlags(
1024+
(superCallExpression as BinaryExpression).left,
1025+
EmitFlags.NoComments)));
1026+
1027+
statements.push(returnStatement);
10151028
return SuperCaptureResult.ReplaceWithReturn;
10161029
}
10171030

‎src/compiler/transformers/esnext.ts

Lines changed: 10 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -99,11 +99,15 @@ namespace ts {
9999
// { a, ...o, b } => __assign({a}, o, {b});
100100
// If the first element is a spread element, then the first argument to __assign is {}:
101101
// { ...o, a, b, ...o2 } => __assign({}, o, {a, b}, o2)
102-
const objects = chunkObjectLiteralElements(node.properties);
103-
if (objects.length && objects[0].kind !== SyntaxKind.ObjectLiteralExpression) {
104-
objects.unshift(createObjectLiteral());
102+
if (forEach(node.properties, p => p.kind === SyntaxKind.SpreadAssignment)) {
103+
const objects = chunkObjectLiteralElements(node.properties);
104+
if (objects.length && objects[0].kind !== SyntaxKind.ObjectLiteralExpression) {
105+
objects.unshift(createObjectLiteral());
106+
}
107+
108+
return aggregateTransformFlags(createCall(createIdentifier("__assign"), undefined, objects));
105109
}
106-
return createCall(createIdentifier("__assign"), undefined, objects);
110+
return visitEachChild(node, visitor, context);
107111
}
108112

109113
function visitExpressionStatement(node: ExpressionStatement): ExpressionStatement {
@@ -269,7 +273,7 @@ namespace ts {
269273
visitEachChild(node.body, visitor, context);
270274
const func = setOriginalNode(
271275
createArrowFunction(
272-
/*modifiers*/ undefined,
276+
node.modifiers,
273277
/*typeParameters*/ undefined,
274278
visitNodes(node.parameters, visitor, isParameter),
275279
/*type*/ undefined,
@@ -290,7 +294,7 @@ namespace ts {
290294
visitEachChild(node.body, visitor, context);
291295
return setOriginalNode(
292296
createFunctionExpression(
293-
/*modifiers*/ undefined,
297+
node.modifiers,
294298
node.asteriskToken,
295299
name,
296300
/*typeParameters*/ undefined,

0 commit comments

Comments
 (0)