rename files

compiler/ast.ts

@@ -1,5 +1,5 @@
-import { Pos } from "./Token.ts";
+import { Pos } from "./token.ts";
-import { VType } from "./vtypes.ts";
+import { VType } from "./vtype.ts";
 
 export type UnaryType = "not";
 export type BinaryType =

compiler/checker.ts

@@ -1,7 +1,7 @@
 import { StmtKind } from "./ast.ts";
 import { EType, Expr, Stmt } from "./ast.ts";
-import { Pos } from "./Token.ts";
+import { Pos } from "./token.ts";
-import { VType, VTypeParam, vtypesEqual, vtypeToString } from "./vtypes.ts";
+import { VType, VTypeParam, vtypesEqual, vtypeToString } from "./vtype.ts";
 
 export class Checker {
     private fnReturnStack: VType[] = [];
@@ -53,8 +53,8 @@ export class Checker {
         if (!vtypesEqual(prevBreakType, exprType)) {
             this.report(
                 `incompatible types for break` +
-                    `, got ${exprType}` +
+                `, got ${exprType}` +
-                    ` incompatible with ${prevBreakType}`,
+                ` incompatible with ${prevBreakType}`,
                 pos,
             );
             return;
@@ -78,8 +78,8 @@ export class Checker {
         if (!vtypesEqual(exprType, returnType)) {
             this.report(
                 `incompatible return type` +
-                    `, got ${exprType}` +
+                `, got ${exprType}` +
-                    `, expected ${returnType}`,
+                `, expected ${returnType}`,
                 pos,
             );
         }
@@ -110,8 +110,8 @@ export class Checker {
         if (!vtypesEqual(returnType, body)) {
             this.report(
                 `incompatible return type` +
-                    `, got ${body}` +
+                `, got ${body}` +
-                    `, expected ${returnType}`,
+                `, expected ${returnType}`,
                 pos,
             );
         }
@@ -128,8 +128,8 @@ export class Checker {
             if (!vtypesEqual(value, paramVtype)) {
                 this.report(
                     `incompatible value type` +
-                        `, got '${vtypeToString(value)}'` +
+                    `, got '${vtypeToString(value)}'` +
-                        `, expected '${vtypeToString(paramVtype)}'`,
+                    `, expected '${vtypeToString(paramVtype)}'`,
                     pos,
                 );
                 return;
@@ -165,8 +165,8 @@ export class Checker {
                 if (!vtypesEqual(found.vtype, value)) {
                     this.report(
                         `cannot assign incompatible type to field '${found.ident}'` +
-                            `, got '${vtypeToString(value)}'` +
+                        `, got '${vtypeToString(value)}'` +
-                            `, expected '${vtypeToString(found.vtype)}'`,
+                        `, expected '${vtypeToString(found.vtype)}'`,
                         pos,
                     );
                     return;
@@ -187,8 +187,8 @@ export class Checker {
                 if (!vtypesEqual(subject.inner, value)) {
                     this.report(
                         `cannot assign incompatible type to array ` +
-                            `'${vtypeToString(subject)}'` +
+                        `'${vtypeToString(subject)}'` +
-                            `, got '${vtypeToString(value)}'`,
+                        `, got '${vtypeToString(value)}'`,
                         pos,
                     );
                     return;
@@ -205,12 +205,11 @@ export class Checker {
                 ) {
                     this.report(
                         `cannot assign to incompatible type` +
-                            `, got '${vtypeToString(value)}'` +
+                        `, got '${vtypeToString(value)}'` +
-                            `, expected '${
+                        `, expected '${vtypeToString(
-                                vtypeToString(
+                            stmt.kind.subject.kind.sym.param.vtype!,
-                                    stmt.kind.subject.kind.sym.param.vtype!,
+                        )
-                                )
+                        }'`,
-                            }'`,
                         pos,
                     );
                     return;
@@ -348,7 +347,7 @@ export class Checker {
         if (args.length !== subject.params.length) {
             this.report(
                 `incorrect number of arguments` +
-                    `, expected ${subject.params.length}`,
+                `, expected ${subject.params.length}`,
                 pos,
             );
         }
@@ -356,8 +355,8 @@ export class Checker {
             if (!vtypesEqual(args[i], subject.params[i].vtype)) {
                 this.report(
                     `incorrect argument ${i} '${subject.params[i].ident}'` +
-                        `, expected ${vtypeToString(subject.params[i].vtype)}` +
+                    `, expected ${vtypeToString(subject.params[i].vtype)}` +
-                        `, got ${vtypeToString(args[i])}`,
+                    `, got ${vtypeToString(args[i])}`,
                     pos,
                 );
                 break;
@@ -383,7 +382,7 @@ export class Checker {
         }
         this.report(
             `cannot apply unary operation '${expr.kind.unaryType}' ` +
-                `on type '${vtypeToString(subject)}'`,
+            `on type '${vtypeToString(subject)}'`,
             pos,
         );
         return { type: "error" };
@@ -410,9 +409,8 @@ export class Checker {
         }
         this.report(
             `cannot apply binary operation '${expr.kind.binaryType}' ` +
-                `on types '${vtypeToString(left)}' and '${
+            `on types '${vtypeToString(left)}' and '${vtypeToString(right)
-                    vtypeToString(right)
+            }'`,
-                }'`,
             pos,
         );
         return { type: "error" };
@@ -438,7 +436,7 @@ export class Checker {
         if (falsy === undefined && truthy.type !== "null") {
             this.report(
                 `if expressions without false-case must result in type 'null'` +
-                    `, got '${vtypeToString(truthy)}'`,
+                `, got '${vtypeToString(truthy)}'`,
                 pos,
             );
             return { type: "error" };
@@ -446,8 +444,8 @@ export class Checker {
         if (falsy !== undefined && !vtypesEqual(truthy, falsy)) {
             this.report(
                 `if cases must be compatible, got incompatible types` +
-                    ` '${vtypeToString(truthy)}'` +
+                ` '${vtypeToString(truthy)}'` +
-                    ` and '${vtypeToString(falsy)}'`,
+                ` and '${vtypeToString(falsy)}'`,
                 pos,
             );
             return { type: "error" };
@@ -465,7 +463,7 @@ export class Checker {
         if (body.type !== "null") {
             this.report(
                 `loop body must result in type 'null'` +
-                    `, got '${vtypeToString(body)}'`,
+                `, got '${vtypeToString(body)}'`,
                 pos,
             );
             return { type: "error" };
@@ -490,8 +488,8 @@ export class Checker {
         if (breakType[1]) {
             this.report(
                 `incompatible types in break statements` +
-                    `, got '${vtypeToString(breakType[2])}'` +
+                `, got '${vtypeToString(breakType[2])}'` +
-                    ` incompatible with ${vtypeToString(breakType[0])}`,
+                ` incompatible with ${vtypeToString(breakType[0])}`,
                 pos,
             );
             return { type: "error" };
@@ -598,35 +596,35 @@ const simpleUnaryOperations: {
     operand: VType;
     result?: VType;
 }[] = [
-    { unaryType: "not", operand: { type: "bool" } },
+        { unaryType: "not", operand: { type: "bool" } },
-];
+    ];
 
 const simpleBinaryOperations: {
     binaryType: string;
     operand: VType;
     result?: VType;
 }[] = [
-    // arithmetic
+        // arithmetic
-    { binaryType: "+", operand: { type: "int" } },
+        { binaryType: "+", operand: { type: "int" } },
-    { binaryType: "+", operand: { type: "string" } },
+        { binaryType: "+", operand: { type: "string" } },
-    { binaryType: "-", operand: { type: "int" } },
+        { binaryType: "-", operand: { type: "int" } },
-    { binaryType: "*", operand: { type: "int" } },
+        { binaryType: "*", operand: { type: "int" } },
-    { binaryType: "/", operand: { type: "int" } },
+        { binaryType: "/", operand: { type: "int" } },
-    // logical
+        // logical
-    { binaryType: "and", operand: { type: "bool" } },
+        { binaryType: "and", operand: { type: "bool" } },
-    { binaryType: "or", operand: { type: "bool" } },
+        { binaryType: "or", operand: { type: "bool" } },
-    // equality
+        // equality
-    { binaryType: "==", operand: { type: "null" }, result: { type: "bool" } },
+        { binaryType: "==", operand: { type: "null" }, result: { type: "bool" } },
-    { binaryType: "==", operand: { type: "int" }, result: { type: "bool" } },
+        { binaryType: "==", operand: { type: "int" }, result: { type: "bool" } },
-    { binaryType: "==", operand: { type: "string" }, result: { type: "bool" } },
+        { binaryType: "==", operand: { type: "string" }, result: { type: "bool" } },
-    { binaryType: "==", operand: { type: "bool" }, result: { type: "bool" } },
+        { binaryType: "==", operand: { type: "bool" }, result: { type: "bool" } },
-    { binaryType: "!=", operand: { type: "null" }, result: { type: "bool" } },
+        { binaryType: "!=", operand: { type: "null" }, result: { type: "bool" } },
-    { binaryType: "!=", operand: { type: "int" }, result: { type: "bool" } },
+        { binaryType: "!=", operand: { type: "int" }, result: { type: "bool" } },
-    { binaryType: "!=", operand: { type: "string" }, result: { type: "bool" } },
+        { binaryType: "!=", operand: { type: "string" }, result: { type: "bool" } },
-    { binaryType: "!=", operand: { type: "bool" }, result: { type: "bool" } },
+        { binaryType: "!=", operand: { type: "bool" }, result: { type: "bool" } },
-    // comparison
+        // comparison
-    { binaryType: "<", operand: { type: "int" }, result: { type: "bool" } },
+        { binaryType: "<", operand: { type: "int" }, result: { type: "bool" } },
-    { binaryType: ">", operand: { type: "int" }, result: { type: "bool" } },
+        { binaryType: ">", operand: { type: "int" }, result: { type: "bool" } },
-    { binaryType: "<=", operand: { type: "int" }, result: { type: "bool" } },
+        { binaryType: "<=", operand: { type: "int" }, result: { type: "bool" } },
-    { binaryType: ">=", operand: { type: "int" }, result: { type: "bool" } },
+        { binaryType: ">=", operand: { type: "int" }, result: { type: "bool" } },
-];
+    ];

compiler/lexer.ts

@@ -1,4 +1,4 @@
-import { Pos, Token } from "./Token.ts";
+import { Pos, Token } from "./token.ts";
 
 export class Lexer {
     private index = 0;

compiler/lowerer.ts

@@ -3,7 +3,7 @@ import { BinaryType, Expr, Stmt } from "./ast.ts";
 import { LocalLeaf, Locals, LocalsFnRoot } from "./lowerer_locals.ts";
 import { Ops } from "./mod.ts";
 import { Assembler } from "./program_builder.ts";
-import { VType, vtypeToString } from "./vtypes.ts";
+import { VType, vtypeToString } from "./vtype.ts";
 
 export class Lowerer {
     private program = new Assembler();

compiler/main.ts

@@ -1,8 +1,8 @@
-import { Checker } from "./Checker.ts";
+import { Checker } from "./checker.ts";
-import { Lexer } from "./Lexer.ts";
+import { Lexer } from "./lexer.ts";
-import { Lowerer } from "./Lowerer.ts";
+import { Lowerer } from "./lowerer.ts";
-import { Parser } from "./Parser.ts";
+import { Parser } from "./parser.ts";
-import { Resolver } from "./Resolver.ts";
+import { Resolver } from "./resolver.ts";
 
 const text = await Deno.readTextFile("example.slg");
 

compiler/mod.ts

@@ -1,12 +1,12 @@
 import { Stmt } from "./ast.ts";
-import { Lexer } from "./Lexer.ts";
+import { Lexer } from "./lexer.ts";
-import { Parser } from "./Parser.ts";
+import { Parser } from "./parser.ts";
 
-export * from "./Parser.ts";
+export * from "./parser.ts";
 export * from "./ast.ts";
 export * from "./arch.ts";
-export * from "./Lexer.ts";
+export * from "./lexer.ts";
-export * from "./Token.ts";
+export * from "./token.ts";
 
 export async function compileWithDebug(filepath: string): Promise<Stmt[]> {
     const text = await Deno.readTextFile(filepath);

compiler/parser.ts

@@ -8,8 +8,8 @@ import {
     Stmt,
     StmtKind,
 } from "./ast.ts";
-import { Lexer } from "./Lexer.ts";
+import { Lexer } from "./lexer.ts";
-import { Pos, Token } from "./Token.ts";
+import { Pos, Token } from "./token.ts";
 
 export class Parser {
     private currentToken: Token | null;
@@ -501,7 +501,7 @@ export class Parser {
         const pos = this.pos();
         if (this.test("ident")) {
             const ident = this.current().identValue!;
-            this.step()
+            this.step();
             return this.etype({ type: "ident", value: ident }, pos);
         }
         if (this.test("[")) {

compiler/resolver.ts

@@ -6,7 +6,7 @@ import {
     StaticSyms,
     Syms,
 } from "./resolver_syms.ts";
-import { Pos } from "./Token.ts";
+import { Pos } from "./token.ts";
 
 export class Resolver {
     private root = new GlobalSyms();