Add lenient generation mode to ignore unsupported lang features

Author: rubensworks

README.md

@@ -105,6 +105,7 @@ Usage:
        -e jsonld               Extension for components files (without .), defaults to 'jsonld'
        -i ignore-classes.json  Relative path to an optional file with class names to ignore
        -r prefix               Optional custom JSON-LD module prefix
+       --lenient               If unsupported language features must produce a warning instead of an error
        --debugState            If a 'componentsjs-generator-debug-state.json' file should be created with debug information
        --help                  Show information about this command
 ```
@@ -127,7 +128,8 @@ The following shows an example of the possible options:
   "ignoreComponents": [ "Class1", "Class2" ],
   "logLevel": "info",
   "modulePrefix": "myprefix",
-  "debugState": "true"
+  "debugState": "true",
+  "hardErrorUnsupported": false
 }
 ```
 

bin/componentsjs-generator.ts

@@ -17,6 +17,7 @@ Usage:
        -i ignore-classes.json  Relative path to an optional file with class names to ignore
        -l info                 The logger level
        -r prefix               Optional custom JSON-LD module prefix
+       --lenient               If unsupported language features must produce a warning instead of an error
        --debugState            If a 'componentsjs-generator-debug-state.json' file should be created with debug information
        --help                  Show information about this command
 `);

lib/config/GeneratorConfig.ts

@@ -36,4 +36,9 @@ export interface GeneratorConfig {
    * If a 'componentsjs-generator-debug-state.json' file should be created with debug information.
    */
   debugState: boolean;
+  /**
+   * If unsupported language features should cause a hard crash.
+   * Otherwise they are emitted as warning instead of error.
+   */
+  hardErrorUnsupported: boolean;
 }

lib/config/GeneratorFactory.ts

@@ -44,6 +44,7 @@ export class GeneratorFactory {
         acc[entry] = true;
         return acc;
       }, {}),
+      hardErrorUnsupported: config.hardErrorUnsupported,
     });
   }
 
@@ -69,6 +70,7 @@ export class GeneratorFactory {
       logLevel: 'info',
       modulePrefix: undefined,
       debugState: false,
+      hardErrorUnsupported: true,
     };
   }
 
@@ -95,6 +97,9 @@ export class GeneratorFactory {
     if (cliArgs.debugState) {
       config.debugState = cliArgs.debugState;
     }
+    if (cliArgs.lenient) {
+      config.hardErrorUnsupported = false;
+    }
     return config;
   }
 }

lib/generate/Generator.ts

@@ -31,6 +31,7 @@ export class Generator {
   private readonly logLevel: LogLevel;
   private readonly debugState: boolean;
   private readonly prefixes?: string | Record<string, string>;
+  private readonly hardErrorUnsupported: boolean;
 
   public constructor(args: GeneratorArgs) {
     this.resolutionContext = args.resolutionContext;
@@ -40,6 +41,7 @@ export class Generator {
     this.logLevel = args.logLevel;
     this.debugState = args.debugState;
     this.prefixes = args.prefixes;
+    this.hardErrorUnsupported = args.hardErrorUnsupported;
   }
 
   public async generateComponents(): Promise<void> {
@@ -49,10 +51,14 @@ export class Generator {
     const classLoader = new ClassLoader({ resolutionContext: this.resolutionContext, logger, commentLoader });
     const classFinder = new ClassFinder({ classLoader });
     const classIndexer = new ClassIndexer({ classLoader, classFinder, ignoreClasses: this.ignoreClasses, logger });
-    const parameterLoader = new ParameterLoader({ commentLoader });
+    const parameterLoader = new ParameterLoader({
+      commentLoader,
+      hardErrorUnsupported: this.hardErrorUnsupported,
+      logger,
+    });
     const parameterResolver = new ParameterResolver({
       classLoader,
-      commentLoader,
+      parameterLoader,
       ignoreClasses: this.ignoreClasses,
     });
 
@@ -80,7 +86,7 @@ export class Generator {
       const classAndInterfaceIndex = await classIndexer.createIndex(packageExports);
 
       // Load constructor data
-      const constructorsUnresolved = new ConstructorLoader({ commentLoader }).getConstructors(classAndInterfaceIndex);
+      const constructorsUnresolved = new ConstructorLoader({ parameterLoader }).getConstructors(classAndInterfaceIndex);
       const constructors = await parameterResolver.resolveAllConstructorParameters(constructorsUnresolved);
 
       // Load generics data
@@ -151,4 +157,5 @@ export interface GeneratorArgs {
   logLevel: LogLevel;
   debugState: boolean;
   prefixes?: string | Record<string, string>;
+  hardErrorUnsupported: boolean;
 }

lib/parse/ConstructorLoader.ts

@@ -2,18 +2,16 @@ import type { ClassDeclaration, MethodDefinition } from '@typescript-eslint/type
 import type { AST, TSESTreeOptions } from '@typescript-eslint/typescript-estree';
 import { AST_NODE_TYPES } from '@typescript-eslint/typescript-estree';
 import type { ClassIndex, ClassLoaded, ClassReferenceLoaded, GenericallyTyped } from './ClassIndex';
-import type { CommentLoader } from './CommentLoader';
-import type { ParameterDataField, ParameterRangeUnresolved } from './ParameterLoader';
-import { ParameterLoader } from './ParameterLoader';
+import type { ParameterDataField, ParameterRangeUnresolved, ParameterLoader } from './ParameterLoader';
 
 /**
  * Loads the constructor data of classes.
  */
 export class ConstructorLoader {
-  private readonly commentLoader: CommentLoader;
+  private readonly parameterLoader: ParameterLoader;
 
   public constructor(args: ConstructorLoaderArgs) {
-    this.commentLoader = args.commentLoader;
+    this.parameterLoader = args.parameterLoader;
   }
 
   /**
@@ -33,10 +31,9 @@ export class ConstructorLoader {
 
       // Fill in constructor data if we're loading a class, and we find a constructor in the inheritance chain.
       if (classLoadedRoot.type === 'class') {
-        const parameterLoader = new ParameterLoader({ commentLoader: this.commentLoader });
         const constructorChain = this.getConstructorChain({ value: classLoadedRoot });
         if (constructorChain.length > 0) {
-          constructorDataIndex[className] = parameterLoader.loadConstructorFields(constructorChain);
+          constructorDataIndex[className] = this.parameterLoader.loadConstructorFields(constructorChain);
         }
       }
     }
@@ -124,7 +121,7 @@ export class ConstructorLoader {
 }
 
 export interface ConstructorLoaderArgs {
-  commentLoader: CommentLoader;
+  parameterLoader: ParameterLoader;
 }
 
 /**

lib/parse/ParameterLoader.ts

@@ -8,6 +8,7 @@ import type { Identifier,
   Parameter,
   EntityName, TSTypeParameterInstantiation } from '@typescript-eslint/types/dist/ts-estree';
 import { AST_NODE_TYPES } from '@typescript-eslint/typescript-estree';
+import type { Logger } from 'winston';
 import type { ClassReferenceLoaded, InterfaceLoaded, ClassReference,
   ClassReferenceLoadedClassOrInterface, ClassIndex } from './ClassIndex';
 import type { CommentData, ConstructorCommentData, CommentLoader } from './CommentLoader';
@@ -25,9 +26,13 @@ export class ParameterLoader {
   ];
 
   private readonly commentLoader: CommentLoader;
+  private readonly hardErrorUnsupported: boolean;
+  private readonly logger: Logger;
 
   public constructor(args: ParameterLoaderArgs) {
     this.commentLoader = args.commentLoader;
+    this.hardErrorUnsupported = args.hardErrorUnsupported;
+    this.logger = args.logger;
   }
 
   /**
@@ -181,7 +186,7 @@ export class ParameterLoader {
     } else if (field.type === AST_NODE_TYPES.TSParameterProperty) {
       this.loadConstructorField(classLoaded, parameters, constructorCommentData, field.parameter);
     } else {
-      throw new Error(`Could not understand constructor parameter type ${field.type} in ${classLoaded.localName} at ${classLoaded.fileName}`);
+      this.throwOrWarn(new Error(`Could not understand constructor parameter type ${field.type} in ${classLoaded.localName} at ${classLoaded.fileName}`));
     }
   }
 
@@ -240,7 +245,7 @@ export class ParameterLoader {
         }
         return;
       default:
-        throw new Error(`Unsupported field type ${typeElement.type} in ${classLoaded.localName} in ${classLoaded.fileName}`);
+        this.throwOrWarn(new Error(`Unsupported field type ${typeElement.type} in ${classLoaded.localName} in ${classLoaded.fileName}`));
     }
   }
 
@@ -321,8 +326,9 @@ export class ParameterLoader {
                   value: this.getRangeFromTypeNode(classLoaded, typeNode.typeParameters.params[0], errorIdentifier),
                 };
               }
-              throw new Error(`Found invalid Array field type at ${errorIdentifier
-              } in ${classLoaded.localName} at ${classLoaded.fileName}`);
+              this.throwOrWarn(new Error(`Found invalid Array field type at ${errorIdentifier
+              } in ${classLoaded.localName} at ${classLoaded.fileName}`));
+              return { type: 'wildcard' };
             default:
               // First check if the type is a direct generic type
               if (classLoaded.type !== 'enum' && typeNode.typeName.name in classLoaded.generics) {
@@ -418,8 +424,9 @@ export class ParameterLoader {
           };
         }
     }
-    throw new Error(`Could not understand parameter type ${typeNode.type} of ${errorIdentifier
-    } in ${classLoaded.localName} at ${classLoaded.fileName}`);
+    this.throwOrWarn(new Error(`Could not understand parameter type ${typeNode.type} of ${errorIdentifier
+    } in ${classLoaded.localName} at ${classLoaded.fileName}`));
+    return { type: 'wildcard' };
   }
 
   protected getGenericTypeParameterInstantiations(
@@ -461,8 +468,9 @@ export class ParameterLoader {
 
     // Throw if no range was found
     if (!range) {
-      throw new Error(`Missing field type on ${this.getFieldName(classLoaded, field)
-      } in ${classLoaded.localName} at ${classLoaded.fileName}`);
+      this.throwOrWarn(new Error(`Missing field type on ${this.getFieldName(classLoaded, field)
+      } in ${classLoaded.localName} at ${classLoaded.fileName}`));
+      return { type: 'wildcard' };
     }
 
     // If the field has the '?' annotation, explicitly allow undefined as value to make it be considered optional.
@@ -610,8 +618,9 @@ export class ParameterLoader {
       );
     }
 
-    throw new Error(`Missing field type on ${this.getErrorIdentifierIndex()
-    } in ${classLoaded.localName} at ${classLoaded.fileName}`);
+    this.throwOrWarn(new Error(`Missing field type on ${this.getErrorIdentifierIndex()
+    } in ${classLoaded.localName} at ${classLoaded.fileName}`));
+    return { type: 'wildcard' };
   }
 
   /**
@@ -626,10 +635,20 @@ export class ParameterLoader {
       }
     }
   }
+
+  protected throwOrWarn(error: Error): void {
+    if (this.hardErrorUnsupported) {
+      throw error;
+    } else {
+      this.logger.error(error.message);
+    }
+  }
 }
 
 export interface ParameterLoaderArgs {
   commentLoader: CommentLoader;
+  hardErrorUnsupported: boolean;
+  logger: Logger;
 }
 
 export type ParameterData<R> = ParameterDataField<R> | ParameterDataIndex<R>;

lib/parse/ParameterResolver.ts

@@ -8,28 +8,25 @@ import type {
   InterfaceLoaded,
 } from './ClassIndex';
 import type { ClassLoader } from './ClassLoader';
-import type { CommentLoader } from './CommentLoader';
 import type { ConstructorData } from './ConstructorLoader';
 import type { GenericsData } from './GenericsLoader';
-import type {
-  ExtensionData,
+import type { ExtensionData,
   GenericTypeParameterData,
   ParameterData,
   ParameterDataField,
   ParameterRangeResolved,
   ParameterRangeUnresolved,
-} from './ParameterLoader';
-import { ParameterLoader } from './ParameterLoader';
+  ParameterLoader } from './ParameterLoader';
 
 export class ParameterResolver {
   private readonly classLoader: ClassLoader;
-  private readonly commentLoader: CommentLoader;
+  private readonly parameterLoader: ParameterLoader;
   private readonly ignoreClasses: Record<string, boolean>;
   private readonly cacheInterfaceRange: LRUCache<string, Promise<ParameterRangeResolved>>;
 
   public constructor(args: ParameterResolverArgs) {
     this.classLoader = args.classLoader;
-    this.commentLoader = args.commentLoader;
+    this.parameterLoader = args.parameterLoader;
     this.ignoreClasses = args.ignoreClasses;
     this.cacheInterfaceRange = new LRUCache(2_048);
   }
@@ -401,8 +398,7 @@ export class ParameterResolver {
 
     // If we find a type alias, just interpret the type directly
     if (classOrInterface.type === 'type') {
-      const parameterLoader = new ParameterLoader({ commentLoader: this.commentLoader });
-      const unresolvedFields = parameterLoader.getRangeFromTypeNode(
+      const unresolvedFields = this.parameterLoader.getRangeFromTypeNode(
         classOrInterface,
         classOrInterface.declaration.typeAnnotation,
         `type alias ${classOrInterface.localName} in ${classOrInterface.fileName}`,
@@ -413,11 +409,10 @@ export class ParameterResolver {
 
     // If we find an enum, just interpret the enum value, and return as union type
     if (classOrInterface.type === 'enum') {
-      const parameterLoader = new ParameterLoader({ commentLoader: this.commentLoader });
       const enumRangeTypes = await Promise.all(classOrInterface.declaration.members
         .map((enumMember, i) => {
           if (enumMember.initializer && enumMember.initializer.type === AST_NODE_TYPES.Literal) {
-            return this.resolveRange(parameterLoader.getRangeFromTypeNode(
+            return this.resolveRange(this.parameterLoader.getRangeFromTypeNode(
               classOrInterface,
               {
                 type: AST_NODE_TYPES.TSLiteralType,
@@ -533,8 +528,7 @@ export class ParameterResolver {
     genericTypeRemappings: Record<string, ParameterRangeUnresolved>,
     handlingInterfaces: Set<string>,
   ): Promise<ParameterData<ParameterRangeResolved>[]> {
-    const parameterLoader = new ParameterLoader({ commentLoader: this.commentLoader });
-    const unresolvedFields = parameterLoader.loadInterfaceFields(iface);
+    const unresolvedFields = this.parameterLoader.loadInterfaceFields(iface);
     return await this.resolveParameterData(unresolvedFields, owningClass, genericTypeRemappings, handlingInterfaces);
   }
 
@@ -551,14 +545,13 @@ export class ParameterResolver {
     genericTypeRemappings: Record<string, ParameterRangeUnresolved>,
     handlingInterfaces: Set<string>,
   ): Promise<ParameterData<ParameterRangeResolved>[]> {
-    const parameterLoader = new ParameterLoader({ commentLoader: this.commentLoader });
-    const unresolvedFields = parameterLoader.loadHashFields(owningClass, hash);
+    const unresolvedFields = this.parameterLoader.loadHashFields(owningClass, hash);
     return this.resolveParameterData(unresolvedFields, owningClass, genericTypeRemappings, handlingInterfaces);
   }
 }
 
 export interface ParameterResolverArgs {
   classLoader: ClassLoader;
-  commentLoader: CommentLoader;
+  parameterLoader: ParameterLoader;
   ignoreClasses: Record<string, boolean>;
 }