jsii-rosetta 1.74.0 → 1.76.0

package/lib/renderer.js

@@ -15,11 +15,12 @@ const types_1 = require("./typescript/types");
  * the type of which should be expressed via the C parameter.
  */
 class AstRenderer {
-    constructor(sourceFile, typeChecker, handler, options = {}) {
+    constructor(sourceFile, typeChecker, handler, options = {}, submoduleReferences = new Map()) {
         this.sourceFile = sourceFile;
         this.typeChecker = typeChecker;
         this.handler = handler;
         this.options = options;
+        this.submoduleReferences = submoduleReferences;
         this.diagnostics = new Array();
         this.currentContext = handler.defaultContext;
     }
@@ -190,152 +191,115 @@ class AstRenderer {
      * Dispatch node to handler
      */
     dispatch(tree) {
-        // Special nodes
-        if (ts.isEmptyStatement(tree)) {
-            // Additional semicolon where it doesn't belong.
-            return o_tree_1.NO_SYNTAX;
-        }
         const visitor = this.handler;
-        // Nodes with meaning
-        if (ts.isSourceFile(tree)) {
-            return visitor.sourceFile(tree, this);
-        }
-        if (ts.isImportEqualsDeclaration(tree)) {
-            return visitor.importStatement((0, imports_1.analyzeImportEquals)(tree, this), this);
-        }
-        if (ts.isImportDeclaration(tree)) {
-            return visitor.importStatement((0, imports_1.analyzeImportDeclaration)(tree, this), this);
-        }
-        if (ts.isStringLiteral(tree) || ts.isNoSubstitutionTemplateLiteral(tree)) {
-            return visitor.stringLiteral(tree, this);
-        }
-        if (ts.isNumericLiteral(tree)) {
-            return visitor.numericLiteral(tree, this);
-        }
-        if (ts.isFunctionDeclaration(tree)) {
-            return visitor.functionDeclaration(tree, this);
-        }
-        if (ts.isIdentifier(tree)) {
-            return visitor.identifier(tree, this);
-        }
-        if (ts.isBlock(tree)) {
-            return visitor.block(tree, this);
-        }
-        if (ts.isParameter(tree)) {
-            return visitor.parameterDeclaration(tree, this);
-        }
-        if (ts.isReturnStatement(tree)) {
-            return visitor.returnStatement(tree, this);
-        }
-        if (ts.isBinaryExpression(tree)) {
-            return visitor.binaryExpression(tree, this);
-        }
-        if (ts.isIfStatement(tree)) {
-            return visitor.ifStatement(tree, this);
-        }
-        if (ts.isPropertyAccessExpression(tree)) {
-            return visitor.propertyAccessExpression(tree, this);
-        }
-        if (ts.isAwaitExpression(tree)) {
-            return visitor.awaitExpression(tree, this);
-        }
-        if (ts.isCallExpression(tree)) {
-            return visitor.callExpression(tree, this);
-        }
-        if (ts.isExpressionStatement(tree)) {
-            return visitor.expressionStatement(tree, this);
-        }
-        if (ts.isToken(tree)) {
-            return visitor.token(tree, this);
-        }
-        if (ts.isObjectLiteralExpression(tree)) {
-            return visitor.objectLiteralExpression(tree, this);
-        }
-        if (ts.isNewExpression(tree)) {
-            return visitor.newExpression(tree, this);
-        }
-        if (ts.isPropertyAssignment(tree)) {
-            return visitor.propertyAssignment(tree, this);
-        }
-        if (ts.isVariableStatement(tree)) {
-            return visitor.variableStatement(tree, this);
-        }
-        if (ts.isVariableDeclarationList(tree)) {
-            return visitor.variableDeclarationList(tree, this);
-        }
-        if (ts.isVariableDeclaration(tree)) {
-            return visitor.variableDeclaration(tree, this);
-        }
-        if (ts.isJSDoc(tree)) {
-            return visitor.jsDoc(tree, this);
-        }
-        if (ts.isArrayLiteralExpression(tree)) {
-            return visitor.arrayLiteralExpression(tree, this);
-        }
-        if (ts.isShorthandPropertyAssignment(tree)) {
-            return visitor.shorthandPropertyAssignment(tree, this);
-        }
-        if (ts.isForOfStatement(tree)) {
-            return visitor.forOfStatement(tree, this);
-        }
-        if (ts.isClassDeclaration(tree)) {
-            return visitor.classDeclaration(tree, this);
-        }
-        if (ts.isConstructorDeclaration(tree)) {
-            return visitor.constructorDeclaration(tree, this);
-        }
-        if (ts.isPropertyDeclaration(tree)) {
-            return visitor.propertyDeclaration(tree, this);
-        }
-        if (ts.isComputedPropertyName(tree)) {
-            return visitor.computedPropertyName(tree.expression, this);
-        }
-        if (ts.isMethodDeclaration(tree)) {
-            return visitor.methodDeclaration(tree, this);
-        }
-        if (ts.isInterfaceDeclaration(tree)) {
-            return visitor.interfaceDeclaration(tree, this);
-        }
-        if (ts.isPropertySignature(tree)) {
-            return visitor.propertySignature(tree, this);
-        }
-        if (ts.isMethodSignature(tree)) {
-            return visitor.methodSignature(tree, this);
-        }
-        if (ts.isAsExpression(tree)) {
-            return visitor.asExpression(tree, this);
-        }
-        if (ts.isPrefixUnaryExpression(tree)) {
-            return visitor.prefixUnaryExpression(tree, this);
-        }
-        if (ts.isSpreadAssignment(tree)) {
-            if (this.textOf(tree) === '...') {
-                return visitor.ellipsis(tree, this);
-            }
-            return visitor.spreadAssignment(tree, this);
-        }
-        if (ts.isSpreadElement(tree)) {
-            if (this.textOf(tree) === '...') {
-                return visitor.ellipsis(tree, this);
-            }
-            return visitor.spreadElement(tree, this);
-        }
-        if (ts.isElementAccessExpression(tree)) {
-            return visitor.elementAccessExpression(tree, this);
-        }
-        if (ts.isTemplateExpression(tree)) {
-            return visitor.templateExpression(tree, this);
-        }
-        if (ts.isNonNullExpression(tree)) {
-            return visitor.nonNullExpression(tree, this);
-        }
-        if (ts.isParenthesizedExpression(tree)) {
-            return visitor.parenthesizedExpression(tree, this);
-        }
-        if (ts.isVoidExpression(tree)) {
-            return visitor.maskingVoidExpression(tree, this);
+        // Using a switch on tree.kind + forced down-casting, because this is significantly faster than
+        // doing a cascade of `if` statements with the `ts.is<NodeType>` functions, since `tree.kind` is
+        // effectively integers, and this switch statement is hence optimizable to a jump table. This is
+        // a VERY significant enhancement to the debugging experience, too.
+        switch (tree.kind) {
+            case ts.SyntaxKind.EmptyStatement:
+                // Additional semicolon where it doesn't belong.
+                return o_tree_1.NO_SYNTAX;
+            case ts.SyntaxKind.SourceFile:
+                return visitor.sourceFile(tree, this);
+            case ts.SyntaxKind.ImportEqualsDeclaration:
+                return visitor.importStatement((0, imports_1.analyzeImportEquals)(tree, this), this);
+            case ts.SyntaxKind.ImportDeclaration:
+                return new o_tree_1.OTree([], (0, imports_1.analyzeImportDeclaration)(tree, this, this.submoduleReferences).map((import_) => visitor.importStatement(import_, this)), { canBreakLine: true, separator: '\n' });
+            case ts.SyntaxKind.StringLiteral:
+            case ts.SyntaxKind.NoSubstitutionTemplateLiteral:
+                return visitor.stringLiteral(tree, this);
+            case ts.SyntaxKind.NumericLiteral:
+                return visitor.numericLiteral(tree, this);
+            case ts.SyntaxKind.FunctionDeclaration:
+                return visitor.functionDeclaration(tree, this);
+            case ts.SyntaxKind.Identifier:
+                return visitor.identifier(tree, this);
+            case ts.SyntaxKind.Block:
+                return visitor.block(tree, this);
+            case ts.SyntaxKind.Parameter:
+                return visitor.parameterDeclaration(tree, this);
+            case ts.SyntaxKind.ReturnStatement:
+                return visitor.returnStatement(tree, this);
+            case ts.SyntaxKind.BinaryExpression:
+                return visitor.binaryExpression(tree, this);
+            case ts.SyntaxKind.IfStatement:
+                return visitor.ifStatement(tree, this);
+            case ts.SyntaxKind.PropertyAccessExpression:
+                const submoduleReference = this.submoduleReferences?.get(tree);
+                return visitor.propertyAccessExpression(tree, this, submoduleReference);
+            case ts.SyntaxKind.AwaitExpression:
+                return visitor.awaitExpression(tree, this);
+            case ts.SyntaxKind.CallExpression:
+                return visitor.callExpression(tree, this);
+            case ts.SyntaxKind.ExpressionStatement:
+                return visitor.expressionStatement(tree, this);
+            case ts.SyntaxKind.ObjectLiteralExpression:
+                return visitor.objectLiteralExpression(tree, this);
+            case ts.SyntaxKind.NewExpression:
+                return visitor.newExpression(tree, this);
+            case ts.SyntaxKind.PropertyAssignment:
+                return visitor.propertyAssignment(tree, this);
+            case ts.SyntaxKind.VariableStatement:
+                return visitor.variableStatement(tree, this);
+            case ts.SyntaxKind.VariableDeclarationList:
+                return visitor.variableDeclarationList(tree, this);
+            case ts.SyntaxKind.VariableDeclaration:
+                return visitor.variableDeclaration(tree, this);
+            case ts.SyntaxKind.ArrayLiteralExpression:
+                return visitor.arrayLiteralExpression(tree, this);
+            case ts.SyntaxKind.ShorthandPropertyAssignment:
+                return visitor.shorthandPropertyAssignment(tree, this);
+            case ts.SyntaxKind.ForOfStatement:
+                return visitor.forOfStatement(tree, this);
+            case ts.SyntaxKind.ClassDeclaration:
+                return visitor.classDeclaration(tree, this);
+            case ts.SyntaxKind.Constructor:
+                return visitor.constructorDeclaration(tree, this);
+            case ts.SyntaxKind.PropertyDeclaration:
+                return visitor.propertyDeclaration(tree, this);
+            case ts.SyntaxKind.ComputedPropertyName:
+                return visitor.computedPropertyName(tree.expression, this);
+            case ts.SyntaxKind.MethodDeclaration:
+                return visitor.methodDeclaration(tree, this);
+            case ts.SyntaxKind.InterfaceDeclaration:
+                return visitor.interfaceDeclaration(tree, this);
+            case ts.SyntaxKind.PropertySignature:
+                return visitor.propertySignature(tree, this);
+            case ts.SyntaxKind.MethodSignature:
+                return visitor.methodSignature(tree, this);
+            case ts.SyntaxKind.AsExpression:
+                return visitor.asExpression(tree, this);
+            case ts.SyntaxKind.PrefixUnaryExpression:
+                return visitor.prefixUnaryExpression(tree, this);
+            case ts.SyntaxKind.SpreadAssignment:
+                if (this.textOf(tree) === '...') {
+                    return visitor.ellipsis(tree, this);
+                }
+                return visitor.spreadAssignment(tree, this);
+            case ts.SyntaxKind.SpreadElement:
+                if (this.textOf(tree) === '...') {
+                    return visitor.ellipsis(tree, this);
+                }
+                return visitor.spreadElement(tree, this);
+            case ts.SyntaxKind.ElementAccessExpression:
+                return visitor.elementAccessExpression(tree, this);
+            case ts.SyntaxKind.TemplateExpression:
+                return visitor.templateExpression(tree, this);
+            case ts.SyntaxKind.NonNullExpression:
+                return visitor.nonNullExpression(tree, this);
+            case ts.SyntaxKind.ParenthesizedExpression:
+                return visitor.parenthesizedExpression(tree, this);
+            case ts.SyntaxKind.VoidExpression:
+                return visitor.maskingVoidExpression(tree, this);
+            case ts.SyntaxKind.JSDocComment:
+                return visitor.jsDoc(tree, this);
+            default:
+                if (ts.isToken(tree)) {
+                    return visitor.token(tree, this);
+                }
+                this.reportUnsupported(tree, undefined);
         }
-        this.reportUnsupported(tree, undefined);
         if (this.options.bestEffort !== false) {
             // When doing best-effort conversion and we don't understand the node type, just return the complete text of it as-is
             return new o_tree_1.OTree([this.textOf(tree)]);

package/lib/submodule-reference.d.ts

@@ -0,0 +1,13 @@
+import * as ts from 'typescript';
+export declare type SubmoduleReferenceMap = ReadonlyMap<ts.PropertyAccessExpression | ts.LeftHandSideExpression | ts.Identifier | ts.PrivateIdentifier, SubmoduleReference>;
+export declare class SubmoduleReference {
+    readonly root: ts.Symbol;
+    readonly submoduleChain: ts.LeftHandSideExpression | ts.Identifier | ts.PrivateIdentifier;
+    readonly path: readonly ts.Node[];
+    static inSourceFile(sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker): SubmoduleReferenceMap;
+    private static inNode;
+    private constructor();
+    get lastNode(): ts.Node;
+    toString(): string;
+}
+//# sourceMappingURL=submodule-reference.d.ts.map

package/lib/submodule-reference.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubmoduleReference = void 0;
+const ts = require("typescript");
+class SubmoduleReference {
+    constructor(root, submoduleChain, path) {
+        this.root = root;
+        this.submoduleChain = submoduleChain;
+        this.path = path;
+    }
+    static inSourceFile(sourceFile, typeChecker) {
+        const importDeclarations = sourceFile.statements
+            .filter((stmt) => ts.isImportDeclaration(stmt))
+            .flatMap((stmt) => importedSymbolsFrom(stmt, sourceFile, typeChecker));
+        return SubmoduleReference.inNode(sourceFile, typeChecker, new Set(importDeclarations));
+    }
+    static inNode(node, typeChecker, importDeclarations, map = new Map()) {
+        if (ts.isPropertyAccessExpression(node)) {
+            const [head, ...tail] = propertyPath(node);
+            const symbol = typeChecker.getSymbolAtLocation(head.name);
+            if (symbol && importDeclarations.has(symbol)) {
+                // This is a reference within an imported namespace, so we need to record that...
+                const firstNonNamespace = tail.findIndex((item) => !isLikelyNamespace(item.name, typeChecker));
+                if (firstNonNamespace < 0) {
+                    map.set(node.expression, new SubmoduleReference(symbol, node.expression, []));
+                }
+                else {
+                    const tailEnd = tail[firstNonNamespace].expression;
+                    const path = tail.slice(0, firstNonNamespace).map((item) => item.name);
+                    map.set(tailEnd, new SubmoduleReference(symbol, tailEnd, path));
+                }
+            }
+            return map;
+        }
+        // Faster than ||-ing a bung of if statements to avoid traversing uninteresting nodes...
+        switch (node.kind) {
+            case ts.SyntaxKind.ImportDeclaration:
+            case ts.SyntaxKind.ExportDeclaration:
+                break;
+            default:
+                for (const child of node.getChildren()) {
+                    map = SubmoduleReference.inNode(child, typeChecker, importDeclarations, map);
+                }
+        }
+        return map;
+    }
+    get lastNode() {
+        if (this.path.length === 0) {
+            const node = this.root.valueDeclaration ?? this.root.declarations[0];
+            return ts.isNamespaceImport(node) || ts.isImportSpecifier(node) ? node.name : node;
+        }
+        return this.path[this.path.length - 1];
+    }
+    toString() {
+        return `${this.constructor.name}<root=${this.root.name}, path=${JSON.stringify(this.path.map((item) => item.getText(item.getSourceFile())))}>`;
+    }
+}
+exports.SubmoduleReference = SubmoduleReference;
+/**
+ * Determines what symbols are imported by the given TypeScript import
+ * delcaration, in the context of the specified file, using the provided type
+ * checker.
+ *
+ * @param decl        an import declaration.
+ * @param sourceFile  the source file that contains the import declaration.
+ * @param typeChecker a TypeChecker instance valid for the provided source file.
+ *
+ * @returns the (possibly empty) list of symbols imported by this declaration.
+ */
+function importedSymbolsFrom(decl, sourceFile, typeChecker) {
+    const { importClause } = decl;
+    if (importClause == null) {
+        // This is a "for side effects" import, which isn't relevant for our business here...
+        return [];
+    }
+    const { name, namedBindings } = importClause;
+    const imports = new Array();
+    if (name != null) {
+        const symbol = typeChecker.getSymbolAtLocation(name);
+        if (symbol == null) {
+            throw new Error(`No symbol was defined for node ${name.getText(sourceFile)}`);
+        }
+        imports.push(symbol);
+    }
+    if (namedBindings != null) {
+        if (ts.isNamespaceImport(namedBindings)) {
+            const { name } = namedBindings;
+            const symbol = typeChecker.getSymbolAtLocation(name);
+            if (symbol == null) {
+                throw new Error(`No symbol was defined for node ${name.getText(sourceFile)}`);
+            }
+            imports.push(symbol);
+        }
+        else {
+            for (const specifier of namedBindings.elements) {
+                const { name } = specifier;
+                const symbol = typeChecker.getSymbolAtLocation(name);
+                if (symbol == null) {
+                    throw new Error(`No symbol was defined for node ${name.getText(sourceFile)}`);
+                }
+                imports.push(symbol);
+            }
+        }
+    }
+    return imports;
+}
+function propertyPath(node) {
+    const { expression, name } = node;
+    if (!ts.isPropertyAccessExpression(expression)) {
+        return [
+            { name: expression, expression },
+            { name, expression },
+        ];
+    }
+    return [...propertyPath(expression), { name, expression }];
+}
+/**
+ * A heuristic to determine whether the provided node likely refers to some
+ * namespace.
+ *
+ * @param node        the node to be checked.
+ * @param typeChecker a type checker that can obtain symbols for this node.
+ *
+ * @returns true if the node likely refers to a namespace name.
+ */
+function isLikelyNamespace(node, typeChecker) {
+    if (!ts.isIdentifier(node)) {
+        return false;
+    }
+    // If the identifier was bound to a symbol, we can inspect the declarations of
+    // it to validate they are all module or namespace declarations.
+    const symbol = typeChecker.getSymbolAtLocation(node);
+    if (symbol != null) {
+        return (symbol.declarations.length > 0 &&
+            symbol.declarations.every((decl) => ts.isModuleDeclaration(decl) || ts.isNamespaceExport(decl) || ts.isNamespaceImport(decl)));
+    }
+    // We understand this is likely a namespace if the name does not start with
+    // upper-case letter.
+    return !startsWithUpperCase(node.text);
+}
+function startsWithUpperCase(text) {
+    return text.length > 0 && text[0] === text[0].toUpperCase();
+}
+//# sourceMappingURL=submodule-reference.js.map

package/lib/translate.d.ts

@@ -81,6 +81,7 @@ export declare class SnippetTranslator {
     private readonly visibleSpans;
     private readonly compilation;
     private readonly tryCompile;
+    private readonly submoduleReferences;
     constructor(snippet: TypeScriptSnippet, options?: SnippetTranslatorOptions);
     /**
      * Returns a boolean if compilation was attempted, and undefined if it was not.

package/lib/translate.js

@@ -11,10 +11,12 @@ const ts = require("typescript");
 const util_1 = require("util");
 const languages_1 = require("./languages");
 const record_references_1 = require("./languages/record-references");
+const target_language_1 = require("./languages/target-language");
 const logging = require("./logging");
 const o_tree_1 = require("./o-tree");
 const renderer_1 = require("./renderer");
 const snippet_1 = require("./snippet");
+const submodule_reference_1 = require("./submodule-reference");
 const key_1 = require("./tablets/key");
 const schema_1 = require("./tablets/schema");
 const tablets_1 = require("./tablets/tablets");
@@ -47,10 +49,14 @@ class Translator {
     translate(snip, languages = Object.values(languages_1.TargetLanguage)) {
         logging.debug(`Translating ${(0, key_1.snippetKey)(snip)} ${(0, util_1.inspect)(snip.parameters ?? {})}`);
         const translator = this.translatorFor(snip);
-        const translations = (0, util_2.mkDict)(languages.map((lang) => {
+        const translations = (0, util_2.mkDict)(languages.flatMap((lang, idx, languages) => {
+            if (languages.slice(0, idx).includes(lang)) {
+                // This language was duplicated in the request... we'll skip that here...
+                return [];
+            }
             const languageConverterFactory = languages_1.TARGET_LANGUAGES[lang];
             const translated = translator.renderUsing(languageConverterFactory.createVisitor());
-            return [lang, { source: translated, version: languageConverterFactory.version }];
+            return [[lang, { source: translated, version: languageConverterFactory.version }]];
         }));
         if (snip.parameters?.infused === undefined) {
             __classPrivateFieldGet(this, _Translator_diagnostics, "f").push(...translator.diagnostics);
@@ -105,6 +111,8 @@ class SnippetTranslator {
         this.compilation = compiler.compileInMemory(removeSlashes((0, snippet_1.formatLocation)(snippet.location)), source, fakeCurrentDirectory);
         // Respect '/// !hide' and '/// !show' directives
         this.visibleSpans = visible_spans_1.Spans.visibleSpansFromSource(source);
+        // Find submodule references on explicit imports
+        this.submoduleReferences = submodule_reference_1.SubmoduleReference.inSourceFile(this.compilation.rootFile, this.compilation.program.getTypeChecker());
         // This makes it about 5x slower, so only do it on demand
         // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
         this.tryCompile = (options.includeCompilerDiagnostics || snippet.strict) ?? false;
@@ -150,7 +158,9 @@ class SnippetTranslator {
         return this.tryCompile ? this.compileDiagnostics.length === 0 : undefined;
     }
     renderUsing(visitor) {
-        const converter = new renderer_1.AstRenderer(this.compilation.rootFile, this.compilation.program.getTypeChecker(), visitor, this.options);
+        const converter = new renderer_1.AstRenderer(this.compilation.rootFile, this.compilation.program.getTypeChecker(), visitor, this.options, 
+        // If we support transitive submodule access, don't provide a submodule reference map.
+        (0, target_language_1.supportsTransitiveSubmoduleAccess)(visitor.language) ? undefined : this.submoduleReferences);
         const converted = converter.convert(this.compilation.rootFile);
         this.translateDiagnostics.push(...filterVisibleDiagnostics(converter.diagnostics, this.visibleSpans));
         return (0, o_tree_1.renderTree)(converted, { indentChar: visitor.indentChar, visibleSpans: this.visibleSpans });
@@ -161,7 +171,7 @@ class SnippetTranslator {
     }
     fqnsReferenced() {
         const visitor = new record_references_1.RecordReferencesVisitor(this.visibleSpans);
-        const converter = new renderer_1.AstRenderer(this.compilation.rootFile, this.compilation.program.getTypeChecker(), visitor, this.options);
+        const converter = new renderer_1.AstRenderer(this.compilation.rootFile, this.compilation.program.getTypeChecker(), visitor, this.options, this.submoduleReferences);
         converter.convert(this.compilation.rootFile);
         return visitor.fqnsReferenced();
     }

package/lib/typescript/imports.d.ts

@@ -1,6 +1,7 @@
 import * as ts from 'typescript';
 import { JsiiSymbol } from '../jsii/jsii-utils';
 import { AstRenderer } from '../renderer';
+import { SubmoduleReferenceMap } from '../submodule-reference';
 /**
  * Our own unification of import statements
  */
@@ -12,7 +13,16 @@ export interface ImportStatement {
 }
 export declare type FullImport = {
     readonly import: 'full';
-    readonly alias: string;
+    /**
+     * The name of the namespace prefix in the source code. Used to strip the
+     * prefix in certain languages (e.g: Java).
+     */
+    readonly sourceName: string;
+    /**
+     * The name under which this module is imported. Undefined if the module is
+     * not aliased (could be the case for namepsace/submodule imports).
+     */
+    readonly alias?: string;
 };
 export declare type SelectiveImport = {
     readonly import: 'selective';
@@ -28,4 +38,5 @@ export interface ImportBinding {
 }
 export declare function analyzeImportEquals(node: ts.ImportEqualsDeclaration, context: AstRenderer<any>): ImportStatement;
 export declare function analyzeImportDeclaration(node: ts.ImportDeclaration, context: AstRenderer<any>): ImportStatement;
+export declare function analyzeImportDeclaration(node: ts.ImportDeclaration, context: AstRenderer<any>, submoduleReferences: SubmoduleReferenceMap): ImportStatement[];
 //# sourceMappingURL=imports.d.ts.map