diff --git a/build/gen.py b/build/gen.py
index 00752ee..3c7c858 100755
--- a/build/gen.py
+++ b/build/gen.py
@@ -516,6 +516,7 @@
         'tools/gn/qt_creator_writer.cc',
         'tools/gn/runtime_deps.cc',
         'tools/gn/rust_substitution_type.cc',
+        'tools/gn/rust_tool.cc',
         'tools/gn/rust_values.cc',
         'tools/gn/rust_variables.cc',
         'tools/gn/scheduler.cc',
diff --git a/tools/gn/function_toolchain.cc b/tools/gn/function_toolchain.cc
index 3d2a100..e5ee5bc 100644
--- a/tools/gn/function_toolchain.cc
+++ b/tools/gn/function_toolchain.cc
@@ -299,6 +299,9 @@
       "copy_bundle_data": [iOS, macOS] Tool to copy files in a bundle.
       "compile_xcassets": [iOS, macOS] Tool to compile asset catalogs.
 
+    Rust tools:
+      "rustc": Rust compiler and linker
+
 Tool variables
 
     command  [string with substitutions]
@@ -359,6 +362,20 @@
 
         Example: description = "Compiling {{source}}"
 
+    exe_output_extension [string, optional, rust tools only]
+    rlib_output_extension [string, optional, rust tools only]
+    dylib_output_extension [string, optional, rust tools only]
+    cdylib_output_extension [string, optional, rust tools only]
+    proc_macro_output_extension [string, optional, rust tools only]
+        Valid for: Rust tools
+
+        These specify the default tool output for each of the crate types.
+        The default is empty for executables, shared, and static libraries and
+        ".rlib" for rlibs. Note that the Rust compiler complains with an error
+        if external crates do not take the form `lib<name>.rlib` or
+        `lib<name>.<shared_extension>`, where `<shared_extension>` is `.so`,
+        `.dylib`, or `.dll` as appropriate for the platform.
+
     lib_switch  [string, optional, link tools only]
     lib_dir_switch  [string, optional, link tools only]
         Valid for: Linker tools except "alink"
@@ -500,7 +517,8 @@
         added to runtime deps (see "gn help runtime_deps"). By default (if
         runtime_outputs is empty or unspecified), it will be the link_output.
 
-Expansions for tool variables
+)"  // String break to prevent overflowing the 16K max VC string length.
+    R"(Expansions for tool variables
 
   All paths are relative to the root build directory, which is the current
   directory for running all tools. These expansions are available to all tools:
@@ -536,8 +554,7 @@
         Example: "libfoo" for the target named "foo" and an output prefix for
         the linker tool of "lib".
 
-)"  // String break to prevent overflowing the 16K max VC string length.
-    R"(  Compiler tools have the notion of a single input and a single output, along
+  Compiler tools have the notion of a single input and a single output, along
   with a set of compiler-specific flags. The following expansions are
   available:
 
@@ -673,6 +690,39 @@
         assets catalog compiler. Usually based on the target_name of
         the create_bundle target.
 
+  Rust tools have the notion of a single input and a single output, along
+  with a set of compiler-specific flags. The following expansions are
+  available:
+
+    {{crate_name}}
+        Expands to the string representing the crate name of target under
+        compilation.
+
+    {{crate_type}}
+        Expands to the string representing the type of crate for the target
+        under compilation.
+
+    {{externs}}
+        Expands to the list of --extern flags needed to include addition Rust
+        libraries in this target. Includes any specified renamed dependencies.
+
+    {{rustc_output_extension}}
+        Expands to the output extension for this target's crate type.
+
+    {{rustc_output_prefix}}
+        Expands to the prefix for shared and static libraries. This should
+        generally be "lib". Empty for executable targets.
+
+    {{rustdeps}}
+        Expands to the list of -Ldependency=<path> strings needed to compile
+        this target.
+
+    {{rustenv}}
+        Expands to the list of environment variables.
+
+    {{rustflags}}
+        Expands to the list of strings representing Rust compiler flags.
+
 Separate linking and dependencies for shared libraries
 
   Shared libraries are special in that not all changes to them require that
diff --git a/tools/gn/function_toolchain_unittest.cc b/tools/gn/function_toolchain_unittest.cc
index e3aa598..ef301e7 100644
--- a/tools/gn/function_toolchain_unittest.cc
+++ b/tools/gn/function_toolchain_unittest.cc
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "tools/gn/functions.h"
+#include "tools/gn/rust_tool.h"
 #include "tools/gn/scheduler.h"
 #include "tools/gn/test_with_scheduler.h"
 #include "tools/gn/test_with_scope.h"
@@ -58,3 +59,35 @@
     ASSERT_TRUE(err.has_error()) << err.message();
   }
 }
+
+TEST_F(FunctionToolchain, Rust) {
+  TestWithScope setup;
+
+  // These runtime outputs are a subset of the outputs so are OK.
+  {
+    TestParseInput input(
+        R"(toolchain("rust") {
+          tool("rustc") {
+            command = "{{rustenv}} rustc --crate-name {{crate_name}} --crate-type bin {{rustflags}} -o {{output}} {{externs}} {{source}}"
+            description = "RUST {{output}}"
+          }
+        })");
+    ASSERT_FALSE(input.has_error());
+
+    Err err;
+    input.parsed()->Execute(setup.scope(), &err);
+    ASSERT_FALSE(err.has_error()) << err.message();
+
+    // It should have generated a toolchain.
+    ASSERT_EQ(1u, setup.items().size());
+    const Toolchain* toolchain = setup.items()[0]->AsToolchain();
+    ASSERT_TRUE(toolchain);
+
+    const Tool* rust = toolchain->GetTool(RustTool::kRsToolRustc);
+    ASSERT_TRUE(rust);
+    ASSERT_EQ(rust->command().AsString(),
+              "{{rustenv}} rustc --crate-name {{crate_name}} --crate-type bin "
+              "{{rustflags}} -o {{output}} {{externs}} {{source}}");
+    ASSERT_EQ(rust->description().AsString(), "RUST {{output}}");
+  }
+}
\ No newline at end of file
diff --git a/tools/gn/rust_tool.cc b/tools/gn/rust_tool.cc
new file mode 100644
index 0000000..e4e127d
--- /dev/null
+++ b/tools/gn/rust_tool.cc
@@ -0,0 +1,156 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "tools/gn/rust_tool.h"
+
+#include "tools/gn/rust_substitution_type.h"
+#include "tools/gn/target.h"
+
+const char* RustTool::kRsToolRustc = "rustc";
+
+RustTool::RustTool(const char* n) : Tool(n), rlib_output_extension_(".rlib") {
+  CHECK(ValidateName(n));
+}
+
+RustTool::~RustTool() = default;
+
+RustTool* RustTool::AsRust() {
+  return this;
+}
+const RustTool* RustTool::AsRust() const {
+  return this;
+}
+
+bool RustTool::ValidateName(const char* name) const {
+  return name_ == kRsToolRustc;
+}
+
+void RustTool::SetComplete() {
+  SetToolComplete();
+}
+
+bool RustTool::SetOutputExtension(const Value* value,
+                                  std::string* var,
+                                  Err* err) {
+  DCHECK(!complete_);
+  if (!value)
+    return true;  // Not present is fine.
+  if (!value->VerifyTypeIs(Value::STRING, err))
+    return false;
+  if (value->string_value().empty())
+    return true;
+
+  *var = std::move(value->string_value());
+  return true;
+}
+
+bool RustTool::ReadOutputExtensions(Scope* scope, Err* err) {
+  if (!SetOutputExtension(scope->GetValue("exe_output_extension", true),
+                          &exe_output_extension_, err))
+    return false;
+  if (!SetOutputExtension(scope->GetValue("rlib_output_extension", true),
+                          &rlib_output_extension_, err))
+    return false;
+  if (!SetOutputExtension(scope->GetValue("dylib_output_extension", true),
+                          &dylib_output_extension_, err))
+    return false;
+  if (!SetOutputExtension(scope->GetValue("cdylib_output_extension", true),
+                          &cdylib_output_extension_, err))
+    return false;
+  if (!SetOutputExtension(scope->GetValue("staticlib_output_extension", true),
+                          &staticlib_output_extension_, err))
+    return false;
+  if (!SetOutputExtension(scope->GetValue("proc_macro_output_extension", true),
+                          &proc_macro_output_extension_, err))
+    return false;
+  return true;
+}
+
+bool RustTool::ReadOutputsPatternList(Scope* scope,
+                                      const char* var,
+                                      SubstitutionList* field,
+                                      Err* err) {
+  DCHECK(!complete_);
+  const Value* value = scope->GetValue(var, true);
+  if (!value)
+    return true;  // Not present is fine.
+  if (!value->VerifyTypeIs(Value::LIST, err))
+    return false;
+
+  SubstitutionList list;
+  if (!list.Parse(*value, err))
+    return false;
+
+  // Validate the right kinds of patterns are used.
+  if (list.list().empty()) {
+    *err = Err(defined_from(), "\"outputs\" must be specified for this tool.");
+    return false;
+  }
+
+  for (const auto& cur_type : list.required_types()) {
+    if (!IsValidRustSubstitution(cur_type)) {
+      *err = Err(*value, "Pattern not valid here.",
+                 "You used the pattern " + std::string(cur_type->name) +
+                     " which is not valid\nfor this variable.");
+      return false;
+    }
+  }
+
+  *field = std::move(list);
+  return true;
+}
+
+bool RustTool::InitTool(Scope* scope, Toolchain* toolchain, Err* err) {
+  // Initialize default vars.
+  if (!Tool::InitTool(scope, toolchain, err)) {
+    return false;
+  }
+
+  if (!ReadOutputExtensions(scope, err)) {
+    return false;
+  }
+
+  // All Rust tools should have outputs.
+  if (!ReadOutputsPatternList(scope, "outputs", &outputs_, err)) {
+    return false;
+  }
+
+  return true;
+}
+
+bool RustTool::ValidateSubstitution(const Substitution* sub_type) const {
+  if (name_ == kRsToolRustc)
+    return IsValidRustSubstitution(sub_type);
+  NOTREACHED();
+  return false;
+}
+
+const std::string& RustTool::rustc_output_extension(
+    Target::OutputType type,
+    const RustValues::CrateType crate_type) const {
+  switch (crate_type) {
+    case RustValues::CRATE_AUTO: {
+      switch (type) {
+        case Target::EXECUTABLE:
+          return exe_output_extension_;
+        case Target::STATIC_LIBRARY:
+          return staticlib_output_extension_;
+        case Target::RUST_LIBRARY:
+          return rlib_output_extension_;
+        default:
+          NOTREACHED();
+          return exe_output_extension_;
+      }
+    }
+    case RustValues::CRATE_DYLIB:
+      return dylib_output_extension_;
+    case RustValues::CRATE_CDYLIB:
+      return cdylib_output_extension_;
+    case RustValues::CRATE_PROC_MACRO:
+      return proc_macro_output_extension_;
+    default:
+      NOTREACHED();
+      return exe_output_extension_;
+  }
+}
diff --git a/tools/gn/rust_tool.h b/tools/gn/rust_tool.h
new file mode 100644
index 0000000..682f74a
--- /dev/null
+++ b/tools/gn/rust_tool.h
@@ -0,0 +1,98 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef TOOLS_GN_RUST_TOOL_H_
+#define TOOLS_GN_RUST_TOOL_H_
+
+#include <string>
+
+#include "base/logging.h"
+#include "base/macros.h"
+#include "tools/gn/label.h"
+#include "tools/gn/label_ptr.h"
+#include "tools/gn/rust_values.h"
+#include "tools/gn/source_file.h"
+#include "tools/gn/substitution_list.h"
+#include "tools/gn/substitution_pattern.h"
+#include "tools/gn/target.h"
+#include "tools/gn/tool.h"
+
+class RustTool : public Tool {
+ public:
+  // Rust tools
+  static const char* kRsToolRustc;
+
+  explicit RustTool(const char* n);
+  ~RustTool();
+
+  // Manual RTTI and required functions ---------------------------------------
+
+  bool InitTool(Scope* block_scope, Toolchain* toolchain, Err* err);
+  bool ValidateName(const char* name) const override;
+  void SetComplete() override;
+  bool ValidateSubstitution(const Substitution* sub_type) const override;
+
+  RustTool* AsRust() override;
+  const RustTool* AsRust() const override;
+
+  void set_exe_output_extension(std::string ext) {
+    DCHECK(!complete_);
+    DCHECK(ext.empty() || ext[0] == '.');
+    exe_output_extension_ = std::move(ext);
+  }
+
+  void set_rlib_output_extension(std::string ext) {
+    DCHECK(!complete_);
+    DCHECK(ext.empty() || ext[0] == '.');
+    rlib_output_extension_ = std::move(ext);
+  }
+
+  void set_dylib_output_extension(std::string ext) {
+    DCHECK(!complete_);
+    DCHECK(ext.empty() || ext[0] == '.');
+    dylib_output_extension_ = std::move(ext);
+  }
+
+  void set_cdylib_output_extension(std::string ext) {
+    DCHECK(!complete_);
+    DCHECK(ext.empty() || ext[0] == '.');
+    cdylib_output_extension_ = std::move(ext);
+  }
+
+  void set_staticlib_output_extension(std::string ext) {
+    DCHECK(!complete_);
+    DCHECK(ext.empty() || ext[0] == '.');
+    staticlib_output_extension_ = std::move(ext);
+  }
+
+  void set_proc_macro_output_extension(std::string ext) {
+    DCHECK(!complete_);
+    DCHECK(ext.empty() || ext[0] == '.');
+    proc_macro_output_extension_ = std::move(ext);
+  }
+
+  // Will include a leading "." if nonempty.
+  const std::string& rustc_output_extension(
+      Target::OutputType type,
+      const RustValues::CrateType crate_type) const;
+
+ private:
+  bool SetOutputExtension(const Value* value, std::string* var, Err* err);
+  bool ReadOutputExtensions(Scope* scope, Err* err);
+  bool ReadOutputsPatternList(Scope* scope,
+                              const char* var,
+                              SubstitutionList* field,
+                              Err* err);
+
+  std::string exe_output_extension_;
+  std::string rlib_output_extension_;
+  std::string dylib_output_extension_;
+  std::string cdylib_output_extension_;
+  std::string staticlib_output_extension_;
+  std::string proc_macro_output_extension_;
+
+  DISALLOW_COPY_AND_ASSIGN(RustTool);
+};
+
+#endif  // TOOLS_GN_RUST_TOOL_H_
diff --git a/tools/gn/test_with_scope.cc b/tools/gn/test_with_scope.cc
index 9dfb6c4..4ebbbfa 100644
--- a/tools/gn/test_with_scope.cc
+++ b/tools/gn/test_with_scope.cc
@@ -194,6 +194,24 @@
   SetCommandForTool("touch {{output}}", compile_xcassets_tool.get());
   toolchain->SetTool(std::move(compile_xcassets_tool));
 
+  // RUST
+  std::unique_ptr<Tool> rustc_tool = Tool::CreateTool(RustTool::kRsToolRustc);
+  SetCommandForTool(
+      "{{rustenv}} rustc --edition=2018 --crate-name {{crate_name}} {{source}} "
+      "--crate-type {{crate_type}} {{rustflags}} -o "
+      "{{target_out_dir}}/"
+      "{{rustc_output_prefix}}{{crate_name}}{{rustc_output_extension}} "
+      "{{rustdeps}} {{externs}}",
+      rustc_tool.get());
+  rustc_tool->AsRust()->set_dylib_output_extension(".so");
+  rustc_tool->AsRust()->set_cdylib_output_extension(".so");
+  rustc_tool->AsRust()->set_staticlib_output_extension(".a");
+  rustc_tool->AsRust()->set_proc_macro_output_extension(".so");
+  rustc_tool->AsRust()->set_outputs(SubstitutionList::MakeForTest(
+      "{{target_out_dir}}/"
+      "{{rustc_output_prefix}}{{crate_name}}{{rustc_output_extension}}"));
+  toolchain->SetTool(std::move(rustc_tool));
+
   toolchain->ToolchainSetupComplete();
 }
 
diff --git a/tools/gn/test_with_scope.h b/tools/gn/test_with_scope.h
index 7950259..897ef1b 100644
--- a/tools/gn/test_with_scope.h
+++ b/tools/gn/test_with_scope.h
@@ -15,6 +15,7 @@
 #include "tools/gn/general_tool.h"
 #include "tools/gn/input_file.h"
 #include "tools/gn/parse_tree.h"
+#include "tools/gn/rust_tool.h"
 #include "tools/gn/scope.h"
 #include "tools/gn/scope_per_file_provider.h"
 #include "tools/gn/settings.h"
diff --git a/tools/gn/tool.cc b/tools/gn/tool.cc
index b040ac2..72bce14 100644
--- a/tools/gn/tool.cc
+++ b/tools/gn/tool.cc
@@ -3,8 +3,10 @@
 // found in the LICENSE file.
 
 #include "tools/gn/tool.h"
+
 #include "tools/gn/c_tool.h"
 #include "tools/gn/general_tool.h"
+#include "tools/gn/rust_tool.h"
 #include "tools/gn/target.h"
 
 const char* Tool::kToolNone = "";
@@ -42,6 +44,13 @@
   return nullptr;
 }
 
+RustTool* Tool::AsRust() {
+  return nullptr;
+}
+const RustTool* Tool::AsRust() const {
+  return nullptr;
+}
+
 bool Tool::IsPatternInOutputList(const SubstitutionList& output_list,
                                  const SubstitutionPattern& pattern) const {
   for (const auto& cur : output_list.list()) {
@@ -216,6 +225,11 @@
       return tool;
     return nullptr;
   }
+  if (RustTool* rust_tool = tool->AsRust()) {
+    if (rust_tool->InitTool(scope, toolchain, err))
+      return tool;
+    return nullptr;
+  }
   NOTREACHED();
   *err = Err(function, "Unknown tool type.");
   return nullptr;
@@ -223,6 +237,7 @@
 
 // static
 std::unique_ptr<Tool> Tool::CreateTool(const std::string& name) {
+  // C tools
   if (name == CTool::kCToolCc)
     return std::make_unique<CTool>(CTool::kCToolCc);
   else if (name == CTool::kCToolCxx)
@@ -244,6 +259,7 @@
   else if (name == CTool::kCToolLink)
     return std::make_unique<CTool>(CTool::kCToolLink);
 
+  // General tools
   else if (name == GeneralTool::kGeneralToolAction)
     return std::make_unique<GeneralTool>(GeneralTool::kGeneralToolAction);
   else if (name == GeneralTool::kGeneralToolStamp)
@@ -257,6 +273,10 @@
     return std::make_unique<GeneralTool>(
         GeneralTool::kGeneralToolCompileXCAssets);
 
+  // Rust tool
+  else if (name == RustTool::kRsToolRustc)
+    return std::make_unique<RustTool>(RustTool::kRsToolRustc);
+
   return nullptr;
 }
 
@@ -276,12 +296,13 @@
       return CTool::kCToolAsm;
     case SourceFile::SOURCE_RC:
       return CTool::kCToolRc;
+    case SourceFile::SOURCE_RS:
+      return RustTool::kRsToolRustc;
     case SourceFile::SOURCE_UNKNOWN:
     case SourceFile::SOURCE_H:
     case SourceFile::SOURCE_O:
     case SourceFile::SOURCE_DEF:
     case SourceFile::SOURCE_GO:
-    case SourceFile::SOURCE_RS:
       return kToolNone;
     default:
       NOTREACHED();
@@ -294,6 +315,8 @@
   // The contents of this list might be suprising (i.e. stamp tool for copy
   // rules). See the header for why.
   // TODO(crbug.com/gn/39): Don't emit stamp files for single-output targets.
+  if (target->source_types_used().RustSourceUsed())
+    return RustTool::kRsToolRustc;
   switch (target->output_type()) {
     case Target::GROUP:
       return GeneralTool::kGeneralToolStamp;
diff --git a/tools/gn/tool.h b/tools/gn/tool.h
index a6f177d..f6bf515 100644
--- a/tools/gn/tool.h
+++ b/tools/gn/tool.h
@@ -23,6 +23,7 @@
 
 class CTool;
 class GeneralTool;
+class RustTool;
 
 // To add a new Tool category, create a subclass implementing SetComplete()
 // Add a new category to ToolCategories
@@ -60,6 +61,8 @@
   virtual const CTool* AsC() const;
   virtual GeneralTool* AsGeneral();
   virtual const GeneralTool* AsGeneral() const;
+  virtual RustTool* AsRust();
+  virtual const RustTool* AsRust() const;
 
   // Basic information ---------------------------------------------------------
 
diff --git a/tools/gn/toolchain.cc b/tools/gn/toolchain.cc
index 0d6cbaf..906068d 100644
--- a/tools/gn/toolchain.cc
+++ b/tools/gn/toolchain.cc
@@ -73,6 +73,20 @@
   return nullptr;
 }
 
+RustTool* Toolchain::GetToolAsRust(const char* name) {
+  if (Tool* tool = GetTool(name)) {
+    return tool->AsRust();
+  }
+  return nullptr;
+}
+
+const RustTool* Toolchain::GetToolAsRust(const char* name) const {
+  if (const Tool* tool = GetTool(name)) {
+    return tool->AsRust();
+  }
+  return nullptr;
+}
+
 void Toolchain::SetTool(std::unique_ptr<Tool> t) {
   DCHECK(t->name() != Tool::kToolNone);
   DCHECK(tools_.find(t->name()) == tools_.end());
@@ -101,6 +115,11 @@
   return GetToolAsGeneral(Tool::GetToolTypeForSourceType(type));
 }
 
+const RustTool* Toolchain::GetToolForSourceTypeAsRust(
+    SourceFile::Type type) const {
+  return GetToolAsRust(Tool::GetToolTypeForSourceType(type));
+}
+
 const Tool* Toolchain::GetToolForTargetFinalOutput(const Target* target) const {
   return GetTool(Tool::GetToolTypeForTargetFinalOutput(target));
 }
@@ -114,3 +133,8 @@
     const Target* target) const {
   return GetToolAsGeneral(Tool::GetToolTypeForTargetFinalOutput(target));
 }
+
+const RustTool* Toolchain::GetToolForTargetFinalOutputAsRust(
+    const Target* target) const {
+  return GetToolAsRust(Tool::GetToolTypeForTargetFinalOutput(target));
+}
diff --git a/tools/gn/toolchain.h b/tools/gn/toolchain.h
index cc93de5..afab7f3 100644
--- a/tools/gn/toolchain.h
+++ b/tools/gn/toolchain.h
@@ -60,6 +60,8 @@
   const GeneralTool* GetToolAsGeneral(const char* name) const;
   CTool* GetToolAsC(const char* name);
   const CTool* GetToolAsC(const char* name) const;
+  RustTool* GetToolAsRust(const char* name);
+  const RustTool* GetToolAsRust(const char* name) const;
 
   // Set a tool. When all tools are configured, you should call
   // ToolchainSetupComplete().
@@ -90,6 +92,7 @@
   const Tool* GetToolForSourceType(SourceFile::Type type) const;
   const CTool* GetToolForSourceTypeAsC(SourceFile::Type type) const;
   const GeneralTool* GetToolForSourceTypeAsGeneral(SourceFile::Type type) const;
+  const RustTool* GetToolForSourceTypeAsRust(SourceFile::Type type) const;
 
   // Returns the tool that produces the final output for the given target type.
   // This isn't necessarily the tool you would expect. For copy target, this
@@ -99,6 +102,7 @@
   const CTool* GetToolForTargetFinalOutputAsC(const Target* target) const;
   const GeneralTool* GetToolForTargetFinalOutputAsGeneral(
       const Target* target) const;
+  const RustTool* GetToolForTargetFinalOutputAsRust(const Target* target) const;
 
   const SubstitutionBits& substitution_bits() const {
     DCHECK(setup_complete_);