Use a different optimization

Oct 13, 2025 by recoveryshake.com 149 views

Introduction

In this article, we will explore the issue of undefined labels in JavaScript, specifically in the context of optimized code. We will examine a minimized reproduction of the problem and discuss the relevant JavaScript code. Our goal is to provide a clear understanding of the issue and potential solutions.

Background

The code in question is written in the Effekt programming language, which is a functional programming language that supports effects. The language is designed to provide a high-level abstraction for working with effects, such as input/output operations and exceptions. The code we will examine is a small demo program that fails in both optimized and unoptimized JavaScript.

Minimized Reproduction

The minimized reproduction of the problem is as follows:

type Exp {
  Abs(t: Exp)
  Thunk(f: Exp => Exp / lookup at {})
  Empty()
}

effect lookup(x: String): Exp

def eval(e: Exp): Exp / {lookup} = e match {
  case Abs(body) => Thunk(box { arg =>
    try eval(body) with lookup { y => resume(arg) }
  })
  case _ => Empty()
}

def run(e: Exp): Exp =
  try eval(e) with lookup { x => resume(Empty()) }

def main() = {
  val example = Abs(Abs(Empty()))
  run(example)
  ()
}

This code defines a type Exp with three constructors: Abs, Thunk, and Empty. It also defines an effect lookup that takes a string as input and returns an Exp. The eval function takes an Exp as input and returns an Exp with the effect lookup. The run function takes an Exp as input and returns an Exp by evaluating it with the effect lookup. The main function creates an example Exp and runs it using the run function.

JavaScript Code

The relevant JavaScript code is as follows:

function eval_0(e_0, lookup_2, ks_1, k_0) {
  eval_1: while (true) {
    switch (e_0.__tag) {
      case 0: 
        const v_y_0 = e_0.t_0;
        return () =>
          k_0(new Thunk_0((arg_0, lookup_0, ks_0, k_1) => {
            const lookup_1 = {  };
            /* prepare call */
            k_0 = k_1;
            e_0 = v_y_0;
            lookup_2 = lookup_1;
            continue eval_1; // <----------
          }), ks_1);
      default:  return () => k_0(new Empty_0(), ks_1);
    }
  }
}

This code defines a function eval_0 that takes four arguments: e_0, lookup_2, ks_1, and k_0. The function uses a labeled loop eval_1 to evaluate the Exp e_0. The loop uses a switch statement to determine the next step based on the tag of e_0. If the tag is 0, the function returns a new Thunk_0 object with a continuation function that calls eval_1 again. If the tag is not 0, the function returns a new Empty_0 object.

Issue

The issue with this code is that the label eval_1 is undefined in the optimized JavaScript code. This is because the compiler has optimized the code to remove the label, but the code still relies on it.

Optimizations

The optimizations that are causing the issue are likely related to the following:

Label elimination: The compiler has eliminated the label eval_1 because it is not used anywhere in the code.
Constant folding: The compiler has folded the constant 0 into the switch statement, which has caused the label eval_1 to be undefined.

Solutions

To fix this issue, we can try the following solutions:

Disable label elimination: We can disable label elimination by adding a flag to the compiler that prevents it from eliminating labels.
Use a different optimization: We can try using a different optimization that does not eliminate labels.
Modify the code: We can modify the code to avoid using labels altogether.

Conclusion

In this article, we have explored the issue of undefined labels in JavaScript, specifically in the context of optimized code. We have examined a minimized reproduction of the problem and discussed the relevant JavaScript code. We have also discussed potential solutions to the issue, including disabling label elimination, using a different optimization, and modifying the code. By understanding the issue and potential solutions, we can write more efficient and effective code that avoids undefined labels.

References

Effekt programming language
JavaScript optimization
Label elimination
Constant folding
Undefined Label in JS with Optimizations: Q&A =====================================================

Introduction

In our previous article, we explored the issue of undefined labels in JavaScript, specifically in the context of optimized code. We examined a minimized reproduction of the problem and discussed the relevant JavaScript code. In this article, we will provide a Q&A section to help clarify any questions or concerns you may have.

Q: What is a label in JavaScript?

A: A label in JavaScript is a way to identify a specific point in the code. Labels are used to break out of loops, continue to the next iteration, or jump to a specific point in the code.

Q: Why are labels important in JavaScript?

A: Labels are important in JavaScript because they allow us to control the flow of the code. Without labels, we would not be able to break out of loops or continue to the next iteration.

Q: What is label elimination in JavaScript?

A: Label elimination is a JavaScript optimization that removes labels from the code. This is done to reduce the size of the code and improve performance.

Q: Why does label elimination cause the issue of undefined labels?

A: Label elimination causes the issue of undefined labels because it removes the labels from the code. When the code is optimized, the labels are no longer present, and the code relies on them to function correctly.

Q: How can I disable label elimination in JavaScript?

A: To disable label elimination in JavaScript, you can add a flag to the compiler that prevents it from eliminating labels. The exact flag will depend on the compiler you are using.

Q: What are some other optimizations that can cause the issue of undefined labels?

A: Some other optimizations that can cause the issue of undefined labels include:

Constant folding: This optimization folds constants into the code, which can cause labels to be undefined.
Dead code elimination: This optimization removes code that is not executed, which can cause labels to be undefined.
Loop unrolling: This optimization unrolls loops, which can cause labels to be undefined.

Q: How can I modify the code to avoid using labels?

A: To modify the code to avoid using labels, you can use alternative control flow statements, such as if statements or switch statements. You can also use functions to encapsulate the code and avoid using labels.

Q: What are some best practices for avoiding undefined labels in JavaScript?

A: Some best practices for avoiding undefined labels in JavaScript include:

Avoid using labels: Try to avoid using labels in your code, as they can cause issues with optimization.
Use alternative control flow statements: Use if statements or switch statements instead of labels.
Use functions: Encapsulate your code in functions to avoid using labels.
Test your code: Test your code thoroughly to ensure that it works correctly with optimization.

Conclusion

In this article, we have provided a Q&A section to help clarify any questions or concerns you may have about undefined labels in JavaScript. We have discussed the importance of labels, the issue of undefined labels, and some best practices for avoiding undefined labels. By following these best practices, you can write more efficient and effective code that avoids undefined labels.