Merge pull request #26 from timocov/fix25_any_unknown

Author: timocov

src/transformer.ts

@@ -286,13 +286,18 @@ function createTransformerFactory(program: ts.Program, options?: Partial<RenameO
 
 		// tslint:disable-next-line:cyclomatic-complexity
 		function isTypePropertyExternal(type: ts.Type, typePropertyName: string): boolean {
-			const symbol = type.getSymbol();
-			const propertySymbol = typeChecker.getPropertyOfType(type, typePropertyName);
+			// if a type is unknown or any - they should be interpret as a public ones
+			if (type.flags & ts.TypeFlags.Unknown || type.flags & ts.TypeFlags.Any) {
+				return true;
+			}
 
 			if (type.flags & ts.TypeFlags.IndexedAccess) {
 				return isTypePropertyExternal(typeChecker.getApparentType(type), typePropertyName);
 			}
 
+			const symbol = type.getSymbol();
+			const propertySymbol = typeChecker.getPropertyOfType(type, typePropertyName);
+
 			if (type.flags & ts.TypeFlags.Object) {
 				const objectType = type as ts.ObjectType;
 				// treat any tuple property as "external"
@@ -353,7 +358,21 @@ function createTransformerFactory(program: ts.Program, options?: Partial<RenameO
 		// tslint:disable-next-line:cyclomatic-complexity
 		function getNodeVisibilityType(node: ts.Expression | ts.Identifier | ts.StringLiteral | ts.BindingElement): VisibilityType {
 			if (ts.isPropertyAssignment(node.parent) || ts.isShorthandPropertyAssignment(node.parent)) {
-				const type = typeChecker.getContextualType(node.parent.parent);
+				let expressionToGetTypeFrom: ts.Expression = node.parent.parent;
+				let lastKnownExpression: ts.AsExpression | ts.ObjectLiteralExpression = node.parent.parent;
+				let currentNode: ts.Node = node.parent.parent.parent;
+
+				while (ts.isParenthesizedExpression(currentNode) || ts.isAsExpression(currentNode)) {
+					if (ts.isAsExpression(currentNode)) {
+						expressionToGetTypeFrom = lastKnownExpression;
+						lastKnownExpression = currentNode;
+					}
+
+					currentNode = currentNode.parent;
+				}
+
+				// to get correct contextual type we need to provide the previous last expression rather than the last one
+				const type = typeChecker.getContextualType(expressionToGetTypeFrom);
 				if (type !== undefined && isTypePropertyExternal(type, node.getText())) {
 					return VisibilityType.External;
 				}

tests/test-cases/any/input.ts

@@ -14,3 +14,14 @@ interface PublicByJSDocInterface {
 function func(obj1: PublicInterface, obj2: InternalInterface, obj3: PublicByJSDocInterface): void {
 	console.log(obj1.field.f1Any, obj2.field.f2Any, obj3.field.f3Any);
 }
+
+function func2(): any {
+	const b = (({ value: 321 }) as any);
+	const c = (((((((((((((({ field: 222 })))))) as any)) as any as any as PublicByJSDocInterface as any)))) as InternalInterface));
+	return {
+		foo: 1,
+		bar: b,
+		baz: 3,
+		c: c,
+	};
+}

tests/test-cases/any/output.js

@@ -3,3 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 function func(obj1, obj2, obj3) {
     console.log(obj1.field.f1Any, obj2._internal_field.f2Any, obj3.field.f3Any);
 }
+function func2() {
+    var b = ({ value: 321 });
+    var c = (((((({ _internal_field: 222 }))))));
+    return {
+        foo: 1,
+        bar: b,
+        baz: 3,
+        c: c,
+    };
+}

tests/test-cases/unknown/input.ts

@@ -0,0 +1,20 @@
+interface InternalInterface {
+	int: number;
+}
+
+/** @public */
+interface PublicInterface {
+	int: number;
+}
+
+function func(): unknown {
+	const b = (({ value: 321 }) as unknown);
+	const c = ((((((((({ int: 222 })))) as unknown)) as unknown as any as PublicInterface) as InternalInterface));
+
+	return {
+		foo: 1,
+		bar: b,
+		baz: 3,
+		c: c,
+	};
+}

tests/test-cases/unknown/output.js

@@ -0,0 +1,10 @@
+function func() {
+    var b = ({ value: 321 });
+    var c = (((({ _internal_int: 222 }))));
+    return {
+        foo: 1,
+        bar: b,
+        baz: 3,
+        c: c,
+    };
+}