iv-phonic 0.1.5 → 0.1.6

data/Manifest.txt

@@ -25,6 +25,7 @@ ext/include/iv/functor.h
 ext/include/iv/keyword.h
 ext/include/iv/lexer.h
 ext/include/iv/location.h
+ext/include/iv/maybe.h
 ext/include/iv/mt19937.h
 ext/include/iv/noncopyable.h
 ext/include/iv/none.h

data/Rakefile

@@ -6,7 +6,7 @@ require 'hoe'
 require 'pp'
 $root = File.dirname(__FILE__)
 $name = 'iv-phonic'
-$version = '0.1.5'
+$version = '0.1.6'
 
 directory "ext/include/iv"
 

data/ext/include/iv/ast.h

@@ -8,6 +8,7 @@
 #include "noncopyable.h"
 #include "utils.h"
 #include "space.h"
+#include "maybe.h"
 #include "functor.h"
 #include "token.h"
 #include "ast_fwd.h"
@@ -120,6 +121,11 @@ class AstNode : public AstNodeBase<Factory> {
   typedef typename SpaceVector<Factory, Statement<Factory>*>::type Statements;
   typedef typename SpaceVector<Factory, Identifier<Factory>*>::type Identifiers;
   typedef typename SpaceVector<Factory, Expression<Factory>*>::type Expressions;
+  typedef typename SpaceVector<Factory,
+                               Maybe<Expression<Factory> > >::type MaybeExpressions;
+  typedef typename SpaceVector<Factory,
+                               Declaration<Factory>*>::type Declarations;
+  typedef typename SpaceVector<Factory, CaseClause<Factory>*>::type CaseClauses;
 
   STATEMENT_NODE_LIST(DECLARE_NODE_TYPE_BASE)
   EXPRESSION_NODE_LIST(DECLARE_NODE_TYPE_BASE)
@@ -308,9 +314,7 @@ INHERIT(VariableStatement);
 template<typename Factory>
 class VariableStatement : public VariableStatementBase<Factory> {
  public:
-  typedef typename SpaceVector<
-            Factory,
-            Declaration<Factory>*>::type Declarations;
+  typedef typename AstNode<Factory>::Declarations Declarations;
   VariableStatement(Token::Type type, Declarations* decls)
     : is_const_(type == Token::CONST),
       decls_(decls) { }
@@ -336,20 +340,21 @@ INHERIT(Declaration);
 template<typename Factory>
 class Declaration : public DeclarationBase<Factory> {
  public:
-  Declaration(Identifier<Factory>* name, Expression<Factory>* expr)
+  Declaration(Identifier<Factory>* name,
+              Maybe<Expression<Factory> > expr)
     : name_(name),
       expr_(expr) {
   }
   inline Identifier<Factory>* name() const {
     return name_;
   }
-  inline Expression<Factory>* expr() const {
+  inline Maybe<Expression<Factory> > expr() const {
     return expr_;
   }
   DECLARE_DERIVED_NODE_TYPE(Declaration)
  private:
   Identifier<Factory>* name_;
-  Expression<Factory>* expr_;
+  Maybe<Expression<Factory> > expr_;
 };
 
 // EmptyStatement
@@ -377,20 +382,19 @@ class IfStatement : public IfStatementBase<Factory> {
  public:
   IfStatement(Expression<Factory>* cond,
               Statement<Factory>* then,
-              Statement<Factory>* elses)
+              Maybe<Statement<Factory> > elses)
     : cond_(cond),
       then_(then),
       else_(elses) {
-    // else maybe NULL
   }
   inline Expression<Factory>* cond() const { return cond_; }
   inline Statement<Factory>* then_statement() const { return then_; }
-  inline Statement<Factory>* else_statement() const { return else_; }
+  inline Maybe<Statement<Factory> > else_statement() const { return else_; }
   DECLARE_DERIVED_NODE_TYPE(IfStatement)
  private:
   Expression<Factory>* cond_;
   Statement<Factory>* then_;
-  Statement<Factory>* else_;
+  Maybe<Statement<Factory> > else_;
 };
 
 // IterationStatement
@@ -461,24 +465,24 @@ template<typename Factory>
 class ForStatement : public ForStatementBase<Factory> {
  public:
   ForStatement(Statement<Factory>* body,
-               Statement<Factory>* init,
-               Expression<Factory>* cond,
-               Statement<Factory>* next)
+               Maybe<Statement<Factory> > init,
+               Maybe<Expression<Factory> > cond,
+               Maybe<Statement<Factory> > next)
     : body_(body),
       init_(init),
       cond_(cond),
       next_(next) {
   }
   inline Statement<Factory>* body() const { return body_; }
-  inline Statement<Factory>* init() const { return init_; }
-  inline Expression<Factory>* cond() const { return cond_; }
-  inline Statement<Factory>* next() const { return next_; }
+  inline Maybe<Statement<Factory> > init() const { return init_; }
+  inline Maybe<Expression<Factory> > cond() const { return cond_; }
+  inline Maybe<Statement<Factory> > next() const { return next_; }
   DECLARE_DERIVED_NODE_TYPE(ForStatement)
  private:
   Statement<Factory>* body_;
-  Statement<Factory>* init_;
-  Expression<Factory>* cond_;
-  Statement<Factory>* next_;
+  Maybe<Statement<Factory> > init_;
+  Maybe<Expression<Factory> > cond_;
+  Maybe<Statement<Factory> > next_;
 };
 
 // ForInStatement
@@ -518,20 +522,20 @@ INHERIT(ContinueStatement);
 template<typename Factory>
 class ContinueStatement : public ContinueStatementBase<Factory> {
  public:
-  ContinueStatement(Identifier<Factory>* label,
+  ContinueStatement(Maybe<Identifier<Factory> > label,
                     IterationStatement<Factory>** target)
     : label_(label),
       target_(target) {
     assert(target_);
   }
-  inline Identifier<Factory>* label() const { return label_; }
+  inline Maybe<Identifier<Factory> > label() const { return label_; }
   inline IterationStatement<Factory>* target() const {
     assert(target_ && *target_);
     return *target_;
   }
   DECLARE_DERIVED_NODE_TYPE(ContinueStatement)
  private:
-  Identifier<Factory>* label_;
+  Maybe<Identifier<Factory> > label_;
   IterationStatement<Factory>** target_;
 };
 
@@ -545,7 +549,7 @@ INHERIT(BreakStatement);
 template<typename Factory>
 class BreakStatement : public BreakStatementBase<Factory> {
  public:
-  BreakStatement(Identifier<Factory>* label,
+  BreakStatement(Maybe<Identifier<Factory> > label,
                  BreakableStatement<Factory>** target)
     : label_(label),
       target_(target) {
@@ -556,7 +560,7 @@ class BreakStatement : public BreakStatementBase<Factory> {
     // if above example, target is NULL
     assert(target_ || label_);
   }
-  inline Identifier<Factory>* label() const { return label_; }
+  inline Maybe<Identifier<Factory> > label() const { return label_; }
   inline BreakableStatement<Factory>* target() const {
     if (target_) {
       assert(*target_);
@@ -567,7 +571,7 @@ class BreakStatement : public BreakStatementBase<Factory> {
   }
   DECLARE_DERIVED_NODE_TYPE(BreakStatement)
  private:
-  Identifier<Factory>* label_;
+  Maybe<Identifier<Factory> > label_;
   BreakableStatement<Factory>** target_;
 };
 
@@ -581,13 +585,13 @@ INHERIT(ReturnStatement);
 template<typename Factory>
 class ReturnStatement : public ReturnStatementBase<Factory> {
  public:
-  explicit ReturnStatement(Expression<Factory>* expr)
+  explicit ReturnStatement(Maybe<Expression<Factory> > expr)
     : expr_(expr) {
   }
-  inline Expression<Factory>* expr() const { return expr_; }
+  inline Maybe<Expression<Factory> > expr() const { return expr_; }
   DECLARE_DERIVED_NODE_TYPE(ReturnStatement)
  private:
-  Expression<Factory>* expr_;
+  Maybe<Expression<Factory> > expr_;
 };
 
 // WithStatement
@@ -646,16 +650,16 @@ class CaseClause : public CaseClauseBase<Factory> {
  public:
   typedef typename AstNode<Factory>::Statements Statements;
   explicit CaseClause(bool is_default,
-                      Expression<Factory>* expr,
+                      Maybe<Expression<Factory> > expr,
                       Statements* body)
     : expr_(expr),
       body_(body),
       default_(is_default) {
   }
   inline bool IsDefault() const {
-    return default_;
+    return !expr_;
   }
-  inline Expression<Factory>* expr() const {
+  inline Maybe<Expression<Factory> > expr() const {
     return expr_;
   }
   inline const Statements& body() const {
@@ -663,7 +667,7 @@ class CaseClause : public CaseClauseBase<Factory> {
   }
   DECLARE_DERIVED_NODE_TYPE(CaseClause)
  private:
-  Expression<Factory>* expr_;
+  Maybe<Expression<Factory> > expr_;
   Statements* body_;
   bool default_;
 };
@@ -678,7 +682,7 @@ INHERIT(SwitchStatement);
 template<typename Factory>
 class SwitchStatement : public SwitchStatementBase<Factory> {
  public:
-  typedef typename SpaceVector<Factory, CaseClause<Factory>*>::type CaseClauses;
+  typedef typename AstNode<Factory>::CaseClauses CaseClauses;
   SwitchStatement(Expression<Factory>* expr,
                   CaseClauses* clauses)
     : expr_(expr),
@@ -722,24 +726,24 @@ template<typename Factory>
 class TryStatement : public TryStatementBase<Factory> {
  public:
   explicit TryStatement(Block<Factory>* try_block,
-                        Identifier<Factory>* catch_name,
-                        Block<Factory>* catch_block,
-                        Block<Factory>* finally_block)
+                        Maybe<Identifier<Factory> > catch_name,
+                        Maybe<Block<Factory> > catch_block,
+                        Maybe<Block<Factory> > finally_block)
     : body_(try_block),
       catch_name_(catch_name),
       catch_block_(catch_block),
       finally_block_(finally_block) {
   }
   inline Block<Factory>* body() const { return body_; }
-  inline Identifier<Factory>* catch_name() const { return catch_name_; }
-  inline Block<Factory>* catch_block() const { return catch_block_; }
-  inline Block<Factory>* finally_block() const { return finally_block_; }
+  inline Maybe<Identifier<Factory> > catch_name() const { return catch_name_; }
+  inline Maybe<Block<Factory> > catch_block() const { return catch_block_; }
+  inline Maybe<Block<Factory> > finally_block() const { return finally_block_; }
   DECLARE_DERIVED_NODE_TYPE(TryStatement)
  private:
   Block<Factory>* body_;
-  Identifier<Factory>* catch_name_;
-  Block<Factory>* catch_block_;
-  Block<Factory>* finally_block_;
+  Maybe<Identifier<Factory> > catch_name_;
+  Maybe<Block<Factory> > catch_block_;
+  Maybe<Block<Factory> > finally_block_;
 };
 
 // DebuggerStatement
@@ -1074,19 +1078,6 @@ class FalseLiteral : public FalseLiteralBase<Factory> {
   DECLARE_DERIVED_NODE_TYPE(FalseLiteral)
 };
 
-// Undefined
-template<typename Factory>
-class Inherit<Factory, kUndefined>
-  : public Literal<Factory> {
-};
-INHERIT(Undefined);
-
-template<typename Factory>
-class Undefined : public UndefinedBase<Factory> {
- public:
-  DECLARE_DERIVED_NODE_TYPE(Undefined)
-};
-
 // RegExpLiteral
 template<typename Factory>
 class Inherit<Factory, kRegExpLiteral>
@@ -1127,17 +1118,17 @@ INHERIT(ArrayLiteral);
 template<typename Factory>
 class ArrayLiteral : public ArrayLiteralBase<Factory> {
  public:
-  typedef typename AstNode<Factory>::Expressions Expressions;
+  typedef typename AstNode<Factory>::MaybeExpressions MaybeExpressions;
 
-  explicit ArrayLiteral(Expressions* items)
+  explicit ArrayLiteral(MaybeExpressions* items)
     : items_(items) {
   }
-  inline const Expressions& items() const {
+  inline const MaybeExpressions& items() const {
     return *items_;
   }
   DECLARE_DERIVED_NODE_TYPE(ArrayLiteral)
  private:
-  Expressions* items_;
+  MaybeExpressions* items_;
 };
 
 // ObjectLiteral
@@ -1208,7 +1199,7 @@ class FunctionLiteral : public FunctionLiteralBase<Factory> {
     SETTER,
     GETTER
   };
-  inline Identifier<Factory>* name() const {
+  inline Maybe<Identifier<Factory> > name() const {
     return name_;
   }
   inline DeclType type() const { return type_; }
@@ -1231,7 +1222,7 @@ class FunctionLiteral : public FunctionLiteralBase<Factory> {
     return strict_;
   }
   FunctionLiteral(DeclType type,
-                  Identifier<Factory>* name,
+                  Maybe<Identifier<Factory> > name,
                   Identifiers* params,
                   Statements* body,
                   Scope<Factory>* scope,
@@ -1249,7 +1240,7 @@ class FunctionLiteral : public FunctionLiteralBase<Factory> {
   }
   DECLARE_DERIVED_NODE_TYPE(FunctionLiteral)
  private:
-  Identifier<Factory>* name_;
+  Maybe<Identifier<Factory> > name_;
   DeclType type_;
   Identifiers* params_;
   Statements* body_;

data/ext/include/iv/ast_factory.h

@@ -20,7 +20,7 @@ class BasicAstFactory {
 #define V(AST) typedef typename ast::AST<Factory> AST;
   AST_NODE_LIST(V)
 #undef V
-#define V(X, XS) typedef typename SpaceVector<Factory, X*>::type XS;
+#define V(XS) typedef typename ast::AstNode<Factory>::XS XS;
   AST_LIST_LIST(V)
 #undef V
 #define V(S) typedef typename SpaceUString<Factory>::type S;
@@ -28,9 +28,7 @@ class BasicAstFactory {
 #undef V
 
   BasicAstFactory()
-    : undefined_instance_(
-          new(static_cast<Factory*>(this))Undefined()),
-      empty_statement_instance_(
+    : empty_statement_instance_(
           new(static_cast<Factory*>(this))EmptyStatement()),
       debugger_statement_instance_(
           new(static_cast<Factory*>(this))DebuggerStatement()),
@@ -88,7 +86,7 @@ class BasicAstFactory {
   }
 
   FunctionLiteral* NewFunctionLiteral(typename FunctionLiteral::DeclType type,
-                                      Identifier* name,
+                                      Maybe<Identifier> name,
                                       Identifiers* params,
                                       Statements* body,
                                       Scope* scope,
@@ -108,7 +106,7 @@ class BasicAstFactory {
                         end_block_position);
   }
 
-  ArrayLiteral* NewArrayLiteral(Expressions* items,
+  ArrayLiteral* NewArrayLiteral(MaybeExpressions* items,
                                 std::size_t begin, std::size_t end) {
     return new (static_cast<Factory*>(this)) ArrayLiteral(items);
   }
@@ -146,10 +144,6 @@ class BasicAstFactory {
     return this_instance_;
   }
 
-  Undefined* NewUndefined() {
-    return undefined_instance_;
-  }
-
   TrueLiteral* NewTrueLiteral(std::size_t begin, std::size_t end) {
     return true_instance_;
   }
@@ -192,7 +186,7 @@ class BasicAstFactory {
 
   // if you want begin / end position,
   // set position to Identifier / Expression and use it
-  Declaration* NewDeclaration(Identifier* name, Expression* expr) {
+  Declaration* NewDeclaration(Identifier* name, Maybe<Expression> expr) {
     return new (static_cast<Factory*>(this)) Declaration(name, expr);
   }
 
@@ -200,7 +194,7 @@ class BasicAstFactory {
   // set position to Statement and use it
   IfStatement* NewIfStatement(Expression* cond,
                               Statement* then_statement,
-                              Statement* else_statement,
+                              Maybe<Statement> else_statement,
                               std::size_t begin) {
     return new (static_cast<Factory*>(this)) IfStatement(cond,
                                                          then_statement,
@@ -235,9 +229,9 @@ class BasicAstFactory {
   // if you want end position,
   // set position to Statement and use it
   ForStatement* NewForStatement(Statement* body,
-                                Statement* init,
-                                Expression* cond,
-                                Statement* next,
+                                Maybe<Statement> init,
+                                Maybe<Expression> cond,
+                                Maybe<Statement> next,
                                 std::size_t begin) {
     return new (static_cast<Factory*>(this)) ForStatement(body, init,
                                                           cond, next);
@@ -247,21 +241,21 @@ class BasicAstFactory {
     return new (static_cast<Factory*>(this)) ExpressionStatement(expr);
   }
 
-  ContinueStatement* NewContinueStatement(Identifier* label,
+  ContinueStatement* NewContinueStatement(Maybe<Identifier> label,
                                           IterationStatement** target,
                                           std::size_t begin,
                                           std::size_t end) {
     return new (static_cast<Factory*>(this)) ContinueStatement(label, target);
   }
 
-  BreakStatement* NewBreakStatement(Identifier* label,
+  BreakStatement* NewBreakStatement(Maybe<Identifier> label,
                                     BreakableStatement** target,
                                     std::size_t begin,
                                     std::size_t end) {
     return new (static_cast<Factory*>(this)) BreakStatement(label, target);
   }
 
-  ReturnStatement* NewReturnStatement(Expression* expr,
+  ReturnStatement* NewReturnStatement(Maybe<Expression> expr,
                                       std::size_t begin,
                                       std::size_t end) {
     return new (static_cast<Factory*>(this)) ReturnStatement(expr);
@@ -281,7 +275,7 @@ class BasicAstFactory {
 
   // !!! if body is empty, end_position is end.
   CaseClause* NewCaseClause(bool is_default,
-                            Expression* expr, Statements* body,
+                            Maybe<Expression> expr, Statements* body,
                             std::size_t begin,
                             std::size_t end) {
     return new (static_cast<Factory*>(this)) CaseClause(is_default, expr, body);
@@ -295,9 +289,9 @@ class BasicAstFactory {
   // if you want end position,
   // set position to Block and use it
   TryStatement* NewTryStatement(Block* try_block,
-                                Identifier* catch_name,
-                                Block* catch_block,
-                                Block* finally_block,
+                                Maybe<Identifier> catch_name,
+                                Maybe<Block> catch_block,
+                                Maybe<Block> finally_block,
                                 std::size_t begin) {
     return new (static_cast<Factory*>(this)) TryStatement(try_block,
                                                           catch_name,
@@ -380,7 +374,6 @@ class BasicAstFactory {
   }
 
  private:
-  Undefined* undefined_instance_;
   EmptyStatement* empty_statement_instance_;
   DebuggerStatement* debugger_statement_instance_;
   ThisLiteral* this_instance_;

data/ext/include/iv/ast_fwd.h

@@ -46,7 +46,6 @@ V(ArrayLiteral)\
 V(ObjectLiteral)\
 V(NullLiteral)\
 V(ThisLiteral)\
-V(Undefined)\
 V(TrueLiteral)\
 V(FalseLiteral)
 
@@ -90,11 +89,12 @@ STATEMENT_NODE_LIST(V)\
 EXPRESSION_NODE_LIST(V)
 
 #define AST_LIST_LIST(V)\
-V(Identifier, Identifiers)\
-V(Declaration, Declarations)\
-V(Expression, Expressions)\
-V(Statement, Statements)\
-V(CaseClause, CaseClauses)
+V(Identifiers)\
+V(Declarations)\
+V(Expressions)\
+V(Statements)\
+V(CaseClauses)\
+V(MaybeExpressions)
 
 #define AST_STRING(V) V(SpaceUString)
 

data/ext/include/iv/ast_info.h

@@ -10,7 +10,7 @@ struct AstInfo {
 #define V(AST) typedef typename AST<Factory> AST;
   AST_NODE_LIST(V)
 #undef V
-#define V(X, XS) typedef typename SpaceVector<Factory, X *>::type XS;
+#define V(XS) typedef typename ast::AstNode<Factory>::XS XS;
   AST_LIST_LIST(V)
 #undef V
 #define V(S) typedef typename SpaceUString<Factory>::type S;

data/ext/include/iv/ast_serializer.h

@@ -20,10 +20,10 @@ class AstSerializer: public AstVisitor<Factory>::const_type {
 
   typedef void ReturnType;
 
-#define V(AST) typedef typename iv::core::ast::AST<Factory> AST;
+#define V(AST) typedef typename core::ast::AST<Factory> AST;
   AST_NODE_LIST(V)
 #undef V
-#define V(X, XS) typedef typename core::SpaceVector<Factory, X *>::type XS;
+#define V(XS) typedef typename core::ast::AstNode<Factory>::XS XS;
   AST_LIST_LIST(V)
 #undef V
 #define V(S) typedef typename core::SpaceUString<Factory>::type S;
@@ -91,8 +91,8 @@ class AstSerializer: public AstVisitor<Factory>::const_type {
       Append("{\"type\":\"decl\",\"name\":");
       decl.name()->Accept(this);
       Append(",\"exp\":");
-      if (decl.expr()) {
-        decl.expr()->Accept(this);
+      if (const Maybe<const Expression> expr = decl.expr()) {
+        (*expr).Accept(this);
       }
       Append('}');
       ++it;
@@ -112,9 +112,9 @@ class AstSerializer: public AstVisitor<Factory>::const_type {
     ifstmt->cond()->Accept(this);
     Append(",\"body\":");
     ifstmt->then_statement()->Accept(this);
-    if (ifstmt->else_statement()) {
+    if (const Maybe<const Statement> else_stmt = ifstmt->else_statement()) {
       Append(",\"else\":");
-      ifstmt->else_statement()->Accept(this);
+      (*else_stmt).Accept(this);
     }
     Append('}');
   }
@@ -137,17 +137,17 @@ class AstSerializer: public AstVisitor<Factory>::const_type {
 
   void Visit(const ForStatement* forstmt) {
     Append("{\"type\":\"for\"");
-    if (forstmt->init() != NULL) {
+    if (const Maybe<const Statement> init = forstmt->init()) {
       Append(",\"init\":");
-      forstmt->init()->Accept(this);
+      (*init).Accept(this);
     }
-    if (forstmt->cond() != NULL) {
+    if (const Maybe<const Expression> cond = forstmt->cond()) {
       Append(",\"cond\":");
-      forstmt->cond()->Accept(this);
+      (*cond).Accept(this);
     }
-    if (forstmt->next() != NULL) {
+    if (const Maybe<const Statement> next = forstmt->next()) {
       Append(",\"next\":");
-      forstmt->next()->Accept(this);
+      (*next).Accept(this);
     }
     Append(",\"body\":");
     forstmt->body()->Accept(this);
@@ -166,25 +166,28 @@ class AstSerializer: public AstVisitor<Factory>::const_type {
 
   void Visit(const ContinueStatement* continuestmt) {
     Append("{\"type\":\"continue\"");
-    if (continuestmt->label()) {
+    if (const Maybe<const Identifier> label = continuestmt->label()) {
       Append(",\"label\":");
-      continuestmt->label()->Accept(this);
+      (*label).Accept(this);
     }
     Append('}');
   }
 
   void Visit(const BreakStatement* breakstmt) {
     Append("{\"type\":\"break\"");
-    if (breakstmt->label()) {
+    if (const Maybe<const Identifier> label = breakstmt->label()) {
       Append(",\"label\":");
-      breakstmt->label()->Accept(this);
+      (*label).Accept(this);
     }
     Append('}');
   }
 
   void Visit(const ReturnStatement* returnstmt) {
-    Append("{\"type\":\"return\",\"exp\":");
-    returnstmt->expr()->Accept(this);
+    Append("{\"type\":\"return\"");
+    if (const Maybe<const Expression> expr = returnstmt->expr()) {
+      Append(",\"exp\":");
+      (*expr).Accept(this);
+    }
     Append('}');
   }
 
@@ -214,11 +217,11 @@ class AstSerializer: public AstVisitor<Factory>::const_type {
         end = switchstmt->clauses().end();
     while (it != end) {
       const CaseClause& clause = **it;
-      if (clause.IsDefault()) {
-        Append("{\"type\":\"default\"");
-      } else {
+      if (const Maybe<const Expression> expr = clause.expr()) {
         Append("{\"type\":\"case\",\"exp\":");
-        clause.expr()->Accept(this);
+        (*expr).Accept(this);
+      } else {
+        Append("{\"type\":\"default\"");
       }
       Append(",\"body\"[");
       typename Statements::const_iterator stit = clause.body().begin();
@@ -248,16 +251,16 @@ class AstSerializer: public AstVisitor<Factory>::const_type {
   void Visit(const TryStatement* trystmt) {
     Append("{\"type\":\"try\",\"body\":");
     trystmt->body()->Accept(this);
-    if (trystmt->catch_name()) {
+    if (const Maybe<const Identifier> ident = trystmt->catch_name()) {
       Append(",\"catch\":{\"type\":\"catch\",\"name\":");
-      trystmt->catch_name()->Accept(this);
+      Visit(ident.Address());
       Append(",\"body\":");
-      trystmt->catch_block()->Accept(this);
+      Visit(trystmt->catch_block().Address());
       Append('}');
     }
-    if (trystmt->finally_block()) {
+    if (const Maybe<const Block> block = trystmt->finally_block()) {
       Append(",\"finally\":{\"type\":\"finally\",\"body\":");
-      trystmt->finally_block()->Accept(this);
+      Visit(block.Address());
       Append('}');
     }
     Append('}');
@@ -355,10 +358,6 @@ class AstSerializer: public AstVisitor<Factory>::const_type {
     Append("{\"type\":\"false\"}");
   }
 
-  void Visit(const Undefined* literal) {
-    Append("{\"type\":\"undefined\"}");
-  }
-
   void Visit(const RegExpLiteral* literal) {
     Append("{\"type\":\"regexp\",\"value\":\"");
     DecodeString(literal->value().begin(), literal->value().end());
@@ -369,12 +368,12 @@ class AstSerializer: public AstVisitor<Factory>::const_type {
 
   void Visit(const ArrayLiteral* literal) {
     Append("{\"type\":\"array\",\"value\":[");
-    typename Expressions::const_iterator it = literal->items().begin();
-    const typename Expressions::const_iterator end = literal->items().end();
+    typename MaybeExpressions::const_iterator it = literal->items().begin();
+    const typename MaybeExpressions::const_iterator end = literal->items().end();
     bool previous_is_elision = false;
     while (it != end) {
       if ((*it)) {
-        (*it)->Accept(this);
+        (**it).Accept(this);
         previous_is_elision = false;
       } else {
         previous_is_elision = true;
@@ -423,8 +422,8 @@ class AstSerializer: public AstVisitor<Factory>::const_type {
 
   void Visit(const FunctionLiteral* literal) {
     Append("{\"type\":\"function\",\"name\":");
-    if (literal->name()) {
-      literal->name()->Accept(this);
+    if (const Maybe<const Identifier> name = literal->name()) {
+      Visit(name.Address());
     }
     Append(",\"params\":[");
     typename Identifiers::const_iterator it = literal->params().begin();