nginx-lint-plugin 0.10.4 → 0.10.5

package/README.md

@@ -122,7 +122,7 @@ The WIT definition file is bundled with this package, so `jco componentize` can
     "test": "tsc && node --test dist/plugin.test.js"
   },
   "dependencies": {
-    "nginx-lint-plugin": "^0.10.4"
+    "nginx-lint-plugin": "^0.10.5"
   },
   "devDependencies": {
     "@bytecodealliance/componentize-js": "^0.19",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nginx-lint-plugin",
-  "version": "0.10.4",
+  "version": "0.10.5",
   "type": "module",
   "license": "MIT",
   "repository": {

package/wasm/parser/parser.js

@@ -1,4 +1,4 @@
-"use jco";
+"use components";
 
 function promiseWithResolvers() {
   if (Promise.withResolvers) {
@@ -13,8 +13,9 @@ function promiseWithResolvers() {
     return { promise, resolve, reject };
   }
 }
-
 const symbolDispose = Symbol.dispose || Symbol.for('dispose');
+const symbolAsyncIterator = Symbol.asyncIterator;
+const symbolIterator = Symbol.iterator;
 
 const _debugLog = (...args) => {
   if (!globalThis?.process?.env?.JCO_DEBUG) { return; }
@@ -109,7 +110,7 @@ async function _clearCurrentTask(args) {
   const { taskID, componentIdx } = args;
   
   const meta = CURRENT_TASK_META[componentIdx];
-  if (!meta) { throw new Error(`missing current task meta for component idx [${componentIdx}]`); }
+  if (!meta) { throw new Error(`missing current task meta for component idx [${componentIdx}]n`); }
   
   if (meta.taskID !== taskID) {
     throw new Error(`task ID [${meta.taskID}] != requested ID [${taskID}]`);
@@ -217,13 +218,54 @@ const _coinFlip = () => { return Math.random() > 0.5; };
 let SCOPE_ID = 0;
 const I32_MIN = -2_147_483_648;
 const I32_MAX = 2_147_483_647;
+
+function _isValidNumericPrimitive(ty, v) {
+  if (v === undefined || v === null) { return false; }
+  switch (ty) {
+    case 'bool':
+    return v === 0 || v === 1;
+    break;
+    case 'u8':
+    return v >= 0 && v <= 255;
+    break;
+    case 's8':
+    return v >= -128 && v <= 127;
+    break;
+    case 'u16':
+    return v >= 0 && v <= 65535;
+    break;
+    case 's16':
+    return v >= -32768 && v <= 32767;
+    case 'u32':
+    return v >= 0 && v <= 4_294_967_295;
+    case 's32':
+    return v >= -2_147_483_648 && v <= 2_147_483_647;
+    case 'u64':
+    return typeof v === 'bigint' && v >= 0 && v <= 18_446_744_073_709_551_615n;
+    case 's64':
+    return typeof v === 'bigint' && v >= -9223372036854775808n && v <= 9223372036854775807n;
+    break;
+    case 'f32':
+    case 'f64': return typeof v === 'number';
+    default:
+    return false;
+  }
+  return true;
+}
+
+function _requireValidNumericPrimitive(ty, v) {
+  if (v === undefined  || v === null || !_isValidNumericPrimitive(ty, v)) {
+    throw new TypeError(`invalid ${ty} value [${v}]`);
+  }
+  return true;
+}
 const _typeCheckValidI32 = (n) => typeof n === 'number' && n >= I32_MIN && n <= I32_MAX;
 
 const _typeCheckAsyncFn= (f) => {
   return f instanceof ASYNC_FN_CTOR;
 };
 
-const ASYNC_FN_CTOR = (async () => {}).constructor;
+let RESOURCE_CALL_BORROWS = [];const ASYNC_FN_CTOR = (async () => {}).constructor;
 
 function clearCurrentTask(componentIdx, taskID) {
   _debugLog('[clearCurrentTask()] args', { componentIdx, taskID });
@@ -512,6 +554,7 @@ class AsyncSubtask {
           realloc,
           vals: [subtaskValue],
           storagePtr: resultPtr,
+          stringEncoding: callMetadata.stringEncoding,
         });
       }
     }
@@ -701,6 +744,7 @@ resultCountOrAsync,
       resultPtr,
       returnFn,
       startFn,
+      stringEncoding,
     }
   });
   
@@ -866,7 +910,8 @@ function _asyncStartCall(args, callee, paramCount, resultCount, flags) {
       memory: callerMemory,
       vals: [res],
       storagePtr: subtaskCallMeta.resultPtr,
-      componentIdx: callerComponentIdx
+      componentIdx: callerComponentIdx,
+      stringEncoding: subtaskCallMeta.stringEncoding,
     });
     
   });
@@ -2156,9 +2201,48 @@ class ComponentAsyncState {
     return new Waitable({ target: args?.target, });
   }
   
+  createReadableStreamEnd(args) {
+    _debugLog('[ComponentAsyncState#createStreamEnd()] args', args);
+    const { tableIdx, elemMeta, hostInjectFn } = args;
+    
+    const { table: localStreamTable, componentIdx } = STREAM_TABLES[tableIdx];
+    if (!localStreamTable) {
+      throw new Error(`missing global stream table lookup for table [${tableIdx}] while creating stream`);
+    }
+    if (componentIdx !== this.#componentIdx) {
+      throw new Error('component idx mismatch while creating stream');
+    }
+    
+    const waitable = this.createWaitable();
+    const streamEnd = new StreamReadableEnd({
+      tableIdx,
+      elemMeta,
+      hostInjectFn,
+      pendingBufferMeta: {},
+      target: `stream read end (lowered, @init)`,
+      waitable,
+    });
+    
+    streamEnd.setWaitableIdx(this.handles.insert(streamEnd));
+    streamEnd.setHandle(localStreamTable.insert(streamEnd));
+    if (streamEnd.streamTableIdx() !== tableIdx) {
+      throw new Error("unexpectedly mismatched stream table");
+    }
+    const streamEndWaitableIdx = streamEnd.waitableIdx();
+    const streamEndHandle = streamEnd.handle();
+    waitable.setTarget(`waitable for stream read end (lowered, waitable [${streamEndWaitableIdx}])`);
+    streamEnd.setTarget(`stream read end (lowered, waitable [${streamEndWaitableIdx}])`);
+    
+    return {
+      waitableIdx: streamEndWaitableIdx,
+      handle: streamEndHandle,
+      streamEnd,
+    };
+  }
+  
   createStream(args) {
     _debugLog('[ComponentAsyncState#createStream()] args', args);
-    const { tableIdx, elemMeta } = args;
+    const { tableIdx, elemMeta, hostInjectFn } = args;
     if (tableIdx === undefined) { throw new Error("missing table idx while adding stream"); }
     if (elemMeta === undefined) { throw new Error("missing element metadata while adding stream"); }
     
@@ -2175,10 +2259,10 @@ class ComponentAsyncState {
     
     const stream = new InternalStream({
       tableIdx,
-      componentIdx: this.#componentIdx,
       elemMeta,
       readWaitable,
       writeWaitable,
+      hostInjectFn,
     });
     stream.setGlobalStreamMapRep(STREAMS.insert(stream));
     
@@ -2203,17 +2287,21 @@ class ComponentAsyncState {
     readEnd.setTarget(`stream read end (waitable [${readEndWaitableIdx}])`);
     
     return {
+      writeEnd,
       writeEndWaitableIdx,
       writeEndHandle,
       readEndWaitableIdx,
       readEndHandle,
+      readEnd,
     };
   }
   
   getStreamEnd(args) {
     _debugLog('[ComponentAsyncState#getStreamEnd()] args', args);
     const { tableIdx, streamEndHandle, streamEndWaitableIdx } = args;
-    if (tableIdx === undefined) { throw new Error('missing table idx while getting stream end'); }
+    if (tableIdx === undefined) {
+      throw new Error('missing table idx while getting stream end');
+    }
     
     const { table, componentIdx } = STREAM_TABLES[tableIdx];
     const cstate = getOrCreateAsyncState(componentIdx);
@@ -2300,6 +2388,127 @@ class ComponentAsyncState {
     
     return streamEnd;
   }
+  
+  createFuture(args) {
+    _debugLog('[ComponentAsyncState#createFuture()] args', args);
+    const { tableIdx, elemMeta, hostInjectFn } = args;
+    if (tableIdx === undefined) { throw new Error("missing table idx while adding future"); }
+    if (elemMeta === undefined) { throw new Error("missing element metadata while adding future"); }
+    
+    const { table: futureTable, componentIdx } = FUTURE_TABLES[tableIdx];
+    if (!futureTable) {
+      throw new Error(`missing global future table lookup for table [${tableIdx}] while creating future`);
+    }
+    if (componentIdx !== this.#componentIdx) {
+      throw new Error('component idx mismatch while creating future');
+    }
+    
+    const readWaitable = this.createWaitable();
+    const writeWaitable = this.createWaitable();
+    
+    const future = new InternalFuture({
+      tableIdx,
+      componentIdx: this.#componentIdx,
+      elemMeta,
+      readWaitable,
+      writeWaitable,
+      hostInjectFn,
+    });
+    future.setGlobalFutureMapRep(FUTURES.insert(future));
+    
+    const writeEnd = future.writeEnd();
+    writeEnd.setWaitableIdx(this.handles.insert(writeEnd));
+    writeEnd.setHandle(futureTable.insert(writeEnd));
+    if (writeEnd.futureTableIdx() !== tableIdx) { throw new Error("unexpectedly mismatched future table"); }
+    
+    const writeEndWaitableIdx = writeEnd.waitableIdx();
+    const writeEndHandle = writeEnd.handle();
+    writeWaitable.setTarget(`waitable for future write end (waitable [${writeEndWaitableIdx}])`);
+    writeEnd.setTarget(`future write end (waitable [${writeEndWaitableIdx}])`);
+    
+    const readEnd = future.readEnd();
+    readEnd.setWaitableIdx(this.handles.insert(readEnd));
+    readEnd.setHandle(futureTable.insert(readEnd));
+    if (readEnd.futureTableIdx() !== tableIdx) { throw new Error("unexpectedly mismatched future table"); }
+    
+    const readEndWaitableIdx = readEnd.waitableIdx();
+    const readEndHandle = readEnd.handle();
+    readWaitable.setTarget(`waitable for read end (waitable [${readEndWaitableIdx}])`);
+    readEnd.setTarget(`future read end (waitable [${readEndWaitableIdx}])`);
+    
+    return {
+      writeEnd,
+      writeEndWaitableIdx,
+      writeEndHandle,
+      readEndWaitableIdx,
+      readEndHandle,
+      readEnd,
+    };
+  }
+  
+  getFutureEnd(args) {
+    _debugLog('[ComponentAsyncState#getFutureEnd()] args', args);
+    const { tableIdx, futureEndHandle, futureEndWaitableIdx } = args;
+    if (tableIdx === undefined) {
+      throw new Error('missing table idx while getting future end');
+    }
+    
+    const { table, componentIdx } = FUTURE_TABLES[tableIdx];
+    const cstate = getOrCreateAsyncState(componentIdx);
+    
+    let futureEnd;
+    if (futureEndWaitableIdx !== undefined) {
+      futureEnd = cstate.handles.get(futureEndWaitableIdx);
+    } else if (futureEndHandle !== undefined) {
+      if (!table) { throw new Error(`missing/invalid table [${tableIdx}] while getting future end`); }
+      futureEnd = table.get(futureEndHandle);
+    } else {
+      throw new TypeError("must specify either waitable idx or handle to retrieve future");
+    }
+    
+    if (!futureEnd) {
+      throw new Error(`missing future end (tableIdx [${tableIdx}], handle [${futureEndHandle}], waitableIdx [${futureEndWaitableIdx}])`);
+    }
+    if (tableIdx && futureEnd.futureTableIdx() !== tableIdx) {
+      throw new Error(`future end table idx [${futureEnd.futureTableIdx()}] does not match [${tableIdx}]`);
+    }
+    
+    return futureEnd;
+  }
+  
+  removeFutureEndFromTable(args) {
+    _debugLog('[ComponentAsyncState#removeFutureEndFromTable()] args', args);
+    
+    const { tableIdx, futureWaitableIdx } = args;
+    if (tableIdx === undefined) { throw new Error("missing table idx while removing future end"); }
+    if (futureWaitableIdx === undefined) {
+      throw new Error("missing future end waitable idx while removing future end");
+    }
+    
+    const { table, componentIdx } = FUTURE_TABLES[tableIdx];
+    if (!table) { throw new Error(`missing/invalid table [${tableIdx}] while removing future end`); }
+    
+    const cstate = getOrCreateAsyncState(componentIdx);
+    
+    const futureEnd = cstate.handles.get(futureWaitableIdx);
+    if (!futureEnd) {
+      throw new Error(`missing future end (handle [${futureWaitableIdx}], table [${tableIdx}])`);
+    }
+    const handle = futureEnd.handle();
+    
+    let removed = cstate.handles.remove(futureWaitableIdx);
+    if (!removed) {
+      throw new Error(`failed to remove futureEnd from handles (waitable idx [${futureWaitableIdx}]), component [${componentIdx}])`);
+    }
+    
+    removed = table.remove(handle);
+    if (!removed) {
+      throw new Error(`failed to remove futureEnd from table (handle [${handle}]), table [${tableIdx}], component [${componentIdx}])`);
+    }
+    
+    return futureEnd;
+  }
+  
 }
 
 const isNode = typeof process !== 'undefined' && process.versions && process.versions.node;
@@ -2320,6 +2529,8 @@ class ComponentError extends Error {
   }
 }
 
+const isLE = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
+
 function throwInvalidBool() {
   throw new TypeError('invalid variant discriminant for bool');
 }