Is it possible somehow to "recover" object instance from PlatformObject

[fluorumlabs]

Let's say I have

Integer x = 5;
PlatformObject nativeObj = Platform.getPlatformObject(x);
// pass nativeObj via some 3rd party JS library
Integer y = (Integer)nativeObj;
Integer z = y + 1;

The last line will fail with $intValue is not a function, because Integer is not a final class and, therefore, TeaVM is not sure which method to call (which is logical), so it's considering intValue a virtual method for this instance. Is it possible somehow to "fake" TeaVM into thinking that (Integer)nativeObj is a concrete instance of Integer?

So far the only thing that comes to mind is to add a new "dummy" empty constructor via class transformer to all classes (which does nothing), then do something like

Integer[] tempArray = new Integer[](1);
tempArray[0] = /* inject instance creation and a call to dummy constructor of Integer */;
/* overwrite element 0 of tempArray with other PlatformObject via JS call */
Integer y = tempArray[0];

Other alternative would be to create via ClassTransformer (again) a constructor taking PlatformObject as an argument, where Object.<init>(PlatformObject that) will call Object.assign(this, that).

Or is there some other better approach?

p.s. TeaVM 0.6.0, platform JS

[konsoletyper]

Hello. It's not valid to cast subtype of JSObject to a type that is not subtype of JSObject. Also, it's not valid to use PlatformObject in user code, since it was designed for writing TeaVM internals. The real reason for such restriction is DCE, which does not know anything about behaviour of JS code. Therefore it does not know if JSObject is really an Integer. Therefore when you call y.intValue(), TeaVM does not know that you really call Integer.intValue. In case of final classes it could be inferred by type in callsite (TeaVM does not do that), but in general case it's impossible. TeaVM should have reported a compile-time error in this code, and I think I had a branch with such diagnostic, but it produced some non-obvious problems and I did not merge it into master.

For what purpose you need pass Java objects to JavaScript and get them back in Java?

[konsoletyper]

The real solution for this is to tell DCE how to treat these external JS object. For example:

  static class JavaObjectExporterDependency extends AbstractDependencyListener {
    DependencyNode node;

    @Override
    public void started(DependencyAgent agent) {
      node = agent.createNode();
    }

    @Override
    public void methodReached(DependencyAgent agent, MethodDependency method) {
      if (method.getMethod().getOwnerName().equals(JavaObjectExporter.class.getName())) {
        switch (method.getMethod().getName()) {
          case "asJsObject":
            method.getVariable(1).connect(node);
            break;
          case "asJavaObject":
            node.connect(method.getResult());
            break;
        }
      }
    }
  }

[fluorumlabs]

My use case is Vue/Vuex integration (https://github.com/fluorumlabs/disconnect-project), where I have some places where Java object is stored inside Vuex storage to be retrieved later, or passed via observers.

I'm not quite sure I understood how snippet from #424 (comment) works or should be used (apart from obvious registration via TeaVMPlugin).

[fluorumlabs]

For now I'm using this approach (generated via Annotation processor). Obviously it assumes that the field name would be exactly that ($ + field name), which is probably not the case when minification is enabled. Faking via array would work better, but will still require some constructor overrides in case "target" class do not have no-args constructor.

...
    private static LoadingState instanceConvert(JSObject state) {
        ((Mirror) Platform.getPlatformObject(MIRROR)).setValue(state);
        return MIRROR.org_vaadin_disconnect_demo_client_LoadingState;
    }

    private static final MirrorHelper MIRROR = new MirrorHelper();

    private interface Mirror extends JSObject {
        @JSBody(params = "object", script = "this.$org_vaadin_disconnect_demo_client_LoadingState = object;")
        void setValue(JSObject object);
    }

    private static class MirrorHelper {
        LoadingState org_vaadin_disconnect_demo_client_LoadingState = new LoadingState();
    }

[konsoletyper]

I don't think that integration with Vue is a good idea. That's the reason I wrote Flavour.

I'm not quite sure I understood how snippet from #424 (comment) works or should be used

You can create you own class that's responsible for passing objects between Java and JavaScript with two native methods. That you write plugin to implement these native methods. First, this plugin should contribute dependency analyzer listener. Second, this plugin should contribute custom renderer for these methods.

The approach with '$' + fieldName is incorrect and must not be used. TeaVM generates names with some non-trivial algorithm and intValue may be changed unexpectedly.

[fluorumlabs]

I don't think that integration with Vue is a good idea. That's the reason I wrote Flavour.

It works quite nicely so far: https://disconnect-demo.herokuapp.com/ ;)

The approach with '$' + fieldName is incorrect

I know. That's why I thought that using Object[] is better (as it's data field name is coming from TeaVM runtime js). It's more stable yet it still requires a way to create a (proper) object instance first. At first I thought that invoking ConstructInstruction is enough for TeaVM to establish DCE link, but I was wrong ;) If only there would be a way to forcibly tell TeaVM that particular instance is of some concrete class...

Something like <T> T forceCast(PlatformObject x, Class<T> clazz), which will produce (in case called with forceCast(nativeInt, Integer.class)) Integer with working intValue...

[konsoletyper]

It works quite nicely so far: https://disconnect-demo.herokuapp.com/ ;)

It may work, but it's still not a good idea. Frameworks like Vue and React are designed for JavaScript idioms, not for Java idioms. This can cause major problems somewhere at integration layers (like this particular problem). AFAIK, Vue had some problems integrating even with TypeScript, which is much closer to JS than Java. Why do you think Google wrote separate implementation of Angular in Dart, rather than integrating JavaScript Angular with Dart?

I know. That's why I thought that using Object[] is better (as it's data field name is coming from TeaVM runtime js). It's more stable yet it still requires a way to create a (proper) object instance first. At first I thought that invoking ConstructInstruction is enough for TeaVM to establish DCE link, but I was wrong ;) If only there would be a way to forcibly tell TeaVM that particular instance is of some concrete class...

Something like T forceCast(PlatformObject x, Class clazz), which will produce (in case called with forceCast(nativeInt, Integer.class)) Integer with working intValue...

Please, do not invent solutions, they won't work. I provided workaround for you above. Please, use it. If there's something unclear, just ask questions.

[fluorumlabs]

On the workaround.

Since the documentation for TeaVM internals does not exist, could you please explain, what exactly method.getVariable(1).connect(node); and node.connect(method.getResult()); do?

What are the signatures for the above mentioned asJsObject and asJavaObject?

Does it require that calls to asJavaObject will work only after first call to asJsObject?

Do I need to create DependencyNode per invocation?

How the target object class is defined?

[konsoletyper]

what exactly method.getVariable(1).connect(node); and node.connect(method.getResult()); do?

Dependency anlyzer uses data flow analysis to determine set of classes that each variable can actually take. Each assignment like a = b produces connection from b to a. In terms of data flow it can be represented like bVariable.connect(aVariable). method.getVariable(n) returns n-th variable of corresponding method. this always has index 0 (even in static methods!), first parameter has index 1, second parameter has index 2, etc. Also, you can access method's nodes that correspond to returning values (method.getResult()) and thrown values (method.getThrown()). The code I provided creates node that does not belong to any method. This node corresponds to 'outer world' (i.e. JS code). So, the purpose of asJsObject is to transfer its parameter to JavaScript (you connect first parameter to outer world node), and the purpose of asJavaObject is to transfer its parameter from JavaScript to Java (you connect outer world to its returning node).

What are the signatures for the above mentioned asJsObject and asJavaObject?

public static native JSObject asJsObject(Object javaObject);

public static native Object asJavaObject(JSObject jsObject);

Does it require that calls to asJavaObject will work only after first call to asJsObject?

Sorry, don't understand this question. Obviously, the only way to get Java object somewhere in JavaScript is to create this object on Java side and pass it to asJsObject. But once it here, it can be passed back to Java as many times as you need.

Do I need to create DependencyNode per invocation?

No, started method is only invoked once, when TeaVM prepares compilation. You don't need several 'outer worlds', you only need one. But if you need multiple node, you sure can create as many as you want.

How the target object class is defined?

You don't need to define it. You get java.lang.Object and then you can cast it to whatever you want.

[fluorumlabs]

Thanks it's getting clearer now.

[fluorumlabs]

Thanks again! I don't know why, but your solution seems to be working just fine.

I made these methods:

    public static JSObject asJsObject(Object that) {
        return Platform.getPlatformObject(that);
    }

    public static <T> T asJavaObject(JSObject that) {
        return (T)(Object)that;
    }

and then used your DependencyListener as is.