Would everything still work if the if statement is moved into the one above?

In other words, can ".object" be added without ".$val" in front of it?

Asking to learn.

Would everything still work if the if statement is moved into the one above?

If you mean:

if _, isInterface := implicit.Type().Underlying().(*types.Interface); !isInterface {
  value += ".$val"

  if typesutil.IsJsObject(implicit.Type().Underlying()) {
    value += ".object"
  }
}

then yes, that's logically equivalent (because something cannot have an underlying type that is both an interface and *js.Object).

In other words, can ".object" be added without ".$val" in front of it?

This is more to do with the structure of the value being type asserted (in Javascript world). Where a Javascript variable, say x, holds a value of an interface type, x.$val will give us the underlying value, regardless of type. Where the underlying value is a struct val or a pointer to a struct val, then it so happens that x.$val === x, hence x.$val.object === x.object.

So yes, we could elide the .$val in the case where the type in the switch case is *js.Object (because we know the structure of js.Object) but to my mind it's clearer and more consistent (with the rest of the code base) to keep things accessing via .$val.

Asking to learn.

I've still got lots to learn about this code base: I dip in and out of it as required 😄

... and it's quite possible some of my understanding is wrong let alone incomplete!

If you mean:

if _, isInterface := implicit.Type().Underlying().(*types.Interface); !isInterface {
  value += ".$val"

  if typesutil.IsJsObject(implicit.Type().Underlying()) {
    value += ".object"
  }
}

Yes, that's what I meant. I wanted to know if something would break/change if the code were written that way.

then yes, that's logically equivalent (because something cannot have an underlying type that is both an interface and *js.Object).

Okay, I see.

To confirm my understanding is correct, let me try to answer my question:

In other words, can ".object" be added without ".$val" in front of it?

No, ".object" cannot be added without ".$val" also being added.

Only these 3 scenarios are possible:

1. implicit.Type().Underlying() type is an interface - then value stays as is
2. implicit.Type().Underlying() type is not an interface, but it's not *js.Object either - then value gets ".$val" appended
3. implicit.Type().Underlying() type is not an interface, it is *js.Object - then value gets ".$val.object" appended

No other possibility exists.

If my understanding is indeed correct, then wouldn't the code become simpler (to understand and reason about) if you do move the if statement inside?

Actually, I think the readability/clarity of can happen would be improved even more if you made it an if/else if statement with these 2 cases:

if typesutil.IsJsObject(implicit.Type().Underlying()) {
	value += ".$val.object"
} else if _, ok := implicit.Type().Underlying().(*types.Interface); !ok {
	value += ".$val"
}

(I also renamed isInterface to just ok because I think the long variable name doesn't actually improve readability here; but this is orthogonal and optional.)

What do you think? Is that better, worse, or the same in your opinion?

I easy either way. I don't think it's particularly unclear one way or the other. I've made the change, rebased this branch and pushed.