rewrite_to_chrome_style: fix windows build

tools/clang/rewrite_to_chrome_style/RewriteToChromeStyle.cpp

 // Copyright 2015 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.
 //
 // Changes Blink-style names to Chrome-style names. Currently transforms:
 //   fields:
 //     int m_operationCount => int operation_count_
 //   variables (including parameters):
 //     int mySuperVariable => int my_super_variable
 //   constants:
 //     const int maxThings => const int kMaxThings
 //   free functions and methods:
 //     void doThisThenThat() => void DoThisAndThat()
 
 #include <assert.h>
 #include <algorithm>
 #include <fstream>
 #include <memory>
 #include <string>
 #include <unordered_map>
 #include <unordered_set>
 
-#if defined(_WIN32)
-#include <windows.h>
-#else
-#include <sys/file.h>
-#include <unistd.h>
-#endif
-
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/ASTMatchers/ASTMatchersMacros.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Tooling/CommonOptionsParser.h"
 #include "clang/Tooling/Refactoring.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/TargetSelect.h"
 
+#if defined(_WIN32)
+#include <windows.h>
+#else
+#include <sys/file.h>
+#include <unistd.h>
+#endif
+
 using namespace clang::ast_matchers;
 using clang::tooling::CommonOptionsParser;
 using clang::tooling::Replacement;
 using clang::tooling::Replacements;
 using llvm::StringRef;
 
 namespace {
 
 AST_MATCHER(clang::FunctionDecl, isOverloadedOperator) {
   return Node.isOverloadedOperator();
 }
 
-constexpr char kBlinkFieldPrefix[] = "m_";
-constexpr char kBlinkStaticMemberPrefix[] = "s_";
+const char kBlinkFieldPrefix[] = "m_";
+const char kBlinkStaticMemberPrefix[] = "s_";
 
 bool GetNameForDecl(const clang::FunctionDecl& decl,
                     const clang::ASTContext& context,
                     std::string& name) {
   name = decl.getNameAsString();
   name[0] = clang::toUppercase(name[0]);
   return true;
 }
 
 // Helper to convert from a camelCaseName to camel_case_name. It uses some
@@ skipping 105 matching lines @@
   }
 
   return true;
 }
 
 template <typename Type>
 struct TargetNodeTraits;
 
 template <>
 struct TargetNodeTraits<clang::NamedDecl> {
-  static constexpr char kName[] = "decl";
+  static const char kName[];
   static clang::CharSourceRange GetRange(const clang::NamedDecl& decl) {
     return clang::CharSourceRange::getTokenRange(decl.getLocation());
   }
 };
-constexpr char TargetNodeTraits<clang::NamedDecl>::kName[];
+const char TargetNodeTraits<clang::NamedDecl>::kName[] = "decl";
 
 template <>
 struct TargetNodeTraits<clang::MemberExpr> {
-  static constexpr char kName[] = "expr";
+  static const char kName[];
   static clang::CharSourceRange GetRange(const clang::MemberExpr& expr) {
     return clang::CharSourceRange::getTokenRange(expr.getMemberLoc());
   }
 };
-constexpr char TargetNodeTraits<clang::MemberExpr>::kName[];
+const char TargetNodeTraits<clang::MemberExpr>::kName[] = "expr";
 
 template <>
 struct TargetNodeTraits<clang::DeclRefExpr> {
-  static constexpr char kName[] = "expr";
+  static const char kName[];
   static clang::CharSourceRange GetRange(const clang::DeclRefExpr& expr) {
     return clang::CharSourceRange::getTokenRange(expr.getLocation());
   }
 };
-constexpr char TargetNodeTraits<clang::DeclRefExpr>::kName[];
+const char TargetNodeTraits<clang::DeclRefExpr>::kName[] = "expr";
 
 template <>
 struct TargetNodeTraits<clang::CXXCtorInitializer> {
-  static constexpr char kName[] = "initializer";
+  static const char kName[];
   static clang::CharSourceRange GetRange(
       const clang::CXXCtorInitializer& init) {
     return clang::CharSourceRange::getTokenRange(init.getSourceLocation());
   }
 };
-constexpr char TargetNodeTraits<clang::CXXCtorInitializer>::kName[];
+const char TargetNodeTraits<clang::CXXCtorInitializer>::kName[] = "initializer";
 
 template <typename DeclNode, typename TargetNode>
 class RewriterBase : public MatchFinder::MatchCallback {
  public:
   explicit RewriterBase(Replacements* replacements)
       : replacements_(replacements) {}
 
   void run(const MatchFinder::MatchResult& result) override {
     std::string name;
     const DeclNode* decl = result.Nodes.getNodeAs<DeclNode>("decl");
@@ skipping 286 matching lines @@
   match_finder.addMatcher(constructor_initializer_matcher,
                           &constructor_initializer_rewriter);
 
   std::unique_ptr<clang::tooling::FrontendActionFactory> factory =
       clang::tooling::newFrontendActionFactory(&match_finder);
   int result = tool.run(factory.get());
   if (result != 0)
     return result;
 
 #if defined(_WIN32)
-  HFILE lockfd = CreateFile("rewrite-sym.lock", GENERIC_READ, FILE_SHARE_READ,
-                            NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+  HANDLE lockfd = CreateFile("rewrite-sym.lock", GENERIC_READ, FILE_SHARE_READ,
+                             NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
   OVERLAPPED overlapped = {};
   LockFileEx(lockfd, LOCKFILE_EXCLUSIVE_LOCK, 0, 1, 0, &overlapped);
 #else
   int lockfd = open("rewrite-sym.lock", O_RDWR | O_CREAT, 0666);
   while (flock(lockfd, LOCK_EX)) {  // :D
   }
 #endif
 
   std::ofstream replacement_db_file("rewrite-sym.txt",
                                     std::ios_base::out | std::ios_base::app);
@@ skipping 20 matching lines @@
   for (const auto& r : replacements) {
     std::string replacement_text = r.getReplacementText().str();
     std::replace(replacement_text.begin(), replacement_text.end(), '\n', '\0');
     llvm::outs() << "r:::" << r.getFilePath() << ":::" << r.getOffset()
                  << ":::" << r.getLength() << ":::" << replacement_text << "\n";
   }
   llvm::outs() << "==== END EDITS ====\n";
 
   return 0;
 }