Several fixes to the Collections API (#57)

Three bugfixes:

- Add missing Map.Updated methods
- Fix a bug in Map.Adjoin and Map.Concat (they're still not ideal, but at least they don't throw an exception)
- Fix a bug that caused MutableMap.op[] to not be recognized

Author: aaron-siegel

desktop-app/nbproject/project.properties

@@ -2,7 +2,7 @@ app.conf=nbproject/cgsuite-app.conf
 app.icon=branding/core/core.jar/org/netbeans/core/startup/frame48.gif
 app.name=CGSuite
 app.title=CGSuite
-app.version=2.2-beta1
+app.version=2.2-beta2
 app.icon.icns=etc/cgsuite.icns
 auxiliary.org-netbeans-modules-apisupport-installer.license-file=release/license.txt
 auxiliary.org-netbeans-modules-apisupport-installer.os-linux=true

lib/core/src/main/resources/org/cgsuite/lang/resources/cgsuite/lang/Map.cgs

@@ -43,6 +43,18 @@ system class Map extends Collection, Function
     */
   external def Reversed;
 
+  /** The `Map` obtained from this `Map` by associating the specified `value` with the specified `key`.
+    * If the specified `key` is already contained in this `Map`, its value will be updated in the new `Map`; otherwise,
+    * the specified key-value pair will be added to the new `Map`.
+    */
+  external def Updated(key, value);
+
+  /** The `Map` obtained from this `Map` by incorporating all entries specified in `newValues`. Entries whose `key` is
+    * already contained in this `Map` will be updated; entries whose `key` is not contained in this map will be added
+    * to the new `Map`.
+    */
+  external def Updated(newValues as Map);
+
   /** All the values of this map, as a [[Set]].
     */
   external def Values;

lib/core/src/main/scala/org/cgsuite/lang/CgscriptClass.scala

@@ -1450,7 +1450,13 @@ class CgscriptClass(
         case 1 => args(0)
         case 2 => (args(0), args(1))
       }
-      fn(if (isStatic) classObject else obj, argsTuple)
+      try {
+        fn(if (isStatic) classObject else obj, argsTuple)
+      } catch {
+        case exc: CgsuiteException => throw exc
+        case exc: Throwable =>
+          throw EvalException(s"An unexpected error occured in a call to `$qualifiedName`.", exc)
+      }
     }
 
   }

lib/core/src/main/scala/org/cgsuite/lang/Ops.scala

@@ -218,7 +218,7 @@ object Ops {
         list(i - 1)
       else
         throw EvalException(s"List index out of bounds: $i")
-    case (map: Map[Any @unchecked, _], key: Any) =>
+    case (map: scala.collection.Map[Any @unchecked, _], key: Any) =>
       map get key match {
         case Some(value) => value
         case None => throw EvalException(s"Key not found: $key")

lib/core/src/main/scala/org/cgsuite/lang/SpecialMethods.scala

@@ -124,6 +124,13 @@ object SpecialMethods {
     "cgsuite.lang.Map.ContainsKey" -> { (map: scala.collection.Map[Any,_], key: Any) =>
       map contains key
     },
+    "cgsuite.lang.Map.Updated" -> { (map: scala.collection.Map[Any,_], arg: Any) =>
+      arg match {
+        case (key, value) => map.toMap.updated(key, value)
+        case entries: Map[_, _] => map.toMap ++ entries
+        case _ => sys.error("this should never happen")
+      }
+    },
     "cgsuite.lang.Set.Intersection" -> { (set: scala.collection.Set[Any], that: scala.collection.Set[Any]) =>
       set intersect that
     },

lib/core/src/main/scala/org/cgsuite/lang/System.scala

@@ -19,7 +19,7 @@ object System extends LazyLogging {
 
   val copyrightYear = "2003-2024"
 
-  val version = "2.2-beta1"
+  val version = "2.2-beta2"
 
   def clearAll(): Unit = {
     UiHarness.uiHarness.clearUiVars()

lib/core/src/main/scala/org/cgsuite/lang/SystemClassRegistry.scala

@@ -35,9 +35,9 @@ private[lang] object SystemClassRegistry {
     "cgsuite.lang.Set" -> classOf[scala.collection.Set[_]],
     "cgsuite.lang.Map" -> classOf[scala.collection.Map[_,_]],
     "cgsuite.lang.MapEntry" -> classOf[(_,_)],
+    "cgsuite.lang.Collection" -> classOf[Iterable[_]],
     "cgsuite.lang.Function" -> classOf[PartialFunction[_, _]],
     "cgsuite.lang.System" -> classOf[System],
-    "cgsuite.lang.Collection" -> classOf[Iterable[_]],
     "cgsuite.lang.InstanceClass" -> classOf[InstanceClass],
 
     "cgsuite.util.Strip" -> classOf[Strip],

lib/core/src/test/scala/org/cgsuite/lang/CgsuiteLangTest.scala

@@ -24,8 +24,18 @@ class CgsuiteLangTest extends CgscriptSpec {
       (s"Set: $call", s"{$seq}.$call", result)
     }
 
+    val mutableLists = collectionScenarios map { case (call, seq, result) =>
+      (s"MutableList: $call", s"x := MutableList(); x.AddAll([$seq]); x.$call", result)
+    }
+
+    val mutableSets = collectionScenarios map { case (call, seq, result) =>
+      (s"MutableSet: $call", s"x := MutableSet(); x.AddAll([$seq]); x.$call", result)
+    }
+
     executeTests(Table(header, lists : _*))
     executeTests(Table(header, sets : _*))
+    executeTests(Table(header, mutableLists : _*))
+    executeTests(Table(header, mutableSets : _*))
 
   }
 
@@ -81,6 +91,9 @@ class CgsuiteLangTest extends CgscriptSpec {
       ("Map: Entries", "{7 => true, 1/2 => ^^*}.Entries", "{1/2 => ^^*,7 => true}"),
       ("Map: Keys", "{7 => true, 1/2 => ^^*}.Keys", "{1/2,7}"),
       ("Map: Reversed", "{7 => true, 1/2 => ^^*}.Reversed", "{^^* => 1/2, true => 7}"),
+      ("Map: Updated 1", "{7 => true, 1/2 => ^^*}.Updated(6, 19)", "{1/2 => ^^*, 6 => 19, 7 => true}"),
+      ("Map: Updated 2", "{7 => true, 1/2 => ^^*}.Updated(7, Left)", "{1/2 => ^^*, 7 => Left}"),
+      ("Map: Updated 3", "{7 => true, 1/2 => ^^*}.Updated({6 => 19, 7 => Left})", "{1/2 => ^^*, 6 => 19, 7 => Left}"),
       ("Map: Values", "{7 => true, 1/2 => ^^*}.Values", "{^^*,true}")
     ))
 

lib/core/src/test/scala/org/cgsuite/lang/CgsuiteUtilTest.scala

@@ -4,6 +4,62 @@ import org.scalatest.prop.TableDrivenPropertyChecks.Table
 
 class CgsuiteUtilTest extends CgscriptSpec {
 
+  "cgsuite.util.MutableList" should "implement methods correctly" in {
+
+    executeTests(Table(
+      header,
+      ("MutableList: Construction (empty)", "MutableList()", "MutableList()"),
+      ("MutableList: Construction (seeded)", "x := MutableList([3,4,5])", "MutableList(3, 4, 5)"),
+      ("MutableList: Lookup", "x[2]", "4"),
+      ("MutableList: Lookup (not in list)", "x[0]", "!!List index out of bounds: 0"),
+      ("MutableList: Add", "x.Add(*); x", "MutableList(3, 4, 5, *)"),
+      ("MutableList: AddAll", "x.AddAll([1/2, 1/4, *2, *3, 1/2, 1/4, *3]); x", "MutableList(3, 4, 5, *, 1/2, 1/4, *2, *3, 1/2, 1/4, *3)"),
+      ("MutableList: Contains", "x.Contains(*3)", "true"),
+      ("MutableList: Remove", "x.Remove(1/2); x", "MutableList(3, 4, 5, *, 1/4, *2, *3, 1/2, 1/4, *3)"),
+      ("MutableList: RemoveAll", "x.RemoveAll([4, *2]); x", "MutableList(3, 5, *, 1/4, *3, 1/2, 1/4, *3)"),
+      ("MutableList: RemoveAll (multi)", "x.RemoveAll([1/4, 1/4]); x", "MutableList(3, 5, *, *3, 1/2, *3)"),
+      ("MutableList: RemoveAt", "x.RemoveAt(2); x", "MutableList(3, *, *3, 1/2, *3)"),
+      ("MutableList: Sort", "x.Sort(); x", "MutableList(1/2, 3, *, *3, *3)"),
+      ("MutableList: SortWith", "x.SortWith((a, b) -> if a < b then -1 elseif a > b then 1 else 0 end)", "MutableList(*, *3, *3, 1/2, 3)"),
+      ("MutableList: Clear", "x.Clear(); x", "MutableList()"),
+
+    ))
+
+  }
+
+  "cgsuite.util.MutableSet" should "implement methods correctly" in {
+
+    executeTests(Table(
+      header,
+      ("MutableSet: Construction (empty)", "MutableSet()", "MutableSet()"),
+      ("MutableSet: Construction (seeded)", "x := MutableSet([3,4,5])", "MutableSet(3, 4, 5)"),
+      ("MutableSet: Add", "x.Add(*); x", "MutableSet(3, 4, 5, *)"),
+      ("MutableSet: AddAll", "x.AddAll([1/2, 1/4, *2, *3, 1/2, 1/4, *3]); x", "MutableSet(1/4, 1/2, 3, 4, 5, *, *2, *3)"),
+      ("MutableSet: Contains", "x.Contains(*3)", "true"),
+      ("MutableSet: Remove", "x.Remove(1/4); x", "MutableSet(1/2, 3, 4, 5, *, *2, *3)"),
+      ("MutableSet: RemoveAll", "x.RemoveAll([3, 5, *2, 5, 19]); x", "MutableSet(1/2, 4, *, *3)"),
+      ("MutableSet: Clear", "x.Clear(); x", "MutableSet()")
+    ))
+
+  }
+  "cgsuite.util.MutableMap" should "implement methods correctly" in {
+
+    executeTests(Table(
+      header,
+      ("MutableMap: Construction (empty)", "MutableMap()", "MutableMap()"),
+      ("MutableMap: Construction (seeded)", "x := MutableMap({3 => true, 5 => Left})", "MutableMap(3 => true, 5 => Left)"),
+      ("MutableMap: Lookup", "x[5]", "Left"),
+      ("MutableMap: Lookup (not in map)", "x[*]", "!!Key not found: *"),
+      ("MutableMap: ContainsKey", "x.ContainsKey(5)", "true"),
+      ("MutableMap: Entries", "x.Entries", "{3 => true,5 => Left}"),
+      ("MutableMap: Put 1", "x.Put(3, false); x", "MutableMap(3 => false, 5 => Left)"),
+      ("MutableMap: Put 2", "x.Put(*, 101); x", "MutableMap(3 => false, 5 => Left, * => 101)"),
+      ("MutableMap: PutAll", "x.PutAll({Right => 1474, 3 => 1/7}); x", "MutableMap(3 => 1/7, 5 => Left, * => 101, Right => 1474)"),
+      ("MutableMap: Clear", "x.Clear(); x", "MutableMap()")
+    ))
+
+  }
+
   "cgsuite.util.Strip" should "implement methods correctly" in {
 
     executeTests(Table(