Feature(compiler): Support mangling method names, Math.floor works!

ovr · ovr · commit 31ec784eebdf · 2018-11-17T22:59:57.000+03:00
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -23,7 +23,7 @@
     "commander": "^2.19.0"
   },
   "dependencies": {
-    "@static-script/runtime": "^0.3.0",
+    "@static-script/runtime": "^0.4.0",
     "llvm-node": "github:MichaReiser/llvm-node#master",
     "typescript": "^3.1.1"
   }
diff --git a/packages/runtime/libhlvm-runtime.bc b/packages/runtime/libhlvm-runtime.bc
diff --git a/packages/runtime/package.json b/packages/runtime/package.json
@@ -5,7 +5,6 @@
   "main": "index.js",
   "scripts": {
     "build": "tsc",
-    "prepublish": "npm run build",
     "install": "cmake . && make"
   },
   "author": "Dmitry Patsura <talk@dmtry.me>",
diff --git a/src/backend/llvm/c.mangler.ts b/src/backend/llvm/c.mangler.ts
@@ -2,6 +2,10 @@
 import * as ts from 'typescript';
 
 export class CMangler {
+    static getMethodName(parent: string, name: string, parameters: ts.NodeArray<ts.ParameterDeclaration>): string {
+        return name;
+    }
+
     static getFunctionName(name: string, parameters: ts.NodeArray<ts.ParameterDeclaration>): string {
         return name;
     }
diff --git a/src/backend/llvm/cpp.mangler.ts b/src/backend/llvm/cpp.mangler.ts
@@ -2,6 +2,31 @@
 import * as ts from 'typescript';
 
 export class CPPMangler {
+    static getMethodName(clazz: string, method: string, parameters: ts.NodeArray<ts.ParameterDeclaration>): string {
+        const name = clazz + '__' + method;
+
+        return '_Z' + name.length + name + parameters.map(
+            (parameter) => {
+                if (parameter.type) {
+                    switch (parameter.type.kind) {
+                        case ts.SyntaxKind.NumberKeyword:
+                            return 'd';
+                        case ts.SyntaxKind.StringKeyword:
+                            return 'PKc';
+                        case ts.SyntaxKind.BooleanKeyword:
+                            return 'b';
+                        default:
+                            throw new Error(
+                                `Unsupported mangling parameter type: ${parameter.type.kind}`
+                            );
+                    }
+                }
+
+                throw new Error('Unsupported mangling without type');
+            }
+        );
+    }
+
     static getFunctionName(name: string, parameters: ts.NodeArray<ts.ParameterDeclaration>): string {
         return '_Z' + name.length + name + parameters.map(
             (parameter) => {
diff --git a/src/backend/llvm/index.ts b/src/backend/llvm/index.ts
@@ -10,6 +10,7 @@ import {RUNTIME_DEFINITION_FILE} from "@static-script/runtime";
 import {LANGUAGE_DEFINITION_FILE} from "../../constants";
 import {CMangler} from "./c.mangler";
 import {ManglerInterface} from "./mangler.interface";
+import {SignatureDeclaration} from "typescript";
 
 export function passReturnStatement(parent: ts.ReturnStatement, ctx: Context, builder: llvm.IRBuilder) {
     if (!parent.expression) {
@@ -375,6 +376,29 @@ function buildFromPostfixUnaryExpression(
     }
 }
 
+
+function mangleNameFromDecleration(
+    declaration: ts.SignatureDeclaration,
+    ctx: Context,
+    mangler: ManglerInterface
+) {
+    if (declaration.kind === ts.SyntaxKind.MethodDeclaration) {
+        const left = ctx.typeChecker.getTypeAtLocation(declaration.parent!) as ts.ObjectType;
+
+        return mangler.getMethodName(
+            <string>left.symbol.escapedName,
+            <string>(<ts.Identifier>declaration.name).escapedText,
+            declaration.parameters
+        );
+    }
+
+    return mangler.getFunctionName(
+        <string>(<ts.Identifier>declaration.name).escapedText,
+        declaration.parameters
+    );
+}
+
+
 function buildCalleFromCallExpression(
     expr: ts.CallExpression,
     ctx: Context,
@@ -386,16 +410,16 @@ function buildCalleFromCallExpression(
             return ctx.signature.get(calleSignature);
         }
 
-        const symbolDeclaration = <ts.SignatureDeclaration>calleSignature.declaration;
-        if (symbolDeclaration.name) {
-            const sourceFile = symbolDeclaration.getSourceFile();
+        const declaration = <ts.SignatureDeclaration>calleSignature.declaration;
+        if (declaration.name) {
+            const sourceFile = declaration.getSourceFile();
 
             if (sourceFile.fileName === RUNTIME_DEFINITION_FILE) {
                 const llvmFunction = declareFunctionFromDefinition(
-                    <ts.FunctionDeclaration>symbolDeclaration,
+                    <ts.FunctionDeclaration>declaration,
                     ctx,
                     builder,
-                    CPPMangler
+                    mangleNameFromDecleration(declaration, ctx, CPPMangler)
                 );
 
                 ctx.signature.set(calleSignature, llvmFunction);
@@ -405,10 +429,10 @@ function buildCalleFromCallExpression(
 
             if (sourceFile.fileName === LANGUAGE_DEFINITION_FILE) {
                 const llvmFunction = declareFunctionFromDefinition(
-                    <ts.FunctionDeclaration>symbolDeclaration,
+                    <ts.FunctionDeclaration>declaration,
                     ctx,
                     builder,
-                    CMangler
+                    mangleNameFromDecleration(declaration, ctx, CMangler)
                 );
 
 
@@ -449,7 +473,7 @@ function declareFunctionFromDefinition(
     stmt: ts.FunctionDeclaration,
     ctx: Context,
     builder: llvm.IRBuilder,
-    mangler: ManglerInterface
+    name: string
 ): llvm.Function {
     let fnType = llvm.FunctionType.get(
         stmt.type ? NativeTypeResolver.getType(ctx.typeChecker.getTypeFromTypeNode(stmt.type), ctx).getType() : llvm.Type.getVoidTy(ctx.llvmContext),
@@ -469,7 +493,7 @@ function declareFunctionFromDefinition(
     return llvm.Function.create(
         fnType,
         llvm.LinkageTypes.ExternalLinkage,
-        mangler.getFunctionName(<string>stmt.name.escapedText, stmt.parameters),
+        name,
         ctx.llvmModule
     );
 }
diff --git a/src/backend/llvm/mangler.interface.ts b/src/backend/llvm/mangler.interface.ts
@@ -3,4 +3,5 @@ import * as ts from "typescript";
 
 export interface ManglerInterface {
     getFunctionName(name: string, parameters: ts.NodeArray<ts.ParameterDeclaration>): string;
+    getMethodName(parent: string, name: string, parameters: ts.NodeArray<ts.ParameterDeclaration>): string;
 }

Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@`
`23`	`23`	`"commander": "^2.19.0"`
`24`	`24`	`},`
`25`	`25`	`"dependencies": {`
`26`		`- "@static-script/runtime": "^0.3.0",`
	`26`	`+ "@static-script/runtime": "^0.4.0",`
`27`	`27`	`"llvm-node": "github:MichaReiser/llvm-node#master",`
`28`	`28`	`"typescript": "^3.1.1"`
`29`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,4 +3,5 @@ import * as ts from "typescript";`
`3`	`3`
`4`	`4`	`export interface ManglerInterface {`
`5`	`5`	`getFunctionName(name: string, parameters: ts.NodeArray<ts.ParameterDeclaration>): string;`
	`6`	`+ getMethodName(parent: string, name: string, parameters: ts.NodeArray<ts.ParameterDeclaration>): string;`
`6`	`7`	`}`