diff --git a/rust/afdo_test.go b/rust/afdo_test.go
index 80327af..0cdf704 100644
--- a/rust/afdo_test.go
+++ b/rust/afdo_test.go
@@ -54,8 +54,8 @@
 
 	expectedCFlag := fmt.Sprintf(afdoFlagFormat, "afdo_profiles_package/foo.afdo")
 
-	if !strings.Contains(foo.RuleParams.Command, expectedCFlag) {
-		t.Errorf("Expected 'foo' to enable afdo, but did not find %q in command %q", expectedCFlag, foo.RuleParams.Command)
+	if !strings.Contains(foo.Args["rustcFlags"], expectedCFlag) {
+		t.Errorf("Expected 'foo' to enable afdo, but did not find %q in cflags %q", expectedCFlag, foo.Args["rustcFlags"])
 	}
 }
 
@@ -96,17 +96,17 @@
 		rustMockedFiles.AddToFixture(),
 	).RunTestWithBp(t, bp)
 
-	fooArm := result.ModuleForTests("foo", "android_arm_armv7-a-neon").Description("rustc")
-	fooArm64 := result.ModuleForTests("foo", "android_arm64_armv8-a").Description("rustc")
+	fooArm := result.ModuleForTests("foo", "android_arm_armv7-a-neon").Rule("rustc")
+	fooArm64 := result.ModuleForTests("foo", "android_arm64_armv8-a").Rule("rustc")
 
 	expectedCFlagArm := fmt.Sprintf(afdoFlagFormat, "afdo_profiles_package/foo_arm.afdo")
 	expectedCFlagArm64 := fmt.Sprintf(afdoFlagFormat, "afdo_profiles_package/foo_arm64.afdo")
 
-	if !strings.Contains(fooArm.RuleParams.Command, expectedCFlagArm) {
-		t.Errorf("Expected 'fooArm' to enable afdo, but did not find %q in command %q", expectedCFlagArm, fooArm.RuleParams.Command)
+	if !strings.Contains(fooArm.Args["rustcFlags"], expectedCFlagArm) {
+		t.Errorf("Expected 'fooArm' to enable afdo, but did not find %q in cflags %q", expectedCFlagArm, fooArm.Args["rustcFlags"])
 	}
 
-	if !strings.Contains(fooArm64.RuleParams.Command, expectedCFlagArm64) {
-		t.Errorf("Expected 'fooArm64' to enable afdo, but did not find %q in command %q", expectedCFlagArm64, fooArm.RuleParams.Command)
+	if !strings.Contains(fooArm64.Args["rustcFlags"], expectedCFlagArm64) {
+		t.Errorf("Expected 'fooArm64' to enable afdo, but did not find %q in cflags %q", expectedCFlagArm64, fooArm64.Args["rustcFlags"])
 	}
 }
diff --git a/rust/binary.go b/rust/binary.go
index 353381d..aee4da6 100644
--- a/rust/binary.go
+++ b/rust/binary.go
@@ -149,6 +149,7 @@
 
 	flags.RustFlags = append(flags.RustFlags, deps.depFlags...)
 	flags.LinkFlags = append(flags.LinkFlags, deps.depLinkFlags...)
+	flags.LinkFlags = append(flags.LinkFlags, deps.linkObjects.Strings()...)
 
 	if binary.stripper.NeedsStrip(ctx) {
 		strippedOutputFile := outputFile
@@ -159,7 +160,7 @@
 	}
 	binary.baseCompiler.unstrippedOutputFile = outputFile
 
-	ret.kytheFile = TransformSrcToBinary(ctx, binary, crateRootPath, deps, flags, outputFile).kytheFile
+	ret.kytheFile = TransformSrcToBinary(ctx, crateRootPath, deps, flags, outputFile).kytheFile
 	return ret
 }
 
diff --git a/rust/binary_test.go b/rust/binary_test.go
index ab1d2bc..dff94ac 100644
--- a/rust/binary_test.go
+++ b/rust/binary_test.go
@@ -135,7 +135,7 @@
 
 	fizzBuzz := ctx.ModuleForTests("fizz-buzz", "linux_glibc_x86_64").Rule("rustc")
 
-	flags := fizzBuzz.RuleParams.Command
+	flags := fizzBuzz.Args["rustcFlags"]
 	if strings.Contains(flags, "--test") {
 		t.Errorf("extra --test flag, rustcFlags: %#v", flags)
 	}
@@ -150,11 +150,11 @@
 			bootstrap: true,
 		}`)
 
-	foo := ctx.ModuleForTests("foo", "android_arm64_armv8-a").Rule("rustc")
+	foo := ctx.ModuleForTests("foo", "android_arm64_armv8-a").Rule("rustLink")
 
 	flag := "-Wl,-dynamic-linker,/system/bin/bootstrap/linker64"
-	if !strings.Contains(foo.RuleParams.Command, flag) {
-		t.Errorf("missing link flag to use bootstrap linker, expecting %#v, command: %#v", flag, foo.RuleParams.Command)
+	if !strings.Contains(foo.Args["linkFlags"], flag) {
+		t.Errorf("missing link flag to use bootstrap linker, expecting %#v, linkFlags: %#v", flag, foo.Args["linkFlags"])
 	}
 }
 
@@ -167,17 +167,19 @@
 		}`)
 
 	fizzOut := ctx.ModuleForTests("fizz", "android_arm64_armv8-a").Rule("rustc")
+	fizzOutLink := ctx.ModuleForTests("fizz", "android_arm64_armv8-a").Rule("rustLink")
 	fizzMod := ctx.ModuleForTests("fizz", "android_arm64_armv8-a").Module().(*Module)
 
-	flags := fizzOut.RuleParams.Command
+	flags := fizzOut.Args["rustcFlags"]
+	linkFlags := fizzOutLink.Args["linkFlags"]
 	if !strings.Contains(flags, "-C relocation-model=static") {
-		t.Errorf("static binary missing '-C relocation-model=static' in command, found: %#v", flags)
+		t.Errorf("static binary missing '-C relocation-model=static' in rustcFlags, found: %#v", flags)
 	}
 	if !strings.Contains(flags, "-C panic=abort") {
-		t.Errorf("static binary missing '-C panic=abort' in command, found: %#v", flags)
+		t.Errorf("static binary missing '-C panic=abort' in rustcFlags, found: %#v", flags)
 	}
-	if !strings.Contains(flags, "-static") {
-		t.Errorf("static binary missing '-static' in command, found: %#v", flags)
+	if !strings.Contains(linkFlags, "-static") {
+		t.Errorf("static binary missing '-static' in linkFlags, found: %#v", flags)
 	}
 
 	if !android.InList("libc", fizzMod.Properties.AndroidMkStaticLibs) {
@@ -199,9 +201,10 @@
 			name: "libfoo",
 		}`)
 
-	fizzBuzz := ctx.ModuleForTests("fizz-buzz", "android_arm64_armv8-a").Rule("rustc")
-	if !strings.Contains(fizzBuzz.RuleParams.Command, "/libfoo.so") {
-		t.Errorf("missing shared dependency 'libfoo.so' in command: %#v", fizzBuzz.RuleParams.Command)
+	fizzBuzz := ctx.ModuleForTests("fizz-buzz", "android_arm64_armv8-a").Rule("rustLink")
+	linkFlags := fizzBuzz.Args["linkFlags"]
+	if !strings.Contains(linkFlags, "/libfoo.so") {
+		t.Errorf("missing shared dependency 'libfoo.so' in linkFlags: %#v", linkFlags)
 	}
 }
 
diff --git a/rust/builder.go b/rust/builder.go
index 0740518..b1f049d 100644
--- a/rust/builder.go
+++ b/rust/builder.go
@@ -15,7 +15,6 @@
 package rust
 
 import (
-	"fmt"
 	"path/filepath"
 	"strings"
 
@@ -26,6 +25,54 @@
 )
 
 var (
+	_     = pctx.SourcePathVariable("rustcCmd", "${config.RustBin}/rustc")
+	_     = pctx.SourcePathVariable("mkcraterspCmd", "build/soong/scripts/mkcratersp.py")
+	rustc = pctx.AndroidStaticRule("rustc",
+		blueprint.RuleParams{
+			Command: "$envVars $rustcCmd " +
+				"-C linker=$mkcraterspCmd " +
+				"--emit link -o $out --emit dep-info=$out.d.raw $in ${libFlags} $rustcFlags" +
+				" && grep \"^$out:\" $out.d.raw > $out.d",
+			CommandDeps: []string{"$rustcCmd", "$mkcraterspCmd"},
+			// Rustc deps-info writes out make compatible dep files: https://github.com/rust-lang/rust/issues/7633
+			// Rustc emits unneeded dependency lines for the .d and input .rs files.
+			// Those extra lines cause ninja warning:
+			//     "warning: depfile has multiple output paths"
+			// For ninja, we keep/grep only the dependency rule for the rust $out file.
+			Deps:    blueprint.DepsGCC,
+			Depfile: "$out.d",
+		},
+		"rustcFlags", "libFlags", "envVars")
+	rustLink = pctx.AndroidStaticRule("rustLink",
+		blueprint.RuleParams{
+			Command: "${config.RustLinker} -o $out ${crtBegin} ${earlyLinkFlags} @$in ${linkFlags} ${crtEnd}",
+		},
+		"earlyLinkFlags", "linkFlags", "crtBegin", "crtEnd")
+
+	_       = pctx.SourcePathVariable("rustdocCmd", "${config.RustBin}/rustdoc")
+	rustdoc = pctx.AndroidStaticRule("rustdoc",
+		blueprint.RuleParams{
+			Command: "$envVars $rustdocCmd $rustdocFlags $in -o $outDir && " +
+				"touch $out",
+			CommandDeps: []string{"$rustdocCmd"},
+		},
+		"rustdocFlags", "outDir", "envVars")
+
+	_            = pctx.SourcePathVariable("clippyCmd", "${config.RustBin}/clippy-driver")
+	clippyDriver = pctx.AndroidStaticRule("clippy",
+		blueprint.RuleParams{
+			Command: "$envVars $clippyCmd " +
+				// Because clippy-driver uses rustc as backend, we need to have some output even during the linting.
+				// Use the metadata output as it has the smallest footprint.
+				"--emit metadata -o $out --emit dep-info=$out.d.raw $in ${libFlags} " +
+				"$rustcFlags $clippyFlags" +
+				" && grep \"^$out:\" $out.d.raw > $out.d",
+			CommandDeps: []string{"$clippyCmd"},
+			Deps:        blueprint.DepsGCC,
+			Depfile:     "$out.d",
+		},
+		"rustcFlags", "libFlags", "clippyFlags", "envVars")
+
 	zip = pctx.AndroidStaticRule("zip",
 		blueprint.RuleParams{
 			Command:        "cat $out.rsp | tr ' ' '\\n' | tr -d \\' | sort -u > ${out}.tmp && ${SoongZipCmd} -o ${out} -C $$OUT_DIR -l ${out}.tmp",
@@ -34,7 +81,7 @@
 			RspfileContent: "$in",
 		})
 
-	cpDir = pctx.AndroidStaticRule("cpDir",
+	cp = pctx.AndroidStaticRule("cp",
 		blueprint.RuleParams{
 			Command:        "cp `cat $outDir.rsp` $outDir",
 			Rspfile:        "${outDir}.rsp",
@@ -42,12 +89,6 @@
 		},
 		"outDir")
 
-	cp = pctx.AndroidStaticRule("cp",
-		blueprint.RuleParams{
-			Command:     "rm -f $out && cp $in $out",
-			Description: "cp $out",
-		})
-
 	// Cross-referencing:
 	_ = pctx.SourcePathVariable("rustExtractor",
 		"prebuilts/build-tools/${config.HostPrebuiltTag}/bin/rust_extractor")
@@ -55,6 +96,23 @@
 		func(ctx android.PackageVarContext) string { return ctx.Config().XrefCorpusName() })
 	_ = pctx.VariableFunc("kytheCuEncoding",
 		func(ctx android.PackageVarContext) string { return ctx.Config().XrefCuEncoding() })
+	_            = pctx.SourcePathVariable("kytheVnames", "build/soong/vnames.json")
+	kytheExtract = pctx.AndroidStaticRule("kythe",
+		blueprint.RuleParams{
+			Command: `KYTHE_CORPUS=${kytheCorpus} ` +
+				`KYTHE_OUTPUT_FILE=$out ` +
+				`KYTHE_VNAMES=$kytheVnames ` +
+				`KYTHE_KZIP_ENCODING=${kytheCuEncoding} ` +
+				`KYTHE_CANONICALIZE_VNAME_PATHS=prefer-relative ` +
+				`$rustExtractor $envVars ` +
+				`$rustcCmd ` +
+				`-C linker=true ` +
+				`$in ${libFlags} $rustcFlags`,
+			CommandDeps:    []string{"$rustExtractor", "$kytheVnames"},
+			Rspfile:        "${out}.rsp",
+			RspfileContent: "$in",
+		},
+		"rustcFlags", "libFlags", "envVars")
 )
 
 type buildOutput struct {
@@ -66,40 +124,40 @@
 	pctx.HostBinToolVariable("SoongZipCmd", "soong_zip")
 }
 
-func TransformSrcToBinary(ctx ModuleContext, c compiler, mainSrc android.Path, deps PathDeps, flags Flags,
+func TransformSrcToBinary(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags,
 	outputFile android.WritablePath) buildOutput {
 	flags.GlobalRustFlags = append(flags.GlobalRustFlags, "-C lto=thin")
 
-	return transformSrctoCrate(ctx, c, mainSrc, deps, flags, outputFile, "bin")
+	return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "bin")
 }
 
-func TransformSrctoRlib(ctx ModuleContext, c compiler, mainSrc android.Path, deps PathDeps, flags Flags,
+func TransformSrctoRlib(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags,
 	outputFile android.WritablePath) buildOutput {
-	return transformSrctoCrate(ctx, c, mainSrc, deps, flags, outputFile, "rlib")
+	return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "rlib")
 }
 
-func TransformSrctoDylib(ctx ModuleContext, c compiler, mainSrc android.Path, deps PathDeps, flags Flags,
+func TransformSrctoDylib(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags,
 	outputFile android.WritablePath) buildOutput {
 	flags.GlobalRustFlags = append(flags.GlobalRustFlags, "-C lto=thin")
 
-	return transformSrctoCrate(ctx, c, mainSrc, deps, flags, outputFile, "dylib")
+	return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "dylib")
 }
 
-func TransformSrctoStatic(ctx ModuleContext, c compiler, mainSrc android.Path, deps PathDeps, flags Flags,
+func TransformSrctoStatic(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags,
 	outputFile android.WritablePath) buildOutput {
 	flags.GlobalRustFlags = append(flags.GlobalRustFlags, "-C lto=thin")
-	return transformSrctoCrate(ctx, c, mainSrc, deps, flags, outputFile, "staticlib")
+	return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "staticlib")
 }
 
-func TransformSrctoShared(ctx ModuleContext, c compiler, mainSrc android.Path, deps PathDeps, flags Flags,
+func TransformSrctoShared(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags,
 	outputFile android.WritablePath) buildOutput {
 	flags.GlobalRustFlags = append(flags.GlobalRustFlags, "-C lto=thin")
-	return transformSrctoCrate(ctx, c, mainSrc, deps, flags, outputFile, "cdylib")
+	return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "cdylib")
 }
 
-func TransformSrctoProcMacro(ctx ModuleContext, c compiler, mainSrc android.Path, deps PathDeps,
+func TransformSrctoProcMacro(ctx ModuleContext, mainSrc android.Path, deps PathDeps,
 	flags Flags, outputFile android.WritablePath) buildOutput {
-	return transformSrctoCrate(ctx, c, mainSrc, deps, flags, outputFile, "proc-macro")
+	return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "proc-macro")
 }
 
 func rustLibsToPaths(libs RustLibraries) android.Paths {
@@ -110,46 +168,28 @@
 	return paths
 }
 
-func makeLibFlags(deps PathDeps, ruleCmd *android.RuleBuilderCommand) []string {
+func makeLibFlags(deps PathDeps) []string {
 	var libFlags []string
 
 	// Collect library/crate flags
-	for _, lib := range deps.Rlibs.ToListDirect() {
-		libPath := ruleCmd.PathForInput(lib.Path)
-		libFlags = append(libFlags, "--extern "+lib.CrateName+"="+libPath)
+	for _, lib := range deps.RLibs {
+		libFlags = append(libFlags, "--extern "+lib.CrateName+"="+lib.Path.String())
 	}
-	for _, lib := range deps.Dylibs.ToListDirect() {
-		libPath := ruleCmd.PathForInput(lib.Path)
-		libFlags = append(libFlags, "--extern "+lib.CrateName+"="+libPath)
+	for _, lib := range deps.DyLibs {
+		libFlags = append(libFlags, "--extern "+lib.CrateName+"="+lib.Path.String())
 	}
-	for _, procMacro := range deps.ProcMacros.ToListDirect() {
-		procMacroPath := ruleCmd.PathForInput(procMacro.Path)
-		libFlags = append(libFlags, "--extern "+procMacro.CrateName+"="+procMacroPath)
+	for _, proc_macro := range deps.ProcMacros {
+		libFlags = append(libFlags, "--extern "+proc_macro.CrateName+"="+proc_macro.Path.String())
 	}
 
 	for _, path := range deps.linkDirs {
-		libFlags = append(libFlags, "-L "+ruleCmd.PathForInput(path))
+		libFlags = append(libFlags, "-L "+path)
 	}
 
 	return libFlags
 }
 
-func collectImplicits(deps PathDeps) android.Paths {
-	depPaths := android.Paths{}
-	depPaths = append(depPaths, rustLibsToPaths(deps.Rlibs.ToList())...)
-	depPaths = append(depPaths, rustLibsToPaths(deps.Dylibs.ToList())...)
-	depPaths = append(depPaths, rustLibsToPaths(deps.ProcMacros.ToList())...)
-	depPaths = append(depPaths, deps.AfdoProfiles...)
-	depPaths = append(depPaths, deps.WholeStaticLibs...)
-	depPaths = append(depPaths, deps.SrcDeps...)
-	depPaths = append(depPaths, deps.srcProviderFiles...)
-	depPaths = append(depPaths, deps.LibDeps...)
-	depPaths = append(depPaths, deps.linkObjects...)
-	depPaths = append(depPaths, deps.BuildToolSrcDeps...)
-	return depPaths
-}
-
-func rustEnvVars(ctx ModuleContext, deps PathDeps, cmd *android.RuleBuilderCommand) []string {
+func rustEnvVars(ctx ModuleContext, deps PathDeps) []string {
 	var envVars []string
 
 	// libstd requires a specific environment variable to be set. This is
@@ -163,17 +203,15 @@
 		moduleGenDir := ctx.RustModule().compiler.CargoOutDir()
 		// We must calculate an absolute path for OUT_DIR since Rust's include! macro (which normally consumes this)
 		// assumes that paths are relative to the source file.
-		var outDir string
-		if filepath.IsAbs(moduleGenDir.String()) {
-			// If OUT_DIR is absolute, then moduleGenDir will be an absolute path, so we don't need to set this to anything.
-			outDir = moduleGenDir.String()
-		} else if moduleGenDir.Valid() {
+		var outDirPrefix string
+		if !filepath.IsAbs(moduleGenDir.String()) {
 			// If OUT_DIR is not absolute, we use $$PWD to generate an absolute path (os.Getwd() returns '/')
-			outDir = filepath.Join("$$PWD/", cmd.PathForInput(moduleGenDir.Path()))
+			outDirPrefix = "$$PWD/"
 		} else {
-			outDir = "$$PWD/"
+			// If OUT_DIR is absolute, then moduleGenDir will be an absolute path, so we don't need to set this to anything.
+			outDirPrefix = ""
 		}
-		envVars = append(envVars, "OUT_DIR="+outDir)
+		envVars = append(envVars, "OUT_DIR="+filepath.Join(outDirPrefix, moduleGenDir.String()))
 	} else {
 		// TODO(pcc): Change this to "OUT_DIR=" after fixing crates to not rely on this value.
 		envVars = append(envVars, "OUT_DIR=out")
@@ -204,7 +242,7 @@
 		}
 	}
 
-	envVars = append(envVars, "AR="+cmd.PathForTool(deps.Llvm_ar))
+	envVars = append(envVars, "AR=${cc_config.ClangBin}/llvm-ar")
 
 	if ctx.Darwin() {
 		envVars = append(envVars, "ANDROID_RUST_DARWIN=true")
@@ -213,18 +251,21 @@
 	return envVars
 }
 
-func transformSrctoCrate(ctx ModuleContext, comp compiler, main android.Path, deps PathDeps, flags Flags,
+func transformSrctoCrate(ctx ModuleContext, main android.Path, deps PathDeps, flags Flags,
 	outputFile android.WritablePath, crateType string) buildOutput {
 
 	var inputs android.Paths
+	var implicits, linkImplicits, linkOrderOnly android.Paths
 	var output buildOutput
 	var rustcFlags, linkFlags []string
-	var earlyLinkFlags []string
+	var earlyLinkFlags string
 
 	output.outputFile = outputFile
 	crateName := ctx.RustModule().CrateName()
 	targetTriple := ctx.toolchain().RustTriple()
 
+	envVars := rustEnvVars(ctx, deps)
+
 	inputs = append(inputs, main)
 
 	// Collect rustc flags
@@ -245,6 +286,7 @@
 	// Enable incremental compilation if requested by user
 	if ctx.Config().IsEnvTrue("SOONG_RUSTC_INCREMENTAL") {
 		incrementalPath := android.PathForOutput(ctx, "rustc").String()
+
 		rustcFlags = append(rustcFlags, "-Cincremental="+incrementalPath)
 	}
 
@@ -256,16 +298,36 @@
 
 	// Collect linker flags
 	if !ctx.Darwin() {
-		earlyLinkFlags = append(earlyLinkFlags, "-Wl,--as-needed")
+		earlyLinkFlags = "-Wl,--as-needed"
 	}
 
+	linkFlags = append(linkFlags, flags.GlobalLinkFlags...)
+	linkFlags = append(linkFlags, flags.LinkFlags...)
+
+	// Check if this module needs to use the bootstrap linker
+	if ctx.RustModule().Bootstrap() && !ctx.RustModule().InRecovery() && !ctx.RustModule().InRamdisk() && !ctx.RustModule().InVendorRamdisk() {
+		dynamicLinker := "-Wl,-dynamic-linker,/system/bin/bootstrap/linker"
+		if ctx.toolchain().Is64Bit() {
+			dynamicLinker += "64"
+		}
+		linkFlags = append(linkFlags, dynamicLinker)
+	}
+
+	libFlags := makeLibFlags(deps)
+
 	// Collect dependencies
-	var linkImplicits android.Paths
-	implicits := collectImplicits(deps)
-	toolImplicits := android.Concat(deps.BuildToolDeps)
+	implicits = append(implicits, rustLibsToPaths(deps.RLibs)...)
+	implicits = append(implicits, rustLibsToPaths(deps.DyLibs)...)
+	implicits = append(implicits, rustLibsToPaths(deps.ProcMacros)...)
+	implicits = append(implicits, deps.AfdoProfiles...)
+	implicits = append(implicits, deps.srcProviderFiles...)
+	implicits = append(implicits, deps.WholeStaticLibs...)
+
+	linkImplicits = append(linkImplicits, deps.LibDeps...)
 	linkImplicits = append(linkImplicits, deps.CrtBegin...)
 	linkImplicits = append(linkImplicits, deps.CrtEnd...)
-	implicits = append(implicits, comp.compilationSourcesAndData(ctx)...)
+
+	linkOrderOnly = append(linkOrderOnly, deps.linkObjects...)
 
 	if len(deps.SrcDeps) > 0 {
 		moduleGenDir := ctx.RustModule().compiler.CargoOutDir()
@@ -280,7 +342,7 @@
 		}
 
 		ctx.Build(pctx, android.BuildParams{
-			Rule:        cpDir,
+			Rule:        cp,
 			Description: "cp " + moduleGenDir.Path().Rel(),
 			Outputs:     outputs,
 			Inputs:      deps.SrcDeps,
@@ -292,176 +354,81 @@
 	}
 
 	if flags.Clippy {
-		// TODO(b/298461712) remove this hack to let slim manifest branches build
-		if deps.Clippy_driver == nil {
-			deps.Clippy_driver = config.RustPath(ctx, "bin/clippy-driver")
-		}
-
-		clippyRule := getRuleBuilder(ctx, pctx, false, "clippy")
-		clippyCmd := clippyRule.Command()
 		clippyFile := android.PathForModuleOut(ctx, outputFile.Base()+".clippy")
-		clippyDepInfoFile := android.PathForModuleOut(ctx, outputFile.Base()+".clippy.d.raw")
-		clippyDepFile := android.PathForModuleOut(ctx, outputFile.Base()+".clippy.d")
-
-		clippyCmd.
-			Flags(rustEnvVars(ctx, deps, clippyCmd)).
-			Tool(deps.Clippy_driver).
-			Flag("--emit metadata").
-			FlagWithOutput("-o ", clippyFile).
-			FlagWithOutput("--emit dep-info=", clippyDepInfoFile).
-			Inputs(inputs).
-			Flags(makeLibFlags(deps, clippyCmd)).
-			Flags(rustcFlags).
-			Flags(flags.ClippyFlags).
-			ImplicitTools(toolImplicits).
-			Implicits(implicits)
-
-		depfileCreationCmd := clippyRule.Command()
-		depfileCreationCmd.
-			Flag(fmt.Sprintf(
-				`grep "^%s:" %s >`,
-				depfileCreationCmd.PathForOutput(clippyFile),
-				depfileCreationCmd.PathForOutput(clippyDepInfoFile),
-			)).
-			DepFile(clippyDepFile)
-
-		clippyRule.BuildWithUnescapedNinjaVars("clippy", "clippy "+main.Rel())
-
+		ctx.Build(pctx, android.BuildParams{
+			Rule:        clippyDriver,
+			Description: "clippy " + main.Rel(),
+			Output:      clippyFile,
+			Inputs:      inputs,
+			Implicits:   implicits,
+			Args: map[string]string{
+				"rustcFlags":  strings.Join(rustcFlags, " "),
+				"libFlags":    strings.Join(libFlags, " "),
+				"clippyFlags": strings.Join(flags.ClippyFlags, " "),
+				"envVars":     strings.Join(envVars, " "),
+			},
+		})
 		// Declare the clippy build as an implicit dependency of the original crate.
 		implicits = append(implicits, clippyFile)
 	}
 
-	sboxDirectory := "rustc"
-	rustSboxOutputFile := android.PathForModuleOut(ctx, sboxDirectory, outputFile.Base())
-	depFile := android.PathForModuleOut(ctx, sboxDirectory, rustSboxOutputFile.Base()+".d")
-	depInfoFile := android.PathForModuleOut(ctx, sboxDirectory, rustSboxOutputFile.Base()+".d.raw")
-	var rustcImplicitOutputs android.WritablePaths
-
-	sandboxedCompilation := comp.crateRoot(ctx) != nil
-	rustcRule := getRuleBuilder(ctx, pctx, sandboxedCompilation, sboxDirectory)
-	rustcCmd := rustcRule.Command()
-
-	linkFlags = append(linkFlags, flags.GlobalLinkFlags...)
-	linkFlags = append(linkFlags, flags.LinkFlags...)
-	linkFlags = append(linkFlags, rustcCmd.PathsForInputs(deps.linkObjects)...)
-
-	// Check if this module needs to use the bootstrap linker
-	if ctx.RustModule().Bootstrap() && !ctx.RustModule().InRecovery() && !ctx.RustModule().InRamdisk() && !ctx.RustModule().InVendorRamdisk() {
-		dynamicLinker := "-Wl,-dynamic-linker,/system/bin/bootstrap/linker"
-		if ctx.toolchain().Is64Bit() {
-			dynamicLinker += "64"
-		}
-		linkFlags = append(linkFlags, dynamicLinker)
-	}
-
-	libFlags := makeLibFlags(deps, rustcCmd)
-
+	rustcOutputFile := outputFile
 	usesLinker := crateType == "bin" || crateType == "dylib" || crateType == "cdylib" || crateType == "proc-macro"
 	if usesLinker {
-		rustSboxOutputFile = android.PathForModuleOut(ctx, sboxDirectory, rustSboxOutputFile.Base()+".rsp")
-		rustcImplicitOutputs = android.WritablePaths{
-			android.PathForModuleOut(ctx, sboxDirectory, rustSboxOutputFile.Base()+".whole.a"),
-			android.PathForModuleOut(ctx, sboxDirectory, rustSboxOutputFile.Base()+".a"),
-		}
+		rustcOutputFile = android.PathForModuleOut(ctx, outputFile.Base()+".rsp")
 	}
 
-	// TODO(b/298461712) remove this hack to let slim manifest branches build
-	if deps.Rustc == nil {
-		deps.Rustc = config.RustPath(ctx, "bin/rustc")
-	}
+	ctx.Build(pctx, android.BuildParams{
+		Rule:        rustc,
+		Description: "rustc " + main.Rel(),
+		Output:      rustcOutputFile,
+		Inputs:      inputs,
+		Implicits:   implicits,
+		Args: map[string]string{
+			"rustcFlags": strings.Join(rustcFlags, " "),
+			"libFlags":   strings.Join(libFlags, " "),
+			"envVars":    strings.Join(envVars, " "),
+		},
+	})
 
-	rustcCmd.
-		Flags(rustEnvVars(ctx, deps, rustcCmd)).
-		Tool(deps.Rustc).
-		FlagWithInput("-C linker=", android.PathForSource(ctx, "build", "soong", "scripts", "mkcratersp.py")).
-		Flag("--emit link").
-		Flag("-o").
-		Output(rustSboxOutputFile).
-		FlagWithOutput("--emit dep-info=", depInfoFile).
-		Inputs(inputs).
-		Flags(libFlags).
-		ImplicitTools(toolImplicits).
-		Implicits(implicits).
-		Flags(rustcFlags).
-		ImplicitOutputs(rustcImplicitOutputs)
-
-	depfileCreationCmd := rustcRule.Command()
-	depfileCreationCmd.
-		Flag(fmt.Sprintf(
-			`grep "^%s:" %s >`,
-			depfileCreationCmd.PathForOutput(rustSboxOutputFile),
-			depfileCreationCmd.PathForOutput(depInfoFile),
-		)).
-		DepFile(depFile)
-
-	if !usesLinker {
+	if usesLinker {
 		ctx.Build(pctx, android.BuildParams{
-			Rule:   cp,
-			Input:  rustSboxOutputFile,
-			Output: outputFile,
-		})
-	} else {
-		// TODO: delmerico - separate rustLink into its own rule
-		// mkcratersp.py hardcodes paths to files within the sandbox, so
-		// those need to be renamed/symlinked to something in the rustLink sandbox
-		// if we want to separate the rules
-		linkerSboxOutputFile := android.PathForModuleOut(ctx, sboxDirectory, outputFile.Base())
-		rustLinkCmd := rustcRule.Command()
-		rustLinkCmd.
-			Tool(deps.Clang).
-			Flag("-o").
-			Output(linkerSboxOutputFile).
-			Inputs(deps.CrtBegin).
-			Flags(earlyLinkFlags).
-			FlagWithInput("@", rustSboxOutputFile).
-			Flags(linkFlags).
-			Inputs(deps.CrtEnd).
-			ImplicitTools(toolImplicits).
-			Implicits(rustcImplicitOutputs.Paths()).
-			Implicits(implicits).
-			Implicits(linkImplicits)
-		ctx.Build(pctx, android.BuildParams{
-			Rule:   cp,
-			Input:  linkerSboxOutputFile,
-			Output: outputFile,
+			Rule:        rustLink,
+			Description: "rustLink " + main.Rel(),
+			Output:      outputFile,
+			Inputs:      android.Paths{rustcOutputFile},
+			Implicits:   linkImplicits,
+			OrderOnly:   linkOrderOnly,
+			Args: map[string]string{
+				"earlyLinkFlags": earlyLinkFlags,
+				"linkFlags":      strings.Join(linkFlags, " "),
+				"crtBegin":       strings.Join(deps.CrtBegin.Strings(), " "),
+				"crtEnd":         strings.Join(deps.CrtEnd.Strings(), " "),
+			},
 		})
 	}
 
-	rustcRule.BuildWithUnescapedNinjaVars("rustc", "rustc "+main.Rel())
-
 	if flags.EmitXrefs {
-		kytheRule := getRuleBuilder(ctx, pctx, false, "kythe")
-		kytheCmd := kytheRule.Command()
 		kytheFile := android.PathForModuleOut(ctx, outputFile.Base()+".kzip")
-		kytheCmd.
-			Flag("KYTHE_CORPUS=${kytheCorpus}").
-			FlagWithOutput("KYTHE_OUTPUT_FILE=", kytheFile).
-			FlagWithInput("KYTHE_VNAMES=", android.PathForSource(ctx, "build", "soong", "vnames.json")).
-			Flag("KYTHE_KZIP_ENCODING=${kytheCuEncoding}").
-			Flag("KYTHE_CANONICALIZE_VNAME_PATHS=prefer-relative").
-			Tool(ctx.Config().PrebuiltBuildTool(ctx, "rust_extractor")).
-			Flags(rustEnvVars(ctx, deps, kytheCmd)).
-			Tool(deps.Rustc).
-			Flag("-C linker=true").
-			Inputs(inputs).
-			Flags(makeLibFlags(deps, kytheCmd)).
-			Flags(rustcFlags).
-			ImplicitTools(toolImplicits).
-			Implicits(implicits)
-		kytheRule.BuildWithUnescapedNinjaVars("kythe", "Xref Rust extractor "+main.Rel())
+		ctx.Build(pctx, android.BuildParams{
+			Rule:        kytheExtract,
+			Description: "Xref Rust extractor " + main.Rel(),
+			Output:      kytheFile,
+			Inputs:      inputs,
+			Implicits:   implicits,
+			Args: map[string]string{
+				"rustcFlags": strings.Join(rustcFlags, " "),
+				"libFlags":   strings.Join(libFlags, " "),
+				"envVars":    strings.Join(envVars, " "),
+			},
+		})
 		output.kytheFile = kytheFile
 	}
 	return output
 }
 
-func Rustdoc(ctx ModuleContext, main android.Path, deps PathDeps, flags Flags) android.ModuleOutPath {
-	// TODO(b/298461712) remove this hack to let slim manifest branches build
-	if deps.Rustdoc == nil {
-		deps.Rustdoc = config.RustPath(ctx, "bin/rustdoc")
-	}
-
-	rustdocRule := getRuleBuilder(ctx, pctx, false, "rustdoc")
-	rustdocCmd := rustdocRule.Command()
+func Rustdoc(ctx ModuleContext, main android.Path, deps PathDeps,
+	flags Flags) android.ModuleOutPath {
 
 	rustdocFlags := append([]string{}, flags.RustdocFlags...)
 	rustdocFlags = append(rustdocFlags, "--sysroot=/dev/null")
@@ -480,7 +447,7 @@
 	crateName := ctx.RustModule().CrateName()
 	rustdocFlags = append(rustdocFlags, "--crate-name "+crateName)
 
-	rustdocFlags = append(rustdocFlags, makeLibFlags(deps, rustdocCmd)...)
+	rustdocFlags = append(rustdocFlags, makeLibFlags(deps)...)
 	docTimestampFile := android.PathForModuleOut(ctx, "rustdoc.timestamp")
 
 	// Silence warnings about renamed lints for third-party crates
@@ -496,26 +463,18 @@
 	// https://github.com/rust-lang/rust/blob/master/src/librustdoc/html/render/write_shared.rs#L144-L146
 	docDir := android.PathForOutput(ctx, "rustdoc")
 
-	rustdocCmd.
-		Flags(rustEnvVars(ctx, deps, rustdocCmd)).
-		Tool(deps.Rustdoc).
-		Flags(rustdocFlags).
-		Input(main).
-		Flag("-o "+docDir.String()).
-		FlagWithOutput("&& touch ", docTimestampFile).
-		Implicit(ctx.RustModule().UnstrippedOutputFile())
+	ctx.Build(pctx, android.BuildParams{
+		Rule:        rustdoc,
+		Description: "rustdoc " + main.Rel(),
+		Output:      docTimestampFile,
+		Input:       main,
+		Implicit:    ctx.RustModule().UnstrippedOutputFile(),
+		Args: map[string]string{
+			"rustdocFlags": strings.Join(rustdocFlags, " "),
+			"outDir":       docDir.String(),
+			"envVars":      strings.Join(rustEnvVars(ctx, deps), " "),
+		},
+	})
 
-	rustdocRule.BuildWithUnescapedNinjaVars("rustdoc", "rustdoc "+main.Rel())
 	return docTimestampFile
 }
-
-func getRuleBuilder(ctx android.ModuleContext, pctx android.PackageContext, sbox bool, sboxDirectory string) *android.RuleBuilder {
-	r := android.NewRuleBuilder(pctx, ctx)
-	if sbox {
-		r = r.Sbox(
-			android.PathForModuleOut(ctx, sboxDirectory),
-			android.PathForModuleOut(ctx, sboxDirectory+".sbox.textproto"),
-		).SandboxInputs()
-	}
-	return r
-}
diff --git a/rust/clippy_test.go b/rust/clippy_test.go
index 2703a1c..bd3bfb1 100644
--- a/rust/clippy_test.go
+++ b/rust/clippy_test.go
@@ -63,14 +63,14 @@
 			).RunTest(t)
 
 			r := result.ModuleForTests("libfoo", "android_arm64_armv8-a_dylib").MaybeRule("clippy")
-			android.AssertStringDoesContain(t, "libfoo flags", r.RuleParams.Command, tc.fooFlags)
+			android.AssertStringEquals(t, "libfoo flags", tc.fooFlags, r.Args["clippyFlags"])
 
 			r = result.ModuleForTests("libbar", "android_arm64_armv8-a_dylib").MaybeRule("clippy")
-			android.AssertStringDoesContain(t, "libbar flags", r.RuleParams.Command, "${config.ClippyDefaultLints}")
+			android.AssertStringEquals(t, "libbar flags", "${config.ClippyDefaultLints}", r.Args["clippyFlags"])
 
 			r = result.ModuleForTests("libfoobar", "android_arm64_armv8-a_dylib").MaybeRule("clippy")
 			if r.Rule != nil {
-				t.Errorf("libfoobar is setup to use clippy when explicitly disabled: command=%q", r.RuleParams.Command)
+				t.Errorf("libfoobar is setup to use clippy when explicitly disabled: clippyFlags=%q", r.Args["clippyFlags"])
 			}
 		})
 	}
diff --git a/rust/compiler.go b/rust/compiler.go
index 3fa3ccd..d6c52e8 100644
--- a/rust/compiler.go
+++ b/rust/compiler.go
@@ -82,9 +82,6 @@
 	//          not directly used as source files.
 	Crate_root *string `android:"path,arch_variant"`
 
-	// Additional data files that are used during compilation only. These are not accessible at runtime.
-	Compile_data []string `android:"path,arch_variant"`
-
 	// name of the lint set that should be used to validate this module.
 	//
 	// Possible values are "default" (for using a sensible set of lints
@@ -346,23 +343,6 @@
 	panic(fmt.Errorf("baseCrater doesn't know how to crate things!"))
 }
 
-func (compile *baseCompiler) crateRoot(ctx ModuleContext) android.Path {
-	if compile.Properties.Crate_root != nil {
-		return android.PathForModuleSrc(ctx, *compile.Properties.Crate_root)
-	}
-	return nil
-}
-
-// compilationSourcesAndData returns a list of files necessary to complete the compilation.
-// This includes the rust source files as well as any other data files that
-// are referenced during the build.
-func (compile *baseCompiler) compilationSourcesAndData(ctx ModuleContext) android.Paths {
-	return android.PathsForModuleSrc(ctx, android.Concat(
-		compile.Properties.Srcs,
-		compile.Properties.Compile_data,
-	))
-}
-
 func (compiler *baseCompiler) rustdoc(ctx ModuleContext, flags Flags,
 	deps PathDeps) android.OptionalPath {
 
diff --git a/rust/compiler_test.go b/rust/compiler_test.go
index e5cc888..ec6829a 100644
--- a/rust/compiler_test.go
+++ b/rust/compiler_test.go
@@ -36,9 +36,9 @@
 
 	libfooDylib := ctx.ModuleForTests("libfoo", "linux_glibc_x86_64_dylib").Rule("rustc")
 
-	if !strings.Contains(libfooDylib.RuleParams.Command, "cfg 'feature=\"fizz\"'") ||
-		!strings.Contains(libfooDylib.RuleParams.Command, "cfg 'feature=\"buzz\"'") {
-		t.Fatalf("missing fizz and buzz feature flags for libfoo dylib, command: %#v", libfooDylib.RuleParams.Command)
+	if !strings.Contains(libfooDylib.Args["rustcFlags"], "cfg 'feature=\"fizz\"'") ||
+		!strings.Contains(libfooDylib.Args["rustcFlags"], "cfg 'feature=\"buzz\"'") {
+		t.Fatalf("missing fizz and buzz feature flags for libfoo dylib, rustcFlags: %#v", libfooDylib.Args["rustcFlags"])
 	}
 }
 
@@ -57,9 +57,9 @@
 
 	libfooDylib := ctx.ModuleForTests("libfoo", "linux_glibc_x86_64_dylib").Rule("rustc")
 
-	if !strings.Contains(libfooDylib.RuleParams.Command, "cfg 'std'") ||
-		!strings.Contains(libfooDylib.RuleParams.Command, "cfg 'cfg1=\"one\"'") {
-		t.Fatalf("missing std and cfg1 flags for libfoo dylib, rustcFlags: %#v", libfooDylib.RuleParams.Command)
+	if !strings.Contains(libfooDylib.Args["rustcFlags"], "cfg 'std'") ||
+		!strings.Contains(libfooDylib.Args["rustcFlags"], "cfg 'cfg1=\"one\"'") {
+		t.Fatalf("missing std and cfg1 flags for libfoo dylib, rustcFlags: %#v", libfooDylib.Args["rustcFlags"])
 	}
 }
 
@@ -146,14 +146,14 @@
 
 	fizz := ctx.ModuleForTests("fizz", "android_arm64_armv8-a").Rule("rustc")
 
-	if !strings.Contains(fizz.RuleParams.Command, "CARGO_BIN_NAME=fizz") {
-		t.Fatalf("expected 'CARGO_BIN_NAME=fizz' in envVars, actual command: %#v", fizz.RuleParams.Command)
+	if !strings.Contains(fizz.Args["envVars"], "CARGO_BIN_NAME=fizz") {
+		t.Fatalf("expected 'CARGO_BIN_NAME=fizz' in envVars, actual envVars: %#v", fizz.Args["envVars"])
 	}
-	if !strings.Contains(fizz.RuleParams.Command, "CARGO_CRATE_NAME=foo") {
-		t.Fatalf("expected 'CARGO_CRATE_NAME=foo' in envVars, actual command: %#v", fizz.RuleParams.Command)
+	if !strings.Contains(fizz.Args["envVars"], "CARGO_CRATE_NAME=foo") {
+		t.Fatalf("expected 'CARGO_CRATE_NAME=foo' in envVars, actual envVars: %#v", fizz.Args["envVars"])
 	}
-	if !strings.Contains(fizz.RuleParams.Command, "CARGO_PKG_VERSION=1.0.0") {
-		t.Fatalf("expected 'CARGO_PKG_VERSION=1.0.0' in envVars, actual command: %#v", fizz.RuleParams.Command)
+	if !strings.Contains(fizz.Args["envVars"], "CARGO_PKG_VERSION=1.0.0") {
+		t.Fatalf("expected 'CARGO_PKG_VERSION=1.0.0' in envVars, actual envVars: %#v", fizz.Args["envVars"])
 	}
 }
 
@@ -230,13 +230,13 @@
 			).RunTest(t)
 
 			r := result.ModuleForTests("libfoo", "android_arm64_armv8-a_dylib").MaybeRule("rustc")
-			android.AssertStringDoesContain(t, "libfoo flags", r.RuleParams.Command, tc.fooFlags)
+			android.AssertStringDoesContain(t, "libfoo flags", r.Args["rustcFlags"], tc.fooFlags)
 
 			r = result.ModuleForTests("libbar", "android_arm64_armv8-a_dylib").MaybeRule("rustc")
-			android.AssertStringDoesContain(t, "libbar flags", r.RuleParams.Command, "${config.RustDefaultLints}")
+			android.AssertStringDoesContain(t, "libbar flags", r.Args["rustcFlags"], "${config.RustDefaultLints}")
 
 			r = result.ModuleForTests("libfoobar", "android_arm64_armv8-a_dylib").MaybeRule("rustc")
-			android.AssertStringDoesContain(t, "libfoobar flags", r.RuleParams.Command, "${config.RustAllowAllLints}")
+			android.AssertStringDoesContain(t, "libfoobar flags", r.Args["rustcFlags"], "${config.RustAllowAllLints}")
 		})
 	}
 }
diff --git a/rust/config/global.go b/rust/config/global.go
index 0ddc116..f397ce9 100644
--- a/rust/config/global.go
+++ b/rust/config/global.go
@@ -126,27 +126,3 @@
 func BazelRustToolchainVars(config android.Config) string {
 	return android.BazelToolchainVars(config, exportedVars)
 }
-
-func RustPath(ctx android.PathContext, file string) android.SourcePath {
-	type rustToolKey string
-	key := android.NewCustomOnceKey(rustToolKey(file))
-	return ctx.Config().OnceSourcePath(key, func() android.SourcePath {
-		return rustPath(ctx).Join(ctx, file)
-	})
-}
-
-var rustPathKey = android.NewOnceKey("clangPath")
-
-func rustPath(ctx android.PathContext) android.SourcePath {
-	return ctx.Config().OnceSourcePath(rustPathKey, func() android.SourcePath {
-		rustBase := RustDefaultBase
-		if override := ctx.Config().Getenv("RUST_PREBUILTS_BASE"); override != "" {
-			rustBase = override
-		}
-		rustVersion := RustDefaultVersion
-		if override := ctx.Config().Getenv("RUST_DEFAULT_VERSION"); override != "" {
-			rustVersion = override
-		}
-		return android.PathForSource(ctx, rustBase, ctx.Config().PrebuiltOS(), rustVersion)
-	})
-}
diff --git a/rust/coverage.go b/rust/coverage.go
index b312194..5216d60 100644
--- a/rust/coverage.go
+++ b/rust/coverage.go
@@ -17,7 +17,6 @@
 import (
 	"github.com/google/blueprint"
 
-	"android/soong/android"
 	"android/soong/cc"
 )
 
@@ -71,10 +70,7 @@
 		// no_std modules are missing libprofiler_builtins which provides coverage, so we need to add it as a dependency.
 		if rustModule, ok := ctx.Module().(*Module); ok && rustModule.compiler.noStdlibs() {
 			profiler_builtins := ctx.GetDirectDepWithTag(ProfilerBuiltins, rlibDepTag).(*Module)
-			deps.Rlibs = android.AddDirectToDepSet[RustLibrary](deps.Rlibs, RustLibrary{
-				Path:      profiler_builtins.OutputFile().Path(),
-				CrateName: profiler_builtins.CrateName(),
-			})
+			deps.RLibs = append(deps.RLibs, RustLibrary{Path: profiler_builtins.OutputFile().Path(), CrateName: profiler_builtins.CrateName()})
 		}
 
 		if cc.EnableContinuousCoverage(ctx) {
diff --git a/rust/coverage_test.go b/rust/coverage_test.go
index 1466e0c..64077cf 100644
--- a/rust/coverage_test.go
+++ b/rust/coverage_test.go
@@ -55,27 +55,27 @@
 	libbarNoCov := ctx.ModuleForTests("libbar_nocov", "android_arm64_armv8-a_dylib").Rule("rustc")
 	fizzCov := ctx.ModuleForTests("fizz_cov", "android_arm64_armv8-a_cov").Rule("rustc")
 	buzzNoCov := ctx.ModuleForTests("buzzNoCov", "android_arm64_armv8-a").Rule("rustc")
-	libfooCovLink := ctx.ModuleForTests("libfoo_cov", "android_arm64_armv8-a_dylib_cov").Rule("rustc")
-	libbarNoCovLink := ctx.ModuleForTests("libbar_nocov", "android_arm64_armv8-a_dylib").Rule("rustc")
-	fizzCovLink := ctx.ModuleForTests("fizz_cov", "android_arm64_armv8-a_cov").Rule("rustc")
-	buzzNoCovLink := ctx.ModuleForTests("buzzNoCov", "android_arm64_armv8-a").Rule("rustc")
+	libfooCovLink := ctx.ModuleForTests("libfoo_cov", "android_arm64_armv8-a_dylib_cov").Rule("rustLink")
+	libbarNoCovLink := ctx.ModuleForTests("libbar_nocov", "android_arm64_armv8-a_dylib").Rule("rustLink")
+	fizzCovLink := ctx.ModuleForTests("fizz_cov", "android_arm64_armv8-a_cov").Rule("rustLink")
+	buzzNoCovLink := ctx.ModuleForTests("buzzNoCov", "android_arm64_armv8-a").Rule("rustLink")
 
 	rustcCoverageFlags := []string{"-C instrument-coverage", " -g "}
 	for _, flag := range rustcCoverageFlags {
 		missingErrorStr := "missing rustc flag '%s' for '%s' module with coverage enabled; rustcFlags: %#v"
 		containsErrorStr := "contains rustc flag '%s' for '%s' module with coverage disabled; rustcFlags: %#v"
 
-		if !strings.Contains(fizzCov.RuleParams.Command, flag) {
-			t.Fatalf(missingErrorStr, flag, "fizz_cov", fizzCov.RuleParams.Command)
+		if !strings.Contains(fizzCov.Args["rustcFlags"], flag) {
+			t.Fatalf(missingErrorStr, flag, "fizz_cov", fizzCov.Args["rustcFlags"])
 		}
-		if !strings.Contains(libfooCov.RuleParams.Command, flag) {
-			t.Fatalf(missingErrorStr, flag, "libfoo_cov dylib", libfooCov.RuleParams.Command)
+		if !strings.Contains(libfooCov.Args["rustcFlags"], flag) {
+			t.Fatalf(missingErrorStr, flag, "libfoo_cov dylib", libfooCov.Args["rustcFlags"])
 		}
-		if strings.Contains(buzzNoCov.RuleParams.Command, flag) {
-			t.Fatalf(containsErrorStr, flag, "buzzNoCov", buzzNoCov.RuleParams.Command)
+		if strings.Contains(buzzNoCov.Args["rustcFlags"], flag) {
+			t.Fatalf(containsErrorStr, flag, "buzzNoCov", buzzNoCov.Args["rustcFlags"])
 		}
-		if strings.Contains(libbarNoCov.RuleParams.Command, flag) {
-			t.Fatalf(containsErrorStr, flag, "libbar_cov", libbarNoCov.RuleParams.Command)
+		if strings.Contains(libbarNoCov.Args["rustcFlags"], flag) {
+			t.Fatalf(containsErrorStr, flag, "libbar_cov", libbarNoCov.Args["rustcFlags"])
 		}
 	}
 
@@ -84,17 +84,17 @@
 		missingErrorStr := "missing rust linker flag '%s' for '%s' module with coverage enabled; rustcFlags: %#v"
 		containsErrorStr := "contains rust linker flag '%s' for '%s' module with coverage disabled; rustcFlags: %#v"
 
-		if !strings.Contains(fizzCovLink.RuleParams.Command, flag) {
-			t.Fatalf(missingErrorStr, flag, "fizz_cov", fizzCovLink.RuleParams.Command)
+		if !strings.Contains(fizzCovLink.Args["linkFlags"], flag) {
+			t.Fatalf(missingErrorStr, flag, "fizz_cov", fizzCovLink.Args["linkFlags"])
 		}
-		if !strings.Contains(libfooCovLink.RuleParams.Command, flag) {
-			t.Fatalf(missingErrorStr, flag, "libfoo_cov dylib", libfooCovLink.RuleParams.Command)
+		if !strings.Contains(libfooCovLink.Args["linkFlags"], flag) {
+			t.Fatalf(missingErrorStr, flag, "libfoo_cov dylib", libfooCovLink.Args["linkFlags"])
 		}
-		if strings.Contains(buzzNoCovLink.RuleParams.Command, flag) {
-			t.Fatalf(containsErrorStr, flag, "buzzNoCov", buzzNoCovLink.RuleParams.Command)
+		if strings.Contains(buzzNoCovLink.Args["linkFlags"], flag) {
+			t.Fatalf(containsErrorStr, flag, "buzzNoCov", buzzNoCovLink.Args["linkFlags"])
 		}
-		if strings.Contains(libbarNoCovLink.RuleParams.Command, flag) {
-			t.Fatalf(containsErrorStr, flag, "libbar_cov", libbarNoCovLink.RuleParams.Command)
+		if strings.Contains(libbarNoCovLink.Args["linkFlags"], flag) {
+			t.Fatalf(containsErrorStr, flag, "libbar_cov", libbarNoCovLink.Args["linkFlags"])
 		}
 	}
 
@@ -107,8 +107,8 @@
 			srcs: ["foo.rs"],
 		}`)
 
-	fizz := ctx.ModuleForTests("fizz", "android_arm64_armv8-a_cov").Rule("rustc")
-	if !strings.Contains(fizz.RuleParams.Command, "libprofile-clang-extras.a") {
-		t.Fatalf("missing expected coverage 'libprofile-clang-extras' dependency in linkFlags: %#v", fizz.RuleParams.Command)
+	fizz := ctx.ModuleForTests("fizz", "android_arm64_armv8-a_cov").Rule("rustLink")
+	if !strings.Contains(fizz.Args["linkFlags"], "libprofile-clang-extras.a") {
+		t.Fatalf("missing expected coverage 'libprofile-clang-extras' dependency in linkFlags: %#v", fizz.Args["linkFlags"])
 	}
 }
diff --git a/rust/fuzz_test.go b/rust/fuzz_test.go
index ea35905..ee28c6d 100644
--- a/rust/fuzz_test.go
+++ b/rust/fuzz_test.go
@@ -51,23 +51,23 @@
 
 	// Check that compiler flags are set appropriately .
 	fuzz_libtest := ctx.ModuleForTests("fuzz_libtest", "android_arm64_armv8-a_fuzzer").Rule("rustc")
-	if !strings.Contains(fuzz_libtest.RuleParams.Command, "-C passes='sancov-module'") ||
-		!strings.Contains(fuzz_libtest.RuleParams.Command, "--cfg fuzzing") {
+	if !strings.Contains(fuzz_libtest.Args["rustcFlags"], "-C passes='sancov-module'") ||
+		!strings.Contains(fuzz_libtest.Args["rustcFlags"], "--cfg fuzzing") {
 		t.Errorf("rust_fuzz module does not contain the expected flags (sancov-module, cfg fuzzing).")
 	}
 
 	// Check that host modules support fuzzing.
 	host_fuzzer := ctx.ModuleForTests("fuzz_libtest", "android_arm64_armv8-a_fuzzer").Rule("rustc")
-	if !strings.Contains(host_fuzzer.RuleParams.Command, "-C passes='sancov-module'") ||
-		!strings.Contains(host_fuzzer.RuleParams.Command, "--cfg fuzzing") {
+	if !strings.Contains(host_fuzzer.Args["rustcFlags"], "-C passes='sancov-module'") ||
+		!strings.Contains(host_fuzzer.Args["rustcFlags"], "--cfg fuzzing") {
 		t.Errorf("rust_fuzz_host module does not contain the expected flags (sancov-module, cfg fuzzing).")
 	}
 
 	// Check that dependencies have 'fuzzer' variants produced for them as well.
-	libtest_fuzzer := ctx.ModuleForTests("libtest_fuzzing", "android_arm64_armv8-a_rlib_rlib-std_fuzzer").Rule("rustc")
-	if !strings.Contains(libtest_fuzzer.RuleParams.Command, "-C passes='sancov-module'") ||
-		!strings.Contains(libtest_fuzzer.RuleParams.Command, "--cfg fuzzing") {
-		t.Errorf("rust_fuzz dependent library does not contain the expected flags (sancov-module, cfg fuzzing). command: %q", libtest_fuzzer.RuleParams.Command)
+	libtest_fuzzer := ctx.ModuleForTests("libtest_fuzzing", "android_arm64_armv8-a_rlib_rlib-std_fuzzer").Output("libtest_fuzzing.rlib")
+	if !strings.Contains(libtest_fuzzer.Args["rustcFlags"], "-C passes='sancov-module'") ||
+		!strings.Contains(libtest_fuzzer.Args["rustcFlags"], "--cfg fuzzing") {
+		t.Errorf("rust_fuzz dependent library does not contain the expected flags (sancov-module, cfg fuzzing).")
 	}
 }
 
diff --git a/rust/image_test.go b/rust/image_test.go
index 813c5bc..fb4d9c1 100644
--- a/rust/image_test.go
+++ b/rust/image_test.go
@@ -59,36 +59,36 @@
 
 	vendor := ctx.ModuleForTests("libfoo", "android_vendor.29_arm64_armv8-a_static").Rule("rustc")
 
-	if !strings.Contains(vendor.RuleParams.Command, "--cfg 'android_vndk'") {
-		t.Errorf("missing \"--cfg 'android_vndk'\" for libfoo vendor variant, rustcFlags: %#v", vendor.RuleParams.Command)
+	if !strings.Contains(vendor.Args["rustcFlags"], "--cfg 'android_vndk'") {
+		t.Errorf("missing \"--cfg 'android_vndk'\" for libfoo vendor variant, rustcFlags: %#v", vendor.Args["rustcFlags"])
 	}
-	if !strings.Contains(vendor.RuleParams.Command, "--cfg 'android_vendor'") {
-		t.Errorf("missing \"--cfg 'android_vendor'\" for libfoo vendor variant, rustcFlags: %#v", vendor.RuleParams.Command)
+	if !strings.Contains(vendor.Args["rustcFlags"], "--cfg 'android_vendor'") {
+		t.Errorf("missing \"--cfg 'android_vendor'\" for libfoo vendor variant, rustcFlags: %#v", vendor.Args["rustcFlags"])
 	}
-	if strings.Contains(vendor.RuleParams.Command, "--cfg 'android_product'") {
-		t.Errorf("unexpected \"--cfg 'android_product'\" for libfoo vendor variant, rustcFlags: %#v", vendor.RuleParams.Command)
+	if strings.Contains(vendor.Args["rustcFlags"], "--cfg 'android_product'") {
+		t.Errorf("unexpected \"--cfg 'android_product'\" for libfoo vendor variant, rustcFlags: %#v", vendor.Args["rustcFlags"])
 	}
 
 	product := ctx.ModuleForTests("libfoo", "android_product.29_arm64_armv8-a_static").Rule("rustc")
-	if !strings.Contains(product.RuleParams.Command, "--cfg 'android_vndk'") {
-		t.Errorf("missing \"--cfg 'android_vndk'\" for libfoo product variant, rustcFlags: %#v", product.RuleParams.Command)
+	if !strings.Contains(product.Args["rustcFlags"], "--cfg 'android_vndk'") {
+		t.Errorf("missing \"--cfg 'android_vndk'\" for libfoo product variant, rustcFlags: %#v", product.Args["rustcFlags"])
 	}
-	if strings.Contains(product.RuleParams.Command, "--cfg 'android_vendor'") {
-		t.Errorf("unexpected \"--cfg 'android_vendor'\" for libfoo product variant, rustcFlags: %#v", product.RuleParams.Command)
+	if strings.Contains(product.Args["rustcFlags"], "--cfg 'android_vendor'") {
+		t.Errorf("unexpected \"--cfg 'android_vendor'\" for libfoo product variant, rustcFlags: %#v", product.Args["rustcFlags"])
 	}
-	if !strings.Contains(product.RuleParams.Command, "--cfg 'android_product'") {
-		t.Errorf("missing \"--cfg 'android_product'\" for libfoo product variant, rustcFlags: %#v", product.RuleParams.Command)
+	if !strings.Contains(product.Args["rustcFlags"], "--cfg 'android_product'") {
+		t.Errorf("missing \"--cfg 'android_product'\" for libfoo product variant, rustcFlags: %#v", product.Args["rustcFlags"])
 	}
 
 	system := ctx.ModuleForTests("libfoo", "android_arm64_armv8-a_static").Rule("rustc")
-	if strings.Contains(system.RuleParams.Command, "--cfg 'android_vndk'") {
-		t.Errorf("unexpected \"--cfg 'android_vndk'\" for libfoo system variant, rustcFlags: %#v", system.RuleParams.Command)
+	if strings.Contains(system.Args["rustcFlags"], "--cfg 'android_vndk'") {
+		t.Errorf("unexpected \"--cfg 'android_vndk'\" for libfoo system variant, rustcFlags: %#v", system.Args["rustcFlags"])
 	}
-	if strings.Contains(system.RuleParams.Command, "--cfg 'android_vendor'") {
-		t.Errorf("unexpected \"--cfg 'android_vendor'\" for libfoo system variant, rustcFlags: %#v", system.RuleParams.Command)
+	if strings.Contains(system.Args["rustcFlags"], "--cfg 'android_vendor'") {
+		t.Errorf("unexpected \"--cfg 'android_vendor'\" for libfoo system variant, rustcFlags: %#v", system.Args["rustcFlags"])
 	}
-	if strings.Contains(system.RuleParams.Command, "--cfg 'android_product'") {
-		t.Errorf("unexpected \"--cfg 'android_product'\" for libfoo system variant, rustcFlags: %#v", product.RuleParams.Command)
+	if strings.Contains(system.Args["rustcFlags"], "--cfg 'android_product'") {
+		t.Errorf("unexpected \"--cfg 'android_product'\" for libfoo system variant, rustcFlags: %#v", product.Args["rustcFlags"])
 	}
 
 }
diff --git a/rust/library.go b/rust/library.go
index 7bb82bc..f4a2b54 100644
--- a/rust/library.go
+++ b/rust/library.go
@@ -485,23 +485,6 @@
 	return flags
 }
 
-func (library *libraryDecorator) compilationSourcesAndData(ctx ModuleContext) android.Paths {
-	var extraSrcs android.Paths
-	if library.rlib() {
-		extraSrcs = android.PathsForModuleSrc(ctx, library.Properties.Rlib.Srcs)
-	} else if library.dylib() {
-		extraSrcs = android.PathsForModuleSrc(ctx, library.Properties.Dylib.Srcs)
-	} else if library.static() {
-		extraSrcs = android.PathsForModuleSrc(ctx, library.Properties.Static.Srcs)
-	} else if library.shared() {
-		extraSrcs = android.PathsForModuleSrc(ctx, library.Properties.Shared.Srcs)
-	}
-	return android.Concat(
-		library.baseCompiler.compilationSourcesAndData(ctx),
-		extraSrcs,
-	)
-}
-
 func (library *libraryDecorator) compile(ctx ModuleContext, flags Flags, deps PathDeps) buildOutput {
 	var outputFile android.ModuleOutPath
 	var ret buildOutput
@@ -542,6 +525,7 @@
 
 	flags.RustFlags = append(flags.RustFlags, deps.depFlags...)
 	flags.LinkFlags = append(flags.LinkFlags, deps.depLinkFlags...)
+	flags.LinkFlags = append(flags.LinkFlags, deps.linkObjects.Strings()...)
 
 	if library.dylib() {
 		// We need prefer-dynamic for now to avoid linking in the static stdlib. See:
@@ -552,13 +536,13 @@
 
 	// Call the appropriate builder for this library type
 	if library.rlib() {
-		ret.kytheFile = TransformSrctoRlib(ctx, library, crateRootPath, deps, flags, outputFile).kytheFile
+		ret.kytheFile = TransformSrctoRlib(ctx, crateRootPath, deps, flags, outputFile).kytheFile
 	} else if library.dylib() {
-		ret.kytheFile = TransformSrctoDylib(ctx, library, crateRootPath, deps, flags, outputFile).kytheFile
+		ret.kytheFile = TransformSrctoDylib(ctx, crateRootPath, deps, flags, outputFile).kytheFile
 	} else if library.static() {
-		ret.kytheFile = TransformSrctoStatic(ctx, library, crateRootPath, deps, flags, outputFile).kytheFile
+		ret.kytheFile = TransformSrctoStatic(ctx, crateRootPath, deps, flags, outputFile).kytheFile
 	} else if library.shared() {
-		ret.kytheFile = TransformSrctoShared(ctx, library, crateRootPath, deps, flags, outputFile).kytheFile
+		ret.kytheFile = TransformSrctoShared(ctx, crateRootPath, deps, flags, outputFile).kytheFile
 	}
 
 	if library.rlib() || library.dylib() {
diff --git a/rust/library_test.go b/rust/library_test.go
index dab9381..30ef333 100644
--- a/rust/library_test.go
+++ b/rust/library_test.go
@@ -48,23 +48,23 @@
 	staticCrateType := "staticlib"
 
 	// Test crate type for rlib is correct.
-	if !strings.Contains(libfooRlib.RuleParams.Command, "crate-type="+rlibCrateType) {
-		t.Errorf("missing crate-type for static variant, expecting %#v, rustcFlags: %#v", rlibCrateType, libfooRlib.RuleParams.Command)
+	if !strings.Contains(libfooRlib.Args["rustcFlags"], "crate-type="+rlibCrateType) {
+		t.Errorf("missing crate-type for static variant, expecting %#v, rustcFlags: %#v", rlibCrateType, libfooRlib.Args["rustcFlags"])
 	}
 
 	// Test crate type for dylib is correct.
-	if !strings.Contains(libfooDylib.RuleParams.Command, "crate-type="+dylibCrateType) {
-		t.Errorf("missing crate-type for static variant, expecting %#v, rustcFlags: %#v", dylibCrateType, libfooDylib.RuleParams.Command)
+	if !strings.Contains(libfooDylib.Args["rustcFlags"], "crate-type="+dylibCrateType) {
+		t.Errorf("missing crate-type for static variant, expecting %#v, rustcFlags: %#v", dylibCrateType, libfooDylib.Args["rustcFlags"])
 	}
 
 	// Test crate type for C static libraries is correct.
-	if !strings.Contains(libfooStatic.RuleParams.Command, "crate-type="+staticCrateType) {
-		t.Errorf("missing crate-type for static variant, expecting %#v, rustcFlags: %#v", staticCrateType, libfooStatic.RuleParams.Command)
+	if !strings.Contains(libfooStatic.Args["rustcFlags"], "crate-type="+staticCrateType) {
+		t.Errorf("missing crate-type for static variant, expecting %#v, rustcFlags: %#v", staticCrateType, libfooStatic.Args["rustcFlags"])
 	}
 
 	// Test crate type for C shared libraries is correct.
-	if !strings.Contains(libfooShared.RuleParams.Command, "crate-type="+sharedCrateType) {
-		t.Errorf("missing crate-type for shared variant, expecting %#v, got rustcFlags: %#v", sharedCrateType, libfooShared.RuleParams.Command)
+	if !strings.Contains(libfooShared.Args["rustcFlags"], "crate-type="+sharedCrateType) {
+		t.Errorf("missing crate-type for shared variant, expecting %#v, got rustcFlags: %#v", sharedCrateType, libfooShared.Args["rustcFlags"])
 	}
 
 }
@@ -78,10 +78,10 @@
 			crate_name: "foo",
 		}`)
 
-	libfooDylib := ctx.ModuleForTests("libfoo", "linux_glibc_x86_64_dylib").Description("rustc")
+	libfooDylib := ctx.ModuleForTests("libfoo", "linux_glibc_x86_64_dylib").Rule("rustc")
 
-	if !strings.Contains(libfooDylib.RuleParams.Command, "prefer-dynamic") {
-		t.Errorf("missing prefer-dynamic flag for libfoo dylib, rustcFlags: %#v", libfooDylib.RuleParams.Command)
+	if !strings.Contains(libfooDylib.Args["rustcFlags"], "prefer-dynamic") {
+		t.Errorf("missing prefer-dynamic flag for libfoo dylib, rustcFlags: %#v", libfooDylib.Args["rustcFlags"])
 	}
 }
 
@@ -94,10 +94,10 @@
 			crate_name: "foo",
 		}`)
 
-	libfooDylib := ctx.ModuleForTests("libfoo", "linux_glibc_x86_64_dylib").Description("rustc")
+	libfooDylib := ctx.ModuleForTests("libfoo", "linux_glibc_x86_64_dylib").Rule("rustc")
 
-	if !strings.Contains(libfooDylib.RuleParams.Command, "--cfg 'android_dylib'") {
-		t.Errorf("missing android_dylib cfg flag for libfoo dylib, rustcFlags: %#v", libfooDylib.RuleParams.Command)
+	if !strings.Contains(libfooDylib.Args["rustcFlags"], "--cfg 'android_dylib'") {
+		t.Errorf("missing android_dylib cfg flag for libfoo dylib, rustcFlags: %#v", libfooDylib.Args["rustcFlags"])
 	}
 }
 
@@ -148,10 +148,10 @@
 
 	libfoo := ctx.ModuleForTests("libfoo", "android_arm64_armv8-a_shared")
 
-	libfooOutput := libfoo.Rule("rustc")
-	if !strings.Contains(libfooOutput.RuleParams.Command, "-Wl,-soname=libfoo.so") {
+	libfooOutput := libfoo.Rule("rustLink")
+	if !strings.Contains(libfooOutput.Args["linkFlags"], "-Wl,-soname=libfoo.so") {
 		t.Errorf("missing expected -Wl,-soname linker flag for libfoo shared lib, linkFlags: %#v",
-			libfooOutput.RuleParams.Command)
+			libfooOutput.Args["linkFlags"])
 	}
 
 	if !android.InList("libstd", libfoo.Module().(*Module).Properties.AndroidMkDylibs) {
@@ -237,21 +237,19 @@
 	// The build system assumes the  cc deps will be at the final linkage (either a shared library or binary)
 	// Hence, these flags are no-op
 	// TODO: We could consider removing these flags
-	expectedSharedFlag := "-L out/soong/.intermediates/shared_cc_dep/android_arm64_armv8-a_shared"
-	expectedStaticFlag := "-L out/soong/.intermediates/static_cc_dep/android_arm64_armv8-a_static"
 	for _, module := range modules {
-		if !strings.Contains(module.Rule("rustc").RuleParams.Command, expectedSharedFlag) {
+		if !strings.Contains(module.Rule("rustc").Args["libFlags"],
+			"-L out/soong/.intermediates/shared_cc_dep/android_arm64_armv8-a_shared/") {
 			t.Errorf(
-				"expected to find shared library linkdir flag %q, rustcFlags: %#v",
-				expectedSharedFlag,
-				rustRlibRlibStd.Rule("rustc").RuleParams.Command,
+				"missing -L flag for shared_cc_dep, rustcFlags: %#v",
+				rustRlibRlibStd.Rule("rustc").Args["libFlags"],
 			)
 		}
-		if !strings.Contains(module.Rule("rustc").RuleParams.Command, expectedStaticFlag) {
+		if !strings.Contains(module.Rule("rustc").Args["libFlags"],
+			"-L out/soong/.intermediates/static_cc_dep/android_arm64_armv8-a_static/") {
 			t.Errorf(
-				"expected to find static library linkdir flag %q, rustcFlags: %#v",
-				expectedStaticFlag,
-				rustRlibRlibStd.Rule("rustc").RuleParams.Command,
+				"missing -L flag for static_cc_dep, rustcFlags: %#v",
+				rustRlibRlibStd.Rule("rustc").Args["libFlags"],
 			)
 		}
 	}
diff --git a/rust/prebuilt.go b/rust/prebuilt.go
index d012680..fe9d0b5 100644
--- a/rust/prebuilt.go
+++ b/rust/prebuilt.go
@@ -146,10 +146,7 @@
 }
 
 func (prebuilt *prebuiltLibraryDecorator) compile(ctx ModuleContext, flags Flags, deps PathDeps) buildOutput {
-	deps.linkDirs = append(deps.linkDirs, android.PathsForModuleSrc(ctx, prebuilt.Properties.Link_dirs)...)
-	prebuilt.flagExporter.exportLinkDirs(deps.linkDirs...)
-	prebuilt.flagExporter.exportLinkObjects(deps.linkObjects...)
-	prebuilt.flagExporter.exportLibDeps(deps.LibDeps...)
+	prebuilt.flagExporter.exportLinkDirs(android.PathsForModuleSrc(ctx, prebuilt.Properties.Link_dirs).Strings()...)
 	prebuilt.flagExporter.setProvider(ctx)
 
 	srcPath, paths := srcPathFromModuleSrcs(ctx, prebuilt.prebuiltSrcs())
@@ -206,7 +203,7 @@
 }
 
 func (prebuilt *prebuiltProcMacroDecorator) compile(ctx ModuleContext, flags Flags, deps PathDeps) buildOutput {
-	prebuilt.flagExporter.exportLinkDirs(android.PathsForModuleSrc(ctx, prebuilt.Properties.Link_dirs)...)
+	prebuilt.flagExporter.exportLinkDirs(android.PathsForModuleSrc(ctx, prebuilt.Properties.Link_dirs).Strings()...)
 	prebuilt.flagExporter.setProvider(ctx)
 
 	srcPath, paths := srcPathFromModuleSrcs(ctx, prebuilt.prebuiltSrcs())
diff --git a/rust/proc_macro.go b/rust/proc_macro.go
index 3f0d17a..b93b24f 100644
--- a/rust/proc_macro.go
+++ b/rust/proc_macro.go
@@ -80,7 +80,7 @@
 	outputFile := android.PathForModuleOut(ctx, fileName)
 
 	srcPath, _ := srcPathFromModuleSrcs(ctx, procMacro.baseCompiler.Properties.Srcs)
-	ret := TransformSrctoProcMacro(ctx, procMacro, srcPath, deps, flags, outputFile)
+	ret := TransformSrctoProcMacro(ctx, srcPath, deps, flags, outputFile)
 	procMacro.baseCompiler.unstrippedOutputFile = outputFile
 	return ret
 }
diff --git a/rust/proc_macro_test.go b/rust/proc_macro_test.go
index a547926..cc81938 100644
--- a/rust/proc_macro_test.go
+++ b/rust/proc_macro_test.go
@@ -30,7 +30,7 @@
 
 	libprocmacro := ctx.ModuleForTests("libprocmacro", "linux_glibc_x86_64").Rule("rustc")
 
-	if !strings.Contains(libprocmacro.RuleParams.Command, "--extern proc_macro") {
-		t.Errorf("--extern proc_macro flag not being passed to rustc for proc macro %#v", libprocmacro.RuleParams.Command)
+	if !strings.Contains(libprocmacro.Args["rustcFlags"], "--extern proc_macro") {
+		t.Errorf("--extern proc_macro flag not being passed to rustc for proc macro %#v", libprocmacro.Args["rustcFlags"])
 	}
 }
diff --git a/rust/rust.go b/rust/rust.go
index 6d6b55e..3b24484 100644
--- a/rust/rust.go
+++ b/rust/rust.go
@@ -438,18 +438,12 @@
 }
 
 type PathDeps struct {
-	Dylibs          *android.DepSet[RustLibrary]
-	Rlibs           *android.DepSet[RustLibrary]
-	ProcMacros      *android.DepSet[RustLibrary]
+	DyLibs          RustLibraries
+	RLibs           RustLibraries
 	LibDeps         android.Paths
 	WholeStaticLibs android.Paths
+	ProcMacros      RustLibraries
 	AfdoProfiles    android.Paths
-	// These paths are files needed to run the build tools and will be located under
-	// __SBOX_SANDBOX_DIR__/tools/...
-	BuildToolDeps android.Paths
-	// These paths are files needed to run the build tools and will be located under
-	// __SBOX_SANDBOX_DIR__/...
-	BuildToolSrcDeps android.Paths
 
 	// depFlags and depLinkFlags are rustc and linker (clang) flags.
 	depFlags     []string
@@ -457,7 +451,7 @@
 
 	// linkDirs are link paths passed via -L to rustc. linkObjects are objects passed directly to the linker.
 	// Both of these are exported and propagate to dependencies.
-	linkDirs    android.Paths
+	linkDirs    []string
 	linkObjects android.Paths
 
 	// Used by bindgen modules which call clang
@@ -472,13 +466,6 @@
 	// Paths to generated source files
 	SrcDeps          android.Paths
 	srcProviderFiles android.Paths
-
-	// Paths to specific build tools
-	Rustc         android.Path
-	Clang         android.Path
-	Llvm_ar       android.Path
-	Clippy_driver android.Path
-	Rustdoc       android.Path
 }
 
 type RustLibraries []RustLibrary
@@ -498,8 +485,6 @@
 	compilerDeps(ctx DepsContext, deps Deps) Deps
 	crateName() string
 	rustdoc(ctx ModuleContext, flags Flags, deps PathDeps) android.OptionalPath
-	crateRoot(ctx ModuleContext) android.Path
-	compilationSourcesAndData(ctx ModuleContext) android.Paths
 
 	// Output directory in which source-generated code from dependencies is
 	// copied. This is equivalent to Cargo's OUT_DIR variable.
@@ -529,7 +514,7 @@
 }
 
 type exportedFlagsProducer interface {
-	exportLinkDirs(...android.Path)
+	exportLinkDirs(...string)
 	exportLinkObjects(...android.Path)
 }
 
@@ -538,13 +523,13 @@
 }
 
 type flagExporter struct {
-	linkDirs    android.Paths
+	linkDirs    []string
 	linkObjects android.Paths
 	libDeps     android.Paths
 }
 
-func (flagExporter *flagExporter) exportLinkDirs(dirs ...android.Path) {
-	flagExporter.linkDirs = android.FirstUniquePaths(append(flagExporter.linkDirs, dirs...))
+func (flagExporter *flagExporter) exportLinkDirs(dirs ...string) {
+	flagExporter.linkDirs = android.FirstUniqueStrings(append(flagExporter.linkDirs, dirs...))
 }
 
 func (flagExporter *flagExporter) exportLinkObjects(flags ...android.Path) {
@@ -571,7 +556,7 @@
 
 type FlagExporterInfo struct {
 	Flags       []string
-	LinkDirs    android.Paths
+	LinkDirs    []string // TODO: this should be android.Paths
 	LinkObjects android.Paths
 	LibDeps     android.Paths
 }
@@ -941,14 +926,6 @@
 func (d *Defaults) GenerateAndroidBuildActions(ctx android.ModuleContext) {
 }
 
-type RustInfo struct {
-	TransitiveRlibs      *android.DepSet[RustLibrary]
-	TransitiveDylibs     *android.DepSet[RustLibrary]
-	TransitiveProcMacros *android.DepSet[RustLibrary]
-}
-
-var RustInfoProvider = blueprint.NewProvider(RustInfo{})
-
 func (mod *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
 	ctx := &moduleContext{
 		ModuleContext: actx,
@@ -1058,12 +1035,6 @@
 
 		ctx.Phony("rust", ctx.RustModule().OutputFile().Path())
 	}
-
-	ctx.SetProvider(RustInfoProvider, RustInfo{
-		TransitiveRlibs:      deps.Rlibs,
-		TransitiveDylibs:     deps.Dylibs,
-		TransitiveProcMacros: deps.ProcMacros,
-	})
 }
 
 func (mod *Module) deps(ctx DepsContext) Deps {
@@ -1122,7 +1093,6 @@
 var _ android.LicenseAnnotationsDependencyTag = dependencyTag{}
 
 var (
-	buildToolDepTag     = dependencyTag{name: "buildToolTag"}
 	customBindgenDepTag = dependencyTag{name: "customBindgenTag"}
 	rlibDepTag          = dependencyTag{name: "rlibTag", library: true}
 	dylibDepTag         = dependencyTag{name: "dylib", library: true, dynamic: true}
@@ -1256,9 +1226,7 @@
 
 	var transitiveAndroidMkSharedLibs []*android.DepSet[string]
 	var directAndroidMkSharedLibs []string
-	transitiveRlibs := android.NewDepSetBuilder[RustLibrary](android.PREORDER)
-	transitiveDylibs := android.NewDepSetBuilder[RustLibrary](android.PREORDER)
-	transitiveProcMacros := android.NewDepSetBuilder[RustLibrary](android.PREORDER)
+
 	ctx.VisitDirectDeps(func(dep android.Module) {
 		depName := ctx.OtherModuleName(dep)
 		depTag := ctx.OtherModuleDependencyTag(dep)
@@ -1271,17 +1239,6 @@
 			return
 		}
 
-		rustInfo := ctx.OtherModuleProvider(dep, RustInfoProvider).(RustInfo)
-		if rustInfo.TransitiveDylibs != nil {
-			transitiveDylibs.Transitive(rustInfo.TransitiveDylibs)
-		}
-		if rustInfo.TransitiveRlibs != nil {
-			transitiveRlibs.Transitive(rustInfo.TransitiveRlibs)
-		}
-		if rustInfo.TransitiveProcMacros != nil {
-			transitiveProcMacros.Transitive(rustInfo.TransitiveProcMacros)
-		}
-
 		if rustDep, ok := dep.(*Module); ok && !rustDep.CcLibraryInterface() {
 			//Handle Rust Modules
 			makeLibName := rustMakeLibName(ctx, mod, rustDep, depName+rustDep.Properties.RustSubName)
@@ -1296,12 +1253,9 @@
 				directDylibDeps = append(directDylibDeps, rustDep)
 				mod.Properties.AndroidMkDylibs = append(mod.Properties.AndroidMkDylibs, makeLibName)
 				mod.Properties.SnapshotDylibs = append(mod.Properties.SnapshotDylibs, cc.BaseLibName(depName))
-				transitiveDylibs.Direct(RustLibrary{
-					Path:      rustDep.UnstrippedOutputFile(),
-					CrateName: rustDep.CrateName(),
-				})
 
 			case rlibDepTag:
+
 				rlib, ok := rustDep.compiler.(libraryInterface)
 				if !ok || !rlib.rlib() {
 					ctx.ModuleErrorf("mod %q not an rlib library", makeLibName)
@@ -1310,18 +1264,10 @@
 				directRlibDeps = append(directRlibDeps, rustDep)
 				mod.Properties.AndroidMkRlibs = append(mod.Properties.AndroidMkRlibs, makeLibName)
 				mod.Properties.SnapshotRlibs = append(mod.Properties.SnapshotRlibs, cc.BaseLibName(depName))
-				transitiveRlibs.Direct(RustLibrary{
-					Path:      rustDep.UnstrippedOutputFile(),
-					CrateName: rustDep.CrateName(),
-				})
 
 			case procMacroDepTag:
 				directProcMacroDeps = append(directProcMacroDeps, rustDep)
 				mod.Properties.AndroidMkProcMacroLibs = append(mod.Properties.AndroidMkProcMacroLibs, makeLibName)
-				transitiveProcMacros.Direct(RustLibrary{
-					Path:      rustDep.UnstrippedOutputFile(),
-					CrateName: rustDep.CrateName(),
-				})
 			}
 
 			transitiveAndroidMkSharedLibs = append(transitiveAndroidMkSharedLibs, rustDep.transitiveAndroidMkSharedLibs)
@@ -1357,8 +1303,9 @@
 
 			if depTag == dylibDepTag || depTag == rlibDepTag || depTag == procMacroDepTag {
 				linkFile := rustDep.UnstrippedOutputFile()
+				linkDir := linkPathFromFilePath(linkFile)
 				if lib, ok := mod.compiler.(exportedFlagsProducer); ok {
-					lib.exportLinkDirs(linkFile.Dir())
+					lib.exportLinkDirs(linkDir)
 				}
 			}
 
@@ -1385,7 +1332,7 @@
 				return
 			}
 
-			linkPath := linkObject.Path().Dir()
+			linkPath := linkPathFromFilePath(linkObject.Path())
 
 			exportDep := false
 			switch {
@@ -1439,7 +1386,7 @@
 					}
 					return
 				}
-				linkPath = linkObject.Path().Dir()
+				linkPath = linkPathFromFilePath(linkObject.Path())
 
 				depPaths.linkDirs = append(depPaths.linkDirs, linkPath)
 				depPaths.linkObjects = append(depPaths.linkObjects, linkObject.AsPaths()...)
@@ -1474,25 +1421,6 @@
 			}
 		} else {
 			switch {
-			case depTag == buildToolDepTag:
-				buildTool := ctx.OtherModuleProvider(dep, android.PrebuiltBuildToolInfoProvider).(android.PrebuiltBuildToolInfo)
-				depPaths.BuildToolDeps = append(depPaths.BuildToolDeps, buildTool.Src)
-				depPaths.BuildToolDeps = append(depPaths.BuildToolDeps, buildTool.Deps...)
-				switch android.RemoveOptionalPrebuiltPrefix(dep.Name()) {
-				case "rustc":
-					depPaths.Rustc = buildTool.Src
-					// rustc expects the standard cc toolchain libraries (libdl, libm, libc, etc.)
-					// not to be under the __SBOX_SANDBOX_DIR__/ directory
-					depPaths.BuildToolSrcDeps = append(depPaths.BuildToolSrcDeps, buildTool.Deps...)
-				case "clang++":
-					depPaths.Clang = buildTool.Src
-				case "llvm-ar":
-					depPaths.Llvm_ar = buildTool.Src
-				case "clippy-driver":
-					depPaths.Clippy_driver = buildTool.Src
-				case "rustdoc":
-					depPaths.Rustdoc = buildTool.Src
-				}
 			case depTag == cc.CrtBeginDepTag:
 				depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
 			case depTag == cc.CrtEndDepTag:
@@ -1508,6 +1436,21 @@
 		}
 	})
 
+	mod.transitiveAndroidMkSharedLibs = android.NewDepSet[string](android.PREORDER, directAndroidMkSharedLibs, transitiveAndroidMkSharedLibs)
+
+	var rlibDepFiles RustLibraries
+	for _, dep := range directRlibDeps {
+		rlibDepFiles = append(rlibDepFiles, RustLibrary{Path: dep.UnstrippedOutputFile(), CrateName: dep.CrateName()})
+	}
+	var dylibDepFiles RustLibraries
+	for _, dep := range directDylibDeps {
+		dylibDepFiles = append(dylibDepFiles, RustLibrary{Path: dep.UnstrippedOutputFile(), CrateName: dep.CrateName()})
+	}
+	var procMacroDepFiles RustLibraries
+	for _, dep := range directProcMacroDeps {
+		procMacroDepFiles = append(procMacroDepFiles, RustLibrary{Path: dep.UnstrippedOutputFile(), CrateName: dep.CrateName()})
+	}
+
 	var libDepFiles android.Paths
 	for _, dep := range directStaticLibDeps {
 		libDepFiles = append(libDepFiles, dep.OutputFile().Path())
@@ -1531,22 +1474,20 @@
 		srcProviderDepFiles = append(srcProviderDepFiles, srcs...)
 	}
 
+	depPaths.RLibs = append(depPaths.RLibs, rlibDepFiles...)
+	depPaths.DyLibs = append(depPaths.DyLibs, dylibDepFiles...)
 	depPaths.LibDeps = append(depPaths.LibDeps, libDepFiles...)
+	depPaths.ProcMacros = append(depPaths.ProcMacros, procMacroDepFiles...)
 	depPaths.SrcDeps = append(depPaths.SrcDeps, srcProviderDepFiles...)
 
 	// Dedup exported flags from dependencies
-	depPaths.linkDirs = android.FirstUniquePaths(depPaths.linkDirs)
+	depPaths.linkDirs = android.FirstUniqueStrings(depPaths.linkDirs)
 	depPaths.linkObjects = android.FirstUniquePaths(depPaths.linkObjects)
 	depPaths.depFlags = android.FirstUniqueStrings(depPaths.depFlags)
 	depPaths.depClangFlags = android.FirstUniqueStrings(depPaths.depClangFlags)
 	depPaths.depIncludePaths = android.FirstUniquePaths(depPaths.depIncludePaths)
 	depPaths.depSystemIncludePaths = android.FirstUniquePaths(depPaths.depSystemIncludePaths)
 
-	depPaths.Rlibs = transitiveRlibs.Build()
-	depPaths.Dylibs = transitiveDylibs.Build()
-	depPaths.ProcMacros = transitiveProcMacros.Build()
-	mod.transitiveAndroidMkSharedLibs = android.NewDepSet[string](android.PREORDER, directAndroidMkSharedLibs, transitiveAndroidMkSharedLibs)
-
 	return depPaths
 }
 
@@ -1569,6 +1510,10 @@
 	return mod.InRecovery()
 }
 
+func linkPathFromFilePath(filepath android.Path) string {
+	return strings.Split(filepath.String(), filepath.Base())[0]
+}
+
 // usePublicApi returns true if the rust variant should link against NDK (publicapi)
 func (r *Module) usePublicApi() bool {
 	return r.Device() && r.UseSdk()
@@ -1611,15 +1556,6 @@
 			blueprint.Variation{Mutator: "rust_stdlinkage", Variation: stdLinkage})
 	}
 
-	ctx.AddFarVariationDependencies([]blueprint.Variation{}, buildToolDepTag, "rustc")
-	ctx.AddFarVariationDependencies([]blueprint.Variation{}, buildToolDepTag, "clippy-driver")
-	ctx.AddFarVariationDependencies([]blueprint.Variation{}, buildToolDepTag, "rustdoc")
-	ctx.AddFarVariationDependencies([]blueprint.Variation{}, buildToolDepTag, "clang++")
-	ctx.AddFarVariationDependencies([]blueprint.Variation{}, buildToolDepTag, "clang++.real")
-	ctx.AddFarVariationDependencies([]blueprint.Variation{}, buildToolDepTag, "lld")
-	ctx.AddFarVariationDependencies([]blueprint.Variation{}, buildToolDepTag, "ld.lld")
-	ctx.AddFarVariationDependencies([]blueprint.Variation{}, buildToolDepTag, "llvm-ar")
-
 	// rlibs
 	rlibDepVariations = append(rlibDepVariations, blueprint.Variation{Mutator: "rust_libraries", Variation: rlibVariation})
 	for _, lib := range deps.Rlibs {
diff --git a/rust/rust_test.go b/rust/rust_test.go
index 576209d..835114c 100644
--- a/rust/rust_test.go
+++ b/rust/rust_test.go
@@ -15,17 +15,14 @@
 package rust
 
 import (
-	"fmt"
 	"os"
 	"runtime"
 	"strings"
 	"testing"
 
 	"github.com/google/blueprint/proptools"
-	"google.golang.org/protobuf/encoding/prototext"
 
 	"android/soong/android"
-	"android/soong/cmd/sbox/sbox_proto"
 	"android/soong/genrule"
 )
 
@@ -67,14 +64,11 @@
 
 // testRust returns a TestContext in which a basic environment has been setup.
 // This environment contains a few mocked files. See rustMockedFiles for the list of these files.
-func testRust(t *testing.T, bp string, preparers ...android.FixturePreparer) *android.TestContext {
+func testRust(t *testing.T, bp string) *android.TestContext {
 	skipTestIfOsNotSupported(t)
 	result := android.GroupFixturePreparers(
 		prepareForRustTest,
 		rustMockedFiles.AddToFixture(),
-		android.GroupFixturePreparers(
-			preparers...,
-		),
 	).
 		RunTestWithBp(t, bp)
 	return result.TestContext
@@ -208,11 +202,11 @@
 // Test that we can extract the link path from a lib path.
 func TestLinkPathFromFilePath(t *testing.T) {
 	barPath := android.PathForTesting("out/soong/.intermediates/external/libbar/libbar/linux_glibc_x86_64_shared/libbar.so")
-	libName := barPath.Dir()
-	expectedResult := "out/soong/.intermediates/external/libbar/libbar/linux_glibc_x86_64_shared"
+	libName := linkPathFromFilePath(barPath)
+	expectedResult := "out/soong/.intermediates/external/libbar/libbar/linux_glibc_x86_64_shared/"
 
-	if libName.String() != expectedResult {
-		t.Errorf("libNameFromFilePath returned the wrong name; expected '%#v', got '%#v'", expectedResult, libName.String())
+	if libName != expectedResult {
+		t.Errorf("libNameFromFilePath returned the wrong name; expected '%#v', got '%#v'", expectedResult, libName)
 	}
 }
 
@@ -262,7 +256,7 @@
 	`)
 	module := ctx.ModuleForTests("fizz-buzz", "linux_glibc_x86_64").Module().(*Module)
 	rustc := ctx.ModuleForTests("librlib", "linux_glibc_x86_64_rlib_rlib-std").Rule("rustc")
-	rustLink := ctx.ModuleForTests("fizz-buzz", "linux_glibc_x86_64").Rule("rustc")
+	rustLink := ctx.ModuleForTests("fizz-buzz", "linux_glibc_x86_64").Rule("rustLink")
 
 	// Since dependencies are added to AndroidMk* properties, we can check these to see if they've been picked up.
 	if !android.InList("librlib.rlib-std", module.Properties.AndroidMkRlibs) {
@@ -281,16 +275,16 @@
 		t.Errorf("Static library dependency not detected (dependency missing from AndroidMkStaticLibs)")
 	}
 
-	if !strings.Contains(rustc.RuleParams.Command, "-lstatic=wholestatic") {
-		t.Errorf("-lstatic flag not being passed to rustc for static library %#v", rustc.RuleParams.Command)
+	if !strings.Contains(rustc.Args["rustcFlags"], "-lstatic=wholestatic") {
+		t.Errorf("-lstatic flag not being passed to rustc for static library %#v", rustc.Args["rustcFlags"])
 	}
 
-	if !strings.Contains(rustLink.RuleParams.Command, "cc_stubs_dep.so") {
-		t.Errorf("shared cc_library not being passed to rustc linkFlags %#v", rustLink.RuleParams.Command)
+	if !strings.Contains(rustLink.Args["linkFlags"], "cc_stubs_dep.so") {
+		t.Errorf("shared cc_library not being passed to rustc linkFlags %#v", rustLink.Args["linkFlags"])
 	}
 
-	if !android.SuffixInList(rustLink.Implicits.Strings(), "cc_stubs_dep.so") {
-		t.Errorf("shared cc dep not being passed as implicit to rustc %#v", rustLink.OrderOnly.Strings())
+	if !android.SuffixInList(rustLink.OrderOnly.Strings(), "cc_stubs_dep.so") {
+		t.Errorf("shared cc dep not being passed as order-only to rustc %#v", rustLink.OrderOnly.Strings())
 	}
 
 	if !android.SuffixInList(rustLink.Implicits.Strings(), "cc_stubs_dep.so.toc") {
@@ -433,7 +427,7 @@
 	`)
 	rustc := ctx.ModuleForTests("libpm", "linux_glibc_x86_64").Rule("rustc")
 
-	if !strings.Contains(rustc.RuleParams.Command, "libbar/linux_glibc_x86_64") {
+	if !strings.Contains(rustc.Args["libFlags"], "libbar/linux_glibc_x86_64") {
 		t.Errorf("Proc_macro is not using host variant of dependent modules.")
 	}
 }
@@ -486,396 +480,3 @@
 		t.Errorf("expected %q got %q", expected, got)
 	}
 }
-
-var (
-	sboxCompilationFiles = []string{
-		"out/soong/.intermediates/defaults/rust/libaddr2line/android_arm64_armv8-a_rlib/libaddr2line.rlib",
-		"out/soong/.intermediates/defaults/rust/libadler/android_arm64_armv8-a_rlib/libadler.rlib",
-		"out/soong/.intermediates/defaults/rust/liballoc/android_arm64_armv8-a_rlib/liballoc.rlib",
-		"out/soong/.intermediates/defaults/rust/libcfg_if/android_arm64_armv8-a_rlib/libcfg_if.rlib",
-		"out/soong/.intermediates/defaults/rust/libcompiler_builtins/android_arm64_armv8-a_rlib/libcompiler_builtins.rlib",
-		"out/soong/.intermediates/defaults/rust/libcore/android_arm64_armv8-a_rlib/libcore.rlib",
-		"out/soong/.intermediates/defaults/rust/libgimli/android_arm64_armv8-a_rlib/libgimli.rlib",
-		"out/soong/.intermediates/defaults/rust/libhashbrown/android_arm64_armv8-a_rlib/libhashbrown.rlib",
-		"out/soong/.intermediates/defaults/rust/liblibc/android_arm64_armv8-a_rlib/liblibc.rlib",
-		"out/soong/.intermediates/defaults/rust/libmemchr/android_arm64_armv8-a_rlib/libmemchr.rlib",
-		"out/soong/.intermediates/defaults/rust/libminiz_oxide/android_arm64_armv8-a_rlib/libminiz_oxide.rlib",
-		"out/soong/.intermediates/defaults/rust/libobject/android_arm64_armv8-a_rlib/libobject.rlib",
-		"out/soong/.intermediates/defaults/rust/libpanic_unwind/android_arm64_armv8-a_rlib/libpanic_unwind.rlib",
-		"out/soong/.intermediates/defaults/rust/librustc_demangle/android_arm64_armv8-a_rlib/librustc_demangle.rlib",
-		"out/soong/.intermediates/defaults/rust/librustc_std_workspace_alloc/android_arm64_armv8-a_rlib/librustc_std_workspace_alloc.rlib",
-		"out/soong/.intermediates/defaults/rust/librustc_std_workspace_core/android_arm64_armv8-a_rlib/librustc_std_workspace_core.rlib",
-		"out/soong/.intermediates/defaults/rust/libstd_detect/android_arm64_armv8-a_rlib/libstd_detect.rlib",
-		"build/soong/scripts/mkcratersp.py",
-		"defaults/rust/linux-x86/1.69.0/bin/rustc",
-		"defaults/rust/linux-x86/1.69.0/lib/libstd.so",
-		"defaults/rust/linux-x86/1.69.0/lib64/libc++.so.1",
-	}
-	sboxCompilationFilesWithCc = []string{
-		"defaults/cc/common",
-		"out/soong/.intermediates/defaults/cc/common/libc/android_arm64_armv8-a_shared/libc.so",
-		"out/soong/.intermediates/defaults/cc/common/libc/android_arm64_armv8-a_shared/libc.so.toc",
-		"out/soong/.intermediates/defaults/cc/common/libdl/android_arm64_armv8-a_shared/libdl.so",
-		"out/soong/.intermediates/defaults/cc/common/libdl/android_arm64_armv8-a_shared/libdl.so.toc",
-		"out/soong/.intermediates/defaults/cc/common/libm/android_arm64_armv8-a_shared/libm.so",
-		"out/soong/.intermediates/defaults/cc/common/libm/android_arm64_armv8-a_shared/libm.so.toc",
-		"out/soong/.intermediates/defaults/rust/liblog/android_arm64_armv8-a_shared/liblog.so",
-		"out/soong/.intermediates/defaults/rust/liblog/android_arm64_armv8-a_shared/liblog.so.toc",
-	}
-)
-
-func TestSandboxCompilation(t *testing.T) {
-	ctx := testRust(t, `
-		filegroup {
-			name: "libsrcs1",
-			srcs: ["src_filegroup1.rs"],
-		}
-		filegroup {
-			name: "libsrcs2",
-			srcs: ["src_filegroup2.rs"],
-		}
-		rust_library {
-			name: "libfizz_buzz",
-			crate_name:"fizz_buzz",
-			crate_root: "foo.rs",
-			srcs: [
-				"src_lib*.rs",
-				":libsrcs1",
-				":libsrcs2",
-			],
-			compile_data: [
-				"compile_data1.txt",
-				"compile_data2.txt",
-			],
-			dylib: {
-				srcs: ["dylib_only.rs"],
-			},
-			rlib: {
-				srcs: ["rlib_only.rs"],
-			},
-		}
-		rust_binary {
-			name: "fizz_buzz",
-			crate_name:"fizz_buzz",
-			crate_root: "foo.rs",
-			srcs: [
-				"src_lib*.rs",
-				":libsrcs1",
-				":libsrcs2",
-			],
-		}
-		rust_ffi {
-			name: "librust_ffi",
-			crate_name: "rust_ffi",
-			crate_root: "foo.rs",
-			static: {
-				srcs: ["static_only.rs"],
-			},
-			shared: {
-				srcs: ["shared_only.rs"],
-			},
-			srcs: ["src1.rs"],
-		}
-		cc_library_static {
-			name: "cc_dep_static",
-		}
-		cc_library_shared {
-			name: "cc_dep_shared",
-		}
-		rust_library {
-			name: "libfizz_buzz_cc_deps",
-			crate_name:"fizz_buzz",
-			crate_root: "foo.rs",
-			srcs: ["src*.rs"],
-			shared_libs: ["cc_dep_shared"],
-			static_libs: ["cc_dep_static"],
-		}
-		rust_library {
-			name: "libfizz_buzz_intermediate_cc_deps",
-			crate_name:"fizz_buzz",
-			crate_root: "foo.rs",
-			srcs: ["src*.rs"],
-			rustlibs: ["libfizz_buzz_cc_deps"],
-		}
-		rust_library {
-			name: "libfizz_buzz_transitive_cc_deps",
-			crate_name:"fizz_buzz",
-			crate_root: "foo.rs",
-			srcs: ["src*.rs"],
-			rustlibs: ["libfizz_buzz_intermediate_cc_deps"],
-		}
-	`,
-		android.FixtureMergeMockFs(android.MockFS{
-			"src_lib1.rs":       nil,
-			"src_lib2.rs":       nil,
-			"src_lib3.rs":       nil,
-			"src_lib4.rs":       nil,
-			"src_filegroup1.rs": nil,
-			"src_filegroup2.rs": nil,
-			"static_only.rs":    nil,
-			"shared_only.rs":    nil,
-		}),
-	)
-
-	testcases := []struct {
-		name                     string
-		moduleName               string
-		variant                  string
-		rustcExpectedFilesToCopy []string
-		expectedFlags            []string
-	}{
-		{
-			name:       "rust_library (dylib)",
-			moduleName: "libfizz_buzz",
-			variant:    "android_arm64_armv8-a_dylib",
-			rustcExpectedFilesToCopy: android.Concat(sboxCompilationFiles, sboxCompilationFilesWithCc, []string{
-				"foo.rs",
-				"src_lib1.rs",
-				"src_lib2.rs",
-				"src_lib3.rs",
-				"src_lib4.rs",
-				"src_filegroup1.rs",
-				"src_filegroup2.rs",
-				"compile_data1.txt",
-				"compile_data2.txt",
-				"dylib_only.rs",
-				"out/soong/.intermediates/libfizz_buzz/android_arm64_armv8-a_dylib/out/src_filegroup1.rs",
-				"out/soong/.intermediates/libfizz_buzz/android_arm64_armv8-a_dylib/out/src_filegroup2.rs",
-
-				"out/soong/.intermediates/defaults/cc/common/libc/android_arm64_armv8-a_shared/libc.so",
-				"out/soong/.intermediates/defaults/cc/common/libc/android_arm64_armv8-a_shared/libc.so.toc",
-				"out/soong/.intermediates/defaults/cc/common/libm/android_arm64_armv8-a_shared/libm.so",
-				"out/soong/.intermediates/defaults/cc/common/libm/android_arm64_armv8-a_shared/libm.so.toc",
-				"out/soong/.intermediates/defaults/cc/common/libdl/android_arm64_armv8-a_shared/libdl.so",
-				"out/soong/.intermediates/defaults/cc/common/libdl/android_arm64_armv8-a_shared/libdl.so.toc",
-				"out/soong/.intermediates/defaults/rust/libstd/android_arm64_armv8-a_dylib/unstripped/libstd.dylib.so",
-				"out/soong/.intermediates/defaults/cc/common/crtbegin_so/android_arm64_armv8-a/crtbegin_so.o",
-				"out/soong/.intermediates/defaults/cc/common/crtend_so/android_arm64_armv8-a/crtend_so.o",
-				"out/soong/.intermediates/libfizz_buzz/android_arm64_armv8-a_dylib/libfizz_buzz.dylib.so.clippy",
-			}),
-			expectedFlags: []string{
-				"-C linker=build/soong/scripts/mkcratersp.py",
-				"--emit link",
-				"-o __SBOX_SANDBOX_DIR__/out/libfizz_buzz.dylib.so.rsp",
-				"--emit dep-info=__SBOX_SANDBOX_DIR__/out/libfizz_buzz.dylib.so.d.raw",
-				"foo.rs", // this is the entry point
-			},
-		},
-		{
-			name:       "rust_library (rlib dylib-std)",
-			moduleName: "libfizz_buzz",
-			variant:    "android_arm64_armv8-a_rlib_dylib-std",
-			rustcExpectedFilesToCopy: android.Concat(sboxCompilationFiles, []string{
-				"foo.rs",
-				"src_lib1.rs",
-				"src_lib2.rs",
-				"src_lib3.rs",
-				"src_lib4.rs",
-				"src_filegroup1.rs",
-				"src_filegroup2.rs",
-				"rlib_only.rs",
-				"out/soong/.intermediates/libfizz_buzz/android_arm64_armv8-a_rlib_dylib-std/out/src_filegroup1.rs",
-				"out/soong/.intermediates/libfizz_buzz/android_arm64_armv8-a_rlib_dylib-std/out/src_filegroup2.rs",
-				"out/soong/.intermediates/defaults/rust/libstd/android_arm64_armv8-a_dylib/unstripped/libstd.dylib.so",
-			}),
-			expectedFlags: []string{
-				"--emit link",
-				"-o __SBOX_SANDBOX_DIR__/out/libfizz_buzz.rlib",
-				"--emit dep-info=__SBOX_SANDBOX_DIR__/out/libfizz_buzz.rlib.d.raw",
-				"foo.rs", // this is the entry point
-			},
-		},
-		{
-			name:       "rust_library (rlib rlib-std)",
-			moduleName: "libfizz_buzz",
-			variant:    "android_arm64_armv8-a_rlib_rlib-std",
-			rustcExpectedFilesToCopy: android.Concat(sboxCompilationFiles, []string{
-				"foo.rs",
-				"src_lib1.rs",
-				"src_lib2.rs",
-				"src_lib3.rs",
-				"src_lib4.rs",
-				"src_filegroup1.rs",
-				"src_filegroup2.rs",
-				"rlib_only.rs",
-				"out/soong/.intermediates/libfizz_buzz/android_arm64_armv8-a_rlib_rlib-std/out/src_filegroup1.rs",
-				"out/soong/.intermediates/libfizz_buzz/android_arm64_armv8-a_rlib_rlib-std/out/src_filegroup2.rs",
-				"out/soong/.intermediates/libfizz_buzz/android_arm64_armv8-a_rlib_rlib-std/libfizz_buzz.rlib.clippy",
-				"out/soong/.intermediates/defaults/rust/libstd/android_arm64_armv8-a_rlib/libstd.rlib",
-			}),
-			expectedFlags: []string{
-				"--emit link",
-				"-o __SBOX_SANDBOX_DIR__/out/libfizz_buzz.rlib",
-				"--emit dep-info=__SBOX_SANDBOX_DIR__/out/libfizz_buzz.rlib.d.raw",
-				"foo.rs", // this is the entry point
-			},
-		},
-		{
-			name:       "rust_binary",
-			moduleName: "fizz_buzz",
-			variant:    "android_arm64_armv8-a",
-			rustcExpectedFilesToCopy: android.Concat(sboxCompilationFiles, sboxCompilationFilesWithCc, []string{
-				"foo.rs",
-				"src_lib1.rs",
-				"src_lib2.rs",
-				"src_lib3.rs",
-				"src_lib4.rs",
-				"src_filegroup1.rs",
-				"src_filegroup2.rs",
-				"out/soong/.intermediates/fizz_buzz/android_arm64_armv8-a/out/src_filegroup1.rs",
-				"out/soong/.intermediates/fizz_buzz/android_arm64_armv8-a/out/src_filegroup2.rs",
-
-				"out/soong/.intermediates/defaults/rust/libstd/android_arm64_armv8-a_dylib/unstripped/libstd.dylib.so",
-				"out/soong/.intermediates/defaults/cc/common/crtbegin_dynamic/android_arm64_armv8-a/crtbegin_dynamic.o",
-				"out/soong/.intermediates/defaults/cc/common/crtend_android/android_arm64_armv8-a/crtend_android.o",
-				"out/soong/.intermediates/fizz_buzz/android_arm64_armv8-a/fizz_buzz.clippy",
-			}),
-			expectedFlags: []string{
-				"--emit link",
-				"-o __SBOX_SANDBOX_DIR__/out/fizz_buzz",
-				"--emit dep-info=__SBOX_SANDBOX_DIR__/out/fizz_buzz.d.raw",
-				"foo.rs", // this is the entry point
-			},
-		},
-		{
-			name:       "rust_ffi static lib variant",
-			moduleName: "librust_ffi",
-			variant:    "android_arm64_armv8-a_static",
-			rustcExpectedFilesToCopy: android.Concat(sboxCompilationFiles, []string{
-				"foo.rs",
-				"src1.rs",
-				"static_only.rs",
-				"out/soong/.intermediates/librust_ffi/android_arm64_armv8-a_static/librust_ffi.a.clippy",
-				"out/soong/.intermediates/defaults/rust/libstd/android_arm64_armv8-a_rlib/libstd.rlib",
-			}),
-			expectedFlags: []string{
-				"--emit link",
-				"-o __SBOX_SANDBOX_DIR__/out/librust_ffi.a",
-				"--emit dep-info=__SBOX_SANDBOX_DIR__/out/librust_ffi.a.d.raw",
-				"foo.rs", // this is the entry point
-			},
-		},
-		{
-			name:       "rust_ffi shared lib variant",
-			moduleName: "librust_ffi",
-			variant:    "android_arm64_armv8-a_shared",
-			rustcExpectedFilesToCopy: android.Concat(sboxCompilationFiles, sboxCompilationFilesWithCc, []string{
-				"foo.rs",
-				"src1.rs",
-				"shared_only.rs",
-
-				"out/soong/.intermediates/defaults/rust/libstd/android_arm64_armv8-a_dylib/unstripped/libstd.dylib.so",
-				"out/soong/.intermediates/defaults/cc/common/crtbegin_so/android_arm64_armv8-a/crtbegin_so.o",
-				"out/soong/.intermediates/defaults/cc/common/crtend_so/android_arm64_armv8-a/crtend_so.o",
-				"out/soong/.intermediates/librust_ffi/android_arm64_armv8-a_shared/librust_ffi.so.clippy",
-			}),
-			expectedFlags: []string{
-				"--emit link",
-				"-o __SBOX_SANDBOX_DIR__/out/librust_ffi.so",
-				"--emit dep-info=__SBOX_SANDBOX_DIR__/out/librust_ffi.so.d.raw",
-				"foo.rs", // this is the entry point
-			},
-		},
-		{
-			name:       "rust_library with cc deps (dylib)",
-			moduleName: "libfizz_buzz_cc_deps",
-			variant:    "android_arm64_armv8-a_dylib",
-			rustcExpectedFilesToCopy: []string{
-				"out/soong/.intermediates/cc_dep_static/android_arm64_armv8-a_static/cc_dep_static.a",
-				"out/soong/.intermediates/cc_dep_shared/android_arm64_armv8-a_shared/cc_dep_shared.so",
-				"out/soong/.intermediates/cc_dep_shared/android_arm64_armv8-a_shared/cc_dep_shared.so.toc",
-			},
-		},
-		{
-			name:       "rust_library with cc deps (rlib rlib-std)",
-			moduleName: "libfizz_buzz_cc_deps",
-			variant:    "android_arm64_armv8-a_rlib_rlib-std",
-			rustcExpectedFilesToCopy: []string{
-				"out/soong/.intermediates/cc_dep_static/android_arm64_armv8-a_static/cc_dep_static.a",
-				"out/soong/.intermediates/cc_dep_shared/android_arm64_armv8-a_shared/cc_dep_shared.so",
-				"out/soong/.intermediates/cc_dep_shared/android_arm64_armv8-a_shared/cc_dep_shared.so.toc",
-			},
-		},
-		{
-			name:       "rust_library with cc deps (rlib dylib-std)",
-			moduleName: "libfizz_buzz_cc_deps",
-			variant:    "android_arm64_armv8-a_rlib_dylib-std",
-			rustcExpectedFilesToCopy: []string{
-				"out/soong/.intermediates/cc_dep_static/android_arm64_armv8-a_static/cc_dep_static.a",
-				"out/soong/.intermediates/cc_dep_shared/android_arm64_armv8-a_shared/cc_dep_shared.so",
-				"out/soong/.intermediates/cc_dep_shared/android_arm64_armv8-a_shared/cc_dep_shared.so.toc",
-			},
-		},
-		{
-			name:       "rust_library with transitive cc deps (dylib)",
-			moduleName: "libfizz_buzz_transitive_cc_deps",
-			variant:    "android_arm64_armv8-a_dylib",
-			rustcExpectedFilesToCopy: []string{
-				"out/soong/.intermediates/cc_dep_static/android_arm64_armv8-a_static/cc_dep_static.a",
-				"out/soong/.intermediates/cc_dep_shared/android_arm64_armv8-a_shared/cc_dep_shared.so",
-				"out/soong/.intermediates/cc_dep_shared/android_arm64_armv8-a_shared/cc_dep_shared.so.toc",
-			},
-		},
-		{
-			name:       "rust_library with transitive cc deps (rlib rlib-std)",
-			moduleName: "libfizz_buzz_transitive_cc_deps",
-			variant:    "android_arm64_armv8-a_rlib_rlib-std",
-			rustcExpectedFilesToCopy: []string{
-				"out/soong/.intermediates/cc_dep_static/android_arm64_armv8-a_static/cc_dep_static.a",
-				"out/soong/.intermediates/cc_dep_shared/android_arm64_armv8-a_shared/cc_dep_shared.so",
-				"out/soong/.intermediates/cc_dep_shared/android_arm64_armv8-a_shared/cc_dep_shared.so.toc",
-			},
-		},
-		{
-			name:       "rust_library with transitive cc deps (rlib dylib-std)",
-			moduleName: "libfizz_buzz_transitive_cc_deps",
-			variant:    "android_arm64_armv8-a_rlib_dylib-std",
-			rustcExpectedFilesToCopy: []string{
-				"out/soong/.intermediates/cc_dep_static/android_arm64_armv8-a_static/cc_dep_static.a",
-				"out/soong/.intermediates/cc_dep_shared/android_arm64_armv8-a_shared/cc_dep_shared.so",
-				"out/soong/.intermediates/cc_dep_shared/android_arm64_armv8-a_shared/cc_dep_shared.so.toc",
-			},
-		},
-	}
-
-	for _, tc := range testcases {
-		t.Run(tc.name, func(t *testing.T) {
-			writeFile := ctx.ModuleForTests(tc.moduleName, tc.variant).Rule("unescapedWriteFile")
-			contents := writeFile.BuildParams.Args["content"]
-			manifestProto := sbox_proto.Manifest{}
-			err := prototext.Unmarshal([]byte(contents), &manifestProto)
-			if err != nil {
-				t.Errorf("expected no errors unmarshaling manifest proto; got %v", err)
-			}
-
-			if len(manifestProto.Commands) != 1 {
-				t.Errorf("expected 1 command; got %v", len(manifestProto.Commands))
-			}
-
-			// check that sandbox contains correct files
-			rustc := manifestProto.Commands[0]
-			actualFilesToCopy := []string{}
-			for _, copy := range rustc.CopyBefore {
-				actualFilesToCopy = append(actualFilesToCopy, copy.GetFrom())
-			}
-			_, expectedFilesNotCopied, _ := android.ListSetDifference(tc.rustcExpectedFilesToCopy, actualFilesToCopy)
-			if len(expectedFilesNotCopied) > 0 {
-				t.Errorf("did not copy expected files to sbox: %v;\n files copied: %v", expectedFilesNotCopied, actualFilesToCopy)
-			}
-
-			rustcCmd := proptools.String(rustc.Command)
-			for _, flag := range tc.expectedFlags {
-				android.AssertStringDoesContain(
-					t,
-					fmt.Sprintf(
-						"missing flag in rustc invocation; expected to find substring %q; got %q",
-						flag,
-						rustcCmd,
-					),
-					rustcCmd,
-					flag,
-				)
-			}
-		})
-	}
-}
diff --git a/rust/sanitize_test.go b/rust/sanitize_test.go
index d6a14b2..43e95f4 100644
--- a/rust/sanitize_test.go
+++ b/rust/sanitize_test.go
@@ -35,7 +35,7 @@
 	note_sync := "note_memtag_heap_sync"
 
 	found := None
-	implicits := m.Rule("rustc").Implicits
+	implicits := m.Rule("rustLink").Implicits
 	for _, lib := range implicits {
 		if strings.Contains(lib.Rel(), note_async) {
 			found = Async
diff --git a/rust/testing.go b/rust/testing.go
index 9951937..3fe751e 100644
--- a/rust/testing.go
+++ b/rust/testing.go
@@ -52,22 +52,6 @@
 
 func GatherRequiredDepsForTest() string {
 	bp := `
-		prebuilt_build_tool {
-			name: "rustc",
-			src: "linux-x86/1.69.0/bin/rustc",
-			deps: [
-				"linux-x86/1.69.0/lib/libstd.so",
-				"linux-x86/1.69.0/lib64/libc++.so.1",
-			],
-		}
-		prebuilt_build_tool {
-			name: "clippy-driver",
-			src: "linux-x86/1.69.0/bin/clippy-driver",
-		}
-		prebuilt_build_tool {
-			name: "rustdoc",
-			src: "linux-x86/1.69.0/bin/rustdoc",
-		}
 		rust_prebuilt_library {
 				name: "libstd",
 				crate_name: "std",
@@ -79,25 +63,6 @@
 				},
 				host_supported: true,
 				sysroot: true,
-			rlibs: [
-			    "libaddr2line",
-			    "libadler",
-			    "liballoc",
-			    "libcfg_if",
-			    "libcompiler_builtins",
-			    "libcore",
-			    "libgimli",
-			    "libhashbrown",
-			    "liblibc",
-			    "libmemchr",
-			    "libminiz_oxide",
-			    "libobject",
-			    "libpanic_unwind",
-			    "librustc_demangle",
-			    "librustc_std_workspace_alloc",
-			    "librustc_std_workspace_core",
-			    "libstd_detect",
-			],
 		}
 		//////////////////////////////
 		// Device module requirements
@@ -134,278 +99,6 @@
 			nocrt: true,
 			system_shared_libs: [],
 		}
-		rust_library_rlib {
-			name: "libaddr2line",
-			crate_name: "addr2line",
-			enabled:true,
-			srcs: ["foo.rs"],
-			no_stdlibs: true,
-			product_available: true,
-			host_supported: true,
-			vendor_available: true,
-			vendor_ramdisk_available: true,
-			recovery_available: true,
-			native_coverage: false,
-			sysroot: true,
-			apex_available: ["//apex_available:platform", "//apex_available:anyapex"],
-			min_sdk_version: "29",
-		}
-		rust_library_rlib {
-			name: "libadler",
-			crate_name: "adler",
-			enabled:true,
-			srcs: ["foo.rs"],
-			no_stdlibs: true,
-			product_available: true,
-			host_supported: true,
-			vendor_available: true,
-			vendor_ramdisk_available: true,
-			recovery_available: true,
-			native_coverage: false,
-			sysroot: true,
-			apex_available: ["//apex_available:platform", "//apex_available:anyapex"],
-			min_sdk_version: "29",
-		}
-		rust_library_rlib {
-			name: "liballoc",
-			crate_name: "alloc",
-			enabled:true,
-			srcs: ["foo.rs"],
-			no_stdlibs: true,
-			product_available: true,
-			host_supported: true,
-			vendor_available: true,
-			vendor_ramdisk_available: true,
-			recovery_available: true,
-			native_coverage: false,
-			sysroot: true,
-			apex_available: ["//apex_available:platform", "//apex_available:anyapex"],
-			min_sdk_version: "29",
-		}
-		rust_library_rlib {
-			name: "libcfg_if",
-			crate_name: "cfg_if",
-			enabled:true,
-			srcs: ["foo.rs"],
-			no_stdlibs: true,
-			product_available: true,
-			host_supported: true,
-			vendor_available: true,
-			vendor_ramdisk_available: true,
-			recovery_available: true,
-			native_coverage: false,
-			sysroot: true,
-			apex_available: ["//apex_available:platform", "//apex_available:anyapex"],
-			min_sdk_version: "29",
-		}
-		rust_library_rlib {
-			name: "libcompiler_builtins",
-			crate_name: "compiler_builtins",
-			enabled:true,
-			srcs: ["foo.rs"],
-			no_stdlibs: true,
-			product_available: true,
-			host_supported: true,
-			vendor_available: true,
-			vendor_ramdisk_available: true,
-			recovery_available: true,
-			native_coverage: false,
-			sysroot: true,
-			apex_available: ["//apex_available:platform", "//apex_available:anyapex"],
-			min_sdk_version: "29",
-		}
-		rust_library_rlib {
-			name: "libcore",
-			crate_name: "core",
-			enabled:true,
-			srcs: ["foo.rs"],
-			no_stdlibs: true,
-			product_available: true,
-			host_supported: true,
-			vendor_available: true,
-			vendor_ramdisk_available: true,
-			recovery_available: true,
-			native_coverage: false,
-			sysroot: true,
-			apex_available: ["//apex_available:platform", "//apex_available:anyapex"],
-			min_sdk_version: "29",
-		}
-		rust_library_rlib {
-			name: "libgimli",
-			crate_name: "gimli",
-			enabled:true,
-			srcs: ["foo.rs"],
-			no_stdlibs: true,
-			product_available: true,
-			host_supported: true,
-			vendor_available: true,
-			vendor_ramdisk_available: true,
-			recovery_available: true,
-			native_coverage: false,
-			sysroot: true,
-			apex_available: ["//apex_available:platform", "//apex_available:anyapex"],
-			min_sdk_version: "29",
-		}
-		rust_library_rlib {
-			name: "libhashbrown",
-			crate_name: "hashbrown",
-			enabled:true,
-			srcs: ["foo.rs"],
-			no_stdlibs: true,
-			product_available: true,
-			host_supported: true,
-			vendor_available: true,
-			vendor_ramdisk_available: true,
-			recovery_available: true,
-			native_coverage: false,
-			sysroot: true,
-			apex_available: ["//apex_available:platform", "//apex_available:anyapex"],
-			min_sdk_version: "29",
-		}
-		rust_library_rlib {
-			name: "liblibc",
-			crate_name: "libc",
-			enabled:true,
-			srcs: ["foo.rs"],
-			no_stdlibs: true,
-			product_available: true,
-			host_supported: true,
-			vendor_available: true,
-			vendor_ramdisk_available: true,
-			recovery_available: true,
-			native_coverage: false,
-			sysroot: true,
-			apex_available: ["//apex_available:platform", "//apex_available:anyapex"],
-			min_sdk_version: "29",
-		}
-		rust_library_rlib {
-			name: "libmemchr",
-			crate_name: "memchr",
-			enabled:true,
-			srcs: ["foo.rs"],
-			no_stdlibs: true,
-			product_available: true,
-			host_supported: true,
-			vendor_available: true,
-			vendor_ramdisk_available: true,
-			recovery_available: true,
-			native_coverage: false,
-			sysroot: true,
-			apex_available: ["//apex_available:platform", "//apex_available:anyapex"],
-			min_sdk_version: "29",
-		}
-		rust_library_rlib {
-			name: "libminiz_oxide",
-			crate_name: "miniz_oxide",
-			enabled:true,
-			srcs: ["foo.rs"],
-			no_stdlibs: true,
-			product_available: true,
-			host_supported: true,
-			vendor_available: true,
-			vendor_ramdisk_available: true,
-			recovery_available: true,
-			native_coverage: false,
-			sysroot: true,
-			apex_available: ["//apex_available:platform", "//apex_available:anyapex"],
-			min_sdk_version: "29",
-		}
-		rust_library_rlib {
-			name: "libobject",
-			crate_name: "object",
-			enabled:true,
-			srcs: ["foo.rs"],
-			no_stdlibs: true,
-			product_available: true,
-			host_supported: true,
-			vendor_available: true,
-			vendor_ramdisk_available: true,
-			recovery_available: true,
-			native_coverage: false,
-			sysroot: true,
-			apex_available: ["//apex_available:platform", "//apex_available:anyapex"],
-			min_sdk_version: "29",
-		}
-		rust_library_rlib {
-			name: "libpanic_unwind",
-			crate_name: "panic_unwind",
-			enabled:true,
-			srcs: ["foo.rs"],
-			no_stdlibs: true,
-			product_available: true,
-			host_supported: true,
-			vendor_available: true,
-			vendor_ramdisk_available: true,
-			recovery_available: true,
-			native_coverage: false,
-			sysroot: true,
-			apex_available: ["//apex_available:platform", "//apex_available:anyapex"],
-			min_sdk_version: "29",
-		}
-		rust_library_rlib {
-			name: "librustc_demangle",
-			crate_name: "rustc_demangle",
-			enabled:true,
-			srcs: ["foo.rs"],
-			no_stdlibs: true,
-			product_available: true,
-			host_supported: true,
-			vendor_available: true,
-			vendor_ramdisk_available: true,
-			recovery_available: true,
-			native_coverage: false,
-			sysroot: true,
-			apex_available: ["//apex_available:platform", "//apex_available:anyapex"],
-			min_sdk_version: "29",
-		}
-		rust_library_rlib {
-			name: "librustc_std_workspace_alloc",
-			crate_name: "rustc_std_workspace_alloc",
-			enabled:true,
-			srcs: ["foo.rs"],
-			no_stdlibs: true,
-			product_available: true,
-			host_supported: true,
-			vendor_available: true,
-			vendor_ramdisk_available: true,
-			recovery_available: true,
-			native_coverage: false,
-			sysroot: true,
-			apex_available: ["//apex_available:platform", "//apex_available:anyapex"],
-			min_sdk_version: "29",
-		}
-		rust_library_rlib {
-			name: "librustc_std_workspace_core",
-			crate_name: "rustc_std_workspace_core",
-			enabled:true,
-			srcs: ["foo.rs"],
-			no_stdlibs: true,
-			product_available: true,
-			host_supported: true,
-			vendor_available: true,
-			vendor_ramdisk_available: true,
-			recovery_available: true,
-			native_coverage: false,
-			sysroot: true,
-			apex_available: ["//apex_available:platform", "//apex_available:anyapex"],
-			min_sdk_version: "29",
-		}
-		rust_library_rlib {
-			name: "libstd_detect",
-			crate_name: "std_detect",
-			enabled:true,
-			srcs: ["foo.rs"],
-			no_stdlibs: true,
-			product_available: true,
-			host_supported: true,
-			vendor_available: true,
-			vendor_ramdisk_available: true,
-			recovery_available: true,
-			native_coverage: false,
-			sysroot: true,
-			apex_available: ["//apex_available:platform", "//apex_available:anyapex"],
-			min_sdk_version: "29",
-		}
 		rust_library {
 			name: "libstd",
 			crate_name: "std",
@@ -420,25 +113,6 @@
 			sysroot: true,
 			apex_available: ["//apex_available:platform", "//apex_available:anyapex"],
 			min_sdk_version: "29",
-			rlibs: [
-			    "libaddr2line",
-			    "libadler",
-			    "liballoc",
-			    "libcfg_if",
-			    "libcompiler_builtins",
-			    "libcore",
-			    "libgimli",
-			    "libhashbrown",
-			    "liblibc",
-			    "libmemchr",
-			    "libminiz_oxide",
-			    "libobject",
-			    "libpanic_unwind",
-			    "librustc_demangle",
-			    "librustc_std_workspace_alloc",
-			    "librustc_std_workspace_core",
-			    "libstd_detect",
-			],
 		}
 		rust_library {
 			name: "libtest",
diff --git a/rust/vendor_snapshot_test.go b/rust/vendor_snapshot_test.go
index 621a724..1e7e7d3 100644
--- a/rust/vendor_snapshot_test.go
+++ b/rust/vendor_snapshot_test.go
@@ -1051,7 +1051,7 @@
 	ctx := testRustVndkFsVersions(t, "", mockFS, "30", "current", "31")
 
 	// libclient uses libvndk.vndk.30.arm64, libvendor.vendor_static.30.arm64, libvendor_without_snapshot
-	libclientLdFlags := ctx.ModuleForTests("libclient", sharedVariant).Rule("rustc").RuleParams.Command
+	libclientLdFlags := ctx.ModuleForTests("libclient", sharedVariant).Rule("rustLink").Args["linkFlags"]
 	for _, input := range [][]string{
 		[]string{sharedVariant, "libvndk.vndk.30.arm64"},
 		[]string{staticVariant, "libvendor.vendor_static.30.arm64"},
@@ -1119,7 +1119,7 @@
 		t.Errorf("Unexpected rust rlib name in AndroidMk: %q, expected: %q\n", rustVendorBinMkDylibName, expectedRustVendorSnapshotName)
 	}
 
-	binWithoutSnapshotLdFlags := ctx.ModuleForTests("bin_without_snapshot", binaryVariant).Rule("rustc").RuleParams.Command
+	binWithoutSnapshotLdFlags := ctx.ModuleForTests("bin_without_snapshot", binaryVariant).Rule("rustLink").Args["linkFlags"]
 	libVndkStaticOutputPaths := cc.GetOutputPaths(ctx, staticVariant, []string{"libvndk.vendor_static.30.arm64"})
 	if !strings.Contains(binWithoutSnapshotLdFlags, libVndkStaticOutputPaths[0].String()) {
 		t.Errorf("libflags for bin_without_snapshot must contain %#v, but was %#v",