loplugin:moveparam in unoidl

Change-Id: Id3069cad0b118b5593bb7a0faa9d7e33e5bef168
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/123353
Tested-by: Jenkins
Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>

7 files changed, 62 insertions, 62 deletions

diff --git a/unoidl/source/legacyprovider.cxx b/unoidl/source/legacyprovider.cxx
index 13a2275282ba..1d147a975582 100644
--- a/unoidl/source/legacyprovider.cxx
+++ b/unoidl/source/legacyprovider.cxx
@@ -297,7 +297,7 @@ rtl::Reference< Entity > readEntity(
                 attrs.emplace_back(
                     attrName, reader.getFieldTypeName(j).replace('/', '.'),
                     bool(flags & RTFieldAccess::BOUND),
-                    bool(flags & RTFieldAccess::READONLY), getExcs, setExcs,
+                    bool(flags & RTFieldAccess::READONLY), std::move(getExcs), std::move(setExcs),
                     translateAnnotations(reader.getFieldDocumentation(j)));
             }
             std::vector< InterfaceTypeEntity::Method > meths;
@@ -355,13 +355,13 @@ rtl::Reference< Entity > readEntity(
                     meths.emplace_back(
                         reader.getMethodName(j),
                         reader.getMethodReturnTypeName(j).replace('/', '.'),
-                        params, excs,
+                        std::move(params), std::move(excs),
                         translateAnnotations(
                             reader.getMethodDocumentation(j)));
                 }
             }
             return new InterfaceTypeEntity(
-                reader.isPublished(), mandBases, optBases, attrs, meths,
+                reader.isPublished(), std::move(mandBases), std::move(optBases), std::move(attrs), std::move(meths),
                 translateAnnotations(reader.getDocumentation()));
         }
     case RT_TYPE_MODULE:
@@ -394,7 +394,7 @@ rtl::Reference< Entity > readEntity(
                         translateAnnotations(reader.getFieldDocumentation(j)));
                 }
                 return new PlainStructTypeEntity(
-                    reader.isPublished(), base, mems,
+                    reader.isPublished(), base, std::move(mems),
                     translateAnnotations(reader.getDocumentation()));
             } else {
                 if (reader.getSuperTypeCount() != 0) {
@@ -422,7 +422,7 @@ rtl::Reference< Entity > readEntity(
                         translateAnnotations(reader.getFieldDocumentation(j)));
                 }
                 return new PolymorphicStructTypeTemplateEntity(
-                    reader.isPublished(), params, mems,
+                    reader.isPublished(), std::move(params), std::move(mems),
                     translateAnnotations(reader.getDocumentation()));
             }
         }
@@ -446,7 +446,7 @@ rtl::Reference< Entity > readEntity(
 
             }
             return new EnumTypeEntity(
-                reader.isPublished(), mems,
+                reader.isPublished(), std::move(mems),
                 translateAnnotations(reader.getDocumentation()));
         }
     case RT_TYPE_EXCEPTION:
@@ -475,7 +475,7 @@ rtl::Reference< Entity > readEntity(
                     translateAnnotations(reader.getFieldDocumentation(j)));
             }
             return new ExceptionTypeEntity(
-                reader.isPublished(), base, mems,
+                reader.isPublished(), base, std::move(mems),
                 translateAnnotations(reader.getDocumentation()));
         }
     case RT_TYPE_TYPEDEF:
@@ -579,8 +579,8 @@ rtl::Reference< Entity > readEntity(
                         translateAnnotations(reader.getFieldDocumentation(j)));
                 }
                 return new AccumulationBasedServiceEntity(
-                    reader.isPublished(), mandServs, optServs, mandIfcs,
-                    optIfcs, props,
+                    reader.isPublished(), std::move(mandServs), std::move(optServs), std::move(mandIfcs),
+                    std::move(optIfcs), std::move(props),
                     translateAnnotations(reader.getDocumentation()));
             }
         case 1:
@@ -661,14 +661,14 @@ rtl::Reference< Entity > readEntity(
                         }
                         ctors.push_back(
                             SingleInterfaceBasedServiceEntity::Constructor(
-                                reader.getMethodName(j), params, excs,
+                                reader.getMethodName(j), std::move(params), std::move(excs),
                                 translateAnnotations(
                                     reader.getMethodDocumentation(j))));
                     }
                 }
                 return new SingleInterfaceBasedServiceEntity(
                     reader.isPublished(),
-                    reader.getSuperTypeName(0).replace('/', '.'), ctors,
+                    reader.getSuperTypeName(0).replace('/', '.'), std::move(ctors),
                     translateAnnotations(reader.getDocumentation()));
             }
         default:
@@ -764,7 +764,7 @@ rtl::Reference< Entity > readEntity(
                     translateAnnotations(reader.getFieldDocumentation(j)));
             }
             return new ConstantGroupEntity(
-                reader.isPublished(), mems,
+                reader.isPublished(), std::move(mems),
                 translateAnnotations(reader.getDocumentation()));
         }
     default:
diff --git a/unoidl/source/sourceprovider-parser-requires.hxx b/unoidl/source/sourceprovider-parser-requires.hxx
index 52b8c79e2a93..59c79b39943c 100644
--- a/unoidl/source/sourceprovider-parser-requires.hxx
+++ b/unoidl/source/sourceprovider-parser-requires.hxx
@@ -108,10 +108,10 @@ struct SourceProviderType {
     SourceProviderType(
         OUString const & polymorphicStructTypeTemplateName,
         SourceProviderEntity const * theEntity,
-        std::vector<SourceProviderType> const & typeArguments):
+        std::vector<SourceProviderType>&& typeArguments):
         type(TYPE_INSTANTIATED_POLYMORPHIC_STRUCT),
         name(polymorphicStructTypeTemplateName), entity(theEntity),
-        subtypes(typeArguments)
+        subtypes(std::move(typeArguments))
     { assert(theEntity != nullptr); }
 
     explicit SourceProviderType(OUString const & identifier):
diff --git a/unoidl/source/sourceprovider-parser.y b/unoidl/source/sourceprovider-parser.y
index 326d0dd7a8c9..0175b5379897 100644
--- a/unoidl/source/sourceprovider-parser.y
+++ b/unoidl/source/sourceprovider-parser.y
@@ -787,7 +787,7 @@ Found findEntity(
                                  + " type parameters"));
                             return FOUND_ERROR;
                         }
-                        t = unoidl::detail::SourceProviderType(n, e, args);
+                        t = unoidl::detail::SourceProviderType(n, e, std::move(args));
                         break;
                     }
                     [[fallthrough]];
@@ -1014,7 +1014,7 @@ enumDefn:
               ent->pad.get());
       assert(pad != nullptr);
       ent->entity = new unoidl::EnumTypeEntity(
-          pad->isPublished(), pad->members, annotations($1));
+          pad->isPublished(), std::move(pad->members), annotations($1));
       ent->pad.clear();
       clearCurrentState(data);
   }
@@ -1146,7 +1146,7 @@ plainStructDefn:
                   ent->pad.get());
       assert(pad != nullptr);
       ent->entity = new unoidl::PlainStructTypeEntity(
-          pad->isPublished(), pad->baseName, pad->members, annotations($1));
+          pad->isPublished(), pad->baseName, std::move(pad->members), annotations($1));
       ent->pad.clear();
       clearCurrentState(data);
   }
@@ -1179,7 +1179,7 @@ polymorphicStructTemplateDefn:
                   ent->pad.get());
       assert(pad != nullptr);
       ent->entity = new unoidl::PolymorphicStructTypeTemplateEntity(
-          pad->isPublished(), pad->typeParameters, pad->members,
+          pad->isPublished(), std::move(pad->typeParameters), std::move(pad->members),
           annotations($1));
       ent->pad.clear();
       clearCurrentState(data);
@@ -1274,7 +1274,7 @@ exceptionDefn:
               ent->pad.get());
       assert(pad != nullptr);
       ent->entity = new unoidl::ExceptionTypeEntity(
-          pad->isPublished(), pad->baseName, pad->members, annotations($1));
+          pad->isPublished(), pad->baseName, std::move(pad->members), annotations($1));
       ent->pad.clear();
       clearCurrentState(data);
   }
@@ -1604,15 +1604,15 @@ interfaceDefn:
       }
       std::vector<unoidl::AnnotatedReference> mbases;
       for (auto & i: pad->directMandatoryBases) {
-          mbases.emplace_back(i.name, i.annotations);
+          mbases.emplace_back(i.name, std::move(i.annotations));
       }
       std::vector<unoidl::AnnotatedReference> obases;
       for (auto & i: pad->directOptionalBases) {
-          obases.emplace_back(i.name, i.annotations);
+          obases.emplace_back(i.name, std::move(i.annotations));
       }
       ent->entity = new unoidl::InterfaceTypeEntity(
-          pad->isPublished(), mbases, obases, pad->directAttributes,
-          pad->directMethods, annotations($1));
+          pad->isPublished(), std::move(mbases), std::move(obases), std::move(pad->directAttributes),
+          std::move(pad->directMethods), annotations($1));
       ent->pad.clear();
       clearCurrentState(data);
   }
@@ -1988,7 +1988,7 @@ constantGroupDefn:
               ent->pad.get());
       assert(pad != nullptr);
       ent->entity = new unoidl::ConstantGroupEntity(
-          pad->isPublished(), pad->members, annotations($1));
+          pad->isPublished(), std::move(pad->members), annotations($1));
       ent->pad.clear();
       clearCurrentState(data);
   }
@@ -2359,7 +2359,7 @@ singleInterfaceBasedServiceDefn:
               }
               ctors.push_back(
                   unoidl::SingleInterfaceBasedServiceEntity::Constructor(
-                      i.name, parms, i.exceptions, i.annotations));
+                      i.name, std::vector(parms), std::vector(i.exceptions), std::vector(i.annotations)));
           }
       } else {
           assert(pad->constructors.empty());
@@ -2367,7 +2367,7 @@ singleInterfaceBasedServiceDefn:
               unoidl::SingleInterfaceBasedServiceEntity::Constructor());
       }
       ent->entity = new unoidl::SingleInterfaceBasedServiceEntity(
-          pad->isPublished(), pad->base, ctors, annotations($1));
+          pad->isPublished(), pad->base, std::move(ctors), annotations($1));
       ent->pad.clear();
       clearCurrentState(data);
   }
@@ -2564,9 +2564,9 @@ accumulationBasedServiceDefn:
               ent->pad.get());
       assert(pad != nullptr);
       ent->entity = new unoidl::AccumulationBasedServiceEntity(
-          pad->isPublished(), pad->directMandatoryBaseServices,
-          pad->directOptionalBaseServices, pad->directMandatoryBaseInterfaces,
-          pad->directOptionalBaseInterfaces, pad->directProperties,
+          pad->isPublished(), std::move(pad->directMandatoryBaseServices),
+          std::move(pad->directOptionalBaseServices), std::move(pad->directMandatoryBaseInterfaces),
+          std::move(pad->directOptionalBaseInterfaces), std::move(pad->directProperties),
           annotations($1));
       ent->pad.clear();
       clearCurrentState(data);
@@ -3941,7 +3941,7 @@ type:
                        + " used in published context"));
                   YYERROR;
               }
-              $$ = new unoidl::detail::SourceProviderType(name, ent, args);
+              $$ = new unoidl::detail::SourceProviderType(name, ent, std::move(args));
               ok = true;
           }
           break;
diff --git a/unoidl/source/sourceprovider-scanner.hxx b/unoidl/source/sourceprovider-scanner.hxx
index 6cad6a540117..8c973b9db169 100644
--- a/unoidl/source/sourceprovider-scanner.hxx
+++ b/unoidl/source/sourceprovider-scanner.hxx
@@ -109,8 +109,8 @@ public:
         DirectBase(
             OUString const & theName,
             rtl::Reference<unoidl::InterfaceTypeEntity> const & theEntity,
-            std::vector<OUString> const & theAnnotations):
-            name(theName), entity(theEntity), annotations(theAnnotations)
+            std::vector<OUString>&& theAnnotations):
+            name(theName), entity(theEntity), annotations(std::move(theAnnotations))
         { assert(theEntity.is()); }
 
         OUString name;
@@ -210,8 +210,8 @@ public:
 
         Constructor(
             OUString const & theName,
-            std::vector< OUString > const & theAnnotations):
-            name(theName), annotations(theAnnotations)
+            std::vector< OUString >&& theAnnotations):
+            name(theName), annotations(std::move(theAnnotations))
         {}
 
         OUString name;
diff --git a/unoidl/source/unoidl-write.cxx b/unoidl/source/unoidl-write.cxx
index b0fbc31e5023..5ddd98468359 100644
--- a/unoidl/source/unoidl-write.cxx
+++ b/unoidl/source/unoidl-write.cxx
@@ -311,8 +311,8 @@ struct Item {
 struct ConstItem {
     ConstItem(
         unoidl::ConstantValue const & theConstant,
-        std::vector< OUString > const & theAnnotations):
-        constant(theConstant), annotations(theAnnotations), nameOffset(0),
+        std::vector< OUString >&& theAnnotations):
+        constant(theConstant), annotations(std::move(theAnnotations)), nameOffset(0),
         dataOffset(0)
     {}
 
@@ -637,7 +637,7 @@ sal_uInt64 writeMap(
                 for (auto & j: ent2->getMembers()) {
                     if (!cmap.insert(
                             std::make_pair(
-                                j.name, ConstItem(j.value, j.annotations))).
+                                j.name, ConstItem(j.value, std::vector(j.annotations)))).
                         second)
                     {
                         std::cout
diff --git a/unoidl/source/unoidl.cxx b/unoidl/source/unoidl.cxx
index b66a6f45e534..749f9afe4f25 100644
--- a/unoidl/source/unoidl.cxx
+++ b/unoidl/source/unoidl.cxx
@@ -32,9 +32,9 @@ namespace {
 class AggregatingModule: public ModuleEntity {
 public:
     AggregatingModule(
-        std::vector< rtl::Reference< Provider > > const & providers,
+        std::vector< rtl::Reference< Provider > >&& providers,
         OUString const & name):
-        providers_(providers), name_(name)
+        providers_(std::move(providers)), name_(name)
     {}
 
 private:
@@ -64,9 +64,9 @@ std::vector< OUString > AggregatingModule::getMemberNames() const {
 class AggregatingCursor: public MapCursor {
 public:
     AggregatingCursor(
-        std::vector< rtl::Reference< Provider > > const & providers,
+        std::vector< rtl::Reference< Provider > >&& providers,
         OUString const & name):
-        providers_(providers), name_(name), iterator_(providers_.begin())
+        providers_(std::move(providers)), name_(name), iterator_(providers_.begin())
     { findCursor(); }
 
 private:
@@ -94,7 +94,7 @@ rtl::Reference< Entity > AggregatingCursor::getNext(OUString * name) {
                 }
                 return ent->getSort() == Entity::SORT_MODULE
                     ? new AggregatingModule(
-                        providers_, (name_.isEmpty() ? name_ : name_ + ".") + n)
+                        std::vector(providers_), (name_.isEmpty() ? name_ : name_ + ".") + n)
                     : ent;
             }
         } else {
@@ -120,7 +120,7 @@ void AggregatingCursor::findCursor() {
 }
 
 rtl::Reference< MapCursor > AggregatingModule::createCursor() const {
-    return new AggregatingCursor(providers_, name_);
+    return new AggregatingCursor(std::vector(providers_), name_);
 }
 
 }
@@ -189,7 +189,7 @@ rtl::Reference< Entity > Manager::findEntity(OUString const & name) const {
 rtl::Reference< MapCursor > Manager::createCursor(OUString const & name)
     const
 {
-    return new AggregatingCursor(providers_, name);
+    return new AggregatingCursor(std::vector(providers_), name);
 }
 
 Manager::~Manager() noexcept {}
diff --git a/unoidl/source/unoidlprovider.cxx b/unoidl/source/unoidlprovider.cxx
index b1c7788c2a40..217251dca053 100644
--- a/unoidl/source/unoidlprovider.cxx
+++ b/unoidl/source/unoidlprovider.cxx
@@ -649,7 +649,7 @@ ConstantValue readConstant(
 
 rtl::Reference< Entity > readEntity(
     rtl::Reference< MappedFile > const & file, sal_uInt32 offset,
-    std::set<Map> const & trace);
+    std::set<Map> && trace);
 
 class UnoidlModuleEntity;
 
@@ -682,7 +682,7 @@ rtl::Reference< Entity > UnoidlCursor::getNext(OUString * name) {
     if (index_ != map_.map.size) {
         *name = file_->readNulName(map_.map.begin[index_].name.getUnsigned32());
         ent = readEntity(
-            file_, map_.map.begin[index_].data.getUnsigned32(), map_.trace);
+            file_, map_.map.begin[index_].data.getUnsigned32(), std::set(map_.trace));
         ++index_;
     }
     return ent;
@@ -692,14 +692,14 @@ class UnoidlModuleEntity: public ModuleEntity {
 public:
     UnoidlModuleEntity(
         rtl::Reference< MappedFile > const & file, sal_uInt32 mapOffset,
-        sal_uInt32 mapSize, std::set<Map> const & trace):
+        sal_uInt32 mapSize, std::set<Map> && trace):
         file_(file)
     {
         assert(file.is());
         map_.map.begin = reinterpret_cast<MapEntry const *>(
             static_cast<char const *>(file_->address) + mapOffset);
         map_.map.size = mapSize;
-        map_.trace = trace;
+        map_.trace = std::move(trace);
         if (!map_.trace.insert(map_.map).second) {
             throw FileFormatException(
                 file_->uri, "UNOIDL format: recursive map");
@@ -732,7 +732,7 @@ std::vector< OUString > UnoidlModuleEntity::getMemberNames() const {
 
 rtl::Reference< Entity > readEntity(
     rtl::Reference< MappedFile > const & file, sal_uInt32 offset,
-    std::set<Map> const & trace)
+    std::set<Map> && trace)
 {
     assert(file.is());
     int v = file->read8(offset);
@@ -761,7 +761,7 @@ rtl::Reference< Entity > readEntity(
                     file->uri,
                     "UNOIDL format: module map offset + size too large");
             }
-            return new UnoidlModuleEntity(file, offset + 5, n, trace);
+            return new UnoidlModuleEntity(file, offset + 5, n, std::move(trace));
         }
     case 1: // enum type
         {
@@ -790,7 +790,7 @@ rtl::Reference< Entity > readEntity(
                     readAnnotations(annotated, file, offset, &offset));
             }
             return new EnumTypeEntity(
-                published, mems, readAnnotations(annotated, file, offset));
+                published, std::move(mems), readAnnotations(annotated, file, offset));
         }
     case 2: // plain struct type without base
     case 2 | 0x20: // plain struct type with base
@@ -826,7 +826,7 @@ rtl::Reference< Entity > readEntity(
                     readAnnotations(annotated, file, offset, &offset));
             }
             return new PlainStructTypeEntity(
-                published, base, mems,
+                published, base, std::move(mems),
                 readAnnotations(annotated, file, offset));
         }
     case 3: // polymorphic struct type template
@@ -873,7 +873,7 @@ rtl::Reference< Entity > readEntity(
                     readAnnotations(annotated, file, offset, &offset));
             }
             return new PolymorphicStructTypeTemplateEntity(
-                published, params, mems,
+                published, std::move(params), std::move(mems),
                 readAnnotations(annotated, file, offset));
         }
     case 4: // exception type without base
@@ -909,7 +909,7 @@ rtl::Reference< Entity > readEntity(
                     readAnnotations(annotated, file, offset, &offset));
             }
             return new ExceptionTypeEntity(
-                published, base, mems,
+                published, base, std::move(mems),
                 readAnnotations(annotated, file, offset));
         }
     case 5: // interface type
@@ -999,7 +999,7 @@ rtl::Reference< Entity > readEntity(
                 }
                 attrs.emplace_back(
                     attrName, attrType, (v & 0x01) != 0, (v & 0x02) != 0,
-                    getExcs, setExcs,
+                    std::move(getExcs), std::move(setExcs),
                     readAnnotations(annotated, file, offset, &offset));
             }
             sal_uInt32 nMeths = file->read32(offset);
@@ -1072,11 +1072,11 @@ rtl::Reference< Entity > readEntity(
                     excs.push_back(exc);
                 }
                 meths.emplace_back(
-                    methName, methType, params, excs,
+                    methName, methType, std::move(params), std::move(excs),
                     readAnnotations(annotated, file, offset, &offset));
             }
             return new InterfaceTypeEntity(
-                published, mandBases, optBases, attrs, meths,
+                published, std::move(mandBases), std::move(optBases), std::move(attrs), std::move(meths),
                 readAnnotations(annotated, file, offset));
         }
     case 6: // typedef
@@ -1115,7 +1115,7 @@ rtl::Reference< Entity > readEntity(
                     readAnnotations(ann, file, off));
             }
             return new ConstantGroupEntity(
-                published, mems,
+                published, std::move(mems),
                 readAnnotations(annotated, file, offset + 5 + 8 * n));
         }
     case 8: // single-interface--based service without default constructor
@@ -1194,12 +1194,12 @@ rtl::Reference< Entity > readEntity(
                     }
                     ctors.push_back(
                         SingleInterfaceBasedServiceEntity::Constructor(
-                            ctorName, params, excs,
+                            ctorName, std::move(params), std::move(excs),
                             readAnnotations(annotated, file, offset, &offset)));
                 }
             }
             return new SingleInterfaceBasedServiceEntity(
-                published, base, ctors,
+                published, base, std::move(ctors),
                 readAnnotations(annotated, file, offset));
         }
     case 9: // accumulation-based service
@@ -1295,7 +1295,7 @@ rtl::Reference< Entity > readEntity(
                     readAnnotations(annotated, file, offset, &offset));
             }
             return new AccumulationBasedServiceEntity(
-                published, mandServs, optServs, mandIfcs, optIfcs, props,
+                published, std::move(mandServs), std::move(optServs), std::move(mandIfcs), std::move(optIfcs), std::move(props),
                 readAnnotations(annotated, file, offset));
         }
     case 10: // interface-based singleton
@@ -1365,7 +1365,7 @@ rtl::Reference< Entity > UnoidlProvider::findEntity(OUString const & name) const
         if (j == name.getLength()) {
             return cgroup
                 ? rtl::Reference< Entity >()
-                : readEntity(file_, off, map.trace);
+                : readEntity(file_, off, std::set(map.trace));
         }
         if (cgroup) {
             return rtl::Reference< Entity >();