porffor 0.56.8 → 0.57.1

package/compiler/codegen.js

@@ -1322,7 +1322,7 @@ const asmFuncToAsm = (scope, func, extra) => func(scope, {
   allocPage: (scope, name) => allocPage({ scope, pages }, name)
 }, extra);
 
-const asmFunc = (name, { wasm, params = [], typedParams = false, locals: localTypes = [], globals: globalTypes = [], globalInits = [], returns = [], returnType, localNames = [], globalNames = [], table = false, constr = false, hasRestArgument = false, usesTag = false, usesImports = false, usedTypes = [] } = {}) => {
+const asmFunc = (name, { wasm, params = [], typedParams = false, locals: localTypes = [], globals: globalTypes = [], globalInits = [], returns = [], returnType, localNames = [], globalNames = [], table = false, constr = false, hasRestArgument = false, usesTag = false, usesImports = false, returnTypes } = {}) => {
   if (wasm == null) { // called with no built-in
     log.warning('codegen', `${name} has no built-in!`);
     wasm = [];
@@ -1379,7 +1379,12 @@ const asmFunc = (name, { wasm, params = [], typedParams = false, locals: localTy
 
   if (table) funcs.table = true;
   if (usesTag) ensureTag();
-  for (const x of usedTypes) typeUsed(func, x);
+
+  if (returnTypes) {
+    for (const x of returnTypes) typeUsed(func, x);
+  } else if (returnType != null) {
+    typeUsed(func, returnType);
+  }
 
   func.wasm = wasm;
   return func;
@@ -1752,7 +1757,7 @@ const getNodeType = (scope, node) => {
   const out = typeof ret === 'number' ? [ number(ret, Valtype.i32) ] : ret;
   if (guess != null) out.guess = typeof guess === 'number' ? [ number(guess, Valtype.i32) ] : guess;
 
-  typeUsed(scope, knownType(scope, out));
+  if (!node._doNotMarkTypeUsed) typeUsed(scope, knownType(scope, out));
   return out;
 };
 
@@ -2654,7 +2659,8 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       args = args.slice(0, paramCount - 1);
       args.push({
         type: 'ArrayExpression',
-        elements: restArgs
+        elements: restArgs,
+        _doNotMarkTypeUsed: true
       });
     }
   }
@@ -3015,10 +3021,14 @@ const typeSwitch = (scope, type, bc, returns = valtypeBinary, fallthrough = fals
     };
 
     if (globalThis.precompile) {
-      // just magic precompile things™
-      out.push([ null, 'typeswitch case start', types ]);
-      add();
-      out.push([ null, 'typeswitch case end' ]);
+      if (scope.usedTypes && types.some(x => scope.usedTypes.has(x))) {
+        add();
+      } else {
+        // just magic precompile things™
+        out.push([ null, 'typeswitch case start', types ]);
+        add();
+        out.push([ null, 'typeswitch case end' ]);
+      }
     } else {
       if (types.some(x => usedTypes.has(x))) {
         // type already used, just add it now
@@ -3135,7 +3145,7 @@ const extractTypeAnnotation = decl => {
   let a = decl;
   while (a.typeAnnotation) a = a.typeAnnotation;
 
-  let type = null, elementType = null;
+  let types = null, type = null, elementType = null;
   if (a.typeName) {
     type = a.typeName.name;
   } else if (a.type.endsWith('Keyword')) {
@@ -3144,12 +3154,16 @@ const extractTypeAnnotation = decl => {
   } else if (a.type === 'TSArrayType') {
     type = 'array';
     elementType = extractTypeAnnotation(a.elementType).type;
+  } else if (a.type === 'TSUnionType') {
+    types = a.types.map(x => extractTypeAnnotation(x).type);
   }
 
   const typeName = type;
   type = typeAnnoToPorfType(type);
 
-  return { type, typeName, elementType };
+  if (!types && type != null) types = [ type ];
+
+  return { type, types, typeName, elementType };
 };
 
 const setLocalWithType = (scope, name, isGlobal, decl, tee = false, overrideType = undefined) => {
@@ -5099,6 +5113,10 @@ const generateSwitch = (scope, decl) => {
     if (canTypeCheck) {
       depth.push('switch_typeswitch');
 
+      // temporarily stub scope used types to have none always included for these cases
+      const usedTypes = scope.usedTypes;
+      scope.usedTypes = { add: () => {}, has: () => false };
+
       const out = typeSwitch(scope, getNodeType(scope, decl.discriminant.arguments[0]), () => {
         const bc = [];
         let types = [];
@@ -5114,6 +5132,8 @@ const generateSwitch = (scope, decl) => {
         return bc;
       }, Blocktype.void, true);
 
+      scope.usedTypes = usedTypes;
+
       depth.pop();
       out.push(number(UNDEFINED));
       return out;
@@ -6602,6 +6622,8 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
           const typeAnno = extractTypeAnnotation(type);
           addVarMetadata(func, name, false, typeAnno);
 
+          if (typeAnno.types) for (const x of typeAnno.types) typeUsed(func, x);
+
           // automatically add throws if unexpected this type to builtins
           if (globalThis.precompile && i === 0 && func.name.includes('_prototype_') && !func.name.startsWith('__Porffor_')) {
             if (typeAnno.type === TYPES.array) {
@@ -6707,6 +6729,7 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
         // make out generator local
         allocVar(func, '#generator_out', false, false);
         typeUsed(func, func.async ? TYPES.__porffor_asyncgenerator : TYPES.__porffor_generator);
+        if (func.async) typeUsed(func, TYPES.promise);
       }
 
       if (func.async && !func.generator) {
@@ -6788,11 +6811,15 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
   funcs.push(func);
 
   if (typedInput && decl.returnType) {
-    const { type } = extractTypeAnnotation(decl.returnType);
+    const { type, types } = extractTypeAnnotation(decl.returnType);
+
     if (type != null) {
       typeUsed(func, type);
       func.returnType = type;
       func.returns = func.returnType === TYPES.undefined && !func.async && !func.generator ? [] : [ valtypeBinary ];
+    } else if (types != null) {
+      func.returnTypes = types;
+      for (const x of types) typeUsed(func, x);
     }
   }
 
@@ -6836,7 +6863,7 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
         break;
     }
 
-    args.push({ name, def, destr, type: typedInput && params[i].typeAnnotation });
+    args.push({ name, def, destr, type: typedInput && x.typeAnnotation });
   }
 
   func.params = new Array((params.length + (func.constr ? 2 : (func.method ? 1 : 0))) * 2).fill(0).map((_, i) => i % 2 ? Valtype.i32 : valtypeBinary);

package/compiler/precompile.js

@@ -260,13 +260,11 @@ ${funcs.map(x => {
   // todo: check for other identifier unsafe characters
   const name = x.name.includes('#') ? `['${x.name}']` : `.${x.name}`;
 
-  const usedTypes = [...(x.usedTypes ?? [])].filter(x => ![ TYPES.empty, TYPES.undefined, TYPES.number, TYPES.boolean, TYPES.function ].includes(x));
-
+  const returnTypes = [...(x.returnTypes ?? [])].filter(x => ![ TYPES.empty, TYPES.undefined, TYPES.number, TYPES.boolean, TYPES.function ].includes(x));
   return `this${name} = {
 wasm:${rewriteWasm(x.wasm)},
-params:${JSON.stringify(x.params)},typedParams:1,returns:${JSON.stringify(x.returns)},${x.returnType != null ? `returnType:${JSON.stringify(x.returnType)},` : ''}
+params:${JSON.stringify(x.params)},typedParams:1,returns:${JSON.stringify(x.returns)},${x.returnType != null ? `returnType:${JSON.stringify(x.returnType)},` : ''}${returnTypes.length > 0 ? `returnTypes:${JSON.stringify(returnTypes)},` : ''}
 locals:${JSON.stringify(locals.slice(x.params.length).map(x => x[1].type))},localNames:${JSON.stringify(locals.map(x => x[0]))},
-${usedTypes.length > 0 ? `usedTypes:${JSON.stringify(usedTypes)},` : ''}
 ${x.globalInits ? `globalInits:{${Object.keys(x.globalInits).map(y => `${y}:${rewriteWasm(x.globalInits[y])}`).join(',')}},` : ''}${x.data && Object.keys(x.data).length > 0 ? `data:${JSON.stringify(x.data)},` : ''}
 ${x.table ? `table:1,` : ''}${x.constr ? `constr:1,` : ''}${x.hasRestArgument ? `hasRestArgument:1,` : ''}${x.usesTag ? `usesTag:1,` : ''}${x.usesImports ? `usesImports:1,` : ''}
 }`.replaceAll('\n\n', '\n').replaceAll('\n\n', '\n').replaceAll('\n\n', '\n');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "An ahead-of-time JavaScript compiler",
-  "version": "0.56.8",
+  "version": "0.57.1",
   "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.8';
+globalThis.version = '0.57.1';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {
@@ -46,9 +46,11 @@ if (process.argv.includes('--help') || process.argv.includes('-h')) {
   // flags
   console.log(`\n\x1B[1m\x1B[4mFlags\x1B[0m`);
   for (let [ flag, desc ] of Object.entries({
+    'On': 'Optimization level, use -O(0|\x1B[1m1\x1B[0m|2|3)',
+    t: 'Force parsing input as TypeScript',
+    d: 'Debug mode (include names in Wasm and debug logs)',
     module: 'Parse input as a module',
-    t: 'Force TypeScript input',
-    d: 'Debug mode (include names in Wasm and debug logs)'
+    secure: 'Secure mode (error on unsafe Porffor features eg FFI)'
   })) {
     flag = '-' + flag;
     if (flag.length > 3) flag = '-' + flag;
@@ -57,10 +59,10 @@ if (process.argv.includes('--help') || process.argv.includes('-h')) {
   }
 
   // niche flags
-  if (process.argv.includes('--flags')) {
+  if (process.argv.includes('all')) {
     for (let [ flag, desc ] of Object.entries({
       f: 'Print disassembled Wasm generated from user functions',
-      pgo: 'Enable PGO (profile-guided optimization)',
+      pgo: 'Enable profile-guided optimization',
       valtype: 'Valtype to use, not well supported (i32|i64|\x1B[1mf64\x1B[0m)',
       'no-coctc': 'Disable COCTC (cross-object compile-time cache)',
       cyclone: 'Enable experimental Cyclone optimizer',
@@ -77,7 +79,7 @@ if (process.argv.includes('--help') || process.argv.includes('-h')) {
       console.log(`  \x1B[1m${flag}\x1B[0m${' '.repeat(36 - flag.length)}${desc}`);
     }
   } else {
-    console.log(`  \x1B[2m(To view all flags also use --flags)\x1B[0m`);
+    console.log(`  \x1B[90m(To view all flags use --help all)\x1B[0m`);
   }
 
   console.log();

package/optional-chaining-tests.js

@@ -1,335 +0,0 @@
-// 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/r.cjs

@@ -1,71 +0,0 @@
-
-// class C {
-//   // static #method = () => 1;
-//   static #method() {
-//     return 'Test262';
-//   }
-
-//   static getPrivateMethod() {
-//     this.#method = () => 2;
-//     return this.#method();
-//   }
-// }
-
-// console.log(C.getPrivateMethod())
-
-// var __assert_throws = (expectedErrorConstructor, func) => {
-//   if (typeof func !== 'function') {
-//     throw new Test262Error('assert.throws invoked with a non-function value');
-//   }
-
-//   try {
-//     func();
-//   } catch {
-//     return;
-//   }
-
-//   throw new Test262Error('assert.throws failed');
-// };
-
-// var __assert__isSameValue = (a, b) => {
-//   if (a === b) {
-//     // Handle +/-0 vs. -/+0
-//     return a !== 0 || 1 / a === 1 / b;
-//   }
-
-//   // Handle NaN vs. NaN
-//   return a !== a && b !== b;
-// };
-
-// var __assert_sameValue = (actual, expected) => {
-//   if (__assert__isSameValue(actual, expected)) {
-//     return;
-//   }
-
-//   throw new Test262Error('assert.sameValue failed');
-// };
-
-// (function() {
-//   eval(
-//     '__assert_throws(ReferenceError, function() {\
-//       f;\
-//     }, "An initialized binding is not created prior to evaluation");\
-//     __assert_sameValue(\
-//       typeof f,\
-//       "undefined",\
-//       "An uninitialized binding is not created prior to evaluation"\
-//     );\
-//     \
-//     {\
-//     let f = 123;if (false) ; else function f() {  }}\
-//     \
-//     __assert_throws(ReferenceError, function() {\
-//       f;\
-//     }, "An initialized binding is not created following evaluation");\
-//     __assert_sameValue(\
-//       typeof f,\
-//       "undefined",\
-//       "An uninitialized binding is not created following evaluation"\
-//     );'
-//   );
-// }());