diff --git a/src/python/pants/backend/awslambda/python/rules_test.py b/src/python/pants/backend/awslambda/python/rules_test.py
index 04d997d38c9..af546edcadf 100644
--- a/src/python/pants/backend/awslambda/python/rules_test.py
+++ b/src/python/pants/backend/awslambda/python/rules_test.py
@@ -31,7 +31,7 @@ def rule_runner() -> RuleRunner:
     )
 
 
-def create_python_awslambda(rule_runner: RuleRunner, addr: str) -> Tuple[str, bytes]:
+def create_python_awslambda(rule_runner: RuleRunner, addr: Address) -> Tuple[str, bytes]:
     rule_runner.set_options(
         [
             "--backend-packages=pants.backend.awslambda.python",
@@ -39,7 +39,7 @@ def create_python_awslambda(rule_runner: RuleRunner, addr: str) -> Tuple[str, by
             "--pants-distdir-legacy-paths=false",
         ]
     )
-    target = rule_runner.get_target(Address.parse(addr))
+    target = rule_runner.get_target(addr)
     created_awslambda = rule_runner.request(
         CreatedAWSLambda, [PythonAwsLambdaFieldSet.create(target)]
     )
@@ -88,7 +88,7 @@ def handler(event, context):
     )
 
     zip_file_relpath, content = create_python_awslambda(
-        rule_runner, "src/python/foo/bar:hello_world_lambda"
+        rule_runner, Address("src/python/foo/bar", target_name="hello_world_lambda")
     )
     assert "src.python.foo.bar/hello_world_lambda.zip" == zip_file_relpath
     zipfile = ZipFile(BytesIO(content))
diff --git a/src/python/pants/backend/awslambda/python/target_types_test.py b/src/python/pants/backend/awslambda/python/target_types_test.py
index d850a8ce0b5..c39d7e1fa25 100644
--- a/src/python/pants/backend/awslambda/python/target_types_test.py
+++ b/src/python/pants/backend/awslambda/python/target_types_test.py
@@ -21,11 +21,13 @@
 )
 def test_to_interpreter_version(runtime, expected_major, expected_minor):
     assert (expected_major, expected_minor) == PythonAwsLambdaRuntime(
-        raw_value=runtime, address=Address.parse("foo/bar:baz")
+        raw_value=runtime, address=Address("foo/bar", target_name="baz")
     ).to_interpreter_version()
 
 
 @pytest.mark.parametrize(["invalid_runtime"], (["python88.99"], ["fooobar"]))
 def test_runtime_validation(invalid_runtime):
     with pytest.raises(InvalidFieldException):
-        PythonAwsLambdaRuntime(raw_value=invalid_runtime, address=Address.parse("foo/bar:baz"))
+        PythonAwsLambdaRuntime(
+            raw_value=invalid_runtime, address=Address("foo/bar", target_name="baz")
+        )
diff --git a/src/python/pants/backend/project_info/filter_targets_test.py b/src/python/pants/backend/project_info/filter_targets_test.py
index 4f581d2f075..eb21bee4695 100644
--- a/src/python/pants/backend/project_info/filter_targets_test.py
+++ b/src/python/pants/backend/project_info/filter_targets_test.py
@@ -60,7 +60,7 @@ def run_goal(
 
 def test_no_filters_provided() -> None:
     # `filter` behaves like `list` when there are no specified filters.
-    targets = [MockTarget({}, address=Address.parse(addr)) for addr in (":t3", ":t2", ":t1")]
+    targets = [MockTarget({}, address=Address("", target_name=name)) for name in ("t3", "t2", "t1")]
     assert run_goal(targets) == dedent(
         """\
         //:t1
@@ -79,8 +79,10 @@ class Smalltalk(Target):
         alias = "smalltalk"
         core_fields = ()
 
-    fortran_targets = [Fortran({}, address=Address.parse(addr)) for addr in (":f1", ":f2")]
-    smalltalk_targets = [Smalltalk({}, address=Address.parse(addr)) for addr in (":s1", ":s2")]
+    fortran_targets = [Fortran({}, address=Address("", target_name=name)) for name in ("f1", "f2")]
+    smalltalk_targets = [
+        Smalltalk({}, address=Address("", target_name=name)) for name in ("s1", "s2")
+    ]
     targets = [*fortran_targets, *smalltalk_targets]
 
     assert run_goal(targets, target_type=["fortran"]).strip() == "//:f1\n//:f2"
@@ -105,8 +107,12 @@ class Smalltalk(Target):
 
 def test_filter_by_address_regex() -> None:
     targets = [
-        MockTarget({}, address=Address.parse(addr))
-        for addr in ("dir1:lib", "dir2:lib", "common:tests")
+        MockTarget({}, address=addr)
+        for addr in (
+            Address("dir1", target_name="lib"),
+            Address("dir2", target_name="lib"),
+            Address("common", target_name="tests"),
+        )
     ]
     assert run_goal(targets, address_regex=[r"^dir"]).strip() == "dir1:lib\ndir2:lib"
     assert run_goal(targets, address_regex=[r"+dir1:lib$"]).strip() == "dir1:lib"
@@ -123,10 +129,10 @@ def test_filter_by_address_regex() -> None:
 
 def test_filter_by_tag_regex() -> None:
     targets = [
-        MockTarget({"tags": ["tag1"]}, address=Address.parse(":t1")),
-        MockTarget({"tags": ["tag2"]}, address=Address.parse(":t2")),
-        MockTarget({"tags": ["tag1", "tag2"]}, address=Address.parse(":both")),
-        MockTarget({}, address=Address.parse(":no_tags")),
+        MockTarget({"tags": ["tag1"]}, address=Address("", target_name="t1")),
+        MockTarget({"tags": ["tag2"]}, address=Address("", target_name="t2")),
+        MockTarget({"tags": ["tag1", "tag2"]}, address=Address("", target_name="both")),
+        MockTarget({}, address=Address("", target_name="no_tags")),
     ]
     assert run_goal(targets, tag_regex=[r"t.?g2$"]).strip() == "//:both\n//:t2"
     assert run_goal(targets, tag_regex=["+tag1"]).strip() == "//:both\n//:t1"
diff --git a/src/python/pants/backend/project_info/list_targets_test.py b/src/python/pants/backend/project_info/list_targets_test.py
index ace932f889e..585a5dcaf37 100644
--- a/src/python/pants/backend/project_info/list_targets_test.py
+++ b/src/python/pants/backend/project_info/list_targets_test.py
@@ -52,8 +52,10 @@ def run_goal(
 
 def test_list_normal() -> None:
     # Note that these are unsorted.
-    addresses = (":t3", ":t2", ":t1")
-    stdout, _ = run_goal([MockTarget({}, address=Address.parse(addr)) for addr in addresses])
+    target_names = ("t3", "t2", "t1")
+    stdout, _ = run_goal(
+        [MockTarget({}, address=Address("", target_name=name)) for name in target_names]
+    )
     assert stdout == dedent(
         """\
         //:t1
@@ -73,9 +75,9 @@ def test_list_documented() -> None:
         [
             MockTarget(
                 {DescriptionField.alias: "Description of a target.\n\tThis target is the best."},
-                address=Address.parse(":described"),
+                address=Address("", target_name="described"),
             ),
-            MockTarget({}, address=Address.parse(":not_described")),
+            MockTarget({}, address=Address("", target_name="not_described")),
         ],
         show_documented=True,
     )
@@ -91,8 +93,10 @@ def test_list_documented() -> None:
 def test_list_provides() -> None:
     sample_artifact = PythonArtifact(name="project.demo")
     targets = [
-        MockTarget({ProvidesField.alias: sample_artifact}, address=Address.parse(":provided")),
-        MockTarget({}, address=Address.parse(":not_provided")),
+        MockTarget(
+            {ProvidesField.alias: sample_artifact}, address=Address("", target_name="provided")
+        ),
+        MockTarget({}, address=Address("", target_name="not_provided")),
     ]
     stdout, _ = run_goal(targets, show_provides=True)
     assert stdout.strip() == f"//:provided {sample_artifact}"
diff --git a/src/python/pants/backend/python/dependency_inference/module_mapper_test.py b/src/python/pants/backend/python/dependency_inference/module_mapper_test.py
index 73f696e0e9c..7e4fbc10d7d 100644
--- a/src/python/pants/backend/python/dependency_inference/module_mapper_test.py
+++ b/src/python/pants/backend/python/dependency_inference/module_mapper_test.py
@@ -54,8 +54,8 @@ def test_first_party_modules_mapping() -> None:
 
 
 def test_third_party_modules_mapping() -> None:
-    colors_addr = Address.parse("//:ansicolors")
-    pants_addr = Address.parse("//:pantsbuild")
+    colors_addr = Address("", target_name="ansicolors")
+    pants_addr = Address("", target_name="pantsbuild")
     mapping = ThirdPartyModuleToAddressMapping(
         FrozenDict({"colors": colors_addr, "pants": pants_addr})
     )
diff --git a/src/python/pants/backend/python/dependency_inference/rules_test.py b/src/python/pants/backend/python/dependency_inference/rules_test.py
index 18b460dfc55..4b94d2aeaa8 100644
--- a/src/python/pants/backend/python/dependency_inference/rules_test.py
+++ b/src/python/pants/backend/python/dependency_inference/rules_test.py
@@ -160,7 +160,7 @@ def run_dep_inference(address: Address) -> InferredDependencies:
             [InferInitDependencies(target[PythonSources])],
         )
 
-    assert run_dep_inference(Address.parse("src/python/root/mid/leaf")) == InferredDependencies(
+    assert run_dep_inference(Address("src/python/root/mid/leaf")) == InferredDependencies(
         [
             Address("src/python/root", relative_file_path="__init__.py", target_name="root"),
             Address("src/python/root/mid", relative_file_path="__init__.py", target_name="mid"),
@@ -200,7 +200,7 @@ def run_dep_inference(address: Address) -> InferredDependencies:
             [InferConftestDependencies(target[PythonSources])],
         )
 
-    assert run_dep_inference(Address.parse("src/python/root/mid/leaf")) == InferredDependencies(
+    assert run_dep_inference(Address("src/python/root/mid/leaf")) == InferredDependencies(
         [
             Address("src/python/root", relative_file_path="conftest.py", target_name="root"),
             Address("src/python/root/mid", relative_file_path="conftest.py", target_name="mid"),
diff --git a/src/python/pants/backend/python/goals/setup_py_test.py b/src/python/pants/backend/python/goals/setup_py_test.py
index eee0f8538db..dce90dc6e9c 100644
--- a/src/python/pants/backend/python/goals/setup_py_test.py
+++ b/src/python/pants/backend/python/goals/setup_py_test.py
@@ -100,9 +100,9 @@ def chroot_rule_runner() -> RuleRunner:
 
 
 def assert_chroot(
-    rule_runner: RuleRunner, expected_files, expected_setup_kwargs, addr: str
+    rule_runner: RuleRunner, expected_files, expected_setup_kwargs, addr: Address
 ) -> None:
-    tgt = rule_runner.get_target(Address.parse(addr))
+    tgt = rule_runner.get_target(addr)
     chroot = rule_runner.request(
         SetupPyChroot,
         [SetupPyChrootRequest(ExportedTarget(tgt), py2=False)],
@@ -112,8 +112,8 @@ def assert_chroot(
     assert expected_setup_kwargs == chroot.setup_kwargs.kwargs
 
 
-def assert_chroot_error(rule_runner: RuleRunner, addr: str, exc_cls: Type[Exception]) -> None:
-    tgt = rule_runner.get_target(Address.parse(addr))
+def assert_chroot_error(rule_runner: RuleRunner, addr: Address, exc_cls: Type[Exception]) -> None:
+    tgt = rule_runner.get_target(addr)
     with pytest.raises(ExecutionError) as excinfo:
         rule_runner.request(
             SetupPyChroot,
@@ -216,7 +216,7 @@ def test_generate_chroot(chroot_rule_runner: RuleRunner) -> None:
             "install_requires": ("baz==1.1.1",),
             "entry_points": {"console_scripts": ["foo_main=foo.qux.bin"]},
         },
-        "src/python/foo:foo-dist",
+        Address("src/python/foo", target_name="foo-dist"),
     )
 
 
@@ -244,10 +244,14 @@ def test_invalid_binary(chroot_rule_runner: RuleRunner) -> None:
     )
 
     assert_chroot_error(
-        chroot_rule_runner, "src/python/invalid_binary:invalid_bin1", InvalidEntryPoint
+        chroot_rule_runner,
+        Address("src/python/invalid_binary", target_name="invalid_bin1"),
+        InvalidEntryPoint,
     )
     assert_chroot_error(
-        chroot_rule_runner, "src/python/invalid_binary:invalid_bin2", InvalidEntryPoint
+        chroot_rule_runner,
+        Address("src/python/invalid_binary", target_name="invalid_bin2"),
+        InvalidEntryPoint,
     )
 
 
@@ -286,7 +290,7 @@ def assert_sources(
         expected_package_data,
         addrs,
     ):
-        targets = Targets(rule_runner.get_target(Address.parse(addr)) for addr in addrs)
+        targets = Targets(rule_runner.get_target(addr) for addr in addrs)
         srcs = rule_runner.request(
             SetupPySources,
             [SetupPySourcesRequest(targets, py2=False)],
@@ -303,7 +307,7 @@ def assert_sources(
         expected_packages=["foo", "foo.bar", "foo.bar.baz"],
         expected_namespace_packages=["foo.bar"],
         expected_package_data={},
-        addrs=["src/python/foo/bar/baz:baz1"],
+        addrs=[Address("src/python/foo/bar/baz", target_name="baz1")],
     )
 
     assert_sources(
@@ -311,7 +315,7 @@ def assert_sources(
         expected_packages=["foo", "foo.bar", "foo.bar.baz"],
         expected_namespace_packages=["foo.bar"],
         expected_package_data={},
-        addrs=["src/python/foo/bar/baz:baz2"],
+        addrs=[Address("src/python/foo/bar/baz", target_name="baz2")],
     )
 
     assert_sources(
@@ -319,7 +323,7 @@ def assert_sources(
         expected_packages=["foo", "foo.qux"],
         expected_namespace_packages=[],
         expected_package_data={},
-        addrs=["src/python/foo/qux"],
+        addrs=[Address("src/python/foo/qux")],
     )
 
     assert_sources(
@@ -334,7 +338,11 @@ def assert_sources(
         expected_packages=["foo", "foo.bar", "foo.bar.baz", "foo.qux"],
         expected_namespace_packages=["foo.bar"],
         expected_package_data={"foo": ("resources/js/code.js",)},
-        addrs=["src/python/foo/bar/baz:baz1", "src/python/foo/qux", "src/python/foo/resources"],
+        addrs=[
+            Address("src/python/foo/bar/baz", target_name="baz1"),
+            Address("src/python/foo/qux"),
+            Address("src/python/foo/resources"),
+        ],
     )
 
     assert_sources(
@@ -351,10 +359,10 @@ def assert_sources(
         expected_namespace_packages=["foo.bar"],
         expected_package_data={"foo": ("resources/js/code.js",)},
         addrs=[
-            "src/python/foo/bar/baz:baz1",
-            "src/python/foo/bar/baz:baz2",
-            "src/python/foo/qux",
-            "src/python/foo/resources",
+            Address("src/python/foo/bar/baz", target_name="baz1"),
+            Address("src/python/foo/bar/baz", target_name="baz2"),
+            Address("src/python/foo/qux"),
+            Address("src/python/foo/resources"),
         ],
     )
 
@@ -432,16 +440,20 @@ def test_get_requirements() -> None:
         ),
     )
 
-    def assert_requirements(expected_req_strs, addr):
-        tgt = rule_runner.get_target(Address.parse(addr))
+    def assert_requirements(expected_req_strs, addr: Address):
+        tgt = rule_runner.get_target(addr)
         reqs = rule_runner.request(
             ExportedTargetRequirements,
             [DependencyOwner(ExportedTarget(tgt))],
         )
         assert sorted(expected_req_strs) == list(reqs)
 
-    assert_requirements(["ext1==1.22.333", "ext2==4.5.6"], "src/python/foo/bar:bar-dist")
-    assert_requirements(["ext3==0.0.1", "bar==9.8.7"], "src/python/foo/corge:corge-dist")
+    assert_requirements(
+        ["ext1==1.22.333", "ext2==4.5.6"], Address("src/python/foo/bar", target_name="bar-dist")
+    )
+    assert_requirements(
+        ["ext3==0.0.1", "bar==9.8.7"], Address("src/python/foo/corge", target_name="corge-dist")
+    )
 
 
 def test_owned_dependencies() -> None:
@@ -504,8 +516,8 @@ def test_owned_dependencies() -> None:
         ),
     )
 
-    def assert_owned(owned: Iterable[str], exported: str):
-        tgt = rule_runner.get_target(Address.parse(exported))
+    def assert_owned(owned: Iterable[str], exported: Address):
+        tgt = rule_runner.get_target(exported)
         assert sorted(owned) == sorted(
             od.target.address.spec
             for od in rule_runner.request(
@@ -516,7 +528,7 @@ def assert_owned(owned: Iterable[str], exported: str):
 
     assert_owned(
         ["src/python/foo/bar:bar1", "src/python/foo/bar:bar1-dist", "src/python/foo/bar/baz:baz1"],
-        "src/python/foo/bar:bar1-dist",
+        Address("src/python/foo/bar", target_name="bar1-dist"),
     )
     assert_owned(
         [
@@ -526,7 +538,7 @@ def assert_owned(owned: Iterable[str], exported: str):
             "src/python/foo/bar:bar-resources",
             "src/python/foo/bar/baz:baz2",
         ],
-        "src/python/foo:foo-dist",
+        Address("src/python/foo", target_name="foo-dist"),
     )
 
 
@@ -540,8 +552,8 @@ def exporting_owner_rule_runner() -> RuleRunner:
     )
 
 
-def assert_is_owner(rule_runner: RuleRunner, owner: str, owned: str):
-    tgt = rule_runner.get_target(Address.parse(owned))
+def assert_is_owner(rule_runner: RuleRunner, owner: str, owned: Address):
+    tgt = rule_runner.get_target(owned)
     assert (
         owner
         == rule_runner.request(
@@ -551,8 +563,8 @@ def assert_is_owner(rule_runner: RuleRunner, owner: str, owned: str):
     )
 
 
-def assert_owner_error(rule_runner, owned: str, exc_cls: Type[Exception]):
-    tgt = rule_runner.get_target(Address.parse(owned))
+def assert_owner_error(rule_runner, owned: Address, exc_cls: Type[Exception]):
+    tgt = rule_runner.get_target(owned)
     with pytest.raises(ExecutionError) as excinfo:
         rule_runner.request(
             ExportedTarget,
@@ -563,11 +575,11 @@ def assert_owner_error(rule_runner, owned: str, exc_cls: Type[Exception]):
     assert type(ex.wrapped_exceptions[0]) == exc_cls
 
 
-def assert_no_owner(rule_runner: RuleRunner, owned: str):
+def assert_no_owner(rule_runner: RuleRunner, owned: Address):
     assert_owner_error(rule_runner, owned, NoOwnerError)
 
 
-def assert_ambiguous_owner(rule_runner: RuleRunner, owned: str):
+def assert_ambiguous_owner(rule_runner: RuleRunner, owned: Address):
     assert_owner_error(rule_runner, owned, AmbiguousOwnerError)
 
 
@@ -619,22 +631,42 @@ def test_get_owner_simple(exporting_owner_rule_runner: RuleRunner) -> None:
     )
 
     assert_is_owner(
-        exporting_owner_rule_runner, "src/python/foo/bar:bar1", "src/python/foo/bar:bar1"
+        exporting_owner_rule_runner,
+        "src/python/foo/bar:bar1",
+        Address("src/python/foo/bar", target_name="bar1"),
     )
     assert_is_owner(
-        exporting_owner_rule_runner, "src/python/foo/bar:bar1", "src/python/foo/bar/baz:baz1"
+        exporting_owner_rule_runner,
+        "src/python/foo/bar:bar1",
+        Address("src/python/foo/bar/baz", target_name="baz1"),
     )
 
-    assert_is_owner(exporting_owner_rule_runner, "src/python/foo:foo1", "src/python/foo:foo1")
+    assert_is_owner(
+        exporting_owner_rule_runner,
+        "src/python/foo:foo1",
+        Address("src/python/foo", target_name="foo1"),
+    )
 
-    assert_is_owner(exporting_owner_rule_runner, "src/python/foo:foo3", "src/python/foo:foo3")
-    assert_is_owner(exporting_owner_rule_runner, "src/python/foo:foo3", "src/python/foo/bar:bar2")
     assert_is_owner(
-        exporting_owner_rule_runner, "src/python/foo:foo3", "src/python/foo/bar:bar-resources"
+        exporting_owner_rule_runner,
+        "src/python/foo:foo3",
+        Address("src/python/foo", target_name="foo3"),
+    )
+    assert_is_owner(
+        exporting_owner_rule_runner,
+        "src/python/foo:foo3",
+        Address("src/python/foo/bar", target_name="bar2"),
+    )
+    assert_is_owner(
+        exporting_owner_rule_runner,
+        "src/python/foo:foo3",
+        Address("src/python/foo/bar", target_name="bar-resources"),
     )
 
-    assert_no_owner(exporting_owner_rule_runner, "src/python/foo:foo2")
-    assert_ambiguous_owner(exporting_owner_rule_runner, "src/python/foo/bar/baz:baz2")
+    assert_no_owner(exporting_owner_rule_runner, Address("src/python/foo", target_name="foo2"))
+    assert_ambiguous_owner(
+        exporting_owner_rule_runner, Address("src/python/foo/bar/baz", target_name="baz2")
+    )
 
 
 def test_get_owner_siblings(exporting_owner_rule_runner: RuleRunner) -> None:
@@ -653,10 +685,14 @@ def test_get_owner_siblings(exporting_owner_rule_runner: RuleRunner) -> None:
     )
 
     assert_is_owner(
-        exporting_owner_rule_runner, "src/python/siblings:sibling2", "src/python/siblings:sibling1"
+        exporting_owner_rule_runner,
+        "src/python/siblings:sibling2",
+        Address("src/python/siblings", target_name="sibling1"),
     )
     assert_is_owner(
-        exporting_owner_rule_runner, "src/python/siblings:sibling2", "src/python/siblings:sibling2"
+        exporting_owner_rule_runner,
+        "src/python/siblings:sibling2",
+        Address("src/python/siblings", target_name="sibling2"),
     )
 
 
@@ -682,9 +718,11 @@ def test_get_owner_not_an_ancestor(exporting_owner_rule_runner: RuleRunner) -> N
         ),
     )
 
-    assert_no_owner(exporting_owner_rule_runner, "src/python/notanancestor/aaa")
+    assert_no_owner(exporting_owner_rule_runner, Address("src/python/notanancestor/aaa"))
     assert_is_owner(
-        exporting_owner_rule_runner, "src/python/notanancestor/bbb", "src/python/notanancestor/bbb"
+        exporting_owner_rule_runner,
+        "src/python/notanancestor/bbb",
+        Address("src/python/notanancestor/bbb"),
     )
 
 
@@ -722,9 +760,13 @@ def test_get_owner_multiple_ancestor_generations(exporting_owner_rule_runner: Ru
         ),
     )
 
-    assert_is_owner(exporting_owner_rule_runner, "src/python/aaa/bbb", "src/python/aaa/bbb/ccc")
-    assert_is_owner(exporting_owner_rule_runner, "src/python/aaa/bbb", "src/python/aaa/bbb")
-    assert_is_owner(exporting_owner_rule_runner, "src/python/aaa", "src/python/aaa")
+    assert_is_owner(
+        exporting_owner_rule_runner, "src/python/aaa/bbb", Address("src/python/aaa/bbb/ccc")
+    )
+    assert_is_owner(
+        exporting_owner_rule_runner, "src/python/aaa/bbb", Address("src/python/aaa/bbb")
+    )
+    assert_is_owner(exporting_owner_rule_runner, "src/python/aaa", Address("src/python/aaa"))
 
 
 def test_validate_args() -> None:
diff --git a/src/python/pants/backend/python/lint/bandit/rules_integration_test.py b/src/python/pants/backend/python/lint/bandit/rules_integration_test.py
index 6dc3428e361..29ecf1bd0ea 100644
--- a/src/python/pants/backend/python/lint/bandit/rules_integration_test.py
+++ b/src/python/pants/backend/python/lint/bandit/rules_integration_test.py
@@ -42,7 +42,7 @@ def make_target(
         rule_runner.create_file(source_file.path, source_file.content.decode())
     return PythonLibrary(
         {PythonInterpreterCompatibility.alias: interpreter_constraints},
-        address=Address.parse(":target"),
+        address=Address("", target_name="target"),
     )
 
 
diff --git a/src/python/pants/backend/python/lint/docformatter/rules_integration_test.py b/src/python/pants/backend/python/lint/docformatter/rules_integration_test.py
index bfdef0d76bf..ae183f50fe3 100644
--- a/src/python/pants/backend/python/lint/docformatter/rules_integration_test.py
+++ b/src/python/pants/backend/python/lint/docformatter/rules_integration_test.py
@@ -30,15 +30,15 @@ def rule_runner() -> RuleRunner:
     )
 
 
-GOOD_SOURCE = FileContent(path="good.py", content=b'"""Good docstring."""\n')
-BAD_SOURCE = FileContent(path="bad.py", content=b'"""Oops, missing a period"""\n')
-FIXED_BAD_SOURCE = FileContent(path="bad.py", content=b'"""Oops, missing a period."""\n')
+GOOD_SOURCE = FileContent("good.py", b'"""Good docstring."""\n')
+BAD_SOURCE = FileContent("bad.py", b'"""Oops, missing a period"""\n')
+FIXED_BAD_SOURCE = FileContent("bad.py", b'"""Oops, missing a period."""\n')
 
 
 def make_target(rule_runner: RuleRunner, source_files: List[FileContent]) -> Target:
     for source_file in source_files:
         rule_runner.create_file(f"{source_file.path}", source_file.content.decode())
-    return PythonLibrary({}, address=Address.parse(":target"))
+    return PythonLibrary({}, address=Address("", target_name="target"))
 
 
 def run_docformatter(
diff --git a/src/python/pants/backend/python/lint/flake8/rules_integration_test.py b/src/python/pants/backend/python/lint/flake8/rules_integration_test.py
index 390cfb594de..e88d7d9ef0f 100644
--- a/src/python/pants/backend/python/lint/flake8/rules_integration_test.py
+++ b/src/python/pants/backend/python/lint/flake8/rules_integration_test.py
@@ -26,9 +26,9 @@ def rule_runner() -> RuleRunner:
     )
 
 
-GOOD_SOURCE = FileContent(path="good.py", content=b"print('Nothing suspicious here..')\n")
-BAD_SOURCE = FileContent(path="bad.py", content=b"import typing\n")  # unused import
-PY3_ONLY_SOURCE = FileContent(path="py3.py", content=b"version: str = 'Py3 > Py2'\n")
+GOOD_SOURCE = FileContent("good.py", b"print('Nothing suspicious here..')\n")
+BAD_SOURCE = FileContent("bad.py", b"import typing\n")  # unused import
+PY3_ONLY_SOURCE = FileContent("py3.py", b"version: str = 'Py3 > Py2'\n")
 
 
 def make_target(
@@ -41,7 +41,7 @@ def make_target(
         rule_runner.create_file(source_file.path, source_file.content.decode())
     return PythonLibrary(
         {PythonInterpreterCompatibility.alias: interpreter_constraints},
-        address=Address.parse(":target"),
+        address=Address("", target_name="target"),
     )
 
 
diff --git a/src/python/pants/backend/python/lint/isort/rules_integration_test.py b/src/python/pants/backend/python/lint/isort/rules_integration_test.py
index 2ac6f531500..66c94183dcc 100644
--- a/src/python/pants/backend/python/lint/isort/rules_integration_test.py
+++ b/src/python/pants/backend/python/lint/isort/rules_integration_test.py
@@ -47,7 +47,7 @@ def rule_runner() -> RuleRunner:
 def make_target(rule_runner: RuleRunner, source_files: List[FileContent]) -> Target:
     for source_file in source_files:
         rule_runner.create_file(f"{source_file.path}", source_file.content.decode())
-    return PythonLibrary({}, address=Address.parse(":target"))
+    return PythonLibrary({}, address=Address("", target_name="target"))
 
 
 def run_isort(
diff --git a/src/python/pants/backend/python/lint/pylint/rules_integration_test.py b/src/python/pants/backend/python/lint/pylint/rules_integration_test.py
index f9e13c17158..e72c6c297aa 100644
--- a/src/python/pants/backend/python/lint/pylint/rules_integration_test.py
+++ b/src/python/pants/backend/python/lint/pylint/rules_integration_test.py
@@ -283,7 +283,7 @@ def test_pep420_namespace_packages(rule_runner: RuleRunner) -> None:
             rule_runner,
             [test_fc],
             package="tests/python/project",
-            dependencies=[Address.parse(f"{PACKAGE}:target")],
+            dependencies=[Address(PACKAGE, target_name="target")],
         ),
     ]
     result = run_pylint(rule_runner, targets)
diff --git a/src/python/pants/backend/python/lint/python_fmt_integration_test.py b/src/python/pants/backend/python/lint/python_fmt_integration_test.py
index 1c5bfc5bbea..499c9b6a2aa 100644
--- a/src/python/pants/backend/python/lint/python_fmt_integration_test.py
+++ b/src/python/pants/backend/python/lint/python_fmt_integration_test.py
@@ -37,7 +37,9 @@ def run_black_and_isort(
 ) -> LanguageFmtResults:
     for source_file in source_files:
         rule_runner.create_file(source_file.path, source_file.content.decode())
-    targets = PythonFmtTargets(Targets([PythonLibrary({}, address=Address.parse(f"test:{name}"))]))
+    targets = PythonFmtTargets(
+        Targets([PythonLibrary({}, address=Address("test", target_name=name))])
+    )
     rule_runner.set_options(
         [
             "--backend-packages=['pants.backend.python.lint.black', 'pants.backend.python.lint.isort']",
diff --git a/src/python/pants/backend/python/target_types_test.py b/src/python/pants/backend/python/target_types_test.py
index 70656567886..c1cb34100c4 100644
--- a/src/python/pants/backend/python/target_types_test.py
+++ b/src/python/pants/backend/python/target_types_test.py
@@ -32,10 +32,10 @@
 
 def test_timeout_validation() -> None:
     with pytest.raises(InvalidFieldException):
-        PythonTestsTimeout(-100, address=Address.parse(":tests"))
+        PythonTestsTimeout(-100, address=Address("", target_name="tests"))
     with pytest.raises(InvalidFieldException):
-        PythonTestsTimeout(0, address=Address.parse(":tests"))
-    assert PythonTestsTimeout(5, address=Address.parse(":tests")).value == 5
+        PythonTestsTimeout(0, address=Address("", target_name="tests"))
+    assert PythonTestsTimeout(5, address=Address("", target_name="tests")).value == 5
 
 
 def test_timeout_calculation() -> None:
@@ -47,7 +47,7 @@ def assert_timeout_calculated(
         global_max: Optional[int] = None,
         timeouts_enabled: bool = True,
     ) -> None:
-        field = PythonTestsTimeout(field_value, address=Address.parse(":tests"))
+        field = PythonTestsTimeout(field_value, address=Address("", target_name="tests"))
         pytest = create_subsystem(
             PyTest,
             timeouts=timeouts_enabled,
diff --git a/src/python/pants/backend/python/util_rules/pex_test.py b/src/python/pants/backend/python/util_rules/pex_test.py
index 146c0538689..e4319d10227 100644
--- a/src/python/pants/backend/python/util_rules/pex_test.py
+++ b/src/python/pants/backend/python/util_rules/pex_test.py
@@ -217,18 +217,21 @@ class MockFieldSet(FieldSet):
     compatibility: PythonInterpreterCompatibility
 
     @classmethod
-    def create_for_test(cls, address: str, compat: Optional[str]) -> "MockFieldSet":
-        addr = Address.parse(address)
-        return cls(address=addr, compatibility=PythonInterpreterCompatibility(compat, address=addr))
+    def create_for_test(cls, address: Address, compat: Optional[str]) -> "MockFieldSet":
+        return cls(
+            address=address, compatibility=PythonInterpreterCompatibility(compat, address=address)
+        )
 
 
 def test_group_field_sets_by_constraints() -> None:
-    py2_fs = MockFieldSet.create_for_test("//:py2", ">=2.7,<3")
+    py2_fs = MockFieldSet.create_for_test(Address("", target_name="py2"), ">=2.7,<3")
     py3_fs = [
-        MockFieldSet.create_for_test("//:py3", "==3.6.*"),
-        MockFieldSet.create_for_test("//:py3_second", "==3.6.*"),
+        MockFieldSet.create_for_test(Address("", target_name="py3"), "==3.6.*"),
+        MockFieldSet.create_for_test(Address("", target_name="py3_second"), "==3.6.*"),
     ]
-    no_constraints_fs = MockFieldSet.create_for_test("//:no_constraints", None)
+    no_constraints_fs = MockFieldSet.create_for_test(
+        Address("", target_name="no_constraints"), None
+    )
     assert PexInterpreterConstraints.group_field_sets_by_constraints(
         [py2_fs, *py3_fs, no_constraints_fs],
         python_setup=create_subsystem(PythonSetup, interpreter_constraints=[]),
@@ -243,9 +246,15 @@ def test_group_field_sets_by_constraints() -> None:
 
 def test_group_field_sets_by_constraints_with_unsorted_inputs() -> None:
     py3_fs = [
-        MockFieldSet.create_for_test("src/python/a_dir/path.py:test", "==3.6.*"),
-        MockFieldSet.create_for_test("src/python/b_dir/path.py:test", ">2.7,<3"),
-        MockFieldSet.create_for_test("src/python/c_dir/path.py:test", "==3.6.*"),
+        MockFieldSet.create_for_test(
+            Address("src/python/a_dir/path.py", target_name="test"), "==3.6.*"
+        ),
+        MockFieldSet.create_for_test(
+            Address("src/python/b_dir/path.py", target_name="test"), ">2.7,<3"
+        ),
+        MockFieldSet.create_for_test(
+            Address("src/python/c_dir/path.py", target_name="test"), "==3.6.*"
+        ),
     ]
 
     ic_36 = PexInterpreterConstraints([Requirement.parse("CPython==3.6.*")])
@@ -256,8 +265,12 @@ def test_group_field_sets_by_constraints_with_unsorted_inputs() -> None:
     )
 
     assert output[ic_36] == (
-        MockFieldSet.create_for_test("src/python/a_dir/path.py:test", "==3.6.*"),
-        MockFieldSet.create_for_test("src/python/c_dir/path.py:test", "==3.6.*"),
+        MockFieldSet.create_for_test(
+            Address("src/python/a_dir/path.py", target_name="test"), "==3.6.*"
+        ),
+        MockFieldSet.create_for_test(
+            Address("src/python/c_dir/path.py", target_name="test"), "==3.6.*"
+        ),
     )
 
 
@@ -270,13 +283,13 @@ class ExactRequirement:
     def parse(cls, requirement: str) -> "ExactRequirement":
         req = Requirement.parse(requirement)
         assert len(req.specs) == 1, (
-            "Expected an exact requirement with only 1 specifier, given {requirement} with "
-            "{count} specifiers".format(requirement=requirement, count=len(req.specs))
+            f"Expected an exact requirement with only 1 specifier, given {requirement} with "
+            f"{len(req.specs)} specifiers"
         )
         operator, version = req.specs[0]
         assert operator == "==", (
-            "Expected an exact requirement using only the '==' specifier, given {requirement} "
-            "using the {operator!r} operator".format(requirement=requirement, operator=operator)
+            f"Expected an exact requirement using only the '==' specifier, given {requirement} "
+            f"using the {operator!r} operator"
         )
         return cls(project_name=req.project_name, version=version)
 
diff --git a/src/python/pants/build_graph/address.py b/src/python/pants/build_graph/address.py
index ff68a73a205..58a9b57fa59 100644
--- a/src/python/pants/build_graph/address.py
+++ b/src/python/pants/build_graph/address.py
@@ -6,7 +6,6 @@
 from pathlib import PurePath
 from typing import Optional, Sequence
 
-from pants.base.deprecated import deprecated
 from pants.engine.engine_aware import EngineAwareParameter
 from pants.util.dirutil import fast_relpath, longest_dir_prefix
 from pants.util.strutil import strip_prefix
@@ -215,29 +214,6 @@ class Address(EngineAwareParameter):
     Where `path/to/buildfile:targetname` is the dependent target address.
     """
 
-    @classmethod
-    @deprecated(
-        "2.1.0.dev0",
-        hint_message=(
-            "An Address object should be resolved from an AddressInput using the engine. "
-            "This does not work properly with generated subtargets."
-        ),
-    )
-    def parse(cls, spec: str, relative_to: str = "", subproject_roots=None) -> "Address":
-        """Parses an address from its serialized form.
-
-        NB: This method is oblivious to file Addresses.
-
-        :param spec: An address in string form <path>:<name>.
-        :param relative_to: For sibling specs, ie: ':another_in_same_build_family', interprets
-                            the missing spec_path part as `relative_to`.
-        :param list subproject_roots: Paths that correspond with embedded build roots
-                                      under the current build root.
-        """
-        return AddressInput.parse(
-            spec, relative_to=relative_to, subproject_roots=subproject_roots
-        ).dir_to_address()
-
     def __init__(
         self,
         spec_path: str,
@@ -335,14 +311,6 @@ def path_safe_spec(self) -> str:
             target_portion = f"{parent_prefix}{target_name}"
         return f"{self.spec_path.replace(os.path.sep, '.')}{file_portion}{target_portion}"
 
-    @deprecated(
-        removal_version="2.1.0.dev0",
-        hint_message="Use the property .spec, which is the same thing.",
-    )
-    def reference(self) -> str:
-        """How to reference this address in a BUILD file."""
-        return self.spec
-
     def maybe_convert_to_base_target(self) -> "Address":
         """If this address is a generated subtarget, convert it back into its original base target.
 
diff --git a/src/python/pants/build_graph/address_test.py b/src/python/pants/build_graph/address_test.py
index e75d9d91465..f897b5d1b1a 100644
--- a/src/python/pants/build_graph/address_test.py
+++ b/src/python/pants/build_graph/address_test.py
@@ -236,7 +236,6 @@ def test_address_spec() -> None:
     def assert_spec(address: Address, *, expected: str, expected_path_spec: str) -> None:
         assert address.spec == expected
         assert str(address) == expected
-        assert address.reference() == expected
         assert address.path_safe_spec == expected_path_spec
 
     assert_spec(Address("a/b"), expected="a/b", expected_path_spec="a.b")
@@ -331,22 +330,3 @@ def assert_conversion(address: Address, *, expected: AddressInput) -> None:
         Address("a/b/c", relative_file_path="subdir/f.txt", target_name="tgt"),
         expected=AddressInput("a/b/c/subdir/f.txt", "../tgt"),
     )
-
-
-def test_address_parse_method() -> None:
-    def assert_parsed(spec_path: str, target_name: str, address: Address) -> None:
-        assert spec_path == address.spec_path
-        assert target_name == address.target_name
-
-    assert_parsed("a/b", "target", Address.parse("a/b:target"))
-    assert_parsed("a/b", "target", Address.parse("//a/b:target"))
-    assert_parsed("a/b", "b", Address.parse("a/b"))
-    assert_parsed("a/b", "b", Address.parse("//a/b"))
-    assert_parsed("a/b", "target", Address.parse(":target", relative_to="a/b"))
-    assert_parsed("", "target", Address.parse("//:target", relative_to="a/b"))
-    assert_parsed("", "target", Address.parse(":target"))
-    assert_parsed("a/b", "target", Address.parse(":target", relative_to="a/b"))
-
-    # Do not attempt to parse generated subtargets, as we would have no way to find the
-    # generated_base_target_name.
-    assert_parsed("a/b/f.py", "f.py", Address.parse("a/b/f.py"))
diff --git a/src/python/pants/core/goals/fmt_test.py b/src/python/pants/core/goals/fmt_test.py
index 8bb0e0be5d9..c47af273216 100644
--- a/src/python/pants/core/goals/fmt_test.py
+++ b/src/python/pants/core/goals/fmt_test.py
@@ -136,7 +136,7 @@ def setUp(self) -> None:
     def make_target(
         address: Optional[Address] = None, *, target_cls: Type[Target] = FortranTarget
     ) -> Target:
-        return target_cls({}, address=address or Address.parse(":tests"))
+        return target_cls({}, address=address or Address("", target_name="tests"))
 
     def run_fmt_rule(
         self,
@@ -234,8 +234,11 @@ def test_summary(self) -> None:
             `--per-file-caching`).
         * Correctly distinguish between skipped, changed, and did not change.
         """
-        fortran_addresses = [Address.parse(":f1"), Address.parse(":needs_formatting")]
-        smalltalk_addresses = [Address.parse(":s1"), Address.parse(":s2")]
+        fortran_addresses = [
+            Address("", target_name="f1"),
+            Address("", target_name="needs_formatting"),
+        ]
+        smalltalk_addresses = [Address("", target_name="s1"), Address("", target_name="s2")]
 
         fortran_targets = [
             self.make_target(addr, target_cls=FortranTarget) for addr in fortran_addresses
diff --git a/src/python/pants/core/goals/lint_test.py b/src/python/pants/core/goals/lint_test.py
index b7935fb7e4f..a7fd5b158a6 100644
--- a/src/python/pants/core/goals/lint_test.py
+++ b/src/python/pants/core/goals/lint_test.py
@@ -107,7 +107,7 @@ def rule_runner() -> RuleRunner:
 
 
 def make_target(address: Optional[Address] = None) -> Target:
-    return MockTarget({}, address=address or Address.parse(":tests"))
+    return MockTarget({}, address=address or Address("", target_name="tests"))
 
 
 def run_lint_rule(
@@ -189,8 +189,8 @@ def test_summary(rule_runner: RuleRunner) -> None:
     * Merge multiple results belonging to the same linter (`--per-file-caching`).
     * Decide correctly between skipped, failed, and succeeded.
     """
-    good_address = Address.parse(":good")
-    bad_address = Address.parse(":bad")
+    good_address = Address("", target_name="good")
+    bad_address = Address("", target_name="bad")
 
     def assert_expected(*, per_file_caching: bool) -> None:
         exit_code, stderr = run_lint_rule(
diff --git a/src/python/pants/core/goals/run_test.py b/src/python/pants/core/goals/run_test.py
index ec897c73cc2..5ec7f9c53c9 100644
--- a/src/python/pants/core/goals/run_test.py
+++ b/src/python/pants/core/goals/run_test.py
@@ -38,10 +38,10 @@ def create_mock_run_request(rule_runner: RuleRunner, program_text: bytes) -> Run
 
 def single_target_run(
     rule_runner: RuleRunner,
-    *,
+    address: Address,
     console: MockConsole,
+    *,
     program_text: bytes,
-    address_spec: str,
 ) -> Run:
     workspace = Workspace(rule_runner.scheduler)
     interactive_runner = InteractiveRunner(rule_runner.scheduler)
@@ -53,7 +53,6 @@ class TestBinaryTarget(Target):
         alias = "binary"
         core_fields = ()
 
-    address = Address.parse(address_spec)
     target = TestBinaryTarget({}, address=address)
     target_with_origin = TargetWithOrigin(
         target, AddressLiteralSpec(address.spec_path, address.target_name)
@@ -91,9 +90,9 @@ def test_normal_run(rule_runner: RuleRunner) -> None:
     program_text = b'#!/usr/bin/python\nprint("hello")'
     res = single_target_run(
         rule_runner,
-        console=console,
+        Address("some/addr"),
+        console,
         program_text=program_text,
-        address_spec="some/addr",
     )
     assert res.exit_code == 0
 
@@ -114,7 +113,5 @@ def test_materialize_input_files(rule_runner: RuleRunner) -> None:
 def test_failed_run(rule_runner: RuleRunner) -> None:
     console = MockConsole(use_colors=False)
     program_text = b'#!/usr/bin/python\nraise RuntimeError("foo")'
-    res = single_target_run(
-        rule_runner, console=console, program_text=program_text, address_spec="some/addr"
-    )
+    res = single_target_run(rule_runner, Address("some/addr"), console, program_text=program_text)
     assert res.exit_code == 1
diff --git a/src/python/pants/core/goals/test_test.py b/src/python/pants/core/goals/test_test.py
index 509ec1b28d9..6ccf6f95647 100644
--- a/src/python/pants/core/goals/test_test.py
+++ b/src/python/pants/core/goals/test_test.py
@@ -97,7 +97,7 @@ def rule_runner() -> RuleRunner:
 
 def make_target_with_origin(address: Optional[Address] = None) -> TargetWithOrigin:
     if address is None:
-        address = Address.parse(":tests")
+        address = Address("", target_name="tests")
     return TargetWithOrigin(
         MockTarget({}, address=address),
         origin=AddressLiteralSpec(address.spec_path, address.target_name),
@@ -233,8 +233,8 @@ def test_invalid_target_noops(rule_runner: RuleRunner) -> None:
 
 
 def test_summary(rule_runner: RuleRunner) -> None:
-    good_address = Address.parse(":good")
-    bad_address = Address.parse(":bad")
+    good_address = Address("", target_name="good")
+    bad_address = Address("", target_name="bad")
 
     exit_code, stderr = run_test_rule(
         rule_runner,
@@ -262,8 +262,8 @@ def test_debug_target(rule_runner: RuleRunner) -> None:
 
 
 def test_coverage(rule_runner: RuleRunner) -> None:
-    addr1 = Address.parse(":t1")
-    addr2 = Address.parse(":t2")
+    addr1 = Address("", target_name="t1")
+    addr2 = Address("", target_name="t2")
     exit_code, stderr = run_test_rule(
         rule_runner,
         field_set=SuccessfulFieldSet,
diff --git a/src/python/pants/core/goals/typecheck_test.py b/src/python/pants/core/goals/typecheck_test.py
index 3e865a9e5ca..516ea4e6637 100644
--- a/src/python/pants/core/goals/typecheck_test.py
+++ b/src/python/pants/core/goals/typecheck_test.py
@@ -111,7 +111,7 @@ def exit_code(_: Iterable[Address]) -> int:
 
 def make_target(address: Optional[Address] = None) -> Target:
     if address is None:
-        address = Address.parse(":tests")
+        address = Address("", target_name="tests")
     return MockTarget({}, address=address)
 
 
@@ -159,8 +159,8 @@ def test_invalid_target_noops() -> None:
 
 
 def test_summary() -> None:
-    good_address = Address.parse(":good")
-    bad_address = Address.parse(":bad")
+    good_address = Address("", target_name="good")
+    bad_address = Address("", target_name="bad")
     exit_code, stderr = run_typecheck_rule(
         request_types=[
             ConditionallySucceedsRequest,
diff --git a/src/python/pants/core/util_rules/source_files_test.py b/src/python/pants/core/util_rules/source_files_test.py
index a787afb0eca..eb3a1b6d91d 100644
--- a/src/python/pants/core/util_rules/source_files_test.py
+++ b/src/python/pants/core/util_rules/source_files_test.py
@@ -49,7 +49,7 @@ def mock_sources_field(
 ) -> SourcesField:
     sources_field = sources_field_cls(
         sources.source_files if include_sources else [],
-        address=Address.parse(f"{sources.source_root}:lib"),
+        address=Address(sources.source_root, target_name="lib"),
     )
     rule_runner.create_files(path=sources.source_root, files=sources.source_files)
     return sources_field
diff --git a/src/python/pants/engine/internals/build_files_test.py b/src/python/pants/engine/internals/build_files_test.py
index bc8f6ccf794..431044041ad 100644
--- a/src/python/pants/engine/internals/build_files_test.py
+++ b/src/python/pants/engine/internals/build_files_test.py
@@ -107,7 +107,7 @@ def make_target():
 
 
 def test_strip_address_origin() -> None:
-    addr = Address.parse("//:demo")
+    addr = Address("", target_name="demo")
     result = run_rule_with_mocks(
         strip_address_origins,
         rule_args=[AddressesWithOrigins([AddressWithOrigin(addr, AddressLiteralSpec("", "demo"))])],
diff --git a/src/python/pants/engine/internals/mapper_test.py b/src/python/pants/engine/internals/mapper_test.py
index 7a6d8d525a1..8a2761cd5be 100644
--- a/src/python/pants/engine/internals/mapper_test.py
+++ b/src/python/pants/engine/internals/mapper_test.py
@@ -69,8 +69,8 @@ def test_address_family_create_single() -> None:
     )
     assert "" == address_family.namespace
     assert {
-        Address.parse("//:one"): TargetAdaptor(type_alias="thing", name="one", age=42),
-        Address.parse("//:two"): TargetAdaptor(type_alias="thing", name="two", age=37),
+        Address("", target_name="one"): TargetAdaptor(type_alias="thing", name="one", age=42),
+        Address("", target_name="two"): TargetAdaptor(type_alias="thing", name="two", age=37),
     } == dict(address_family.addresses_to_target_adaptors.items())
 
 
@@ -89,8 +89,12 @@ def test_address_family_create_multiple() -> None:
 
     assert "name/space" == address_family.namespace
     assert {
-        Address.parse("name/space:one"): TargetAdaptor(type_alias="thing", name="one", age=42),
-        Address.parse("name/space:two"): TargetAdaptor(type_alias="thing", name="two", age=37),
+        Address("name/space", target_name="one"): TargetAdaptor(
+            type_alias="thing", name="one", age=42
+        ),
+        Address("name/space", target_name="two"): TargetAdaptor(
+            type_alias="thing", name="two", age=37
+        ),
     } == dict(address_family.addresses_to_target_adaptors.items())
 
 
diff --git a/src/python/pants/engine/target_test.py b/src/python/pants/engine/target_test.py
index de21ec1aa3a..3f584901415 100644
--- a/src/python/pants/engine/target_test.py
+++ b/src/python/pants/engine/target_test.py
@@ -122,14 +122,16 @@ class FortranTarget(Target):
 
 def test_invalid_fields_rejected() -> None:
     with pytest.raises(InvalidFieldException) as exc:
-        FortranTarget({"invalid_field": True}, address=Address.parse(":lib"))
+        FortranTarget({"invalid_field": True}, address=Address("", target_name="lib"))
     assert "Unrecognized field `invalid_field=True`" in str(exc)
     assert "//:lib" in str(exc)
 
 
 def test_get_field() -> None:
     extensions = ("FortranExt1",)
-    tgt = FortranTarget({FortranExtensions.alias: extensions}, address=Address.parse(":lib"))
+    tgt = FortranTarget(
+        {FortranExtensions.alias: extensions}, address=Address("", target_name="lib")
+    )
 
     assert tgt[FortranExtensions].value == extensions
     assert tgt.get(FortranExtensions).value == extensions
@@ -142,7 +144,7 @@ def test_get_field() -> None:
     # the field is not registered on the target type. To override the default field value, either
     # subclass the Field and create a new target, or, in your call site, interpret the result and
     # and apply your default.
-    default_field_tgt = FortranTarget({}, address=Address.parse(":default"))
+    default_field_tgt = FortranTarget({}, address=Address("", target_name="default"))
     assert default_field_tgt[FortranExtensions].value == ()
     assert default_field_tgt.get(FortranExtensions).value == ()
     assert default_field_tgt.get(FortranExtensions, default_raw_value=["FortranExt2"]).value == ()
@@ -173,7 +175,7 @@ def test_primitive_field_hydration_is_eager() -> None:
     with pytest.raises(InvalidFieldException) as exc:
         FortranTarget(
             {FortranExtensions.alias: ["FortranExt1", "DoesNotStartWithFortran"]},
-            address=Address.parse(":bad_extension"),
+            address=Address("", target_name="bad_extension"),
         )
     assert "DoesNotStartWithFortran" in str(exc)
     assert "//:bad_extension" in str(exc)
@@ -181,7 +183,7 @@ def test_primitive_field_hydration_is_eager() -> None:
 
 def test_has_fields() -> None:
     empty_union_membership = UnionMembership({})
-    tgt = FortranTarget({}, address=Address.parse(":lib"))
+    tgt = FortranTarget({}, address=Address("", target_name="lib"))
 
     assert tgt.field_types == (FortranExtensions, FortranSources)
     assert FortranTarget.class_field_types(union_membership=empty_union_membership) == (
@@ -228,7 +230,7 @@ def hydrate_field(
         *, raw_source_files: List[str], hydrated_source_files: Tuple[str, ...]
     ) -> FortranSourcesResult:
         sources_field = FortranTarget(
-            {FortranSources.alias: raw_source_files}, address=Address.parse(":lib")
+            {FortranSources.alias: raw_source_files}, address=Address("", target_name="lib")
         )[FortranSources]
         result: FortranSourcesResult = run_rule_with_mocks(
             hydrate_fortran_sources,
@@ -254,7 +256,7 @@ def hydrate_field(
 
     # Test that `raw_value` gets sanitized/validated eagerly.
     with pytest.raises(ValueError) as exc:
-        FortranTarget({FortranSources.alias: [0, 1, 2]}, address=Address.parse(":lib"))
+        FortranTarget({FortranSources.alias: [0, 1, 2]}, address=Address("", target_name="lib"))
     assert "Not all elements of the iterable have type" in str(exc)
 
     # Test post-hydration validation.
@@ -274,7 +276,7 @@ class CustomField(BoolField):
     )
     tgt_values = {CustomField.alias: True}
     tgt = FortranTarget(
-        tgt_values, address=Address.parse(":lib"), union_membership=union_membership
+        tgt_values, address=Address("", target_name="lib"), union_membership=union_membership
     )
 
     assert tgt.field_types == (FortranExtensions, FortranSources, CustomField)
@@ -295,7 +297,7 @@ class CustomField(BoolField):
     assert tgt[CustomField].value is True
 
     default_tgt = FortranTarget(
-        {}, address=Address.parse(":default"), union_membership=union_membership
+        {}, address=Address("", target_name="default"), union_membership=union_membership
     )
     assert default_tgt[CustomField].value is False
 
@@ -304,7 +306,7 @@ class OtherTarget(Target):
         alias = "other_target"
         core_fields = ()
 
-    other_tgt = OtherTarget({}, address=Address.parse(":other"))
+    other_tgt = OtherTarget({}, address=Address("", target_name="other"))
     assert other_tgt.plugin_fields == ()
     assert other_tgt.has_field(CustomField) is False
 
@@ -349,7 +351,7 @@ class CustomFortranTarget(Target):
         )
 
     custom_tgt = CustomFortranTarget(
-        {FortranExtensions.alias: ["FortranExt1"]}, address=Address.parse(":custom")
+        {FortranExtensions.alias: ["FortranExt1"]}, address=Address("", target_name="custom")
     )
 
     assert custom_tgt.has_field(FortranExtensions) is True
@@ -363,7 +365,7 @@ class CustomFortranTarget(Target):
     # Ensure that subclasses not defined on a target are not accepted. This allows us to, for
     # example, filter every target with `PythonSources` (or a subclass) and to ignore targets with
     # only `Sources`.
-    normal_tgt = FortranTarget({}, address=Address.parse(":normal"))
+    normal_tgt = FortranTarget({}, address=Address("", target_name="normal"))
     assert normal_tgt.has_field(FortranExtensions) is True
     assert normal_tgt.has_field(CustomFortranExtensions) is False
 
@@ -375,7 +377,7 @@ class CustomFortranTarget(Target):
 
     # Check custom default value
     assert (
-        CustomFortranTarget({}, address=Address.parse(":default"))[FortranExtensions].value
+        CustomFortranTarget({}, address=Address("", target_name="default"))[FortranExtensions].value
         == CustomFortranExtensions.default_extensions
     )
 
@@ -383,7 +385,7 @@ class CustomFortranTarget(Target):
     with pytest.raises(InvalidFieldException) as exc:
         CustomFortranTarget(
             {FortranExtensions.alias: CustomFortranExtensions.banned_extensions},
-            address=Address.parse(":invalid"),
+            address=Address("", target_name="invalid"),
         )
     assert str(list(CustomFortranExtensions.banned_extensions)) in str(exc)
     assert "//:invalid" in str(exc)
@@ -407,7 +409,7 @@ class RequiredTarget(Target):
         alias = "required_target"
         core_fields = (RequiredPrimitiveField, RequiredAsyncField)
 
-    address = Address.parse(":lib")
+    address = Address("", target_name="lib")
 
     # No errors when all defined
     RequiredTarget({"primitive": "present", "async": 0}, address=address)
@@ -437,7 +439,7 @@ class MockTarget(Target):
     # different address.
     single_source_tgt = MockTarget(
         {Sources.alias: ["demo.f95"], Tags.alias: ["demo"]},
-        address=Address.parse("src/fortran:demo"),
+        address=Address("src/fortran", target_name="demo"),
     )
     expected_single_source_address = Address(
         "src/fortran", relative_file_path="demo.f95", target_name="demo"
@@ -453,7 +455,8 @@ class MockTarget(Target):
     )
 
     subdir_tgt = MockTarget(
-        {Sources.alias: ["demo.f95", "subdir/demo.f95"]}, address=Address.parse("src/fortran:demo")
+        {Sources.alias: ["demo.f95", "subdir/demo.f95"]},
+        address=Address("src/fortran", target_name="demo"),
     )
     expected_subdir_address = Address(
         "src/fortran", relative_file_path="subdir/demo.f95", target_name="demo"
@@ -515,11 +518,11 @@ class UnrelatedFieldSet(FieldSet):
 
         unrelated_field: UnrelatedField
 
-    fortran_addr = Address.parse(":fortran")
+    fortran_addr = Address("", target_name="fortran")
     fortran_tgt = FortranTarget({}, address=fortran_addr)
-    unrelated_addr = Address.parse(":unrelated")
+    unrelated_addr = Address("", target_name="unrelated")
     unrelated_tgt = UnrelatedTarget({UnrelatedField.alias: "configured"}, address=unrelated_addr)
-    no_fields_addr = Address.parse(":no_fields")
+    no_fields_addr = Address("", target_name="no_fields")
     no_fields_tgt = NoFieldsTarget({}, address=no_fields_addr)
 
     assert FortranFieldSet.is_applicable(fortran_tgt) is True
@@ -560,7 +563,7 @@ def compute_value(
         ) -> Optional[CustomObject]:
             return super().compute_value(raw_value, address=address)
 
-    addr = Address.parse(":example")
+    addr = Address("", target_name="example")
 
     with pytest.raises(InvalidFieldTypeException) as exc:
         Example(1, address=addr)
@@ -584,7 +587,7 @@ class GivenEnum(StringField):
         valid_choices = LeafyGreens
         default = LeafyGreens.KALE.value
 
-    addr = Address.parse(":example")
+    addr = Address("", target_name="example")
     assert GivenStrings("spinach", address=addr).value == "spinach"
     assert GivenEnum("spinach", address=addr).value == "spinach"
 
@@ -613,7 +616,7 @@ def compute_value(
         ) -> Optional[Tuple[CustomObject, ...]]:
             return super().compute_value(raw_value, address=address)
 
-    addr = Address.parse(":example")
+    addr = Address("", target_name="example")
 
     def assert_flexible_constructor(raw_value: Iterable[CustomObject]) -> None:
         assert Example(raw_value, address=addr).value == tuple(raw_value)
@@ -636,7 +639,7 @@ def test_string_sequence_field() -> None:
     class Example(StringSequenceField):
         alias = "example"
 
-    addr = Address.parse(":example")
+    addr = Address("", target_name="example")
     assert Example(["hello", "world"], address=addr).value == ("hello", "world")
     assert Example(None, address=addr).value is None
     with pytest.raises(InvalidFieldTypeException):
@@ -649,7 +652,7 @@ def test_string_or_string_sequence_field() -> None:
     class Example(StringOrStringSequenceField):
         alias = "example"
 
-    addr = Address.parse(":example")
+    addr = Address("", target_name="example")
     assert Example(["hello", "world"], address=addr).value == ("hello", "world")
     assert Example("hello world", address=addr).value == ("hello world",)
     with pytest.raises(InvalidFieldTypeException):
@@ -686,7 +689,7 @@ def test_dict_string_to_string_sequence_field() -> None:
     class Example(DictStringToStringSequenceField):
         alias = "example"
 
-    addr = Address.parse(":example")
+    addr = Address("", target_name="example")
 
     def assert_flexible_constructor(raw_value: Dict[str, Iterable[str]]) -> None:
         assert Example(raw_value, address=addr).value == FrozenDict(