@idlizer/core 2.1.5 → 2.1.9-arktscgen-4

package/build/lib/src/LanguageWriters/LanguageWriter.js

@@ -73,6 +73,18 @@ export class MethodCallExpression extends FunctionCallExpression {
         return `${this.receiver}${this.nullable ? "?" : ""}.${super.asString()}`;
     }
 }
+export class MethodStaticCallExpression extends MethodCallExpression {
+    constructor(receiver, method, params, nullable = false) {
+        super(receiver, method, params, nullable);
+        this.receiver = receiver;
+        this.nullable = nullable;
+    }
+}
+export class ThisCallExpression extends FunctionCallExpression {
+    constructor(params) {
+        super("this", params);
+    }
+}
 export class FieldAccessExpression {
     constructor(receiver, field, nullable = false) {
         this.receiver = receiver;
@@ -283,6 +295,9 @@ export class LambdaExpression {
                 stmt.write(writer);
             }
         }
+        writer.features.forEach(([feature, module]) => {
+            this.originalWriter.addFeature(feature, module);
+        });
         return (this.body ? ((_a = this.body) === null || _a === void 0 ? void 0 : _a.length) > 1 ? '\n' : '' : '').concat(writer.getOutput()
             .filter(line => line !== "")
             .map(line => indentedBy(line.endsWith('{') || line.endsWith('}') || line.endsWith(';') ? line : `${line};`, 1))
@@ -320,6 +335,7 @@ export var MethodModifier;
     MethodModifier[MethodModifier["THROWS"] = 8] = "THROWS";
     MethodModifier[MethodModifier["FREE"] = 9] = "FREE";
     MethodModifier[MethodModifier["FORCE_CONTEXT"] = 10] = "FORCE_CONTEXT";
+    MethodModifier[MethodModifier["OVERRIDE"] = 11] = "OVERRIDE";
 })(MethodModifier || (MethodModifier = {}));
 export var ClassModifier;
 (function (ClassModifier) {
@@ -327,6 +343,11 @@ export var ClassModifier;
     ClassModifier[ClassModifier["PRIVATE"] = 1] = "PRIVATE";
     ClassModifier[ClassModifier["PROTECTED"] = 2] = "PROTECTED";
 })(ClassModifier || (ClassModifier = {}));
+export var DelegationType;
+(function (DelegationType) {
+    DelegationType[DelegationType["THIS"] = 0] = "THIS";
+    DelegationType[DelegationType["SUPER"] = 1] = "SUPER";
+})(DelegationType || (DelegationType = {}));
 export class Field {
     constructor(name, type, modifiers = []) {
         this.name = name;
@@ -355,6 +376,7 @@ PrintHint.AsPointer = new PrintHint('AsPointer');
 PrintHint.AsConstPointer = new PrintHint('AsConstPointer');
 PrintHint.AsValue = new PrintHint('AsValue');
 PrintHint.AsConstReference = new PrintHint('AsConstReference');
+PrintHint.AsReference = new PrintHint('AsReference');
 export class MethodSignature {
     constructor(returnType, args, defaults = undefined, argsModifiers = undefined, printHints, argNames) {
         this.returnType = returnType;
@@ -410,11 +432,15 @@ export class LanguageWriter {
         this.resolver = resolver;
         this.language = language;
         this.namespaceStack = [];
+        this.features = [];
     }
     indentDepth() {
         return this.printer.indentDepth();
     }
     maybeSemicolon() { return ";"; }
+    addFeature(feature, module) {
+        this.features.push([feature, module]);
+    }
     // version of makeCast which uses TypeCheck.typeCast<T>(value) call for ETS language writer
     // Use it only if TypeChecker class is added as import to the generated file
     makeTypeCast(value, type, options) {
@@ -441,12 +467,17 @@ export class LanguageWriter {
         var _a;
         this.writeMethodImplementation(new Method(method.name, method.signature, [MethodModifier.SETTER].concat((_a = method.modifiers) !== null && _a !== void 0 ? _a : [])), op);
     }
+    // Deprecated
+    // Use instead declarationCall parameter in writeConstructorImplementation(...)
     writeSuperCall(params) {
         this.printer.print(`super(${params.join(", ")})${this.maybeSemicolon()}`);
     }
     writeMethodCall(receiver, method, params, nullable = false) {
         this.printer.print(`${receiver}${nullable ? "?" : ""}.${method}(${params.join(", ")})`);
     }
+    writeStaticMethodCall(receiver, method, params, nullable = false) {
+        this.writeMethodCall(receiver, method, params, nullable);
+    }
     writeStatement(stmt) {
         stmt.write(this);
     }
@@ -497,6 +528,14 @@ export class LanguageWriter {
     makeMethodCall(receiver, method, params, nullable) {
         return new MethodCallExpression(receiver, method, params, nullable);
     }
+    // Deprecated
+    // Use instead declarationCall parameter in writeConstructorImplementation(...) with DelegationType.THIS
+    makeThisCall(params) {
+        return new ThisCallExpression(params);
+    }
+    makeStaticMethodCall(receiver, method, params, nullable) {
+        return new MethodStaticCallExpression(receiver, method, params, nullable);
+    }
     makeFieldAccess(receiver, method, nullable) {
         return new FieldAccessExpression(receiver, method, nullable);
     }
@@ -678,6 +717,9 @@ export class LanguageWriter {
     makeCallIsObject(value) {
         return this.makeString(`typeof ${value} === "object"`);
     }
+    makeStaticBlock(op) {
+        op(this);
+    }
     instanceOf(convertor, value, _duplicateMembers) {
         return this.makeString(`${value} instanceof ${this.getNodeName(convertor.idlType)}`);
     }
@@ -694,17 +736,17 @@ export class LanguageWriter {
      * Writes `namespace <namespace> {` and adds extra indent
      * @param namespace Namespace to begin
      */
-    pushNamespace(namespace, ident = true) {
+    pushNamespace(namespace, options) {
         this.print(`namespace ${namespace} {`);
-        if (ident)
+        if (options.ident)
             this.pushIndent();
     }
     /**
      * Writes closing brace of namespace block and removes one level of indent
      */
-    popNamespace(ident = true) {
+    popNamespace(options) {
         this.namespaceStack.pop();
-        if (ident)
+        if (options.ident)
             this.popIndent();
         this.print(`}`);
     }

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

@@ -32,4 +32,5 @@ export declare class CJIDLTypeToForeignStringConvertor extends CJTypeNameConvert
 export declare class CJInteropArgConvertor extends InteropArgConvertor {
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
 }
+export declare function removePoints(s: string): string;
 //# sourceMappingURL=CJConvertors.d.ts.map

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

@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 import * as idl from '../../idl';
+import { CJKeywords } from '../../languageSpecificKeywords';
 import { convertNode, convertType } from '../nameConvertor';
 import { InteropArgConvertor } from './InteropConvertors';
 export class CJTypeNameConvertor {
@@ -40,6 +41,12 @@ export class CJTypeNameConvertor {
         }
         if (idl.IDLContainerUtils.isRecord(type)) {
             const stringes = type.elementType.slice(0, 2).map(it => convertType(this, it));
+            if (idl.isReferenceType(type.elementType[0])) {
+                const keyValueType = this.resolver.resolveTypeReference(type.elementType[0]);
+                if (idl.isInterface(keyValueType) || idl.isEnum(keyValueType)) {
+                    return `HashMap<Int64, ${stringes[1]}>`;
+                }
+            }
             return `HashMap<${stringes[0]}, ${stringes[1]}>`;
         }
         if (idl.IDLContainerUtils.isPromise(type)) {
@@ -48,19 +55,19 @@ export class CJTypeNameConvertor {
         throw new Error(`IDL type ${idl.DebugUtils.debugPrintType(type)} not supported`);
     }
     convertNamespace(node) {
-        throw new Error('Method not implemented.');
+        return node.name;
     }
     convertInterface(node) {
-        return node.name;
+        return removePoints(idl.getNamespaceName(node).concat(node.name));
     }
     convertEnum(node) {
-        return node.name;
+        return removePoints(idl.getNamespaceName(node).concat(node.name));
     }
     convertTypedef(node) {
         return node.name;
     }
     convertCallback(type) {
-        const params = type.parameters.map(it => `${it.name}: ${it.isOptional ? "?" : ""}${this.convert(it.type)}`);
+        const params = type.parameters.map(it => `${CJKeywords.has(it.name) ? it.name.concat("_") : it.name}: ${it.isOptional ? "?" : ""}${this.convert(it.type)}`);
         return `(${params.join(", ")}) -> ${this.convert(type.returnType)}`;
     }
     convertMethod(node) {
@@ -74,15 +81,17 @@ export class CJTypeNameConvertor {
         return type.name;
     }
     convertTypeReferenceAsImport(type, importClause) {
-        return type.name;
+        var _a;
+        const maybeTypeArguments = ((_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.length) ? `<${type.typeArguments.join(', ')}>` : "";
+        let decl = this.resolver.resolveTypeReference(type);
+        if (decl)
+            return `${decl.name}${maybeTypeArguments}`;
+        return this.convert(idl.IDLCustomObjectType);
     }
     convertTypeReference(type) {
-        if (type.name === "Object")
+        var _a, _b;
+        if (type.name === idl.IDLObjectType.name)
             return "KPointer";
-        const importAttr = idl.getExtAttribute(type, idl.IDLExtendedAttributes.Import);
-        if (importAttr) {
-            return this.convertTypeReferenceAsImport(type, importAttr);
-        }
         // resolve synthetic types
         const decl = this.resolver.resolveTypeReference(type);
         if (decl && idl.isSyntheticEntry(decl)) {
@@ -95,13 +104,20 @@ export class CJTypeNameConvertor {
                 return this.productType(decl, isTuple, !isTuple);
             }
         }
-        return type.name;
+        let name = type.name.split('.');
+        let typeArgs = (_b = (_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => this.convert(it))) !== null && _b !== void 0 ? _b : [];
+        const maybeTypeArguments = !(typeArgs === null || typeArgs === void 0 ? void 0 : typeArgs.length) ? '' : `<${typeArgs.join(', ')}>`;
+        if (decl) {
+            return idl.getNamespacesPathFor(decl).map(ns => ns.name).join().concat(name[name.length - 1].concat(maybeTypeArguments));
+        }
+        return this.convert(idl.IDLCustomObjectType);
     }
     convertTypeParameter(type) {
         return type.name;
     }
     convertPrimitiveType(type) {
         switch (type) {
+            case idl.IDLThisType: return 'this';
             case idl.IDLStringType: return 'String';
             case idl.IDLBooleanType: return 'Bool';
             case idl.IDLNumberType: return 'Float64';
@@ -123,16 +139,19 @@ export class CJTypeNameConvertor {
             case idl.IDLBigintType: return 'Int64';
             case idl.IDLSerializerBuffer: return 'KSerializerBuffer';
             case idl.IDLAnyType: return 'Any';
+            case idl.IDLDate: return 'DateTime';
+            case idl.IDLObjectType: return 'Any';
+            case idl.IDLUnknownType:
+            case idl.IDLFunctionType:
+            case idl.IDLCustomObjectType: return 'Any';
         }
         throw new Error(`Unsupported IDL primitive ${idl.DebugUtils.debugPrintType(type)}`);
     }
     callbackType(decl) {
-        const params = decl.parameters.map(it => `${it.name}: ${this.convert(it.type)}`);
+        const params = decl.parameters.map(it => `${CJKeywords.has(it.name) ? it.name.concat("_") : it.name}: ${this.convert(it.type)}`);
         return `((${params.join(", ")}) -> ${this.convert(decl.returnType)})`;
     }
     productType(decl, isTuple, includeFieldNames) {
-        if (!isTuple)
-            throw new Error('Only tuples supported from IDL synthetic types for now');
         return decl.name;
     }
 }
@@ -143,6 +162,7 @@ export class CJIDLTypeToForeignStringConvertor extends CJTypeNameConvertor {
                 case idl.IDLStringType: return 'CString';
                 case idl.IDLInteropReturnBufferType: return 'KInteropReturnBuffer';
                 case idl.IDLSerializerBuffer: return 'KSerializerBuffer';
+                case idl.IDLObjectType: return 'Unit';
             }
         }
         if (idl.isContainerType(type)) {
@@ -178,4 +198,7 @@ export class CJInteropArgConvertor extends InteropArgConvertor {
         return super.convertPrimitiveType(type);
     }
 }
+export function removePoints(s) {
+    return s.split(/[\.\-]/g).join('_');
+}
 //# sourceMappingURL=CJConvertors.js.map

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

@@ -5,6 +5,7 @@ import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
 export interface ConvertResult {
     text: string;
     noPrefix: boolean;
+    resolvedType: idl.IDLType;
 }
 export declare class GenericCppConvertor implements NodeConvertor<ConvertResult> {
     protected resolver: ReferenceResolver;

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

@@ -26,8 +26,8 @@ export class GenericCppConvertor {
     constructor(resolver) {
         this.resolver = resolver;
     }
-    make(text, noPrefix = false) {
-        return { text, noPrefix };
+    make(text, resolvedType, noPrefix = false) {
+        return { text, noPrefix, resolvedType };
     }
     convertNode(node) {
         return convertNode(this, node);
@@ -39,60 +39,65 @@ export class GenericCppConvertor {
         switch (node.subkind) {
             case idl.IDLInterfaceSubkind.AnonymousInterface:
                 return node.name
-                    ? this.make(this.qualifiedName(node))
-                    : this.make(this.computeTargetTypeLiteralName(node), true);
+                    ? this.make(this.qualifiedName(node), idl.createReferenceType(node))
+                    : this.make(this.computeTargetTypeLiteralName(node), idl.createReferenceType(node), true);
             case idl.IDLInterfaceSubkind.Interface:
             case idl.IDLInterfaceSubkind.Class:
                 if (isInIdlizeInternal(node)) {
-                    return this.make(this.qualifiedName(node), true);
+                    return this.make(this.qualifiedName(node), idl.createReferenceType(node), true);
                 }
-                return this.make(this.qualifiedName(node));
+                return this.make(this.qualifiedName(node), idl.createReferenceType(node));
             case idl.IDLInterfaceSubkind.Tuple:
                 return node.name
-                    ? this.make(this.qualifiedName(node))
-                    : this.make(`Tuple_${node.properties.map(it => this.convertNode(idl.maybeOptional(it.type, it.isOptional)).text).join("_")}`, true);
+                    ? this.make(this.qualifiedName(node), idl.createReferenceType(node))
+                    : this.make(`Tuple_${node.properties.map(it => this.convertNode(idl.maybeOptional(it.type, it.isOptional)).text).join("_")}`, idl.createReferenceType(node), true);
         }
     }
     convertEnum(node) {
-        return this.make(this.qualifiedName(node));
+        return this.make(this.qualifiedName(node), idl.createReferenceType(node));
     }
     convertTypedef(node) {
-        return this.make(this.qualifiedName(node));
+        return this.make(this.qualifiedName(node), idl.createReferenceType(node));
     }
     convertCallback(node) {
-        return this.make(generatorConfiguration().LibraryPrefix + this.qualifiedName(node), true);
+        return this.make(generatorConfiguration().LibraryPrefix + this.qualifiedName(node), idl.createReferenceType(node), true);
     }
     convertMethod(node) {
-        return this.make(node.name);
+        return this.make(node.name, idl.createReferenceType(node));
     }
     convertConstant(node) {
-        return this.make(this.qualifiedName(node));
+        return this.make(this.qualifiedName(node), idl.createReferenceType(node));
     }
     /////////////////////////////////////////////////////////////////////////////////////////
     convertOptional(type) {
-        return { text: generatorConfiguration().OptionalPrefix + this.convertNode(type.type).text, noPrefix: true };
+        const converted = this.convertNode(type.type);
+        const prefix = generatorConfiguration().OptionalPrefix;
+        if (idl.isOptionalType(converted.resolvedType)) {
+            return converted;
+        }
+        return this.make(prefix + converted.text, type, true);
     }
     convertUnion(type) {
-        return this.make(type.name, false);
+        return this.make(type.name, type, false);
     }
     convertContainer(type) {
         if (idl.IDLContainerUtils.isPromise(type)) {
-            return this.make(`Promise_${this.convertNode(type.elementType[0]).text}`);
+            return this.make(`Promise_${this.convertNode(type.elementType[0]).text}`, type);
         }
         if (idl.IDLContainerUtils.isSequence(type)) {
             if (type.elementType[0] === idl.IDLU8Type) {
-                return this.make(`uint8_t*`, true);
+                return this.make(`uint8_t*`, type, true);
             }
-            return this.make(`Array_${this.convertNode(type.elementType[0]).text}`, true);
+            return this.make(`Array_${this.convertNode(type.elementType[0]).text}`, type, true);
         }
         if (idl.IDLContainerUtils.isRecord(type)) {
-            return this.make(`Map_${this.convertNode(type.elementType[0]).text}_${this.convertNode(type.elementType[1]).text}`, true);
+            return this.make(`Map_${this.convertNode(type.elementType[0]).text}_${this.convertNode(type.elementType[1]).text}`, type, true);
         }
         throw new Error(`Unmapped container type ${idl.DebugUtils.debugPrintType(type)}`);
     }
     convertImport(type) {
         console.warn("Imports are not implemented yet");
-        return this.make(idl.IDLCustomObjectType.name);
+        return this.make(idl.IDLCustomObjectType.name, idl.IDLCustomObjectType);
     }
     convertTypeReferenceAsImport(type, _) {
         return this.convertTypeReference(type);
@@ -100,14 +105,8 @@ export class GenericCppConvertor {
     convertTypeReference(type) {
         var _a;
         const refName = type.name;
-        switch (refName) {
-            case "object":
-            case "Object":
-                // treat object as interop resource
-                return this.make('Object');
-        }
         if (generatorConfiguration().parameterized.includes(refName)) {
-            return this.make('CustomObject');
+            return this.make('CustomObject', idl.IDLCustomObjectType);
         }
         let decl = this.resolver.toDeclaration(type);
         if (idl.isCallback(decl)) {
@@ -115,45 +114,47 @@ export class GenericCppConvertor {
         }
         if (idl.isType(decl)) {
             if (idl.isReferenceType(decl)) {
-                return this.make(`${capitalize(decl.name)}`);
+                return this.make(`${capitalize(decl.name)}`, decl);
             }
             return this.convertNode(decl);
         }
         let res = this.convertNode(decl);
         if (type.name === "Optional")
-            res = this.make("Opt_" + res.text, true);
+            res = this.make("Opt_" + res.text, idl.createOptionalType(type.typeArguments[0]), true);
         return res;
     }
     convertTypeParameter(type) {
-        return this.make('CustomObject');
+        return this.make('CustomObject', idl.IDLCustomObjectType);
     }
     convertPrimitiveType(type) {
         switch (type) {
-            case idl.IDLVoidType: return this.make('void', true);
-            case idl.IDLI8Type: return this.make(`Int8`);
-            case idl.IDLU8Type: return this.make(`UInt8`);
-            case idl.IDLI16Type: return this.make(`Int16`);
-            case idl.IDLU16Type: return this.make(`UInt16`);
-            case idl.IDLI32Type: return this.make(`Int32`);
-            case idl.IDLU32Type: return this.make(`UInt32`);
-            case idl.IDLI64Type: return this.make(`Int64`);
-            case idl.IDLU64Type: return this.make(`UInt64`);
-            case idl.IDLF32Type: return this.make(`Float32`);
-            case idl.IDLF64Type: return this.make(`Float64`);
-            case idl.IDLNumberType: return this.make(`Number`);
-            case idl.IDLStringType: return this.make(`String`);
-            case idl.IDLBooleanType: return this.make(`Boolean`);
-            case idl.IDLBigintType: return this.make(`Int64`); // TODO add arbitrary precision numeric type
-            case idl.IDLPointerType: return this.make('NativePointer');
-            case idl.IDLCustomObjectType: return this.make('CustomObject');
+            case idl.IDLThisType: // maybe fix it in another level?
+            case idl.IDLVoidType: return this.make('void', type, true);
+            case idl.IDLI8Type: return this.make(`Int8`, type);
+            case idl.IDLU8Type: return this.make(`UInt8`, type);
+            case idl.IDLI16Type: return this.make(`Int16`, type);
+            case idl.IDLU16Type: return this.make(`UInt16`, type);
+            case idl.IDLI32Type: return this.make(`Int32`, type);
+            case idl.IDLU32Type: return this.make(`UInt32`, type);
+            case idl.IDLI64Type: return this.make(`Int64`, type);
+            case idl.IDLU64Type: return this.make(`UInt64`, type);
+            case idl.IDLF32Type: return this.make(`Float32`, type);
+            case idl.IDLF64Type: return this.make(`Float64`, type);
+            case idl.IDLNumberType: return this.make(`Number`, type);
+            case idl.IDLStringType: return this.make(`String`, type);
+            case idl.IDLBooleanType: return this.make(`Boolean`, type);
+            case idl.IDLBigintType: return this.make(`Int64`, type); // TODO add arbitrary precision numeric type
+            case idl.IDLPointerType: return this.make('NativePointer', type);
+            case idl.IDLCustomObjectType: return this.make('CustomObject', type);
             case idl.IDLUnknownType:
-            case idl.IDLAnyType: return this.make(`Object`);
-            case idl.IDLUndefinedType: return this.make(`Undefined`);
-            case idl.IDLFunctionType: return this.make(`Function`);
-            case idl.IDLDate: return this.make(`Date`);
-            case idl.IDLBufferType: return this.make('Buffer');
-            case idl.IDLPointerType: return this.make('Pointer');
-            case idl.IDLSerializerBuffer: return { text: 'KSerializerBuffer', noPrefix: true };
+            case idl.IDLObjectType:
+            case idl.IDLAnyType: return this.make(`Object`, type);
+            case idl.IDLUndefinedType: return this.make(`Undefined`, type);
+            case idl.IDLFunctionType: return this.make(`Function`, type);
+            case idl.IDLDate: return this.make(`Date`, type);
+            case idl.IDLBufferType: return this.make('Buffer', type);
+            case idl.IDLPointerType: return this.make('Pointer', type);
+            case idl.IDLSerializerBuffer: return this.make('KSerializerBuffer', type, true);
         }
         throw new Error(`Unmapped primitive type ${idl.DebugUtils.debugPrintType(type)}`);
     }

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

@@ -4,7 +4,7 @@ export declare class ETSTypeNameConvertor extends TSTypeNameConvertor {
     convertTypeReference(type: idl.IDLReferenceType): string;
     convertContainer(type: idl.IDLContainerType): string;
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
-    protected productType(decl: idl.IDLInterface, isTuple: boolean, includeFieldNames: boolean): string;
+    protected productType(decl: idl.IDLInterface, args: idl.IDLType[] | undefined, isTuple: boolean, includeFieldNames: boolean): string;
     protected processTupleType(idlProperty: idl.IDLProperty): idl.IDLProperty;
     protected mapCallback(decl: idl.IDLCallback): string;
     protected mapFunctionType(typeArgs: string[]): string;

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

@@ -70,11 +70,11 @@ export class ETSTypeNameConvertor extends TSTypeNameConvertor {
         }
         return super.convertPrimitiveType(type);
     }
-    productType(decl, isTuple, includeFieldNames) {
+    productType(decl, args, isTuple, includeFieldNames) {
         if (decl.subkind === idl.IDLInterfaceSubkind.AnonymousInterface) {
             return decl.name;
         }
-        return super.productType(decl, isTuple, includeFieldNames);
+        return super.productType(decl, args, isTuple, includeFieldNames);
     }
     processTupleType(idlProperty) {
         if (idlProperty.isOptional) {

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

@@ -66,6 +66,7 @@ export class InteropReturnTypeConvertor {
             case idl.IDLThisType:
             case idl.IDLUndefinedType:
             case idl.IDLUnknownType:
+            case idl.IDLObjectType:
             case idl.IDLVoidType: return idl.IDLVoidType.name;
             case idl.IDLBufferType: return KInteropReturnBuffer; /* ArkTS can not return buffer as language object yet */
             case idl.IDLStringType: return PrimitiveTypesInstance.String.getText();

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

@@ -0,0 +1,24 @@
+import * as idl from '../../idl';
+import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
+import { IdlNameConvertor, NodeConvertor } from '../nameConvertor';
+export declare class KotlinTypeNameConvertor implements NodeConvertor<string>, IdlNameConvertor {
+    protected resolver: ReferenceResolver;
+    constructor(resolver: ReferenceResolver);
+    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;
+    convertCallback(node: idl.IDLCallback): string;
+    convertMethod(node: idl.IDLMethod): string;
+    convertConstant(node: idl.IDLConstant): string;
+    convertOptional(type: idl.IDLOptionalType): string;
+    convertUnion(type: idl.IDLUnionType): string;
+    convertContainer(type: idl.IDLContainerType): 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;
+}
+//# sourceMappingURL=KotlinConvertor.d.ts.map

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

@@ -0,0 +1,69 @@
+/*
+ * 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 { convertNode } from '../nameConvertor';
+export class KotlinTypeNameConvertor {
+    constructor(resolver) {
+        this.resolver = resolver;
+    }
+    convert(node) {
+        return convertNode(this, node);
+    }
+    convertNamespace(node) {
+        throw new Error("Not implemented");
+    }
+    convertInterface(node) {
+        throw new Error("Not implemented");
+    }
+    convertEnum(node) {
+        throw new Error("Not implemented");
+    }
+    convertTypedef(node) {
+        throw new Error("Not implemented");
+    }
+    convertCallback(node) {
+        throw new Error("Not implemented");
+    }
+    convertMethod(node) {
+        throw new Error("Not implemented");
+    }
+    convertConstant(node) {
+        throw new Error("Not implemented");
+    }
+    convertOptional(type) {
+        throw new Error("Not implemented");
+    }
+    convertUnion(type) {
+        throw new Error("Not implemented");
+    }
+    convertContainer(type) {
+        throw new Error("Not implemented");
+    }
+    convertImport(type) {
+        throw new Error("Not implemented");
+    }
+    convertTypeReferenceAsImport(type, importClause) {
+        throw new Error("Not implemented");
+    }
+    convertTypeReference(type) {
+        throw new Error("Not implemented");
+    }
+    convertTypeParameter(type) {
+        throw new Error("Not implemented");
+    }
+    convertPrimitiveType(type) {
+        throw new Error("Not implemented");
+    }
+}
+//# sourceMappingURL=KotlinConvertor.js.map

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

@@ -0,0 +1,25 @@
+import * as idl from '../../idl';
+import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
+import { IdlNameConvertor, NodeConvertor } from '../nameConvertor';
+export declare class KotlinTypeNameConvertor implements NodeConvertor<string>, IdlNameConvertor {
+    protected resolver: ReferenceResolver;
+    constructor(resolver: ReferenceResolver);
+    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;
+    convertCallback(node: idl.IDLCallback): string;
+    convertMethod(node: idl.IDLMethod): string;
+    convertConstant(node: idl.IDLConstant): string;
+    convertOptional(type: idl.IDLOptionalType): string;
+    convertUnion(type: idl.IDLUnionType): string;
+    convertContainer(type: idl.IDLContainerType): 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 callbackType;
+}
+//# sourceMappingURL=KotlinConvertors.d.ts.map