Design: Overlay Types

1. Every overlay type is transformed from a class to an empty interface.

1. Every overlay type is copied into an implementation class.
2. The new type has the same name as the old type, plus the $ character appended.
3. The new type's superclass is the implementation class of its original superclass (except for JavaScriptObject$ itself whose superclass remains Object).
4. All instance methods are made static and given a synthetic this parameter of the interface type.
• All this references are changed to access the synthetic parameter.
5. All static methods and fields are copied unchanged.

1. References methods and fields in overlay types are rewritten to target that overlay implementation type.
2. Instance methods calls are also rewritten as static calls; the instance qualifier becomes argument 0.

1. Marshalling of reference-type JsValues into Java used to be based only on the declared type of the value. Now it is based only on the runtime type of the value.
2. A ClassCastException is thrown if the marshalled value does not conform to the declared type of the value.
3. JavaScript strings (both primitive and wrapper) always marshal as Java String. It no longer legal to pass a string if an overlay type is declared.
4. JavaScript non-string objects always marshal as JavaScriptObject$.
5. Wrapped Java objects are always unwrapped. It is no longer legal to treat a wrapped Java Object as an overlay type.

1. Previously, declaring an overlay type argument used to be the trigger for unwrapping an overlay type into its native value. Declaring an argument of type Object and passing in an overlay type instance would cause the instance to be rewrapped. Now, any overlay type object passing into JavaScript is always unwrapped back to the underlying JavaScript object.
2. Java String is always passed as a JavaScript string value, even if the declared type is Object.

public class Customer extends JavaScriptObject {
  public final native String getFirstName() /*-{ return this.first_name; }-*/;

  public final native String getLastName() /*-{ return this.last_name; }-*/;

  public final native int computeAge() /*-{ return this.getComputedAge(); }-*/;

  final native String getArea();
}

public class Shape extends JavaScriptObject {
  public final native double getArea() /*-{ return this.getArea(); }-*/;
}

public class Rectangle extends Shape {
  public final native int getWidth();
  public final native int getHeight();
}

public void foo(Customer c) {
  System.out.println(c.getFirstName());
  System.out.println(c.getArea());        // prints a string
  Shape s = (Shape) (JavaScriptObject) c; // succeeds always
  System.out.println(s.getArea());        // prints a double
}

interface Customer extends JavaScriptObject { }
class Customer$ {
  public static String getFirstName(Customer this) { ... }
  // etc
}

interface Shape extends JavaScriptObject {
class Shape$ {
  public static double getArea(Shape this) { ... }
}

interface Rectangle extends Shape {
class Rectangle$ {
  public static int getWidth(Rectangle this) { ... }
  public static int getHeight(Rectangle this) { ... }
}

public void foo(Customer c) {
  System.out.println(Customer$.getFirstName(c));
  System.out.println(Customer$.getArea(c)); // prints a string
  Shape s = (Shape) (JavaScriptObject) c;   // succeeds always
  System.out.println(Shape$.getArea(s));    // prints a double
}