Feature(compiler): Initial support for Array<T>

ovr · ovr · commit dc723d4023a4 · 2018-12-15T14:50:23.000+09:00
diff --git a/src/backend/llvm/code-generation/array-literal-expression.ts b/src/backend/llvm/code-generation/array-literal-expression.ts
@@ -0,0 +1,31 @@
+
+import * as ts from "typescript";
+import * as llvm from 'llvm-node';
+import {NodeGenerateInterface} from "../node-generate.interface";
+import {Context} from "../context";
+import {ArrayReference} from "../value";
+
+export class ArrayLiteralExpressionCodeGenerator implements NodeGenerateInterface<ts.ArrayLiteralExpression, ArrayReference> {
+    generate(node: ts.ArrayLiteralExpression, ctx: Context, builder: llvm.IRBuilder): ArrayReference {
+        // const type = ctx.typeChecker.getTypeAtLocation(node);
+        // const elementType = NativeTypeResolver.getType(type, ctx);
+
+        // @todo Fix this hardcore...
+        const elementType = llvm.Type.getDoublePtrTy(ctx.llvmContext);
+
+        const structType = llvm.StructType.create(ctx.llvmContext, 'array<int>');
+        structType.setBody([
+            elementType,
+            llvm.Type.getInt32Ty(ctx.llvmContext),
+        ]);
+
+        const allocate = builder.createAlloca(
+            structType
+        );
+
+        return new ArrayReference(
+            elementType,
+            allocate
+        );
+    }
+}
diff --git a/src/backend/llvm/index.ts b/src/backend/llvm/index.ts
@@ -9,7 +9,15 @@ 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 {ClassReference, FunctionReference, ObjectReference, Primitive, Value, ValueTypeEnum} from "./value";
+import {
+    ArrayReference,
+    ClassReference,
+    FunctionReference,
+    ObjectReference,
+    Primitive,
+    Value,
+    ValueTypeEnum
+} from "./value";
 import {BinaryExpressionCodeGenerator} from "./code-generation/binary-expression";
 import {ReturnStatementCodeGenerator} from "./code-generation/return-statement";
 import {ForStatementGenerator} from "./code-generation/for-statement";
@@ -19,6 +27,8 @@ import {BreakStatementGenerator} from "./code-generation/break-statement";
 import {ContinueStatementGenerator} from "./code-generation/continue-statement";
 import {ClassDeclarationGenerator} from "./code-generation/class-statement";
 import {NewExpressionGenerator} from "./code-generation/new-expression";
+import {ArrayLiteralExpressionCodeGenerator} from "./code-generation/array-literal-expression";
+import {ArrayLiteralExpression} from "typescript";
 
 export function passIfStatement(parent: ts.IfStatement, ctx: Context, builder: llvm.IRBuilder) {
     const positiveBlock = llvm.BasicBlock.create(ctx.llvmContext, "if.true");
@@ -408,6 +418,8 @@ export function buildFromExpression(block: ts.Expression, ctx: Context, builder:
             return buildFromIdentifier(<any>block, ctx, builder);
         case ts.SyntaxKind.NumericLiteral:
             return buildFromNumericLiteral(<any>block, ctx, builder, nativeType);
+        case ts.SyntaxKind.ArrayLiteralExpression:
+            return new ArrayLiteralExpressionCodeGenerator().generate(block as ArrayLiteralExpression, ctx, builder);
         case ts.SyntaxKind.StringLiteral:
             return buildFromStringValue(<any>block, ctx, builder);
         case ts.SyntaxKind.TrueKeyword:
@@ -443,7 +455,7 @@ export function passVariableDeclaration(block: ts.VariableDeclaration, ctx: Cont
         let allocate: llvm.AllocaInst;
 
         const defaultValue = buildFromExpression(block.initializer, ctx, builder, nativeTypeForDefaultValue);
-        if (defaultValue instanceof ObjectReference) {
+        if (defaultValue instanceof ObjectReference || defaultValue instanceof ArrayReference) {
             allocate = defaultValue.getValue();
         } else {
             allocate = builder.createAlloca(
diff --git a/src/backend/llvm/value.ts b/src/backend/llvm/value.ts
@@ -55,6 +55,28 @@ export class FunctionReference implements Value {
     }
 }
 
+export class ArrayReference implements Value {
+    public elementType: llvm.Type;
+    public llvmValue: llvm.AllocaInst;
+
+    constructor(elementType: llvm.Type, llvmValue: llvm.AllocaInst) {
+        this.elementType = elementType;
+        this.llvmValue = llvmValue;
+    }
+
+    getValue(): llvm.AllocaInst {
+        return this.llvmValue;
+    }
+
+    public toBoolean(ctx: Context, builder: llvm.IRBuilder, node: ts.Node): Value {
+        throw new UnsupportedError(node, 'Cannot cast ClassReference to boolean');
+    }
+
+    public isString(): boolean {
+        return false;
+    }
+}
+
 export class ObjectReference implements Value {
     public classReference: ClassReference;
     public llvmValue: llvm.AllocaInst;
