Kit: a magical, high performance programming language, designed for game development

Describe the problem. What did you see? What did you expect to see?

When I tried to compile a simple sdl2 hello-world, the compiler gave me an error.

kitc HelloWorld.kit --run -I 3rdparty\SDL2\include
[2019-03-18 12:02:02.2754] ===> parsing and building module graph
[2019-03-18 12:02:02.3255] ===> processing C includes
----------------------------------------
Error: Parsing C header "build\\include\\__clibs.h" failed: C:/Users/madic/scoop/apps/gcc/current/x86_64-w64-mingw32/include/psdk_inc/intrin-impl.h:835: (column 222) [ERROR]  >>> Syntax Error !
  Syntax error !
  The symbol `)' does not fit here.

[2019-03-18 12:02:03.0012] ERR: compilation failed (1 errors)

If this is a code issue, provide a minimal code example:

It's just a line of SDL_Init

include "SDL.h";

function main(){
    SDL_Init(${SDL_INIT_EVERYTHING:Uint32});
}

Environment

[2019-03-18 12:11:15.5615] ===> kitc version
[2019-03-18 12:11:15.5655] DBG: 0.1.0
[2019-03-18 12:11:15.5685] ===> OS
[2019-03-18 12:11:15.5715] DBG: mingw32
[2019-03-18 12:11:15.5755] ===> Source paths
[2019-03-18 12:11:15.5805] DBG: ["src","C:\\Users\\madic\\scoop\\apps\\kitlang-prerelease\\0.1.0-prerelease-0\\std"]
[2019-03-18 12:11:15.5855] ===> Standard prelude location
[2019-03-18 12:11:15.5905] DBG: C:\Users\madic\scoop\apps\kitlang-prerelease\0.1.0-prerelease-0\std\prelude.kit
[2019-03-18 12:11:15.5965] ===> ** COMPILER **
[2019-03-18 12:11:15.6005] ===> Toolchain
[2019-03-18 12:11:15.6035] DBG: C:\Users\madic\scoop\apps\kitlang-prerelease\0.1.0-prerelease-0\toolchains\windows-mingw[2019-03-18 12:11:15.6105] ===> Compiler
[2019-03-18 12:11:15.6135] DBG: gcc
gcc (x86_64-posix-seh-rev0, Built by MinGW-W64 project) 8.1.0
Copyright (C) 2018 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

[2019-03-18 12:11:15.6546] ===> Include paths
[2019-03-18 12:11:15.6585] DBG: []
[2019-03-18 12:11:15.6625] ===> Compiler flags
[2019-03-18 12:11:15.6655] DBG: ["-D__USE_MINGW_ANSI_STDIO","-std=c99","-pedantic","-O3","-Os","-Wno-missing-braces","-Wno-shift-op-parentheses"]
[2019-03-18 12:11:15.6735] ===> Linker flags
[2019-03-18 12:11:15.6765] DBG: ["-std=c99","-pedantic","-O3","-Os","-Wno-missing-braces","-Wno-shift-op-parentheses"]

• Kit version: v0.1.0 (heads/master-0-g68f4515772c9f333858995270320589a87780056)
• OS/Platform: Linux

Describe the problem. What did you see? What did you expect to see?

codehz-pc :: /tmp/kit » kitc helloworld.kit -I /usr/include [2018-12-20 14:42:58.161347] ===> parsing and building module graph [2018-12-20 14:42:58.184124] ===> processing C includes kitc: Prelude.head: empty list

If this is a code issue, provide a minimal code example:

function main() {
    printf("%s\n", "Hello from Kit!");
}

• Kit version: 5c1e92607958
• OS/Platform: Mac

Describe the problem. What did you see? What did you expect to see?

This code should (according to https://www.kitlang.org/examples.html#trait-constraints) write "hello" to /tmp/greeting:

import kit.sys.file;

function greet[W: Writer](w: W) {
    w.write("hello");
}

function main() {
    var f = File.write("/tmp/greeting");
    greet(f);
}

It produces a warning when building, but it builds successfully:

[2018-10-04 13:44:22.247710] ===> compiling main.greet
[2018-10-04 13:44:22.248143] /usr/bin/cc -Ibuild/include -c build/lib/main/kit_greet.c -o build/obj/main/kit_greet.o -D_GNU_SOURCE -D_BSD_SOURCE -D_DEFAULT_SOURCE '-std=c99' -pedantic -O3 -Os -U__BLOCKS__ -Wno-expansion-to-defined -Wno-gnu-zero-variadic-macro-arguments
build/lib/main/kit_greet.c:5:30: warning: incompatible pointer types passing 'FILE **' (aka 'struct __sFILE **') to parameter of type 'char *' [-Wincompatible-pointer-types]
    kit_sys_file_File__write(&w);
                             ^~
build/include/main.h:85:40: note: passing argument to parameter 'path' here
FILE * kit_sys_file_File__write(char * path);
                                       ^
1 warning generated.

After running it:

% ls -h /tmp/greeting
ls: /tmp/greeting: No such file or directory
% ./main 
% ls -lh /tmp/greeting
-rw-r--r--  1 kuba  wheel     0B Oct  4 13:57 /tmp/greeting

I had a look at the generated code, see below.

lib/kit_main.c:

#include "main.h"

int main()
{
    {
        FILE * f = kit_sys_file_File__write((char *) "/tmp/greeting");
        main_greet__fac4fab0400c4242(f);
    }
    return 0;
}

`lib/main/kit_greet.c':

#include "main.h"

void main_greet__fac4fab0400c4242(FILE * w)
{
    kit_sys_file_File__write(&w);
}

And kit_sys_file_File__write (in lib/kit/sys/file/kit_File.c) is the static function that opens the file in the first place - it's done again by main_greet... above.

`lib/kit/sys/file/kit_File.c':

// ...
FILE * kit_sys_file_File__write(char * path)
{
    return fopen(path, (char *) "w");
}

//...

After some digging it seems that the presence of the static write function (the same name as the write function in the Write trait) in the File Abstract silences the issue, because if the names differ the code won't compile and we know right away something's fishy:

% cat ../kitbox/main.kit      
import kit.sys.file;

trait Blablaber[T] {
    public function blabla(value: T): Void;
}

implement Blablaber[CString] for File {
    public function blabla(value: CString) {
        fwrite(value, sizeof Char, strlen(value), this);
    }
}

function greet[B: Blablaber](b: B) {
    b.blabla("hello");
}

function main() {
    var f = File.write("/tmp/greeting");
    greet(f);
}

% kitc -s ./std -s ../kitbox main
[2018-10-04 14:05:24.635907] ===> parsing and building module graph
[2018-10-04 14:05:24.647979] ===> processing C includes
[2018-10-04 14:05:24.852206] ===> resolving module types
[2018-10-04 14:05:24.855792] ===> typing module content
----------------------------------------
Error: ../kitbox/main.kit:14: Field access is not allowed on FILE

  @../kitbox/main.kit:14:5-12
      14        b.blabla("hello");
                ^^^^^^^^

[2018-10-04 14:05:24.865898] ===> total time: 0.230116s
[2018-10-04 14:05:24.866340] ERR: compilation failed (1 errors)

I tried to narrow the issue down and got lost somewhere around following/unifying types so I decided to leave a report instead, hope it helps.

Previously the code would unconditionally refuse to unify pointer to void with any other pointer. That lead to a test failure on Mac OS:

tests/Kit/CompilerSpec.hs:52:11:
1) Kit.Compiler, Successful compile tests, tests/compile-src/std/sys/utils.kit
   expected: Nothing
    but got: Just KitErrors [KitErrors [BasicError "The type of this expression is ambiguous; not enough information to infer a type for type var #153.\n\nTry adding a type annotation: `expression: Type`" (Just @std/kit/sys/utils.kit:16:23-26)]]

The compiler output when called manually:

$ kitc -s ./std -s ./tests/compile-src/std/sys utils
[2018-10-03 19:59:42.650042] ===> parsing and building module graph
[2018-10-03 19:59:42.665697] ===> processing C includes
[2018-10-03 19:59:43.087041] ===> resolving module types
[2018-10-03 19:59:43.090047] ===> typing module content
[2018-10-03 19:59:43.093123] ===> generating intermediate representation
----------------------------------------
Error: ./std/kit/sys/utils.kit:16: The type of this expression is ambiguous; not enough information to infer a type for type var #153.

Try adding a type annotation: `expression: Type`

  @./std/kit/sys/utils.kit:16:23-26
      16        gettimeofday(&tv, null);
                                  ^^^^

[2018-10-03 19:59:43.097176] ===> total time: 0.4465s
[2018-10-03 19:59:43.097729] ERR: compilation failed (1 errors)

The test wasn't failing on Linux, because on Linux gettimeofday is declared like this:

extern int gettimeofday (struct timeval *__restrict __tv,
    __timezone_ptr_t __tz) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));

While on Mac OS gettimeofday is declared as:

int gettimeofday(struct timeval *restrict, void *restrict);

Since this case is being handled now I let myself remove two no longer necessary Ptr[Void] annotations.

• Kit version: v0.1.0
• OS/Platform: (Linux)

Describe the problem. What did you see? What did you expect to see?

build/lib/sobreviver/kit_Chunk.c: In function 'sobreviver_chunk__new':
build/lib/sobreviver/kit_Chunk.c:7:23: error: expected expression before '{' token 
(*chunk).blocks = {0};

If this is a code issue, provide a minimal code example:

struct Chunk
{
   private var blocks : CArray[Block, 4096];

   public static function new(allocator : Box[Allocator]) : Ptr[Chunk]{
     var chunk : Ptr[Chunk] = allocator.alloc(sizeof Chunk);
     chunk.blocks = empty;
     return chunk;
   }
}

function main(){
var chunk = Chunk.new();
}

• Kit version: 828881970de4
• OS/Platform: Mac

Let's have a couple of modules:

% cat src/kitbox/mod1.kit 
include 'stdio.h';

function hello() {
    printf("Hello from mod1\n");
}

% cat src/kitbox/mod2.kit
include 'stdio.h';

function hello() {
    printf("Hello from mod2\n");
}

% cat src/kitbox.kit 
include "stdio.h";
import kitbox.mod1;
import kitbox.mod2;

function main() {
    hello();
}

The application, when run, prints:

Hello from mod1

I'd expect a compilation error here with an instruction to disambiguate. If I understand correctly there's currently no disambiguation mechanism in place. This issue could also affect types, traits and variables.

As one data point, in C# this would be solved by one of the following (just some proof of concept samples):

• fully qualifying the reference:

import kitbox.mod1;
import kitbox.mod2;

function main() {
    kitbox.mod1.hello();
    kitbox.mod2.hello();
}

• creating a namespace alias:

import kitbox.mod1 as mod1;
import kitbox.mod2 as mod2;

function main() {
    mod1.hello();
    mod2.hello();
}

• creating a symbol alias (probably not applicable here but I'm mentioning it just in case):

import kitbox.mod1.hello as mod1_hello;
import kitbox.mod2.hello as mod2_hello;

function main() {
    mod1_hello();
    mod2_hello();
}

Regardless of whether it's a good practice or not to have clashing identifiers in different modules - what should happen here? Implementing disambiguation mechanism seems like a fun task but, as with #10, I'd need some assistance to tackle it if it's actually a good idea.

• Kit version: 0.1.0
• OS/Platform: Mac

Describe the problem. What did you see? What did you expect to see?

The docs say that match can be used as an expression. I would like to return the result of a match from a function. I can't figure out how to do so. Returning the match doesn't work -- Kit doesn't like wrapping it in parentheses -- and just leaving the match as the body of the function also does not work.

If this is a code issue, provide a minimal code example:

enum Exp {
    IntLit(value: Int);
}

function toString(e: Exp): CString {
    return (match e {
        IntLit(v) => "hello";
        default => "uh oh";
    });
}

// OR this

function toString(e: Exp): CString {
    match e {
        IntLit(v) =>= "hello";
        default => "uh oh";
    })
}

The top toString is a syntax error and the bottom toString generates a function that does not return any value in C:

char * ast__toString(struct ast__Exp e)
{
    if (e.__dsc == ast_Exp__IntLit)
    {
        int v = e.__var.variant_IntLit.value;
        (char *) "hello";
    }
    else
    {
        (char *) "uh oh";
    }
}

Additionally, it doesn't appear as though this would work anyway -- do the string literals live long enough?

Describe the problem. What did you see? What did you expect to see?

In the playgound.

I change this line:

    printf("%s, %s!", greeting.firstWord, greeting.secondWord);

to:

    printf("%s, %s %s %s %s %s!", greeting.firstWord, greeting.secondWord);

And it prints:

Hello, world Hello world (null) (null)!

I would expect either (if it's supposed to cycle)

Hello, world Hello world Hello world!

Or this

Hello, world (null) (null) (null) (null)!

• Kit version: 0.1.0
• OS/Platform: (Windows)

Describe the problem. What did you see? What did you expect to see?

When comparing a CString literal to a stored CString variable using the == operator, comparison is false even when value of CString is the same.

If this is a code issue, provide a minimal code example:

import kit.map;
import kit.array;

trait Component{
    function type(): CString;
}

struct PositionComponent{
    public var x: Int;
    public var y: Int;
    public var z: Int;
}

implement Component for PositionComponent{
    function type(): CString{
        return "Position";
    }
}

function main() {

    var myMap: Map[CString, Box[Component]] = Map.new(10);

    var myPosStruct = struct PositionComponent{
        x: 12,
        y: 12,
        z: 23
    };

    var myPosStructBox: Box[Component] = myPosStruct;
    myMap.put(myPosStructBox.type(), myPosStructBox);

    var keys = myMap.keys();

    printf("myMap has PositionComponent: %s\n", if myMap.exists(myPosStructBox.type()) then "true" else "false");
    printf("myMap has PositionComponent: %s\n", if myMap.exists(keys[0]) then "true" else "false");
    printf("myMap has PositionComponent: %s\n", if myMap.exists("Position") then "true" else "false");
}

Which outputs:

myMap has PositionComponent: true
myMap has PositionComponent: true
myMap has PositionComponent: false

However all three should be true.

• Kit version: git, commit 866ae15;
• OS/Platform: Linux.

Describe the problem. What did you see? What did you expect to see?

Creating an empty prelude file in root of the project overwrite the std.

If this is a code issue, provide a minimal code example:

function main() {
	var zero = 0;
}

this lead to:

Error: Sanity check failed: couldn't required trait kit.numeric.Numeric, which should be provided by the standard library; check your kitc installation
----------------------------------------
Error: Sanity check failed: couldn't required trait kit.numeric.Integral, which should be provided by the standard library; check your kitc installation
----------------------------------------
Error: Sanity check failed: couldn't required trait kit.numeric.NumericMixed, which should be provided by the standard library; check your kitc installation
----------------------------------------
Error: Sanity check failed: couldn't required trait kit.iterator.Iterator, which should be provided by the standard library; check your kitc installation
----------------------------------------
Error: Sanity check failed: couldn't required trait kit.iterator.Iterable, which should be provided by the standard library; check your kitc installation

• Kit version: 0.1.0
• OS/Platform: (Linux)

Describe the problem. What did you see? What did you expect to see?

When using generics, and a tuple in an Array, I get an error.

[email protected]:~/Documents/Sobreviver$ kitc map --lib
[2018-10-28 13:57:55.517743] ===> parsing and building module graph
[2018-10-28 13:57:55.532441] ===> processing C includes
[2018-10-28 13:57:55.728193] ===> resolving module types
[2018-10-28 13:57:55.737627] ===> typing module content
[2018-10-28 13:57:55.772649] ===> generating intermediate representation
----------------------------------------
Error: /usr/lib/kit/kit/array.kit:6: Couldn't find underlying type for type
    param map.Map.K; this is probably an error with monomorph generation!

  @/usr/lib/kit/kit/array.kit:6:5-12
       6        var data: Ptr[T];
                ^^^^^^^^

If this is a code issue, provide a minimal code example:

Here are the relevant parts of the code:

struct Map[K, V]
{
    private var size: Int;
    private var allocator: Box[Allocator];
    private var internalArray : Array[(K, V)];

    public static function new(allocator: Box[Allocator]): Map[K, V] using implicit allocator
    {
        var internalArray: Array[(K, V)] = Array.new(10);
        return struct Self
        {
            size: 0,
            allocator,
            internalArray,
        };

    }

}

The compiler accepts comparison between a char CArray and a CString but it is not compiled/executed as a string comparison correctly! (results here are random).

struct Instr {
    var mnem: CArray[Char, 8]; // mnemonic of op
    var valF: Float32;
}

// interpret instruction
function interp(instr: Instr, stack: Ptr[Stack]) {
    if (instr.mnem) == "PUSHCF  " {
        stack.arr[stack.idx++] = instr.valF; // push
        printf("PUSH\n");
    }
    else if instr.mnem == "LININTER" {
        var intr = stack.arr[stack.idx--];
        var b = stack.arr[stack.idx--];
        var a = stack.arr[stack.idx--];
        
        stack.arr[stack.idx++] = a*(1.0-intr) + (b-a)*intr;
        printf("LININTER\n");
    }
}

The compiler should infer types correctly and not push type-inference to the backend (C).

If this is a code issue, provide a minimal code example:

include "math.h";
function exp(v:(Float64,Float64)):(Float64,Float64) {
    var r = expf(v[0]);
    var d = 0.0;
    return (r,d);
}

gives a compile error from the gcc:

Error: build/lib/kit_test0.c: In Funktion »test0__exp«:
build/lib/kit_test0.c:19:12: Fehler: unverträgliche Typen bei Rückgabe von Typ »struct tuple2bf0b99cc56f6aa69d896315«, aber »struct tuplee7731a893109b41a186a62ef« wurde erwartet
   19 |     return (struct tuple2bf0b99cc56f6aa69d896315) {.__slot0 = r, .__slot1 = d};
      |            ^

I tried to see what the compiler is doing and got a crash trying to compile a simple hello world with kitc -vvv test0.kit

function main() {
    printf("%s\n", "Hello from Kit!");
}

Result:

CallStack (from HasCallStack):
  error, called at libraries/base/GHC/Err.hs:79:14 in base:GHC.Err
  undefined, called at src/Kit/Ast/Definitions/EnumVariant.hs:38:24 in kitlang-0.1.0-7uWjdU81ybAH34QXJWKK6w:Kit.Ast.Definitions.EnumVariant

I made a simple file hello.kit file containing:

function main() {
    printf("%s\n", "Hello from Kit!");
}

and tried to compile it using kitc hello.kit. At the linking stage I get a bunch of "multiple definition" errors for all kinds of symbols (e.g. kit_mem_Allocator__...). This seems logical, as the generated build/include/main.h file contains these definitions, but it is included in every .c-file and does not contain a header guard or similar. I assume this is not intended behavior, so what could be going wrong on my side?

Environment

[2020-08-01 16:26:57.1947] ===> kitc version
[2020-08-01 16:26:57.2686] DBG: 0.1.0
[2020-08-01 16:26:57.3465] ===> OS
[2020-08-01 16:26:57.4413] DBG: mingw32
[2020-08-01 16:26:57.4813] ===> Source paths
[2020-08-01 16:26:57.5721] ===> Standard prelude location
[2020-08-01 16:26:57.6480] DBG: C:\tools\kit\std\prelude.kit
[2020-08-01 16:26:57.6900] ===> ** COMPILER **
[2020-08-01 16:26:57.7339] ===> Toolchain
[2020-08-01 16:26:57.7898] DBG: C:\tools\kit\toolchains\windows-mingw
[2020-08-01 16:26:57.8433] ===> Compiler
[2020-08-01 16:26:58.6820] DBG: gcc
gcc (Rev1, Built by MSYS2 project) 10.2.0
Copyright (C) 2020 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO 
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

[2020-08-01 16:26:59.4545] ===> Include paths
[2020-08-01 16:26:59.4745] DBG: []
[2020-08-01 16:26:59.5274] ===> Compiler flags
[2020-08-01 16:26:59.5723] DBG: ["-D__USE_MINGW_ANSI_STDIO","-std=c99","-pedantic","-O3","-Os","-Wno-missing-braces","-Wno-shift-op-parentheses"]
[2020-08-01 16:26:59.7491] ===> Linker flags
[2020-08-01 16:26:59.7810] DBG: ["-std=c99","-pedantic","-O3","-Os","-Wno-missing-braces","-Wno-shift-op-parentheses"]

I see mingw32 here, not mingw64, is that a problem? I got it from the scoop package, but am using my existing install of gcc-mingw64 via msys2.

It does not compile on Freebsd 12.1. Error : /home/x/_kit/kit-dev x> $stack build Preparing to install GHC (ino64) to an isolated location. This will not interfere with any system-level installation. Downloaded ghc-ino64-8.4.3.
rts-1.0: Warning: .:464:1: The field "hugs-options" is deprecated. hugs isn't supported anymore Installed GHC.
Found an invalid compiler at "/usr/home/x/.stack/programs/x86_64-freebsd/ghc-ino64-8.4.3/bin/ghc-8.4.3": Control.Exception.Safe.throwString called with:

Could not find any of: ["/usr/home/x/.stack/programs/x86_64-freebsd/ghc-ino64-8.4.3/bin/haddock-8.4.3","/usr/home/x/.stack/programs/x86_64-freebsd/ghc-ino64-8.4.3/bin/haddock-ghc-8.4.3","/usr/home/x/.stack/programs/x86_64-freebsd/ghc-ino64-8.4.3/bin/haddock","/usr/home/x/.stack/programs/x86_64-freebsd/ghc-ino64-8.4.3/bin/haddock-ghc"] Called from: throwString (src/Stack/Setup.hs:721:25 in stack-2.1.3.1-inplace:Stack.Setup)

Used stack version : hs-stack-2.1.3.1 Default ghc: ghc-8.6.5_3