word_parse.py: Remove obsolete None checks.

Addresses issue #103.

osh/word_parse.py

@@ -77,6 +77,23 @@ def __init__(self, lexer, line_reader, lex_mode=lex_mode_e.OUTER):
     self.line_reader = line_reader
     self.Reset(lex_mode=lex_mode)
 
+  def Reset(self, lex_mode=lex_mode_e.OUTER):
+    """Called by interactive loop."""
+    # For _Peek()
+    self.prev_token = None  # for completion
+    self.cur_token = None
+    self.token_kind = Kind.Undefined
+    self.token_type = Id.Undefined_Tok
+
+    self.next_lex_mode = lex_mode
+
+    # For newline.  TODO: I think we can do this iteratively, without member
+    # state.
+    self.cursor = None
+    self.cursor_was_newline = False
+
+    self.error_stack = []
+
   def _Peek(self):
     """Helper method."""
     if self.next_lex_mode is not None:
@@ -95,23 +112,6 @@ def _Next(self, lex_mode):
     """
     self.next_lex_mode = lex_mode
 
-  def Reset(self, lex_mode=lex_mode_e.OUTER):
-    """Called by interactive loop."""
-    # For _Peek()
-    self.prev_token = None  # for completion
-    self.cur_token = None
-    self.token_kind = Kind.Undefined
-    self.token_type = Id.Undefined_Tok
-
-    self.next_lex_mode = lex_mode
-
-    # For newline.  TODO: I think we can do this iteratively, without member
-    # state.
-    self.cursor = None
-    self.cursor_was_newline = False
-
-    self.error_stack = []
-
   def Error(self):
     return self.error_stack
 
@@ -152,25 +152,18 @@ def _ReadSliceVarOp(self):
       begin = None  # no beginning specified
     else:
       begin = self._ReadArithExpr()
-      if not begin: return None
-      #print('BEGIN', begin)
-      #print('BVS2', self.cur_token)
 
     if self.token_type == Id.Arith_RBrace:
       return ast.Slice(begin, None)  # No length specified
 
     # Id.Arith_Colon is a pun for Id.VOp2_Colon
-    elif self.token_type == Id.Arith_Colon:
+    if self.token_type == Id.Arith_Colon:
       self._Next(lex_mode_e.ARITH)
       length = self._ReadArithExpr()
-      if not length: return None
-
-      #print('after colon', self.cur_token)
       return ast.Slice(begin, length)
 
-    else:
-      p_die("Unexpected token in slice: %r", self.cur_token.val,
-            token=self.cur_token)
+    p_die("Unexpected token in slice: %r", self.cur_token.val,
+          token=self.cur_token)
 
   def _ReadPatSubVarOp(self, lex_mode):
     """
@@ -183,8 +176,6 @@ def _ReadPatSubVarOp(self, lex_mode):
     do_suffix = False
 
     pat = self._ReadVarOpArg(lex_mode, eof_type=Id.Lit_Slash, empty_ok=False)
-    if not pat:
-      return None
 
     if len(pat.parts) == 1:
       ok, s, quoted = word.StaticEval(pat)
@@ -219,10 +210,8 @@ def _ReadPatSubVarOp(self, lex_mode):
       # e.g. ${v/a} is the same as ${v/a/}  -- empty replacement string
       return ast.PatSub(pat, None, do_all, do_prefix, do_suffix)
 
-    elif self.token_type == Id.Lit_Slash:
+    if self.token_type == Id.Lit_Slash:
       replace = self._ReadVarOpArg(lex_mode)  # do not stop at /
-      if not replace:
-        return None
 
       self._Peek()
       if self.token_type != Id.Right_VarSub:
@@ -234,10 +223,9 @@ def _ReadPatSubVarOp(self, lex_mode):
 
       return ast.PatSub(pat, replace, do_all, do_prefix, do_suffix)
 
-    else:
-      # Happens with ${x//} and ${x///foo}, see test/parse-errors.sh
-      p_die("Expected } after pat sub, got %r", self.cur_token.val,
-            token=self.cur_token)
+    # Happens with ${x//} and ${x///foo}, see test/parse-errors.sh
+    p_die("Expected } after pat sub, got %r", self.cur_token.val,
+          token=self.cur_token)
 
   def _ReadSubscript(self):
     """ Subscript = '[' ('@' | '*' | ArithExpr) ']'
@@ -436,7 +424,6 @@ def _ReadBracedBracedVarSub(self, d_quoted=False):
 
       else:  # not a prefix, '#' is the variable
         part = self._ParseVarExpr(arg_lex_mode)
-        if not part: return None
 
     elif ty == Id.VSub_Bang:
       t = self.lexer.LookAhead(lex_mode_e.VS_1)
@@ -450,18 +437,15 @@ def _ReadBracedBracedVarSub(self, d_quoted=False):
         # No lookahead -- do it in a second step, or at runtime
         self._Next(lex_mode_e.VS_1)
         part = self._ParseVarExpr(arg_lex_mode)
-        if not part: return None
 
         part.prefix_op = Id.VSub_Bang
 
       else:  # not a prefix, '!' is the variable
         part = self._ParseVarExpr(arg_lex_mode)
-        if not part: return None
 
     # VS_NAME, VS_NUMBER, symbol that isn't # or !
     elif self.token_kind == Kind.VSub:
       part = self._ParseVarExpr(arg_lex_mode)
-      if not part: return None
 
     else:
       # e.g. ${^}
@@ -665,7 +649,6 @@ def _ReadDoubleQuotedPart(self):
     self._ReadLikeDQ(left_dq_token, dq_part.parts)
 
     dq_part.spids.append(self.cur_token.span_id)  # Right "
-
     return dq_part
 
   def _ReadCommandSubPart(self, token_type):
@@ -800,7 +783,6 @@ def ReadDParen(self):
 
     self._Next(lex_mode_e.ARITH)
     anode = self._ReadArithExpr()
-    assert anode is not None
 
     #print('xx ((', self.cur_token)
     if self.token_type != Id.Arith_RParen:
@@ -995,7 +977,6 @@ def _ReadCompoundWord(self, eof_type=Id.Undefined_Tok,
 
   def _ReadArithWord(self):
     """Helper function for ReadArithWord."""
-
     self._Peek()
 
     if self.token_kind == Kind.Unknown:
@@ -1151,18 +1132,16 @@ def ReadWord(self, lex_mode):
     return self.cursor
 
   def ReadHereDocBody(self, parts):
-    """
-    Sort of like Read(), except we're in a double quoted context, but not using
-    double quotes.
-    """
+    """A here doc is like a double quoted context, except " isn't special."""
     self._ReadLikeDQ(None, parts)
     # Returns nothing
 
   def ReadPS(self):
-    """For $PS1, $PS4, etc."""
-    # NOTE: Reading PS4 is just like reading a here doc line.  "\n" is allowed
-    # too.  The OUTER mode would stop at spaces, and ReadWord doesn't allow
-    # lex_mode_e.DQ.
+    """For $PS1, $PS4, etc.
+
+    This is just like reading a here doc line.  "\n" is allowed, as well as the
+    typical substitutions ${x} $(echo hi) $((1 + 2)).
+    """
     w = ast.CompoundWord()
     self._ReadLikeDQ(None, w.parts)
     return w