Add ninja mode to aidl and aidl-cpp am: 93298ee273

am: 50b560560f

Change-Id: I2f03fb0d1a879628a9442daa46ac36b40dc3058b

5 files changed, 112 insertions, 19 deletions

diff --git a/aidl.cpp b/aidl.cpp
index cd778fa..142f5f2 100644
--- a/aidl.cpp
+++ b/aidl.cpp
@@ -247,16 +247,20 @@ int check_types(const string& filename,
 
 void write_common_dep_file(const string& output_file,
                            const vector<string>& aidl_sources,
-                           CodeWriter* writer) {
+                           CodeWriter* writer,
+                           const bool ninja) {
   // Encode that the output file depends on aidl input files.
   writer->Write("%s : \\\n", output_file.c_str());
   writer->Write("  %s", Join(aidl_sources, " \\\n  ").c_str());
-  writer->Write("\n\n");
+  writer->Write("\n");
 
-  // Output "<input_aidl_file>: " so make won't fail if the input .aidl file
-  // has been deleted, moved or renamed in incremental build.
-  for (const auto& src : aidl_sources) {
-    writer->Write("%s :\n", src.c_str());
+  if (!ninja) {
+    writer->Write("\n");
+    // Output "<input_aidl_file>: " so make won't fail if the input .aidl file
+    // has been deleted, moved or renamed in incremental build.
+    for (const auto& src : aidl_sources) {
+      writer->Write("%s :\n", src.c_str());
+    }
   }
 }
 
@@ -281,7 +285,8 @@ bool write_java_dep_file(const JavaOptions& options,
     }
   }
 
-  write_common_dep_file(output_file_name, source_aidl, writer.get());
+  write_common_dep_file(output_file_name, source_aidl, writer.get(),
+                        options.DependencyFileNinja());
 
   return true;
 }
@@ -310,20 +315,24 @@ bool write_cpp_dep_file(const CppOptions& options,
     }
   }
 
-  vector<string> headers;
-  for (ClassNames c : {ClassNames::CLIENT,
-                       ClassNames::SERVER,
-                       ClassNames::INTERFACE}) {
-    headers.push_back(options.OutputHeaderDir() + '/' +
-                      HeaderFile(interface, c, false /* use_os_sep */));
-  }
+  write_common_dep_file(options.OutputCppFilePath(), source_aidl, writer.get(),
+                        options.DependencyFileNinja());
 
-  write_common_dep_file(options.OutputCppFilePath(), source_aidl, writer.get());
-  writer->Write("\n");
+  if (!options.DependencyFileNinja()) {
+    vector<string> headers;
+    for (ClassNames c : {ClassNames::CLIENT,
+                         ClassNames::SERVER,
+                         ClassNames::INTERFACE}) {
+      headers.push_back(options.OutputHeaderDir() + '/' +
+                        HeaderFile(interface, c, false /* use_os_sep */));
+    }
+
+    writer->Write("\n");
 
-  // Generated headers also depend on the source aidl files.
-  writer->Write("%s : \\\n    %s\n", Join(headers, " \\\n    ").c_str(),
-                Join(source_aidl, " \\\n    ").c_str());
+    // Generated headers also depend on the source aidl files.
+    writer->Write("%s : \\\n    %s\n", Join(headers, " \\\n    ").c_str(),
+                  Join(source_aidl, " \\\n    ").c_str());
+  }
 
   return true;
 }
diff --git a/aidl_unittest.cpp b/aidl_unittest.cpp
index 22ad1bd..570ecc7 100644
--- a/aidl_unittest.cpp
+++ b/aidl_unittest.cpp
@@ -48,6 +48,11 @@ R"(place/for/output/p/IFoo.java : \
 p/IFoo.aidl :
 )";
 
+const char kExpectedNinjaDepFileContents[] =
+R"(place/for/output/p/IFoo.java : \
+  p/IFoo.aidl
+)";
+
 const char kExpectedParcelableDepFileContents[] =
 R"( : \
   p/Foo.aidl
@@ -393,6 +398,24 @@ TEST_F(AidlTest, WritesCorrectDependencyFile) {
   EXPECT_EQ(actual_dep_file_contents, kExpectedDepFileContents);
 }
 
+TEST_F(AidlTest, WritesCorrectDependencyFileNinja) {
+  // While the in tree build system always gives us an output file name,
+  // other android tools take advantage of our ability to infer the intended
+  // file name.  This test makes sure we handle this correctly.
+  JavaOptions options;
+  options.input_file_name_ = "p/IFoo.aidl";
+  options.output_base_folder_ = "place/for/output";
+  options.dep_file_name_ = "dep/file/path";
+  options.dep_file_ninja_ = true;
+  io_delegate_.SetFileContents(options.input_file_name_,
+                               "package p; interface IFoo {}");
+  EXPECT_EQ(0, ::android::aidl::compile_aidl_to_java(options, io_delegate_));
+  string actual_dep_file_contents;
+  EXPECT_TRUE(io_delegate_.GetWrittenContents(options.dep_file_name_,
+                                              &actual_dep_file_contents));
+  EXPECT_EQ(actual_dep_file_contents, kExpectedNinjaDepFileContents);
+}
+
 TEST_F(AidlTest, WritesTrivialDependencyFileForParcelable) {
   // The SDK uses aidl to decide whether a .aidl file is a parcelable.  It does
   // this by calling aidl with every .aidl file it finds, then parsing the
diff --git a/options.cpp b/options.cpp
index c7cef5c..72c7575 100644
--- a/options.cpp
+++ b/options.cpp
@@ -43,6 +43,8 @@ unique_ptr<JavaOptions> java_usage() {
           "   -d<FILE>   generate dependency file.\n"
           "   -a         generate dependency file next to the output file with "
           "the name based on the input file.\n"
+          "   -ninja     generate dependency file in a format ninja "
+          "understands.\n"
           "   -p<FILE>   file created by --preprocess to import.\n"
           "   -o<FOLDER> base output folder for generated files.\n"
           "   -b         fail when trying to compile a parcelable.\n"
@@ -122,6 +124,8 @@ unique_ptr<JavaOptions> JavaOptions::Parse(int argc, const char* const* argv) {
       }
     } else if (strcmp(s, "-b") == 0) {
       options->fail_on_parcelable_ = true;
+    } else if (strcmp(s, "-ninja") == 0) {
+      options->dep_file_ninja_ = true;
     } else {
       // s[1] is not known
       fprintf(stderr, "unknown option (%d): %s\n", i, s);
@@ -186,6 +190,8 @@ unique_ptr<CppOptions> cpp_usage() {
        << "OPTIONS:" << endl
        << "   -I<DIR>   search path for import statements" << endl
        << "   -d<FILE>  generate dependency file" << endl
+       << "   -ninja    generate dependency file in a format ninja "
+          "understands" << endl
        << endl
        << "INPUT_FILE:" << endl
        << "   an aidl interface file" << endl
@@ -218,6 +224,8 @@ unique_ptr<CppOptions> CppOptions::Parse(int argc, const char* const* argv) {
       options->import_paths_.push_back(the_rest);
     } else if (s[1] == 'd') {
       options->dep_file_name_ = the_rest;
+    } else if (strcmp(s, "-ninja") == 0) {
+      options->dep_file_ninja_ = true;
     } else {
       cerr << "Invalid argument '" << s << "'." << endl;
       return cpp_usage();
diff --git a/options.h b/options.h
index 6f32c62..89a4412 100644
--- a/options.h
+++ b/options.h
@@ -42,6 +42,7 @@ class JavaOptions final {
   static std::unique_ptr<JavaOptions> Parse(int argc, const char* const* argv);
 
   std::string DependencyFilePath() const;
+  bool DependencyFileNinja() const { return dep_file_ninja_; }
 
   int task{COMPILE_AIDL_TO_JAVA};
   bool fail_on_parcelable_{false};
@@ -52,6 +53,7 @@ class JavaOptions final {
   std::string output_base_folder_;
   std::string dep_file_name_;
   bool auto_dep_file_{false};
+  bool dep_file_ninja_{false};
   std::vector<std::string> files_to_preprocess_;
 
  private:
@@ -61,6 +63,7 @@ class JavaOptions final {
   FRIEND_TEST(AidlTest, FailOnParcelable);
   FRIEND_TEST(AidlTest, WritePreprocessedFile);
   FRIEND_TEST(AidlTest, WritesCorrectDependencyFile);
+  FRIEND_TEST(AidlTest, WritesCorrectDependencyFileNinja);
   FRIEND_TEST(AidlTest, WritesTrivialDependencyFileForParcelable);
 
   DISALLOW_COPY_AND_ASSIGN(JavaOptions);
@@ -82,6 +85,7 @@ class CppOptions final {
 
   std::vector<std::string> ImportPaths() const { return import_paths_; }
   std::string DependencyFilePath() const { return dep_file_name_; }
+  bool DependencyFileNinja() const { return dep_file_ninja_; }
 
  private:
   CppOptions() = default;
@@ -91,8 +95,10 @@ class CppOptions final {
   std::string output_header_dir_;
   std::string output_file_name_;
   std::string dep_file_name_;
+  bool dep_file_ninja_{false};
 
   FRIEND_TEST(CppOptionsTests, ParsesCompileCpp);
+  FRIEND_TEST(CppOptionsTests, ParsesCompileCppNinja);
   DISALLOW_COPY_AND_ASSIGN(CppOptions);
 };
 
diff --git a/options_unittest.cpp b/options_unittest.cpp
index 568765b..f221b54 100644
--- a/options_unittest.cpp
+++ b/options_unittest.cpp
@@ -56,6 +56,16 @@ const char* kCompileJavaCommand[] = {
 };
 const char kCompileCommandJavaOutput[] = "directory/ITool.java";
 
+const char kCompileDepFileNinja[] = "-ninja";
+const char* kCompileJavaCommandNinja[] = {
+    "aidl",
+    "-b",
+    kCompileDepFileNinja,
+    kCompileCommandIncludePath,
+    kCompileCommandInput,
+    nullptr,
+};
+
 const char kCompileDepFile[] = "-doutput.deps";
 const char kCompileCommandHeaderDir[] = "output/dir";
 const char kCompileCommandCppOutput[] = "some/file.cpp";
@@ -68,6 +78,16 @@ const char* kCompileCppCommand[] = {
     kCompileCommandCppOutput,
     nullptr,
 };
+const char* kCompileCppCommandNinja[] = {
+    "aidl-cpp",
+    kCompileCommandIncludePath,
+    kCompileDepFile,
+    kCompileDepFileNinja,
+    kCompileCommandInput,
+    kCompileCommandHeaderDir,
+    kCompileCommandCppOutput,
+    nullptr,
+};
 
 template <typename T>
 unique_ptr<T> GetOptions(const char* command[]) {
@@ -113,6 +133,20 @@ TEST(JavaOptionsTests, ParsesCompileJava) {
   EXPECT_EQ(string{kCompileCommandInput}, options->input_file_name_);
   EXPECT_EQ(string{kCompileCommandJavaOutput}, options->output_file_name_);
   EXPECT_EQ(false, options->auto_dep_file_);
+  EXPECT_EQ(false, options->DependencyFileNinja());
+}
+
+TEST(JavaOptionsTests, ParsesCompileJavaNinja) {
+  unique_ptr<JavaOptions> options =
+      GetOptions<JavaOptions>(kCompileJavaCommandNinja);
+  EXPECT_EQ(JavaOptions::COMPILE_AIDL_TO_JAVA, options->task);
+  EXPECT_EQ(true, options->fail_on_parcelable_);
+  EXPECT_EQ(1u, options->import_paths_.size());
+  EXPECT_EQ(0u, options->preprocessed_files_.size());
+  EXPECT_EQ(string{kCompileCommandInput}, options->input_file_name_);
+  EXPECT_EQ(string{kCompileCommandJavaOutput}, options->output_file_name_);
+  EXPECT_EQ(false, options->auto_dep_file_);
+  EXPECT_EQ(true, options->DependencyFileNinja());
 }
 
 TEST(CppOptionsTests, ParsesCompileCpp) {
@@ -121,6 +155,19 @@ TEST(CppOptionsTests, ParsesCompileCpp) {
   EXPECT_EQ(string{kCompileCommandIncludePath}.substr(2),
             options->import_paths_[0]);
   EXPECT_EQ(string{kCompileDepFile}.substr(2), options->dep_file_name_);
+  EXPECT_EQ(false, options->DependencyFileNinja());
+  EXPECT_EQ(kCompileCommandInput, options->InputFileName());
+  EXPECT_EQ(kCompileCommandHeaderDir, options->OutputHeaderDir());
+  EXPECT_EQ(kCompileCommandCppOutput, options->OutputCppFilePath());
+}
+
+TEST(CppOptionsTests, ParsesCompileCppNinja) {
+  unique_ptr<CppOptions> options = GetOptions<CppOptions>(kCompileCppCommandNinja);
+  ASSERT_EQ(1u, options->import_paths_.size());
+  EXPECT_EQ(string{kCompileCommandIncludePath}.substr(2),
+            options->import_paths_[0]);
+  EXPECT_EQ(string{kCompileDepFile}.substr(2), options->dep_file_name_);
+  EXPECT_EQ(true, options->DependencyFileNinja());
   EXPECT_EQ(kCompileCommandInput, options->InputFileName());
   EXPECT_EQ(kCompileCommandHeaderDir, options->OutputHeaderDir());
   EXPECT_EQ(kCompileCommandCppOutput, options->OutputCppFilePath());