diff --git a/generator/generator_tests_support/test_feature.cpp b/generator/generator_tests_support/test_feature.cpp
index 73d57ca048..f2414054f4 100644
--- a/generator/generator_tests_support/test_feature.cpp
+++ b/generator/generator_tests_support/test_feature.cpp
@@ -153,100 +153,72 @@ void TestFeature::Serialize(FeatureBuilder & fb) const
   }
 }
 
-// TestCountry -------------------------------------------------------------------------------------
-TestCountry::TestCountry(m2::PointD const & center, string const & name, string const & lang)
-  : TestFeature(center, name, lang)
+// TestPlace -------------------------------------------------------------------------------------
+TestPlace::TestPlace(m2::PointD const & center, string const & name, string const & lang,
+                     uint32_t type, uint8_t rank /* = 0 */)
+  : TestFeature(center, name, lang), m_type(type), m_rank(rank)
 {
 }
 
-void TestCountry::Serialize(FeatureBuilder & fb) const
+TestPlace::TestPlace(m2::PointD const & center, StringUtf8Multilang const & name,
+                     uint32_t type, uint8_t rank)
+  : TestFeature(center, name), m_type(type), m_rank(rank)
+{
+}
+
+TestPlace::TestPlace(std::vector<m2::PointD> const & boundary, std::string const & name, std::string const & lang,
+                     uint32_t type, uint8_t rank)
+  : TestFeature(boundary, name, lang), m_type(type), m_rank(rank)
+{
+}
+
+void TestPlace::Serialize(FeatureBuilder & fb) const
 {
   TestFeature::Serialize(fb);
-  auto const & classificator = classif();
-  fb.AddType(classificator.GetTypeByPath({"place", "country"}));
+  fb.AddType(m_type);
 }
 
-string TestCountry::ToDebugString() const
+string TestPlace::ToDebugString() const
 {
   ostringstream os;
-  os << "TestCountry [" << DebugPrint(m_names) << ", " << DebugPrint(m_center) << "]";
+  os << "TestPlace { " << DebugPrint(m_names) << ", " << DebugPrint(m_center) << ", "
+     << classif().GetReadableObjectName(m_type) << ", " << int(m_rank) << " }";
   return os.str();
 }
 
-// TestState -------------------------------------------------------------------------------------
+TestCountry::TestCountry(m2::PointD const & center, std::string const & name, std::string const & lang)
+  : TestPlace(center, name, lang, classif().GetTypeByPath({"place", "country"}))
+{
+}
+
 TestState::TestState(m2::PointD const & center, string const & name, string const & lang)
-  : TestFeature(center, name, lang)
+  : TestPlace(center, name, lang, classif().GetTypeByPath({"place", "state"}))
 {
 }
 
-void TestState::Serialize(FeatureBuilder & fb) const
+uint32_t TestCity::GetCityType()
 {
-  TestFeature::Serialize(fb);
-  auto const & classificator = classif();
-  fb.AddType(classificator.GetTypeByPath({"place", "state"}));
+  return classif().GetTypeByPath({"place", "city"});
 }
 
-string TestState::ToDebugString() const
-{
-  ostringstream os;
-  os << "TestState [" << DebugPrint(m_names) << ", " << DebugPrint(m_center) << "]";
-  return os.str();
-}
-
-// TestCity ----------------------------------------------------------------------------------------
-TestCity::TestCity(m2::PointD const & center, string const & name, string const & lang,
-                   uint8_t rank)
-  : TestFeature(center, name, lang), m_rank(rank)
+TestCity::TestCity(m2::PointD const & center, string const & name, string const & lang, uint8_t rank)
+  : TestPlace(center, name, lang, GetCityType(), rank)
 {
 }
 
 TestCity::TestCity(m2::PointD const & center, StringUtf8Multilang const & name, uint8_t rank)
-  : TestFeature(center, name), m_rank(rank)
+  : TestPlace(center, name, GetCityType(), rank)
 {
 }
 
-TestCity::TestCity(vector<m2::PointD> const & boundary, string const & name, string const & lang,
-                   uint8_t rank)
-  : TestFeature(boundary, name, lang), m_rank(rank)
+TestCity::TestCity(vector<m2::PointD> const & boundary, string const & name, string const & lang, uint8_t rank)
+  : TestPlace(boundary, name, lang, GetCityType(), rank)
 {
 }
 
-void TestCity::Serialize(FeatureBuilder & fb) const
+TestVillage::TestVillage(m2::PointD const & center, string const & name, string const & lang, uint8_t rank)
+  : TestPlace(center, name, lang, classif().GetTypeByPath({"place", "village"}), rank)
 {
-  TestFeature::Serialize(fb);
-  auto const & classificator = classif();
-  fb.AddType(classificator.GetTypeByPath({"place", "city"}));
-  fb.SetRank(m_rank);
-}
-
-string TestCity::ToDebugString() const
-{
-  ostringstream os;
-  os << "TestCity [" << DebugPrint(m_names) << ", " << DebugPrint(m_center) << "]";
-  return os.str();
-}
-
-// TestVillage
-// ----------------------------------------------------------------------------------------
-TestVillage::TestVillage(m2::PointD const & center, string const & name, string const & lang,
-                         uint8_t rank)
-  : TestFeature(center, name, lang), m_rank(rank)
-{
-}
-
-void TestVillage::Serialize(FeatureBuilder & fb) const
-{
-  TestFeature::Serialize(fb);
-  auto const & classificator = classif();
-  fb.AddType(classificator.GetTypeByPath({"place", "village"}));
-  fb.SetRank(m_rank);
-}
-
-string TestVillage::ToDebugString() const
-{
-  ostringstream os;
-  os << "TestVillage [" << DebugPrint(m_names) << ", " << DebugPrint(m_center) << "]";
-  return os.str();
 }
 
 // TestStreet --------------------------------------------------------------------------------------
diff --git a/generator/generator_tests_support/test_feature.hpp b/generator/generator_tests_support/test_feature.hpp
index 654878d446..0a6897cb24 100644
--- a/generator/generator_tests_support/test_feature.hpp
+++ b/generator/generator_tests_support/test_feature.hpp
@@ -74,54 +74,50 @@ private:
   void Init();
 };
 
-class TestCountry : public TestFeature
+class TestPlace : public TestFeature
+{
+public:
+  TestPlace(m2::PointD const & center, std::string const & name, std::string const & lang,
+            uint32_t type, uint8_t rank = 0);
+  TestPlace(m2::PointD const & center, StringUtf8Multilang const & name,
+            uint32_t type, uint8_t rank);
+  TestPlace(std::vector<m2::PointD> const & boundary, std::string const & name, std::string const & lang,
+            uint32_t type, uint8_t rank);
+
+  // TestFeature overrides:
+  void Serialize(feature::FeatureBuilder & fb) const override;
+  std::string ToDebugString() const override;
+
+protected:
+  uint32_t const m_type;
+  uint8_t const m_rank;
+};
+
+class TestCountry : public TestPlace
 {
 public:
   TestCountry(m2::PointD const & center, std::string const & name, std::string const & lang);
-
-  // TestFeature overrides:
-  void Serialize(feature::FeatureBuilder & fb) const override;
-  std::string ToDebugString() const override;
 };
 
-class TestState : public TestFeature
+class TestState : public TestPlace
 {
 public:
   TestState(m2::PointD const & center, std::string const & name, std::string const & lang);
-
-  // TestFeature overrides:
-  void Serialize(feature::FeatureBuilder & fb) const override;
-  std::string ToDebugString() const override;
 };
 
-class TestCity : public TestFeature
+class TestCity : public TestPlace
 {
+  static uint32_t GetCityType();
 public:
-  TestCity(m2::PointD const & center, std::string const & name, std::string const & lang,
-           uint8_t rank);
+  TestCity(m2::PointD const & center, std::string const & name, std::string const & lang, uint8_t rank);
   TestCity(m2::PointD const & center, StringUtf8Multilang const & name, uint8_t rank);
-  TestCity(std::vector<m2::PointD> const & boundary, std::string const & name,
-           std::string const & lang, uint8_t rank);
-
-  // TestFeature overrides:
-  void Serialize(feature::FeatureBuilder & fb) const override;
-  std::string ToDebugString() const override;
-
-private:
-  uint8_t const m_rank;
+  TestCity(std::vector<m2::PointD> const & boundary, std::string const & name, std::string const & lang, uint8_t rank);
 };
 
-class TestVillage : public TestFeature
+class TestVillage : public TestPlace
 {
 public:
   TestVillage(m2::PointD const & center, std::string const & name, std::string const & lang, uint8_t rank);
-
-  // TestFeature overrides:
-  void Serialize(feature::FeatureBuilder & fb) const override;
-  std::string ToDebugString() const override;
-
-private:
-  uint8_t const m_rank;
 };
 
 class TestStreet : public TestFeature
diff --git a/indexer/feature_visibility.cpp b/indexer/feature_visibility.cpp
index 53a65d4f04..28aabc0042 100644
--- a/indexer/feature_visibility.cpp
+++ b/indexer/feature_visibility.cpp
@@ -62,12 +62,12 @@ namespace
   class IsDrawableRulesChecker
   {
     int m_scale;
-    GeomType m_gt;
+    GeomType m_geomType;
     bool m_arr[3];
 
   public:
-    IsDrawableRulesChecker(int scale, GeomType gt, int rules)
-      : m_scale(scale), m_gt(gt)
+    IsDrawableRulesChecker(int scale, GeomType geomType, int rules)
+      : m_scale(scale), m_geomType(geomType)
     {
       m_arr[0] = rules & RULE_CAPTION;
       m_arr[1] = rules & RULE_PATH_TEXT;
@@ -77,7 +77,7 @@ namespace
     bool operator() (ClassifObject const * p) const
     {
       drule::KeysT keys;
-      p->GetSuitable(m_scale, m_gt, keys);
+      p->GetSuitable(m_scale, m_geomType, keys);
 
       for (auto const & k : keys)
       {
@@ -99,28 +99,35 @@ namespace
   /// The functions names and set of types looks strange now and definitely should be revised.
   /// @{
 
-  bool IsUsefulStandaloneType(uint32_t type, GeomType g = GeomType::Undefined)
+  /// These types will be included in geometry index for the corresponding scale (World or Country).
+  /// Needed for search and routing algorithms.
+  int GetNondrawableStandaloneIndexScale(uint32_t type, GeomType geomType = GeomType::Undefined)
   {
     auto const & cl = classif();
 
     static uint32_t const shuttle = cl.GetTypeByPath({"route", "shuttle_train"});
-    if ((g == GeomType::Line || g == GeomType::Undefined) && type == shuttle)
-      return true;
+    if ((geomType == GeomType::Line || geomType == GeomType::Undefined) && type == shuttle)
+      return scales::GetUpperScale();
 
     static uint32_t const region = cl.GetTypeByPath({"place", "region"});
-    if ((g == GeomType::Point || g == GeomType::Undefined) && type == region)
-      return true;
+    if ((geomType == GeomType::Point || geomType == GeomType::Undefined) && type == region)
+      return scales::GetUpperWorldScale();
 
-    return false;
+    return -1;
   }
 
-  bool TypeAlwaysExists(uint32_t type, GeomType g = GeomType::Undefined)
+  bool IsUsefulStandaloneType(uint32_t type, GeomType geomType = GeomType::Undefined)
+  {
+    return GetNondrawableStandaloneIndexScale(type, geomType) >= 0;
+  }
+
+  bool TypeAlwaysExists(uint32_t type, GeomType geomType = GeomType::Undefined)
   {
     auto const & cl = classif();
     if (!cl.IsTypeValid(type))
       return false;
 
-    if (IsUsefulStandaloneType(type, g))
+    if (IsUsefulStandaloneType(type, geomType))
       return true;
 
     static uint32_t const internet = cl.GetTypeByPath({"internet_access"});
@@ -129,7 +136,7 @@ namespace
     uint8_t const typeLevel = ftype::GetLevel(type);
     ftype::TruncValue(type, 1);
 
-    if (g != GeomType::Line)
+    if (geomType != GeomType::Line)
     {
       if (type == internet)
         return true;
@@ -149,13 +156,13 @@ namespace
     return (type == complexEntry);
   }
 
-  bool IsUsefulNondrawableType(uint32_t type, GeomType g = GeomType::Undefined)
+  bool IsUsefulNondrawableType(uint32_t type, GeomType geomType = GeomType::Undefined)
   {
     auto const & cl = classif();
     if (!cl.IsTypeValid(type))
       return false;
 
-    if (TypeAlwaysExists(type, g))
+    if (TypeAlwaysExists(type, geomType))
       return true;
 
     // Exclude generic 1-arity types like [wheelchair].
@@ -167,11 +174,11 @@ namespace
     static uint32_t const psurface = cl.GetTypeByPath({"psurface"});
 
     /// @todo "roundabout" type itself has caption drawing rules (for point junctions?).
-    if ((g == GeomType::Line || g == GeomType::Undefined) && type == roundabout)
+    if ((geomType == GeomType::Line || geomType == GeomType::Undefined) && type == roundabout)
       return true;
 
     ftype::TruncValue(type, 1);
-    if (g == GeomType::Line || g == GeomType::Undefined)
+    if (geomType == GeomType::Line || geomType == GeomType::Undefined)
     {
       if (type == hwtag || type == psurface)
         return true;
@@ -243,10 +250,11 @@ bool IsDrawableForIndexClassifOnly(TypesHolder const & types, int level)
   Classificator const & c = classif();
   for (uint32_t t : types)
   {
-    // By VNG: TypeAlwaysExists check was removed. These kind of types (internet, recycling, fee, access, etc)
-    // should NOT influence on draw priority and index visibility. Some fancy logic may be broken ..
     if (c.GetObject(t)->IsDrawable(level))
       return true;
+
+    if (level == GetNondrawableStandaloneIndexScale(t))
+      return true;
   }
 
   return false;
diff --git a/search/search_integration_tests/processor_test.cpp b/search/search_integration_tests/processor_test.cpp
index c00b118daa..ba093401e2 100644
--- a/search/search_integration_tests/processor_test.cpp
+++ b/search/search_integration_tests/processor_test.cpp
@@ -3194,4 +3194,17 @@ UNIT_CLASS_TEST(ProcessorTest, ComplexPoi_Rank)
   TEST(ResultsMatch({results[1]}, {ExactMatch(countryId, poiInMall)}), ());
 }
 
+UNIT_CLASS_TEST(ProcessorTest, Place_Region)
+{
+  TestPlace region({1, 1}, "Carthage", "en", classif().GetTypeByPath({"place", "region"}));
+
+  auto const worldId = BuildWorld([&](TestMwmBuilder & builder)
+  {
+    builder.Add(region);
+  });
+
+  Rules rules{ExactMatch(worldId, region)};
+  TEST(ResultsMatch("carth", rules, "en"), ());
+}
+
 } // namespace processor_test