Improve naming style in rustllvm.

As per the LLVM style guide, use CamelCase for all locals and classes,
and camelCase for all non-FFI functions.
Also, make names of variables of commonly used types more consistent.

Fixes #38688.

Author: isker

src/librustc_llvm/lib.rs

@@ -126,11 +126,11 @@ pub enum RustString_opaque {}
 pub type RustStringRef = *mut RustString_opaque;
 type RustStringRepr = *mut RefCell<Vec<u8>>;
 
-/// Appending to a Rust string -- used by raw_rust_string_ostream.
+/// Appending to a Rust string -- used by RawRustStringOstream.
 #[no_mangle]
-pub unsafe extern "C" fn rust_llvm_string_write_impl(sr: RustStringRef,
-                                                     ptr: *const c_char,
-                                                     size: size_t) {
+pub unsafe extern "C" fn LLVMRustStringWriteImpl(sr: RustStringRef,
+                                                 ptr: *const c_char,
+                                                 size: size_t) {
     let slice = slice::from_raw_parts(ptr as *const u8, size as usize);
 
     let sr = sr as RustStringRepr;

src/rustllvm/ArchiveWrapper.cpp

@@ -17,32 +17,32 @@ using namespace llvm;
 using namespace llvm::object;
 
 struct RustArchiveMember {
-  const char *filename;
-  const char *name;
-  Archive::Child child;
+  const char *Filename;
+  const char *Name;
+  Archive::Child Child;
 
   RustArchiveMember()
-      : filename(nullptr), name(nullptr),
+      : Filename(nullptr), Name(nullptr),
 #if LLVM_VERSION_GE(3, 8)
-        child(nullptr, nullptr, nullptr)
+        Child(nullptr, nullptr, nullptr)
 #else
-        child(nullptr, nullptr)
+        Child(nullptr, nullptr)
 #endif
   {
   }
   ~RustArchiveMember() {}
 };
 
 struct RustArchiveIterator {
-  bool first;
-  Archive::child_iterator cur;
-  Archive::child_iterator end;
+  bool First;
+  Archive::child_iterator Cur;
+  Archive::child_iterator End;
 #if LLVM_VERSION_GE(3, 9)
-  Error err;
+  Error Err;
 
-  RustArchiveIterator() : first(true), err(Error::success()) {}
+  RustArchiveIterator() : First(true), Err(Error::success()) {}
 #else
-  RustArchiveIterator() : first(true) {}
+  RustArchiveIterator() : First(true) {}
 #endif
 };
 
@@ -54,8 +54,8 @@ enum class LLVMRustArchiveKind {
   COFF,
 };
 
-static Archive::Kind from_rust(LLVMRustArchiveKind kind) {
-  switch (kind) {
+static Archive::Kind fromRust(LLVMRustArchiveKind Kind) {
+  switch (Kind) {
   case LLVMRustArchiveKind::GNU:
     return Archive::K_GNU;
   case LLVMRustArchiveKind::MIPS64:
@@ -75,59 +75,61 @@ typedef Archive::Child *LLVMRustArchiveChildRef;
 typedef Archive::Child const *LLVMRustArchiveChildConstRef;
 typedef RustArchiveIterator *LLVMRustArchiveIteratorRef;
 
-extern "C" LLVMRustArchiveRef LLVMRustOpenArchive(char *path) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> buf_or =
-      MemoryBuffer::getFile(path, -1, false);
-  if (!buf_or) {
-    LLVMRustSetLastError(buf_or.getError().message().c_str());
+extern "C" LLVMRustArchiveRef LLVMRustOpenArchive(char *Path) {
+  ErrorOr<std::unique_ptr<MemoryBuffer>> BufOr =
+      MemoryBuffer::getFile(Path, -1, false);
+  if (!BufOr) {
+    LLVMRustSetLastError(BufOr.getError().message().c_str());
     return nullptr;
   }
 
 #if LLVM_VERSION_LE(3, 8)
-  ErrorOr<std::unique_ptr<Archive>> archive_or =
+  ErrorOr<std::unique_ptr<Archive>> ArchiveOr =
 #else
-  Expected<std::unique_ptr<Archive>> archive_or =
+  Expected<std::unique_ptr<Archive>> ArchiveOr =
 #endif
-      Archive::create(buf_or.get()->getMemBufferRef());
+      Archive::create(BufOr.get()->getMemBufferRef());
 
-  if (!archive_or) {
+  if (!ArchiveOr) {
 #if LLVM_VERSION_LE(3, 8)
-    LLVMRustSetLastError(archive_or.getError().message().c_str());
+    LLVMRustSetLastError(ArchiveOr.getError().message().c_str());
 #else
-    LLVMRustSetLastError(toString(archive_or.takeError()).c_str());
+    LLVMRustSetLastError(toString(ArchiveOr.takeError()).c_str());
 #endif
     return nullptr;
   }
 
-  OwningBinary<Archive> *ret = new OwningBinary<Archive>(
-      std::move(archive_or.get()), std::move(buf_or.get()));
+  OwningBinary<Archive> *Ret = new OwningBinary<Archive>(
+      std::move(ArchiveOr.get()), std::move(BufOr.get()));
 
-  return ret;
+  return Ret;
 }
 
-extern "C" void LLVMRustDestroyArchive(LLVMRustArchiveRef ar) { delete ar; }
+extern "C" void LLVMRustDestroyArchive(LLVMRustArchiveRef RustArchive) {
+  delete RustArchive;
+}
 
 extern "C" LLVMRustArchiveIteratorRef
-LLVMRustArchiveIteratorNew(LLVMRustArchiveRef ra) {
-  Archive *ar = ra->getBinary();
-  RustArchiveIterator *rai = new RustArchiveIterator();
+LLVMRustArchiveIteratorNew(LLVMRustArchiveRef RustArchive) {
+  Archive *Archive = RustArchive->getBinary();
+  RustArchiveIterator *RAI = new RustArchiveIterator();
 #if LLVM_VERSION_LE(3, 8)
-  rai->cur = ar->child_begin();
+  RAI->Cur = Archive->child_begin();
 #else
-  rai->cur = ar->child_begin(rai->err);
-  if (rai->err) {
-    LLVMRustSetLastError(toString(std::move(rai->err)).c_str());
-    delete rai;
+  RAI->Cur = Archive->child_begin(RAI->Err);
+  if (RAI->Err) {
+    LLVMRustSetLastError(toString(std::move(RAI->Err)).c_str());
+    delete RAI;
     return nullptr;
   }
 #endif
-  rai->end = ar->child_end();
-  return rai;
+  RAI->End = Archive->child_end();
+  return RAI;
 }
 
 extern "C" LLVMRustArchiveChildConstRef
-LLVMRustArchiveIteratorNext(LLVMRustArchiveIteratorRef rai) {
-  if (rai->cur == rai->end)
+LLVMRustArchiveIteratorNext(LLVMRustArchiveIteratorRef RAI) {
+  if (RAI->Cur == RAI->End)
     return nullptr;
 
   // Advancing the iterator validates the next child, and this can
@@ -136,94 +138,94 @@ LLVMRustArchiveIteratorNext(LLVMRustArchiveIteratorRef rai) {
   // the next child.
   // This means we must not advance the iterator in the *first* call,
   // but instead advance it *before* fetching the child in all later calls.
-  if (!rai->first) {
-    ++rai->cur;
+  if (!RAI->First) {
+    ++RAI->Cur;
 #if LLVM_VERSION_GE(3, 9)
-    if (rai->err) {
-      LLVMRustSetLastError(toString(std::move(rai->err)).c_str());
+    if (RAI->Err) {
+      LLVMRustSetLastError(toString(std::move(RAI->Err)).c_str());
       return nullptr;
     }
 #endif
   } else {
-    rai->first = false;
+    RAI->First = false;
   }
 
-  if (rai->cur == rai->end)
+  if (RAI->Cur == RAI->End)
     return nullptr;
 
 #if LLVM_VERSION_EQ(3, 8)
-  const ErrorOr<Archive::Child> *cur = rai->cur.operator->();
-  if (!*cur) {
-    LLVMRustSetLastError(cur->getError().message().c_str());
+  const ErrorOr<Archive::Child> *Cur = RAI->Cur.operator->();
+  if (!*Cur) {
+    LLVMRustSetLastError(Cur->getError().message().c_str());
     return nullptr;
   }
-  const Archive::Child &child = cur->get();
+  const Archive::Child &Child = Cur->get();
 #else
-  const Archive::Child &child = *rai->cur.operator->();
+  const Archive::Child &Child = *RAI->Cur.operator->();
 #endif
-  Archive::Child *ret = new Archive::Child(child);
+  Archive::Child *Ret = new Archive::Child(Child);
 
-  return ret;
+  return Ret;
 }
 
-extern "C" void LLVMRustArchiveChildFree(LLVMRustArchiveChildRef child) {
-  delete child;
+extern "C" void LLVMRustArchiveChildFree(LLVMRustArchiveChildRef Child) {
+  delete Child;
 }
 
-extern "C" void LLVMRustArchiveIteratorFree(LLVMRustArchiveIteratorRef rai) {
-  delete rai;
+extern "C" void LLVMRustArchiveIteratorFree(LLVMRustArchiveIteratorRef RAI) {
+  delete RAI;
 }
 
 extern "C" const char *
-LLVMRustArchiveChildName(LLVMRustArchiveChildConstRef child, size_t *size) {
+LLVMRustArchiveChildName(LLVMRustArchiveChildConstRef Child, size_t *Size) {
 #if LLVM_VERSION_GE(4, 0)
-  Expected<StringRef> name_or_err = child->getName();
-  if (!name_or_err) {
-    // rustc_llvm currently doesn't use this error string, but it might be useful
-    // in the future, and in the mean time this tells LLVM that the error was
-    // not ignored and that it shouldn't abort the process.
-    LLVMRustSetLastError(toString(name_or_err.takeError()).c_str());
+  Expected<StringRef> NameOrErr = Child->getName();
+  if (!NameOrErr) {
+    // rustc_llvm currently doesn't use this error string, but it might be
+    // useful in the future, and in the mean time this tells LLVM that the
+    // error was not ignored and that it shouldn't abort the process.
+    LLVMRustSetLastError(toString(NameOrErr.takeError()).c_str());
     return nullptr;
   }
 #else
-  ErrorOr<StringRef> name_or_err = child->getName();
-  if (name_or_err.getError())
+  ErrorOr<StringRef> NameOrErr = Child->getName();
+  if (NameOrErr.getError())
     return nullptr;
 #endif
-  StringRef name = name_or_err.get();
-  *size = name.size();
-  return name.data();
+  StringRef Name = NameOrErr.get();
+  *Size = Name.size();
+  return Name.data();
 }
 
-extern "C" const char *LLVMRustArchiveChildData(LLVMRustArchiveChildRef child,
-                                                size_t *size) {
-  StringRef buf;
+extern "C" const char *LLVMRustArchiveChildData(LLVMRustArchiveChildRef Child,
+                                                size_t *Size) {
+  StringRef Buf;
 #if LLVM_VERSION_GE(4, 0)
-  Expected<StringRef> buf_or_err = child->getBuffer();
-  if (!buf_or_err) {
-    LLVMRustSetLastError(toString(buf_or_err.takeError()).c_str());
+  Expected<StringRef> BufOrErr = Child->getBuffer();
+  if (!BufOrErr) {
+    LLVMRustSetLastError(toString(BufOrErr.takeError()).c_str());
     return nullptr;
   }
 #else
-  ErrorOr<StringRef> buf_or_err = child->getBuffer();
-  if (buf_or_err.getError()) {
-    LLVMRustSetLastError(buf_or_err.getError().message().c_str());
+  ErrorOr<StringRef> BufOrErr = Child->getBuffer();
+  if (BufOrErr.getError()) {
+    LLVMRustSetLastError(BufOrErr.getError().message().c_str());
     return nullptr;
   }
 #endif
-  buf = buf_or_err.get();
-  *size = buf.size();
-  return buf.data();
+  Buf = BufOrErr.get();
+  *Size = Buf.size();
+  return Buf.data();
 }
 
 extern "C" LLVMRustArchiveMemberRef
 LLVMRustArchiveMemberNew(char *Filename, char *Name,
-                         LLVMRustArchiveChildRef child) {
+                         LLVMRustArchiveChildRef Child) {
   RustArchiveMember *Member = new RustArchiveMember;
-  Member->filename = Filename;
-  Member->name = Name;
-  if (child)
-    Member->child = *child;
+  Member->Filename = Filename;
+  Member->Name = Name;
+  if (Child)
+    Member->Child = *Child;
   return Member;
 }
 
@@ -234,38 +236,38 @@ extern "C" void LLVMRustArchiveMemberFree(LLVMRustArchiveMemberRef Member) {
 extern "C" LLVMRustResult
 LLVMRustWriteArchive(char *Dst, size_t NumMembers,
                      const LLVMRustArchiveMemberRef *NewMembers,
-                     bool WriteSymbtab, LLVMRustArchiveKind rust_kind) {
+                     bool WriteSymbtab, LLVMRustArchiveKind RustKind) {
 
 #if LLVM_VERSION_LE(3, 8)
   std::vector<NewArchiveIterator> Members;
 #else
   std::vector<NewArchiveMember> Members;
 #endif
-  auto Kind = from_rust(rust_kind);
+  auto Kind = fromRust(RustKind);
 
-  for (size_t i = 0; i < NumMembers; i++) {
-    auto Member = NewMembers[i];
-    assert(Member->name);
-    if (Member->filename) {
+  for (size_t I = 0; I < NumMembers; I++) {
+    auto Member = NewMembers[I];
+    assert(Member->Name);
+    if (Member->Filename) {
 #if LLVM_VERSION_GE(3, 9)
       Expected<NewArchiveMember> MOrErr =
-          NewArchiveMember::getFile(Member->filename, true);
+          NewArchiveMember::getFile(Member->Filename, true);
       if (!MOrErr) {
         LLVMRustSetLastError(toString(MOrErr.takeError()).c_str());
         return LLVMRustResult::Failure;
       }
       Members.push_back(std::move(*MOrErr));
 #elif LLVM_VERSION_EQ(3, 8)
-      Members.push_back(NewArchiveIterator(Member->filename));
+      Members.push_back(NewArchiveIterator(Member->Filename));
 #else
-      Members.push_back(NewArchiveIterator(Member->filename, Member->name));
+      Members.push_back(NewArchiveIterator(Member->Filename, Member->Name));
 #endif
     } else {
 #if LLVM_VERSION_LE(3, 8)
-      Members.push_back(NewArchiveIterator(Member->child, Member->name));
+      Members.push_back(NewArchiveIterator(Member->Child, Member->Name));
 #else
       Expected<NewArchiveMember> MOrErr =
-          NewArchiveMember::getOldMember(Member->child, true);
+          NewArchiveMember::getOldMember(Member->Child, true);
       if (!MOrErr) {
         LLVMRustSetLastError(toString(MOrErr.takeError()).c_str());
         return LLVMRustResult::Failure;
@@ -275,12 +277,12 @@ LLVMRustWriteArchive(char *Dst, size_t NumMembers,
     }
   }
 #if LLVM_VERSION_GE(3, 8)
-  auto pair = writeArchive(Dst, Members, WriteSymbtab, Kind, true, false);
+  auto Pair = writeArchive(Dst, Members, WriteSymbtab, Kind, true, false);
 #else
-  auto pair = writeArchive(Dst, Members, WriteSymbtab, Kind, true);
+  auto Pair = writeArchive(Dst, Members, WriteSymbtab, Kind, true);
 #endif
-  if (!pair.second)
+  if (!Pair.second)
     return LLVMRustResult::Success;
-  LLVMRustSetLastError(pair.second.message().c_str());
+  LLVMRustSetLastError(Pair.second.message().c_str());
   return LLVMRustResult::Failure;
 }

src/rustllvm/PassWrapper.cpp

@@ -64,8 +64,8 @@ enum class LLVMRustPassKind {
   Module,
 };
 
-static LLVMRustPassKind to_rust(PassKind kind) {
-  switch (kind) {
+static LLVMRustPassKind toRust(PassKind Kind) {
+  switch (Kind) {
   case PT_Function:
     return LLVMRustPassKind::Function;
   case PT_Module:
@@ -86,17 +86,17 @@ extern "C" LLVMPassRef LLVMRustFindAndCreatePass(const char *PassName) {
   return nullptr;
 }
 
-extern "C" LLVMRustPassKind LLVMRustPassKind(LLVMPassRef rust_pass) {
-  assert(rust_pass);
-  Pass *pass = unwrap(rust_pass);
-  return to_rust(pass->getPassKind());
+extern "C" LLVMRustPassKind LLVMRustPassKind(LLVMPassRef RustPass) {
+  assert(RustPass);
+  Pass *Pass = unwrap(RustPass);
+  return toRust(Pass->getPassKind());
 }
 
-extern "C" void LLVMRustAddPass(LLVMPassManagerRef PM, LLVMPassRef rust_pass) {
-  assert(rust_pass);
-  Pass *pass = unwrap(rust_pass);
-  PassManagerBase *pm = unwrap(PM);
-  pm->add(pass);
+extern "C" void LLVMRustAddPass(LLVMPassManagerRef PMR, LLVMPassRef RustPass) {
+  assert(RustPass);
+  Pass *Pass = unwrap(RustPass);
+  PassManagerBase *PMB = unwrap(PMR);
+  PMB->add(Pass);
 }
 
 #ifdef LLVM_COMPONENT_X86
@@ -160,7 +160,7 @@ GEN_SUBTARGETS
 #undef SUBTARGET
 
 extern "C" bool LLVMRustHasFeature(LLVMTargetMachineRef TM,
-                                   const char *feature) {
+                                   const char *Feature) {
   TargetMachine *Target = unwrap(TM);
   const MCSubtargetInfo *MCInfo = Target->getMCSubtargetInfo();
   const FeatureBitset &Bits = MCInfo->getFeatureBits();
@@ -174,7 +174,7 @@ extern "C" bool LLVMRustHasFeature(LLVMTargetMachineRef TM,
   GEN_SUBTARGETS { return false; }
 #undef SUBTARGET
 
-  while (strcmp(feature, FeatureEntry->Key) != 0)
+  while (strcmp(Feature, FeatureEntry->Key) != 0)
     FeatureEntry++;
 
   return (Bits & FeatureEntry->Value) == FeatureEntry->Value;
@@ -190,8 +190,8 @@ enum class LLVMRustCodeModel {
   Large,
 };
 
-static CodeModel::Model from_rust(LLVMRustCodeModel model) {
-  switch (model) {
+static CodeModel::Model fromRust(LLVMRustCodeModel Model) {
+  switch (Model) {
   case LLVMRustCodeModel::Default:
     return CodeModel::Default;
   case LLVMRustCodeModel::JITDefault:
@@ -217,8 +217,8 @@ enum class LLVMRustCodeGenOptLevel {
   Aggressive,
 };
 
-static CodeGenOpt::Level from_rust(LLVMRustCodeGenOptLevel level) {
-  switch (level) {
+static CodeGenOpt::Level fromRust(LLVMRustCodeGenOptLevel Level) {
+  switch (Level) {
   case LLVMRustCodeGenOptLevel::None:
     return CodeGenOpt::None;
   case LLVMRustCodeGenOptLevel::Less:
@@ -282,9 +282,9 @@ extern "C" void LLVMRustPrintTargetFeatures(LLVMTargetMachineRef) {
 #endif
 
 extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
-    const char *triple, const char *cpu, const char *feature,
-    LLVMRustCodeModel rust_CM, LLVMRelocMode Reloc,
-    LLVMRustCodeGenOptLevel rust_OptLevel, bool UseSoftFloat,
+    const char *TripleStr, const char *CPU, const char *Feature,
+    LLVMRustCodeModel RustCM, LLVMRelocMode Reloc,
+    LLVMRustCodeGenOptLevel RustOptLevel, bool UseSoftFloat,
     bool PositionIndependentExecutable, bool FunctionSections,
     bool DataSections) {
 
@@ -293,8 +293,8 @@ extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
 #else
   Optional<Reloc::Model> RM;
 #endif
-  auto CM = from_rust(rust_CM);
-  auto OptLevel = from_rust(rust_OptLevel);
+  auto CM = fromRust(RustCM);
+  auto OptLevel = fromRust(RustOptLevel);
 
   switch (Reloc) {
   case LLVMRelocStatic:
@@ -314,17 +314,17 @@ extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
   }
 
   std::string Error;
-  Triple Trip(Triple::normalize(triple));
+  Triple Trip(Triple::normalize(TripleStr));
   const llvm::Target *TheTarget =
       TargetRegistry::lookupTarget(Trip.getTriple(), Error);
   if (TheTarget == nullptr) {
     LLVMRustSetLastError(Error.c_str());
     return nullptr;
   }
 
-  StringRef real_cpu = cpu;
-  if (real_cpu == "native") {
-    real_cpu = sys::getHostCPUName();
+  StringRef RealCPU = CPU;
+  if (RealCPU == "native") {
+    RealCPU = sys::getHostCPUName();
   }
 
   TargetOptions Options;
@@ -340,7 +340,7 @@ extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
   Options.FunctionSections = FunctionSections;
 
   TargetMachine *TM = TheTarget->createTargetMachine(
-      Trip.getTriple(), real_cpu, feature, Options, RM, CM, OptLevel);
+      Trip.getTriple(), RealCPU, Feature, Options, RM, CM, OptLevel);
   return wrap(TM);
 }
 
@@ -360,45 +360,45 @@ extern "C" void LLVMRustAddAnalysisPasses(LLVMTargetMachineRef TM,
 }
 
 extern "C" void LLVMRustConfigurePassManagerBuilder(
-    LLVMPassManagerBuilderRef PMB, LLVMRustCodeGenOptLevel OptLevel,
+    LLVMPassManagerBuilderRef PMBR, LLVMRustCodeGenOptLevel OptLevel,
     bool MergeFunctions, bool SLPVectorize, bool LoopVectorize) {
   // Ignore mergefunc for now as enabling it causes crashes.
-  // unwrap(PMB)->MergeFunctions = MergeFunctions;
-  unwrap(PMB)->SLPVectorize = SLPVectorize;
-  unwrap(PMB)->OptLevel = from_rust(OptLevel);
-  unwrap(PMB)->LoopVectorize = LoopVectorize;
+  // unwrap(PMBR)->MergeFunctions = MergeFunctions;
+  unwrap(PMBR)->SLPVectorize = SLPVectorize;
+  unwrap(PMBR)->OptLevel = fromRust(OptLevel);
+  unwrap(PMBR)->LoopVectorize = LoopVectorize;
 }
 
 // Unfortunately, the LLVM C API doesn't provide a way to set the `LibraryInfo`
 // field of a PassManagerBuilder, we expose our own method of doing so.
-extern "C" void LLVMRustAddBuilderLibraryInfo(LLVMPassManagerBuilderRef PMB,
+extern "C" void LLVMRustAddBuilderLibraryInfo(LLVMPassManagerBuilderRef PMBR,
                                               LLVMModuleRef M,
                                               bool DisableSimplifyLibCalls) {
   Triple TargetTriple(unwrap(M)->getTargetTriple());
   TargetLibraryInfoImpl *TLI = new TargetLibraryInfoImpl(TargetTriple);
   if (DisableSimplifyLibCalls)
     TLI->disableAllFunctions();
-  unwrap(PMB)->LibraryInfo = TLI;
+  unwrap(PMBR)->LibraryInfo = TLI;
 }
 
 // Unfortunately, the LLVM C API doesn't provide a way to create the
 // TargetLibraryInfo pass, so we use this method to do so.
-extern "C" void LLVMRustAddLibraryInfo(LLVMPassManagerRef PMB, LLVMModuleRef M,
+extern "C" void LLVMRustAddLibraryInfo(LLVMPassManagerRef PMR, LLVMModuleRef M,
                                        bool DisableSimplifyLibCalls) {
   Triple TargetTriple(unwrap(M)->getTargetTriple());
   TargetLibraryInfoImpl TLII(TargetTriple);
   if (DisableSimplifyLibCalls)
     TLII.disableAllFunctions();
-  unwrap(PMB)->add(new TargetLibraryInfoWrapperPass(TLII));
+  unwrap(PMR)->add(new TargetLibraryInfoWrapperPass(TLII));
 }
 
 // Unfortunately, the LLVM C API doesn't provide an easy way of iterating over
 // all the functions in a module, so we do that manually here. You'll find
 // similar code in clang's BackendUtil.cpp file.
-extern "C" void LLVMRustRunFunctionPassManager(LLVMPassManagerRef PM,
+extern "C" void LLVMRustRunFunctionPassManager(LLVMPassManagerRef PMR,
                                                LLVMModuleRef M) {
   llvm::legacy::FunctionPassManager *P =
-      unwrap<llvm::legacy::FunctionPassManager>(PM);
+      unwrap<llvm::legacy::FunctionPassManager>(PMR);
   P->doInitialization();
 
   // Upgrade all calls to old intrinsics first.
@@ -418,10 +418,10 @@ extern "C" void LLVMRustSetLLVMOptions(int Argc, char **Argv) {
   // check if they've already been initialized.  (This could happen if we're
   // being called from rustpkg, for example). If the arguments change, then
   // that's just kinda unfortunate.
-  static bool initialized = false;
-  if (initialized)
+  static bool Initialized = false;
+  if (Initialized)
     return;
-  initialized = true;
+  Initialized = true;
   cl::ParseCommandLineOptions(Argc, Argv);
 }
 
@@ -431,8 +431,8 @@ enum class LLVMRustFileType {
   ObjectFile,
 };
 
-static TargetMachine::CodeGenFileType from_rust(LLVMRustFileType type) {
-  switch (type) {
+static TargetMachine::CodeGenFileType fromRust(LLVMRustFileType Type) {
+  switch (Type) {
   case LLVMRustFileType::AssemblyFile:
     return TargetMachine::CGFT_AssemblyFile;
   case LLVMRustFileType::ObjectFile:
@@ -444,14 +444,14 @@ static TargetMachine::CodeGenFileType from_rust(LLVMRustFileType type) {
 
 extern "C" LLVMRustResult
 LLVMRustWriteOutputFile(LLVMTargetMachineRef Target, LLVMPassManagerRef PMR,
-                        LLVMModuleRef M, const char *path,
-                        LLVMRustFileType rust_FileType) {
+                        LLVMModuleRef M, const char *Path,
+                        LLVMRustFileType RustFileType) {
   llvm::legacy::PassManager *PM = unwrap<llvm::legacy::PassManager>(PMR);
-  auto FileType = from_rust(rust_FileType);
+  auto FileType = fromRust(RustFileType);
 
   std::string ErrorInfo;
   std::error_code EC;
-  raw_fd_ostream OS(path, EC, sys::fs::F_None);
+  raw_fd_ostream OS(Path, EC, sys::fs::F_None);
   if (EC)
     ErrorInfo = EC.message();
   if (ErrorInfo != "") {
@@ -470,12 +470,12 @@ LLVMRustWriteOutputFile(LLVMTargetMachineRef Target, LLVMPassManagerRef PMR,
 }
 
 extern "C" void LLVMRustPrintModule(LLVMPassManagerRef PMR, LLVMModuleRef M,
-                                    const char *path) {
+                                    const char *Path) {
   llvm::legacy::PassManager *PM = unwrap<llvm::legacy::PassManager>(PMR);
   std::string ErrorInfo;
 
   std::error_code EC;
-  raw_fd_ostream OS(path, EC, sys::fs::F_None);
+  raw_fd_ostream OS(Path, EC, sys::fs::F_None);
   if (EC)
     ErrorInfo = EC.message();
 
@@ -489,10 +489,10 @@ extern "C" void LLVMRustPrintModule(LLVMPassManagerRef PMR, LLVMModuleRef M,
 extern "C" void LLVMRustPrintPasses() {
   LLVMInitializePasses();
   struct MyListener : PassRegistrationListener {
-    void passEnumerate(const PassInfo *info) {
+    void passEnumerate(const PassInfo *Info) {
 #if LLVM_VERSION_GE(4, 0)
-      StringRef PassArg = info->getPassArgument();
-      StringRef PassName = info->getPassName();
+      StringRef PassArg = Info->getPassArgument();
+      StringRef PassName = Info->getPassName();
       if (!PassArg.empty()) {
         // These unsigned->signed casts could theoretically overflow, but
         // realistically never will (and even if, the result is implementation
@@ -501,37 +501,37 @@ extern "C" void LLVMRustPrintPasses() {
                (int)PassName.size(), PassName.data());
       }
 #else
-      if (info->getPassArgument() && *info->getPassArgument()) {
-        printf("%15s - %s\n", info->getPassArgument(), info->getPassName());
+      if (Info->getPassArgument() && *Info->getPassArgument()) {
+        printf("%15s - %s\n", Info->getPassArgument(), Info->getPassName());
       }
 #endif
     }
-  } listener;
+  } Listener;
 
   PassRegistry *PR = PassRegistry::getPassRegistry();
-  PR->enumerateWith(&listener);
+  PR->enumerateWith(&Listener);
 }
 
-extern "C" void LLVMRustAddAlwaysInlinePass(LLVMPassManagerBuilderRef PMB,
+extern "C" void LLVMRustAddAlwaysInlinePass(LLVMPassManagerBuilderRef PMBR,
                                             bool AddLifetimes) {
 #if LLVM_VERSION_GE(4, 0)
-  unwrap(PMB)->Inliner = llvm::createAlwaysInlinerLegacyPass(AddLifetimes);
+  unwrap(PMBR)->Inliner = llvm::createAlwaysInlinerLegacyPass(AddLifetimes);
 #else
-  unwrap(PMB)->Inliner = createAlwaysInlinerPass(AddLifetimes);
+  unwrap(PMBR)->Inliner = createAlwaysInlinerPass(AddLifetimes);
 #endif
 }
 
-extern "C" void LLVMRustRunRestrictionPass(LLVMModuleRef M, char **symbols,
-                                           size_t len) {
+extern "C" void LLVMRustRunRestrictionPass(LLVMModuleRef M, char **Symbols,
+                                           size_t Len) {
   llvm::legacy::PassManager passes;
 
 #if LLVM_VERSION_LE(3, 8)
-  ArrayRef<const char *> ref(symbols, len);
-  passes.add(llvm::createInternalizePass(ref));
+  ArrayRef<const char *> Ref(Symbols, Len);
+  passes.add(llvm::createInternalizePass(Ref));
 #else
   auto PreserveFunctions = [=](const GlobalValue &GV) {
-    for (size_t i = 0; i < len; i++) {
-      if (GV.getName() == symbols[i]) {
+    for (size_t I = 0; I < Len; I++) {
+      if (GV.getName() == Symbols[I]) {
         return true;
       }
     }

src/rustllvm/RustWrapper.cpp

@@ -106,24 +106,24 @@ typedef struct LLVMOpaqueDebugLoc *LLVMDebugLocRef;
 typedef struct LLVMOpaqueSMDiagnostic *LLVMSMDiagnosticRef;
 typedef struct LLVMOpaqueRustJITMemoryManager *LLVMRustJITMemoryManagerRef;
 
-extern "C" void rust_llvm_string_write_impl(RustStringRef str, const char *ptr,
-                                            size_t size);
+extern "C" void LLVMRustStringWriteImpl(RustStringRef Str, const char *Ptr,
+                                        size_t Size);
 
-class raw_rust_string_ostream : public llvm::raw_ostream {
-  RustStringRef str;
-  uint64_t pos;
+class RawRustStringOstream : public llvm::raw_ostream {
+  RustStringRef Str;
+  uint64_t Pos;
 
-  void write_impl(const char *ptr, size_t size) override {
-    rust_llvm_string_write_impl(str, ptr, size);
-    pos += size;
+  void write_impl(const char *Ptr, size_t Size) override {
+    LLVMRustStringWriteImpl(Str, Ptr, Size);
+    Pos += Size;
   }
 
-  uint64_t current_pos() const override { return pos; }
+  uint64_t current_pos() const override { return Pos; }
 
 public:
-  explicit raw_rust_string_ostream(RustStringRef str) : str(str), pos(0) {}
+  explicit RawRustStringOstream(RustStringRef Str) : Str(Str), Pos(0) {}
 
-  ~raw_rust_string_ostream() {
+  ~RawRustStringOstream() {
     // LLVM requires this.
     flush();
   }