@idlizer/core 2.0.26 → 2.0.28

package/build/lib/src/languageSpecificKeywords.js

@@ -38,7 +38,7 @@ export const CJKeywords = new Set([
     /*'false', */ 'static', 'public', 'private',
     'protected', 'override', 'redef', 'abstract',
     'open', 'operator', 'foreign', 'inout',
-    'prop', 'mut', 'unsafe', 'get', 'set'
+    'prop', 'mut', 'unsafe', 'get', 'set', 'type'
 ]);
 export const IDLKeywords = new Set([
     "attribute", "callback", "object", "toString",

package/build/lib/src/library.d.ts

@@ -24,7 +24,7 @@ declare function req<A, R>(key: string, fn: (x: A) => R): LibraryQuery<A, R>;
 declare function compose<B, R>(base: LibraryReducer<B>, next: LibraryQuery<B, R>): LibraryReducer<R>;
 declare function concat<A, R1, R2>(f: LibraryQuery<A, R1>, g: LibraryQuery<A, R2>): LibraryQuery<A, [R1, R2]>;
 declare class LensBuilder<R> {
-    private req;
+    req: LibraryReducer<R>;
     private constructor();
     static make<R>(r: LibraryReducer<R>): LensBuilder<R>;
     pipe<T>(r: LibraryQuery<R, T>): LensBuilder<T>;
@@ -48,13 +48,14 @@ export declare const lib: {
         nodes(params: EntitiesParams): LibraryQuery<readonly IDLFile[], idl.IDLNode[]>;
         entries(): LibraryQuery<idl.IDLNode[], idl.IDLEntry[]>;
         interfaces(): LibraryQuery<idl.IDLNode[], idl.IDLInterface[]>;
+        hasExt<T extends idl.IDLNode>(attr: idl.IDLExtendedAttributes): LibraryQuery<T[], T[]>;
         names(): LibraryQuery<idl.IDLNode[], string[]>;
         name(name: string): LibraryReducer<idl.IDLNode[]>;
     };
     utils: {
-        idx: <T>(x: number) => LibraryQuery<T[], T | undefined>;
-        fst: <T_1>() => LibraryQuery<T_1[], T_1 | undefined>;
-        lst: <T_2>() => LibraryQuery<T_2[], T_2 | undefined>;
+        idx: <T_1>(x: number) => LibraryQuery<T_1[], T_1 | undefined>;
+        fst: <T_2>() => LibraryQuery<T_2[], T_2 | undefined>;
+        lst: <T_3>() => LibraryQuery<T_3[], T_3 | undefined>;
     };
     req: typeof req;
     compose: typeof compose;

package/build/lib/src/library.js

@@ -157,6 +157,9 @@ const select = {
     interfaces() {
         return req('interfaces', it => it.filter(idl.isInterface));
     },
+    hasExt(attr) {
+        return req('with_attr=' + serializeParam(attr), it => it.filter(x => idl.hasExtAttribute(x, attr)));
+    },
     names() {
         return req('names', xs => xs.flatMap(x => idl.isNamedNode(x) ? [x.name] : []));
     },

package/build/lib/src/peer-generation/BuilderClass.js

@@ -32,7 +32,7 @@ export class BuilderClass {
  */
 export function isBuilderClass(declaration) {
     const className = declaration.name;
-    if (generatorConfiguration().param("builderClasses").includes(className)) {
+    if (generatorConfiguration().builderClasses.includes(className)) {
         return true;
     }
     if (isCustomBuilderClass(className)) {

package/build/lib/src/peer-generation/LayoutManager.d.ts

@@ -1,7 +1,8 @@
 import { IDLEntry } from "../idl";
 export declare enum LayoutNodeRole {
     PEER = 0,
-    INTERFACE = 1
+    INTERFACE = 1,
+    GLOBAL = 2
 }
 export interface LayoutManagerStrategy {
     resolve(node: IDLEntry, role: LayoutNodeRole): string;

package/build/lib/src/peer-generation/LayoutManager.js

@@ -16,6 +16,7 @@ export var LayoutNodeRole;
 (function (LayoutNodeRole) {
     LayoutNodeRole[LayoutNodeRole["PEER"] = 0] = "PEER";
     LayoutNodeRole[LayoutNodeRole["INTERFACE"] = 1] = "INTERFACE";
+    LayoutNodeRole[LayoutNodeRole["GLOBAL"] = 2] = "GLOBAL";
 })(LayoutNodeRole || (LayoutNodeRole = {}));
 export class LayoutManager {
     constructor(strategy) {

package/build/lib/src/peer-generation/Materialized.d.ts

@@ -4,7 +4,6 @@ import { Field, Method } from '../LanguageWriters/LanguageWriter';
 import { PeerClassBase } from './PeerClass';
 import { PeerMethod } from './PeerMethod';
 import { ReferenceResolver } from './ReferenceResolver';
-export declare function isMaterialized(declaration: idl.IDLInterface, resolver: ReferenceResolver): boolean;
 export declare class MaterializedField {
     field: Field;
     argConvertor: ArgConvertor;

package/build/lib/src/peer-generation/Materialized.js

@@ -12,42 +12,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { generatorConfiguration } from '../config';
 import * as idl from '../idl';
-import { CppReturnTypeConvertor } from '../LanguageWriters/convertors/CppConvertors';
 import { copyMethod, Method, MethodModifier, NamedMethodSignature } from '../LanguageWriters/LanguageWriter';
 import { capitalize } from '../util';
-import { isBuilderClass } from './BuilderClass';
 import { qualifiedName } from './idl/common';
 import { PeerMethod } from './PeerMethod';
-export function isMaterialized(declaration, resolver) {
-    if (!idl.isInterfaceSubkind(declaration) && !idl.isClassSubkind(declaration))
-        return false;
-    if (idl.isHandwritten(declaration) || isBuilderClass(declaration))
-        return false;
-    for (const forceMaterialized of generatorConfiguration().param("forceMaterialized")) {
-        if (declaration.name == forceMaterialized)
-            return true;
-    }
-    for (const ignore of generatorConfiguration().param("ignoreMaterialized")) {
-        if (declaration.name.endsWith(ignore))
-            return false;
-    }
-    // A materialized class is a class or an interface with methods
-    // excluding components and related classes
-    if (declaration.methods.length > 0 || declaration.constructors.length > 0)
-        return true;
-    // Or a class or an interface derived from materialized class
-    if (idl.hasSuperType(declaration)) {
-        const superType = resolver.resolveTypeReference(idl.getSuperType(declaration));
-        if (!superType || !idl.isInterface(superType)) {
-            console.log(`Unable to resolve ${idl.getSuperType(declaration).name} type, consider ${declaration.name} to be not materialized`);
-            return false;
-        }
-        return isMaterialized(superType, resolver);
-    }
-    return false;
-}
 export class MaterializedField {
     constructor(field, argConvertor, outArgConvertor, isNullableOriginalTypeField) {
         this.field = field;
@@ -76,28 +45,14 @@ export class MaterializedMethod extends PeerMethod {
         }
     }
     dummyReturnValue(resolver) {
-        var _a;
         if (this.method.name === "ctor")
-            return `(${this.originalParentName}Peer*) 100`;
+            return `(Ark_${this.originalParentName}) 100`;
         if (this.method.name === "getFinalizer")
             return `fnPtr<KNativePointer>(dummyClassFinalizer)`;
-        if ((_a = this.method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.STATIC)) {
-            if (this.method.signature.returnType === idl.IDLNumberType) {
-                return '100';
-            }
-            if (this.method.signature.returnType === idl.IDLBooleanType) {
-                return '0';
-            }
-            const convertor = new CppReturnTypeConvertor(resolver);
-            return `(${convertor.convert(this.returnType)}) 300`;
-        }
-        if (idl.isReferenceType(this.method.signature.returnType)) {
-            return "{}";
-        }
         return undefined;
     }
     get receiverType() {
-        return `${this.originalParentName}Peer*`;
+        return `Ark_${this.originalParentName}`;
     }
     get apiCall() {
         return "GetAccessors()";
@@ -110,7 +65,7 @@ export class MaterializedMethod extends PeerMethod {
             return undefined;
         return {
             argName: 'peer',
-            argType: `${this.originalParentName}Peer*`
+            argType: `Ark_${this.originalParentName}`
         };
     }
     getImplementationName() {

package/build/lib/src/peer-generation/PeerFile.d.ts

@@ -8,6 +8,7 @@ export declare class PeerFile implements LibraryFileInterface {
     readonly peers: Map<string, PeerClass>;
     constructor(originalFilename: string, entries: idl.IDLEntry[], isPredefined?: boolean);
     packageName(): string;
+    package(): idl.IDLPackage | undefined;
     get peersToGenerate(): PeerClass[];
 }
 //# sourceMappingURL=PeerFile.d.ts.map

package/build/lib/src/peer-generation/PeerFile.js

@@ -21,7 +21,7 @@ export class PeerFile {
         this.peers = new Map();
     }
     packageName() {
-        let packageTag = this.entries.find(it => idl.isPackage(it));
+        const packageTag = this.package();
         if (packageTag === undefined) {
             return "";
         }
@@ -30,6 +30,9 @@ export class PeerFile {
         }
         return packageTag.name;
     }
+    package() {
+        return this.entries.find(it => idl.isPackage(it));
+    }
     get peersToGenerate() {
         const peers = Array.from(this.peers.values());
         return peers;