|
| 1 | +/* @internal */ |
| 2 | +namespace ts.codefix { |
| 3 | + type AcceptedDeclaration = ParameterPropertyDeclaration | PropertyDeclaration | PropertyAssignment; |
| 4 | + type AcceptedNameType = Identifier | StringLiteral; |
| 5 | + type ContainerDeclaration = ClassLikeDeclaration | ObjectLiteralExpression; |
| 6 | + |
| 7 | + interface Info { |
| 8 | + readonly container: ContainerDeclaration; |
| 9 | + readonly isStatic: boolean; |
| 10 | + readonly isReadonly: boolean; |
| 11 | + readonly type: TypeNode | undefined; |
| 12 | + readonly declaration: AcceptedDeclaration; |
| 13 | + readonly fieldName: AcceptedNameType; |
| 14 | + readonly accessorName: AcceptedNameType; |
| 15 | + readonly originalName: string; |
| 16 | + readonly renameAccessor: boolean; |
| 17 | + } |
| 18 | + |
| 19 | + export function generateAccessorFromProperty(file: SourceFile, start: number, end: number, context: textChanges.TextChangesContext, _actionName: string): FileTextChanges[] | undefined { |
| 20 | + const fieldInfo = getAccessorConvertiblePropertyAtPosition(file, start, end); |
| 21 | + if (!fieldInfo) return undefined; |
| 22 | + |
| 23 | + const changeTracker = textChanges.ChangeTracker.fromContext(context); |
| 24 | + const { isStatic, isReadonly, fieldName, accessorName, originalName, type, container, declaration } = fieldInfo; |
| 25 | + |
| 26 | + suppressLeadingAndTrailingTrivia(fieldName); |
| 27 | + suppressLeadingAndTrailingTrivia(accessorName); |
| 28 | + suppressLeadingAndTrailingTrivia(declaration); |
| 29 | + suppressLeadingAndTrailingTrivia(container); |
| 30 | + |
| 31 | + let accessorModifiers: ModifiersArray | undefined; |
| 32 | + let fieldModifiers: ModifiersArray | undefined; |
| 33 | + if (isClassLike(container)) { |
| 34 | + const modifierFlags = getEffectiveModifierFlags(declaration); |
| 35 | + if (isSourceFileJS(file)) { |
| 36 | + const modifiers = createModifiers(modifierFlags); |
| 37 | + accessorModifiers = modifiers; |
| 38 | + fieldModifiers = modifiers; |
| 39 | + } |
| 40 | + else { |
| 41 | + accessorModifiers = createModifiers(prepareModifierFlagsForAccessor(modifierFlags)); |
| 42 | + fieldModifiers = createModifiers(prepareModifierFlagsForField(modifierFlags)); |
| 43 | + } |
| 44 | + } |
| 45 | + |
| 46 | + updateFieldDeclaration(changeTracker, file, declaration, fieldName, fieldModifiers); |
| 47 | + |
| 48 | + const getAccessor = generateGetAccessor(fieldName, accessorName, type, accessorModifiers, isStatic, container); |
| 49 | + suppressLeadingAndTrailingTrivia(getAccessor); |
| 50 | + insertAccessor(changeTracker, file, getAccessor, declaration, container); |
| 51 | + |
| 52 | + if (isReadonly) { |
| 53 | + // readonly modifier only existed in classLikeDeclaration |
| 54 | + const constructor = getFirstConstructorWithBody(<ClassLikeDeclaration>container); |
| 55 | + if (constructor) { |
| 56 | + updateReadonlyPropertyInitializerStatementConstructor(changeTracker, file, constructor, fieldName.text, originalName); |
| 57 | + } |
| 58 | + } |
| 59 | + else { |
| 60 | + const setAccessor = generateSetAccessor(fieldName, accessorName, type, accessorModifiers, isStatic, container); |
| 61 | + suppressLeadingAndTrailingTrivia(setAccessor); |
| 62 | + insertAccessor(changeTracker, file, setAccessor, declaration, container); |
| 63 | + } |
| 64 | + |
| 65 | + return changeTracker.getChanges(); |
| 66 | + } |
| 67 | + |
| 68 | + function isConvertibleName(name: DeclarationName): name is AcceptedNameType { |
| 69 | + return isIdentifier(name) || isStringLiteral(name); |
| 70 | + } |
| 71 | + |
| 72 | + function isAcceptedDeclaration(node: Node): node is AcceptedDeclaration { |
| 73 | + return isParameterPropertyDeclaration(node, node.parent) || isPropertyDeclaration(node) || isPropertyAssignment(node); |
| 74 | + } |
| 75 | + |
| 76 | + function createPropertyName(name: string, originalName: AcceptedNameType) { |
| 77 | + return isIdentifier(originalName) ? createIdentifier(name) : createLiteral(name); |
| 78 | + } |
| 79 | + |
| 80 | + function createAccessorAccessExpression(fieldName: AcceptedNameType, isStatic: boolean, container: ContainerDeclaration) { |
| 81 | + const leftHead = isStatic ? (<ClassLikeDeclaration>container).name! : createThis(); // TODO: GH#18217 |
| 82 | + return isIdentifier(fieldName) ? createPropertyAccess(leftHead, fieldName) : createElementAccess(leftHead, createLiteral(fieldName)); |
| 83 | + } |
| 84 | + |
| 85 | + function createModifiers(modifierFlags: ModifierFlags): ModifiersArray | undefined { |
| 86 | + return modifierFlags ? createNodeArray(createModifiersFromModifierFlags(modifierFlags)) : undefined; |
| 87 | + } |
| 88 | + |
| 89 | + function prepareModifierFlagsForAccessor(modifierFlags: ModifierFlags): ModifierFlags { |
| 90 | + modifierFlags &= ~ModifierFlags.Readonly; // avoid Readonly modifier because it will convert to get accessor |
| 91 | + modifierFlags &= ~ModifierFlags.Private; |
| 92 | + |
| 93 | + if (!(modifierFlags & ModifierFlags.Protected)) { |
| 94 | + modifierFlags |= ModifierFlags.Public; |
| 95 | + } |
| 96 | + |
| 97 | + return modifierFlags; |
| 98 | + } |
| 99 | + |
| 100 | + function prepareModifierFlagsForField(modifierFlags: ModifierFlags): ModifierFlags { |
| 101 | + modifierFlags &= ~ModifierFlags.Public; |
| 102 | + modifierFlags &= ~ModifierFlags.Protected; |
| 103 | + modifierFlags |= ModifierFlags.Private; |
| 104 | + return modifierFlags; |
| 105 | + } |
| 106 | + |
| 107 | + export function getAccessorConvertiblePropertyAtPosition(file: SourceFile, start: number, end: number): Info | undefined { |
| 108 | + const node = getTokenAtPosition(file, start); |
| 109 | + const declaration = findAncestor(node.parent, isAcceptedDeclaration); |
| 110 | + // make sure declaration have AccessibilityModifier or Static Modifier or Readonly Modifier |
| 111 | + const meaning = ModifierFlags.AccessibilityModifier | ModifierFlags.Static | ModifierFlags.Readonly; |
| 112 | + if (!declaration || !nodeOverlapsWithStartEnd(declaration.name, file, start, end) |
| 113 | + || !isConvertibleName(declaration.name) || (getEffectiveModifierFlags(declaration) | meaning) !== meaning) return undefined; |
| 114 | + |
| 115 | + const name = declaration.name.text; |
| 116 | + const startWithUnderscore = startsWithUnderscore(name); |
| 117 | + const fieldName = createPropertyName(startWithUnderscore ? name : getUniqueName(`_${name}`, file), declaration.name); |
| 118 | + const accessorName = createPropertyName(startWithUnderscore ? getUniqueName(name.substring(1), file) : name, declaration.name); |
| 119 | + return { |
| 120 | + isStatic: hasStaticModifier(declaration), |
| 121 | + isReadonly: hasEffectiveReadonlyModifier(declaration), |
| 122 | + type: getTypeAnnotationNode(declaration), |
| 123 | + container: declaration.kind === SyntaxKind.Parameter ? declaration.parent.parent : declaration.parent, |
| 124 | + originalName: (<AcceptedNameType>declaration.name).text, |
| 125 | + declaration, |
| 126 | + fieldName, |
| 127 | + accessorName, |
| 128 | + renameAccessor: startWithUnderscore |
| 129 | + }; |
| 130 | + } |
| 131 | + |
| 132 | + function generateGetAccessor(fieldName: AcceptedNameType, accessorName: AcceptedNameType, type: TypeNode | undefined, modifiers: ModifiersArray | undefined, isStatic: boolean, container: ContainerDeclaration) { |
| 133 | + return createGetAccessor( |
| 134 | + /*decorators*/ undefined, |
| 135 | + modifiers, |
| 136 | + accessorName, |
| 137 | + /*parameters*/ undefined!, // TODO: GH#18217 |
| 138 | + type, |
| 139 | + createBlock([ |
| 140 | + createReturn( |
| 141 | + createAccessorAccessExpression(fieldName, isStatic, container) |
| 142 | + ) |
| 143 | + ], /*multiLine*/ true) |
| 144 | + ); |
| 145 | + } |
| 146 | + |
| 147 | + function generateSetAccessor(fieldName: AcceptedNameType, accessorName: AcceptedNameType, type: TypeNode | undefined, modifiers: ModifiersArray | undefined, isStatic: boolean, container: ContainerDeclaration) { |
| 148 | + return createSetAccessor( |
| 149 | + /*decorators*/ undefined, |
| 150 | + modifiers, |
| 151 | + accessorName, |
| 152 | + [createParameter( |
| 153 | + /*decorators*/ undefined, |
| 154 | + /*modifiers*/ undefined, |
| 155 | + /*dotDotDotToken*/ undefined, |
| 156 | + createIdentifier("value"), |
| 157 | + /*questionToken*/ undefined, |
| 158 | + type |
| 159 | + )], |
| 160 | + createBlock([ |
| 161 | + createStatement( |
| 162 | + createAssignment( |
| 163 | + createAccessorAccessExpression(fieldName, isStatic, container), |
| 164 | + createIdentifier("value") |
| 165 | + ) |
| 166 | + ) |
| 167 | + ], /*multiLine*/ true) |
| 168 | + ); |
| 169 | + } |
| 170 | + |
| 171 | + function updatePropertyDeclaration(changeTracker: textChanges.ChangeTracker, file: SourceFile, declaration: PropertyDeclaration, fieldName: AcceptedNameType, modifiers: ModifiersArray | undefined) { |
| 172 | + const property = updateProperty( |
| 173 | + declaration, |
| 174 | + declaration.decorators, |
| 175 | + modifiers, |
| 176 | + fieldName, |
| 177 | + declaration.questionToken || declaration.exclamationToken, |
| 178 | + declaration.type, |
| 179 | + declaration.initializer |
| 180 | + ); |
| 181 | + changeTracker.replaceNode(file, declaration, property); |
| 182 | + } |
| 183 | + |
| 184 | + function updatePropertyAssignmentDeclaration(changeTracker: textChanges.ChangeTracker, file: SourceFile, declaration: PropertyAssignment, fieldName: AcceptedNameType) { |
| 185 | + const assignment = updatePropertyAssignment(declaration, fieldName, declaration.initializer); |
| 186 | + changeTracker.replacePropertyAssignment(file, declaration, assignment); |
| 187 | + } |
| 188 | + |
| 189 | + function updateFieldDeclaration(changeTracker: textChanges.ChangeTracker, file: SourceFile, declaration: AcceptedDeclaration, fieldName: AcceptedNameType, modifiers: ModifiersArray | undefined) { |
| 190 | + if (isPropertyDeclaration(declaration)) { |
| 191 | + updatePropertyDeclaration(changeTracker, file, declaration, fieldName, modifiers); |
| 192 | + } |
| 193 | + else if (isPropertyAssignment(declaration)) { |
| 194 | + updatePropertyAssignmentDeclaration(changeTracker, file, declaration, fieldName); |
| 195 | + } |
| 196 | + else { |
| 197 | + changeTracker.replaceNode(file, declaration, |
| 198 | + updateParameter(declaration, declaration.decorators, modifiers, declaration.dotDotDotToken, cast(fieldName, isIdentifier), declaration.questionToken, declaration.type, declaration.initializer)); |
| 199 | + } |
| 200 | + } |
| 201 | + |
| 202 | + function insertAccessor(changeTracker: textChanges.ChangeTracker, file: SourceFile, accessor: AccessorDeclaration, declaration: AcceptedDeclaration, container: ContainerDeclaration) { |
| 203 | + isParameterPropertyDeclaration(declaration, declaration.parent) ? changeTracker.insertNodeAtClassStart(file, <ClassLikeDeclaration>container, accessor) : |
| 204 | + isPropertyAssignment(declaration) ? changeTracker.insertNodeAfterComma(file, declaration, accessor) : |
| 205 | + changeTracker.insertNodeAfter(file, declaration, accessor); |
| 206 | + } |
| 207 | + |
| 208 | + function updateReadonlyPropertyInitializerStatementConstructor(changeTracker: textChanges.ChangeTracker, file: SourceFile, constructor: ConstructorDeclaration, fieldName: string, originalName: string) { |
| 209 | + if (!constructor.body) return; |
| 210 | + constructor.body.forEachChild(function recur(node) { |
| 211 | + if (isElementAccessExpression(node) && |
| 212 | + node.expression.kind === SyntaxKind.ThisKeyword && |
| 213 | + isStringLiteral(node.argumentExpression) && |
| 214 | + node.argumentExpression.text === originalName && |
| 215 | + isWriteAccess(node)) { |
| 216 | + changeTracker.replaceNode(file, node.argumentExpression, createStringLiteral(fieldName)); |
| 217 | + } |
| 218 | + if (isPropertyAccessExpression(node) && node.expression.kind === SyntaxKind.ThisKeyword && node.name.text === originalName && isWriteAccess(node)) { |
| 219 | + changeTracker.replaceNode(file, node.name, createIdentifier(fieldName)); |
| 220 | + } |
| 221 | + if (!isFunctionLike(node) && !isClassLike(node)) { |
| 222 | + node.forEachChild(recur); |
| 223 | + } |
| 224 | + }); |
| 225 | + } |
| 226 | + |
| 227 | + export function getAllSupers(decl: ClassOrInterface | undefined, checker: TypeChecker): readonly ClassOrInterface[] { |
| 228 | + const res: ClassLikeDeclaration[] = []; |
| 229 | + while (decl) { |
| 230 | + const superElement = getClassExtendsHeritageElement(decl); |
| 231 | + const superSymbol = superElement && checker.getSymbolAtLocation(superElement.expression); |
| 232 | + if (!superSymbol) break; |
| 233 | + const symbol = superSymbol.flags & SymbolFlags.Alias ? checker.getAliasedSymbol(superSymbol) : superSymbol; |
| 234 | + const superDecl = find(symbol.declarations, isClassLike); |
| 235 | + if (!superDecl) break; |
| 236 | + res.push(superDecl); |
| 237 | + decl = superDecl; |
| 238 | + } |
| 239 | + return res; |
| 240 | + } |
| 241 | + |
| 242 | + export type ClassOrInterface = ClassLikeDeclaration | InterfaceDeclaration; |
| 243 | +} |
0 commit comments