Switch parameters to ordered hash map

src/backend/bytecode/codegen/generator.nim

@@ -420,8 +420,8 @@ proc beginProgram(self: BytecodeGenerator): int =
     ## Emits boilerplate code to set up
     ## a peon program
     self.emitByte(LoadUInt64, 1)
-    # The initial jump address is always the same
-    self.emitBytes(self.chunk.writeConstant(12.toLong()), 1)
+    # The initial jump address is always the same (12)
+    self.emitBytes(self.chunk.writeConstant(0xC.toLong()), 1)
     self.emitByte(LoadUInt64, 1)
     # We emit a dummy return address which is patched later
     self.emitBytes(self.chunk.writeConstant(0.toLong()), 1)

src/frontend/parsing/ast.nim

@@ -108,18 +108,18 @@ type
         valueType*: Expression
         default*: Expression
 
-    Parameters* = TableRef[string, Parameter]
+    Parameters* = OrderedTableRef[string, Parameter]
 
     TypeField* = ref object of Parameter
         isPrivate*: bool
 
-    TypeFields* = TableRef[string, TypeField]
+    TypeFields* = OrderedTableRef[string, TypeField]
 
     TypeGeneric* = ref object
         ident*: IdentExpr
         constr*: Expression
 
-    TypeGenerics* = TableRef[string, TypeGeneric]
+    TypeGenerics* = OrderedTableRef[string, TypeGeneric]
 
     Declaration* = ref object of ASTNode
         ## A declaration
@@ -467,10 +467,10 @@ proc newGroupingExpr*(expression: Expression, token: Token): GroupingExpr =
     result.token = token
 
 
-proc newLambdaExpr*(parameters: Parameters = newTable[string, Parameter](), 
+proc newLambdaExpr*(parameters: Parameters = newOrderedTable[string, Parameter](), 
                     body: Statement = nil, token: Token = nil, pragmas: seq[Pragma] = @[], 
-                    returnType: Expression = nil, genericTypes: TypeGenerics = newTable[string, TypeGeneric](), 
-                    genericValues: TypeGenerics = newTable[string, TypeGeneric]()): LambdaExpr =
+                    returnType: Expression = nil, genericTypes: TypeGenerics = newOrderedTable[string, TypeGeneric](), 
+                    genericValues: TypeGenerics = newOrderedTable[string, TypeGeneric]()): LambdaExpr =
     new(result)
     result.kind = NodeKind.lambdaExpr
     result.body = body
@@ -657,8 +657,8 @@ proc newVarDecl*(name: IdentExpr, valueType, value: Expression, token: Token,
 
 
 proc newFunDecl*(name: IdentExpr, parameters: Parameters, body: Statement, isPrivate: bool, token: Token, pragmas: seq[Pragma] = @[],
-                 returnType: Expression, genericTypes: TypeGenerics = newTable[string, TypeGeneric](), 
-                 genericValues: TypeGenerics = newTable[string, TypeGeneric]()): FunDecl =
+                 returnType: Expression, genericTypes: TypeGenerics = newOrderedTable[string, TypeGeneric](), 
+                 genericValues: TypeGenerics = newOrderedTable[string, TypeGeneric]()): FunDecl =
     new(result)
     result.kind = NodeKind.funDecl
     result.name = name
@@ -673,7 +673,7 @@ proc newFunDecl*(name: IdentExpr, parameters: Parameters, body: Statement, isPri
 
 
 proc newTypeDecl*(name: IdentExpr, fields: TypeFields, isPrivate: bool, token: Token, pragmas: seq[Pragma], parent: IdentExpr, isEnum: bool, isRef: bool,
-                 genericTypes: TypeGenerics = newTable[string, TypeGeneric](), genericValues: TypeGenerics = newTable[string, TypeGeneric]()): TypeDecl =
+                 genericTypes: TypeGenerics = newOrderedTable[string, TypeGeneric](), genericValues: TypeGenerics = newOrderedTable[string, TypeGeneric]()): TypeDecl =
     new(result)
     result.kind = NodeKind.typeDecl
     result.name = name

src/frontend/parsing/parser.nim

@@ -115,9 +115,10 @@ proc addOperator(self: OperatorTable, lexeme: string) =
         prec = Precedence.And
     elif lexeme == "or":
         prec = Precedence.Or
-    elif lexeme.endsWith("=") and lexeme[0] notin {'<', '>', '!', '?', '~', '='} or lexeme == "=":
+    elif lexeme == "=" or lexeme.endsWith("=") and lexeme[0] notin {'<', '>', '!', '?', '~', '='}:
         prec = Assign
     elif lexeme[0] in {'$', } or lexeme == "**":
+        # TODO: Redundant?
         prec = Power
     elif lexeme[0] in {'*', '%', '/', '\\'}:
         prec = Multiplication
@@ -1043,7 +1044,7 @@ proc funDecl(self: Parser, isOperator: bool = false): FunDecl =
     self.expect(Identifier, "expecting function name")
     let name = self.peek(-1)
     var
-        parameters: Parameters = newTable[string, Parameter]()
+        parameters: Parameters = newOrderedTable[string, Parameter]()
         returnType: Expression
         function = newFunDecl(newIdentExpr(name), parameters, nil, true, name, @[], returnType)
     function.file = self.file
@@ -1174,7 +1175,7 @@ proc statement(self: Parser): Statement =
 
 proc parseTypeFields(self: Parser): TypeFields =
     ## Parses type fields
-    result = newTable[string, TypeField]()
+    result = newOrderedTable[string, TypeField]()
     var 
         argName: IdentExpr
         argPrivate: bool
@@ -1202,7 +1203,7 @@ proc typeDecl(self: Parser): TypeDecl =
     let token = self.peek(-1)
     self.expect(Identifier, "expecting type name after 'type'")
     var name = newIdentExpr(self.peek(-1))
-    result = newTypeDecl(name, newTable[string, TypeField](), true, token, @[], nil, false, false)
+    result = newTypeDecl(name, newOrderedTable[string, TypeField](), true, token, @[], nil, false, false)
     result.file = self.file
     if self.check(["<", "["]):
         self.parseGenerics(result)

src/peon.nim

@@ -83,7 +83,6 @@ proc runFile(filename: string, fromString: bool = false, dump: bool = true, gene
         output = output
     if output == "":
         output = filename.replace(".pn", "")
-    echo output
     tokenizer.fillSymbolTable()
     try:
         if not fromString and filename.endsWith(".pbc"):