Type checking unsigned int and long, and static initializers for them. Chapter 12 type checking complete

Author: dplassgit

src/com/plasstech/lang/c/parser/FunDecl.java

@@ -15,4 +15,11 @@ public record FunDecl(String name, FunType funType, List<String> paramNames, Opt
   public <R> R accept(Visitor<R> visitor) {
     return visitor.visit(this);
   }
+
+  public BlockItem nthItem(int i) {
+    if (body.isEmpty()) {
+      return null;
+    }
+    return body.get().items().get(i);
+  }
 }

src/com/plasstech/lang/c/typecheck/Initializer.java

@@ -11,6 +11,13 @@ public static Initializer of(long value, Type type) {
     if (type.equals(Type.LONG)) {
       return new Initializer(new LongInit(value));
     }
+    // Not sure if this is right. Page 280
+    if (type.equals(Type.UNSIGNED_INT)) {
+      return new Initializer(new UIntInit((int) value));
+    }
+    if (type.equals(Type.UNSIGNED_LONG)) {
+      return new Initializer(new ULongInit(value));
+    }
     throw new IllegalStateException("Cannot create of type " + type.toString());
   }
 

src/com/plasstech/lang/c/typecheck/StaticInit.java

@@ -5,5 +5,6 @@ public interface StaticInit {
 
   long valueAsLong();
 
+  // Name for the asm generation
   String name();
 }

src/com/plasstech/lang/c/typecheck/Type.java

@@ -1,28 +1,26 @@
 package com.plasstech.lang.c.typecheck;
 
-import com.plasstech.lang.c.lex.TokenType;
-
 public interface Type {
   String name();
 
-  record SimpleType(String name) implements Type {
+  default int size() {
+    return 0;
+  }
+
+  default boolean signed() {
+    return false;
+  }
+
+  record SimpleType(String name, int size, boolean signed) implements Type {
     @Override
     public final String toString() {
       return name;
     }
   }
 
-  Type INT = new SimpleType("int");
-  Type LONG = new SimpleType("long");
-  Type UNSIGNED_INT = new SimpleType("unsigned int");
-  Type UNSIGNED_LONG = new SimpleType("unsigned long");
-  Type NO_TYPE = new SimpleType("no type");
-
-  static Type fromTokenType(TokenType type) {
-    return switch (type) {
-      case INT -> INT;
-      case LONG -> LONG;
-      default -> throw new IllegalArgumentException("Unexpected value: " + type);
-    };
-  }
+  Type INT = new SimpleType("int", 32, true);
+  Type LONG = new SimpleType("long", 64, true);
+  Type UNSIGNED_INT = new SimpleType("unsigned int", 32, false);
+  Type UNSIGNED_LONG = new SimpleType("unsigned long", 64, false);
+  Type NO_TYPE = new SimpleType("no type", 0, false);
 }

src/com/plasstech/lang/c/typecheck/TypeChecker.java

@@ -210,6 +210,13 @@ private Optional<Long> getDeclInitialValue(VarDecl decl) {
         if (ci.type().equals(Type.LONG)) {
           yield Optional.of(ci.asLong());
         }
+        // Page 280. Not sure if this is right.
+        if (ci.type().equals(Type.UNSIGNED_INT)) {
+          yield Optional.of(ci.asLong());
+        }
+        if (ci.type().equals(Type.UNSIGNED_LONG)) {
+          yield Optional.of(ci.asLong());
+        }
         throw new IllegalArgumentException("Unexpected value: " + ci.type());
       }
       default -> Optional.empty();
@@ -254,12 +261,21 @@ private Return typeCheckReturn(Return r) {
     return new Return(convertTo(typeCheckExp(r.exp()), currentRetType));
   }
 
-  // Page 254
-  private static Type getCommonType(Type t1, Type t2) {
-    if (t1.equals(t2)) {
-      return t1;
+  // Page 254, 280
+  private static Type getCommonType(Type type1, Type type2) {
+    if (type1.equals(type2)) {
+      return type1;
+    }
+    if (type1.size() == type2.size()) {
+      if (type1.signed()) {
+        return type2;
+      }
+      return type1;
+    }
+    if (type1.size() > type2.size()) {
+      return type1;
     }
-    return Type.LONG;
+    return type2;
   }
 
   // Page 255

src/com/plasstech/lang/c/typecheck/UIntInit.java

@@ -0,0 +1,18 @@
+package com.plasstech.lang.c.typecheck;
+
+public record UIntInit(int value) implements StaticInit {
+  @Override
+  public long valueAsLong() {
+    return value;
+  }
+
+  @Override
+  public int bytes() {
+    return 4;
+  }
+
+  @Override
+  public String name() {
+    return "long";
+  }
+}

src/com/plasstech/lang/c/typecheck/ULongInit.java

@@ -0,0 +1,18 @@
+package com.plasstech.lang.c.typecheck;
+
+public record ULongInit(long value) implements StaticInit {
+  @Override
+  public long valueAsLong() {
+    return value;
+  }
+
+  @Override
+  public int bytes() {
+    return 8;
+  }
+
+  @Override
+  public String name() {
+    return "quad";
+  }
+}

test/com/plasstech/lang/c/typecheck/TypeCheckerTest.java

@@ -259,7 +259,7 @@ int main(long a) {
         """;
     Program program = validate(input);
     FunDecl fd = (FunDecl) program.declarations().get(0);
-    Return r = (Return) fd.body().get().items().get(0);
+    Return r = (Return) fd.nthItem(0);
     assertThat(r.exp().type()).isEqualTo(Type.INT);
   }
 
@@ -273,7 +273,7 @@ long main(long a) {
         """;
     Program program = validate(input);
     FunDecl fd = (FunDecl) program.declarations().get(0);
-    Return r = (Return) fd.body().get().items().get(1);
+    Return r = (Return) fd.nthItem(1);
     assertThat(r.exp().type()).isEqualTo(Type.LONG);
   }
 
@@ -287,7 +287,7 @@ int main(long a) {
         """;
     Program program = validate(input);
     FunDecl fd = (FunDecl) program.declarations().get(0);
-    Return r = (Return) fd.body().get().items().get(1);
+    Return r = (Return) fd.nthItem(1);
     assertThat(r.exp().type()).isEqualTo(Type.INT);
   }
 
@@ -331,4 +331,92 @@ int main(void) {
         assertThrows(SemanticAnalyzerException.class, () -> validate(input));
     assertThat(e.getMessage()).contains("Conflicting types for 'foo'");
   }
+
+  @Test
+  public void unsignedIntAndIntBecomesUnsignedInt() {
+    String input = """
+        unsigned int main(unsigned int a) {
+          int b = 1;
+          return b + a;
+        }
+        """;
+    Program program = validate(input);
+    FunDecl fd = (FunDecl) program.declarations().get(0);
+    Return r = (Return) fd.nthItem(1);
+    assertThat(r.exp().type()).isEqualTo(Type.UNSIGNED_INT);
+  }
+
+  @Test
+  public void unsignedIntAndUnsignedLongBecomesUnsignedLong() {
+    String input = """
+        unsigned long main(unsigned long a) {
+          unsigned int b = 1u;
+          return b + a;
+        }
+        """;
+    Program program = validate(input);
+    FunDecl fd = (FunDecl) program.declarations().get(0);
+    Return r = (Return) fd.nthItem(1);
+    assertThat(r.exp().type()).isEqualTo(Type.UNSIGNED_LONG);
+  }
+
+  @Test
+  public void unsignedIntAndLongBecomesLong() {
+    String input = """
+        unsigned int main(unsigned int a) {
+          long b = 1L;
+          return b + a; // it actually IS a long but then it gets cast AGAIN to the return type
+        }
+        """;
+    Program program = validate(input);
+    FunDecl fd = (FunDecl) program.declarations().get(0);
+    Return r = (Return) fd.nthItem(1);
+    assertThat(r.exp().type()).isEqualTo(Type.UNSIGNED_INT);
+  }
+
+  @Test
+  public void unsignedLongAndLongBecomesUnsignedLong() {
+    String input = """
+        unsigned long main(unsigned long a) {
+          signed long b = 1L;
+          return b + a;
+        }
+        """;
+    Program program = validate(input);
+    FunDecl fd = (FunDecl) program.declarations().get(0);
+    Return r = (Return) fd.nthItem(1);
+    assertThat(r.exp().type()).isEqualTo(Type.UNSIGNED_LONG);
+  }
+
+  @Test
+  public void staticInitUnsignedIntOverflow() {
+    String input = """
+        static unsigned int u = 4294967299L;
+        """;
+    validate(input);
+    Symbol u = symbols.get("u");
+    StaticAttr attr = (StaticAttr) u.attribute();
+    assertThat(attr.init()).isInstanceOf(Initializer.class);
+    Initializer initialValue = (Initializer) attr.init();
+    assertThat(initialValue.staticInit()).isInstanceOf(UIntInit.class);
+    UIntInit staticInit = (UIntInit) initialValue.staticInit();
+    // whoa, this actually works. Thanks Java.
+    assertThat(staticInit.value()).isEqualTo(3);
+  }
+
+  @Test
+  public void staticInitIntOverflow() {
+    String input = """
+        static int u = 4294967246u;
+        """;
+    validate(input);
+    Symbol u = symbols.get("u");
+    StaticAttr attr = (StaticAttr) u.attribute();
+    assertThat(attr.init()).isInstanceOf(Initializer.class);
+    Initializer initialValue = (Initializer) attr.init();
+    assertThat(initialValue.staticInit()).isInstanceOf(IntInit.class);
+    IntInit staticInit = (IntInit) initialValue.staticInit();
+    // whoa, this actually works. Thanks Java.
+    assertThat(staticInit.value()).isEqualTo(-50);
+  }
 }