Release Notes v0.4.0

What's new?

CaesarJ Compiler

Virtual Class Scoping

 
public cclass A {
    public cclass X {...}
    public cclass Y extends X {...}
}

public cclass B extends A {
    public cclass Z extends Y {...}
}

In the earlier versions it was necessary to make an empty redefiniton of Y in B. The current compiler version extends the Java lookup rules, hence, extends Y is recognized as B.Y, rather than A.Y.

Method redefinition Mechanism

Methods having in their signatures references to virtual classes can be redefined now.

 
public cclass A {
    public cclass X {...}
    public void doSomethingWithX(X x) {...}
}

public cclass B extends A {
    public cclass X {...} // furtherbinding 
    public void doSomethingWithX(X x) {...}
}

In the current version the compiler will automatically ensure that the signatures of the redefined methods are compatible to the method redefiniton mechanism provided by Java.

Automatic Casts

Expressions which have a virtual types are automatically casted to the most specific type, which can be statically determined.

 
public cclass A {
    private X x;
    public cclass X {...}
}

public cclass B extends A {
    public cclass X {
        public void someNewMethodIntroduced() {...}
    }

    public void doSomething() {
        // The reference x is casted to the most specific X known in the context
        x.someNewMethodIntroduced();
    }
}

CJDT

Added Outline Views for Caesar source files.
Added Hierarchy and Mixin List View for Caesar types

Bug Fixes

Please consider the bugtracking tool [http://www.st.informatik.tu-darmstadt.de:8080/mantis/] for the list of open/resolved bugs.

Known Limitations

Arrays of cclass-es are not allowed.
The type checking according family polymorphism rules is not implemented. For this reason the programmer has to manually ensure that objects are not mixed among incompatible families.
It is not possible for Caesar classes to inherit from pure Java classes. Nevertheless Caesar classes can implement Java interfaces.
Caesar does not support abstract classes, so abstract methods must be replaced with methods with empty bodies.
Direct access to data members of another object is not possible, even if this object is of the same class or it is the outer object. Access to inherited data members is possible.
Constructors of Caesar classes cannot take parameters. So more sophisticated initialization must be achieved through additional initializing method call after the object is created.
Some language constructs are currently expressed by a temporary syntax. Access to outer object is achieved through variable $outer.
Pointcut language cannot refer to Caesar type system but rather to the underlying generated Java classes and interfaces.