Fixes lookup problem of constants in a package.

Author: modlfo

src/core/env.ml

@@ -818,9 +818,8 @@ type expression_symbol =
   | ExprEnum of (path * Loc.t * int)
   | ExprNotFound
 
-let lookupExpressionSymbol (env : env) (name : string) (loc : Loc.t) (in_constant_context : bool) : expression_symbol =
-  let name_path : path = { id = name; n = None; loc } in
-  let results = lookupPath env name_path in
+let lookupExpressionSymbol (env : env) (path : path) (in_constant_context : bool) : expression_symbol =
+  let results = lookupPath env path in
   if in_constant_context then
     (* In constant context: constants first, then enums, then types *)
     match findVar results with

src/core/inference.ml

@@ -373,7 +373,8 @@ and exp ?(in_constant_context = false) (env : env) (e : Syntax.exp) : env * exp
     env, { e = EString value; t; loc }
   | { e = SEGroup e; _ } -> exp ~in_constant_context env e
   | { e = SEId name; loc } when not (String.equal (String.capitalize_ascii name) name) -> (
-    match Env.lookupExpressionSymbol env name loc in_constant_context with
+    let name_path : path = { id = name; n = None; loc } in
+    match Env.lookupExpressionSymbol env name_path in_constant_context with
     | ExprVariable var ->
       let t = var.t in
       let e =
@@ -503,41 +504,61 @@ and exp ?(in_constant_context = false) (env : env) (e : Syntax.exp) : env * exp
     let t = applyFunction e.loc args_t ret [ e ] in
     env, { e = EUnOp (op, e); t; loc }
   | { e = SEMember (e1, m); loc } -> (
-    (* First, try to interpret this as an enum reference if e1 is an SEId *)
+    (* First, try to interpret this as an enum reference if e1 is an SEId or SEEnum *)
     match e1 with
-    | { e = SEId module_name; _ } -> (
-      (* Try to lookup as enum: module_name.m *)
-      let enum_path = Syntax.{ id = m; n = Some module_name; loc } in
-      try
-        let type_path, tloc, index = Env.lookEnum env enum_path loc in
-        let t = C.path_t tloc type_path in
-        env, { e = EInt index; t; loc }
-      with
-      | _ -> (
-        (* If enum lookup fails, fall back to normal member access *)
-        let env, e1 = exp ~in_constant_context env e1 in
-        match (unlink e1.t).tx with
-        | TEId path -> (
-          match Env.lookType env path loc with
-          | { path; descr = Record members; _ } -> (
-            match Map.find m members with
-            | None -> Error.raiseError ("The field '" ^ m ^ "' is not part of the type '" ^ pathString path ^ "'") loc
-            | Some { t; _ } ->
-              let t = refreshConstness t in
-              (* if the type is a builtin (a value) do not unify the constness *)
-              let () =
-                if (not in_constant_context) && not (Env.isBuiltinType t) then
-                  unifyConstness t e1.t
-              in
-              env, { e = EMember (e1, m); t; loc })
-          | _ ->
-            let t = Pla.print (Typed.print_type_ e1.t) in
-            let e = Pla.print (Typed.print_exp e1) in
-            Error.raiseError ("The expression '" ^ e ^ "' of type '" ^ t ^ "' does not have a member '" ^ m ^ "'.") loc)
-        | _ ->
-          let t = Pla.print (Typed.print_type_ e1.t) in
-          let e = Pla.print (Typed.print_exp e1) in
-          Error.raiseError ("The expression '" ^ e ^ "' of type '" ^ t ^ "' does not have a member '" ^ m ^ "'.") loc))
+    | { e = SEId module_name; _ } when String.equal (String.capitalize_ascii module_name) module_name -> (
+      (* First check if this is a module name - try module-qualified access *)
+      let const_path = Syntax.{ id = m; n = Some module_name; loc } in
+      let results = Env.lookupPath env const_path in
+      match results with
+      | _ :: _ -> (
+        (* Found something in module - check what it is *)
+        match Env.findVar results with
+        | Some var when var.kind = Const ->
+          let t = var.t in
+          env, { e = EConst const_path; t; loc }
+        | Some var ->
+          Error.raiseError
+            ("Found '"
+            ^ module_name
+            ^ "."
+            ^ m
+            ^ "' but it's not a constant (it's a "
+            ^ (match var.kind with
+              | Val -> "variable"
+              | Mem _ -> "memory"
+              | Inst -> "instance"
+              | Const -> "constant")
+            ^ ")")
+            loc
+        | None -> (
+          (* Check for function or enum *)
+          match Env.findFunction results with
+          | Some _ ->
+            Error.raiseError
+              ("'"
+              ^ module_name
+              ^ "."
+              ^ m
+              ^ "' is a function, not a constant. Use function call syntax: "
+              ^ module_name
+              ^ "."
+              ^ m
+              ^ "(args)")
+              loc
+          | None -> (
+            match Env.findEnum results with
+            | Some (type_path, tloc, index) ->
+              let t = C.path_t tloc type_path in
+              env, { e = EInt index; t; loc }
+            | None ->
+              Error.raiseError ("Found '" ^ module_name ^ "." ^ m ^ "' but it's not a constant, function, or enum") loc)
+          ))
+      | [] ->
+        (* Module not found - check if it's an actual module name or just not found *)
+        Error.raiseError
+          ("Module '" ^ module_name ^ "' not found. Check that the module is included or spelled correctly")
+          loc)
     | _ -> (
       (* For non-SEId expressions, use normal member access *)
       let env, e1 = exp ~in_constant_context env e1 in
@@ -563,13 +584,10 @@ and exp ?(in_constant_context = false) (env : env) (e : Syntax.exp) : env * exp
         let t = Pla.print (Typed.print_type_ e1.t) in
         let e = Pla.print (Typed.print_exp e1) in
         Error.raiseError ("The expression '" ^ e ^ "' of type '" ^ t ^ "' does not have a member '" ^ m ^ "'.") loc))
-  | { e = SEEnum path; loc } ->
-    let type_path, tloc, index = Env.lookEnum env path loc in
-    let t = C.path_t tloc type_path in
-    env, { e = EInt index; t; loc }
   | { e = SEId id; loc } -> (
     (* This case handles uppercase identifiers (enum constructors) *)
-    match Env.lookupExpressionSymbol env id loc in_constant_context with
+    let id_path : path = { id; n = None; loc } in
+    match Env.lookupExpressionSymbol env id_path in_constant_context with
     | ExprEnum (type_path, tloc, index) ->
       let t = C.path_t tloc type_path in
       env, { e = EInt index; t; loc }
@@ -755,7 +773,7 @@ let makeIterWhile (env : env) name id_loc value body loc =
   { s = SStmtBlock [ decl; while_s ]; loc }
 
 
-let makeIfOfMatch e cases =
+let makeIfOfMatch env e cases =
   let rec makeComparison (e : Syntax.exp) (p : Syntax.pattern) =
     let makeEq e1 e2 = Syntax.{ e = SEOp ("==", e1, e2); loc = e1.loc } in
     let makeAnd e1 e2 = Syntax.{ e = SEOp ("&&", e1, e2); loc = e1.loc } in
@@ -789,7 +807,17 @@ let makeIfOfMatch e cases =
     | _, { p = SPReal f; loc } -> makeEq e Syntax.{ e = SEReal f; loc }
     | _, { p = SPFixed f; loc } -> makeEq e Syntax.{ e = SEFixed f; loc }
     | _, { p = SPString s; loc } -> makeEq e Syntax.{ e = SEString s; loc }
-    | _, { p = SPEnum p; loc } -> makeEq e Syntax.{ e = SEEnum p; loc }
+    | _, { p = SPId id; loc } -> (
+      (* Handle enum constructor and constant patterns *)
+      let id_path : path = { id; n = None; loc } in
+      match Env.lookupExpressionSymbol env id_path false with
+      | ExprEnum (_, _, _) ->
+        (* Enum constructor: compare with the enum value itself *)
+        makeEq e Syntax.{ e = SEId id; loc }
+      | ExprVariable var when var.kind = Const ->
+        (* Constant: create a constant reference for comparison *)
+        makeEq e Syntax.{ e = SEId id; loc }
+      | _ -> Error.raiseError ("Pattern '" ^ id ^ "' is not a valid enum constructor or constant") loc)
   in
   let if_stmt =
     CCList.fold_right
@@ -855,7 +883,7 @@ let rec stmt (env : env) (return : type_) (s : Syntax.stmt) : env * stmt list =
     let while_s = makeIterWhile env name id_loc value body loc in
     stmt env return while_s
   | { s = SStmtMatch { e; cases }; _ } ->
-    let if_stmt = makeIfOfMatch e cases in
+    let if_stmt = makeIfOfMatch env e cases in
     stmt env return if_stmt
 
 

src/driver/loader.ml

@@ -71,9 +71,17 @@ module Dependencies = struct
     | SEOp (_, e1, e2) -> exp (exp set e1) e2
     | SEIf { cond; then_; else_ } -> exp (exp (exp set cond) then_) else_
     | SETuple elems -> list exp set elems
-    | SEMember (e, _) -> exp set e
+    | SEMember (e, member) -> (
+      (* Check if this is module-qualified access: Module.member *)
+      match e with
+      | { e = SEId module_name; loc } when String.equal (String.capitalize_ascii module_name) module_name ->
+        (* This is module-qualified access, add module to dependencies *)
+        let module_path = { id = member; n = Some module_name; loc } in
+        path set module_path
+      | _ ->
+        (* Regular member access, just process the expression *)
+        exp set e)
     | SEGroup e -> exp set e
-    | SEEnum p -> path set p
     | SERecord { path = p; elems } -> list (fun set (p, v) -> exp (path set p) v) (path set p) elems
 
 
@@ -85,9 +93,9 @@ module Dependencies = struct
     | SPReal _ -> set
     | SPFixed _ -> set
     | SPString _ -> set
+    | SPId _ -> set
     | SPTuple elems -> list pattern set elems
     | SPGroup e -> pattern set e
-    | SPEnum p -> path set p
 
 
   let rec dexp set d =

src/generators/java.ml

@@ -547,38 +547,55 @@ let print_top_stmt (args : Util.Args.args) t =
     {%pla|public static final <#t#> <#name#s> = <#rhs#>;<#>|}
 
 
-(* Collect type aliases needed based on function signatures *)
+(* Extract the base type from a function call in the return statement *)
+let extract_base_type_from_call = function
+  | { e = ECall { path; _ }; _ } when CCString.suffix ~suf:"_type_alloc" path ->
+    let len = String.length path in
+    Some (String.sub path 0 (len - 6))
+    (* Remove "_alloc" *)
+  | _ -> None
+
+
+(* Collect type aliases needed based on function signatures and bodies *)
 let collect_type_aliases stmts =
   let aliases = ref [] in
   let collect_from_stmt stmt =
     match stmt.top with
-    | TopFunction (def, _) ->
+    | TopFunction (def, body) ->
       let name = def.name in
       (* Look for pattern: *_function_type_alloc that takes arguments (indicating it's a type alias) *)
       if String.contains name '_' && CCString.suffix ~suf:"_type_alloc" name && List.length def.args > 0 then
-        let parts = String.split_on_char '_' name in
-        (* Handle patterns like Module_noteOn_type_alloc or Module_submodule_pulse_start_type_alloc *)
-        let len = List.length parts in
-        if len >= 4 then
-          (* Check for various patterns including perf variants *)
-          if len >= 5 && List.nth parts (len - 4) = "perf" then
-            (* Handle perf patterns like Module_perf_noteOn_type_alloc *)
-            let module_parts = CCList.take (len - 4) parts in
-            let module_name = String.concat "_" module_parts in
-            let name_len = String.length name in
-            let alias_type = String.sub name 0 (name_len - 6) in
-            (* Remove "_alloc" *)
-            let base_type = module_name ^ "_perf_process_type" in
-            aliases := (alias_type, base_type) :: !aliases
-          else
-            (* Handle regular patterns like Module_noteOn_type_alloc or Module_pulse_start_type_alloc *)
-            let module_parts = CCList.take (len - 3) parts in
-            let module_name = String.concat "_" module_parts in
-            let name_len = String.length name in
-            let alias_type = String.sub name 0 (name_len - 6) in
-            (* Remove "_alloc" *)
-            let base_type = module_name ^ "_process_type" in
-            aliases := (alias_type, base_type) :: !aliases
+        let name_len = String.length name in
+        let alias_type = String.sub name 0 (name_len - 6) in
+        (* Remove "_alloc" *)
+        (* Try to extract the base type from the function body *)
+        let base_type =
+          match body.s with
+          | StmtReturn exp -> (
+            match extract_base_type_from_call exp with
+            | Some base -> base
+            | None ->
+              (* Fallback to old logic if we can't parse the body *)
+              let parts = String.split_on_char '_' name in
+              let len = List.length parts in
+              if len >= 4 then
+                let module_parts = CCList.take (len - 3) parts in
+                let module_name = String.concat "_" module_parts in
+                module_name ^ "_process_type"
+              else
+                alias_type ^ "_base_type")
+          | _ ->
+            (* Fallback if no return statement found *)
+            let parts = String.split_on_char '_' name in
+            let len = List.length parts in
+            if len >= 4 then
+              let module_parts = CCList.take (len - 3) parts in
+              let module_name = String.concat "_" module_parts in
+              module_name ^ "_process_type"
+            else
+              alias_type ^ "_base_type"
+        in
+        aliases := (alias_type, base_type) :: !aliases
     | _ -> ()
   in
   List.iter collect_from_stmt stmts;

src/generators/js.ml

@@ -265,6 +265,7 @@ let getTemplateCode (args : Util.Args.args) =
   match args.template with
   | None -> Pla.unit, Pla.unit
   | Some "performance" -> T_performance.generateJs args
+  | Some "performance-bun" -> T_performance.generateJsBun args
   | Some name -> Util.Error.raiseErrorMsg ("Unknown template '" ^ name ^ "'")
 
 

src/generators/t_performance.ml

@@ -115,7 +115,7 @@ let luaPost (args : Util.Args.args) =
 
 let generateLua (args : Util.Args.args) = Pla.unit, luaPost args
 
-let jsPost (args : Util.Args.args) =
+let jsPostWithLabel (args : Util.Args.args) (label : string) =
   let module_name =
     match args.files with
     | Util.Args.File s :: _ -> Pparser.Parse.moduleName s
@@ -138,12 +138,18 @@ while (samples > 0) {
   samples = samples -1;
 }
 var finish = Number(process.hrtime.bigint() - start) / 1000000 / time;
-console.log(`<#module_name#s>\tJs\t${finish.toFixed(2)} ms/s`)
+console.log(`<#module_name#s>\t<#label#s>\t${finish.toFixed(2)} ms/s`)
 |}
 
 
+let jsPost (args : Util.Args.args) = jsPostWithLabel args "Js"
+
+let jsBunPost (args : Util.Args.args) = jsPostWithLabel args "Bun"
+
 let generateJs (args : Util.Args.args) = Pla.unit, jsPost args
 
+let generateJsBun (args : Util.Args.args) = Pla.unit, jsBunPost args
+
 let juliaPost (args : Util.Args.args) =
   let module_name =
     match args.files with

src/mparser/bast.ml

@@ -404,8 +404,13 @@ let patt_PattString (loc : Lexing.position * Lexing.position) (s : string) (stat
 
 let patt_PattId (loc : Lexing.position * Lexing.position) (p : 'state -> 'state * path) (state : 'state) :
     'state * pattern =
-  let state, p = p state in
-  state, { p = SPEnum p; loc = mk_loc state loc }
+  let state, path = p state in
+  (* Allow identifier patterns - inference will validate if they're enum constructors *)
+  match path with
+  | { id; n = None; _ } -> state, { p = SPId id; loc = mk_loc state loc }
+  | { id; n = Some module_name; _ } ->
+    (* Module-qualified enum patterns like Module.EnumValue *)
+    state, { p = SPId (module_name ^ "_" ^ id); loc = mk_loc state loc }
 
 
 let patt_PattGroup (loc : Lexing.position * Lexing.position) (p : 'state -> 'state * pattern) (state : 'state) :