chore(go): Release smithy-dafny-standard-library Go module 0.2.2 (#1696)

Co-authored-by: GitHub Actions <[email protected]>

Author: rishav-karanjit

releases/go/smithy-dafny-standard-library/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [releases/go/mpl/v0.2.2] - 2025-08-25
+
+### Maintenance
+
+- _(go)_ Update release script (#1676)
+- _(go)_ Update release script to cd to right directory (#1679)
+- _(go)_ Remove create pull request step in go release workflow (#1681)
+- _(all languages)_ Add new SearchAndReplaceWhole and friends (#1680)
+- _(all languages)_ Add fuzz testing to MPL (#1622)
+- _(all languages)_ Optimize mutation map for O(1) performance in Go (#1687)
+- _(go)_ Add go 1.25 to CI (#1684)
+- _(go)_ Put back content() in mutable maps extern (#1694)
+
 ## [releases/go/mpl/v0.2.1] - 2025-08-05
 
 ### Fixes

releases/go/smithy-dafny-standard-library/DafnyLibraries/externs.go

@@ -8,15 +8,36 @@ import (
 )
 
 // Definition of class MutableMap copied over from
-// https://github.com/dafny-lang/dafny/blob/master/Source/DafnyStandardLibraries/src/Std_Concurrent/Std_Concurrent.go
+// https://github.com/dafny-lang/dafny/blob/99327494b3f8b6e49b00824deb4cc2c25b375b05/Source/DafnyStandardLibraries/src/Std/ConcurrentExterns/Std_Concurrent/Std_Concurrent.go
 type MutableMap struct {
-	mu sync.Mutex
-
-	Internal _dafny.Map
-}
-
-func New_MutableMap_() *MutableMap {
-	return &MutableMap{}
+	// Default implementation - synchronized Dafny map<K, V>,
+	// which is just a list of key-value pairs
+	// with O(n) lookup.
+	mu            sync.Mutex
+	dafnyInternal _dafny.Map
+
+	// Optimized for seq<bytes>
+	// The Dafny byte sequences are converted to Go strings,
+	// which can contain arbitrary bytes,
+	// and are comparable and hence can be used as map keys,
+	// whereas a Go byte array cannot.
+	goInternal sync.Map
+
+	// Switch to control which is active
+	bytesKeys bool
+}
+
+// bytesKeys should be set using ctor but it does not because of Dafny bug
+// https://github.com/dafny-lang/dafny/issues/6333
+// This uses variadic parameters to make it backward compatible while adding the boolean parameter bytesKeys
+func New_MutableMap_(bytesKeys ...bool) *MutableMap {
+	useBytes := false
+	if len(bytesKeys) > 0 {
+		useBytes = bytesKeys[0]
+	}
+	return &MutableMap{
+		bytesKeys: useBytes,
+	}
 }
 
 type CompanionStruct_MutableMap_ struct {
@@ -31,7 +52,10 @@ func (_this *MutableMap) Equals(other *MutableMap) bool {
 // If you use the returned value, and ALSO continue to modify the MutableMap
 // Then things might get weird.
 func (_this *MutableMap) Content() _dafny.Map {
-	return _this.Internal
+	if _this.bytesKeys == true {
+		panic("To maintain compatibility with other runtimes, this method does not work when bytesKeys is true.")
+	}
+	return _this.dafnyInternal
 }
 
 func (_this *MutableMap) EqualsGeneric(x interface{}) bool {
@@ -65,79 +89,157 @@ func (_this *MutableMap) ParentTraits_() []*_dafny.TraitID {
 
 var _ _dafny.TraitOffspring = &MutableMap{}
 
-func (_this *MutableMap) Ctor__() {
+func (_this *MutableMap) Ctor__(bytesKeys bool) {
 	{
+		_this.bytesKeys = bytesKeys
 	}
 }
+
+// Converts a Dafny seq<byte> to a Go string,
+// which can contain artibitrary bytes.
+func dafnyBytesToGoString(b interface{}) string {
+	return string(_dafny.ToByteArray(b.(_dafny.Sequence)))
+}
+
+// Converts a Dafny seq<byte> from a Go string,
+// which can contain artibitrary bytes.
+func dafnyBytesFromGoString(b interface{}) _dafny.Sequence {
+	return _dafny.SeqOfBytes([]byte(b.(string)))
+}
+
 func (_this *MutableMap) Keys() _dafny.Set {
 	{
-		_this.mu.Lock()
-		defer _this.mu.Unlock()
+		if _this.bytesKeys {
+			keys := make([]interface{}, 0)
+
+			_this.goInternal.Range(func(key, value interface{}) bool {
+				keys = append(keys, dafnyBytesFromGoString(key))
+				return true
+			})
+
+			return _dafny.SetOf(keys[:]...)
+		} else {
+			_this.mu.Lock()
+			defer _this.mu.Unlock()
 
-		return _this.Internal.Keys()
+			return _this.dafnyInternal.Keys()
+		}
 	}
 }
 func (_this *MutableMap) HasKey(k interface{}) bool {
 	{
-		_this.mu.Lock()
-		defer _this.mu.Unlock()
+		if _this.bytesKeys {
+			_, ok := _this.goInternal.Load(dafnyBytesToGoString(k))
+			return ok
+		} else {
+			_this.mu.Lock()
+			defer _this.mu.Unlock()
 
-		return _this.Internal.Contains(k)
+			return _this.dafnyInternal.Contains(k)
+		}
 	}
 }
 func (_this *MutableMap) Values() _dafny.Set {
 	{
-		_this.mu.Lock()
-		defer _this.mu.Unlock()
+		if _this.bytesKeys {
+			values := make([]interface{}, 0)
+
+			_this.goInternal.Range(func(key, value interface{}) bool {
+				values = append(values, value)
+				return true
+			})
 
-		return _this.Internal.Values()
+			return _dafny.SetOf(values[:]...)
+		} else {
+			_this.mu.Lock()
+			defer _this.mu.Unlock()
+
+			return _this.dafnyInternal.Values()
+		}
 	}
 }
 func (_this *MutableMap) Items() _dafny.Set {
 	{
-		_this.mu.Lock()
-		defer _this.mu.Unlock()
+		if _this.bytesKeys {
+			items := make([]interface{}, 0)
+
+			_this.goInternal.Range(func(key, value interface{}) bool {
+				items = append(items, _dafny.TupleOf(dafnyBytesFromGoString(key), value))
+				return true
+			})
 
-		return _this.Internal.Items()
+			return _dafny.SetOf(items[:]...)
+		} else {
+			_this.mu.Lock()
+			defer _this.mu.Unlock()
+
+			return _this.dafnyInternal.Items()
+		}
 	}
 }
 func (_this *MutableMap) Get(k interface{}) Std_Wrappers.Option {
 	{
-		_this.mu.Lock()
-		defer _this.mu.Unlock()
-
-		value, ok := _this.Internal.Find(k)
-		if ok {
-			return Std_Wrappers.Companion_Option_.Create_Some_(value)
+		if _this.bytesKeys {
+			value, ok := _this.goInternal.Load(dafnyBytesToGoString(k))
+			if ok {
+				return Std_Wrappers.Companion_Option_.Create_Some_(value)
+			} else {
+				return Std_Wrappers.Companion_Option_.Create_None_()
+			}
 		} else {
-			return Std_Wrappers.Companion_Option_.Create_None_()
+			_this.mu.Lock()
+			defer _this.mu.Unlock()
+
+			value, ok := _this.dafnyInternal.Find(k)
+			if ok {
+				return Std_Wrappers.Companion_Option_.Create_Some_(value)
+			} else {
+				return Std_Wrappers.Companion_Option_.Create_None_()
+			}
 		}
 	}
 }
 func (_this *MutableMap) Put(k interface{}, v interface{}) {
-	{
+	if _this.bytesKeys {
+		_this.goInternal.Store(dafnyBytesToGoString(k), v)
+	} else {
 		_this.mu.Lock()
 		defer _this.mu.Unlock()
 
-		_this.Internal = _this.Internal.UpdateUnsafe(k, v)
+		_this.dafnyInternal = _this.dafnyInternal.UpdateUnsafe(k, v)
 	}
 }
 func (_this *MutableMap) Remove(k interface{}) {
 	{
-		_this.mu.Lock()
-		defer _this.mu.Unlock()
+		if _this.bytesKeys {
+			_this.goInternal.Delete(dafnyBytesToGoString(k))
+		} else {
+			_this.mu.Lock()
+			defer _this.mu.Unlock()
 
-		// This could be special-cased for a single remove to be a bit faster,
-		// but it's still going to be O(n) so likely not worth it.
-		_this.Internal = _this.Internal.Subtract(_dafny.SetOf(k))
+			// This could be special-cased for a single remove to be a bit faster,
+			// but it's still going to be O(n) so likely not worth it.
+			_this.dafnyInternal = _this.dafnyInternal.Subtract(_dafny.SetOf(k))
+		}
 	}
 }
 func (_this *MutableMap) Size() _dafny.Int {
 	{
-		_this.mu.Lock()
-		defer _this.mu.Unlock()
+		if _this.bytesKeys {
+			var c _dafny.Int = _dafny.Zero
+
+			_this.goInternal.Range(func(key, value interface{}) bool {
+				c = c.Plus(_dafny.One)
+				return true
+			})
 
-		return _this.Internal.Cardinality()
+			return c
+		} else {
+			_this.mu.Lock()
+			defer _this.mu.Unlock()
+
+			return _this.dafnyInternal.Cardinality()
+		}
 	}
 }