diff --git a/src/main/java/com/google/devtools/build/lib/skylarkdebug/server/SkylarkDebugServer.java b/src/main/java/com/google/devtools/build/lib/skylarkdebug/server/SkylarkDebugServer.java
index b546fa6f..d87bfda 100644
--- a/src/main/java/com/google/devtools/build/lib/skylarkdebug/server/SkylarkDebugServer.java
+++ b/src/main/java/com/google/devtools/build/lib/skylarkdebug/server/SkylarkDebugServer.java
@@ -26,7 +26,6 @@
 import com.google.devtools.build.lib.syntax.Eval;
 import com.google.devtools.build.lib.syntax.EvalException;
 import com.google.devtools.build.lib.syntax.Statement;
-import com.google.devtools.build.lib.syntax.TokenKind;
 import java.io.IOException;
 import java.net.ServerSocket;
 import java.util.List;
@@ -255,9 +254,9 @@
     }
 
     @Override
-    protected TokenKind exec(Statement st) throws EvalException, InterruptedException {
+    public void exec(Statement st) throws EvalException, InterruptedException {
       pauseIfNecessary(env, st.getLocation());
-      return super.exec(st);
+      super.exec(st);
     }
   }
 }
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/Environment.java b/src/main/java/com/google/devtools/build/lib/syntax/Environment.java
index 8348d60..4a6d014 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/Environment.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/Environment.java
@@ -56,7 +56,9 @@
  * respect to this {@code Environment}.
  *
  * <p>{@link Continuation}-s are explicitly represented, but only partly, with another part being
- * implicit in a series of try-catch statements, to maintain the direct style.
+ * implicit in a series of try-catch statements, to maintain the direct style. One notable trick is
+ * how a {@link UserDefinedFunction} implements returning values as the function catching a {@link
+ * ReturnStatement.ReturnException} thrown by a {@link ReturnStatement} in the body.
  *
  * <p>Every {@code Environment} has a {@link Mutability} field, and must be used within a function
  * that creates and closes this {@link Mutability} with the try-with-resource pattern. This {@link
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/Eval.java b/src/main/java/com/google/devtools/build/lib/syntax/Eval.java
index f8e1b6d..7a4273b 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/Eval.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/Eval.java
@@ -25,7 +25,18 @@
  */
 public class Eval {
   protected final Environment env;
-  private Object result = Runtime.NONE;
+
+  /** An exception that signals changes in the control flow (e.g. break or continue) */
+  private static class FlowException extends EvalException {
+    FlowException(String message) {
+      super(null, message);
+    }
+
+    @Override
+    public boolean canBeAddedToStackTrace() {
+      return false;
+    }
+  }
 
   public static Eval fromEnvironment(Environment env) {
     return evalSupplier.apply(env);
@@ -43,6 +54,10 @@
   // TODO(bazel-team): remove this static state in favor of storing Eval instances in Environment
   private static Function<Environment, Eval> evalSupplier = Eval::new;
 
+  private static final FlowException breakException = new FlowException("FlowException - break");
+  private static final FlowException continueException =
+      new FlowException("FlowException - continue");
+
   /**
    * This constructor should never be called directly. Call {@link #fromEnvironment(Environment)}
    * instead.
@@ -51,11 +66,6 @@
     this.env = env;
   }
 
-  /** getResult returns the value returned by executing a ReturnStatement. */
-  Object getResult() {
-    return this.result;
-  }
-
   void execAssignment(AssignmentStatement node) throws EvalException, InterruptedException {
     Object rvalue = node.getExpression().eval(env);
     node.getLValue().assign(rvalue, env, node.getLocation());
@@ -67,12 +77,12 @@
         .assignAugmented(node.getOperator(), node.getExpression(), env, node.getLocation());
   }
 
-  TokenKind execIfBranch(IfStatement.ConditionalStatements node)
+  void execIfBranch(IfStatement.ConditionalStatements node)
       throws EvalException, InterruptedException {
-    return execStatements(node.getStatements());
+    execStatements(node.getStatements());
   }
 
-  TokenKind execFor(ForStatement node) throws EvalException, InterruptedException {
+  void execFor(ForStatement node) throws EvalException, InterruptedException {
     Object o = node.getCollection().eval(env);
     Iterable<?> col = EvalUtils.toIterable(o, node.getLocation(), env);
     EvalUtils.lock(o, node.getLocation());
@@ -80,25 +90,17 @@
       for (Object it : col) {
         node.getVariable().assign(it, env, node.getLocation());
 
-        switch (execStatements(node.getBlock())) {
-          case PASS:
-          case CONTINUE:
-            // Stay in loop.
-            continue;
-          case BREAK:
-            // Finish loop, execute next statement after loop.
-            return TokenKind.PASS;
-          case RETURN:
-            // Finish loop, return from function.
-            return TokenKind.RETURN;
-          default:
-            throw new IllegalStateException("unreachable");
+        try {
+          execStatements(node.getBlock());
+        } catch (FlowException ex) {
+          if (ex == breakException) {
+            return;
+          }
         }
       }
     } finally {
       EvalUtils.unlock(o, node.getLocation());
     }
-    return TokenKind.PASS;
   }
 
   void execDef(FunctionDefStatement node) throws EvalException, InterruptedException {
@@ -128,16 +130,17 @@
             env.getGlobals()));
   }
 
-  TokenKind execIf(IfStatement node) throws EvalException, InterruptedException {
+  void execIf(IfStatement node) throws EvalException, InterruptedException {
     ImmutableList<IfStatement.ConditionalStatements> thenBlocks = node.getThenBlocks();
     // Avoid iterator overhead - most of the time there will be one or few "if"s.
     for (int i = 0; i < thenBlocks.size(); i++) {
       IfStatement.ConditionalStatements stmt = thenBlocks.get(i);
       if (EvalUtils.toBoolean(stmt.getCondition().eval(env))) {
-        return exec(stmt);
+        exec(stmt);
+        return;
       }
     }
-    return execStatements(node.getElseBlock());
+    execStatements(node.getElseBlock());
   }
 
   void execLoad(LoadStatement node) throws EvalException, InterruptedException {
@@ -160,12 +163,12 @@
     }
   }
 
-  TokenKind execReturn(ReturnStatement node) throws EvalException, InterruptedException {
+  void execReturn(ReturnStatement node) throws EvalException, InterruptedException {
     Expression ret = node.getReturnExpression();
-    if (ret != null) {
-      this.result = ret.eval(env);
+    if (ret == null) {
+      throw new ReturnStatement.ReturnException(node.getLocation(), Runtime.NONE);
     }
-    return TokenKind.RETURN;
+    throw new ReturnStatement.ReturnException(ret.getLocation(), ret.eval(env));
   }
 
   /**
@@ -174,54 +177,57 @@
    * @throws EvalException if execution of the statement could not be completed.
    * @throws InterruptedException may be thrown in a sub class.
    */
-  protected TokenKind exec(Statement st) throws EvalException, InterruptedException {
+  public void exec(Statement st) throws EvalException, InterruptedException {
     try {
-      return execDispatch(st);
+      execDispatch(st);
     } catch (EvalException ex) {
       throw st.maybeTransformException(ex);
     }
   }
 
-  TokenKind execDispatch(Statement st) throws EvalException, InterruptedException {
+  void execDispatch(Statement st) throws EvalException, InterruptedException {
     switch (st.kind()) {
       case ASSIGNMENT:
         execAssignment((AssignmentStatement) st);
-        return TokenKind.PASS;
+        break;
       case AUGMENTED_ASSIGNMENT:
         execAugmentedAssignment((AugmentedAssignmentStatement) st);
-        return TokenKind.PASS;
+        break;
       case CONDITIONAL:
-        return execIfBranch((IfStatement.ConditionalStatements) st);
+        execIfBranch((IfStatement.ConditionalStatements) st);
+        break;
       case EXPRESSION:
         ((ExpressionStatement) st).getExpression().eval(env);
-        return TokenKind.PASS;
+        break;
       case FLOW:
-        return ((FlowStatement) st).getKind();
+        throw ((FlowStatement) st).getKind() == FlowStatement.Kind.BREAK
+            ? breakException
+            : continueException;
       case FOR:
-        return execFor((ForStatement) st);
+        execFor((ForStatement) st);
+        break;
       case FUNCTION_DEF:
         execDef((FunctionDefStatement) st);
-        return TokenKind.PASS;
+        break;
       case IF:
-        return execIf((IfStatement) st);
+        execIf((IfStatement) st);
+        break;
       case LOAD:
         execLoad((LoadStatement) st);
-        return TokenKind.PASS;
+        break;
+      case PASS:
+        break;
       case RETURN:
-        return execReturn((ReturnStatement) st);
+        execReturn((ReturnStatement) st);
+        break;
     }
-    throw new IllegalArgumentException("unexpected statement: " + st.kind());
   }
 
-  public TokenKind execStatements(ImmutableList<Statement> statements)
+  private void execStatements(ImmutableList<Statement> statements)
       throws EvalException, InterruptedException {
     // Hot code path, good chance of short lists which don't justify the iterator overhead.
     for (int i = 0; i < statements.size(); i++) {
-      TokenKind flow = exec(statements.get(i));
-      if (flow != TokenKind.PASS) {
-        return flow;
-      }
+      exec(statements.get(i));
     }
-    return TokenKind.PASS;
   }
 }
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/EvalException.java b/src/main/java/com/google/devtools/build/lib/syntax/EvalException.java
index cefb389..d0f94ff 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/EvalException.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/EvalException.java
@@ -67,7 +67,25 @@
    * @param dueToIncompleteAST if the error is caused by a previous error, such as parsing.
    */
   public EvalException(Location location, String message, boolean dueToIncompleteAST) {
-    super(null, null, /*enableSuppression=*/ true, /*writableStackTrace=*/ true);
+    this(location, message, dueToIncompleteAST, true);
+  }
+
+  /**
+   * Create an EvalException with the option to not fill in the java stack trace. An optimization
+   * for ReturnException, and potentially others, which aren't exceptional enough to include a
+   * stack trace.
+   *
+   * @param location the location where evaluation/execution failed.
+   * @param message the error message.
+   * @param dueToIncompleteAST if the error is caused by a previous error, such as parsing.
+   * @param fillInJavaStackTrace whether or not to fill in the java stack trace for this exception
+   */
+  EvalException(
+      Location location,
+      String message,
+      boolean dueToIncompleteAST,
+      boolean fillInJavaStackTrace) {
+    super(null, null, /*enableSuppression=*/ true, fillInJavaStackTrace);
     this.location = location;
     this.message = Preconditions.checkNotNull(message);
     this.dueToIncompleteAST = dueToIncompleteAST;
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/FlowStatement.java b/src/main/java/com/google/devtools/build/lib/syntax/FlowStatement.java
index 4477b91..b060b78 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/FlowStatement.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/FlowStatement.java
@@ -15,29 +15,48 @@
 
 import java.io.IOException;
 
-/** A class for flow statements (e.g. break, continue, and pass) */
+/** A class for flow statements (e.g. break and continue) */
 public final class FlowStatement extends Statement {
+  // TODO(laurentlb): This conflicts with Statement.Kind, maybe remove it?
+  public enum Kind {
+    BREAK("break"),
+    CONTINUE("continue");
 
-  private final TokenKind kind; // BREAK | CONTINUE | PASS
+    private final String name;
 
-  /** @param kind The label of the statement (break, continue, or pass) */
-  public FlowStatement(TokenKind kind) {
+    private Kind(String name) {
+      this.name = name;
+    }
+
+    public String getName() {
+      return name;
+    }
+  }
+
+  private final Kind kind;
+
+  /**
+   *
+   * @param kind The label of the statement (either break or continue)
+   */
+  public FlowStatement(Kind kind) {
     this.kind = kind;
   }
 
-  public TokenKind getKind() {
+  public Kind getKind() {
     return kind;
   }
 
   @Override
   public void prettyPrint(Appendable buffer, int indentLevel) throws IOException {
     printIndent(buffer, indentLevel);
-    buffer.append(kind.getPrettyName()).append('\n');
+    buffer.append(kind.name);
+    buffer.append('\n');
   }
 
   @Override
   public String toString() {
-    return kind.getPrettyName() + "\n";
+    return kind.name + "\n";
   }
 
   @Override
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/Parser.java b/src/main/java/com/google/devtools/build/lib/syntax/Parser.java
index 169b731..fad276c 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/Parser.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/Parser.java
@@ -1126,16 +1126,26 @@
     }
   }
 
+  // small_stmt | 'pass'
+  private void parseSmallStatementOrPass(List<Statement> list) {
+    if (token.kind == TokenKind.PASS) {
+      list.add(setLocation(new PassStatement(), token.left, token.right));
+      expect(TokenKind.PASS);
+    } else {
+      list.add(parseSmallStatement());
+    }
+  }
+
   // simple_stmt ::= small_stmt (';' small_stmt)* ';'? NEWLINE
   private void parseSimpleStatement(List<Statement> list) {
-    list.add(parseSmallStatement());
+    parseSmallStatementOrPass(list);
 
     while (token.kind == TokenKind.SEMI) {
       nextToken();
       if (token.kind == TokenKind.NEWLINE) {
         break;
       }
-      list.add(parseSmallStatement());
+      parseSmallStatementOrPass(list);
     }
     expectAndRecover(TokenKind.NEWLINE);
   }
@@ -1143,7 +1153,7 @@
   //     small_stmt ::= assign_stmt
   //                  | expr
   //                  | return_stmt
-  //                  | BREAK | CONTINUE | PASS
+  //                  | flow_stmt
   //     assign_stmt ::= expr ('=' | augassign) expr
   //     augassign ::= ('+=' | '-=' | '*=' | '/=' | '%=' | '//=' )
   // Note that these are in Python, but not implemented here (at least for now):
@@ -1152,13 +1162,8 @@
     int start = token.left;
     if (token.kind == TokenKind.RETURN) {
       return parseReturnStatement();
-    } else if (token.kind == TokenKind.BREAK
-        || token.kind == TokenKind.CONTINUE
-        || token.kind == TokenKind.PASS) {
-      TokenKind kind = token.kind;
-      int end = token.right;
-      expect(kind);
-      return setLocation(new FlowStatement(kind), start, end);
+    } else if (token.kind == TokenKind.BREAK || token.kind == TokenKind.CONTINUE) {
+      return parseFlowStatement(token.kind);
     }
     Expression expression = parseExpression();
     if (token.kind == TokenKind.EQUALS) {
@@ -1328,6 +1333,16 @@
     return list;
   }
 
+  // flow_stmt ::= BREAK | CONTINUE
+  private FlowStatement parseFlowStatement(TokenKind kind) {
+    int start = token.left;
+    int end = token.right;
+    expect(kind);
+    FlowStatement.Kind flowKind =
+        kind == TokenKind.BREAK ? FlowStatement.Kind.BREAK : FlowStatement.Kind.CONTINUE;
+    return setLocation(new FlowStatement(flowKind), start, end);
+  }
+
   // return_stmt ::= RETURN [expr]
   private ReturnStatement parseReturnStatement() {
     int start = token.left;
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/PassStatement.java b/src/main/java/com/google/devtools/build/lib/syntax/PassStatement.java
new file mode 100644
index 0000000..e035100
--- /dev/null
+++ b/src/main/java/com/google/devtools/build/lib/syntax/PassStatement.java
@@ -0,0 +1,37 @@
+// Copyright 2017 The Bazel Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.devtools.build.lib.syntax;
+
+import java.io.IOException;
+
+/** Syntax node for a `pass` statement. */
+public class PassStatement extends Statement {
+
+  @Override
+  public void prettyPrint(Appendable buffer, int indentLevel) throws IOException {
+    printIndent(buffer, indentLevel);
+    buffer.append("pass\n");
+  }
+
+  @Override
+  public void accept(SyntaxTreeVisitor visitor) {
+    visitor.visit(this);
+  }
+
+  @Override
+  public Kind kind() {
+    return Kind.PASS;
+  }
+}
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/ReturnStatement.java b/src/main/java/com/google/devtools/build/lib/syntax/ReturnStatement.java
index 6f249cf..4d9c2ad 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/ReturnStatement.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/ReturnStatement.java
@@ -13,12 +13,38 @@
 // limitations under the License.
 package com.google.devtools.build.lib.syntax;
 
+import com.google.devtools.build.lib.events.Location;
 import java.io.IOException;
 import javax.annotation.Nullable;
 
 /** A wrapper Statement class for return expressions. */
 public final class ReturnStatement extends Statement {
 
+  /**
+   * Exception sent by the return statement, to be caught by the function body.
+   */
+  public static class ReturnException extends EvalException {
+    private final Object value;
+
+    public ReturnException(Location location, Object value) {
+      super(
+          location,
+          "return statements must be inside a function",
+          /*dueToIncompleteAST=*/false,
+          /*fillInJavaStackTrace=*/false);
+      this.value = value;
+    }
+
+    public Object getValue() {
+      return value;
+    }
+
+    @Override
+    public boolean canBeAddedToStackTrace() {
+      return false;
+    }
+  }
+
   @Nullable private final Expression returnExpression;
 
   public ReturnStatement(@Nullable Expression returnExpression) {
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/Statement.java b/src/main/java/com/google/devtools/build/lib/syntax/Statement.java
index 1f08bbb..43363fc 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/Statement.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/Statement.java
@@ -33,6 +33,7 @@
     FUNCTION_DEF,
     IF,
     LOAD,
+    PASS,
     RETURN,
   }
 
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/SyntaxTreeVisitor.java b/src/main/java/com/google/devtools/build/lib/syntax/SyntaxTreeVisitor.java
index 523177d..117bbf0 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/SyntaxTreeVisitor.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/SyntaxTreeVisitor.java
@@ -143,13 +143,16 @@
     visitBlock(node.getStatements());
   }
 
+  public void visit(PassStatement node) {}
+
   public void visit(ReturnStatement node) {
     if (node.getReturnExpression() != null) {
       visit(node.getReturnExpression());
     }
   }
 
-  public void visit(FlowStatement node) {}
+  public void visit(FlowStatement node) {
+  }
 
   public void visit(DictionaryLiteral node) {
     visitAll(node.getEntries());
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/UserDefinedFunction.java b/src/main/java/com/google/devtools/build/lib/syntax/UserDefinedFunction.java
index 5bc2da9..460bc35 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/UserDefinedFunction.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/UserDefinedFunction.java
@@ -77,8 +77,24 @@
       }
 
       Eval eval = Eval.fromEnvironment(env);
-      eval.execStatements(statements);
-      return eval.getResult();
+      try {
+        for (Statement stmt : statements) {
+          if (stmt instanceof ReturnStatement) {
+            // Performance optimization.
+            // Executing the statement would throw an exception, which is slow.
+            Expression returnExpr = ((ReturnStatement) stmt).getReturnExpression();
+            if (returnExpr == null) {
+              return Runtime.NONE;
+            }
+            return returnExpr.eval(env);
+          } else {
+            eval.exec(stmt);
+          }
+        }
+      } catch (ReturnStatement.ReturnException e) {
+        return e.getValue();
+      }
+      return Runtime.NONE;
     } finally {
       env.exitScope();
     }
diff --git a/src/main/java/com/google/devtools/build/lib/syntax/ValidationEnvironment.java b/src/main/java/com/google/devtools/build/lib/syntax/ValidationEnvironment.java
index c410aaa..ada8a87 100644
--- a/src/main/java/com/google/devtools/build/lib/syntax/ValidationEnvironment.java
+++ b/src/main/java/com/google/devtools/build/lib/syntax/ValidationEnvironment.java
@@ -144,6 +144,7 @@
       case CONDITIONAL:
       case EXPRESSION:
       case FLOW:
+      case PASS:
       case RETURN:
         // nothing to declare
     }
@@ -212,10 +213,9 @@
 
   @Override
   public void visit(FlowStatement node) {
-    if (node.getKind() != TokenKind.PASS && loopCount <= 0) {
+    if (loopCount <= 0) {
       throw new ValidationException(
-          node.getLocation(),
-          node.getKind().getPrettyName() + " statement must be inside a for loop");
+          node.getLocation(), node.getKind().getName() + " statement must be inside a for loop");
     }
     super.visit(node);
   }
diff --git a/src/test/java/com/google/devtools/build/lib/syntax/ASTPrettyPrintTest.java b/src/test/java/com/google/devtools/build/lib/syntax/ASTPrettyPrintTest.java
index 91b67da..262e4e4 100644
--- a/src/test/java/com/google/devtools/build/lib/syntax/ASTPrettyPrintTest.java
+++ b/src/test/java/com/google/devtools/build/lib/syntax/ASTPrettyPrintTest.java
@@ -291,11 +291,11 @@
   @Test
   public void flowStatement() {
     // The parser would complain if we tried to construct them from source.
-    ASTNode breakNode = new FlowStatement(TokenKind.BREAK);
+    ASTNode breakNode = new FlowStatement(FlowStatement.Kind.BREAK);
     assertIndentedPrettyMatches(breakNode, "  break\n");
     assertTostringMatches(breakNode, "break\n");
 
-    ASTNode continueNode = new FlowStatement(TokenKind.CONTINUE);
+    ASTNode continueNode = new FlowStatement(FlowStatement.Kind.CONTINUE);
     assertIndentedPrettyMatches(continueNode, "  continue\n");
     assertTostringMatches(continueNode, "continue\n");
   }
diff --git a/src/test/java/com/google/devtools/build/lib/syntax/ParserTest.java b/src/test/java/com/google/devtools/build/lib/syntax/ParserTest.java
index 28d7a2a..15bbe94 100644
--- a/src/test/java/com/google/devtools/build/lib/syntax/ParserTest.java
+++ b/src/test/java/com/google/devtools/build/lib/syntax/ParserTest.java
@@ -608,33 +608,28 @@
   }
 
   @Test
-  public void testForBreakContinuePass() throws Exception {
-    List<Statement> file =
-        parseFileForSkylark(
-            "def foo():",
-            "  for i in [1, 2]:",
-            "    break",
-            "    continue",
-            "    pass",
-            "    break");
+  public void testForBreakContinue() throws Exception {
+    List<Statement> file = parseFileForSkylark(
+        "def foo():",
+        "  for i in [1, 2]:",
+        "    break",
+        "    continue",
+        "    break");
     assertThat(file).hasSize(1);
     List<Statement> body = ((FunctionDefStatement) file.get(0)).getStatements();
     assertThat(body).hasSize(1);
 
     List<Statement> loop = ((ForStatement) body.get(0)).getBlock();
-    assertThat(loop).hasSize(4);
+    assertThat(loop).hasSize(3);
 
-    assertThat(((FlowStatement) loop.get(0)).getKind()).isEqualTo(TokenKind.BREAK);
+    assertThat(((FlowStatement) loop.get(0)).getKind()).isEqualTo(FlowStatement.Kind.BREAK);
     assertLocation(34, 39, loop.get(0).getLocation());
 
-    assertThat(((FlowStatement) loop.get(1)).getKind()).isEqualTo(TokenKind.CONTINUE);
+    assertThat(((FlowStatement) loop.get(1)).getKind()).isEqualTo(FlowStatement.Kind.CONTINUE);
     assertLocation(44, 52, loop.get(1).getLocation());
 
-    assertThat(((FlowStatement) loop.get(2)).getKind()).isEqualTo(TokenKind.PASS);
-    assertLocation(57, 61, loop.get(2).getLocation());
-
-    assertThat(((FlowStatement) loop.get(3)).getKind()).isEqualTo(TokenKind.BREAK);
-    assertLocation(66, 71, loop.get(3).getLocation());
+    assertThat(((FlowStatement) loop.get(2)).getKind()).isEqualTo(FlowStatement.Kind.BREAK);
+    assertLocation(57, 62, loop.get(2).getLocation());
   }
 
   @Test
@@ -1019,6 +1014,13 @@
   }
 
   @Test
+  public void testPass() throws Exception {
+    List<Statement> statements = parseFileForSkylark("pass\n");
+    assertThat(statements).hasSize(1);
+    assertThat(statements.get(0)).isInstanceOf(PassStatement.class);
+  }
+
+  @Test
   public void testForPass() throws Exception {
     List<Statement> statements = parseFileForSkylark(
         "def foo():",
@@ -1026,7 +1028,7 @@
 
     assertThat(statements).hasSize(1);
     FunctionDefStatement stmt = (FunctionDefStatement) statements.get(0);
-    assertThat(stmt.getStatements().get(0)).isInstanceOf(FlowStatement.class);
+    assertThat(stmt.getStatements().get(0)).isInstanceOf(PassStatement.class);
   }
 
   @Test