casc-lang / yakou Goto Github PK

"a" + java::lang::Integer::toString(1)

This will cuase parsing error somehow, require further investigation at toString(1)

CASC code:

a := 1
b := a as i64

is same as:

int a = 1;
long b = (long) a;

Possible solution: generate a temporary .class file for ASM to infer (between declaration checking phase and body checking phase)

Summary

Check (Prelude) is used to emit compiled unchecked files into bytecode and load it in current compilation process, this is needed because ClassWriter::getCommonType(String, String) from ASM lib requires types already exists in JVM environment. But we can override it by checking caching to make sure class exists with our internal type table.

Pros:

By profiling our compiler, it seems it has some relatively heavy performance penalty from ClassLoader::defineClass(byte[]). With this proposal, we can reduce lots of time on compilation.

Cons:

Our typing system needs to be refined so no cached class will be requested to ClassLoader::loadClass(String) calling and throws exception.

Current status

• Implement type symbol table lookup in CommonClassWriter::getCommonType
• Remove phase Check (Prelude)
• Stablize cached class registeration (including separating JVM-loaded class and cached class)

Need to implement & resolve #31 first

public in default.

Currently we only support primitive types (I'm not sure why there's no System.out.println(S)V), we'll need to support object's print and println.

Possible solution: Checkout dcmpl and dcmpg opcodes

1. To declare a non-companion function, add self keyword in parameter list like rust does:

impl Main {
    pub fn hello(self, s: str[]) {
        //...
    }
}

2. Vice versa, declare companion function without self in parameter list:

impl Main {
    pub fn hello(s: str[]) {
        //...
    }
}

3. Treat companion block in impl block like Java's static block

impl Main {
    comp {
        System.out.println("Hello");
    }
}

The above example does the same thing as the following Java code:

class Main {
    static {
        System.out.println("Hello");
    }
}

By doing this, we can remove explicit type() calling while cached file is not loaded by JVM

• Trait
• Annotation
• Abstract Class

I. Discard ANTLR

Reason:
Although ANTLR can greatly provides huge development assistance on lex-parse units, but there are still some big cons come along with: Proper error message is hard to implement, Heavily depends on ANTLR library (not very fine since might encounters some unknown library-internal bugs, thus causes compiler errors even syntax is fine). Therefore, we are going to revamp lex-parse unit manually.

II. Enhance code quality

Reason:
Currently, few parts of entire compiler has either TODO or comment, which is not very developer friendly when others want to either contribute CASC compiler unit or take it as an education source, plus there's tons of improper OOP design, which could end up with even creator himself (which is me lol) doesn't actually know how it works.

You can track this issue's progress in branch Revamp. Before this issue being resolved, all other issue are temporarily not in progress.

Note: This Issue's finish date is TBA, and there'll be some minor syntax changes as well.

• Should not run into OutOfHeap problem

Current array syntax will conflict with identifier call in BNF grammar, to avoid this, we will introduce Rust's solution:

a := [i32; 3] // array declaration
b := [; 3]{ 1, 2, 3 } // array initialization (no type)
c := [i32; 3]{ 1, 2, 3 } // array initialization
d := [[i32; 3]; 3] // multidimensional array declaration
// and so on

This syntax will greatly makes lots of works easier.

Additionally, we might change array type's syntax (Not final syntax):

i32[]
// into:
[i32]

The following code should throw : "Duplicated field declarations is not allowed."

priv mut:
    a: i32
priv mut:
    b: i32

Continue from issue #45, refers to JVM spec dcmp

Both array initiation and index operator.

intArrayOf()

There are several problem may occurs unexpected issue, need to implement a proper diagnostic system in order to terminate entire compilation as long as there are something went wrong.

• [] Use object class to store diagnostic info.
• [] Terminate when there are problems in lexing / parsing / analyzing / emitting phase.

This should not happen ;)

You should add multiple assignment syntax for no reason
It's a cool feature in Lua which makes variadic function and multiple return possible
a, b = 1, 2

Reference:
https://www.lua.org/pil/4.1.html

File: example/Donut.casc

This happens when the if expression in line 37 has && or || operators involved in condition expression.

infinite loop:

for {
    //...
}

detailed loop:

for (i := 1; i < 10; i++) {
    //...
}

predicate loop:

for i < 10 {
    //...
}

CASC doesn't allow declaring array without top dimension size provided:

// err
a := [i32;]{}
b := [[i32;];]{}
// ok
c := [i32;10]{}
d := [[i32;];10]{}

1. Detect circular secondary constructor call then terminate compilation
2. Since secondary constructor must implement primary or another secondary one, move the self call into a parsing rule.

byte -> i8
short -> i16
int -> i32
long -> i64
etc.

This issue is part of refactoring task

Possible solution:

File#getAbsoluteFile

This issue is found by @palapapa