отловил баг в конвертере c пропуском типов

cp/module/module.go

@@ -1,7 +1,6 @@
 package module
 
 import (
-	"fmt"
 	"fw/cp"
 	"fw/cp/constant/enter"
 	"fw/cp/node"
@@ -137,7 +136,7 @@ func (m *Module) Init(inittd ...func(t object.ComplexType)) {
 		return strconv.Itoa(int(id))
 	}
 
-	fmt.Println("init", m.Name)
+	//fmt.Println("init", m.Name)
 	for k, s := range m.Types {
 		q := ""
 		switch e := k.(type) {

rt2/module/ml.go

@@ -60,7 +60,7 @@ func (l *list) Handle(msg interface{}) {}
 
 func (l *list) Load(name string, ldr ...Loader) (ret *mod.Module, err error) {
 	assert.For(name != "", 20)
-	fmt.Println("loading", name, "loaded", l.Loaded(name) != nil)
+	//fmt.Println("loading", name, "loaded", l.Loaded(name) != nil)
 	ret = l.Loaded(name)
 	var loader Loader = func(m *mod.Module) {}
 	if len(ldr) > 0 {
@@ -71,16 +71,18 @@ func (l *list) Load(name string, ldr ...Loader) (ret *mod.Module, err error) {
 		ret = xev.Load(path, name+".oz")
 		ret.Name = name
 		for _, imp := range ret.Imports {
-			fmt.Println(name, "imports", imp.Name, "loaded", l.Loaded(imp.Name) != nil)
-			_, err = l.Load(imp.Name, loader)
+			//fmt.Println(name, "imports", imp.Name, "loaded", l.Loaded(imp.Name) != nil)
+			if l.Loaded(imp.Name) == nil {
+				_, err = l.Load(imp.Name, loader)
+			}
 		}
 		if err == nil {
 			ret.Init(func(t object.ComplexType) {
-				fmt.Println(t.Qualident())
+				//fmt.Println(t.Adr(), t.Qualident())
 			})
 			l.inner[name] = ret
 			loader(ret)
-			fmt.Println("loaded", name)
+			//fmt.Println("loaded", name)
 		}
 	}
 	return ret, err
@@ -227,7 +229,7 @@ func (c *tc) ConnectTo(x interface{}) {
 		halt.As(100, reflect.TypeOf(t))
 	}
 	c.m = ModuleOfType(c.ml.Domain(), c.typ)
-	assert.For(c.m != nil, 60, c.typ.Qualident(), c.typ)
+	assert.For(c.m != nil, 60, c.typ.Qualident(), c.typ.Adr())
 }
 
 func (c *tc) MethodList() (ret map[int][]Method) {

rt2/nodeframe/frame.go

@@ -78,13 +78,15 @@ type nodeFrame struct {
 }
 
 func done(f frame.Frame) {
-	utils.PrintScope("== SCOPE ==")
-	utils.PrintScope(f.Domain().Discover(context.SCOPE))
-	utils.PrintScope("==  HEAP ==")
-	utils.PrintScope(f.Domain().Discover(context.HEAP))
-	utils.PrintScope("== CALL ==")
-	utils.PrintScope(f.Domain().Discover(context.CALL))
-	utils.PrintScope("^^^^^^^^^")
+	utils.Do(func() {
+		utils.PrintScope("== SCOPE ==")
+		utils.PrintScope(f.Domain().Discover(context.SCOPE))
+		utils.PrintScope("==  HEAP ==")
+		utils.PrintScope(f.Domain().Discover(context.HEAP))
+		utils.PrintScope("== CALL ==")
+		utils.PrintScope(f.Domain().Discover(context.CALL))
+		utils.PrintScope("^^^^^^^^^")
+	})
 }
 
 func (f *nodeFrame) Do() frame.WAIT {

utils/debug.go

@@ -33,3 +33,9 @@ func PrintTrap(x ...interface{}) {
 		fmt.Println(x...)
 	}
 }
+
+func Do(do func()) {
+	if debugFrame {
+		do()
+	}
+}

xev/converter.go

@@ -191,17 +191,21 @@ func init() { reset() }
 func (r *Result) doType(n *Node) (ret object.ComplexType) {
 	//fmt.Println("type", n.Id)
 	ret = typeMap[n.Id]
+	var tail func()
 	if ret == nil {
+		tail = nil
 		switch n.Data.Typ.Form {
 		case "BASIC":
 			switch n.Data.Typ.Typ {
 			case "PROCEDURE":
 				t := object.NewBasicType(object.PROCEDURE, n.Id)
-				link := r.findLink(n, "link")
-				if link != nil {
-					t.SetLink(r.doObject(link))
-					assert.For(t.Link() != nil, 40)
-					t.Link().SetRef(t)
+				tail = func() {
+					link := r.findLink(n, "link")
+					if link != nil {
+						t.SetLink(r.doObject(link))
+						assert.For(t.Link() != nil, 40)
+						t.Link().SetRef(t)
+					}
 				}
 				ret = t
 			case "SHORTSTRING":
@@ -217,10 +221,12 @@ func (r *Result) doType(n *Node) (ret object.ComplexType) {
 				"NOTYP":
 			case "POINTER":
 				t := object.NewPointerType(n.Data.Typ.Name, n.Id)
-				base := r.findLink(n, "base")
-				if base != nil {
-					t.Complex(r.doType(base))
-					assert.For(t.Complex() != nil, 41)
+				tail = func() {
+					base := r.findLink(n, "base")
+					if base != nil {
+						t.Complex(r.doType(base))
+						assert.For(t.Complex() != nil, 41)
+					}
 				}
 				ret = t
 			default:
@@ -238,10 +244,12 @@ func (r *Result) doType(n *Node) (ret object.ComplexType) {
 				ret = object.NewDynArrayType(object.REAL, n.Id)
 			case "POINTER":
 				ret = object.NewDynArrayType(object.COMPLEX, n.Id)
-				base := r.findLink(n, "base")
-				if base != nil {
-					ret.(object.DynArrayType).Complex(r.doType(base))
-					assert.For(ret.(object.DynArrayType).Complex() != nil, 41)
+				tail = func() {
+					base := r.findLink(n, "base")
+					if base != nil {
+						ret.(object.DynArrayType).Complex(r.doType(base))
+						assert.For(ret.(object.DynArrayType).Complex() != nil, 41)
+					}
 				}
 			default:
 				panic(fmt.Sprintln("unknown dyn type", n.Id, n.Data.Typ.Base, n.Data.Typ.Typ))
@@ -256,10 +264,12 @@ func (r *Result) doType(n *Node) (ret object.ComplexType) {
 				ret = object.NewArrayType(object.REAL, int64(n.Data.Typ.Par), n.Id)
 			case "COMPLEX":
 				ret = object.NewArrayType(object.COMPLEX, int64(n.Data.Typ.Par), n.Id)
-				base := r.findLink(n, "base")
-				if base != nil {
-					ret.(object.ArrayType).Complex(r.doType(base))
-					assert.For(ret.(object.ArrayType).Complex() != nil, 41)
+				tail = func() {
+					base := r.findLink(n, "base")
+					if base != nil {
+						ret.(object.ArrayType).Complex(r.doType(base))
+						assert.For(ret.(object.ArrayType).Complex() != nil, 41)
+					}
 				}
 			default:
 				panic(fmt.Sprintln("unknown array type", n.Id, n.Data.Typ.Base))
@@ -271,16 +281,18 @@ func (r *Result) doType(n *Node) (ret object.ComplexType) {
 			default:
 				ret = object.NewRecordType(n.Data.Typ.Name, n.Id, n.Data.Typ.Base)
 			}
-			link := r.findLink(n, "link")
-			if link != nil {
-				ret.SetLink(r.doObject(link))
-				assert.For(ret.Link() != nil, 40)
-				ret.Link().SetRef(ret)
-			}
-			base := r.findLink(n, "base")
-			if base != nil {
-				ret.(object.RecordType).Complex(r.doType(base))
-				assert.For(ret.(object.RecordType).BaseRec() != nil, 41)
+			tail = func() {
+				link := r.findLink(n, "link")
+				if link != nil {
+					ret.SetLink(r.doObject(link))
+					assert.For(ret.Link() != nil, 40)
+					ret.Link().SetRef(ret)
+				}
+				base := r.findLink(n, "base")
+				if base != nil {
+					ret.(object.RecordType).Complex(r.doType(base))
+					assert.For(ret.(object.RecordType).BaseRec() != nil, 41)
+				}
 			}
 		default:
 			panic(fmt.Sprintln("unknown form", n.Data.Typ.Form))
@@ -288,6 +300,9 @@ func (r *Result) doType(n *Node) (ret object.ComplexType) {
 	}
 	if ret != nil {
 		typeMap[n.Id] = ret
+		if tail != nil { //функция нужна чтобы выполнить рекурсивный вызов doType после обновления индекса типов typeMap
+			tail()
+		}
 	}
 	return ret
 }