porffor 0.56.6 → 0.56.8

package/compiler/codegen.js

@@ -351,6 +351,10 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
     case 'TSAsExpression':
       return cacheAst(decl, generate(scope, decl.expression));
 
+    case 'WithStatement':
+      if (Prefs.d) log.warning('codegen', 'with is not supported, treating as expression');
+      return cacheAst(decl, generate(scope, decl.body));
+
     default:
       // ignore typescript nodes
       if (decl.type.startsWith('TS') ||
@@ -3196,6 +3200,7 @@ const setDefaultFuncName = (decl, name) => {
 const generateVarDstr = (scope, kind, pattern, init, defaultValue, global) => {
   // statically analyzed ffi dlopen hack to let 2c handle it
   if (init && init.type === 'CallExpression' && init.callee.name === '__Porffor_dlopen') {
+    if (Prefs.secure) throw new Error('Porffor.dlopen is not allowed in --secure');
     if (Prefs.target !== 'native' && Prefs.target !== 'c' && !Prefs.native) throw new Error('Porffor.dlopen is only supported for native target (use --native)');
 
     // disable pgo if using ffi (lol)
@@ -6404,6 +6409,7 @@ const generateTaggedTemplate = (scope, decl, global = false, name = undefined, v
     },
 
     __Porffor_c: str => {
+      if (Prefs.secure) throw new Error('Porffor.c is not allowed in --secure');
       return [
         [ null, 'c', str ]
       ];

package/optional-chaining-tests.js

@@ -0,0 +1,335 @@
+// Optional Chaining Tests
+// This file tests all major features of the optional chaining operator (?.)
+
+// Test utility function
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error('Assertion failed: ' + message);
+  }
+  return true;
+}
+
+// BASIC OBJECT PROPERTY ACCESS TESTS
+console.log('\n=== Basic Object Property Access ===');
+
+// Test 1: Basic property access with existing property
+(function() {
+  const obj = { a: 1 };
+  assert(obj?.a === 1, 'Basic property access failed');
+  console.log('✓ Basic property access with existing property');
+})();
+
+// Test 2: Basic property access with undefined object
+(function() {
+  const obj = undefined;
+  assert(obj?.a === undefined, 'Optional chaining with undefined object failed');
+  console.log('✓ Basic property access with undefined object');
+})();
+
+// Test 3: Basic property access with null object
+(function() {
+  const obj = null;
+  assert(obj?.a === undefined, 'Optional chaining with null object failed');
+  console.log('✓ Basic property access with null object');
+})();
+
+// NESTED PROPERTY ACCESS TESTS
+console.log('\n=== Nested Property Access ===');
+
+// Test 4: Nested property access with all properties existing
+(function() {
+  const obj = { a: { b: { c: 42 } } };
+  assert(obj?.a?.b?.c === 42, 'Nested property access failed');
+  console.log('✓ Nested property access with all properties existing');
+})();
+
+// Test 5: Nested property access with missing intermediate property
+(function() {
+  const obj = { a: {} };
+  assert(obj?.a?.b?.c === undefined, 'Nested property access with missing intermediate property failed');
+  console.log('✓ Nested property access with missing intermediate property');
+})();
+
+// Test 6: Nested property access with null intermediate property
+(function() {
+  const obj = { a: { b: null } };
+  assert(obj?.a?.b?.c === undefined, 'Nested property access with null intermediate property failed');
+  console.log('✓ Nested property access with null intermediate property');
+})();
+
+// METHOD CALL TESTS
+console.log('\n=== Method Call Tests ===');
+
+// Test 7: Method call on existing method
+(function() {
+  const obj = {
+    method: function() { return 'result'; }
+  };
+  assert(obj?.method?.() === 'result', 'Method call on existing method failed');
+  console.log('✓ Method call on existing method');
+})();
+
+// Test 8: Method call on undefined object
+(function() {
+  const obj = undefined;
+  assert(obj?.method?.() === undefined, 'Method call on undefined object failed');
+  console.log('✓ Method call on undefined object');
+})();
+
+// Test 9: Method call on null method
+(function() {
+  const obj = { method: null };
+  assert(obj?.method?.() === undefined, 'Method call on null method failed');
+  console.log('✓ Method call on null method');
+})();
+
+// Test 10: Method call on undefined method
+(function() {
+  const obj = {};
+  assert(obj?.method?.() === undefined, 'Method call on undefined method failed');
+  console.log('✓ Method call on undefined method');
+})();
+
+// ARRAY ELEMENT ACCESS TESTS
+console.log('\n=== Array Element Access ===');
+
+// Test 11: Array element access with valid index
+(function() {
+  const arr = [1, 2, 3];
+  assert(arr?.[1] === 2, 'Array element access with valid index failed');
+  console.log('✓ Array element access with valid index');
+})();
+
+// Test 12: Array element access with undefined array
+(function() {
+  const arr = undefined;
+  assert(arr?.[1] === undefined, 'Array element access with undefined array failed');
+  console.log('✓ Array element access with undefined array');
+})();
+
+// Test 13: Array element access with null array
+(function() {
+  const arr = null;
+  assert(arr?.[1] === undefined, 'Array element access with null array failed');
+  console.log('✓ Array element access with null array');
+})();
+
+// Test 14: Access array method with optional chaining
+(function() {
+  const arr = [1, 2, 3];
+  assert(arr?.map(x => x * 2)?.[0] === 2, 'Access array method with optional chaining failed');
+  console.log('✓ Access array method with optional chaining');
+})();
+
+// MIXED SYNTAX TESTS
+console.log('\n=== Mixed Syntax Tests ===');
+
+// Test 15: Mix of array and object property access
+(function() {
+  const obj = { arr: [{ val: 42 }] };
+  assert(obj?.arr?.[0]?.val === 42, 'Mix of array and object property access failed');
+  console.log('✓ Mix of array and object property access');
+})();
+
+// Test 16: Method returning object with property
+(function() {
+  const obj = {
+    getObject: function() { return { prop: 'value' }; }
+  };
+  assert(obj?.getObject?.()?.prop === 'value', 'Method returning object with property failed');
+  console.log('✓ Method returning object with property');
+})();
+
+// Test 17: Object with method returning array
+(function() {
+  const obj = {
+    getArray: function() { return [1, 2, 3]; }
+  };
+  assert(obj?.getArray?.()?.[1] === 2, 'Object with method returning array failed');
+  console.log('✓ Object with method returning array');
+})();
+
+// COMPLEX EXPRESSIONS AND EDGE CASES
+console.log('\n=== Complex Expressions and Edge Cases ===');
+
+// Test 18: Optional chaining with function arguments
+(function() {
+  const obj = {
+    method: function(a, b) { return a + b; }
+  };
+  assert(obj?.method?.(1, 2) === 3, 'Optional chaining with function arguments failed');
+  console.log('✓ Optional chaining with function arguments');
+})();
+
+// Test 19: Optional chaining in expressions
+(function() {
+  const obj = { a: 5 };
+  assert((obj?.a + 5) === 10, 'Optional chaining in expressions failed');
+  console.log('✓ Optional chaining in expressions');
+})();
+
+// Test 20: Optional chaining with property names containing special characters
+(function() {
+  const obj = { 'special-prop': 42 };
+  assert(obj?.['special-prop'] === 42, 'Optional chaining with property names containing special characters failed');
+  console.log('✓ Optional chaining with property names containing special characters');
+})();
+
+// Test 21: Optional chaining with computed property names
+(function() {
+  const key = 'dynamicKey';
+  const obj = { dynamicKey: 'dynamic value' };
+  assert(obj?.[key] === 'dynamic value', 'Optional chaining with computed property names failed');
+  console.log('✓ Optional chaining with computed property names');
+})();
+
+// Test 22: Optional chaining with Symbol properties
+(function() {
+  const sym = Symbol('test');
+  const obj = {};
+  obj[sym] = 'symbol value';
+  assert(obj?.[sym] === 'symbol value', 'Optional chaining with Symbol properties failed');
+  console.log('✓ Optional chaining with Symbol properties');
+})();
+
+// Test 23: Optional chaining with object returned from function
+(function() {
+  function getObject(returnValue) {
+    return returnValue ? { prop: 'exists' } : null;
+  }
+  assert(getObject(true)?.prop === 'exists', 'Optional chaining with object returned from function (true case) failed');
+  assert(getObject(false)?.prop === undefined, 'Optional chaining with object returned from function (false case) failed');
+  console.log('✓ Optional chaining with object returned from function');
+})();
+
+// Test 24: Optional chaining with prototype chain
+(function() {
+  const proto = { inheritedProp: 'inherited' };
+  const obj = Object.create(proto);
+  assert(obj?.inheritedProp === 'inherited', 'Optional chaining with prototype chain failed');
+  console.log('✓ Optional chaining with prototype chain');
+})();
+
+// Test 25: Optional chaining with getters
+(function() {
+  const obj = {
+    get prop() { return 'getter value'; }
+  };
+  assert(obj?.prop === 'getter value', 'Optional chaining with getters failed');
+  console.log('✓ Optional chaining with getters');
+})();
+
+// SHORT-CIRCUIT EVALUATION TESTS
+console.log('\n=== Short-circuit Evaluation Tests ===');
+
+// Test 26: Short-circuit evaluation - should not call function after undefined
+(function() {
+  let functionCalled = false;
+  const obj = undefined;
+
+  function sideEffect() {
+    functionCalled = true;
+    return 'side effect';
+  }
+
+  obj?.prop?.[sideEffect()];
+  assert(functionCalled === false, 'Short-circuit evaluation failed - function called when it should not have been');
+  console.log('✓ Short-circuit evaluation - function not called after undefined');
+})();
+
+// Test 27: Non-short-circuit evaluation - should call function when property exists
+(function() {
+  let functionCalled = false;
+  const obj = { prop: {} };
+
+  function sideEffect() {
+    functionCalled = true;
+    return 'key';
+  }
+
+  obj?.prop?.[sideEffect()];
+  assert(functionCalled === true, 'Non-short-circuit evaluation failed - function not called when it should have been');
+  console.log('✓ Non-short-circuit evaluation - function called when property exists');
+})();
+
+// ASSIGNMENT AND DESTRUCTURING TESTS
+console.log('\n=== Assignment and Destructuring Tests ===');
+
+// Test 28: Optional chaining in destructuring
+(function() {
+  const obj = { nested: { value: 42 } };
+  const { nested: { value } = {} } = obj ?? {};
+  assert(value === 42, 'Optional chaining in destructuring failed');
+  console.log('✓ Optional chaining in destructuring');
+})();
+
+// Test 29: Optional chaining with the nullish coalescing operator
+(function() {
+  const obj = null;
+  const value = obj?.prop ?? 'default';
+  assert(value === 'default', 'Optional chaining with nullish coalescing operator failed');
+  console.log('✓ Optional chaining with nullish coalescing operator');
+})();
+
+// Test 30: Optional chaining in logical expressions
+(function() {
+  const obj = { prop: true };
+  const nullObj = null;
+
+  assert((obj?.prop && 'yes') === 'yes', 'Optional chaining in logical AND expression failed');
+  assert((nullObj?.prop && 'yes') === undefined, 'Optional chaining in logical AND expression with null failed');
+  assert((obj?.prop || 'fallback') === true, 'Optional chaining in logical OR expression failed');
+  assert((nullObj?.prop || 'fallback') === 'fallback', 'Optional chaining in logical OR expression with null failed');
+
+  console.log('✓ Optional chaining in logical expressions');
+})();
+
+// PERFORMANCE EDGE CASES
+console.log('\n=== Performance Edge Cases ===');
+
+// Test 31: Deep nesting - many levels
+(function() {
+  const obj = { a: { b: { c: { d: { e: { f: { g: { h: { i: { j: 'deep' } } } } } } } } } };
+  assert(obj?.a?.b?.c?.d?.e?.f?.g?.h?.i?.j === 'deep', 'Deep nesting optional chaining failed');
+  console.log('✓ Deep nesting - many levels');
+})();
+
+// Test 32: Complex real-world scenario
+(function() {
+  const data = {
+    user: {
+      profile: {
+        name: 'John',
+        address: {
+          city: 'New York',
+          zipcode: '10001'
+        }
+      },
+      preferences: {
+        theme: 'dark',
+        notifications: {
+          email: true,
+          sms: false
+        }
+      },
+      friends: [
+        { id: 1, name: 'Alice' },
+        { id: 2, name: 'Bob' }
+      ]
+    }
+  };
+
+  // Multiple complex optional chaining expressions
+  assert(data?.user?.profile?.name === 'John', 'Complex scenario - user name test failed');
+  assert(data?.user?.profile?.address?.city === 'New York', 'Complex scenario - address city test failed');
+  assert(data?.user?.preferences?.notifications?.email === true, 'Complex scenario - notifications email test failed');
+  assert(data?.user?.friends?.[1]?.name === 'Bob', 'Complex scenario - friends name test failed');
+  assert(data?.user?.nonexistent?.something === undefined, 'Complex scenario - nonexistent property test failed');
+
+  console.log('✓ Complex real-world scenario');
+})();
+
+// SUMMARY
+console.log('\n=== Test Summary ===');
+console.log('All tests completed successfully!');
+console.log('Total tests: 32');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "An ahead-of-time JavaScript compiler",
-  "version": "0.56.6",
+  "version": "0.56.8",
   "author": "Oliver Medhurst <honk@goose.icu>",
   "license": "MIT",
   "scripts": {},

package/runner/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
-globalThis.version = '0.56.6';
+globalThis.version = '0.56.8';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {