diff --git a/src/gn/target.cc b/src/gn/target.cc
index fb8dbef..0dd5689 100644
--- a/src/gn/target.cc
+++ b/src/gn/target.cc
@@ -6,6 +6,8 @@
 
 #include <stddef.h>
 
+#include <algorithm>
+
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ -630,8 +632,7 @@
     if (!bundle_data().GetOutputsAsSourceFiles(settings(), this, outputs, err))
       return false;
   } else if (IsBinary() && output_type() != Target::SOURCE_SET) {
-    // Binary target with normal outputs (source sets have stamp outputs like
-    // groups).
+    // Binary target with normal outputs (source sets have phony targets).
     DCHECK(IsBinary()) << static_cast<int>(output_type());
     if (!build_complete) {
       // Can't access the toolchain for a target before the build is complete.
@@ -651,15 +652,20 @@
           output_file.AsSourceFile(settings()->build_settings()));
     }
   } else {
-    // Everything else (like a group or bundle_data) has a stamp output. The
-    // dependency output file should have computed what this is. This won't be
+    // Everything else (like a group or bundle_data) has a phony output. The
+    // dependency output phony should have computed what this is. This won't be
     // valid unless the build is complete.
     if (!build_complete) {
       *err = Err(loc_for_error, kBuildIncompleteMsg);
       return false;
     }
-    outputs->push_back(
-        dependency_output_file().AsSourceFile(settings()->build_settings()));
+
+    // The dependency output might be empty if there is no output file or a
+    // phony alias for a set of inputs.
+    if (has_dependency_output()) {
+      outputs->push_back(
+          dependency_output().AsSourceFile(settings()->build_settings()));
+    }
   }
   return true;
 }
@@ -774,27 +780,77 @@
     bundle_data().OnTargetResolved(this);
 }
 
+bool Target::HasRealInputs() const {
+  // This check is only necessary if this target will result in a phony target.
+  // Phony targets with no real inputs are treated as always dirty.
+
+  // Actions always have at least one input file: the script used to execute
+  // the action. As such, they will never have an input-less phony target. We
+  // check this first to elide the common checks.
+  if (output_type() == ACTION || output_type() == ACTION_FOREACH) {
+    return true;
+  }
+
+  // If any of this target's dependencies is non-phony target or a phony target
+  // with real inputs, then this target should be considered to have inputs.
+  for (const auto& pair : GetDeps(DEPS_ALL)) {
+    if (pair.ptr->has_dependency_output()) {
+      return true;
+    }
+  }
+
+  if (output_type() == BUNDLE_DATA) {
+    return !sources().empty();
+  }
+  if (output_type() == CREATE_BUNDLE) {
+    // CREATE_BUNDLE targets pick up most of their inputs in the form of
+    // dependencies on bundle_data targets, which were checked above when
+    // looping through GetDeps. This code handles the remaining possible
+    // CREATE_BUNDLE inputs.
+    return !bundle_data().assets_catalog_sources().empty() ||
+           !bundle_data().partial_info_plist().is_null() ||
+           !bundle_data().post_processing_script().is_null();
+  }
+
+  // If any of this target's sources will result in output files, then this
+  // target should be considered to have real inputs.
+  std::vector<OutputFile> tool_outputs;
+  return std::any_of(
+      sources().begin(), sources().end(), [&, this](const auto& source) {
+        const char* tool_name = Tool::kToolNone;
+        return GetOutputFilesForSource(source, &tool_name, &tool_outputs);
+      });
+}
+
 bool Target::FillOutputFiles(Err* err) {
   const Tool* tool = toolchain_->GetToolForTargetFinalOutput(this);
   bool check_tool_outputs = false;
   switch (output_type_) {
-    case GROUP:
-    case BUNDLE_DATA:
-    case CREATE_BUNDLE:
-    case SOURCE_SET:
-    case COPY_FILES:
     case ACTION:
     case ACTION_FOREACH:
-    case GENERATED_FILE: {
-      // These don't get linked to and use stamps which should be the first
-      // entry in the outputs. These stamps are named
-      // "<target_out_dir>/<targetname>.stamp". Setting "output_name" does not
-      // affect the stamp file name: it is always based on the original target
-      // name.
-      dependency_output_file_ =
-          GetBuildDirForTargetAsOutputFile(this, BuildDirType::OBJ);
-      dependency_output_file_.value().append(label().name());
-      dependency_output_file_.value().append(".stamp");
+    case BUNDLE_DATA:
+    case COPY_FILES:
+    case CREATE_BUNDLE:
+    case GENERATED_FILE:
+    case GROUP:
+    case SOURCE_SET: {
+      if (settings()->build_settings()->no_stamp_files()) {
+        if (HasRealInputs()) {
+          dependency_output_alias_ =
+              GetBuildDirForTargetAsOutputFile(this, BuildDirType::PHONY);
+          dependency_output_alias_.value().append(label().name());
+        }
+      } else {
+        // These don't get linked to and use stamps which should be the first
+        // entry in the outputs. These stamps are named
+        // "<target_out_dir>/<targetname>.stamp". Setting "output_name" does not
+        // affect the stamp file name: it is always based on the original target
+        // name.
+        dependency_output_file_ =
+            GetBuildDirForTargetAsOutputFile(this, BuildDirType::OBJ);
+        dependency_output_file_.value().append(label().name());
+        dependency_output_file_.value().append(".stamp");
+      }
       break;
     }
     case EXECUTABLE:
diff --git a/src/gn/target.h b/src/gn/target.h
index 5cf5360..f794035 100644
--- a/src/gn/target.h
+++ b/src/gn/target.h
@@ -345,7 +345,7 @@
   // action or a copy step, and the output library or executable file(s) from
   // binary targets.
   //
-  // It will NOT include stamp files and object files.
+  // It will NOT include phony targets or object files.
   const std::vector<OutputFile>& computed_outputs() const {
     return computed_outputs_;
   }
@@ -358,16 +358,53 @@
   // a dependency on this one. It could be the same as the link output file
   // (this will be the case for static libraries). For shared libraries it
   // could be the same or different than the link output file, depending on the
-  // system. For actions this will be the stamp file.
+  // system.
+  //
+  // The dependency output alias is only set when the target does not have an
+  // output file and is using a Ninja phony target to represent it. The
+  // exception to this is for phony targets without any real inputs. Ninja
+  // treats empty phony targets as always dirty, so no other targets should
+  // depend on that target. In that scenario, both dependency_output_alias or
+  // dependency_output_file will be empty.
+  //
+  // Callers that do not care whether the dependency is represented by a file or
+  // an alias should use dependency_output().
   //
   // These are only known once the target is resolved and will be empty before
   // that. This is a cache of the files to prevent every target that depends on
   // a given library from recomputing the same pattern.
   const OutputFile& link_output_file() const { return link_output_file_; }
+
+  // Returns true if there is an output dependency file or phony alias.
+  bool has_dependency_output() const {
+    return has_dependency_output_file() || has_dependency_output_alias();
+  }
+  // Returns the output dependency file path or phony alias if one is defined,
+  // or an empty string otherwise.
+  const OutputFile& dependency_output() const {
+    return has_dependency_output_file() ? dependency_output_file_
+                                        : dependency_output_alias_;
+  }
+
+  // Returns true if there is a dependency file path defined for this target.
+  bool has_dependency_output_file() const {
+    return !dependency_output_file_.value().empty();
+  }
+  // Returns the dependency output file path for this target if defined, or
+  // an empty string otherwise.
   const OutputFile& dependency_output_file() const {
     return dependency_output_file_;
   }
 
+  // Returns true if there is a dependency output alias defined for this target.
+  bool has_dependency_output_alias() const {
+    return !dependency_output_alias_.value().empty();
+  }
+  // Returns the dependency output alias if any, or an empty string otherwise.
+  const OutputFile& dependency_output_alias() const {
+    return dependency_output_alias_;
+  }
+
   // The subset of computed_outputs that are considered runtime outputs.
   const std::vector<OutputFile>& runtime_outputs() const {
     return runtime_outputs_;
@@ -391,6 +428,11 @@
   // The |loc_for_error| is used to blame a location for any errors produced. It
   // can be empty if there is no range (like this is being called based on the
   // command-line.
+  //
+  // It is possible for |outputs| to be returned empty without an error being
+  // reported. This can occur when the output type will result in a phony alias
+  // target (like a source_set) that is omitted from build files when they have
+  // no real inputs.
   bool GetOutputsAsSourceFiles(const LocationRange& loc_for_error,
                                bool build_complete,
                                std::vector<SourceFile>* outputs,
@@ -418,6 +460,7 @@
 
  private:
   FRIEND_TEST_ALL_PREFIXES(TargetTest, ResolvePrecompiledHeaders);
+  FRIEND_TEST_ALL_PREFIXES(TargetTest, HasRealInputs);
 
   // Pulls necessary information from dependencies to this one when all
   // dependencies have been resolved.
@@ -427,6 +470,11 @@
   void PullRecursiveHardDeps();
   void PullRecursiveBundleData();
 
+  // Checks to see whether this target or any of its dependencies have real
+  // inputs. If not, this target should be omitted as a dependency. This check
+  // only applies to targets that will result in a phony rule.
+  bool HasRealInputs() const;
+
   // Fills the link and dependency output files when a target is resolved.
   bool FillOutputFiles(Err* err);
 
@@ -498,6 +546,7 @@
   std::vector<OutputFile> computed_outputs_;
   OutputFile link_output_file_;
   OutputFile dependency_output_file_;
+  OutputFile dependency_output_alias_;
   std::vector<OutputFile> runtime_outputs_;
 
   std::unique_ptr<Metadata> metadata_;
diff --git a/src/gn/target_unittest.cc b/src/gn/target_unittest.cc
index 5cc2182..c510ba1 100644
--- a/src/gn/target_unittest.cc
+++ b/src/gn/target_unittest.cc
@@ -862,6 +862,46 @@
   EXPECT_EQ("//out/Debug/one", computed_outputs[0].value());
 }
 
+TEST_F(TargetTest, HasRealInputs) {
+  TestWithScope setup;
+  Err err;
+  // Action always have real inputs.
+  TestTarget target_a(setup, "//a:a", Target::ACTION);
+  ASSERT_TRUE(target_a.FillOutputFiles(&err));
+  EXPECT_TRUE(target_a.HasRealInputs());
+
+  // A target with no inputs and no deps has no real inputs.
+  TestTarget target_b(setup, "//a:b", Target::GROUP);
+  ASSERT_TRUE(target_b.FillOutputFiles(&err));
+  EXPECT_FALSE(target_b.HasRealInputs());
+
+  // A target with no inputs and one dep with real inputs has real inputs.
+  target_b.private_deps().push_back(LabelTargetPair(&target_a));
+  ASSERT_TRUE(target_b.FillOutputFiles(&err));
+  EXPECT_TRUE(target_b.HasRealInputs());
+
+  // A target with one input with no tool, and no deps, has no real inputs.
+  TestTarget target_c(setup, "//a:c", Target::SOURCE_SET);
+  target_c.config_values().inputs().push_back(SourceFile("//a/no_tool.txt"));
+  ASSERT_TRUE(target_c.FillOutputFiles(&err));
+  EXPECT_FALSE(target_c.HasRealInputs());  // One input with no tool, no deps.
+
+  // The same, but with one dep without a dependency output.
+  TestTarget target_d(setup, "//a:c2", Target::GROUP);
+  target_c.private_deps().push_back(LabelTargetPair(&target_d));
+  ASSERT_TRUE(target_c.FillOutputFiles(&err));
+  EXPECT_FALSE(target_c.HasRealInputs());
+
+  // The same, but with one dep with a dependency output.
+  TestTarget target_e(setup, "//a:d", Target::EXECUTABLE);
+  target_e.sources().push_back(SourceFile("//a/source.cc"));
+  ASSERT_TRUE(target_e.FillOutputFiles(&err));
+  EXPECT_TRUE(target_e.HasRealInputs());
+  target_c.private_deps().push_back(LabelTargetPair(&target_e));
+  ASSERT_TRUE(target_c.FillOutputFiles(&err));
+  EXPECT_TRUE(target_c.HasRealInputs());
+}
+
 TEST_F(TargetTest, GeneratedInputs) {
   TestWithScope setup;
   Err err;