@idlizer/core 2.1.10-arktscgen-4 → 2.1.10-arktscgen-6

package/build/lib/src/LanguageWriters/convertors/JavaConvertors.d.ts

@@ -1,37 +0,0 @@
-import * as idl from '../../idl';
-import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
-import { IdlNameConvertor, NodeConvertor } from '../nameConvertor';
-import { InteropArgConvertor } from './InteropConvertors';
-export declare class JavaTypeNameConvertor implements NodeConvertor<string>, IdlNameConvertor {
-    private resolver;
-    constructor(resolver: ReferenceResolver);
-    protected solidConvertor: import("../../util").Lazy<JavaIdlNodeToSolidStringConvertor>;
-    convert(node: idl.IDLNode): string;
-    convertNamespace(node: idl.IDLNamespace): string;
-    convertInterface(node: idl.IDLInterface): string;
-    convertEnum(node: idl.IDLEnum): string;
-    convertTypedef(node: idl.IDLTypedef): string;
-    convertOptional(type: idl.IDLOptionalType): string;
-    convertUnion(type: idl.IDLUnionType): string;
-    convertContainer(type: idl.IDLContainerType): string;
-    convertCallback(type: idl.IDLCallback): string;
-    convertMethod(type: idl.IDLMethod): string;
-    convertConstant(type: idl.IDLConstant): string;
-    convertImport(type: idl.IDLImport): string;
-    convertTypeReferenceAsImport(type: idl.IDLReferenceType, importClause: string): string;
-    convertTypeReference(type: idl.IDLReferenceType): string;
-    convertTypeParameter(type: idl.IDLTypeParameterType): string;
-    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
-    private readonly javaPrimitiveToReferenceTypeMap;
-    protected maybeConvertPrimitiveType(javaType: string): string;
-    private mapTypeName;
-}
-declare class JavaIdlNodeToSolidStringConvertor extends JavaTypeNameConvertor {
-    protected solidConvertor: import("../../util").Lazy<this>;
-    convertContainer(type: idl.IDLContainerType): string;
-}
-export declare class JavaInteropArgConvertor extends InteropArgConvertor {
-    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
-}
-export {};
-//# sourceMappingURL=JavaConvertors.d.ts.map

package/build/lib/src/LanguageWriters/convertors/JavaConvertors.js

@@ -1,210 +0,0 @@
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import * as idl from '../../idl';
-import { lazy } from '../../util';
-import { convertNode, convertType } from '../nameConvertor';
-import { InteropArgConvertor } from './InteropConvertors';
-function convertJavaOptional(type) {
-    switch (type) {
-        case 'boolean': return 'Opt_Boolean';
-        case 'double': return 'Opt_Number';
-    }
-    return type;
-}
-export class JavaTypeNameConvertor {
-    constructor(resolver) {
-        this.resolver = resolver;
-        this.solidConvertor = lazy(() => new JavaIdlNodeToSolidStringConvertor(this.resolver));
-        this.javaPrimitiveToReferenceTypeMap = new Map([
-            ['byte', 'Byte'],
-            ['short', 'Short'],
-            ['int', 'Integer'],
-            ['float', 'Float'],
-            ['double', 'Double'],
-            ['boolean', 'Boolean'],
-            ['char', 'Character'],
-        ]);
-    }
-    convert(node) {
-        const typeString = convertNode(this, node);
-        return this.mapTypeName(typeString);
-    }
-    convertNamespace(node) {
-        throw new Error('Method not implemented.'); // TODO: namespace-related-to-rework
-    }
-    convertInterface(node) {
-        if (node.subkind === idl.IDLInterfaceSubkind.Tuple) {
-            const javaTypeAliases = node.properties.map(it => convertType(this, idl.maybeOptional(it.type, it.isOptional)));
-            return `Tuple_${javaTypeAliases.join('_')}`;
-        }
-        return node.name;
-    }
-    convertEnum(node) {
-        return node.name;
-    }
-    convertTypedef(node) {
-        return node.name;
-    }
-    convertOptional(type) {
-        return convertJavaOptional(this.convert(type.type));
-    }
-    convertUnion(type) {
-        const aliases = type.types.map(it => convertType(this.solidConvertor.value, it));
-        return `Union_${aliases.join('_')}`;
-    }
-    convertContainer(type) {
-        if (idl.IDLContainerUtils.isSequence(type)) {
-            const javaType = convertType(this, type.elementType[0]);
-            return `${javaType}[]`;
-        }
-        if (idl.IDLContainerUtils.isRecord(type)) {
-            const javaTypes = type.elementType.slice(0, 2).map(it => convertType(this, it)).map(this.maybeConvertPrimitiveType, this);
-            return `Map<${javaTypes[0]}, ${javaTypes[1]}>`;
-        }
-        throw new Error(`IDL type ${idl.DebugUtils.debugPrintType(type)} not supported`);
-    }
-    convertCallback(type) {
-        return `Callback`;
-    }
-    convertMethod(type) {
-        throw new Error('Method not implemented.'); // TODO: namespace-related-to-rework
-    }
-    convertConstant(type) {
-        throw new Error('Method not implemented.'); // TODO: namespace-related-to-rework
-    }
-    convertImport(type) {
-        console.warn("Imports are not implemented yet");
-        return type.name;
-    }
-    convertTypeReferenceAsImport(type, importClause) {
-        return type.name;
-    }
-    convertTypeReference(type) {
-        const importAttr = idl.getExtAttribute(type, idl.IDLExtendedAttributes.Import);
-        if (importAttr) {
-            return this.convertTypeReferenceAsImport(type, importAttr);
-        }
-        const decl = this.resolver.resolveTypeReference(type);
-        if (decl) {
-            const declName = this.convert(decl);
-            return declName;
-        }
-        if (type.name === `Optional`) {
-            return convertJavaOptional(idl.printType(type.typeArguments[0]));
-        }
-        return type.name;
-    }
-    convertTypeParameter(type) {
-        // TODO
-        return type.name;
-    }
-    convertPrimitiveType(type) {
-        switch (type) {
-            case idl.IDLStringType: return 'String';
-            case idl.IDLNumberType: return 'double';
-            case idl.IDLBooleanType: return 'boolean';
-            case idl.IDLUndefinedType: return 'Ark_Undefined';
-            case idl.IDLI8Type: return 'byte';
-            case idl.IDLU8Type: return 'byte';
-            case idl.IDLI16Type: return 'short';
-            case idl.IDLU16Type: return 'short';
-            case idl.IDLI32Type: return 'int';
-            case idl.IDLU32Type: return 'int';
-            case idl.IDLI64Type: return 'long';
-            case idl.IDLU64Type: return 'long';
-            case idl.IDLF32Type: return 'float';
-            case idl.IDLF64Type: return 'double';
-            case idl.IDLPointerType: return 'long';
-            case idl.IDLVoidType: return 'void';
-            case idl.IDLDate: return 'Date';
-            case idl.IDLBufferType: return 'byte[]';
-            case idl.IDLInteropReturnBufferType: return 'byte[]';
-            case idl.IDLSerializerBuffer: return 'long';
-            case idl.IDLAnyType: return 'Ark_Object';
-            case idl.IDLUnknownType: return 'Ark_Object';
-        }
-        throw new Error(`Unsupported IDL primitive ${idl.DebugUtils.debugPrintType(type)}`);
-    }
-    maybeConvertPrimitiveType(javaType) {
-        if (this.javaPrimitiveToReferenceTypeMap.has(javaType)) {
-            return this.javaPrimitiveToReferenceTypeMap.get(javaType);
-        }
-        return javaType;
-    }
-    mapTypeName(name) {
-        switch (name) {
-            case 'KPointer': return 'long';
-            case 'KBoolean': return 'boolean';
-            case 'KUInt': return 'int';
-            case 'int32':
-            case 'KInt': return 'int';
-            case 'int64':
-            case 'KLong': return 'long';
-            case 'float32':
-            case 'KFloat': return 'float';
-            case 'float64':
-            case 'KDouble': return 'double';
-            case 'KUint8ArrayPtr': return 'byte[]';
-            case 'KInt32ArrayPtr': return 'int[]';
-            case 'KFloat32ArrayPtr': return 'float[]';
-            // case 'ArrayBuffer': return 'byte[]'
-            case 'KStringPtr': return 'String';
-            case 'string': return 'String';
-        }
-        return name.split(".").at(-1);
-    }
-}
-class JavaIdlNodeToSolidStringConvertor extends JavaTypeNameConvertor {
-    constructor() {
-        super(...arguments);
-        this.solidConvertor = lazy(() => this);
-    }
-    convertContainer(type) {
-        if (idl.IDLContainerUtils.isSequence(type)) {
-            const javaTypeSolid = convertType(this, type.elementType[0]);
-            return `Array_${javaTypeSolid}`;
-        }
-        if (idl.IDLContainerUtils.isRecord(type)) {
-            const javaTypeSolids = type.elementType.slice(0, 2).map(it => convertType(this, it)).map(this.maybeConvertPrimitiveType, this);
-            return `Map_${javaTypeSolids[0]}_${javaTypeSolids[1]}`;
-        }
-        throw new Error(`IDL type ${idl.DebugUtils.debugPrintType(type)} not supported`);
-    }
-}
-export class JavaInteropArgConvertor extends InteropArgConvertor {
-    convertPrimitiveType(type) {
-        switch (type) {
-            case idl.IDLNumberType: return "double";
-            case idl.IDLBooleanType: return "boolean";
-            case idl.IDLI64Type: return "long";
-            case idl.IDLU64Type: return "long";
-            case idl.IDLI32Type: return "int";
-            case idl.IDLU32Type: return "int";
-            case idl.IDLF32Type: return "float";
-            case idl.IDLF64Type: return "double";
-            case idl.IDLBigintType: return "long";
-            case idl.IDLSerializerBuffer: return "long";
-            case idl.IDLFunctionType: return "int";
-            case idl.IDLStringType: return "String";
-            case idl.IDLBufferType: return "byte[]";
-            case idl.IDLDate: return "long";
-            case idl.IDLVoidType: return "void";
-            case idl.IDLUndefinedType: return "long";
-            case idl.IDLPointerType: return "long"; // return PrimitiveTypesInstance.NativePointer.getText()
-        }
-        return super.convertPrimitiveType(type);
-    }
-}
-//# sourceMappingURL=JavaConvertors.js.map

package/build/lib/src/LanguageWriters/writers/JavaLanguageWriter.d.ts

@@ -1,83 +0,0 @@
-import { IndentedPrinter } from "../../IndentedPrinter";
-import { AssignStatement, DelegationCall, FieldModifier, LanguageExpression, LanguageStatement, LanguageWriter, MakeCastOptions, Method, MethodModifier, MethodSignature, ObjectArgs } from "../LanguageWriter";
-import { CLikeLanguageWriter } from "./CLikeLanguageWriter";
-import * as idl from '../../idl';
-import { ArgConvertor, BaseArgConvertor } from "../ArgConvertors";
-import { IdlNameConvertor } from "../nameConvertor";
-import { RuntimeType } from "../common";
-import { ReferenceResolver } from "../../peer-generation/ReferenceResolver";
-export declare class JavaCastExpression implements LanguageExpression {
-    value: LanguageExpression;
-    type: string;
-    private unsafe;
-    constructor(value: LanguageExpression, type: string, unsafe?: boolean);
-    asString(): string;
-}
-export declare class JavaAssignStatement extends AssignStatement {
-    variableName: string;
-    type: idl.IDLType | undefined;
-    expression: LanguageExpression;
-    isDeclared: boolean;
-    protected isConst: boolean;
-    constructor(variableName: string, type: idl.IDLType | undefined, expression: LanguageExpression, isDeclared?: boolean, isConst?: boolean);
-    write(writer: LanguageWriter): void;
-}
-export declare class JavaLanguageWriter extends CLikeLanguageWriter {
-    protected typeConvertor: IdlNameConvertor;
-    constructor(printer: IndentedPrinter, resolver: ReferenceResolver, typeConvertor: IdlNameConvertor);
-    getNodeName(type: idl.IDLNode): string;
-    fork(options?: {
-        resolver?: ReferenceResolver;
-    }): LanguageWriter;
-    writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[], generics?: string[], isDeclared?: boolean, isExport?: boolean): void;
-    writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[], generics?: string[]): void;
-    writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
-    writeFieldDeclaration(name: string, type: idl.IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
-    writeNativeMethodDeclaration(method: Method): void;
-    writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, delegationCall?: DelegationCall, modifiers?: MethodModifier[]): void;
-    writeProperty(propName: string, propType: idl.IDLType, modifiers: FieldModifier[], getter?: {
-        method: Method;
-        op: () => void;
-    }, setter?: {
-        method: Method;
-        op: () => void;
-    }, initExpr?: LanguageExpression): void;
-    writeTypeDeclaration(decl: idl.IDLTypedef): void;
-    writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
-    makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression, isDeclared?: boolean, isConst?: boolean): LanguageStatement;
-    makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
-    makeReturn(expr: LanguageExpression): LanguageStatement;
-    makeDefinedCheck(value: string): LanguageExpression;
-    makeLoop(counter: string, limit: string, statement?: LanguageStatement): LanguageStatement;
-    makeMapForEach(map: string, key: string, value: string, body: LanguageStatement[]): LanguageStatement;
-    makeMapSize(map: string): LanguageExpression;
-    makeCast(value: LanguageExpression, node: idl.IDLNode, options?: MakeCastOptions): LanguageExpression;
-    makeStatement(expr: LanguageExpression): LanguageStatement;
-    makeUnionSelector(value: string, valueType: string): LanguageStatement;
-    makeUnionVariantCondition(_convertor: ArgConvertor, _valueName: string, valueType: string, _type: string, convertorIndex: number): LanguageExpression;
-    makeUnionVariantCast(value: string, type: string, convertor: ArgConvertor, index: number): LanguageExpression;
-    makeUnionTypeDefaultInitializer(): LanguageExpression;
-    writePrintLog(message: string): void;
-    mapIDLContainerType(type: idl.IDLContainerType): string;
-    applyToObject(p: BaseArgConvertor, param: string, value: string, args?: ObjectArgs): LanguageStatement;
-    getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
-    makeUndefined(): LanguageExpression;
-    makeRuntimeType(rt: RuntimeType): LanguageExpression;
-    protected makeRuntimeTypeGetterCall(value: string): LanguageExpression;
-    makeMapInsert(keyAccessor: string, key: string, valueAccessor: string, value: string): LanguageStatement;
-    getTagType(): idl.IDLType;
-    getRuntimeType(): idl.IDLType;
-    makeTupleAssign(receiver: string, tupleFields: string[]): LanguageStatement;
-    get supportedModifiers(): MethodModifier[];
-    get supportedFieldModifiers(): FieldModifier[];
-    makeArrayInit(type: idl.IDLContainerType, size?: number): LanguageExpression;
-    makeClassInit(type: idl.IDLType, paramenters: LanguageExpression[]): LanguageExpression;
-    makeMapInit(type: idl.IDLType): LanguageExpression;
-    makeTupleAccess(value: string, index: number): LanguageExpression;
-    enumFromI32(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
-    makeValueFromOption(value: string): LanguageExpression;
-    runtimeType(param: ArgConvertor, valueType: string, value: string): void;
-    i32FromEnum(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
-    castToBoolean(value: string): string;
-}
-//# sourceMappingURL=JavaLanguageWriter.d.ts.map

package/build/lib/src/LanguageWriters/writers/JavaLanguageWriter.js

@@ -1,295 +0,0 @@
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { Language } from '../../Language';
-import { IndentedPrinter } from "../../IndentedPrinter";
-import { AssignStatement, BlockStatement, FieldModifier, LambdaExpression, Method, MethodModifier, MethodSignature, NamedMethodSignature, } from "../LanguageWriter";
-import { CLikeExpressionStatement, CLikeLanguageWriter, CLikeLoopStatement, CLikeReturnStatement } from "./CLikeLanguageWriter";
-import * as idl from '../../idl';
-import { RuntimeType } from "../common";
-////////////////////////////////////////////////////////////////
-//                        EXPRESSIONS                         //
-////////////////////////////////////////////////////////////////
-class JavaLambdaExpression extends LambdaExpression {
-    constructor(writer, signature, resolver, body) {
-        super(writer, signature, resolver, body);
-    }
-    get statementHasSemicolon() {
-        return true;
-    }
-    asString() {
-        const params = this.signature.args.map((it, i) => `${idl.forceAsNamedNode(it).name} ${this.signature.argName(i)}`);
-        return `(${params.join(", ")}) ->${this.bodyAsString(true)}`;
-    }
-}
-export class JavaCastExpression {
-    constructor(value, type, unsafe = false) {
-        this.value = value;
-        this.type = type;
-        this.unsafe = unsafe;
-    }
-    asString() {
-        return `(${this.type})(${this.value.asString()})`;
-    }
-}
-////////////////////////////////////////////////////////////////
-//                         STATEMENTS                         //
-////////////////////////////////////////////////////////////////
-export class JavaAssignStatement extends AssignStatement {
-    constructor(variableName, type, expression, isDeclared = true, isConst = true) {
-        super(variableName, type, expression, isDeclared, isConst);
-        this.variableName = variableName;
-        this.type = type;
-        this.expression = expression;
-        this.isDeclared = isDeclared;
-        this.isConst = isConst;
-    }
-    write(writer) {
-        if (this.isDeclared) {
-            const typeSpec = this.type ? writer.getNodeName(this.type) : "var";
-            writer.print(`${typeSpec} ${this.variableName} = ${this.expression.asString()};`);
-        }
-        else {
-            writer.print(`${this.variableName} = ${this.expression.asString()};`);
-        }
-    }
-}
-class JavaMapForEachStatement {
-    constructor(map, key, value, body) {
-        this.map = map;
-        this.key = key;
-        this.value = value;
-        this.body = body;
-    }
-    write(writer) {
-        const entryVar = `${this.map}Entry`;
-        writer.print(`for (var ${entryVar}: ${this.map}.entrySet()) {`);
-        writer.pushIndent();
-        writer.print(`var ${this.key} = ${entryVar}.getKey();`);
-        writer.print(`var ${this.value} = ${entryVar}.getValue();`);
-        writer.writeStatement(new BlockStatement(this.body, false));
-        writer.popIndent();
-        writer.print(`}`);
-    }
-}
-////////////////////////////////////////////////////////////////
-//                           WRITER                           //
-////////////////////////////////////////////////////////////////
-export class JavaLanguageWriter extends CLikeLanguageWriter {
-    constructor(printer, resolver, typeConvertor) {
-        super(printer, resolver, Language.JAVA);
-        this.typeConvertor = typeConvertor;
-    }
-    getNodeName(type) {
-        // another stub. Bad one.
-        // I hope that I will rewrite LWs soon
-        if (idl.isType(type) && idl.isReferenceType(type)) {
-            if (type.name.startsWith('%TEXT%:')) {
-                return type.name.substring(7);
-            }
-        }
-        return this.typeConvertor.convert(type);
-    }
-    fork(options) {
-        var _a;
-        return new JavaLanguageWriter(new IndentedPrinter([], this.indentDepth()), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor);
-    }
-    writeClass(name, op, superClass, interfaces, generics, isDeclared, isExport = true) {
-        let genericsClause = (generics === null || generics === void 0 ? void 0 : generics.length) ? `<${generics.join(', ')}> ` : ``;
-        let extendsClause = superClass ? ` extends ${superClass}` : '';
-        let implementsClause = interfaces ? ` implements ${interfaces.join(",")}` : '';
-        this.printer.print(`${isExport ? 'public ' : ''}class ${name}${genericsClause}${extendsClause}${implementsClause} {`); // TODO check for multiple classes in file
-        this.pushIndent();
-        op(this);
-        this.popIndent();
-        this.printer.print(`}`);
-    }
-    writeInterface(name, op, superInterfaces, generics) {
-        let extendsClause = superInterfaces ? ` extends ${superInterfaces.join(",")}` : '';
-        this.printer.print(`interface ${name}${extendsClause} {`);
-        this.pushIndent();
-        op(this);
-        this.popIndent();
-        this.printer.print(`}`);
-    }
-    writeMethodCall(receiver, method, params, nullable = false) {
-        if (nullable) {
-            this.printer.print(`if (${receiver} != null) ${receiver}.${method}(${params.join(", ")});`);
-        }
-        else {
-            super.writeMethodCall(receiver, method, params, nullable);
-        }
-    }
-    writeFieldDeclaration(name, type, modifiers, optional, initExpr) {
-        let prefix = this.makeFieldModifiersList(modifiers);
-        this.printer.print(`${prefix} ${(this.getNodeName(type))} ${name}${initExpr ? ` = ${initExpr.asString()}` : ""};`);
-    }
-    writeNativeMethodDeclaration(method) {
-        this.writeMethodDeclaration(method.name, method.signature, [MethodModifier.STATIC, MethodModifier.NATIVE]);
-    }
-    writeConstructorImplementation(className, signature, op, delegationCall, modifiers) {
-        this.printer.print(`${modifiers ? modifiers.map((it) => MethodModifier[it].toLowerCase()).join(' ') : ''} ${className}(${signature.args.map((it, index) => `${this.getNodeName(it)} ${signature.argName(index)}`).join(", ")}) {`);
-        this.pushIndent();
-        if (delegationCall) {
-            this.print(`super(${delegationCall.delegationArgs.map(it => it.asString()).join(", ")});`);
-        }
-        op(this);
-        this.popIndent();
-        this.printer.print(`}`);
-    }
-    writeProperty(propName, propType, modifiers, getter, setter, initExpr) {
-        let isStatic = modifiers.includes(FieldModifier.STATIC);
-        let isMutable = !modifiers.includes(FieldModifier.READONLY);
-        let containerName = propName.concat("_container");
-        if (getter) {
-            if (!getter.op) {
-                this.print(`private var ${this.getNodeName(propType)} ${containerName};`);
-            }
-            this.writeGetterImplementation(new Method(propName, new MethodSignature(propType, []), isStatic ? [MethodModifier.STATIC, MethodModifier.PUBLIC] : [MethodModifier.PUBLIC]), getter ? getter.op :
-                (writer) => {
-                    writer.print(`return ${containerName}`);
-                });
-            if (isMutable) {
-                const setSignature = new NamedMethodSignature(idl.IDLVoidType, [propType], [propName]);
-                this.writeSetterImplementation(new Method(propName, setSignature, isStatic ? [MethodModifier.STATIC, MethodModifier.PUBLIC] : [MethodModifier.PUBLIC]), setter ? setter.op :
-                    (writer) => {
-                        writer.print(`${containerName} = ${propName};`);
-                    });
-            }
-        }
-        else {
-            // TBD: use initExpr
-            this.writeMethodDeclaration(propName, new MethodSignature(propType, []));
-        }
-    }
-    writeTypeDeclaration(decl) {
-        throw new Error(`Type declarations do not exist in Java, use something else`);
-    }
-    writeConstant(constName, constType, constVal) {
-        throw new Error("writeConstant for Java is not implemented yet.");
-    }
-    makeAssign(variableName, type, expr, isDeclared = true, isConst = true) {
-        return new JavaAssignStatement(variableName, type, expr, isDeclared, isConst);
-    }
-    makeLambda(signature, body) {
-        return new JavaLambdaExpression(this, signature, this.resolver, body);
-    }
-    makeReturn(expr) {
-        return new CLikeReturnStatement(expr);
-    }
-    makeDefinedCheck(value) {
-        return this.makeString(`${value} != null`);
-    }
-    makeLoop(counter, limit, statement) {
-        return new CLikeLoopStatement(counter, limit, statement);
-    }
-    makeMapForEach(map, key, value, body) {
-        return new JavaMapForEachStatement(map, key, value, body);
-    }
-    makeMapSize(map) {
-        return this.makeString(`${map}.size()`);
-    }
-    makeCast(value, node, options) {
-        var _a;
-        return new JavaCastExpression(value, this.getNodeName(node), (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
-    }
-    makeStatement(expr) {
-        return new CLikeExpressionStatement(expr);
-    }
-    makeUnionSelector(value, valueType) {
-        return this.makeAssign(valueType, undefined, this.makeMethodCall(value, "getSelector", []), false);
-    }
-    makeUnionVariantCondition(_convertor, _valueName, valueType, _type, convertorIndex) {
-        return this.makeString(`${valueType} == ${convertorIndex}`);
-    }
-    makeUnionVariantCast(value, type, convertor, index) {
-        return this.makeMethodCall(value, `getValue${index}`, []);
-    }
-    makeUnionTypeDefaultInitializer() {
-        return this.makeString("-1");
-    }
-    writePrintLog(message) {
-        this.print(`System.out.println("${message}")`);
-    }
-    mapIDLContainerType(type) {
-        switch (type.containerKind) {
-            case "sequence": return `${this.getNodeName(type.elementType[0])}[]`;
-        }
-        throw new Error(`Unmapped container type ${idl.DebugUtils.debugPrintType(type)}`);
-    }
-    applyToObject(p, param, value, args) {
-        throw new Error("Method not implemented.");
-    }
-    getObjectAccessor(convertor, value, args) {
-        return value;
-    }
-    makeUndefined() {
-        return this.makeString("null");
-    }
-    makeRuntimeType(rt) {
-        return this.makeString(`RuntimeType.${RuntimeType[rt]}`);
-    }
-    makeRuntimeTypeGetterCall(value) {
-        return this.makeMethodCall("Ark_Object", "getRuntimeType", [this.makeString(value)]);
-    }
-    makeMapInsert(keyAccessor, key, valueAccessor, value) {
-        throw new Error("Method not implemented.");
-    }
-    getTagType() {
-        throw new Error("Method not implemented.");
-    }
-    getRuntimeType() {
-        throw new Error("Method not implemented.");
-    }
-    makeTupleAssign(receiver, tupleFields) {
-        throw new Error("Method not implemented.");
-    }
-    get supportedModifiers() {
-        return [MethodModifier.PUBLIC, MethodModifier.PRIVATE, MethodModifier.STATIC, MethodModifier.NATIVE];
-    }
-    get supportedFieldModifiers() {
-        return [FieldModifier.PUBLIC, FieldModifier.PRIVATE, FieldModifier.PROTECTED, FieldModifier.STATIC, FieldModifier.FINAL];
-    }
-    makeArrayInit(type, size) {
-        return this.makeString(`new ${this.getNodeName(type.elementType[0])}[${size !== null && size !== void 0 ? size : 0}]`);
-    }
-    makeClassInit(type, paramenters) {
-        throw new Error("Method not implemented.");
-    }
-    makeMapInit(type) {
-        throw new Error("Method not implemented.");
-    }
-    makeTupleAccess(value, index) {
-        return this.makeString(`${value}.value${index}`);
-    }
-    enumFromI32(value, enumEntry) {
-        const enumName = idl.forceAsNamedNode(enumEntry).name;
-        const ordinal = value.asString();
-        return this.makeString(`${enumName}.values()[${ordinal}]`);
-    }
-    makeValueFromOption(value) {
-        return this.makeString(`${value}`);
-    }
-    runtimeType(param, valueType, value) {
-        this.writeStatement(this.makeAssign(valueType, undefined, this.makeRuntimeTypeGetterCall(value), false));
-    }
-    i32FromEnum(value, enumEntry) {
-        const i32Value = idl.isStringEnum(enumEntry)
-            ? `${value.asString()}.ordinal`
-            : `${value.asString()}.value`;
-        return this.makeString(i32Value);
-    }
-    castToBoolean(value) { return value; }
-}
-//# sourceMappingURL=JavaLanguageWriter.js.map

package/build/lib/src/from-idl/webidl2-utils.d.ts

@@ -1,21 +0,0 @@
-import * as webidl2 from "webidl2";
-export declare function isEnum(node: webidl2.IDLRootType): node is webidl2.EnumType;
-export declare function isInterface(node: webidl2.IDLRootType): node is webidl2.InterfaceType;
-export declare function isImport(node: webidl2.IDLRootType): node is webidl2.ImportType;
-export declare function isPackage(node: webidl2.IDLRootType): node is webidl2.PackageType;
-export declare function isClass(node: webidl2.IDLRootType): node is webidl2.InterfaceType;
-export declare function isCallback(node: webidl2.IDLRootType): node is webidl2.CallbackType;
-export declare function isTypedef(node: webidl2.IDLRootType): node is webidl2.TypedefType;
-export declare function isDictionary(node: webidl2.IDLRootType): node is webidl2.DictionaryType;
-export declare function isAttribute(node: webidl2.IDLInterfaceMemberType | webidl2.IDLNamespaceMemberType): node is webidl2.AttributeMemberType;
-export declare function isOperation(node: webidl2.IDLInterfaceMemberType | webidl2.IDLNamespaceMemberType): node is webidl2.OperationMemberType;
-export declare function isConstructor(node: webidl2.IDLInterfaceMemberType): node is webidl2.ConstructorMemberType;
-export declare function isUnionTypeDescription(node: webidl2.IDLTypeDescription): node is webidl2.UnionTypeDescription;
-export declare function isSingleTypeDescription(node: webidl2.IDLTypeDescription): node is webidl2.SingleTypeDescription;
-export declare function isSequenceTypeDescription(node: webidl2.IDLTypeDescription): node is webidl2.SequenceTypeDescription;
-export declare function isPromiseTypeDescription(node: webidl2.IDLTypeDescription): node is webidl2.PromiseTypeDescription;
-export declare function isRecordTypeDescription(node: webidl2.IDLTypeDescription): node is webidl2.RecordTypeDescription;
-export declare function isConstant(node: webidl2.IDLRootType): node is webidl2.ConstantMemberType;
-export declare function isUnspecifiedGenericTypeDescription(node: webidl2.IDLTypeDescription): node is webidl2.UnspecifiedGenericTypeDescription;
-export declare function isOptional(node: webidl2.AttributeMemberType | webidl2.OperationMemberType): boolean;
-//# sourceMappingURL=webidl2-utils.d.ts.map