[spec/ysh-user-feedback] Failing test cases for feedback related to static var and setvar

From Julian, Aidan, Machine Stops

OK we should get rid of those static checks.

[demo] Test out the equivalent in JavaScript

Funny thing: I found a corner of JavaScript where you can either mutate
or redeclare the loop variable, with 'let'.  I thought that you would
not be allowed to redeclare it - because there should be a single
block/scope for the loop body?

But it appears there are two?

More JavaScript oddities.

Author: Andy C

demo/survey-static-names.sh

@@ -84,42 +84,232 @@ js-var() {
   }
   '
 
-  banner 'STRICT UNDEF'
+  banner 'USE BEFORE LET'
+  nodejs -e '
+  function outer() {
+    // fails dynamically with ReferenceError
+    console.log(`use before let: x=${x}`);
+    let x = "foo";
+  }
+
+  outer();
+  '
+
+  echo
+}
+
+control-flow() {
+  banner 'BREAK'
+
+  # this is a syntax error!  OK good
+  nodejs -e '
+  function f() {
+    break;
+  }
+'
+}
+
+use-strict-static() {
+  set +o errexit
+
+  banner 'DUPE PARAMS'
   nodejs -e '
   "use strict";
+  function f(a, a) {
+    return 42;
+  }
+  '
 
-  function outer() {
-    let y = x + 1
-    console.log(`x=${x}`);
+  banner 'OCTAL'
+  nodejs -e '
+  "use strict";
+  function f(a) {
+    return 0123;
   }
   '
 
-  banner 'STRICT MUTATE'
+  banner 'WITH'
+
   nodejs -e '
+  "use strict";
+  function f() {
+    with (x) {
+      console.log(x);
+    }
+  }
+  '
 
-  // Use strict prevents global mutation!  But only at runtime
+  banner 'OBJECT KEYS'
+
+  # Claude AI hallucinated this duplicate object keys, and then corrected itself
+  nodejs -e '
+  "use strict";
+  function f() {
+    return {a:1, a:2};
+  }
+  '
+}
+
+branches() {
+  set +o errexit
+
+  # spec/ysh-user-feedback - Julian
+
+  # JavaScript allows this because it's block scoped
+  banner 'IF'
+  nodejs -e '
+  function f(x) {
+    if (x === 2) {
+      let tmp = "hello"
+    } else {
+      let tmp = "world"
+      // This is an error
+      // let tmp = "z"
+    }
+    //console.log(tmp);
+  }
+
+  f(1);
+  f(2);
+  '
+
+  banner 'SWITCH'
+  nodejs -e '
+  function f(x) {
+    switch (x) {
+      case 1:
+        let tmp = "hello"
+        break;
+      case 2:
+        let tmp = "world"
+        break;
+    }
+  }
+
+  f(1);
+  f(2);
+  '
+
+  banner 'SWITCH BLOCK'
+  nodejs -e '
+  function f(x) {
+    switch (x) {
+      case 1: {
+        let tmp = "hello"
+        console.log(tmp);
+        break;
+      }
+      case 2: {
+        let tmp = "world"
+        console.log(tmp);
+        break;
+      }
+    }
+  }
+
+  f(1);
+  f(2);
+  '
+}
+
+loop() {
+  banner 'MODIFY FOR'
+  nodejs -e '
+  function f() {
+    for (let x of [1, 2]) {
+      console.log(`x = ${x}`);
+      x = 3;
+      console.log(x);
+    }
+  }
+
+  f();
+  '
+
+  # Hm why is this allowed?
+  banner 'LET LET'
+  nodejs -e '
+  function f() {
+    for (let x of [1, 2]) {
+      // console.log(`x = ${x}`);
+      let x = 3;
+      console.log(x);
+    }
+  }
+
+  f();
+  '
+  # Claude AI claims that there are two nested scopes, but I'm not so sure
+  # It seemed to enter an infinite loop where the code analysis didn't agree
+  # with it
+
+  # It also refers to "loop initialization scope" and "loop body scope"
+
+  # Another attempt:
+
+  # "What the specification actually describes is more precise and technical.
+  # For a for...of loop like for (let x of [1,2]) { let x = 3 }, the ECMAScript
+  # spec (as of ES2022) describes the behavior using concepts like:
+
+  # "Per-iteration binding instantiation - Each iteration of the loop creates a
+  # new lexical environment for the loop variable
+  #
+  # "Block scoping - The {} of the loop body creates its own lexical environment
+
+  # "According to the specification, for loops with let declarations create a
+  # fresh binding (variable) for each iteration of the loop. The loop body then
+  # creates another lexical environment (scope) where another binding with the
+  # same name can exist independently.
+
+  # "The precise section in the ECMAScript spec that addresses this is
+  # typically found in sections covering "for statement" execution semantics.
+  # The loop iteration variable and the loop body variable are in different
+  # lexical environments in the specification's terminology, rather than
+  # different "scopes" as I informally described.
+
+  banner 'LET x y'
+  nodejs -e '
+
+  // Uh this is weird too, y = 1?
+  function f() {
+    for (let x = 0, y = x + 1; x < 5; ++x) {
+      console.log(`x = ${x}, y = ${y}`);
+      //let x = 3;
+    }
+  }
+
+  f();
+  '
+}
+
+
+use-strict-dynamic() {
+  set +o errexit
+
+  banner 'STRICT UNDEF'
+  nodejs -e '
   "use strict";
 
   function outer() {
-    x = "mutate"
+    let y = x + 1;  // ReferenceError
+    console.log(`x=${x}`);
   }
 
   outer();
-  console.log(`was global created? x=${x}`);
   '
 
-  banner 'USE BEFORE LET'
+  banner 'STRICT MUTATE'
   nodejs -e '
+  // Use strict prevents global mutation!  But only at runtime
+  "use strict";
+
   function outer() {
-    // fails dynamically with ReferenceError
-    console.log(`use before let: x=${x}`);
-    let x = "foo";
+    x = "mutate"
   }
 
   outer();
+  console.log(`was global created? x=${x}`);
   '
-
-  echo
 }
 
 "$@"

spec/ysh-user-feedback.test.sh

@@ -1,4 +1,5 @@
 ## our_shell: ysh
+## oils_failures_allowed: 3
 
 #### !== operator
 var a = 'bar'
@@ -126,7 +127,7 @@ json write (e)
 ## END
 
 #### Invalid op on string
-shopt -s oil:all
+shopt -s ysh:all
 
 var clients = {'email': 'foo', 'e2': 'bar'}
 for c in (clients) {
@@ -139,3 +140,73 @@ for c in (clients) {
 ## STDOUT:
 email
 ## END
+
+
+#### var in both branches of if (Julian)
+
+# remove static check?
+
+proc scopetest(; var) {
+  if (var === 2) {
+    var tmp = "hello"
+    write $tmp
+  } else {
+    var tmp = "world"
+    write $tmp
+  }
+}
+
+scopetest (1)
+scopetest (2)
+
+## STDOUT:
+## END
+
+#### var in branches of case (Aidan)
+shopt -s ysh:all
+
+# at top level, there is no static check
+case (1) {
+  (1) { var name = "one" }
+  (2) { var name = "two" }
+}
+echo name=$name
+
+proc my-proc {
+  case (1) {
+    (1) { var name = "one" }
+    (2) { var name = "two" }
+  }
+}
+
+## STDOUT:
+## END
+
+#### Modify for loop variable with var or setvar? (Machine Stops)
+
+proc do-var {
+  for x in a b {
+    echo $x
+    var x = 'zz'
+    echo $x
+  }
+}
+
+proc do-setvar {
+  for x in a b {
+    echo $x
+    setvar x = 'zz'
+    echo $x
+  }
+}
+
+do-var
+echo
+do-setvar
+
+## STDOUT:
+a
+zz
+b
+zz
+## END