Microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2025-11-18 17:21:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename syntax properties to match Roslyn/Fidelity naming.

Browse Source
This commit is contained in:
Cyrus Najmabadi
2014-11-29 15:47:02 -08:00
parent 13f319b6ec
commit e1011aa2f0
7 changed files with 88 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/compiler/checker.ts
+33 -33
View File
@@ -4328,7 +4328,7 @@ module ts {
case SyntaxKind.ArrayLiteral:
case SyntaxKind.ObjectLiteral:
case SyntaxKind.PropertyAccess:
case SyntaxKind.IndexedAccess:
case SyntaxKind.ElementAccessExpression:
case SyntaxKind.CallExpression:
case SyntaxKind.NewExpression:
case SyntaxKind.TypeAssertion:
@@ -4625,7 +4625,7 @@ module ts {
}
function checkSuperExpression(node: Node): Type {
var isCallExpression = node.parent.kind === SyntaxKind.CallExpression && (<CallExpression>node.parent).func === node;
var isCallExpression = node.parent.kind === SyntaxKind.CallExpression && (<CallExpression>node.parent).expression === node;
var enclosingClass = <ClassDeclaration>getAncestor(node, SyntaxKind.ClassDeclaration);
var baseClass: Type;
if (enclosingClass && enclosingClass.baseType) {
@@ -5208,15 +5208,15 @@ module ts {
return true;
}
function checkIndexedAccess(node: IndexedAccess): Type {
function checkIndexedAccess(node: ElementAccessExpression): Type {
// Obtain base constraint such that we can bail out if the constraint is an unknown type
var objectType = getApparentType(checkExpression(node.object));
var indexType = checkExpression(node.index);
var objectType = getApparentType(checkExpression(node.expression));
var indexType = checkExpression(node.argumentExpression);
if (objectType === unknownType) return unknownType;
if (isConstEnumObjectType(objectType) && node.index.kind !== SyntaxKind.StringLiteral) {
error(node.index, Diagnostics.Index_expression_arguments_in_const_enums_must_be_of_type_string);
if (isConstEnumObjectType(objectType) && node.argumentExpression.kind !== SyntaxKind.StringLiteral) {
error(node.argumentExpression, Diagnostics.Index_expression_arguments_in_const_enums_must_be_of_type_string);
}
// TypeScript 1.0 spec (April 2014): 4.10 Property Access
@@ -5229,8 +5229,8 @@ module ts {
// - Otherwise, if IndexExpr is of type Any, the String or Number primitive type, or an enum type, the property access is of type Any.
// See if we can index as a property.
if (node.index.kind === SyntaxKind.StringLiteral || node.index.kind === SyntaxKind.NumericLiteral) {
var name = (<LiteralExpression>node.index).text;
if (node.argumentExpression.kind === SyntaxKind.StringLiteral || node.argumentExpression.kind === SyntaxKind.NumericLiteral) {
var name = (<LiteralExpression>node.argumentExpression).text;
var prop = getPropertyOfType(objectType, name);
if (prop) {
getNodeLinks(node).resolvedSymbol = prop;
@@ -5629,7 +5629,7 @@ module ts {
Diagnostics.The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_type_arguments_explicitly,
typeToString(failedTypeParameter));
reportNoCommonSupertypeError(inferenceCandidates, (<CallExpression>node).func || (<TaggedTemplateExpression>node).tag, diagnosticChainHead);
reportNoCommonSupertypeError(inferenceCandidates, (<CallExpression>node).expression || (<TaggedTemplateExpression>node).tag, diagnosticChainHead);
}
}
else {
@@ -5759,15 +5759,15 @@ module ts {
}
function resolveCallExpression(node: CallExpression, candidatesOutArray: Signature[]): Signature {
if (node.func.kind === SyntaxKind.SuperKeyword) {
var superType = checkSuperExpression(node.func);
if (node.expression.kind === SyntaxKind.SuperKeyword) {
var superType = checkSuperExpression(node.expression);
if (superType !== unknownType) {
return resolveCall(node, getSignaturesOfType(superType, SignatureKind.Construct), candidatesOutArray);
}
return resolveUntypedCall(node);
}
var funcType = checkExpression(node.func);
var funcType = checkExpression(node.expression);
var apparentType = getApparentType(funcType);
if (apparentType === unknownType) {
@@ -5811,7 +5811,7 @@ module ts {
}
function resolveNewExpression(node: NewExpression, candidatesOutArray: Signature[]): Signature {
var expressionType = checkExpression(node.func);
var expressionType = checkExpression(node.expression);
// TS 1.0 spec: 4.11
// If ConstructExpr is of type Any, Args can be any argument
// list and the result of the operation is of type Any.
@@ -5911,7 +5911,7 @@ module ts {
function checkCallExpression(node: CallExpression): Type {
var signature = getResolvedSignature(node);
if (node.func.kind === SyntaxKind.SuperKeyword) {
if (node.expression.kind === SyntaxKind.SuperKeyword) {
return voidType;
}
if (node.kind === SyntaxKind.NewExpression) {
@@ -5936,7 +5936,7 @@ module ts {
}
function checkTypeAssertion(node: TypeAssertion): Type {
var exprType = checkExpression(node.operand);
var exprType = checkExpression(node.expression);
var targetType = getTypeFromTypeNode(node.type);
if (fullTypeCheck && targetType !== unknownType) {
var widenedType = getWidenedType(exprType, /*supressNoImplicitAnyErrors*/ true);
@@ -6171,7 +6171,7 @@ module ts {
// A property access expression is always classified as a reference.
// NOTE (not in spec): assignment to enum members should not be allowed
return !symbol || symbol === unknownSymbol || (symbol.flags & ~SymbolFlags.EnumMember) !== 0;
case SyntaxKind.IndexedAccess:
case SyntaxKind.ElementAccessExpression:
// old compiler doesn't check indexed assess
return true;
case SyntaxKind.ParenExpression:
@@ -6187,9 +6187,9 @@ module ts {
case SyntaxKind.PropertyAccess:
var symbol = findSymbol(n);
return symbol && (symbol.flags & SymbolFlags.Variable) !== 0 && (getDeclarationFlagsFromSymbol(symbol) & NodeFlags.Const) !== 0;
case SyntaxKind.IndexedAccess:
var index = (<IndexedAccess>n).index;
var symbol = findSymbol((<IndexedAccess>n).object);
case SyntaxKind.ElementAccessExpression:
var index = (<ElementAccessExpression>n).argumentExpression;
var symbol = findSymbol((<ElementAccessExpression>n).expression);
if (symbol && index.kind === SyntaxKind.StringLiteral) {
var name = (<LiteralExpression>index).text;
var prop = getPropertyOfType(getTypeOfSymbol(symbol), name);
@@ -6525,7 +6525,7 @@ module ts {
// - target in rhs of import statement
var ok =
(node.parent.kind === SyntaxKind.PropertyAccess && (<PropertyAccess>node.parent).left === node) ||
(node.parent.kind === SyntaxKind.IndexedAccess && (<IndexedAccess>node.parent).object === node) ||
(node.parent.kind === SyntaxKind.ElementAccessExpression && (<ElementAccessExpression>node.parent).expression === node) ||
((node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName) && isInRightSideOfImportOrExportAssignment(<EntityName>node));
if (!ok) {
@@ -6565,8 +6565,8 @@ module ts {
return checkObjectLiteral(<ObjectLiteral>node, contextualMapper);
case SyntaxKind.PropertyAccess:
return checkPropertyAccess(<PropertyAccess>node);
case SyntaxKind.IndexedAccess:
return checkIndexedAccess(<IndexedAccess>node);
case SyntaxKind.ElementAccessExpression:
return checkIndexedAccess(<ElementAccessExpression>node);
case SyntaxKind.CallExpression:
case SyntaxKind.NewExpression:
return checkCallExpression(<CallExpression>node);
@@ -6763,7 +6763,7 @@ module ts {
}
function isSuperCallExpression(n: Node): boolean {
return n.kind === SyntaxKind.CallExpression && (<CallExpression>n).func.kind === SyntaxKind.SuperKeyword;
return n.kind === SyntaxKind.CallExpression && (<CallExpression>n).expression.kind === SyntaxKind.SuperKeyword;
}
function containsSuperCall(n: Node): boolean {
@@ -8139,7 +8139,7 @@ module ts {
case SyntaxKind.ParenExpression:
return enumIsConst ? evalConstant((<ParenExpression>e).expression) : undefined;
case SyntaxKind.Identifier:
case SyntaxKind.IndexedAccess:
case SyntaxKind.ElementAccessExpression:
case SyntaxKind.PropertyAccess:
if (!enumIsConst) {
return undefined;
@@ -8157,12 +8157,12 @@ module ts {
propertyName = (<Identifier>e).text;
}
else {
if (e.kind === SyntaxKind.IndexedAccess) {
if ((<IndexedAccess>e).index.kind !== SyntaxKind.StringLiteral) {
if (e.kind === SyntaxKind.ElementAccessExpression) {
if ((<ElementAccessExpression>e).argumentExpression.kind !== SyntaxKind.StringLiteral) {
return undefined;
}
var enumType = getTypeOfNode((<IndexedAccess>e).object);
propertyName = (<LiteralExpression>(<IndexedAccess>e).index).text;
var enumType = getTypeOfNode((<ElementAccessExpression>e).expression);
propertyName = (<LiteralExpression>(<ElementAccessExpression>e).argumentExpression).text;
}
else {
var enumType = getTypeOfNode((<PropertyAccess>e).left);
@@ -8491,7 +8491,7 @@ module ts {
case SyntaxKind.ObjectLiteral:
case SyntaxKind.PropertyAssignment:
case SyntaxKind.PropertyAccess:
case SyntaxKind.IndexedAccess:
case SyntaxKind.ElementAccessExpression:
case SyntaxKind.CallExpression:
case SyntaxKind.NewExpression:
case SyntaxKind.TaggedTemplateExpression:
@@ -8907,8 +8907,8 @@ module ts {
// Intentional fall-through
case SyntaxKind.NumericLiteral:
// index access
if (node.parent.kind == SyntaxKind.IndexedAccess && (<IndexedAccess>node.parent).index === node) {
var objectType = checkExpression((<IndexedAccess>node.parent).object);
if (node.parent.kind == SyntaxKind.ElementAccessExpression && (<ElementAccessExpression>node.parent).argumentExpression === node) {
var objectType = checkExpression((<ElementAccessExpression>node.parent).expression);
if (objectType === unknownType) return undefined;
var apparentType = getApparentType(objectType);
if (apparentType === unknownType) return undefined;
@@ -9160,7 +9160,7 @@ module ts {
return getNodeLinks(node).enumMemberValue;
}
function getConstantValue(node: PropertyAccess | IndexedAccess): number {
function getConstantValue(node: PropertyAccess | ElementAccessExpression): number {
var symbol = getNodeLinks(node).resolvedSymbol;
if (symbol && (symbol.flags & SymbolFlags.EnumMember)) {
var declaration = symbol.valueDeclaration;
src/compiler/emitter.ts
+17 -17
View File
@@ -2027,7 +2027,7 @@ module ts {
switch (parent.kind) {
case SyntaxKind.CallExpression:
case SyntaxKind.NewExpression:
return (<CallExpression>parent).func === template;
return (<CallExpression>parent).expression === template;
case SyntaxKind.ParenExpression:
return false;
case SyntaxKind.TaggedTemplateExpression:
@@ -2249,10 +2249,10 @@ module ts {
}
}
function tryEmitConstantValue(node: PropertyAccess | IndexedAccess): boolean {
function tryEmitConstantValue(node: PropertyAccess | ElementAccessExpression): boolean {
var constantValue = resolver.getConstantValue(node);
if (constantValue !== undefined) {
var propertyName = node.kind === SyntaxKind.PropertyAccess ? declarationNameToString((<PropertyAccess>node).right) : getTextOfNode((<IndexedAccess>node).index);
var propertyName = node.kind === SyntaxKind.PropertyAccess ? declarationNameToString((<PropertyAccess>node).right) : getTextOfNode((<ElementAccessExpression>node).argumentExpression);
write(constantValue.toString() + " /* " + propertyName + " */");
return true;
}
@@ -2268,29 +2268,29 @@ module ts {
emit(node.right);
}
function emitIndexedAccess(node: IndexedAccess) {
function emitIndexedAccess(node: ElementAccessExpression) {
if (tryEmitConstantValue(node)) {
return;
}
emit(node.object);
emit(node.expression);
write("[");
emit(node.index);
emit(node.argumentExpression);
write("]");
}
function emitCallExpression(node: CallExpression) {
var superCall = false;
if (node.func.kind === SyntaxKind.SuperKeyword) {
if (node.expression.kind === SyntaxKind.SuperKeyword) {
write("_super");
superCall = true;
}
else {
emit(node.func);
superCall = node.func.kind === SyntaxKind.PropertyAccess && (<PropertyAccess>node.func).left.kind === SyntaxKind.SuperKeyword;
emit(node.expression);
superCall = node.expression.kind === SyntaxKind.PropertyAccess && (<PropertyAccess>node.expression).left.kind === SyntaxKind.SuperKeyword;
}
if (superCall) {
write(".call(");
emitThis(node.func);
emitThis(node.expression);
if (node.arguments.length) {
write(", ");
emitCommaList(node.arguments, /*includeTrailingComma*/ false);
@@ -2306,7 +2306,7 @@ module ts {
function emitNewExpression(node: NewExpression) {
write("new ");
emit(node.func);
emit(node.expression);
if (node.arguments) {
write("(");
emitCommaList(node.arguments, /*includeTrailingComma*/ false);
@@ -2323,12 +2323,12 @@ module ts {
function emitParenExpression(node: ParenExpression) {
if (node.expression.kind === SyntaxKind.TypeAssertion) {
var operand = (<TypeAssertion>node.expression).operand;
var operand = (<TypeAssertion>node.expression).expression;
// Make sure we consider all nested cast expressions, e.g.:
// (<any><number><any>-A).x;
while (operand.kind == SyntaxKind.TypeAssertion) {
operand = (<TypeAssertion>operand).operand;
operand = (<TypeAssertion>operand).expression;
}
// We have an expression of the form: (<Type>SubExpr)
@@ -2883,7 +2883,7 @@ module ts {
if (statement && statement.kind === SyntaxKind.ExpressionStatement) {
var expr = (<ExpressionStatement>statement).expression;
if (expr && expr.kind === SyntaxKind.CallExpression) {
var func = (<CallExpression>expr).func;
var func = (<CallExpression>expr).expression;
if (func && func.kind === SyntaxKind.SuperKeyword) {
return <ExpressionStatement>statement;
}
@@ -3507,8 +3507,8 @@ module ts {
return emitComputedPropertyName(<ComputedPropertyName>node);
case SyntaxKind.PropertyAccess:
return emitPropertyAccess(<PropertyAccess>node);
case SyntaxKind.IndexedAccess:
return emitIndexedAccess(<IndexedAccess>node);
case SyntaxKind.ElementAccessExpression:
return emitIndexedAccess(<ElementAccessExpression>node);
case SyntaxKind.CallExpression:
return emitCallExpression(<CallExpression>node);
case SyntaxKind.NewExpression:
@@ -3516,7 +3516,7 @@ module ts {
case SyntaxKind.TaggedTemplateExpression:
return emitTaggedTemplateExpression(<TaggedTemplateExpression>node);
case SyntaxKind.TypeAssertion:
return emit((<TypeAssertion>node).operand);
return emit((<TypeAssertion>node).expression);
case SyntaxKind.ParenExpression:
return emitParenExpression(<ParenExpression>node);
case SyntaxKind.FunctionDeclaration:
src/compiler/parser.ts
+23 -23
View File
@@ -262,12 +262,12 @@ module ts {
case SyntaxKind.PropertyAccess:
return child((<PropertyAccess>node).left) ||
child((<PropertyAccess>node).right);
case SyntaxKind.IndexedAccess:
return child((<IndexedAccess>node).object) ||
child((<IndexedAccess>node).index);
case SyntaxKind.ElementAccessExpression:
return child((<ElementAccessExpression>node).expression) ||
child((<ElementAccessExpression>node).argumentExpression);
case SyntaxKind.CallExpression:
case SyntaxKind.NewExpression:
return child((<CallExpression>node).func) ||
return child((<CallExpression>node).expression) ||
children((<CallExpression>node).typeArguments) ||
children((<CallExpression>node).arguments);
case SyntaxKind.TaggedTemplateExpression:
@@ -275,7 +275,7 @@ module ts {
child((<TaggedTemplateExpression>node).template);
case SyntaxKind.TypeAssertion:
return child((<TypeAssertion>node).type) ||
child((<TypeAssertion>node).operand);
child((<TypeAssertion>node).expression);
case SyntaxKind.ParenExpression:
return child((<ParenExpression>node).expression);
case SyntaxKind.DeleteExpression:
@@ -502,7 +502,7 @@ module ts {
}
// Will either be a CallExpression or NewExpression.
return (<CallExpression>node).func;
return (<CallExpression>node).expression;
}
export function isExpression(node: Node): boolean {
@@ -516,7 +516,7 @@ module ts {
case SyntaxKind.ArrayLiteral:
case SyntaxKind.ObjectLiteral:
case SyntaxKind.PropertyAccess:
case SyntaxKind.IndexedAccess:
case SyntaxKind.ElementAccessExpression:
case SyntaxKind.CallExpression:
case SyntaxKind.NewExpression:
case SyntaxKind.TaggedTemplateExpression:
@@ -572,7 +572,7 @@ module ts {
return (<ForInStatement>parent).variable === node ||
(<ForInStatement>parent).expression === node;
case SyntaxKind.TypeAssertion:
return node === (<TypeAssertion>parent).operand;
return node === (<TypeAssertion>parent).expression;
case SyntaxKind.TemplateSpan:
return node === (<TemplateSpan>parent).expression;
default:
@@ -2798,7 +2798,7 @@ module ts {
parseExpected(SyntaxKind.LessThanToken);
node.type = parseType();
parseExpected(SyntaxKind.GreaterThanToken);
node.operand = parseUnaryExpressionOrHigher();
node.expression = parseUnaryExpressionOrHigher();
return finishNode(node);
}
@@ -2853,21 +2853,21 @@ module ts {
}
if (token === SyntaxKind.OpenBracketToken) {
var indexedAccess = <IndexedAccess>createNode(SyntaxKind.IndexedAccess, expression.pos);
indexedAccess.object = expression;
var indexedAccess = <ElementAccessExpression>createNode(SyntaxKind.ElementAccessExpression, expression.pos);
indexedAccess.expression = expression;
indexedAccess.openBracketToken = parseTokenNode(SyntaxKind.OpenBracketToken);
// It's not uncommon for a user to write: "new Type[]".
// Check for that common pattern and report a better error message.
if (token !== SyntaxKind.CloseBracketToken) {
indexedAccess.index = allowInAnd(parseExpression);
if (indexedAccess.index.kind === SyntaxKind.StringLiteral || indexedAccess.index.kind === SyntaxKind.NumericLiteral) {
var literal = <LiteralExpression>indexedAccess.index;
indexedAccess.argumentExpression = allowInAnd(parseExpression);
if (indexedAccess.argumentExpression.kind === SyntaxKind.StringLiteral || indexedAccess.argumentExpression.kind === SyntaxKind.NumericLiteral) {
var literal = <LiteralExpression>indexedAccess.argumentExpression;
literal.text = internIdentifier(literal.text);
}
}
else {
indexedAccess.index = createMissingNode();
indexedAccess.argumentExpression = createMissingNode();
}
indexedAccess.closeBracketToken = parseTokenNode(SyntaxKind.CloseBracketToken);
@@ -2901,7 +2901,7 @@ module ts {
}
var callExpr = <CallExpression>createNode(SyntaxKind.CallExpression, expression.pos);
callExpr.func = expression;
callExpr.expression = expression;
callExpr.typeArguments = typeArguments;
callExpr.arguments = parseDelimitedList(ParsingContext.ArgumentExpressions, parseArgumentExpression);
parseExpected(SyntaxKind.CloseParenToken);
@@ -2911,7 +2911,7 @@ module ts {
if (token === SyntaxKind.OpenParenToken) {
var callExpr = <CallExpression>createNode(SyntaxKind.CallExpression, expression.pos);
callExpr.func = expression;
callExpr.expression = expression;
parseExpected(SyntaxKind.OpenParenToken);
callExpr.arguments = parseDelimitedList(ParsingContext.ArgumentExpressions, parseArgumentExpression);
parseExpected(SyntaxKind.CloseParenToken);
@@ -3123,7 +3123,7 @@ module ts {
function parseNewExpression(): NewExpression {
var node = <NewExpression>createNode(SyntaxKind.NewExpression);
parseExpected(SyntaxKind.NewKeyword);
node.func = parseMemberExpressionOrHigher();
node.expression = parseMemberExpressionOrHigher();
if (parseOptional(SyntaxKind.OpenParenToken) || (token === SyntaxKind.LessThanToken && (node.typeArguments = tryParse(parseTypeArgumentsAndOpenParen)))) {
node.arguments = parseDelimitedList(ParsingContext.ArgumentExpressions, parseArgumentExpression);
parseExpected(SyntaxKind.CloseParenToken);
@@ -4120,7 +4120,7 @@ module ts {
if (expr) {
switch (expr.kind) {
case SyntaxKind.PropertyAccess:
case SyntaxKind.IndexedAccess:
case SyntaxKind.ElementAccessExpression:
case SyntaxKind.NewExpression:
case SyntaxKind.CallExpression:
case SyntaxKind.TaggedTemplateExpression:
@@ -4236,7 +4236,7 @@ module ts {
case SyntaxKind.FunctionDeclaration: return checkFunctionDeclaration(<FunctionLikeDeclaration>node);
case SyntaxKind.FunctionExpression: return checkFunctionExpression(<FunctionExpression>node);
case SyntaxKind.GetAccessor: return checkGetAccessor(<MethodDeclaration>node);
case SyntaxKind.IndexedAccess: return checkIndexedAccess(<IndexedAccess>node);
case SyntaxKind.ElementAccessExpression: return checkIndexedAccess(<ElementAccessExpression>node);
case SyntaxKind.IndexSignature: return checkIndexSignature(<SignatureDeclaration>node);
case SyntaxKind.InterfaceDeclaration: return checkInterfaceDeclaration(<InterfaceDeclaration>node);
case SyntaxKind.LabeledStatement: return checkLabeledStatement(<LabeledStatement>node);
@@ -4632,10 +4632,10 @@ module ts {
checkAccessor(node);
}
function checkIndexedAccess(node: IndexedAccess) {
if (node.index.kind === SyntaxKind.Missing) {
function checkIndexedAccess(node: ElementAccessExpression) {
if (node.argumentExpression.kind === SyntaxKind.Missing) {
if (node.parent.kind === SyntaxKind.NewExpression &&
(<NewExpression>node.parent).func === node) {
(<NewExpression>node.parent).expression === node) {
var start = skipTrivia(sourceText, node.openBracketToken.pos);
var end = node.closeBracketToken.end;
src/compiler/types.ts
+7 -7
View File
@@ -170,7 +170,7 @@ module ts {
PropertyAssignment,
ShorthandPropertyAssignment,
PropertyAccess,
IndexedAccess,
ElementAccessExpression,
CallExpression,
NewExpression,
TaggedTemplateExpression,
@@ -512,15 +512,15 @@ module ts {
right: Identifier;
}
export interface IndexedAccess extends Expression {
object: Expression;
export interface ElementAccessExpression extends Expression {
expression: Expression;
openBracketToken: Node;
index: Expression;
argumentExpression: Expression;
closeBracketToken: Node;
}
export interface CallExpression extends Expression {
func: Expression;
expression: Expression;
typeArguments?: NodeArray<TypeNode>;
arguments: NodeArray<Expression>;
}
@@ -536,7 +536,7 @@ module ts {
export interface TypeAssertion extends Expression {
type: TypeNode;
operand: Expression;
expression: Expression;
}
export interface Statement extends Node { }
@@ -890,7 +890,7 @@ module ts {
isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult;
isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
// Returns the constant value this property access resolves to, or 'undefined' for a non-constant
getConstantValue(node: PropertyAccess | IndexedAccess): number;
getConstantValue(node: PropertyAccess | ElementAccessExpression): number;
isEmitBlocked(sourceFile?: SourceFile): boolean;
}
src/harness/typeWriter.ts
+1 -1
View File
@@ -32,7 +32,7 @@ class TypeWriterWalker {
case ts.SyntaxKind.ArrayLiteral:
case ts.SyntaxKind.ObjectLiteral:
case ts.SyntaxKind.PropertyAccess:
case ts.SyntaxKind.IndexedAccess:
case ts.SyntaxKind.ElementAccessExpression:
case ts.SyntaxKind.CallExpression:
case ts.SyntaxKind.NewExpression:
case ts.SyntaxKind.TypeAssertion:
src/services/breakpoints.ts
+2 -2
View File
@@ -243,7 +243,7 @@ module ts.BreakpointResolver {
// Breakpoint in type assertion goes to its operand
if (node.parent.kind === SyntaxKind.TypeAssertion && (<TypeAssertion>node.parent).type === node) {
return spanInNode((<TypeAssertion>node.parent).operand);
return spanInNode((<TypeAssertion>node.parent).expression);
}
// return type of function go to previous token
@@ -484,7 +484,7 @@ module ts.BreakpointResolver {
function spanInGreaterThanOrLessThanToken(node: Node): TextSpan {
if (node.parent.kind === SyntaxKind.TypeAssertion) {
return spanInNode((<TypeAssertion>node.parent).operand);
return spanInNode((<TypeAssertion>node.parent).expression);
}
return spanInNode(node.parent);
src/services/services.ts
+5 -5
View File
@@ -1934,14 +1934,14 @@ module ts {
if (isRightSideOfPropertyAccess(node)) {
node = node.parent;
}
return node && node.parent && node.parent.kind === SyntaxKind.CallExpression && (<CallExpression>node.parent).func === node;
return node && node.parent && node.parent.kind === SyntaxKind.CallExpression && (<CallExpression>node.parent).expression === node;
}
function isNewExpressionTarget(node: Node): boolean {
if (isRightSideOfPropertyAccess(node)) {
node = node.parent;
}
return node && node.parent && node.parent.kind === SyntaxKind.NewExpression && (<CallExpression>node.parent).func === node;
return node && node.parent && node.parent.kind === SyntaxKind.NewExpression && (<CallExpression>node.parent).expression === node;
}
function isNameOfModuleDeclaration(node: Node) {
@@ -1970,8 +1970,8 @@ module ts {
case SyntaxKind.SetAccessor:
case SyntaxKind.ModuleDeclaration:
return (<Declaration>node.parent).name === node;
case SyntaxKind.IndexedAccess:
return (<IndexedAccess>node.parent).index === node;
case SyntaxKind.ElementAccessExpression:
return (<ElementAccessExpression>node.parent).argumentExpression === node;
}
}
@@ -2903,7 +2903,7 @@ module ts {
signature = candidateSignatures[0];
}
var useConstructSignatures = callExpression.kind === SyntaxKind.NewExpression || callExpression.func.kind === SyntaxKind.SuperKeyword;
var useConstructSignatures = callExpression.kind === SyntaxKind.NewExpression || callExpression.expression.kind === SyntaxKind.SuperKeyword;
var allSignatures = useConstructSignatures ? type.getConstructSignatures() : type.getCallSignatures();
if (!contains(allSignatures, signature.target || signature)) {