Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Optional chaining stage1 #32599

Closed
wants to merge 2 commits into from
Closed

Optional chaining stage1 #32599

Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
650fd38
Optional chaining prototype
rbuckton Sep 26, 2017
625dc0f
parse, emit, initial check for optional chaining
rbuckton Sep 27, 2017
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Prev Previous commit
parse, emit, initial check for optional chaining
  • Loading branch information
@rbuckton
rbuckton committed Sep 27, 2017
commit 625dc0f32e20a0e4c64557da1e7061bd371191a6
33 changes: 19 additions & 14 deletions src/compiler/binder.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2674,11 +2674,24 @@ namespace ts {
case SyntaxKind.PropertyAccessExpression:
return computePropertyAccess(<PropertyAccessExpression>node, subtreeFlags);

case SyntaxKind.CallChain:
return computeCallChain(<CallChain>node, subtreeFlags);

default:
return computeOther(node, kind, subtreeFlags);
}
}

function computeCallChain(node: CallChain, subtreeFlags: TransformFlags) {
let transformFlags = subtreeFlags;
if (node.typeArguments) {
transformFlags |= TransformFlags.AssertTypeScript;
}

node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
return transformFlags & ~TransformFlags.ArrayLiteralOrCallOrNewExcludes;
}

function computeCallExpression(node: CallExpression, subtreeFlags: TransformFlags) {
let transformFlags = subtreeFlags;
const expression = node.expression;
Expand All @@ -2688,10 +2701,6 @@ namespace ts {
transformFlags |= TransformFlags.AssertTypeScript;
}

if (node.flags & NodeFlags.Optional) {
transformFlags |= TransformFlags.AssertESNext;
}

if (subtreeFlags & TransformFlags.ContainsSpread
|| isSuperOrSuperProperty(expression, expressionKind)) {
// If the this node contains a SpreadExpression, or is a super call, then it is an ES6
Expand Down Expand Up @@ -3136,10 +3145,6 @@ namespace ts {
const expression = node.expression;
const expressionKind = expression.kind;

if (node.flags & NodeFlags.Optional) {
transformFlags |= TransformFlags.AssertESNext;
}

// If a PropertyAccessExpression starts with a super keyword, then it is
// ES6 syntax, and requires a lexical `this` binding.
if (expressionKind === SyntaxKind.SuperKeyword) {
Expand Down Expand Up @@ -3296,6 +3301,12 @@ namespace ts {
transformFlags |= TransformFlags.AssertJsx;
break;

case SyntaxKind.OptionalExpression:
case SyntaxKind.PropertyAccessChain:
case SyntaxKind.ElementAccessChain:
transformFlags |= TransformFlags.AssertESNext;
break;

case SyntaxKind.NoSubstitutionTemplateLiteral:
case SyntaxKind.TemplateHead:
case SyntaxKind.TemplateMiddle:
Expand Down Expand Up @@ -3466,12 +3477,6 @@ namespace ts {

break;

case SyntaxKind.ElementAccessExpression:
if (node.flags & NodeFlags.Optional) {
transformFlags |= TransformFlags.AssertESNext;
}
break;

case SyntaxKind.DoStatement:
case SyntaxKind.WhileStatement:
case SyntaxKind.ForStatement:
Expand Down
204 changes: 93 additions & 111 deletions src/compiler/checker.ts
View file
Open in desktop

Large diffs are not rendered by default.

62 changes: 55 additions & 7 deletions src/compiler/emitter.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -583,6 +583,14 @@ namespace ts {
case SyntaxKind.BindingElement:
return emitBindingElement(<BindingElement>node);

// Optional chains
case SyntaxKind.PropertyAccessChain:
return emitPropertyAccessChain(<PropertyAccessChain>node);
case SyntaxKind.ElementAccessChain:
return emitElementAccessChain(<ElementAccessChain>node);
case SyntaxKind.CallChain:
return emitCallChain(<CallChain>node);

// Misc
case SyntaxKind.TemplateSpan:
return emitTemplateSpan(<TemplateSpan>node);
Expand Down Expand Up @@ -768,6 +776,8 @@ namespace ts {
return emitPropertyAccessExpression(<PropertyAccessExpression>node);
case SyntaxKind.ElementAccessExpression:
return emitElementAccessExpression(<ElementAccessExpression>node);
case SyntaxKind.OptionalExpression:
return emitOptionalExpression(<OptionalExpression>node);
case SyntaxKind.CallExpression:
return emitCallExpression(<CallExpression>node);
case SyntaxKind.NewExpression:
Expand Down Expand Up @@ -1195,13 +1205,12 @@ namespace ts {
}

function emitPropertyAccessExpression(node: PropertyAccessExpression) {
const isOptionalExpression = node.flags & NodeFlags.OptionalExpression;
let indentBeforeDot = false;
let indentAfterDot = false;
if (!(getEmitFlags(node) & EmitFlags.NoIndentation)) {
const dotRangeStart = node.expression.end;
const dotRangeEnd = skipTrivia(currentSourceFile.text, node.expression.end) + 1;
const dotToken = createToken(isOptionalExpression ? SyntaxKind.QuestionDotToken : SyntaxKind.DotToken);
const dotToken = createToken(SyntaxKind.DotToken);
dotToken.pos = dotRangeStart;
dotToken.end = dotRangeEnd;
indentBeforeDot = needsIndentation(node, node.expression, dotToken);
Expand All @@ -1211,8 +1220,8 @@ namespace ts {
emitExpression(node.expression);
increaseIndentIf(indentBeforeDot);

const shouldEmitDotDot = !isOptionalExpression && !indentBeforeDot && needsDotDotForPropertyAccess(node.expression);
write(shouldEmitDotDot ? ".." : isOptionalExpression ? "?." : ".");
const shouldEmitDotDot = !indentBeforeDot && needsDotDotForPropertyAccess(node.expression);
write(shouldEmitDotDot ? ".." : ".");

increaseIndentIf(indentAfterDot);
emit(node.name);
Expand Down Expand Up @@ -1241,16 +1250,55 @@ namespace ts {

function emitElementAccessExpression(node: ElementAccessExpression) {
emitExpression(node.expression);
write(node.flags & NodeFlags.OptionalExpression ? "?.[" : "[");
write("[");
emitExpression(node.argumentExpression);
write("]");
}

function emitCallExpression(node: CallExpression) {
function emitOptionalExpression(node: OptionalExpression) {
emitExpression(node.expression);
if (node.flags & NodeFlags.OptionalExpression) {
emit(node.chain);
}

function emitPropertyAccessChain(node: PropertyAccessChain) {
if (node.chain) {
emit(node.chain);
write(".");
}
else {
write("?.");
}

emit(node.name);
}

function emitElementAccessChain(node: ElementAccessChain) {
if (node.chain) {
emit(node.chain);
}
else {
write("?.");
}

write("[");
emitExpression(node.argumentExpression);
write("]");
}

function emitCallChain(node: CallChain) {
if (node.chain) {
emit(node.chain);
}
else {
write("?.");
}

emitTypeArguments(node, node.typeArguments);
emitExpressionList(node, node.arguments, ListFormat.CallExpressionArguments);
}

function emitCallExpression(node: CallExpression) {
emitExpression(node.expression);
emitTypeArguments(node, node.typeArguments);
emitExpressionList(node, node.arguments, ListFormat.CallExpressionArguments);
}
Expand Down
65 changes: 58 additions & 7 deletions src/compiler/factory.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -859,7 +859,6 @@ namespace ts {

export function createPropertyAccess(expression: Expression, name: string | Identifier) {
const node = <PropertyAccessExpression>createSynthesizedNode(SyntaxKind.PropertyAccessExpression);
if (expression.flags & NodeFlags.Optional) node.flags |= NodeFlags.OptionalChain;
node.expression = parenthesizeForAccess(expression);
node.name = asName(name);
setEmitFlags(node, EmitFlags.NoIndentation);
Expand All @@ -877,7 +876,6 @@ namespace ts {

export function createElementAccess(expression: Expression, index: number | Expression) {
const node = <ElementAccessExpression>createSynthesizedNode(SyntaxKind.ElementAccessExpression);
if (expression.flags & NodeFlags.Optional) node.flags |= NodeFlags.OptionalChain;
node.expression = parenthesizeForAccess(expression);
node.argumentExpression = asExpression(index);
return node;
Expand All @@ -890,9 +888,66 @@ namespace ts {
: node;
}

export function createOptionalExpression(expression: Expression, chain: OptionalChain) {
const node = <OptionalExpression>createSynthesizedNode(SyntaxKind.ElementAccessExpression);
node.expression = parenthesizeForAccess(expression);
node.chain = chain;
return node;
}

export function updateOptionalExpression(node: OptionalExpression, expression: Expression, chain: OptionalChain) {
return node.expression !== expression
|| node.chain !== chain
? updateNode(createOptionalExpression(expression, chain), node)
: node;
}

export function createPropertyAccessChain(chain: OptionalChain | undefined, name: Identifier) {
const node = <PropertyAccessChain>createSynthesizedNode(SyntaxKind.PropertyAccessChain);
node.chain = chain;
node.name = name;
return node;
}

export function updatePropertyAccessChain(node: PropertyAccessChain, chain: OptionalChain | undefined, name: Identifier) {
return node.chain !== chain
|| node.name !== name
? updateNode(createPropertyAccessChain(chain, name), node)
: node;
}

export function createElementAccessChain(chain: OptionalChain | undefined, argumentExpression: Expression) {
const node = <ElementAccessChain>createSynthesizedNode(SyntaxKind.ElementAccessChain);
node.chain = chain;
node.argumentExpression = argumentExpression;
return node;
}

export function updateElementAccessChain(node: ElementAccessChain, chain: OptionalChain | undefined, argumentExpression: Expression) {
return node.chain !== chain
|| node.argumentExpression !== argumentExpression
? updateNode(createElementAccessChain(chain, argumentExpression), node)
: node;
}

export function createCallChain(chain: OptionalChain | undefined, typeArguments: ReadonlyArray<TypeNode> | undefined, argumentList: ReadonlyArray<Expression>) {
const node = <CallChain>createSynthesizedNode(SyntaxKind.CallChain);
node.chain = chain;
node.typeArguments = asNodeArray(typeArguments);
node.arguments = createNodeArray(argumentList);
return node;
}

export function updateCallChain(node: CallChain, chain: OptionalChain | undefined, typeArguments: ReadonlyArray<TypeNode> | undefined, argumentList: ReadonlyArray<Expression>) {
return node.chain !== chain
|| node.typeArguments !== typeArguments
|| node.arguments !== argumentList
? updateNode(createCallChain(chain, typeArguments, argumentList), node)
: node;
}

export function createCall(expression: Expression, typeArguments: ReadonlyArray<TypeNode> | undefined, argumentsArray: ReadonlyArray<Expression>) {
const node = <CallExpression>createSynthesizedNode(SyntaxKind.CallExpression);
if (expression.flags & NodeFlags.Optional) node.flags |= NodeFlags.OptionalChain;
node.expression = parenthesizeForAccess(expression);
node.typeArguments = asNodeArray(typeArguments);
node.arguments = parenthesizeListElements(createNodeArray(argumentsArray));
Expand Down Expand Up @@ -2505,10 +2560,6 @@ namespace ts {
return createBinary(left, SyntaxKind.EqualsToken, right);
}

export function createEquality(left: Expression, right: Expression) {
return createBinary(left, SyntaxKind.EqualsEqualsToken, right);
}

export function createStrictEquality(left: Expression, right: Expression) {
return createBinary(left, SyntaxKind.EqualsEqualsEqualsToken, right);
}
Expand Down
Loading