Feature(compiler): TypeOf - initial support

ovr · ovr · commit c00912df34eb · 2019-01-25T19:28:11.000+09:00
diff --git a/src/backend/llvm/code-generation/typeof-expression.ts b/src/backend/llvm/code-generation/typeof-expression.ts
@@ -0,0 +1,37 @@
+import * as ts from "typescript";
+import * as llvm from 'llvm-node';
+import {NodeGenerateInterface} from "../node-generate.interface";
+import {Context} from "../context";
+import {Value, ValueTypeEnum} from "../value";
+import {NativeType} from "../native-type";
+import {buildFromExpression, buildFromString} from "../index";
+import UnsupportedError from "../../error";
+
+export class TypeOfExpressionCodeGenerator implements NodeGenerateInterface<ts.TypeOfExpression, Value> {
+    generate(node: ts.TypeOfExpression, ctx: Context, builder: llvm.IRBuilder, nativeType?: NativeType): Value {
+        const right = buildFromExpression(node.expression, ctx, builder);
+        switch (right.getType()) {
+            case ValueTypeEnum.BOOLEAN:
+                return buildFromString('boolean', ctx, builder);
+            case ValueTypeEnum.STRING:
+                return buildFromString('string', ctx, builder);
+            case ValueTypeEnum.DOUBLE:
+                return buildFromString('number', ctx, builder);
+            case ValueTypeEnum.INT8:
+                return buildFromString('int8', ctx, builder);
+            case ValueTypeEnum.INT16:
+                return buildFromString('int16', ctx, builder);
+            case ValueTypeEnum.INT32:
+                return buildFromString('int32', ctx, builder);
+            case ValueTypeEnum.INT64:
+                return buildFromString('int64', ctx, builder);
+            case ValueTypeEnum.INT128:
+                return buildFromString('int128', ctx, builder);
+            default:
+                throw new UnsupportedError(
+                    node,
+                    `Unsupported typeof call`,
+                )
+        }
+    }
+}
diff --git a/src/backend/llvm/index.ts b/src/backend/llvm/index.ts
@@ -35,6 +35,7 @@ import {PropertyAccessExpressionCodeGenerator} from "./code-generation/property-
 import {TryStatementGenerator} from "./code-generation/try-statement";
 import {PostfixUnaryExpressionCodeGenerator} from "./code-generation/postfix-unary-expression";
 import {FunctionDeclarationCodeGenerator} from "./code-generation/function-declaration";
+import {TypeOfExpressionCodeGenerator} from "./code-generation/typeof-expression";
 
 export function emitCondition(
     condition: ts.Expression,
@@ -49,15 +50,17 @@ export function emitCondition(
     builder.createCondBr(conditionBoolValue.getValue(), positiveBlock, negativeBlock);
 }
 
-export function buildFromStringValue(node: ts.StringLiteral, ctx: Context, builder: llvm.IRBuilder): Value {
+export function buildFromString(value: string, ctx: Context, builder: llvm.IRBuilder): Value {
     return new Primitive(
-        builder.createGlobalStringPtr(
-            node.text,
-        ),
+        builder.createGlobalStringPtr(value),
         ValueTypeEnum.STRING
     );
 }
 
+export function buildFromStringValue(node: ts.StringLiteral, ctx: Context, builder: llvm.IRBuilder): Value {
+    return buildFromString(node.text, ctx, builder);
+}
+
 export function buildFromTrueKeyword(node: ts.BooleanLiteral, ctx: Context, builder: llvm.IRBuilder): Value {
     return new Primitive(
         llvm.ConstantInt.get(
@@ -307,9 +310,10 @@ export function buildFromExpression(block: ts.Expression, ctx: Context, builder:
             return new CallExpressionCodeGenerator().generate(<any>block, ctx, builder);
         case ts.SyntaxKind.ExpressionStatement:
             return <any>buildFromExpression((<any>block).expression, ctx, builder);
-        case ts.SyntaxKind.ParenthesizedExpression: {
+        case ts.SyntaxKind.TypeOfExpression:
+            return new TypeOfExpressionCodeGenerator().generate(block as ts.TypeOfExpression, ctx, builder);
+        case ts.SyntaxKind.ParenthesizedExpression:
             return buildFromExpression((<ts.ParenthesizedExpression>block).expression, ctx, builder);
-        }
         default:
             throw new UnsupportedError(
                 block,
diff --git a/tests/snapshots/general/typeof.ts b/tests/snapshots/general/typeof.ts
@@ -0,0 +1,16 @@
+
+{
+    function callTypeOfOnStaticTypes(): void {
+        console_log("callTypeOfOnStaticTypes");
+
+        console_log(typeof true);
+        console_log(typeof false);
+        console_log(typeof 1);
+        console_log(typeof 1.0);
+        console_log(typeof "hey");
+
+        console_log("");
+    }
+
+    callTypeOfOnStaticTypes();
+}
diff --git a/tests/snapshots/general/typeof.ts.stdout b/tests/snapshots/general/typeof.ts.stdout
@@ -0,0 +1,7 @@
+callTypeOfOnStaticTypes
+boolean
+boolean
+number
+number
+string
+

-Original file line number
+Diff line change
@@ @@ -0,0 +1,7 @@ @@
 +callTypeOfOnStaticTypes
 +boolean
 +boolean
 +number
 +number
 +string
++