typechecker+interpreter: Expose comptime generics as comptime variables

...unless they're of a trivial type which C++ can safely have as an
NTTP.

Author: alimpfard

samples/generics/const_generics.jakt

@@ -1,13 +1,10 @@
 /// Expect:
 /// - output: "70\n"
 
-comptime id<T>(anon x: T) -> T => x
-
 fn actually_kinda_useless<comptime T>() -> i32 {
-    // FIXME: Can't really acccess the value of 'T' outside a comptime context yet (a binding exists, but not at runtime)
-    return id(T) as! i32 + 1
+    return T + 1
 }
 
 fn main() {
-    println("{}", actually_kinda_useless<comptime 69>())
+    println("{}", actually_kinda_useless<comptime 69i32>())
 }

samples/generics/typed_and_untyped_const_generics.jakt

@@ -1,17 +1,15 @@
 /// Expect:
 /// - output: "typed: 10\nuntyped: 20\n"
 
-comptime id<T>(anon x: T) -> T => x
-
 fn typed_version<comptime N: i32>() -> i32 {
-    return id(N) as! i32
+    return N
 }
 
 fn untyped_version<comptime N>() -> i32 {
-    return id(N) as! i32
+    return N
 }
 
 fn main() {
     println("typed: {}", typed_version<comptime 10i32>())
-    println("untyped: {}", untyped_version<comptime 20>())
+    println("untyped: {}", untyped_version<comptime 20i32>())
 }

samples/generics/typed_const_generic_bool.jakt

@@ -1,10 +1,8 @@
 /// Expect:
 /// - output: "true\nfalse\n"
 
-comptime id<T>(anon x: T) -> T => x
-
 fn is_enabled<comptime B: bool>() -> bool {
-    return id(B) as! bool
+    return B
 }
 
 fn main() {

samples/generics/typed_const_generic_i32.jakt

@@ -1,10 +1,8 @@
 /// Expect:
 /// - output: "42\n"
 
-comptime id<T>(anon x: T) -> T => x
-
 fn get_value<comptime N: i32>() -> i32 {
-    return id(N) as! i32
+    return N
 }
 
 fn main() {

samples/generics/typed_const_generic_multiple.jakt

@@ -4,9 +4,7 @@
 comptime id<T>(anon x: T) -> T => x
 
 fn multiply<comptime A: i32, comptime B: i32>() -> i32 {
-    let a = id(A) as! i32
-    let b = id(B) as! i32
-    return a * b
+    return A * B
 }
 
 fn main() {

samples/generics/typed_const_generic_u64.jakt

@@ -4,7 +4,7 @@
 comptime id<T>(anon x: T) -> T => x
 
 fn add_ten<comptime N: u64>() -> u64 {
-    return (id(N) as! u64) + 10u64
+    return N + 10u64
 }
 
 fn main() {

samples/generics/typed_const_generic_with_type_param.jakt

@@ -3,11 +3,11 @@
 
 comptime id<T>(anon x: T) -> T => x
 
-fn format_with_count<T, comptime N: i32>(anon value: T) throws -> String {
-    let count = id(N) as! i32
+fn format_with_count<comptime N: i32, comptime value: String>() throws -> String {
+    let count = N
     return format("{} {}", value, count)
 }
 
 fn main() {
-    println("{}", format_with_count<String, comptime 5i32>("hello"))
+    println("{}", format_with_count<comptime 5i32, comptime "hello">())
 }

selfhost/interpreter.jakt

@@ -3545,13 +3545,32 @@ class Interpreter {
             }
         }
 
+        // Add comptime generic parameter values as interpreter bindings
+        mut comptime_bindings: [String:Value] = [:]
+        for i in 0..function_to_run.generics.params.size() {
+            let param = function_to_run.generics.params[i]
+            let param_type_id = param.checked_parameter.type_id
+            if .program.get_type(param_type_id) is TypeVariable(name, is_value) and is_value {
+                if i < function_to_run.generics.specializations.size() and function_to_run.specialization_index.has_value() {
+                    let spec = function_to_run.generics.specializations[function_to_run.specialization_index!]
+                    if i < spec.size() and .program.get_type(spec[i]) is Const(value) {
+                        comptime_bindings[name] = value
+                    }
+                }
+            }
+        }
+
         match function_to_run.type {
             Normal => {
                 mut scope = InterpreterScope::create(parent: invocation_scope, compiler: .compiler, runtime_scope_id)
                 defer {
                     scope.perform_defers(interpreter: this, span: call_span)
                 }
 
+                for pair in comptime_bindings {
+                    scope.bindings[pair.0] = pair.1
+                }
+
                 for i in 0..function_to_run.params.size() {
                     if this_offset != 0 and i == 0 {
                         continue
@@ -3580,6 +3599,10 @@ class Interpreter {
                     scope.perform_defers(interpreter: this, span: call_span)
                 }
 
+                for pair in comptime_bindings {
+                    scope.bindings[pair.0] = pair.1
+                }
+
                 for i in 0..function_to_run.params.size() {
                     if this_offset != 0 and i == 0 {
                         continue

selfhost/typechecker.jakt

@@ -4890,16 +4890,6 @@ struct Typechecker {
                     }
                 }
                 scope.comptime_bindings[type_name] = value
-                let checked_var = CheckedVariable(
-                    name: type_name
-                    type_id: value.impl.type_id(&mut .program)
-                    is_mutable: false
-                    definition_span: value.span
-                    type_span: None
-                    visibility: CheckedVisibility::Public
-                    invisible_to_ide: false
-                )
-                scope.vars[type_name] = module.add_variable(checked_var)
             }
 
             if dependent_scope_id.has_value() {
@@ -9245,13 +9235,44 @@ struct Typechecker {
 
             yield CheckedExpression::OptionalSome(expr: checked_expr, span, type_id: optional_type_id)
         }
-        Var(name, span) => {
-            let var = .find_var_in_scope(scope_id, var: name)
-            let result = match var {
-                Some(var_) => CheckedExpression::Var(var: var_, span)
+        Var(name, span) => match .find_var_in_scope(scope_id, var: name) {
+            Some(var) => {
+                let var = .find_var_in_scope(scope_id, var: name)
+                let result = match var {
+                    Some(var_) => CheckedExpression::Var(var: var_, span)
+                    None => {
+                        .error(format("Variable '{}' not found", name), span)
+
+                        mut type_id: TypeId? = None
+                        if type_hint.has_value() {
+                            type_id = type_hint!.type_id
+                        }
+
+                        yield CheckedExpression::Var(
+                            var: CheckedVariable(
+                                name,
+                                type_id: type_id.value_or(unknown_type_id()),
+                                is_mutable: false,
+                                definition_span: span,
+                                type_span: None
+                                visibility: CheckedVisibility::Public
+                                invisible_to_ide: false
+                            ),
+                            span
+                        )
+                    }
+                }
+
+                if type_hint is Some(hint) and hint is MustBe(type_id) {
+                    .unify_with_type(found_type: result.type(), expected_type: type_id, span)
+                }
+
+                yield result
+            }
+            None => match .find_comptime_binding_in_scope(scope_id, name) {
+                Some(value) => value_to_checked_expression(value, interpreter: .interpreter())
                 None => {
                     .error(format("Variable '{}' not found", name), span)
-
                     mut type_id: TypeId? = None
                     if type_hint.has_value() {
                         type_id = type_hint!.type_id
@@ -9271,12 +9292,6 @@ struct Typechecker {
                     )
                 }
             }
-
-            if type_hint is Some(hint) and hint is MustBe(type_id) {
-                .unify_with_type(found_type: result.type(), expected_type: type_id, span)
-            }
-
-            yield result
         }
         ForcedUnwrap(expr, span) => {
             let checked_expr = .typecheck_expression_and_dereference_if_needed(expr, scope_id, safety_mode, type_hint: None, span)