Add type predicate converter

Also add a few more tests + rebuild specs again.

Author: Gerrit0

scripts/copy_test_files.js

@@ -13,7 +13,8 @@ const copy = [
 const copies = copy.map(dir => {
     const source = join(__dirname, '../src', dir);
     const target = join(__dirname, '../dist', dir);
-    return fs.mkdirp(target)
+    return fs.remove(target)
+        .then(() => fs.mkdirp(target))
         .then(() => fs.copy(source, target));
 })
 

src/lib/converter/converter.ts

@@ -218,12 +218,12 @@ export class Converter extends ChildableComponent<Application, ConverterComponen
     private addTypeConverter(converter: ConverterTypeComponent) {
         if ('supportsNode' in converter && 'convertNode' in converter) {
             this.typeNodeConverters.push(<TypeNodeConverter<any, any>> converter);
-            this.typeNodeConverters.sort((a, b) => (b.priority || 0) - (a.priority || 0));
+            this.typeNodeConverters.sort((a, b) => b.priority - a.priority);
         }
 
         if ('supportsType' in converter && 'convertType' in converter) {
             this.typeTypeConverters.push(<TypeTypeConverter<any>> converter);
-            this.typeTypeConverters.sort((a, b) => (b.priority || 0) - (a.priority || 0));
+            this.typeTypeConverters.sort((a, b) => b.priority - a.priority);
         }
     }
 

src/lib/converter/types/index.ts

@@ -4,6 +4,7 @@ export { BindingArrayConverter } from './binding-array';
 export { BindingObjectConverter } from './binding-object';
 export { EnumConverter } from './enum';
 export { IntrinsicConverter } from './intrinsic';
+export { PredicateConverter } from './predicate';
 export { StringLiteralConverter } from './string-literal';
 export { ReferenceConverter } from './reference';
 export { ThisConverter } from './this';

src/lib/converter/types/predicate.ts

@@ -0,0 +1,30 @@
+import * as ts from 'typescript';
+
+import { PredicateType } from '../../models/types/index';
+import { Component, ConverterTypeComponent } from '../components';
+import { Context } from '../context';
+
+@Component({ name: 'type:predicate' })
+export class PredicateConverter extends ConverterTypeComponent {
+    /**
+     * This must run before the base `Type` converter.
+     */
+    priority = 50;
+
+    /**
+     * Test whether this converter can handle the given TypeScript node.
+     */
+    supportsNode(_context: Context, node: ts.Node): boolean {
+        return ts.isTypePredicateNode(node);
+    }
+
+    /**
+     * Convert the given predicate type node to its type reflection.
+     */
+    convertNode(context: Context, node: ts.TypePredicateNode): PredicateType {
+        const name = ts.isThisTypeNode(node.parameterName) ? 'this' : node.parameterName.getText();
+        const asserts = !!node.assertsModifier;
+        const targetType = this.owner.convertType(context, node.type);
+        return new PredicateType(name, asserts, targetType);
+    }
+}

src/lib/models/types/index.ts

@@ -1,7 +1,8 @@
 export { Type } from './abstract';
 export { ArrayType } from './array';
-export { IntrinsicType } from './intrinsic';
 export { IntersectionType } from './intersection';
+export { IntrinsicType } from './intrinsic';
+export { PredicateType } from './predicate';
 export { ReferenceType } from './reference';
 export { ReflectionType } from './reflection';
 export { StringLiteralType } from './string-literal';

src/lib/models/types/predicate.ts

@@ -0,0 +1,101 @@
+import { Type } from './abstract';
+
+/**
+ * Represents a type predicate.
+ *
+ * ```ts
+ * function isString(anything: any): anything is string {}
+ * function assert(condition: boolean): asserts condition {}
+ * ```
+ */
+export class PredicateType extends Type {
+    /**
+     * The type that the identifier is tested to be.
+     * May be undefined if the type is of the form `asserts val`.
+     * Will be defined if the type is of the form `asserts val is string` or `val is string`.
+     */
+    targetType?: Type;
+
+    /**
+     * The identifier name which is tested by the predicate.
+     */
+    name: string;
+
+    /**
+     * True if the type is of the form `asserts val is string`, false if
+     * the type is of the form `val is string`
+     */
+    asserts: boolean;
+
+    /**
+     * The type name identifier.
+     */
+    readonly type = 'predicate';
+
+    /**
+     * Create a new PredicateType instance.
+     */
+    constructor(name: string, asserts: boolean, targetType?: Type) {
+        super();
+        this.name = name;
+        this.asserts = asserts;
+        this.targetType = targetType;
+    }
+
+    /**
+     * Clone this type.
+     *
+     * @return A clone of this type.
+     */
+    clone(): Type {
+        return new PredicateType(this.name, this.asserts, this.targetType);
+    }
+
+    /**
+     * Test whether this type equals the given type.
+     *
+     * @param type  The type that should be checked for equality.
+     * @returns TRUE if the given type equals this type, FALSE otherwise.
+     */
+    equals(type: Type): boolean {
+        if (!(type instanceof PredicateType)) {
+            return false;
+        }
+
+        if (!this.targetType && type.targetType) {
+            return false;
+        }
+        if (this.targetType && !type.targetType) {
+            return false;
+        }
+
+        return this.name === type.name
+            && this.asserts === type.asserts
+            && (this.targetType?.equals(type.targetType!) ?? true);
+    }
+
+    /**
+     * Return a raw object representation of this type.
+     * @deprecated Use serializers instead
+     */
+    toObject(): any {
+        return {
+            ...super.toObject(),
+            name: this.name,
+            asserts: this.asserts,
+            targetType: this.targetType
+        };
+    }
+
+    /**
+     * Return a string representation of this type.
+     */
+    toString() {
+        const out = this.asserts ? ['asserts', this.name] : [this.name];
+        if (this.targetType) {
+            out.push('is', this.targetType.toString());
+        }
+
+        return out.join(' ');
+    }
+}

src/lib/serialization/serializers/types/index.ts

@@ -2,6 +2,7 @@ export * from './abstract';
 export * from './array';
 export * from './intersection-union';
 export * from './intrinsic';
+export * from './predicate';
 export * from './reference';
 export * from './reflection';
 export * from './string-literal';

src/lib/serialization/serializers/types/predicate.ts

@@ -0,0 +1,19 @@
+import { Component } from '../../../utils/component';
+import { PredicateType } from '../../../models';
+import { TypeSerializerComponent } from '../../components';
+
+@Component({ name: 'serializer:predicate-type' })
+export class PredicateTypeSerializer extends TypeSerializerComponent<PredicateType> {
+    supports(t: unknown) {
+        return t instanceof PredicateType;
+    }
+
+    toObject(type: PredicateType, obj?: any): any {
+        return {
+            ...obj,
+            name: type.name,
+            asserts: type.asserts,
+            targetType: type.targetType
+        };
+    }
+}

src/test/converter/function/function.ts

@@ -1,14 +1,12 @@
 /**
  * This is an internal function.
  */
-function internalFunction():void { }
-
+function internalFunction(): void { }
 
 /**
  * This is a simple exported function.
  */
-export function exportedFunction():void { }
-
+export function exportedFunction(): void { }
 
 /**
  * This is a function with multiple arguments and a return value.
@@ -27,30 +25,27 @@ export function exportedFunction():void { }
  *
  * @returns This is the return value of the function.
  */
-export function functionWithParameters(paramZ:string, paramG:any, paramA:Object):number {
+export function functionWithParameters(paramZ: string, paramG: any, paramA: Object): number {
     return 0;
 }
 
-
 /**
  * This is a function that is assigned to a variable.
  *
  * @param someParam  This is some numeric parameter.
  * @return This is the return value of the function.
  */
-export const variableFunction = function(someParam:number):number {
+export const variableFunction = function(someParam: number): number {
     return 0;
 };
 
-
 /**
  * This is a function with a parameter that is optional.
  *
  * @param requiredParam  A normal parameter.
  * @param optionalParam  An optional parameter.
  */
-export function functionWithOptionalValue(requiredParam:string, optionalParam?:string) { }
-
+export function functionWithOptionalValue(requiredParam: string, optionalParam?: string) { }
 
 /**
  * This is a function with a parameter that has a default value.
@@ -63,51 +58,49 @@ export function functionWithOptionalValue(requiredParam:string, optionalParam?:s
  * @return This is the return value of the function.
  */
 export function functionWithDefaults(
-    valueA:string = 'defaultValue',
-    valueB:number = 100,
-    valueC:number = Number.NaN,
-    valueD:boolean = true,
-    valueE:boolean = null
-):string {
+    valueA: string = 'defaultValue',
+    valueB: number = 100,
+    valueC: number = Number.NaN,
+    valueD: boolean = true,
+    valueE: boolean = null
+): string {
     return valueA;
 }
 
-
 /**
  * This is a function with rest parameter.
  *
  * @param rest  The rest parameter.
  * @return This is the return value of the function.
  */
-function functionWithRest(...rest:string[]):string {
+function functionWithRest(...rest: string[]): string {
     return rest.join(', ');
 }
 
-
 /**
  * This is the first signature of a function with multiple signatures.
  *
  * @param value  The name value.
  */
-export function multipleSignatures(value:string):string;
+export function multipleSignatures(value: string): string;
 
 /**
  * This is the second signature of a function with multiple signatures.
  *
  * @param value       An object containing the name value.
  * @param value.name  A value of the object.
  */
-export function multipleSignatures(value:{name:string}):string;
+export function multipleSignatures(value: {name: string}): string;
 
 /**
  * This is the actual implementation, this comment will not be visible
  * in the generated documentation.
  *
  * @return This is the return value of the function.
  */
-export function multipleSignatures():string {
+export function multipleSignatures(): string {
     if (arguments.length > 0) {
-        if (typeof arguments[0] == 'object') {
+        if (typeof arguments[0] === 'object') {
             return arguments[0].name;
         } else {
             return arguments[0];
@@ -117,33 +110,54 @@ export function multipleSignatures():string {
     return '';
 }
 
-
 /**
  * This is a function that is extended by a module.
  *
  * @param arg An argument.
  */
-export function moduleFunction(arg:string):string { return ''; }
-
+export function moduleFunction(arg: string): string { return ''; }
 
 /**
  * This is an assertion function.
  *
  * @param condition The condition that is asserted to be true when this function returns.
  */
-export function assertionFunction(condition:boolean):asserts condition { }
+export function assertionFunction(condition: boolean): asserts condition { }
+
+/**
+ * Assertion function with a type.
+ * @param anything
+ */
+export function checkerFunction(anything: any): anything is string {
+    return typeof anything === 'string';
+}
 
+/**
+ * Asserts that an argument is not null.
+ * @param arg
+ */
+export function assertIsNonNull<T>(arg: T | null | undefined): asserts arg is T {
+    if (arg == null) {
+        throw new Error('Was nullable');
+    }
+}
+
+/**
+ * Checks that an argument is not null.
+ * @param arg
+ */
+export function isNonNull<T>(arg: T | null | undefined): arg is T {
+    return arg != null;
+}
 
 /**
  * This is the module extending the function moduleFunction().
  */
-export module moduleFunction
-{
+export module moduleFunction {
     /**
      * This variable is appended to a function.
      */
-    let functionVariable:string;
-
+    let functionVariable: string;
 
     /**
      * This function is appended to another function.