From 5482bbcbed22b856bec6e57c06aeb7e0bee9a1ab Mon Sep 17 00:00:00 2001
From: tserg <8017125+tserg@users.noreply.github.com>
Date: Wed, 18 Oct 2023 00:26:56 +0800
Subject: [PATCH] feat: remove builtin constants (#3350)

Builtin constants like `MAX_INT128`, `MIN_INT128`, `MIN_DECIMAL`,
`MAX_DECIMAL` and `MAX_UINT256` have been deprecated since v0.3.4 with
the introduction of the `min_value` and `max_value` builtins, and
further back for `ZERO_ADDRESS` and `EMPTY_BYTES32` with the `empty`
builtin.

This PR removes them from the language entirely, and will be a breaking
change.
---
 tests/ast/test_folding.py                     | 43 -------------------
 .../features/decorators/test_private.py       |  2 +-
 .../test_external_contract_calls.py           | 14 +++---
 .../features/iteration/test_for_in_list.py    |  2 +-
 tests/parser/features/test_assignment.py      |  4 +-
 tests/parser/features/test_memory_dealloc.py  |  2 +-
 tests/parser/functions/test_abi_decode.py     |  4 +-
 tests/parser/functions/test_convert.py        | 18 --------
 .../parser/functions/test_default_function.py |  2 +-
 tests/parser/functions/test_empty.py          | 20 ++++-----
 tests/parser/functions/test_return_tuple.py   |  4 +-
 tests/parser/integration/test_escrow.py       |  4 +-
 tests/parser/syntax/test_bool.py              |  4 +-
 tests/parser/syntax/test_interfaces.py        |  4 +-
 tests/parser/syntax/test_no_none.py           | 12 +++---
 tests/parser/syntax/test_tuple_assign.py      |  2 +-
 tests/parser/syntax/test_unbalanced_return.py |  4 +-
 tests/parser/types/numbers/test_constants.py  |  8 ++--
 tests/parser/types/test_identifier_naming.py  |  8 +---
 tests/parser/types/test_string.py             |  2 +-
 vyper/ast/folding.py                          | 33 --------------
 vyper/compiler/phases.py                      |  1 -
 22 files changed, 49 insertions(+), 148 deletions(-)

diff --git a/tests/ast/test_folding.py b/tests/ast/test_folding.py
index 22d5f58222..62a7140e97 100644
--- a/tests/ast/test_folding.py
+++ b/tests/ast/test_folding.py
@@ -132,49 +132,6 @@ def test_replace_constant_no(source):
     assert vy_ast.compare_nodes(unmodified_ast, folded_ast)
 
 
-builtins_modified = [
-    "ZERO_ADDRESS",
-    "foo = ZERO_ADDRESS",
-    "foo: int128[ZERO_ADDRESS] = 42",
-    "foo = [ZERO_ADDRESS]",
-    "def foo(bar: address = ZERO_ADDRESS): pass",
-    "def foo(): bar = ZERO_ADDRESS",
-    "def foo(): return ZERO_ADDRESS",
-    "log foo(ZERO_ADDRESS)",
-    "log foo(42, ZERO_ADDRESS)",
-]
-
-
-@pytest.mark.parametrize("source", builtins_modified)
-def test_replace_builtin_constant(source):
-    unmodified_ast = vy_ast.parse_to_ast(source)
-    folded_ast = vy_ast.parse_to_ast(source)
-
-    folding.replace_builtin_constants(folded_ast)
-
-    assert not vy_ast.compare_nodes(unmodified_ast, folded_ast)
-
-
-builtins_unmodified = [
-    "ZERO_ADDRESS = 2",
-    "ZERO_ADDRESS()",
-    "def foo(ZERO_ADDRESS: int128 = 42): pass",
-    "def foo(): ZERO_ADDRESS = 42",
-    "def ZERO_ADDRESS(): pass",
-    "log ZERO_ADDRESS(42)",
-]
-
-
-@pytest.mark.parametrize("source", builtins_unmodified)
-def test_replace_builtin_constant_no(source):
-    unmodified_ast = vy_ast.parse_to_ast(source)
-    folded_ast = vy_ast.parse_to_ast(source)
-
-    folding.replace_builtin_constants(folded_ast)
-
-    assert vy_ast.compare_nodes(unmodified_ast, folded_ast)
-
-
 userdefined_modified = [
     "FOO",
     "foo = FOO",
diff --git a/tests/parser/features/decorators/test_private.py b/tests/parser/features/decorators/test_private.py
index 7c92f72af9..51e6d90ee1 100644
--- a/tests/parser/features/decorators/test_private.py
+++ b/tests/parser/features/decorators/test_private.py
@@ -304,7 +304,7 @@ def test(a: bytes32) -> (bytes32, uint256, int128):
     b: uint256 = 1
     c: int128 = 1
     d: int128 = 123
-    f: bytes32 = EMPTY_BYTES32
+    f: bytes32 = empty(bytes32)
     f, b, c = self._test(a)
     assert d == 123
     return f, b, c
diff --git a/tests/parser/features/external_contracts/test_external_contract_calls.py b/tests/parser/features/external_contracts/test_external_contract_calls.py
index b3cc6f5576..12fcde2f4f 100644
--- a/tests/parser/features/external_contracts/test_external_contract_calls.py
+++ b/tests/parser/features/external_contracts/test_external_contract_calls.py
@@ -775,9 +775,9 @@ def foo() -> (address, Bytes[3], address): view
 
 @external
 def bar(arg1: address) -> (address, Bytes[3], address):
-    a: address = ZERO_ADDRESS
+    a: address = empty(address)
     b: Bytes[3] = b""
-    c: address = ZERO_ADDRESS
+    c: address = empty(address)
     a, b, c = Foo(arg1).foo()
     return a, b, c
 """
@@ -808,9 +808,9 @@ def foo() -> (address, Bytes[3], address): view
 
 @external
 def bar(arg1: address) -> (address, Bytes[3], address):
-    a: address = ZERO_ADDRESS
+    a: address = empty(address)
     b: Bytes[3] = b""
-    c: address = ZERO_ADDRESS
+    c: address = empty(address)
     a, b, c = Foo(arg1).foo()
     return a, b, c
 """
@@ -841,9 +841,9 @@ def foo() -> (address, Bytes[3], address): view
 
 @external
 def bar(arg1: address) -> (address, Bytes[3], address):
-    a: address = ZERO_ADDRESS
+    a: address = empty(address)
     b: Bytes[3] = b""
-    c: address = ZERO_ADDRESS
+    c: address = empty(address)
     a, b, c = Foo(arg1).foo()
     return a, b, c
 """
@@ -1538,7 +1538,7 @@ def out_literals() -> (int128, address, Bytes[10]) : view
 @external
 def test(addr: address) -> (int128, address, Bytes[10]):
     a: int128 = 0
-    b: address = ZERO_ADDRESS
+    b: address = empty(address)
     c: Bytes[10] = b""
     (a, b, c) = Test(addr).out_literals()
     return a, b,c
diff --git a/tests/parser/features/iteration/test_for_in_list.py b/tests/parser/features/iteration/test_for_in_list.py
index bfd960a787..fb01cc98eb 100644
--- a/tests/parser/features/iteration/test_for_in_list.py
+++ b/tests/parser/features/iteration/test_for_in_list.py
@@ -230,7 +230,7 @@ def iterate_return_second() -> address:
         count += 1
         if count == 2:
             return i
-    return ZERO_ADDRESS
+    return empty(address)
     """
 
     c = get_contract_with_gas_estimation(code)
diff --git a/tests/parser/features/test_assignment.py b/tests/parser/features/test_assignment.py
index 35b008a8ba..cd26659a5c 100644
--- a/tests/parser/features/test_assignment.py
+++ b/tests/parser/features/test_assignment.py
@@ -331,7 +331,7 @@ def foo():
 @external
 def foo():
     y: int128 = 1
-    z: bytes32 = EMPTY_BYTES32
+    z: bytes32 = empty(bytes32)
     z = y
     """,
         """
@@ -344,7 +344,7 @@ def foo():
 @external
 def foo():
     y: uint256 = 1
-    z: bytes32 = EMPTY_BYTES32
+    z: bytes32 = empty(bytes32)
     z = y
     """,
     ],
diff --git a/tests/parser/features/test_memory_dealloc.py b/tests/parser/features/test_memory_dealloc.py
index de82f03296..814bf0d3bb 100644
--- a/tests/parser/features/test_memory_dealloc.py
+++ b/tests/parser/features/test_memory_dealloc.py
@@ -9,7 +9,7 @@ def sendit(): nonpayable
 
 @external
 def foo(target: address) -> uint256[2]:
-    log Shimmy(ZERO_ADDRESS, 3)
+    log Shimmy(empty(address), 3)
     amount: uint256 = 1
     flargen: uint256 = 42
     Other(target).sendit()
diff --git a/tests/parser/functions/test_abi_decode.py b/tests/parser/functions/test_abi_decode.py
index 2216a5bd76..242841e1cf 100644
--- a/tests/parser/functions/test_abi_decode.py
+++ b/tests/parser/functions/test_abi_decode.py
@@ -25,7 +25,7 @@ def test_abi_decode_complex(get_contract):
 
 @external
 def abi_decode(x: Bytes[160]) -> (address, int128, bool, decimal, bytes32):
-    a: address = ZERO_ADDRESS
+    a: address = empty(address)
     b: int128 = 0
     c: bool = False
     d: decimal = 0.0
@@ -39,7 +39,7 @@ def abi_decode_struct(x: Bytes[544]) -> Human:
         name: "",
         pet: Animal({
             name: "",
-            address_: ZERO_ADDRESS,
+            address_: empty(address),
             id_: 0,
             is_furry: False,
             price: 0.0,
diff --git a/tests/parser/functions/test_convert.py b/tests/parser/functions/test_convert.py
index eb8449447c..b5ce613235 100644
--- a/tests/parser/functions/test_convert.py
+++ b/tests/parser/functions/test_convert.py
@@ -534,24 +534,6 @@ def foo(a: {typ}) -> Status:
         assert_compile_failed(lambda: get_contract_with_gas_estimation(contract), TypeMismatch)
 
 
-# TODO CMC 2022-04-06 I think this test is somewhat unnecessary.
-@pytest.mark.parametrize(
-    "builtin_constant,out_type,out_value",
-    [("ZERO_ADDRESS", "bool", False), ("msg.sender", "bool", True)],
-)
-def test_convert_builtin_constant(
-    get_contract_with_gas_estimation, builtin_constant, out_type, out_value
-):
-    contract = f"""
-@external
-def convert_builtin_constant() -> {out_type}:
-    return convert({builtin_constant}, {out_type})
-    """
-
-    c = get_contract_with_gas_estimation(contract)
-    assert c.convert_builtin_constant() == out_value
-
-
 # uint256 conversion is currently valid due to type inference on literals
 # not quite working yet
 same_type_conversion_blocked = sorted(TEST_TYPES - {UINT256_T})
diff --git a/tests/parser/functions/test_default_function.py b/tests/parser/functions/test_default_function.py
index 4aa0b04a77..4ad68697ac 100644
--- a/tests/parser/functions/test_default_function.py
+++ b/tests/parser/functions/test_default_function.py
@@ -41,7 +41,7 @@ def test_basic_default_default_param_function(w3, get_logs, get_contract_with_ga
 @external
 @payable
 def fooBar(a: int128 = 12345) -> int128:
-    log Sent(ZERO_ADDRESS)
+    log Sent(empty(address))
     return a
 
 @external
diff --git a/tests/parser/functions/test_empty.py b/tests/parser/functions/test_empty.py
index c10d03550a..c3627785dc 100644
--- a/tests/parser/functions/test_empty.py
+++ b/tests/parser/functions/test_empty.py
@@ -87,8 +87,8 @@ def foo():
     self.foobar = empty(address)
     bar = empty(address)
 
-    assert self.foobar == ZERO_ADDRESS
-    assert bar == ZERO_ADDRESS
+    assert self.foobar == empty(address)
+    assert bar == empty(address)
     """,
         """
 @external
@@ -214,12 +214,12 @@ def foo():
     self.foobar = empty(address[3])
     bar = empty(address[3])
 
-    assert self.foobar[0] == ZERO_ADDRESS
-    assert self.foobar[1] == ZERO_ADDRESS
-    assert self.foobar[2] == ZERO_ADDRESS
-    assert bar[0] == ZERO_ADDRESS
-    assert bar[1] == ZERO_ADDRESS
-    assert bar[2] == ZERO_ADDRESS
+    assert self.foobar[0] == empty(address)
+    assert self.foobar[1] == empty(address)
+    assert self.foobar[2] == empty(address)
+    assert bar[0] == empty(address)
+    assert bar[1] == empty(address)
+    assert bar[2] == empty(address)
     """,
     ],
 )
@@ -376,14 +376,14 @@ def foo():
     assert self.foobar.c == False
     assert self.foobar.d == 0.0
     assert self.foobar.e == 0x0000000000000000000000000000000000000000000000000000000000000000
-    assert self.foobar.f == ZERO_ADDRESS
+    assert self.foobar.f == empty(address)
 
     assert bar.a == 0
     assert bar.b == 0
     assert bar.c == False
     assert bar.d == 0.0
     assert bar.e == 0x0000000000000000000000000000000000000000000000000000000000000000
-    assert bar.f == ZERO_ADDRESS
+    assert bar.f == empty(address)
     """
 
     c = get_contract_with_gas_estimation(code)
diff --git a/tests/parser/functions/test_return_tuple.py b/tests/parser/functions/test_return_tuple.py
index 87b7cdcde3..b375839147 100644
--- a/tests/parser/functions/test_return_tuple.py
+++ b/tests/parser/functions/test_return_tuple.py
@@ -99,7 +99,7 @@ def out_literals() -> (int128, address, Bytes[10]):
 @external
 def test() -> (int128, address, Bytes[10]):
     a: int128 = 0
-    b: address = ZERO_ADDRESS
+    b: address = empty(address)
     c: Bytes[10] = b""
     (a, b, c) = self._out_literals()
     return a, b, c
@@ -138,7 +138,7 @@ def test2() -> (int128, address):
 
 @external
 def test3() -> (address, int128):
-    x: address = ZERO_ADDRESS
+    x: address = empty(address)
     self.a, self.c, x, self.d = self._out_literals()
     return x, self.a
     """
diff --git a/tests/parser/integration/test_escrow.py b/tests/parser/integration/test_escrow.py
index 2982ff9eae..1578f5a418 100644
--- a/tests/parser/integration/test_escrow.py
+++ b/tests/parser/integration/test_escrow.py
@@ -9,7 +9,7 @@ def test_arbitration_code(w3, get_contract_with_gas_estimation, assert_tx_failed
 
 @external
 def setup(_seller: address, _arbitrator: address):
-    if self.buyer == ZERO_ADDRESS:
+    if self.buyer == empty(address):
         self.buyer = msg.sender
         self.seller = _seller
         self.arbitrator = _arbitrator
@@ -43,7 +43,7 @@ def test_arbitration_code_with_init(w3, assert_tx_failed, get_contract_with_gas_
 @external
 @payable
 def __init__(_seller: address, _arbitrator: address):
-    if self.buyer == ZERO_ADDRESS:
+    if self.buyer == empty(address):
         self.buyer = msg.sender
         self.seller = _seller
         self.arbitrator = _arbitrator
diff --git a/tests/parser/syntax/test_bool.py b/tests/parser/syntax/test_bool.py
index 09f799d91c..48ed37321a 100644
--- a/tests/parser/syntax/test_bool.py
+++ b/tests/parser/syntax/test_bool.py
@@ -52,7 +52,7 @@ def foo() -> bool:
     """
 @external
 def foo() -> bool:
-    a: address = ZERO_ADDRESS
+    a: address = empty(address)
     return a == 1
     """,
     (
@@ -137,7 +137,7 @@ def foo() -> bool:
     """
 @external
 def foo2(a: address) -> bool:
-    return a != ZERO_ADDRESS
+    return a != empty(address)
     """,
 ]
 
diff --git a/tests/parser/syntax/test_interfaces.py b/tests/parser/syntax/test_interfaces.py
index 5afb34e6bd..498f1363d8 100644
--- a/tests/parser/syntax/test_interfaces.py
+++ b/tests/parser/syntax/test_interfaces.py
@@ -47,7 +47,7 @@ def test():
 
 @external
 def test():
-    a: address(ERC20) = ZERO_ADDRESS
+    a: address(ERC20) = empty(address)
     """,
         InvalidType,
     ),
@@ -306,7 +306,7 @@ def some_func(): nonpayable
 
 @external
 def __init__():
-    self.my_interface[self.idx] = MyInterface(ZERO_ADDRESS)
+    self.my_interface[self.idx] = MyInterface(empty(address))
     """,
     """
 interface MyInterface:
diff --git a/tests/parser/syntax/test_no_none.py b/tests/parser/syntax/test_no_none.py
index 7030a56b18..24c32a46a4 100644
--- a/tests/parser/syntax/test_no_none.py
+++ b/tests/parser/syntax/test_no_none.py
@@ -30,13 +30,13 @@ def foo():
         """
 @external
 def foo():
-    bar: bytes32 = EMPTY_BYTES32
+    bar: bytes32 = empty(bytes32)
     bar = None
     """,
         """
 @external
 def foo():
-    bar: address = ZERO_ADDRESS
+    bar: address = empty(address)
     bar = None
     """,
         """
@@ -104,13 +104,13 @@ def foo():
         """
 @external
 def foo():
-    bar: bytes32 = EMPTY_BYTES32
+    bar: bytes32 = empty(bytes32)
     assert bar is None
     """,
         """
 @external
 def foo():
-    bar: address = ZERO_ADDRESS
+    bar: address = empty(address)
     assert bar is None
     """,
     ]
@@ -148,13 +148,13 @@ def foo():
         """
 @external
 def foo():
-    bar: bytes32 = EMPTY_BYTES32
+    bar: bytes32 = empty(bytes32)
     assert bar == None
     """,
         """
 @external
 def foo():
-    bar: address = ZERO_ADDRESS
+    bar: address = empty(address)
     assert bar == None
     """,
     ]
diff --git a/tests/parser/syntax/test_tuple_assign.py b/tests/parser/syntax/test_tuple_assign.py
index 115499ce8b..49b63ee614 100644
--- a/tests/parser/syntax/test_tuple_assign.py
+++ b/tests/parser/syntax/test_tuple_assign.py
@@ -41,7 +41,7 @@ def out_literals() -> (int128, int128, Bytes[10]):
 @external
 def test() -> (int128, address, Bytes[10]):
     a: int128 = 0
-    b: address = ZERO_ADDRESS
+    b: address = empty(address)
     a, b = self.out_literals()  # tuple count mismatch
     return
     """,
diff --git a/tests/parser/syntax/test_unbalanced_return.py b/tests/parser/syntax/test_unbalanced_return.py
index 5337b4b677..d1d9732777 100644
--- a/tests/parser/syntax/test_unbalanced_return.py
+++ b/tests/parser/syntax/test_unbalanced_return.py
@@ -56,7 +56,7 @@ def valid_address(sender: address) -> bool:
         """
 @internal
 def valid_address(sender: address) -> bool:
-    if sender == ZERO_ADDRESS:
+    if sender == empty(address):
         selfdestruct(sender)
         _sender: address = sender
     else:
@@ -144,7 +144,7 @@ def test() -> int128:
     """
 @external
 def test() -> int128:
-    x: bytes32 = EMPTY_BYTES32
+    x: bytes32 = empty(bytes32)
     if False:
         if False:
             return 0
diff --git a/tests/parser/types/numbers/test_constants.py b/tests/parser/types/numbers/test_constants.py
index 0d5e386dad..652c8e8bd9 100644
--- a/tests/parser/types/numbers/test_constants.py
+++ b/tests/parser/types/numbers/test_constants.py
@@ -12,12 +12,12 @@ def test_builtin_constants(get_contract_with_gas_estimation):
     code = """
 @external
 def test_zaddress(a: address) -> bool:
-    return a == ZERO_ADDRESS
+    return a == empty(address)
 
 
 @external
 def test_empty_bytes32(a: bytes32) -> bool:
-    return a == EMPTY_BYTES32
+    return a == empty(bytes32)
 
 
 @external
@@ -81,12 +81,12 @@ def goo() -> int128:
 
 @external
 def hoo() -> bytes32:
-    bar: bytes32 = EMPTY_BYTES32
+    bar: bytes32 = empty(bytes32)
     return bar
 
 @external
 def joo() -> address:
-    bar: address = ZERO_ADDRESS
+    bar: address = empty(address)
     return bar
 
 @external
diff --git a/tests/parser/types/test_identifier_naming.py b/tests/parser/types/test_identifier_naming.py
index 5cfc7e8ed7..0a93329848 100755
--- a/tests/parser/types/test_identifier_naming.py
+++ b/tests/parser/types/test_identifier_naming.py
@@ -1,16 +1,12 @@
 import pytest
 
-from vyper.ast.folding import BUILTIN_CONSTANTS
 from vyper.ast.identifiers import RESERVED_KEYWORDS
 from vyper.builtins.functions import BUILTIN_FUNCTIONS
 from vyper.codegen.expr import ENVIRONMENT_VARIABLES
 from vyper.exceptions import NamespaceCollision, StructureException, SyntaxException
 from vyper.semantics.types.primitives import AddressT
 
-BUILTIN_CONSTANTS = set(BUILTIN_CONSTANTS.keys())
-ALL_RESERVED_KEYWORDS = (
-    BUILTIN_CONSTANTS | BUILTIN_FUNCTIONS | RESERVED_KEYWORDS | ENVIRONMENT_VARIABLES
-)
+ALL_RESERVED_KEYWORDS = BUILTIN_FUNCTIONS | RESERVED_KEYWORDS | ENVIRONMENT_VARIABLES
 
 
 @pytest.mark.parametrize("constant", sorted(ALL_RESERVED_KEYWORDS))
@@ -46,7 +42,7 @@ def test({constant}: int128):
 
 
 SELF_NAMESPACE_MEMBERS = set(AddressT._type_members.keys())
-DISALLOWED_FN_NAMES = SELF_NAMESPACE_MEMBERS | RESERVED_KEYWORDS | BUILTIN_CONSTANTS
+DISALLOWED_FN_NAMES = SELF_NAMESPACE_MEMBERS | RESERVED_KEYWORDS
 ALLOWED_FN_NAMES = ALL_RESERVED_KEYWORDS - DISALLOWED_FN_NAMES
 
 
diff --git a/tests/parser/types/test_string.py b/tests/parser/types/test_string.py
index a5eef66dae..7f1fa71329 100644
--- a/tests/parser/types/test_string.py
+++ b/tests/parser/types/test_string.py
@@ -139,7 +139,7 @@ def out_literals() -> (int128, address, String[10]) : view
 @external
 def test(addr: address) -> (int128, address, String[10]):
     a: int128 = 0
-    b: address = ZERO_ADDRESS
+    b: address = empty(address)
     c: String[10] = ""
     (a, b, c) = Test(addr).out_literals()
     return a, b,c
diff --git a/vyper/ast/folding.py b/vyper/ast/folding.py
index fbd1dfc2f4..38d58f6fd0 100644
--- a/vyper/ast/folding.py
+++ b/vyper/ast/folding.py
@@ -1,4 +1,3 @@
-import warnings
 from typing import Optional, Union
 
 from vyper.ast import nodes as vy_ast
@@ -6,21 +5,6 @@
 from vyper.exceptions import UnfoldableNode, UnknownType
 from vyper.semantics.types.base import VyperType
 from vyper.semantics.types.utils import type_from_annotation
-from vyper.utils import SizeLimits
-
-BUILTIN_CONSTANTS = {
-    "EMPTY_BYTES32": (
-        vy_ast.Hex,
-        "0x0000000000000000000000000000000000000000000000000000000000000000",
-        "empty(bytes32)",
-    ),  # NOQA: E501
-    "ZERO_ADDRESS": (vy_ast.Hex, "0x0000000000000000000000000000000000000000", "empty(address)"),
-    "MAX_INT128": (vy_ast.Int, 2**127 - 1, "max_value(int128)"),
-    "MIN_INT128": (vy_ast.Int, -(2**127), "min_value(int128)"),
-    "MAX_DECIMAL": (vy_ast.Decimal, SizeLimits.MAX_AST_DECIMAL, "max_value(decimal)"),
-    "MIN_DECIMAL": (vy_ast.Decimal, SizeLimits.MIN_AST_DECIMAL, "min_value(decimal)"),
-    "MAX_UINT256": (vy_ast.Int, 2**256 - 1, "max_value(uint256)"),
-}
 
 
 def fold(vyper_module: vy_ast.Module) -> None:
@@ -32,8 +16,6 @@ def fold(vyper_module: vy_ast.Module) -> None:
     vyper_module : Module
         Top-level Vyper AST node.
     """
-    replace_builtin_constants(vyper_module)
-
     changed_nodes = 1
     while changed_nodes:
         changed_nodes = 0
@@ -138,21 +120,6 @@ def replace_builtin_functions(vyper_module: vy_ast.Module) -> int:
     return changed_nodes
 
 
-def replace_builtin_constants(vyper_module: vy_ast.Module) -> None:
-    """
-    Replace references to builtin constants with their literal values.
-
-    Arguments
-    ---------
-    vyper_module : Module
-        Top-level Vyper AST node.
-    """
-    for name, (node, value, replacement) in BUILTIN_CONSTANTS.items():
-        found = replace_constant(vyper_module, name, node(value=value), True)
-        if found > 0:
-            warnings.warn(f"{name} is deprecated. Please use `{replacement}` instead.")
-
-
 def replace_user_defined_constants(vyper_module: vy_ast.Module) -> int:
     """
     Find user-defined constant assignments, and replace references
diff --git a/vyper/compiler/phases.py b/vyper/compiler/phases.py
index 5ddf071caf..72be4396e4 100644
--- a/vyper/compiler/phases.py
+++ b/vyper/compiler/phases.py
@@ -235,7 +235,6 @@ def generate_unfolded_ast(
     vyper_module: vy_ast.Module, interface_codes: Optional[InterfaceImports]
 ) -> vy_ast.Module:
     vy_ast.validation.validate_literal_nodes(vyper_module)
-    vy_ast.folding.replace_builtin_constants(vyper_module)
     vy_ast.folding.replace_builtin_functions(vyper_module)
     # note: validate_semantics does type inference on the AST
     validate_semantics(vyper_module, interface_codes)