chore: make jsii fully synchronous

packages/@jsii/python-runtime/.gitignore

@@ -12,6 +12,7 @@ __pycache__
 .mypy_cache
 .pytest_cache
 
-build
+# Occasionally left behind by pip, transient (safe to delete)
+build/
 
 README.md

packages/@jsii/python-runtime/build-tools/deps.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env npx ts-node
 
+import { removeSync } from 'fs-extra';
 import { join, resolve } from 'path';
 import { venv, runCommand } from './_constants';
 
@@ -18,3 +19,8 @@ runCommand(
   ['-m', 'pip', 'install', '-r', resolve(__dirname, '..', 'requirements.txt')],
   { env },
 );
+
+// Sometimes, pip leaves a `build` directory behind, which can mess with mypy
+// when run with `pytest --mypy`. This directory should be transient and so we
+// simply clean it up here.
+removeSync(resolve(__dirname, '..', 'build'));

packages/@jsii/python-runtime/pyproject.toml

@@ -1,12 +1,11 @@
 [build-system]
-requires = [
-  "pip~=20.2",
-  "setuptools~=50.3",
-  "wheel~=0.35",
-]
+requires = ["pip~=20.2", "setuptools~=50.3", "wheel~=0.35"]
 build-backend = 'setuptools.build_meta'
 
 [tool.black]
 target-version = ['py36', 'py37', 'py38']
 include = '\.pyi?$'
 exclude = '\.(git|mypy_cache|env)'
+
+[tool.mypy]
+ignore_missing_imports = true

packages/jsii-calc/test/assembly.jsii

@@ -1128,10 +1128,10 @@
                   "primitive": "number"
                 },
                 {
-                  "fqn": "jsii-calc.Multiply"
+                  "fqn": "@scope/jsii-calc-lib.Number"
                 },
                 {
-                  "fqn": "@scope/jsii-calc-lib.Number"
+                  "fqn": "jsii-calc.Multiply"
                 }
               ]
             }
@@ -16931,5 +16931,5 @@
     }
   },
   "version": "3.20.120",
-  "fingerprint": "sqJBfFAp4Hg5OgntWB3IRyRS7mpPF7G3qoh4NYSDeSw="
+  "fingerprint": "x8U5PHtkMg1Me8BU5rwy98qvqY6p+AhernFr4narjHc="
 }

packages/jsii-diff/test/diagnostics.test.ts

@@ -2,8 +2,8 @@ import { classifyDiagnostics, hasErrors } from '../lib/diagnostics';
 import { compare } from './util';
 
 // ----------------------------------------------------------------------
-test('experimental elements lead to warnings', async () => {
-  const mms = await compare(
+test('experimental elements lead to warnings', () => {
+  const mms = compare(
     `
     /** @experimental */
     export class Foo1 { }
@@ -21,8 +21,8 @@ test('experimental elements lead to warnings', async () => {
 });
 
 // ----------------------------------------------------------------------
-test('external stability violations are reported as warnings', async () => {
-  const mms = await compare(
+test('external stability violations are reported as warnings', () => {
+  const mms = compare(
     `
     /** @stability external */
     export class Foo1 { }
@@ -40,8 +40,8 @@ test('external stability violations are reported as warnings', async () => {
 });
 
 // ----------------------------------------------------------------------
-test('warnings can be turned into errors', async () => {
-  const mms = await compare(
+test('warnings can be turned into errors', () => {
+  const mms = compare(
     `
     /** @experimental */
     export class Foo1 { }
@@ -59,8 +59,8 @@ test('warnings can be turned into errors', async () => {
 });
 
 // ----------------------------------------------------------------------
-test('external stability violations are never turned into errors', async () => {
-  const mms = await compare(
+test('external stability violations are never turned into errors', () => {
+  const mms = compare(
     `
     /** @stability external */
     export class Foo1 { }
@@ -78,8 +78,8 @@ test('external stability violations are never turned into errors', async () => {
 });
 
 // ----------------------------------------------------------------------
-test('errors can be skipped', async () => {
-  const mms = await compare(
+test('errors can be skipped', () => {
+  const mms = compare(
     `
     export class Foo1 { }
   `,
@@ -100,8 +100,8 @@ test('errors can be skipped', async () => {
 });
 
 // ----------------------------------------------------------------------
-test('changing stable to experimental is breaking', async () => {
-  const mms = await compare(
+test('changing stable to experimental is breaking', () => {
+  const mms = compare(
     `
     /** @stable */
     export class Foo1 { }
@@ -128,8 +128,8 @@ test('changing stable to experimental is breaking', async () => {
 
 // ----------------------------------------------------------------------
 
-test('can make fields optional in output struct if it is marked @external', async () => {
-  const mms = await compare(
+test('can make fields optional in output struct if it is marked @external', () => {
+  const mms = compare(
     `
     /** @stability external */
     export interface TheStruct {

packages/jsii-diff/test/util.ts

@@ -4,25 +4,25 @@ import * as reflect from 'jsii-reflect';
 import { compareAssemblies } from '../lib';
 import { Mismatches } from '../lib/types';
 
-export async function expectNoError(original: string, updated: string) {
-  const mms = await compare(original, updated);
+export function expectNoError(original: string, updated: string) {
+  const mms = compare(original, updated);
   for (const msg of mms.messages()) {
     console.error(`- ${msg}`);
   }
   expect(mms.count).toBe(0);
 }
 
-export async function expectError(
+export function expectError(
   error: RegExp | undefined,
   original: string,
   updated: string,
 ) {
   if (error == null) {
-    await expectNoError(original, updated);
+    expectNoError(original, updated);
     return;
   }
 
-  const mms = await compare(original, updated);
+  const mms = compare(original, updated);
   expect(mms.count).not.toBe(0);
 
   const msgs = Array.from(mms.messages());
@@ -32,23 +32,14 @@ export async function expectError(
   }
 }
 
-export async function compare(
-  original: string,
-  updated: string,
-): Promise<Mismatches> {
+export function compare(original: string, updated: string): Mismatches {
   const ass1 = sourceToAssemblyHelper(original);
-  await expect(ass1).resolves.not.toThrowError();
   const ts1 = new reflect.TypeSystem();
-  const originalAssembly = ts1.addAssembly(
-    new reflect.Assembly(ts1, await ass1),
-  );
+  const originalAssembly = ts1.addAssembly(new reflect.Assembly(ts1, ass1));
 
   const ass2 = sourceToAssemblyHelper(updated);
-  await expect(ass2).resolves.not.toThrowError();
   const ts2 = new reflect.TypeSystem();
-  const updatedAssembly = ts2.addAssembly(
-    new reflect.Assembly(ts2, await ass2),
-  );
+  const updatedAssembly = ts2.addAssembly(new reflect.Assembly(ts2, ass2));
 
   return compareAssemblies(originalAssembly, updatedAssembly);
 }

packages/jsii-pacmak/test/generated-code/examples.test.ts

@@ -13,7 +13,7 @@ for (const name of fs.readdirSync(EXAMPLES_ROOT)) {
   const file = path.join(EXAMPLES_ROOT, name);
   test(name, async () => {
     const source = await fs.readFile(file, 'utf8');
-    const compiled = await jsii.compileJsiiForTest(source);
+    const compiled = jsii.compileJsiiForTest(source);
 
     const targets: AssemblyTargets = {
       dotnet: {

packages/jsii-reflect/test/independent.test.ts

@@ -1,9 +1,9 @@
 import * as reflect from '../lib';
 import { assemblyFromSource } from './util';
 
-test('get full github source location for a class or method', async () => {
+test('get full github source location for a class or method', () => {
   // WHEN
-  const assembly = await assemblyFromSource(
+  const assembly = assemblyFromSource(
     `
     export class Foo {
       public bar() {

packages/jsii-reflect/test/type-system.test.ts

@@ -203,8 +203,8 @@ test('Submodules can have a README', () => {
   );
 });
 
-test('overridden member knows about both parent types', async () => {
-  const ts = await typeSystemFromSource(`
+test('overridden member knows about both parent types', () => {
+  const ts = typeSystemFromSource(`
     export class Foo {
       public bar() {
         Array.isArray(3);
@@ -256,8 +256,8 @@ describe('Stability', () => {
   // ----------------------------------------------------------------------
 
   describe('lowest stability guarantee is advertised', () => {
-    test('when subclass is experimental', async () => {
-      const ts = await typeSystemFromSource(`
+    test('when subclass is experimental', () => {
+      const ts = typeSystemFromSource(`
         /**
          * @stable
          */
@@ -285,8 +285,8 @@ describe('Stability', () => {
       expect(method.docs.stability).toEqual(Stability.Experimental);
     });
 
-    test('when method is experimental', async () => {
-      const ts = await typeSystemFromSource(`
+    test('when method is experimental', () => {
+      const ts = typeSystemFromSource(`
         /**
          * @stable
          */
@@ -321,8 +321,8 @@ describe('Stability', () => {
       expect(method.docs.stability).toEqual(Stability.Experimental);
     });
 
-    test('when method is explicitly marked stable', async () => {
-      const ts = await typeSystemFromSource(`
+    test('when method is explicitly marked stable', () => {
+      const ts = typeSystemFromSource(`
         /**
          * @stable
          */
@@ -357,8 +357,8 @@ describe('Stability', () => {
       expect(method.docs.stability).toEqual(Stability.Experimental);
     });
 
-    test('external stability', async () => {
-      const ts = await typeSystemFromSource(`
+    test('external stability', () => {
+      const ts = typeSystemFromSource(`
         /**
          * @stability external
          */
@@ -383,8 +383,8 @@ describe('Stability', () => {
   });
 });
 
-test('TypeSystem.properties', async () => {
-  const ts = await typeSystemFromSource(`
+test('TypeSystem.properties', () => {
+  const ts = typeSystemFromSource(`
   export namespace submodule {
     export class Foo {
       public readonly test = 'TEST';
@@ -397,8 +397,8 @@ test('TypeSystem.properties', async () => {
   expect(ts.properties).toHaveLength(2);
 });
 
-test('TypeSystem.methods', async () => {
-  const ts = await typeSystemFromSource(`
+test('TypeSystem.methods', () => {
+  const ts = typeSystemFromSource(`
   export namespace submodule {
     export class Foo {
       public method(): void {}
@@ -411,8 +411,8 @@ test('TypeSystem.methods', async () => {
   expect(ts.methods).toHaveLength(2);
 });
 
-test('Assembly allTypes includes submodule types', async () => {
-  const asm = await assemblyFromSource({
+test('Assembly allTypes includes submodule types', () => {
+  const asm = assemblyFromSource({
     'index.ts': 'export * as submod from "./submod";',
     'submod.ts': `export class Foo {}`,
   });

packages/jsii-reflect/test/util.ts

@@ -2,19 +2,19 @@ import { sourceToAssemblyHelper, MultipleSourceFiles, PackageInfo } from 'jsii';
 
 import { Assembly, TypeSystem } from '../lib';
 
-export async function typeSystemFromSource(
+export function typeSystemFromSource(
   source: string | MultipleSourceFiles,
   cb?: (obj: PackageInfo) => void,
 ) {
-  const asm = await assemblyFromSource(source, cb);
+  const asm = assemblyFromSource(source, cb);
   return asm.system;
 }
 
-export async function assemblyFromSource(
+export function assemblyFromSource(
   source: string | MultipleSourceFiles,
   cb?: (obj: PackageInfo) => void,
-): Promise<Assembly> {
-  const ass = await sourceToAssemblyHelper(source, cb);
+): Assembly {
+  const ass = sourceToAssemblyHelper(source, cb);
   const ts = new TypeSystem();
   return ts.addAssembly(new Assembly(ts, ass));
 }