[rename] Oil -> YshExpr in frontend/syntax.asdl

oilshell · May 21, 2023 · 0d2f731 · 0d2f731
1 parent ebdce70
commit 0d2f731
Show file tree

Hide file tree

Showing 4 changed files with 24 additions and 25 deletions.
diff --git a/frontend/syntax.asdl b/frontend/syntax.asdl
@@ -1,4 +1,4 @@
-# Data types for the Oil AST, aka "Lossless Syntax Tree".
+# Data types for the Oils AST, aka "Lossless Syntax Tree".
 #
 # Invariant: the source text can be reconstructed byte-for-byte from this
 # tree.  The test/arena.sh file partially verifies this.
@@ -118,7 +118,7 @@ module syntax
   suffix_op = 
     Nullary %Token  # ${x@Q} or ${!prefix@} (which also has prefix_op)
   | Unary(Token op, rhs_word arg_word)  # e.g. ${v:-default}
-    # TODO: Implement Oil's ${x|html} and ${x %.3f}
+    # TODO: Implement YSH ${x|html} and ${x %.3f}
   | Static(Token tok, str arg)
   | PatSub(CompoundWord pat, rhs_word replace, id replace_mode, Token slash_tok)
     # begin is optional with ${array::1}
@@ -180,7 +180,7 @@ module syntax
   # extended globs are parsed statically, unlike globs
   | ExtGlob(Token op, List[CompoundWord] arms, Token right)
 
-    # Oil word_part extensions
+    # YSH word_part extensions
 
     # @myarray
   | Splice(Token blame_tok, str var_name)
@@ -254,7 +254,7 @@ module syntax
 
   condition = 
     Shell(List[command] commands)  # if false; true; then echo hi; fi
-  | Oil(expr e)                    # if (x > 0) { echo hi }
+  | YshExpr(expr e)                # if (x > 0) { echo hi }
 
   # Each arm tests one word against multiple words
   # shell:  *.cc|*.h) echo C++ ;;
@@ -277,7 +277,7 @@ module syntax
   # commands we match against a word.
   case_arg =
     Word(word w)
-  | OilExpr(expr e)
+  | YshExpr(expr e)
 
   # Each if arm starts with either an "if" or "elif" keyword
   # In YSH, the then keyword is not used (replaced by braces {})
@@ -286,10 +286,10 @@ module syntax
       List[int] spids)
 
   for_iter =
-    Args                      # for x; do echo $x; done # implicit "$@"
-  | Words(List[word] words)   # for x in 'foo' *.py { echo $x }
-                              # like ShArrayLiteral, but no location for %(
-  | Oil(expr e, Token blame)  # for x in (mylist) { echo $x }
+    Args                          # for x; do echo $x; done # implicit "$@"
+  | Words(List[word] words)       # for x in 'foo' *.py { echo $x }
+                                  # like ShArrayLiteral, but no location for %(
+  | YshExpr(expr e, Token blame)  # for x in (mylist) { echo $x }
 
   BraceGroup = (
       Token left, Token? doc_token, List[command] children,
@@ -351,7 +351,7 @@ module syntax
     # 4. Subshell  # single child that's a CommandList
   | CommandList(List[command] children)
 
-    # Oil stuff
+    # YSH command constructs
 
     # For 'x = myexpr'.  There's no type and no comma allowed.
   | BareDecl(Token lhs, expr rhs)
@@ -525,8 +525,7 @@ module syntax
     # (Starred is NOT used for {k:v, **a}.  That used a blank "keys"
     # attribute.)
 
-    # In Oil, "spreading" will be @[1 ...array2] [b, ...list2] and
-    # {k: v, ...dict2}.  We don't need two different symbols.
+    # I think we can use { **pairs } like Python
   | Spread(expr child, expr_context ctx)
 
   #

diff --git a/osh/cmd_eval.py b/osh/cmd_eval.py
@@ -612,9 +612,9 @@ def _EvalCondition(self, cond, blame_tok):
 
         b = cond_status == 0
 
-      elif case(condition_e.Oil):
+      elif case(condition_e.YshExpr):
         if mylib.PYTHON:
-          cond = cast(condition.Oil, UP_cond)
+          cond = cast(condition.YshExpr, UP_cond)
           obj = self.expr_ev.EvalExpr(cond.e, blame_tok)
           b = bool(obj)
 
@@ -635,9 +635,9 @@ def _EvalCaseArg(self, arg, blame):
         arg = cast(case_arg.Word, UP_arg)
         return self.word_ev.EvalWordToString(arg.w).s
 
-      elif case(case_arg_e.OilExpr):
+      elif case(case_arg_e.YshExpr):
         if mylib.PYTHON:
-          arg = cast(case_arg.OilExpr, UP_arg)
+          arg = cast(case_arg.YshExpr, UP_arg)
           obj = self.expr_ev.EvalExpr(arg.e, blame)
           return str(obj) # TODO: handle typed args
 
@@ -1186,8 +1186,8 @@ def _Dispatch(self, node, cmd_st):
             words = braces.BraceExpandWords(iterable.words)
             iter_list = self.word_ev.EvalWordSequence(words)
 
-          elif case(for_iter_e.Oil):
-            iterable = cast(for_iter.Oil, UP_iterable)
+          elif case(for_iter_e.YshExpr):
+            iterable = cast(for_iter.YshExpr, UP_iterable)
             iter_expr = iterable.e
             iter_expr_blame = iterable.blame
 

diff --git a/osh/cmd_parse.py b/osh/cmd_parse.py
@@ -1206,7 +1206,7 @@ def _ParseForEachLoop(self, for_kw):
       self._Next()  # skip in
       if self.w_parser.LookPastSpace() == Id.Op_LParen:
         enode, last_token = self.parse_ctx.ParseOilExpr(self.lexer, grammar_nt.oil_expr)
-        node.iterable = for_iter.Oil(enode, last_token)
+        node.iterable = for_iter.YshExpr(enode, last_token)
 
         # For simplicity, we don't accept for x in (obj); do ...
         self._Peek()
@@ -1288,7 +1288,7 @@ def ParseWhileUntil(self, keyword):
 
     if self.parse_opts.parse_paren() and self.w_parser.LookPastSpace() == Id.Op_LParen:
       enode, _ = self.parse_ctx.ParseOilExpr(self.lexer, grammar_nt.oil_expr)
-      cond = condition.Oil(enode)  # type: condition_t
+      cond = condition.YshExpr(enode)  # type: condition_t
     else:
       self.allow_block = False
       commands = self._ParseCommandList()
@@ -1447,7 +1447,7 @@ def ParseOilCase(self, case_node):
     Call this after we're past 'case'.
     """
     enode, _ = self.parse_ctx.ParseOilExpr(self.lexer, grammar_nt.oil_expr)
-    case_node.to_match = case_arg.OilExpr(enode)
+    case_node.to_match = case_arg.YshExpr(enode)
 
     ate = self._Eat(Id.Lit_LBrace)
     case_node.arms_start = word_.BraceToken(ate)
@@ -1526,7 +1526,7 @@ def _ParseOilElifElse(self, if_node):
       if (self.parse_opts.parse_paren() and
           self.w_parser.LookPastSpace() == Id.Op_LParen):
         enode, _ = self.parse_ctx.ParseOilExpr(self.lexer, grammar_nt.oil_expr)
-        cond = condition.Oil(enode)  # type: condition_t
+        cond = condition.YshExpr(enode)  # type: condition_t
       else:
         self.allow_block = False
         commands= self._ParseCommandList()
@@ -1627,7 +1627,7 @@ def ParseIf(self):
     # Remove ambiguity with if cd / {
     if self.parse_opts.parse_paren() and self.w_parser.LookPastSpace() == Id.Op_LParen:
       enode, _ = self.parse_ctx.ParseOilExpr(self.lexer, grammar_nt.oil_expr)
-      cond = condition.Oil(enode)  # type: condition_t
+      cond = condition.YshExpr(enode)  # type: condition_t
     else:
       self.allow_block = False
       commands = self._ParseCommandList()

diff --git a/tools/osh2oil.py b/tools/osh2oil.py
@@ -642,7 +642,7 @@ def DoCommand(self, node, local_symbols, at_top_level=False):
           elif case(for_iter_e.Words):
             pass
 
-          elif case(for_iter_e.Oil):
+          elif case(for_iter_e.YshExpr):
             pass
 
         if node.semi_tok is not None:
@@ -734,7 +734,7 @@ def DoCommand(self, node, local_symbols, at_top_level=False):
 
         to_match = None  # type: word_t
         with tagswitch(node.to_match) as case:
-          if case(case_arg_e.OilExpr):
+          if case(case_arg_e.YshExpr):
             #self.cursor.PrintUntilSpid(arms_end_spid)
             #self.cursor.SkipUntilSpid(arms_end_spid + 1)
             return