fix: fails when a method returns an anonymous class with a method

`jsii` used to fail when trying to generate deprecation warnings and
given a statement like this:

```ts
export function propertyInjectionDecorator<T extends Constructor>(ctr: T) {
  // Important for the bug: the anonymous class extends something, *and*
  // declares a method.
  return class extends ctr {
    public someMethod(): string {
      return 'abc';
    }
  };
}
```

The reason is that during generation of deprecation warnings we iterate
over all classes and methods (both exported and unexported), and
generate a symbol identifier for every method; but this class is anonymous
so it doesn't have a symbol, and generating the identifier fails with
the error:

```
TypeError: Cannot read properties of undefined (reading 'flags')
    at symbolIdentifier (.../jsii/lib/common/symbol-id.js:40:17)
```

Handle this by handling the case where we don't have a symbol
and returning `undefined`.

Author: rix0rrr

fixtures/jsii-calc/lib/decorators.ts

@@ -1,4 +1,17 @@
-function classDecorator(x: typeof SomeDecoratedClass, _context: ClassDecoratorContext): typeof SomeDecoratedClass {
+type Constructor = { new (...args: any[]): {} };
+
+export function functionReturnsClasstype<T extends Constructor>(ctr: T) {
+  return class extends ctr {
+  };
+}
+
+/**
+ * A class decorator that changes inherited state and adds a readonly field to the class.
+ *
+ * This wasn't the thing that was exploding, see `function-returning-anonymous-class.ts` for that.
+ * Nevertheless, this makes for a good class decorator demo.
+ */
+export function classDecorator(x: typeof SomeDecoratedClass): typeof SomeDecoratedClass {
   const ret = class extends x {
     constructor() {
       super();
@@ -8,27 +21,22 @@ function classDecorator(x: typeof SomeDecoratedClass, _context: ClassDecoratorCo
 
   // This adds a field to the class, but we can't reflect that in the type because of the limitations
   // of decorators. That's we advertise it through interface merging below.
-  ret.prototype['field'] = 'some_added_field';
+  (ret.prototype as any)['field'] = 'some_added_field';
 
   return ret;
 }
 
-function methodDecorator<A extends Function>(x: A, _context: ClassMethodDecoratorContext): A {
-  return x;
-}
-
 @classDecorator
 export class SomeDecoratedClass {
   protected state = 'state';
 
-  @methodDecorator
   public accessState() {
     return this.state;
   }
 }
 
 export interface SomeDecoratedClass {
-  field: string;
+  readonly field: string;
 }
 
 /**

fixtures/jsii-calc/lib/function-returning-anonymous-class.ts

@@ -0,0 +1,16 @@
+type Constructor = { new (...args: any[]): {} };
+
+/**
+ * Just the mere presence of this function is enough to break jsii, even if it's not exported
+ *
+ * The reason is that when we add deprecation warnings we visit all functions in all files.
+ */
+export function propertyInjectionDecorator<T extends Constructor>(ctr: T) {
+  // Important for the bug: the anonymous class extends something, *and*
+  // declares a method.
+  return class extends ctr {
+    public someMethod(): string {
+      return 'abc';
+    }
+  };
+}

src/common/symbol-id.ts

@@ -49,9 +49,13 @@ interface SymbolIdOptions {
  */
 export function symbolIdentifier(
   typeChecker: ts.TypeChecker,
-  sym: ts.Symbol,
+  sym: ts.Symbol | undefined,
   options: SymbolIdOptions = {},
 ): string | undefined {
+  if (!sym) {
+    return undefined;
+  }
+
   // If this symbol happens to be an alias, resolve it first
   // eslint-disable-next-line no-bitwise
   while ((sym.flags & ts.SymbolFlags.Alias) !== 0) {

src/transforms/deprecation-warnings.ts

@@ -469,6 +469,9 @@ class Transformer {
   private getStatementsForDeclaration(
     node: ts.MethodDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration | ts.ConstructorDeclaration,
   ): ts.Statement[] {
+    const printer = ts.createPrinter();
+    console.log(printer.printNode(ts.EmitHint.Unspecified, node, node.getSourceFile()));
+
     const klass = node.parent;
     const classSymbolId = symbolIdentifier(this.typeChecker, this.typeChecker.getTypeAtLocation(klass).symbol);
     if (classSymbolId && this.typeIndex.has(classSymbolId)) {

src/tsconfig/compiler-options.ts

@@ -4,6 +4,7 @@ import * as Case from '../case';
 export const BASE_COMPILER_OPTIONS: ts.CompilerOptions = {
   alwaysStrict: true,
   declaration: true,
+  experimentalDecorators: true,
   incremental: true,
   lib: ['lib.es2020.d.ts'],
   module: ts.ModuleKind.CommonJS,

test/__snapshots__/integration.test.ts.snap

@@ -235,4 +235,3 @@ describe('Object Validator', () => {
 function anythingExceptUndefined() {
   return fc.anything().filter((x) => x !== undefined);
 }
-