Jan 23, 2020 · Jan 8, 2020 · Jan 8, 2020 · Jan 8, 2020 · Jan 8, 2020 · Jan 8, 2020
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
            }
        }

        // Aliases that resolve to const enums are not marked as referenced because they are not emitted,
        // but their usage in value positions must be tracked to determine if the import can be type-only.
        function markConstEnumAliasAsReferenced(symbol: Symbol) {
            const links = getSymbolLinks(symbol);
            if (!links.constEnumReferenced) {
                links.constEnumReferenced = true;
            }
        }

        // This function is only for imports with entity names
        function getSymbolOfPartOfRightHandSideOfImportEquals(entityName: EntityName, dontResolveAlias?: boolean): Symbol | undefined {
            // There are three things we might try to look for. In the following examples,
        }

        function markAliasReferenced(symbol: Symbol, location: Node) {
            if (isNonLocalAlias(symbol, /*excludes*/ SymbolFlags.Value) &&
                !isInTypeQuery(location) &&
                ((compilerOptions.preserveConstEnums && isExportOrExportExpression(location)) || !isConstEnumOrConstEnumOnlyModule(resolveAlias(symbol))) &&
                !getTypeOnlyAliasDeclaration(symbol)
            ) {
                markAliasSymbolAsReferenced(symbol);
            if (isNonLocalAlias(symbol, /*excludes*/ SymbolFlags.Value) && !isInTypeQuery(location) && !getTypeOnlyAliasDeclaration(symbol)) {
                if (compilerOptions.preserveConstEnums && isExportOrExportExpression(location) || !isConstEnumOrConstEnumOnlyModule(resolveAlias(symbol))) {
                    markAliasSymbolAsReferenced(symbol);
                }
                else {
                    markConstEnumAliasAsReferenced(symbol);
                }
            }
        }

        }

        function importClauseContainsReferencedImport(importClause: ImportClause) {
            return importClause.name && isReferenced(importClause)
                || importClause.namedBindings && namedBindingsContainsReferencedImport(importClause.namedBindings);
            return forEachImportClauseDeclaration(importClause, declaration => {
                return !!getSymbolOfNode(declaration).isReferenced;
            });
        }

            function isReferenced(declaration: Declaration) {
                return !!getMergedSymbol(getSymbolOfNode(declaration)).isReferenced;
            }
            function namedBindingsContainsReferencedImport(namedBindings: NamedImportBindings) {
                return isNamespaceImport(namedBindings)
                    ? isReferenced(namedBindings)
                    : some(namedBindings.elements, isReferenced);
            }
        function importClauseContainsConstEnumUsedAsValue(importClause: ImportClause) {
            return forEachImportClauseDeclaration(importClause, declaration => {
                return !!getSymbolLinks(getSymbolOfNode(declaration)).constEnumReferenced;
            });
        }

        function checkImportsForTypeOnlyConversion(sourceFile: SourceFile) {
                    statement.importClause &&
                    !statement.importClause.isTypeOnly &&
                    importClauseContainsReferencedImport(statement.importClause) &&
                    !isReferencedAliasDeclaration(statement.importClause, /*checkChildren*/ true)
                    !isReferencedAliasDeclaration(statement.importClause, /*checkChildren*/ true) &&
                    !importClauseContainsConstEnumUsedAsValue(statement.importClause)
                ) {
                    const isError = compilerOptions.importsNotUsedAsValues === importsNotUsedAsValues.Error;
                    errorOrSuggestion(
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
        instantiations?: Map<Type>;                 // Instantiations of generic type alias (undefined if non-generic)
        inferredClassSymbol?: Map<TransientSymbol>; // Symbol of an inferred ES5 constructor function
        mapper?: TypeMapper;                        // Type mapper for instantiation alias
        referenced?: boolean;                       // True if alias symbol has been referenced as a value
        referenced?: boolean;                       // True if alias symbol has been referenced as a value that can be emitted
        constEnumReferenced?: boolean;              // True if alias symbol resolves to a const enum and is referenced as a value ('referenced' will be false)
        containingType?: UnionOrIntersectionType;   // Containing union or intersection type for synthetic property
        leftSpread?: Symbol;                        // Left source for synthetic spread property
        rightSpread?: Symbol;                       // Right source for synthetic spread property
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
        return node.kind === SyntaxKind.ImportDeclaration && !!node.importClause && !!node.importClause.name;
    }

    export function forEachImportClauseDeclaration<T>(node: ImportClause, action: (declaration: ImportClause | NamespaceImport | ImportSpecifier) => T | undefined): T | undefined {
        if (node.name) {
            const result = action(node);
            if (result) return result;
        }
        if (node.namedBindings) {
            const result = isNamespaceImport(node.namedBindings)
                ? action(node.namedBindings)
                : forEach(node.namedBindings.elements, action);
            if (result) return result;
        }
    }

    export function hasQuestionToken(node: Node) {
        if (node) {
            switch (node.kind) {
diff --git a/tests/cases/conformance/externalModules/typeOnly/importsNotUsedAsValues_error.ts b/tests/cases/conformance/externalModules/typeOnly/importsNotUsedAsValues_error.ts
 export default class {}
 export class A {}
 export type B = {};
 export const enum C { One, Two }

 // @Filename: /b.ts
 import { A, B } from './a'; // Error

 // @Filename: /e.ts
 import { A, B } from './a'; // noUnusedLocals error only

 // @Filename: /f.ts
 import { C } from './a';
 import type { C as D } from './a';
 C.One;
 let c: D = C.Two;
 let d: D.Two = C.Two;
 console.log(c, d);

 // @Filename: /g.ts
 import { C } from './a';
 let c: C;
 let d: C.Two;
 console.log(c, d);
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2532,6 +2532,15 @@ namespace ts {
		}
		}

		// Aliases that resolve to const enums are not marked as referenced because they are not emitted,
		// but their usage in value positions must be tracked to determine if the import can be type-only.
		function markConstEnumAliasAsReferenced(symbol: Symbol) {
		const links = getSymbolLinks(symbol);
		if (!links.constEnumReferenced) {
		links.constEnumReferenced = true;
		}
		}
andrewbranch marked this conversation as resolved. Show resolvedHide resolved

		// This function is only for imports with entity names
		function getSymbolOfPartOfRightHandSideOfImportEquals(entityName: EntityName, dontResolveAlias?: boolean): Symbol \| undefined {
		// There are three things we might try to look for. In the following examples,
Expand DownExpand Up		@@ -20211,12 +20220,13 @@ namespace ts {
		}

		function markAliasReferenced(symbol: Symbol, location: Node) {
		if (isNonLocalAlias(symbol, /excludes/ SymbolFlags.Value) &&
		!isInTypeQuery(location) &&
		((compilerOptions.preserveConstEnums && isExportOrExportExpression(location)) \|\| !isConstEnumOrConstEnumOnlyModule(resolveAlias(symbol))) &&
		!getTypeOnlyAliasDeclaration(symbol)
		) {
		markAliasSymbolAsReferenced(symbol);
		if (isNonLocalAlias(symbol, /excludes/ SymbolFlags.Value) && !isInTypeQuery(location) && !getTypeOnlyAliasDeclaration(symbol)) {
		if (compilerOptions.preserveConstEnums && isExportOrExportExpression(location) \|\| !isConstEnumOrConstEnumOnlyModule(resolveAlias(symbol))) {
		markAliasSymbolAsReferenced(symbol);
		}
		else {
		markConstEnumAliasAsReferenced(symbol);
		}
		}
		}

Expand DownExpand Up		@@ -33045,17 +33055,15 @@ namespace ts {
		}

		function importClauseContainsReferencedImport(importClause: ImportClause) {
		return importClause.name && isReferenced(importClause)
		\|\| importClause.namedBindings && namedBindingsContainsReferencedImport(importClause.namedBindings);
		return forEachImportClauseDeclaration(importClause, declaration => {
		return !!getSymbolOfNode(declaration).isReferenced;
		});
		}

		function isReferenced(declaration: Declaration) {
		return !!getMergedSymbol(getSymbolOfNode(declaration)).isReferenced;
		}
		function namedBindingsContainsReferencedImport(namedBindings: NamedImportBindings) {
		return isNamespaceImport(namedBindings)
		? isReferenced(namedBindings)
		: some(namedBindings.elements, isReferenced);
		}
		function importClauseContainsConstEnumUsedAsValue(importClause: ImportClause) {
		return forEachImportClauseDeclaration(importClause, declaration => {
		return !!getSymbolLinks(getSymbolOfNode(declaration)).constEnumReferenced;
		});
		}

		function checkImportsForTypeOnlyConversion(sourceFile: SourceFile) {
Expand All		@@ -33065,7 +33073,8 @@ namespace ts {
		statement.importClause &&
		!statement.importClause.isTypeOnly &&
		importClauseContainsReferencedImport(statement.importClause) &&
		!isReferencedAliasDeclaration(statement.importClause, /checkChildren/ true)
		!isReferencedAliasDeclaration(statement.importClause, /checkChildren/ true) &&
		!importClauseContainsConstEnumUsedAsValue(statement.importClause)
		) {
		const isError = compilerOptions.importsNotUsedAsValues === importsNotUsedAsValues.Error;
		errorOrSuggestion(
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -4059,7 +4059,8 @@ namespace ts {
		instantiations?: Map<Type>; // Instantiations of generic type alias (undefined if non-generic)
		inferredClassSymbol?: Map<TransientSymbol>; // Symbol of an inferred ES5 constructor function
		mapper?: TypeMapper; // Type mapper for instantiation alias
		referenced?: boolean; // True if alias symbol has been referenced as a value
		referenced?: boolean; // True if alias symbol has been referenced as a value that can be emitted
		constEnumReferenced?: boolean; // True if alias symbol resolves to a const enum and is referenced as a value ('referenced' will be false)
		containingType?: UnionOrIntersectionType; // Containing union or intersection type for synthetic property
		leftSpread?: Symbol; // Left source for synthetic spread property
		rightSpread?: Symbol; // Right source for synthetic spread property
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2273,6 +2273,19 @@ namespace ts {
		return node.kind === SyntaxKind.ImportDeclaration && !!node.importClause && !!node.importClause.name;
		}

		export function forEachImportClauseDeclaration<T>(node: ImportClause, action: (declaration: ImportClause \| NamespaceImport \| ImportSpecifier) => T \| undefined): T \| undefined {
		if (node.name) {
		const result = action(node);
		if (result) return result;
		}
		if (node.namedBindings) {
		const result = isNamespaceImport(node.namedBindings)
		? action(node.namedBindings)
		: forEach(node.namedBindings.elements, action);
		if (result) return result;
		}
		}

		export function hasQuestionToken(node: Node) {
		if (node) {
		switch (node.kind) {
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -5,6 +5,7 @@
		export default class {}
		export class A {}
		export type B = {};
		export const enum C { One, Two }

		// @Filename: /b.ts
		import { A, B } from './a'; // Error
Expand All		@@ -26,3 +27,17 @@ console.log(a, b);

		// @Filename: /e.ts
		import { A, B } from './a'; // noUnusedLocals error only

		// @Filename: /f.ts
		import { C } from './a';
		import type { C as D } from './a';
		C.One;
		let c: D = C.Two;
		let d: D.Two = C.Two;
		console.log(c, d);

		// @Filename: /g.ts
		import { C } from './a';
		let c: C;
		let d: C.Two;
		console.log(c, d);