Housekeeping: rename struct Facts -> FactsExtension

Summary:
we use `namespace Facts` all over the place, so lets not also have
a `struct Facts` to confuse things. Most other extensions use the
naming convention `FooExtension`, so go with that.

Drop a few unnecessary `public` qualifiers.

AutoloadMap::Result was only used in AutoloadHandler code and only
has one bit of state anyway, so replace it with `bool`.

Reviewed By: paulbiss

Differential Revision: D45909272

fbshipit-source-id: 404f13db959b887b5c0d62ba34dc6ef864c73e38

hphp/runtime/base/autoload-handler.cpp

@@ -215,14 +215,14 @@ Array AutoloadHandler::getSymbols(const String& path,
 }
 
 template <class T>
-AutoloadMap::Result
+bool
 AutoloadHandler::loadFromMapImpl(const String& clsName,
                                  AutoloadMap::KindOf kind,
                                  const T &checkExists,
                                  Variant& err) {
   auto fileRes = getFile(clsName, kind);
   if (!fileRes) {
-    return AutoloadMap::Result::Failure;
+    return false;
   }
   bool ok = false;
   // Utility for logging errors in server mode.
@@ -275,54 +275,50 @@ AutoloadHandler::loadFromMapImpl(const String& clsName,
   }
   if (ok && checkExists()) {
     onPostAutoload(kind, clsName);
-    return AutoloadMap::Result::Success;
+    return true;
   }
-  return AutoloadMap::Result::Failure;
+  return false;
 }
 
 template <class T>
-AutoloadMap::Result
+bool
 AutoloadHandler::loadFromMap(const String& clsName,
                              AutoloadMap::KindOf kind,
                              const T &checkExists) {
   assertx(m_map);
   Variant err{Variant::NullInit()};
-  AutoloadMap::Result res = loadFromMapImpl(clsName, kind, checkExists, err);
-  if (res == AutoloadMap::Result::Success) {
-    return AutoloadMap::Result::Success;
-  }
-  return AutoloadMap::Result::Failure;
+  return loadFromMapImpl(clsName, kind, checkExists, err);
 }
 
 bool AutoloadHandler::autoloadFunc(StringData* name) {
   tracing::BlockNoTrace _{(m_map) ? "autoload-native" : "autoload"};
   return m_map &&
     loadFromMap(String{name},
                 AutoloadMap::KindOf::Function,
-                FuncExistsChecker(name)) != AutoloadMap::Result::Failure;
+                FuncExistsChecker(name));
 }
 
 bool AutoloadHandler::autoloadConstant(StringData* name) {
   tracing::BlockNoTrace _{(m_map) ? "autoload-native" : "autoload"};
   return m_map &&
     loadFromMap(String{name},
                 AutoloadMap::KindOf::Constant,
-                ConstExistsChecker(name)) != AutoloadMap::Result::Failure;
+                ConstExistsChecker(name));
 }
 
 bool AutoloadHandler::autoloadTypeAlias(const String& name) {
   tracing::BlockNoTrace _{(m_map) ? "autoload-native" : "autoload"};
   return m_map &&
     loadFromMap(name, AutoloadMap::KindOf::TypeAlias,
-                TypeAliasExistsChecker(name)) != AutoloadMap::Result::Failure;
+                TypeAliasExistsChecker(name));
 }
 
 bool AutoloadHandler::autoloadModule(StringData* name) {
   tracing::BlockNoTrace _{(m_map) ? "autoload-native" : "autoload"};
   return m_map &&
     loadFromMap(String{name},
                 AutoloadMap::KindOf::Module,
-                ModuleExistsChecker(name)) != AutoloadMap::Result::Failure;
+                ModuleExistsChecker(name));
 }
 
 /**
@@ -354,7 +350,7 @@ bool AutoloadHandler::autoloadType(const String& clsName) {
   }
   return m_map &&
     loadFromMap(className, AutoloadMap::KindOf::Type,
-                ClassExistsChecker(className)) != AutoloadMap::Result::Failure;
+                ClassExistsChecker(className));
 }
 
 bool AutoloadHandler::autoloadTypeOrTypeAlias(const String& clsName) {
@@ -365,7 +361,7 @@ bool AutoloadHandler::autoloadTypeOrTypeAlias(const String& clsName) {
 
   return m_map &&
     loadFromMap(className, AutoloadMap::KindOf::TypeOrTypeAlias,
-                NamedTypeExistsChecker(className)) != AutoloadMap::Result::Failure;
+                NamedTypeExistsChecker(className));
 }
 
 void AutoloadHandler::setRepoAutoloadMap(std::unique_ptr<RepoAutoloadMap> map) {

hphp/runtime/base/autoload-handler.h

@@ -87,21 +87,19 @@ struct AutoloadHandler final : RequestEventHandler {
 
 private:
   /**
-   * This method may return Success or Failure.
+   * This method may return true on success or false on failure.
    */
   template <class T>
-  AutoloadMap::Result loadFromMapImpl(const String& name,
-                                      AutoloadMap::KindOf kind,
-                                      const T &checkExists,
-                                      Variant& err);
+  bool loadFromMapImpl(const String& name, AutoloadMap::KindOf kind,
+                       const T &checkExists, Variant& err);
 
   /**
    * This method attempts to load the unit containing the given symbol,
-   * and will return Success or Failure.
+   * and will return true on success.
    */
   template <class T>
-  AutoloadMap::Result loadFromMap(const String& name, AutoloadMap::KindOf kind,
-                                  const T &checkExists);
+  bool loadFromMap(const String& name, AutoloadMap::KindOf kind,
+                   const T &checkExists);
 
   /**
    * Invoke `m_onPostAutoloadFunc` after autoloading a class.

hphp/runtime/base/autoload-map.h

@@ -35,12 +35,6 @@ struct Variant;
 struct RepoUnitInfo;
 
 struct AutoloadMap {
-
-  enum class Result {
-    Failure,
-    Success,
-  };
-
   /**
    * Keep enum values in sync with `HH\Facts\SymbolKind` in `ext_facts.php`
    */

hphp/runtime/ext/facts/ext_facts.cpp

@@ -489,8 +489,8 @@ struct WatchmanAutoloadMapFactory final : public FactsFactory {
       m_lastUsed;
 };
 
-struct Facts final : Extension {
-  Facts() : Extension("facts", "1.0", NO_ONCALL_YET) {}
+struct FactsExtension final : Extension {
+  FactsExtension() : Extension("facts", "1.0", NO_ONCALL_YET) {}
 
   void moduleLoad(const IniSetting::Map& ini, Hdf config) override {
     if (!RuntimeOption::AutoloadEnabled) {
@@ -1019,7 +1019,7 @@ Array HHVM_FUNCTION(
 
 namespace Facts {
 
-void Facts::moduleInit() {
+void FactsExtension::moduleInit() {
   // This, unfortunately, cannot be done in moduleLoad() due to the fact
   // that certain async loggers may create a new thread.  HHVM will throw
   // if any threads have been created during the moduleLoad() step.

hphp/runtime/ext/random/ext_random.cpp

@@ -92,7 +92,7 @@ int64_t HHVM_FUNCTION(random_int, int64_t min, int64_t max) {
   return getRandomInt(min, max);
 }
 
-static struct RandomExtension final : public Extension {
+static struct RandomExtension final : Extension {
   RandomExtension() : Extension("random", NO_EXTENSION_VERSION_YET, NO_ONCALL_YET) {}
   void moduleInit() override {
     HHVM_FE(random_bytes);

hphp/runtime/server/host-health-monitor.cpp

@@ -35,7 +35,7 @@ int32_t MaxUpdatePeriod;
 auto DampenTime = std::chrono::milliseconds{0};
 int32_t ProcStatusUpdateSeconds;
 
-struct HostHealthMonitorExtension final : public Extension {
+struct HostHealthMonitorExtension final : Extension {
   HostHealthMonitorExtension() : Extension("hosthealthmonitor", "1.0", NO_ONCALL_YET) {}
 
   void moduleLoad(const IniSetting::Map& ini, Hdf globalConfig) override {