diff --git a/ast_java.cpp b/ast_java.cpp
index 5eab218..f997494 100644
--- a/ast_java.cpp
+++ b/ast_java.cpp
@@ -65,7 +65,7 @@
   }
 }
 
-void WriteArgumentList(CodeWriter* to, const vector<Expression*>& arguments) {
+void WriteArgumentList(CodeWriter* to, const vector<std::shared_ptr<Expression>>& arguments) {
   size_t N = arguments.size();
   for (size_t i = 0; i < N; i++) {
     arguments[i]->Write(to);
@@ -75,7 +75,7 @@
   }
 }
 
-Field::Field(int m, Variable* v) : ClassElement(), modifiers(m), variable(v) {}
+Field::Field(int m, std::shared_ptr<Variable> v) : ClassElement(), modifiers(m), variable(v) {}
 
 void Field::Write(CodeWriter* to) const {
   if (this->comment.length() != 0) {
@@ -113,13 +113,14 @@
 
 void Variable::Write(CodeWriter* to) const { to->Write("%s", name.c_str()); }
 
-FieldVariable::FieldVariable(Expression* o, const string& n) : receiver(o), name(n) {}
+FieldVariable::FieldVariable(std::shared_ptr<Expression> o, const string& n)
+    : receiver(o), name(n) {}
 
 FieldVariable::FieldVariable(const string& c, const string& n) : receiver(c), name(n) {}
 
 void FieldVariable::Write(CodeWriter* to) const {
   visit(
-      overloaded{[&](Expression* e) { e->Write(to); },
+      overloaded{[&](std::shared_ptr<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());
@@ -142,24 +143,26 @@
   to->Write("}\n");
 }
 
-void StatementBlock::Add(Statement* statement) {
+void StatementBlock::Add(std::shared_ptr<Statement> statement) {
   this->statements.push_back(statement);
 }
 
-void StatementBlock::Add(Expression* expression) {
-  this->statements.push_back(new ExpressionStatement(expression));
+void StatementBlock::Add(std::shared_ptr<Expression> expression) {
+  this->statements.push_back(std::make_shared<ExpressionStatement>(expression));
 }
 
-ExpressionStatement::ExpressionStatement(Expression* e) : expression(e) {}
+ExpressionStatement::ExpressionStatement(std::shared_ptr<Expression> e) : expression(e) {}
 
 void ExpressionStatement::Write(CodeWriter* to) const {
   this->expression->Write(to);
   to->Write(";\n");
 }
 
-Assignment::Assignment(Variable* l, Expression* r) : lvalue(l), rvalue(r) {}
+Assignment::Assignment(std::shared_ptr<Variable> l, std::shared_ptr<Expression> r)
+    : lvalue(l), rvalue(r) {}
 
-Assignment::Assignment(Variable* l, Expression* r, string c) : lvalue(l), rvalue(r), cast(c) {}
+Assignment::Assignment(std::shared_ptr<Variable> l, std::shared_ptr<Expression> r, string c)
+    : lvalue(l), rvalue(r), cast(c) {}
 
 void Assignment::Write(CodeWriter* to) const {
   this->lvalue->Write(to);
@@ -172,42 +175,24 @@
 
 MethodCall::MethodCall(const string& n) : name(n) {}
 
-MethodCall::MethodCall(const string& n, int argc = 0, ...) : name(n) {
-  va_list args;
-  va_start(args, argc);
-  init(argc, args);
-  va_end(args);
-}
+MethodCall::MethodCall(const string& n, const std::vector<std::shared_ptr<Expression>>& args)
+    : name(n), arguments(args) {}
 
-MethodCall::MethodCall(Expression* o, const string& n) : receiver(o), name(n) {}
+MethodCall::MethodCall(std::shared_ptr<Expression> o, const string& n) : receiver(o), 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, ...) : receiver(o), name(n) {
-  va_list args;
-  va_start(args, argc);
-  init(argc, args);
-  va_end(args);
-}
+MethodCall::MethodCall(std::shared_ptr<Expression> o, const string& n,
+                       const std::vector<std::shared_ptr<Expression>>& args)
+    : receiver(o), name(n), arguments(args) {}
 
-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);
-  va_end(args);
-}
-
-void MethodCall::init(int n, va_list args) {
-  for (int i = 0; i < n; i++) {
-    Expression* expression = (Expression*)va_arg(args, void*);
-    this->arguments.push_back(expression);
-  }
-}
+MethodCall::MethodCall(const std::string& t, const string& n,
+                       const std::vector<std::shared_ptr<Expression>>& args)
+    : receiver(t), name(n), arguments(args) {}
 
 void MethodCall::Write(CodeWriter* to) const {
   visit(
-      overloaded{[&](Expression* e) {
+      overloaded{[&](std::shared_ptr<Expression> e) {
                    e->Write(to);
                    to->Write(".");
                  },
@@ -218,7 +203,8 @@
   to->Write(")");
 }
 
-Comparison::Comparison(Expression* l, const string& o, Expression* r)
+Comparison::Comparison(std::shared_ptr<Expression> l, const string& o,
+                       std::shared_ptr<Expression> r)
     : lvalue(l), op(o), rvalue(r) {}
 
 void Comparison::Write(CodeWriter* to) const {
@@ -231,19 +217,9 @@
 
 NewExpression::NewExpression(const std::string& n) : instantiableName(n) {}
 
-NewExpression::NewExpression(const std::string& n, int argc = 0, ...) : instantiableName(n) {
-  va_list args;
-  va_start(args, argc);
-  init(argc, args);
-  va_end(args);
-}
-
-void NewExpression::init(int n, va_list args) {
-  for (int i = 0; i < n; i++) {
-    Expression* expression = (Expression*)va_arg(args, void*);
-    this->arguments.push_back(expression);
-  }
-}
+NewExpression::NewExpression(const std::string& n,
+                             const std::vector<std::shared_ptr<Expression>>& args)
+    : instantiableName(n), arguments(args) {}
 
 void NewExpression::Write(CodeWriter* to) const {
   to->Write("new %s(", this->instantiableName.c_str());
@@ -251,7 +227,8 @@
   to->Write(")");
 }
 
-NewArrayExpression::NewArrayExpression(const std::string& t, Expression* s) : type(t), size(s) {}
+NewArrayExpression::NewArrayExpression(const std::string& t, std::shared_ptr<Expression> s)
+    : type(t), size(s) {}
 
 void NewArrayExpression::Write(CodeWriter* to) const {
   to->Write("new %s[", this->type.c_str());
@@ -259,7 +236,7 @@
   to->Write("]");
 }
 
-Cast::Cast(const std::string& t, Expression* e) : type(t), expression(e) {}
+Cast::Cast(const std::string& t, std::shared_ptr<Expression> e) : type(t), expression(e) {}
 
 void Cast::Write(CodeWriter* to) const {
   to->Write("((%s)", this->type.c_str());
@@ -267,9 +244,10 @@
   to->Write(")");
 }
 
-VariableDeclaration::VariableDeclaration(Variable* l, Expression* r) : lvalue(l), rvalue(r) {}
+VariableDeclaration::VariableDeclaration(std::shared_ptr<Variable> l, std::shared_ptr<Expression> r)
+    : lvalue(l), rvalue(r) {}
 
-VariableDeclaration::VariableDeclaration(Variable* l) : lvalue(l) {}
+VariableDeclaration::VariableDeclaration(std::shared_ptr<Variable> l) : lvalue(l) {}
 
 void VariableDeclaration::Write(CodeWriter* to) const {
   this->lvalue->WriteDeclaration(to);
@@ -293,7 +271,7 @@
   }
 }
 
-ReturnStatement::ReturnStatement(Expression* e) : expression(e) {}
+ReturnStatement::ReturnStatement(std::shared_ptr<Expression> e) : expression(e) {}
 
 void ReturnStatement::Write(CodeWriter* to) const {
   to->Write("return ");
@@ -330,7 +308,7 @@
   statements->Write(to);
 }
 
-SwitchStatement::SwitchStatement(Expression* e) : expression(e) {}
+SwitchStatement::SwitchStatement(std::shared_ptr<Expression> e) : expression(e) {}
 
 void SwitchStatement::Write(CodeWriter* to) const {
   to->Write("switch (");
@@ -477,11 +455,11 @@
   }
 }
 
-Expression* NULL_VALUE = new LiteralExpression("null");
-Expression* THIS_VALUE = new LiteralExpression("this");
-Expression* SUPER_VALUE = new LiteralExpression("super");
-Expression* TRUE_VALUE = new LiteralExpression("true");
-Expression* FALSE_VALUE = new LiteralExpression("false");
+std::shared_ptr<Expression> NULL_VALUE = std::make_shared<LiteralExpression>("null");
+std::shared_ptr<Expression> THIS_VALUE = std::make_shared<LiteralExpression>("this");
+std::shared_ptr<Expression> SUPER_VALUE = std::make_shared<LiteralExpression>("super");
+std::shared_ptr<Expression> TRUE_VALUE = std::make_shared<LiteralExpression>("true");
+std::shared_ptr<Expression> FALSE_VALUE = std::make_shared<LiteralExpression>("false");
 }  // namespace java
 }  // namespace aidl
 }  // namespace android