jsii-rosetta 1.74.0 → 1.76.0

package/jest.config.mjs

@@ -4,4 +4,5 @@ import { default as defaultConfig, overriddenConfig } from '../../jest.config.mj
 export default overriddenConfig({
   setupFiles: [createRequire(import.meta.url).resolve('./jestsetup.js')],
   testTimeout: process.env.CI === 'true' ? 30_000 : defaultConfig.testTimeout,
+  watchPathIgnorePatterns: ['(\\.d)?\\.tsx?$'],
 });

package/lib/languages/csharp.js

@@ -63,7 +63,7 @@ class CSharpVisitor extends default_1.DefaultVisitor {
         const guessedNamespace = guessDotnetNamespace(importStatement.packageName);
         const namespace = (0, util_1.fmap)(importStatement.moduleSymbol, findDotnetName) ?? guessedNamespace;
         if (importStatement.imports.import === 'full') {
-            this.dropPropertyAccesses.add(importStatement.imports.alias);
+            this.dropPropertyAccesses.add(importStatement.imports.sourceName);
             this.alreadyImportedNamespaces.add(namespace);
             return new o_tree_1.OTree([`using ${namespace};`], [], { canBreakLine: true });
         }
@@ -366,27 +366,27 @@ class CSharpVisitor extends default_1.DefaultVisitor {
         return new o_tree_1.OTree(['(', this.renderTypeNode(node.type, false, context), ')', context.convert(node.expression)]);
     }
     variableDeclaration(node, renderer) {
-        let fallback = 'var';
-        if (node.type) {
-            fallback = node.type.getText();
-        }
-        const type = (node.type && renderer.typeOfType(node.type)) ||
+        let typeOrVar = 'var';
+        const fallback = node.type?.getText() ?? 'var';
+        const type = (node.type && renderer.typeOfType(node.type)) ??
             (node.initializer && renderer.typeOfExpression(node.initializer));
-        let renderedType = this.renderType(node, type, false, fallback, renderer);
-        if (renderedType === 'object') {
-            renderedType = 'var';
+        const varType = this.renderType(node, type, false, fallback, renderer);
+        // If there is an initializer, and the value isn't "IDictionary<...", we always use var, as this is the
+        // recommendation from Roslyn.
+        if (varType !== 'object' && (varType.startsWith('IDictionary<') || node.initializer == null)) {
+            typeOrVar = varType;
         }
         if (!node.initializer) {
-            return new o_tree_1.OTree([renderedType, ' ', renderer.convert(node.name), ';'], []);
+            return new o_tree_1.OTree([typeOrVar, ' ', renderer.convert(node.name), ';']);
         }
         return new o_tree_1.OTree([
-            renderedType,
+            typeOrVar,
             ' ',
             renderer.convert(node.name),
             ' = ',
             renderer.updateContext({ preferObjectLiteralAsStruct: false }).convert(node.initializer),
             ';',
-        ], [], { canBreakLine: true });
+        ], undefined, { canBreakLine: true });
     }
     templateExpression(node, context) {
         // If this is a multi-line string literal, we need not quote much, as @"string" literals in C#
@@ -491,7 +491,7 @@ function findDotnetName(jsiiSymbol) {
                 return modName;
             }
         }
-        return `${recurse((0, jsii_utils_1.namespaceName)(fqn))}.${(0, jsii_utils_1.simpleName)(jsiiSymbol.fqn)}`;
+        return `${recurse((0, jsii_utils_1.namespaceName)(fqn))}.${ucFirst((0, jsii_utils_1.simpleName)(jsiiSymbol.fqn))}`;
     }
 }
 function guessDotnetNamespace(ref) {

package/lib/languages/default.d.ts

@@ -2,6 +2,7 @@ import * as ts from 'typescript';
 import { ObjectLiteralStruct } from '../jsii/jsii-types';
 import { OTree } from '../o-tree';
 import { AstRenderer, AstHandler, CommentSyntax } from '../renderer';
+import { SubmoduleReference } from '../submodule-reference';
 import { ImportStatement } from '../typescript/imports';
 import { TargetLanguage } from '.';
 /**
@@ -28,7 +29,7 @@ export declare abstract class DefaultVisitor<C> implements AstHandler<C> {
     translateUnaryOperator(operator: ts.PrefixUnaryOperator): string;
     translateBinaryOperator(operator: string): string;
     ifStatement(node: ts.IfStatement, context: AstRenderer<C>): OTree;
-    propertyAccessExpression(node: ts.PropertyAccessExpression, context: AstRenderer<C>): OTree;
+    propertyAccessExpression(node: ts.PropertyAccessExpression, context: AstRenderer<C>, _submoduleReference: SubmoduleReference | undefined): OTree;
     /**
      * Do some work on property accesses to translate common JavaScript-isms to language-specific idioms
      */

package/lib/languages/default.js

@@ -7,6 +7,7 @@ const jsii_utils_1 = require("../jsii/jsii-utils");
 const o_tree_1 = require("../o-tree");
 const renderer_1 = require("../renderer");
 const ast_utils_1 = require("../typescript/ast-utils");
+const types_1 = require("../typescript/types");
 /**
  * A basic visitor that applies for most curly-braces-based languages
  */
@@ -76,7 +77,7 @@ class DefaultVisitor {
     ifStatement(node, context) {
         return this.notImplemented(node, context);
     }
-    propertyAccessExpression(node, context) {
+    propertyAccessExpression(node, context, _submoduleReference) {
         return new o_tree_1.OTree([context.convert(node.expression), '.', context.convert(node.name)]);
     }
     /**
@@ -132,7 +133,7 @@ class DefaultVisitor {
             : ts.isShorthandPropertyAssignment(p)
                 ? isExpressionOfFunctionType(context.typeChecker, p.name)
                 : false);
-        const inferredType = context.inferredTypeOfExpression(node);
+        const inferredType = (0, types_1.inferredTypeOfExpression)(context.typeChecker, node);
         if ((inferredType && (0, jsii_utils_1.isJsiiProtocolType)(context.typeChecker, inferredType)) || anyMembersFunctions) {
             context.report(node, `You cannot use an object literal to make an instance of an interface. Define a class instead.`);
         }

package/lib/languages/go.d.ts

@@ -2,6 +2,7 @@ import * as ts from 'typescript';
 import { ObjectLiteralStruct } from '../jsii/jsii-types';
 import { OTree } from '../o-tree';
 import { AstRenderer } from '../renderer';
+import { SubmoduleReference } from '../submodule-reference';
 import { ImportStatement } from '../typescript/imports';
 import { DefaultVisitor } from './default';
 import { TargetLanguage } from './target-language';
@@ -70,14 +71,14 @@ export declare class GoVisitor extends DefaultVisitor<GoLanguageContext> {
     asExpression(node: ts.AsExpression, renderer: AstRenderer<GoLanguageContext>): OTree;
     parameterDeclaration(node: ts.ParameterDeclaration, renderer: GoRenderer): OTree;
     printStatement(args: ts.NodeArray<ts.Expression>, renderer: GoRenderer): OTree;
-    propertyAccessExpression(node: ts.PropertyAccessExpression, renderer: GoRenderer): OTree;
+    propertyAccessExpression(node: ts.PropertyAccessExpression, renderer: GoRenderer, submoduleReference?: SubmoduleReference): OTree;
     methodSignature(node: ts.MethodSignature, renderer: AstRenderer<GoLanguageContext>): OTree;
     propertyDeclaration(node: ts.PropertyDeclaration, renderer: AstRenderer<GoLanguageContext>): OTree;
     propertySignature(node: ts.PropertySignature, renderer: GoRenderer): OTree;
     regularCallExpression(node: ts.CallExpression, renderer: GoRenderer): OTree;
     returnStatement(node: ts.ReturnStatement, renderer: AstRenderer<GoLanguageContext>): OTree;
     binaryExpression(node: ts.BinaryExpression, renderer: AstRenderer<GoLanguageContext>): OTree;
-    stringLiteral(node: ts.StringLiteral, renderer: GoRenderer): OTree;
+    stringLiteral(node: ts.StringLiteral | ts.NoSubstitutionTemplateLiteral, renderer: GoRenderer): OTree;
     numericLiteral(node: ts.NumericLiteral, renderer: GoRenderer): OTree;
     classDeclaration(node: ts.ClassDeclaration, renderer: AstRenderer<GoLanguageContext>): OTree;
     structInterfaceDeclaration(node: ts.InterfaceDeclaration, renderer: GoRenderer): OTree;

package/lib/languages/go.js

@@ -6,6 +6,7 @@ exports.GoVisitor = void 0;
 const assert_1 = require("assert");
 const ts = require("typescript");
 const jsii_types_1 = require("../jsii/jsii-types");
+const jsii_utils_1 = require("../jsii/jsii-utils");
 const o_tree_1 = require("../o-tree");
 const ast_utils_1 = require("../typescript/ast-utils");
 const imports_1 = require("../typescript/imports");
@@ -133,6 +134,14 @@ class GoVisitor extends default_1.DefaultVisitor {
                         classNamespace: renderer.updateContext({ isExported: false }).convert(expr.expression),
                     };
                 }
+                else if (ts.isPropertyAccessExpression(expr.expression) &&
+                    renderer.submoduleReferences.has(expr.expression)) {
+                    const submodule = renderer.submoduleReferences.get(expr.expression);
+                    return {
+                        className: ucFirst(expr.name.text),
+                        classNamespace: renderer.updateContext({ isExported: false }).convert(submodule.lastNode),
+                    };
+                }
                 renderer.reportUnsupported(expr.expression, target_language_1.TargetLanguage.GO);
                 return {
                     className: ucFirst(expr.name.text),
@@ -174,14 +183,16 @@ class GoVisitor extends default_1.DefaultVisitor {
                 ? JSON.stringify(node.name.text)
                 : this.goName(node.name.text, renderer, renderer.typeChecker.getSymbolAtLocation(node.name))
             : renderer.convert(node.name);
-        // Struct member values are always pointers...
         return new o_tree_1.OTree([
             key,
             ': ',
             renderer
                 .updateContext({
-                wrapPtr: renderer.currentContext.isStruct || renderer.currentContext.inMapLiteral,
+                // Reset isExported, as this was intended for the key name translation...
+                isExported: undefined,
+                // Struct member values are always pointers...
                 isPtr: renderer.currentContext.isStruct,
+                wrapPtr: renderer.currentContext.isStruct || renderer.currentContext.inMapLiteral,
             })
                 .convert(node.initializer),
         ], [], {
@@ -252,11 +263,12 @@ class GoVisitor extends default_1.DefaultVisitor {
         });
     }
     knownStructObjectLiteralExpression(node, structType, renderer) {
+        const isExported = structType.kind === 'struct';
         return new o_tree_1.OTree([
             '&',
-            this.goName(structType.type.symbol.name, renderer.updateContext({ isPtr: false }), structType.type.symbol),
+            this.goName(structType.type.symbol.name, renderer.updateContext({ isExported, isPtr: false }), structType.type.symbol),
             '{',
-        ], renderer.updateContext({ isStruct: true }).convertAll(node.properties), {
+        ], renderer.updateContext({ isExported, isStruct: true }).convertAll(node.properties), {
             suffix: '}',
             separator: ',',
             trailingSeparator: true,
@@ -295,29 +307,48 @@ class GoVisitor extends default_1.DefaultVisitor {
         const renderedArgs = this.argumentList(args, renderer);
         return new o_tree_1.OTree(['fmt.Println(', renderedArgs, ')']);
     }
-    propertyAccessExpression(node, renderer) {
+    propertyAccessExpression(node, renderer, submoduleReference) {
+        if (submoduleReference != null) {
+            return new o_tree_1.OTree([
+                renderer
+                    .updateContext({ isExported: false, isPtr: false, wrapPtr: false })
+                    .convert(submoduleReference.lastNode),
+            ]);
+        }
         const expressionType = (0, types_1.typeOfExpression)(renderer.typeChecker, node.expression);
         const valueSymbol = renderer.typeChecker.getSymbolAtLocation(node.name);
-        const isClassStaticMember = expressionType?.symbol?.valueDeclaration != null &&
+        const isStaticMember = valueSymbol?.valueDeclaration != null && (0, ast_utils_1.isStatic)(valueSymbol.valueDeclaration);
+        const isClassStaticPropertyAccess = isStaticMember &&
+            expressionType?.symbol?.valueDeclaration != null &&
             ts.isClassDeclaration(expressionType.symbol.valueDeclaration) &&
-            valueSymbol?.valueDeclaration != null &&
-            ts.isPropertyDeclaration(valueSymbol.valueDeclaration) &&
-            (0, ast_utils_1.isStatic)(valueSymbol.valueDeclaration);
+            (ts.isPropertyDeclaration(valueSymbol.valueDeclaration) || ts.isAccessor(valueSymbol.valueDeclaration));
+        const isClassStaticMethodAccess = isStaticMember && !isClassStaticPropertyAccess && ts.isMethodDeclaration(valueSymbol.valueDeclaration);
         // When the expression has an unknown type (unresolved symbol), and has an upper-case first
         // letter, we assume it's a type name... In such cases, what comes after can be considered a
         // static member access. Note that the expression might be further qualified, so we check using
         // a regex that checks for the last "."-delimited segment if there's dots in there...
         const expressionLooksLikeTypeReference = expressionType.symbol == null &&
             /(?:\.|^)[A-Z][^.]*$/.exec(node.expression.getText(node.expression.getSourceFile())) != null;
-        const isEnum = expressionType?.symbol?.valueDeclaration != null && ts.isEnumDeclaration(expressionType.symbol.valueDeclaration);
-        const delimiter = isEnum || isClassStaticMember || expressionLooksLikeTypeReference ? '_' : '.';
+        // Whether the node is an enum member reference.
+        const isEnumMember = expressionType?.symbol?.valueDeclaration != null && ts.isEnumDeclaration(expressionType.symbol.valueDeclaration);
+        const jsiiSymbol = (0, jsii_utils_1.lookupJsiiSymbolFromNode)(renderer.typeChecker, node.name);
+        const isExportedTypeName = jsiiSymbol != null && jsiiSymbol.symbolType !== 'module';
+        const delimiter = isEnumMember || isClassStaticPropertyAccess || isClassStaticMethodAccess || expressionLooksLikeTypeReference
+            ? '_'
+            : '.';
         return new o_tree_1.OTree([
             renderer.convert(node.expression),
             delimiter,
             renderer
-                .updateContext({ isExported: isClassStaticMember || expressionLooksLikeTypeReference || isEnum })
+                .updateContext({
+                isExported: isClassStaticPropertyAccess ||
+                    isClassStaticMethodAccess ||
+                    expressionLooksLikeTypeReference ||
+                    isEnumMember ||
+                    isExportedTypeName,
+            })
                 .convert(node.name),
-            ...(isClassStaticMember
+            ...(isClassStaticPropertyAccess
                 ? ['()']
                 : // If the parent's not a call-like expression, and it's an inferred static property access, we need to put call
                     // parentheses at the end, as static properties are accessed via synthetic readers.
@@ -404,7 +435,11 @@ class GoVisitor extends default_1.DefaultVisitor {
         return wrapPtrExpression(renderer.typeChecker, node, output);
     }
     stringLiteral(node, renderer) {
-        const text = JSON.stringify(node.text);
+        // Go supports backtick-delimited multi-line string literals, similar/same as JavaScript no-substitution templates.
+        // We only use this trick if the literal includes actual new line characters (otherwise it just looks weird in go).
+        const text = ts.isNoSubstitutionTemplateLiteral(node) && /[\n\r]/m.test(node.text)
+            ? node.getText(node.getSourceFile())
+            : JSON.stringify(node.text);
         return new o_tree_1.OTree([`${renderer.currentContext.wrapPtr ? jsiiStr(text) : text}`]);
     }
     numericLiteral(node, renderer) {
@@ -556,18 +591,26 @@ class GoVisitor extends default_1.DefaultVisitor {
     }
     importStatement(node, renderer) {
         const packageName = node.moduleSymbol?.sourceAssembly?.packageJson.jsii?.targets?.go?.packageName ??
-            this.goName(node.packageName, renderer, undefined);
+            node.packageName
+                // Special case namespaced npm package names, so they are mangled the same way pacmak does.
+                .replace(/@([a-z0-9_-]+)\/([a-z0-9_-])/, '$1$2')
+                .split('/')
+                .map((txt) => this.goName(txt, renderer, undefined))
+                .filter((txt) => txt !== '')
+                .join('/');
         const moduleName = node.moduleSymbol?.sourceAssembly?.packageJson.jsii?.targets?.go?.moduleName
             ? `${node.moduleSymbol.sourceAssembly.packageJson.jsii.targets.go.moduleName}/${packageName}`
             : `github.com/aws-samples/dummy/${packageName}`;
         if (node.imports.import === 'full') {
-            return new o_tree_1.OTree(['import ', this.goName(node.imports.alias, renderer, undefined), ' "', moduleName, '"'], undefined, { canBreakLine: true });
+            // We don't emit the alias if it matches the last path segment (conventionally this is the package name)
+            const maybeAlias = node.imports.alias ? `${this.goName(node.imports.alias, renderer, undefined)} ` : '';
+            return new o_tree_1.OTree([`import ${maybeAlias}${JSON.stringify(moduleName)}`], undefined, { canBreakLine: true });
         }
         if (node.imports.elements.length === 0) {
             // This is a blank import (for side-effects only)
-            return new o_tree_1.OTree(['import _ "', moduleName, '"'], undefined, { canBreakLine: true });
+            return new o_tree_1.OTree([`import _ ${JSON.stringify(moduleName)}`], undefined, { canBreakLine: true });
         }
-        return new o_tree_1.OTree(['import "', moduleName, '"'], undefined, { canBreakLine: true });
+        return new o_tree_1.OTree([`import ${JSON.stringify(moduleName)}`], undefined, { canBreakLine: true });
     }
     variableDeclaration(node, renderer) {
         if (!node.initializer) {

package/lib/languages/java.d.ts

@@ -3,6 +3,7 @@ import { ObjectLiteralStruct } from '../jsii/jsii-types';
 import { TargetLanguage } from '../languages/target-language';
 import { OTree } from '../o-tree';
 import { AstRenderer } from '../renderer';
+import { SubmoduleReference } from '../submodule-reference';
 import { ImportStatement } from '../typescript/imports';
 import { DefaultVisitor } from './default';
 interface JavaContext {
@@ -122,7 +123,7 @@ export declare class JavaVisitor extends DefaultVisitor<JavaContext> {
     knownStructObjectLiteralExpression(node: ts.ObjectLiteralExpression, structType: ObjectLiteralStruct, renderer: JavaRenderer): OTree;
     propertyAssignment(node: ts.PropertyAssignment, renderer: JavaRenderer): OTree;
     shorthandPropertyAssignment(node: ts.ShorthandPropertyAssignment, renderer: JavaRenderer): OTree;
-    propertyAccessExpression(node: ts.PropertyAccessExpression, renderer: JavaRenderer): OTree;
+    propertyAccessExpression(node: ts.PropertyAccessExpression, renderer: JavaRenderer, submoduleRef: SubmoduleReference | undefined): OTree;
     stringLiteral(node: ts.StringLiteral | ts.NoSubstitutionTemplateLiteral, renderer: JavaRenderer): OTree;
     identifier(node: ts.Identifier | ts.StringLiteral | ts.NoSubstitutionTemplateLiteral, renderer: JavaRenderer): OTree;
     private renderObjectLiteralAsBuilder;

package/lib/languages/java.js

@@ -29,13 +29,20 @@ class JavaVisitor extends default_1.DefaultVisitor {
     importStatement(importStatement) {
         const guessedNamespace = guessJavaNamespaceName(importStatement.packageName);
         if (importStatement.imports.import === 'full') {
-            this.dropPropertyAccesses.add(importStatement.imports.alias);
+            this.dropPropertyAccesses.add(importStatement.imports.sourceName);
             const namespace = (0, util_1.fmap)(importStatement.moduleSymbol, findJavaName) ?? guessedNamespace;
             return new o_tree_1.OTree([`import ${namespace}.*;`], [], { canBreakLine: true });
         }
         const imports = importStatement.imports.elements.map((e) => {
             const fqn = (0, util_1.fmap)(e.importedSymbol, findJavaName) ?? `${guessedNamespace}.${e.sourceName}`;
-            return e.importedSymbol?.symbolType === 'module' ? `import ${fqn}.*;` : `import ${fqn};`;
+            // If there is no imported symbol, we check if there is anything looking like a type name in
+            // the source name (that is, any segment that starts with an upper case letter), and if none
+            // is found, assume this refers to a namespace/module.
+            return (e.importedSymbol?.symbolType == null &&
+                !e.sourceName.split('.').some((segment) => /^[A-Z]/.test(segment))) ||
+                e.importedSymbol?.symbolType === 'module'
+                ? `import ${fqn}.*;`
+                : `import ${fqn};`;
         });
         const localNames = importStatement.imports.elements
             .filter((el) => el.importedSymbol?.symbolType === 'module')
@@ -345,8 +352,12 @@ class JavaVisitor extends default_1.DefaultVisitor {
             ? this.singlePropertyInJavaScriptObjectLiteralToJavaMap(node.name, node.name, renderer)
             : this.singlePropertyInJavaScriptObjectLiteralToFluentSetters(node.name, node.name, renderer);
     }
-    propertyAccessExpression(node, renderer) {
+    propertyAccessExpression(node, renderer, submoduleRef) {
         const rightHandSide = renderer.convert(node.name);
+        // If a submodule access, then just render the name, we emitted a * import of the expression segment already.
+        if (submoduleRef != null) {
+            return rightHandSide;
+        }
         let parts;
         const leftHandSide = renderer.textOf(node.expression);
         // Suppress the LHS of the dot operator if it matches an alias for a module import.
@@ -572,7 +583,10 @@ function findJavaName(jsiiSymbol) {
                 return modName;
             }
         }
-        return `${recurse((0, jsii_utils_1.namespaceName)(fqn))}.${(0, jsii_utils_1.simpleName)(jsiiSymbol.fqn)}`;
+        const ns = (0, jsii_utils_1.namespaceName)(fqn);
+        const nsJavaName = recurse(ns);
+        const leaf = (0, jsii_utils_1.simpleName)(fqn);
+        return `${nsJavaName}.${leaf}`;
     }
 }
 function guessJavaNamespaceName(packageName) {

package/lib/languages/python.d.ts

@@ -3,6 +3,7 @@ import { ObjectLiteralStruct } from '../jsii/jsii-types';
 import { TargetLanguage } from '../languages/target-language';
 import { OTree } from '../o-tree';
 import { AstRenderer, CommentSyntax } from '../renderer';
+import { SubmoduleReference } from '../submodule-reference';
 import { ImportStatement } from '../typescript/imports';
 import { DefaultVisitor } from './default';
 interface StructVar {
@@ -74,7 +75,7 @@ export declare class PythonVisitor extends DefaultVisitor<PythonLanguageContext>
      * existing cached translations.
      */
     static readonly VERSION = "2";
-    readonly language = TargetLanguage.PYTHON;
+    readonly language = TargetLanguage.VISUALIZE;
     readonly defaultContext: {};
     /**
      * Keep track of module imports we've seen, so that if we need to render a type we can pick from these modules
@@ -101,7 +102,7 @@ export declare class PythonVisitor extends DefaultVisitor<PythonLanguageContext>
     }): OTree;
     block(node: ts.Block, context: PythonVisitorContext): OTree;
     regularCallExpression(node: ts.CallExpression, context: PythonVisitorContext): OTree;
-    propertyAccessExpression(node: ts.PropertyAccessExpression, context: PythonVisitorContext): OTree;
+    propertyAccessExpression(node: ts.PropertyAccessExpression, context: PythonVisitorContext, submoduleReference: SubmoduleReference | undefined): OTree;
     parameterDeclaration(node: ts.ParameterDeclaration, context: PythonVisitorContext): OTree;
     ifStatement(node: ts.IfStatement, context: PythonVisitorContext): OTree;
     unknownTypeObjectLiteralExpression(node: ts.ObjectLiteralExpression, context: PythonVisitorContext): OTree;

package/lib/languages/python.js

@@ -58,11 +58,12 @@ class PythonVisitor extends default_1.DefaultVisitor {
     importStatement(node, context) {
         if (node.imports.import === 'full') {
             const moduleName = (0, util_1.fmap)(node.moduleSymbol, findPythonName) ?? guessPythonPackageName(node.packageName);
+            const importName = node.imports.alias ?? node.imports.sourceName;
             this.addImport({
                 importedFqn: node.moduleSymbol?.fqn ?? node.packageName,
-                importName: node.imports.alias,
+                importName,
             });
-            return new o_tree_1.OTree([`import ${moduleName} as ${mangleIdentifier(node.imports.alias)}`], [], {
+            return new o_tree_1.OTree([`import ${moduleName} as ${mangleIdentifier(importName)}`], [], {
                 canBreakLine: true,
             });
         }
@@ -167,7 +168,7 @@ class PythonVisitor extends default_1.DefaultVisitor {
             ')',
         ], [], { canBreakLine: true });
     }
-    propertyAccessExpression(node, context) {
+    propertyAccessExpression(node, context, submoduleReference) {
         const fullText = context.textOf(node);
         if (fullText in BUILTIN_FUNCTIONS) {
             return new o_tree_1.OTree([BUILTIN_FUNCTIONS[fullText]]);
@@ -178,7 +179,10 @@ class PythonVisitor extends default_1.DefaultVisitor {
         if (explodedParameter && context.textOf(node.expression) === explodedParameter.variableName) {
             return context.convert(node.name);
         }
-        return super.propertyAccessExpression(node, context);
+        if (submoduleReference != null) {
+            return context.convert(submoduleReference.lastNode);
+        }
+        return super.propertyAccessExpression(node, context, submoduleReference);
     }
     parameterDeclaration(node, context) {
         const type = node.type && context.typeOfType(node.type);

package/lib/languages/record-references.d.ts

@@ -2,6 +2,7 @@ import * as ts from 'typescript';
 import { TargetLanguage } from '../languages/target-language';
 import { OTree } from '../o-tree';
 import { AstRenderer } from '../renderer';
+import { SubmoduleReference } from '../submodule-reference';
 import { Spans } from '../typescript/visible-spans';
 import { DefaultVisitor } from './default';
 interface RecordReferencesContext {
@@ -13,7 +14,7 @@ declare type RecordReferencesRenderer = AstRenderer<RecordReferencesContext>;
 export declare class RecordReferencesVisitor extends DefaultVisitor<RecordReferencesContext> {
     private readonly visibleSpans;
     static readonly VERSION = "2";
-    readonly language = TargetLanguage.PYTHON;
+    readonly language = TargetLanguage.VISUALIZE;
     readonly defaultContext: {};
     private readonly references;
     constructor(visibleSpans: Spans);
@@ -26,7 +27,7 @@ export declare class RecordReferencesVisitor extends DefaultVisitor<RecordRefere
      */
     variableDeclaration(node: ts.VariableDeclaration, renderer: RecordReferencesRenderer): OTree;
     newExpression(node: ts.NewExpression, context: RecordReferencesRenderer): OTree;
-    propertyAccessExpression(node: ts.PropertyAccessExpression, context: RecordReferencesRenderer): OTree;
+    propertyAccessExpression(node: ts.PropertyAccessExpression, context: RecordReferencesRenderer, submoduleReference: SubmoduleReference | undefined): OTree;
     regularCallExpression(node: ts.CallExpression, context: RecordReferencesRenderer): OTree;
     objectLiteralExpression(node: ts.ObjectLiteralExpression, context: RecordReferencesRenderer): OTree;
     propertyAssignment(node: ts.PropertyAssignment, renderer: RecordReferencesRenderer): OTree;

package/lib/languages/record-references.js

@@ -12,7 +12,7 @@ class RecordReferencesVisitor extends default_1.DefaultVisitor {
     constructor(visibleSpans) {
         super();
         this.visibleSpans = visibleSpans;
-        this.language = target_language_1.TargetLanguage.PYTHON; // Doesn't matter, but we need it to use the visitor infra :(
+        this.language = target_language_1.TargetLanguage.VISUALIZE;
         this.defaultContext = {};
         this.references = new Set();
     }
@@ -45,13 +45,13 @@ class RecordReferencesVisitor extends default_1.DefaultVisitor {
         }
         return super.newExpression(node, context);
     }
-    propertyAccessExpression(node, context) {
+    propertyAccessExpression(node, context, submoduleReference) {
         if (this.visibleSpans.containsStartOfNode(node)) {
             // The property itself
             this.recordNode(node, context);
             // Not currently considering the return type as "referenced"
         }
-        return super.propertyAccessExpression(node, context);
+        return super.propertyAccessExpression(node, context, submoduleReference);
     }
     regularCallExpression(node, context) {
         if (this.visibleSpans.containsStartOfNode(node)) {

package/lib/languages/target-language.d.ts

@@ -1,12 +1,37 @@
 export declare enum TargetLanguage {
+    /** @internal an alias of PYTHON to make intent clear when language is irrelevant */
+    VISUALIZE = "python",
     PYTHON = "python",
     CSHARP = "csharp",
     JAVA = "java",
     GO = "go"
 }
-export declare function targetName(language: TargetLanguage.PYTHON): 'python';
+export declare function targetName(language: TargetLanguage.PYTHON | TargetLanguage.VISUALIZE): 'python';
 export declare function targetName(language: TargetLanguage.CSHARP): 'dotnet';
 export declare function targetName(language: TargetLanguage.JAVA): 'java';
 export declare function targetName(language: TargetLanguage.GO): 'go';
 export declare function targetName(language: TargetLanguage): 'python' | 'dotnet' | 'java' | 'go';
+/**
+ * Determines whether the supplied language supports transitive submodule
+ * access (similar to how TypeScript/Javascript allows to use a partially
+ * qualified name to access a namespace-nested value).
+ *
+ * If `true`, imports will mirror those found in the original TypeScript
+ * code, namespace-traversing property accesses will be rendered as such. This
+ * means the following snippet would be transformed "as-is":
+ * ```ts
+ * import * as cdk from 'aws-cdk-lib';
+ * new cdk.aws_s3.Bucket(this, 'Bucket');
+ * ```
+ *
+ * If `false` on the other hand, each used submodule will be imported
+ * separately and namespace-traversing property accesses will be replaced with
+ * references to the separately-imported submodule. This means the above
+ * snippet would be transformed as if it had been modifired to:
+ * ```ts
+ * import * as aws_s3 from 'aws-cdk-lib/aws-s3';
+ * new aws_s3.Bucket(this, 'Bucket');
+ * ```
+ */
+export declare function supportsTransitiveSubmoduleAccess(language: TargetLanguage): boolean;
 //# sourceMappingURL=target-language.d.ts.map

package/lib/languages/target-language.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.targetName = exports.TargetLanguage = void 0;
+exports.supportsTransitiveSubmoduleAccess = exports.targetName = exports.TargetLanguage = void 0;
 const assert = require("assert");
 var TargetLanguage;
 (function (TargetLanguage) {
+    /** @internal an alias of PYTHON to make intent clear when language is irrelevant */
+    TargetLanguage["VISUALIZE"] = "python";
     TargetLanguage["PYTHON"] = "python";
     TargetLanguage["CSHARP"] = "csharp";
     TargetLanguage["JAVA"] = "java";
@@ -20,6 +22,7 @@ function targetName(language) {
     // values of the TargetLanguage enum, but we add an assert here for clarity of intent.
     assert(VALID_TARGET_LANGUAGES.has(language), `Invalid/unexpected target language identifier: ${language}`);
     switch (language) {
+        case TargetLanguage.VISUALIZE:
         case TargetLanguage.PYTHON:
             return 'python';
         case TargetLanguage.CSHARP:
@@ -31,4 +34,39 @@ function targetName(language) {
     }
 }
 exports.targetName = targetName;
+/**
+ * Determines whether the supplied language supports transitive submodule
+ * access (similar to how TypeScript/Javascript allows to use a partially
+ * qualified name to access a namespace-nested value).
+ *
+ * If `true`, imports will mirror those found in the original TypeScript
+ * code, namespace-traversing property accesses will be rendered as such. This
+ * means the following snippet would be transformed "as-is":
+ * ```ts
+ * import * as cdk from 'aws-cdk-lib';
+ * new cdk.aws_s3.Bucket(this, 'Bucket');
+ * ```
+ *
+ * If `false` on the other hand, each used submodule will be imported
+ * separately and namespace-traversing property accesses will be replaced with
+ * references to the separately-imported submodule. This means the above
+ * snippet would be transformed as if it had been modifired to:
+ * ```ts
+ * import * as aws_s3 from 'aws-cdk-lib/aws-s3';
+ * new aws_s3.Bucket(this, 'Bucket');
+ * ```
+ */
+function supportsTransitiveSubmoduleAccess(language) {
+    switch (language) {
+        case TargetLanguage.PYTHON:
+            return true;
+        case TargetLanguage.CSHARP:
+            return true;
+        case TargetLanguage.JAVA:
+            return false;
+        case TargetLanguage.GO:
+            return false;
+    }
+}
+exports.supportsTransitiveSubmoduleAccess = supportsTransitiveSubmoduleAccess;
 //# sourceMappingURL=target-language.js.map

package/lib/languages/visualize.d.ts

@@ -2,8 +2,10 @@ import * as ts from 'typescript';
 import { OTree } from '../o-tree';
 import { AstRenderer, AstHandler, CommentSyntax } from '../renderer';
 import { ImportStatement } from '../typescript/imports';
+import { TargetLanguage } from './target-language';
 export declare class VisualizeAstVisitor implements AstHandler<void> {
     private readonly includeHandlerNames?;
+    readonly language = TargetLanguage.VISUALIZE;
     readonly defaultContext: void;
     constructor(includeHandlerNames?: boolean | undefined);
     mergeContext(_old: any, _update: any): any;

package/lib/languages/visualize.js

@@ -3,9 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.VisualizeAstVisitor = void 0;
 const o_tree_1 = require("../o-tree");
 const renderer_1 = require("../renderer");
+const target_language_1 = require("./target-language");
 class VisualizeAstVisitor {
     constructor(includeHandlerNames) {
         this.includeHandlerNames = includeHandlerNames;
+        this.language = target_language_1.TargetLanguage.VISUALIZE;
         this.defaultContext = undefined;
     }
     mergeContext(_old, _update) {

package/lib/renderer.d.ts

@@ -1,6 +1,7 @@
 import * as ts from 'typescript';
 import { TargetLanguage } from './languages';
 import { OTree, UnknownSyntax, Span } from './o-tree';
+import { SubmoduleReference, SubmoduleReferenceMap } from './submodule-reference';
 import { ImportStatement } from './typescript/imports';
 /**
  * Render a TypeScript AST to some other representation (encoded in OTrees)
@@ -15,9 +16,10 @@ export declare class AstRenderer<C> {
     readonly typeChecker: ts.TypeChecker;
     private readonly handler;
     private readonly options;
+    readonly submoduleReferences: SubmoduleReferenceMap;
     readonly diagnostics: ts.Diagnostic[];
     readonly currentContext: C;
-    constructor(sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker, handler: AstHandler<C>, options?: AstRendererOptions);
+    constructor(sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker, handler: AstHandler<C>, options?: AstRendererOptions, submoduleReferences?: SubmoduleReferenceMap);
     /**
      * Merge the new context with the current context and create a new Converter from it
      */
@@ -95,6 +97,7 @@ export declare class AstRenderer<C> {
  * of AST node.
  */
 export interface AstHandler<C> {
+    readonly language: TargetLanguage;
     readonly defaultContext: C;
     readonly indentChar?: ' ' | '\t';
     mergeContext(old: C, update: Partial<C>): C;
@@ -110,7 +113,7 @@ export interface AstHandler<C> {
     returnStatement(node: ts.ReturnStatement, context: AstRenderer<C>): OTree;
     binaryExpression(node: ts.BinaryExpression, context: AstRenderer<C>): OTree;
     ifStatement(node: ts.IfStatement, context: AstRenderer<C>): OTree;
-    propertyAccessExpression(node: ts.PropertyAccessExpression, context: AstRenderer<C>): OTree;
+    propertyAccessExpression(node: ts.PropertyAccessExpression, context: AstRenderer<C>, submoduleReference: SubmoduleReference | undefined): OTree;
     awaitExpression(node: ts.AwaitExpression, context: AstRenderer<C>): OTree;
     callExpression(node: ts.CallExpression, context: AstRenderer<C>): OTree;
     expressionStatement(node: ts.ExpressionStatement, context: AstRenderer<C>): OTree;