Improving Bean Shell Support in Playground

.github/workflows/cn1playground-language.yml

@@ -0,0 +1,47 @@
+name: CN1 Playground Language Tests
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened, ready_for_review]
+    paths:
+      - 'scripts/cn1playground/**'
+      - '.github/workflows/cn1playground-language.yml'
+  push:
+    branches: [main, master]
+    paths:
+      - 'scripts/cn1playground/**'
+      - '.github/workflows/cn1playground-language.yml'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  language-smoke:
+    name: Playground language smoke
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v4
+
+      - name: Set up Java 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: '17'
+          cache: maven
+
+      - name: Ensure Xvfb is available
+        run: |
+          set -euo pipefail
+          if ! command -v xvfb-run >/dev/null 2>&1; then
+            sudo apt-get update
+            sudo apt-get install -y xvfb
+          fi
+
+      - name: Run playground language smoke tests
+        run: |
+          set -euo pipefail
+          cd scripts/cn1playground
+          xvfb-run -a bash tools/run-playground-smoke-tests.sh

scripts/cn1playground/README.md

@@ -202,70 +202,76 @@ The playground uses a customized version of [BeanShell](https://github.com/beans
 - **Variable capture**: Lambdas capture variables from enclosing scopes
 - **Nested lambdas**: Inner lambdas are rewritten before outer lambdas execute
 
-### Limitations
-
-#### Class Declarations Have Limited Support
-
-BeanShell's class generation is disabled in this playground, but single top-level classes are automatically unwrapped:
-
-```java
-// This works - playground unwraps the class:
-public class DemoApp {
-    private Label status;  // Becomes script variable: status = null;
-
-    public void start() {
-        status = new Label("Ready");
-        // ...
-    }
-}
-```
-
-**What doesn't work**:
-- Nested classes
-- Multiple top-level classes
-- Interfaces or enums
-- Static fields or methods that reference instance fields
-
-For complex state management, consider using loose methods with script-level variables instead of class fields.
-
-#### Instance Field Access in Lambdas
-
-Variables from enclosing scopes work in lambdas, but instance field references without `this` may not resolve correctly:
-
-```java
-// Works:
-String prefix = "Hello ";
-button.addActionListener(e -> status.setText(prefix + "World"));
-
-// May not work as expected if 'status' is an instance field:
-// Use 'this.status' or move the field to script scope
-```
-
-#### Generic Type Parameters Are Erased
-
-Generic type parameters are erased at runtime. Methods that rely on specific generic types may require casting:
+### Class, Interface, Enum, and Record Support
+
+The playground includes a CN1-safe scripted-class runtime so user-declared
+types work without runtime bytecode generation or reflection. The
+`PlaygroundSyntaxMatrixHarness` (in `common/src/test/java/...`) is a
+table-driven matrix that pins exactly what is supported — every entry
+either reaches `SUCCESS` or documents a known gap with its diagnostic.
+
+What works:
+
+- **Classes** with fields, constructors (overloaded), methods (overloaded),
+  generic type parameters (`class Pair<T>`), inheritance with method
+  overrides, and `super.method()` / `super(args)` dispatch.
+- **Static nested classes** (`Outer.Inner`) with `Outer.Inner.staticField` /
+  `new Outer.Inner()` access.
+- **Interfaces** with static methods, default methods, and anonymous
+  implementations (`new Greeter() { public String greet() { ... } }`).
+- **Enums** with simple constants, constants taking constructor args,
+  per-constant method bodies, and built-in `name()` / `ordinal()` /
+  `values()` / `valueOf()`.
+- **Records** (`record Point(int x, int y) {}`) with auto-generated
+  accessors and an optional body block.
+- **Sealed / non-sealed / permits** modifiers parse cleanly (the permit
+  list is not enforced at runtime — best-effort syntactic support).
+
+What still doesn't work:
+
+- Non-static inner classes that need an enclosing-instance reference.
+- Reflection APIs (`java.lang.reflect.*`, `Class.forName`) — forbidden in
+  CN1 and out of scope.
+- Streams via `Collection.stream()` — CN1's `java.util.Collection` backport
+  doesn't expose `stream()`.
+
+### Lambdas and Method References
+
+- Lambdas in any context: assignment (`Runnable r = () -> {};`), return
+  expressions, method-call arguments, and as fields.
+- Lambdas implement common SAM types directly: `Runnable`, `Supplier`,
+  `Consumer`, `BiConsumer`, `Function`, `Predicate`, `Comparator`. Other
+  CN1-specific listener interfaces are wrapped via `PlaygroundListenerBridge`.
+- Method references for static (`System.out::println`), bound-instance
+  (`prefix::concat`), unbound-instance (`String::length` →
+  `(s) -> s.length()`), and constructor (`ArrayList::new`) forms.
+
+### Switch and Pattern Matching
+
+- Classic switch statements (int, String, fall-through with explicit break).
+- Switch expression arrow form: `String s = switch (x) { case 1 -> "one"; default -> "?"; };`.
+- Switch expression yield form: `case 1: yield "one"; default: yield "?";`.
+- Arrow-form switch statements (no result value).
+- Pattern matching for instanceof: `if (o instanceof String s) { use(s); }`.
+
+### Try-with-resources, Multi-catch, var
+
+- `try (Reader r = ...)` with single, multiple, and trailing-semicolon
+  resource lists.
+- Multi-catch `catch (E1 | E2 e)`.
+- Local variable type inference with `var` (BSH already treats `var` as a
+  loose type).
+
+### Generic Type Parameters Are Erased
+
+Generic type parameters are not enforced at runtime. Methods that rely on
+specific generic types may require casting:
 
 ```java
 // Generic types are erased, so explicit casting may be needed:
 List<String> items = (List<String>) someMethod();
 ```
 
-#### Some Java Syntax Is Unsupported
-
-- **Enhanced for-each with arrays**: BeanShell's for-each works for `Collection` types but not for arrays when using the generated access registry. Use traditional `for (int i = 0; i < arr.length; i++)` loops for arrays, or convert to a List first:
-  ```java
-  // Doesn't work with arrays:
-  String[] arr = {"a", "b", "c"};
-  for (String s : arr) { }  // May fail
-
-  // Workaround:
-  for (int i = 0; i < arr.length; i++) { String s = arr[i]; }
-  // Or convert to List:
-  for (String s : java.util.Arrays.asList(arr)) { }
-  ```
-- **Method references**: `Object::toString` syntax is not supported; use lambdas instead
-- **Try-with-resources**: Use try/finally blocks manually
-
 ## JavaScript Port Considerations
 
 ### `BrowserComponent` and Dialogs
@@ -347,9 +353,37 @@ mvn clean install
 
 ```bash
 cd scripts/cn1playground
-./scripts/run-tests.sh
+bash tools/run-playground-smoke-tests.sh
 ```
 
+This smoke command currently runs:
+
+1. CN1 access registry generation (`tools/generate-cn1-access-registry.sh`).
+2. Registry sanity checks (expected/forbidden class entries).
+3. `PlaygroundSmokeHarness` end-to-end behavior checks.
+4. `PlaygroundSyntaxMatrixHarness` syntax regression checks.
+
+## Language Feature Rollout Process
+
+Use this process when adding or fixing Java syntax support in Playground:
+
+1. **Add/adjust matrix coverage first**  
+   Update `common/src/test/java/com/codenameone/playground/PlaygroundSyntaxMatrixHarness.java` with a focused snippet for the target syntax.
+   - For currently unsupported syntax, add as `ExpectedOutcome.FAILURE`.
+   - When support lands, flip that case to `ExpectedOutcome.SUCCESS`.
+
+2. **Implement parser/runtime change in small steps**  
+   Prefer one syntax feature per PR (e.g. method references only) to keep regressions easy to isolate.
+
+3. **Run smoke + syntax matrix locally**  
+   Run `bash tools/run-playground-smoke-tests.sh` from `scripts/cn1playground`.
+
+4. **Require CI green before merge**  
+   The `CN1 Playground Language Tests` workflow runs the same smoke command under CI (`xvfb-run`) and should pass before merging syntax updates.
+
+5. **Document behavior changes**  
+   Update this README's known issues/limitations when syntax support changes so users know what is now supported.
+
 ## Known Issues
 
 1. **Parse errors with complex expressions**: BeanShell's parser may fail on some Java syntax. Simplify complex expressions or break them into multiple statements.
@@ -360,4 +394,4 @@ cd scripts/cn1playground
 
 ## Contributing
 
-See the main Codename One repository for contribution guidelines.
+See the main Codename One repository for contribution guidelines.

scripts/cn1playground/common/src/main/java/bsh/BSHAllocationExpression.java

@@ -77,7 +77,31 @@ private Object objectAllocation(
         if ( args == null)
             throw new EvalError( "Null args in new.", this, callstack );
 
-        // Lookup class
+        // Lookup class. Try a regular variable lookup first so that names
+        // bound to a ScriptedClass (declared earlier in the same script)
+        // resolve before we force a Java class lookup.
+        Object scripted = lookupScriptedClass(nameNode.text, callstack);
+        if (scripted != null) {
+            ScriptedClass sc = (ScriptedClass) scripted;
+            // Anonymous-class style: `new Iface() { method bodies }` —
+            // synthesise a one-off subclass whose instance methods come from
+            // the body, then construct it. Works for both interfaces and
+            // regular classes.
+            boolean hasBody = jjtGetNumChildren() > 2;
+            if (hasBody) {
+                BSHBlock body = (BSHBlock) jjtGetChild(2);
+                ScriptedClass anonClass = ScriptedClass.build(
+                        sc.getName() + "$anon", callstack.top(), body, sc,
+                        callstack, interpreter);
+                return anonClass.newInstance(args, callstack, interpreter);
+            }
+            if (sc.isInterface()) {
+                throw new EvalError("Cannot instantiate scripted interface "
+                        + sc.getName() + " directly; use a class that implements it.",
+                        this, callstack);
+            }
+            return sc.newInstance(args, callstack, interpreter);
+        }
         Object obj = nameNode.toObject(
             callstack, interpreter, true /*force class*/ );
 
@@ -112,6 +136,49 @@ private Object objectAllocation(
             return constructObject( type, args, callstack, interpreter );
     }
 
+    private static Object lookupScriptedClass(String rawName, CallStack callstack) {
+        if (rawName == null || rawName.length() == 0) return null;
+        if (callstack == null) return null;
+        // Strip a generic suffix like "Pair<String>" — type arguments are
+        // erased at runtime in our scripted-class model.
+        String simpleName = rawName;
+        int lt = simpleName.indexOf('<');
+        if (lt >= 0) simpleName = simpleName.substring(0, lt);
+        // Dotted names like "Outer.Inner": resolve the head as a
+        // ScriptedClass and walk through nested classes via the static
+        // namespace of each enclosing class. We split manually because
+        // String.split(regex) is not available on CN1's restricted String.
+        java.util.List<String> partsList = new java.util.ArrayList<String>();
+        int from = 0;
+        for (int j = 0; j < simpleName.length(); j++) {
+            if (simpleName.charAt(j) == '.') {
+                partsList.add(simpleName.substring(from, j));
+                from = j + 1;
+            }
+        }
+        partsList.add(simpleName.substring(from));
+        String[] parts = partsList.toArray(new String[partsList.size()]);
+        if (parts.length == 0) return null;
+        ScriptedClass current;
+        try {
+            Object v = callstack.top().getVariable(parts[0]);
+            if (!(v instanceof ScriptedClass)) return null;
+            current = (ScriptedClass) v;
+        } catch (UtilEvalError ex) {
+            return null;
+        }
+        for (int i = 1; i < parts.length; i++) {
+            try {
+                Object next = current.getStaticNameSpace().getVariable(parts[i]);
+                if (!(next instanceof ScriptedClass)) return null;
+                current = (ScriptedClass) next;
+            } catch (UtilEvalError ex) {
+                return null;
+            }
+        }
+        return current;
+    }
+
     Object constructFromEnclosingInstance(Object obj, CallStack callstack,
             Interpreter interpreter ) throws EvalError {
         throw new EvalError(

scripts/cn1playground/common/src/main/java/bsh/BSHAutoCloseable.java

@@ -31,9 +31,12 @@ public Object eval(CallStack callstack, Interpreter interpreter)
         renderTypeNode();
         this.type = evalType(callstack, interpreter);
 
-        if (!AutoCloseable.class.isAssignableFrom(this.getType()))
+        // `var` and untyped resources resolve to null; defer the
+        // AutoCloseable check to runtime after the initializer has run.
+        if (this.type != null && !AutoCloseable.class.isAssignableFrom(this.type)) {
             throw new EvalException("The resource type "+ this.type.getName()
                 +" does not implement java.lang.AutoCloseable.", this, callstack);
+        }
 
         this.name = this.getDeclarators()[0].name;
 
@@ -48,6 +51,22 @@ public Object eval(CallStack callstack, Interpreter interpreter)
                 this, callstack);
         }
 
+        // Verify the bound value is actually AutoCloseable when the type was
+        // inferred (var) rather than declared.
+        if (this.type == null && this.varThis != null) {
+            try {
+                Object value = this.varThis.getValue();
+                if (value != null && !(value instanceof AutoCloseable)) {
+                    throw new EvalException("The resource value "
+                            + value.getClass().getName()
+                            + " does not implement java.lang.AutoCloseable.",
+                            this, callstack);
+                }
+            } catch (UtilEvalError e) {
+                throw e.toEvalError(this, callstack);
+            }
+        }
+
         return Primitive.VOID;
     }
 

scripts/cn1playground/common/src/main/java/bsh/BSHBinaryExpression.java

@@ -34,6 +34,11 @@
 */
 class BSHBinaryExpression extends SimpleNode implements ParserConstants {
     public int kind;
+    /** For pattern-matching `instanceof Type binding`, the binding identifier
+     * captured at parse time. When non-null, a positive instanceof test binds
+     * the lhs value to this name in the current namespace before returning
+     * true. */
+    public String instanceofBinding;
 
     BSHBinaryExpression(int id) { super(id); }
 
@@ -68,8 +73,15 @@ public Object eval( CallStack callstack, Interpreter interpreter)
                     lhs = Primitive.unwrap(lhs);
 
             // General case - perform the instanceof based on assignable
-            return Types.isJavaBaseAssignable( rhs, lhs.getClass() )
-                    ? Primitive.TRUE : Primitive.FALSE;
+            boolean matches = Types.isJavaBaseAssignable(rhs, lhs.getClass());
+            if (matches && instanceofBinding != null) {
+                try {
+                    callstack.top().setVariable(instanceofBinding, lhs, false);
+                } catch (UtilEvalError ex) {
+                    throw ex.toEvalError(this, callstack);
+                }
+            }
+            return matches ? Primitive.TRUE : Primitive.FALSE;
         }
 
         /*