feat(rendering) Multi-Bar Rests

.mocharc.json

@@ -8,5 +8,8 @@
         "no-warnings"
     ],
     "spec": "test/**/*.test.ts",
-    "timeout": "10000"
+    "timeout": "10000",
+    "require": [
+        "test/global-hooks.ts"
+    ]
 }

package.json

@@ -63,7 +63,8 @@
         "test": "mocha",
         "test-csharp": "cd src.csharp && dotnet test -c Release",
         "test-kotlin": "node scripts/gradlew.mjs testReleaseUnitTest --info",
-        "test-accept-reference": "tsx scripts/accept-new-reference-files.ts"
+        "test-accept-reference": "tsx scripts/accept-new-reference-files.ts",
+        "typecheck": "tsc --noEmit"
     },
     "devDependencies": {
         "@coderline/alphaskia": "^2.3.120",

playground-template/alphatex-editor.html

@@ -51,15 +51,21 @@
 
         function setupEditor(api, selector) {
             const element = document.querySelector(selector);
-            element.innerHTML = trimCode(element.innerHTML);
+
+            const initialCode = sessionStorage.getItem('alphatex-editor.code') ?? trimCode(element.innerHTML);
+            element.innerHTML = initialCode;
             const editor = ace.edit(element, {
                 mode: 'ace/mode/tex'
             });
             editor.session.on('change', () => {
+                const tex = editor.getSession().getDocument().getAllLines().join('\n');
                 api.tex(editor.getSession().getDocument().getAllLines().join('\n'), 'all');
+                sessionStorage.setItem('alphatex-editor.code', tex)
             });
         }
 
+
+
         const req = new XMLHttpRequest();
         req.onload = data => {
             document.getElementById('placeholder').outerHTML = req.responseText;

src.compiler/csharp/CSharpAstTransformer.ts

@@ -1519,30 +1519,6 @@ export default class CSharpAstTransformer {
             return null;
         }
 
-        // chai property statements like "expected(false).to.be.ok;"
-        if (
-            ts.isPropertyAccessExpression(s.expression) &&
-            ts.isPropertyAccessExpression(s.expression.expression) &&
-            ts.isPropertyAccessExpression(s.expression.expression.expression) &&
-            ts.isIdentifier(s.expression.expression.name) &&
-            s.expression.expression.name.text == 'be' &&
-            ts.isIdentifier(s.expression.expression.expression.name) &&
-            (s.expression.expression.expression.name.text == 'to' ||
-                s.expression.expression.expression.name.text == 'not')
-        ) {
-            const access = expressionStatement.expression;
-
-            expressionStatement.expression = {
-                nodeType: cs.SyntaxKind.InvocationExpression,
-                parent: expressionStatement,
-                arguments: [],
-                expression: access,
-                tsNode: s.expression,
-                skipEmit: access.skipEmit
-            } as cs.InvocationExpression;
-            access.parent = expressionStatement.expression;
-        }
-
         return expressionStatement;
     }
 
@@ -3193,6 +3169,8 @@ export default class CSharpAstTransformer {
             nodeType: cs.SyntaxKind.MemberAccessExpression
         } as cs.MemberAccessExpression;
 
+        let convertToInvocation = false;
+
         if (memberAccess.tsSymbol) {
             if (this._context.isMethodSymbol(memberAccess.tsSymbol)) {
                 memberAccess.member = this._context.toMethodName(expression.name.text);
@@ -3212,10 +3190,12 @@ export default class CSharpAstTransformer {
         if (memberAccess.tsSymbol) {
             const parentSymbol = (memberAccess.tsSymbol as any).parent as ts.Symbol;
             if (parentSymbol) {
-                const renamed = this.getSymbolName(parentSymbol!, memberAccess.tsSymbol!, memberAccess);
+                const renamed = this.getSymbolName(parentSymbol!, memberAccess.tsSymbol!);
                 if (renamed) {
                     memberAccess.member = renamed;
                 }
+
+                convertToInvocation = this.convertPropertyToInvocation(parentSymbol!, memberAccess.tsSymbol!);
             }
         }
 
@@ -3228,10 +3208,42 @@ export default class CSharpAstTransformer {
             return null;
         }
 
-        return this.wrapToSmartCast(parent, memberAccess, expression);
+        if (convertToInvocation && !ts.isCallExpression(expression.parent)) {
+            const invocation: cs.InvocationExpression = {
+                nodeType: cs.SyntaxKind.InvocationExpression,
+                expression: memberAccess,
+                arguments: [],
+                tsNode: memberAccess.tsNode,
+                tsSymbol: memberAccess.tsSymbol,
+                parent: memberAccess.parent,
+                skipEmit: memberAccess.skipEmit
+            };
+
+            memberAccess.parent = invocation;
+
+            return this.wrapToSmartCast(parent, invocation, expression);
+        } else {
+            return this.wrapToSmartCast(parent, memberAccess, expression);
+        }
+    }
+
+    protected convertPropertyToInvocation(parentSymbol: ts.Symbol, symbol: ts.Symbol): boolean {
+        switch (parentSymbol.name) {
+            case 'Error':
+                switch (symbol.name) {
+                    case 'stack':
+                    case 'cause':
+                        return true;
+                }
+                break;
+            // chai assertions
+            case 'Assertion':
+                return true;
+        }
+        return false;
     }
 
-    protected getSymbolName(parentSymbol: ts.Symbol, symbol: ts.Symbol, expression: cs.Expression): string | null {
+    protected getSymbolName(parentSymbol: ts.Symbol, symbol: ts.Symbol): string | null {
         switch (parentSymbol.name) {
             case 'Array':
                 switch (symbol.name) {

src.compiler/csharp/CSharpEmitterContext.ts

@@ -93,6 +93,10 @@ export default class CSharpEmitterContext {
                 expr.tsSymbol.flags & ts.SymbolFlags.ConstEnum ||
                 expr.tsSymbol.flags & ts.SymbolFlags.RegularEnum
             ) {
+                if (expr.tsSymbol.name === 'Error') {
+                    return this.makeExceptionType();
+                }
+
                 return this.buildCoreNamespace(expr.tsSymbol) + this.toCoreTypeName(expr.tsSymbol.name);
             } else if (expr.tsSymbol.flags & ts.SymbolFlags.Function) {
                 if (this.isTestFunction(expr.tsSymbol)) {
@@ -368,6 +372,13 @@ export default class CSharpEmitterContext {
                 }
 
                 return this.createMapType(tsSymbol, node, mapKeyType!, mapValueType!);
+            case 'Error':
+                return {
+                    nodeType: cs.SyntaxKind.TypeReference,
+                    isAsync: false,
+                    isNullable: false,
+                    reference: this.makeExceptionType()
+                } as cs.TypeReference;
             case 'Array':
                 const arrayType = tsType as ts.TypeReference;
                 let arrayElementType: cs.TypeNode | null = null;
@@ -865,8 +876,9 @@ export default class CSharpEmitterContext {
         return null;
     }
 
-    public makeExceptionType(): cs.TypeReferenceType {
-        return this.makeTypeName('system.Exception');
+    public makeExceptionType(): string {
+        // global alias
+        return this.makeTypeName('Error');
     }
 
     public makeTypeName(tsName: string): string {
@@ -892,6 +904,10 @@ export default class CSharpEmitterContext {
             return this.toPascalCase('alphaTab.collections') + suffix + '.';
         }
 
+        if (aliasSymbol.name === 'Error') {
+            return '';
+        }
+
         if (aliasSymbol.declarations) {
             for (const decl of aliasSymbol.declarations) {
                 let fileName = path.basename(decl.getSourceFile().fileName).toLowerCase();

src.compiler/kotlin/KotlinAstTransformer.ts

@@ -22,10 +22,13 @@ export default class KotlinAstTransformer extends CSharpAstTransformer {
         return 'param' + name;
     }
 
-    protected override visitMethodSignature(parent: cs.ClassDeclaration | cs.InterfaceDeclaration, classElement: ts.MethodSignature) {
+    protected override visitMethodSignature(
+        parent: cs.ClassDeclaration | cs.InterfaceDeclaration,
+        classElement: ts.MethodSignature
+    ) {
         const csMethod = super.visitMethodSignature(parent, classElement);
 
-        if(!!ts.getJSDocTags(classElement).find(t => t.tagName.text === 'async')) {
+        if (!!ts.getJSDocTags(classElement).find(t => t.tagName.text === 'async')) {
             csMethod.isAsync = true;
         }
 
@@ -244,10 +247,12 @@ export default class KotlinAstTransformer extends CSharpAstTransformer {
             const method = this._context.typeChecker.getSymbolAtLocation(expression.expression);
 
             if (returnType?.symbol?.name === 'Promise' && (method as any)?.parent?.name !== 'Promise') {
-                const isSuspend = method?.valueDeclaration && (
-                    (method.valueDeclaration as ts.MethodDeclaration).modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) ||
-                    ts.getJSDocTags(method.valueDeclaration!).find(t => t.tagName.text === 'async')
-                );
+                const isSuspend =
+                    method?.valueDeclaration &&
+                    ((method.valueDeclaration as ts.MethodDeclaration).modifiers?.some(
+                        m => m.kind === ts.SyntaxKind.AsyncKeyword
+                    ) ||
+                        ts.getJSDocTags(method.valueDeclaration!).find(t => t.tagName.text === 'async'));
 
                 if (!ts.isAwaitExpression(expression.parent) && isSuspend) {
                     const suspendToDeferred = {
@@ -586,4 +591,13 @@ export default class KotlinAstTransformer extends CSharpAstTransformer {
         }
         return null;
     }
+
+    protected override convertPropertyToInvocation(parentSymbol: ts.Symbol, symbol: ts.Symbol): boolean {
+        switch (parentSymbol.name) {
+            // chai assertions
+            case 'Assertion':
+                return true;
+        }
+        return false;
+    }
 }

src.compiler/kotlin/KotlinEmitterContext.ts

@@ -31,23 +31,21 @@ export default class KotlinEmitterContext extends CSharpEmitterContext {
     }
 
     protected override toCoreTypeName(s: string) {
-        if(s === 'String') {
+        if (s === 'String') {
             return 'CoreString';
         }
-        if(s === 'Map') {
-            return 'Map<*, *>'
+        if (s === 'Map') {
+            return 'Map<*, *>';
         }
         return s;
     }
 
     public override getDefaultUsings(): string[] {
-        return [
-            this.toPascalCase('alphaTab') + '.' + this.toPascalCase('core')
-        ];
+        return [this.toPascalCase('alphaTab') + '.' + this.toPascalCase('core')];
     }
 
-    public override makeExceptionType(): cs.TypeReferenceType {
-        return this.makeTypeName('kotlin.Throwable')
+    public override makeExceptionType(): string {
+        return this.makeTypeName('kotlin.Throwable');
     }
 
     private isSymbolPartial(tsSymbol: ts.Symbol): boolean {
@@ -58,18 +56,23 @@ export default class KotlinEmitterContext extends CSharpEmitterContext {
         return !!ts.getJSDocTags(tsSymbol.valueDeclaration).find(t => t.tagName.text === 'partial');
     }
 
-
     protected override getOverriddenMembers(classType: ts.InterfaceType, classElement: ts.ClassElement): ts.Symbol[] {
         const symbols: ts.Symbol[] = [];
         this.collectOverriddenMembersByName(symbols, classType, classElement.name!.getText(), false, true);
         return symbols;
     }
 
-    protected override collectOverriddenMembersByName(symbols: ts.Symbol[], classType: ts.InterfaceType, memberName: string, includeOwnMembers: boolean = false, allowInterfaces: boolean = false) {
+    protected override collectOverriddenMembersByName(
+        symbols: ts.Symbol[],
+        classType: ts.InterfaceType,
+        memberName: string,
+        includeOwnMembers: boolean = false,
+        allowInterfaces: boolean = false
+    ) {
         super.collectOverriddenMembersByName(symbols, classType, memberName, includeOwnMembers, allowInterfaces);
 
         if (
-            classType.symbol.valueDeclaration && 
+            classType.symbol.valueDeclaration &&
             ts.isClassDeclaration(classType.symbol.valueDeclaration) &&
             classType.symbol.valueDeclaration.heritageClauses
         ) {
@@ -80,7 +83,13 @@ export default class KotlinEmitterContext extends CSharpEmitterContext {
             if (implementsClause) {
                 for (const typeSyntax of implementsClause.types) {
                     const type = this.typeChecker.getTypeFromTypeNode(typeSyntax);
-                    super.collectOverriddenMembersByName(symbols, type as ts.InterfaceType, memberName, true, allowInterfaces);
+                    super.collectOverriddenMembersByName(
+                        symbols,
+                        type as ts.InterfaceType,
+                        memberName,
+                        true,
+                        allowInterfaces
+                    );
                 }
             }
         }