[spec/builtin-meta] Failing test cases for builtin local s=42, etc.

Also refactor detection of assignment builtins.

Author: Andy C

osh/word_eval.py

@@ -377,9 +377,8 @@ def _PerformSlice(
             # NOTE: This error is ALWAYS fatal in bash.  It's inconsistent with
             # strings.
             if has_length and length < 0:
-                e_die(
-                    "Array slice can't have negative length: %d" %
-                    length, loc.WordPart(part))
+                e_die("Array slice can't have negative length: %d" % length,
+                      loc.WordPart(part))
 
             # Quirk: "begin" for positional arguments ($@ and $*) counts $0.
             if arg0_val is not None:
@@ -2151,7 +2150,7 @@ def SimpleEvalWordSequence2(self, words, allow_assign):
         for i, w in enumerate(words):
             # No globbing in the first arg for command.Simple.
             if i == 0 and allow_assign:
-                strs0 = self._EvalWordToArgv(w)  # respects strict-array
+                strs0 = self._EvalWordToArgv(w)
                 if len(strs0) == 1:
                     arg0 = strs0[0]
                     builtin_id = consts.LookupAssignBuiltin(arg0)
@@ -2202,17 +2201,30 @@ def SimpleEvalWordSequence2(self, words, allow_assign):
 
         return cmd_value.Argv(strs, locs, None, None, None, None)
 
+    def _DetectAssignBuiltinStr(self, arg0, words):
+        # type: (str, List[CompoundWord]) -> Optional[cmd_value.Assign]
+        builtin_id = consts.LookupAssignBuiltin(arg0)
+        if builtin_id != consts.NO_INDEX:
+            return self._EvalAssignBuiltin(builtin_id, arg0, words)
+        return None
+
+    def _DetectAssignBuiltin(self, val0, words):
+        # type: (part_value_t, List[CompoundWord]) -> Optional[cmd_value.Assign]
+        UP_val0 = val0
+        if val0.tag() == part_value_e.String:
+            val0 = cast(Piece, UP_val0)
+            if not val0.quoted:
+                return self._DetectAssignBuiltinStr(val0.s, words)
+        return None
+
     def EvalWordSequence2(self, words, allow_assign=False):
         # type: (List[CompoundWord], bool) -> cmd_value_t
         """Turns a list of Words into a list of strings.
 
         Unlike the EvalWord*() methods, it does globbing.
 
         Args:
-          words: list of Word instances
-
-        Returns:
-          argv: list of string arguments, or None if there was an eval error
+          allow_assign: True for command.Simple, False for BashArray a=(1 2 3)
         """
         if self.exec_opts.simple_word_eval():
             return self.SimpleEvalWordSequence2(words, allow_assign)
@@ -2242,10 +2254,9 @@ def EvalWordSequence2(self, words, allow_assign=False):
 
                 # e.g. the 'local' in 'local a=b c=d' will be here
                 if allow_assign and i == 0:
-                    builtin_id = consts.LookupAssignBuiltin(fast_str)
-                    if builtin_id != consts.NO_INDEX:
-                        return self._EvalAssignBuiltin(builtin_id, fast_str,
-                                                       words)
+                    cmd_val = self._DetectAssignBuiltinStr(fast_str, words)
+                    if cmd_val:
+                        return cmd_val
                 continue
 
             part_vals = []  # type: List[part_value_t]
@@ -2261,15 +2272,9 @@ def EvalWordSequence2(self, words, allow_assign=False):
             # But we don't want to evaluate the first word twice in the case of:
             #   $(some-command) --flag
             if allow_assign and i == 0 and len(part_vals) == 1:
-                val0 = part_vals[0]
-                UP_val0 = val0
-                if val0.tag() == part_value_e.String:
-                    val0 = cast(Piece, UP_val0)
-                    if not val0.quoted:
-                        builtin_id = consts.LookupAssignBuiltin(val0.s)
-                        if builtin_id != consts.NO_INDEX:
-                            return self._EvalAssignBuiltin(
-                                builtin_id, val0.s, words)
+                cmd_val = self._DetectAssignBuiltin(part_vals[0], words)
+                if cmd_val:
+                    return cmd_val
 
             if 0:
                 log('')

spec/builtin-meta.test.sh

@@ -1,8 +1,6 @@
-## oils_failures_allowed: 0
+## oils_failures_allowed: 6
 ## compare_shells: dash bash mksh zsh
 
-
-
 #### command -v
 myfunc() { echo x; }
 command -v echo
@@ -320,3 +318,200 @@ builtin command echo hi
 ## stdout: hi
 ## N-I dash status: 127
 ## N-I dash stdout-json: ""
+
+#### builtin typeset / export / readonly
+case $SH in dash) exit ;; esac
+
+builtin typeset s=typeset
+echo s=$s
+
+builtin export s=export
+echo s=$s
+
+builtin readonly s=readonly
+echo s=$s
+
+echo --
+
+builtin builtin typeset s2=typeset
+echo s2=$s2
+
+builtin builtin export s2=export
+echo s2=$s2
+
+builtin builtin readonly s2=readonly
+echo s2=$s2
+
+## STDOUT:
+s=typeset
+s=export
+s=readonly
+--
+s2=typeset
+s2=export
+s2=readonly
+## END
+## N-I dash STDOUT:
+## END
+
+#### builtin declare / local
+case $SH in dash|mksh) exit ;; esac
+
+builtin declare s=declare
+echo s=$s
+
+f() {
+  builtin local s=local
+  echo s=$s
+}
+
+f
+
+## STDOUT:
+s=declare
+s=local
+## END
+## N-I dash/mksh STDOUT:
+## END
+
+#### builtin declare etc. with array is not parsed
+
+$SH -c 'builtin declare a=(x y)'
+test $? -ne 0 && echo 'fail'
+
+$SH -c 'builtin declare -a a=(x y)'
+test $? -ne 0 && echo 'fail'
+
+## STDOUT:
+fail
+fail
+## END
+
+#### command export / readonly
+case $SH in zsh) exit ;; esac
+
+# dash doesn't have declare typeset
+
+command export c=export
+echo c=$c
+
+command readonly c=readonly
+echo c=$c
+
+echo --
+
+command command export cc=export
+echo cc=$cc
+
+command command readonly cc=readonly
+echo cc=$cc
+
+## STDOUT:
+c=export
+c=readonly
+--
+cc=export
+cc=readonly
+## END
+## N-I zsh STDOUT:
+## END
+
+#### command local
+
+f() {
+  command local s=local
+  echo s=$s
+}
+
+f
+
+## STDOUT:
+s=local
+## END
+## BUG dash/mksh/zsh STDOUT:
+s=
+## END
+
+
+#### static builtin command ASSIGN, command builtin ASSIGN
+case $SH in dash|zsh) exit ;; esac
+
+# dash doesn't have declare typeset
+
+builtin command export bc=export
+echo bc=$bc
+
+builtin command readonly bc=readonly
+echo bc=$bc
+
+echo --
+
+command builtin export cb=export
+echo cb=$cb
+
+command builtin readonly cb=readonly
+echo cb=$cb
+
+## STDOUT:
+bc=export
+bc=readonly
+--
+cb=export
+cb=readonly
+## END
+## N-I dash/zsh STDOUT:
+## END
+
+#### dynamic builtin command ASSIGN, command builtin ASSIGN
+case $SH in dash|zsh) exit ;; esac
+
+b=builtin
+c=command
+e=export
+r=readonly
+
+$b $c export bc=export
+echo bc=$bc
+
+$b $c readonly bc=readonly
+echo bc=$bc
+
+echo --
+
+$c $b export cb=export
+echo cb=$cb
+
+$c $b readonly cb=readonly
+echo cb=$cb
+
+echo --
+
+$b $c $e bce=export
+echo bce=$bce
+
+$b $c $r bcr=readonly
+echo bcr=$bcr
+
+echo --
+
+$c $b $e cbe=export
+echo cbe=$cbe
+
+$c $b $r cbr=readonly
+echo cbr=$cbr
+
+## STDOUT:
+bc=export
+bc=readonly
+--
+cb=export
+cb=readonly
+--
+bce=export
+bcr=readonly
+--
+cbe=export
+cbr=readonly
+## END
+## N-I dash/zsh STDOUT:
+## END