wip

Author: mccanne

runtime/sam/expr/function/downcast.go

@@ -1,7 +1,7 @@
 package function
 
 import (
-	"runtime/debug"
+	"fmt"
 	"slices"
 
 	"github.com/brimdata/super"
@@ -40,15 +40,15 @@ func (d *downcast) Cast(from super.Value, to super.Type) (super.Value, bool) {
 }
 
 func (d *downcast) downcast(typ super.Type, bytes scode.Bytes, to super.Type) (super.Value, *super.Value) {
-	//fmt.Println("DOWNCAST", sup.String(super.NewValue(typ, bytes)), "TO", sup.String(to))
+	fmt.Println("DOWNCAST", sup.String(super.NewValue(typ, bytes)), "TO", sup.String(to))
 	// XXX typ, bytes = deunion(typ, bytes)
 	if _, ok := to.(*super.TypeUnion); !ok {
 		if fusionType, ok := typ.(*super.TypeFusion); ok {
 			superBytes, subtype := fusionType.Deref(d.sctx, bytes)
 			return d.downcast(fusionType.Type, superBytes, subtype)
 		}
 	}
-	typ, bytes = deunion(typ, bytes)
+	//typ, bytes = deunion(typ, bytes)
 	switch to := to.(type) {
 	case *super.TypeRecord:
 		return d.toRecord(typ, bytes, to)
@@ -210,6 +210,7 @@ func (d *downcast) toError(typ super.Type, bytes scode.Bytes, to *super.TypeErro
 }
 
 func (d *downcast) toNamed(typ super.Type, bytes scode.Bytes, to *super.TypeNamed) (super.Value, *super.Value) {
+	fmt.Println("TO NAMED", sup.String(super.NewValue(typ, bytes)), "TO", sup.String(to))
 	/*
 		fromType, ok := typ.(*super.TypeNamed)
 		if !ok {
@@ -239,59 +240,61 @@ func (d *downcast) toNamed(typ super.Type, bytes scode.Bytes, to *super.TypeName
 		}
 		return super.NewValue(to, val.Bytes()), errVal
 	*/
+	if unionType, ok := typ.(*super.TypeUnion); ok {
+		typ, bytes = deunion(typ, bytes)
+		// If we are casting a union type to a named, we need to look through the
+		// union for the named type in question since type fusion fuses named
+		// types by name.  Then when we find the name, we need to form the subtype
+		// from the union options present. XXX devise a torture test that
+		// reconstruct nested unions from the flattened named union...?
+		for _, t := range unionType.Types {
+			if named, ok := t.(*super.TypeNamed); ok && named.Name == to.Name {
+				val, errVal := d.downcast(typ, bytes, to.Type)
+				if errVal != nil {
+					return super.Value{}, errVal
+				}
+				return super.NewValue(to, val.Bytes()), nil
+			}
+
+		}
+		return super.Value{}, d.errMismatch(typ, bytes, to)
+	}
 	/*
-		if unionType, ok := typ.(*super.TypeUnion); !ok {
-			// If we are casting a union type to a named, we need to look through the
-			// union for the named type in question since type fusion fuses named
-			// types by name.  Then when we find the name, we need to form the subtype
-			// from the union options present. XXX devise a torture test that
-			// reconstruct nested unions from the flattened named union...?
-			for _, t := range unionType.Types {
-				if named, ok := t.(*super.TypeNamed); ok && t.Name == to.Name {
-					val, errVal := d.downcast(named.Type, bytes, to.Type)
+		fromType, ok := typ.(*super.TypeNamed)
+		if !ok {
+			if unionType, ok := typ.(*super.TypeUnion); ok {
+				if unionType.TagOf(to) >= 0 {
+					typ, bytes = deunion(typ, bytes)
+					val, errVal := d.downcast(typ, bytes, to)
 					if errVal != nil {
 						return super.Value{}, errVal
 					}
-					return super.NewValue(to, val.Bytes()), nil
-				}
-				fused := noFusion(f.fuse(existingNamed.Type, noFusion(named.Type)))
-				var err error
-				out[i], err = f.sctx.LookupTypeNamed(named.Name, fused)
-				if err != nil {
-					panic(err)
+					return super.NewValue(to, val.Bytes()), errVal
 				}
-
 			}
-
-		}
-		if !ok {
+			//fmt.Println("MISS", sup.String(typ))
 			return super.Value{}, d.errMismatch(typ, bytes, to)
 		}
 	*/
-	fromType, ok := typ.(*super.TypeNamed)
-	if !ok {
-		if unionType, ok := typ.(*super.TypeUnion); ok {
-			if unionType.TagOf(to) >= 0 {
-				typ, bytes = deunion(typ, bytes)
-				val, errVal := d.downcast(typ, bytes, to)
-				if errVal != nil {
-					return super.Value{}, errVal
-				}
-				return super.NewValue(to, val.Bytes()), errVal
-			}
+	if fromType, ok := typ.(*super.TypeNamed); ok {
+		if fromType.Name != to.Name {
+			return super.Value{}, d.errMismatch(typ, bytes, to)
 		}
-		//fmt.Println("MISS", sup.String(typ))
-		return super.Value{}, d.errMismatch(typ, bytes, to)
+		val, errVal := d.downcast(fromType.Type, bytes, to.Type)
+		if errVal != nil {
+			return super.Value{}, errVal
+		}
+		return super.NewValue(to, val.Bytes()), errVal
 	}
-	val, errVal := d.downcast(fromType.Type, bytes, to.Type)
+	val, errVal := d.downcast(typ, bytes, to.Type)
 	if errVal != nil {
 		return super.Value{}, errVal
 	}
 	return super.NewValue(to, val.Bytes()), errVal
 }
 
 func (d *downcast) errMismatch(typ super.Type, bytes []byte, to super.Type) *super.Value {
-	debug.PrintStack()
+	//debug.PrintStack()
 	return d.sctx.WrapError("downcast: type mismatch to "+sup.FormatType(to), super.NewValue(typ, bytes)).Ptr()
 }