diff --git a/ast_java.cpp b/ast_java.cpp
index 0be172c..1dd3818 100644
--- a/ast_java.cpp
+++ b/ast_java.cpp
@@ -22,6 +22,13 @@
 using std::vector;
 using std::string;
 
+template <class... Ts>
+struct overloaded : Ts... {
+  using Ts::operator()...;
+};
+template <class... Ts>
+overloaded(Ts...)->overloaded<Ts...>;
+
 namespace android {
 namespace aidl {
 namespace java {
@@ -114,18 +121,15 @@
 
 void Variable::Write(CodeWriter* to) const { to->Write("%s", name.c_str()); }
 
-FieldVariable::FieldVariable(Expression* o, const string& n)
-    : object(o), clazz(nullptr), name(n) {}
+FieldVariable::FieldVariable(Expression* o, const string& n) : receiver(o), name(n) {}
 
-FieldVariable::FieldVariable(const Type* c, const string& n)
-    : object(nullptr), clazz(c), name(n) {}
+FieldVariable::FieldVariable(const string& c, const string& n) : receiver(c), name(n) {}
 
 void FieldVariable::Write(CodeWriter* to) const {
-  if (this->object != nullptr) {
-    this->object->Write(to);
-  } else if (this->clazz != nullptr) {
-    to->Write("%s", this->clazz->JavaType().c_str());
-  }
+  visit(
+      overloaded{[&](Expression* e) { e->Write(to); },
+                 [&](const std::string& s) { to->Write("%s", s.c_str()); }, [](std::monostate) {}},
+      this->receiver);
   to->Write(".%s", name.c_str());
 }
 
@@ -161,17 +165,15 @@
   to->Write(";\n");
 }
 
-Assignment::Assignment(Variable* l, Expression* r)
-    : lvalue(l), rvalue(r), cast(nullptr) {}
+Assignment::Assignment(Variable* l, Expression* r) : lvalue(l), rvalue(r) {}
 
-Assignment::Assignment(Variable* l, Expression* r, const Type* c)
-    : lvalue(l), rvalue(r), cast(c) {}
+Assignment::Assignment(Variable* l, Expression* r, string c) : lvalue(l), rvalue(r), cast(c) {}
 
 void Assignment::Write(CodeWriter* to) const {
   this->lvalue->Write(to);
   to->Write(" = ");
-  if (this->cast != nullptr) {
-    to->Write("(%s)", this->cast->JavaType().c_str());
+  if (this->cast) {
+    to->Write("(%s)", this->cast->c_str());
   }
   this->rvalue->Write(to);
 }
@@ -185,20 +187,19 @@
   va_end(args);
 }
 
-MethodCall::MethodCall(Expression* o, const string& n) : obj(o), name(n) {}
+MethodCall::MethodCall(Expression* o, const string& n) : receiver(o), name(n) {}
 
-MethodCall::MethodCall(const Type* t, const string& n) : clazz(t), name(n) {}
+MethodCall::MethodCall(const std::string& t, const string& n) : receiver(t), name(n) {}
 
-MethodCall::MethodCall(Expression* o, const string& n, int argc = 0, ...)
-    : obj(o), name(n) {
+MethodCall::MethodCall(Expression* o, const string& n, int argc = 0, ...) : receiver(o), name(n) {
   va_list args;
   va_start(args, argc);
   init(argc, args);
   va_end(args);
 }
 
-MethodCall::MethodCall(const Type* t, const string& n, int argc = 0, ...)
-    : clazz(t), name(n) {
+MethodCall::MethodCall(const std::string& t, const string& n, int argc = 0, ...)
+    : receiver(t), name(n) {
   va_list args;
   va_start(args, argc);
   init(argc, args);
@@ -213,12 +214,13 @@
 }
 
 void MethodCall::Write(CodeWriter* to) const {
-  if (this->obj != nullptr) {
-    this->obj->Write(to);
-    to->Write(".");
-  } else if (this->clazz != nullptr) {
-    to->Write("%s.", this->clazz->JavaType().c_str());
-  }
+  visit(
+      overloaded{[&](Expression* e) {
+                   e->Write(to);
+                   to->Write(".");
+                 },
+                 [&](const std::string& s) { to->Write("%s.", s.c_str()); }, [](std::monostate) {}},
+      this->receiver);
   to->Write("%s(", this->name.c_str());
   WriteArgumentList(to, this->arguments);
   to->Write(")");
diff --git a/ast_java.h b/ast_java.h
index 1a65d85..33bc3be 100644
--- a/ast_java.h
+++ b/ast_java.h
@@ -21,6 +21,7 @@
 #include <memory>
 #include <optional>
 #include <string>
+#include <variant>
 #include <vector>
 
 enum {
@@ -102,12 +103,11 @@
 };
 
 struct FieldVariable : public Expression {
-  Expression* object;
-  const Type* clazz;
+  std::variant<Expression*, std::string> receiver;
   std::string name;
 
   FieldVariable(Expression* object, const std::string& name);
-  FieldVariable(const Type* clazz, const std::string& name);
+  FieldVariable(const std::string& clazz, const std::string& name);
   virtual ~FieldVariable() = default;
 
   void Write(CodeWriter* to) const;
@@ -163,17 +163,16 @@
 struct Assignment : public Expression {
   Variable* lvalue;
   Expression* rvalue;
-  const Type* cast;
+  std::optional<std::string> cast = std::nullopt;
 
   Assignment(Variable* lvalue, Expression* rvalue);
-  Assignment(Variable* lvalue, Expression* rvalue, const Type* cast);
+  Assignment(Variable* lvalue, Expression* rvalue, std::string cast);
   virtual ~Assignment() = default;
   void Write(CodeWriter* to) const override;
 };
 
 struct MethodCall : public Expression {
-  Expression* obj = nullptr;
-  const Type* clazz = nullptr;
+  std::variant<std::monostate, Expression*, std::string> receiver;
   std::string name;
   std::vector<Expression*> arguments;
   std::vector<std::string> exceptions;
@@ -181,9 +180,9 @@
   explicit MethodCall(const std::string& name);
   MethodCall(const std::string& name, int argc, ...);
   MethodCall(Expression* obj, const std::string& name);
-  MethodCall(const Type* clazz, const std::string& name);
+  MethodCall(const std::string& clazz, const std::string& name);
   MethodCall(Expression* obj, const std::string& name, int argc, ...);
-  MethodCall(const Type* clazz, const std::string& name, int argc, ...);
+  MethodCall(const std::string&, const std::string& name, int argc, ...);
   virtual ~MethodCall() = default;
   void Write(CodeWriter* to) const override;
 
diff --git a/generate_java_binder.cpp b/generate_java_binder.cpp
index c3b41e8..847e65c 100644
--- a/generate_java_binder.cpp
+++ b/generate_java_binder.cpp
@@ -608,13 +608,13 @@
 
   // the parcels
   Variable* _data = new Variable(types->ParcelType()->JavaType(), "_data");
-  proxy->statements->Add(new VariableDeclaration(
-      _data, new MethodCall(types->ParcelType(), "obtain")));
+  proxy->statements->Add(
+      new VariableDeclaration(_data, new MethodCall(types->ParcelType()->JavaType(), "obtain")));
   Variable* _reply = nullptr;
   if (!oneway) {
     _reply = new Variable(types->ParcelType()->JavaType(), "_reply");
-    proxy->statements->Add(new VariableDeclaration(
-        _reply, new MethodCall(types->ParcelType(), "obtain")));
+    proxy->statements->Add(
+        new VariableDeclaration(_reply, new MethodCall(types->ParcelType()->JavaType(), "obtain")));
   }
 
   // the return value
diff --git a/type_java.cpp b/type_java.cpp
index c38ef81..27fe9d4 100644
--- a/type_java.cpp
+++ b/type_java.cpp
@@ -54,7 +54,7 @@
     return new LiteralExpression("0");
   }
   if ((flags & PARCELABLE_WRITE_RETURN_VALUE) != 0) {
-    return new FieldVariable(m_types->ParcelableInterfaceType(),
+    return new FieldVariable(m_types->ParcelableInterfaceType()->JavaType(),
                              "PARCELABLE_WRITE_RETURN_VALUE");
   }
   return new LiteralExpression("0");