microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-05-17 21:06:50 -05:00
Code Issues Packages Projects Releases 212 Wiki Activity

Merge branch 'master' into returnStatus

Browse Source
This commit is contained in:
Cyrus Najmabadi
2015-03-07 13:51:44 -08:00
parent a18934d6da 21627384a8
commit 7570aaac65
74 changed files with 747 additions and 159 deletions
Download Patch File Download Diff File Expand all files Collapse all files

112
src/compiler/emitter.ts
View File

@@ -2918,6 +2918,7 @@ module ts {
function createPropertyAccessExpression(expression: LeftHandSideExpression, name: Identifier): PropertyAccessExpression {
var result = <PropertyAccessExpression>createSynthesizedNode(SyntaxKind.PropertyAccessExpression);
result.expression = expression;
result.dotToken = createSynthesizedNode(SyntaxKind.DotToken);
result.name = name;
return result;
@@ -3033,13 +3034,38 @@ module ts {
return false;
}
function indentIfOnDifferentLines(parent: Node, node1: Node, node2: Node) {
var isSynthesized = nodeIsSynthesized(parent);
var realNodesAreOnDifferentLines = !isSynthesized && !nodeEndIsOnSameLineAsNodeStart(node1, node2);
var synthesizedNodeIsOnDifferentLine = synthesizedNodeStartsOnNewLine(node2);
if (realNodesAreOnDifferentLines || synthesizedNodeIsOnDifferentLine) {
increaseIndent();
writeLine();
return true;
}
return false;
}
function emitPropertyAccess(node: PropertyAccessExpression) {
if (tryEmitConstantValue(node)) {
return;
}
emit(node.expression);
var indented = indentIfOnDifferentLines(node, node.expression, node.dotToken);
write(".");
indented = indented || indentIfOnDifferentLines(node, node.dotToken, node.name);
emit(node.name);
if (indented) {
decreaseIndent();
}
}
function emitQualifiedName(node: QualifiedName) {
@@ -3273,25 +3299,31 @@ module ts {
else {
emit(node.left);
if (node.operatorToken.kind !== SyntaxKind.CommaToken) {
// If there was a newline between the left side of the binary expression and the
// operator, then try to preserve that.
var indented1 = indentIfOnDifferentLines(node, node.left, node.operatorToken);
// Otherwise just emit the operator right afterwards. For everything but
// comma, emit a space before the operator.
if (!indented1 && node.operatorToken.kind !== SyntaxKind.CommaToken) {
write(" ");
}
write(tokenToString(node.operatorToken.kind));
var shouldPlaceOnNewLine = !nodeIsSynthesized(node) && !nodeEndIsOnSameLineAsNodeStart(node.operatorToken, node.right);
// Check if the right expression is on a different line versus the operator itself. If so,
// we'll emit newline.
if (shouldPlaceOnNewLine || synthesizedNodeStartsOnNewLine(node.right)) {
increaseIndent();
writeLine();
emit(node.right);
decreaseIndent();
if (!indented1) {
var indented2 = indentIfOnDifferentLines(node, node.operatorToken, node.right);
}
else {
if (!indented2) {
write(" ");
emit(node.right);
}
emit(node.right);
// If we indented the left or the right side, then dedent now.
if (indented1 || indented2) {
decreaseIndent();
}
}
}
@@ -3302,10 +3334,45 @@ module ts {
function emitConditionalExpression(node: ConditionalExpression) {
emit(node.condition);
write(" ? ");
var indent1 = indentIfOnDifferentLines(node, node.condition, node.questionToken);
if (!indent1) {
write(" ");
}
write("?");
if (!indent1) {
var indent2 = indentIfOnDifferentLines(node, node.questionToken, node.whenTrue);
}
if (!indent2) {
write(" ");
}
emit(node.whenTrue);
write(" : ");
if (indent1 || indent2) {
decreaseIndent();
}
var indent3 = indentIfOnDifferentLines(node, node.whenTrue, node.colonToken);
if (!indent3) {
write(" ");
}
write(":");
if (!indent3) {
var indent4 = indentIfOnDifferentLines(node, node.colonToken, node.whenFalse);
}
if (!indent4) {
write(" ");
}
emit(node.whenFalse);
if (indent3 || indent4) {
decreaseIndent();
}
}
function isSingleLineEmptyBlock(node: Node) {
@@ -3678,10 +3745,16 @@ module ts {
equals.left = value;
equals.operatorToken = createSynthesizedNode(SyntaxKind.EqualsEqualsEqualsToken);
equals.right = createVoidZero();
return createConditionalExpression(equals, defaultValue, value);
}
function createConditionalExpression(condition: Expression, whenTrue: Expression, whenFalse: Expression) {
var cond = <ConditionalExpression>createSynthesizedNode(SyntaxKind.ConditionalExpression);
cond.condition = equals;
cond.whenTrue = defaultValue;
cond.whenFalse = value;
cond.condition = condition;
cond.questionToken = createSynthesizedNode(SyntaxKind.QuestionToken);
cond.whenTrue = whenTrue;
cond.colonToken = createSynthesizedNode(SyntaxKind.ColonToken);
cond.whenFalse = whenFalse;
return cond;
}
@@ -3704,10 +3777,7 @@ module ts {
if (propName.kind !== SyntaxKind.Identifier) {
return createElementAccess(object, propName);
}
var node = <PropertyAccessExpression>createSynthesizedNode(SyntaxKind.PropertyAccessExpression);
node.expression = parenthesizeForAccess(object);
node.name = propName;
return node;
return createPropertyAccessExpression(parenthesizeForAccess(object), propName);
}
function createElementAccess(object: Expression, index: Expression): Expression {

29
src/compiler/parser.ts
View File

@@ -120,6 +120,7 @@ module ts {
return visitNodes(cbNodes, (<ObjectLiteralExpression>node).properties);
case SyntaxKind.PropertyAccessExpression:
return visitNode(cbNode, (<PropertyAccessExpression>node).expression) ||
visitNode(cbNode, (<PropertyAccessExpression>node).dotToken) ||
visitNode(cbNode, (<PropertyAccessExpression>node).name);
case SyntaxKind.ElementAccessExpression:
return visitNode(cbNode, (<ElementAccessExpression>node).expression) ||
@@ -156,7 +157,9 @@ module ts {
visitNode(cbNode, (<BinaryExpression>node).right);
case SyntaxKind.ConditionalExpression:
return visitNode(cbNode, (<ConditionalExpression>node).condition) ||
visitNode(cbNode, (<ConditionalExpression>node).questionToken) ||
visitNode(cbNode, (<ConditionalExpression>node).whenTrue) ||
visitNode(cbNode, (<ConditionalExpression>node).colonToken) ||
visitNode(cbNode, (<ConditionalExpression>node).whenFalse);
case SyntaxKind.SpreadElementExpression:
return visitNode(cbNode, (<SpreadElementExpression>node).expression);
@@ -1327,13 +1330,16 @@ module ts {
function parseOptionalToken(t: SyntaxKind): Node {
if (token === t) {
var node = createNode(t);
nextToken();
return finishNode(node);
return parseTokenNode();
}
return undefined;
}
function parseExpectedToken(t: SyntaxKind, reportAtCurrentPosition: boolean, diagnosticMessage: DiagnosticMessage, arg0?: any): Node {
return parseOptionalToken(t) ||
createMissingNode(t, reportAtCurrentPosition, diagnosticMessage, arg0);
}
function parseTokenNode<T extends Node>(): T {
var node = <T>createNode(token);
nextToken();
@@ -2162,8 +2168,7 @@ module ts {
literal = parseLiteralNode();
}
else {
literal = <LiteralExpression>createMissingNode(
SyntaxKind.TemplateTail, /*reportAtCurrentPosition:*/ false, Diagnostics._0_expected, tokenToString(SyntaxKind.CloseBraceToken));
literal = <LiteralExpression>parseExpectedToken(SyntaxKind.TemplateTail, /*reportAtCurrentPosition:*/ false, Diagnostics._0_expected, tokenToString(SyntaxKind.CloseBraceToken));
}
span.literal = literal;
@@ -3186,7 +3191,8 @@ module ts {
function parseConditionalExpressionRest(leftOperand: Expression): Expression {
// Note: we are passed in an expression which was produced from parseBinaryExpressionOrHigher.
if (!parseOptional(SyntaxKind.QuestionToken)) {
var questionToken = parseOptionalToken(SyntaxKind.QuestionToken);
if (!questionToken) {
return leftOperand;
}
@@ -3194,8 +3200,10 @@ module ts {
// we do not that for the 'whenFalse' part.
var node = <ConditionalExpression>createNode(SyntaxKind.ConditionalExpression, leftOperand.pos);
node.condition = leftOperand;
node.questionToken = questionToken;
node.whenTrue = allowInAnd(parseAssignmentExpressionOrHigher);
parseExpected(SyntaxKind.ColonToken);
node.colonToken = parseExpectedToken(SyntaxKind.ColonToken, /*reportAtCurrentPosition:*/ false,
Diagnostics._0_expected, tokenToString(SyntaxKind.ColonToken));
node.whenFalse = parseAssignmentExpressionOrHigher();
return finishNode(node);
}
@@ -3458,7 +3466,7 @@ module ts {
// If it wasn't then just try to parse out a '.' and report an error.
var node = <PropertyAccessExpression>createNode(SyntaxKind.PropertyAccessExpression, expression.pos);
node.expression = expression;
parseExpected(SyntaxKind.DotToken, Diagnostics.super_must_be_followed_by_an_argument_list_or_member_access);
node.dotToken = parseExpectedToken(SyntaxKind.DotToken, /*reportAtCurrentPosition:*/ false, Diagnostics.super_must_be_followed_by_an_argument_list_or_member_access);
node.name = parseRightSideOfDot(/*allowIdentifierNames:*/ true);
return finishNode(node);
}
@@ -3474,10 +3482,11 @@ module ts {
function parseMemberExpressionRest(expression: LeftHandSideExpression): MemberExpression {
while (true) {
var dotOrBracketStart = scanner.getTokenPos();
if (parseOptional(SyntaxKind.DotToken)) {
var dotToken = parseOptionalToken(SyntaxKind.DotToken);
if (dotToken) {
var propertyAccess = <PropertyAccessExpression>createNode(SyntaxKind.PropertyAccessExpression, expression.pos);
propertyAccess.expression = expression;
propertyAccess.dotToken = dotToken;
propertyAccess.name = parseRightSideOfDot(/*allowIdentifierNames:*/ true);
expression = finishNode(propertyAccess);
continue;

3
src/compiler/types.ts
View File

@@ -641,7 +641,9 @@ module ts {
export interface ConditionalExpression extends Expression {
condition: Expression;
questionToken: Node;
whenTrue: Expression;
colonToken: Node;
whenFalse: Expression;
}
@@ -694,6 +696,7 @@ module ts {
export interface PropertyAccessExpression extends MemberExpression {
expression: LeftHandSideExpression;
dotToken: Node;
name: Identifier;
}