aws · rix0rrr · Jan 3, 2020 · Jan 3, 2020 · Jan 3, 2020
diff --git a/packages/jsii-rosetta/lib/commands/extract.ts b/packages/jsii-rosetta/lib/commands/extract.ts
@@ -96,12 +96,25 @@ async function translateAll(snippets: IterableIterator<TypeScriptSnippet>, inclu
 export function singleThreadedTranslateAll(snippets: IterableIterator<TypeScriptSnippet>, includeCompilerDiagnostics: boolean): TranslateAllResult {
   const translatedSnippets = new Array<TranslatedSnippet>();
 
+  const failures = new Array<ts.Diagnostic>();
+
   const translator = new Translator(includeCompilerDiagnostics);
   for (const block of snippets) {
-    translatedSnippets.push(translator.translate(block));
+    try {
+      translatedSnippets.push(translator.translate(block));
+    } catch(e) {
+      failures.push({
+        category: ts.DiagnosticCategory.Error,
+        code: 999,
+        messageText: `rosetta: error translating snippet: ${e}\n${block.completeSource}`,
+        file: undefined,
+        start: undefined,
+        length: undefined,
+      });
+    }
   }
 
-  return { translatedSnippets, diagnostics: translator.diagnostics };
+  return { translatedSnippets, diagnostics: [...translator.diagnostics, ...failures] };
 }
 
 /**

diff --git a/packages/jsii-rosetta/lib/languages/csharp.ts b/packages/jsii-rosetta/lib/languages/csharp.ts
@@ -24,6 +24,11 @@ interface CSharpLanguageContext {
    */
   readonly inStructInterface: boolean;
 
+  /**
+   * So we know how to render property signatures
+   */
+  readonly inRegularInterface: boolean;
+
   /**
    * So we know how to render property assignments
    */
@@ -53,9 +58,12 @@ interface CSharpLanguageContext {
 type CSharpRenderer = AstRenderer<CSharpLanguageContext>;
 
 export class CSharpVisitor extends DefaultVisitor<CSharpLanguageContext> {
+  public readonly language = 'csharp';
+
   public readonly defaultContext = {
     propertyOrMethod: false,
     inStructInterface: false,
+    inRegularInterface: false,
     inKeyValueList: false,
     stringAsIdentifier: false,
     identifierAsString: false,
@@ -136,6 +144,17 @@ export class CSharpVisitor extends DefaultVisitor<CSharpLanguageContext> {
     return this.functionLike(node, renderer);
   }
 
+  public methodSignature(node: ts.MethodSignature, renderer: CSharpRenderer): OTree {
+    return new OTree([
+      this.renderTypeNode(node.type, false, renderer),
+      ' ',
+      renderer.updateContext({ propertyOrMethod: true }).convert(node.name),
+      '(',
+      new OTree([], renderer.convertAll(node.parameters), { separator: ', ' }),
+      ');'
+    ], [], { canBreakLine: true });
+  }
+
   // tslint:disable-next-line:max-line-length
   public functionLike(node: ts.FunctionLikeDeclarationBase, renderer: CSharpRenderer, opts: { isConstructor?: boolean } = {}): OTree {
     const methodName = opts.isConstructor ? renderer.currentContext.currentClassName || 'MyClass' : renderer.updateContext({ propertyOrMethod: true }).convert(node.name);
@@ -248,13 +267,15 @@ export class CSharpVisitor extends DefaultVisitor<CSharpLanguageContext> {
   }
 
   public propertySignature(node: ts.PropertySignature, renderer: CSharpRenderer): OTree {
+    const canSet = renderer.currentContext.inStructInterface || !isReadOnly(node);
+
     return new OTree([
-      visibility(node),
-      ' ',
+      !renderer.currentContext.inRegularInterface ? `${visibility(node)} ` : NO_SYNTAX,
       this.renderTypeNode(node.type, node.questionToken !== undefined, renderer),
       ' ',
       renderer.updateContext({ propertyOrMethod: true }).convert(node.name),
-      ';',
+      ' ',
+      canSet ? '{ get; set; }' : '{ get; }',
     ], [], { canBreakLine: true });
   }
 
@@ -308,7 +329,7 @@ export class CSharpVisitor extends DefaultVisitor<CSharpLanguageContext> {
       ...this.classHeritage(node, renderer),
       '\n{',
     ],
-    renderer.convertAll(node.members),
+    renderer.updateContext({ inRegularInterface: true }).convertAll(node.members),
     {
       indent: 4,
       canBreakLine: true,
@@ -503,7 +524,7 @@ function typeNameFromType(type: ts.Type, fallback: string): string {
 }
 
 function csharpTypeName(jsTypeName: string | undefined): string {
-  if (jsTypeName === undefined) { return '???'; }
+  if (jsTypeName === undefined) { return 'void'; }
   switch (jsTypeName) {
     case 'number': return 'int';
     case 'any': return 'object';

diff --git a/packages/jsii-rosetta/lib/languages/default.ts b/packages/jsii-rosetta/lib/languages/default.ts
@@ -5,12 +5,14 @@ import { ImportStatement } from '../typescript/imports';
 import { isStructInterface, isStructType } from '../jsii/jsii-utils';
 import { mapElementType, typeWithoutUndefinedUnion } from '../typescript/types';
 import { voidExpressionString } from '../typescript/ast-utils';
+import { TargetLanguage } from '.';
 
 /**
  * A basic visitor that applies for most curly-braces-based languages
  */
 export abstract class DefaultVisitor<C> implements AstHandler<C> {
   public abstract readonly defaultContext: C;
+  public abstract readonly language: TargetLanguage;
 
   public abstract mergeContext(old: C, update: C): C;
 
@@ -240,6 +242,10 @@ export abstract class DefaultVisitor<C> implements AstHandler<C> {
     return this.notImplemented(node, context);
   }
 
+  public methodSignature(node: ts.MethodSignature, context: AstRenderer<C>): OTree {
+    return this.notImplemented(node, context);
+  }
+
   public asExpression(node: ts.AsExpression, context: AstRenderer<C>): OTree {
     return this.notImplemented(node, context);
   }
@@ -284,7 +290,7 @@ export abstract class DefaultVisitor<C> implements AstHandler<C> {
   }
 
   private notImplemented(node: ts.Node, context: AstRenderer<C>) {
-    context.reportUnsupported(node);
+    context.reportUnsupported(node, this.language);
     return nimpl(node, context);
   }
 }

diff --git a/packages/jsii-rosetta/lib/languages/java.ts b/packages/jsii-rosetta/lib/languages/java.ts
@@ -1,7 +1,7 @@
 import * as ts from 'typescript';
 import { DefaultVisitor } from './default';
 import { AstRenderer } from '../renderer';
-import { OTree } from '../o-tree';
+import { OTree, NO_SYNTAX } from '../o-tree';
 import { builtInTypeName, mapElementType, typeWithoutUndefinedUnion } from '../typescript/types';
 import { isReadOnly, matchAst, nodeOfType, quoteStringLiteral, visibility } from '../typescript/ast-utils';
 import { ImportStatement } from '../typescript/imports';
@@ -72,11 +72,17 @@ interface InsideTypeDeclaration {
    * Needed to correctly generate the constructor.
    */
   readonly typeName: ts.Node | undefined;
+
+  /**
+   * Is this an interface (true) or a class (unset/false)
+   */
+  readonly isInterface?: boolean;
 }
 
 type JavaRenderer = AstRenderer<JavaContext>;
 
 export class JavaVisitor extends DefaultVisitor<JavaContext> {
+  public readonly language = 'java';
   public readonly defaultContext = {};
 
   public mergeContext(old: JavaContext, update: Partial<JavaContext>): JavaContext {
@@ -110,11 +116,34 @@ export class JavaVisitor extends DefaultVisitor<JavaContext> {
     return this.renderClassDeclaration(node, renderer);
   }
 
+  public regularInterfaceDeclaration(node: ts.InterfaceDeclaration, renderer: JavaRenderer): OTree {
+    return new OTree(
+      [
+        'public ',
+        'interface ',
+        renderer.convert(node.name),
+        ...this.typeHeritage(node, renderer.updateContext({ ignorePropertyPrefix: true })),
+        ' {',
+      ],
+      renderer
+        .updateContext({ insideTypeDeclaration: { typeName: node.name, isInterface: true } })
+        .convertAll(node.members),
+      {
+        indent: 4,
+        canBreakLine: true,
+        suffix: '\n}',
+      },
+    );
+  }
+
   public propertySignature(node: ts.PropertySignature, renderer: JavaRenderer): OTree {
     const propertyType = this.renderTypeNode(node.type, renderer, 'Object');
     const propertyName = renderer.convert(node.name);
 
-    const field = new OTree(
+    const isClass = !renderer.currentContext.insideTypeDeclaration?.isInterface;
+    const blockSep = isClass ? ' ' : ';';
+
+    const field = isClass ? new OTree(
       [],
       [
         'private ',
@@ -126,16 +155,16 @@ export class JavaVisitor extends DefaultVisitor<JavaContext> {
       {
         canBreakLine: true,
       },
-    );
+    ) : NO_SYNTAX;
 
     const getter = new OTree(
       [],
       [
-        'public ',
+        isClass ? 'public ' : NO_SYNTAX,
         propertyType,
         ' ',
-        `get${capitalize(renderer.textOf(node.name))}() `,
-        this.renderBlock([
+        `get${capitalize(renderer.textOf(node.name))}()${blockSep}`,
+        isClass ? this.renderBlock([
           new OTree(
             [
               '\n',
@@ -146,26 +175,28 @@ export class JavaVisitor extends DefaultVisitor<JavaContext> {
               ';',
             ],
           ),
-        ]),
+        ]) : NO_SYNTAX,
       ],
       {
         canBreakLine: true,
       },
     );
 
-    const setter = new OTree(
+    const hasSetter = isClass || !isReadOnly(node);
+
+    const setter = hasSetter ? new OTree(
       [],
       [
-        'public ',
+        isClass ? 'public ' : NO_SYNTAX,
         renderer.convert(renderer.currentContext.insideTypeDeclaration!.typeName),
         ' ',
         propertyName, // don't prefix the setter with `set` - makes it more aligned with JSII builders
         '(',
         propertyType,
         ' ',
         propertyName,
-        ') ',
-        this.renderBlock([
+        `)${blockSep}`,
+        isClass ? this.renderBlock([
           new OTree(
             [
               '\n',
@@ -186,12 +217,12 @@ export class JavaVisitor extends DefaultVisitor<JavaContext> {
               'return this;',
             ],
           ),
-        ]),
+        ]) : NO_SYNTAX,
       ],
       {
         canBreakLine: true,
       },
-    );
+    ) : NO_SYNTAX;
 
     return new OTree([], [field, getter, setter], { canBreakLine: true, separator: '\n' });
   }
@@ -234,6 +265,17 @@ export class JavaVisitor extends DefaultVisitor<JavaContext> {
       this.renderTypeNode(node.type, renderer, 'void'));
   }
 
+  public methodSignature(node: ts.MethodSignature, renderer: JavaRenderer): OTree {
+    return new OTree([
+      this.renderTypeNode(node.type, renderer, 'void'),
+      ' ',
+      renderer.convert(node.name),
+      '(',
+      new OTree([], renderer.convertAll(node.parameters), { separator: ', ' }),
+      ');',
+    ], [], { canBreakLine: true });
+  }
+
   public parameterDeclaration(node: ts.ParameterDeclaration, renderer: JavaRenderer): OTree {
     return new OTree([
       this.renderTypeNode(node.type, renderer),
@@ -472,8 +514,14 @@ export class JavaVisitor extends DefaultVisitor<JavaContext> {
 
   public propertyAssignment(node: ts.PropertyAssignment, renderer: JavaRenderer): OTree {
     return renderer.currentContext.inKeyValueList
-      ? this.singlePropertyInJavaScriptObjectLiteralToJavaMap(node, renderer)
-      : this.singlePropertyInJavaScriptObjectLiteralToFluentSetters(node, renderer);
+      ? this.singlePropertyInJavaScriptObjectLiteralToJavaMap(node.name, node.initializer, renderer)
+      : this.singlePropertyInJavaScriptObjectLiteralToFluentSetters(node.name, node.initializer, renderer);
+  }
+
+  public shorthandPropertyAssignment(node: ts.ShorthandPropertyAssignment, renderer: JavaRenderer): OTree {
+    return renderer.currentContext.inKeyValueList
+      ? this.singlePropertyInJavaScriptObjectLiteralToJavaMap(node.name, node.name, renderer)
+      : this.singlePropertyInJavaScriptObjectLiteralToFluentSetters(node.name, node.name, renderer);
   }
 
   public propertyAccessExpression(node: ts.PropertyAccessExpression, renderer: JavaRenderer): OTree {
@@ -530,28 +578,28 @@ export class JavaVisitor extends DefaultVisitor<JavaContext> {
     );
   }
 
-  private singlePropertyInJavaScriptObjectLiteralToJavaMap(node: ts.PropertyAssignment, renderer: JavaRenderer): OTree {
+  private singlePropertyInJavaScriptObjectLiteralToJavaMap(name: ts.Node, initializer: ts.Node, renderer: JavaRenderer): OTree {
     return new OTree(
       [],
       [
-        renderer.updateContext({ identifierAsString: true }).convert(node.name),
+        renderer.updateContext({ identifierAsString: true }).convert(name),
         ', ',
-        renderer.updateContext({ inKeyValueList: false }).convert(node.initializer),
+        renderer.updateContext({ inKeyValueList: false }).convert(initializer),
       ],
       {
         canBreakLine: true,
       },
     );
   }
 
-  private singlePropertyInJavaScriptObjectLiteralToFluentSetters(node: ts.PropertyAssignment, renderer: JavaRenderer): OTree {
+  private singlePropertyInJavaScriptObjectLiteralToFluentSetters(name: ts.Node, initializer: ts.Node, renderer: JavaRenderer): OTree {
     return new OTree(
       [],
       [
         '.',
-        renderer.updateContext({ stringLiteralAsIdentifier: true }).convert(node.name),
+        renderer.updateContext({ stringLiteralAsIdentifier: true }).convert(name),
         '(',
-        renderer.updateContext({ inNewExprWithObjectLiteralAsLastArg: false }).convert(node.initializer),
+        renderer.updateContext({ inNewExprWithObjectLiteralAsLastArg: false }).convert(initializer),
         ')',
       ],
       {

diff --git a/packages/jsii-rosetta/lib/languages/python.ts b/packages/jsii-rosetta/lib/languages/python.ts
@@ -69,6 +69,7 @@ export interface PythonVisitorOptions {
 }
 
 export class PythonVisitor extends DefaultVisitor<PythonLanguageContext> {
+  public readonly language = 'python';
   public readonly defaultContext = {};
 
   public constructor(private readonly options: PythonVisitorOptions = {}) {
@@ -442,6 +443,11 @@ export class PythonVisitor extends DefaultVisitor<PythonLanguageContext> {
     return NO_SYNTAX;
   }
 
+  public methodSignature(_node: ts.MethodSignature, _context: PythonVisitorContext): OTree {
+    // Does not represent in Python
+    return NO_SYNTAX;
+  }
+
   public asExpression(node: ts.AsExpression, context: PythonVisitorContext): OTree {
     return context.convert(node.expression);
   }

diff --git a/packages/jsii-rosetta/lib/languages/visualize.ts b/packages/jsii-rosetta/lib/languages/visualize.ts
@@ -138,6 +138,10 @@ export class VisualizeAstVisitor implements AstHandler<void> {
     return this.defaultNode('propertySignature', node, context);
   }
 
+  public methodSignature(node: ts.MethodSignature, context: AstRenderer<void>): OTree {
+    return this.defaultNode('methodSignature', node, context);
+  }
+
   public asExpression(node: ts.AsExpression, context: AstRenderer<void>): OTree {
     return this.defaultNode('asExpression', node, context);
   }