Runtime behavior of existing JavaScript code

Oct 13, 2025 by recoveryshake.com 138 views

Introduction

TypeScript is a statically typed language that helps developers catch errors early and improve code maintainability. However, its type system is not without its complexities, and one such area of concern is the compatibility between optional-never objects and normal objects. In this article, we will delve into the intricacies of this compatibility and explore the implications of introducing stricter type checking for optional never to prevent runtime errors.

🔍 Search Terms

TypeScript type system
Optional-never objects
Normal objects
Type compatibility
Stricter type checking
Runtime errors

The Problem with Optional-Never Objects

Optional-never objects are a type of object that has a property with a type of never. This means that the property is never present in the object, and attempting to access it will result in a runtime error. However, when combined with normal objects, the compatibility between these two types of objects can lead to unintended consequences.

Consider the following TypeScript types:

type Ob1 = {
  a: string,
  b?: never
}

type Ob2 = {
  a: string,
}

type Ob3 = {
  a: string,
  b?: number
}

type Ob4 = {
  a: string,
  b: number
}

type Ob5 = {
  a: string,
  b?: undefined
}

type Ob6 = {
  a: string,
  b?: unknown
}

As we can see, Ob1 has a property b with a type of never, while Ob2 has no such property. When we try to assign an instance of Ob2 to a variable of type Ob1, TypeScript does not throw an error, even though this is not a valid assignment.

declare let n1: Ob1
declare let n2: Ob2

// OK
let case1: Ob1 = n2

However, when we try to assign an instance of Ob3 or Ob4 to a variable of type Ob1, TypeScript throws an error, as these objects have a property b that is not compatible with the never type.

type Ob3 = {
  a: string,
  b?: number
}

type Ob4 = {
  a: string,
  b: number
}

declare let n3: Ob3
declare let n4: Ob4

// Error
let case2: Ob1 = n3
let case3: Ob1 = n4

This behavior is not limited to the never type. When we try to assign an instance of Ob5 or Ob6 to a variable of type Ob1, TypeScript also throws an error, as these objects have a property b that is not compatible with the never type.

type Ob5 = {
  a: string,
  b?: undefined
}

type Ob6 = {
  a: string,
  b?: unknown
}

declare let n5: Ob5
declare let n6: Ob6

// Error if exactOptionalPropertyTypes=true
let case4: Ob1 = n5
let case5: Ob1 = n6

The Viability Checklist

Before we proceed with introducing stricter type checking for optional never, let's consider the viability of this feature. Here are some points to consider:

Breaking change in existing TypeScript/JavaScript code: Introducing stricter type checking for optional never would not be a breaking change in existing TypeScript/JavaScript code, as it would not affect the runtime behavior of existing JavaScript code.
Runtime behavior of existing JavaScript code: This feature would not change the runtime behavior of existing JavaScript code, as it would only affect the type checking at compile-time.
Implementation without emitting different JS: This feature could be implemented without emitting different JS based on the types of the expressions, as it would only affect the type checking at compile-time.
Non-ECMAScript syntax with JavaScript output: This feature is not a request to add a new utility type, as it would only affect the type checking at compile-time.
Agreement with the rest of our Design Goals: This feature would agree with the rest of our Design Goals, as it would improve the type safety of the language.

Suggestion

Introducing stricter type checking for optional never would prevent runtime errors and improve the type safety of the language. Here is an example of how this feature could be implemented:

const funcB = (params: { b: string }) => {
  const result = funcA(params) // Type Check Error expected here
  console.log("Result Length: ", result.length)
}

Motivating Example

The inconsistency between optional-never objects and normal objects can lead to unintended runtime errors. Here is an example of how this can happen:

type Params = { a?: never, b: string } | { a: string, c: string }

const funcA = (params: Params): string => {
  if (params.a !== undefined) {
    return params.c
  } else {
    return params.b
  }
}

const funcB = (params: { b: string }) => {
  const result = funcA(params)
  console.log("Result Length: ", result.length) // runtime error
}

const params = { a: 'a', b: 'b' }
funcB(params)

In this example, the funcA function takes a parameter of type Params, which is a union type of two objects: one with a property a of type never and another with a property c of type string. When we call the funcA function with a parameter of type { a: 'a', b: 'b' }, the function returns the value of params.c, which is undefined. However, when we call the funcB function with a parameter of type { b: 'b' }, the function throws a runtime error, as the result variable is undefined and we are trying to access its length property.

💻 Use Cases

What do you want to use this for?
- To prevent runtime errors caused by the inconsistency between optional-never objects and normal objects.
- To improve the type safety of the language.
What shortcomings exist with current approaches?
- The current approach does not prevent runtime errors caused by the inconsistency between optional-never objects and normal objects.
- The current approach does not improve the type safety of the language.
What workarounds are you using in the meantime?
- Using type guards to check the type of the object before accessing its properties.
- Using the as keyword to cast the object to a specific type.
- Using the in operator to check if a property exists in the object before accessing it.

Introduction

In our previous article, we explored the compatibility between optional-never objects and normal objects in TypeScript. We discussed the implications of introducing stricter type checking for optional never to prevent runtime errors. In this article, we will answer some frequently asked questions about this topic.

🔍 Search Terms

TypeScript type system
Optional-never objects
Normal objects
Type compatibility
Stricter type checking
Runtime errors

Q&A

Q: What is the problem with optional-never objects?

A: The problem with optional-never objects is that they can lead to unintended runtime errors when combined with normal objects. This is because the never type is not compatible with the string type, and attempting to access a property with a never type will result in a runtime error.

Q: Why is the compatibility between optional-never objects and normal objects not a breaking change in existing TypeScript/JavaScript code?

A: The compatibility between optional-never objects and normal objects is not a breaking change in existing TypeScript/JavaScript code because it does not affect the runtime behavior of existing JavaScript code. It only affects the type checking at compile-time.

Q: How can we prevent runtime errors caused by the inconsistency between optional-never objects and normal objects?

A: We can prevent runtime errors caused by the inconsistency between optional-never objects and normal objects by introducing stricter type checking for optional never. This can be achieved by adding a type guard to check the type of the object before accessing its properties.

Q: What are some workarounds for the current approach?

A: Some workarounds for the current approach include:

Using type guards to check the type of the object before accessing its properties.
Using the as keyword to cast the object to a specific type.
Using the in operator to check if a property exists in the object before accessing it.

Q: Why is introducing stricter type checking for optional never not a request to add a new utility type?

A: Introducing stricter type checking for optional never is not a request to add a new utility type because it only affects the type checking at compile-time. It does not add any new functionality to the language.

Q: How does introducing stricter type checking for optional never agree with the rest of our Design Goals?

A: Introducing stricter type checking for optional never agrees with the rest of our Design Goals because it improves the type safety of the language. It prevents runtime errors caused by the inconsistency between optional-never objects and normal objects.

Q: What are some use cases for introducing stricter type checking for optional never?

A: Some use cases for introducing stricter type checking for optional never include:

Preventing runtime errors caused by the inconsistency between optional-never objects and normal objects.
Improving the type safety of the language.
Making the code more maintainable and easier to understand.

Q: How can we implement stricter type checking for optional never?

A: We can implement stricter type checking for optional never by adding a type guard to check the type of the object before accessing its properties. We can also use the as keyword to cast the object to a specific type or use the in operator to check if a property exists in the object before accessing it.

Q: What are some benefits of introducing stricter type checking for optional never?

A: Some benefits of introducing stricter type checking for optional never include:

Preventing runtime errors caused by the inconsistency between optional-never objects and normal objects.
Improving the type safety of the language.
Making the code more maintainable and easier to understand.

Q: What are some challenges of introducing stricter type checking for optional never?

A: Some challenges of introducing stricter type checking for optional never include:

Adding complexity to the type system.
Requiring developers to use type guards or casting to access properties of optional-never objects.
Potentially breaking existing code that relies on the current behavior.

Q: How can we balance the benefits and challenges of introducing stricter type checking for optional never?

A: We can balance the benefits and challenges of introducing stricter type checking for optional never by:

Adding type guards or casting to access properties of optional-never objects.
Using the in operator to check if a property exists in the object before accessing it.
Providing clear documentation and guidance on how to use the new feature.

Q: What is the future of introducing stricter type checking for optional never?

A: The future of introducing stricter type checking for optional never is uncertain. However, it is likely that the feature will be implemented in a future version of TypeScript, and it will provide a more robust and maintainable type system.