[processing] Always require real QgsFields objects in getVectorWriter,

don't allow arrays of fields as inputs
2025-04-15 00:04:00 -04:00 · 2017-05-02 21:15:03 +10:00 · 2017-05-02 21:15:03 +10:00 · 15de36ab26
commit 15de36ab26
parent 43a86808a2
48 changed files with 131 additions and 95 deletions
--- a/python/plugins/processing/algs/qgis/BoundingBox.py
+++ b/python/plugins/processing/algs/qgis/BoundingBox.py
@ -66,7 +66,7 @@ class BoundingBox(GeoAlgorithm):
        layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT_LAYER), context)

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), QgsWkbTypes.Polygon, layer.crs(), context)
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), QgsWkbTypes.Polygon, layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/CheckValidity.py
+++ b/python/plugins/processing/algs/qgis/CheckValidity.py
@ -30,7 +30,13 @@ import os
 from qgis.PyQt.QtGui import QIcon
 from qgis.PyQt.QtCore import QVariant

-from qgis.core import QgsSettings, QgsGeometry, QgsFeature, QgsField, QgsWkbTypes, QgsProcessingUtils
+from qgis.core import (QgsSettings,
+                       QgsGeometry,
+                       QgsFeature,
+                       QgsField,
+                       QgsWkbTypes,
+                       QgsProcessingUtils,
+                       QgsFields)
 from processing.core.GeoAlgorithm import GeoAlgorithm
 from processing.core.parameters import ParameterVector
 from processing.core.parameters import ParameterSelection
@ -110,18 +116,16 @@ class CheckValidity(GeoAlgorithm):
        valid_count = 0

        invalid_output = self.getOutputFromName(self.INVALID_OUTPUT)
-        invalid_fields = layer.fields().toList() + [
-            QgsField(name='_errors',
-                     type=QVariant.String,
-                     len=255)]
+        invalid_fields = layer.fields()
+        invalid_fields.append(QgsField('_errors',
+                                       QVariant.String,
+                                       255))
        invalid_writer = invalid_output.getVectorWriter(invalid_fields, layer.wkbType(), layer.crs(), context)
        invalid_count = 0

        error_output = self.getOutputFromName(self.ERROR_OUTPUT)
-        error_fields = [
-            QgsField(name='message',
-                     type=QVariant.String,
-                     len=255)]
+        error_fields = QgsFields()
+        error_fields.append(QgsField('message', QVariant.String, 255))
        error_writer = error_output.getVectorWriter(error_fields, QgsWkbTypes.Point, layer.crs(), context)
        error_count = 0

--- a/python/plugins/processing/algs/qgis/ConcaveHull.py
+++ b/python/plugins/processing/algs/qgis/ConcaveHull.py
@ -136,7 +136,7 @@ class ConcaveHull(GeoAlgorithm):
        feedback.setProgressText(self.tr('Saving data...'))
        feat = QgsFeature()
        QgsProcessingUtils.getFeatures(dissolved_layer, context).nextFeature(feat)
-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), QgsWkbTypes.Polygon,
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), QgsWkbTypes.Polygon,
                                                                     layer.crs(), context)
        geom = feat.geometry()
        if no_multigeom and geom.isMultipart():
--- a/python/plugins/processing/algs/qgis/ConvexHull.py
+++ b/python/plugins/processing/algs/qgis/ConvexHull.py
@ -31,7 +31,12 @@ import os
 from qgis.PyQt.QtGui import QIcon
 from qgis.PyQt.QtCore import QVariant

-from qgis.core import QgsField, QgsFeature, QgsGeometry, QgsWkbTypes, QgsProcessingUtils
+from qgis.core import (QgsField,
+                       QgsFeature,
+                       QgsGeometry,
+                       QgsWkbTypes,
+                       QgsProcessingUtils,
+                       QgsFields)

 from processing.core.GeoAlgorithm import GeoAlgorithm
 from processing.core.GeoAlgorithmExecutionException import GeoAlgorithmExecutionException
@ -96,11 +101,11 @@ class ConvexHull(GeoAlgorithm):
                f.setType(QVariant.String)
                f.setLength(255)

-        fields = [QgsField('id', QVariant.Int, '', 20),
-                  f,
-                  QgsField('area', QVariant.Double, '', 20, 6),
-                  QgsField('perim', QVariant.Double, '', 20, 6)
-                  ]
+        fields = QgsFields()
+        fields.append(QgsField('id', QVariant.Int, '', 20))
+        fields.append(f)
+        fields.append(QgsField('area', QVariant.Double, '', 20, 6))
+        fields.append(QgsField('perim', QVariant.Double, '', 20, 6))

        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Polygon, layer.crs(), context)

--- a/python/plugins/processing/algs/qgis/Delaunay.py
+++ b/python/plugins/processing/algs/qgis/Delaunay.py
@ -31,7 +31,14 @@ import os
 from qgis.PyQt.QtGui import QIcon
 from qgis.PyQt.QtCore import QVariant

-from qgis.core import QgsField, QgsFeatureRequest, QgsFeature, QgsGeometry, QgsPoint, QgsWkbTypes, QgsProcessingUtils
+from qgis.core import (QgsField,
+                       QgsFeatureRequest,
+                       QgsFeature,
+                       QgsGeometry,
+                       QgsPoint,
+                       QgsWkbTypes,
+                       QgsProcessingUtils,
+                       QgsFields)

 from processing.core.GeoAlgorithm import GeoAlgorithm
 from processing.core.GeoAlgorithmExecutionException import GeoAlgorithmExecutionException
@ -72,9 +79,10 @@ class Delaunay(GeoAlgorithm):
    def processAlgorithm(self, context, feedback):
        layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT), context)

-        fields = [QgsField('POINTA', QVariant.Double, '', 24, 15),
-                  QgsField('POINTB', QVariant.Double, '', 24, 15),
-                  QgsField('POINTC', QVariant.Double, '', 24, 15)]
+        fields = QgsFields()
+        fields.append(QgsField('POINTA', QVariant.Double, '', 24, 15))
+        fields.append(QgsField('POINTB', QVariant.Double, '', 24, 15))
+        fields.append(QgsField('POINTC', QVariant.Double, '', 24, 15))

        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Polygon, layer.crs(), context)

--- a/python/plugins/processing/algs/qgis/DensifyGeometries.py
+++ b/python/plugins/processing/algs/qgis/DensifyGeometries.py
@ -82,7 +82,7 @@ class DensifyGeometries(GeoAlgorithm):
        isPolygon = layer.geometryType() == QgsWkbTypes.PolygonGeometry

        writer = self.getOutputFromName(
-            self.OUTPUT).getVectorWriter(layer.fields().toList(), layer.wkbType(), layer.crs(), context)
+            self.OUTPUT).getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/DensifyGeometriesInterval.py
+++ b/python/plugins/processing/algs/qgis/DensifyGeometriesInterval.py
@ -77,7 +77,7 @@ class DensifyGeometriesInterval(GeoAlgorithm):
        isPolygon = layer.geometryType() == QgsWkbTypes.PolygonGeometry

        writer = self.getOutputFromName(
-            self.OUTPUT).getVectorWriter(layer.fields().toList(), layer.wkbType(), layer.crs(), context)
+            self.OUTPUT).getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/Dissolve.py
+++ b/python/plugins/processing/algs/qgis/Dissolve.py
@ -81,7 +81,7 @@ class Dissolve(GeoAlgorithm):
        vlayerA = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(Dissolve.INPUT), context)

        writer = self.getOutputFromName(
-            Dissolve.OUTPUT).getVectorWriter(vlayerA.fields().toList(), vlayerA.wkbType(), vlayerA.crs(), context)
+            Dissolve.OUTPUT).getVectorWriter(vlayerA.fields(), vlayerA.wkbType(), vlayerA.crs(), context)

        outFeat = QgsFeature()
        features = QgsProcessingUtils.getFeatures(vlayerA, context)
--- a/python/plugins/processing/algs/qgis/ExecuteSQL.py
+++ b/python/plugins/processing/algs/qgis/ExecuteSQL.py
@ -145,7 +145,7 @@ class ExecuteSQL(GeoAlgorithm):
        if not vLayer.isValid():
            raise GeoAlgorithmExecutionException(vLayer.dataProvider().error().message())

-        writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(vLayer.fields().toList(),
+        writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(vLayer.fields(),
                                                                           vLayer.wkbType() if geometry_type != 1 else 1,
                                                                           vLayer.crs(), context)

--- a/python/plugins/processing/algs/qgis/ExportGeometryInfo.py
+++ b/python/plugins/processing/algs/qgis/ExportGeometryInfo.py
@ -106,7 +106,7 @@ class ExportGeometryInfo(GeoAlgorithm):
                zName = vector.createUniqueFieldName('mvalue', fields)
                fields.append(QgsField(zName, QVariant.Double))

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields.toList(), layer.wkbType(), layer.crs(),
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, layer.wkbType(), layer.crs(),
                                                                     context)

        ellips = None
--- a/python/plugins/processing/algs/qgis/ExtentFromLayer.py
+++ b/python/plugins/processing/algs/qgis/ExtentFromLayer.py
@ -30,7 +30,13 @@ import os
 from qgis.PyQt.QtGui import QIcon
 from qgis.PyQt.QtCore import QVariant

-from qgis.core import QgsField, QgsPoint, QgsGeometry, QgsFeature, QgsWkbTypes, QgsProcessingUtils
+from qgis.core import (QgsField,
+                       QgsPoint,
+                       QgsGeometry,
+                       QgsFeature,
+                       QgsWkbTypes,
+                       QgsProcessingUtils,
+                       QgsFields)

 from processing.core.GeoAlgorithm import GeoAlgorithm
 from processing.core.parameters import ParameterVector
@ -75,18 +81,17 @@ class ExtentFromLayer(GeoAlgorithm):
        layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT_LAYER), context)
        byFeature = self.getParameterValue(self.BY_FEATURE)

-        fields = [
-            QgsField('MINX', QVariant.Double),
-            QgsField('MINY', QVariant.Double),
-            QgsField('MAXX', QVariant.Double),
-            QgsField('MAXY', QVariant.Double),
-            QgsField('CNTX', QVariant.Double),
-            QgsField('CNTY', QVariant.Double),
-            QgsField('AREA', QVariant.Double),
-            QgsField('PERIM', QVariant.Double),
-            QgsField('HEIGHT', QVariant.Double),
-            QgsField('WIDTH', QVariant.Double),
-        ]
+        fields = QgsFields()
+        fields.append(QgsField('MINX', QVariant.Double))
+        fields.append(QgsField('MINY', QVariant.Double))
+        fields.append(QgsField('MAXX', QVariant.Double))
+        fields.append(QgsField('MAXY', QVariant.Double))
+        fields.append(QgsField('CNTX', QVariant.Double))
+        fields.append(QgsField('CNTY', QVariant.Double))
+        fields.append(QgsField('AREA', QVariant.Double))
+        fields.append(QgsField('PERIM', QVariant.Double))
+        fields.append(QgsField('HEIGHT', QVariant.Double))
+        fields.append(QgsField('WIDTH', QVariant.Double))

        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Polygon, layer.crs(), context)

--- a/python/plugins/processing/algs/qgis/FieldsMapper.py
+++ b/python/plugins/processing/algs/qgis/FieldsMapper.py
@ -29,6 +29,7 @@ __copyright__ = '(C) 2014, Arnaud Morvan'
 __revision__ = '$Format:%H$'

 from qgis.core import (QgsField,
+                       QgsFields,
                       QgsExpression,
                       QgsDistanceArea,
                       QgsProject,
@ -115,7 +116,7 @@ class FieldsMapper(GeoAlgorithm):
        output = self.getOutputFromName(self.OUTPUT_LAYER)

        layer = QgsProcessingUtils.mapLayerFromString(layer, context)
-        fields = []
+        fields = QgsFields()
        expressions = []

        da = QgsDistanceArea()
@ -125,10 +126,10 @@ class FieldsMapper(GeoAlgorithm):
        exp_context = layer.createExpressionContext()

        for field_def in mapping:
-            fields.append(QgsField(name=field_def['name'],
-                                   type=field_def['type'],
-                                   len=field_def['length'],
-                                   prec=field_def['precision']))
+            fields.append(QgsField(field_def['name'],
+                                   field_def['type'],
+                                   field_def['length'],
+                                   field_def['precision']))

            expression = QgsExpression(field_def['expression'])
            expression.setGeomCalculator(da)
--- a/python/plugins/processing/algs/qgis/FixedDistanceBuffer.py
+++ b/python/plugins/processing/algs/qgis/FixedDistanceBuffer.py
@ -106,7 +106,7 @@ class FixedDistanceBuffer(GeoAlgorithm):
        miter_limit = self.getParameterValue(self.MITRE_LIMIT)

        writer = self.getOutputFromName(
-            self.OUTPUT).getVectorWriter(layer.fields().toList(), QgsWkbTypes.Polygon, layer.crs(), context)
+            self.OUTPUT).getVectorWriter(layer.fields(), QgsWkbTypes.Polygon, layer.crs(), context)

        buff.buffering(feedback, context, writer, distance, None, False, layer, dissolve, segments, end_cap_style,
                       join_style, miter_limit)
--- a/python/plugins/processing/algs/qgis/GridLine.py
+++ b/python/plugins/processing/algs/qgis/GridLine.py
@ -37,7 +37,8 @@ from qgis.core import (QgsRectangle,
                       QgsGeometry,
                       QgsPointV2,
                       QgsLineString,
-                       QgsWkbTypes)
+                       QgsWkbTypes,
+                       QgsFields)
 from processing.core.GeoAlgorithm import GeoAlgorithm
 from processing.core.GeoAlgorithmExecutionException import GeoAlgorithmExecutionException
 from processing.core.parameters import ParameterExtent
@ -118,13 +119,13 @@ class GridLine(GeoAlgorithm):
            raise GeoAlgorithmExecutionException(
                self.tr('Vertical spacing is too small for the covered area'))

-        fields = [QgsField('left', QVariant.Double, '', 24, 16),
-                  QgsField('top', QVariant.Double, '', 24, 16),
-                  QgsField('right', QVariant.Double, '', 24, 16),
-                  QgsField('bottom', QVariant.Double, '', 24, 16),
-                  QgsField('id', QVariant.Int, '', 10, 0),
-                  QgsField('coord', QVariant.Double, '', 24, 15)
-                  ]
+        fields = QgsFields()
+        fields.append(QgsField('left', QVariant.Double, '', 24, 16))
+        fields.append(QgsField('top', QVariant.Double, '', 24, 16))
+        fields.append(QgsField('right', QVariant.Double, '', 24, 16))
+        fields.append(QgsField('bottom', QVariant.Double, '', 24, 16))
+        fields.append(QgsField('id', QVariant.Int, '', 10, 0))
+        fields.append(QgsField('coord', QVariant.Double, '', 24, 15))

        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.LineString, crs, context)

--- a/python/plugins/processing/algs/qgis/GridPolygon.py
+++ b/python/plugins/processing/algs/qgis/GridPolygon.py
@ -30,7 +30,14 @@ import math

 from qgis.PyQt.QtGui import QIcon
 from qgis.PyQt.QtCore import QVariant
-from qgis.core import QgsRectangle, QgsCoordinateReferenceSystem, QgsField, QgsFeature, QgsGeometry, QgsPoint, QgsWkbTypes
+from qgis.core import (QgsRectangle,
+                       QgsCoordinateReferenceSystem,
+                       QgsField,
+                       QgsFeature,
+                       QgsGeometry,
+                       QgsPoint,
+                       QgsWkbTypes,
+                       QgsFields)

 from processing.core.GeoAlgorithm import GeoAlgorithm
 from processing.core.GeoAlgorithmExecutionException import GeoAlgorithmExecutionException
@ -123,12 +130,12 @@ class GridPolygon(GeoAlgorithm):
            raise GeoAlgorithmExecutionException(
                self.tr('Vertical spacing is too small for the covered area'))

-        fields = [QgsField('left', QVariant.Double, '', 24, 16),
-                  QgsField('top', QVariant.Double, '', 24, 16),
-                  QgsField('right', QVariant.Double, '', 24, 16),
-                  QgsField('bottom', QVariant.Double, '', 24, 16),
-                  QgsField('id', QVariant.Int, '', 10, 0)
-                  ]
+        fields = QgsFields()
+        fields.append(QgsField('left', QVariant.Double, '', 24, 16))
+        fields.append(QgsField('top', QVariant.Double, '', 24, 16))
+        fields.append(QgsField('right', QVariant.Double, '', 24, 16))
+        fields.append(QgsField('bottom', QVariant.Double, '', 24, 16))
+        fields.append(QgsField('id', QVariant.Int, '', 10, 0))

        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Polygon, crs, context)

--- a/python/plugins/processing/algs/qgis/LinesIntersection.py
+++ b/python/plugins/processing/algs/qgis/LinesIntersection.py
@ -103,7 +103,8 @@ class LinesIntersection(GeoAlgorithm):
            fieldListB = layerB.fields()

        fieldListB = vector.testForUniqueness(fieldListA, fieldListB)
-        fieldListA.extend(fieldListB)
+        for b in fieldListB:
+            fieldListA.append(b)

        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fieldListA, QgsWkbTypes.Point, layerA.crs(),
                                                                     context)
--- a/python/plugins/processing/algs/qgis/LinesToPolygons.py
+++ b/python/plugins/processing/algs/qgis/LinesToPolygons.py
@ -68,7 +68,7 @@ class LinesToPolygons(GeoAlgorithm):
    def processAlgorithm(self, context, feedback):
        layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT), context)

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), QgsWkbTypes.Polygon,
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), QgsWkbTypes.Polygon,
                                                                     layer.crs(), context)

        outFeat = QgsFeature()
--- a/python/plugins/processing/algs/qgis/MeanCoords.py
+++ b/python/plugins/processing/algs/qgis/MeanCoords.py
@ -93,9 +93,10 @@ class MeanCoords(GeoAlgorithm):
        else:
            uniqueIndex = layer.fields().lookupField(uniqueField)

-        fieldList = [QgsField('MEAN_X', QVariant.Double, '', 24, 15),
-                     QgsField('MEAN_Y', QVariant.Double, '', 24, 15),
-                     QgsField('UID', QVariant.String, '', 255)]
+        fieldList = QgsFields()
+        fieldList.append(QgsField('MEAN_X', QVariant.Double, '', 24, 15))
+        fieldList.append(QgsField('MEAN_Y', QVariant.Double, '', 24, 15))
+        fieldList.append(QgsField('UID', QVariant.String, '', 255))

        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fieldList, QgsWkbTypes.Point, layer.crs(), context)

--- a/python/plugins/processing/algs/qgis/Merge.py
+++ b/python/plugins/processing/algs/qgis/Merge.py
@ -95,7 +95,7 @@ class Merge(GeoAlgorithm):
                    fields.append(sfield)

        total = 100.0 / totalFeatureCount
-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields.toList(), layers[0].wkbType(),
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, layers[0].wkbType(),
                                                                     layers[0].crs(), context)

        featureCount = 0
--- a/python/plugins/processing/algs/qgis/MergeLines.py
+++ b/python/plugins/processing/algs/qgis/MergeLines.py
@ -69,7 +69,7 @@ class MergeLines(GeoAlgorithm):
        layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT_LAYER), context)

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), layer.wkbType(), layer.crs(), context)
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/MultipartToSingleparts.py
+++ b/python/plugins/processing/algs/qgis/MultipartToSingleparts.py
@ -63,7 +63,7 @@ class MultipartToSingleparts(GeoAlgorithm):
        layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT), context)
        geomType = QgsWkbTypes.singleType(layer.wkbType())

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), geomType, layer.crs(),
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), geomType, layer.crs(),
                                                                     context)

        features = QgsProcessingUtils.getFeatures(layer, context)
--- a/python/plugins/processing/algs/qgis/OffsetLine.py
+++ b/python/plugins/processing/algs/qgis/OffsetLine.py
@ -87,7 +87,7 @@ class OffsetLine(GeoAlgorithm):
        layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT_LAYER), context)

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), QgsWkbTypes.LineString, layer.crs(), context)
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), QgsWkbTypes.LineString, layer.crs(), context)

        distance = self.getParameterValue(self.DISTANCE)
        segments = int(self.getParameterValue(self.SEGMENTS))
--- a/python/plugins/processing/algs/qgis/PointOnSurface.py
+++ b/python/plugins/processing/algs/qgis/PointOnSurface.py
@ -66,7 +66,7 @@ class PointOnSurface(GeoAlgorithm):
        layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT_LAYER), context)

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), QgsWkbTypes.Point, layer.crs(), context)
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), QgsWkbTypes.Point, layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/PointsFromLines.py
+++ b/python/plugins/processing/algs/qgis/PointsFromLines.py
@ -87,7 +87,7 @@ class PointsFromLines(GeoAlgorithm):
        fields.append(QgsField('line_id', QVariant.Int, '', 10, 0))
        fields.append(QgsField('point_id', QVariant.Int, '', 10, 0))

-        writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(fields.toList(), QgsWkbTypes.Point,
+        writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(fields, QgsWkbTypes.Point,
                                                                           layer.crs(), context)

        outFeature = QgsFeature()
--- a/python/plugins/processing/algs/qgis/PointsFromPolygons.py
+++ b/python/plugins/processing/algs/qgis/PointsFromPolygons.py
@ -87,7 +87,7 @@ class PointsFromPolygons(GeoAlgorithm):
        fields.append(QgsField('poly_id', QVariant.Int, '', 10, 0))
        fields.append(QgsField('point_id', QVariant.Int, '', 10, 0))

-        writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(fields.toList(), QgsWkbTypes.Point,
+        writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(fields, QgsWkbTypes.Point,
                                                                           layer.crs(), context)

        outFeature = QgsFeature()
--- a/python/plugins/processing/algs/qgis/PointsInPolygon.py
+++ b/python/plugins/processing/algs/qgis/PointsInPolygon.py
@ -80,7 +80,7 @@ class PointsInPolygon(GeoAlgorithm):
        (idxCount, fieldList) = vector.findOrCreateField(polyLayer,
                                                         polyLayer.fields(), fieldName)

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields.toList(), polyLayer.wkbType(),
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, polyLayer.wkbType(),
                                                                     polyLayer.crs(), context)

        spatialIndex = QgsProcessingUtils.createSpatialIndex(pointLayer, context)
--- a/python/plugins/processing/algs/qgis/PointsInPolygonUnique.py
+++ b/python/plugins/processing/algs/qgis/PointsInPolygonUnique.py
@ -87,7 +87,7 @@ class PointsInPolygonUnique(GeoAlgorithm):
        (idxCount, fieldList) = vector.findOrCreateField(polyLayer,
                                                         polyLayer.fields(), fieldName)

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields.toList(), polyLayer.wkbType(),
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, polyLayer.wkbType(),
                                                                     polyLayer.crs(), context)

        spatialIndex = QgsProcessingUtils.createSpatialIndex(pointLayer, context)
--- a/python/plugins/processing/algs/qgis/PointsInPolygonWeighted.py
+++ b/python/plugins/processing/algs/qgis/PointsInPolygonWeighted.py
@ -93,7 +93,7 @@ class PointsInPolygonWeighted(GeoAlgorithm):
        (idxCount, fieldList) = vector.findOrCreateField(polyLayer,
                                                         polyLayer.fields(), fieldName)

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields.toList(), polyLayer.wkbType(),
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, polyLayer.wkbType(),
                                                                     polyLayer.crs(), context)

        spatialIndex = QgsProcessingUtils.createSpatialIndex(pointLayer, context)
--- a/python/plugins/processing/algs/qgis/PolygonsToLines.py
+++ b/python/plugins/processing/algs/qgis/PolygonsToLines.py
@ -68,7 +68,7 @@ class PolygonsToLines(GeoAlgorithm):
    def processAlgorithm(self, context, feedback):
        layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT), context)

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), QgsWkbTypes.LineString,
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), QgsWkbTypes.LineString,
                                                                     layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
--- a/python/plugins/processing/algs/qgis/RandomExtract.py
+++ b/python/plugins/processing/algs/qgis/RandomExtract.py
@ -96,7 +96,7 @@ class RandomExtract(GeoAlgorithm):

        selran = random.sample(list(range(featureCount)), value)

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), layer.wkbType(),
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), layer.wkbType(),
                                                                     layer.crs(), context)

        total = 100.0 / featureCount
--- a/python/plugins/processing/algs/qgis/RandomExtractWithinSubsets.py
+++ b/python/plugins/processing/algs/qgis/RandomExtractWithinSubsets.py
@ -103,7 +103,7 @@ class RandomExtractWithinSubsets(GeoAlgorithm):
                            "correct value and try again."))
            value = value / 100.0

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), layer.wkbType(),
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), layer.wkbType(),
                                                                     layer.crs(), context)

        selran = []
--- a/python/plugins/processing/algs/qgis/RectanglesOvalsDiamondsFixed.py
+++ b/python/plugins/processing/algs/qgis/RectanglesOvalsDiamondsFixed.py
@ -101,7 +101,7 @@ class RectanglesOvalsDiamondsFixed(GeoAlgorithm):
        segments = self.getParameterValue(self.SEGMENTS)

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), QgsWkbTypes.Polygon, layer.crs(), context)
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), QgsWkbTypes.Polygon, layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)

--- a/python/plugins/processing/algs/qgis/RectanglesOvalsDiamondsVariable.py
+++ b/python/plugins/processing/algs/qgis/RectanglesOvalsDiamondsVariable.py
@ -110,7 +110,7 @@ class RectanglesOvalsDiamondsVariable(GeoAlgorithm):
        segments = self.getParameterValue(self.SEGMENTS)

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), QgsWkbTypes.Polygon, layer.crs(), context)
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), QgsWkbTypes.Polygon, layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)

--- a/python/plugins/processing/algs/qgis/ReprojectLayer.py
+++ b/python/plugins/processing/algs/qgis/ReprojectLayer.py
@ -72,7 +72,7 @@ class ReprojectLayer(GeoAlgorithm):
        targetCrs = QgsCoordinateReferenceSystem()
        targetCrs.createFromUserInput(crsId)

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), layer.wkbType(),
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), layer.wkbType(),
                                                                     targetCrs, context)

        layerCrs = layer.crs()
--- a/python/plugins/processing/algs/qgis/ReverseLineDirection.py
+++ b/python/plugins/processing/algs/qgis/ReverseLineDirection.py
@ -65,7 +65,7 @@ class ReverseLineDirection(GeoAlgorithm):
        layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT_LAYER), context)

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), layer.wkbType(), layer.crs(), context)
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(), context)

        outFeat = QgsFeature()

--- a/python/plugins/processing/algs/qgis/ShortestPathLayerToPoint.py
+++ b/python/plugins/processing/algs/qgis/ShortestPathLayerToPoint.py
@ -180,7 +180,7 @@ class ShortestPathLayerToPoint(GeoAlgorithm):
        feat.setFields(fields)

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(fields.toList(), QgsWkbTypes.LineString, layer.crs(), context)
+            self.OUTPUT_LAYER).getVectorWriter(fields, QgsWkbTypes.LineString, layer.crs(), context)

        tmp = endPoint.split(',')
        endPoint = QgsPoint(float(tmp[0]), float(tmp[1]))
--- a/python/plugins/processing/algs/qgis/ShortestPathPointToLayer.py
+++ b/python/plugins/processing/algs/qgis/ShortestPathPointToLayer.py
@ -173,7 +173,7 @@ class ShortestPathPointToLayer(GeoAlgorithm):
        feat.setFields(fields)

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(fields.toList(), QgsWkbTypes.LineString, layer.crs(), context)
+            self.OUTPUT_LAYER).getVectorWriter(fields, QgsWkbTypes.LineString, layer.crs(), context)

        tmp = startPoint.split(',')
        startPoint = QgsPoint(float(tmp[0]), float(tmp[1]))
--- a/python/plugins/processing/algs/qgis/ShortestPathPointToPoint.py
+++ b/python/plugins/processing/algs/qgis/ShortestPathPointToPoint.py
@ -180,7 +180,7 @@ class ShortestPathPointToPoint(GeoAlgorithm):
        fields.append(QgsField('cost', QVariant.Double, '', 20, 7))

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(fields.toList(), QgsWkbTypes.LineString, layer.crs(), context)
+            self.OUTPUT_LAYER).getVectorWriter(fields, QgsWkbTypes.LineString, layer.crs(), context)

        tmp = startPoint.split(',')
        startPoint = QgsPoint(float(tmp[0]), float(tmp[1]))
--- a/python/plugins/processing/algs/qgis/SimplifyGeometries.py
+++ b/python/plugins/processing/algs/qgis/SimplifyGeometries.py
@ -86,7 +86,7 @@ class SimplifyGeometries(GeoAlgorithm):
        pointsBefore = 0
        pointsAfter = 0

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), layer.wkbType(),
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), layer.wkbType(),
                                                                     layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
--- a/python/plugins/processing/algs/qgis/SinglePartsToMultiparts.py
+++ b/python/plugins/processing/algs/qgis/SinglePartsToMultiparts.py
@ -71,7 +71,7 @@ class SinglePartsToMultiparts(GeoAlgorithm):

        geomType = QgsWkbTypes.multiType(layer.wkbType())

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), geomType, layer.crs(),
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), geomType, layer.crs(),
                                                                     context)

        outFeat = QgsFeature()
--- a/python/plugins/processing/algs/qgis/SingleSidedBuffer.py
+++ b/python/plugins/processing/algs/qgis/SingleSidedBuffer.py
@ -97,7 +97,7 @@ class SingleSidedBuffer(GeoAlgorithm):
        layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT_LAYER), context)

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), QgsWkbTypes.Polygon, layer.crs(), context)
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), QgsWkbTypes.Polygon, layer.crs(), context)

        distance = self.getParameterValue(self.DISTANCE)
        segments = int(self.getParameterValue(self.SEGMENTS))
--- a/python/plugins/processing/algs/qgis/Smooth.py
+++ b/python/plugins/processing/algs/qgis/Smooth.py
@ -75,7 +75,7 @@ class Smooth(GeoAlgorithm):
        max_angle = self.getParameterValue(self.MAX_ANGLE)

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), layer.wkbType(), layer.crs(), context)
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
--- a/python/plugins/processing/algs/qgis/SumLines.py
+++ b/python/plugins/processing/algs/qgis/SumLines.py
@ -83,7 +83,7 @@ class SumLines(GeoAlgorithm):
        (idxCount, fieldList) = vector.findOrCreateField(polyLayer, fieldList,
                                                         countFieldName)

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fieldList.toList(), polyLayer.wkbType(),
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fieldList, polyLayer.wkbType(),
                                                                     polyLayer.crs(), context)

        spatialIndex = QgsProcessingUtils.createSpatialIndex(lineLayer, context)
--- a/python/plugins/processing/algs/qgis/Translate.py
+++ b/python/plugins/processing/algs/qgis/Translate.py
@ -73,7 +73,7 @@ class Translate(GeoAlgorithm):
        layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT_LAYER), context)

        writer = self.getOutputFromName(
-            self.OUTPUT_LAYER).getVectorWriter(layer.fields().toList(), layer.wkbType(), layer.crs(), context)
+            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(), context)

        delta_x = self.getParameterValue(self.DELTA_X)
        delta_y = self.getParameterValue(self.DELTA_Y)
--- a/python/plugins/processing/algs/qgis/VariableDistanceBuffer.py
+++ b/python/plugins/processing/algs/qgis/VariableDistanceBuffer.py
@ -82,7 +82,7 @@ class VariableDistanceBuffer(GeoAlgorithm):
        field = self.getParameterValue(self.FIELD)
        segments = int(self.getParameterValue(self.SEGMENTS))

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), QgsWkbTypes.Polygon,
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), QgsWkbTypes.Polygon,
                                                                     layer.crs(), context)

        buff.buffering(feedback, context, writer, 0, field, True, layer, dissolve, segments)
--- a/python/plugins/processing/algs/qgis/VoronoiPolygons.py
+++ b/python/plugins/processing/algs/qgis/VoronoiPolygons.py
@ -75,7 +75,7 @@ class VoronoiPolygons(GeoAlgorithm):

        buf = self.getParameterValue(self.BUFFER)

-        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields().toList(), QgsWkbTypes.Polygon,
+        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), QgsWkbTypes.Polygon,
                                                                     layer.crs(), context)

        outFeat = QgsFeature()
--- a/python/plugins/processing/algs/qgis/ZonalStatistics.py
+++ b/python/plugins/processing/algs/qgis/ZonalStatistics.py
@ -176,7 +176,7 @@ class ZonalStatistics(GeoAlgorithm):
            (idxMode, fields) = vector.findOrCreateField(layer, fields,
                                                         columnPrefix + 'mode', 21, 6)

-        writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(fields.toList(), layer.wkbType(),
+        writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(fields, layer.wkbType(),
                                                                           layer.crs(), context)

        outFeat = QgsFeature()
--- a/python/plugins/processing/tools/vector.py
+++ b/python/plugins/processing/tools/vector.py
@ -280,7 +280,10 @@ def combineVectorFields(layerA, layerB):
            field = QgsField(newName, field.type(), field.typeName())
        fields.append(field)

-    return fields
+    real_fields = QgsFields()
+    for f in fields:
+        real_fields.append(f)
+    return real_fields


 def checkMinDistance(point, index, distance, points):