More conversion from error codes to exceptions.

- Remove None checks
- Remove AddErrorContext calls
- Make sure to tickle the errors from test/parse-errors.sh

core/tdop.py

@@ -259,7 +259,7 @@ def ParseUntil(self, rbp):
     """
     # TODO: use Kind.Eof
     if self.op_id in (Id.Eof_Real, Id.Eof_RParen, Id.Eof_Backtick):
-      p_die('Unexpected end of input')
+      p_die('Unexpected end of input', word=self.cur_word)
 
     t = self.cur_word
     self.Next()  # skip over the token, e.g. ! ~ + -
@@ -287,13 +287,8 @@ def ParseUntil(self, rbp):
     return node
 
   def Parse(self):
-    try:
-      self.Next()  # may raise ParseError
-      node = self.ParseUntil(0)
-    except util.ParseError as e:
-      self.error_stack.append(e)
-      return None
-    return node
+    self.Next()  # may raise ParseError
+    return self.ParseUntil(0)
 
 
 class DynamicTdopParser(TdopParser):

osh/arith_parse_test.py

@@ -16,23 +16,16 @@
 from core import word_eval
 from core import state
 from core import test_lib
+from core import util
 
 from osh import parse_lib
 #from osh import arith_parse
 
 
-class ExprSyntaxError(Exception):
-  pass
-
-
 def ParseAndEval(code_str):
   arena = test_lib.MakeArena('<arith_parse_test.py>')
   w_parser, _ = parse_lib.MakeParserForCompletion(code_str, arena)
   anode = w_parser._ReadArithExpr()  # need the right lex state?
-
-  if not anode:
-    raise ExprSyntaxError("failed %s" % w_parser.Error())
-
   print('node:', anode)
 
   mem = state.Mem('', [], {}, None)
@@ -55,7 +48,7 @@ def testEvalExpr(e, expected):
 def testSyntaxError(ex):
   try:
     actual = ParseAndEval(ex)
-  except ExprSyntaxError as e:
+  except util.ParseError as e:
     print(ex, '\t\t', e)
   else:
     raise AssertionError('Expected parse error: %r, got %r' % (ex, actual))

osh/cmd_parse.py

@@ -77,10 +77,6 @@ def ResetInputObjects(self):
   def Error(self):
     return self.error_stack
 
-  def AddErrorContext(self, msg, *args, **kwargs):
-    err = util.ParseError(msg, *args, **kwargs)
-    self.error_stack.append(err)
-
   def GetCompletionState(self):
     return self.completion_stack
 
@@ -124,10 +120,7 @@ def _MaybeReadHereDocs(self):
 
         # NOTE: There can be different kinds of parse errors in here docs.
         word = w_parser.ReadHereDocBody()
-        if not word:
-          self.AddErrorContext(
-              'Error reading here doc body: %s', w_parser.Error())
-          return False
+        assert word is not None
         h.body = word
         h.was_filled = True
       else:
@@ -190,12 +183,10 @@ def _Eat(self, c_id):
     """
     if not self._Peek():
       return False
-    # TODO: It would be nicer to print the word type, right now we get a number
+    # TODO: Printing something like KW_Do is not friendly.  We can map
+    # backwards using the _KEYWORDS list in osh/lex.py.
     if self.c_id != c_id:
-      self.AddErrorContext(
-          "Expected word type %s, got %s", c_id, self.cur_word,
-          word=self.cur_word)
-      return False
+      p_die("Expected word type %s", c_id, word=self.cur_word)
     self._Next()
     return True
 
@@ -686,11 +677,7 @@ def _ParseForExprLoop(self):
     for (( init; cond; update )) for_sep? do_group
     """
     node = self.w_parser.ReadForExpression()
-    if not node:
-      error_stack = self.w_parser.Error()
-      self.error_stack.extend(error_stack)
-      self.AddErrorContext("Parsing for expression failed")
-      return None
+    assert node is not None
     self._Next()
 
     if not self._Peek(): return None
@@ -751,11 +738,8 @@ def _ParseForEachLoop(self):
       node.do_arg_iter = True  # implicit for loop
       # do not advance
 
-    else:
-      # Hm I think these never happens?
-      self.AddErrorContext("Unexpected word in for loop: %s", self.cur_word,
-                           word=self.cur_word)
-      return None
+    else:  # for foo BAD
+      p_die('Unexpected word after for loop variable', word=self.cur_word)
 
     node.spids.extend((in_spid, semi_spid))
 
@@ -851,10 +835,8 @@ def ParseCaseItem(self):
       dsemi_spid = word.LeftMostSpanForWord(self.cur_word)
       self._Next()
     else:
-      # This never happens?
-      self.AddErrorContext('Expected DSEMI or ESAC, got %s', self.cur_word,
-                           word=self.cur_word)
-      return None
+      # Happens on EOF
+      p_die('Expected ;; or esac', word=self.cur_word)
 
     if not self._NewlineOk(): return None
 
@@ -1037,10 +1019,7 @@ def ParseCompoundCommand(self):
       return self.ParseDParen()
 
     # This never happens?
-    self.AddErrorContext(
-        "Expected a compound command (e.g. for while if case), got %s",
-        self.cur_word, word=self.cur_word)
-    return None
+    p_die('Unexpected word while parsing compound command', word=self.cur_word)
 
   def ParseFunctionBody(self, func):
     """
@@ -1185,15 +1164,8 @@ def ParseDBracket(self):
   def ParseDParen(self):
     maybe_error_word = self.cur_word
     self._Next()  # skip ((
-    #print('1 ((', self.cur_word)
     anode = self.w_parser.ReadDParen()
-    if not anode:
-      error_stack = self.w_parser.Error()
-      self.error_stack.extend(error_stack)
-      self.AddErrorContext("Error parsing ((", word=maybe_error_word)
-      return None
-
-    #print('2 ((', self.cur_word)
+    assert anode is not None
     return ast.DParen(anode)
 
   def ParseCommand(self):
@@ -1241,11 +1213,11 @@ def ParseCommand(self):
 
       return self.ParseSimpleCommand()  # echo foo
 
-    # Does this ever happen?
-    self.AddErrorContext(
-        "ParseCommand: Expected to parse a command, got %s", self.cur_word,
-        word=self.cur_word)
-    return None
+    if self.c_kind == Kind.Eof:
+      p_die("Unexpected EOF while parsing command", word=self.cur_word)
+
+    # e.g. )
+    p_die("Invalid word while parsing command", word=self.cur_word)
 
   def ParsePipeline(self):
     """
@@ -1286,7 +1258,6 @@ def ParsePipeline(self):
 
       child = self.ParseCommand()
       if not child:
-        self.AddErrorContext('Error parsing command after pipe')
         # TODO: Return partial pipeline here?  All signatures shouldbe (ok,
         # node).  Only the completion uses the node when ok is False.
         return None
@@ -1399,9 +1370,8 @@ def ParseCommandLine(self):
         done = True
 
       else:
-        self.AddErrorContext(
-            'ParseCommandLine: Unexpected token %s', self.cur_word)
-        return None
+        # Shouldn't happen?
+        assert False, 'ParseCommandLine: Unexpected word %s' % self.cur_word
 
       children.append(child)
 
@@ -1450,7 +1420,6 @@ def ParseCommandTerm(self):
 
       child = self.ParseAndOr()
       if not child:
-        self.AddErrorContext('Error parsing AndOr in ParseCommandTerm')
         return None
 
       if not self._Peek(): return None

osh/cmd_parse_test.py

@@ -489,10 +489,7 @@ def testParsePipeline(self):
     self.assertEqual(3, len(node.children))
     self.assertEqual(command_e.Pipeline, node.tag)
 
-    # Should be an error
-    _, c_parser = InitCommandParser('ls foo|')
-    self.assertEqual(None, c_parser.ParsePipeline())
-    print(c_parser.Error())
+    _assertParseMethod(self, 'ls foo|', 'ParsePipeline', expect_success=False)
 
   def testParsePipelineBash(self):
     node = assertParseCommandList(self, 'ls | cat |& cat')

osh/word_parse.py

@@ -767,9 +767,7 @@ def _ReadArithExpr(self, do_next=True):
     # calls self.ReadWord(lex_mode_e.ARITH)
     a_parser = tdop.TdopParser(arith_parse.SPEC, self)
     anode = a_parser.Parse()
-    if not anode:
-      error_stack = a_parser.Error()
-      self.error_stack.extend(error_stack)
+    assert anode is not None
     return anode  # could be None
 
   def _ReadArithSubPart(self):
@@ -846,9 +844,7 @@ def ReadDParen(self):
     self.lexer.PushHint(Id.Op_RParen, Id.Op_DRightParen)
 
     anode = self._ReadArithExpr()
-    if not anode:
-      self.AddErrorContext("Error parsing dparen statement")
-      return None
+    assert anode is not None
 
     #print('xx ((', self.cur_token)
     if self.token_type != Id.Arith_RParen:
@@ -866,52 +862,33 @@ def ReadDParen(self):
     return anode
 
   def ReadForExpression(self):
-    """Read ((i=0; i<5; ++i)) -- part of command context.
-
-    """
+    """Read ((i=0; i<5; ++i)) -- part of command context."""
     # No PushHint because we're in arith state.
     #self.lexer.PushHint(Id.Op_RParen, Id.Op_DRightParen)
 
     self._Next(lex_mode_e.ARITH)  # skip over ((
 
     self._Peek()
-    if self.token_type == Id.Arith_Semi:
-      #print('Got empty init')
+    if self.token_type == Id.Arith_Semi:  # for (( ; i < 10; i++ ))
       init_node = None
     else:
       init_node = self._ReadArithExpr(do_next=False)
-      if not init_node:
-        self.AddErrorContext("Error parsing for init")
-        return None
     self._Next(lex_mode_e.ARITH)
-    #print('INIT',init_node)
 
     self._Peek()
-    if self.token_type == Id.Arith_Semi:
-      #print('Got empty condition')
+    if self.token_type == Id.Arith_Semi:  # for (( ; ; i++ ))
       cond_node = None
     else:
       cond_node = self._ReadArithExpr(do_next=False)
-      if not cond_node:
-        self.AddErrorContext("Error parsing for cond")
-        return None
     self._Next(lex_mode_e.ARITH)
-    #print('COND',cond_node)
 
     self._Peek()
-    if self.token_type == Id.Arith_RParen:
-      #print('Got empty update')
+    if self.token_type == Id.Arith_RParen:  # for (( ; ; ))
       update_node = None
     else:
       update_node = self._ReadArithExpr(do_next=False)
-      if not update_node:
-        self.AddErrorContext("Error parsing for update")
-        return None
     self._Next(lex_mode_e.ARITH)
-    #print('UPDATE',update_node)
 
-    #print('TT', self.cur_token)
-    # Second paren
     self._Peek()
     if self.token_type != Id.Arith_RParen:
       p_die('Expected ) to end for loop expression, got %r',
@@ -1240,8 +1217,6 @@ def ReadHereDocBody(self):
     """
     w = ast.CompoundWord()
     dq = self._ReadDoubleQuotedPart(here_doc=True)
-    if not dq:
-      self.AddErrorContext('Error parsing here doc body')
-      return False
+    assert dq is not None
     w.parts.append(dq)
     return w

test/parse-errors.sh

@@ -203,12 +203,20 @@ cmd-parse() {
   _error-case 'for $x in 1 2 3; do echo $i; done'
   _error-case 'for x.y in 1 2 3; do echo $i; done'
   _error-case 'for x in 1 2 3; &'
+  _error-case 'for foo BAD'
 
   _error-case 'x"y"() { echo hi; }'
 
   _error-case 'function x"y" { echo hi; }'
 
   _error-case '}'
+
+  _error-case 'case foo in *) echo '
+
+  _error-case 'ls foo|'
+  _error-case 'ls foo&&'
+
+  _error-case 'foo()'
 }
 
 redirect() {