diff --git a/android/prebuilt_build_tool.go b/android/prebuilt_build_tool.go
index 17b3230..aeae20f 100644
--- a/android/prebuilt_build_tool.go
+++ b/android/prebuilt_build_tool.go
@@ -17,7 +17,7 @@
 import "path/filepath"
 
 func init() {
-	RegisterModuleType("prebuilt_build_tool", NewPrebuiltBuildTool)
+	RegisterModuleType("prebuilt_build_tool", prebuiltBuildToolFactory)
 }
 
 type prebuiltBuildToolProperties struct {
@@ -101,6 +101,10 @@
 
 // prebuilt_build_tool is to declare prebuilts to be used during the build, particularly for use
 // in genrules with the "tools" property.
+func prebuiltBuildToolFactory() Module {
+	return NewPrebuiltBuildTool()
+}
+
 func NewPrebuiltBuildTool() Module {
 	module := &prebuiltBuildTool{}
 	module.AddProperties(&module.properties)
diff --git a/android/rule_builder.go b/android/rule_builder.go
index 97582db..777c1cf 100644
--- a/android/rule_builder.go
+++ b/android/rule_builder.go
@@ -474,23 +474,13 @@
 		Inputs(depFiles.Paths())
 }
 
-// BuildWithNinjaVars adds the built command line to the build graph, with dependencies on Inputs and Tools, and output files for
-// Outputs. This function will not escape Ninja variables, so it may be used to write sandbox manifests using Ninja variables.
-func (r *RuleBuilder) BuildWithUnescapedNinjaVars(name string, desc string) {
-	r.build(name, desc, false)
-}
-
 // Build adds the built command line to the build graph, with dependencies on Inputs and Tools, and output files for
 // Outputs.
 func (r *RuleBuilder) Build(name string, desc string) {
-	r.build(name, desc, true)
-}
-
-func (r *RuleBuilder) build(name string, desc string, ninjaEscapeCommandString bool) {
 	name = ninjaNameEscape(name)
 
 	if len(r.missingDeps) > 0 {
-		r.ctx.Build(r.pctx, BuildParams{
+		r.ctx.Build(pctx, BuildParams{
 			Rule:        ErrorRule,
 			Outputs:     r.Outputs(),
 			Description: desc,
@@ -629,35 +619,12 @@
 				name, r.sboxManifestPath.String(), r.outDir.String())
 		}
 
-		// Create a rule to write the manifest as textproto.
+		// Create a rule to write the manifest as a the textproto.
 		pbText, err := prototext.Marshal(&manifest)
 		if err != nil {
 			ReportPathErrorf(r.ctx, "sbox manifest failed to marshal: %q", err)
 		}
-		if ninjaEscapeCommandString {
-			WriteFileRule(r.ctx, r.sboxManifestPath, string(pbText))
-		} else {
-			// We need  to have a rule to write files that is
-			// defined on the RuleBuilder's pctx in order to
-			// write Ninja variables in the string.
-			// The WriteFileRule function above rule can only write
-			// raw strings because it is defined on the android
-			// package's pctx, and it can't access variables defined
-			// in another context.
-			r.ctx.Build(r.pctx, BuildParams{
-				Rule: r.ctx.Rule(r.pctx, "unescapedWriteFile", blueprint.RuleParams{
-					Command:        `rm -rf ${out} && cat ${out}.rsp > ${out}`,
-					Rspfile:        "${out}.rsp",
-					RspfileContent: "${content}",
-					Description:    "write file",
-				}, "content"),
-				Output:      r.sboxManifestPath,
-				Description: "write sbox manifest " + r.sboxManifestPath.Base(),
-				Args: map[string]string{
-					"content": string(pbText),
-				},
-			})
-		}
+		WriteFileRule(r.ctx, r.sboxManifestPath, string(pbText))
 
 		// Generate a new string to use as the command line of the sbox rule.  This uses
 		// a RuleBuilderCommand as a convenience method of building the command line, then
@@ -757,7 +724,7 @@
 	}
 
 	r.ctx.Build(r.pctx, BuildParams{
-		Rule: r.ctx.Rule(r.pctx, name, blueprint.RuleParams{
+		Rule: r.ctx.Rule(pctx, name, blueprint.RuleParams{
 			Command:        proptools.NinjaEscape(commandString),
 			CommandDeps:    proptools.NinjaEscapeList(tools.Strings()),
 			Restat:         r.restat,
diff --git a/android/rule_builder_test.go b/android/rule_builder_test.go
index a6b3a27..86647eb 100644
--- a/android/rule_builder_test.go
+++ b/android/rule_builder_test.go
@@ -28,17 +28,6 @@
 	"android/soong/shared"
 )
 
-var (
-	pctx_ruleBuilderTest           = NewPackageContext("android/soong/rule_builder")
-	pctx_ruleBuilderTestSubContext = NewPackageContext("android/soong/rule_builder/config")
-)
-
-func init() {
-	pctx_ruleBuilderTest.Import("android/soong/rule_builder/config")
-	pctx_ruleBuilderTest.StaticVariable("cmdFlags", "${config.ConfigFlags}")
-	pctx_ruleBuilderTestSubContext.StaticVariable("ConfigFlags", "--some-clang-flag")
-}
-
 func builderContext() BuilderContext {
 	return BuilderContextForTesting(TestConfig("out", nil, "", map[string][]byte{
 		"ld":      nil,
@@ -507,13 +496,11 @@
 type testRuleBuilderModule struct {
 	ModuleBase
 	properties struct {
-		Srcs  []string
-		Flags []string
+		Srcs []string
 
-		Restat              bool
-		Sbox                bool
-		Sbox_inputs         bool
-		Unescape_ninja_vars bool
+		Restat      bool
+		Sbox        bool
+		Sbox_inputs bool
 	}
 }
 
@@ -531,9 +518,8 @@
 	rspFileContents2 := PathsForSource(ctx, []string{"rsp_in2"})
 	manifestPath := PathForModuleOut(ctx, "sbox.textproto")
 
-	testRuleBuilder_Build(ctx, in, implicit, orderOnly, validation, t.properties.Flags,
-		out, outDep, outDir,
-		manifestPath, t.properties.Restat, t.properties.Sbox, t.properties.Sbox_inputs, t.properties.Unescape_ninja_vars,
+	testRuleBuilder_Build(ctx, in, implicit, orderOnly, validation, out, outDep, outDir,
+		manifestPath, t.properties.Restat, t.properties.Sbox, t.properties.Sbox_inputs,
 		rspFile, rspFileContents, rspFile2, rspFileContents2)
 }
 
@@ -557,18 +543,17 @@
 	rspFileContents2 := PathsForSource(ctx, []string{"rsp_in2"})
 	manifestPath := PathForOutput(ctx, "singleton/sbox.textproto")
 
-	testRuleBuilder_Build(ctx, in, implicit, orderOnly, validation, nil, out, outDep, outDir,
-		manifestPath, true, false, false, false,
+	testRuleBuilder_Build(ctx, in, implicit, orderOnly, validation, out, outDep, outDir,
+		manifestPath, true, false, false,
 		rspFile, rspFileContents, rspFile2, rspFileContents2)
 }
 
 func testRuleBuilder_Build(ctx BuilderContext, in Paths, implicit, orderOnly, validation Path,
-	flags []string,
 	out, outDep, outDir, manifestPath WritablePath,
-	restat, sbox, sboxInputs, unescapeNinjaVars bool,
+	restat, sbox, sboxInputs bool,
 	rspFile WritablePath, rspFileContents Paths, rspFile2 WritablePath, rspFileContents2 Paths) {
 
-	rule := NewRuleBuilder(pctx_ruleBuilderTest, ctx)
+	rule := NewRuleBuilder(pctx, ctx)
 
 	if sbox {
 		rule.Sbox(outDir, manifestPath)
@@ -579,7 +564,6 @@
 
 	rule.Command().
 		Tool(PathForSource(ctx, "cp")).
-		Flags(flags).
 		Inputs(in).
 		Implicit(implicit).
 		OrderOnly(orderOnly).
@@ -593,11 +577,7 @@
 		rule.Restat()
 	}
 
-	if unescapeNinjaVars {
-		rule.BuildWithUnescapedNinjaVars("rule", "desc")
-	} else {
-		rule.Build("rule", "desc")
-	}
+	rule.Build("rule", "desc")
 }
 
 var prepareForRuleBuilderTest = FixtureRegisterWithContext(func(ctx RegistrationContext) {
@@ -812,47 +792,3 @@
 		})
 	}
 }
-
-func TestRuleBuilderWithNinjaVarEscaping(t *testing.T) {
-	bp := `
-		rule_builder_test {
-			name: "foo_sbox_escaped_ninja",
-			flags: ["${cmdFlags}"],
-			sbox: true,
-			sbox_inputs: true,
-		}
-		rule_builder_test {
-			name: "foo_sbox",
-			flags: ["${cmdFlags}"],
-			sbox: true,
-			sbox_inputs: true,
-			unescape_ninja_vars: true,
-		}
-	`
-	result := GroupFixturePreparers(
-		prepareForRuleBuilderTest,
-		FixtureWithRootAndroidBp(bp),
-	).RunTest(t)
-
-	escapedNinjaMod := result.ModuleForTests("foo_sbox_escaped_ninja", "").Rule("writeFile")
-	AssertStringDoesContain(
-		t,
-		"",
-		escapedNinjaMod.BuildParams.Args["content"],
-		"$${cmdFlags}",
-	)
-
-	unescapedNinjaMod := result.ModuleForTests("foo_sbox", "").Rule("unescapedWriteFile")
-	AssertStringDoesContain(
-		t,
-		"",
-		unescapedNinjaMod.BuildParams.Args["content"],
-		"${cmdFlags}",
-	)
-	AssertStringDoesNotContain(
-		t,
-		"",
-		unescapedNinjaMod.BuildParams.Args["content"],
-		"$${cmdFlags}",
-	)
-}
diff --git a/cc/testing.go b/cc/testing.go
index dbdee9e..d1632aa 100644
--- a/cc/testing.go
+++ b/cc/testing.go
@@ -35,7 +35,6 @@
 
 	multitree.RegisterApiImportsModule(ctx)
 
-	ctx.RegisterModuleType("prebuilt_build_tool", android.NewPrebuiltBuildTool)
 	ctx.RegisterModuleType("cc_benchmark", BenchmarkFactory)
 	ctx.RegisterModuleType("cc_object", ObjectFactory)
 	ctx.RegisterModuleType("cc_genrule", GenRuleFactory)
diff --git a/cmd/sbox/sbox.go b/cmd/sbox/sbox.go
index 3364f50..fc56dd5 100644
--- a/cmd/sbox/sbox.go
+++ b/cmd/sbox/sbox.go
@@ -119,9 +119,6 @@
 	}
 
 	manifest, err := readManifest(manifestFile)
-	if err != nil {
-		return err
-	}
 
 	if len(manifest.Commands) == 0 {
 		return fmt.Errorf("at least one commands entry is required in %q", manifestFile)
diff --git a/rust/binary.go b/rust/binary.go
index 2c9f64d..1e24beb 100644
--- a/rust/binary.go
+++ b/rust/binary.go
@@ -137,14 +137,9 @@
 
 func (binary *binaryDecorator) compile(ctx ModuleContext, flags Flags, deps PathDeps) buildOutput {
 	fileName := binary.getStem(ctx) + ctx.toolchain().ExecutableSuffix()
+	srcPath, _ := srcPathFromModuleSrcs(ctx, binary.baseCompiler.Properties.Srcs)
 	outputFile := android.PathForModuleOut(ctx, fileName)
 	ret := buildOutput{outputFile: outputFile}
-	var crateRootPath android.Path
-	if binary.baseCompiler.Properties.Crate_root == nil {
-		crateRootPath, _ = srcPathFromModuleSrcs(ctx, binary.baseCompiler.Properties.Srcs)
-	} else {
-		crateRootPath = android.PathForModuleSrc(ctx, *binary.baseCompiler.Properties.Crate_root)
-	}
 
 	flags.RustFlags = append(flags.RustFlags, deps.depFlags...)
 	flags.LinkFlags = append(flags.LinkFlags, deps.depLinkFlags...)
@@ -159,7 +154,7 @@
 	}
 	binary.baseCompiler.unstrippedOutputFile = outputFile
 
-	ret.kytheFile = TransformSrcToBinary(ctx, crateRootPath, deps, flags, outputFile).kytheFile
+	ret.kytheFile = TransformSrcToBinary(ctx, srcPath, deps, flags, outputFile).kytheFile
 	return ret
 }
 
diff --git a/rust/compiler.go b/rust/compiler.go
index d6c52e8..e6a7a93 100644
--- a/rust/compiler.go
+++ b/rust/compiler.go
@@ -73,15 +73,6 @@
 	// If no source file is defined, a single generated source module can be defined to be used as the main source.
 	Srcs []string `android:"path,arch_variant"`
 
-	// Entry point that is passed to rustc to begin the compilation. E.g. main.rs or lib.rs.
-	// When this property is set,
-	//    * sandboxing is enabled for this module, and
-	//    * the srcs attribute is interpreted as a list of all source files potentially
-	//          used in compilation, including the entrypoint, and
-	//    * compile_data can be used to add additional files used in compilation that
-	//          not directly used as source files.
-	Crate_root *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
@@ -520,8 +511,6 @@
 		ctx.PropertyErrorf("srcs", "only a single generated source module can be defined without a main source file.")
 	}
 
-	// TODO: b/297264540 - once all modules are sandboxed, we need to select the proper
-	// entry point file from Srcs rather than taking the first one
 	paths := android.PathsForModuleSrc(ctx, srcs)
 	return paths[srcIndex], paths[1:]
 }
diff --git a/rust/library.go b/rust/library.go
index 7432a12..3f031c1 100644
--- a/rust/library.go
+++ b/rust/library.go
@@ -489,7 +489,7 @@
 	var outputFile android.ModuleOutPath
 	var ret buildOutput
 	var fileName string
-	crateRootPath := library.crateRootPath(ctx, deps)
+	srcPath := library.srcPath(ctx, deps)
 
 	if library.sourceProvider != nil {
 		deps.srcProviderFiles = append(deps.srcProviderFiles, library.sourceProvider.Srcs()...)
@@ -536,13 +536,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, srcPath, deps, flags, outputFile).kytheFile
 	} else if library.dylib() {
-		ret.kytheFile = TransformSrctoDylib(ctx, crateRootPath, deps, flags, outputFile).kytheFile
+		ret.kytheFile = TransformSrctoDylib(ctx, srcPath, deps, flags, outputFile).kytheFile
 	} else if library.static() {
-		ret.kytheFile = TransformSrctoStatic(ctx, crateRootPath, deps, flags, outputFile).kytheFile
+		ret.kytheFile = TransformSrctoStatic(ctx, srcPath, deps, flags, outputFile).kytheFile
 	} else if library.shared() {
-		ret.kytheFile = TransformSrctoShared(ctx, crateRootPath, deps, flags, outputFile).kytheFile
+		ret.kytheFile = TransformSrctoShared(ctx, srcPath, deps, flags, outputFile).kytheFile
 	}
 
 	if library.rlib() || library.dylib() {
@@ -585,15 +585,13 @@
 	return ret
 }
 
-func (library *libraryDecorator) crateRootPath(ctx ModuleContext, _ PathDeps) android.Path {
+func (library *libraryDecorator) srcPath(ctx ModuleContext, _ PathDeps) android.Path {
 	if library.sourceProvider != nil {
 		// Assume the first source from the source provider is the library entry point.
 		return library.sourceProvider.Srcs()[0]
-	} else if library.baseCompiler.Properties.Crate_root == nil {
+	} else {
 		path, _ := srcPathFromModuleSrcs(ctx, library.baseCompiler.Properties.Srcs)
 		return path
-	} else {
-		return android.PathForModuleSrc(ctx, *library.baseCompiler.Properties.Crate_root)
 	}
 }
 
@@ -608,7 +606,7 @@
 		return android.OptionalPath{}
 	}
 
-	return android.OptionalPathForPath(Rustdoc(ctx, library.crateRootPath(ctx, deps),
+	return android.OptionalPathForPath(Rustdoc(ctx, library.srcPath(ctx, deps),
 		deps, flags))
 }
 
diff --git a/rust/toolchain_library.go b/rust/toolchain_library.go
index e118f92..326d529 100644
--- a/rust/toolchain_library.go
+++ b/rust/toolchain_library.go
@@ -21,8 +21,6 @@
 
 	"android/soong/android"
 	"android/soong/rust/config"
-
-	"github.com/google/blueprint/proptools"
 )
 
 // This module is used to compile the rust toolchain libraries
@@ -35,15 +33,11 @@
 		rustToolchainLibraryRlibFactory)
 	android.RegisterModuleType("rust_toolchain_library_dylib",
 		rustToolchainLibraryDylibFactory)
-	android.RegisterModuleType("rust_toolchain_rustc_prebuilt",
-		rustToolchainRustcPrebuiltFactory)
 }
 
 type toolchainLibraryProperties struct {
-	// path to the toolchain crate root, relative to the top of the toolchain source
-	Toolchain_crate_root *string `android:"arch_variant"`
-	// path to the rest of the toolchain srcs, relative to the top of the toolchain source
-	Toolchain_srcs []string `android:"arch_variant"`
+	// path to the toolchain source, relative to the top of the toolchain source
+	Toolchain_src *string `android:"arch_variant"`
 }
 
 type toolchainLibraryDecorator struct {
@@ -89,20 +83,15 @@
 func rustSetToolchainSource(ctx android.LoadHookContext) {
 	if toolchainLib, ok := ctx.Module().(*Module).compiler.(*toolchainLibraryDecorator); ok {
 		prefix := "linux-x86/" + GetRustPrebuiltVersion(ctx)
-		versionedCrateRoot := path.Join(prefix, android.String(toolchainLib.Properties.Toolchain_crate_root))
-		versionedSrcs := make([]string, len(toolchainLib.Properties.Toolchain_srcs))
-		for i, src := range toolchainLib.Properties.Toolchain_srcs {
-			versionedSrcs[i] = path.Join(prefix, src)
-		}
+		newSrcs := []string{path.Join(prefix, android.String(toolchainLib.Properties.Toolchain_src))}
 
 		type props struct {
-			Crate_root *string
-			Srcs       []string
+			Srcs []string
 		}
 		p := &props{}
-		p.Crate_root = &versionedCrateRoot
-		p.Srcs = versionedSrcs
+		p.Srcs = newSrcs
 		ctx.AppendProperties(p)
+
 	} else {
 		ctx.ModuleErrorf("Called rustSetToolchainSource on a non-Rust Module.")
 	}
@@ -112,47 +101,3 @@
 func GetRustPrebuiltVersion(ctx android.LoadHookContext) string {
 	return ctx.AConfig().GetenvWithDefault("RUST_PREBUILTS_VERSION", config.RustDefaultVersion)
 }
-
-type toolchainRustcPrebuiltProperties struct {
-	// path to rustc prebuilt, relative to the top of the toolchain source
-	Toolchain_prebuilt_src *string
-	// path to deps, relative to the top of the toolchain source
-	Toolchain_deps []string
-	// path to deps, relative to module directory
-	Deps []string
-}
-
-func rustToolchainRustcPrebuiltFactory() android.Module {
-	module := android.NewPrebuiltBuildTool()
-	module.AddProperties(&toolchainRustcPrebuiltProperties{})
-	android.AddLoadHook(module, func(ctx android.LoadHookContext) {
-		var toolchainProps *toolchainRustcPrebuiltProperties
-		for _, p := range ctx.Module().GetProperties() {
-			toolchainProperties, ok := p.(*toolchainRustcPrebuiltProperties)
-			if ok {
-				toolchainProps = toolchainProperties
-			}
-		}
-
-		if toolchainProps.Toolchain_prebuilt_src == nil {
-			ctx.PropertyErrorf("toolchain_prebuilt_src", "must set path to rustc prebuilt")
-		}
-
-		prefix := "linux-x86/" + GetRustPrebuiltVersion(ctx)
-		deps := make([]string, 0, len(toolchainProps.Toolchain_deps)+len(toolchainProps.Deps))
-		for _, d := range toolchainProps.Toolchain_deps {
-			deps = append(deps, path.Join(prefix, d))
-		}
-		deps = append(deps, toolchainProps.Deps...)
-
-		props := struct {
-			Src  *string
-			Deps []string
-		}{
-			Src:  proptools.StringPtr(path.Join(prefix, *toolchainProps.Toolchain_prebuilt_src)),
-			Deps: deps,
-		}
-		ctx.AppendProperties(&props)
-	})
-	return module
-}