Implicit conversions??

jpetalc/src/main/java/org/ikeran/petal/semantic/SemPhase1.kt

@@ -34,15 +34,27 @@ class SemPhase1(val errors: ErrorRecorder): SemVisitor<Unit>() {
             type = type.resolve()
             node.type = type
         }
+        if (type is ForwardDeclType) {
+            errors.report(
+                node,
+                ErrorType.TYPE_NOT_FOUND,
+                "failed to locate type ${type.name}"
+            )
+        }
         if (init != null) {
-            logger.info("checking type ${init.type.name} vs ${node.type.name}")
-            if (init.type != type) {
+            logger.info("checking type ${init.type.name} vs ${type.name}")
+            if (init.type != type && !init.type.canImplicitConvertTo(type)) {
                 logger.info("adding error")
                 errors.report(
                         node,
                         ErrorType.TYPE_MISMATCH,
                         "can't initialize ${node.name} of type ${node.type.name} with ${init.type.name}")
             }
+            if (init.type != type) {
+                val cast = CastExpr(init, type, implicit = true)
+                cast.ast = init.ast
+                node.init = cast
+            }
         }
     }
 }

jpetalc/src/main/java/org/ikeran/petal/semantic/SemVisitor.kt

@@ -118,4 +118,7 @@ abstract class SemVisitor<T> {
     open fun visitIntLiteral(node: IntLiteral): T { return defaultValue() }
     open fun visitFloatLiteral(node: FloatLiteral): T { return defaultValue() }
     open fun visitInvokeExpr(node: InvokeExpr): T { return defaultValue() }
+    open fun visitCastExpr(node: CastExpr): T {
+        return visit(node.child)
+    }
 }

jpetalc/src/main/java/org/ikeran/petal/semantic/SemanticNodes.kt

@@ -103,13 +103,13 @@ class StringLiteral(val value: String): Expr(type = Type.STRING) {
     }
 }
 // TODO make this work for unsigned longs somehow
-class IntLiteral(val value: Long, type: Type = Type.INT): Expr(type) {
+class IntLiteral(val value: Long, type: Type = Type.NUMLITERAL): Expr(type) {
     override fun <T> accept(visitor: SemVisitor<T>): T {
         return visitor.visitIntLiteral(this)
     }
 
 }
-class FloatLiteral(val value: Double, type: Type = Type.FLOAT): Expr(type) {
+class FloatLiteral(val value: Double, type: Type = Type.NUMLITERAL): Expr(type) {
     override fun <T> accept(visitor: SemVisitor<T>): T {
         return visitor.visitFloatLiteral(this)
     }
@@ -119,5 +119,9 @@ class InvokeExpr(val parts: List<String>): Expr(type = Type.UNKNOWN) {
     override fun <T> accept(visitor: SemVisitor<T>): T {
         return visitor.visitInvokeExpr(this)
     }
-
+}
+class CastExpr(val child: Expr, type: Type, val implicit: Boolean): Expr(type = type) {
+    override fun <T> accept(visitor: SemVisitor<T>): T {
+        return visitor.visitCastExpr(this)
+    }
 }

jpetalc/src/main/java/org/ikeran/petal/semantic/Types.kt

@@ -2,6 +2,7 @@ package org.ikeran.petal.semantic
 
 import java.util.ArrayList
 import java.util.HashMap
+import org.slf4j.LoggerFactory
 
 /**
  * Types that we know about.
@@ -31,6 +32,7 @@ abstract class Type(
         val UNKNOWN = UnknownType()
         val ERROR = ErrorType()
         val UNIT = UnitType()
+        val NUMLITERAL = NumberLiteralType()
 
         val registry = HashMap<String, Type>()
 
@@ -38,17 +40,21 @@ abstract class Type(
             val existing = registry.get(t.name)
             if (existing == null) {
                 registry.put(t.name, t)
+                logger.info("added ${t.name} -> ${t} to type registry")
                 return t
             }
             if (existing is ForwardDeclType && t !is ForwardDeclType) {
                 registry.put(t.name, t)
                 existing.realType = t
+                logger.info("added ${t.name} -> ${t} to type registry, overwriting fwd decl")
                 return t
             }
+            logger.info("returning existing type ${existing}")
             return existing
         }
 
         fun lookup(fqn: String): Type {
+            if (registry.size == 0) registerBuiltins()
             val fwd = ForwardDeclType(fqn)
             return register(fwd)
         }
@@ -70,14 +76,21 @@ abstract class Type(
             register(UNKNOWN)
             register(ERROR)
             register(UNIT)
+            register(NUMLITERAL)
         }
     }
 
     open fun isValid(): Boolean {
         return true
     }
+
+    open fun canImplicitConvertTo(other: Type): Boolean {
+        return other == this
+    }
 }
 
+val logger = LoggerFactory.getLogger("types")
+
 // Special cases
 /** UnknownType is the type initially assigned with eg `let a = someFunc()` and we don't know the func's return type. */
 class UnknownType(): Type("<unknown>") {
@@ -113,8 +126,18 @@ class ForwardDeclType(name: String): Type(name) {
         return other
     }
 }
+class NumberLiteralType: Type("<numeric>") {
+    override fun isValid(): Boolean { return false }
+    override fun canImplicitConvertTo(other: Type): Boolean {
+        logger.info("canImplicitConvertTo(${this} ${javaClass} to ${other} ${other.javaClass})")
+        if (other is NumberLiteralType) return true
+        if (other is IntType) return true
+        if (other is FloatType) return true
+        return false
+    }
+}
 // Builtin types
-data class IntType(val signed: Boolean, val size: Int) : Type("${if (signed) "" else "u"}int${size*8}}")
+data class IntType(val signed: Boolean, val size: Int) : Type("${if (signed) "" else "u"}int${size*8}")
 data class FloatType(val size: Int) : Type("float${size * 8}") {}
 class StringType : Type("string") {
     override fun equals(other: Any?): Boolean {
@@ -143,7 +166,7 @@ open class UserDefinedType(name: String = ""): Type(name) {
 }
 open class AggregateType(name: String = "") : Type(name)
 data class ClassType(val shortName: String, val qualifiedName: String) : AggregateType(qualifiedName) {
-    /** Only class Object should have a null parent. Otherwise, if the parent's null, we'll set it to Object. */
+    /** Only class ProtoObject should have a null parent. Otherwise, if the parent's null, we'll set it to Object. */
     var base: Type? = null
     val interfaces = ArrayList<InterfaceType>()
 }

jpetalc/src/test/petal/semantic/test0003.petal

@@ -2,5 +2,5 @@ namespace test.
 #testerror 5:6
 # Typecheck in initialization with literal.
 main {
-    let int a = 10.0.
+    let int64 a = "hello".
 }

jpetalc/src/test/petal/semantic/test0004.petal

@@ -0,0 +1,14 @@
+namespace test.
+# Number literals automatically convert to their related types.
+main {
+    let int8 b = 10.
+    let int16 b = 10.
+    let int32 b = 10.
+    let int64 b = 10.
+    let uint8 b = 10.
+    let uint16 b = 10.
+    let uint32 b = 10.
+    let uint64 b = 10.
+    let float32 b = 10.
+    let float64 b = 10.
+}

petal.md

@@ -83,6 +83,7 @@ class MyClass
   provided. Python allows this but makes an implicit static variable, while D says it has to be a
   compile-time constant. If we said compile-time constant, that would mean bringing in null
   everywhere, and I don't want null.
+* Override functions don't need to mention their return types maybe?
 
 ## Metaprogramming
 I want easy metaprogramming. This means: