Print enum values in stack traces. Fixes #912.

guidotack · cyderize · commit 809109a5523f · 2025-05-02T09:43:16.000+10:00
diff --git a/changes.rst b/changes.rst
@@ -31,6 +31,7 @@ Bug fixes:
    result in a segfault (:bugref:`901`).
 -  Fix a problem where an operator such as ``<=`` on an optional type would
    sometimes lead to an internal compiler error (:bugref:`898`).
+-  Print enum values in stack traces (:bugref:`912`).
 
 .. _v2.9.2:
 
diff --git a/include/minizinc/prettyprinter.hh b/include/minizinc/prettyprinter.hh
@@ -145,6 +145,10 @@ std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& o
 
 void pp_floatval(std::ostream& os, const FloatVal& fv, bool hexFloat = false);
 
+std::string show_enum_type(EnvI& env, Expression* e, Type t, bool dzn, bool json);
+
+std::string show_with_type(EnvI& env, Expression* exp, Type t, bool showDzn);
+
 }  // namespace MiniZinc
 
 void debugprint(const MiniZinc::Expression* e);
diff --git a/include/minizinc/stackdump.hh b/include/minizinc/stackdump.hh
@@ -25,7 +25,7 @@ class Expression;
 class StackDump {
 public:
   StackDump(EnvI& env);
-  StackDump() {}
+  StackDump() : _env(nullptr) {}
   void print(std::ostream& os) const;
   void json(std::ostream& os) const;
   bool empty() const { return _stack.empty(); }
@@ -37,6 +37,7 @@ public:
   }
 
 private:
+  EnvI* _env;
   std::vector<std::pair<Expression*, bool>> _stack;
 };
 
diff --git a/lib/builtins.cpp b/lib/builtins.cpp
@@ -2333,95 +2333,6 @@ std::string b_show_index_sets(EnvI& env, Call* c) {
   return oss.str();
 }
 
-std::string b_show_enum_type(EnvI& env, Expression* e, Type t, bool dzn, bool json) {
-  Id* ti_id = env.getEnum(t.typeId())->e()->id();
-  GCLock lock;
-  std::vector<Expression*> args(3);
-  args[0] = e;
-  if (Expression::type(e).dim() > 1) {
-    Call* array1d = Call::a(Location().introduce(), env.constants.ids.array1d, {e});
-    Type array1dt = Type::arrType(env, Type::partop(1), t);
-    array1d->type(array1dt);
-    array1d->decl(env.model->matchFn(env, array1d, false, true));
-    args[0] = array1d;
-  }
-  args[1] = env.constants.boollit(dzn);
-  args[2] = env.constants.boollit(json);
-  ASTString enumName(create_enum_to_string_name(ti_id, "_toString_"));
-  auto* call = Call::a(Location().introduce(), enumName, args);
-  auto* fi = env.model->matchFn(env, call, false, true);
-  call->decl(fi);
-  Expression::type(call, Type::parstring());
-  return eval_string(env, call);
-}
-
-std::string show_with_type(EnvI& env, Expression* exp, Type t, bool showDzn) {
-  GCLock lock;
-  Expression* e = follow_id_to_decl(exp);
-  if (auto* vd = Expression::dynamicCast<VarDecl>(e)) {
-    if ((vd->e() != nullptr) && !Expression::isa<Call>(vd->e())) {
-      e = vd->e();
-    } else {
-      e = vd->id();
-    }
-  }
-  if (Expression::type(e).isPar()) {
-    e = eval_par(env, e);
-  }
-  if (Expression::type(e).dim() > 0 || Expression::type(e).structBT()) {
-    e = eval_array_lit(env, e);
-  }
-  if (Expression::type(e).isPar() && Expression::type(e).dim() == 0 && t.bt() == Type::BT_INT &&
-      t.typeId() != 0) {
-    return b_show_enum_type(env, e, t, showDzn, false);
-  }
-  std::ostringstream oss;
-  if (auto* al = Expression::dynamicCast<ArrayLit>(e)) {
-    auto al_t = t;
-    if (al->isTuple() && env.getTransparentType(t) != t) {
-      // Unwrap nested array type
-      al = eval_array_lit(env, (*al)[0]);
-      al_t = env.getTransparentType(t);
-    }
-    oss << (al->isTuple() ? "(" : "[");
-    if (al->type().isrecord()) {
-      RecordType* rt = env.getRecordType(al->type());
-      assert(al->size() == rt->size());
-      for (unsigned int i = 0; i < al->size(); i++) {
-        oss << Printer::quoteId(rt->fieldName(i)) << ": "
-            << show_with_type(env, (*al)[i], (*rt)[i], showDzn);
-        if (i < al->size() - 1) {
-          oss << ", ";
-        }
-      }
-    } else if (al->type().istuple()) {
-      TupleType* tt = env.getTupleType(al->type());
-      for (unsigned int i = 0; i < al->size(); i++) {
-        oss << show_with_type(env, (*al)[i], (*tt)[i], showDzn);
-        if (i < al->size() - 1) {
-          oss << ", ";
-        }
-      }
-      if (al->size() == 1) {
-        oss << ",";
-      }
-    } else {
-      // Use element type from al_t since evaluating e may have removed the enum types
-      auto elemType = al_t.elemType(env);
-      for (unsigned int i = 0; i < al->size(); i++) {
-        oss << show_with_type(env, (*al)[i], elemType, showDzn);
-        if (i < al->size() - 1) {
-          oss << ", ";
-        }
-      }
-    }
-    oss << (al->isTuple() ? ")" : "]");
-  } else {
-    Printer p(oss, 0, false, &env);
-    p.print(e);
-  }
-  return oss.str();
-}
 std::string show(EnvI& env, Expression* exp) {
   return show_with_type(env, exp, Expression::type(exp), false);
 }
@@ -2438,7 +2349,7 @@ std::string b_show_dzn_id(EnvI& env, Call* call) {
 
 std::string b_show_json_basic(EnvI& env, Expression* e, Type t) {
   if (t.bt() == Type::BT_INT && t.typeId() != 0 && t.isPar()) {
-    return b_show_enum_type(env, e, t, false, true);
+    return show_enum_type(env, e, t, false, true);
   }
   std::ostringstream oss;
   Printer p(oss, 0, false, &env);
diff --git a/lib/prettyprinter.cpp b/lib/prettyprinter.cpp
@@ -20,6 +20,7 @@
 #include <minizinc/model.hh>
 #include <minizinc/prettyprinter.hh>
 #include <minizinc/type.hh>
+#include <minizinc/typecheck.hh>
 
 #include <iomanip>
 #include <limits>
@@ -2612,6 +2613,96 @@ void FznJSONPrinter::print(MiniZinc::Model* m) {
       << "}\n";
 }
 
+std::string show_enum_type(EnvI& env, Expression* e, Type t, bool dzn, bool json) {
+  Id* ti_id = env.getEnum(t.typeId())->e()->id();
+  GCLock lock;
+  std::vector<Expression*> args(3);
+  args[0] = e;
+  if (Expression::type(e).dim() > 1) {
+    Call* array1d = Call::a(Location().introduce(), env.constants.ids.array1d, {e});
+    Type array1dt = Type::arrType(env, Type::partop(1), t);
+    array1d->type(array1dt);
+    array1d->decl(env.model->matchFn(env, array1d, false, true));
+    args[0] = array1d;
+  }
+  args[1] = env.constants.boollit(dzn);
+  args[2] = env.constants.boollit(json);
+  ASTString enumName(create_enum_to_string_name(ti_id, "_toString_"));
+  auto* call = Call::a(Location().introduce(), enumName, args);
+  auto* fi = env.model->matchFn(env, call, false, true);
+  call->decl(fi);
+  Expression::type(call, Type::parstring());
+  return eval_string(env, call);
+}
+
+std::string show_with_type(EnvI& env, Expression* exp, Type t, bool showDzn) {
+  GCLock lock;
+  Expression* e = follow_id_to_decl(exp);
+  if (auto* vd = Expression::dynamicCast<VarDecl>(e)) {
+    if ((vd->e() != nullptr) && !Expression::isa<Call>(vd->e())) {
+      e = vd->e();
+    } else {
+      e = vd->id();
+    }
+  }
+  if (Expression::type(e).isPar()) {
+    e = eval_par(env, e);
+  }
+  if (Expression::type(e).dim() > 0 || Expression::type(e).structBT()) {
+    e = eval_array_lit(env, e);
+  }
+  if (Expression::type(e).isPar() && Expression::type(e).dim() == 0 && t.bt() == Type::BT_INT &&
+      t.typeId() != 0) {
+    return show_enum_type(env, e, t, showDzn, false);
+  }
+  std::ostringstream oss;
+  if (auto* al = Expression::dynamicCast<ArrayLit>(e)) {
+    auto al_t = t;
+    if (al->isTuple() && env.getTransparentType(t) != t) {
+      // Unwrap nested array type
+      al = eval_array_lit(env, (*al)[0]);
+      al_t = env.getTransparentType(t);
+    }
+    oss << (al->isTuple() ? "(" : "[");
+    if (al->type().isrecord()) {
+      RecordType* rt = env.getRecordType(al->type());
+      assert(al->size() == rt->size());
+      for (unsigned int i = 0; i < al->size(); i++) {
+        oss << Printer::quoteId(rt->fieldName(i)) << ": "
+            << show_with_type(env, (*al)[i], (*rt)[i], showDzn);
+        if (i < al->size() - 1) {
+          oss << ", ";
+        }
+      }
+    } else if (al->type().istuple()) {
+      TupleType* tt = env.getTupleType(al->type());
+      for (unsigned int i = 0; i < al->size(); i++) {
+        oss << show_with_type(env, (*al)[i], (*tt)[i], showDzn);
+        if (i < al->size() - 1) {
+          oss << ", ";
+        }
+      }
+      if (al->size() == 1) {
+        oss << ",";
+      }
+    } else {
+      // Use element type from al_t since evaluating e may have removed the enum types
+      auto elemType = al_t.elemType(env);
+      for (unsigned int i = 0; i < al->size(); i++) {
+        oss << show_with_type(env, (*al)[i], elemType, showDzn);
+        if (i < al->size() - 1) {
+          oss << ", ";
+        }
+      }
+    }
+    oss << (al->isTuple() ? ")" : "]");
+  } else {
+    Printer p(oss, 0, false, &env);
+    p.print(e);
+  }
+  return oss.str();
+}
+
 }  // namespace MiniZinc
 
 void debugprint(const MiniZinc::Expression* e) { std::cerr << *e << "\n"; }
diff --git a/lib/stackdump.cpp b/lib/stackdump.cpp
@@ -11,12 +11,13 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include <minizinc/ast.hh>
+#include <minizinc/builtins.hh>
 #include <minizinc/flatten_internal.hh>
 #include <minizinc/stackdump.hh>
 #include <minizinc/typecheck.hh>
 
 namespace MiniZinc {
-StackDump::StackDump(EnvI& env) {
+StackDump::StackDump(EnvI& env) : _env(&env) {
   // Make sure the call stack items are kept alive
   for (auto it = env.callStack.rbegin(); it != env.callStack.rend(); it++) {
     bool isCompIter = it->tag;
@@ -87,7 +88,10 @@ void StackDump::print(std::ostream& os) const {
         if (isCompIter) {
           if ((Expression::cast<Id>(e)->decl()->e() != nullptr) &&
               Expression::type(Expression::cast<Id>(e)->decl()->e()).isPar()) {
-            os << *e << " = " << *Expression::cast<Id>(e)->decl()->e() << std::endl;
+            os << *e << " = "
+               << show_with_type(*_env, Expression::cast<Id>(e)->decl()->e(), Expression::type(e),
+                                 false)
+               << std::endl;
           } else {
             os << *e << " = <expression>" << std::endl;
           }
@@ -211,7 +215,9 @@ void StackDump::json(std::ostream& os) const {
         if (isCompIter) {
           if ((Expression::cast<Id>(e)->decl()->e() != nullptr) &&
               Expression::type(Expression::cast<Id>(e)->decl()->e()).isPar()) {
-            ss << *e << " = " << *Expression::cast<Id>(e)->decl()->e();
+            ss << *e << " = "
+               << show_with_type(*_env, Expression::cast<Id>(e)->decl()->e(), Expression::type(e),
+                                 false);
           } else {
             ss << *e << " = <expression>";
           }
diff --git a/tests/spec/unit/regression/github_912.mzn b/tests/spec/unit/regression/github_912.mzn
@@ -0,0 +1,2 @@
+enum Foo = { A };
+constraint forall (x in Foo) (abort("foo"));
diff --git a/tests/spec/unit/regression/github_912.py b/tests/spec/unit/regression/github_912.py
@@ -0,0 +1,23 @@
+from pathlib import Path
+from minizinc import default_driver, Driver
+import subprocess
+import json
+
+
+def test_github_912():
+    here = Path(__file__).resolve().parent
+    assert isinstance(default_driver, Driver)
+    model_file = here / "github_912.mzn"
+    p = subprocess.run(
+        [default_driver._executable, model_file, "--json-stream"],
+        stdin=None,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    assert p.returncode == 1
+    messages = [json.loads(l) for l in p.stdout.splitlines(False)]
+    errors = [m for m in messages if m["type"] == "error"]
+    assert len(errors) == 1
+    entries = [s for s in errors[0]["stack"] if s["isCompIter"]]
+    assert len(entries) == 1
+    assert entries[0]["description"] == "x = A"

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+enum Foo = { A };`
	`2`	`+constraint forall (x in Foo) (abort("foo"));`