diff --git a/rust/afdo_test.go b/rust/afdo_test.go
index 0cdf704..80327af 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.Args["rustcFlags"], expectedCFlag) {
-		t.Errorf("Expected 'foo' to enable afdo, but did not find %q in cflags %q", expectedCFlag, foo.Args["rustcFlags"])
+	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)
 	}
 }
 
@@ -96,17 +96,17 @@
 		rustMockedFiles.AddToFixture(),
 	).RunTestWithBp(t, bp)
 
-	fooArm := result.ModuleForTests("foo", "android_arm_armv7-a-neon").Rule("rustc")
-	fooArm64 := result.ModuleForTests("foo", "android_arm64_armv8-a").Rule("rustc")
+	fooArm := result.ModuleForTests("foo", "android_arm_armv7-a-neon").Description("rustc")
+	fooArm64 := result.ModuleForTests("foo", "android_arm64_armv8-a").Description("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.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(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(fooArm64.Args["rustcFlags"], expectedCFlagArm64) {
-		t.Errorf("Expected 'fooArm64' to enable afdo, but did not find %q in cflags %q", expectedCFlagArm64, fooArm64.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)
 	}
 }
diff --git a/rust/binary.go b/rust/binary.go
index 2c9f64d..20d9409 100644
--- a/rust/binary.go
+++ b/rust/binary.go
@@ -148,7 +148,6 @@
 
 	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 +158,7 @@
 	}
 	binary.baseCompiler.unstrippedOutputFile = outputFile
 
-	ret.kytheFile = TransformSrcToBinary(ctx, crateRootPath, deps, flags, outputFile).kytheFile
+	ret.kytheFile = TransformSrcToBinary(ctx, binary, crateRootPath, deps, flags, outputFile).kytheFile
 	return ret
 }
 
diff --git a/rust/binary_test.go b/rust/binary_test.go
index dff94ac..ab1d2bc 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.Args["rustcFlags"]
+	flags := fizzBuzz.RuleParams.Command
 	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("rustLink")
+	foo := ctx.ModuleForTests("foo", "android_arm64_armv8-a").Rule("rustc")
 
 	flag := "-Wl,-dynamic-linker,/system/bin/bootstrap/linker64"
-	if !strings.Contains(foo.Args["linkFlags"], flag) {
-		t.Errorf("missing link flag to use bootstrap linker, expecting %#v, linkFlags: %#v", flag, foo.Args["linkFlags"])
+	if !strings.Contains(foo.RuleParams.Command, flag) {
+		t.Errorf("missing link flag to use bootstrap linker, expecting %#v, command: %#v", flag, foo.RuleParams.Command)
 	}
 }
 
@@ -167,19 +167,17 @@
 		}`)
 
 	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.Args["rustcFlags"]
-	linkFlags := fizzOutLink.Args["linkFlags"]
+	flags := fizzOut.RuleParams.Command
 	if !strings.Contains(flags, "-C relocation-model=static") {
-		t.Errorf("static binary missing '-C relocation-model=static' in rustcFlags, found: %#v", flags)
+		t.Errorf("static binary missing '-C relocation-model=static' in command, found: %#v", flags)
 	}
 	if !strings.Contains(flags, "-C panic=abort") {
-		t.Errorf("static binary missing '-C panic=abort' in rustcFlags, found: %#v", flags)
+		t.Errorf("static binary missing '-C panic=abort' in command, found: %#v", flags)
 	}
-	if !strings.Contains(linkFlags, "-static") {
-		t.Errorf("static binary missing '-static' in linkFlags, found: %#v", flags)
+	if !strings.Contains(flags, "-static") {
+		t.Errorf("static binary missing '-static' in command, found: %#v", flags)
 	}
 
 	if !android.InList("libc", fizzMod.Properties.AndroidMkStaticLibs) {
@@ -201,10 +199,9 @@
 			name: "libfoo",
 		}`)
 
-	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)
+	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)
 	}
 }
 
diff --git a/rust/builder.go b/rust/builder.go
index b1f049d..0740518 100644
--- a/rust/builder.go
+++ b/rust/builder.go
@@ -15,6 +15,7 @@
 package rust
 
 import (
+	"fmt"
 	"path/filepath"
 	"strings"
 
@@ -25,54 +26,6 @@
 )
 
 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",
@@ -81,7 +34,7 @@
 			RspfileContent: "$in",
 		})
 
-	cp = pctx.AndroidStaticRule("cp",
+	cpDir = pctx.AndroidStaticRule("cpDir",
 		blueprint.RuleParams{
 			Command:        "cp `cat $outDir.rsp` $outDir",
 			Rspfile:        "${outDir}.rsp",
@@ -89,6 +42,12 @@
 		},
 		"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")
@@ -96,23 +55,6 @@
 		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 {
@@ -124,40 +66,40 @@
 	pctx.HostBinToolVariable("SoongZipCmd", "soong_zip")
 }
 
-func TransformSrcToBinary(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags,
+func TransformSrcToBinary(ctx ModuleContext, c compiler, mainSrc android.Path, deps PathDeps, flags Flags,
 	outputFile android.WritablePath) buildOutput {
 	flags.GlobalRustFlags = append(flags.GlobalRustFlags, "-C lto=thin")
 
-	return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "bin")
+	return transformSrctoCrate(ctx, c, mainSrc, deps, flags, outputFile, "bin")
 }
 
-func TransformSrctoRlib(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags,
+func TransformSrctoRlib(ctx ModuleContext, c compiler, mainSrc android.Path, deps PathDeps, flags Flags,
 	outputFile android.WritablePath) buildOutput {
-	return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "rlib")
+	return transformSrctoCrate(ctx, c, mainSrc, deps, flags, outputFile, "rlib")
 }
 
-func TransformSrctoDylib(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags,
+func TransformSrctoDylib(ctx ModuleContext, c compiler, mainSrc android.Path, deps PathDeps, flags Flags,
 	outputFile android.WritablePath) buildOutput {
 	flags.GlobalRustFlags = append(flags.GlobalRustFlags, "-C lto=thin")
 
-	return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "dylib")
+	return transformSrctoCrate(ctx, c, mainSrc, deps, flags, outputFile, "dylib")
 }
 
-func TransformSrctoStatic(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags,
+func TransformSrctoStatic(ctx ModuleContext, c compiler, mainSrc android.Path, deps PathDeps, flags Flags,
 	outputFile android.WritablePath) buildOutput {
 	flags.GlobalRustFlags = append(flags.GlobalRustFlags, "-C lto=thin")
-	return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "staticlib")
+	return transformSrctoCrate(ctx, c, mainSrc, deps, flags, outputFile, "staticlib")
 }
 
-func TransformSrctoShared(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags,
+func TransformSrctoShared(ctx ModuleContext, c compiler, mainSrc android.Path, deps PathDeps, flags Flags,
 	outputFile android.WritablePath) buildOutput {
 	flags.GlobalRustFlags = append(flags.GlobalRustFlags, "-C lto=thin")
-	return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "cdylib")
+	return transformSrctoCrate(ctx, c, mainSrc, deps, flags, outputFile, "cdylib")
 }
 
-func TransformSrctoProcMacro(ctx ModuleContext, mainSrc android.Path, deps PathDeps,
+func TransformSrctoProcMacro(ctx ModuleContext, c compiler, mainSrc android.Path, deps PathDeps,
 	flags Flags, outputFile android.WritablePath) buildOutput {
-	return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "proc-macro")
+	return transformSrctoCrate(ctx, c, mainSrc, deps, flags, outputFile, "proc-macro")
 }
 
 func rustLibsToPaths(libs RustLibraries) android.Paths {
@@ -168,28 +110,46 @@
 	return paths
 }
 
-func makeLibFlags(deps PathDeps) []string {
+func makeLibFlags(deps PathDeps, ruleCmd *android.RuleBuilderCommand) []string {
 	var libFlags []string
 
 	// Collect library/crate flags
-	for _, lib := range deps.RLibs {
-		libFlags = append(libFlags, "--extern "+lib.CrateName+"="+lib.Path.String())
+	for _, lib := range deps.Rlibs.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 _, lib := range deps.Dylibs.ToListDirect() {
+		libPath := ruleCmd.PathForInput(lib.Path)
+		libFlags = append(libFlags, "--extern "+lib.CrateName+"="+libPath)
 	}
-	for _, proc_macro := range deps.ProcMacros {
-		libFlags = append(libFlags, "--extern "+proc_macro.CrateName+"="+proc_macro.Path.String())
+	for _, procMacro := range deps.ProcMacros.ToListDirect() {
+		procMacroPath := ruleCmd.PathForInput(procMacro.Path)
+		libFlags = append(libFlags, "--extern "+procMacro.CrateName+"="+procMacroPath)
 	}
 
 	for _, path := range deps.linkDirs {
-		libFlags = append(libFlags, "-L "+path)
+		libFlags = append(libFlags, "-L "+ruleCmd.PathForInput(path))
 	}
 
 	return libFlags
 }
 
-func rustEnvVars(ctx ModuleContext, deps PathDeps) []string {
+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 {
 	var envVars []string
 
 	// libstd requires a specific environment variable to be set. This is
@@ -203,15 +163,17 @@
 		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 outDirPrefix string
-		if !filepath.IsAbs(moduleGenDir.String()) {
-			// If OUT_DIR is not absolute, we use $$PWD to generate an absolute path (os.Getwd() returns '/')
-			outDirPrefix = "$$PWD/"
-		} else {
+		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.
-			outDirPrefix = ""
+			outDir = moduleGenDir.String()
+		} else if moduleGenDir.Valid() {
+			// 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()))
+		} else {
+			outDir = "$$PWD/"
 		}
-		envVars = append(envVars, "OUT_DIR="+filepath.Join(outDirPrefix, moduleGenDir.String()))
+		envVars = append(envVars, "OUT_DIR="+outDir)
 	} else {
 		// TODO(pcc): Change this to "OUT_DIR=" after fixing crates to not rely on this value.
 		envVars = append(envVars, "OUT_DIR=out")
@@ -242,7 +204,7 @@
 		}
 	}
 
-	envVars = append(envVars, "AR=${cc_config.ClangBin}/llvm-ar")
+	envVars = append(envVars, "AR="+cmd.PathForTool(deps.Llvm_ar))
 
 	if ctx.Darwin() {
 		envVars = append(envVars, "ANDROID_RUST_DARWIN=true")
@@ -251,21 +213,18 @@
 	return envVars
 }
 
-func transformSrctoCrate(ctx ModuleContext, main android.Path, deps PathDeps, flags Flags,
+func transformSrctoCrate(ctx ModuleContext, comp compiler, 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
@@ -286,7 +245,6 @@
 	// 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)
 	}
 
@@ -298,36 +256,16 @@
 
 	// Collect linker flags
 	if !ctx.Darwin() {
-		earlyLinkFlags = "-Wl,--as-needed"
+		earlyLinkFlags = append(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
-	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...)
+	var linkImplicits android.Paths
+	implicits := collectImplicits(deps)
+	toolImplicits := android.Concat(deps.BuildToolDeps)
 	linkImplicits = append(linkImplicits, deps.CrtBegin...)
 	linkImplicits = append(linkImplicits, deps.CrtEnd...)
-
-	linkOrderOnly = append(linkOrderOnly, deps.linkObjects...)
+	implicits = append(implicits, comp.compilationSourcesAndData(ctx)...)
 
 	if len(deps.SrcDeps) > 0 {
 		moduleGenDir := ctx.RustModule().compiler.CargoOutDir()
@@ -342,7 +280,7 @@
 		}
 
 		ctx.Build(pctx, android.BuildParams{
-			Rule:        cp,
+			Rule:        cpDir,
 			Description: "cp " + moduleGenDir.Path().Rel(),
 			Outputs:     outputs,
 			Inputs:      deps.SrcDeps,
@@ -354,81 +292,176 @@
 	}
 
 	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")
-		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, " "),
-			},
-		})
+		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())
+
 		// Declare the clippy build as an implicit dependency of the original crate.
 		implicits = append(implicits, clippyFile)
 	}
 
-	rustcOutputFile := outputFile
+	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)
+
 	usesLinker := crateType == "bin" || crateType == "dylib" || crateType == "cdylib" || crateType == "proc-macro"
 	if usesLinker {
-		rustcOutputFile = android.PathForModuleOut(ctx, outputFile.Base()+".rsp")
+		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"),
+		}
 	}
 
-	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, " "),
-		},
-	})
+	// TODO(b/298461712) remove this hack to let slim manifest branches build
+	if deps.Rustc == nil {
+		deps.Rustc = config.RustPath(ctx, "bin/rustc")
+	}
 
-	if usesLinker {
+	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 {
 		ctx.Build(pctx, android.BuildParams{
-			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(), " "),
-			},
+			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,
 		})
 	}
 
+	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")
-		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, " "),
-			},
-		})
+		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())
 		output.kytheFile = kytheFile
 	}
 	return output
 }
 
-func Rustdoc(ctx ModuleContext, main android.Path, deps PathDeps,
-	flags Flags) android.ModuleOutPath {
+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()
 
 	rustdocFlags := append([]string{}, flags.RustdocFlags...)
 	rustdocFlags = append(rustdocFlags, "--sysroot=/dev/null")
@@ -447,7 +480,7 @@
 	crateName := ctx.RustModule().CrateName()
 	rustdocFlags = append(rustdocFlags, "--crate-name "+crateName)
 
-	rustdocFlags = append(rustdocFlags, makeLibFlags(deps)...)
+	rustdocFlags = append(rustdocFlags, makeLibFlags(deps, rustdocCmd)...)
 	docTimestampFile := android.PathForModuleOut(ctx, "rustdoc.timestamp")
 
 	// Silence warnings about renamed lints for third-party crates
@@ -463,18 +496,26 @@
 	// https://github.com/rust-lang/rust/blob/master/src/librustdoc/html/render/write_shared.rs#L144-L146
 	docDir := android.PathForOutput(ctx, "rustdoc")
 
-	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), " "),
-		},
-	})
+	rustdocCmd.
+		Flags(rustEnvVars(ctx, deps, rustdocCmd)).
+		Tool(deps.Rustdoc).
+		Flags(rustdocFlags).
+		Input(main).
+		Flag("-o "+docDir.String()).
+		FlagWithOutput("&& touch ", docTimestampFile).
+		Implicit(ctx.RustModule().UnstrippedOutputFile())
 
+	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 bd3bfb1..2703a1c 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.AssertStringEquals(t, "libfoo flags", tc.fooFlags, r.Args["clippyFlags"])
+			android.AssertStringDoesContain(t, "libfoo flags", r.RuleParams.Command, tc.fooFlags)
 
 			r = result.ModuleForTests("libbar", "android_arm64_armv8-a_dylib").MaybeRule("clippy")
-			android.AssertStringEquals(t, "libbar flags", "${config.ClippyDefaultLints}", r.Args["clippyFlags"])
+			android.AssertStringDoesContain(t, "libbar flags", r.RuleParams.Command, "${config.ClippyDefaultLints}")
 
 			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: clippyFlags=%q", r.Args["clippyFlags"])
+				t.Errorf("libfoobar is setup to use clippy when explicitly disabled: command=%q", r.RuleParams.Command)
 			}
 		})
 	}
diff --git a/rust/compiler.go b/rust/compiler.go
index d6c52e8..3fa3ccd 100644
--- a/rust/compiler.go
+++ b/rust/compiler.go
@@ -82,6 +82,9 @@
 	//          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
@@ -343,6 +346,23 @@
 	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 ec6829a..e5cc888 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.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"])
+	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)
 	}
 }
 
@@ -57,9 +57,9 @@
 
 	libfooDylib := ctx.ModuleForTests("libfoo", "linux_glibc_x86_64_dylib").Rule("rustc")
 
-	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"])
+	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)
 	}
 }
 
@@ -146,14 +146,14 @@
 
 	fizz := ctx.ModuleForTests("fizz", "android_arm64_armv8-a").Rule("rustc")
 
-	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_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_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_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_PKG_VERSION=1.0.0") {
-		t.Fatalf("expected 'CARGO_PKG_VERSION=1.0.0' 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)
 	}
 }
 
@@ -230,13 +230,13 @@
 			).RunTest(t)
 
 			r := result.ModuleForTests("libfoo", "android_arm64_armv8-a_dylib").MaybeRule("rustc")
-			android.AssertStringDoesContain(t, "libfoo flags", r.Args["rustcFlags"], tc.fooFlags)
+			android.AssertStringDoesContain(t, "libfoo flags", r.RuleParams.Command, tc.fooFlags)
 
 			r = result.ModuleForTests("libbar", "android_arm64_armv8-a_dylib").MaybeRule("rustc")
-			android.AssertStringDoesContain(t, "libbar flags", r.Args["rustcFlags"], "${config.RustDefaultLints}")
+			android.AssertStringDoesContain(t, "libbar flags", r.RuleParams.Command, "${config.RustDefaultLints}")
 
 			r = result.ModuleForTests("libfoobar", "android_arm64_armv8-a_dylib").MaybeRule("rustc")
-			android.AssertStringDoesContain(t, "libfoobar flags", r.Args["rustcFlags"], "${config.RustAllowAllLints}")
+			android.AssertStringDoesContain(t, "libfoobar flags", r.RuleParams.Command, "${config.RustAllowAllLints}")
 		})
 	}
 }
diff --git a/rust/config/global.go b/rust/config/global.go
index bacea03..deaccfd 100644
--- a/rust/config/global.go
+++ b/rust/config/global.go
@@ -126,3 +126,27 @@
 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 5216d60..b312194 100644
--- a/rust/coverage.go
+++ b/rust/coverage.go
@@ -17,6 +17,7 @@
 import (
 	"github.com/google/blueprint"
 
+	"android/soong/android"
 	"android/soong/cc"
 )
 
@@ -70,7 +71,10 @@
 		// 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 = append(deps.RLibs, RustLibrary{Path: profiler_builtins.OutputFile().Path(), CrateName: profiler_builtins.CrateName()})
+			deps.Rlibs = android.AddDirectToDepSet[RustLibrary](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 64077cf..1466e0c 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("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")
+	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")
 
 	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.Args["rustcFlags"], flag) {
-			t.Fatalf(missingErrorStr, flag, "fizz_cov", fizzCov.Args["rustcFlags"])
+		if !strings.Contains(fizzCov.RuleParams.Command, flag) {
+			t.Fatalf(missingErrorStr, flag, "fizz_cov", fizzCov.RuleParams.Command)
 		}
-		if !strings.Contains(libfooCov.Args["rustcFlags"], flag) {
-			t.Fatalf(missingErrorStr, flag, "libfoo_cov dylib", libfooCov.Args["rustcFlags"])
+		if !strings.Contains(libfooCov.RuleParams.Command, flag) {
+			t.Fatalf(missingErrorStr, flag, "libfoo_cov dylib", libfooCov.RuleParams.Command)
 		}
-		if strings.Contains(buzzNoCov.Args["rustcFlags"], flag) {
-			t.Fatalf(containsErrorStr, flag, "buzzNoCov", buzzNoCov.Args["rustcFlags"])
+		if strings.Contains(buzzNoCov.RuleParams.Command, flag) {
+			t.Fatalf(containsErrorStr, flag, "buzzNoCov", buzzNoCov.RuleParams.Command)
 		}
-		if strings.Contains(libbarNoCov.Args["rustcFlags"], flag) {
-			t.Fatalf(containsErrorStr, flag, "libbar_cov", libbarNoCov.Args["rustcFlags"])
+		if strings.Contains(libbarNoCov.RuleParams.Command, flag) {
+			t.Fatalf(containsErrorStr, flag, "libbar_cov", libbarNoCov.RuleParams.Command)
 		}
 	}
 
@@ -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.Args["linkFlags"], flag) {
-			t.Fatalf(missingErrorStr, flag, "fizz_cov", fizzCovLink.Args["linkFlags"])
+		if !strings.Contains(fizzCovLink.RuleParams.Command, flag) {
+			t.Fatalf(missingErrorStr, flag, "fizz_cov", fizzCovLink.RuleParams.Command)
 		}
-		if !strings.Contains(libfooCovLink.Args["linkFlags"], flag) {
-			t.Fatalf(missingErrorStr, flag, "libfoo_cov dylib", libfooCovLink.Args["linkFlags"])
+		if !strings.Contains(libfooCovLink.RuleParams.Command, flag) {
+			t.Fatalf(missingErrorStr, flag, "libfoo_cov dylib", libfooCovLink.RuleParams.Command)
 		}
-		if strings.Contains(buzzNoCovLink.Args["linkFlags"], flag) {
-			t.Fatalf(containsErrorStr, flag, "buzzNoCov", buzzNoCovLink.Args["linkFlags"])
+		if strings.Contains(buzzNoCovLink.RuleParams.Command, flag) {
+			t.Fatalf(containsErrorStr, flag, "buzzNoCov", buzzNoCovLink.RuleParams.Command)
 		}
-		if strings.Contains(libbarNoCovLink.Args["linkFlags"], flag) {
-			t.Fatalf(containsErrorStr, flag, "libbar_cov", libbarNoCovLink.Args["linkFlags"])
+		if strings.Contains(libbarNoCovLink.RuleParams.Command, flag) {
+			t.Fatalf(containsErrorStr, flag, "libbar_cov", libbarNoCovLink.RuleParams.Command)
 		}
 	}
 
@@ -107,8 +107,8 @@
 			srcs: ["foo.rs"],
 		}`)
 
-	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"])
+	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)
 	}
 }
diff --git a/rust/fuzz_test.go b/rust/fuzz_test.go
index ee28c6d..ea35905 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.Args["rustcFlags"], "-C passes='sancov-module'") ||
-		!strings.Contains(fuzz_libtest.Args["rustcFlags"], "--cfg fuzzing") {
+	if !strings.Contains(fuzz_libtest.RuleParams.Command, "-C passes='sancov-module'") ||
+		!strings.Contains(fuzz_libtest.RuleParams.Command, "--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.Args["rustcFlags"], "-C passes='sancov-module'") ||
-		!strings.Contains(host_fuzzer.Args["rustcFlags"], "--cfg fuzzing") {
+	if !strings.Contains(host_fuzzer.RuleParams.Command, "-C passes='sancov-module'") ||
+		!strings.Contains(host_fuzzer.RuleParams.Command, "--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").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).")
+	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)
 	}
 }
 
diff --git a/rust/image_test.go b/rust/image_test.go
index fb4d9c1..813c5bc 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.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_vndk'") {
+		t.Errorf("missing \"--cfg 'android_vndk'\" 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_vendor'") {
+		t.Errorf("missing \"--cfg 'android_vendor'\" 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"])
+	if strings.Contains(vendor.RuleParams.Command, "--cfg 'android_product'") {
+		t.Errorf("unexpected \"--cfg 'android_product'\" for libfoo vendor variant, rustcFlags: %#v", vendor.RuleParams.Command)
 	}
 
 	product := ctx.ModuleForTests("libfoo", "android_product.29_arm64_armv8-a_static").Rule("rustc")
-	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_vndk'") {
+		t.Errorf("missing \"--cfg 'android_vndk'\" 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_vendor'") {
+		t.Errorf("unexpected \"--cfg 'android_vendor'\" 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"])
+	if !strings.Contains(product.RuleParams.Command, "--cfg 'android_product'") {
+		t.Errorf("missing \"--cfg 'android_product'\" for libfoo product variant, rustcFlags: %#v", product.RuleParams.Command)
 	}
 
 	system := ctx.ModuleForTests("libfoo", "android_arm64_armv8-a_static").Rule("rustc")
-	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_vndk'") {
+		t.Errorf("unexpected \"--cfg 'android_vndk'\" 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_vendor'") {
+		t.Errorf("unexpected \"--cfg 'android_vendor'\" for libfoo system variant, rustcFlags: %#v", system.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"])
+	if strings.Contains(system.RuleParams.Command, "--cfg 'android_product'") {
+		t.Errorf("unexpected \"--cfg 'android_product'\" for libfoo system variant, rustcFlags: %#v", product.RuleParams.Command)
 	}
 
 }
diff --git a/rust/library.go b/rust/library.go
index 7432a12..87b25cb 100644
--- a/rust/library.go
+++ b/rust/library.go
@@ -485,6 +485,23 @@
 	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
@@ -525,7 +542,6 @@
 
 	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:
@@ -536,13 +552,13 @@
 
 	// Call the appropriate builder for this library type
 	if library.rlib() {
-		ret.kytheFile = TransformSrctoRlib(ctx, crateRootPath, deps, flags, outputFile).kytheFile
+		ret.kytheFile = TransformSrctoRlib(ctx, library, crateRootPath, deps, flags, outputFile).kytheFile
 	} else if library.dylib() {
-		ret.kytheFile = TransformSrctoDylib(ctx, crateRootPath, deps, flags, outputFile).kytheFile
+		ret.kytheFile = TransformSrctoDylib(ctx, library, crateRootPath, deps, flags, outputFile).kytheFile
 	} else if library.static() {
-		ret.kytheFile = TransformSrctoStatic(ctx, crateRootPath, deps, flags, outputFile).kytheFile
+		ret.kytheFile = TransformSrctoStatic(ctx, library, crateRootPath, deps, flags, outputFile).kytheFile
 	} else if library.shared() {
-		ret.kytheFile = TransformSrctoShared(ctx, crateRootPath, deps, flags, outputFile).kytheFile
+		ret.kytheFile = TransformSrctoShared(ctx, library, crateRootPath, deps, flags, outputFile).kytheFile
 	}
 
 	if library.rlib() || library.dylib() {
diff --git a/rust/library_test.go b/rust/library_test.go
index 30ef333..dab9381 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.Args["rustcFlags"], "crate-type="+rlibCrateType) {
-		t.Errorf("missing crate-type for static variant, expecting %#v, rustcFlags: %#v", rlibCrateType, libfooRlib.Args["rustcFlags"])
+	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)
 	}
 
 	// Test crate type for dylib is correct.
-	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"])
+	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)
 	}
 
 	// Test crate type for C static libraries is correct.
-	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"])
+	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)
 	}
 
 	// Test crate type for C shared libraries is correct.
-	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"])
+	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)
 	}
 
 }
@@ -78,10 +78,10 @@
 			crate_name: "foo",
 		}`)
 
-	libfooDylib := ctx.ModuleForTests("libfoo", "linux_glibc_x86_64_dylib").Rule("rustc")
+	libfooDylib := ctx.ModuleForTests("libfoo", "linux_glibc_x86_64_dylib").Description("rustc")
 
-	if !strings.Contains(libfooDylib.Args["rustcFlags"], "prefer-dynamic") {
-		t.Errorf("missing prefer-dynamic flag for libfoo dylib, rustcFlags: %#v", libfooDylib.Args["rustcFlags"])
+	if !strings.Contains(libfooDylib.RuleParams.Command, "prefer-dynamic") {
+		t.Errorf("missing prefer-dynamic flag for libfoo dylib, rustcFlags: %#v", libfooDylib.RuleParams.Command)
 	}
 }
 
@@ -94,10 +94,10 @@
 			crate_name: "foo",
 		}`)
 
-	libfooDylib := ctx.ModuleForTests("libfoo", "linux_glibc_x86_64_dylib").Rule("rustc")
+	libfooDylib := ctx.ModuleForTests("libfoo", "linux_glibc_x86_64_dylib").Description("rustc")
 
-	if !strings.Contains(libfooDylib.Args["rustcFlags"], "--cfg 'android_dylib'") {
-		t.Errorf("missing android_dylib cfg flag for libfoo dylib, rustcFlags: %#v", libfooDylib.Args["rustcFlags"])
+	if !strings.Contains(libfooDylib.RuleParams.Command, "--cfg 'android_dylib'") {
+		t.Errorf("missing android_dylib cfg flag for libfoo dylib, rustcFlags: %#v", libfooDylib.RuleParams.Command)
 	}
 }
 
@@ -148,10 +148,10 @@
 
 	libfoo := ctx.ModuleForTests("libfoo", "android_arm64_armv8-a_shared")
 
-	libfooOutput := libfoo.Rule("rustLink")
-	if !strings.Contains(libfooOutput.Args["linkFlags"], "-Wl,-soname=libfoo.so") {
+	libfooOutput := libfoo.Rule("rustc")
+	if !strings.Contains(libfooOutput.RuleParams.Command, "-Wl,-soname=libfoo.so") {
 		t.Errorf("missing expected -Wl,-soname linker flag for libfoo shared lib, linkFlags: %#v",
-			libfooOutput.Args["linkFlags"])
+			libfooOutput.RuleParams.Command)
 	}
 
 	if !android.InList("libstd", libfoo.Module().(*Module).Properties.AndroidMkDylibs) {
@@ -237,19 +237,21 @@
 	// 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").Args["libFlags"],
-			"-L out/soong/.intermediates/shared_cc_dep/android_arm64_armv8-a_shared/") {
+		if !strings.Contains(module.Rule("rustc").RuleParams.Command, expectedSharedFlag) {
 			t.Errorf(
-				"missing -L flag for shared_cc_dep, rustcFlags: %#v",
-				rustRlibRlibStd.Rule("rustc").Args["libFlags"],
+				"expected to find shared library linkdir flag %q, rustcFlags: %#v",
+				expectedSharedFlag,
+				rustRlibRlibStd.Rule("rustc").RuleParams.Command,
 			)
 		}
-		if !strings.Contains(module.Rule("rustc").Args["libFlags"],
-			"-L out/soong/.intermediates/static_cc_dep/android_arm64_armv8-a_static/") {
+		if !strings.Contains(module.Rule("rustc").RuleParams.Command, expectedStaticFlag) {
 			t.Errorf(
-				"missing -L flag for static_cc_dep, rustcFlags: %#v",
-				rustRlibRlibStd.Rule("rustc").Args["libFlags"],
+				"expected to find static library linkdir flag %q, rustcFlags: %#v",
+				expectedStaticFlag,
+				rustRlibRlibStd.Rule("rustc").RuleParams.Command,
 			)
 		}
 	}
diff --git a/rust/prebuilt.go b/rust/prebuilt.go
index fe9d0b5..d012680 100644
--- a/rust/prebuilt.go
+++ b/rust/prebuilt.go
@@ -146,7 +146,10 @@
 }
 
 func (prebuilt *prebuiltLibraryDecorator) compile(ctx ModuleContext, flags Flags, deps PathDeps) buildOutput {
-	prebuilt.flagExporter.exportLinkDirs(android.PathsForModuleSrc(ctx, prebuilt.Properties.Link_dirs).Strings()...)
+	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.setProvider(ctx)
 
 	srcPath, paths := srcPathFromModuleSrcs(ctx, prebuilt.prebuiltSrcs())
@@ -203,7 +206,7 @@
 }
 
 func (prebuilt *prebuiltProcMacroDecorator) compile(ctx ModuleContext, flags Flags, deps PathDeps) buildOutput {
-	prebuilt.flagExporter.exportLinkDirs(android.PathsForModuleSrc(ctx, prebuilt.Properties.Link_dirs).Strings()...)
+	prebuilt.flagExporter.exportLinkDirs(android.PathsForModuleSrc(ctx, prebuilt.Properties.Link_dirs)...)
 	prebuilt.flagExporter.setProvider(ctx)
 
 	srcPath, paths := srcPathFromModuleSrcs(ctx, prebuilt.prebuiltSrcs())
diff --git a/rust/proc_macro.go b/rust/proc_macro.go
index 26227d0..c385424 100644
--- a/rust/proc_macro.go
+++ b/rust/proc_macro.go
@@ -79,7 +79,7 @@
 	outputFile := android.PathForModuleOut(ctx, fileName)
 
 	srcPath, _ := srcPathFromModuleSrcs(ctx, procMacro.baseCompiler.Properties.Srcs)
-	ret := TransformSrctoProcMacro(ctx, srcPath, deps, flags, outputFile)
+	ret := TransformSrctoProcMacro(ctx, procMacro, 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 cc81938..a547926 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.Args["rustcFlags"], "--extern proc_macro") {
-		t.Errorf("--extern proc_macro flag not being passed to rustc for proc macro %#v", libprocmacro.Args["rustcFlags"])
+	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)
 	}
 }
diff --git a/rust/rust.go b/rust/rust.go
index 1ee99cd..a3bc510 100644
--- a/rust/rust.go
+++ b/rust/rust.go
@@ -437,12 +437,18 @@
 }
 
 type PathDeps struct {
-	DyLibs          RustLibraries
-	RLibs           RustLibraries
+	Dylibs          *android.DepSet[RustLibrary]
+	Rlibs           *android.DepSet[RustLibrary]
+	ProcMacros      *android.DepSet[RustLibrary]
 	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
@@ -450,7 +456,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    []string
+	linkDirs    android.Paths
 	linkObjects android.Paths
 
 	// Used by bindgen modules which call clang
@@ -465,6 +471,13 @@
 	// 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
@@ -484,6 +497,8 @@
 	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.
@@ -513,7 +528,7 @@
 }
 
 type exportedFlagsProducer interface {
-	exportLinkDirs(...string)
+	exportLinkDirs(...android.Path)
 	exportLinkObjects(...android.Path)
 }
 
@@ -522,13 +537,13 @@
 }
 
 type flagExporter struct {
-	linkDirs    []string
+	linkDirs    android.Paths
 	linkObjects android.Paths
 	libDeps     android.Paths
 }
 
-func (flagExporter *flagExporter) exportLinkDirs(dirs ...string) {
-	flagExporter.linkDirs = android.FirstUniqueStrings(append(flagExporter.linkDirs, dirs...))
+func (flagExporter *flagExporter) exportLinkDirs(dirs ...android.Path) {
+	flagExporter.linkDirs = android.FirstUniquePaths(append(flagExporter.linkDirs, dirs...))
 }
 
 func (flagExporter *flagExporter) exportLinkObjects(flags ...android.Path) {
@@ -555,7 +570,7 @@
 
 type FlagExporterInfo struct {
 	Flags       []string
-	LinkDirs    []string // TODO: this should be android.Paths
+	LinkDirs    android.Paths
 	LinkObjects android.Paths
 	LibDeps     android.Paths
 }
@@ -925,6 +940,14 @@
 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,
@@ -1034,6 +1057,12 @@
 
 		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 {
@@ -1092,6 +1121,7 @@
 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}
@@ -1225,7 +1255,9 @@
 
 	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)
@@ -1238,6 +1270,17 @@
 			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)
@@ -1252,9 +1295,12 @@
 				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)
@@ -1263,10 +1309,18 @@
 				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)
@@ -1302,9 +1356,8 @@
 
 			if depTag == dylibDepTag || depTag == rlibDepTag || depTag == procMacroDepTag {
 				linkFile := rustDep.UnstrippedOutputFile()
-				linkDir := linkPathFromFilePath(linkFile)
 				if lib, ok := mod.compiler.(exportedFlagsProducer); ok {
-					lib.exportLinkDirs(linkDir)
+					lib.exportLinkDirs(linkFile.Dir())
 				}
 			}
 
@@ -1331,7 +1384,7 @@
 				return
 			}
 
-			linkPath := linkPathFromFilePath(linkObject.Path())
+			linkPath := linkObject.Path().Dir()
 
 			exportDep := false
 			switch {
@@ -1385,7 +1438,7 @@
 					}
 					return
 				}
-				linkPath = linkPathFromFilePath(linkObject.Path())
+				linkPath = linkObject.Path().Dir()
 
 				depPaths.linkDirs = append(depPaths.linkDirs, linkPath)
 				depPaths.linkObjects = append(depPaths.linkObjects, linkObject.AsPaths()...)
@@ -1420,6 +1473,25 @@
 			}
 		} 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:
@@ -1435,21 +1507,6 @@
 		}
 	})
 
-	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())
@@ -1473,20 +1530,22 @@
 		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.FirstUniqueStrings(depPaths.linkDirs)
+	depPaths.linkDirs = android.FirstUniquePaths(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
 }
 
@@ -1509,10 +1568,6 @@
 	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()
@@ -1555,6 +1610,15 @@
 			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 835114c..576209d 100644
--- a/rust/rust_test.go
+++ b/rust/rust_test.go
@@ -15,14 +15,17 @@
 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"
 )
 
@@ -64,11 +67,14 @@
 
 // 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) *android.TestContext {
+func testRust(t *testing.T, bp string, preparers ...android.FixturePreparer) *android.TestContext {
 	skipTestIfOsNotSupported(t)
 	result := android.GroupFixturePreparers(
 		prepareForRustTest,
 		rustMockedFiles.AddToFixture(),
+		android.GroupFixturePreparers(
+			preparers...,
+		),
 	).
 		RunTestWithBp(t, bp)
 	return result.TestContext
@@ -202,11 +208,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 := linkPathFromFilePath(barPath)
-	expectedResult := "out/soong/.intermediates/external/libbar/libbar/linux_glibc_x86_64_shared/"
+	libName := barPath.Dir()
+	expectedResult := "out/soong/.intermediates/external/libbar/libbar/linux_glibc_x86_64_shared"
 
-	if libName != expectedResult {
-		t.Errorf("libNameFromFilePath returned the wrong name; expected '%#v', got '%#v'", expectedResult, libName)
+	if libName.String() != expectedResult {
+		t.Errorf("libNameFromFilePath returned the wrong name; expected '%#v', got '%#v'", expectedResult, libName.String())
 	}
 }
 
@@ -256,7 +262,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("rustLink")
+	rustLink := ctx.ModuleForTests("fizz-buzz", "linux_glibc_x86_64").Rule("rustc")
 
 	// 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) {
@@ -275,16 +281,16 @@
 		t.Errorf("Static library dependency not detected (dependency missing from AndroidMkStaticLibs)")
 	}
 
-	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(rustc.RuleParams.Command, "-lstatic=wholestatic") {
+		t.Errorf("-lstatic flag not being passed to rustc for static library %#v", rustc.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 !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 !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") {
+		t.Errorf("shared cc dep not being passed as implicit to rustc %#v", rustLink.OrderOnly.Strings())
 	}
 
 	if !android.SuffixInList(rustLink.Implicits.Strings(), "cc_stubs_dep.so.toc") {
@@ -427,7 +433,7 @@
 	`)
 	rustc := ctx.ModuleForTests("libpm", "linux_glibc_x86_64").Rule("rustc")
 
-	if !strings.Contains(rustc.Args["libFlags"], "libbar/linux_glibc_x86_64") {
+	if !strings.Contains(rustc.RuleParams.Command, "libbar/linux_glibc_x86_64") {
 		t.Errorf("Proc_macro is not using host variant of dependent modules.")
 	}
 }
@@ -480,3 +486,396 @@
 		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 43e95f4..d6a14b2 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("rustLink").Implicits
+	implicits := m.Rule("rustc").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 3fe751e..9951937 100644
--- a/rust/testing.go
+++ b/rust/testing.go
@@ -52,6 +52,22 @@
 
 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",
@@ -63,6 +79,25 @@
 				},
 				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
@@ -99,6 +134,278 @@
 			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",
@@ -113,6 +420,25 @@
 			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 1e7e7d3..621a724 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("rustLink").Args["linkFlags"]
+	libclientLdFlags := ctx.ModuleForTests("libclient", sharedVariant).Rule("rustc").RuleParams.Command
 	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("rustLink").Args["linkFlags"]
+	binWithoutSnapshotLdFlags := ctx.ModuleForTests("bin_without_snapshot", binaryVariant).Rule("rustc").RuleParams.Command
 	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",