Generate wildcard parameter ranges

Author: rubensworks

lib/parse/ParameterLoader.ts

@@ -387,12 +387,13 @@ export class ParameterLoader {
         };
       case AST_NODE_TYPES.TSParenthesizedType:
         return this.getRangeFromTypeNode(classLoaded, typeNode.typeAnnotation, errorIdentifier);
-      case AST_NODE_TYPES.TSUnknownKeyword:
       case AST_NODE_TYPES.TSUndefinedKeyword:
+        return { type: 'undefined' };
+      case AST_NODE_TYPES.TSUnknownKeyword:
       case AST_NODE_TYPES.TSVoidKeyword:
       case AST_NODE_TYPES.TSNullKeyword:
       case AST_NODE_TYPES.TSAnyKeyword:
-        return { type: 'undefined' };
+        return { type: 'wildcard' };
       case AST_NODE_TYPES.TSTupleType:
         return {
           type: 'tuple',
@@ -508,6 +509,7 @@ export class ParameterLoader {
         // Replace these types
         return override;
       case 'undefined':
+      case 'wildcard':
       case 'override':
         // Override has no effect here
         return range;
@@ -731,6 +733,8 @@ export type ParameterRangeUnresolved = {
   value: TSTypeLiteral;
 } | {
   type: 'undefined';
+} | {
+  type: 'wildcard';
 } | {
   type: 'union';
   elements: ParameterRangeUnresolved[];
@@ -772,6 +776,8 @@ export type ParameterRangeResolved = {
   value: ParameterData<ParameterRangeResolved>[];
 } | {
   type: 'undefined';
+} | {
+  type: 'wildcard';
 } | {
   type: 'union';
   elements: ParameterRangeResolved[];

lib/parse/ParameterResolver.ts

@@ -211,7 +211,7 @@ export class ParameterResolver {
       case 'interface':
         if (this.isIgnored(range.qualifiedPath, range.value)) {
           return {
-            type: 'undefined',
+            type: 'wildcard',
           };
         }
 
@@ -243,6 +243,10 @@ export class ParameterResolver {
           value: await this
             .getNestedFieldsFromHash(range.value, owningClass, genericTypeRemappings, handlingInterfaces),
         };
+      case 'wildcard':
+        return {
+          type: 'wildcard',
+        };
       case 'undefined':
         return {
           type: 'undefined',
@@ -291,6 +295,8 @@ export class ParameterResolver {
     switch (range.type) {
       case 'undefined':
         return 'undefined';
+      case 'wildcard':
+        return 'wildcard';
       case 'interface':
       case 'genericTypeReference':
       case 'raw':

lib/serialize/ComponentConstructor.ts

@@ -731,12 +731,16 @@ export class ComponentConstructor {
       case 'nested':
         // TODO: Composition of nested fields is unsupported
         return {
-          '@type': 'ParameterRangeUndefined',
+          '@type': 'ParameterRangeWildcard',
         };
       case 'undefined':
         return {
           '@type': 'ParameterRangeUndefined',
         };
+      case 'wildcard':
+        return {
+          '@type': 'ParameterRangeWildcard',
+        };
       case 'union':
       case 'intersection':
       case 'tuple':

lib/serialize/ComponentDefinitions.ts

@@ -58,6 +58,8 @@ export type ParameterDefinitionRange = string | { '@id': string; parameters: Par
   parameterRangeValue: ParameterDefinitionRange;
 } | {
   '@type': 'ParameterRangeUndefined';
+} | {
+  '@type': 'ParameterRangeWildcard';
 } | {
   '@type': 'ParameterRangeCollectEntries';
   'parameterRangeCollectEntriesParameters': ParameterDefinition[];

test/parse/ParameterLoader.test.ts

@@ -1779,29 +1779,29 @@ export interface A{
         });
     });
 
-    it('should get the range of an unknown type as undefined', async() => {
+    it('should get the range of an unknown type as wildcard', async() => {
       expect(await getFieldRange('fieldA: unknown', {}))
-        .toEqual({ type: 'undefined' });
+        .toEqual({ type: 'wildcard' });
     });
 
     it('should get the range of an undefined type as undefined', async() => {
       expect(await getFieldRange('fieldA: undefined', {}))
         .toEqual({ type: 'undefined' });
     });
 
-    it('should get the range of an any type as undefined', async() => {
+    it('should get the range of an any type as wildcard', async() => {
       expect(await getFieldRange('fieldA: any', {}))
-        .toEqual({ type: 'undefined' });
+        .toEqual({ type: 'wildcard' });
     });
 
-    it('should get the range of an void type as undefined', async() => {
+    it('should get the range of an void type as wildcard', async() => {
       expect(await getFieldRange('fieldA: void', {}))
-        .toEqual({ type: 'undefined' });
+        .toEqual({ type: 'wildcard' });
     });
 
-    it('should get the range of a null type as undefined', async() => {
+    it('should get the range of a null type as wildcard', async() => {
       expect(await getFieldRange('fieldA: null', {}))
-        .toEqual({ type: 'undefined' });
+        .toEqual({ type: 'wildcard' });
     });
 
     it('should get the range of a union type of two raw types', async() => {

test/parse/ParameterResolver.test.ts

@@ -542,6 +542,11 @@ describe('ParameterResolver', () => {
         .toEqual('undefined');
     });
 
+    it('should hash wildcard', () => {
+      expect(loader.hashParameterRangeUnresolved({ type: 'wildcard' }))
+        .toEqual('wildcard');
+    });
+
     it('should hash interface', () => {
       expect(loader.hashParameterRangeUnresolved(<any> { type: 'interface', value: 'IFACE' }))
         .toEqual('interface:IFACE');
@@ -724,7 +729,7 @@ describe('ParameterResolver', () => {
         genericTypeParameterInstantiations: [],
         origin: classReference,
       }, classReference, {}, true, new Set())).toMatchObject({
-        type: 'undefined',
+        type: 'wildcard',
       });
     });
 
@@ -741,7 +746,7 @@ describe('ParameterResolver', () => {
         genericTypeParameterInstantiations: [],
         origin: classReference,
       }, classReference, {}, true, new Set())).toMatchObject({
-        type: 'undefined',
+        type: 'wildcard',
       });
     });
 
@@ -805,6 +810,14 @@ export interface MyInterface extends IgnoredInterface{};
       });
     });
 
+    it('should handle a wildcard range', async() => {
+      expect(await loader.resolveRange({
+        type: 'wildcard',
+      }, classReference, {}, true, new Set())).toMatchObject({
+        type: 'wildcard',
+      });
+    });
+
     it('should handle an undefined range', async() => {
       expect(await loader.resolveRange({
         type: 'undefined',

test/serialize/ComponentConstructor.test.ts

@@ -2468,15 +2468,15 @@ describe('ComponentConstructor', () => {
       });
     });
 
-    it('should construct on a nested parameter range as undefined', async() => {
+    it('should construct on a nested parameter range as wildcard', async() => {
       const rangeValue: ParameterData<any>[] = [];
       expect(await ctor.constructParameterRange(
         { type: 'nested', value: rangeValue },
         context,
         externalContextsCallback,
         'mp:components/a/b/file-param.jsonld#MyClass_field',
       )).toEqual({
-        '@type': 'ParameterRangeUndefined',
+        '@type': 'ParameterRangeWildcard',
       });
     });
 
@@ -2491,6 +2491,17 @@ describe('ComponentConstructor', () => {
       });
     });
 
+    it('should construct a wildcard parameter range', async() => {
+      expect(await ctor.constructParameterRange(
+        { type: 'wildcard' },
+        context,
+        externalContextsCallback,
+        'mp:components/a/b/file-param.jsonld#MyClass_field',
+      )).toEqual({
+        '@type': 'ParameterRangeWildcard',
+      });
+    });
+
     it('should construct a union parameter range', async() => {
       const rangeValueClass: ClassReferenceLoaded = <any> {
         packageName: 'my-package',