Adapt non-android specific changes from android branch

src.compiler/BuilderHelpers.ts

@@ -1,10 +1,57 @@
 import * as ts from 'typescript';
 
+export function setMethodBody(m: ts.MethodDeclaration, body: ts.FunctionBody): ts.MethodDeclaration {
+    return ts.factory.updateMethodDeclaration(
+        m,
+        m.decorators,
+        m.modifiers,
+        m.asteriskToken,
+        m.name,
+        m.questionToken,
+        m.typeParameters,
+        m.parameters,
+        m.type,
+        body
+    );
+}
+
+export function createNodeFromSource<T extends ts.Node>(source: string, kind: ts.SyntaxKind): T {
+    const sourceFile = ts.createSourceFile(
+        'temp.ts',
+        source.trim(),
+        ts.ScriptTarget.Latest,
+        /*setParentNodes */ true,
+        ts.ScriptKind.TS
+    );
+    const node = findNode(sourceFile, kind);
+    if (!node) {
+        throw new Error(
+            `Could not parse TS source to ${ts.SyntaxKind[kind]}, node count was ${sourceFile.getChildCount()}`
+        );
+    }
+    return markNodeSynthesized(node) as T;
+}
+
+function findNode(node: ts.Node, kind: ts.SyntaxKind): ts.Node | null {
+    if (node.kind === kind) {
+        return node;
+    }
+
+    for (const c of node.getChildren()) {
+        const f = findNode(c, kind);
+        if (f) {
+            return f;
+        }
+    }
+
+    return null;
+}
+
 export function addNewLines(stmts: ts.Statement[]) {
     return stmts.map(stmt => ts.addSyntheticTrailingComment(stmt, ts.SyntaxKind.SingleLineCommentTrivia, '', true));
 }
 export function getTypeWithNullableInfo(checker: ts.TypeChecker, node: ts.TypeNode | undefined) {
-    if(!node) {
+    if (!node) {
         return {
             isNullable: false,
             type: {} as ts.Type
@@ -20,7 +67,12 @@ export function getTypeWithNullableInfo(checker: ts.TypeChecker, node: ts.TypeNo
             } else if (ts.isLiteralTypeNode(t) && t.literal.kind === ts.SyntaxKind.NullKeyword) {
                 isNullable = true;
             } else if (type !== null) {
-                throw new Error('Multi union types on JSON settings not supported: ' + node.getSourceFile().fileName + ':' + node.getText());
+                throw new Error(
+                    'Multi union types on JSON settings not supported: ' +
+                        node.getSourceFile().fileName +
+                        ':' +
+                        node.getText()
+                );
             } else {
                 type = checker.getTypeAtLocation(t);
             }
@@ -52,7 +104,6 @@ export function unwrapArrayItemType(type: ts.Type, typeChecker: ts.TypeChecker):
     return null;
 }
 
-
 export function isPrimitiveType(type: ts.Type | null) {
     if (!type) {
         return false;
@@ -85,7 +136,7 @@ export function isNumberType(type: ts.Type | null) {
     if (hasFlag(type, ts.TypeFlags.Number)) {
         return true;
     }
-    
+
     return false;
 }
 
@@ -116,4 +167,15 @@ export function hasFlag(type: ts.Type, flag: ts.TypeFlags): boolean {
 
 export function isMap(type: ts.Type | null): boolean {
     return !!(type && type.symbol?.name === 'Map');
-}
+}
+
+function markNodeSynthesized(node: ts.Node): ts.Node {
+    for(const c of node.getChildren()) {
+        markNodeSynthesized(c);
+    }
+    ts.setTextRange(node, {
+        pos: -1,
+        end: -1
+    });
+    return node;
+}

src.compiler/csharp/CSharpAst.ts

@@ -21,6 +21,7 @@ export enum SyntaxKind {
     PrimitiveTypeNode,
     EnumMember,
     ArrayTypeNode,
+    MapTypeNode,
 
     Block,
     EmptyStatement,
@@ -138,6 +139,7 @@ export interface NamedTypeDeclaration extends NamedElement, DocumentedElement, N
     typeParameters?: TypeParameterDeclaration[];
     visibility: Visibility;
     partial: boolean;
+    hasVirtualMembersOrSubClasses: boolean;
 }
 
 export interface ClassDeclaration extends NamedTypeDeclaration {
@@ -236,7 +238,7 @@ export interface UnresolvedTypeNode extends TypeNode {
     typeArguments?: UnresolvedTypeNode[];
 }
 
-export type TypeReferenceType = NamedTypeDeclaration | TypeParameterDeclaration | PrimitiveTypeNode | string;
+export type TypeReferenceType = NamedTypeDeclaration | TypeParameterDeclaration | TypeNode | string;
 export interface TypeReference extends TypeNode {
     reference: TypeReferenceType;
     typeArguments?: TypeNode[];
@@ -246,6 +248,13 @@ export interface ArrayTypeNode extends TypeNode {
     elementType: TypeNode;
 }
 
+export interface MapTypeNode extends TypeNode {
+    keyType: TypeNode;
+    keyIsValueType: boolean;
+    valueType: TypeNode;
+    valueIsValueType:boolean;
+}
+
 export interface FunctionTypeNode extends TypeNode {
     parameterTypes: TypeNode[];
     returnType: TypeNode;
@@ -492,6 +501,7 @@ export interface CatchClause extends Node {
 }
 
 // Node Tests
+export function isNode(node: any): node is Node { return typeof(node) === 'object' && 'nodeType' in node; }
 export function isSourceFile(node: Node): node is SourceFile { return node.nodeType === SyntaxKind.SourceFile; }
 export function isUsingDeclaration(node: Node): node is UsingDeclaration { return node.nodeType === SyntaxKind.UsingDeclaration; }
 export function isNamespaceDeclaration(node: Node): node is NamespaceDeclaration { return node.nodeType === SyntaxKind.NamespaceDeclaration; }
@@ -511,6 +521,7 @@ export function isFunctionTypeNode(node: Node): node is FunctionTypeNode { retur
 export function isPrimitiveTypeNode(node: Node): node is PrimitiveTypeNode { return node.nodeType === SyntaxKind.PrimitiveTypeNode; }
 export function isEnumMember(node: Node): node is EnumMember { return node.nodeType === SyntaxKind.EnumMember; }
 export function isArrayTypeNode(node: Node): node is ArrayTypeNode { return node.nodeType === SyntaxKind.ArrayTypeNode; }
+export function isMapTypeNode(node: Node): node is MapTypeNode { return node.nodeType === SyntaxKind.MapTypeNode; }
 
 export function isBlock(node: Node): node is Block { return node.nodeType === SyntaxKind.Block; }
 export function isEmptyStatement(node: Node): node is EmptyStatement { return node.nodeType === SyntaxKind.EmptyStatement; }

src.compiler/csharp/CSharpAstPrinter.ts

@@ -258,12 +258,10 @@ export default class CSharpAstPrinter extends AstPrinterBase {
         if (d.isAbstract) {
             this.write('abstract ');
         }
-
-        if (d.isVirtual) {
+        else if (d.isVirtual) {
             this.write('virtual ');
         }
-
-        if (d.isOverride) {
+        else if (d.isOverride) {
             this.write('override ');
         }
 
@@ -351,12 +349,10 @@ export default class CSharpAstPrinter extends AstPrinterBase {
             if (d.isAbstract) {
                 this.write('abstract ');
             }
-
-            if (d.isVirtual) {
+            else if (d.isVirtual) {
                 this.write('virtual ');
             }
-
-            if (d.isOverride) {
+            else if (d.isOverride) {
                 this.write('override ');
             }
         }
@@ -483,7 +479,7 @@ export default class CSharpAstPrinter extends AstPrinterBase {
                         this.write('System.Collections.IList');
                     } else {
                         if (forNew) {
-                            this.write('AlphaTab.Core.List<');
+                            this.write('AlphaTab.Collections.List<');
                         } else {
                             this.write('System.Collections.Generic.IList<');
                         }
@@ -492,6 +488,26 @@ export default class CSharpAstPrinter extends AstPrinterBase {
                     }
                 }
 
+                break;
+            case cs.SyntaxKind.MapTypeNode:
+                const mapType = type as cs.MapTypeNode;
+                if (!mapType.valueIsValueType) {
+                    if (forNew) {
+                        this.write('AlphaTab.Collections.Map<');
+                    } else {
+                        this.write('AlphaTab.Collections.IMap<');
+                    }
+                } else {
+                    if (forNew) {
+                        this.write('AlphaTab.Collections.ValueTypeMap<');
+                    } else {
+                        this.write('AlphaTab.Collections.IValueTypeMap<');
+                    }
+                }
+                this.writeType(mapType.keyType);
+                this.write(', ');
+                this.writeType(mapType.valueType);
+                this.write('>');
                 break;
             case cs.SyntaxKind.FunctionTypeNode:
                 const functionType = type as cs.FunctionTypeNode;
@@ -699,7 +715,7 @@ export default class CSharpAstPrinter extends AstPrinterBase {
 
     protected writeNonNullExpression(expr: cs.NonNullExpression) {
         this.writeExpression(expr.expression);
-        if(!cs.isNonNullExpression(expr)) {
+        if (!cs.isNonNullExpression(expr)) {
             this.write('!');
         }
     }