Various fixes:

dibyendumajumdar · dibyendumajumdar · commit febdbb4c87a3 · 2025-04-06T14:40:37.000+01:00
1. We do need lexical scopes - so the idea that we could just create unique names for all vars doesn't work because then it means that all vars are available in scopes where they are not supposed to be, leading to creation of phi's that reference undefined vars.

2. The type conversion from EeZee to SON Types had many bugs.

3. The definition of ARY in TypeStruct meant that int[] ended up with incorrect aliases.

Additional fixes.
diff --git a/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/Compiler.java b/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/Compiler.java
@@ -90,7 +90,12 @@ public TypeDictionary createAST(String src) {
 
 
     private void populateDefaultTypes(Map<String,SONType> types) {
+        // Pre-create int, [int] and *[int] types
         types.put(typeDictionary.INT.name(), SONTypeInteger.BOT);
+        var intArrayType = SONTypeStruct.makeAry(SONTypeInteger.U32, _code.getALIAS(), SONTypeInteger.BOT, _code.getALIAS());
+        var ptrIntArrayType = SONTypeMemPtr.make(intArrayType);
+        types.put("[" + typeDictionary.INT.name() + "]", ptrIntArrayType);
+        // Also get the types created by default
         for (SONType t: SONType.gather()) {
             types.put(t.str(), t);
         }
@@ -145,26 +150,31 @@ private void createSONStructType(Map<String, SONType> structTypes, String typeNa
             Type type = typeStruct.getField(name); // FIXME
             fs.push(new Field(name,getSONType(structTypes,type),_code.getALIAS(),false));
         }
+        // A Struct type may have been created before because of
+        // reference from itself; in which case we need to update that
         SONType fref = structTypes.get(typeName);
         if (fref != null) {
-            if (fref instanceof SONTypeStruct ts) {
+            if (fref instanceof SONTypeMemPtr ptr &&
+                ptr._obj instanceof SONTypeStruct ts) {
+                assert ts._fields.length == 0;
+                // Add the fields to the existing type
                 ts._fields = fs.asAry();
             }
-            else throw new CompilerException("");
+            else throw new CompilerException("Expected struct type " + typeName + " but got " + fref);
         }
         else {
-            structTypes.put(typeName, new SONTypeStruct(typeName, fs.asAry()));
+            var ts = SONTypeStruct.make(typeName, fs.asAry());
+            var ptr = SONTypeMemPtr.make((byte)2,ts);
+            structTypes.put(typeName,ptr);
         }
-//        SONTypeStruct ts = SONTypeStruct.make(typeName, fs.asAry());
-//        TYPES.put(typeName, SONTypeMemPtr.make(ts));
     }
 
     private String getSONTypeName(Type type) {
         if (type instanceof Type.TypeFunction typeFunction) {
             return typeFunction.name;
         }
         else if (type instanceof Type.TypeArray typeArray) {
-            return typeArray.name();
+            return "*[" + getSONTypeName(typeArray.getElementType()) + "]";
         }
         else if (type instanceof Type.TypeStruct typeStruct) {
             return "*" + typeStruct.name;
@@ -183,36 +193,25 @@ else if (type instanceof Type.TypeNullable typeNullable) {
     }
 
     private SONType getSONType(Map<String, SONType> structTypes, Type type) {
-        String tname = getSONTypeName(type);
-        SONType t = structTypes.get(tname);
+        SONType t = structTypes.get(type.name());
         if (t != null) return t;
         if (type instanceof Type.TypeStruct) {
-            SONType existing = structTypes.get(type.name);
-            SONTypeStruct ts;
-            if (existing instanceof SONTypeStruct tsExisting)
-                ts = tsExisting;
-            else {
-                ts = new SONTypeStruct(type.name, new Field[0]);
-                structTypes.put(ts.str(), ts);
-            }
-            SONTypeMemPtr ptr = new SONTypeMemPtr((byte)2,ts);
-            if (type.name().equals(ts.str())) {
-                structTypes.put(ptr.str(), ptr);
-                return ptr;
-            }
-            else throw new CompilerException("Unexpected error");
+            // For struct types in EeZee language a reference
+            // to T means *T in SoN
+            // Create SON struct type
+            SONTypeStruct ts = SONTypeStruct.make(type.name, new Field[0]);
+            // Now create *T
+            SONTypeMemPtr ptr = SONTypeMemPtr.make((byte)2,ts);
+            // EeZee T maps to SoN *T
+            structTypes.put(type.name(), ptr);
+            return ptr;
         }
         else if (type instanceof Type.TypeArray typeArray) {
+            // A reference to array in EeZee means
+            // *array in SoN
             SONType elementType = getSONType(structTypes,typeArray.getElementType());
-            SONTypeStruct ts = null;
-            SONType existing = structTypes.get(typeArray.name());
-            if (existing instanceof SONTypeStruct tsExisting)
-                ts = tsExisting;
-            else {
-                ts = SONTypeStruct.makeArray(SONTypeInteger.U32, _code.getALIAS(), elementType, _code.getALIAS());
-                structTypes.put(ts.str(), ts);
-            }
-            SONTypeMemPtr ptr = new SONTypeMemPtr((byte)2,ts);
+            SONTypeStruct ts = SONTypeStruct.makeArray(SONTypeInteger.U32, _code.getALIAS(), elementType, _code.getALIAS());
+            SONTypeMemPtr ptr = SONTypeMemPtr.make((byte)2,ts);
             structTypes.put(typeArray.name(), ptr); // Array type name is not same as ptr str()
             return ptr;
         }
@@ -223,11 +222,11 @@ else if (type instanceof Type.TypeNullable typeNullable) {
                 if (ptr1.nullable())
                     ptr = ptr1;
                 else
-                    ptr = new SONTypeMemPtr((byte)3,ptr1._obj);
+                    ptr = SONTypeMemPtr.make((byte)3,ptr1._obj);
             }
             else
-                ptr = new SONTypeMemPtr((byte)2,(SONTypeStruct) baseType);
-            structTypes.put(ptr.str(), ptr);
+                ptr = SONTypeMemPtr.make((byte)2,(SONTypeStruct) baseType);
+            structTypes.put(typeNullable.name(), ptr);
             return ptr;
         }
         else if (type instanceof Type.TypeVoid) {
@@ -241,13 +240,13 @@ else if (type instanceof Type.TypeVoid) {
 
     // TODO because first two slots are MEM and RPC
     private int REGNUM = 2;
-    private void setVarIds(Scope scope, ScopeNode scopeNode, FunNode fun) {
+    private void defineScopedVars(Scope scope, ScopeNode scopeNode, FunNode fun) {
         for (Symbol symbol: scope.getLocalSymbols()) {
             if (symbol instanceof Symbol.VarSymbol varSymbol) {
                 varSymbol.regNumber = REGNUM++;
-                String sonTypeName = getSONTypeName(varSymbol.type);
-                SONType sonType = TYPES.get(sonTypeName);
-                if (sonType == null) throw new CompilerException("Unknown SON Type "+sonTypeName);
+                SONType sonType = TYPES.get(varSymbol.type.name());
+                if (sonType == null)
+                    throw new CompilerException("Unknown SON Type "+varSymbol.type.name());
                 Node init = null;
 
                 if (varSymbol instanceof Symbol.ParameterSymbol) {
@@ -256,9 +255,6 @@ private void setVarIds(Scope scope, ScopeNode scopeNode, FunNode fun) {
                 scopeNode.define(makeVarName(varSymbol), sonType, false, init);
             }
         }
-        for (Scope childScope: scope.children) {
-            setVarIds(childScope, scopeNode, fun);
-        }
     }
 
     private void generateFunction(Symbol.FunctionTypeSymbol functionTypeSymbol) {
@@ -338,7 +334,8 @@ private ReturnNode generateFunctionBody(Symbol.FunctionTypeSymbol functionTypeSy
         _scope.mem(mem);
         // All args, "as-if" called externally
         AST.FuncDecl funcDecl = (AST.FuncDecl) functionTypeSymbol.functionDecl;
-        setVarIds(funcDecl.scope,_scope,fun);
+        REGNUM = 2;
+        defineScopedVars(funcDecl.scope,_scope,fun);
 
         // Parse the body
         Node last = compileStatement(funcDecl.block);
@@ -556,12 +553,12 @@ private Node newStruct( SONTypeStruct obj, Node size) {
     private Node compileNewExpr(AST.NewExpr newExpr) {
         Type type = newExpr.type;
         if (type instanceof Type.TypeArray typeArray) {
-            SONTypeMemPtr tarray = (SONTypeMemPtr) TYPES.get(getSONTypeName(typeArray));
+            SONTypeMemPtr tarray = (SONTypeMemPtr) TYPES.get(typeArray.name());
             return newArray(tarray._obj,ZERO);
         }
         else if (type instanceof Type.TypeStruct typeStruct) {
-            SONTypeStruct tstruct = (SONTypeStruct) TYPES.get(typeStruct.name());
-            return newStruct(tstruct,con(tstruct.offset(tstruct._fields.length)));
+            SONTypeMemPtr tptr = (SONTypeMemPtr) TYPES.get(typeStruct.name());
+            return newStruct(tptr._obj,con(tptr._obj.offset(tptr._obj._fields.length)));
         }
         else
             throw new CompilerException("Unexpected type: " + type);
@@ -701,7 +698,7 @@ private Node compileCallExpr(AST.CallExpr callExpr) {
     }
 
     private String makeVarName(Symbol.VarSymbol varSymbol) {
-        return varSymbol.name + "$" + varSymbol.regNumber;
+        return varSymbol.name; // + "$" + varSymbol.regNumber;
     }
 
     private Node compileStatement(AST.Stmt statement) {
@@ -955,9 +952,12 @@ private Node compileReturn(AST.ReturnStmt returnStmt) {
 
     private Node compileBlock(AST.BlockStmt block) {
         Node last = ZERO;
+        _scope.push(ScopeNode.Kind.Block);
+        defineScopedVars(block.scope, _scope, _fun);
         for (AST.Stmt stmt: block.stmtList) {
             last = compileStatement(stmt);
         }
+        _scope.pop();
         return last;
     }
 
diff --git a/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/sontypes/SONTypeFunPtr.java b/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/sontypes/SONTypeFunPtr.java
@@ -41,10 +41,10 @@ public SONTypeFunPtr(byte nil, SONTypeTuple sig, SONType ret, long fidxs) {
     public SONTypeFunPtr makeFrom(int fidx ) { return make((byte)2, _sig,_ret,1L<<fidx ); }
 
     public static SONTypeFunPtr BOT   = make((byte)3, SONTypeTuple.BOT, SONType.BOTTOM,-1);
-    public static SONTypeFunPtr TEST  = make((byte)2, SONTypeTuple.TEST, SONTypeInteger.BOT,1);
-    public static SONTypeFunPtr TEST0 = make((byte)3, SONTypeTuple.TEST, SONTypeInteger.BOT,3);
+//    public static SONTypeFunPtr TEST  = make((byte)2, SONTypeTuple.TEST, SONTypeInteger.BOT,1);
+//    public static SONTypeFunPtr TEST0 = make((byte)3, SONTypeTuple.TEST, SONTypeInteger.BOT,3);
     public static SONTypeFunPtr MAIN  = make((byte)3, SONTypeTuple.MAIN, SONTypeInteger.BOT,-1);
-    public static void gather(ArrayList<SONType> ts) { ts.add(TEST); ts.add(TEST0); ts.add(BOT); ts.add(MAIN); }
+    public static void gather(ArrayList<SONType> ts) { /* ts.add(TEST); ts.add(TEST0); */ ts.add(BOT); ts.add(MAIN); }
 
     @Override
     SONType xmeet(SONType t) {
diff --git a/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/sontypes/SONTypeMemPtr.java b/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/sontypes/SONTypeMemPtr.java
@@ -31,7 +31,7 @@ public SONTypeMemPtr(byte nil, SONTypeStruct obj) {
         assert obj!=null;
         _obj = obj;
     }
-    static SONTypeMemPtr make(byte nil, SONTypeStruct obj) { return new SONTypeMemPtr(nil, obj).intern(); }
+    public static SONTypeMemPtr make(byte nil, SONTypeStruct obj) { return new SONTypeMemPtr(nil, obj).intern(); }
     public static SONTypeMemPtr makeNullable(SONTypeStruct obj) { return make((byte)3, obj); }
     public static SONTypeMemPtr make(SONTypeStruct obj) { return new SONTypeMemPtr((byte)2, obj).intern(); }
     public SONTypeMemPtr makeFrom(SONTypeStruct obj) { return obj==_obj ? this : make(_nil, obj); }
@@ -47,8 +47,8 @@ public SONTypeMemPtr(byte nil, SONTypeStruct obj) {
     public static SONTypeMemPtr TOP = BOT.dual();
     public static SONTypeMemPtr NOTBOT = make((byte)2, SONTypeStruct.BOT);
 
-    public static SONTypeMemPtr TEST= make((byte)2, SONTypeStruct.TEST);
-    public static void gather(ArrayList<SONType> ts) { ts.add(NOTBOT); ts.add(BOT); ts.add(TEST); }
+    //public static SONTypeMemPtr TEST= make((byte)2, SONTypeStruct.TEST);
+    public static void gather(ArrayList<SONType> ts) { ts.add(NOTBOT); ts.add(BOT); /* ts.add(TEST); */ }
 
     @Override
     public SONTypeNil xmeet(SONType t) {
diff --git a/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/sontypes/SONTypeStruct.java b/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/sontypes/SONTypeStruct.java
@@ -35,7 +35,7 @@ public SONTypeStruct(String name, Field[] fields) {
     public static SONTypeStruct make(String name, Field... fields) { return new SONTypeStruct(name, fields).intern(); }
     public static final SONTypeStruct TOP = make("$TOP",new Field[0]);
     public static final SONTypeStruct BOT = make("$BOT",new Field[0]);
-    public static final SONTypeStruct TEST = make("test",new Field[]{Field.TEST});
+    //public static final SONTypeStruct TEST = make("test",new Field[]{Field.TEST});
     // Forward-ref version
     public static SONTypeStruct makeFRef(String name) { return make(name, (Field[])null); }
     // Make a read-only version
@@ -66,14 +66,14 @@ public static SONTypeStruct makeArray(SONTypeInteger len, int lenAlias, SONType
     }
 
     // A pair of self-cyclic types
-    private static final SONTypeStruct S1F = makeFRef("S1");
-    private static final SONTypeStruct S2F = makeFRef("S2");
-    public  static final SONTypeStruct S1  = make("S1", Field.make("a", SONTypeInteger.BOT, -1, false), Field.make("s2", SONTypeMemPtr.make((byte)2,S2F),-2, false) );
-    private static final SONTypeStruct S2  = make("S2", Field.make("b", SONTypeFloat.F64, -3, false), Field.make("s1", SONTypeMemPtr.make((byte)2,S1F),-4, false) );
+//    private static final SONTypeStruct S1F = makeFRef("S1");
+//    private static final SONTypeStruct S2F = makeFRef("S2");
+//    public  static final SONTypeStruct S1  = make("S1", Field.make("a", SONTypeInteger.BOT, -1, false), Field.make("s2", SONTypeMemPtr.make((byte)2,S2F),-2, false) );
+//    private static final SONTypeStruct S2  = make("S2", Field.make("b", SONTypeFloat.F64, -3, false), Field.make("s1", SONTypeMemPtr.make((byte)2,S1F),-4, false) );
+//
+//    private static final SONTypeStruct ARY = makeAry(SONTypeInteger.U32,-1, SONTypeInteger.BOT,-2);
 
-    private static final SONTypeStruct ARY = makeAry(SONTypeInteger.U32,-1, SONTypeInteger.BOT,-2);
-
-    public static void gather(ArrayList<SONType> ts) { ts.add(TEST); ts.add(BOT); ts.add(S1); ts.add(S2); ts.add(ARY); }
+    public static void gather(ArrayList<SONType> ts) { /* ts.add(TEST); ts.add(BOT); ts.add(S1); ts.add(S2); ts.add(ARY); */ }
 
     // Find field index by name
     public int find(String fname) {
diff --git a/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/sontypes/SONTypeTuple.java b/seaofnodes/src/main/java/com/compilerprogramming/ezlang/compiler/sontypes/SONTypeTuple.java
@@ -13,7 +13,7 @@ public class SONTypeTuple extends SONType {
     public static final SONTypeTuple BOT = new SONTypeTuple(new SONType[0]).intern();
     public static final SONTypeTuple TOP = new SONTypeTuple(null).intern();
 
-    public static final SONTypeTuple TEST = make(SONTypeInteger.BOT, SONTypeMemPtr.TEST);
+    //public static final SONTypeTuple TEST = make(SONTypeInteger.BOT, SONTypeMemPtr.TEST);
     public static final SONTypeTuple START= make(SONType.CONTROL, SONTypeMem.TOP, SONTypeInteger.BOT);
     public static final SONTypeTuple MAIN = make(SONTypeInteger.BOT);
     public static final SONTypeTuple RET  = make(SONType.CONTROL, SONTypeMem.BOT, SONType.BOTTOM);
@@ -23,7 +23,7 @@ public class SONTypeTuple extends SONType {
     public static final SONTypeTuple IF_TRUE    = make(new SONType[]{SONType. CONTROL, SONType.XCONTROL});
     public static final SONTypeTuple IF_FALSE   = make(new SONType[]{SONType.XCONTROL, SONType. CONTROL});
 
-    public  static void gather(ArrayList<SONType> ts) { ts.add(BOT); ts.add(TEST); ts.add(START); ts.add(MAIN); ts.add(IF_TRUE); }
+    public  static void gather(ArrayList<SONType> ts) { ts.add(BOT); /* ts.add(TEST); */ ts.add(START); ts.add(MAIN); ts.add(IF_TRUE); }
 
     @Override
     SONType xmeet(SONType other) {
diff --git a/seaofnodes/src/test/cases/fib/fib.ez b/seaofnodes/src/test/cases/fib/fib.ez
@@ -0,0 +1,18 @@
+func fib(n: Int)->Int {
+    var i: Int;
+    var temp=0;
+    var f1=1;
+    var f2=1;
+    i=n;
+    while( i>1 ){
+        temp = f1+f2;
+        f1=f2;
+        f2=temp;
+        i=i-1;
+    }
+    return f2;
+}
+
+func foo()->Int {
+    return fib(10);
+}
diff --git a/seaofnodes/src/test/cases/fib/fib.ir b/seaofnodes/src/test/cases/fib/fib.ir
@@ -0,0 +1,46 @@
+START:                            [[   ]]
+   1 Start   ____ ____ ____       [[     3    4    9   16   18    8    5   46  ]]  [  Ctrl, #TOP, int]
+
+L8:                               [[  START      ]]
+   8 fib     ____    1            [[    10   17   19   20   22  ]]  Ctrl
+  10 $rpc       8    9            [[    14       ]]  $[ALL]
+  17 $mem       8   16            [[    14       ]]  #BOT
+  19 n$2        8   18            [[    25       ]]  int
+  20 #1         8                 [[    37   39   26   41  ]]  1
+
+L46:                              [[  START      ]]
+  46 foo     ____    1            [[    48   55   56   57   59  ]]  Ctrl
+  48 $rpc      46    9            [[    52       ]]  $[ALL]
+  55 $mem      46   16            [[    59       ]]  #BOT
+  57 #10       46                 [[    59       ]]  10
+  56 #{ int    46                 [[    59       ]]  { int -> int #1}
+  59 Call      46   55   57   56  [[    60       ]]  Ctrl
+
+LOOP22:                           [[  L8        L29        ]]
+  22 Loop    ____    8   29       [[    39   25   37   26   28  ]]  Ctrl
+  39 Phi_f2$   22   20   38       [[    37   14   38  ]]  int
+  25 Phi_i$3   22   19   41       [[    26   41  ]]  int
+  37 Phi_f1$   22   20   39       [[    38       ]]  int
+  26 LT        22   20   25       [[    28       ]]  bool
+  28 If        22   26            [[    29   30  ]]  [  Ctrl, Ctrl]
+
+L60:                              [[  L46        ]]
+  60 CallEnd   59                 [[    61   63   64  ]]  [  Ctrl, #BOT, int]
+  63 $mem      60                 [[    52       ]]  #BOT
+  64 #2        60                 [[    52       ]]  int
+
+L30:                              [[  LOOP22     ]]
+  30 False     28                 [[    14       ]]  Ctrl
+  14 Return    30   17   39   10  [[     2       ]]  [  Ctrl, #BOT, int]
+
+L29:                              [[  LOOP22     ]]
+  29 True      28                 [[    38   41   22  ]]  Ctrl
+  41 Sub       29   25   20       [[    25       ]]  int
+  38 Add       29   39   37       [[    39       ]]  int
+
+L61:                              [[  L60        ]]
+  61 $ctrl     60                 [[    52       ]]  Ctrl
+  52 Return    61   63   64   48  [[     2       ]]  [  Ctrl, #BOT, int]
+
+L2:                               [[   ]]
+   2 Stop      14   52            [[             ]]  Bot
diff --git a/seaofnodes/src/test/cases/fib/fib.simple b/seaofnodes/src/test/cases/fib/fib.simple
@@ -0,0 +1,15 @@
+val fib = {int n ->
+    int temp=0;
+    int f1=1;
+    int f2=1;
+    int i=n;
+    while( i>1 ){
+        temp = f1+f2;
+        f1=f2;
+        f2=temp;
+        i=i-1;
+    }
+    return f2;
+};
+
+fib(10);
diff --git a/seaofnodes/src/test/cases/fib/fib.simple_ir b/seaofnodes/src/test/cases/fib/fib.simple_ir
diff --git a/seaofnodes/src/test/cases/hello/hello.ez b/seaofnodes/src/test/cases/hello/hello.ez
diff --git a/seaofnodes/src/test/cases/mergsort/sort.ez b/seaofnodes/src/test/cases/mergsort/sort.ez
diff --git a/seaofnodes/src/test/java/com/compilerprogramming/ezlang/compiler/TestSONTypes.java b/seaofnodes/src/test/java/com/compilerprogramming/ezlang/compiler/TestSONTypes.java
