diff --git a/BUILD.bazel b/BUILD.bazel
index 9cd6d3ca60..f45ec37ba2 100644
--- a/BUILD.bazel
+++ b/BUILD.bazel
@@ -923,8 +923,6 @@ filegroup(
 filegroup(
     name = "torque_base_files",
     srcs = [
-        "src/numbers/integer-literal-inl.h",
-        "src/numbers/integer-literal.h",
         "src/torque/ast.h",
         "src/torque/cc-generator.cc",
         "src/torque/cc-generator.h",
@@ -2803,8 +2801,6 @@ filegroup(
         "src/interpreter/interpreter-generator.h",
         "src/interpreter/interpreter-intrinsics-generator.cc",
         "src/interpreter/interpreter-intrinsics-generator.h",
-        "src/numbers/integer-literal-inl.h",
-        "src/numbers/integer-literal.h",
     ] + select({
         "@v8//bazel/config:v8_target_ia32": ["src/builtins/ia32/builtins-ia32.cc"],
         "@v8//bazel/config:v8_target_x64": ["src/builtins/x64/builtins-x64.cc"],
diff --git a/BUILD.gn b/BUILD.gn
index a9294fa158..9a80fae541 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -2364,8 +2364,6 @@ v8_source_set("v8_initializers") {
     "src/interpreter/interpreter-generator.h",
     "src/interpreter/interpreter-intrinsics-generator.cc",
     "src/interpreter/interpreter-intrinsics-generator.h",
-    "src/numbers/integer-literal-inl.h",
-    "src/numbers/integer-literal.h",
   ]
 
   if (v8_enable_webassembly) {
@@ -4857,8 +4855,6 @@ v8_source_set("torque_base") {
   visibility = [ ":*" ]  # Only targets in this file can depend on this.
 
   sources = [
-    "src/numbers/integer-literal-inl.h",
-    "src/numbers/integer-literal.h",
     "src/torque/ast.h",
     "src/torque/cc-generator.cc",
     "src/torque/cc-generator.h",
diff --git a/src/bigint/bigint.h b/src/bigint/bigint.h
index f366952762..300229c97d 100644
--- a/src/bigint/bigint.h
+++ b/src/bigint/bigint.h
@@ -301,10 +301,6 @@ class Processor {
   // Z := the contents of {accumulator}.
   // Assume that this leaves {accumulator} in unusable state.
   Status FromString(RWDigits Z, FromStringAccumulator* accumulator);
-
- protected:
-  // Use {Destroy} or {Destroyer} instead of the destructor directly.
-  ~Processor() = default;
 };
 
 inline int AddResultLength(int x_length, int y_length) {
@@ -422,13 +418,13 @@ class FromStringAccumulator {
       : max_digits_(std::max(max_digits, kStackParts)) {}
 
   // Step 2: Call this method to read all characters.
-  // {CharIt} should be a forward iterator and
-  // std::iterator_traits<CharIt>::value_type shall be a character type, such as
-  // uint8_t or uint16_t. {end} should be one past the last character (i.e.
-  // {start == end} would indicate an empty string). Returns the current
-  // position when an invalid character is encountered.
-  template <class CharIt>
-  ALWAYS_INLINE CharIt Parse(CharIt start, CharIt end, digit_t radix);
+  // {Char} should be a character type, such as uint8_t or uint16_t.
+  // {end} should be one past the last character (i.e. {start == end} would
+  // indicate an empty string).
+  // Returns the current position when an invalid character is encountered.
+  template <class Char>
+  ALWAYS_INLINE const Char* Parse(const Char* start, const Char* end,
+                                  digit_t radix);
 
   // Step 3: Check if a result is available, and determine its required
   // allocation size (guaranteed to be <= max_digits passed to the constructor).
@@ -438,13 +434,14 @@ class FromStringAccumulator {
   }
 
   // Step 4: Use BigIntProcessor::FromString() to retrieve the result into an
-  // {RWDigits} struct allocated for the size returned by step 3.
+  // {RWDigits} struct allocated for the size returned by step 2.
 
  private:
   friend class ProcessorImpl;
 
-  template <class CharIt>
-  ALWAYS_INLINE CharIt ParsePowerTwo(CharIt start, CharIt end, digit_t radix);
+  template <class Char>
+  ALWAYS_INLINE const Char* ParsePowerTwo(const Char* start, const Char* end,
+                                          digit_t radix);
 
   ALWAYS_INLINE bool AddPart(digit_t multiplier, digit_t part, bool is_last);
   ALWAYS_INLINE bool AddPart(digit_t part);
@@ -494,9 +491,10 @@ static constexpr uint8_t kCharValue[] = {
 // A space- and time-efficient way to map {2,4,8,16,32} to {1,2,3,4,5}.
 static constexpr uint8_t kCharBits[] = {1, 2, 3, 0, 4, 0, 0, 0, 5};
 
-template <class CharIt>
-CharIt FromStringAccumulator::ParsePowerTwo(CharIt current, CharIt end,
-                                            digit_t radix) {
+template <class Char>
+const Char* FromStringAccumulator::ParsePowerTwo(const Char* current,
+                                                 const Char* end,
+                                                 digit_t radix) {
   radix_ = static_cast<uint8_t>(radix);
   const int char_bits = kCharBits[radix >> 2];
   int bits_left;
@@ -530,10 +528,11 @@ CharIt FromStringAccumulator::ParsePowerTwo(CharIt current, CharIt end,
   return current;
 }
 
-template <class CharIt>
-CharIt FromStringAccumulator::Parse(CharIt start, CharIt end, digit_t radix) {
+template <class Char>
+const Char* FromStringAccumulator::Parse(const Char* start, const Char* end,
+                                         digit_t radix) {
   BIGINT_H_DCHECK(2 <= radix && radix <= 36);
-  CharIt current = start;
+  const Char* current = start;
 #if !HAVE_BUILTIN_MUL_OVERFLOW
   const digit_t kMaxMultiplier = (~digit_t{0}) / radix;
 #endif
diff --git a/src/bigint/tostring.cc b/src/bigint/tostring.cc
index 3f1a277c3d..0447ce0c22 100644
--- a/src/bigint/tostring.cc
+++ b/src/bigint/tostring.cc
@@ -127,7 +127,6 @@ class ToStringFormatter {
         out_end_(out + chars_available),
         out_(out_end_),
         processor_(processor) {
-    digits_.Normalize();
     DCHECK(chars_available >= ToStringResultLength(digits_, radix_, sign_));
   }
 
diff --git a/src/builtins/array-join.tq b/src/builtins/array-join.tq
index c88a0c2800..b87827442f 100644
--- a/src/builtins/array-join.tq
+++ b/src/builtins/array-join.tq
@@ -548,7 +548,7 @@ macro JoinStackPopInline(implicit context: Context)(receiver: JSReceiver):
   // Builtin call was not nested (receiver is the first entry) and
   // did not contain other nested arrays that expanded the stack.
   if (stack.objects[0] == receiver && len == kMinJoinStackSize) {
-    stack.objects[0] = TheHole;
+    StoreFixedArrayElement(stack, 0, TheHole, SKIP_WRITE_BARRIER);
   } else
     deferred {
       JoinStackPop(stack, receiver);
diff --git a/src/builtins/base.tq b/src/builtins/base.tq
index bdeac88b67..00d21c1470 100644
--- a/src/builtins/base.tq
+++ b/src/builtins/base.tq
@@ -27,8 +27,6 @@
 type void;
 type never;
 
-type IntegerLiteral constexpr 'IntegerLiteral';
-
 type Tagged generates 'TNode<MaybeObject>' constexpr 'MaybeObject';
 type StrongTagged extends Tagged
     generates 'TNode<Object>' constexpr 'Object';
@@ -615,7 +613,7 @@ transitioning macro ToIntegerImpl(implicit context: Context)(input: JSAny):
         if (Float64IsNaN(value)) return SmiConstant(0);
         value = math::Float64Trunc(value);
         // ToInteger normalizes -0 to +0.
-        if (value == 0) return SmiConstant(0);
+        if (value == 0.0) return SmiConstant(0);
         const result = ChangeFloat64ToTagged(value);
         dcheck(IsNumberNormalized(result));
         return result;
@@ -991,38 +989,6 @@ extern operator '==' macro ConstexprInt32Equal(
 extern operator '!=' macro ConstexprInt32NotEqual(
     constexpr int32, constexpr int32): constexpr bool;
 
-// IntegerLiteral overloads
-extern macro ConstexprIntegerLiteralToInt31(constexpr IntegerLiteral):
-    constexpr int31;
-extern macro ConstexprIntegerLiteralToInt32(constexpr IntegerLiteral):
-    constexpr int32;
-extern macro ConstexprIntegerLiteralToUint32(constexpr IntegerLiteral):
-    constexpr uint32;
-extern macro ConstexprIntegerLiteralToUint64(constexpr IntegerLiteral):
-    constexpr uint64;
-extern macro ConstexprIntegerLiteralToIntptr(constexpr IntegerLiteral):
-    constexpr intptr;
-extern macro ConstexprIntegerLiteralToUintptr(constexpr IntegerLiteral):
-    constexpr uintptr;
-extern macro ConstexprIntegerLiteralToInt8(constexpr IntegerLiteral):
-    constexpr int8;
-extern macro ConstexprIntegerLiteralToUint8(constexpr IntegerLiteral):
-    constexpr uint8;
-extern macro ConstexprIntegerLiteralToFloat64(constexpr IntegerLiteral):
-    constexpr float64;
-
-extern operator '==' macro ConstexprIntegerLiteralEqual(
-    constexpr IntegerLiteral, constexpr IntegerLiteral): constexpr bool;
-extern operator '+' macro ConstexprIntegerLiteralAdd(
-    constexpr IntegerLiteral,
-    constexpr IntegerLiteral): constexpr IntegerLiteral;
-extern operator '<<' macro ConstexprIntegerLiteralLeftShift(
-    constexpr IntegerLiteral,
-    constexpr IntegerLiteral): constexpr IntegerLiteral;
-extern operator '|' macro ConstexprIntegerLiteralBitwiseOr(
-    constexpr IntegerLiteral,
-    constexpr IntegerLiteral): constexpr IntegerLiteral;
-
 extern operator '==' macro Word32Equal(int32, int32): bool;
 extern operator '==' macro Word32Equal(uint32, uint32): bool;
 extern operator '!=' macro Word32NotEqual(int32, int32): bool;
@@ -1212,29 +1178,19 @@ extern macro IntPtrConstant(constexpr int32): intptr;
 extern macro Uint16Constant(constexpr uint16): uint16;
 extern macro Int32Constant(constexpr int31): int31;
 extern macro Int32Constant(constexpr int32): int32;
-macro Int32Constant(i: constexpr IntegerLiteral): int32 {
-  return Int32Constant(ConstexprIntegerLiteralToInt32(i));
-}
 extern macro Int64Constant(constexpr int64): int64;
 extern macro Uint64Constant(constexpr uint64): uint64;
 extern macro Float64Constant(constexpr int32): float64;
 extern macro Float64Constant(constexpr float64): float64;
-extern macro Float64Constant(constexpr IntegerLiteral): float64;
 extern macro SmiConstant(constexpr int31): Smi;
 extern macro SmiConstant(constexpr Smi): Smi;
 extern macro SmiConstant(constexpr MessageTemplate): Smi;
 extern macro SmiConstant(constexpr bool): Smi;
 extern macro SmiConstant(constexpr uint32): Smi;
-macro SmiConstant(il: constexpr IntegerLiteral): Smi {
-  return SmiConstant(ConstexprIntegerLiteralToInt31(il));
-}
 extern macro BoolConstant(constexpr bool): bool;
 extern macro StringConstant(constexpr string): String;
 extern macro IntPtrConstant(constexpr ContextSlot): ContextSlot;
 extern macro IntPtrConstant(constexpr intptr): intptr;
-macro IntPtrConstant(il: constexpr IntegerLiteral): intptr {
-  return IntPtrConstant(ConstexprIntegerLiteralToIntptr(il));
-}
 extern macro PointerConstant(constexpr RawPtr): RawPtr;
 extern macro SingleCharacterStringConstant(constexpr string): String;
 extern macro Float64SilenceNaN(float64): float64;
diff --git a/src/builtins/convert.tq b/src/builtins/convert.tq
index 23995e50e3..64c81ca572 100644
--- a/src/builtins/convert.tq
+++ b/src/builtins/convert.tq
@@ -4,59 +4,6 @@
 
 intrinsic %FromConstexpr<To: type, From: type>(b: From): To;
 macro FromConstexpr<To: type, From: type>(o: From): To;
-// Conversions for IntegerLiteral
-FromConstexpr<intptr, constexpr IntegerLiteral>(i: constexpr IntegerLiteral):
-    intptr {
-  return ConstexprIntegerLiteralToIntptr(i);
-}
-FromConstexpr<uintptr, constexpr IntegerLiteral>(i: constexpr IntegerLiteral):
-    uintptr {
-  return ConstexprIntegerLiteralToUintptr(i);
-}
-FromConstexpr<int32, constexpr IntegerLiteral>(i: constexpr IntegerLiteral):
-    int32 {
-  return ConstexprIntegerLiteralToInt32(i);
-}
-FromConstexpr<uint32, constexpr IntegerLiteral>(i: constexpr IntegerLiteral):
-    uint32 {
-  return ConstexprIntegerLiteralToUint32(i);
-}
-FromConstexpr<int31, constexpr IntegerLiteral>(i: constexpr IntegerLiteral):
-    int31 {
-  return ConstexprIntegerLiteralToInt31(i);
-}
-FromConstexpr<int8, constexpr IntegerLiteral>(i: constexpr IntegerLiteral):
-    int8 {
-  return ConstexprIntegerLiteralToInt8(i);
-}
-FromConstexpr<uint8, constexpr IntegerLiteral>(i: constexpr IntegerLiteral):
-    uint8 {
-  return ConstexprIntegerLiteralToUint8(i);
-}
-FromConstexpr<uint64, constexpr IntegerLiteral>(i: constexpr IntegerLiteral):
-    uint64 {
-  return ConstexprIntegerLiteralToUint64(i);
-}
-FromConstexpr<constexpr int31, constexpr IntegerLiteral>(
-    i: constexpr IntegerLiteral): constexpr int31 {
-  return ConstexprIntegerLiteralToInt31(i);
-}
-FromConstexpr<constexpr int32, constexpr IntegerLiteral>(
-    i: constexpr IntegerLiteral): constexpr int32 {
-  return ConstexprIntegerLiteralToInt32(i);
-}
-FromConstexpr<Number, constexpr IntegerLiteral>(i: constexpr IntegerLiteral):
-    Number {
-  return NumberConstant(ConstexprIntegerLiteralToFloat64(i));
-}
-FromConstexpr<Smi, constexpr IntegerLiteral>(i: constexpr IntegerLiteral): Smi {
-  return Convert<Smi>(ConstexprIntegerLiteralToInt31(i));
-}
-FromConstexpr<char8, constexpr IntegerLiteral>(i: constexpr IntegerLiteral):
-    char8 {
-  return %RawDownCast<char8>(FromConstexpr<uint8>(i));
-}
-
 FromConstexpr<int31, constexpr int31>(i: constexpr int31): int31 {
   return %FromConstexpr<int31>(i);
 }
@@ -378,10 +325,6 @@ Convert<intptr, Number>(n: Number): intptr {
 Convert<bint, int32>(v: int32): bint {
   return IntPtrToBInt(Convert<intptr>(v));
 }
-FromConstexpr<float64, constexpr IntegerLiteral>(v: constexpr IntegerLiteral):
-    float64 {
-  return ConstexprIntegerLiteralToFloat64(v);
-}
 extern macro IntPtrToBInt(intptr): bint;
 Convert<bint, intptr>(v: intptr): bint {
   return IntPtrToBInt(v);
diff --git a/src/builtins/number.tq b/src/builtins/number.tq
index c68a32c678..4136b9a693 100644
--- a/src/builtins/number.tq
+++ b/src/builtins/number.tq
@@ -90,7 +90,7 @@ macro NumberToStringSmi(x: int32, radix: int32): String labels Slow {
 
   // Calculate length and pre-allocate the result string.
   let temp: int32 = n;
-  let length: int32 = isNegative ? Convert<int32>(1) : Convert<int32>(0);
+  let length: int32 = isNegative ? 1 : 0;
   while (temp > 0) {
     temp = temp / radix;
     length = length + 1;
@@ -277,7 +277,7 @@ transitioning builtin ParseInt(implicit context: Context)(
         // the runtime for the range [0,1[ because the result could be -0.
         const kMaxAbsValue: float64 = 2147483648.0;
         const absInput: float64 = math::Float64Abs(asFloat64);
-        if (absInput < kMaxAbsValue && absInput >= 1.0) goto Int32(asInt32);
+        if (absInput < kMaxAbsValue && absInput >= 1) goto Int32(asInt32);
         goto CallRuntime;
       }
       case (s: String): {
@@ -690,7 +690,7 @@ builtin Negate(implicit context: Context)(value: JSAny): Numeric {
   } label Smi(s: Smi) {
     return SmiMul(s, -1);
   } label HeapNumber(h: HeapNumber) {
-    return AllocateHeapNumberWithValue(Convert<float64>(h) * -1.0);
+    return AllocateHeapNumberWithValue(Convert<float64>(h) * -1);
   } label BigInt(b: BigInt) {
     tail runtime::BigIntUnaryOp(
         context, b, SmiTag<Operation>(Operation::kNegate));
diff --git a/src/builtins/string-repeat.tq b/src/builtins/string-repeat.tq
index 0c2d68861e..b5ced876b7 100644
--- a/src/builtins/string-repeat.tq
+++ b/src/builtins/string-repeat.tq
@@ -55,7 +55,7 @@ transitioning javascript builtin StringPrototypeRepeat(
 
         // 4. If n < 0, throw a RangeError exception.
         // 5. If n is +∞, throw a RangeError exception.
-        if (n == V8_INFINITY || n < 0) goto InvalidCount;
+        if (n == V8_INFINITY || n < 0.0) goto InvalidCount;
 
         // 6. If n is 0, return the empty String.
         if (s.length_uint32 == 0) goto EmptyString;
diff --git a/src/builtins/torque-internal.tq b/src/builtins/torque-internal.tq
index ad21e24ace..8765a7b8ac 100644
--- a/src/builtins/torque-internal.tq
+++ b/src/builtins/torque-internal.tq
@@ -105,10 +105,6 @@ struct Slice<T: type, Reference: type> {
     return this.TryAtIndex(Convert<intptr>(index)) otherwise unreachable;
   }
 
-  macro AtIndex(index: constexpr IntegerLiteral): Reference {
-    return this.AtIndex(FromConstexpr<uintptr>(index));
-  }
-
   macro AtIndex(index: constexpr int31): Reference {
     const i: intptr = Convert<intptr>(index);
     return this.TryAtIndex(i) otherwise unreachable;
diff --git a/src/codegen/code-stub-assembler.cc b/src/codegen/code-stub-assembler.cc
index 01b9bc9b5a..fe1d92e1bc 100644
--- a/src/codegen/code-stub-assembler.cc
+++ b/src/codegen/code-stub-assembler.cc
@@ -17,7 +17,6 @@
 #include "src/heap/heap-inl.h"  // For MemoryChunk. TODO(jkummerow): Drop.
 #include "src/heap/memory-chunk.h"
 #include "src/logging/counters.h"
-#include "src/numbers/integer-literal-inl.h"
 #include "src/objects/api-callbacks.h"
 #include "src/objects/cell.h"
 #include "src/objects/descriptor-array.h"
@@ -14886,19 +14885,6 @@ void CodeStubAssembler::Print(const char* prefix,
   CallRuntime(Runtime::kDebugPrint, NoContextConstant(), arg);
 }
 
-IntegerLiteral CodeStubAssembler::ConstexprIntegerLiteralAdd(
-    const IntegerLiteral& lhs, const IntegerLiteral& rhs) {
-  return lhs + rhs;
-}
-IntegerLiteral CodeStubAssembler::ConstexprIntegerLiteralLeftShift(
-    const IntegerLiteral& lhs, const IntegerLiteral& rhs) {
-  return lhs << rhs;
-}
-IntegerLiteral CodeStubAssembler::ConstexprIntegerLiteralBitwiseOr(
-    const IntegerLiteral& lhs, const IntegerLiteral& rhs) {
-  return lhs | rhs;
-}
-
 void CodeStubAssembler::PerformStackCheck(TNode<Context> context) {
   Label ok(this), stack_check_interrupt(this, Label::kDeferred);
 
diff --git a/src/codegen/code-stub-assembler.h b/src/codegen/code-stub-assembler.h
index 19b124d274..986495cba4 100644
--- a/src/codegen/code-stub-assembler.h
+++ b/src/codegen/code-stub-assembler.h
@@ -13,7 +13,6 @@
 #include "src/common/globals.h"
 #include "src/common/message-template.h"
 #include "src/compiler/code-assembler.h"
-#include "src/numbers/integer-literal.h"
 #include "src/objects/arguments.h"
 #include "src/objects/bigint.h"
 #include "src/objects/cell.h"
@@ -3775,45 +3774,6 @@ class V8_EXPORT_PRIVATE CodeStubAssembler
   }
 
   bool ConstexprBoolNot(bool value) { return !value; }
-  int31_t ConstexprIntegerLiteralToInt31(const IntegerLiteral& i) {
-    return int31_t(i.To<int32_t>());
-  }
-  int32_t ConstexprIntegerLiteralToInt32(const IntegerLiteral& i) {
-    return i.To<int32_t>();
-  }
-  uint32_t ConstexprIntegerLiteralToUint32(const IntegerLiteral& i) {
-    return i.To<uint32_t>();
-  }
-  int8_t ConstexprIntegerLiteralToInt8(const IntegerLiteral& i) {
-    return i.To<int8_t>();
-  }
-  uint8_t ConstexprIntegerLiteralToUint8(const IntegerLiteral& i) {
-    return i.To<uint8_t>();
-  }
-  uint64_t ConstexprIntegerLiteralToUint64(const IntegerLiteral& i) {
-    return i.To<uint64_t>();
-  }
-  intptr_t ConstexprIntegerLiteralToIntptr(const IntegerLiteral& i) {
-    return i.To<intptr_t>();
-  }
-  uintptr_t ConstexprIntegerLiteralToUintptr(const IntegerLiteral& i) {
-    return i.To<uintptr_t>();
-  }
-  double ConstexprIntegerLiteralToFloat64(const IntegerLiteral& i) {
-    int64_t i_value = i.To<int64_t>();
-    double d_value = static_cast<double>(i_value);
-    CHECK_EQ(i_value, static_cast<int64_t>(d_value));
-    return d_value;
-  }
-  bool ConstexprIntegerLiteralEqual(IntegerLiteral lhs, IntegerLiteral rhs) {
-    return lhs == rhs;
-  }
-  IntegerLiteral ConstexprIntegerLiteralAdd(const IntegerLiteral& lhs,
-                                            const IntegerLiteral& rhs);
-  IntegerLiteral ConstexprIntegerLiteralLeftShift(const IntegerLiteral& lhs,
-                                                  const IntegerLiteral& rhs);
-  IntegerLiteral ConstexprIntegerLiteralBitwiseOr(const IntegerLiteral& lhs,
-                                                  const IntegerLiteral& rhs);
 
   bool ConstexprInt31Equal(int31_t a, int31_t b) { return a == b; }
   bool ConstexprInt31NotEqual(int31_t a, int31_t b) { return a != b; }
diff --git a/src/numbers/integer-literal-inl.h b/src/numbers/integer-literal-inl.h
deleted file mode 100644
index 561f9880de..0000000000
--- a/src/numbers/integer-literal-inl.h
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright 2022 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef V8_NUMBERS_INTEGER_LITERAL_INL_H_
-#define V8_NUMBERS_INTEGER_LITERAL_INL_H_
-
-#include "src/numbers/integer-literal.h"
-
-namespace v8 {
-namespace internal {
-
-inline std::string IntegerLiteral::ToString() const {
-  if (negative_) return std::string("-") + std::to_string(absolute_value_);
-  return std::to_string(absolute_value_);
-}
-
-inline IntegerLiteral operator<<(const IntegerLiteral& x,
-                                 const IntegerLiteral& y) {
-  DCHECK(!y.is_negative());
-  DCHECK_LT(y.absolute_value(), sizeof(uint64_t) * kBitsPerByte);
-  return IntegerLiteral(x.is_negative(), x.absolute_value()
-                                             << y.absolute_value());
-}
-
-inline IntegerLiteral operator+(const IntegerLiteral& x,
-                                const IntegerLiteral& y) {
-  if (x.is_negative() == y.is_negative()) {
-    DCHECK_GE(x.absolute_value() + y.absolute_value(), x.absolute_value());
-    return IntegerLiteral(x.is_negative(),
-                          x.absolute_value() + y.absolute_value());
-  }
-  if (x.absolute_value() >= y.absolute_value()) {
-    return IntegerLiteral(x.is_negative(),
-                          x.absolute_value() - y.absolute_value());
-  }
-  return IntegerLiteral(!x.is_negative(),
-                        y.absolute_value() - x.absolute_value());
-}
-
-}  // namespace internal
-}  // namespace v8
-#endif  // V8_NUMBERS_INTEGER_LITERAL_INL_H_
diff --git a/src/numbers/integer-literal.h b/src/numbers/integer-literal.h
deleted file mode 100644
index 5ac3ae76ee..0000000000
--- a/src/numbers/integer-literal.h
+++ /dev/null
@@ -1,106 +0,0 @@
-// Copyright 2022 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef V8_NUMBERS_INTEGER_LITERAL_H_
-#define V8_NUMBERS_INTEGER_LITERAL_H_
-
-#include "src/base/optional.h"
-#include "src/common/globals.h"
-
-namespace v8 {
-namespace internal {
-
-class IntegerLiteral {
- public:
-  IntegerLiteral(bool negative, uint64_t absolute_value)
-      : negative_(negative), absolute_value_(absolute_value) {
-    if (absolute_value == 0) negative_ = false;
-  }
-
-  template <typename T>
-  explicit IntegerLiteral(T value) : IntegerLiteral(value, true) {}
-
-  bool is_negative() const { return negative_; }
-  uint64_t absolute_value() const { return absolute_value_; }
-
-  template <typename T>
-  bool IsRepresentableAs() const {
-    static_assert(std::is_integral<T>::value, "Integral type required");
-    static_assert(sizeof(T) <= sizeof(uint64_t),
-                  "Types with more than 64 bits are not supported");
-    return Compare(IntegerLiteral(std::numeric_limits<T>::min(), false)) >= 0 &&
-           Compare(IntegerLiteral(std::numeric_limits<T>::max(), false)) <= 0;
-  }
-
-  template <typename T>
-  T To() const {
-    static_assert(std::is_integral<T>::value, "Integral type required");
-    DCHECK(IsRepresentableAs<T>());
-    uint64_t v = absolute_value_;
-    if (negative_) v = ~v + 1;
-    return static_cast<T>(v);
-  }
-
-  template <typename T>
-  base::Optional<T> TryTo() const {
-    static_assert(std::is_integral<T>::value, "Integral type required");
-    if (!IsRepresentableAs<T>()) return base::nullopt;
-    return To<T>();
-  }
-
-  int Compare(const IntegerLiteral& other) const {
-    if (absolute_value_ == other.absolute_value_) {
-      if (absolute_value_ == 0 || negative_ == other.negative_) return 0;
-      return negative_ ? -1 : 1;
-    } else if (absolute_value_ < other.absolute_value_) {
-      return other.negative_ ? 1 : -1;
-    } else {
-      return negative_ ? -1 : 1;
-    }
-  }
-
-  std::string ToString() const;
-
- private:
-  template <typename T>
-  explicit IntegerLiteral(T value, bool perform_dcheck) : negative_(false) {
-    static_assert(std::is_integral<T>::value, "Integral type required");
-    absolute_value_ = static_cast<uint64_t>(value);
-    if (value < T(0)) {
-      negative_ = true;
-      absolute_value_ = ~absolute_value_ + 1;
-    }
-    if (perform_dcheck) DCHECK_EQ(To<T>(), value);
-  }
-
-  bool negative_;
-  uint64_t absolute_value_;
-};
-
-inline bool operator==(const IntegerLiteral& x, const IntegerLiteral& y) {
-  return x.Compare(y) == 0;
-}
-
-inline bool operator!=(const IntegerLiteral& x, const IntegerLiteral& y) {
-  return x.Compare(y) != 0;
-}
-
-inline std::ostream& operator<<(std::ostream& stream,
-                                const IntegerLiteral& literal) {
-  return stream << literal.ToString();
-}
-
-inline IntegerLiteral operator|(const IntegerLiteral& x,
-                                const IntegerLiteral& y) {
-  DCHECK(!x.is_negative());
-  DCHECK(!y.is_negative());
-  return IntegerLiteral(false, x.absolute_value() | y.absolute_value());
-}
-
-IntegerLiteral operator<<(const IntegerLiteral& x, const IntegerLiteral& y);
-IntegerLiteral operator+(const IntegerLiteral& x, const IntegerLiteral& y);
-
-}  // namespace internal
-}  // namespace v8
-#endif  // V8_NUMBERS_INTEGER_LITERAL_H_
diff --git a/src/objects/descriptor-array-inl.h b/src/objects/descriptor-array-inl.h
index 3756fafa33..387ae8d276 100644
--- a/src/objects/descriptor-array-inl.h
+++ b/src/objects/descriptor-array-inl.h
@@ -5,11 +5,12 @@
 #ifndef V8_OBJECTS_DESCRIPTOR_ARRAY_INL_H_
 #define V8_OBJECTS_DESCRIPTOR_ARRAY_INL_H_
 
+#include "src/objects/descriptor-array.h"
+
 #include "src/execution/isolate.h"
 #include "src/handles/maybe-handles-inl.h"
 #include "src/heap/heap-write-barrier.h"
 #include "src/heap/heap.h"
-#include "src/objects/descriptor-array.h"
 #include "src/objects/field-type.h"
 #include "src/objects/heap-object-inl.h"
 #include "src/objects/lookup-cache-inl.h"
diff --git a/src/objects/fixed-array-inl.h b/src/objects/fixed-array-inl.h
index 5dea891511..b9e348f7fd 100644
--- a/src/objects/fixed-array-inl.h
+++ b/src/objects/fixed-array-inl.h
@@ -5,12 +5,13 @@
 #ifndef V8_OBJECTS_FIXED_ARRAY_INL_H_
 #define V8_OBJECTS_FIXED_ARRAY_INL_H_
 
+#include "src/objects/fixed-array.h"
+
 #include "src/handles/handles-inl.h"
 #include "src/heap/heap-write-barrier-inl.h"
 #include "src/numbers/conversions.h"
 #include "src/objects/bigint.h"
 #include "src/objects/compressed-slots.h"
-#include "src/objects/fixed-array.h"
 #include "src/objects/map.h"
 #include "src/objects/maybe-object-inl.h"
 #include "src/objects/objects-inl.h"
diff --git a/src/objects/turbofan-types.tq b/src/objects/turbofan-types.tq
index 147927f61c..f1cab8c491 100644
--- a/src/objects/turbofan-types.tq
+++ b/src/objects/turbofan-types.tq
@@ -80,7 +80,7 @@ class TurbofanOtherNumberConstantType extends TurbofanType {
 }
 
 macro IsMinusZero(x: float64): bool {
-  return x == 0 && 1.0 / x < 0;
+  return x == 0 && 1 / x < 0;
 }
 
 macro TestTurbofanBitsetType(
@@ -94,13 +94,13 @@ macro TestTurbofanBitsetType(
       if (IsInteger(value)) {
         if (IsMinusZero(valueF)) {
           return bitsetLow.minus_zero;
-        } else if (valueF < -0x80000000) {
+        } else if (valueF < Convert<float64>(-0x80000000)) {
           return bitsetLow.other_number;
         } else if (valueF < -0x40000000) {
           return bitsetLow.other_signed32;
         } else if (valueF < 0) {
           return bitsetLow.negative31;
-        } else if (valueF < 0x40000000) {
+        } else if (valueF < Convert<float64>(0x40000000)) {
           return bitsetLow.unsigned30;
         } else if (valueF < 0x80000000) {
           return bitsetLow.other_unsigned31;
diff --git a/src/torque/ast.h b/src/torque/ast.h
index d80993e38f..a4ccefb304 100644
--- a/src/torque/ast.h
+++ b/src/torque/ast.h
@@ -14,7 +14,6 @@
 #include <vector>
 
 #include "src/base/optional.h"
-#include "src/numbers/integer-literal.h"
 #include "src/torque/constants.h"
 #include "src/torque/source-positions.h"
 #include "src/torque/utils.h"
@@ -34,8 +33,7 @@ namespace torque {
   V(ConditionalExpression)               \
   V(IdentifierExpression)                \
   V(StringLiteralExpression)             \
-  V(IntegerLiteralExpression)            \
-  V(FloatingPointLiteralExpression)      \
+  V(NumberLiteralExpression)             \
   V(FieldAccessExpression)               \
   V(ElementAccessExpression)             \
   V(DereferenceExpression)               \
@@ -461,28 +459,16 @@ struct StringLiteralExpression : Expression {
   std::string literal;
 };
 
-struct IntegerLiteralExpression : Expression {
-  DEFINE_AST_NODE_LEAF_BOILERPLATE(IntegerLiteralExpression)
-  IntegerLiteralExpression(SourcePosition pos, IntegerLiteral value)
-      : Expression(kKind, pos), value(std::move(value)) {}
+struct NumberLiteralExpression : Expression {
+  DEFINE_AST_NODE_LEAF_BOILERPLATE(NumberLiteralExpression)
+  NumberLiteralExpression(SourcePosition pos, double number)
+      : Expression(kKind, pos), number(number) {}
 
   void VisitAllSubExpressions(VisitCallback callback) override {
     callback(this);
   }
 
-  IntegerLiteral value;
-};
-
-struct FloatingPointLiteralExpression : Expression {
-  DEFINE_AST_NODE_LEAF_BOILERPLATE(FloatingPointLiteralExpression)
-  FloatingPointLiteralExpression(SourcePosition pos, double value)
-      : Expression(kKind, pos), value(value) {}
-
-  void VisitAllSubExpressions(VisitCallback callback) override {
-    callback(this);
-  }
-
-  double value;
+  double number;
 };
 
 struct ElementAccessExpression : LocationExpression {
diff --git a/src/torque/constants.h b/src/torque/constants.h
index 325c6dea8f..63cddf6e0a 100644
--- a/src/torque/constants.h
+++ b/src/torque/constants.h
@@ -67,8 +67,6 @@ static const char* const FLOAT64_OR_HOLE_TYPE_STRING = "float64_or_hole";
 static const char* const CONST_INT31_TYPE_STRING = "constexpr int31";
 static const char* const CONST_INT32_TYPE_STRING = "constexpr int32";
 static const char* const CONST_FLOAT64_TYPE_STRING = "constexpr float64";
-static const char* const INTEGER_LITERAL_TYPE_STRING =
-    "constexpr IntegerLiteral";
 static const char* const TORQUE_INTERNAL_NAMESPACE_STRING = "torque_internal";
 static const char* const MUTABLE_REFERENCE_TYPE_STRING = "MutableReference";
 static const char* const CONST_REFERENCE_TYPE_STRING = "ConstReference";
diff --git a/src/torque/earley-parser.cc b/src/torque/earley-parser.cc
index adb7e77153..f99424b1a6 100644
--- a/src/torque/earley-parser.cc
+++ b/src/torque/earley-parser.cc
@@ -127,7 +127,6 @@ LexerResult Lexer::RunLexer(const std::string& input) {
   while (pos != end) {
     token_start = pos;
     Symbol* symbol = MatchToken(&pos, end);
-    DCHECK_IMPLIES(symbol != nullptr, pos != token_start);
     InputPosition token_end = pos;
     line_column_tracker.Advance(token_start, token_end);
     if (!symbol) {
diff --git a/src/torque/earley-parser.h b/src/torque/earley-parser.h
index 6be44a619b..bca3cf5fb1 100644
--- a/src/torque/earley-parser.h
+++ b/src/torque/earley-parser.h
@@ -44,8 +44,6 @@ enum class ParseResultHolderBase::TypeId {
   kStdString,
   kBool,
   kInt32,
-  kDouble,
-  kIntegerLiteral,
   kStdVectorOfString,
   kExpressionPtr,
   kIdentifierPtr,
diff --git a/src/torque/implementation-visitor.cc b/src/torque/implementation-visitor.cc
index f8d3e20ebd..5c7c689650 100644
--- a/src/torque/implementation-visitor.cc
+++ b/src/torque/implementation-visitor.cc
@@ -10,7 +10,6 @@
 
 #include "src/base/optional.h"
 #include "src/common/globals.h"
-#include "src/numbers/integer-literal-inl.h"
 #include "src/torque/cc-generator.h"
 #include "src/torque/cfg.h"
 #include "src/torque/constants.h"
@@ -183,7 +182,6 @@ void ImplementationVisitor::BeginDebugMacrosFile() {
   header << "#ifndef " << kHeaderDefine << "\n";
   header << "#define " << kHeaderDefine << "\n\n";
   header << "#include \"tools/debug_helper/debug-helper-internal.h\"\n";
-  header << "#include \"src/numbers/integer-literal.h\"\n";
   header << "\n";
 
   header << "namespace v8 {\n"
@@ -945,18 +943,22 @@ VisitResult ImplementationVisitor::Visit(AssignmentExpression* expr) {
   return scope.Yield(assignment_value);
 }
 
-VisitResult ImplementationVisitor::Visit(FloatingPointLiteralExpression* expr) {
+VisitResult ImplementationVisitor::Visit(NumberLiteralExpression* expr) {
   const Type* result_type = TypeOracle::GetConstFloat64Type();
+  if (expr->number >= std::numeric_limits<int32_t>::min() &&
+      expr->number <= std::numeric_limits<int32_t>::max()) {
+    int32_t i = static_cast<int32_t>(expr->number);
+    if (i == expr->number) {
+      if ((i >> 30) == (i >> 31)) {
+        result_type = TypeOracle::GetConstInt31Type();
+      } else {
+        result_type = TypeOracle::GetConstInt32Type();
+      }
+    }
+  }
   std::stringstream str;
   str << std::setprecision(std::numeric_limits<double>::digits10 + 1)
-      << expr->value;
-  return VisitResult{result_type, str.str()};
-}
-
-VisitResult ImplementationVisitor::Visit(IntegerLiteralExpression* expr) {
-  const Type* result_type = TypeOracle::GetIntegerLiteralType();
-  std::stringstream str;
-  str << "IntegerLiteral(" << expr->value << ")";
+      << expr->number;
   return VisitResult{result_type, str.str()};
 }
 
@@ -2846,9 +2848,7 @@ VisitResult ImplementationVisitor::GenerateCall(
     // If we're currently generating a C++ macro and it's calling another macro,
     // then we need to make sure that we also generate C++ code for the called
     // macro within the same -inl.inc file.
-    if ((output_type_ == OutputType::kCC ||
-         output_type_ == OutputType::kCCDebug) &&
-        !inline_macro) {
+    if (output_type_ == OutputType::kCC && !inline_macro) {
       if (auto* torque_macro = TorqueMacro::DynamicCast(macro)) {
         auto* streams = CurrentFileStreams::Get();
         SourceId file = streams ? streams->file : SourceId::Invalid();
@@ -2862,32 +2862,14 @@ VisitResult ImplementationVisitor::GenerateCall(
       std::stringstream result;
       result << "(";
       bool first = true;
-      switch (output_type_) {
-        case OutputType::kCSA: {
-          if (auto* extern_macro = ExternMacro::DynamicCast(macro)) {
-            result << extern_macro->external_assembler_name() << "(state_)."
-                   << extern_macro->ExternalName() << "(";
-          } else {
-            result << macro->ExternalName() << "(state_";
-            first = false;
-          }
-          break;
-        }
-        case OutputType::kCC: {
-          auto* extern_macro = ExternMacro::DynamicCast(macro);
-          CHECK_NOT_NULL(extern_macro);
-          result << extern_macro->CCName() << "(";
-          break;
-        }
-        case OutputType::kCCDebug: {
-          auto* extern_macro = ExternMacro::DynamicCast(macro);
-          CHECK_NOT_NULL(extern_macro);
-          result << extern_macro->CCDebugName() << "(accessor";
-          first = false;
-          break;
-        }
+      if (auto* extern_macro = ExternMacro::DynamicCast(macro)) {
+        result << extern_macro->external_assembler_name() << "(state_)."
+               << extern_macro->ExternalName() << "(";
+      } else {
+        result << macro->ExternalName() << "(state_";
+        first = false;
       }
-      for (VisitResult arg : converted_arguments) {
+      for (VisitResult arg : arguments.parameters) {
         DCHECK(!arg.IsOnStack());
         if (!first) {
           result << ", ";
diff --git a/src/torque/implementation-visitor.h b/src/torque/implementation-visitor.h
index 36c9ca452e..8ebb72cc2e 100644
--- a/src/torque/implementation-visitor.h
+++ b/src/torque/implementation-visitor.h
@@ -555,8 +555,7 @@ class ImplementationVisitor {
   VisitResult Visit(IncrementDecrementExpression* expr);
   VisitResult Visit(AssignmentExpression* expr);
   VisitResult Visit(StringLiteralExpression* expr);
-  VisitResult Visit(FloatingPointLiteralExpression* expr);
-  VisitResult Visit(IntegerLiteralExpression* expr);
+  VisitResult Visit(NumberLiteralExpression* expr);
   VisitResult Visit(AssumeTypeImpossibleExpression* expr);
   VisitResult Visit(TryLabelExpression* expr);
   VisitResult Visit(StatementExpression* expr);
diff --git a/src/torque/runtime-macro-shims.h b/src/torque/runtime-macro-shims.h
index fe20a4052d..294cea6a5d 100644
--- a/src/torque/runtime-macro-shims.h
+++ b/src/torque/runtime-macro-shims.h
@@ -10,8 +10,6 @@
 
 #include <cstdint>
 
-#include "src/numbers/integer-literal.h"
-
 namespace v8 {
 namespace internal {
 
@@ -37,15 +35,6 @@ inline uintptr_t Unsigned(intptr_t s) { return static_cast<uintptr_t>(s); }
 #endif
 inline bool Word32Equal(uint32_t a, uint32_t b) { return a == b; }
 inline bool Word32NotEqual(uint32_t a, uint32_t b) { return a != b; }
-inline int32_t ConstexprIntegerLiteralToInt32(const IntegerLiteral& i) {
-  return i.To<int32_t>();
-}
-inline int31_t ConstexprIntegerLiteralToInt31(const IntegerLiteral& i) {
-  return int31_t(ConstexprIntegerLiteralToInt32(i));
-}
-inline intptr_t ConstexprIntegerLiteralToIntptr(const IntegerLiteral& i) {
-  return i.To<intptr_t>();
-}
 
 }  // namespace CodeStubAssembler
 }  // namespace TorqueRuntimeMacroShims
diff --git a/src/torque/torque-parser.cc b/src/torque/torque-parser.cc
index 4df9e36102..a2dfa43e6a 100644
--- a/src/torque/torque-parser.cc
+++ b/src/torque/torque-parser.cc
@@ -92,12 +92,6 @@ template <>
 V8_EXPORT_PRIVATE const ParseResultTypeId ParseResultHolder<int32_t>::id =
     ParseResultTypeId::kInt32;
 template <>
-V8_EXPORT_PRIVATE const ParseResultTypeId ParseResultHolder<double>::id =
-    ParseResultTypeId::kDouble;
-template <>
-V8_EXPORT_PRIVATE const ParseResultTypeId
-    ParseResultHolder<IntegerLiteral>::id = ParseResultTypeId::kIntegerLiteral;
-template <>
 V8_EXPORT_PRIVATE const ParseResultTypeId
     ParseResultHolder<std::vector<std::string>>::id =
         ParseResultTypeId::kStdVectorOfString;
@@ -871,8 +865,8 @@ bool ProcessIfAnnotation(ParseResultIterator* child_results) {
   return true;
 }
 
-base::Optional<ParseResult> YieldInt32(ParseResultIterator* child_results) {
-  std::string value = child_results->matched_input().ToString();
+base::Optional<ParseResult> MakeInt32(ParseResultIterator* child_results) {
+  std::string value = child_results->NextAs<std::string>();
   size_t num_chars_converted = 0;
   int result = 0;
   try {
@@ -889,43 +883,6 @@ base::Optional<ParseResult> YieldInt32(ParseResultIterator* child_results) {
   return ParseResult{result};
 }
 
-base::Optional<ParseResult> YieldDouble(ParseResultIterator* child_results) {
-  std::string value = child_results->matched_input().ToString();
-  size_t num_chars_converted = 0;
-  double result = 0;
-  try {
-    result = std::stod(value, &num_chars_converted);
-  } catch (const std::out_of_range&) {
-    Error("double literal out-of-range");
-    return ParseResult{result};
-  }
-  // Tokenizer shouldn't have included extra trailing characters.
-  DCHECK_EQ(num_chars_converted, value.size());
-  return ParseResult{result};
-}
-
-base::Optional<ParseResult> YieldIntegerLiteral(
-    ParseResultIterator* child_results) {
-  std::string value = child_results->matched_input().ToString();
-  // Consume a leading minus.
-  bool negative = false;
-  if (value.size() > 0 && value[0] == '-') {
-    negative = true;
-    value = value.substr(1);
-  }
-  uint64_t absolute_value;
-  try {
-    size_t parsed = 0;
-    absolute_value = std::stoull(value, &parsed, 0);
-    DCHECK_EQ(parsed, value.size());
-  } catch (const std::invalid_argument&) {
-    Error("integer literal could not be parsed").Throw();
-  } catch (const std::out_of_range&) {
-    Error("integer literal value out of range").Throw();
-  }
-  return ParseResult(IntegerLiteral(negative, absolute_value));
-}
-
 base::Optional<ParseResult> MakeStringAnnotationParameter(
     ParseResultIterator* child_results) {
   std::string value = child_results->NextAs<std::string>();
@@ -1946,17 +1903,29 @@ base::Optional<ParseResult> MakeAssignmentExpression(
   return ParseResult{result};
 }
 
-base::Optional<ParseResult> MakeFloatingPointLiteralExpression(
+base::Optional<ParseResult> MakeNumberLiteralExpression(
     ParseResultIterator* child_results) {
-  auto value = child_results->NextAs<double>();
-  Expression* result = MakeNode<FloatingPointLiteralExpression>(value);
-  return ParseResult{result};
-}
-
-base::Optional<ParseResult> MakeIntegerLiteralExpression(
-    ParseResultIterator* child_results) {
-  auto value = child_results->NextAs<IntegerLiteral>();
-  Expression* result = MakeNode<IntegerLiteralExpression>(std::move(value));
+  auto number = child_results->NextAs<std::string>();
+  // TODO(turbofan): Support 64bit literals.
+  // Meanwhile, we type it as constexpr float64 when out of int32 range.
+  double value = 0;
+  try {
+#if defined(V8_OS_SOLARIS)
+    // stod() on Solaris does not currently support hex strings. Use strtol()
+    // specifically for hex literals until stod() support is available.
+    if (number.find("0x") == std::string::npos &&
+        number.find("0X") == std::string::npos) {
+      value = std::stod(number);
+    } else {
+      value = static_cast<double>(strtol(number.c_str(), nullptr, 0));
+    }
+#else
+    value = std::stod(number);
+#endif  // !defined(V8_OS_SOLARIS)
+  } catch (const std::out_of_range&) {
+    Error("double literal out-of-range").Throw();
+  }
+  Expression* result = MakeNode<NumberLiteralExpression>(value);
   return ParseResult{result};
 }
 
@@ -2116,19 +2085,8 @@ base::Optional<ParseResult> MakeClassField(ParseResultIterator* child_results) {
       // Internally, an optional field is just an indexed field where the count
       // is zero or one.
       index = MakeNode<ConditionalExpression>(
-          *index,
-          MakeCall(
-              MakeNode<Identifier>("FromConstexpr"),
-              {MakeNode<BasicTypeExpression>(std::vector<std::string>{},
-                                             MakeNode<Identifier>("intptr"),
-                                             std::vector<TypeExpression*>{})},
-              {MakeNode<IntegerLiteralExpression>(IntegerLiteral(1))}, {}),
-          MakeCall(
-              MakeNode<Identifier>("FromConstexpr"),
-              {MakeNode<BasicTypeExpression>(std::vector<std::string>{},
-                                             MakeNode<Identifier>("intptr"),
-                                             std::vector<TypeExpression*>{})},
-              {MakeNode<IntegerLiteralExpression>(IntegerLiteral(0))}, {}));
+          *index, MakeNode<NumberLiteralExpression>(1),
+          MakeNode<NumberLiteralExpression>(0));
     }
     index_info = ClassFieldIndexInfo{*index, optional};
   }
@@ -2247,24 +2205,12 @@ struct TorqueGrammar : Grammar {
     return false;
   }
 
-  static bool MatchIntegerLiteral(InputPosition* pos) {
+  static bool MatchDecimalLiteral(InputPosition* pos) {
     InputPosition current = *pos;
     bool found_digit = false;
     MatchString("-", &current);
     while (MatchChar(std::isdigit, &current)) found_digit = true;
-    if (found_digit) {
-      *pos = current;
-      return true;
-    }
-    return false;
-  }
-
-  static bool MatchFloatingPointLiteral(InputPosition* pos) {
-    InputPosition current = *pos;
-    bool found_digit = false;
-    MatchString("-", &current);
-    while (MatchChar(std::isdigit, &current)) found_digit = true;
-    if (!MatchString(".", &current)) return false;
+    MatchString(".", &current);
     while (MatchChar(std::isdigit, &current)) found_digit = true;
     if (!found_digit) return false;
     *pos = current;
@@ -2338,18 +2284,13 @@ struct TorqueGrammar : Grammar {
   // Result: std::string
   Symbol externalString = {Rule({&stringLiteral}, StringLiteralUnquoteAction)};
 
-  // Result: IntegerLiteral
-  Symbol integerLiteral = {
-      Rule({Pattern(MatchIntegerLiteral)}, YieldIntegerLiteral),
-      Rule({Pattern(MatchHexLiteral)}, YieldIntegerLiteral)};
-
-  // Result: double
-  Symbol floatingPointLiteral = {
-      Rule({Pattern(MatchFloatingPointLiteral)}, YieldDouble)};
+  // Result: std::string
+  Symbol decimalLiteral = {
+      Rule({Pattern(MatchDecimalLiteral)}, YieldMatchedInput),
+      Rule({Pattern(MatchHexLiteral)}, YieldMatchedInput)};
 
   // Result: int32_t
-  Symbol int32Literal = {Rule({Pattern(MatchIntegerLiteral)}, YieldInt32),
-                         Rule({Pattern(MatchHexLiteral)}, YieldInt32)};
+  Symbol int32Literal = {Rule({&decimalLiteral}, MakeInt32)};
 
   // Result: AnnotationParameter
   Symbol annotationParameter = {
@@ -2568,8 +2509,7 @@ struct TorqueGrammar : Grammar {
            MakeReferenceFieldAccessExpression),
       Rule({&primaryExpression, Token("["), expression, Token("]")},
            MakeElementAccessExpression),
-      Rule({&integerLiteral}, MakeIntegerLiteralExpression),
-      Rule({&floatingPointLiteral}, MakeFloatingPointLiteralExpression),
+      Rule({&decimalLiteral}, MakeNumberLiteralExpression),
       Rule({&stringLiteral}, MakeStringLiteralExpression),
       Rule({&simpleType, &initializerList}, MakeStructExpression),
       Rule({&newExpression}),
diff --git a/src/torque/type-oracle.h b/src/torque/type-oracle.h
index 7bcbd6a77b..e184bc0f72 100644
--- a/src/torque/type-oracle.h
+++ b/src/torque/type-oracle.h
@@ -315,10 +315,6 @@ class TypeOracle : public ContextualClass<TypeOracle> {
     return Get().GetBuiltinType(CONST_FLOAT64_TYPE_STRING);
   }
 
-  static const Type* GetIntegerLiteralType() {
-    return Get().GetBuiltinType(INTEGER_LITERAL_TYPE_STRING);
-  }
-
   static const Type* GetNeverType() {
     return Get().GetBuiltinType(NEVER_TYPE_STRING);
   }
diff --git a/src/torque/type-visitor.cc b/src/torque/type-visitor.cc
index 7ca916f4ff..aaae9e559c 100644
--- a/src/torque/type-visitor.cc
+++ b/src/torque/type-visitor.cc
@@ -459,12 +459,12 @@ void TypeVisitor::VisitClassFieldsAndMethods(
                               field_size * ResidueClass::Unknown());
 
       if (auto literal =
-              IntegerLiteralExpression::DynamicCast(field.index->expr)) {
-        if (auto value = literal->value.TryTo<size_t>()) {
-          field_size *= *value;
-        } else {
-          Error("Not a valid field index").Position(field.pos);
+              NumberLiteralExpression::DynamicCast(field.index->expr)) {
+        size_t value = static_cast<size_t>(literal->number);
+        if (value != literal->number) {
+          Error("non-integral array length").Position(field.pos);
         }
+        field_size *= value;
       } else {
         field_size *= ResidueClass::Unknown();
       }
diff --git a/src/torque/types.cc b/src/torque/types.cc
index 9fa92d8723..c69986e407 100644
--- a/src/torque/types.cc
+++ b/src/torque/types.cc
@@ -850,7 +850,7 @@ void ClassType::GenerateSliceAccessor(size_t field_index) {
 
   if (field.offset.has_value()) {
     offset_expression =
-        MakeNode<IntegerLiteralExpression>(IntegerLiteral(*field.offset));
+        MakeNode<NumberLiteralExpression>(static_cast<double>(*field.offset));
   } else {
     const Field* previous = GetFieldPreceding(field_index);
     DCHECK_NOT_NULL(previous);
@@ -879,8 +879,8 @@ void ClassType::GenerateSliceAccessor(size_t field_index) {
     std::tie(previous_element_size, std::ignore) =
         *SizeOf(previous->name_and_type.type);
     Expression* previous_element_size_expression =
-        MakeNode<IntegerLiteralExpression>(
-            IntegerLiteral(previous_element_size));
+        MakeNode<NumberLiteralExpression>(
+            static_cast<double>(previous_element_size));
 
     // previous.length
     Expression* previous_length_expression = MakeFieldAccessExpression(
diff --git a/test/torque/test-torque.tq b/test/torque/test-torque.tq
index 661042399c..0b3be07e3b 100644
--- a/test/torque/test-torque.tq
+++ b/test/torque/test-torque.tq
@@ -196,8 +196,8 @@ macro TestFunctionPointers(implicit context: Context)(): Boolean {
 
 @export
 macro TestVariableRedeclaration(implicit context: Context)(): Boolean {
-  let _var1: int31 = FromConstexpr<bool>(42 == 0) ? FromConstexpr<int31>(0) : 1;
-  let _var2: int31 = FromConstexpr<bool>(42 == 0) ? FromConstexpr<int31>(1) : 0;
+  let _var1: int31 = FromConstexpr<bool>(42 == 0) ? 0 : 1;
+  let _var2: int31 = FromConstexpr<bool>(42 == 0) ? 1 : 0;
   return True;
 }
 
diff --git a/test/unittests/torque/torque-unittest.cc b/test/unittests/torque/torque-unittest.cc
index 5299766823..f6a3eef8e1 100644
--- a/test/unittests/torque/torque-unittest.cc
+++ b/test/unittests/torque/torque-unittest.cc
@@ -20,8 +20,6 @@ constexpr const char* kTestTorquePrelude = R"(
 type void;
 type never;
 
-type IntegerLiteral constexpr 'IntegerLiteral';
-
 namespace torque_internal {
   struct Reference<T: type> {
     const object: HeapObject;
@@ -114,8 +112,6 @@ extern macro TaggedToHeapObject(Object): HeapObject
 extern macro Float64SilenceNaN(float64): float64;
 
 extern macro IntPtrConstant(constexpr int31): intptr;
-extern macro ConstexprIntegerLiteralToInt32(constexpr IntegerLiteral): constexpr int32;
-extern macro SmiFromInt32(int32): Smi;
 
 macro FromConstexpr<To: type, From: type>(o: From): To;
 FromConstexpr<Smi, constexpr Smi>(s: constexpr Smi): Smi {
@@ -137,15 +133,6 @@ FromConstexpr<bool, constexpr bool>(b: constexpr bool): bool {
 FromConstexpr<int32, constexpr int31>(i: constexpr int31): int32 {
   return %FromConstexpr<int32>(i);
 }
-FromConstexpr<int32, constexpr int32>(i: constexpr int32): int32 {
-  return %FromConstexpr<int32>(i);
-}
-FromConstexpr<int32, constexpr IntegerLiteral>(i: constexpr IntegerLiteral): int32 {
-  return FromConstexpr<int32>(ConstexprIntegerLiteralToInt32(i));
-}
-FromConstexpr<Smi, constexpr IntegerLiteral>(i: constexpr IntegerLiteral): Smi {
-  return SmiFromInt32(FromConstexpr<int32>(i));
-}
 
 macro Cast<A : type extends Object>(implicit context: Context)(o: Object): A
     labels CastError {
diff --git a/tools/debug_helper/debug-macro-shims.h b/tools/debug_helper/debug-macro-shims.h
index 02deb3d766..04ca1467a5 100644
--- a/tools/debug_helper/debug-macro-shims.h
+++ b/tools/debug_helper/debug-macro-shims.h
@@ -8,7 +8,6 @@
 #ifndef V8_TORQUE_DEBUG_MACRO_SHIMS_H_
 #define V8_TORQUE_DEBUG_MACRO_SHIMS_H_
 
-#include "src/numbers/integer-literal.h"
 #include "src/objects/smi.h"
 #include "tools/debug_helper/debug-helper-internal.h"
 
@@ -82,9 +81,6 @@ inline Value<int32_t> SmiUntag(d::MemoryAccessor accessor, uintptr_t s_t) {
   Smi s(s_t);
   return {d::MemoryAccessResult::kOk, s.value()};
 }
-inline Value<uintptr_t> SmiFromInt32(d::MemoryAccessor accessor, int32_t i) {
-  return {d::MemoryAccessResult::kOk, Smi::FromInt(i).ptr()};
-}
 inline Value<bool> UintPtrLessThan(d::MemoryAccessor accessor, uintptr_t a,
                                    uintptr_t b) {
   return {d::MemoryAccessResult::kOk, a < b};
@@ -105,19 +101,6 @@ inline Value<bool> Word32NotEqual(d::MemoryAccessor accessor, uint32_t a,
                                   uint32_t b) {
   return {d::MemoryAccessResult::kOk, a != b};
 }
-// This is used in a nested call where we cannot pass Value<int32_t>.
-inline int31_t ConstexprIntegerLiteralToInt31(d::MemoryAccessor accessor,
-                                              const IntegerLiteral& i) {
-  return i.To<int32_t>();
-}
-inline int32_t ConstexprIntegerLiteralToInt32(d::MemoryAccessor accessor,
-                                              const IntegerLiteral& i) {
-  return i.To<int32_t>();
-}
-inline intptr_t ConstexprIntegerLiteralToIntptr(d::MemoryAccessor accessor,
-                                                const IntegerLiteral& i) {
-  return i.To<intptr_t>();
-}
 
 }  // namespace CodeStubAssembler
 }  // namespace TorqueDebugMacroShims