Channel arithmetics

compiler/package.json

@@ -21,7 +21,7 @@
         "dist:esm": "tsc -p tsconfig.esm.json",
         "dist:cjs": "tsc -p tsconfig.cjs.json",
         "dist": "npm run parseTypeDocs && rm -rf ./dist/* && npm run dist:esm && npm run dist:cjs && node ./scripts/setVersionConstant.mjs",
-        "test": "c8 mocha './dist/cjs/**/*.spec.js'",
+        "test": "c8 mocha './dist/cjs/**/*.spec.js' --reporter-option maxDiffSize=0",
         "test:single": "mocha './dist/cjs/**/*.spec.js' --reporter-option maxDiffSize=0 --grep",
         "check": "eslint ./src && tsc --noEmit",
         "parseTypeDocs": "node ./scripts/parseTypeDocs.mjs"

compiler/src/js2eel/compiler/Js2EelCompiler.spec.ts

@@ -278,10 +278,14 @@ someVar = 1;
 
 /* Channel 0 */
 
+CH__0 = 0;
+
 someVar += ;
 
 /* Channel 1 */
 
+CH__1 = 1;
+
 someVar += ;
 
 
@@ -326,10 +330,14 @@ out_pin:In 1
 
 /* Channel 0 */
 
+CH__0 = 0;
+
 someVar__S4 = 1;
 
 /* Channel 1 */
 
+CH__1 = 1;
+
 someVar__S5 = 1;
 
 

compiler/src/js2eel/generatorNodes/assignmentExpression/assignmentExpression.spec.ts

@@ -435,11 +435,15 @@ out_pin:In 1
 
 /* Channel 0 */
 
+CH__0 = 0;
+
 spl0 = 4;
  = 3;
 
 /* Channel 1 */
 
+CH__1 = 1;
+
 spl1 = 4;
  = 3;
 

compiler/src/js2eel/generatorNodes/callExpression/callExpression.ts

@@ -11,6 +11,7 @@
 import { evaluateUserFunctionCall } from './utils/evaluateUserFunctionCall.js';
 import { suffixInlineReturn } from '../../suffixersAndPrefixers/suffixInlineReturn.js';
 import { prefixParam } from '../../suffixersAndPrefixers/prefixParam.js';
+import { stripChannelPrefix } from '../../suffixersAndPrefixers/prefixChannel.js';
 import { addSemicolonIfNone } from '../../suffixersAndPrefixers/addSemicolonIfNone.js';
 import { EEL_LIBRARY_FUNCTION_NAMES } from '../../constants.js';
 
@@ -99,16 +100,22 @@
                         let replacedReturnSource = returnSrc?.src;
 
                         for (const [_key, arg] of Object.entries(args)) {
+                            let cleanValue = arg.value;
+
+                            if (typeof cleanValue === 'string') {
+                                cleanValue = stripChannelPrefix(arg.value);
+                            }
+
                             // FIXME this might hurt performance if functions get large
                             replacedBodySrc = replacedBodySrc.replaceAll(
                                 `${prefixParam(arg.scopedName)}`,
-                                arg.value
+                                cleanValue
                             );
 
                             if (replacedReturnSource) {
                                 replacedReturnSource = replacedReturnSource.replaceAll(
                                     `${prefixParam(arg.scopedName)}`,
-                                    arg.value
+                                    cleanValue
                                 );
                             }
                         }
@@ -156,7 +163,7 @@
                 break;
             }
             /* c8 ignore start */
             // FIXME: Don't know how to test that
             default: {
                 instance.error(
                     'UnknownSymbolError',

compiler/src/js2eel/generatorNodes/callExpression/eelLib/eelLibraryFunctionCall.spec.ts

@@ -98,11 +98,15 @@ out_pin:In 1
 
 /* Channel 0 */
 
-myVar__S4 = spl(0);
+CH__0 = 0;
+
+myVar__S4 = spl(CH__0);
 
 /* Channel 1 */
 
-myVar__S5 = spl(1);
+CH__1 = 1;
+
+myVar__S5 = spl(CH__1);
 
 
 

compiler/src/js2eel/generatorNodes/callExpression/js2EelLib/eachChannel.spec.ts

@@ -116,15 +116,19 @@
 
 /* Channel 0 */
 
+CH__0 = 0;
+
 
 /* Channel 1 */
 
+CH__1 = 1;
+
 
 
 
 `)
         );
         expect(result.errors.length).to.equal(2); // FIXME Do not check twice
         expect(result.errors[0].type).to.equal('TypeError');
         expect(result.errors[1].type).to.equal('TypeError');
     });

compiler/src/js2eel/generatorNodes/callExpression/utils/evaluateUserFunctionCall.ts

@@ -117,7 +117,7 @@ export const evaluateUserFunctionCall = <ArgName extends string>(
                 break;
             }
             case 'Identifier': {
-                const id = identifier(givenArg, instance);
+                const id = identifier(givenArg, instance, { isParam: true });
                 value = id;
                 rawValue = id;
                 break;

compiler/src/js2eel/generatorNodes/conditionalExpression/conditionalExpression.spec.ts

@@ -257,6 +257,87 @@ out_pin:In 1
 spl3 = spl0 == 1 ? 3 : -4 * 2;
 
 
+`)
+        );
+        expect(result.errors.length).to.equal(0);
+    });
+
+    it('Consequent is member expression', () => {
+        const compiler = new Js2EelCompiler();
+        const result =
+            compiler.compile(`config({ description: "conditional", inChannels: 2, outChannels: 2 });
+
+const myEelbuf = new EelBuffer(2, 2);
+
+onSample(() => {
+    spl3 = spl0 === 1 ? myEelbuf[0][1] : -4 * 2;
+});`);
+
+        expect(result.success).to.equal(true);
+        expect(testEelSrc(result.src)).to.equal(
+            testEelSrc(`/* Compiled with JS2EEL v0.9.1 */
+
+desc:conditional
+
+in_pin:In 0
+in_pin:In 1
+out_pin:In 0
+out_pin:In 1
+
+
+@init
+
+myEelbuf__B0 = 0 * 2;
+myEelbuf__B1 = 1 * 2;
+myEelbuf__size = 2;
+
+
+@sample
+
+spl3 = spl0 == 1 ? myEelbuf__B0[1] : -4 * 2;
+
+
+`)
+        );
+        expect(result.errors.length).to.equal(0);
+    });
+
+    it('Alternate is member expression', () => {
+        const compiler = new Js2EelCompiler();
+        const result =
+            compiler.compile(`config({ description: 'conditional', inChannels: 2, outChannels: 2 });
+
+const myEelbuf = new EelBuffer(2, 2);
+
+onSample(() => {
+    spl3 = spl0 === 1 ? 3 : myEelbuf[1][1];
+});
+`);
+
+        expect(result.success).to.equal(true);
+        expect(testEelSrc(result.src)).to.equal(
+            testEelSrc(`/* Compiled with JS2EEL v0.9.1 */
+
+desc:conditional
+
+in_pin:In 0
+in_pin:In 1
+out_pin:In 0
+out_pin:In 1
+
+
+@init
+
+myEelbuf__B0 = 0 * 2;
+myEelbuf__B1 = 1 * 2;
+myEelbuf__size = 2;
+
+
+@sample
+
+spl3 = spl0 == 1 ? 3 : myEelbuf__B1[1];
+
+
 `)
         );
         expect(result.errors.length).to.equal(0);

compiler/src/js2eel/generatorNodes/conditionalExpression/conditionalExpression.ts

@@ -2,6 +2,7 @@ import { literal } from '../literal/literal';
 import { identifier } from '../identifier/identifier';
 import { unaryExpression } from '../unaryExpression/unaryExpression';
 import { binaryExpression } from '../binaryExpression/binaryExpression';
+import { memberExpression } from '../memberExpression/memberExpression';
 
 import type { ConditionalExpression } from 'estree';
 import type { Js2EelCompiler } from '../../compiler/Js2EelCompiler';
@@ -51,10 +52,18 @@ export const conditionalExpression = (
             );
             break;
         }
+        case 'MemberExpression': {
+            conditionalExpressionSrc += memberExpression(
+                conditionalExpressionNode,
+                conditionalExpressionNode.consequent,
+                instance
+            );
+            break;
+        }
         default: {
             instance.error(
                 'TypeError',
-                `Type ${conditionalExpressionNode.consequent.type} not allowed`,
+                `Conditional expression: Consequent: Type ${conditionalExpressionNode.consequent.type} not allowed`,
                 conditionalExpressionNode.consequent
             );
         }
@@ -88,10 +97,18 @@ export const conditionalExpression = (
                 );
                 break;
             }
+            case 'MemberExpression': {
+                conditionalExpressionSrc += memberExpression(
+                    conditionalExpressionNode,
+                    conditionalExpressionNode.alternate,
+                    instance
+                );
+                break;
+            }
             default: {
                 instance.error(
                     'TypeError',
-                    `Type ${conditionalExpressionNode.alternate.type} not allowed`,
+                    `Conditional expression: Alternate: Type ${conditionalExpressionNode.alternate.type} not allowed`,
                     conditionalExpressionNode.alternate
                 );
             }

compiler/src/js2eel/generatorNodes/functionExpression/functionExpression.ts

@@ -1,6 +1,7 @@
 import { blockStatement } from '../blockStatement/blockStatement.js';
 
 import { registerDeclarationParam } from '../../declarationParams/registerDeclarationParam.js';
+import { prefixChannel } from '../../suffixersAndPrefixers/prefixChannel.js';
 
 import type { ArrowFunctionExpression, FunctionExpression } from 'estree';
 import type { Js2EelCompiler } from '../../compiler/Js2EelCompiler.js';
@@ -103,7 +104,11 @@ export const functionExpression = <ParamName extends string>(
                 i < instance.getChannels().inChannels;
                 /* FIXME is this sufficient? what about out? */ i++
             ) {
-                callbackSrc += `/* Channel ${i} */\n\n`;
+                callbackSrc += `/* Channel ${i} */
+
+${prefixChannel(i)} = ${i};
+
+`;
 
                 instance.setCurrentChannel(i);
 
@@ -190,7 +195,7 @@ export const functionExpression = <ParamName extends string>(
         default: {
             instance.error(
                 'GenericError',
-                "Function expressions are only allowed as arguments to onInit(), onBlock(), onSample(), eachChannel() and onSlider()",
+                'Function expressions are only allowed as arguments to onInit(), onBlock(), onSample(), eachChannel() and onSlider()',
                 functionExpression
             );
         }

compiler/src/js2eel/generatorNodes/identifier/identifier.spec.ts

@@ -0,0 +1,37 @@
+import { expect } from 'chai';
+import { Js2EelCompiler } from '../../compiler/Js2EelCompiler';
+import { testEelSrc } from '../../test/helpers';
+
+describe('identifier()', () => {
+    it('error if using EelArray or EelBuffer without accessors', () => {
+        const compiler = new Js2EelCompiler();
+        const result =
+            compiler.compile(`config({ description: 'mono_delay', inChannels: 2, outChannels: 2 });
+
+const myEelArray = new EelArray(2, 2);
+const myVar = myEelArray;`);
+
+        expect(result.success).to.equal(false);
+        expect(testEelSrc(result.src)).to.equal(
+            testEelSrc(`/* Compiled with JS2EEL v0.9.1 */
+
+desc:mono_delay
+
+in_pin:In 0
+in_pin:In 1
+out_pin:In 0
+out_pin:In 1
+
+
+@init
+
+myVar = ?ä__DENY_COMPILATION;
+
+
+`)
+        );
+        expect(result.errors.length).to.equal(1);
+        expect(result.errors[0].type).to.equal('GenericError');
+    });
+
+});

compiler/src/js2eel/generatorNodes/identifier/identifier.ts

@@ -5,12 +5,17 @@ import {
     suffixScopeBySymbol
 } from '../../suffixersAndPrefixers/suffixScope.js';
 import { prefixParam } from '../../suffixersAndPrefixers/prefixParam.js';
-import { EEL_LIBRARY_VARS } from '../../constants.js';
+import { prefixChannel } from '../../suffixersAndPrefixers/prefixChannel.js';
+import { EEL_LIBRARY_VARS, JSFX_DENY_COMPILATION } from '../../constants.js';
 
 import type { Identifier } from 'estree';
 import type { Js2EelCompiler } from '../../compiler/Js2EelCompiler.js';
 
-export const identifier = (identifier: Identifier, instance: Js2EelCompiler): string => {
+export const identifier = (
+    identifier: Identifier,
+    instance: Js2EelCompiler,
+    additionalData?: { isObjectInMemberExpression?: boolean; isParam?: boolean }
+): string => {
     if (EEL_LIBRARY_VARS.has(identifier.name.toLowerCase())) {
         // We can lowercase here because there's only lowercase symbols in EEL
         return identifier.name;
@@ -20,6 +25,21 @@ export const identifier = (identifier: Identifier, instance: Js2EelCompiler): st
 
     const declaredSymbol = getSymbolInNextUpScope(identifier.name, instance);
 
+    if (
+        (declaredSymbol?.symbol.currentAssignment?.type === 'EelArray' ||
+            declaredSymbol?.symbol.currentAssignment?.type === 'EelBuffer') &&
+        (!additionalData?.isObjectInMemberExpression &&
+            !additionalData?.isParam)
+    ) {
+        instance.error(
+            'GenericError',
+            'EelBuffer/EelArray cannot be used without accessors: ' + identifier.name,
+            identifier
+        );
+
+        return JSFX_DENY_COMPILATION;
+    }
+
     const sampleParamsMap = instance.getEachChannelParams();
     const inSampleParamsMap = Object.values(sampleParamsMap).includes(identifier.name);
 
@@ -39,7 +59,7 @@ export const identifier = (identifier: Identifier, instance: Js2EelCompiler): st
             const currentChannel = instance.getCurrentChannel();
 
             if (sampleParamsMap.channelIdentifier === identifier.name) {
-                identifierSrc = currentChannel.toString();
+                identifierSrc = `${prefixChannel(currentChannel)}`;
             } else {
                 identifierSrc = `spl${currentChannel}`;
             }

compiler/src/js2eel/generatorNodes/memberExpression/js2EelLib/eelArrayMemberCall.ts

@@ -4,7 +4,6 @@ import type { EelArray } from '../../../types.js';
 
 export const eelArrayMemberCall = (
     eelArray: EelArray,
-    calleeObject: Identifier,
     calleeProperty: Identifier | PrivateIdentifier,
     instance: Js2EelCompiler
 ): string => {

compiler/src/js2eel/generatorNodes/memberExpression/memberExpressionCall.ts

@@ -79,7 +79,6 @@ export const memberExpressionCall = (
                     } else if (eelArray) {
                         parentCallExpressionSrc += eelArrayMemberCall(
                             eelArray,
-                            calleeObject,
                             calleeProperty,
                             instance
                         );