Fixes for clojure-test-suite

Signed-off-by: James Hamlin <jfhamlin@gmail.com>

Author: jfhamlin

pkg/lang/catch.go

@@ -16,15 +16,33 @@ func CatchMatches(r, expect any) bool {
 		return false
 	}
 
+	expectType := expect.(reflect.Type)
+
 	// if expect is an error type, check if r is an instance of it
 	if rErr, ok := r.(error); ok {
-		if expectTyp, ok := expect.(reflect.Type); ok && expectTyp.Implements(errorType) {
-			expectVal := reflect.New(expectTyp).Elem().Interface().(error)
-			if errors.Is(rErr, expectVal) {
+		if expectType.Implements(errorType) {
+			// if expectType is a pointer type, instantiate a new value of that type
+			// and check if rErr is an instance of it
+			if expectType.Kind() == reflect.Ptr {
+				expectVal := reflect.New(expectType.Elem()).Interface()
+				if errors.As(rErr, expectVal) {
+					return true
+				}
+			}
+			// if expectType is an interface type, check if rErr implements it
+			if expectType.Kind() == reflect.Interface {
+				if reflect.TypeOf(rErr).Implements(expectType) {
+					return true
+				}
+			}
+			// otherwise, create a new value of the expectType and check if
+			// rErr is an instance of it
+			expectVal := reflect.New(expectType).Interface()
+			if errors.As(rErr, expectVal) {
 				return true
 			}
 		}
 	}
 
-	return reflect.TypeOf(r).AssignableTo(expect.(reflect.Type))
+	return reflect.TypeOf(r).AssignableTo(expectType)
 }

pkg/lang/equal.go

@@ -70,6 +70,37 @@ func Equals(a, b any) bool {
 }
 
 func Identical(a, b any) bool {
+	aVal, bVal := reflect.ValueOf(a), reflect.ValueOf(b)
+
+	// check if comparing functions, because == panics on func comparison.
+	if aVal.Kind() == reflect.Func || bVal.Kind() == reflect.Func {
+		if !(aVal.Kind() == reflect.Func && bVal.Kind() == reflect.Func) {
+			return false
+		}
+		return aVal.Pointer() == bVal.Pointer()
+	}
+	// slices
+	if aVal.Kind() == reflect.Slice || bVal.Kind() == reflect.Slice {
+		if !(aVal.Kind() == reflect.Slice && bVal.Kind() == reflect.Slice) {
+			return false
+		}
+		return aVal.Pointer() == bVal.Pointer()
+	}
+	// arrays
+	if aVal.Kind() == reflect.Array || bVal.Kind() == reflect.Array {
+		if !(aVal.Kind() == reflect.Array && bVal.Kind() == reflect.Array) {
+			return false
+		}
+		return aVal.Pointer() == bVal.Pointer()
+	}
+	// maps
+	if aVal.Kind() == reflect.Map || bVal.Kind() == reflect.Map {
+		if !(aVal.Kind() == reflect.Map && bVal.Kind() == reflect.Map) {
+			return false
+		}
+		return aVal.Pointer() == bVal.Pointer()
+	}
+
 	return a == b
 }
 

pkg/lang/slices.go

@@ -7,7 +7,16 @@ import (
 
 func SliceSet(slc any, idx int, val any) {
 	slcVal := reflect.ValueOf(slc)
-	slcVal.Index(idx).Set(reflect.ValueOf(val))
+	valVal := reflect.ValueOf(val)
+	// coerce valVal to the element type of slcVal
+	if valVal.Type() != slcVal.Type().Elem() {
+		if valVal.Type().ConvertibleTo(slcVal.Type().Elem()) {
+			valVal = valVal.Convert(slcVal.Type().Elem())
+		} else {
+			panic(NewIllegalArgumentError(fmt.Sprintf("Cannot convert %T to %s", val, slcVal.Type().Elem().String())))
+		}
+	}
+	slcVal.Index(idx).Set(valVal)
 }
 
 func ToSlice(x any) []any {

pkg/runtime/rtcompat.go

@@ -261,10 +261,39 @@ func (rt *RTMethods) Alength(x any) int {
 	panic(fmt.Errorf("Alength not supported on type: %T", x))
 }
 
+func (rt *RTMethods) Aclone(x any) any {
+	xVal := reflect.ValueOf(x)
+	switch xVal.Kind() {
+	case reflect.Slice:
+		cloned := reflect.MakeSlice(xVal.Type(), xVal.Len(), xVal.Cap())
+		reflect.Copy(cloned, xVal)
+		return cloned.Interface()
+	case reflect.Array:
+		cloned := reflect.New(xVal.Type()).Elem()
+		reflect.Copy(cloned, xVal)
+		return cloned.Interface()
+	}
+	panic(fmt.Errorf("Aclone not supported on type: %T", x))
+}
+
 func (rt *RTMethods) ToArray(coll any) any {
 	return lang.ToSlice(coll)
 }
 
+// ObjectArray creates an array of objects ([]any)
+func (rt *RTMethods) ObjectArray(sizeOrSeq any) any {
+	if lang.IsNumber(sizeOrSeq) {
+		return make([]any, lang.MustAsInt(sizeOrSeq))
+	}
+	s := lang.Seq(sizeOrSeq)
+	size := lang.Count(s)
+	ret := make([]any, size)
+	for i := 0; i < len(ret) && s != nil; i, s = i+1, s.Next() {
+		ret[i] = s.First()
+	}
+	return ret
+}
+
 var (
 	mungeCharMap = map[rune]string{
 		'-':  "_",

pkg/stdlib/clojure/core.glj

@@ -5350,10 +5350,10 @@
 
 (defn object-array
   "Creates an array of objects"
-  {:inline (fn [arg] `(. github.com:glojurelang:glojure:pkg:runtime.RT Object_array ~arg))
+  {:inline (fn [arg] `(. github.com:glojurelang:glojure:pkg:runtime.RT ObjectArray ~arg))
    :inline-arities #{1}
    :added "1.2"}
-  ([size-or-seq] (. github.com:glojurelang:glojure:pkg:runtime.RT Object_array size-or-seq)))
+  ([size-or-seq] (. github.com:glojurelang:glojure:pkg:runtime.RT ObjectArray size-or-seq)))
 
 (defn int-array
   "Creates an array of ints"

pkg/stdlib/clojure/core/loader.go

@@ -774,6 +774,9 @@
    (sexpr-replace 'clojure.lang.RT 'github.com:glojurelang:glojure:pkg:runtime.RT)
    (sexpr-replace '(nextID) '(NextID))
 
+   ;; Replace Object_array with ObjectArray
+   (sexpr-replace 'Object_array 'ObjectArray)
+
    (sexpr-replace '(nth coll index not-found) '(NthDefault coll index not-found))
 
    [(fn select [zloc] (and (z/list? zloc)