No reverse mapping for syntactically known strings

Author: frigus02

src/compiler/checker.ts

@@ -45114,10 +45114,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     (isSyntacticallyString(right) || rightIsNumeric) &&
                     (expr as BinaryExpression).operatorToken.kind === SyntaxKind.PlusToken
                 );
-            case SyntaxKind.TemplateExpression:
-                return (expr as TemplateExpression).templateSpans.every(span => isSyntacticallyString(span.expression));
             case SyntaxKind.ParenthesizedExpression:
                 return isSyntacticallyString((expr as ParenthesizedExpression).expression);
+            case SyntaxKind.TemplateExpression:
             case SyntaxKind.StringLiteral:
             case SyntaxKind.NoSubstitutionTemplateLiteral:
                 return true;
@@ -48297,6 +48296,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 const node = getParseTreeNode(nodeIn, canHaveConstantValue);
                 return node ? getConstantValue(node) : undefined;
             },
+            isSyntacticallyString,
             collectLinkedAliases,
             getReferencedValueDeclaration,
             getReferencedValueDeclarations,

src/compiler/emitter.ts

@@ -1158,6 +1158,7 @@ export const notImplementedResolver: EmitResolver = {
     isEntityNameVisible: notImplemented,
     // Returns the constant value this property access resolves to: notImplemented, or 'undefined' for a non-constant
     getConstantValue: notImplemented,
+    isSyntacticallyString: notImplemented,
     getReferencedValueDeclaration: notImplemented,
     getReferencedValueDeclarations: notImplemented,
     getTypeReferenceSerializationKind: notImplemented,

src/compiler/transformers/ts.ts

@@ -1873,7 +1873,12 @@ export function transformTypeScript(context: TransformationContext) {
             ),
             valueExpression,
         );
-        const outerAssignment = valueExpression.kind === SyntaxKind.StringLiteral ?
+        const isString = valueExpression.kind === SyntaxKind.StringLiteral ||
+            // Fix ts.transpileModule() emit: we may not have been able to determine a known string due
+            // to missing type information, but we know syntactically that it's a string. The checker
+            // ensures that only syntactically determined strings are allowed under isolatedModules.
+            (member.initializer && resolver.isSyntacticallyString(member.initializer));
+        const outerAssignment = isString ?
             innerAssignment :
             factory.createAssignment(
                 factory.createElementAccessExpression(

src/compiler/types.ts

@@ -5691,6 +5691,7 @@ export interface EmitResolver {
     isEntityNameVisible(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node): SymbolVisibilityResult;
     // Returns the constant value this property access resolves to, or 'undefined' for a non-constant
     getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): string | number | undefined;
+    isSyntacticallyString(node: Expression): boolean;
     getReferencedValueDeclaration(reference: Identifier): Declaration | undefined;
     getReferencedValueDeclarations(reference: Identifier): Declaration[] | undefined;
     getTypeReferenceSerializationKind(typeName: EntityName, location?: Node): TypeReferenceSerializationKind;