jsii-pacmak 1.65.0 → 1.67.0

package/lib/targets/go/runtime/class-constructor.js

@@ -8,9 +8,12 @@ class ClassConstructor {
     constructor(parent) {
         this.parent = parent;
     }
-    emit(code) {
+    emit({ code, runtimeTypeChecking }) {
         (0, util_1.emitInitialization)(code);
         code.line();
+        if (runtimeTypeChecking) {
+            this.parent.validator?.emitCall(code);
+        }
         const resultVar = (0, util_1.slugify)(this.parent.parent.proxyName[0], this.parent.parameters.map((p) => p.name));
         const args = (0, emit_arguments_1.emitArguments)(code, this.parent.parameters, resultVar);
         code.line(`${resultVar} := ${this.parent.parent.proxyName}{}`);

package/lib/targets/go/runtime/method-call.d.ts

@@ -1,11 +1,11 @@
-import { CodeMaker } from 'codemaker';
+import { EmitContext } from '../emit-context';
 import { GoMethod } from '../types';
 import { FunctionCall } from './function-call';
 export declare class MethodCall extends FunctionCall {
     readonly parent: GoMethod;
     private _returnVarName;
     constructor(parent: GoMethod);
-    emit(code: CodeMaker): void;
+    emit(context: EmitContext): void;
     private emitDynamic;
     private emitStatic;
     private get returnVarName();

package/lib/targets/go/runtime/method-call.js

@@ -12,15 +12,18 @@ class MethodCall extends function_call_1.FunctionCall {
         this.parent = parent;
         this._returnVarName = '';
     }
-    emit(code) {
+    emit(context) {
         if (this.inStatic) {
-            this.emitStatic(code);
+            this.emitStatic(context);
         }
         else {
-            this.emitDynamic(code);
+            this.emitDynamic(context);
         }
     }
-    emitDynamic(code) {
+    emitDynamic({ code, runtimeTypeChecking }) {
+        if (runtimeTypeChecking) {
+            this.parent.validator?.emitCall(code);
+        }
         const args = (0, emit_arguments_1.emitArguments)(code, this.parent.parameters, this.returnVarName);
         if (this.returnsVal) {
             code.line(`var ${this.returnVarName} ${this.returnType}`);
@@ -42,9 +45,12 @@ class MethodCall extends function_call_1.FunctionCall {
             code.line(`return ${this.returnVarName}`);
         }
     }
-    emitStatic(code) {
+    emitStatic({ code, runtimeTypeChecking }) {
         (0, util_1.emitInitialization)(code);
         code.line();
+        if (runtimeTypeChecking) {
+            this.parent.validator?.emitCall(code);
+        }
         const args = (0, emit_arguments_1.emitArguments)(code, this.parent.parameters, this.returnVarName);
         if (this.returnsVal) {
             code.line(`var ${this.returnVarName} ${this.returnType}`);

package/lib/targets/go/runtime/property-access.d.ts

@@ -1,4 +1,5 @@
 import { CodeMaker } from 'codemaker';
+import { EmitContext } from '../emit-context';
 import { GoProperty } from '../types';
 import { FunctionCall } from './function-call';
 export declare class GetProperty extends FunctionCall {
@@ -9,7 +10,7 @@ export declare class GetProperty extends FunctionCall {
 export declare class SetProperty {
     readonly parent: GoProperty;
     constructor(parent: GoProperty);
-    emit(code: CodeMaker): void;
+    emit({ code, runtimeTypeChecking }: EmitContext): void;
 }
 export declare class StaticGetProperty extends FunctionCall {
     readonly parent: GoProperty;
@@ -19,6 +20,6 @@ export declare class StaticGetProperty extends FunctionCall {
 export declare class StaticSetProperty {
     readonly parent: GoProperty;
     constructor(parent: GoProperty);
-    emit(code: CodeMaker): void;
+    emit({ code, runtimeTypeChecking }: EmitContext): void;
 }
 //# sourceMappingURL=property-access.d.ts.map

package/lib/targets/go/runtime/property-access.js

@@ -25,7 +25,9 @@ class SetProperty {
     constructor(parent) {
         this.parent = parent;
     }
-    emit(code) {
+    emit({ code, runtimeTypeChecking }) {
+        if (runtimeTypeChecking)
+            this.parent.validator?.emitCall(code);
         code.open(`${constants_1.JSII_SET_FUNC}(`);
         code.line(`${this.parent.instanceArg},`);
         code.line(`"${this.parent.property.name}",`);
@@ -56,8 +58,11 @@ class StaticSetProperty {
     constructor(parent) {
         this.parent = parent;
     }
-    emit(code) {
+    emit({ code, runtimeTypeChecking }) {
         (0, util_1.emitInitialization)(code);
+        if (runtimeTypeChecking) {
+            this.parent.validator?.emitCall(code);
+        }
         code.open(`${constants_1.JSII_SSET_FUNC}(`);
         code.line(`"${this.parent.parent.fqn}",`);
         code.line(`"${this.parent.property.name}",`);

package/lib/targets/go/runtime/runtime-type-checking.d.ts

@@ -0,0 +1,29 @@
+import { CodeMaker } from 'codemaker';
+import { SpecialDependencies } from '../dependencies';
+import { Package } from '../package';
+import { GoClassConstructor, GoMethod, GoProperty, Struct } from '../types';
+export declare class ParameterValidator {
+    static forConstructor(ctor: GoClassConstructor): ParameterValidator | undefined;
+    static forMethod(method: GoMethod): ParameterValidator | undefined;
+    static forProperty(property: GoProperty): ParameterValidator | undefined;
+    private static fromParts;
+    private readonly receiver?;
+    private readonly name;
+    private readonly parameters;
+    private readonly validations;
+    private constructor();
+    get dependencies(): readonly Package[];
+    get specialDependencies(): SpecialDependencies;
+    emitCall(code: CodeMaker): void;
+    emitImplementation(code: CodeMaker, scope: Package, noOp?: boolean): void;
+}
+export declare class StructValidator {
+    private readonly receiver;
+    private readonly validations;
+    static for(struct: Struct): StructValidator | undefined;
+    private constructor();
+    get dependencies(): Package[];
+    get specialDependencies(): SpecialDependencies;
+    emitImplementation(code: CodeMaker, scope: Package, noOp?: boolean): void;
+}
+//# sourceMappingURL=runtime-type-checking.d.ts.map

package/lib/targets/go/runtime/runtime-type-checking.js

@@ -0,0 +1,408 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StructValidator = exports.ParameterValidator = void 0;
+const crypto_1 = require("crypto");
+const jsii_reflect_1 = require("jsii-reflect");
+const dependencies_1 = require("../dependencies");
+const types_1 = require("../types");
+const constants_1 = require("./constants");
+class ParameterValidator {
+    constructor(baseName, validations, receiver) {
+        this.receiver = receiver;
+        this.name = `validate${baseName}Parameters`;
+        this.validations = validations;
+        this.parameters = Array.from(validations.keys());
+    }
+    static forConstructor(ctor) {
+        return ParameterValidator.fromParts(`New${ctor.parent.name}`, ctor.parameters);
+    }
+    static forMethod(method) {
+        return ParameterValidator.fromParts(method.name, method.parameters, method.static
+            ? undefined
+            : {
+                name: method.instanceArg,
+                type: `*${method.parent.proxyName}`,
+            });
+    }
+    static forProperty(property) {
+        if (property.immutable) {
+            return undefined;
+        }
+        return ParameterValidator.fromParts(property.setterName, [
+            syntheticParameter(property.parent, 'val', property.reference.reference.spec, property.property.optional),
+        ], property.static
+            ? undefined
+            : {
+                name: property.instanceArg,
+                type: `*${property.parent.proxyName}`,
+            });
+    }
+    static fromParts(name, parameters, receiver) {
+        if (parameters.length === 0) {
+            return undefined;
+        }
+        const parameterValidations = new Map();
+        for (const param of parameters) {
+            const expr = param.name;
+            const descr = `parameter ${param.name}`;
+            const validations = new Array();
+            if (!param.isOptional && !param.isVariadic) {
+                validations.push(Validation.nullCheck(expr, descr, param.reference));
+            }
+            const validation = Validation.forTypeMap(expr, descr, param.isVariadic
+                ? { type: 'array', value: param.reference }
+                : param.reference.typeMap);
+            if (validation) {
+                validations.push(validation);
+            }
+            if (validations.length !== 0) {
+                parameterValidations.set(param, validations);
+            }
+        }
+        if (parameterValidations.size === 0) {
+            return undefined;
+        }
+        return new ParameterValidator(name, parameterValidations, receiver);
+    }
+    get dependencies() {
+        return [
+            ...this.parameters.flatMap((p) => p.reference.withTransparentUnions.dependencies),
+            ...Array.from(this.validations.values()).flatMap((vs) => vs.flatMap((v) => v.dependencies)),
+        ];
+    }
+    get specialDependencies() {
+        return (0, dependencies_1.reduceSpecialDependencies)(...this.parameters.map((p) => p.reference.specialDependencies), ...Array.from(this.validations.values()).flatMap((vs) => vs.flatMap((v) => v.specialDependencies)));
+    }
+    emitCall(code) {
+        const recv = this.receiver?.name ? `${this.receiver.name}.` : '';
+        const params = this.parameters
+            .map((p) => (p.isVariadic ? `&${p.name}` : p.name))
+            .join(', ');
+        code.openBlock(`if err := ${recv}${this.name}(${params}); err != nil`);
+        code.line(`panic(err)`);
+        code.closeBlock();
+    }
+    emitImplementation(code, scope, noOp = false) {
+        code.openBlock(`func ${this.receiver ? `(${this.receiver.name} ${this.receiver.type}) ` : ''}${this.name}(${this.parameters
+            .map((p) => p.isVariadic
+            ? `${p.name} *[]${p.reference.scopedReference(scope)}`
+            : p.toString())
+            .join(', ')}) error`);
+        if (noOp) {
+            code.line('return nil');
+        }
+        else {
+            for (const [_parameter, validations] of this.validations) {
+                for (const validation of validations) {
+                    validation.emit(code, scope);
+                }
+                code.line();
+            }
+            code.line('return nil');
+        }
+        code.closeBlock();
+        code.line();
+    }
+}
+exports.ParameterValidator = ParameterValidator;
+class StructValidator {
+    constructor(receiver, validations) {
+        this.receiver = receiver;
+        this.validations = validations;
+    }
+    static for(struct) {
+        const receiver = {
+            name: struct.name.slice(0, 1).toLowerCase(),
+            type: `*${struct.name}`,
+        };
+        const fieldValidations = new Map();
+        for (const prop of struct.properties) {
+            const expr = `${receiver.name}.${prop.name}`;
+            const descr = `@{desc()}.${prop.name}`;
+            const validations = new Array();
+            if (!prop.property.optional) {
+                validations.push(Validation.nullCheck(expr, descr, prop.reference));
+            }
+            const validation = Validation.forTypeMap(expr, descr, prop.reference.typeMap);
+            if (validation) {
+                validations.push(validation);
+            }
+            if (validations.length > 0) {
+                fieldValidations.set(prop, validations);
+            }
+        }
+        if (fieldValidations.size === 0) {
+            return undefined;
+        }
+        return new StructValidator(receiver, fieldValidations);
+    }
+    get dependencies() {
+        return Array.from(this.validations.values()).flatMap((vs) => vs.flatMap((v) => v.dependencies));
+    }
+    get specialDependencies() {
+        return (0, dependencies_1.reduceSpecialDependencies)({
+            fmt: true,
+            init: false,
+            internal: false,
+            runtime: false,
+            time: false,
+        }, ...Array.from(this.validations.values()).flatMap((vs) => vs.flatMap((v) => v.specialDependencies)));
+    }
+    emitImplementation(code, scope, noOp = false) {
+        code.openBlock(`func (${this.receiver.name} ${this.receiver.type}) validate(desc func() string) error`);
+        if (noOp) {
+            code.line('return nil');
+        }
+        else {
+            for (const [_prop, validations] of this.validations) {
+                for (const validation of validations) {
+                    validation.emit(code, scope);
+                }
+                code.line();
+            }
+            code.line('return nil');
+        }
+        code.closeBlock();
+        code.line();
+    }
+}
+exports.StructValidator = StructValidator;
+class Validation {
+    static forTypeMap(expression, description, typeMap) {
+        switch (typeMap.type) {
+            case 'union':
+                return Validation.unionCheck(expression, description, typeMap.value);
+            case 'interface':
+                return Validation.interfaceCheck(expression, description, typeMap.value);
+            case 'array':
+            case 'map':
+                return Validation.collectionCheck(expression, description, typeMap.value);
+            case 'primitive':
+            case 'void':
+                return undefined;
+        }
+    }
+    static collectionCheck(expression, description, elementType) {
+        // We need to come up with a unique-enough ID here... so we use a hash.
+        const idx = `idx_${(0, crypto_1.createHash)('sha256')
+            .update(expression)
+            .digest('hex')
+            .slice(0, 6)}`;
+        // This is actually unused
+        const elementValidator = Validation.forTypeMap('v', `${description}[@{${idx}:#v}]`, elementType.typeMap);
+        if (elementValidator == null) {
+            return undefined;
+        }
+        class CollectionCheck extends Validation {
+            get specialDependencies() {
+                return elementValidator.specialDependencies;
+            }
+            get dependencies() {
+                return elementValidator.dependencies;
+            }
+            emit(code, scope) {
+                // We need to de-reference the pointer here (range does not operate on pointers)
+                code.openBlock(`for ${idx}, v := range *${expression}`);
+                elementValidator.emit(code, scope);
+                code.closeBlock();
+            }
+        }
+        return new CollectionCheck();
+    }
+    static interfaceCheck(expression, description, iface) {
+        if (!iface.datatype) {
+            return undefined;
+        }
+        class InterfaceCheck extends Validation {
+            get dependencies() {
+                return [];
+            }
+            get specialDependencies() {
+                return {
+                    fmt: INTERPOLATION.test(description),
+                    init: false,
+                    internal: false,
+                    runtime: !!iface.datatype,
+                    time: false,
+                };
+            }
+            emit(code, _scope) {
+                code.openBlock(`if err := ${constants_1.JSII_RT_ALIAS}.ValidateStruct(${expression}, func() string { return ${interpolated(description)} }); err != nil`);
+                code.line(`return err`);
+                code.closeBlock();
+            }
+        }
+        return new InterfaceCheck();
+    }
+    static nullCheck(expression, description, typeRef) {
+        class NullCheck extends Validation {
+            get dependencies() {
+                return [];
+            }
+            get specialDependencies() {
+                return {
+                    fmt: true,
+                    init: false,
+                    internal: false,
+                    runtime: false,
+                    time: false,
+                };
+            }
+            emit(code) {
+                const nullValue = typeRef.type?.type?.isEnumType()
+                    ? `""` // Enums are represented as string-valued constants
+                    : 'nil';
+                code.openBlock(`if ${expression} == ${nullValue}`);
+                code.line(returnErrorf(`${description} is required, but nil was provided`));
+                code.closeBlock();
+            }
+        }
+        return new NullCheck();
+    }
+    static unionCheck(expression, description, types) {
+        const hasInterface = types.some((t) => t.typeMap.type === 'interface');
+        class UnionCheck extends Validation {
+            get dependencies() {
+                return types.flatMap((t) => t.dependencies);
+            }
+            get specialDependencies() {
+                return (0, dependencies_1.reduceSpecialDependencies)({
+                    fmt: true,
+                    init: false,
+                    internal: false,
+                    runtime: hasInterface,
+                    time: false,
+                }, ...types.flatMap((t) => {
+                    const validator = Validation.forTypeMap(expression, description, t.typeMap);
+                    if (validator == null)
+                        return [];
+                    return [validator.specialDependencies];
+                }));
+            }
+            emit(code, scope) {
+                const validTypes = new Array();
+                code.line(`switch ${expression}.(type) {`);
+                for (const type of types) {
+                    const typeName = type.scopedReference(scope);
+                    validTypes.push(typeName);
+                    // Maps a type to the conversion instructions to the ${typeName} type
+                    const acceptableTypes = new Map();
+                    acceptableTypes.set(typeName, undefined);
+                    switch (typeName) {
+                        case '*float64':
+                            // For numbers, we accept everything that implictly converts to float64 (pointer & not)
+                            acceptableTypes.set('float64', (code, inVar, outVar) => code.line(`${outVar} := &${inVar}`));
+                            const ALTERNATE_TYPES = [
+                                'int',
+                                'uint',
+                                'int8',
+                                'int16',
+                                'int32',
+                                'int64',
+                                'uint8',
+                                'uint16',
+                                'uint32',
+                                'uint64',
+                            ];
+                            for (const otherType of ALTERNATE_TYPES) {
+                                const varName = (0, crypto_1.createHash)('sha256')
+                                    .update(expression)
+                                    .digest('hex')
+                                    .slice(6);
+                                acceptableTypes.set(`*${otherType}`, (code) => {
+                                    code.openBlock(`${varName} := func (v *${otherType}) *float64`);
+                                    code.openBlock('if v == nil {');
+                                    code.line('return nil');
+                                    code.closeBlock();
+                                    code.line(`val := float64(*v)`);
+                                    code.line(`return &val`);
+                                    code.closeBlock('()');
+                                });
+                                acceptableTypes.set(otherType, (code) => {
+                                    code.openBlock(`${varName} := func (v ${otherType}) *float64`);
+                                    code.line(`val := float64(v)`);
+                                    code.line(`return &val`);
+                                    code.closeBlock('()');
+                                });
+                            }
+                            break;
+                        default:
+                            // Accept pointer and non-pointer versions of everything
+                            if (typeName.startsWith('*')) {
+                                const nonPointerType = typeName.slice(1);
+                                acceptableTypes.set(nonPointerType, (code, inVar, outVar) => code.line(`${outVar} := &${inVar}`));
+                            }
+                    }
+                    for (const [acceptableType, conversion] of acceptableTypes) {
+                        code.indent(`case ${acceptableType}:`);
+                        const outVar = /^[a-z0-9_]+$/.test(expression) ? expression : `v`;
+                        const validation = Validation.forTypeMap(outVar, description, type.typeMap);
+                        if (validation) {
+                            const inVar = conversion ? `${outVar}_` : outVar;
+                            code.line(`${inVar} := ${expression}.(${acceptableType})`);
+                            if (conversion) {
+                                conversion(code, inVar, outVar);
+                            }
+                            validation.emit(code, scope);
+                        }
+                        else {
+                            code.line('// ok');
+                        }
+                        code.unindent(false);
+                    }
+                }
+                code.indent('default:');
+                if (hasInterface)
+                    code.openBlock(`if !${constants_1.JSII_RT_ALIAS}.IsAnonymousProxy(${expression})`);
+                code.line(returnErrorf(`${description} must be one of the allowed types: ${validTypes.join(', ')}; received @{${expression}:#v} (a @{${expression}:T})`));
+                if (hasInterface)
+                    code.closeBlock();
+                code.unindent('}');
+            }
+        }
+        return new UnionCheck();
+    }
+    constructor() { }
+}
+const INTERPOLATION = /@\{([^}:]+)(?::([^}]+))?\}/;
+function interpolated(message) {
+    // Need to escape literal percent signes, as a precaution.
+    let escaped = message.replace(/%/gm, '%%');
+    const args = new Array();
+    let match;
+    while ((match = INTERPOLATION.exec(escaped))) {
+        const before = escaped.slice(0, match.index);
+        const expr = match[1];
+        const mod = match[2];
+        const after = escaped.slice(match.index + match[1].length + 3 + (mod ? mod.length + 1 : 0));
+        escaped = `${before}%${mod || 'v'}${after}`;
+        args.push(expr);
+    }
+    if (args.length === 0) {
+        return JSON.stringify(message);
+    }
+    return `fmt.Sprintf(${JSON.stringify(escaped)}, ${args.join(', ')})`;
+}
+function returnErrorf(message) {
+    const args = new Array();
+    // Need to escape literal percent signes, as a precaution.
+    message = message.replace(/%/gm, '%%');
+    let match;
+    while ((match = INTERPOLATION.exec(message))) {
+        const before = message.slice(0, match.index);
+        const expr = match[1];
+        const mod = match[2];
+        const after = message.slice(match.index + match[1].length + 3 + (mod ? mod.length + 1 : 0));
+        message = `${before}%${mod || 'v'}${after}`;
+        args.push(expr);
+    }
+    return `return fmt.Errorf(${[JSON.stringify(message), ...args].join(', ')})`;
+}
+function syntheticParameter(parent, name, type, optional) {
+    return new types_1.GoParameter(parent, new jsii_reflect_1.Parameter(parent.type.system, parent.type, new jsii_reflect_1.Method(parent.type.system, parent.type.assembly, parent.type, parent.type, { name: '__synthetic__' }), {
+        name,
+        optional,
+        type,
+    }));
+}
+//# sourceMappingURL=runtime-type-checking.js.map

package/lib/targets/go/types/class.d.ts

@@ -1,13 +1,14 @@
-import { CodeMaker } from 'codemaker';
 import { Method, ClassType, Initializer } from 'jsii-reflect';
 import { SpecialDependencies } from '../dependencies';
 import { EmitContext } from '../emit-context';
 import { Package } from '../package';
 import { MethodCall } from '../runtime';
+import { ParameterValidator } from '../runtime/runtime-type-checking';
 import { GoType } from './go-type';
 import { GoInterface } from './interface';
 import { GoMethod, GoProperty, GoTypeMember } from './type-member';
 export declare class GoClass extends GoType<ClassType> {
+    #private;
     readonly methods: ClassMethod[];
     readonly staticMethods: StaticMethod[];
     readonly properties: GoProperty[];
@@ -16,26 +17,28 @@ export declare class GoClass extends GoType<ClassType> {
     private _implements?;
     private readonly initializer?;
     constructor(pkg: Package, type: ClassType);
+    get parameterValidators(): readonly ParameterValidator[];
     get extends(): GoClass | undefined;
     get implements(): readonly GoInterface[];
     get baseTypes(): ReadonlyArray<GoClass | GoInterface>;
     emit(context: EmitContext): void;
-    emitRegistration(code: CodeMaker): void;
+    emitRegistration({ code }: EmitContext): void;
     get members(): GoTypeMember[];
     get specialDependencies(): SpecialDependencies;
     protected emitInterface(context: EmitContext): void;
     private emitGetters;
     private emitStruct;
-    private emitStaticProperty;
     private emitSetters;
     get dependencies(): Package[];
     get interfaces(): string[];
 }
 export declare class GoClassConstructor extends GoMethod {
+    #private;
     readonly parent: GoClass;
     private readonly type;
     private readonly constructorRuntimeCall;
     constructor(parent: GoClass, type: Initializer);
+    get validator(): ParameterValidator | undefined;
     get specialDependencies(): SpecialDependencies;
     emit(context: EmitContext): void;
     private emitNew;
@@ -46,15 +49,17 @@ export declare class ClassMethod extends GoMethod {
     readonly method: Method;
     readonly runtimeCall: MethodCall;
     constructor(parent: GoClass, method: Method);
-    emit({ code }: EmitContext): void;
+    emit(context: EmitContext): void;
     emitDecl({ code, documenter }: EmitContext): void;
     get instanceArg(): string;
+    get static(): boolean;
     get specialDependencies(): SpecialDependencies;
 }
 export declare class StaticMethod extends ClassMethod {
     readonly parent: GoClass;
     readonly method: Method;
+    readonly name: string;
     constructor(parent: GoClass, method: Method);
-    emit({ code, documenter }: EmitContext): void;
+    emit(context: EmitContext): void;
 }
 //# sourceMappingURL=class.d.ts.map