From b96ff239a9f7b68b758159fa074b77c7e5be0c0d Mon Sep 17 00:00:00 2001
From: "Jurgen J. Vinju" <Jurgen.Vinju@cwi.nl>
Date: Fri, 21 Nov 2025 08:41:38 +0100
Subject: [PATCH 1/2] added default keyword parameters to ICollector to help
 write correct and safe scope and stack pushes and pops. shorthands for manual
 enter/leave, push/pop pairs

---
 src/analysis/typepal/ICollector.rsc | 48 ++++++++++++++++++++++++++++-
 1 file changed, 47 insertions(+), 1 deletion(-)

diff --git a/src/analysis/typepal/ICollector.rsc b/src/analysis/typepal/ICollector.rsc
index d5df681..ecf75ef 100644
--- a/src/analysis/typepal/ICollector.rsc
+++ b/src/analysis/typepal/ICollector.rsc
@@ -77,5 +77,51 @@ data Collector
                          void (value l, value r, FailMessage fm) requireEqual,
                          void (value l, value r, FailMessage fm) requireComparable,
                          void (value l, value r, FailMessage fm) requireSubType,
-                         void (value l, value r, FailMessage fm) requireUnify
+                         void (value l, value r, FailMessage fm) requireUnify,
+
+    /* blocked short-hands for scope stack and info stack management (default kwparams) */
+
+    /* enter/leave */   void (Tree id, void () block) scope = (Tree id, void() block) {
+                            enterScope(id);
+                            try
+                                block();
+                            catch 22: ;
+                            finally
+                                leaveScope(id);
+                        },
+    /* lub ent/leave */ void (Tree id, void () block) lubScope = (Tree id, void() block) {
+                            enterLubScope(id);
+                            try
+                                block();
+                            catch 22: ;
+                            finally
+                                leaveScope(id);
+                        },
+    /* comp lub */      void (list[Tree] ids, void () block) compositeLubScope = (list[Tree] ids, void () block) {
+                            enterCompositeLubScope(ids);
+                            try 
+                                block();
+                            catch 22: ;
+                            finally 
+                                leaveCompositeScope(ids);
+                        },
+    /* comp ent/leave*/ void (list[Tree] ids, void () block) compositeScope = (list[Tree] ids, void () block) {
+                            enterCompositeScope(ids);
+                            try 
+                                block();
+                            catch 22: ;
+                            finally 
+                                leaveCompositeScope(ids);
+                            
+                        },
+    /* push/pop info*/  void (str key, value val, void () block) nestInfo = (str key, value val, void () block) {
+                            push(key, val);
+                            try {
+                                block();
+                            }
+                            catch 22: ;
+                            finally {
+                                pop(key);
+                            }
+                        }
       ); 
\ No newline at end of file

From cb99eeeecb0ab7413a5572f62e5ca77109feba01 Mon Sep 17 00:00:00 2001
From: "Jurgen J. Vinju" <Jurgen.Vinju@cwi.nl>
Date: Fri, 21 Nov 2025 09:11:28 +0100
Subject: [PATCH 2/2] changed pico checker to use a block function for example.
 also reformatted a switch and changed list to tuple syntax for better
 efficiency

---
 src/examples/pico/Checker.rsc | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/src/examples/pico/Checker.rsc b/src/examples/pico/Checker.rsc
index 3c1e926..3765add 100644
--- a/src/examples/pico/Checker.rsc
+++ b/src/examples/pico/Checker.rsc
@@ -27,9 +27,9 @@ str prettyAType(strType()) = "str";
 // ----  Collect definitions, uses and requirements -----------------------
 
 void collect(current: (Program) `begin <Declarations decls> <{Statement  ";"}* body> end`, Collector c){
-    c.enterScope(current);
+    c.scope(current, () {
         collect(decls, body, c);
-    c.leaveScope(current);
+    });
 }
 
 void collect(current: (Declarations) `declare <{Declaration ","}* decls> ;`, Collector c){
@@ -71,15 +71,18 @@ void collect(current: (Statement) `while <Expression cond> do <{Statement ";"}*
 
 void collect(current: (Expression) `<Expression lhs> + <Expression rhs>`, Collector c){
      c.calculate("addition", current, [lhs, rhs], 
-        AType (Solver s) { switch([s.getType(lhs), s.getType(rhs)]){
-                   case [intType(), intType()]: return intType();
-                   case [strType(), strType()]: return strType();
-                   default: {
+        AType (Solver s) { 
+            switch(<s.getType(lhs), s.getType(rhs)>){
+                case <intType(), intType()>: 
+                    return intType();
+                case <strType(), strType()>: 
+                    return strType();
+                default: {
                        s.report(error(current, "Operator `+` cannot be applied to %t and %t", lhs, rhs));
                        return intType();
-                     }
-                   }
-                 });
+            }
+        }
+    });
      collect(lhs, rhs, c);
 }