GC unused code.

14 files changed, 94 insertions, 139 deletions

diff --git a/document/src/tests/annotation/annotation_test.cpp b/document/src/tests/annotation/annotation_test.cpp
index 846504fda94..5e7fc325ecd 100644
--- a/document/src/tests/annotation/annotation_test.cpp
+++ b/document/src/tests/annotation/annotation_test.cpp
@@ -140,8 +140,8 @@ TEST("requireThatSpanTreeCanHaveMultipleLevels") {
 TEST("requireThatAnnotationsCanHaveValues") {
     PrimitiveDataType double_type(DataType::T_DOUBLE);
     StructDataType city_data_type;
-    city_data_type.addField(Field("latitude", 0, double_type, false));
-    city_data_type.addField(Field("longitude", 1, double_type, false));
+    city_data_type.addField(Field("latitude", 0, double_type));
+    city_data_type.addField(Field("longitude", 1, double_type));
 
     StructFieldValue::UP position(new StructFieldValue(city_data_type));
     position->setValue("latitude", DoubleFieldValue(37.774929));
@@ -162,14 +162,12 @@ TEST("requireThatAnnotationsCanReferenceAnnotations") {
     AnnotationReferenceDataType annotation_ref_type(text_type, 101);
     ArrayDataType array_type(annotation_ref_type);
     StructDataType city_data_type("name", 42);
-    city_data_type.addField(Field("references", 0, array_type, false));
+    city_data_type.addField(Field("references", 0, array_type));
 
     StructFieldValue::UP city_data(new StructFieldValue(city_data_type));
     ArrayFieldValue ref_list(array_type);
-    ref_list.add(AnnotationReferenceFieldValue(annotation_ref_type,
-                                               san_index));
-    ref_list.add(AnnotationReferenceFieldValue(annotation_ref_type,
-                                               fran_index));
+    ref_list.add(AnnotationReferenceFieldValue(annotation_ref_type, san_index));
+    ref_list.add(AnnotationReferenceFieldValue(annotation_ref_type, fran_index));
     city_data->setValue("references", ref_list);
     StructFieldValue original(*city_data);
 
diff --git a/document/src/tests/datatype/datatype_test.cpp b/document/src/tests/datatype/datatype_test.cpp
index fff913a0f91..1e9b9ad64fa 100644
--- a/document/src/tests/datatype/datatype_test.cpp
+++ b/document/src/tests/datatype/datatype_test.cpp
@@ -51,8 +51,8 @@ TEST("require that assignment operator works for LongFieldValue") {
 
 TEST("require that StructDataType can redeclare identical fields.") {
     StructDataType s("foo");
-    Field field1("field1", 42, *DataType::STRING, true);
-    Field field2("field2", 42, *DataType::STRING, true);
+    Field field1("field1", 42, *DataType::STRING);
+    Field field2("field2", 42, *DataType::STRING);
 
     s.addField(field1);
     s.addField(field1);  // ok
diff --git a/document/src/tests/documentselectparsertest.cpp b/document/src/tests/documentselectparsertest.cpp
index b75d094459b..6fd9ab80faa 100644
--- a/document/src/tests/documentselectparsertest.cpp
+++ b/document/src/tests/documentselectparsertest.cpp
@@ -1002,7 +1002,7 @@ TEST_F(DocumentSelectParserTest, testBodyFieldDetection)
         select::BodyFieldDetector detector(*_repo);
 
         root->visit(detector);
-        EXPECT_TRUE(!detector.foundBodyField);
+        EXPECT_FALSE(detector.foundBodyField);
         EXPECT_TRUE(detector.foundHeaderField);
     }
 
@@ -1011,7 +1011,7 @@ TEST_F(DocumentSelectParserTest, testBodyFieldDetection)
         select::BodyFieldDetector detector(*_repo);
 
         root->visit(detector);
-        EXPECT_TRUE(!detector.foundBodyField);
+        EXPECT_FALSE(detector.foundBodyField);
         EXPECT_TRUE(detector.foundHeaderField);
     }
 
@@ -1020,7 +1020,7 @@ TEST_F(DocumentSelectParserTest, testBodyFieldDetection)
         select::BodyFieldDetector detector(*_repo);
 
         root->visit(detector);
-        EXPECT_TRUE(!detector.foundBodyField);
+        EXPECT_FALSE(detector.foundBodyField);
         EXPECT_TRUE(detector.foundHeaderField);
     }
 
@@ -1029,7 +1029,7 @@ TEST_F(DocumentSelectParserTest, testBodyFieldDetection)
         select::BodyFieldDetector detector(*_repo);
 
         root->visit(detector);
-        EXPECT_TRUE(detector.foundBodyField);
+        EXPECT_FALSE(detector.foundBodyField);
     }
 
     {
@@ -1040,7 +1040,7 @@ TEST_F(DocumentSelectParserTest, testBodyFieldDetection)
         select::BodyFieldDetector detector(*_repo);
 
         root->visit(detector);
-        EXPECT_TRUE(!detector.foundBodyField);
+        EXPECT_FALSE(detector.foundBodyField);
     }
 
 }
diff --git a/document/src/tests/documenttestcase.cpp b/document/src/tests/documenttestcase.cpp
index 968470e9693..e917e33f9ef 100644
--- a/document/src/tests/documenttestcase.cpp
+++ b/document/src/tests/documenttestcase.cpp
@@ -92,29 +92,29 @@ Handler::~Handler() = default;
 
 TEST(DocumentTest, testTraversing)
 {
-    Field primitive1("primitive1", 1, *DataType::INT, true);
-    Field primitive2("primitive2", 2, *DataType::INT, true);
+    Field primitive1("primitive1", 1, *DataType::INT);
+    Field primitive2("primitive2", 2, *DataType::INT);
     StructDataType struct1("struct1");
     struct1.addField(primitive1);
     struct1.addField(primitive2);
 
     ArrayDataType iarr(*DataType::INT);
     ArrayDataType sarr(struct1);
-    Field iarrF("iarray", 21, iarr, true);
-    Field sarrF("sarray", 22, sarr, true);
+    Field iarrF("iarray", 21, iarr);
+    Field sarrF("sarray", 22, sarr);
 
     StructDataType struct2("struct2");
     struct2.addField(primitive1);
     struct2.addField(primitive2);
     struct2.addField(iarrF);
     struct2.addField(sarrF);
-    Field s2("ss", 12, struct2, true);
+    Field s2("ss", 12, struct2);
 
     StructDataType struct3("struct3");
     struct3.addField(primitive1);
     struct3.addField(s2);
 
-    Field structl1s1("l1s1", 11, struct3, true);
+    Field structl1s1("l1s1", 11, struct3);
 
     DocumentType type("test");
     type.addField(primitive1);
@@ -175,7 +175,7 @@ TEST(DocumentTest, testVariables)
     ArrayDataType iiarr(static_cast<DataType &>(iarr));
     ArrayDataType iiiarr(static_cast<DataType &>(iiarr));
 
-    Field iiiarrF("iiiarray", 1, iiiarr, true);
+    Field iiiarrF("iiiarray", 1, iiiarr);
     DocumentType type("test");
     type.addField(iiiarrF);
 
@@ -255,19 +255,19 @@ public:
 TEST(DocumentTest, testModifyDocument)
 {
     // Create test document type and content
-    Field primitive1("primitive1", 1, *DataType::INT, true);
-    Field primitive2("primitive2", 2, *DataType::INT, true);
+    Field primitive1("primitive1", 1, *DataType::INT);
+    Field primitive2("primitive2", 2, *DataType::INT);
     StructDataType struct1("struct1");
     struct1.addField(primitive1);
     struct1.addField(primitive2);
 
     ArrayDataType iarr(*DataType::INT);
     ArrayDataType sarr(struct1);
-    Field iarrF("iarray", 21, iarr, true);
-    Field sarrF("sarray", 22, sarr, true);
+    Field iarrF("iarray", 21, iarr);
+    Field sarrF("sarray", 22, sarr);
 
     MapDataType smap(*DataType::STRING, *DataType::STRING);
-    Field smapF("smap", 23, smap, true);
+    Field smapF("smap", 23, smap);
 
     StructDataType struct2("struct2");
     struct2.addField(primitive1);
@@ -275,16 +275,16 @@ TEST(DocumentTest, testModifyDocument)
     struct2.addField(iarrF);
     struct2.addField(sarrF);
     struct2.addField(smapF);
-    Field s2("ss", 12, struct2, true);
+    Field s2("ss", 12, struct2);
 
     MapDataType structmap(*DataType::STRING, struct2);
-    Field structmapF("structmap", 24, structmap, true);
+    Field structmapF("structmap", 24, structmap);
 
     WeightedSetDataType wset(*DataType::STRING, false, false);
-    Field wsetF("wset", 25, wset, true);
+    Field wsetF("wset", 25, wset);
 
     WeightedSetDataType structwset(struct2, false, false);
-    Field structwsetF("structwset", 26, structwset, true);
+    Field structwsetF("structwset", 26, structwset);
 
     StructDataType struct3("struct3");
     struct3.addField(primitive1);
@@ -293,7 +293,7 @@ TEST(DocumentTest, testModifyDocument)
     struct3.addField(wsetF);
     struct3.addField(structwsetF);
 
-    Field structl1s1("l1s1", 11, struct3, true);
+    Field structl1s1("l1s1", 11, struct3);
 
     DocumentType type("test");
     type.addField(primitive1);
@@ -363,9 +363,9 @@ TEST(DocumentTest, testModifyDocument)
 TEST(DocumentTest, testSimpleUsage)
 {
     DocumentType::SP type(new DocumentType("test"));
-    Field intF("int", 1, *DataType::INT, true);
-    Field longF("long", 2, *DataType::LONG, true);
-    Field strF("content", 4, *DataType::STRING, false);
+    Field intF("int", 1, *DataType::INT);
+    Field longF("long", 2, *DataType::LONG);
+    Field strF("content", 4, *DataType::STRING);
 
     type->addField(intF);
     type->addField(longF);
@@ -462,9 +462,9 @@ TEST(DocumentTest, testSimpleUsage)
 "    DocumentType(test, id -877171244)\n"
 "        : DocumentType(document) {\n"
 "      StructDataType(test.header, id 306916075) {\n"
-"        Field(content, id 4, PrimitiveDataType(String, id 2), body)\n"
-"        Field(int, id 1, NumericDataType(Int, id 0), header)\n"
-"        Field(long, id 2, NumericDataType(Long, id 4), header)\n"
+"        Field(content, id 4, PrimitiveDataType(String, id 2))\n"
+"        Field(int, id 1, NumericDataType(Int, id 0))\n"
+"        Field(long, id 2, NumericDataType(Long, id 4))\n"
 "      }\n"
 "    }\n"
 "    int: 1\n"
@@ -484,7 +484,7 @@ TEST(DocumentTest, testSimpleUsage)
         // Fetch a field not existing in type
         // (Would be nice if this failed, but whole idea to fetch by field
         // objects is to improve performance.)
-    Field anotherIntF("int", 17, *DataType::INT, true);
+    Field anotherIntF("int", 17, *DataType::INT);
     EXPECT_TRUE(!value.hasValue(anotherIntF));
     EXPECT_TRUE(!value.getValue(anotherIntF));
 
@@ -1096,10 +1096,10 @@ TEST(DocumentTest, testUnknownEntries)
     // We should be able to deserialize a document with unknown values in it.
     DocumentType type1("test", 0);
     DocumentType type2("test", 0);
-    Field field1("int1", *DataType::INT, true);
-    Field field2("int2", *DataType::INT, true);
-    Field field3("int3", *DataType::INT, false);
-    Field field4("int4", *DataType::INT, false);
+    Field field1("int1", *DataType::INT);
+    Field field2("int2", *DataType::INT);
+    Field field3("int3", *DataType::INT);
+    Field field4("int4", *DataType::INT);
 
     type1.addField(field1);
     type1.addField(field2);
diff --git a/document/src/tests/documenttypetestcase.cpp b/document/src/tests/documenttypetestcase.cpp
index caddfbc70fc..901f02652fb 100644
--- a/document/src/tests/documenttypetestcase.cpp
+++ b/document/src/tests/documenttypetestcase.cpp
@@ -5,7 +5,6 @@
 #include <vespa/document/repo/configbuilder.h>
 #include <vespa/document/repo/documenttyperepo.h>
 #include <vespa/vespalib/testkit/test_kit.h>
-#include <vespa/vespalib/util/exceptions.h>
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 
@@ -22,8 +21,8 @@ TEST(DocumentTypeTest, testSetGet)
 {
   DocumentType docType("doctypetestdoc", 0);
 
-  docType.addField(Field("stringattr", 3, *DataType::STRING, true));
-  docType.addField(Field("nalle", 0, *DataType::INT, false));
+  docType.addField(Field("stringattr", 3, *DataType::STRING));
+  docType.addField(Field("nalle", 0, *DataType::INT));
 
   const Field& fetch1 = docType.getField("stringattr");
   const Field& fetch2 = docType.getField("stringattr");
@@ -42,17 +41,11 @@ TEST(DocumentTypeTest, testSetGet)
 
 void
 categorizeFields(const Field::Set& fields,
-                 std::vector<const Field*>& headers,
-                 std::vector<const Field*>& bodies)
+                 std::vector<const Field*>& headers)
 {
-    for (Field::Set::const_iterator it(fields.begin()), e(fields.end());
-         it != e; ++it)
+    for (const Field * field : fields)
     {
-        if ((*it)->isHeaderField()) {
-            headers.push_back(*it);
-        } else {
-            bodies.push_back(*it);
-        }
+        headers.push_back(field);
     }
 }
 
@@ -81,18 +74,15 @@ TEST(DocumentTypeTest, testHeaderContent)
     Field::Set fields = type->getFieldsType().getFieldSet();
 
     std::vector<const Field*> headers;
-    std::vector<const Field*> bodies;
-    categorizeFields(fields, headers, bodies);
+    categorizeFields(fields, headers);
 
-    EXPECT_TRUE(headers.size() == 4);
+    EXPECT_TRUE(headers.size() == 6);
     EXPECT_TRUE(headers[0]->getName() == "field1");
     EXPECT_TRUE(headers[1]->getName() == "field2");
-    EXPECT_TRUE(headers[2]->getName() == "field4");
-    EXPECT_TRUE(headers[3]->getName() == "fieldarray1");
-
-    EXPECT_TRUE(bodies.size() == 2);
-    EXPECT_TRUE(bodies[0]->getName() == "field3");
-    EXPECT_TRUE(bodies[1]->getName() == "field5");
+    EXPECT_TRUE(headers[2]->getName() == "field3");
+    EXPECT_TRUE(headers[3]->getName() == "field4");
+    EXPECT_TRUE(headers[4]->getName() == "field5");
+    EXPECT_TRUE(headers[5]->getName() == "fieldarray1");
 }
 
 TEST(DocumentTypeTest, testMultipleInheritance)
@@ -142,8 +132,8 @@ bool containsField(const DocumentType::FieldSet &fieldSet, const vespalib::strin
 TEST(DocumentTypeTest, testFieldSetCanContainFieldsNotInDocType)
 {
     DocumentType docType("test1");
-    docType.addField(Field("stringattr", 3, *DataType::STRING, false));
-    docType.addField(Field("nalle", 0, *DataType::INT, false));
+    docType.addField(Field("stringattr", 3, *DataType::STRING));
+    docType.addField(Field("nalle", 0, *DataType::INT));
     {
         DocumentType::FieldSet::Fields tmp;
         tmp.insert("nalle");
@@ -160,13 +150,13 @@ TEST(DocumentTypeTest, testInheritance)
 {
         // Inheritance of conflicting but equal datatype ok
     DocumentType docType("test1");
-    docType.addField(Field("stringattr", 3, *DataType::STRING, false));
-    docType.addField(Field("nalle", 0, *DataType::INT, false));
+    docType.addField(Field("stringattr", 3, *DataType::STRING));
+    docType.addField(Field("nalle", 0, *DataType::INT));
 
     DocumentType docType2("test2");
-    docType2.addField(Field("stringattr", 3, *DataType::STRING, false));
-    docType2.addField(Field("tmp", 5, *DataType::STRING, false));
-    docType2.addField(Field("tall", 10, *DataType::INT, false));
+    docType2.addField(Field("stringattr", 3, *DataType::STRING));
+    docType2.addField(Field("tmp", 5, *DataType::STRING));
+    docType2.addField(Field("tall", 10, *DataType::INT));
 
     docType.inherit(docType2);
     EXPECT_TRUE(docType.hasField("stringattr"));
@@ -175,8 +165,8 @@ TEST(DocumentTypeTest, testInheritance)
     EXPECT_TRUE(docType.hasField("tall"));
 
     DocumentType docType3("test3");
-    docType3.addField(Field("stringattr", 3, *DataType::RAW, false));
-    docType3.addField(Field("tall", 10, *DataType::INT, false));
+    docType3.addField(Field("stringattr", 3, *DataType::RAW));
+    docType3.addField(Field("tall", 10, *DataType::INT));
 
     try{
         docType2.inherit(docType3);
@@ -206,7 +196,7 @@ TEST(DocumentTypeTest, testInheritance)
     }
 
     DocumentType docType5("test5");
-    docType5.addField(Field("stringattr", 20, *DataType::RAW, false));
+    docType5.addField(Field("stringattr", 20, *DataType::RAW));
 
     try{
         docType4.inherit(docType5);
diff --git a/document/src/tests/serialization/vespadocumentserializer_test.cpp b/document/src/tests/serialization/vespadocumentserializer_test.cpp
index 2ad06dc93de..c0ebdad6373 100644
--- a/document/src/tests/serialization/vespadocumentserializer_test.cpp
+++ b/document/src/tests/serialization/vespadocumentserializer_test.cpp
@@ -422,8 +422,8 @@ TEST("requireThatWeightedSetFieldValueCanBeSerialized") {
     EXPECT_EQUAL(3u, weight);
 }
 
-const Field field1("field1", *DataType::INT, false);
-const Field field2("field2", *DataType::STRING, false);
+const Field field1("field1", *DataType::INT);
+const Field field2("field2", *DataType::STRING);
 
 StructDataType getStructDataType() {
     StructDataType struct_type("struct");
@@ -638,7 +638,7 @@ TEST("requireThatDocumentWithDocumentCanBeSerialized") {
 
 
     setSpanTree(str, *tree);
-    const Field str_field("str", *DataType::STRING, false);
+    const Field str_field("str", *DataType::STRING);
 
     Document inner(*inner_type, DocumentId("id:ns:" + inner_type->getName() + "::"));
     inner.setValue(str_field, str);
@@ -646,7 +646,7 @@ TEST("requireThatDocumentWithDocumentCanBeSerialized") {
     ASSERT_TRUE(type);
     DocumentId doc_id("id:ns:" + type->getName() + "::");
     Document value(*type, doc_id);
-    const Field doc_field(inner_name, *inner_type, false);
+    const Field doc_field(inner_name, *inner_type);
     value.setValue(doc_field, inner);
 
     nbostream stream;
diff --git a/document/src/vespa/document/base/field.cpp b/document/src/vespa/document/base/field.cpp
index 316394c289f..ac195ccf7ea 100644
--- a/document/src/vespa/document/base/field.cpp
+++ b/document/src/vespa/document/base/field.cpp
@@ -10,22 +10,18 @@
 
 namespace document {
 
-Field::Field() : Field("", 0, *DataType::INT, false) { }
+Field::Field() : Field("", 0, *DataType::INT) { }
 
-Field::Field(vespalib::stringref name, int fieldId,
-             const DataType& dataType, bool headerField)
+Field::Field(vespalib::stringref name, int fieldId, const DataType& dataType)
     : FieldBase(name),
       _dataType(&dataType),
-      _fieldId(fieldId),
-      _isHeaderField(headerField)
+      _fieldId(fieldId)
 { }
 
-Field::Field(vespalib::stringref name,
-             const DataType& dataType, bool headerField)
+Field::Field(vespalib::stringref name, const DataType& dataType)
     : FieldBase(name),
       _dataType(&dataType),
-      _fieldId(calculateIdV7()),
-      _isHeaderField(headerField)
+      _fieldId(calculateIdV7())
 { }
 
 FieldValue::UP
@@ -42,9 +38,6 @@ Field::toString(bool verbose) const
         out << ", id " << _fieldId;
     }
     out << ", " << _dataType->toString();
-    if (verbose) {
-        out << ", " << (_isHeaderField ? "header" : "body");
-    }
     out << ")";
     return out.str();
 }
diff --git a/document/src/vespa/document/base/field.h b/document/src/vespa/document/base/field.h
index a77034932cf..3c739b2bfd3 100644
--- a/document/src/vespa/document/base/field.h
+++ b/document/src/vespa/document/base/field.h
@@ -26,8 +26,7 @@ class Field final : public vespalib::FieldBase,
                     public FieldSet
 {
     const DataType *_dataType;
-    int  _fieldId;
-    bool _isHeaderField;
+    int             _fieldId;
 public:
     typedef std::shared_ptr<const Field> CSP;
     typedef std::shared_ptr<Field> SP;
@@ -49,7 +48,7 @@ public:
      * @param headerField Whether or not this is a "header" field.
      */
     Field(vespalib::stringref name, int fieldId,
-          const DataType &type, bool headerField);
+          const DataType &type);
 
     Field();
 
@@ -61,7 +60,7 @@ public:
      * @param dataType The datatype of the field.
      * @param headerField Whether or not this is a "header" field.
      */
-    Field(vespalib::stringref name, const DataType &dataType, bool headerField);
+    Field(vespalib::stringref name, const DataType &dataType);
 
     Field* clone() const override { return new Field(*this); }
     std::unique_ptr<FieldValue> createValue() const;
@@ -74,7 +73,6 @@ public:
     const DataType &getDataType() const { return *_dataType; }
 
     int getId() const { return _fieldId; }
-    bool isHeaderField() const { return _isHeaderField; }
 
     vespalib::string toString(bool verbose=false) const;
     bool contains(const FieldSet& fields) const override;
diff --git a/document/src/vespa/document/datatype/positiondatatype.cpp b/document/src/vespa/document/datatype/positiondatatype.cpp
index 24fbcc76be3..a8e9c81c895 100644
--- a/document/src/vespa/document/datatype/positiondatatype.cpp
+++ b/document/src/vespa/document/datatype/positiondatatype.cpp
@@ -21,17 +21,17 @@ StructDataType::UP
 PositionDataType::createInstance()
 {
     StructDataType::UP type(new StructDataType(PositionDataType::STRUCT_NAME));
-    type->addField(Field(PositionDataType::FIELD_X, *DataType::INT, true));
-    type->addField(Field(PositionDataType::FIELD_Y, *DataType::INT, true));
+    type->addField(Field(PositionDataType::FIELD_X, *DataType::INT));
+    type->addField(Field(PositionDataType::FIELD_Y, *DataType::INT));
     return type;
 }
 
 const StructDataType &
 PositionDataType::getInstance()
 {
-    if (_instance.get() == NULL) {
+    if ( ! _instance) {
         vespalib::LockGuard guard(_lock);
-        if (_instance.get() == NULL) {
+        if ( ! _instance) {
             _instance = createInstance();
         }
     }
diff --git a/document/src/vespa/document/datatype/urldatatype.cpp b/document/src/vespa/document/datatype/urldatatype.cpp
index 95f8af2a881..00ea31408af 100644
--- a/document/src/vespa/document/datatype/urldatatype.cpp
+++ b/document/src/vespa/document/datatype/urldatatype.cpp
@@ -20,22 +20,22 @@ StructDataType::UP
 UrlDataType::createInstance()
 {
     StructDataType::UP type(new StructDataType(UrlDataType::STRUCT_NAME));
-    type->addField(Field(UrlDataType::FIELD_ALL,     *DataType::STRING, true));
-    type->addField(Field(UrlDataType::FIELD_SCHEME,  *DataType::STRING, true));
-    type->addField(Field(UrlDataType::FIELD_HOST,    *DataType::STRING, true));
-    type->addField(Field(UrlDataType::FIELD_PORT,    *DataType::STRING, true));
-    type->addField(Field(UrlDataType::FIELD_PATH,    *DataType::STRING, true));
-    type->addField(Field(UrlDataType::FIELD_QUERY,   *DataType::STRING, true));
-    type->addField(Field(UrlDataType::FIELD_FRAGMENT,*DataType::STRING, true));
+    type->addField(Field(UrlDataType::FIELD_ALL,     *DataType::STRING));
+    type->addField(Field(UrlDataType::FIELD_SCHEME,  *DataType::STRING));
+    type->addField(Field(UrlDataType::FIELD_HOST,    *DataType::STRING));
+    type->addField(Field(UrlDataType::FIELD_PORT,    *DataType::STRING));
+    type->addField(Field(UrlDataType::FIELD_PATH,    *DataType::STRING));
+    type->addField(Field(UrlDataType::FIELD_QUERY,   *DataType::STRING));
+    type->addField(Field(UrlDataType::FIELD_FRAGMENT,*DataType::STRING));
     return type;
 }
 
 const StructDataType &
 UrlDataType::getInstance()
 {
-    if (_instance.get() == NULL) {
+    if ( ! _instance ) {
         vespalib::LockGuard guard(_lock);
-        if (_instance.get() == NULL) {
+        if ( ! _instance ) {
             _instance = createInstance();
         }
     }
diff --git a/document/src/vespa/document/repo/configbuilder.cpp b/document/src/vespa/document/repo/configbuilder.cpp
index 7d9b607facd..2f507a43204 100644
--- a/document/src/vespa/document/repo/configbuilder.cpp
+++ b/document/src/vespa/document/repo/configbuilder.cpp
@@ -6,7 +6,7 @@ namespace document::config_builder {
 
 int32_t createFieldId(const vespalib::string &name, int32_t type) {
     StructDataType dummy("dummy", type);
-    Field f(name, dummy, true);
+    Field f(name, dummy);
     return f.getId();
 }
 
diff --git a/document/src/vespa/document/repo/documenttyperepo.cpp b/document/src/vespa/document/repo/documenttyperepo.cpp
index 58dbd16beb6..bcd4edb3ab8 100644
--- a/document/src/vespa/document/repo/documenttyperepo.cpp
+++ b/document/src/vespa/document/repo/documenttyperepo.cpp
@@ -232,7 +232,7 @@ struct DataTypeRepo {
 namespace {
 void addAnnotationType(const DocumenttypesConfig::Documenttype::Annotationtype &type, AnnotationTypeRepo &annotations)
 {
-    AnnotationType::UP a(new AnnotationType(type.id, type.name));
+    auto a = std::make_unique<AnnotationType>(type.id, type.name);
     annotations.addAnnotationType(std::move(a));
 }
 
@@ -257,17 +257,12 @@ void setAnnotationDataTypes(const vector<DocumenttypesConfig::Documenttype::Anno
 
 typedef DocumenttypesConfig::Documenttype::Datatype Datatype;
 
-void addField(const Datatype::Sstruct::Field &field, Repo &repo, StructDataType &struct_type, bool isHeaderField)
+void addField(const Datatype::Sstruct::Field &field, Repo &repo, StructDataType &struct_type)
 {
-    LOG(spam, "Adding field %s to %s (header: %s)",
-        field.name.c_str(), struct_type.getName().c_str(), isHeaderField ? "yes" : "no");
+    LOG(spam, "Adding field %s to %s",
+        field.name.c_str(), struct_type.getName().c_str());
     const DataType &field_type = repo.findOrThrowOrCreate(field.datatype, field.detailedtype);
-    struct_type.addField(Field(field.name, field.id, field_type, isHeaderField));
-}
-
-bool hasSuffix(const string &s, const string &suffix) {
-    string::size_type pos = s.rfind(suffix.c_str());
-    return pos != string::npos && pos == s.size() - suffix.size();
+    struct_type.addField(Field(field.name, field.id, field_type));
 }
 
 void addStruct(int32_t id, const Datatype::Sstruct &s, Repo &repo) {
@@ -318,7 +313,7 @@ void addStruct(int32_t id, const Datatype::Sstruct &s, Repo &repo) {
             CompressionConfig(type, s.compression.level, s.compression.threshold, s.compression.minsize));
 
     for (size_t i = 0; i < s.field.size(); ++i) {
-        addField(s.field[i], repo, *struct_type, hasSuffix(s.name, ".header"));
+        addField(s.field[i], repo, *struct_type);
     }
 }
 
diff --git a/document/src/vespa/document/select/bodyfielddetector.cpp b/document/src/vespa/document/select/bodyfielddetector.cpp
index 228fec26277..3d32813621d 100644
--- a/document/src/vespa/document/select/bodyfielddetector.cpp
+++ b/document/src/vespa/document/select/bodyfielddetector.cpp
@@ -18,11 +18,7 @@ BodyFieldDetector::detectFieldType(const FieldValueNode *expr, const DocumentTyp
         FieldPath path;
         type.buildFieldPath(path, expr->getFieldName());
         if ( ! path.empty() ) {
-            if (path[0].getFieldRef().isHeaderField()) {
-                foundHeaderField = true;
-            } else {
-                foundBodyField = true;
-            }
+            foundHeaderField = true;
         }
     } catch (FieldNotFoundException &) {
     }
diff --git a/document/src/vespa/document/select/bodyfielddetector.h b/document/src/vespa/document/select/bodyfielddetector.h
index 028519c8101..99cf9f7c6ea 100644
--- a/document/src/vespa/document/select/bodyfielddetector.h
+++ b/document/src/vespa/document/select/bodyfielddetector.h
@@ -33,19 +33,4 @@ public:
     void visitFieldValueNode(const FieldValueNode& expr) override;
 };
 
-class NeedDocumentDetector : public TraversingVisitor
-{
-private:
-    bool _needDocument;
-    void visitDocumentType(const DocType &) override {
-        _needDocument = true;
-    }
-    void visitFieldValueNode(const FieldValueNode &) override {
-        _needDocument = true;
-    }
-public:
-    NeedDocumentDetector() : _needDocument(false) { }
-    bool needDocument() const { return _needDocument; }
-};
-
 }