fix(parse): Error on empty expressions

Initially, I planned for `{{}}` to evaluate to `""`.  I asked myself:
when would people ever do `{{}}` intentionally?  How often might it be
unintentional?  So I decided to make it
an error for now.

Fixes #139

src/compiler/parser.rs

@@ -42,29 +42,32 @@ pub fn parse(elements: &[Element], options: &LiquidOptions) -> Result<Vec<Box<Re
     let mut iter = elements.iter();
     let mut token = iter.next();
     while token.is_some() {
-        match *token.unwrap() {
-            Element::Expression(ref tokens, _) => ret.push(try!(parse_expression(tokens, options))),
-            Element::Tag(ref tokens, _) => ret.push(try!(parse_tag(&mut iter, tokens, options))),
-            Element::Raw(ref x) => ret.push(Box::new(Text::new(x))),
-        }
+        let render = match *token.unwrap() {
+            Element::Expression(ref tokens, _) => parse_expression(tokens, options)?,
+            Element::Tag(ref tokens, _) => parse_tag(&mut iter, tokens, options)?,
+            Element::Raw(ref x) => Box::new(Text::new(x)),
+        };
+        ret.push(render);
         token = iter.next();
     }
     Ok(ret)
 }
 
 // creates an expression, which wraps everything that gets rendered
 fn parse_expression(tokens: &[Token], options: &LiquidOptions) -> Result<Box<Renderable>> {
-    match tokens[0] {
-        Token::Identifier(ref x) if tokens.len() > 1 &&
-                                    (tokens[1] == Token::Dot || tokens[1] == Token::OpenSquare) => {
+    match tokens.get(0) {
+        Some(&Token::Identifier(ref x)) if tokens.len() > 1 &&
+                                           (tokens[1] == Token::Dot ||
+                                            tokens[1] == Token::OpenSquare) => {
             let indexes = parse_indexes(&tokens[1..])?;
             let mut result = Variable::new(x.clone());
             result.extend(indexes);
             Ok(Box::new(result))
         }
-        Token::Identifier(ref x) if options.tags.contains_key(x) => {
+        Some(&Token::Identifier(ref x)) if options.tags.contains_key(x) => {
             options.tags[x].parse(x, &tokens[1..], options)
         }
+        None => Error::parser("expression", None),
         _ => {
             let output = parse_output(tokens)?;
             Ok(Box::new(output))
@@ -381,6 +384,7 @@ mod test_split_block {
     use super::super::FnParseBlock;
     use interpreter::Renderable;
     use interpreter::Context;
+    use interpreter;
 
     #[derive(Debug)]
     struct NullBlock;
@@ -409,6 +413,15 @@ mod test_split_block {
         options
     }
 
+    #[test]
+    fn parse_empty_expression() {
+        let text = "{{}}";
+
+        let tokens = tokenize(&text).unwrap();
+        let template = parse(&tokens, &options()).map(interpreter::Template::new);
+        assert!(template.is_err());
+    }
+
     #[test]
     fn handles_nonmatching_stream() {
         // A stream of tokens with lots of `else`s in it, but only one at the
@@ -425,7 +438,6 @@ mod test_split_block {
         assert!(trailing.is_none());
     }
 
-
     #[test]
     fn honours_nesting() {
         // A stream of tokens with lots of `else`s in it, but only one at the