maxmustermann/TypeScript
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

some missed token bugs

Browse source
This commit is contained in:
Arthur Ozga 2017-03-13 20:20:26 -07:00
parent e02ac178ca
commit 27fe2df203
9 changed files with 34 additions and 36 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
src/compiler/checker.ts
View file

@ -2361,7 +2361,7 @@ namespace ts {
return createArrayTypeNode(elementType);
}
else if (type.target.objectFlags & ObjectFlags.Tuple) {
return createTupleTypeNode(mapToTypeNodeArray(typeArguments.slice(0, getTypeReferenceArity(type))));
return createTupleTypeNode(typeArguments.length > 0 ? mapToTypeNodeArray(typeArguments.slice(0, getTypeReferenceArity(type))) : undefined);
}
else {
// TODO: handle type parameters in qualified names...
@ -2406,7 +2406,7 @@ namespace ts {
entityName = nameIdentifier;
}
const typeParameterCount = (type.target.typeParameters || emptyArray).length;
const typeArgumentNodes = mapToTypeNodeArray(typeArguments.slice(i, typeParameterCount - i));
const typeArgumentNodes = mapToTypeNodeArray(typeArguments.length > 0 ? typeArguments.slice(i, typeParameterCount - i) : undefined);
return createTypeReferenceNode(entityName, typeArgumentNodes);
}
}
@ -2478,7 +2478,8 @@ namespace ts {
, /*dotDotDotToken*/ undefined
, name
, /*questionToken*/ undefined
, stringTypeNode);
, stringTypeNode
, /*initializer*/ undefined);
const typeNode = createTypeNode(indexInfo.type);
return createIndexSignatureDeclaration(
[indexingParameter]
@ -7261,10 +7262,6 @@ namespace ts {
}
}
// export function synthesizeTypeNode(type: Type, enclosingDeclaration: Node): TypeNode {
// throw new Error("Not implemented" + enclosingDeclaration);
// }
function instantiateList<T>(items: T[], mapper: TypeMapper, instantiator: (item: T, mapper: TypeMapper) => T): T[] {
if (items && items.length) {
const result: T[] = [];

9
src/compiler/factory.ts
View file

@ -355,8 +355,6 @@ namespace ts {
export function createIndexSignatureDeclaration(parameters: ParameterDeclaration[], type: TypeNode, decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined): IndexSignatureDeclaration {
const indexSignature = createSynthesizedNode(SyntaxKind.IndexSignature) as IndexSignatureDeclaration;
// indexSignature.name = asName(name);
// type parameters
indexSignature.parameters = asNodeArray(parameters);
indexSignature.type = type;
indexSignature.decorators = asNodeArray(decorators);
@ -373,6 +371,8 @@ namespace ts {
: node;
}
// Signature elements
export function createParameter(decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken?: QuestionToken, type?: TypeNode, initializer?: Expression) {
const node = <ParameterDeclaration>createSynthesizedNode(SyntaxKind.Parameter);
node.decorators = asNodeArray(decorators);
@ -385,11 +385,12 @@ namespace ts {
return node;
}
export function updateParameter(node: ParameterDeclaration, decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: BindingName, type: TypeNode | undefined, initializer: Expression | undefined) {
export function updateParameter(node: ParameterDeclaration, decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined) {
return node.decorators !== decorators
|| node.modifiers !== modifiers
|| node.dotDotDotToken !== dotDotDotToken
|| node.name !== name
|| node.questionToken !== questionToken
|| node.type !== type
|| node.initializer !== initializer
? updateNode(createParameter(decorators, modifiers, dotDotDotToken, name, node.questionToken, type, initializer), node)
@ -438,7 +439,7 @@ namespace ts {
node.asteriskToken = asteriskToken;
node.name = asName(name);
node.typeParameters = asNodeArray(typeParameters);
node.parameters = createNodeArray(parameters);
node.parameters = asNodeArray(parameters);
node.type = type;
node.body = body;
return node;

1
src/compiler/transformers/esnext.ts
View file

@ -475,6 +475,7 @@ namespace ts {
/*modifiers*/ undefined,
node.dotDotDotToken,
getGeneratedNameForNode(node),
node.questionToken,
/*type*/ undefined,
visitNode(node.initializer, visitor, isExpression)
);

2
src/compiler/types.ts
View file

@ -895,7 +895,7 @@ namespace ts {
exprName: EntityName;
}
/** A TypeLiteral is the declaration node for an anonymous symbol. */
// A TypeLiteral is the declaration node for an anonymous symbol.
export interface TypeLiteralNode extends TypeNode, Declaration {
kind: SyntaxKind.TypeLiteral;
members: NodeArray<TypeElement>;

1
src/compiler/visitor.ts
View file

@ -272,6 +272,7 @@ namespace ts {
nodesVisitor((<ParameterDeclaration>node).modifiers, visitor, isModifier),
(<ParameterDeclaration>node).dotDotDotToken,
visitNode((<ParameterDeclaration>node).name, visitor, isBindingName),
visitNode((<ParameterDeclaration>node).questionToken, visitor, isToken),
visitNode((<ParameterDeclaration>node).type, visitor, isTypeNode),
visitNode((<ParameterDeclaration>node).initializer, visitor, isExpression));

3
src/services/codefixes/fixAddMissingMember.ts
View file

@ -61,7 +61,8 @@ namespace ts.codefix {
, /*dotDotDotToken*/ undefined
, "x"
, /*questionToken*/ undefined
, stringTypeNode);
, stringTypeNode
, /*initializer*/ undefined);
const indexSignature = createIndexSignatureDeclaration(
[indexingParameter]
, typeNode

39
src/services/codefixes/helpers.ts
View file

@ -126,7 +126,7 @@ namespace ts.codefix {
}
else {
Debug.assert(declarations.length === signatures.length);
const methodImplementingSignatures = createMethodImplementingSignatures(signatures, enclosingDeclaration, name, modifiers);
const methodImplementingSignatures = createMethodImplementingSignatures(signatures, name, modifiers);
signatureDeclarations.push(methodImplementingSignatures);
}
return signatureDeclarations;
@ -135,11 +135,8 @@ namespace ts.codefix {
}
}
// TODO: infer types of arguments?
function createMethodImplementingSignatures(signatures: Signature[], enclosingDeclaration: ClassLikeDeclaration, name: string, modifiers: Modifier[] | undefined): MethodDeclaration {
const newMethodDeclaration = createNode(SyntaxKind.CallSignature) as SignatureDeclaration;
newMethodDeclaration.parent = enclosingDeclaration;
newMethodDeclaration.name = signatures[0].getDeclaration().name;
function createMethodImplementingSignatures(signatures: Signature[], name: string, modifiers: Modifier[] | undefined): MethodDeclaration {
Debug.assert(signatures && signatures.length > 0);
let maxNonRestArgs = -1;
let maxArgsIndex = 0;
@ -157,46 +154,45 @@ namespace ts.codefix {
}
const maxArgsParameterSymbolNames = signatures[maxArgsIndex].getParameters().map(symbol => symbol.getName());
const parameters = createNodeArray<ParameterDeclaration>();
const parameters: ParameterDeclaration[] = [];
for (let i = 0; i < maxNonRestArgs; i++) {
const anyType = createKeywordTypeNode(SyntaxKind.AnyKeyword);
const newParameter = createParameter(
/*decorators*/ undefined
, /*modifiers*/ undefined
, /*dotDotDotToken*/ undefined
, maxArgsParameterSymbolNames[i]
, /*questionToken*/ i >= minArgumentCount ? createToken(SyntaxKind.QuestionToken) : undefined
, /*type*/ undefined
, anyType
, /*initializer*/ undefined);
parameters.push(newParameter);
}
if (hasRestParameter) {
const anyType = createKeywordTypeNode(SyntaxKind.AnyKeyword);
const restParameter = createParameter(
/*decorators*/ undefined
, /*modifiers*/ undefined
, createToken(SyntaxKind.DotDotDotToken)
, maxArgsParameterSymbolNames[maxNonRestArgs] || "rest"
, /*questionToken*/ maxNonRestArgs >= minArgumentCount ? createToken(SyntaxKind.QuestionToken) : undefined
, /*type*/ undefined
, anyType
, /*initializer*/ undefined);
parameters.push(restParameter);
}
return createMethod(
/*decorators*/ undefined
, modifiers
, /*asteriskToken*/ undefined
return createStubbedMethod(
modifiers
, name
, /*typeParameters*/undefined
, parameters
, /*type*/ undefined
, /*body*/undefined);
, /*returnType*/ undefined);
}
export function createStubbedMethod(modifiers: Modifier[], name: string, typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], returnType?: TypeNode) {
export function createStubbedMethod(modifiers: Modifier[], name: string, typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], returnType: TypeNode | undefined) {
return createMethod(
/*decorators*/undefined
, /*modifiers*/modifiers
, modifiers
, /*asteriskToken*/undefined
, name
, typeParameters
@ -231,12 +227,13 @@ namespace ts.codefix {
const parameterTypeNode = checker.createTypeNode(parameterType);
// TODO: deep cloning of decorators/any node.
const parameterNode = createParameter(
parameterDeclaration.decorators && parameterDeclaration.decorators.map(getSynthesizedClone)
, parameterDeclaration.modifiers && parameterDeclaration.modifiers.map(getSynthesizedClone)
parameterDeclaration.decorators && parameterDeclaration.decorators.map(getSynthesizedDeepClone)
, parameterDeclaration.modifiers && parameterDeclaration.modifiers.map(getSynthesizedDeepClone)
, parameterDeclaration.dotDotDotToken && createToken(SyntaxKind.DotDotDotToken)
, parameterDeclaration.name
, getSynthesizedDeepClone(parameterDeclaration.name)
, parameterDeclaration.questionToken && createToken(SyntaxKind.QuestionToken)
, parameterTypeNode);
, parameterTypeNode
, /*initializer*/ undefined);
return parameterNode;
}

2
src/services/textChanges.ts
View file

@ -360,7 +360,7 @@ namespace ts.textChanges {
return visited;
}
// clone nodearray if necessary
const nodeArray = visited === nodes ? createNodeArray(visited) : visited;
const nodeArray = visited === nodes ? createNodeArray(visited.slice(0)) : visited;
nodeArray.pos = getPos(nodes);
nodeArray.end = getEnd(nodes);
return nodeArray;

2
tests/cases/fourslash/codeFixClassExtendAbstractGetterSetter.ts
View file

@ -28,4 +28,4 @@ verify.rangeAfterCodeFix(`
e: this;
f: A;
g: string;
`);
`);