Fixed detecting public/protected class fields declared in constructor

Fixes #13

Author: timocov

src/transformer.ts

@@ -3,12 +3,14 @@ import * as ts from 'typescript';
 import { ExportsSymbolTree } from './exports-symbol-tree';
 import {
 	getDeclarationsForSymbol,
+	getNodeJSDocComment,
 	isClassMember,
 	isConstructorParameter,
+	isNodeNamedDeclaration,
 	isPrivateClassMember,
+	isSymbolClassMember,
 	splitTransientSymbol,
-	getNodeJSDocComment,
-	isNodeNamedDeclaration,
+	getClassOfMemberSymbol,
 } from './typescript-helpers';
 
 export interface RenameOptions {
@@ -373,11 +375,13 @@ function createTransformerFactory(program: ts.Program, options?: Partial<RenameO
 				return VisibilityType.External;
 			}
 
-			if (isClassMember(node.parent) && isTypePropertyExternal(typeChecker.getTypeAtLocation(node.parent.parent), node.getText())) {
+			const nodeSymbol = getNodeSymbol(node);
+			const classOfMember = nodeSymbol !== null ? getClassOfMemberSymbol(nodeSymbol) : null;
+			if (classOfMember !== null && isTypePropertyExternal(typeChecker.getTypeAtLocation(classOfMember), node.getText())) {
 				return VisibilityType.External;
 			}
 
-			const symbol = ts.isBindingElement(node) ? getShorthandObjectBindingElementSymbol(node) : getNodeSymbol(node);
+			const symbol = ts.isBindingElement(node) ? getShorthandObjectBindingElementSymbol(node) : nodeSymbol;
 			if (symbol === null) {
 				return VisibilityType.External;
 			}
@@ -478,7 +482,7 @@ function createTransformerFactory(program: ts.Program, options?: Partial<RenameO
 				return false;
 			}
 
-			return isPrivateClassMember(typeChecker.getSymbolAtLocation(node));
+			return isSymbolClassMember(typeChecker.getSymbolAtLocation(node));
 		}
 
 		return (sourceFile: ts.SourceFile) => transformNodeAndChildren(sourceFile, context);

src/typescript-helpers.ts

@@ -9,6 +9,7 @@ const namedDeclarationKinds = [
 	ts.SyntaxKind.FunctionDeclaration,
 	ts.SyntaxKind.VariableDeclaration,
 	ts.SyntaxKind.PropertySignature,
+	ts.SyntaxKind.Parameter,
 ];
 
 export function isNodeNamedDeclaration(node: ts.Node): node is ts.NamedDeclaration {
@@ -111,6 +112,21 @@ export function isClassMember(node: ts.Node): node is ClassMember {
 	return ts.isMethodDeclaration(node) || ts.isPropertyDeclaration(node) || ts.isGetAccessor(node) || ts.isSetAccessor(node);
 }
 
+export function getClassOfMemberSymbol(nodeSymbol: ts.Symbol): ts.ClassLikeDeclaration | ts.ObjectLiteralExpression | null {
+	const classMembers = getClassMemberDeclarations(nodeSymbol);
+	if (classMembers.length !== 0) {
+		// we need any member to get class' declaration
+		const classMember = classMembers[0];
+		if (isConstructorParameter(classMember)) {
+			return (classMember.parent as ts.ConstructorDeclaration).parent;
+		}
+
+		return classMember.parent;
+	}
+
+	return null;
+}
+
 export function hasPrivateKeyword(node: ClassMember | ts.ParameterDeclaration): boolean {
 	return hasModifier(node, ts.SyntaxKind.PrivateKeyword);
 }
@@ -129,17 +145,29 @@ export function isConstructorParameter(node: ts.Node): node is ts.ParameterDecla
 		);
 }
 
-export function isPrivateClassMember(symbol: ts.Symbol | undefined): boolean {
-	// for some reason ts.Symbol.declarations can be undefined (for example in order to accessing to proto member)
-	if (symbol === undefined || symbol.declarations === undefined) { // tslint:disable-line:strict-type-predicates
-		return false;
+function getClassMemberDeclarations(symbol: ts.Symbol | undefined): (ClassMember | ts.ParameterDeclaration)[] {
+	if (symbol === undefined) {
+		return [];
 	}
 
-	return symbol.declarations.some((x: ts.Declaration) => {
-		return (isClassMember(x) || isConstructorParameter(x)) && hasPrivateKeyword(x);
+	const declarations = symbol.getDeclarations();
+	if (declarations === undefined) {
+		return [];
+	}
+
+	return declarations.filter((x: ts.Declaration): x is (ClassMember | ts.ParameterDeclaration) => {
+		return isClassMember(x) || isConstructorParameter(x);
 	});
 }
 
+export function isSymbolClassMember(symbol: ts.Symbol | undefined): boolean {
+	return getClassMemberDeclarations(symbol).length !== 0;
+}
+
+export function isPrivateClassMember(symbol: ts.Symbol | undefined): boolean {
+	return getClassMemberDeclarations(symbol).some(hasPrivateKeyword);
+}
+
 export function getNodeJSDocComment(node: ts.Node): string {
 	const start = node.getStart();
 	const jsDocStart = node.getStart(undefined, true);

tests/test-cases/reference-ctor-params/input.ts

@@ -1,7 +1,42 @@
+interface Foo {
+	bar: number;
+	baz: number;
+}
+
+class Measure {
+	height: number;
+
+	constructor(public width: number, public ascent: number, public descent: number) {
+		this.height = ascent + descent;
+	}
+}
+
+class Test {
+	constructor(public pub: number, protected prot: number, private priv: number) {
+		console.log(pub, prot, priv, this.pub, this.prot, this.priv);
+	}
+}
+
+export class ExportedClass {
+	constructor(public pub: number, protected prot: number, private priv: number) {
+		console.log(pub, prot, priv, this.pub, this.prot, this.priv);
+	}
+}
+
+class FooImpl implements Foo {
+	baz: number = 15;
+
+	constructor(public bar: number) {}
+}
+
 export class Class {
 	public constructor(
 		private privateField: number
 	) {
 		console.log(privateField);
 	}
+
+	public getFoo(): Foo {
+		return new FooImpl(42);
+	}
 }

tests/test-cases/reference-ctor-params/output.js

@@ -1,11 +1,49 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Class = void 0;
+exports.Class = exports.ExportedClass = void 0;
+var Measure = /** @class */ (function () {
+    function Measure(_internal_width, _internal_ascent, _internal_descent) {
+        this._internal_width = _internal_width;
+        this._internal_ascent = _internal_ascent;
+        this._internal_descent = _internal_descent;
+        this._internal_height = _internal_ascent + _internal_descent;
+    }
+    return Measure;
+}());
+var Test = /** @class */ (function () {
+    function Test(_internal_pub, _internal_prot, _private_priv) {
+        this._internal_pub = _internal_pub;
+        this._internal_prot = _internal_prot;
+        this._private_priv = _private_priv;
+        console.log(_internal_pub, _internal_prot, _private_priv, this._internal_pub, this._internal_prot, this._private_priv);
+    }
+    return Test;
+}());
+var ExportedClass = /** @class */ (function () {
+    function ExportedClass(pub, prot, _private_priv) {
+        this.pub = pub;
+        this.prot = prot;
+        this._private_priv = _private_priv;
+        console.log(pub, prot, _private_priv, this.pub, this.prot, this._private_priv);
+    }
+    return ExportedClass;
+}());
+exports.ExportedClass = ExportedClass;
+var FooImpl = /** @class */ (function () {
+    function FooImpl(bar) {
+        this.bar = bar;
+        this.baz = 15;
+    }
+    return FooImpl;
+}());
 var Class = /** @class */ (function () {
     function Class(_private_privateField) {
         this._private_privateField = _private_privateField;
         console.log(_private_privateField);
     }
+    Class.prototype.getFoo = function () {
+        return new FooImpl(42);
+    };
     return Class;
 }());
 exports.Class = Class;